pax_global_header00006660000000000000000000000064144625545600014525gustar00rootroot0000000000000052 comment=3519a38195215c06873580749dc9c55ecdfc9aa8 scikit-bio-0.5.9/000077500000000000000000000000001446255456000135755ustar00rootroot00000000000000scikit-bio-0.5.9/.coveragerc000066400000000000000000000005221446255456000157150ustar00rootroot00000000000000# this file is based on the examples provided on scikit-learn's .coveragerc [run] omit = */tests* */__init__.py source = skbio branch = True include = */skbio/* relative_files = True [report] exclude_lines = pragma: no cover raise NotImplementedError if __name__ == .__main__.: omit = */tests* */__init__.py scikit-bio-0.5.9/.dockerignore000066400000000000000000000001371446255456000162520ustar00rootroot00000000000000.pytest_cache build/ dist/ *.swp env*/ __pycache__/ */__pycache__/ **/__pycache__/ *.egg-info/ scikit-bio-0.5.9/.editorconfig000066400000000000000000000003251446255456000162520ustar00rootroot00000000000000root = true [*] charset = utf-8 insert_final_newline = false [*.{py,c,h}] indent_style = space indent_size = 4 [*.{yml,yaml}] indent_style = space indent_size = 2 [Makefile] indent_style = tab indent_size = 4 scikit-bio-0.5.9/.github/000077500000000000000000000000001446255456000151355ustar00rootroot00000000000000scikit-bio-0.5.9/.github/CONTRIBUTING.md000066400000000000000000000362031446255456000173720ustar00rootroot00000000000000Contributing to scikit-bio ========================== [scikit-bio](http://scikit-bio.org) is an open source software package and we welcome community contributions. You can find the scikit-bio source code on GitHub [here](https://github.com/biocore/scikit-bio). This document covers what you should do to get started with contributing to scikit-bio. You should read the entire document before contributing code to scikit-bio. This will save time for both you and the scikit-bio developers. Types of contributions ---------------------- We're interested in many different types of contributions, including feature additions, bug fixes, continuous integration improvements, and documentation/website updates, additions, and fixes. When considering contributing to scikit-bio, you should begin by posting an issue to the [scikit-bio issue tracker](https://github.com/biocore/scikit-bio/issues). The information that you include in that post will differ based on the type of contribution. Your contribution will also need to be fully tested where applicable (discussed further below). * For feature additions, please describe why the functionality that you are proposing to add is relevant. For it to be relevant, it should be demonstrably useful to scikit-bio users and it should also fit within the biology/bioinformatics domain. This typically means that a new analytic method is implemented (you should describe why it's useful, ideally including a link to a paper that uses this method), or an existing method is enhanced (e.g., improved performance). We will request benchmark results comparing your method to the pre-existing methods (which would also be required for publication of your method) so pointing to a paper or other document containing benchmark results, or including benchmark results in your issue, will speed up the process. Before contributing a new feature, it's also a good idea to check whether the functionality exists in other Python packages, or if the feature would fit better in another Python package. For example, low-level statistical methods/tests may fit better in a project that is focused on statistics (e.g., [SciPy](https://scipy.org/) or [statsmodels](https://www.statsmodels.org/)). * For bug fixes, please provide a detailed description of the bug so other developers can reproduce it. We take bugs in scikit-bio very seriously. Bugs can be related to errors in code, documentation, or tests. Errors in documentation or tests are usually updated in the next scheduled release of scikit-bio. Errors in code that could result in incorrect results or inability to access certain functionality may result in a bug fix release of scikit-bio that is released ahead of schedule. You should include the following information in your bug report: 1. The exact command(s) necessary to reproduce the bug. 2. A link to all necessary input files for reproducing the bug. These files should only be as large as necessary to create the bug. For example, if you have an input file with 10,000 FASTA-formatted sequences but the error only arises due to one of the sequences, create a new FASTA file with only that sequence, run the command that was giving you problems, and verify that you still get an error. Then post that command and link to the trimmed FASTA file. This is *extremely* useful to other developers and it is likely that if you don't provide this information you'll get a response asking for it. Often this process helps you to better understand the bug as well. * For documentation additions, you should first post an issue describing what you propose to add, where you'd like to add it in the documentation, and a description of why you think it's an important addition. For documentation improvements and fixes, you should post an issue describing what is currently wrong or missing and how you propose to address it. For more information about building and contributing to scikit-bio's documentation, see our [documentation guide](../doc/README.md). When you post your issue, the scikit-bio developers will respond to let you know if we agree with the addition or change. It's very important that you go through this step to avoid wasting time working on a feature that we are not interested in including in scikit-bio. **This initial discussion with the developers is important because scikit-bio is rapidly changing, including complete re-writes of some of the core objects. If you don't get in touch first you could easily waste time by working on an object or interface that is deprecated.** Getting started --------------- ### "quick fixes" Some of our issues are labeled as ``quick fix``. Working on [these issues](https://github.com/biocore/scikit-bio/issues?q=is%3Aopen+is%3Aissue+label%3A%22quick+fix%22) is a good way to get started with contributing to scikit-bio. These are usually small bugs or documentation errors that will only require one or a few lines of code to fix. Getting started by working on one of these issues will allow you to familiarize yourself with our development process before committing to a large amount of work (e.g., adding a new feature to scikit-bio). Please post a comment on the issue if you're interested in working on one of these "quick fixes". ### Joining development Once you are more comfortable with our development process, you can check out the [``on deck`` label](https://github.com/biocore/scikit-bio/labels/on%20deck) on our issue tracker. These issues represent what our current focus is in the project. As such, they are probably the best place to start if you are looking to join the conversation and contribute code. Code review ----------- When you submit code to scikit-bio, it will be reviewed by one or more scikit-bio developers. These reviews are intended to confirm a few points: * Your code provides relevant changes or additions to scikit-bio ([Types of contributions](#types-of-contributions)). * Your code adheres to our coding guidelines ([Coding guidelines](#coding-guidelines)). * Your code is sufficiently well-tested ([Testing guidelines](#testing-guidelines)). * Your code is sufficiently well-documented ([Documentation guidelines](#documentation-guidelines)). This process is designed to ensure the quality of scikit-bio and can be a very useful experience for new developers. Particularly for big changes, if you'd like feedback on your code in the form of a code review as you work, you should request help in the issue that you created and one of the scikit-bio developers will work with you to perform regular code reviews. This can greatly reduce development time (and frustration) so we highly recommend that new developers take advantage of this rather than submitting a pull request with a massive amount of code. That can lead to frustration when the developer thinks they are done but the reviewer requests large amounts of changes, and it also makes it harder to review. Submitting code to scikit-bio ----------------------------- scikit-bio is hosted on [GitHub](https://github.com/), and we use GitHub's [Pull Request](https://help.github.com/articles/using-pull-requests) mechanism for reviewing and accepting submissions. You should work through the following steps to submit code to scikit-bio. 1. Begin by [creating an issue](https://github.com/biocore/scikit-bio/issues) describing your proposed change (see [Types of contributions](#types-of-contributions) for details). 2. [Fork](https://help.github.com/articles/fork-a-repo) the scikit-bio repository on the GitHub website. 3. Clone your forked repository to the system where you'll be developing with ``git clone``. ``cd`` into the ``scikit-bio`` directory that was created by ``git clone``. 4. Ensure that you have the latest version of all files. This is especially important if you cloned a long time ago, but you'll need to do this before submitting changes regardless. You should do this by adding scikit-bio as a remote repository and then pulling from that repository. You'll only need to run the ``git remote`` command the first time you do this: ``` git remote add upstream https://github.com/biocore/scikit-bio.git git checkout master git pull upstream master ``` 5. Install scikit-bio for development. See [Setting up a development environment](#setting-up-a-development-environment). 6. Create a new topic branch that you will make your changes in with ``git checkout -b``: ``` git checkout -b my-topic-branch ``` What you name your topic branch is up to you, though we recommend including the issue number in the topic branch, since there is usually already an issue associated with the changes being made in the pull request. For example, if you were addressing issue number 42, you might name your topic branch ``issue-42``. 7. Run ``make test`` to confirm that the tests pass before you make any changes. 8. Make your changes, add them (with ``git add``), and commit them (with ``git commit``). Don't forget to update associated tests and documentation as necessary. Write descriptive commit messages to accompany each commit. We recommend following [NumPy's commit message guidelines](https://numpy.org/doc/stable/dev/development_workflow.html#writing-the-commit-message), including the usage of commit tags (i.e., starting commit messages with acronyms such ``ENH``, ``BUG``, etc.). 9. Please mention your changes in [CHANGELOG.md](../CHANGELOG.md). This file informs scikit-bio *users* of changes made in each release, so be sure to describe your changes with this audience in mind. It is especially important to note API additions and changes, particularly if they are backward-incompatible, as well as bug fixes. Be sure to make your updates under the section designated for the latest development version of scikit-bio (this will be at the top of the file). Describe your changes in detail under the most appropriate section heading(s). For example, if your pull request fixes a bug, describe the bug fix under the "Bug fixes" section of [CHANGELOG.md](../CHANGELOG.md). Please also include a link to the issue(s) addressed by your changes. See [CHANGELOG.md](../CHANGELOG.md) for examples of how we recommend formatting these descriptions. 10. When you're ready to submit your code, ensure that you have the latest version of all files in case some changed while you were working on your edits. You can do this by merging master into your topic branch: ``` git checkout master git pull upstream master git checkout my-topic-branch git merge master ``` 11. Run ``make test`` to ensure that your changes did not cause anything expected to break. 12. Once the tests pass, you should push your changes to your forked repository on GitHub using: ``` git push origin my-topic-branch ``` 13. Issue a [pull request](https://help.github.com/articles/using-pull-requests) on the GitHub website to request that we merge your branch's changes into scikit-bio's master branch. Be sure to include a description of your changes in the pull request, as well as any other information that will help the scikit-bio developers involved in reviewing your code. Please include ``fixes #`` in your pull request description or in one of your commit messages so that the corresponding issue will be closed when the pull request is merged (see [here](https://help.github.com/articles/closing-issues-via-commit-messages/) for more details). One of the scikit-bio developers will review your code at this stage. If we request changes (which is very common), *don't issue a new pull request*. You should make changes on your topic branch, and commit and push them to GitHub. Your pull request will update automatically. Setting up a development environment ------------------------------------ **Note:** scikit-bio must be developed in a Python 3.8 or later environment. The recommended way to set up a development environment for contributing to scikit-bio is using [Conda](https://conda.io/). The primary benefit of `conda` over `pip` is that on some operating systems (ie Linux), `pip` installs packages from source. This can take a very long time to install Numpy, scipy, matplotlib, etc. `conda` installs these packages using pre-built binaries, so the installation is much faster. Another benefit of `conda` is that it provides both package and environment management, which removes the necessity of using `virtualenv` separately. Not all packages are available using `conda`, therefore our strategy is to install as many packages as possible using `conda`, then install any remaining packages using `pip`. 1. Install Conda See [Conda's site](https://docs.conda.io/en/latest/) for instructions. [Miniconda](https://conda.io/miniconda.html) provides a fast way to get conda up and running. 2. Navigate to the scikit-bio directory See [the section on submitting code](#submitting-code-to-scikit-bio). ``` cd /path/to/scikit-bio ``` 3. Create a new conda environment ``` conda create -n skbio-dev -c conda-forge --file ci/conda_requirements.txt --file ci/requirements.test.txt ``` Note that `skbio-dev` can be any name desired. 4. Activate the environment This may be slightly different depending on the operating system. Refer to the Conda site to find instructions for your OS. ``` conda activate skbio-dev ``` 5. Install scikit-bio ``` pip install --no-deps -e . ``` 6. Test the installation ``` make test ``` Coding guidelines ----------------- We adhere to the [PEP 8](https://peps.python.org/pep-0008/) Python style guidelines. Please see scikit-bio's [coding guidelines](http://scikit-bio.org/docs/latest/development/coding_guidelines.html) for more details. Before submitting code to scikit-bio, you should read this document carefully and apply the guidelines in your code. Testing guidelines ------------------ All code that is added to scikit-bio must be unit tested, and the unit test code must be submitted in the same pull request as the library code that you are submitting. We will only merge code that is unit tested and that passes the [continuous integration build](https://github.com/biocore/scikit-bio/blob/master/.travis.yml). This build includes, but is not limited to, the following checks: - Full unit test suite and doctests execute without errors in supported versions of Python 3. - C code can be correctly compiled. - Cython code is correctly generated. - All tests import functionality from the appropriate minimally deep API. - Documentation can be built. - Current code coverage is maintained or improved. - Code passes ``flake8`` checks. Running ``make test`` locally during development will include a subset of the full checks performed by Travis-CI. The scikit-bio coding guidelines describe our [expectations for unit tests](http://scikit-bio.org/docs/latest/development/coding_guidelines.html). You should review the unit test section before working on your test code. Tests can be executed by running ``make test`` from the base directory of the project or from within a Python or IPython session: ``` python >>> from skbio.test import pytestrunner >>> pytestrunner() # full test suite is executed ``` Documentation guidelines ------------------------ We strive to keep scikit-bio well-documented, particularly its public-facing API. See our [documentation guide](../doc/README.md) for more details. Getting help with git --------------------- If you're new to GitHub, you'll probably find the [GitHub Docs](https://docs.github.com/) helpful. scikit-bio-0.5.9/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000025561446255456000207460ustar00rootroot00000000000000Please complete the following checklist: * [ ] I have read the guidelines in [CONTRIBUTING.md](https://github.com/biocore/scikit-bio/blob/master/.github/CONTRIBUTING.md). * [ ] I have documented all public-facing changes in [CHANGELOG.md](https://github.com/biocore/scikit-bio/blob/master/CHANGELOG.md). * [ ] **This pull request includes code, documentation, or other content derived from external source(s).** If this is the case, ensure the external source's license is compatible with scikit-bio's [license](https://github.com/biocore/scikit-bio/blob/master/LICENSE.txt). Include the license in the `licenses` directory and add a comment in the code giving proper attribution. Ensure any other requirements set forth by the license and/or author are satisfied. **It is your responsibility to disclose code, documentation, or other content derived from external source(s).** If you have questions about whether something can be included in the project or how to give proper attribution, include those questions in your pull request and a reviewer will assist you. * [ ] **This pull request does not include code, documentation, or other content derived from external source(s).** **Note:** [REVIEWING.md](https://github.com/biocore/scikit-bio/blob/master/REVIEWING.md) may also be helpful to see some of the things code reviewers will be verifying when reviewing your pull request. scikit-bio-0.5.9/.github/workflows/000077500000000000000000000000001446255456000171725ustar00rootroot00000000000000scikit-bio-0.5.9/.github/workflows/ci.yml000066400000000000000000000125531446255456000203160ustar00rootroot00000000000000name: CI on: push: branches: [ master ] pull_request: branches: [ master ] env: latest_python: "3.11" supported_pythons: '["3.8", "3.9", "3.10", "3.11"]' miniforge_version: "22.9.0-2" miniforge_variant: "Mambaforge" jobs: conf: # This job is needed to route the global environment variables into # a context that's available for matrix (and name, but that's unimportant) name: Prepare Test Plan runs-on: "ubuntu-latest" outputs: latest_python: ${{ steps.set-vars.outputs.latest_python }} supported_pythons: ${{ steps.set-vars.outputs.supported_pythons }} steps: - name: Report Plan id: set-vars run: | echo "latest_python=$latest_python" >> $GITHUB_OUTPUT echo "supported_pythons=$supported_pythons" >> $GITHUB_OUTPUT lint: name: Lint code (${{ needs.conf.outputs.latest_python }}, ubuntu-latest) needs: conf runs-on: "ubuntu-latest" steps: - uses: actions/checkout@v3 - uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true python-version: ${{ env.latest_python }} miniforge-version: ${{ env.miniforge_version }} miniforge-variant: ${{ env.miniforge_variant }} environment-file: ci/conda_host_env.yml - name: Install dependencies shell: bash -l {0} run: | pip install -r ci/requirements.lint.txt conda list - name: Run linter shell: bash -l {0} run: make lint doc: name: Build Documentation (${{ needs.conf.outputs.latest_python }}, ubuntu-latest) needs: ["conf", "lint"] runs-on: "ubuntu-latest" steps: - uses: actions/checkout@v3 - uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true python-version: ${{ env.latest_python }} miniforge-version: ${{ env.miniforge_version }} miniforge-variant: ${{ env.miniforge_variant }} environment-file: ci/conda_host_env.yml - name: Install dependencies shell: bash -l {0} run: | pip install -r ci/requirements.doc.txt pip install . conda list - name: Make docs shell: bash -l {0} run: make doc test-cython: name: Test Cython (${{ needs.conf.outputs.latest_python }}, ${{ matrix.os }}) needs: conf runs-on: ${{ matrix.os }} env: MPLBACKEND: Agg USE_CYTHON: TRUE strategy: fail-fast: true matrix: os: ["ubuntu-latest", "macos-latest"] steps: - uses: actions/checkout@v3 - uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true python-version: ${{ env.latest_python }} miniforge-version: ${{ env.miniforge_version }} miniforge-variant: ${{ env.miniforge_variant }} environment-file: ci/conda_host_env.yml - name: Install dependencies shell: bash -l {0} run: | pip install . conda list - name: Run unit tests shell: bash -l {0} env: WITH_COVERAGE: "TRUE" run: make test test-cython-aarch64: name: Test Cython (${{ needs.conf.outputs.latest_python }}, qemu::aarch64-centos) needs: conf runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 # setup-buildx-action uses the git context directly # but checklist wants the .git directory - name: Set up QEMU id: qemu uses: docker/setup-qemu-action@v1 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v1 - name: Build and test for linux-aarch64 id: docker_build uses: docker/build-push-action@v2 with: context: . # ^ to use the local checkout, not the git context file: aarch64.Dockerfile cache-from: type=gha cache-to: type=gha,mode=max build-args: | PYTHON_VERSION=${{ env.latest_python }} test-all: name: Test (${{ matrix.python_version }}, ${{ matrix.os }}, ${{ fromJSON('["pypi", "conda"]')[matrix.use_conda] }}) runs-on: ${{ matrix.os }} needs: ["conf", "test-cython", "lint"] env: # not testing Cython here, whether the Cython compiles to C is tested # above MPLBACKEND: Agg strategy: fail-fast: false matrix: os: ["ubuntu-latest", "macos-latest"] python_version: ${{ fromJSON(needs.conf.outputs.supported_pythons) }} use_conda: [true, false] steps: - uses: actions/checkout@v3 - uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true python-version: ${{ env.latest_python }} miniforge-version: ${{ env.miniforge_version }} miniforge-variant: ${{ env.miniforge_variant }} environment-file: ci/conda_host_env.yml - name: Install dependencies (conda) if: ${{ matrix.use_conda }} shell: bash -l {0} run: | conda install -q --yes -c conda-forge --file ci/conda_requirements.txt pip install . --no-deps conda list - name: Install dependencies if: ${{ !matrix.use_conda }} shell: bash -l {0} run: | pip install . conda list - name: Run unit tests shell: bash -l {0} env: WITH_COVERAGE: "TRUE" run: make test scikit-bio-0.5.9/.github/workflows/release.yml000066400000000000000000000014311446255456000213340ustar00rootroot00000000000000name: Release on: push: tags: - '*' jobs: release: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: submodules: true - name: Set up Python 3.8 uses: actions/setup-python@v2 with: python-version: 3.8 - name: Build distribution run: | # set version from '${{ github.ref_name }}' export RELEASE_VERSION=${{ github.ref_name }} pip install numpy cython python setup.py sdist - name: Publish a Python distribution to PyPI if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') uses: pypa/gh-action-pypi-publish@release/v1 with: user: __token__ password: ${{ secrets.PYPI_API_TOKEN }} scikit-bio-0.5.9/.gitignore000066400000000000000000000006601446255456000155670ustar00rootroot00000000000000# Temporary files *~ \#*# .pytest_cache/* *.py[cod] # C extensions *.so # Packages *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg lib lib64 __pycache__ # Installer logs pip-log.txt # Unit test / coverage reports .coverage .tox nosetests.xml # Translations *.mo # Mr Developer .mr.developer.cfg .project .pydevproject # vi .*.swp # Sphinx builds doc/source/generated # OSX files .DS_Store scikit-bio-0.5.9/CHANGELOG.md000066400000000000000000002434561446255456000154240ustar00rootroot00000000000000# scikit-bio changelog ## Version 0.5.9 ### Features * Adding Variance log ratio estimators in `skbio.stats.composition.vlr` and `skbio.stats.composition.pairwise_vlr` ([#1803](https://github.com/biocore/scikit-bio/pull/1803)) * Added `skbio.stats.composition.tree_basis` to construct ILR bases from `TreeNode` objects. ([#1862](https://github.com/biocore/scikit-bio/pull/1862)) * `IntervalMetadata.query` now defaults to obtaining all results, see ([#1817](https://github.com/biocore/scikit-bio/issues/1817). ### Backward-incompatible changes [experimental] * With the introduction of the `tree_basis` object, the ILR bases are now represented in log-odds coordinates rather than in probabilities to minimize issues with numerical stability. Furthermore, the `ilr` and `ilr_inv` functions now takes the `basis` input parameter in terms of log-odds coordinates. This affects the `skbio.stats.composition.sbp_basis` as well. ([#1862](https://github.com/biocore/scikit-bio/pull/1862)) ### Important * Complex multiple axis indexing operations with `TabularMSA` have been removed from testing due to incompatibilities with modern versions of Pandas. ([#1851](https://github.com/biocore/scikit-bio/pull/1851)) * Pinning `scipy <= 1.10.1` ([#1851](https://github.com/biocore/scikit-bio/pull/1867)) ### Bug fixes * Fixed a bug that caused build failure on the ARM64 microarchitecture due to floating-point number handling. ([#1859](https://github.com/biocore/scikit-bio/pull/1859)) * Never let the Gini index go below 0.0, see [#1844](https://github.com/biocore/scikit-bio/issue/1844). * Fixed bug [#1847](https://github.com/biocore/scikit-bio/issues/1847) in which the edge from the root was inadvertantly included in the calculation for `descending_branch_length` ### Miscellaneous * Replaced dependencies `CacheControl` and `lockfile` with `requests` to avoid a dependency inconsistency issue of the former. (See [#1863](https://github.com/biocore/scikit-bio/pull/1863), merged in [#1859](https://github.com/biocore/scikit-bio/pull/1859)) * Updated installation instructions for developers in `CONTRIBUTING.md` ([#1860](https://github.com/biocore/scikit-bio/pull/1860)) ## Version 0.5.8 ### Features * Added NCBI taxonomy database dump format (`taxdump`) ([#1810](https://github.com/biocore/scikit-bio/pull/1810)). * Added `TreeNode.from_taxdump` for converting taxdump into a tree ([#1810](https://github.com/biocore/scikit-bio/pull/1810)). * scikit-learn has been removed as a dependency. This was a fairly heavy-weight dependency that was providing minor functionality to scikit-bio. The critical components have been implemented in scikit-bio directly, and the non-criticial components are listed under "Backward-incompatible changes [experimental]". * Python 3.11 is now supported. ### Backward-incompatible changes [experimental] * With the removal of the scikit-learn dependency, three beta diversity metric names can no longer be specified. These are `wminkowski`, `nan_euclidean`, and `haversine`. On testing, `wminkowski` and `haversine` did not work through `skbio.diversity.beta_diversity` (or `sklearn.metrics.pairwise_distances`). The former was deprecated in favor of calling `minkowski` with a vector of weights provided as kwarg `w` (example below), and the latter does not work with data of this shape. `nan_euclidean` can still be accessed fron scikit-learn directly if needed, if a user installs scikit-learn in their environment (example below). ``` counts = [[23, 64, 14, 0, 0, 3, 1], [0, 3, 35, 42, 0, 12, 1], [0, 5, 5, 0, 40, 40, 0], [44, 35, 9, 0, 1, 0, 0], [0, 2, 8, 0, 35, 45, 1], [0, 0, 25, 35, 0, 19, 0], [88, 31, 0, 5, 5, 5, 5], [44, 39, 0, 0, 0, 0, 0]] # new mechanism of accessing wminkowski from skbio.diversity import beta_diversity beta_diversity("minkowski", counts, w=[1,1,1,1,1,1,2]) # accessing nan_euclidean through scikit-learn directly import skbio from sklearn.metrics import pairwise_distances sklearn_dm = pairwise_distances(counts, metric="nan_euclidean") skbio_dm = skbio.DistanceMatrix(sklearn_dm) ``` ### Deprecated functionality [experimental] * `skbio.alignment.local_pairwise_align_ssw` has been deprecated ([#1814](https://github.com/biocore/scikit-bio/issues/1814)) and will be removed or replaced in scikit-bio 0.6.0. ### Bug fixes * Use `oldest-supported-numpy` as build dependency. This fixes problems with environments that use an older version of numpy than the one used to build scikit-bio ([#1813](https://github.com/biocore/scikit-bio/pull/1813)). ## Version 0.5.7 ### Features * Introduce support for Python 3.10 ([#1801](https://github.com/biocore/scikit-bio/pull/1801)). * Tentative support for Apple M1 ([#1709](https://github.com/biocore/scikit-bio/pull/1709)). * Added support for reading and writing a binary distance matrix object format. ([#1716](https://github.com/biocore/scikit-bio/pull/1716)) * Added support for `np.float32` with `DissimilarityMatrix` objects. * Added support for method and number_of_dimensions to permdisp reducing the runtime by 100x at 4000 samples, [issue #1769](https://github.com/biocore/scikit-bio/pull/1769). * OrdinationResults object is now accepted as input for permdisp. ### Performance enhancements * Avoid an implicit data copy on construction of `DissimilarityMatrix` objects. * Avoid validation on copy of `DissimilarityMatrix` and `DistanceMatrix` objects, see [PR #1747](https://github.com/biocore/scikit-bio/pull/1747) * Use an optimized version of symmetry check in DistanceMatrix, see [PR #1747](https://github.com/biocore/scikit-bio/pull/1747) * Avoid performing filtering when ids are identical, see [PR #1752](https://github.com/biocore/scikit-bio/pull/1752) * center_distance_matrix has been re-implemented in cython for both speed and memory use. Indirectly speeds up pcoa [PR #1749](https://github.com/biocore/scikit-bio/pull/1749) * Use a memory-optimized version of permute in DistanceMatrix, see [PR #1756](https://github.com/biocore/scikit-bio/pull/1756). * Refactor pearson and spearman skbio.stats.distance.mantel implementations to drastically improve memory locality. Also cache intermediate results that are invariant across permutations, see [PR #1756](https://github.com/biocore/scikit-bio/pull/1756). * Refactor permanova to remove intermediate buffers and cythonize the internals, see [PR #1768](https://github.com/biocore/scikit-bio/pull/1768). ### Bug fixes * Fix windows and 32bit incompatibility in `unweighted_unifrac`. ### Miscellaneous * Python 3.6 has been removed from our testing matrix. * Specify build dependencies in pyproject.toml. This allows the package to be installed without having to first manually install numpy. * Update hdmedians package to a version which doesn't require an initial manual numpy install. * Now buildable on non-x86 platforms due to use of the [SIMD Everywhere](https://github.com/simd-everywhere/simde) library. * Regenerate Cython wrapper by default to avoid incompatibilities with installed CPython. * Update documentation for the `skbio.stats.composition.ancom` function. ([#1741](https://github.com/biocore/scikit-bio/pull/1741)) ## Version 0.5.6 ### Features * Added option to return a capture group compiled regex pattern to any class inheriting ``GrammaredSequence`` through the ``to_regex`` method. ([#1431](https://github.com/biocore/scikit-bio/issues/1431)) * Added `Dissimilarity.within` and `.between` to obtain the respective distances and express them as a `DataFrame`. ([#1662](https://github.com/biocore/scikit-bio/pull/1662)) * Added Kendall Tau as possible correlation method in the `skbio.stats.distance.mantel` function ([#1675](https://github.com/biocore/scikit-bio/issues/1675)). * Added support for IUPAC amino acid codes U (selenocysteine), O (pyrrolysine), and J (leucine or isoleucine). ([#1576](https://github.com/biocore/scikit-bio/issues/1576) ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] * Changed `skbio.tree.TreeNode.support` from a method to a property. * Added `assign_supports` method to `skbio.tree.TreeNode` to extract branch support values from node labels. * Modified the way a node's label is printed: `support:name` if both exist, or `support` or `name` if either exists. ### Performance enhancements ### Bug fixes * Require `Sphinx <= 3.0`. Newer Sphinx versions caused build errors. [#1719](https://github.com/biocore/scikit-bio/pull/1719) * * `skbio.stats.ordination` tests have been relaxed. ([#1713](https://github.com/biocore/scikit-bio/issues/1713)) * Fixes build errors for newer versions of NumPy, Pandas, and SciPy. * Corrected a criticial bug in `skbio.alignment.StripedSmithWaterman`/`skbio.alignment.local_pairwise_align_ssw` which would cause the formatting of the aligned sequences to misplace gap characters by the number of gap characters present in the opposing aligned sequence up to that point. This was caused by a faulty implementation of CIGAR string parsing, see [#1679](https://github.com/biocore/scikit-bio/pull/1679) for full details. * Fixes build errors for newer versions of NumPy, Pandas, and SciPy. * Corrected a criticial bug in `skbio.alignment.StripedSmithWaterman`/`skbio.alignment.local_pairwise_align_ssw` which would cause the formatting of the aligned sequences to misplace gap characters by the number of gap characters present in the opposing aligned sequence up to that point. This was caused by a faulty implementation of CIGAR string parsing, see [#1679](https://github.com/biocore/scikit-bio/pull/1679) for full details. ### Deprecated functionality [stable] ### Deprecated functionality [experimental] ### Miscellaneous * `skbio.diversity.beta_diversity` now accepts a pandas DataFrame as input. * Avoid pandas 1.0.0 import warning ([#1688](https://github.com/biocore/scikit-bio/issues/1688)) * Added support for Python 3.8 and dropped support for Python 3.5. * This version now depends on `scipy >= 1.3` and `pandas >= 1.0`. ## Version 0.5.5 (2018-12-10) ### Features * `skbio.stats.composition` now has methods to compute additive log-ratio transformation and inverse additive log-ratio transformation (`alr`, `alr_inv`) as well as a method to build a basis from a sequential binary partition (`sbp_basis`). ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] ### Performance enhancements ### Bug fixes ### Deprecated functionality [stable] ### Deprecated functionality [experimental] ### Miscellaneous * Python 3.6 and 3.7 compatibility is now supported * A pytest runner is shipped with every installation ([#1633](https://github.com/biocore/scikit-bio/pull/1633)) * The nosetest framework has been replaced in favor of pytest ([#1624](https://github.com/biocore/scikit-bio/pull/1624)) * The numpy docs are deprecated in favor of [Napoleon](http://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html) ([#1629](https://github.com/biocore/scikit-bio/pull/1629)) * This version is now compatible with NumPy >= 1.9.2 and Pandas >= 0.23. ([#1627](https://github.com/biocore/scikit-bio/pull/1627)) ## Version 0.5.4 (2018-08-23) ### Features * Added `FSVD`, an alternative fast heuristic method to perform Principal Coordinates Analysis, to `skbio.stats.ordination.pcoa`. ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] ### Performance enhancements * Added optimized utility methods `f_matrix_inplace` and `e_matrix_inplace` which perform `f_matrix` and `e_matrix` computations in-place and are used by the new `center_distance_matrix` method in `skbio.stats.ordination`. ### Bug fixes ### Deprecated functionality [stable] ### Deprecated functionality [experimental] ### Miscellaneous ## Version 0.5.3 (2018-08-07) ### Features * Added `unpack` and `unpack_by_func` methods to `skbio.tree.TreeNode` to unpack one or multiple internal nodes. The `unpack` operation removes an internal node and regrafts its children to its parent while retaining the overall length. ([#1572](https://github.com/biocore/scikit-bio/pull/1572)) * Added `support` to `skbio.tree.TreeNode` to return the support value of a node. * Added `permdisp` to `skbio.stats.distance` to test for the homogeniety of groups. ([#1228](https://github.com/biocore/scikit-bio/issues/1228)). * Added `pcoa_biplot` to `skbio.stats.ordination` to project descriptors into a PCoA plot. * Fixed pandas to 0.22.0 due to this: https://github.com/pandas-dev/pandas/issues/20527 ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] ### Performance enhancements ### Bug fixes * Relaxing type checking in diversity calculations. ([#1583](https://github.com/biocore/scikit-bio/issues/1583)). ### Deprecated functionality [stable] ### Deprecated functionality [experimental] ### Miscellaneous ## Version 0.5.2 (2018-04-18) ### Features * Added ``skbio.io.format.embl`` for reading and writing EMBL files for ``DNA``, ``RNA`` and ``Sequence`` classes. * Removing ValueError check in `skbio.stats._subsample.subsample_counts` when `replace=True` and `n` is greater than the number of items in counts. [#1527](https://github.com/biocore/scikit-bio/pull/1527) * Added ``skbio.io.format.gff3`` for reading and writing GFF3 files for ``DNA``, ``Sequence``, and ``IntervalMetadata`` classes. ([#1450](https://github.com/biocore/scikit-bio/pull/1450)) * `skbio.metadata.IntervalMetadata` constructor has a new keyword argument, `copy_from`, for creating an `IntervalMetadata` object from an existing `IntervalMetadata` object with specified `upper_bound`. * `skbio.metadata.IntervalMetadata` constructor allows `None` as a valid value for `upper_bound`. An `upper_bound` of `None` means that the `IntervalMetadata` object has no upper bound. * `skbio.metadata.IntervalMetadata.drop` has a new boolean parameter `negate` to indicate whether to drop or keep the specified `Interval` objects. ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] ### Performance enhancements * `skbio.tree.nj` wall-clock runtime was decreased by 99% for a 500x500 distance matrix and 93% for a 100x100 distance matrix. ([#1512](https://github.com/biocore/scikit-bio/pull/1512), [#1513](https://github.com/biocore/scikit-bio/pull/1513)) ### Bug fixes * The `include_self` parameter was not being honored in `skbio.TreeNode.tips`. The scope of this bug was that if `TreeNode.tips` was called on a tip, it would always result in an empty `list` when unrolled. * In `skbio.stats.ordination.ca`, `proportion_explained` was missing in the returned `OrdinationResults` object. ([#1345](https://github.com/biocore/scikit-bio/issues/1345)) * `skbio.diversity.beta_diversity` now handles qualitative metrics as expected such that `beta_diversity('jaccard', mat) == beta_diversity('jaccard', mat > 0)`. Please see [#1549](https://github.com/biocore/scikit-bio/issues/1549) for further detail. * `skbio.stats.ordination.rda` The occasional column mismatch in output `biplot_scores` is fixed ([#1519](https://github.com/biocore/scikit-bio/issues/1519)). ### Deprecated functionality [stable] ### Deprecated functionality [experimental] ### Miscellaneous * scikit-bio now depends on pandas >= 0.19.2, and is compatible with newer pandas versions (e.g. 0.20.3) that were previously incompatible. * scikit-bio now depends on `numpy >= 1.9.2, < 1.14.0` for compatibility with Python 3.4, 3.5, and 3.6 and the available numpy conda packages in `defaults` and `conda-forge` channels. * added support for running tests from `setup.py`. Both `python setup.py nosetests` and `python setup.py test` are now supported, however `python setup.py test` will only run a subset of the full test suite. ([#1341](https://github.com/biocore/scikit-bio/issues/1341)) ## Version 0.5.1 (2016-11-12) ### Features * Added `IntervalMetadata` and `Interval` classes in `skbio.metadata` to store, query, and manipulate information of a sub-region of a sequence. ([#1414](https://github.com/biocore/scikit-bio/issues/1414)) * `Sequence` and its child classes (including `GrammaredSequence`, `RNA`, `DNA`, `Protein`) now accept `IntervalMetadata` in their constructor API. Some of their relevant methods are also updated accordingly. ([#1430](https://github.com/biocore/scikit-bio/pull/1430)) * GenBank parser now reads and writes `Sequence` or its subclass objects with `IntervalMetadata`. ([#1440](https://github.com/biocore/scikit-bio/pull/1440)) * `DissimilarityMatrix` now has a new constructor method called `from_iterable`. ([#1343](https://github.com/biocore/scikit-bio/issues/1343)). * `DissimilarityMatrix` now allows non-hollow matrices. ([#1343](https://github.com/biocore/scikit-bio/issues/1343)). * `DistanceMatrix.from_iterable` now accepts a `validate=True` parameter. ([#1343](https://github.com/biocore/scikit-bio/issues/1343)). * ``DistanceMatrix`` now has a new method called ``to_series`` to create a ``pandas.Series`` from a ``DistanceMatrix`` ([#1397](https://github.com/biocore/scikit-bio/issues/1397)). * Added parallel beta diversity calculation support via `skbio.diversity.block_beta_diversity`. The issue and idea is discussed in ([#1181](https://github.com/biocore/scikit-bio/issues/1181), while the actual code changes are in [#1352](https://github.com/biocore/scikit-bio/pull/1352)). ### Backward-incompatible changes [stable] * The constructor API for `Sequence` and its child classes (including `GrammaredSequence`, `RNA`, `DNA`, `Protein`) are changed from `(sequence, metadata=None, positional_metadata=None, lowercase=False)` to `(sequence, metadata=None, positional_metadata=None, interval_metadata=None, lowercase=False)` The changes are made to allow these classes to adopt `IntervalMetadata` object for interval features on the sequence. The `interval_metadata` parameter is added imediately after `positional_metadata` instead of appended to the end, because it is more natural and logical and, more importantly, because it is unlikely in practice to break user code. A user's code would break only if they had supplied `metadata`, `postional_metadata`, and `lowercase` parameters positionally. In the unlikely event that this happens, users will get an error telling them a bool isn't a valid `IntervalMetadata` type, so it won't silently produce buggy behavior. ### Backward-incompatible changes [experimental] * Modifying basis handling in `skbio.stats.composition.ilr_inv` prior to checking for orthogonality. Now the basis is strictly assumed to be in the Aitchison simplex. * `DistanceMatrix.from_iterable` default behavior is now to validate matrix by computing all pairwise distances. Pass `validate=False` to get the previous behavior (no validation, but faster execution).([#1343](https://github.com/biocore/scikit-bio/issues/1343)). * GenBank I/O now parses sequence features into the attribute of `interval_metadata` instead of `positiona_metadata`. And the key of `FEATURES` is removed from `metadata` attribute. ### Performance enhancements * `TreeNode.shear` was rewritten for approximately a 25% performance increase. ([#1399](https://github.com/biocore/scikit-bio/pull/1399)) * The `IntervalMetadata` allows dramatic decrease in memory usage in reading GenBank files of feature rich sequences. ([#1159](https://github.com/biocore/scikit-bio/issues/1159)) ### Bug fixes * `skbio.tree.TreeNode.prune` and implicitly `skbio.tree.TreeNode.shear` were not handling a situation in which a parent was validly removed during pruning operations as may happen if the resulting subtree does not include the root. Previously, an `AttributeError` would raise as `parent` would be `None` in this situation. * numpy linking was fixed for installation under El Capitan. * A bug was introduced in #1398 into `TreeNode.prune` and fixed in #1416 in which, under the special case of a single descendent existing from the root, the resulting children parent references were not updated. The cause of the bug was a call made to `self.children.extend` as opposed to `self.extend` where the former is a `list.extend` without knowledge of the tree, while the latter is `TreeNode.extend` which is able to adjust references to `self.parent`. ### Miscellaneous * Removed deprecated functions from `skbio.util`: `is_casava_v180_or_later`, `remove_files`, and `create_dir`. * Removed deprecated `skbio.Sequence.copy` method. ## Version 0.5.0 (2016-06-14) **IMPORTANT**: scikit-bio is no longer compatible with Python 2. scikit-bio is compatible with Python 3.4 and later. ### Features * Added more descriptive error message to `skbio.io.registry` when attempting to read without specifying `into` and when there is no generator reader. ([#1326](https://github.com/biocore/scikit-bio/issues/1326)) * Added support for reference tags to `skbio.io.format.stockholm` reader and writer. ([#1348](https://github.com/biocore/scikit-bio/issues/1348)) * Expanded error message in `skbio.io.format.stockholm` reader when `constructor` is not passed, in order to provide better explanation to user. ([#1327](https://github.com/biocore/scikit-bio/issues/1327)) * Added `skbio.sequence.distance.kmer_distance` for computing the kmer distance between two sequences. ([#913](https://github.com/biocore/scikit-bio/issues/913)) * Added `skbio.sequence.Sequence.replace` for assigning a character to positions in a `Sequence`. ([#1222](https://github.com/biocore/scikit-bio/issues/1222)) * Added support for `pandas.RangeIndex`, lowering the memory footprint of default integer index objects. `Sequence.positional_metadata` and `TabularMSA.positional_metadata` now use `pd.RangeIndex` as the positional metadata index. `TabularMSA` now uses `pd.RangeIndex` as the default index. Usage of `pd.RangeIndex` over the previous `pd.Int64Index` [should be transparent](http://pandas.pydata.org/pandas-docs/version/0.18.0/whatsnew.html#range-index), so these changes should be non-breaking to users. scikit-bio now depends on pandas >= 0.18.0 ([#1308](https://github.com/biocore/scikit-bio/issues/1308)) * Added `reset_index=False` parameter to `TabularMSA.append` and `TabularMSA.extend` for resetting the MSA's index to the default index after appending/extending. * Added support for partial pairwise calculations via `skbio.diversity.partial_beta_diversity`. ([#1221](https://github.com/biocore/scikit-bio/issues/1221), [#1337](https://github.com/biocore/scikit-bio/pull/1337)). This function is immediately deprecated as its return type will change in the future and should be used with caution in its present form (see the function's documentation for details). * `TemporaryFile` and `NamedTemporaryFile` are now supported IO sources for `skbio.io` and related functionality. ([#1291](https://github.com/biocore/scikit-bio/issues/1291)) * Added `tree_node_class=TreeNode` parameter to `skbio.tree.majority_rule` to support returning consensus trees of type `TreeNode` (the default) or a type that has the same interface as `TreeNode` (e.g. `TreeNode` subclasses) ([#1193](https://github.com/biocore/scikit-bio/pull/1193)) * `TreeNode.from_linkage_matrix` and `TreeNode.from_taxonomy` now support constructing `TreeNode` subclasses. `TreeNode.bifurcate` now supports `TreeNode` subclasses ([#1193](https://github.com/biocore/scikit-bio/pull/1193)) * The `ignore_metadata` keyword has been added to `TabularMSA.iter_positions` to improve performance when metadata is not necessary. * Pairwise aligners in `skbio.alignment` now propagate per-sequence `metadata` objects (this does not include `positional_metadata`). ### Backward-incompatible changes [stable] ### Backward-incompatible changes [experimental] * `TabularMSA.append` and `TabularMSA.extend` now require one of `minter`, `index`, or `reset_index` to be provided when incorporating new sequences into an MSA. Previous behavior was to auto-increment the index labels if `minter` and `index` weren't provided and the MSA had a default integer index, otherwise error. Use `reset_index=True` to obtain the previous behavior in a more explicit way. * `skbio.stats.composition.ancom` now returns two `pd.DataFrame` objects, where it previously returned one. The first contains the ANCOM test results, as before, and the second contains percentile abundances of each feature in each group. The specific percentiles that are computed and returned is controlled by the new `percentiles` parameter to `skbio.stats.composition.ancom`. In the future, this second `pd.DataFrame` will not be returned by this function, but will be available through the [contingency table API](https://github.com/biocore/scikit-bio/issues/848). ([#1293](https://github.com/biocore/scikit-bio/issues/1293)) * `skbio.stats.composition.ancom` now performs multiple comparisons correction by default. The previous behavior of not performing multiple comparisons correction can be achieved by passing ``multiple_comparisons_correction=None``. * The ``reject`` column in the first ``pd.DataFrame`` returned from `skbio.stats.composition.ancom` has been renamed ``Reject null hypothesis`` for clarity. ([#1375](https://github.com/biocore/scikit-bio/issues/1375)) ### Bug fixes * Fixed row and column names to `biplot_scores` in the `OrdinationResults` object from `skbio.stats.ordination`. This fix affect the `cca` and `rda` methods. ([#1322](https://github.com/biocore/scikit-bio/issues/1322)) * Fixed bug when using `skbio.io.format.stockholm` reader on file with multi-line tree with no id. Previously this raised an `AttributeError`, now it correctly handles this type of tree. ([#1334](https://github.com/biocore/scikit-bio/issues/1334)) * Fixed bug when reading Stockholm files with GF or GS features split over multiple lines. Previously, the feature text was simply concatenated because it was assumed to have trailing whitespace. There are examples of Stockholm files with and without trailing whitespace for multi-line features, so the `skbio.io.format.stockholm` reader now adds a single space when concatenating feature text without trailing whitespace to avoid joining words together. Multi-line trees stored as GF metadata are concatenated as they appear in the file; a space is not added when concatenating. ([#1328](https://github.com/biocore/scikit-bio/issues/1328)) * Fixed bug when using `Sequence.iter_kmers` on empty `Sequence` object. Previously this raised a `ValueError`, now it returns an empty generator. * Fixed minor bug where adding sequences to an empty `TabularMSA` with MSA-wide `positional_metadata` would result in a `TabularMSA` object in an inconsistent state. This could happen using `TabularMSA.append` or `TabularMSA.extend`. This bug only affects a `TabularMSA` object *without* sequences that has MSA-wide `positional_metadata` (for example, `TabularMSA([], positional_metadata={'column': []})`). * `TreeNode.distance` now handles the situation in which `self` or `other` are ancestors. Previosly, a node further up the tree was used resulting in inflated distances. ([#807](https://github.com/biocore/scikit-bio/issues/807)) * `TreeNode.prune` can now handle a root with a single descendent. Previously, the root was ignored from possibly having a single descendent. ([#1247](https://github.com/biocore/scikit-bio/issues/1247)) * Providing the `format` keyword to `skbio.io.read` when creating a generator with an empty file will now return an empty generator instead of raising `StopIteration`. ([#1313](https://github.com/biocore/scikit-bio/issues/1313)) * `OrdinationResults` is now importable from `skbio` and `skbio.stats.ordination` and correctly linked from the documentation ([#1205](https://github.com/biocore/scikit-bio/issues/1205)) * Fixed performance bug in pairwise aligners resulting in 100x worse performance than in 0.2.4. ### Deprecated functionality [stable] * Deprecated use of the term "non-degenerate", in favor of "definite". `GrammaredSequence.nondegenerate_chars`, `GrammaredSequence.nondegenerates`, and `GrammaredSequence.has_nondegenerates` have been renamed to `GrammaredSequence.definite_chars`, `GrammaredSequence.definites`, and `GrammaredSequence.has_definites`, respectively. The old names will be removed in scikit-bio 0.5.2. Relevant affected public classes include `GrammaredSequence`, `DNA`, `RNA`, and `Protein`. ### Deprecated functionality [experimental] * Deprecated function `skbio.util.create_dir`. This function will be removed in scikit-bio 0.5.1. Please use the Python standard library functionality described [here](https://docs.python.org/2/library/os.html#os.makedirs). ([#833](https://github.com/biocore/scikit-bio/issues/833)) * Deprecated function `skbio.util.remove_files`. This function will be removed in scikit-bio 0.5.1. Please use the Python standard library functionality described [here](https://docs.python.org/2/library/os.html#os.remove). ([#833](https://github.com/biocore/scikit-bio/issues/833)) * Deprecated function `skbio.util.is_casava_v180_or_later`. This function will be removed in 0.5.1. Functionality moved to FASTQ sniffer. ([#833](https://github.com/biocore/scikit-bio/issues/833)) ### Miscellaneous * When installing scikit-bio via `pip`, numpy must now be installed first ([#1296](https://github.com/biocore/scikit-bio/issues/1296)) ## Version 0.4.2 (2016-02-17) Minor maintenance release. **This is the last Python 2.7 compatible release. Future scikit-bio releases will only support Python 3.** ### Features * Added `skbio.tree.TreeNode.bifurcate` for converting multifurcating trees into bifurcating trees. ([#896](https://github.com/biocore/scikit-bio/issues/896)) * Added `skbio.io.format.stockholm` for reading Stockholm files into a `TabularMSA` and writing from a `TabularMSA`. ([#967](https://github.com/biocore/scikit-bio/issues/967)) * scikit-bio `Sequence` objects have better compatibility with numpy. For example, calling `np.asarray(sequence)` now converts the sequence to a numpy array of characters (the same as calling `sequence.values`). * Added `skbio.sequence.distance` subpackage for computing distances between scikit-bio `Sequence` objects ([#913](https://github.com/biocore/scikit-bio/issues/913)) * Added ``skbio.sequence.GrammaredSequence``, which can be inherited from to create grammared sequences with custom alphabets (e.g., for use with TabularMSA) ([#1175](https://github.com/biocore/scikit-bio/issues/1175)) * Added ``skbio.util.classproperty`` decorator ### Backward-incompatible changes [stable] * When sniffing or reading a file (`skbio.io.sniff`, `skbio.io.read`, or the object-oriented `.read()` interface), passing `newline` as a keyword argument to `skbio.io.open` now raises a `TypeError`. This backward-incompatible change to a stable API is necessary because it fixes a bug (more details in bug fix section below). * When reading a FASTQ or QSEQ file and passing `variant='solexa'`, `ValueError` is now raised instead of `NotImplementedError`. This backward-incompatible change to a stable API is necessary to avoid creating a spin-locked process due to [a bug in Python](https://bugs.python.org/issue25786). See [#1256](https://github.com/biocore/scikit-bio/issues/1256) for details. This change is temporary and will be reverted to `NotImplementedError` when the bug is fixed in Python. ### Backward-incompatible changes [experimental] * `skbio.io.format.genbank`: When reading GenBank files, the date field of the LOCUS line is no longer parsed into a `datetime.datetime` object and is left as a string. When writing GenBank files, the locus date metadata is expected to be a string instead of a `datetime.datetime` object ([#1153](https://github.com/biocore/scikit-bio/issues/1153)) * `Sequence.distance` now converts the input sequence (`other`) to its type before passing both sequences to `metric`. Previous behavior was to always convert to `Sequence`. ### Bug fixes * Fixed bug when using `Sequence.distance` or `DistanceMatrix.from_iterable` to compute distances between `Sequence` objects with differing `metadata`/`positional_metadata` and passing `metric=scipy.spatial.distance.hamming` ([#1254](https://github.com/biocore/scikit-bio/issues/1254)) * Fixed performance bug when computing Hamming distances between `Sequence` objects in `DistanceMatrix.from_iterable` ([#1250](https://github.com/biocore/scikit-bio/issues/1250)) * Changed `skbio.stats.composition.multiplicative_replacement` to raise an error whenever a large value of `delta` is chosen ([#1241](https://github.com/biocore/scikit-bio/issues/1241)) * When sniffing or reading a file (`skbio.io.sniff`, `skbio.io.read`, or the object-oriented `.read()` interface), passing `newline` as a keyword argument to `skbio.io.open` now raises a `TypeError`. The file format's `newline` character will be used when opening the file. Previous behavior allowed overriding the format's `newline` character but this could cause issues with readers that assume newline characters are those defined by the file format (which is an entirely reasonable assumption). This bug is very unlikely to have surfaced in practice as the default `newline` behavior is *universal newlines mode*. * DNA, RNA, and Protein are no longer inheritable because they assume an IUPAC alphabet. * `DistanceMatrix` constructor provides more informative error message when data contains NaNs ([#1276](https://github.com/biocore/scikit-bio/issues/1276)) ### Miscellaneous * Warnings raised by scikit-bio now share a common subclass ``skbio.util.SkbioWarning``. ## Version 0.4.1 (2015-12-09) ### Features * The ``TabularMSA`` object was added to represent and operate on tabular multiple sequence alignments. This satisfies [RFC 1](https://github.com/biocore/scikit-bio-rfcs/blob/master/active/001-tabular-msa.md). See the ``TabularMSA`` docs for full details. * Added phylogenetic diversity metrics, including weighted UniFrac, unweighted UniFrac, and Faith's Phylogenetic Diversity. These are accessible as ``skbio.diversity.beta.unweighted_unifrac``, ``skbio.diversity.beta.weighted_unifrac``, and ``skbio.diversity.alpha.faith_pd``, respectively. * Addition of the function ``skbio.diversity.alpha_diversity`` to support applying an alpha diversity metric to multiple samples in one call. * Addition of the functions ``skbio.diversity.get_alpha_diversity_metrics`` and ``skbio.diversity.get_beta_diversity_metrics`` to support discovery of the alpha and beta diversity metrics implemented in scikit-bio. * Added `skbio.stats.composition.ancom` function, a test for OTU differential abundance across sample categories. ([#1054](https://github.com/biocore/scikit-bio/issues/1054)) * Added `skbio.io.format.blast7` for reading BLAST+ output format 7 or BLAST output format 9 files into a `pd.DataFrame`. ([#1110](https://github.com/biocore/scikit-bio/issues/1110)) * Added `skbio.DissimilarityMatrix.to_data_frame` method for creating a ``pandas.DataFrame`` from a `DissimilarityMatrix` or `DistanceMatrix`. ([#757](https://github.com/biocore/scikit-bio/issues/757)) * Added support for one-dimensional vector of dissimilarities in `skbio.stats.distance.DissimilarityMatrix` constructor. ([#6240](https://github.com/biocore/scikit-bio/issues/624)) * Added `skbio.io.format.blast6` for reading BLAST+ output format 6 or BLAST output format 8 files into a `pd.DataFrame`. ([#1110](https://github.com/biocore/scikit-bio/issues/1110)) * Added `inner`, `ilr`, `ilr_inv` and `clr_inv`, ``skbio.stats.composition``, which enables linear transformations on compositions ([#892](https://github.com/biocore/scikit-bio/issues/892) * Added ``skbio.diversity.alpha.pielou_e`` function as an evenness metric of alpha diversity. ([#1068](https://github.com/biocore/scikit-bio/issues/1068)) * Added `to_regex` method to `skbio.sequence._iupac_sequence` ABC - it returns a regex object that matches all non-degenerate versions of the sequence. * Added ``skbio.util.assert_ordination_results_equal`` function for comparing ``OrdinationResults`` objects in unit tests. * Added ``skbio.io.format.genbank`` for reading and writing GenBank/GenPept for ``DNA``, ``RNA``, ``Protein`` and ``Sequence`` classes. * Added ``skbio.util.RepresentationWarning`` for warning about substitutions, assumptions, or particular alterations that were made for the successful completion of a process. * ``TreeNode.tip_tip_distances`` now supports nodes without an associated length. In this case, a length of 0.0 is assumed and an ``skbio.util.RepresentationWarning`` is raised. Previous behavior was to raise a ``NoLengthError``. ([#791](https://github.com/biocore/scikit-bio/issues/791)) * ``DistanceMatrix`` now has a new constructor method called `from_iterable`. * ``Sequence`` now accepts ``lowercase`` keyword like ``DNA`` and others. Updated ``fasta``, ``fastq``, and ``qseq`` readers/writers for ``Sequence`` to reflect this. * The ``lowercase`` method has been moved up to ``Sequence`` meaning all sequence objects now have a ``lowercase`` method. * Added ``reverse_transcribe`` class method to ``RNA``. * Added `Sequence.observed_chars` property for obtaining the set of observed characters in a sequence. ([#1075](https://github.com/biocore/scikit-bio/issues/1075)) * Added `Sequence.frequencies` method for computing character frequencies in a sequence. ([#1074](https://github.com/biocore/scikit-bio/issues/1074)) * Added experimental class-method ``Sequence.concat`` which will produce a new sequence from an iterable of existing sequences. Parameters control how positional metadata is propagated during a concatenation. * ``TreeNode.to_array`` now supports replacing ``nan`` branch lengths in the resulting branch length vector with the value provided as ``nan_length_value``. * ``skbio.io.format.phylip`` now supports sniffing and reading strict, sequential PHYLIP-formatted files into ``skbio.Alignment`` objects. ([#1006](https://github.com/biocore/scikit-bio/issues/1006)) * Added `default_gap_char` class property to ``DNA``, ``RNA``, and ``Protein`` for representing gap characters in a new sequence. ### Backward-incompatible changes [stable] * `Sequence.kmer_frequencies` now returns a `dict`. Previous behavior was to return a `collections.Counter` if `relative=False` was passed, and a `collections.defaultdict` if `relative=True` was passed. In the case of a missing key, the `Counter` would return 0 and the `defaultdict` would return 0.0. Because the return type is now always a `dict`, attempting to access a missing key will raise a `KeyError`. This change *may* break backwards-compatibility depending on how the `Counter`/`defaultdict` is being used. We hope that in most cases this change will not break backwards-compatibility because both `Counter` and `defaultdict` are `dict` subclasses. If the previous behavior is desired, convert the `dict` into a `Counter`/`defaultdict`: ```python import collections from skbio import Sequence seq = Sequence('ACCGAGTTTAACCGAATA') # Counter freqs_dict = seq.kmer_frequencies(k=8) freqs_counter = collections.Counter(freqs_dict) # defaultdict freqs_dict = seq.kmer_frequencies(k=8, relative=True) freqs_default_dict = collections.defaultdict(float, freqs_dict) ``` **Rationale:** We believe it is safer to return `dict` instead of `Counter`/`defaultdict` as this may prevent error-prone usage of the return value. Previous behavior allowed accessing missing kmers, returning 0 or 0.0 depending on the `relative` parameter. This is convenient in many cases but also potentially misleading. For example, consider the following code: ```python from skbio import Sequence seq = Sequence('ACCGAGTTTAACCGAATA') freqs = seq.kmer_frequencies(k=8) freqs['ACCGA'] ``` Previous behavior would return 0 because the kmer `'ACCGA'` is not present in the `Counter`. In one respect this is the correct answer because we asked for kmers of length 8; `'ACCGA'` is a different length so it is not included in the results. However, we believe it is safer to avoid this implicit behavior in case the user assumes there are no `'ACCGA'` kmers in the sequence (which there are!). A `KeyError` in this case is more explicit and forces the user to consider their query. Returning a `dict` will also be consistent with `Sequence.frequencies`. ### Backward-incompatible changes [experimental] * Replaced ``PCoA``, ``CCA``, ``CA`` and ``RDA`` in ``skbio.stats.ordination`` with equivalent functions ``pcoa``, ``cca``, ``ca`` and ``rda``. These functions now take ``pd.DataFrame`` objects. * Change ``OrdinationResults`` to have its attributes based on ``pd.DataFrame`` and ``pd.Series`` objects, instead of pairs of identifiers and values. The changes are as follows: - ``species`` and ``species_ids`` have been replaced by a ``pd.DataFrame`` named ``features``. - ``site`` and ``site_ids`` have been replaced by a ``pd.DataFrame`` named ``samples``. - ``eigvals`` is now a ``pd.Series`` object. - ``proportion_explained`` is now a ``pd.Series`` object. - ``biplot`` is now a ``pd.DataFrame`` object named ``biplot_scores``. - ``site_constraints`` is now a ``pd.DataFrame`` object named ``sample_constraints``. * ``short_method_name`` and ``long_method_name`` are now required arguments of the ``OrdinationResults`` object. * Removed `skbio.diversity.alpha.equitability`. Please use `skbio.diversity.alpha.pielou_e`, which is more accurately named and better documented. Note that `equitability` by default used logarithm base 2 while `pielou_e` uses logarithm base `e` as described in Heip 1974. * ``skbio.diversity.beta.pw_distances`` is now called ``skbio.diversity.beta_diversity``. This function no longer defines a default metric, and ``metric`` is now the first argument to this function. This function can also now take a pairwise distances function as ``pairwise_func``. * Deprecated function ``skbio.diversity.beta.pw_distances_from_table`` has been removed from scikit-bio as scheduled. Code that used this should be adapted to use ``skbio.diversity.beta_diversity``. * ``TreeNode.index_tree`` now returns a 2-D numpy array as its second return value (the child node index) instead of a 1-D numpy array. * Deprecated functions `skbio.draw.boxplots` and `skbio.draw.grouped_distributions` have been removed from scikit-bio as scheduled. These functions generated plots that were not specific to bioinformatics. These types of plots can be generated with seaborn or another general-purpose plotting package. * Deprecated function `skbio.stats.power.bootstrap_power_curve` has been removed from scikit-bio as scheduled. Use `skbio.stats.power.subsample_power` or `skbio.stats.power.subsample_paired_power` followed by `skbio.stats.power.confidence_bound`. * Deprecated function `skbio.stats.spatial.procrustes` has been removed from scikit-bio as scheduled in favor of `scipy.spatial.procrustes`. * Deprecated class `skbio.tree.CompressedTrie` and function `skbio.tree.fasta_to_pairlist` have been removed from scikit-bio as scheduled in favor of existing general-purpose Python trie packages. * Deprecated function `skbio.util.flatten` has been removed from scikit-bio as scheduled in favor of solutions available in the Python standard library (see [here](http://stackoverflow.com/a/952952/3639023) and [here](http://stackoverflow.com/a/406199/3639023) for examples). * Pairwise alignment functions in `skbio.alignment` now return a tuple containing the `TabularMSA` alignment, alignment score, and start/end positions. The returned `TabularMSA`'s `index` is always the default integer index; sequence IDs are no longer propagated to the MSA. Additionally, the pairwise alignment functions now accept the following input types to align: - `local_pairwise_align_nucleotide`: `DNA` or `RNA` - `local_pairwise_align_protein`: `Protein` - `local_pairwise_align`: `IUPACSequence` - `global_pairwise_align_nucleotide`: `DNA`, `RNA`, or `TabularMSA[DNA|RNA]` - `global_pairwise_align_protein`: `Protein` or `TabularMSA[Protein]` - `global_pairwise_align`: `IUPACSequence` or `TabularMSA` - `local_pairwise_align_ssw`: `DNA`, `RNA`, or `Protein`. Additionally, this function now overrides the `protein` kwarg based on input type. `constructor` parameter was removed because the function now determines the return type based on input type. * Removed `skbio.alignment.SequenceCollection` in favor of using a list or other standard library containers to store scikit-bio sequence objects (most `SequenceCollection` operations were simple list comprehensions). Use `DistanceMatrix.from_iterable` instead of `SequenceCollection.distances` (pass `key="id"` to exactly match original behavior). * Removed `skbio.alignment.Alignment` in favor of `skbio.alignment.TabularMSA`. * Removed `skbio.alignment.SequenceCollectionError` and `skbio.alignment.AlignmentError` exceptions as their corresponding classes no longer exist. ### Bug Fixes * ``Sequence`` objects now handle slicing of empty positional metadata correctly. Any metadata that is empty will no longer be propagated by the internal ``_to`` constructor. ([#1133](https://github.com/biocore/scikit-bio/issues/1133)) * ``DissimilarityMatrix.plot()`` no longer leaves a white border around the heatmap it plots (PR #1070). * TreeNode.root_at_midpoint`` no longer fails when a node with two equal length child branches exists in the tree. ([#1077](https://github.com/biocore/scikit-bio/issues/1077)) * ``TreeNode._set_max_distance``, as called through ``TreeNode.get_max_distance`` or ``TreeNode.root_at_midpoint`` would store distance information as ``list``s in the attribute ``MaxDistTips`` on each node in the tree, however, these distances were only valid for the node in which the call to ``_set_max_distance`` was made. The values contained in ``MaxDistTips`` are now correct across the tree following a call to ``get_max_distance``. The scope of impact of this bug is limited to users that were interacting directly with ``MaxDistTips`` on descendant nodes; this bug does not impact any known method within scikit-bio. ([#1223](https://github.com/biocore/scikit-bio/issues/1223)) * Added missing `nose` dependency to setup.py's `install_requires`. ([#1214](https://github.com/biocore/scikit-bio/issues/1214)) * Fixed issue that resulted in legends of ``OrdinationResult`` plots sometimes being truncated. ([#1210](https://github.com/biocore/scikit-bio/issues/1210)) ### Deprecated functionality [stable] * `skbio.Sequence.copy` has been deprecated in favor of `copy.copy(seq)` and `copy.deepcopy(seq)`. ### Miscellaneous * Doctests are now written in Python 3. * ``make test`` now validates MANIFEST.in using [check-manifest](https://github.com/mgedmin/check-manifest). ([#461](https://github.com/biocore/scikit-bio/issues/461)) * Many new alpha diversity equations added to ``skbio.diversity.alpha`` documentation. ([#321](https://github.com/biocore/scikit-bio/issues/321)) * Order of ``lowercase`` and ``validate`` keywords swapped in ``DNA``, ``RNA``, and ``Protein``. ## Version 0.4.0 (2015-07-08) Initial beta release. In addition to the changes detailed below, the following subpackages have been mostly or entirely rewritten and most of their APIs are substantially different (and improved!): * `skbio.sequence` * `skbio.io` The APIs of these subpackages are now stable, and all others are experimental. See the [API stability docs](https://github.com/biocore/scikit-bio/tree/0.4.0/doc/source/user/api_stability.rst) for more details, including what we mean by *stable* and *experimental* in this context. We recognize that this is a lot of backward-incompatible changes. To avoid these types of changes being a surprise to our users, our public APIs are now decorated to make it clear to developers when an API can be relied upon (stable) and when it may be subject to change (experimental). ### Features * Added `skbio.stats.composition` for analyzing data made up of proportions * Added new ``skbio.stats.evolve`` subpackage for evolutionary statistics. Currently contains a single function, ``hommola_cospeciation``, which implements a permutation-based test of correlation between two distance matrices. * Added support for ``skbio.io.util.open_file`` and ``skbio.io.util.open_files`` to pull files from HTTP and HTTPS URLs. This behavior propagates to the I/O registry. * FASTA/QUAL (``skbio.io.format.fasta``) and FASTQ (``skbio.io.format.fastq``) readers now allow blank or whitespace-only lines at the beginning of the file, between records, or at the end of the file. A blank or whitespace-only line in any other location will continue to raise an error [#781](https://github.com/biocore/scikit-bio/issues/781). * scikit-bio now ignores leading and trailing whitespace characters on each line while reading FASTA/QUAL and FASTQ files. * Added `ratio` parameter to `skbio.stats.power.subsample_power`. This allows the user to calculate power on groups for uneven size (For example, draw twice as many samples from Group B than Group A). If `ratio` is not set, group sizes will remain equal across all groups. * Power calculations (`skbio.stats.power.subsample_power` and `skbio.stats.power.subsample_paired_power`) can use test functions that return multiple p values, like some multivariate linear regression models. Previously, the power calculations required the test to return a single p value. * Added ``skbio.util.assert_data_frame_almost_equal`` function for comparing ``pd.DataFrame`` objects in unit tests. ### Performance enhancements * The speed of quality score decoding has been significantly improved (~2x) when reading `fastq` files. * The speed of `NucleotideSequence.reverse_complement` has been improved (~6x). ### Bug fixes * Changed `Sequence.distance` to raise an error any time two sequences are passed of different lengths regardless of the `distance_fn` being passed. [(#514)](https://github.com/biocore/scikit-bio/issues/514) * Fixed issue with ``TreeNode.extend`` where if given the children of another ``TreeNode`` object (``tree.children``), both trees would be left in an incorrect and unpredictable state. ([#889](https://github.com/biocore/scikit-bio/issues/889)) * Changed the way power was calculated in `subsample_paired_power` to move the subsample selection before the test is performed. This increases the number of Monte Carlo simulations performed during power estimation, and improves the accuracy of the returned estimate. Previous power estimates from `subsample_paired_power` should be disregarded and re-calculated. ([#910](https://github.com/biocore/scikit-bio/issues/910)) * Fixed issue where `randdm` was attempting to create asymmetric distance matrices.This was causing an error to be raised by the `DistanceMatrix` constructor inside of the `randdm` function, so that `randdm` would fail when attempting to create large distance matrices. ([#943](https://github.com/biocore/scikit-bio/issues/943)) ### Deprecated functionality * Deprecated `skbio.util.flatten`. This function will be removed in scikit-bio 0.3.1. Please use standard python library functionality described here [Making a flat list out of lists of lists](http://stackoverflow.com/a/952952/3639023), [Flattening a shallow list](http://stackoverflow.com/a/406199/3639023) ([#833](https://github.com/biocore/scikit-bio/issues/833)) * Deprecated `skbio.stats.power.bootstrap_power_curve` will be removed in scikit-bio 0.4.1. It is deprecated in favor of using ``subsample_power`` or ``sample_paired_power`` to calculate a power matrix, and then the use of ``confidence_bounds`` to calculate the average and confidence intervals. ### Backward-incompatible changes * Removed the following deprecated functionality: - `skbio.parse` subpackage, including `SequenceIterator`, `FastaIterator`, `FastqIterator`, `load`, `parse_fasta`, `parse_fastq`, `parse_qual`, `write_clustal`, `parse_clustal`, and `FastqParseError`; please use `skbio.io` instead. - `skbio.format` subpackage, including `fasta_from_sequence`, `fasta_from_alignment`, and `format_fastq_record`; please use `skbio.io` instead. - `skbio.alignment.SequenceCollection.int_map`; please use `SequenceCollection.update_ids` instead. - `skbio.alignment.SequenceCollection` methods `to_fasta` and `toFasta`; please use `SequenceCollection.write` instead. - `constructor` parameter in `skbio.alignment.Alignment.majority_consensus`; please convert returned biological sequence object manually as desired (e.g., `str(seq)`). - `skbio.alignment.Alignment.to_phylip`; please use `Alignment.write` instead. - `skbio.sequence.BiologicalSequence.to_fasta`; please use `BiologicalSequence.write` instead. - `skbio.tree.TreeNode` methods `from_newick`, `from_file`, and `to_newick`; please use `TreeNode.read` and `TreeNode.write` instead. - `skbio.stats.distance.DissimilarityMatrix` methods `from_file` and `to_file`; please use `DissimilarityMatrix.read` and `DissimilarityMatrix.write` instead. - `skbio.stats.ordination.OrdinationResults` methods `from_file` and `to_file`; please use `OrdinationResults.read` and `OrdinationResults.write` instead. - `skbio.stats.p_value_to_str`; there is no replacement. - `skbio.stats.subsample`; please use `skbio.stats.subsample_counts` instead. - `skbio.stats.distance.ANOSIM`; please use `skbio.stats.distance.anosim` instead. - `skbio.stats.distance.PERMANOVA`; please use `skbio.stats.distance.permanova` instead. - `skbio.stats.distance.CategoricalStatsResults`; there is no replacement, please use `skbio.stats.distance.anosim` or `skbio.stats.distance.permanova`, which will return a `pandas.Series` object. * `skbio.alignment.Alignment.majority_consensus` now returns `BiologicalSequence('')` if the alignment is empty. Previously, `''` was returned. * `min_observations` was removed from `skbio.stats.power.subsample_power` and `skbio.stats.power.subsample_paired_power`. The minimum number of samples for subsampling depends on the data set and statistical tests. Having a default parameter to set unnecessary limitations on the technique. ### Miscellaneous * Changed testing procedures - Developers should now use `make test` - Users can use `python -m skbio.test` - Added `skbio.util._testing.TestRunner` (available through `skbio.util.TestRunner`). Used to provide a `test` method for each module init file. This class represents a unified testing path which wraps all `skbio` testing functionality. - Autodetect Python version and disable doctests for Python 3. * `numpy` is no longer required to be installed before installing scikit-bio! * Upgraded checklist.py to check source files non-conforming to [new header style](http://scikit-bio.org/docs/latest/development/new_module.html). ([#855](https://github.com/biocore/scikit-bio/issues/855)) * Updated to use `natsort` >= 4.0.0. * The method of subsampling was changed for ``skbio.stats.power.subsample_paired_power``. Rather than drawing a paired sample for the run and then subsampling for each count, the subsample is now drawn for each sample and each run. In test data, this did not significantly alter the power results. * checklist.py now enforces `__future__` imports in .py files. ## Version 0.2.3 (2015-02-13) ### Features * Modified ``skbio.stats.distance.pwmantel`` to accept a list of filepaths. This is useful as it allows for a smaller amount of memory consumption as it only loads two matrices at a time as opposed to requiring that all distance matrices are loaded into memory. * Added ``skbio.util.find_duplicates`` for finding duplicate elements in an iterable. ### Bug fixes * Fixed floating point precision bugs in ``Alignment.position_frequencies``, ``Alignment.position_entropies``, ``Alignment.omit_gap_positions``, ``Alignment.omit_gap_sequences``, ``BiologicalSequence.k_word_frequencies``, and ``SequenceCollection.k_word_frequencies`` ([#801](https://github.com/biocore/scikit-bio/issues/801)). ### Backward-incompatible changes * Removed ``feature_types`` attribute from ``BiologicalSequence`` and all subclasses ([#797](https://github.com/biocore/scikit-bio/pull/797)). * Removed ``find_features`` method from ``BiologicalSequence`` and ``ProteinSequence`` ([#797](https://github.com/biocore/scikit-bio/pull/797)). * ``BiologicalSequence.k_word_frequencies`` now returns a ``collections.defaultdict`` of type ``float`` instead of type ``int``. This only affects the "default" case, when a key isn't present in the dictionary. Previous behavior would return ``0`` as an ``int``, while the new behavior is to return ``0.0`` as a ``float``. This change also affects the ``defaultdict``s that are returned by ``SequenceCollection.k_word_frequencies``. ### Miscellaneous * ``DissimilarityMatrix`` and ``DistanceMatrix`` now report duplicate IDs in the ``DissimilarityMatrixError`` message that can be raised during validation. ## Version 0.2.2 (2014-12-04) ### Features * Added ``plot`` method to ``skbio.stats.distance.DissimilarityMatrix`` for creating basic heatmaps of a dissimilarity/distance matrix (see [#684](https://github.com/biocore/scikit-bio/issues/684)). Also added ``_repr_png_`` and ``_repr_svg_`` methods for automatic display in the IPython Notebook, with ``png`` and ``svg`` properties for direct access. * Added `__str__` method to `skbio.stats.ordination.OrdinationResults`. * Added ``skbio.stats.distance.anosim`` and ``skbio.stats.distance.permanova`` functions, which replace the ``skbio.stats.distance.ANOSIM`` and ``skbio.stats.distance.PERMANOVA`` classes. These new functions provide simpler procedural interfaces to running these statistical methods. They also provide more convenient access to results by returning a ``pandas.Series`` instead of a ``CategoricalStatsResults`` object. These functions have more extensive documentation than their previous versions. If significance tests are suppressed, p-values are returned as ``np.nan`` instead of ``None`` for consistency with other statistical methods in scikit-bio. [#754](https://github.com/biocore/scikit-bio/issues/754) * Added `skbio.stats.power` for performing empirical power analysis. The module uses existing datasets and iteratively draws samples to estimate the number of samples needed to see a significant difference for a given critical value. * Added `skbio.stats.isubsample` for subsampling from an unknown number of values. This method supports subsampling from multiple partitions and does not require that all items be stored in memory, requiring approximately `O(N*M)`` space where `N` is the number of partitions and `M` is the maximum subsample size. * Added ``skbio.stats.subsample_counts``, which replaces ``skbio.stats.subsample``. See deprecation section below for more details ([#770](https://github.com/biocore/scikit-bio/issues/770)). ### Bug fixes * Fixed issue where SSW wouldn't compile on i686 architectures ([#409](https://github.com/biocore/scikit-bio/issues/409)). ### Deprecated functionality * Deprecated ``skbio.stats.p_value_to_str``. This function will be removed in scikit-bio 0.3.0. Permutation-based p-values in scikit-bio are calculated as ``(num_extreme + 1) / (num_permutations + 1)``, so it is impossible to obtain a p-value of zero. This function historically existed for correcting the number of digits displayed when obtaining a p-value of zero. Since this is no longer possible, this functionality will be removed. * Deprecated ``skbio.stats.distance.ANOSIM`` and ``skbio.stats.distance.PERMANOVA`` in favor of ``skbio.stats.distance.anosim`` and ``skbio.stats.distance.permanova``, respectively. * Deprecated ``skbio.stats.distance.CategoricalStatsResults`` in favor of using ``pandas.Series`` to store statistical method results. ``anosim`` and ``permanova`` return ``pandas.Series`` instead of ``CategoricalStatsResults``. * Deprecated ``skbio.stats.subsample`` in favor of ``skbio.stats.subsample_counts``, which provides an identical interface; only the function name has changed. ``skbio.stats.subsample`` will be removed in scikit-bio 0.3.0. ### Backward-incompatible changes * Deprecation warnings are now raised using ``DeprecationWarning`` instead of ``UserWarning`` ([#774](https://github.com/biocore/scikit-bio/issues/774)). ### Miscellaneous * The ``pandas.DataFrame`` returned by ``skbio.stats.distance.pwmantel`` now stores p-values as floats and does not convert them to strings with a specific number of digits. p-values that were previously stored as "N/A" are now stored as ``np.nan`` for consistency with other statistical methods in scikit-bio. See note in "Deprecated functionality" above regarding ``p_value_to_str`` for details. * scikit-bio now supports versions of IPython < 2.0.0 ([#767](https://github.com/biocore/scikit-bio/issues/767)). ## Version 0.2.1 (2014-10-27) This is an alpha release of scikit-bio. At this stage, major backwards-incompatible API changes can and will happen. Unified I/O with the scikit-bio I/O registry was the focus of this release. ### Features * Added ``strict`` and ``lookup`` optional parameters to ``skbio.stats.distance.mantel`` for handling reordering and matching of IDs when provided ``DistanceMatrix`` instances as input (these parameters were previously only available in ``skbio.stats.distance.pwmantel``). * ``skbio.stats.distance.pwmantel`` now accepts an iterable of ``array_like`` objects. Previously, only ``DistanceMatrix`` instances were allowed. * Added ``plot`` method to ``skbio.stats.ordination.OrdinationResults`` for creating basic 3-D matplotlib scatterplots of ordination results, optionally colored by metadata in a ``pandas.DataFrame`` (see [#518](https://github.com/biocore/scikit-bio/issues/518)). Also added ``_repr_png_`` and ``_repr_svg_`` methods for automatic display in the IPython Notebook, with ``png`` and ``svg`` properties for direct access. * Added ``skbio.stats.ordination.assert_ordination_results_equal`` for comparing ``OrdinationResults`` objects for equality in unit tests. * ``BiologicalSequence`` (and its subclasses) now optionally store Phred quality scores. A biological sequence's quality scores are stored as a 1-D ``numpy.ndarray`` of nonnegative integers that is the same length as the biological sequence. Quality scores can be provided upon object instantiation via the keyword argument ``quality``, and can be retrieved via the ``BiologicalSequence.quality`` property. ``BiologicalSequence.has_quality`` is also provided for determining whether a biological sequence has quality scores or not. See [#616](https://github.com/biocore/scikit-bio/issues/616) for more details. * Added ``BiologicalSequence.sequence`` property for retrieving the underlying string representing the sequence characters. This was previously (and still is) accessible via ``BiologicalSequence.__str__``. It is provided via a property for convenience and explicitness. * Added ``BiologicalSequence.equals`` for full control over equality testing of biological sequences. By default, biological sequences must have the same type, underlying sequence of characters, identifier, description, and quality scores to compare equal. These properties can be ignored via the keyword argument ``ignore``. The behavior of ``BiologicalSequence.__eq__``/``__ne__`` remains unchanged (only type and underlying sequence of characters are compared). * Added ``BiologicalSequence.copy`` for creating a copy of a biological sequence, optionally with one or more attributes updated. * ``BiologicalSequence.__getitem__`` now supports specifying a sequence of indices to take from the biological sequence. * Methods to read and write taxonomies are now available under ``skbio.tree.TreeNode.from_taxonomy`` and ``skbio.tree.TreeNode.to_taxonomy`` respectively. * Added ``SequenceCollection.update_ids``, which provides a flexible way of updating sequence IDs on a ``SequenceCollection`` or ``Alignment`` (note that a new object is returned, since instances of these classes are immutable). Deprecated ``SequenceCollection.int_map`` in favor of this new method; it will be removed in scikit-bio 0.3.0. * Added ``skbio.util.cardinal_to_ordinal`` for converting a cardinal number to ordinal string (e.g., useful for error messages). * New I/O Registry: supports multiple file formats, automatic file format detection when reading, unified procedural ``skbio.io.read`` and ``skbio.io.write`` in addition to OOP interfaces (``read/write`` methods) on the below objects. See ``skbio.io`` for more details. - Added "clustal" format support: * Has sniffer * Readers: ``Alignment`` * Writers: ``Alignment`` - Added "lsmat" format support: * Has sniffer * Readers: ``DissimilarityMatrix``, ``DistanceMatrix`` * Writers: ``DissimilarityMatrix``, ``DistanceMatrix`` - Added "ordination" format support: * Has sniffer * Readers: ``OrdinationResults`` * Writers: ``OrdinationResults`` - Added "newick" format support: * Has sniffer * Readers: ``TreeNode`` * Writers: ``TreeNode`` - Added "phylip" format support: * No sniffer * Readers: None * Writers: ``Alignment`` - Added "qseq" format support: * Has sniffer * Readers: generator of ``BiologicalSequence`` or its subclasses, ``SequenceCollection``, ``BiologicalSequence``, ``NucleotideSequence``, ``DNASequence``, ``RNASequence``, ``ProteinSequence`` * Writers: None - Added "fasta"/QUAL format support: * Has sniffer * Readers: generator of ``BiologicalSequence`` or its subclasses, ``SequenceCollection``, ``Alignment``, ``BiologicalSequence``, ``NucleotideSequence``, ``DNASequence``, ``RNASequence``, ``ProteinSequence`` * Writers: same as readers - Added "fastq" format support: * Has sniffer * Readers: generator of ``BiologicalSequence`` or its subclasses, ``SequenceCollection``, ``Alignment``, ``BiologicalSequence``, ``NucleotideSequence``, ``DNASequence``, ``RNASequence``, ``ProteinSequence`` * Writers: same as readers ### Bug fixes * Removed ``constructor`` parameter from ``Alignment.k_word_frequencies``, ``BiologicalSequence.k_words``, ``BiologicalSequence.k_word_counts``, and ``BiologicalSequence.k_word_frequencies`` as it had no effect (it was never hooked up in the underlying code). ``BiologicalSequence.k_words`` now returns a generator of ``BiologicalSequence`` objects instead of strings. * Modified the ``Alignment`` constructor to verify that all sequences have the same length, if not, raise an ``AlignmentError`` exception. Updated the method ``Alignment.subalignment`` to calculate the indices only once now that identical sequence length is guaranteed. ### Deprecated functionality * Deprecated ``constructor`` parameter in ``Alignment.majority_consensus`` in favor of having users call ``str`` on the returned ``BiologicalSequence``. This parameter will be removed in scikit-bio 0.3.0. * Existing I/O functionality deprecated in favor of I/O registry, old functionality will be removed in scikit-bio 0.3.0. All functionality can be found at ``skbio.io.read``, ``skbio.io.write``, and the methods listed below: * Deprecated the following "clustal" readers/writers: - ``write_clustal`` -> ``Alignment.write`` - ``parse_clustal`` -> ``Alignment.read`` * Deprecated the following distance matrix format ("lsmat") readers/writers: - ``DissimilarityMatrix.from_file`` -> ``DissimilarityMatrix.read`` - ``DissimilarityMatrix.to_file`` -> ``DissimilarityMatrix.write`` - ``DistanceMatrix.from_file`` -> ``DistanceMatrix.read`` - ``DistanceMatrix.to_file`` -> ``DistanceMatrix.write`` * Deprecated the following ordination format ("ordination") readers/writers: - ``OrdinationResults.from_file`` -> ``OrdinationResults.read`` - ``OrdinationResults.to_file`` -> ``OrdinationResults.write`` * Deprecated the following "newick" readers/writers: - ``TreeNode.from_file`` -> ``TreeNode.read`` - ``TreeNode.from_newick`` -> ``TreeNode.read`` - ``TreeNode.to_newick`` -> ``TreeNode.write`` * Deprecated the following "phylip" writers: - ``Alignment.to_phylip`` -> ``Alignment.write`` * Deprecated the following "fasta"/QUAL readers/writers: - ``SequenceCollection.from_fasta_records`` -> ``SequenceCollection.read`` - ``SequenceCollection.to_fasta`` -> ``SequenceCollection.write`` - ``fasta_from_sequences`` -> ``skbio.io.write(obj, into=, format='fasta')`` - ``fasta_from_alignment`` -> ``Alignment.write`` - ``parse_fasta`` -> ``skbio.io.read(, format='fasta')`` - ``parse_qual`` -> ``skbio.io.read(, format='fasta', qual=)`` - ``BiologicalSequence.to_fasta`` -> ``BiologicalSequence.write`` * Deprecated the following "fastq" readers/writers: - ``parse_fastq`` -> ``skbio.io.read(, format='fastq')`` - ``format_fastq_record`` -> ``skbio.io.write(, format='fastq')`` ### Backward-incompatible changes * ``skbio.stats.distance.mantel`` now returns a 3-element tuple containing correlation coefficient, p-value, and the number of matching rows/cols in the distance matrices (``n``). The return value was previously a 2-element tuple containing only the correlation coefficient and p-value. * ``skbio.stats.distance.mantel`` reorders input ``DistanceMatrix`` instances based on matching IDs (see optional parameters ``strict`` and ``lookup`` for controlling this behavior). In the past, ``DistanceMatrix`` instances were treated the same as ``array_like`` input and no reordering took place, regardless of ID (mis)matches. ``array_like`` input behavior remains the same. * If mismatched types are provided to ``skbio.stats.distance.mantel`` (e.g., a ``DistanceMatrix`` and ``array_like``), a ``TypeError`` will be raised. ### Miscellaneous * Added git timestamp checking to checklist.py, ensuring that when changes are made to Cython (.pyx) files, their corresponding generated C files are also updated. * Fixed performance bug when instantiating ``BiologicalSequence`` objects. The previous runtime scaled linearly with sequence length; it is now constant time when the sequence is already a string. See [#623](https://github.com/biocore/scikit-bio/issues/623) for details. * IPython and six are now required dependencies. ## Version 0.2.0 (2014-08-07) This is an initial alpha release of scikit-bio. At this stage, major backwards-incompatible API changes can and will happen. Many backwards-incompatible API changes were made since the previous release. ### Features * Added ability to compute distances between sequences in a ``SequenceCollection`` object ([#509](https://github.com/biocore/scikit-bio/issues/509)), and expanded ``Alignment.distance`` to allow the user to pass a function for computing distances (the default distance metric is still ``scipy.spatial.distance.hamming``) ([#194](https://github.com/biocore/scikit-bio/issues/194)). * Added functionality to not penalize terminal gaps in global alignment. This functionality results in more biologically relevant global alignments (see [#537](https://github.com/biocore/scikit-bio/issues/537) for discussion of the issue) and is now the default behavior for global alignment. * The python global aligners (``global_pairwise_align``, ``global_pairwise_align_nucleotide``, and ``global_pairwise_align_protein``) now support aligning pairs of sequences, pairs of alignments, and a sequence and an alignment (see [#550](https://github.com/biocore/scikit-bio/issues/550)). This functionality supports progressive multiple sequence alignment, among other things such as adding a sequence to an existing alignment. * Added ``StockholmAlignment.to_file`` for writing Stockholm-formatted files. * Added ``strict=True`` optional parameter to ``DissimilarityMatrix.filter``. * Added ``TreeNode.find_all`` for finding all tree nodes that match a given name. ### Bug fixes * Fixed bug that resulted in a ``ValueError`` from ``local_align_pairwise_nucleotide`` (see [#504](https://github.com/biocore/scikit-bio/issues/504)) under many circumstances. This would not generate incorrect results, but would cause the code to fail. ### Backward-incompatible changes * Removed ``skbio.math``, leaving ``stats`` and ``diversity`` to become top level packages. For example, instead of ``from skbio.math.stats.ordination import PCoA`` you would now import ``from skbio.stats.ordination import PCoA``. * The module ``skbio.math.gradient`` as well as the contents of ``skbio.math.subsample`` and ``skbio.math.stats.misc`` are now found in ``skbio.stats``. As an example, to import subsample: ``from skbio.stats import subsample``; to import everything from gradient: ``from skbio.stats.gradient import *``. * The contents of ``skbio.math.stats.ordination.utils`` are now in ``skbio.stats.ordination``. * Removed ``skbio.app`` subpackage (i.e., the *application controller framework*) as this code has been ported to the standalone [burrito](https://github.com/biocore/burrito) Python package. This code was not specific to bioinformatics and is useful for wrapping command-line applications in general. * Removed ``skbio.core``, leaving ``alignment``, ``genetic_code``, ``sequence``, ``tree``, and ``workflow`` to become top level packages. For example, instead of ``from skbio.core.sequence import DNA`` you would now import ``from skbio.sequence import DNA``. * Removed ``skbio.util.exception`` and ``skbio.util.warning`` (see [#577](https://github.com/biocore/scikit-bio/issues/577) for the reasoning behind this change). The exceptions/warnings were moved to the following locations: - ``FileFormatError``, ``RecordError``, ``FieldError``, and ``EfficiencyWarning`` have been moved to ``skbio.util`` - ``BiologicalSequenceError`` has been moved to ``skbio.sequence`` - ``SequenceCollectionError`` and ``StockholmParseError`` have been moved to ``skbio.alignment`` - ``DissimilarityMatrixError``, ``DistanceMatrixError``, ``DissimilarityMatrixFormatError``, and ``MissingIDError`` have been moved to ``skbio.stats.distance`` - ``TreeError``, ``NoLengthError``, ``DuplicateNodeError``, ``MissingNodeError``, and ``NoParentError`` have been moved to ``skbio.tree`` - ``FastqParseError`` has been moved to ``skbio.parse.sequences`` - ``GeneticCodeError``, ``GeneticCodeInitError``, and ``InvalidCodonError`` have been moved to ``skbio.genetic_code`` * The contents of ``skbio.genetic_code`` formerly ``skbio.core.genetic_code`` are now in ``skbio.sequence``. The ``GeneticCodes`` dictionary is now a function ``genetic_code``. The functionality is the same, except that because this is now a function rather than a dict, retrieving a genetic code is done using a function call rather than a lookup (so, for example, ``GeneticCodes[2]`` becomes ``genetic_code(2)``. * Many submodules have been made private with the intention of simplifying imports for users. See [#562](https://github.com/biocore/scikit-bio/issues/562) for discussion of this change. The following list contains the previous module name and where imports from that module should now come from. - ``skbio.alignment.ssw`` to ``skbio.alignment`` - ``skbio.alignment.alignment`` to ``skbio.alignment`` - ``skbio.alignment.pairwise`` to ``skbio.alignment`` - ``skbio.diversity.alpha.base`` to ``skbio.diversity.alpha`` - ``skbio.diversity.alpha.gini`` to ``skbio.diversity.alpha`` - ``skbio.diversity.alpha.lladser`` to ``skbio.diversity.alpha`` - ``skbio.diversity.beta.base`` to ``skbio.diversity.beta`` - ``skbio.draw.distributions`` to ``skbio.draw`` - ``skbio.stats.distance.anosim`` to ``skbio.stats.distance`` - ``skbio.stats.distance.base`` to ``skbio.stats.distance`` - ``skbio.stats.distance.permanova`` to ``skbio.stats.distance`` - ``skbio.distance`` to ``skbio.stats.distance`` - ``skbio.stats.ordination.base`` to ``skbio.stats.ordination`` - ``skbio.stats.ordination.canonical_correspondence_analysis`` to ``skbio.stats.ordination`` - ``skbio.stats.ordination.correspondence_analysis`` to ``skbio.stats.ordination`` - ``skbio.stats.ordination.principal_coordinate_analysis`` to ``skbio.stats.ordination`` - ``skbio.stats.ordination.redundancy_analysis`` to ``skbio.stats.ordination`` - ``skbio.tree.tree`` to ``skbio.tree`` - ``skbio.tree.trie`` to ``skbio.tree`` - ``skbio.util.misc`` to ``skbio.util`` - ``skbio.util.testing`` to ``skbio.util`` - ``skbio.util.exception`` to ``skbio.util`` - ``skbio.util.warning`` to ``skbio.util`` * Moved ``skbio.distance`` contents into ``skbio.stats.distance``. ### Miscellaneous * Relaxed requirement in ``BiologicalSequence.distance`` that sequences being compared are of equal length. This is relevant for Hamming distance, so the check is still performed in that case, but other distance metrics may not have that requirement. See [#504](https://github.com/biocore/scikit-bio/issues/507)). * Renamed ``powertrip.py`` repo-checking script to ``checklist.py`` for clarity. * ``checklist.py`` now ensures that all unit tests import from a minimally deep API. For example, it will produce an error if ``skbio.core.distance.DistanceMatrix`` is used over ``skbio.DistanceMatrix``. * Extra dimension is no longer calculated in ``skbio.stats.spatial.procrustes``. * Expanded documentation in various subpackages. * Added new scikit-bio logo. Thanks [Alina Prassas](http://cargocollective.com/alinaprassas)! ## Version 0.1.4 (2014-06-25) This is a pre-alpha release. At this stage, major backwards-incompatible API changes can and will happen. ### Features * Added Python implementations of Smith-Waterman and Needleman-Wunsch alignment as ``skbio.core.alignment.pairwise.local_pairwise_align`` and ``skbio.core.alignment.pairwise.global_pairwise_align``. These are much slower than native C implementations (e.g., ``skbio.core.alignment.local_pairwise_align_ssw``) and as a result raise an ``EfficencyWarning`` when called, but are included as they serve as useful educational examples as they’re simple to experiment with. * Added ``skbio.core.diversity.beta.pw_distances`` and ``skbio.core.diversity.beta.pw_distances_from_table``. These provide convenient access to the ``scipy.spatial.distance.pdist`` *beta diversity* metrics from within scikit-bio. The ``skbio.core.diversity.beta.pw_distances_from_table`` function will only be available temporarily, until the ``biom.table.Table`` object is merged into scikit-bio (see [#489](https://github.com/biocore/scikit-bio/issues/489)), at which point ``skbio.core.diversity.beta.pw_distances`` will be updated to use that. * Added ``skbio.core.alignment.StockholmAlignment``, which provides support for parsing [Stockholm-formatted alignment files](http://sonnhammer.sbc.su.se/Stockholm.html) and working with those alignments in the context RNA secondary structural information. * Added ``skbio.core.tree.majority_rule`` function for computing consensus trees from a list of trees. ### Backward-incompatible changes * Function ``skbio.core.alignment.align_striped_smith_waterman`` renamed to ``local_pairwise_align_ssw`` and now returns an ``Alignment`` object instead of an ``AlignmentStructure`` * The following keyword-arguments for ``StripedSmithWaterman`` and ``local_pairwise_align_ssw`` have been renamed: * ``gap_open`` -> ``gap_open_penalty`` * ``gap_extend`` -> ``gap_extend_penalty`` * ``match`` -> ``match_score`` * ``mismatch`` -> ``mismatch_score`` * Removed ``skbio.util.sort`` module in favor of [natsort](https://pypi.python.org/pypi/natsort) package. ### Miscellaneous * Added powertrip.py script to perform basic sanity-checking of the repo based on recurring issues that weren't being caught until release time; added to Travis build. * Added RELEASE.md with release instructions. * Added intersphinx mappings to docs so that "See Also" references to numpy, scipy, matplotlib, and pandas are hyperlinks. * The following classes are no longer ``namedtuple`` subclasses (see [#359](https://github.com/biocore/scikit-bio/issues/359) for the rationale): * ``skbio.math.stats.ordination.OrdinationResults`` * ``skbio.math.gradient.GroupResults`` * ``skbio.math.gradient.CategoryResults`` * ``skbio.math.gradient.GradientANOVAResults`` * Added coding guidelines draft. * Added new alpha diversity formulas to the ``skbio.math.diversity.alpha`` documentation. ## Version 0.1.3 (2014-06-12) This is a pre-alpha release. At this stage, major backwards-incompatible API changes can and will happen. ### Features * Added ``enforce_qual_range`` parameter to ``parse_fastq`` (on by default, maintaining backward compatibility). This allows disabling of the quality score range-checking. * Added ``skbio.core.tree.nj``, which applies neighbor-joining for phylogenetic reconstruction. * Added ``bioenv``, ``mantel``, and ``pwmantel`` distance-based statistics to ``skbio.math.stats.distance`` subpackage. * Added ``skbio.math.stats.misc`` module for miscellaneous stats utility functions. * IDs are now optional when constructing a ``DissimilarityMatrix`` or ``DistanceMatrix`` (monotonically-increasing integers cast as strings are automatically used). * Added ``DistanceMatrix.permute`` method for randomly permuting rows and columns of a distance matrix. * Added the following methods to ``DissimilarityMatrix``: ``filter``, ``index``, and ``__contains__`` for ID-based filtering, index lookup, and membership testing, respectively. * Added ``ignore_comment`` parameter to ``parse_fasta`` (off by default, maintaining backward compatibility). This handles stripping the comment field from the header line (i.e., all characters beginning with the first space) before returning the label. * Added imports of ``BiologicalSequence``, ``NucleotideSequence``, ``DNA``, ``DNASequence``, ``RNA``, ``RNASequence``, ``Protein``, ``ProteinSequence``, ``DistanceMatrix``, ``align_striped_smith_waterman``, `` SequenceCollection``, ``Alignment``, ``TreeNode``, ``nj``, ``parse_fasta``, ``parse_fastq``, ``parse_qual``, ``FastaIterator``, ``FastqIterator``, ``SequenceIterator`` in ``skbio/__init__.py`` for convenient importing. For example, it's now possible to ``from skbio import Alignment``, rather than ``from skbio.core.alignment import Alignment``. ### Bug fixes * Fixed a couple of unit tests that could fail stochastically. * Added missing ``__init__.py`` files to a couple of test directories so that these tests won't be skipped. * ``parse_fastq`` now raises an error on dangling records. * Fixed several warnings that were raised while running the test suite with Python 3.4. ### Backward-incompatible changes * Functionality imported from ``skbio.core.ssw`` must now be imported from ``skbio.core.alignment`` instead. ### Miscellaneous * Code is now flake8-compliant; added flake8 checking to Travis build. * Various additions and improvements to documentation (API, installation instructions, developer instructions, etc.). * ``__future__`` imports are now standardized across the codebase. * New website front page and styling changes throughout. Moved docs site to its own versioned subdirectories. * Reorganized alignment data structures and algorithms (e.g., SSW code, ``Alignment`` class, etc.) into an ``skbio.core.alignment`` subpackage. ## Version 0.1.1 (2014-05-16) Fixes to setup.py. This is a pre-alpha release. At this stage, major backwards-incompatible API changes can and will happen. ## Version 0.1.0 (2014-05-15) Initial pre-alpha release. At this stage, major backwards-incompatible API changes can and will happen. scikit-bio-0.5.9/LICENSE.txt000066400000000000000000000027531446255456000154270ustar00rootroot00000000000000Copyright (c) 2013--, scikit-bio development team. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the names scikit-bio, skbio, or biocore nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/MANIFEST.in000066400000000000000000000005171446255456000153360ustar00rootroot00000000000000include CHANGELOG.md include LICENSE.txt include Makefile include pyproject.toml include README.rst include simde-sse2.h graft assets graft ci graft doc graft licenses graft skbio prune doc/build prune doc/source/generated global-exclude *.pyc global-exclude *.pyo global-exclude *.so global-exclude .*.swp global-exclude .coverage scikit-bio-0.5.9/Makefile000066400000000000000000000024611446255456000152400ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- ifeq ($(WITH_COVERAGE), TRUE) TEST_COMMAND = coverage run --rcfile ../.coveragerc -m skbio.test && coverage report --rcfile ../.coveragerc else TEST_COMMAND = python -m skbio.test endif .PHONY: doc lint test dev install cython doc: $(MAKE) -C doc clean html clean: $(MAKE) -C doc clean rm -rf build dist scikit_bio.egg-info lint: flake8 skbio setup.py checklist.py ./checklist.py check-manifest # cd into a directory that is different from scikit-bio root directory to # simulate a user's install and testing of scikit-bio. Running from the root # directory will find the `skbio` subpackage (not necessarily the installed # one!) because cwd is considered in Python's search path. It is important to # simulate a user's install/test process this way to find package data that did # not install correctly (for example). test: cd ci && $(TEST_COMMAND) cython: USE_CYTHON=TRUE python setup.py build_ext --inplace install: pip install . dev: pip install -e . scikit-bio-0.5.9/README.rst000066400000000000000000000163411446255456000152710ustar00rootroot00000000000000**Important project update (April 2022):** scikit-bio is currently in maintenance mode. Due to limited developer bandwidth, we are focusing on keeping scikit-bio up-to-date with Python and Python scientific computing libraries. We plan to do this through two annual releases of scikit-bio. At this time, we have less availability for reviewing or adding new features. We realize that scikit-bio is an important tool for the bioinformatics community, and we hope to transition back to more active development in the future. If you're interested in helping by taking a leadership role in the project, please reach out. .. image:: http://scikit-bio.org/assets/logo.svg :target: http://scikit-bio.org :alt: scikit-bio logo |Build Status| |Coverage Status| |ASV Benchmarks| |Gitter Badge| |Depsy Badge| |Anaconda Build Platforms| |Anaconda Build Version| |License| |Downloads| |Install| scikit-bio is an open-source, BSD-licensed Python 3 package providing data structures, algorithms and educational resources for bioinformatics. To view scikit-bio's documentation, visit `scikit-bio.org `__. **Note:** scikit-bio is no longer compatible with Python 2. scikit-bio is compatible with Python 3.8 and later. scikit-bio is currently in beta. We are very actively developing it, and **backward-incompatible interface changes can and will arise**. To avoid these types of changes being a surprise to our users, our public APIs are decorated to make it clear to users when an API can be relied upon (stable) and when it may be subject to change (experimental). See the `API stability docs `_ for more details, including what we mean by *stable* and *experimental* in this context. Installing ---------- The recommended way to install scikit-bio is via the ``conda`` package manager available in `Anaconda `_ or `miniconda `_. To install the latest release of scikit-bio:: conda install -c conda-forge scikit-bio Alternatively, you can install scikit-bio using ``pip``:: pip install scikit-bio You can verify your installation by running the scikit-bio unit tests:: python -m skbio.test For users of Debian, ``skbio`` is in the Debian software distribution and may be installed using:: sudo apt-get install python3-skbio python-skbio-doc Getting help ------------ To get help with scikit-bio, you should use the `skbio `_ tag on StackOverflow (SO). Before posting a question, check out SO's guide on how to `ask a question `_. The scikit-bio developers regularly monitor the ``skbio`` SO tag. Projects using scikit-bio ------------------------- Some of the projects that we know of that are using scikit-bio are: - `QIIME 2 `__ - `Emperor `__ - `An Introduction to Applied Bioinformatics `__ - `tax2tree `__ - `Qiita `__ - `ghost-tree `__ - `Platypus-Conquistador `__ If you're using scikit-bio in your own projects, feel free to issue a pull request to add them to this list. scikit-bio development ---------------------- If you're interested in getting involved in scikit-bio development, see `CONTRIBUTING.md `__. See the list of `scikit-bio's contributors `__. Licensing --------- scikit-bio is available under the new BSD license. See `LICENSE.txt `__ for scikit-bio's license, and the `licenses directory `_ for the licenses of third-party software that is (either partially or entirely) distributed with scikit-bio. The pre-history of scikit-bio ----------------------------- scikit-bio began from code derived from `PyCogent `__ and `QIIME `__, and the contributors and/or copyright holders have agreed to make the code they wrote for PyCogent and/or QIIME available under the BSD license. The contributors to PyCogent and/or QIIME modules that have been ported to scikit-bio are: Rob Knight (`@rob-knight `__), Gavin Huttley (`@gavinhuttley `__), Daniel McDonald (`@wasade `__), Micah Hamady, Antonio Gonzalez (`@antgonza `__), Sandra Smit, Greg Caporaso (`@gregcaporaso `__), Jai Ram Rideout (`@jairideout `__), Cathy Lozupone (`@clozupone `__), Mike Robeson (`@mikerobeson `__), Marcin Cieslik, Peter Maxwell, Jeremy Widmann, Zongzhi Liu, Michael Dwan, Logan Knecht (`@loganknecht `__), Andrew Cochran, Jose Carlos Clemente (`@cleme `__), Damien Coy, Levi McCracken, Andrew Butterfield, Will Van Treuren (`@wdwvt1 `__), Justin Kuczynski (`@justin212k `__), Jose Antonio Navas Molina (`@josenavas `__), Matthew Wakefield (`@genomematt `__) and Jens Reeder (`@jensreeder `__). Logo ---- scikit-bio's logo was created by `Alina Prassas `_. .. |Build Status| image:: https://travis-ci.org/biocore/scikit-bio.svg?branch=master :target: https://travis-ci.org/biocore/scikit-bio .. |Coverage Status| image:: https://coveralls.io/repos/biocore/scikit-bio/badge.png :target: https://coveralls.io/r/biocore/scikit-bio .. |ASV Benchmarks| image:: http://img.shields.io/badge/benchmarked%20by-asv-green.svg?style=flat :target: https://s3-us-west-2.amazonaws.com/scikit-bio.org/benchmarks/master/index.html .. |Gitter Badge| image:: https://badges.gitter.im/Join%20Chat.svg :alt: Join the chat at https://gitter.im/biocore/scikit-bio :target: https://gitter.im/biocore/scikit-bio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge .. |Depsy Badge| image:: http://depsy.org/api/package/pypi/scikit-bio/badge.svg :target: http://depsy.org/package/python/scikit-bio .. |Anaconda Build Platforms| image:: https://anaconda.org/conda-forge/scikit-bio/badges/platforms.svg :target: https://anaconda.org/conda-forge/scikit-bio .. |Anaconda Build Version| image:: https://anaconda.org/conda-forge/scikit-bio/badges/version.svg :target: https://anaconda.org/conda-forge/scikit-bio .. |License| image:: https://anaconda.org/conda-forge/scikit-bio/badges/license.svg :target: https://anaconda.org/conda-forge/scikit-bio .. |Downloads| image:: https://anaconda.org/conda-forge/scikit-bio/badges/downloads.svg :target: https://anaconda.org/conda-forge/scikit-bio .. |Install| image:: https://anaconda.org/conda-forge/scikit-bio/badges/installer/conda.svg :target: https://conda.anaconda.org/conda-forge scikit-bio-0.5.9/RELEASE.md000066400000000000000000000214631446255456000152050ustar00rootroot00000000000000# Releasing a new version of scikit-bio ## Introduction This guide explains how to release a new version of scikit-bio. To illustrate examples of commands you might run, let's assume that the current version is x.y.y-dev and we want to release version x.y.z. **Note:** The following commands assume you are in the top-level directory of the scikit-bio repository unless otherwise noted. They also assume that you have [Miniconda3](http://conda.pydata.org/miniconda.html) installed. It is important that you use Miniconda3, and not Miniconda2, because the root `conda` environment needs Python 3 for the build steps below. ## Prep the release 1. Ensure the Travis build is passing against master. 2. Update the version strings (x.y.y-dev) to the new version (x.y.z). This will include `__version__` defined in ``skbio/__init__.py``, as well as any `@experimental/@stable/@deprecated` [API stability decorators](http://scikit-bio.org/docs/latest/user/api_stability.html) with `as_of='x.y.y-dev'`. ``grep`` for the current version string to find all occurrences: grep -r 'x\.y\.y-dev' . 3. Remove any deprecated functionality that was scheduled for removal on or before this release. When removing deprecated functionality, make sure the functionality has been in a deprecated state for the appropriate number of releases described in the [API stability docs](http://scikit-bio.org/docs/latest/user/api_stability.html). If there is functionality that shouldn't be removed yet, bump the `until` version to a future version. To find all deprecated functionality, search for `@deprecated` decorators: grep -r '@deprecated' . Note any deprecated functionality that was removed in the `### Miscellaneous` section of `CHANGELOG.md`. 4. Update ``CHANGELOG.md`` to include descriptions of all **user-facing** changes that made it into this release. Be sure to update the heading to include the new version (x.y.z) and the date of the release. Use the existing structure in the file as a template/guide. 5. Submit a pull request and merge when Travis-CI tests are passing. ## Build website docs You will need to **fully install** the latest master branch of scikit-bio (including built extensions) and build the docs from this version. **Make sure the version of scikit-bio that is imported by ``import skbio`` is the correct one before building the docs.** 1. Build the documentation locally: make -C doc clean html 2. Switch to the ``gh-pages`` branch of the repository. 3. Remove ``docs/latest``: git rm -rf docs/latest 4. Copy over the built documentation to ``docs/x.y.z`` and ``docs/latest``: cp -r doc/build/html docs/latest cp -r doc/build/html docs/x.y.z 5. Add a new list item to ``index.html`` to link to ``docs/x.y.z/index.html``. 6. Port content from ``README.md`` to ``index.html`` if there are any changes that need to be included on the front page. 7. Test out your changes by opening the site locally in a browser. Be sure to check the error console for any errors. 8. Submit a pull request with the website updates and merge. **Note:** Once merged, the live website is updated, so be sure to poke through the live site to make sure things are rendered correctly with the right version strings. ## Tag the release From the [scikit-bio GitHub page](https://github.com/biocore/scikit-bio), click on the releases tab and draft a new release. Use the version number for the tag name (x.y.z) and create the tag against master. Fill in a release title that is consistent with previous release titles and add a summary of the release (linking to ``CHANGELOG.md`` is a good idea). This release summary will be the primary information that we point users to when we announce the release. Once the release is created on GitHub, it's a good idea to test out the release tarball before publishing to PyPI: 1. Create a new `conda` environment for testing (fill in a name for ``): conda create -n python=3.5 numpy source activate 2. Install the release tarball from GitHub and run the tests: pip install https://github.com/biocore/scikit-bio/archive/x.y.z.tar.gz python -m skbio.test ## Publish the release Assuming the GitHub release tarball correctly installs and passes its tests, you're ready to create the source distribution (``sdist``) that will be published to PyPI. It is important to test the source distribution because it is created in an entirely different way than the release tarball on GitHub. Thus, there is the danger of having two different release tarballs: the one created on GitHub and the one uploaded to PyPI. 1. Download the release tarball from GitHub, extract it, and ``cd`` into the top-level directory. 2. Build a source distribution: python setup.py sdist 3. Create and activate a new `conda` environment, and test the `sdist`: pip install dist/scikit-bio-x.y.z.tar.gz cd # cd somewhere outside the extracted scikit-bio directory python -m skbio.test 4. If everything goes well, it is finally time to push the release to PyPI: python setup.py sdist upload You must have the proper login credentials to add a release to PyPI. Currently [@gregcaporaso](https://github.com/gregcaporaso) has these, but they can be shared with other release managers. 5. Once the release is available on PyPI, do a final round of testing. Create a new `conda` environment and run: pip install scikit-bio cd # cd somewhere outside the extracted scikit-bio directory python -m skbio.test If this succeeds, the PyPI release appears to be a success. Make sure the installed version is the correct one. 6. Next, we'll prepare and post the release to [anaconda.org](http://www.anaconda.org). You'll need to have ``conda-build`` and ``anaconda-client`` installed to perform these steps. Both can be conda-installed. First, log into anaconda with your anaconda username using the following command. You should have access to push to the ``biocore`` anaconda account through your account (if you don't, get in touch with [@gregcaporaso](https://github.com/gregcaporaso) who is the owner of that account). anaconda login Due to its C extensions, releasing scikit-bio packages for different platforms will require you to perform the following steps on each of those platforms. For example, an ``osx-64`` package will need to be built on OS X, and a ``linux-64`` package will need to be built on 64-bit Linux. These steps will be the same on all platforms, so you should repeat them for every platform you want to release for. conda skeleton pypi scikit-bio conda build scikit-bio --python 3.4 conda build scikit-bio --python 3.5 **Note:** When building 64-bit Linux packages, it is recommended that you use conda-forge's `linux-anvil` Docker image. This ensures a consistent Linux build environment that has an old enough version of `libc` to be compatible on most Linux systems. To start up a `linux-anvil` Docker container: docker run -i -t condaforge/linux-anvil # Now you should be in the linux-anvil environment sed -i '/conda-forge/d' ~/.condarc # Run the build commands from above At this stage you have built Python 3.4 and 3.5 packages. The absolute path to the packages will be provided as output from each ``conda build`` commands. You should now create conda environments for each, and run the tests as described above. You can install these local packages as follows: conda install --use-local scikit-bio If the tests pass, you're ready to upload. anaconda upload -u biocore ```` should be replaced with the path to the package that was was created above. Repeat this for each package you created (here, the Python 3.4 and 3.5 packages). After uploading, you should create new environments for every package you uploaded, install scikit-bio from each package, and re-run the tests. You can install the packages you uploaded as follows: conda install -c https://conda.anaconda.org/biocore scikit-bio ## Post-release cleanup 1. Submit and merge a pull request to update the version strings from x.y.z to x.y.z-dev (`skbio.__version__` should be the only thing needing an update). Update ``CHANGELOG.md`` to include a new section for x.y.z-dev (there won't be any changes to note here yet). 2. Close the release milestone on the GitHub issue tracker if there was one. 3. Send an email to the skbio developers list and anyone else who might be interested (e.g., lab mailing lists). You might include links to the GitHub release page. 4. Tweet about the release from `@scikit-bio`, including a link to the GitHub release page (for example, https://github.com/biocore/scikit-bio/releases/tag/x.y.z). Post a similar message to [scikit-bio's Gitter](https://gitter.im/biocore/scikit-bio). 5. :beers: scikit-bio-0.5.9/REVIEWING.md000066400000000000000000000163351446255456000154660ustar00rootroot00000000000000# Reviewing pull requests This document provides a high-level, general, and **incomplete** checklist of things that pull request reviewers should be aware of when performing code review. These are guidelines which generally make sense to follow, but they are not intended to be rigid. The checklist mainly consists of things that are specific to the scikit-bio project and that generally apply to incoming pull requests. The checklist is incomplete because it is not possible to describe all things to verify during code review (that depends on what is being reviewed). This document also doesn't attempt to describe *how* to perform code review (there are many online resources for that). Reviewers are encouraged to keep this document up-to-date as the project evolves and to add anything that's missing. The checklist is not in any particular order. ## Licensing and attribution Verify that code being included from external sources has a compatible license and is properly attributed: - Include the code's license in the top-level `licenses` directory. - Include a comment with the external code giving attribution and noting the license in the `licenses` directory. - Any other requirements set by the code's license and/or author. ## Changelog This is one of the most important points to remember as users will review the changelog to identify changes relevant to them. This is one of the easiest parts to forget in a pull request. - Note all public (i.e. user-facing) changes in `CHANGELOG.md` under the latest development version section at the top of the file. This includes things like bug fixes, API additions/changes/removal, performance enhancements, etc. The changelog has several subsections for organizing these changes. - If a corresponding issue exists, it should be linked to from the changelog. - Use public imports (`skbio.sequence.Sequence` instead of `skbio.sequence._sequence.Sequence`) when documenting import paths in the changelog. - Internal changes not visible/applicable to users (e.g. refactoring, private methods, etc.) are better suited for commit messages than the changelog. ## Public vs. private API Be aware of what type of API changes are being made. scikit-bio uses the following conventions to distinguish public vs. private API: **Public API:** API with an import path that doesn't contain leading underscores in any submodule/subpackage/object names. Users and scikit-bio devs can use public API. Example: `skbio.sequence.Sequence`, `skbio.stats.subsample` **Package-private API:** API with an import path containing a leading underscore in at least one submodule/subpackage. Users should not import package-private API. Package-private API can be imported anywhere *within* the scikit-bio package. Example: `skbio.util._misc.chunk_str`, `skbio.util._testing.ReallyEqualMixin` **Private API:** API with object name starting with an underscore. Users should not import private API. Private API should only be imported and used in the module where it is defined. It should not be imported in other parts of the scikit-bio package. Example: `skbio.util._testing._normalize_signs`, `skbio.stats.composition._gram_schmidt_basis` - Prefer defining private APIs and only promote things to the public API that users need access to. - Private/package-private API does not need to be decorated with `@experimental`/`@stable`/`@deprecated`, only public API. - Within scikit-bio, prefer *using* public APIs defined in the package even if private APIs offer the same functionality. ## API stability Refer to scikit-bio's [API stability docs](http://scikit-bio.org/docs/latest/user/api_stability.html) for the current API lifecycle. - Prefer making new APIs experimental. This allows for changes to the API without needing to deprecate it first. - Try to avoid changing stable API if at all possible. If a change is necessary, deprecate the API and remove after 2+ minor releases. - Under extreme circumstances, a stable API can be changed without deprecation warning to users. This has happened in the past to fix bugs that required an API change. If this happens, discuss with other devs before committing to the change and document this change extensively in the changelog. - Always document stable/experimental API changes and any deprecated APIs in the changelog. ## Integration/consistency with existing API When reviewing API changes/additions, look at them in the context of the rest of the codebase and its existing APIs. For example, are there existing parameter names that could be reused for consistency/predictability? Does the new API (or changed API) compose with other relevant APIs? Example: `skbio.stats.distance.anosim` uses a `permutations` parameter, so a new nonparametric function would want to use this name over something like `n` or `num_permutations`. ## Commit messages and merging pull requests When merging pull requests, use GitHub's "Squash and merge" option to merge a single commit. See [this commit message](https://github.com/biocore/scikit-bio/commit/f3d736aabd717971332781b98d8fde861f354dc3) for an example. - Rewrite commit message to describe all changes being merged. This usually involves deleting individual commit messages that GitHub includes in the text box. - Include "fixes #n" text if there's an associated issue to be closed. - Use [numpy-style commit tags](https://docs.scipy.org/doc/numpy/dev/gitwash/development_workflow.html#writing-the-commit-message) (ENH, BUG, PERF, etc.). - Include contributors' and reviewers' GitHub usernames in commit message (attribution will be lost on squash). ## Test changes locally **This step is extremely important.** Pull down the PR changes locally and try out the API as a user would. Try to break it, make sure the docs are complete, etc. Build the docs locally and verify that they render correctly (this is a common pitfall). ## Docs - Verify the docs follow the instructions in the scikit-bio [documentation guide](https://github.com/biocore/scikit-bio/blob/master/doc/README.md). - Verify the docs follow [this page](http://scikit-bio.org/docs/latest/development/new_module.html) when adding a new module or subpackage to scikit-bio. - Public API should have docstrings conforming to [numpydoc standards](https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt). Manual and careful verification of the numpydoc docstrings is currently necessary; they are easy to get wrong and building the docs won't always flag issues. Building the docs and inspecting the rendered output can help with this process. - Package-private and private APIs do not need to be extensively documented; numpydoc docstrings are not required. Document these APIs as appropriate to help other devs understand the code (code comments are usually better for this anyways). ## CI - Make sure Travis-CI is passing before merging a pull request. - Make sure coverage doesn’t drop. Strive to have 100% coverage for new code being merged. ## Unit testing - Make sure the tests are as complete as possible. - Check that border cases are tested (e.g. zeros, '', [], None, etc.). - Check that the base case is tested (`n`), along with the inductive step (`n + 1`). - Verify that tests cover more than one input data set. - Make each test case simple, ideally only testing a single thing (follow [Arrange Act Assert](http://wiki.c2.com/?ArrangeActAssert)). scikit-bio-0.5.9/aarch64.Dockerfile000066400000000000000000000020441446255456000170160ustar00rootroot00000000000000FROM --platform=linux/arm64 condaforge/linux-anvil-aarch64 RUN sudo yum update -y && \ sudo yum install -y make git && \ sudo yum clean all ENV MPLBACKEND=Agg ENV USE_CYTHON=TRUE ARG PYTHON_VERSION RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate base && conda create -n testing -c conda-forge --yes python=$PYTHON_VERSION gxx_linux-aarch64" COPY . /work WORKDIR /work RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && conda env update -q -f ci/conda_host_env.yml" RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && conda install -q --yes --file ci/aarch64.conda_requirements.txt" RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && pip install -r ci/aarch64.requirements.txt" RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && pip install . --no-deps" RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && conda list" RUN bash -c ". /opt/conda/etc/profile.d/conda.sh && conda activate testing && make test" scikit-bio-0.5.9/assets/000077500000000000000000000000001446255456000150775ustar00rootroot00000000000000scikit-bio-0.5.9/assets/.no.gif000066400000000000000000076511061446255456000163000ustar00rootroot00000000000000GIF89aí÷ÿ646îîî)ÎÎÎ4&vY7EGW9BMŒŒŒW_z```ˆwh‰wU¿¿¿57A!!#UJDˆyveZSXTEulghcI“‚„YYS/-+%fI&”ˆq>ŠtG†jDgVFgp’iJB†dW{kJJNCHE4…g8VC&5)C7%iR)‰jdG@(^8)†XMB9@ ZR)*#(*3PPPYD;{s_gW7 F4SJU@@@˜th}ƒD;5DCH§‹b]f8,$’jY9:'XcWD)cO2S:"$,[5vH7 tT)uJC:=L>4#JA9tpj-0;"sWMQC. LSk =;AfY@=3, –‘p`A51+[QK '5:Hxc=‡ƒ|-*uG(DI]kcRLA-dXNU?548E&%#z]U000a_ZAFX=/\P7HLaaKA\I.l]>DD?C?341"]f†H,!MH'xfVP3]C#UTSWR8KFM, slYUPCG@!R;/YC+™wuPPK ¦yqufZmPCi[NR1%NJ5–V )&)qhV<82›œš[=KNTO= 9`SHfJ¢e\™¨Û’Z\°¬º¬™¨>*SL&dC66(£´]XaYa¸¾ØÆ·Íd@0ÏËßȨ¬£££aL'TOVßßß ÔÔÔ̽¾ŸŸŸL7+ppp¯¯¯õõõxxx–––°°°yn\~c@€oMLKFVG,xs”UZSY’†ogggPWqwgJLF@–ŒˆznsGJOzc8J8"WH4fH5MQfiT5F/˜•ŒtWEzZOucDÿÿÿÿÿÿ!ÿ NETSCAPE2.0!ÿ XMP DataXMP ÿþýüûúùø÷öõôóòñðïîíìëêéèçæåäãâáàßÞÝÜÛÚÙØ×ÖÕÔÓÒÑÐÏÎÍÌËÊÉÈÇÆÅÄÃÂÁÀ¿¾½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥¤£¢¡ Ÿžœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…„ƒ‚€~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  !ù ÿ,íÿ÷ H° Áƒ*\Ȱ¡Ã‡#JœH±¢Å‹3jÜȱ£Ç C6¬À¯$É’(Sª\ɲ¥Ë—0cÆDÄ@.|páºAB|:7ü¥s>|~Dˆ@ÁDP }`ÄèÃ{óæ±81/ÆÔ¬Œæ}¨pCÂØ©U,¨PÁj[¶*ºqãÇž† É‹H¯!D*L\áUFƒçþŠ÷ÆD!ó!Se¼’—3ó+À/ç—AoMºhÓžO«6Íš I”'+Ëž]Ym”ùøåÎWAƒœ6à³ð”‚…QÀ×yÓÂÒ­šöÍk(_XFö¨Î;!‹yŒNœÿÐþáF„²&\¿¨íØ cå ®@áÆ†t/\K7ðܼ 6# 6Á\÷wžc#4ˆÒe`&agjOfž]xš†žu¶áh†˜¡ˆ [l0åV’ŠºáF‹0º¸âm*©¨"" '”4EAN¸XЊB…R<5eS…ðV`ѳ òt—WÐS•y´÷d 2A[cŽ…È … VßøVXO Ñ^yI0N O,Ô >æ e+YH¡f‡^…$†H∞¢kü ØâŒ˜ÊX#™¦d£¦³}Z’>#¬Ð§ZŒQЊMεÃÝÿ5Twf5O ZqUÕvÜÝ#®VU5&"Kf'=ð¥7•zà¸A+iæe’èµ×™M9UgžìG—yÁ9e”EXR„ˆÚÙ…ëzÈ!hÆ ï£ô‚襕æÛ©§,±¸oŠýœiŒ%9¸i‹¤ŠpO~F÷ªs+¨Á­L‡ˆY„AV[mU‚–ZUyÄ=ßÙZ•=VýÕWx¸š #r ÇuNE ~õiKs^=Q—qÑÜ“Íw5(¡–MøàÒìj&Ú¼ïÊéÔ’žæÚ‰¶|é¿þÞFðŒœ•öJþ2ÀÀdüØ–›m¶Auà €1|ƒŸCGÜ}­UVMÿB®%ÛZ¥<÷ OWSžP‚âàX‚ödÈG¥š¤’ûA¦µpÙ7Nâ *ÚKSèúe‡ú™g<í!£îή;ˆ›©Æ¥úTÐ5¿œfÍRÖÃÜén[¯]ꫯ$ " 2}Ü­@7ñœO]B>Ra¬­[Ùz #ß3ò¯ZŒ…¯?2üVruëx!L€ˆÌõ_Ÿp÷Ñ\Ïn`ˆÁìÇZf“!löƒú´"8² ”Áøa.˜ÀnQìR ¤ìõ4 ¹k4T ¾`0Ú b%Æ#ÞJÂö©®1¯`ÛVD¸ñäLt›Øy(°¨| @V Zÿ@v>®|ç|„ƒ_ä¨D€& O$€šØÄ‘a@«–Ÿîò@œÍh¬S‰¹Ò… m†wa7”¡ÑÈë3½#HðTè’ä±ä„(9!"Gµ¯¯‰mS-LõŒF(}jngZÁVà*M b7Їz²ò§ìmrƒ’xæW8_UɉP„âgIEà '8‚-«²? °ÇKA£ÏŽòƒbªª>ø¹Á²à3˜ôHËì{$(G¥¥ä‚íê#jBt;mrHjUKͽâ¢A ŒS)I¡Ö”7£ÜŒíR¼!•ê"CMoС›œóÿªí=)+@>+–+•O2ÄbØ$Y\JƒÝ5kšÎtˆ›ÞœO£¦G|ÅfxŽ,^K”Šª07½1jT¡¢±òãn8Ê¡V…ÄÕ ÿ”%,Lú@kÿé"v'‰µ¤¢Z:˸F´Š¿"Ü&Ê74,czŠS|‚QåHwñâJpÒj¥ñæY ¬l U¨ÆQ²’­©{—šnZ¶ƒSó)kF#È­s6GEdjÓ¶Tùë…—ÊTDð˜„pæ¤P\Y}–!nEl«p§J¸R¶G®>îÀÒ¡ÐÿÖ³•KW$BNÃØ^. pµíðR¬g·‹!€¶Ñ=ÑŒMtIwO€<œóêÊéMZÓìÅ;oúQDò…¾þZ!Rÿ]¡¿ì1#Cðãmì™ÛöàŠI'h.’Vû‰ˆ¡-K…[žËÂq8¸pöÎ[á:E rËõÕù. ¹ŠºuÐ×Ñ84œ´bç5u¦užÅ0e¤°².qèâ  ¾Ži¹i»$uïÒ<ý›PÓ i€×›ÖRËV6ªìÓVpØC’_ùàúÚ´JôìˆØ,°ÉPB¸øµV•’U¦H`ÄÎÊà§á:ß#Ã3ù[sÀýXJ”pê#™ÿœÅ¯Ü¿:póX`uñá£XwÝ‚OÛR­0.%ÑŒ_2n’½@µNéõ¶.7õ^¡A€§ÇGùæ(‚d)„N/±_ûZɳpÖc3]²§ã* ¿ÖOXe>£1añ8Tb+jeQU‚~·RWr¥rð~ëórKTwmÕrg…+ú£Às@+ˆa b3G"v?Ð 3XÀ€ ¶Åyç‚&0!ò–MK§MØdúÖ(ã$YFZ2!`÷"Mk-Âøt”€q7ðk~b³C|­Ð03‡]¢,|8£l%S>æÃDÇUK4Èl‚~Ù¦Mÿ”aç1ŠÃ8óP€ ×0 7p#uˆ " êÇ3vy#U]Àp øÀyHã:G–¢çtPÃ^ë¥o´o¬g<öBNÕ"½ˆ®Æ_³g(òo,1j‘Œø@ 9qDóy¨€O­1€±FMñ Rñ$U"Wbx$2æ3xÊæ+€7gal~­dDºT8ìè1¶b27€РŠ;·9èÁ,}Su!Fsóx€CðÀÐ ¸Ð%ŽAA­ƒ^‰±˜M–eG8…pa“‘‰â!#*ÆXe(Ô–â/'²"ÂÃt£8aB õÁCÙÕWú * ðfÿ¡7?gÛq%­Ä>ó %É–PÌ–}†çV…ór9ßñ8$6hº‡Q p×p  †1ù£,NqcáÕ=vŠÈ À0…‹”tŸ‡AÙ4¤¡…pé–t!®¡" 5½È<œáNð*&¡N~iŒ @ Xe‡6‘|}ÑZ2y“ú“5c)>Žˆƒ>¾R>aÁé3?St8àÖVT”aƒˆKwÚ±E|“?0sWÆ•x¢,l1Œnšƒ3+f9 Eã)q…ˆS‹)r¹œ‘ò;ý&T¼ˆeL%*)„j¯—³†C˜æ!Ѐ Žu1ÿ‰CDÁÒ3Ç¢98@ùq‰ŸwZbrÈV —1À1-ø2‡¡%ùÃ^€™(‚2Ú(O–.E9cÈP–¸=@Séi:oXYØ–³3€ñp5öå‹*º—¥•ïD’£Â€)ª/HõKq“˜|eñ˜qA  †Å7f4_õÇf?¢éröSwËf8Ã\‘P®$‹S3‰¸ò¤%sÍru9ßyR L’íQdnMØròe £€ˆäy–‘…"‘wŠœ7uœboxº.©çSFkw”¦E0*"£Yÿ¼‘#ÀŒ¾W(…|3Á< ÷[!aðQP‹Ÿ|ÖD„CµUÂ¥°í[)öÉ(];ã¥Ø„nʱ?°¡„r&²ic!(‹§jÝô·6…S¦Á‘äÔz¯v{…**ÞZ³ X†Î²Oü4|Êd‚sÙÿš¯±ÊP×'ª½õ+„÷´¨*µkÅVØ‚„'¥mÕŽù¹”€7bµÔ‚dÁ•C‚±1Û¬Ï13×òd”ÅT]ú#p™‘…è2²Ð ¢ ‹|:¢Éù–QFNÆ* ’˜òNxYB¯q)8D$,ÿù* `]‰J`¡¯Wtaèx}ìÛ¹¿õ©Ë·¯ËÖgþú¯ê¨P¦ gÉUQíûˆòtBÀf²& "]µQÓ36$øP £ ì·¡˜áñàx;GÏÚ¼ÕšM(‹²I‹%R¸ƒ¤68+k‰{G€$7{<_nj̡U”°°@Ž=‰K¬9à—>°ÛJ¦I°©+ªô[¿ZÛJsÖJôÃg\±1,«ðI?%Ð2š¸iU=q1‘×¾ë@Á+ e‰ €R#²YÈ& ¼Î;zmÜ–wz,+½.K{Âø‹c¨Â²Ö—Ø‹)…,9[­DÚ“¡ÉDîøwëÿ8Ÿ¥éVì88|ö¯ƒCEuˆ»nUºñ#ªæ3}-ö[¾òãÁÛu+…<3g’pñ3_ü„øð¦Í°ŠìÑ.k¼ÆxË–lÙMÄË{Ë·$|¢&\)Äh{¿¨"uY;|lp,Á€­•#ɧ|B¨äCJ€aìûÃMÚÍú©µéóJzvˆkUºH9¥ƒ³¢”YôõÈž±PwÅf¦ó <idr‚h›Ë ¶…4¸œ6Wا:õÆÀܬ#¼Ë¥·‚zjŒD¨×û€ôHùÀBÌŒpȬe1²‹£ÒZsÃ’ÎÈpC¤‡ó ôp”××Í.½gî£Ä‰L\ÿÀ¤yÎ58¥ø:ðqKP%»ª‹<š?ÛíZW\Û\ƒ/çÒÆÅ&Óù+ÉUÛŽàÿ°ÉŹRê%wõ¸®É2&NÍÀ€ám[ À0Õȧ IYHv(°œ­M!ùpЭݧ±­Ó+†ü•Zú j,¢‘l½µC6ºÇÑ­ló¸ŒaâóC'P&öÜålºñÈEœÉ†#ÎÙ­Ý9}Äø«µ?Þ]¥õ8sð\¯ÐW&¨,zâgÄ3Ó4öÙTmߥڧ½‘wÚßÍ«(Ê9zZ̳]̆›/]ÓÛ>6|™å³U¾ÇüõÇàp=ñ˜~W"aØ­rèÒÈJ—×Çäܤÿ›ÝfëõëVs>ìo–ðòðf¢ŠÎ ÿqßw_ñ[Ë~>-³1~c9yì-4­P]Èa–óý ™øÅyä™®(Jà—Χà^Y±Haÿ’N0ËH¼q½†äÛÀmå-ì—^ÞZ ã¡ôC•«áA%‹3¿¼ð‰Ý¤RûïO¿îJ ŸðYѶ"%'Àðߨò»ðï;8Hú$gåLk?Ðå‡úüÂê¶±,òó½è˧uÐùÚ/Oî²Ún|­ré²W‡àSîå}¹ž/a3êÊÒŒ¤Z Ðv¶R!Оµpð­ûÒÿÎôô°-RB! ú£?úZÿ+^µßöUž–i¥§ºôܕڸö?3:ÞöÏe¹ ×ð $? @.Gþí‰"îŠÌôfä™þ·%,†^†YÇñ€¨i}GYÞÌ- *¶Q=Oÿòf ‹!ƒ´ÓíÍ5¨Èê8ð­ŽÜ”¤ï$ðŸ{£?^ŸõìÌðL°@½Ó²,æ•81Ï AF>(¬ð¡¡„ †$"¢pƒ|À4[öÌã2\?FŒôÀÏ„I~ñR®T/_Ë”-ãé““¦Ë˜)_àW@%Ïx*÷ ÝÇϨQDúø!ª°”ŸÒ|JæãGµjUžWyhʓꇞWf kUìÔ§O+èËá„ÀLç½'ÏîÝ{ôîÕ›—@^¿|Þë×ðß»òZ Â^>È‘!‡ wpñ¼ÊôN´`ÁYqbòX°8!ZÞ[º†ø°°µ‡+P¤ðÃöÿQÀ»ÖñÈ7yQæñœAc¾œ©¼ÀÍäAo¥žü%Ñ}ˆž25º6­¾¦FÙíNöl¾®=+å:Ö*U³ç¯R]ë]Ÿ„ó ÌëVà¼#;âÀúÂà/ #L0À $ð/ ¼ë„Í0k,ª¨ôÑ2{(«ŒÂÊ ¢PžZ(¡³Ð»k´ÑZ8 ƒæQhF…$0¤!‰ ©è|xÔ™e|[|F@d$å¤Cî§ãj¢®% pJ’ªætª;µÒÒŽ<ñ¸”ʬø¨Új=£Ð˪=.Ë+¾ù®Dòù€µ B(AžýR¼kÀ#<ðAä‹@>ï‘'ÂU<ÿm±Å豇- N¶æ´Ç Ëèqq±‚ZðLQ»R|‹´bdäÔy‘Ñ¡ Šè¢ð‘5·Ý|{†È#G`)¹]“´RɪZbn:&¡ ¨” ÀÒËíše–¼÷äó*,® ³Í3Ã:jZøÔÌ‘àl­¡¹b!@#D°À#þr·0=ÔC ]”ÂFû2}à¡_ÈöÍBsM4ñ­Oé5-4‚c4¨TS?°‘‚VxDf”Ýt㨣eð®¸]{] YêˆmNÉ’Qꥑ•[6)ò´“Jª4Ï"Ï«õÈä‡Lú¼ÚªLó¸E ¾µ¡D8D`û@Õýæ*MÀC h—ÝãEÿTBE[øLEçatžÆôý@Ê–ôßJós‘‚Øöz4…S Å ²»Tú@ÇÚ2ÚH·!;º FZIä%mZ¹9¤3Á¥Æ]ªN%æz6,iîR)ÍÒœ¾6·½6[kÊ™§ÓOwOM7oX`„Sš‘¥÷+áN=ïðÁ©!L°^àíµk‰ÎØfÛÓÏ6ûšÇX !ª¢~Ò¤òi ÓËuzĹAížayæ! îQ!ž`¾mC¦·¿5 ráŒÒU%£o’¹ÈŸdîäȧ›n§”,«f1ë\ͤ-~€%ÕÚç#´|T‹gjªÀ·`ç:DBb­™€~DÔÿ½C (^½‹Ð€æu—&Èc k+Hf²™Íì'3úŠL¿¤wÃIécN•ùZ§ BÑÉ€éÅ©C–œ')CtEœie¿'šÿ̃qâ(pEŽ ¨€/µ¸E™àïI]\Ù‡™2.JK[rçÚh3ùh«ZTÁæ˜J§5)>,†üøŠ‹$…œK #èqN=É#@ì”W$ïE°JÖ“yÌ[ ÷)©~zR«ª€Ý¤þ©Ò³ ‹Ý^ä¢}jnH„ØÞ(Ú·[J1H׸ÆtåKúS&þ“ÜÉGR”±Ì',CãPÒBž¾Ôf`ÒYu¦•±Éÿ¦ \OöȪi~l…†0Ô…uiNëÞêÕ;tE’S©§cÕ¡æ}à1QIÊÙDpC­z’«»•Þ¤¬'VyZ’2ùya‰ì¦5¸=t4™ÀEtT±el½¡nÇF¢+ã´ñ87ñÉM"W€cšTr‘cÎN–©XÄÂtMcQydª:«PS¦zü@µJ§D€ऀÒ`£Ö\Š Š…vç.¬ª–4ª%;dɶ5’éWÙp{CUl6Ã+ØíëTв±e¸Â¥ê=ç$J™5­DìÞ‹hç <—G¸ÙHju \Ü@~GÉ/SJÞ”ô¯‘ËŸO€|^"%±Ðÿ zÚT_õÐ4Ä#eH&lÖ·)àÚ€,Îû´æ5Úù@çF؃ ‹$P‚еàK:JÂ&˜U5dá o· xÅTñŠø Ï>ðs¸ö¹¡ UðGÍq}¸å"Ñ ±Ey„Œ¹o#×x.z‰¤,ÒÇ,¡‰w‡Ü×—ˆrÇê+vXšÞ. MÝÊãÏ$+ºöV0§’­¬–»i”l@ûÍà Å<DÈöTGeÄÓ¤¯Hj¯yvÌ„÷eç~‘í¶yŽWWh{‚öA¹)AhoKÏ_I1„œcÔý¼èE-ß÷XK‰H :º4¦‘±>v¸ëÿ¨ó*²”|×/Y¸1…lêbY¥i\2zŸ9]'p*ÛÙ€žgpûYÐF×ïÑ‘^îO†+)b3q½¶bÓŒj|á£]. u$ôÍ6~›ëtwEâŒÀWYÜM†ÿåpï‚ñ¤û#rÛ [”¥H¥™‡µ¸U2ŽÀ¡ýÌù ‡2•©l­Ô×±YÊ Â¥#@â>†h6^_ÂP ÷ÁÖyd$pÕl› Ï—¿°Ÿ_Aè>þÜú-z¹}Û¤¸9阛 9ÔŸR‰±­«Û¨… ’gÀ±Oã=³ëÀJ»¾Z;À*¯xð‰‰3,š©8Y‹©«X1á5«£h±¬šŠ {°,ËŠ ÉC×ñ£ïC„ñ›™K ¨r<Ç‹°(¸6H¡¼}òªù£? ã3¡37Ï›Â(·Þ @’“z¡ÓÔ¸7#j½¹$¨˜h|¨•éš+O».ÿ݋ę,¾“™Ž˜ð+•9¾£HŠðX¾4I,³è&Ôñ™[ᙣªÁ¨©ú*¹²à ¤!'C°ˆ:À Õ`49›0 {¿C»3¬²°ŸsB=4üó*D:£;:B“¦ë ÐÂë‰T’·‘70d@‰ÑC‚ø`LC`h† ™."¹À®•  -Z’UCµ¿º ;l gLšp5æÛFź–õz¯3‰#³©ÔìKÄD¤AF̾£p/Ë þÂÓÀÕÀ ÇcKɹ|x¿ ‰”l[B¯ZÛ*Enë°û4ULÈ*¬BW|EÑÓ|êR*—³ÂÅ·0.ÿh•&ª%ÛH…Œ6ü´‚³Fû1™ü¡Ã^¡ Ÿà•–Èœ-K,@d¯kÁ» b G´¯k‚,j©»­°AE´ÁëS“p@B„Z*¼M,*ǘ€{b|â—P E&H¼Júó3> 4(Œ€ûû¼£7tƒh:wûÖy\´›Ð €Šp¢'‚"Þ’k… ¸¢7Dj¾Zˆ’ýI‰jÜRŠÙx 6I 0‰¦»£9šÌ¼›–­‹}QD˺&ì›ÁºÃŠ˜áÁÐ 8ÑØ{øÑrž9›“€”µE,´-«œžËÓÊû·û#4BÓ?) ¼r§ÿè$wC1Ë€‘²:+ã2ˆYª¥VÆ'Ê [©Àº®g4Ì%ñ=aâ@ÂjŽî4–@2|£½kÏ”#=’,mÊŠõìI˪/ÍŒ í«#¤àAÙ€ÄÐÿ`´{21¨ŒJ~Å©$~ÈN"È<û¿ÿKUàÍÏK:£ë¿U =z9Ós˜ƒ(•Ûˆ`" ÀÁV¨  ä8Q\°«ùA8û¡C—xœ0:»;$,ËY옙X»8˜9<Ú û¢L,ë ¿k/ø„Ïì«AϤAtÄ,«ð>á˜ÀOtY•ÿ"=+Œ±éGÙ¼3mH/ÅÊ=ó$åÊA·*·ýsÅýJÈÿÀƒz· u˜¶)%æ”Kaœ=‹rŸ­@ø)8£È._i’ì«ü9#ìD©“Y–Îé–hÉ©MÏ´)ž29¼‹,ì»Ô$…Ï|¨©žà)ù¯0„¤Ù€Vð2Ûh ø,ÒÓ¹Ö€¿%¬0ÚÈÚ¼°"¨¿±ì³ûkPJøJÏ+:JðMØ $wdÅÐì˜4?ºè¤•»ÜS1œ#É”d»´#¬bZ‰ýùVìZ;AK-ÄGµ¯®€²#Õk Ò| kñÌtäÌtŒÁ«€Ñ}F (Æf¸˜Z°UÍ€ñÄY-MŠñ*Úì9/eXˆmB­$´¡C:ÿaUÅaÖ*¤ }7z€€8ÅPÆÐ‘xÎÍ4 ±•Û³NÏë$É¿âŸAm“y › Še™µ²ØÙöêÔžå)´¬Ê R;2Ï¢×EÜÌôI-öã¾~¡Ši!†gh†aÀ‡W‚±³€ÁÕª,[pñªCÛ9ZÝ6ØÙ­àô¼ŒÛaý¤û ›t˜ ”K?ŠÖ«•7,»;ÌÖñL$©CÍ ÁúÀã{L²xÁž¦¨)ûZ{ ν¦MUÁöÚ>ìÌKMǤõÌ’#ôˆÄ°ah†«_]`†VˆØ`‹YÜǨˆÍ„%ÐÿˆuØ}ʇ#lŒÖj ªÜ6^}P¹ÍXþ34ë¹Û»½Ð¦£z AZ/³|‹’.XYk ™k ¦.Z\Ô´œd‘Æ AŸP–4¾ÊåÌžàTœ¬©uÔÜõHÒlDÏýßE `Çz×xMÚM=ÝæIÈ8GÉàÁí}]¬õað…f†ZX¯ k Ð$P†…¿}Z4ò”M%ªR[}žÞÌ¿ýjÞ¹ž¤y:Öp<b Ç—¥ý¢/ÓÚ¿±•j]Ñí¢ÂÒζkðb5欳3¾%–ß¡ØÔöÜ`͵‡þåL®(¹ÓÕâ{ZÄM…°ì`6`x}WÿNà$UR1~cƒàˆ Þ  ðÚYÌÝkÛÝ}’ÕY[ˆDžâšhŒ(ˆŒ(Ð!€Œ£cEÎXØ©ž§³PFƒ·{z?|ýzI„† FQ¾œ}X¸ú‘¨Ÿø}_\åø­Q"LWÆuDÚ÷ Ú¤­e¬4>Ý/†05^D`f16`_FÝÑíe2`-æÁ9®cÙÅZÛÕW9© ÓRE 䱋°O›çÑRp‡•ž_d^çaý¿p!=çQ"dJN¢ˆþ‹žWx…K€P6Qȱëò•W~eøm»ø=èÁre˱,ø¥Á†–â}xãK=Òÿ[Æe4&ã\¾haþâVæe¶,'xW(HæE„5æaÞÔoYí×fÀÚfð nÜcWŠƒd±(€OyÅgfž(DÎèÒžÃçüVu–äá´x¾Ûyn ô§WXÂ_Øgh0ÆíSãØ‰\è…Æå4݇Æeµ^kËÂÿ]u$i”æ‹>i`æèe6éŽf“žÁöëÐë6i(ìe6ঠ€W¨…®¶à—ÖÚVÐ×Ý [~‘Ê©ÄÂ}ºîн՗D>j±UêÚÌ?OÖØaµ¾ÔÎXwŽ-ä 9‘^ÖXáWTÛ.ç\p‚\Øjh¸†ÿ—®À"©VëƒîT¶fèãNîã¦eeöåcþåÃþèÃþe½¾k`®î‘NÚ¿i{èë’Vã¾æî¾æ@ª­à—~i_° Ø Èàã,d‹}Ôé ù-¾¥ª°1ê§Å¶s¾¡Ò†ÛŒUm_íÀƒ^+UÖ|¿87S…Kx…_ppè!ðmÁ)(IkåîpÏî‘q·f/q?qW`VññînqëkÃ6éìwñ¿îî q{P¿'}8U­Mo îZü˜Åk»¶°E4ŽŒ°i¿{Ò9ÐNd¶Hj€Ä3^uêÓNm ð^ µRئ-×±mÛ¾ÿ4 w‚_è…®†Ýg€á¶ïðìl¼s=·,ÀsÂqÂÆô/tB?tCWqCtotGOt ‡A—ô÷qGqtI—ôGÇto(ÐtMw‚G›óNoh¨…˜a%—ïýÆ6úÞ€Iäç1êY‚¢Nä\Èþþ3>ëá¸írIŒÛI[+e QåÊ +Gó^è…_hƒ6s€Ÿx ó6VGðvqÂVmçöîöv(wn÷î÷pwtG·ôJ_wwww׈HWy×JºwJ²÷|—t|Ï÷{oƒHxzÈw~¯w ø}¿÷H”V „×½ÚÿõîÚ0¿iÉxMl~u !Þˆ‚°šª© žû¹Ý”Û.?yÕnçp™ïØxmè!:é1óK „fw6hvºò`¸^.é>wÂÖöowqpÿvs‡¤OznGws_úptP‡÷w÷wÇ÷‚çw ˜‡yÇ÷¸z|·w¯ÿw¬×÷?ø¯?ûO{}G{{|PìZxlaˆ€U=±°‘°+]u.ýÛ:›ú¶ž"±á2êE¶žü;óïðõ™§/ŸÛ²TŠ}y¿vƒcï3Û^"Pö3wögï…}æ´[¹k/§q¤'z÷ñso}§÷ñ6¨ôsx_zn—wuwt†¿zÿÞ—÷‚Wû±÷ñµà{ã?þ´ûµW{æGû´w} !HoõZ.Ìú°º§DFÂ%˜5UÄ Yüåñ¢?}úTîü¹ó‡”6³ÐŠÇ<òîq¿g•jÖóèyu;–¬Ù´kËês" ½sçµ Ÿ•j}ò!η‹Vð+>VØa.°dˆeÈe˜E°Â+š©â™*½Œ&Z/¿˜fáRϰVÅ6ÛF¸ w[I½¡äM¼Cp»Õ”r7A×Rs7Ú¤ãr} S<܃AwÞ5AxZÉÂçéuÖ>¸B[oÉÕ—YÑ÷ÝTäåÿ×~€ ¦Jx aV"8eQ€¸™g—ø0Ú+£‘ÖKAÐ@£0 TP€E#’HÒ‰ñ¶cn(µq›Iƨ`iK1ÂtN$%שr;5—#¥:'WB@#ÄS'ÑÝwUÉ*UxrE!–>ÿ­ Šfëé=\ÖÇ%ñUµ• A§ƒ™©¢Ög’Ö'iY8¨j?TpQD$Ê&cŠ(Ê[“Lò’d©¦3íVï¾ÏåHªr š:”\úD D+ÌS‚<Úá'ìU²69ž=RŠÀëg©¢W{ZÒC_}P~—SµðB eòG–zªIÿ›ŠvícúL¦"P°Bš p&‚ .ü2´¸=è ËàshFîêæ(ÔûžïÔ”Òd)¦)­D"§2Ú4\¨õî$ðP-ê{¶Ù« ×D€É'°0Ýu×w“²Ê…—zúà™Z{E¡¥°oE©ÏÈ-@p²âQ%äßþ€ÒRBmaWÂÉ óLIœéE.Ad¹Cÿr º×ŒrƒQänÔUC]»M,ê…1Uã»=%¯Áð*Ìã(¿A­]’Oô•6¤;&*õÓƒè Ï]÷Çã &~ä·–g”üýÊÆ{—äå#ÁXoÑ ¥e™A¾+þ›¯ÿfÌlˆàœä´‚:¥I@+pA.œPºÒD\AÚ2®ŒÖ4Í]Œº`¼ußTíi÷’ˆÖT2š Ïk$L=f©®Mï'8yaNÌÆ/º„bˆ8êS7îyo*KâÎvœÿ|FëŒZ\¿öN,ÞR?µpæYùÛ_媥E5¨AˆhŦ4¡ÌE.~áÒøé\ÐX†‡âÚÕlSË ×lgG”'xñ£E¹¯µá¦„0JshxHé%o†Ï =øA ȯnâÁJ²æqï ‹*â{œZô·Q~‹cƒ‹Ë“à–ÃMñ~ù%c^¶Å¨ÿ3žkEfÒd¾W¨.hAC£Ò h ãJ;¢*ø®FÑ z“*É3[Â;߸8²9^!› © oG+Û";µHGÖKœ;J¡KìÁŽgXá ÏT’t#Ý£>ÍÊUõ7¡E}!p™î‚«²˜Å•ŸéÌþd¹&QB-;ÛÙ"ªKƬ C š‰&.AAËÆÒ¢Ì‘h ¡pTdØ0ª$½Ãp H:æjÅ+ñgp~­§újô€únbx X@>>¦­0)žó|*8ÀïÐc %)ûÙ1¸Œ,¹À•Å£#FK¡²ŒèZµ¦ sÿÉP/¹Qhã×ÀGk ð½Îî"ŠrMD0RÒvµë5éM­ ™þQ#~dGpÊÓÛÕ„–ìeMøXGÙC ЇR³Â‚pR*OgT”,«N¨32ßK©Ä||5 ¶Í‡ãÀ:¥³¤eBÐJ¨š6À¦ÅP‚¸ c.ÅØÖ™U®¦q‚F{ñ A a}Câ!»½n÷"®ùnˆB¤½†÷»…=oI7Âà,¶¯ËklM‹÷4 'j#\)fó›Ùš(§ú`À ìÑ‚Ô'žWÑ$’Œ”Z#€~ üV€Faü©¯-·Ë_ø#Ö–Eøe13+EíQ¶FÀ¸”h.ÿi†–À’†®À2€ 9>¤Ù­±=  ãëµÇ=þ.y]SÞ!CA"m8l»bÊ®‘:¶6¸™ïd™yY(“„Ê5­2L¬þqŽ÷úã‡H¯¢¯k»äUË´"mXìGåÇœ´¾·› £b}å][¹× ÞÓR¨AñXkfÄÇ üù|ÀªòA„­4á¿}+‰|á¶[ÁϢ̢ÿ>ÿ쿳Ö23Ê£qE㸪qº„0(a ü`£ÀÇ.iLªßàGòñ`à‡ÊÇ¿®pëá¡ÖqˆBý˜¶·âî…µ«ëHkûòw²VÞ/È—‡ÁÈÚ㨟@v¦RK.{* ÆËãþ, ßJøZ¥äØy”¨Ä_¸ùbÞ†åš>< B3¦Št ¢Ýê£ ­hBˆ´è{[ºüè÷Õmü~| ù°úÖ½.ö týë[_¥À ^pçÃmo¸ŽUmqv­±\©)ÞumëÑT×OÎ2à±,ø]Ëz8ä%1² @‰dš¤ÛU®2Zñ¸Ýªs†-1O¡ÿÀMIJ<Ÿ§Ôí|fq¡†9ý¸ÿ‡EÀm + …Ý ^ Òˆz+,pïÜàÒWÿ½Õ­ü|üžÅçºñÉþ{âóãëÌ'~XÂð|PœÕ«¶ˆ@2Ò\SöÖøÅ Ô|=xñÿðrQÁ6°DDÝhÅv(ZZ1»ÙyyE´ôÚW´ Ú×[t^艕ŸùMæZb$Ú,QBc PYìLë½a„Îè©‚hŒ†*AC/żý>à[ï!?\F ž ’ ®` Ÿ Ÿ Zó¹ >Ÿ5ÑÝFÜ]{õ•ÅÝMá—‰Ü{mÖ6–ŒÜT|aNE’¸ÿMC3ƒ#8ÞãÝX†™¨Å.•´Í µáO?mÛ”lÌ+ñ_類hœžB=È‘ØZ5”ç]Ìž\ gô‰!”À äÞ½Ý@çP€!Œ@œ$¢">ƒ\F#6"dT?èCPb Jb Z"?XSy]EøQÅiÀb¶”fÁWá½— ”!adž€-Ã0Y€â!›%é>l€côþAÛPÂþ ˆ„`·Æ/ìÙZ,#h|›,ˆBaå¸áδÂ+°-†*†(…Ûªä ÌäÝ[´‚!Ή!ÞÀ#RÀÍãeT 2ÿ ¦ • ’Á`ÕÝ{dðT)¢â÷umYù¡*LÛCš_MÈb-.…B\Œ‡%±%Áê©…ÏìšUg|K·ýo¡¤ù߂̄æÈ’J‰9!a€‹þ¼AC0#”À-ÐÛ(à2ü€:‚;R€;â àÂ%` ù¼–þ¼ÖÌÀ´‰aJžÅ·,æÅà  ñaL‹a`5‚޶•ëŤæ±á,Ò•>@Pþÿ!Ê>´!*%S¶#"âj£R:%lF%TÊ mrËP€L=èb÷ü4¬ßãDØHŠ’xfVT?©¤bþÜxdZÎËŒÑåX}Ò§šÀR©JuHÀøä\@X×(e!è œf<>¥k(<åj¶&„²æÎIj²&nzÅVnå@rWoþ&r^Äf 'ލA"ás.gN¥è‰2IXB$„0¤Â ðgW‡~¬À5Ã^†fˆ¤€èŸÿåŸ` Ï-æ3b1F#ˆÿ†|&Z}6¡fjž€°‰0ÐÕ „€!TÀLÀ€à½ýÀ„âR¾fjR¨™rËivTV(;2¥TRnf¨œ>Wôæbù¦œ®ZA2$‰òiKÜÚ ÕŠŠÜKP‚BPgS´‚!<‘WÁ3úPQåd‘ÿm†oEˆÍ¡gz¦$þLB£B…›–êÆ“ÚgLâ'1î¤ð§!ÂJÝÔáÛˆ©Ræj®>åšî*™¶¦ššéikjÆi†Úéœ"«o‚¨w-ënž(7E+´*ç‰a ©(:u :íH\CB0E-Ìèp…á€4\Ã%8Ë®üha !þùL„ Oµ¡$o]ÿL‘éÌ-©,if“º }Bi”b•ž†0Hª=LÀH@9âX@- C-X¨£®*%RFèkº&±ªiƒÒ‰˜zìšÒ nšÚWÌ)†jèœâiªlqÐÃN¸¬ññÇñÄl̶ìËŠ\ ¡S ¹\ÆD í„**S8Žë¸¾? –€’ËXêÌDÈfhF¯tjb ‘Fpék¢é’×RKªº^´`• %H#Ì#@À"Á€@-<¬/%Ü0%Rªé¼Eeç«T¾©mö-;.p4Û¸ÝÀ \†¶]Ê6n†‡\Ä@𴬧øQÍ^îòH.qñtî̶ÿÄ<èDÐj@èîDé‚.¼(S¤‚ͼEWtŬ.Hª™€j1F .&çY-þ8#éµda>¦Yyíþ+”Þ'VíÉÓ­À¸f ”€+ ü€Üú‚/¤‚:hÞ¶ã¼iÞBhßB%ßz,à ná>ú¦¯ú®/ûÚùïá.#ØÃü"[ýº¬ýn'²Å#Hnÿ~Œ.¦-ÿ~Œä0ðËí’ð¦ò®^|Ë2~êŸeÞþ¥¡šL”|R f/èœOìucèC¤­vø¡+ A€@[¯/ÔBç q¬¶²+»rœ$qç\ìàJ±Ï p˜ó‰]×õ2Ùýr/o1ú‚ñÕ/ýÚ¯Ožq2ûd/sŸñk$ññ°Ï4“.›A!SCÂíë‚â‰nEžIoá ÿ&bÖk [¨–(ÿíÖÊ$“Z據íZýß®$cžµ‡=h3@À¸B”ò)[o#A Á+?4DÇj0EDzEÇ*eb«Ä/³Gûr0c1gñ¼ïÐoö'^³O:³OªmÚÆ4L«-MðÛ1N/°L ðKŸ#¸hzsëÂ…oFAgs³‰…„Ïå‚W‘E>écÖën1ãR`‡cåða‚˜|VrëY”’ÑÚYXÐï^ò€+¸B=2Àm-(t+8´DC´d)^O´^ç5_ï5Ds pT€T€`ö`ƒôGs×ýrIké96#¤t"óÏtLï4McvÚÞ4ÓÿÍfó´gët§í+@a¢>Åû>Ig1€à¼…Rënµ@ÔS ä‚^ÁAeஸ3Úëb)»Îó’Ö0Xϧ}ö "|̵…[T!Ô A=´õ[ ±ƒ0t9^@p·wö`‡7x6wöx‡·!LFB`¶{‹7|Ÿ·awÝ]}Ó÷ÁV@dïwN@Kÿ·Úê¯þZöe[vf¸f¸Ó!TiS¼ Ž–ÄEèE£:*Ë85—pG (Јž½ZíYð™UƒFqõV×ó©zíWK ¿ZrD9ÃÜ$¶ñÀ<÷t“r) q*1ü§–ji}o©‘ÿ9’ù ù×7wO4E³÷JD4^Ǫx¿·|ö`7vIwyI3ãMöKÿwK¸™'8š£yÝ|€¬]FxX\xg%•°´y8Ðè95@•ŽçåÙ2rÛnÿS¸ž¸ ³«Š¯8£ÑY2H„¯Ló \™ñ@tëx[#t\§r Ári’9˜—ú–‚¹Ÿú¨+ù v¬•×µ+ßuzO´«‹÷ws÷–ù—«º© €¹Ú; »±¯í±‡6M/ûfï³× ¬€XÓ§¸ŽÌ\Ѓ^Ñà KØ9må¹ç¡‘m‘ŽmóYµ™á¶:3 ž$TWH‹÷ÿ Æ;èˆQD{d"?¸ï–ªõsë¸t´)ûx*P@ô^À-º—:™7<#Ü‚OB|K§ú–>v×I¹JÄúz[9ÇK´C7tw‡|®O@vV<ª/<^’9=ûN{f»|L;²vhÓ¼ÌÓM±C"ˆ5ÂDøÈÔ(]ø&iͶ<4ûÅç ˆEžõV·áöNI :¢g£$O²e~µ8zÖGzD5e B_ü’<¦K÷tëøA'@Çõ2¤2vß$üÀÜO@°ßÂÂüäÊ•ÀÞó½ßó½Þ?ü—ôbúƷ2”C9âK4wk· y‘+üÁN|±,üÚ^>Ì_>Lÿ{ËyÓ|Úû^BX·‚0*yØCn¶ÀÈö’Øy›ý¹^4}cž»Zœ¤§êŠŸ­«`‚λOàÖo½ðÇøe¾Þ½£US¢üÚ½Z³µ¦×CHu³½/,CQÆý- |ÝCÀ-Àßûýó>oø—ùó=ù«í’wþCSÆâW¹_ë5Cö“w·“‹ú,y—F&02xaB… d4ï!#'J|â<>D°`¡•¾BØ£wò¤É-äµXÒ¢…zQòåÓ§ODΜEV¨ZQD•O ?}®Xñk…UJEôôôÕ+JRP²zÕjÕ”là#ÿÂW±´.ð±í DùF~°7 ®êñ¨wo½ jÕòõ××2d \ 1­ ·–p옋‘°¨óeÉŽŘ𡂄}£÷2„È4jCV›nmšõk$XW¸@ÛvîÛ*|žðû7£‚C _xÜ`C‹—'XcôyXX°BÉ’ôì™TqRC‹•'Pž¤ySgÓžë…uÏ“gR£JUµà•YJ>¦Vµ*–+Ôj«²ò»nDÖrë-ƒäâÁºîbÂzöê ÿ–©„ ~; Ä[›Ì²ÊL´¬DO,áˆ>“ ÒöQ­Ôbs-¶Ú`ƒ­ÿ‚Ùh» HÝBëMßú@¸â *HI‹”{ÒÉçškJ(5Ú²D ɤí¾™4É$”B@/§¤Ôê½öæëI=÷Œz¥§ü¢úê<ñë ,®( +@±ªê ­ë¸ADÚ¨ W⊰.¼òJRIÅ¿4¬% [,±D,áRK<ÂDTU]õ2?@4Ò\S͵Zm}-ÇÕnëñG!'¸€ "}ûlÉ ¹…Š2!‡”£h# ! ‘ìJ »“¾“©¼“œ0Ó&œt2*>žžúI>9Ù[W:¹òá°âÀNB-ß@ó; AG1…TÒ»ô²pÿ¯Tüê+°L s¸[•TRQU‘UV1+Á Wc”õÖq ™×Ù`4Ù œ Ha ŽQ€-Jö *kfvYç åh…(Ð'„²=©0»å.„¤± Á¦qÇ]¨åkª(uŸŠ`©VàJëxWÀÚO>óí*ìBZÀß Šãa!,nƒ)U°ÀC¢°Ã»EDKýûâŒ5.ažé^u´[iµõÆ[gÓ•W f»@‚•‰dyX™‰-¨ :N Ä`vÖ9(?·™Ê,W` Û£¿4Ó ¦óY:ÜôšºÝ÷p—ó\÷|ªø=¿Î,¯Ê ,Aé¼A-} Aò7 ŒPÿ¸åÖ‹Ò…ëoW<üo¾G45ã{P5ÿbÂ…;\F‘ݯµGøMÎ̓¤s—£98Î.t3#³f&À›E †@›vQ&z¼®°‚ˆ%ŒÀÖÚ‰„†úZU¼®òkFi¬ÔÈzT¯†ÿ³ö0U·ZàÍC™T Ã÷Œ .2¬ ¡Ä%2ñ6°Œ„¤_õæ‡Yì_ýÇE˜ðscŒRÎ2D¨%I Jæ‚H …pÌG PAqÁG]ÑÄ Ó¢idí:×Þž u–¯ØkP†4›‚² Ä%.4”TõªÇƒ„U*‡IEàà ø0‹Šéä-(¸S]ÌE,“@)AvÊSBQй™¢+=ôB,ÎR9Ÿ«å-Ò¬›)D9ΩÀDÀ¡ÑI!ˆÒʈ5Däb™qdNÌåUøà>E™¦íªéžkÂË,‚4Ôi/°Øk„&UÔØö¨GÑ’wI*ÿ^*Å!KÕÍ„©ç¾wOð-fb£¢LŠV$±` Ô”}_ŽVY›ûU­•¥ÿØ ³¶Э·#F”æ)êZöÀ–%°‚PhqLéy\Á ô±x̉>Z8®júd1M¬N{V¨“,‰\@+%éIo`2´žRãf)…i 0*Ì„|b5|ZÅLŠB¹¤W™&¬b…ŸkžØJ^Ý–¼É"ãê?dµÕq-–\w‰Ëä|à—ˆ0 #ØÂÆ !‚B ”&Ç(|—&ù@©> ëÁÞ-ö&éÍ#ï"»mö ¾×ÁÖÐ2<´ðk­HPvxðÙ£ÚÅõp€ÿ‰H8{a`R7òͪ|˪øø9D¡HT#enu+2Û¬F³Uƒ»Öþ!fÇ=.= ‚$âÇ8Érù‘ ’@!˜Çô±íRB;G3Ïw—™ òŠ ¼N1Ê/ÒÛdœÈGj7­e u_{U–¾ðea¥G‚é¹"À"ð€ ·ËS‡—¬çšùÆI‰ÅVˆ“Y‘ú¾JÐÄux·©ÌojáîF¸&ÖçPLÑäD¢Å]nC>Ì !JÇ!À®, y´àÒ0Ñt èÁé“,-iß½‰ ’â‚›ä"¹/zÒu®ö"ˆ²ôÅo"³¼ý"â‘Þ£ fÿ Ì¿ð %•°¢VžxC êÉÉÅæ$"?Ke™Çì®á°AãgÖ!õ¸»±  {ó+µž`(6ÎpØ­Üu#š€ø¥>$ ‚²±Ù]XÒ‚&´¤ ›øÀ9ýÆï*$µ»ãAHeÍbóágëæe/€a°°œq_O ž§…jÃæéà6ë3ˆ‰Ùçˆ6³¾Û¹4xÙ@…$¤”ùöW€ŽåZÓ­9E·ÛÐË}÷¢%C¬€…ˆ@[ë>P{ô[Mø·Ô›pªW½÷ÈúÖµÞ‡:¼t„2aMÂDÒI³úÝ,|BÏç5Ç à_ÿ[’•²Ã¶0dô¥äú¼›£-¾Ç”Š3ŸI%"¶­[^ÕïÛ‘_huþÂr›˜ÐꆷÐ7ßî‰>©HÐÄuÌz$êÒò‡Õµ~Öo®ýìïÁ­= 8šÔTSÊÂk‰d;‚ÌèYÄ^sÆ9.ì÷ºÀ‚ ቡZ\*{·›TQŽr0âû…Õø¯ý™ÛÂ\æŒ;Yn Øg˽ò7€Æü ]ÿ¶ÞèÅ2.tYØ3è˜æ¡ìAõªNö80_OÓT­P­Œ ÕPª&ÂMÌË=í„OøäË=Zá1H 2ΡoãPPÀzmØÿHË`†@ïôû®Oä6dÙìä8éû¤mTzc>#4p« Ò/ÄÊ*HXÉýü –ÊíŠæ8~n¹ð¯ó¢ð­ÒM(@ô8KÇæAæá–`õPÆ0° 3&’FÕÖPÕôÁÈœ /È÷âË=‚ÛÎ(e#ŽOî0Ž7ŽùfˆW°†°§©27 \!¶&€¤ hÂbë0<™Ð/ý\ãqŽP7Dl s.¸.ïò²È­4ÏÝ8ÏþŠ YB ¯~)Aðb1  ö[Àö`" Øð ɋɎâ,/0šˆÏ«IíDé #J€=ÎãþPSð¤Ìÿ’ ÁöÙ|áqŸ&ˆœMŸ#t^éåÛ@¬‰ ¡|k7V­0çKóf©Kñ3( Yh WBõd µŽà`"vzQ‚QšÐ «¦ŠÑÖØé̈…>`JJ°×‚@«¯±.þ°9Ò‹-N  àñÀ†ZR`(`ú‘ª1þšHï,k¥·Ú1 ]©ÄBÑ ¡Ðï‘­ŽëUÌ(A0‚Nà]oàr!«R {1ò(–,'˜Lrw$Îá$Î(@Pô°°Z @2.2#32@#EÀ‚ÍÀÌàD²×ªÌö‚/|ÿL/€~ ~ FCƳ“&WkW 5Ðñ”n¤6æ'ÜZ ­ÄíWä‘‘²¸D³–€£ÑÐ’"V¢ß6-v ²䨂ڰ¼š)¶ò u"²!3P‘ÚNXˆ… aã"52ÞR9€9órÉ $™s/÷²ÀÊLnNëRúN{jáï®ïúbðR,À%/ JÛ†°'iŽÊ}å&;4{Î}ŽÐè“ÕH ‚Fl¬p°E`âÒ:-i^³‚¢À R½Ò6§æ+’ã„ø¢é,#R-(ày^^ 9;4$™/À@t:YPDÀ4².ÿë©¢ÏÌJ2Cúsžn¨RA1A &Í“,Óñ&ǃÄýþ¬7ˆò3Aó çQ–íÄL3Ý°è ±Ph؈J/-ÓŒ©Ó¼Å˜ÀÎÈL ²2‚LÁRªI™2"…Ó_  8Ô’.™ó-órDE/¥ñ-QÔ^`:©g©^Ô´bt;¿{òbïR&kÅGÇ GBŒýØs3I þvIåG³>“´k$€–#„<È#@a¢ÓœÀT«2vvQ½pB\Ä¥±K½Ž,÷Ñ=&”,Ô³ÃCß´9CDéTNMTO€:[t´àfnDŽï¬ïRb°Rpˆ;ÿS¡†À0tQ Šæô ¸†tÜ>Q ]‹R3/ÝB³I™T>›TmCÞÔ"5©´N‚Ó6­ÓŽœ©É++½r`ò¦ÎtWûOAD WK 9ßXó2/…DíÔ9EPT#‰z\4/Æ›õ´¬Odûâ$¹3S¬Ï€¡04[·•‰'4À­=Å-“†R–ÊuIÙÊ\‘”g_ä(`vFª ËÓRàbÇɼÒUÖUv`Vš"rWawUAüe8ÔC#vb¥óN‰uD_À.¶•Š.lm)(EZáÉm±ngPaâiäc¸‘Óe= vDfÿ§¨Ï:S ãÑŠ€gÑug{6g£8 ™à5¹p^;­T5í^‰ÓhbÕöui=+QÒÄŒÒ$ñpjû/éÖôÖ´6DÅbïò.?Dõôêaú\Rwa°b°w{—m×¶mßÖRL+;·ªîf²GÑ3yeH‚²='8Fѵ·×5óÒU=Ç‘„˜¸…^;<²t|—&÷jÂÉ+tv`6j­vôÄBd8Ùô8T…µNáRvÿ7RLwutw ˜n8xÛöxëöníön@oÏo= ƒgV¸üŒ\Gñp„×J €MÛtÅöD‡XEñwu÷€Ñ¶€q·BÀBžØ‰£ø`t7ePäê¶n–aCfroÇj~nnf9³HÔzíH?8„AÓ‡³HÔBZGÈâ¸[”¦9·Ac5tCwjF‡-ÔBs5a‡ó7„xOQTˆ“À\B(¤‰˜‰áÆ‘ Š+9Š-¤%«XuÈøš—'{òñö¬r õ·Ü‘¡xãz?ózÓXJôðJŽkÙL*Èo¢±tb†áwjkx~uXWÄy>`u b EíTE[´—/&¹cÿ­‡B\ò‰‘ cÙöR8‹µ˜A ‹EæqÊ3½U7îç¬ÊMRãï&3Épa–Š ¬–- `;àøhÞÔÒ—L{¹}û‡z‡¯öjëg²6ó÷Ot¡E’.ÅlYš§Yš+Šé p(žØ3œ)¸'çêÇd6ñœUFRÇH­ÈÝže ‹ÎÍ4‘ 5‚¦-H"Ÿe3ÔBÍ…/ð‚6–¤}‰¹… Áy²#äáXàUD#–é¢.'«­G¢¡™Z5‹½zyÃÙ}Ç4ÌÓouåæ"uÜ$µÏ¸Ä>Ó¥M,¦M3–éz$.´…nz$”&_ÿ±Åto™>@}sù§ÇeW!Ws5Qø¸—‰Ùyè­~²£Mà0@lUˆYÐ.¥:³Ú³?»`¢Xû8º£¹Q¬¹m¤IÚo®0Öú•FŒòÂõ7>qXâ®k{®ãHŒ„®u›eðz•žg¯ßH¯f°Ãk}m§)ôÁ¡v‡C—±Ò ©% `åe^€²)ûX—™O«:بz@[¼±Ú5å‘÷nS‰X–eCZdÌz €$eÒºr¨ ¥Ûùý¬¥ÿL®å7\æ{rÀ$ÛÔC[ŸéX™ô!—iêv(±åc–çW`[è±%@* -Ãb.ûbµ™!Dã EYÇÛÄÿ#ú©Æ’F®d„e±Õ†àÅÝÛúÖ4ʳÆËz¾)牀¤¾ñÇ6êû¶ýŒ î×þEéÏÑ’ÚÇÙóÖ4ŒÙ{RÚ™½rRFr2žÇ;>ÛIì&¹ÜÍzõû3GþÜ™ÜÉIé1),ª%Þk°<½du®PW£»…v^ßaßäß1 Ö/öÃSÔ¡IK×^陇 xÅS«}°PÆ)^â'[Ù;Ƴ>ë}ëµÞÙoüÐGZì%ÇÑËþäC¾Ü“ÜCQÜß­L^¿‹$X²µÂÂ:Bb¯s/ìÿ>€áp翔童çõ:ÖWQ# ‡M@è1àbo}OUô™8«·zé'ÿÌHªˆ}4dœ0û¶ó'þóo\âÛûëµÞô¹¾oÃ~ÇË“õ7žœÅäa Hʽѻ}en?\Cž¥—°¡€VÁÓÂ…Þ8i´<÷æ}uY†à&^½- Ÿ$Ôè! §pÚTŸñ‰¾C§nz½òéŠóì/d„0¯^Æ'¾ÆÛCŸýô¡½Ùã?DZ5õs\ìw¼”½µÑYÝâB$Lxáà@…œ0a† %X4x‘B«VIø`/„ÈQD– ‘+ß}ú$°d9„¥Ë–ÿj~ña‚HzÍû9ïÄOy÷Ž`0Š!)/1` ^TõªR­Š5«Ö­\»z­:ì×z®°&H*•¯µlÙÖZ»/î>CP k×м|‡Üõ›w¯^C„ Lx/’Á‹%,FâØÐÉ'K”@áÀ˜/`æ,1tĈ GkFˆ1#…,†˜@žÈ³qæ Á2Ÿ¾réËÕ»&Α:ç…˜è¼ó^œ‡TéR œ>5à**ÙzWÇzÿ^l× UÔK"ÕÛem}ÕzëKî> €ëÒ§›ØP^ýwó#Þ{˜ˆ-–d™eŽ9fÙf¨y†ZA’šÿi§…Öf~à™j­}O±É6ÒH7} R·8Üp:…ÁqÊ-× ÏapŽÒ½ PýˆÝTYñPVxFÖWE–‡žZí­õ^|röWu!&àbÆå–‡íµ ‚^„`e’ia†j‚águVšš¶# tˆQLž9C%´£áEfŒôÌ#²‘Xâp75zŒÆ)×Â<,Ôø‚<Ò%ÅDÉCÛaµä‘\0EªªªêÕæ½zž+æq+zéÁç|òݵŸb\b¹eŒý*Xd‘•i¬ƒz¦¬‚jÂ)ggh¢)§(RìÓO¶Ún»í>tè"­ÿ{åAr?Å€èO‡ÇS£Æ8ãOB©<™êH$Åc®„ÊC¨@fWd©ßÍÊ0pËðZ!a–¬õ@LV›G1“Mâ ¥{µÈ7à¯ZöÉú,¬~`8² N{¦™m:{æ³iJk3šf`ÀpÏ>ÃPE††x4A¼êÅSº’†cŒëÎSi5² OÕš‘c<ÀoA|*ðÙZ°w{µ°ÏÛ:U­HÔzÞÄqÃmkzNº—\w݇„b‡•œ²¯¢<™’Îì´–!Ž&â Iö â8§)g Û¡@0Ø4ÀyçSƒÜJG‡9ÍxBêBµAÿ¥F+gîr––pB ,°pt9ê‹IÑ/À6TdWe°YàM‘í=<=ôÙnQžòg¹ ëÜÕWvsì1È'+¶ ²ˆ›¯l³5ÇŒsû™M¹ƒ¢½mý˜U"ƶ=`€?þÿ@RÐÖ'þP‹|(6j`êlÄœ”@‚œà©F5«ešò¾>È5ày-HóÑÀÊRªäm%{\‘E¶‚@j«V×;K à*íMlV6LÝž$¥¸ìç@åcâwDË\ ¥a¢›(Bš™½/3TŒSýf¦¸ ´#mýèAbÆ Ú‚X´Ûa°j—Z£ÿ½¬öÆ Ö«j<Ê=<¨¯ è‘k/è—ײS< A…*(DžVxž¼0ŒþÐV=°gÃHJ’nëž÷~Ø ¡oÈR³·¸ÇMN¤yÈD0dÅœI‹W¤°•-0r–Ü ²e‰‹€hUË{ ÇÜaMSE)ŠŽî˜¯|= úzðJàGâýè)_ƒ Á¬"•Q­p{qãŠ"ûÃ0Îp’ ¨Û%m¸=bï’>¼[ÄǸ—Aˆ}¬Ì"EL‰Ï‰äŸ™H?O §iÉLqÅÈ ¾HË„ú£Ú‚E*“ bM˜¾fŽ.zL%™½û`ƒebà%B4ÿÿej ÒšÚ)KTTˆ°$uå›áã8»‡ô ¡œ hÅ9)·^2-iɤ\Äe‘PbrÔš´ô9¨ê3!‘jT¯JÕ†D«\=åÌj&­Ê4ÄrÙ€BÏJÆ~À@Päêå=ˆ‚5^£tí(ŽÌe>`¾ëc½öâ¹b„NIéuD5Ȩ+2åæL)ÎlIà)OÍɹYÒ{DM Çäc¸":ëf¤-í?¡zÕÔª–ªU­êTÿÉ!›)¬øƒ¶dyÖ³°¢T'ÀÛA' (p„rð„b®8Ê^“ ݆t¤`ð€&€Â× ‚SªSÿøˆ`c#*æÀ„ȨpìWhÊÈqV6§ÞË©ö04ä]è ÍÙÙ¢¾ó¨ÑPÍX)ÅÎDd«ø´ªj¼ÚS2XÂϨ†Äj‰lõ@¡àœYŠ ƒ Š­@°„Ô¶ÍWG{—½jíNŸ@±˜€ïzíS,fPc†íã SpÀ|¶Y¸¡ðl?zHß;LjS+æà¡Ú-À¸™±ÆäI9!8C †°™Wëà©Þ“rõ¬ f  -jÐ¢Ó ´Ñ¿YÞ² Ÿª°ç*o«¾»(G“™#pQÐÙ"…¾û‚a盌4 ÜÐd›JÿV Àt¥·……,³3Àâ\À¤ŸÐ‚Òpªl“)Q{æ³vª îçVÛ$3\c†gýPÀ,PŸÙ!ÏaT@¶DqÌ#ÃÛ¢A´Œh£uÞ–#ðŠ×æb R²Ÿ-íiW[[L0Åf€‚Ú¹ÒVÀ¸-‹LÇБ‘œÃzÀnik£»ÝÖl•Š-UWSÊ«Sí8~Š\mm¬ÑLkZÛÚfgbœgÒ†Ð0;[ûèF1]ƒÓî7!&XöãÎc¶±ñl}¢˜ÙÞšÊYÎȗǼàñx Ð mõ``¤FZûF†öc ò ½ÏBem)€èÿ9‡ù¶˜ÀÙÎ~/oqALhÅ´DӝРg­keíà³G<Ÿë@'CŽæÍRéýÀÀV? mmtïÖ®ú•ƒØ´¤F´¥ƒÜéÈÛüY og õ·ŒÀ-“>½¦Ë0[çIÀ‘5,çÇ>[XWO€oeêÂŒ¬AÇä gÅ2C5«·Èjƒ%¾O]C&‰@¶|Íȳá!=ÀØÀhãª)7hËs‹my¡˜ùs~nÿýéaç Ú†B-ù¥kþŽÂn{ýÿiC[hPO-L?TS¨0†;"fÜÜ&.±ŠÎ}>×€üä, B3tK9§-'WŸ6ÿ:QU Ö—~þb¸”#iCÏw}ØW`A¦ ¹•q¤tLYšÖõÀ<Ùâ}è?G·ïñ~iÁYSp!#&Æ’TgB€¡™Q=Xv·vkd€^UOi¢n!(‚ÙR ·0 È0¬p È‚þVû O@…,x…`P„W…#8~þ£-nK5U…·žõ~ïÇYð$ 'Z ²T@H„¨t‡™q{XõlB€ŽSi†4–0€ aᦈ‹˜V^6”W…þPg9ðˆ‘ø?u†%h‰b¨‰N—-.Ôv0KØPø¶‚E·gëà~ïÑYšô+"vë£DKµJyhÿ‹kvvÿç> vÚ2KiÅ$`€àt}Üò³´ u¦¡FJ—6ÇÈHÉø{ÌCΘ-ÔCmX™×‰›§VÙ¢„ÿïÖƒè?ë×3p+0HTpøŠb‚p‰c>“ÁDúJLÕJw˜‹jwk8ƒ¤á‹Œ”VtÀȆ Å-§CêhgÜø?ýÖ @¹…ÔoÐXlÛ|áG‚Äèdr§q=“ÿC 2׎¬˜ðøŠA(/YDNvøw w(“DøpV¥‡P5aŒ€Å¸-è¸P=³aad‘DIwúÃHy”`¤ÚR’ÿÉ i‚ÙòEç3C»¥ «èÿŽ,†1 E¤ö(V«¦–dçp9k= F Èg• µ-¢¸‘ýðÐq~¡ÈHÆÖFà”†T)•Á—-×ePŒT•SI†Û2ލ6‡é?‚‰lè1©À’ÁÒ’er85IaÅ KÄTLd‡Aø`@k{‘þ³ Ù’ó”¹Å‘ŒTgí0C°[i’RÇ›Ù2K±gÂé?'ùÿ³g=Ðeå‘cØHÛb™þ@ £œC”iÕ~0øïçŠ[28ƒ3!3¡93@xOµ“:yU¯I¬Éš@­é–Ý Ž•—-Õ@2Мñ•˜Nö›CÀkYuéÿ‰ýà€™¨ àˆ ÚŸ7™E)~š Ùb‰1T›ýpíè14Øu7h>aò2ú7ša—©i‹ÿ7®Ðš3:Ÿ÷IŸ·@Ÿ­ùš®™Z¯™›a´g)À ¿· 0›:¡Ù2À?:oª- ú PJ¥ýP¡ûٌޡä·-º„ý@ hƒá#qâ tèDøí)f·Ÿf—£år $0÷Y$PŒ@ŒNøš=1ŸzzÙr™-\Pjó”OZ¥Cà °[Iº¥‘É I¡’š•`´g¨tXÚ:©Št^Š˜`º1PB¢ûàá QdZWTZ¨Zªÿ£ó9§uZwZ·«xª§uª§å²§ÐÉHÌÙb F) ¿WœýPR/ nTCÈÚ‘1Tg3à A×Ô@Ⱥ¨´qÙ—_ú‘’z¤ê?#¸1𑪦TQ¯øäªn:{{a®`Ÿ5j«¸š«ÿ °¹ºxʺÊA¦œÿstŠÚ¬]d¨ý Aà{é Fê°yI˜ývKÑÈ0™ú©[ÀUê©”}P¨-²Ð=îjjffvø”Ñ`i×g¦£8Z£}z§¼°=û¯+°wJFK'Ë04àx!ÙJɬH9”É”N«-Gj‘çè˜ZŠ®“:([FKVÿ¨çòñpEˆvn9<À£3𶬩§ë³,`;qû³»«-j’û¦-˜“°à¨‚MÉ-ÈHÙ·¹rG*‘ ›Ñ†·ë:=#ªÜ‚—`$‘ßh Ó Lâ~a+f»Om™¯†Ÿj[Ÿ¶Êšû¶q ··“«pë³ÌÁl“«®\ª-\Ct¶rËÈHøŒ£(:4 »aÄ»_è¥#¹’ Kjyû|ÙÙ{·g{P 0¦bËÀå¹=ŸöUøÙ½Ü;£¬¹§¦‹£s °nÛºj¤¾«»¾« °Íª–h@h‰°[gP‰õ{¿X¼[¥ ®¤·ô @”þðÿ¡™;½êÁ¹qñ`×ë–ø)Ÿ<ú§®YÁ ¨Âª§Œº¯‹;í ¬ëºK—9»þl‡Z™~‚ ¹‚‰.ì h ×ù˜Íêèg‰Ë»ŽfqªòÑÀ5º×ë„×{Á|½:ŠÄQ•Äʳå²Á5úºëºê{¼Å·ÓÅ",·[}7ì¥hr ^Ð<× bÚ²]/ðŒl¸Ür­™-~ÜÚ3[ÀÙÄXÍxî3Àsp0Ý#¶£ËâIì„3¾â{Šâ2~â<ãã‹·º§wê¯/ݺäÜÉ?N5[ÞèLÓ,`)¥ ¢ÀD@e@¬`ÿ6 ùàäô ô ¹öp(DÑ;JÁGS0È*Ô6foÝēܚI¼âQÌÈ“ÞÍ–l𾪫¸ªãËãžÜÉ…íé!L;p{¤Î§Î¼Áù°ñ ¼žëÆë ò‡B/:²)ýÍ#zqΞìLÊnNóÒNæaîæ ó\ì;¿ó Ûsž Ç æ¦îI¿îì®ßQH¦rbë„ÜËÈÍ3ã3NÿÝ¿ŠÝm{ uŠã¼ªéÿ*Â] ê† Â…­ö¤F;£ Ïñ–]M®-p-ÐMÐz¯&¯)J±/A}ÄôaÜå*ôÑß)ÅËKqÐ8_óm.¥àó>_å\­-MK»% LI/H¦‚ïl}H Í+ζöÉÈU\Ôíú“.ÝyýèŸã9ÞÁdÏé3½F´Åg¿öê[ñ¢ü"üðï]ëôаư}¯:'À/à;z´#u0X/à ­ð›õX4ÏË8Où–/ùÝ®óFÀ5èÿhŸW¨UèÂxð#ÙÔôú¿ôQOà@‚빈ÿЕƒÖK°Oâ¾ +ÞšFF$MàHbBGF<Š$y2eÇy'IÌ»õ²„ÌóJÜÄÉ¢„N=ødñS^P¢BYÈ;‚T©¼¡L{²8ÁbÞT{>äËg/_zô4œhÑbI²MZœ˜÷!Ä< Úfxᆆq$…!®ð:X0àp€!1àŠcxÐx0áWú]VàOófÎ;+¸ÜïJ=†¥0]5ꇭ’nmðu½‰;Nðhr$È‘ycTy ‚pà‡'þ2fM2Ià„¾s'ϧ?mzÝhÒ#÷’2굀 FŒB|à‡5Jÿ{]Ã;Qv | ôìM(1×-† xqÅ•Â.૞ ÁÉ SÐȃ¬±Ç4Ì€ ˜­j<ãp³zí ÖRc¶ÔLŒ ÙfƒM¡‚V¤m"‹>ò­8‘0î6’†é–’rTN£ K`d¦šn12:è¨ê)'«Ón¨îòn©ë š‡F>Ð «œ § ¯Z0†L²ÊDë¼^§­^8Ðê †à‹‡Â0àÓ#›ì0Ä{ÀAÈ›ðÏÅ °­Ÿh CÍ@ÀŽH±8`5I;q5ÖRŒí5<ˆ¡…@­ Ü^å1$?ˆG6ÊÍGÿK©¥˜`z®ÈT’ºéš´.Ù£¸Sª;gïÏ),³¬ +{¢h¯«2Í« øì©ª„6÷{!¿¹äœÏüÚ31lPÁ L1ë ¬Ñ =àŒH#í!`ÿ ñ0QCEQTØHm¨!SS=´×T; ¶*²u$ü-%ÜVR)Wäœ#r&b•\J'­C¶Yï^~™Ù¡¤2¯KkAL ÈlÁ,o[Ð@Í2 €Ï9œK² @ȳ°?P ^9 ì0 ›—Þªû3€Ñþ® …`±#Ýç 4¨î4a=5-EM›Øá…U[­¶‹vËu7Ž>Þu#!g y¥† vØÿç’,V:d›$jÙf“Šfhï9 ­Øó['²}g³Z ç¼ÞrkN¨È # •¾â¼wÏ>©6LÞ«ñíS18½ÞwßÃИ”Nƾì,˜µNf{ă–­TL-m!æ»®M¤ŠDrÇUâ¤Ûˆû;p~%ÉÂo:¹Ø'‡_(fp–€îb^ ­š»,À0ÅlÃÎÊ4@Ð}-¸ÑÜò'>©ÎFžú‚ ¨ù 0³«]Õn‡» ¦wRÞ 3ÂÀÌà &¼Â5ÂN-y.¤ÛóJô½hzª*Ý:e·Þ|p´êÍs³‘¾™O9Ï °†ÿ…2ÅMGYŒK–Ëî×ûÝÊVdŠþèq•|@síÏÄXÀyŒ‹OãÊê˜ Á@N£Ëœä„ÁA AWc ¢ääµNõÇw´C[íX(ÈëuÍ`+dÛ–ÄD‡°^ ±7Wa VqUù~d’’œ9Ÿ|IsФ“11:ïCåSâ8ŠU¤_Rzr‚€«^ÚÜÿ€F&v%AÑæDº> hÅúCAä_€ªã9èÁ}°…€´ WØ5n^‘‡< k8N5’™¡¹ÉCdd“¸€­~´£Üˆ„ ìÈIJö«š,ÑŸ99”dùÿ²’JϲîQÅ*¡%tZ¹e.7ו L]ùÀ îј9¥®˜Å¼€ëÖ.9*¨ŽÑÜ ½ìåA~µÐB( ¤Õ’ÃB^‘‰œ^9ò°FLm«iaö.v±¿aÒ|)ÎqD&œPæó6Iß?™Ø“€ª2(RÊÎA½CE*&´ŠY$¸²ÒE'ô/L^ÑÀË´ÅyÌ%ŽmÉÁGWÇ¿äe™"TaHHij­¥lÔ c*È™.¦á”Wò€ÚÍž.ìaæô)‰@ÅÍÃðž‹gIħÂÁH Y?ùI¬öôIÖ‘Òuš"¿«rU¡€-lꬄ5ÀmYu{ÖŠîÿLLkÁÀ=è53wâax`!8½àv äK!>ÙKP¾3$e÷zÒmÞTyáª`¼»Øñ‡9MgÄÚ&*—¶*#,ÀÀ&5>ѯºô½¯ŠO—´dŸ%3åM¨ŠJ¬þD–Þêlc»à¯bÉ>ØŠnû÷?´#­ôÀ™¸Œæ~C¸À¹ú35ª‰P¯Œ._ëU]ªõŽ_ , eLX—&r±ƒRÌx»yÎE¶M!åEçO*(BmñÅÀ(”Ì'%YÉøÀÅ‘dòQÙWG„*ûN©¸•-.;ò{œw¼à#(4)µµDóá„O4€ô­=ÖT_ýä ®ÿÅŒ ä´LçºÛÅ&ŠEG^W±+”1¢]jXðÞ1Ö}áórºªsV:T‰£m…Õ\tÎ}NcÊ’7Ò‚ïwi ½Á›é Õ¢ YÙ‰$™O¸øô‘£j¬`ëG¶÷§OmuP‡]Ô ÅÙMù”ª´ÀWmmýÊÛ‹Û9¶ŸÎbW<ÞE;áÇnèJÞ&”c Ù žË xð— ¡æ: m×A¿Š/E´!£ûsrw¾Ñ‰®ÚwÓí)„4ns»±v]\›$ãÊZ/š¨=MöøüȪ¶7À³Ž[<`ÀÁ}ÿ€ÒJGq¦ŸãZ»Jæ·2¡Ÿ®{Ýw -_Óãã^ì{¶ŠÝœ±uË>‚˜gÀ`ñ|âÿHÓ»Âü%0“ÇcsâŸK]P1Õ&пkc¥›[Çê–$Éz!Dóª£7|K;«c²¢ >ÙË VK²ÆP8>98± ¾´Ã@زª²*0㸠3û¢»´³­^ë¸.⻬ð»³êŠÐa‹“C2È0&$¸€Åp™s€zxÛ—Û«[”,4n+¬ûÛ®î*ºý³1ÿS,£“!x«©Cê£ÃX=É«3²­k='ÀNê·%SÀ&ëº'û4|¾ß[;'*ŠfÃù9¨×²8;+Á;¼8Øš´¸–[røÃ(“ Ñ!—Ó1‚ˆ Wà“ 8¿Æ¸“n³#¼åº£Á ´)Œj34噿h²6yã¿*œ:;êšjÒ¿Ã’!Ô°žê.,\!Ë‚š¸€|KµøŠ'€‹½ÚãÅ¢)”Ó©ÁW[8”a[°ÓŠ;¤àŽe¤¯ªÃ´³h´;…ê5ûð8øÃˆâŠm<‚«á€hŒ @‚¤qéW‚ä*±@I1¿*ÄÂÞé>ê&Á²6k…‚X›Cò ö¢Ç},$P‰¤…`”—z)s”Š©‡„Ȉ”ȉ¤ÈŠ´È‹ÄÈŒÔÈäÈŽôÈÉÉ‘$É’4É“DÉ”TÉ•äÈ€!ù ÿ,éÿÿ H° Áƒ*\Ȱ!A~ü-À…k>hþQ ®Q,àEq>|#´ÒøÏÐ? >0bô¡&£y'æÑ¬ðA Î úQ… øñäù¯‚KCˆ(Üøwƒ"—-5’àôj… >\è93ì!«"B4â_[·üÞ:œK·®Ý»xó*ÔÇo>~õIR‘ð†–­,PDiaÔ¿Å"¨\0U¨Õ«ÿæÙ¼yâ߉Œìá,ª™*¢13¸1•è„=+¼D4é C[²nJ{ëÀ ̃0A‚Ä ?œ*p„ÜxnÆã÷ozuêÖõjßν;]êÿñÿEäIȆÿÎG¥à׿ÄBH¢ŒÀz£„ccV‘Y§èy,ÈÃhŒäô=4µW÷T°Ý[P†È¦rU]ð’!¬áÆ!M]PÁŒ@ Ðpˆœd”±UÒ]7ÝŒüdçÝ8æ˜xà Ô—P‡)ÙF†Ï{" YU-Ò`póôW :…0Ï•,Ü# NôL`L¬ <•ÕÓ™(ꈤxÃÉ u†M~è¾½„¢†€ˆÔ, WA#@ç#t5R§ã¢Œn˜ù@ê£[ƒ> Ø¥"ØFU PÐJG‘i$§ ¢ÏVð%€Ÿ•€`Êÿ£egC U-¾6Œ 4Ój)WLHÜhrP¹$AzUœl÷áöæ0Ý?0z¶vëm]‘þ£¨@ùŒÀ€Ή÷O¸ê²µÂ B­°@+o²x½VQp*Ÿ0Õ„â<%œÀÂ@Wž ¬÷Ñß•:õJ¿Œ8p” ÿjˆESáv®'m°UZmU!žVaÕäm¸#°Å–q*î·4×<У3ÿ®Îã®{iD,»¸®Ï-·ŒÈ k(Õ¨Êݰ‚U1¹”„5… Ü?/Lñ?Gh©€òqpØ,Lɵ–“F¥f ‚ñz±Ö1“IeH›Oµ4lS|"ÿ'ÇÕ.+®mõlóዲ;ô_~)¹}1Ð\ÎésCkU¶B+  §’TO#"A!À4lM2Ý4ZNXÊó÷Üó ÞCÀíÃ?²cð ƒfàÚ OTm|ƒHÈ Ô§TIpôÃŽ(Ö­hÑ·<µÌµLP[ˆ†áˆ—?TÀ@\ª¸ÏÔ‰¼¸—ZÞô?OwþdûÇ}š•4É"ô‘:zŒfv™×x';Ù.øÇî2Á×Àu7‰•€²ó\æ>|•HÞÃ$©´â·éÉ}€>M¥*?ø>¯P']>‚QÌÇC½DJQí‹ãÿÖ‡3Æý0‚‘ß”¨ñðãr5¤Jç@ XÀ62¹ò!•ý¨'j¬€×5±=PDãîÔ(2Î#Yº hŒsxå)ZøÁ‘š÷ƒVœ2†€¯tu":õ P{¼ŸÐn6®î°‡DHúÈ5³œÉf Œë +D(ñB—åœFyí¯ŠBxO9…áüä 8 Ãp0œÔÎv´.#ø6 @ãïn'+ýN@F‘ ÝJ9#ùH#ð \àj%Hš²Â¡pJ”©Ì#r«’‘L':HÉpQg}•Ô™@8)˜¶ˆ@(‘œ'‘öÿ¦SþÊDBÉ $ Å|e  È€À溂ðÒvAã/%ØË Þî´“;S¦Ð_âè QE%(tž^“Í9OÒ#)5-¢¸À¥‰6È9ÕÙCvBnRB¤Î£Œ¨¨ñÈïžò£Í=i#/åHÆƳÀ§¬¸¦m­ú0Ñ€”Íum ¼!ºF‚LT¬³ó*FO`L (¸#Jð¨l1"…I,PMªTEs-‰F$ !VŒaµ"¿I™@QˆROy:Iw¶3žâúá E¯¬`‰k‘×SÏSÅQ£TE!ò(•@@‰•ìÀÚËÿvívÀü%0wÛÆÛÅŠwGPXhÒZ± ¬%`„q¨SŽÈ}< ½–׸EhSv¡ÇP5Š8„QŒ +®Möp}AçÐ$5)ô«‰ŠZ–ü<+‰D€!‰LO²?‘DfY&NMæáºì·!ì„»^$˜ÞÁ€‹Ñ¯ÑÒu 6n Þ "zbñæ{èu›ééæ6ÛuÉúDÍÎç…Þ+/_òXúÝ,ï;/ލ«(ôMª îµ,»Æ5‚©È‹kAÞ¬¨¤ÈäÕÉV\@¬™ÖþC/ÐÁfËËæNv´›mE'*Ìab`Ë]ÛªÀv„°@ÿÃŒx+møW7Oqn#"jJÊF„ˆ•üí^÷òî‹iS©ê:42´ŽsD>ø®g‹3ܱŠÕÌ­Å©Sç–l¤þÆÊkâÁˆ{åƒL£³X]'0Ù‘˜¦–Ê(ˆk¨† ˜éJ L…¯è h5Ÿbº¦ôéšÊªyÂ'ƒr*àG¶Ô{¨G.zÇ=£´AÜùx‘D L¥ÿdDÜ·Z+°ÀažJ‘Tþ“1‰ V²é“ hmc&ðö-º‚í¹Uã/Õx»#”QKipíœ0±4™™]´Â# Lô̯C®(†Cºø‘píÒ9äÿUˆ#áyí¼4ñfîäÌÂ.Ëòc©nÛÀÓB²¦%S¢+ Tq匠6ˆPÕpŒYêþ„­¶ lûÓjç®¶½º¬Ä& ÞÝ;lmNؽ©äo ,À#ø ÙH>Ð×EŸaJývqÇFwK´ M¾¯·å;ÈË ò¾¾g¶gîÂßò„ð.%u¿­À•@”$U®¤ŠCD›ø3àØvæJ²’5Àä“+½V ÜîLL‚LXìkæÝ1Ëvºfs8ìÁ06€ô}+Ä)JQ$.ÃÃ(;†yÉÝGAJMj§i¢ÁõUð IïæùIžï‰øƒåÿ„€¢£å¿+è©` ô»J棧k­ë¶„ _ðme–bŸ»‹ú¬ V #a§Ö[iæô–%p¸p À°.Qr†€]aQÆ‚óò&­€C{xkÑ:Dcù°SЇ}%¸‚Ý74Ô!/(.œÄ à§D %×n÷µ& ´é—%£œC*|B@ÓoŸ7•3Á0Z6aÕo…aa;®Ó5°“0 §K]#vý‘ª“"Ѐ¸pHà!n5añ •‡B÷y†…'dwGBoñH†bx‡r}*x=Ò3ð%8@FI9“!” ?K¦¸ÿ@~¤"IC¡!QKˆ õZ¢<v bÄf¸TaŒ`@#{¼Sp ƒ69áURG;¬3Eq&qVøp ×p÷"Â׆/õB+‘RC$ ¸°&ãTh†¦4>•$}‡},i3£0¨(—ôhÙ×Qàñ @ ‘Ð@~¬±-¡¸NËRusn•@1«H1$£3FE0Eñ0 ÷:ú¦%Sw¯% tå+EÁ!°¾Ö€øÚU"°Q|Jq/ÊAHÐz„ wW-oaaјÓQñ`('}†Ò>äR“8ÿV}ÔÇr7’>>ÕÚH?AYˆçNÝ8Oqqûte p§B@´K±ÔZQò W¼b5¦ Qb°Rj'õ×P`% e  ÷…¶ñ„B;Z3ôð%:Àq»ˆ ˆ]%‚§! b,RäM†€HG ÈvBA*i‰’h6 ‘2#?IDqÐa““žÉ(=r3ìµm?–caP€1çáYàˆR†zFéW'™EÆ40ÒÆd% tk­Q½f°õ;Æõy>A–µ'0¦gkD—@`ñ q†n5fJÍÂ\»áWÿ8z‰ ÿpR7ÀI7•(Û¦-ãóÒW“5Ò™‡".í“'š8ò“>ˆ˜tˆãÂN†£žâ¢ ”PJ­0~B@ˆq*Áò=$—úè:’ŠÂtóùQ¿ƒk uk±#´bLóúøœµW;¡—Vš± BñVz‰ ðq6oÕ'™=Ìö£`’£ðP8敟“Y#Ôx0ù’Ö3ò’äe}á“|¨©IŸ™µ8?Fm£écÝ7TG!ä‡?¨´²!‘ÁÐ¥A–£16gö/Ðu¬ƒœ ô 7ý·…\‡0]%ŸaKÿ6óWjòà; ;úx£é 9wÜÉ+½o¢ôò1T’ʸmá¤üà†W™Ô7>9Y#á‚™:EŸ, nÕ!}“7‚«>&Tèôrì4dÕ˜cð3”÷)Ôr2¡¡ò6‘%,Z0§özb&- f $ ¬v0aå`föŠºÄj +ö;²#;Àƒ]ƒaZr uó@éYޝq%oeg¡= ’ ÔaèábŽÑ˜é‰-åUú ^ñyc'8Ÿ˜¹‡Õq™@äHôù¥x¡8C44ð4IhjˆêÕcÇÚO‘JU´.‘½BO¸•QJ©°£0ze0ÿÊ›C¢¨®ñ”ÚPŽ;'z¢o6V©ßŠ®p\ÁÉõ>ª\]Q/”'B‘,Ç6˜Ë†ŒI&(Çž|ñXи‡ÔØ3ÖQ™3‰VzŸÔ73^ª<#™>ù857s˜5š”Dú0b"Âð·©…‹S0a<³´2ÛŠôóGz+ßZf´%©¬;º´o㺢k“5Æ;ñª% rsE+g\JMc7Â\Qgňµ ¤Ð2q&úp»¡¥áC±e‹c|Ç»;D¬^Ê“wA>îs±ë3?F>?YˆG”)C' ©dEÿs³CWâ:ðz6±³…¼ÿô;¾C©_åWv¾±eiU¹†«¸¢(Š4»%tk´ò¨ðZLm£Z#|qÖL)7%Ã1Á'¡D/z”¤ww$70N5âžÀzhf[^l».1 Ÿù9“Ø!¦Ò·CiÔÑ0×3;ã^Ám’¹·Êñ~ûOÿå$Ø[LÄõt³%½³¾ƒW¸ÃÞz¢’+ÿ¾Yg¹^÷K06‚½W60KXjTg܉5ôö+²‰"+P†,LU*±VF%ð%`…7<up3ÿÛ@% ÀmäP ¤Ã,: #êÅ„ ÷ëŠZ{«øy¼W!:’•qºqXX&¹ Ë Œ0ãÄñ_)Ø}3I«ÒÁ.À+Á×w«àâ>! PBU‘bÌnü8Ì; ØX_áeøˆúõ4× ³ÃÚH`ñˆ¼¸WV¾áz;LpAù†¹'*´«È:-`Äœæ«è«eÇu0U6bøSí›÷j¸Åu &… 㵌Á ±‡µ“.(c1r»ûNu¬ðT±ùÇ`Ìnk¡$¼™í8C¶äȦSÔ)‚1:T:§‘6Vúÿ¦bfÕê{…ÕŠ7Í¢Gìzz¾£³5´“5óÀqú"|:Ãb2)£Gµ€Ð¯Œ (ä"Žmј(Ò·C/§™††h‰¥2¢Á¼š (=ÁÌ=†«ëRÌ”TÌÀ·b ²”)lzEH5¿h%f¹ß ¯§6ð*Äh”K²†Äm”ùDÓ®‡p=+;K` D=†@ŠŠ5ñÏr%§ù—„’Èy¤Gø`ž¯l°ÿZ¡ÜÕâs¥Üâž’u™“ŠšxqIÑt-¦m Ûr]Â'Á‡8¡_@ j—©›@' ;Éá¬ø:BËKÿEߺeDûÍ‘|ӬȽSÄ‘­•ÌÉQ¢:ëÔiu ‘kˆ›¨q=ËÀuøȰ ÿà€ø°ù5æ’“É.8«Ð˜°î™“;•Ök¡úiP”Ò3ntÇ€X”è$‰™Òܱ´£c"öMWêÍëËØe[¬˜Kÿ˜Ý5üâ✮éÚ³“½ÝBk-À¢ 4]z¼‰e´ò&©n¥BC²ž²l#áßÀ° Ïp KºB5™\Æag¼Ë,ùrïy“ú‰±sO0È}>CD3ž¼ ²|qd¬´‘‘œÑR8Ñfó´>°ÖDdÌÝf¬Õ8Ñy 4Í}tçàÏÂAÖP’{Óáû…•;´„ Þmtãý‡pŠÄ-p¾é›Øš¾ÏQî‘6W’E­‚@Ž+†¯!!¬K§NÑ'NޤîaRTþ »·,BõX²íH3ÒàŽör½<4mÁêåÆs!iezxJsî™?ds낎ÆY p®%ù`“5RøÃèÓ ±¾‘ÎZç-0î™a@ôÿ`"ô`@=~îõ\HL+©èTR6”ÿÀyÐ:"‚“G£€ÐwàU®Ðð"máÆŠÆn™*a^«üù¤VÏú`¬CeˆàÖc ýN²1Icú>–”Û‡4Vb` 1@‚5:Ø.Ä;ìP&OØ¢h³¾ 䤑œ—!`@š-îÌy@åÞPÂI1“52-ïÑ=Ká<·Â\àçy êx'Ë{ËŠfѸÞDÐXŸ·á«o‘}c: Ë ëc L ªª„*2Da…?F#¼ìß³gÀðQ@ô‘‰øÅ›\™r¼Ë•ÿQÞlU¡UÌ ã•Ĭ/Þf^M¨ZacˆÓž”غÿH~òYü rágˆ©M’„¨[àq}!Ì›*Áå‰å&2åùsöõžDµë4ÉTû?§'ºÎ£GOëBÙÿ¶ Áõ„ø°]Û–ø÷Ò,‹¢òð£ÕbÔ ù'@º*h¬À¾nøá|ðQ` {æšÅLšl Ì2ãM¡Ñ8œì4 Õ;í¤ÒN«,Ì*Ñ1ÇøAÄ Ó Î$«²H5Œø±G¸†*Èñ¶‹NÂ(¢ÞPª*7õ(ˆª >hëŸyèãîŸ#¸»¸Ã€¨´x"ÀK…¦ä'´À“‡,…`2ª|ôH„DÐ'Ÿê ¡«¯¸Š**ñZð/-ôôIˆŒ .F>`ÿ„ $è+‚ÿBzf™Q@‘ ›¬¡ ?ÌŒÃôLSÈTõ6HÉÍZE±(V²ÅØV3j¢€üè¡Û|¬ µÝ| rµÛj«1¤|t[aÇ$ÈÇ9ü–‹êOþ~Ò¨0ÿ±"žbJ[µÊ„èž§Þ‚²<©äj6DDP/Ÿ¬¸‚Ê\¯2÷:?K07¬ÿ ,!,º¥ •pd1`nàt„ô,“xÔ|\h•ÊS4õU†2{è2 xVYk•Í5[S¾È·ÔxûÕ"‹>Ê-Ç“ÅÈGDbH·ô¹Á‡V@D¹¤•6PÿÊ´òlÒÒ[m¹$×)þÖ"ÿ묧ÆCש¦ÒÇ]…âDdΖ üªÏÍkP£åïl}¡|r¾y™@`‚ñ¹Æ0Ã^˜6l„‹±ƒè´W-®Õ¢x,n¼¨Ó6\QFˆÆ^ 媂{È3†¸~èWŠdÞ-È™GZù¶ˆ )!X`‡©€è¹¢Zî+ýÌÔV'Ÿ¸ã®ÛqÁÓVž%Ðzïì¯`ïêsË›ªNxÓc±ó±çÎz¡$‹OðîU-¤Ï, ü·ÀǯFêÆûþgÂ"fN)21ÔPSͲWG[ÑñÃQäcCQI,„ÙDì7¶òLŽ‘Ûl¤e¶ñ‘v¶!AP8VqѲÐÿŠÆÌN.¸S\Ĩ0IM(:¹ÒwÀ%&ü£x-øJWε'®œK!å!\B¯u‰€Y›>ZBíÙp_hÊð„'¨å)$PP,‹Mê â`_€ñk¼~˸Æ(@8€Êpú]p‹¹@r‰ D ]6I2 æb@‚Ç">ZˆË6 ’$‚ d‘¬¢ÆD@h°iÔ–# ³ý‰JRÓ=¦ÄŸ3½ç\û*Jyص©L%z_ Û?^69¥g{§<ÔZþá'?™ -~ÊSžEÿÌ#`Z¤ÿa°DèÉ$#>n+ÔàO3µºE47ÿ¶qE ñßH42²ÕÈFiñÌU£‘ŽpÄ*qYËD‚Áœ‡$äB@I×µ‚†hŒ>ðbÉó¤-ßÓ¨TáÝòL»xÝ 3ë‰ä9TTÈrŸ¶Ô—5TÕr‡>¢30£À„¾¸Ì÷]cÏüáÖX9šdEÀA܈&#’VMæÐ, å˜Z’d ž%‰Ù1¨i„#!é?êÒ™mj”ˆc†ðJR…!Hß?ÞR¼ñQÇ;G JxÜJC~¡«<öØZìñ{0ÄMƒAa[¶,Ë+šBD0¶²E´ÿ–=<åCOð’]VlaDΧ>Dð…‹ÀÇ(˜ 2^Ïá¸ùSeS˜q\6‡¡lšÆ"Nmê¡ÉUàP„#lŽÔ¹Õ“©/[§USc’¸ˆzÿ$cð2B­Ô)7h[èJW/Õµ{5ÜÓ?AÐ#¤×«Óg‚Ø.“0kY‰UEÐTñJW­ŸiOT$Û­\–a‹[íc¤Ù$QDûG_ØÇ>Ó~Ñ0ºÆü†ëS5jfT§*ªâǸÏUD!®ÈÊ®sÏâbG€À]ÝnpV,Ó1„*!aççA»ÔxÆíZÀÈ¡ H.uÒ€ÄFÄ€³;ÿ¡«'ý¶ç¯öàZêDõ¸é`#âêëÊeÝW¯€H}=º_:M´%V®h{Ó§±Ð‡>³)~ê&…ô%oøðâû’ÙŒk”±1®á̈2dª(c­Š67Ç™FÄ q‹z;£¦¦ìs'.±¸Ú2_š‘õì#; R£† ‚°%@¨çàYv\ó¯@YÀ”ßMÍ­ ¥Çyýà¶+Ñ˲a‹âeÚ7h­Lö?»ØÂ>Ö]n›@ìt^(íé²ör[Òü¾H [Piÿ¡½fBàé$“aÎXæT2´Å:&GCÇqÚ,À‡±“ße"¿9Öÿq+ë6«{ñÁ+RÁyäB°@ž‰ëN€ ²û@ ²Ý …®Þrò{Â"ÑëQY.UשÒ.8Ad¿E¹o²½üJ¼b:§„B(პ7;±íÒòV¨ÂV³ék ÜÆOÈK`ì­ÿ¸áJÁvæ‹gÔûE6‘íãjÕGo¦ßý[êS%ΕÄ5î”˨ySã™å ôæÊ¸† º‹¯ã§uËÆVš°¥&žäÒwÉŸóv*ÿøë•]StÇÂvÙÿ 3³˜õ  1 è>ý²-g’š-JhßWšÎ‚É„#¸ÊÝÅ/*ddÄÅ\ÿ+™Ë¨Ñ(pñ¼áØ?EÛ‘TŽå„•ÜLg5ÆZH=aFc$=|áZE]±òè÷„ì("ù@„ë6Õ«Âʵ„•HîKæ ñ×\[ù°_ɼÜ]\^cb= zˆ€Ð빟#Àh¬×Ù¢“–À¤lÛ¬ðYº²9aÊ C ½¾PˆÀ@dh…Ø› Û€h-…H£O™˜ ¹˜ŠéŒyk#6š·7ê˜~Ó¦¸S ¸´h1•É­ò­Ò™éE²D¢Š!$r 걺b*< иïño™š¶¨¶šŠ¿J‰( H:•Ç š/Tˆ™ÃÆÒ¨³±j¬ð9œã¨ÿ :õ¨¨!ky*Äx:̲‰¼à¾7H >‹Ý ÁvK.Š@ÁqÁVy#‹Y*Š4éSÐI ßà-²êc$C®N“‹D®`± *˜ùSÜ #„¹¿Ø€(¼˜€i \›“;­ø5ak9«Ùx¹-Ó¼ù3ˆ+2ƒJø¹6Dú c§¯ $°.Ú ŽŠ BDj¹z’®Á¡ „‰´E¦¨B’2ó(Hé›±éÂ0„þ3 úâ¨/s¥ž[CÀôÑ<Žò?ËÑÈÊʶ}ñËÊÃyxñÐI x¦b ÒB†½J2R £FCG±û ÅÙ˜Íã&i üIɃÈD>b1„Lĉ ³Œ T$¤¿{ ÈBªŠÿª²žB"ä‡@W¤ €)ºÒòÀ6z ¡¿J¥Ï¨¨øD“ˆ%0̼8I›û2Ð92+Àt¶ì9gË/\9­@¢2 šàž›Ì¶ @‚-HI  ?›Å`wcME´ ű7J{;<‰±3œ“1È,‰áòªÕúó‘® ¤ Bu TÜP’€®ü p ó“€ [<‚*Dˆ8º•»2J Ì<Ø 3/ó²òä< Ì44@Ÿ«!²œøtÀûü¢(ù—¨£€h…Ÿl „ˆÄÀ A”‘&ÿa#Ç9ÆY 0 Öà­ë¤…û;ÿ)§t"ˆú8Bbàèòˆ”¹MVŒòc -B¡è ó0 ªh³9Y Z›~Ú2йäË2ÛÑúú2ûQˆ:MMI6\€Ç²©XÌ~™3ˆ€Š»y¦)”°”ÄÁžJGΘÚzˆôØL•”0ÌÁ´>2 PSSSËATt1» ¼Î!8S4ÂŽ  mEžj·€€¾ €!-úÅ®¤“6ÓèIüè׀ÔðÜËfSˆJmO ÁÔô̯fŒ²Â9׉#‚B ‡¸ ÏZR€‰¤€°cZUK!Çžr-XMÊTa´ŒÇõÊ`¹+8°”ˆÿÄMÜ Sƒ§Û\9èØƒÓPEºÓd5BÀûŒ!¹²_¡‡}à  €a†öi…†¶…`gÙN“1 Hâ2¡ƒ“‘$Ú(ÿ3‰ûºTÂ4OõÄ9öô9•œ¨^+Ô4ˆ} pCÕ(-ƒ) yd¸Öª ykÍE”ÇlzXÁ#}ì ©„¾éH©âª­ºŽ}¸á[«ÈrÂÛòâ@EKY”ÝÞ`¸Mq lm!†fh„ù‡Z¨¸p–ßh³6I–´›Ž¼ÃÚ?iÿÆh wI¬°qCól¬–L‹Á Èš ©`„}…‹‡ ‹7¿ˆ€¯5­ÿÙ½Ãxrä„•¤”-z3»YyIyÄÌËÃ]§r‚ ›ÞLÓÔq ½³‡OìÍÙ KŒØ ‰àŒû‡Vˆ †Ãð@/ x5¹0¢°_ŸZõ]ŒJ¶=Š“ÂºK7Á2,;ÝÍ[UX2[C5, ”$¡i/¤+Ô’²ÂD©~b °…¨©ÓBŒ:ÛX=JÈÁ²\ˆ2…7õ˜ADÃ#©ü£œa§uz±Û4Ei¤Ãá®¶ë!Ü-€’Ã*!þaTìÍ‘°¯òǺ»5Üà…™Ü_hùmgÑÜT¹ß¢øÅ ZøÚ².,²‰ã!ÿ²pžÀ¼h{C KƨuàÁ#ŠÑµ²}е‚ À¸5¤ ÷Uá%ÞÑÒw‹05Êà.]´ã´•ˆ½ÿ b«2ÜÀº!VÔ‹_ÊÛðåá,úâN<­¨N¦<éãá#^ ϼ“ ù‡ æàÉõ`¸b_ #²ßº šÕ_ÆØp“‰¢!æYž®Ëa£j#ZÐ@ìhµÃ4“ E‰O©`Ž ®åt@dh^ )Ê (У²ÛX[$ì7z†[z6ê7|;$T’Û¿6‰áºSèÂŽ»£¿".1®9å¿+hƒ. S>â)¿ÿŠkßÉ% Ê`vY¢ÑÈÐHOZwÁbæópŠïyŠP³–k“ÁrŒÂJ¬t]el5e\I:½CÝE²]óòšMñ¨ CàWh€†­“2Rˆxä¢Â‘¹5H<ªgªV;Äçшe¬²Dè~&Æ„F=ˆÆgʳ'@=T†e„.h‡Fb« W‹÷¥Üh^ž_ XÀõÖ¾Ç,#›€&:‹ïiË( 6ÌóH™NÆÙà`©•Ý8:éiªÐ×¼@K,JXp\p_¸hÁÃ-¥dDrá´œ¶Ó¼×îÍ…îäØk£°í„ž †‚ÿV.(¸ˆàN {€ñ e'°ˆá^è¿â‡h‹þ_¸k®ºc<;Ô…ãTA]—³ÚÃV“Äfãº,º89WÕÅfö\쩕“–‹SKZ3/^FuU…_p'p‚\è…K£f@ \ðäR;§ÌLJ–mÃaëµîgëØÆP‹ ¿…îN.îOÆÐåNëPžmãþ‡´.€´6îÞnÊ)­Yˆ˜\ù‚Fqxñ…èh$lª9‰OÂΫ®É …ˆ÷,Ùà?=“hµ9¾^Æ¡KÔc­‹ Æ'û®¯KP…^øw^8mLŒø×Vp0s1_p uåàþpÿ Wˆån´V'0n'àš8sãþð€sÞP7ÿ¬@„5tß+Æka+—ú_‹­K±3¢‡˜(5›¼8µXÊÑ¿7TÐSFœ³$ïtNŸÚÓ+Š£»_±–òKèÑ&m£Þr` p§sY7 {ès[¯u\¿u]Çu>Wpàsõrev¬Rˆ>oÊCöaWeÇÐ6 ¿_gö‚èûm…W(ä]žß³b3»@B&_£¬,¬¨¨(`“ÈxYì9 Æ¢ð(šVO÷tÒK,Í5 Cýs `¬W2ÆKHõ^ø‡6(í£¾† ù 5 ·mÜžu†gx €zPÿ‡×$’x“xøŠö­x øu¿ŽÊšx… x{øã¨…ºÆâWÀY«q_9é´È¿¢4†ô®)  2Vˆ›3 AŽwN·€Ã<ˆ-ž“ 8¼dtUP…Kð*oƒþ>íÃ(#‚.b;¿ó4ox°szˆ‡'û¢xø_G{ˆ)‘_öÀxìÀø´O{>W? €†gÀâ˵.WÞêaëÖyË?-ÿ-¬tçñˆÚ Sš(@š(7“Ôt¨…÷$ÿ9;VÚæÄ:@g,³~¯ò_p‚^‚@CŒ ØÞ¢èú°oýÙøø‹ÿ8¸7ŠŽyˆ°xcO ‹‡}ÿÝ{“Hûòp‘V¨ë,‚–À¡¨˜(û!„6 š§žÎ2›Ÿ¨­`üXl—Ž’ðV Á„w…úKø‡ 8̱y–¼Ð~ÚkêÙ9Æ"³"xzˆú^誯ÿt> |€ (ÿþ©°7ð „ 2lèPƒŠ%F„8QÃÃc8ìèñcC ôBPx%¬Y3a}€pBÞ‰,Zü;qpžŠùìEù "ý1PÄ "‚æ‹’/ÄMzôþ騨¾¢ÿ~†ÐtÂW)ý£tÉÂÙ²”|¬Àêó"CYõQX±`à+Uõºté_¯_m~]‚†²¾  ÿ‚l츱Š*0Fž ’#BŒ7oÖÃ]aÏšYhÅ yòþÝcýOÍš'¤Úóé4(\£W$E´+ÔRéÍ#nü_ñ­p­nª{…*„ÑžýKiÁ‚¡¶gHvJ+(©ò±VÕ¥è—zn“«4ÃÏð}øgO…@ÎúG>8™2fœ¸ AÔ•Q)µ"Á<ªýCÀ@÷´6l1ÙD=!øtUQFõϼõpÍsM4µv<ó„ÜúTåÜ@+¼òáAiý³%k…hTP† òw‰â?¯\âÃ_5ÙË?ï†>†,V –qôf”ä™gi–ÿ%™ýCÏMi!°ðRˆl¯µp¢T?á†Ô‡zñ¶T]I[ 'Ì3M«ÝCÓ‹RQÕU>BýÛ*ˆ5VÕ©Å–oÿ²\]\‡ä ¿D7{~±—KðÅ× .Ÿ^Y&­y6™ ¹â:æGéÇk­å´‚B,ÁAª­öM1ÁVa¡RmØá l ÄÖ Azæ‰w¶BOĆÁjˆj˜K>zJ:iµz¥é@=†ˆQˆHPo‘”ˆÊ[”.üóË/ÿÄÞ/P¶ .7T`cÁf¹«eifÑ® uIÑ?™éQEc|‘Ç cœrÞ`ÁJ/²À‚MÜ"‡ÿèK/ÉÓHéâFé?>èügV!8qf wjø[·Ì¾àâº)¥‡ÿ¨R-Y‘EZ›¶ԽݭAY>Üø¹äâoÁѱ¥«(cAöäð~*œx¦eôD4ÐÝ ©`·˜NôöAY68e…ž÷Èb"þwH{Û3Þ‚ÙTžRÅ”j†Òs""<íîyIè -Ô,—ŒÈBà"n Öç×´Z~í¨¿E È ­Ø¥/%¯ˆào.QŽð_õõa׬mÈ Ãý+AôP<•­ñÍëFÀz)&àfzœ¸Èä¸H*ÔG Á!47q/½&O¯5!T^éCÿ©Xk%9éðôñ” ¹hhúTFå.“šÔÓN%»²Äkð’× (  Rà­X€¨Ê²UÌ.p‚ Ž¥†y͸Æ5ðˆ…5lzŽÉÆ"†8…Øí"€ÃÌÝ*ó6Ë$Î?ÜËãw8ˆÄ7 "ÜG¹CÑl1©Ÿ¢Tc:¯(åQ»ÖÓ–¶­3a¯>ùð‰„ÒÁK‰:n¼×Üå$ Ò.^âAÊVp»pMT¯PE°Ÿ‰íëÌ_ Œ La?©¡ Cìí WóØT|(ˆhDbfJ¢Áw>Æ•”9Óí!‚Dô0”M U¨—8Èÿ5¬Y”‹"Õ¹§åL/:#Ï~‚®8%R¸ašVj»>ÉQ!U‹ˆ¬å­k<:Ï¿~á‚_ p›!L3ùç- m³Š¤C ²·„`{½B%âpeIþoc"\Gp5•ÉØüQˆ3YÚD5+"€„@°ˆÆÔÍÓ.u-„PÿØVOBP¼ƒp!²QκÖ&aŠk Ê hG¾æ_þrBÀP%„øà΋@Úæt2ä>÷qßü“Ƀ U8ÓßvÈÓO®“ŸÑ`³9É¡÷€Š?.Bg„Õ¢ Yز´¦@å)UPºs>å— ÿ¹D¦ž)µ/†(D Š×, Uð%0‚ÀÓ‹™ C6Æ3H.•!|Û'%Ýö6<†qk,Q‘±|ˆ€ú NИÅÕ4pšPV…&çDð zyÅ(šÝŒ.¹øº6º®dFTg!«!å:Úõ/w±ËÈ:îUÿÛF 6S X`À@ì?rjx`ö#Œª=0BÙ†L©‘œ$ÞÚÀO{< -LTÃW–`YzZ¤“H)¥­y1ÎTq#kÑv+¶µŠ>\ Öþ® |ý­^È×êhŠu”BŠ4QE@¯›ê«6ÓÍô­Ð+ÿ0ð¡°,¬Åöà{ëS¼ý!?½OdIÖSÚ“!ƒ£¬ Ô !WD>2ÄÔ;Ô1©woEX@>Nßù‡ ŠÐhIk›!E €íoæ4ŠÖH™ËRvÓßI5“‚ ù sí¢º W_tTK’úêÒ˜¦J+0Äð1 |làüøG<*h3Z§èT§n\©´Áêݘ$5K±MOÈœþ4Ä@}iôRV3RA„XqEȲrËV³ìW(8+Ïu¢s$¯= ,ÃcÎ@L¨_¥‹Ð‘ /¡é¤ªEÍÂjù2o£ ë•,#äk/Š °oþC—ÐÇNÿ<ŠAß`ü¨À¹?pè|T 0>7»ù¡nu×ʧYì½s嶈\º²xëH¿Ç;Y3•zàâ%8ÂïYÔÀÝ'!:#V÷Üd3IMZT›‡:ÍË—zíÜëƒè&`YñW‡<$`5Ó,eù \â£?I›jeá0[Š mõ ¬¥Âø… qƒŒ{ ºÑ¤7ÄÑX2oDîmKS="ŒÕÖ'Fz*1Ô^5¨!kd~chG,ù€2¨ ˜ÈŠÿxÓLfSëÎÙÈ^°y¢¦^Š.Ái69É!øÛ°¾Ü,h‘🢶ԥ!䆻¬¿’/¯(Ö/ 0¤ÿVüc…¾QítŽ"‚¥?ý¡ÉTÆahg·}‚Ü`é ½•|};#òXÝó~Èc‡ˆÝˆL"S,  Z!`-1ÑÄc2“y|À7iühÎ^á?í_«GØtÚëX_›Ê(|õÚZä8µ±Hg®âQ{]‚Wñ$:!õ‹×ü J¬ú¸A Ú ½üÃàAC‰§( §\…>ðÃU¤ž*DÔÑØ½áMj†:݇yý›­@ÌáØÞ>Ëe± RÚ'%„Ñ uÙ.DÀ½Þ¡´@ Êø+1 ¥ØÈè¦ä˜‰ÙŸ$…èüÂΩ¸ÿ‹»LXÕÀ‹4[XEX4Þ†Íßu™!­…_4¨‚•M€!PÑÂÜ”á¬á |J\€Þ xħü ‰é5àèY`:ŽãD¥éžAüaãˆî•'5d-ÄP œ;‘LÁ \õ .0 „JH@}lj =,€dÝÙˆyÍAHTXµVƒ‘Ü´©‚Ê%ÉZ ¢¥E“Ô…é Xˆç™T½_yøVp]ÂL "@@ 0œ.à>¤á?¼áÿEã3þßT#‘ \ÌaGT B@’ÕåÍ:ù”>bGcõè:öP%áíI9jF©=â=i€àÐà ÿÖ%6óµÂ0=0BÅ̓>ËRðÉÿ¬E¨_YôOyDÇ´…+Fù5a’´™“¬_q•EµÝœrýCQ%x™Ç˩ŚìŸ@#À,€ 0 ávÐ?¸¡Ðñ‚Œèà5ê$6eacO¹ ŽeÔµž‚D¡—öŽ9âÐB„ø`ÚÄЃÃ?¨0X€!@EpLEq„€àYÐ]lÝÝ¥4ž…•WõZ¹â‡ØŸÞÅËt([BGÞ%uyXq9á„„0ðã0Âø>,c3jã@ÌäÞ€þßÅÿ 6F#ïÐdON#7ÄÕÿ•ô¼ž}L…=˜cBUõ¬¦"²æ"ÞÞP-\CÈæNQ„>àB3l¥/æ|‰LÅp„"ÄG¶ô—* $C¼V/ý»…è@Ã3§BGÔh_x låÅ—‰P©ÔÈ@XöYdGDÍFnXHæÕ?çwBS𸋒Dê·AÀHÀø_òý@-Œ2 C*´BtdRªÖ¤eòŽ{fc†¡ªeF¦ª%h:Dp°Þ­:Äiö*=HÆ¯Š„dà„Füjd«ÜNdLeôõ˜)øgƘ‰F\ D̃=A›C-DÀ\èHœfWŒq2Êù›ÁâÝ ˜8¤èˆ+Bì|ÜtŽÿTv²e¼@ŒF*ué«›Q”YË ÔÇ<¨¤+\€@+ÔB-ø2Ô€€w<)4ÂEÎäÄÖäA|G†)`5jì@D…þçAÔ‡AÓ…î†ÄÀÊj)NDN+˜«Ý$i ǘpD˜x˾OÆh¶ Á5Œi¼ÂÔà@hH¬ò‚­AÇÝ‘‰.¤×|™/¡š™m!€A÷…ÙAˆ$=Þv˜§Š¨„¬|ۜŕ@ ¸Â€¨"Ã?8l*¨j ]MþŸÐ¹¡à*©Or#ÇÚ'6¶á¶M‹5–v„?Fî™0B Pî?Z®åÎåú#·p@JÿÄÜ(Ä<H ŒnÎzƯj®^Ih-,ˆÒFOW|@˜es(Eá­Ÿ)º«‡|TÀ¼‘à™¢ìH-á5„Ù\HÚœwê•Ié.zˆ@”5ˆ<° Ðm¤Ãú‚/C*œ*Té ݧ¼á3–ácþíg:„|†lv½o­0Bm`Häþãëý#þÖ¯ä"Ç@”®;õ¬;âI;Íê²,GhÄÜxFqDÀÐê£P@.hbL†KØÖWàø™tôÈ¥À¥¯ùZ©hǹBNçöÉÜ‹r؆Á¨¤–m,"ı-Åiž ¼ ðÀ$@€Ãæ­/”*„/tD"„´ÿ¯5.1‘Xl}äÔT@obÔ#DûÊï?p.¤=Dî‰p®W.q°ìèÚlÿ–®ŸñÇ€FXX`⣧†ØpÁˆ‰¬K¯9ä]*\%ä¡âÈ»…\ŽB˜"uÞ¥ñŽÅãiäÙökÔØ_è†írä Ðíô°öæm3¤ì!zÊA|Š*Ç…BT „¿r–X±ÉÚÇa†€3âÕ@XBØï¡È;}.›Hwâ¡n¦Di g}Ç–U‹QÓ°!¡Rø‹êîýr±MŠ2a¢¢pÎT*ØJ ‡O)oµY!X¸À¯¥Uºÿð€=»B=ð0hoÃúB- ñ1üz2DÂA'4B/4ûJ@Û8ô?8t— -_1#àòT|.B¤/7Féîò.[Y€X™F$fœñX€" ƒ‰ 잉NAô ¸ìÉRäBp| ÏF)˜Kÿ„ÀðÀ? A=t2øp?× AÛmFAGt@4+„C§õ[¯µ\Çu\«µ&Æò…VÀ|Àèµ=LÀY{Äç¤æ"a¶akî“´b“4C”t L@¬tiN3LžTrº¸äÿ<»@ ¨È¢´€ ý 5˜ç$Å©(±Ù®ž¢ZzíQj_ÊÜ:Ãè£FÀp6óÃö?h5Ôqó0?so-5têY÷uÉzD`gWtÄvxÄA³uv¡çZg÷B8ôäõ^ŸµE÷#ùlaŸ7b¶c46{3ФwúŽl6©Òg!GÐlN¤ŒNDAИN\ÀxPŇ ›s"EÇ5^ «D)S;2GâÕSc¼ööVH}|7Bä³'‡uüÂr¸B ¦‰fz$Š£¸C˜òz´§8ôv©!\æøwëõ&÷FãòO€J2‚J®‘kÿ®‘'¹boq79“ƒ´CŠœ->XÀ+PÀu…AŒDäƒÐý܉C%Ó?¤ØDATû݈9$É›Qüî¡æE𔳠OM:G@²É_„…c…Uœ_÷p÷@÷‡ñ÷ºÂÁÄ-„F;#4ºFætOôcȸŒ{ ¢²Žëxb^+D`c.79‘3ö©7¶’û2«7vbû,r@À‰y§Ñ A$P¸ÒM4‹8g…‚ýZä‚ßA+‚_©$!ì(xCf_H)êžg§¢êkŸËóNðu}¸‚ÿC=D·x-0’÷Jì? Á-°¤OÀ<À<4úUl9e9Š4A~CU'ØÉ™ë¡jÛAû?hm}”CJ§½BaŠÞѨà9„ã•^Xx[üDºD`ëð¶{;·ë3?„/,2€€¹D£ß xÄ› ŽÝÄ%@bw¾/ãÖ!¾3ôB”ò@àø°Ýèñuz¦¸ûpÆ«!9“—´zóo‘ŸwÄ!B‡Y¡KCÅÔAÖ ,Áý,,M…º´9mÛ ‹¼jãˆ\&2âùƒç«^Üùúñ¹¾$ñ¹(þ“Û ·+$D·{ÿ¸÷½Ñ³ä°$C” <½G´ ”+Ö£2B´ ¾„‹{}Žw½Ø?÷اx¨ƒÄ£ßÄ«dè"ˉyB¨¤à+Ñq†Õij€,MËŒÄmtG 2_íÜ¡NŠÈ¡ óÕ+ÈyˆF˜¼Ðð€5/Ù[ÜÀPø¦ôyVÿƒ¢ãs¡sû?w* D¸~-D‚ ®þM Áè_„%QøbÄ&|`è_Œ!ªðÏ£BŒ2^¨`òá… )Rd9ÑJ„ÿfrä"Œv&œg3!BþEX¡ïC¾!þÙkúOÅ?zþXBÕ©Tzùòéû'âÿß "V¬PõÐìŠ"ÿЬ«PتÜþ[P÷ß+¯"ü£´àà¿”", ìïᢈ‹úµ{‘¾|N?„˜€óWõþ|X/AÿRý«UëŸ/_Ëj%pEQ…,Jaaèl… IPˆdBàÿ¸y$'ƒ_ؘ;hAF0‰Ê†þ°æ„y5ÿa~ø“'xó†R€\ùiBzRÛD\Ekˆ® ǺmÛ–®Âºrß⭻╳ô Œ»þaì•„|ˆ€0,êAó«,Dù½ÌÒ,!Ïþ©‡³„@­4_Nûg_~È’ˆº¥!†þ±Í! jü‰¨ |»Nÿ$ FJé$âlú`º˜`Z‰£yd ¨œäé!œzâ !ž 0dVDÈÃ¥žŠêªÔ£g=/é‘O}øƒH-·Î"«­¯æš­³ÂJ0!À+,0(,¡¿"X0¡Aûê+¬"[é,ëPC›@ „SS hQº`ü§6x58‰žËH"“–“à$Œ>òí•TªÈº„¨£Ž'˜v‚I¡*ªH]}…;>X`*cê!z²óÌ(ì/ù”òо6jË>°ärˬ9ÓÒ ¨WVˆOÄsŒÐÿÔó®"“`%¦xàá% ñJB-ÅZ@â‚[\,èÿSˆD¨FŽ„ü8R‹óˆU“<" ¢‡!šàHšpʼn(…Ò•&œ ä®§î„"¶W)‰Z©œUO"2«U*iCˆ"Mþ¼eK¿µ"Z3¬³ÀM¯¼ú4*A µ+C\÷.E経ãÌ8ä_ˆêñ°ßRAíÒeFI‰Ò.ˆínq;·{$ž;!“TÕ‘8Œd{GîØ¹ä"w \å½ÃN¢š03KD¸ÔÊž2É”üÌ¢È9Ÿ»òJ„"Èú–M¼~Nú-ºèÚk…½îÒ³®À ´°uCw o @½yè°ëˆ8›”Ä~+UHµTÐ&áF N(a…h´©á‡v$UÿcC¬Ï¨bÕÞØ¤ ºG¢`ïîï¿gªÉï„ÆW¿Xž$Xá~¢Shò3׫6!®2¿\M²€Vå,v²Éçä„»¨BO>pSBÜ’ µ«0ü“_…,y!Â7! I¾6Ô)äk"ÑF“ ˆlÅs ÁjU«æ‰ŠF û‡ é–æøæGiÓÛÞ0V‰EpE"_Èl5Dö±m~ᣠùÔ÷DÈk2!°#œEØC!HJBr‘34uNBKˆ*£ÀD m,±SêRǺÚ1Yy2Ô»hG;ÛaÐ%»ÓZ¤>#€©(Íðb"´!Á` »ÅnÁ¹† ÿ‰áC|XC‰h„9z›Gj•8\}2X¡ô˜Ç„’D‰¬&ˆ`"äGE{0åLT„€>Ä¢(| ‹—ãŸ>\0–8!\ˆ)KYÀ’¦þsa£ˆÀ¤+dLBðd”PƒKrÅî^ã=zˆ3`ûP=i²]ª5,\¹E† ù‰K,iŒø&m:¤(aò(Ë0"E èDªÔIõQéI)#™®*pƒðƒLRù™ PÂ+¨L˜e¹(Àgs½tÁCCb>ĘrË0_§ ×­`u0uÝc u.¾Ô@­P”.âp“kÜÌ?þèA=~pœ¢©…ÿj,U¼Mq,‘ETÈÛdä¼…UÕ õTÈŽðƪåØí$9ÚáÂÏPÊæ|²tL¶8[­$~ÿ˜‡=>0E2}@‚ôQ­ŽÒÌrùë"/9“Ž”‹ÿ0&œ„ 3¦w)J9’ ®›Ý îÕ¡òQDGõhÆ–Ò”M` é¤#gRÕÙÔH†•Ô*H2=ߌ5#¨@Vg D^Yp™Î…ÐÜÀ+ÌR A"ÀL™Ò‚fÉ,!~B.z&¤i);Ãåbåä.à,è•l^ÞhÓ8>¤/’Í"ˆÈYDjwõøã~õ«_ŠR‚\*DŠÿ§6ä%’‘ŒŒNÂJP›ˆJT0²È&kH1L‚¬_ ’nÿ±Á¹5XѡΡóÛQ:©ŠÚâ1Ìã” pÒ‚Èú£jAD³»]©X.s‹õVœbF<)dOª¦ôÃbèdCÛt…òû!…𠨟ý ¥YÚsú"5™:dÁü)O•y’¤äl‹³*í%ŸA²[‡sËæ^x¸Ã實ĸê8ÊxèñP"+8n‚<²hGãÇ÷h¤) ‘·`gåJÏ"—ü¦Ð|‹QHjœîôA•3ÓµýÕˆÔf† òœ¦ ³9WÄ©ÿENµ:îÜM$-bçdÏ$È–3qt{Üö¶¬£TmY©+¶¡cˆÀ¬¶aöâyÌc•¸ñ?äq&@¤ rûÇ=8Àî{``ÝX÷ClŒ¿Ëm[i£2© ÓÆ¸…ÔF鋿ò€ø²&ê”±Œå=¼¨ú•5A@Ä™!ˆ¦Ëæ<-®1¥©lì·8ˆÈßVòˆ°ÊØưF.I’ÝjÌ’¼¢ÌyåI[¡ÏI¥6‚XÒ¢òX‚<ҭ[Þóþ‡sÑ‚\0‹)!Èwÿ¡?Åv7™Y#`˜\¨·P³ð£¯Nî{åýr„3XVøg€÷žs©ËXF*\qßgÿä×Íó”±3–ì U¬$Þo9âß÷ð«õ-vLì+ z:5=~2zœ€Ñëf·¼ €‡p€°±9ª\pñôÿ@lÕ’&DèÛNŸ^ïìñR»V0PÅRâìÚ5¤ð?b™¨ "jB&ÎZ‡­œ¦=jæ¾Îã=6Ÿú5D`”l;×ö9zÓ0X‹#V¯ÙðÔež­Sóñ›ñ>Äf…­ÌÏ[nøü?äÍÑ›þôiúîWVð‹_€e¤”"!„Ì€($OHg²Î踬æÛ 2cíD‹÷6¤wdÍÂ34píËT¤ì`F¦#aʬ îëp¢«fK#îI9ÿŽ "Ö)"ì¦Ù8ì:ÂoÚ@icÂWå2ôAÐvN(oN`éÊÝè #¢Þ¤N±¾K~.Àe,Vo9‡hl"ÔÖK§n³°ib³°ìbíd-D._BäÖð!,Àº¬Á€!©î €þNZ!†àøœ­ˆ(L«,oVNwK!\®nˆ“tPÃǬ>‰&,ÉâEíZ€ÿŒnéFѺêm»N ÁâXê _¥)ë¾ÉÞ‚ ¿® /D®J` PÖðþ cm3ŽŠ3b _€ [­3(x*%G£_àöRáþelÿ~ ~àþ°†`mœ #Nen6B#n‹Î¦SB!˜#!>âÙ(IÍjTdƒÏ8#0«¯|â'"ó–Ó,‡ ŸÎ .‡»ôáÿTÑ-V á QÊ #â Ð- \-ÐEFÆÐ‰O!‚à'ð â&Ná†Êk&¥4j¡´À,…PPÃRþ¡„, (@ù®ÝÌôæî bÎvkƒ¾oü®M(¥­ˆ@ k&  ”òñ®‰¾hæ—n¬ »þÁ ðg)|ÌFÊ[ÄB?|F.À‹€d1"ÀE?àÇ-,0µRíÇð^àÀ€qø~Ç<ò` Íð;£wÿ¼&4R’x`R5ÌÉ„F4HÈ4,n2å|#{^Î1“ˆât«…ÞqcHÌ&Vë‡ÐÊ;&àñnG”’~¦ò'¨«YœÀ*£%ÿ "¼å ògŠ©Ó`1"ßb÷ð¸ró+(ÀBt‘¨xQ$õ2!èÒä’ø6’.ƒ ¹†G~çÖJC×LD;S#1ÃFD”*ñø*¬1ÙxR!ÒQ3](æÀOµr#}nÎÚ¦ƒH„q` )¾­òª‚vŒ~¤¢œ —®ZòO± °—:Í["fT"y³?ˆD Bù^¼C#1.Â9÷€•“.ÍÐCÄI"`Rÿà05¾L×Éídס&ÅÑ’* H,,=+Sµ˜ãå ‚wK(£Í”€¢æh.(d¢ˆªãÍÀG,O®þs=Ö@³Ëéa SO,Õ¤6R±Æ8¼ÂA¢.MÛ,”,Ôr 3^ÀDôqø@áèò#ër/G²ªÌâþ¡Ö _"ÂK(X5L"– á|S«ÈQñnV.G€Ô{|rŸôÌΠ®"ž¥tÉd5ËÒþ>P"ÔÄÕ„L¿‚hÌ2!ÐTQ¶í!Ör<þ¥3u$û’Cb 1OÇ Y/NP!" 1 Q"JCZc’ÀÿVƒ5 µÂžc9TN9– ÃP¥Ùzè#Ò:ô,ÏbNµ†b($À¡ !r~BÖÃò¬”ºô—¤PJÔ$L¿8DÀ_¯>Ìr¥äDÐôÃ7×’)tqár.Ùøæ” ƒqB4öðö@ ûerPÕÖLHd¡UÀlÌ–FÙ¬[Í[ƒdûÑ'?b=;¬(Ô(ïl~Њ·\¢"(@^>`5÷Ñ'|ÂÆþS=v,œ Z€¬õø•s:ÍB`,nà RµÍBEWuu ÷ëR.}ï9­ P…Gu‘mÏö:BC"®slrÍ´.EP[çF90 ı[ÿ)UΈs j'9é2>Àà's„¶Y~ŒJé'vÌfòÕ!÷,^[h `Å~ü-€#--bÆ®-U$ùRD©Ì3† Žo<-ö3õw€‚3d!nå6&—!"NÖ°s¶~Ä2+µeç "v(3 ÷=wcdˇX IW 9â~ò§õ„£_oUjÅBt§ö[´­t+”MÇpW_À9çòè²kcMøÀélUTEc©h÷:\×ÝvPY´n ,!äŽnõv[#âx ø`"b`3—’VB)wQäIb´Ô¯PNÀË_÷j3·"=WkÓÒ-2ƒ$à'JàWƒ 9ÿ»vOU—¨JÒ¨€‚vdÕ&\W~q÷CTt9ðd%‚ùPvx a9@¢U,&!ÖfÙŠ·2eÃE˜9b­‚)Â7°©^~ì¯è§J—â~nÆ‚¯N¥ ™äâ_%"„ou„qBFQWç”/‘qN/p3.PË$"0%¥_óu­ 4’õ: E|8EÀ ')¬ˆ[€3U–8H€ty·ü ¸"Õdã•°tL&ÂK&‚)¸¢ ¿[:M,öðƒK9„]bJ÷ØÖR˜u¢9SX#5£O‘Šo77VTz؇Q„µj€Â¦GRCB‘7Øh¶3(›×’ÀÇã³ ÿº›¾øˆìGŠäƒY,WUCV×Ôµ–¦Öõ"cL Aèå g„aÙC‰Ïá>Ä…Qô‰íø;‰—Wî~y¶`WPU¼ŠûPeƒÜñ$H"Vr«{ÙØ"š_Â+°i˜%V"B‹´IV‚1˜>¼¥>øPœEjµws+ ÕXà¢g9›s$‹OÖôÅlë:„R,E~×—iºáì9$@‡&Uò†%è,¡Ù(½Ç{b¥V„4‰"VxzT¢ |ª­ÃE|ãvRy„5™%>à–,W9š?ÄÂB½rMkU¤/88$[0ä2VÚ!Vú!ørøŒªAˆžy:"ÿ\wS!Ÿõ!øùpû¶‰Wm$y¹/Vœ3SH”š"™§233yêØ2õ©7Æš©š¢ËÔ-† ³¬Oû!6š_³Î¦³È¢B÷P„!Æ+ÒYŠ-#¥`}£':ù”k: ÷:"r×yk÷;E㇢ØF“w#œã[¨ëæ#VbÎ2Õ'WÂG_â`€r²1ÕE\„©éL©w„45â~óöZƒü*)¾ø‹ÁëõþõB/Ô¬e[N€#bb‹àZ'Tú0€®[zu5c:CèŽù:—u™— ÙEqÒj-ÂAâø û°;l'K%U%ªáÌ{ª[z”ZVž:3ÿc%¬ª·xê"|öö %pñ´»HŒ=¹õF:,Ô7sÓBË­­´)kÆc¥üôôÈåò#§sÃémœínÚZ[Ô~;Â&‡Vü´|ͼo=iÐ;¬=ë,Iœ©-;¡—š4%€Z!K …Å«¿Y"jÛµrjÍÙ+|#‘)¾úÅBæÁØ™ám}w5¦k÷› |n~‡DÆwû·n‡`‘@8m’o3} a==Â'\;Ô'üä@¨º§mÂå([©½Û²gVµ™Ög0Å!¢²;ŒŠ áàÜ¢w&¢ôRU“mü_õêæ¥Ï0£‰äÅp‚<ÿæªýŒÕ-[˜âB´l×ѽ&‡ñ9¡Ã&"Óû¶Ö>½Ö,]˜Ï#:=!àÝžŽm'ëºíÝÞ9%šme…eW}‘55¬Ìœ¡]oÜüö€ƒ² ¬m—¬™¤ÅØmw$£/K1ãÛTšÞèòzõ›J²–y„¸¡¼vG…þw°Qƒ0½Ó…ÓCÓ…yæƒÞ%P7BÂ×9 {T}Þ¡› -³ª[‰“Ú²™-feæò&¡­z•Í#°‰^D>n©ê¢ÎêVâÇ%>¥´H“•Ò¸0Þ'X@Ž@nÆXë²WI2»ýÛ÷xõ÷32pD’ÏÉÆzÿZþÜÏÝÓÑ­§¹q^"Ð]ˆÃqœãØ´œñS=m¶"DH|CcPbo±§­OHjËÍ{(Ú2®K1:g|cëá,*=&€  õ%¸„åáì¢ãB:ÕÎɹýÛíí:ä†3nÒÑI`ø^ÞKEæÕÓk˯œÔ)\m"<Õï©ñ§? £Ûn&ûw䀹 y©›Ì-¿Kb‘)Ú:.¤Õ¹;¤”º.ÙKr!).:õ9¹2”Òõ럺æ¡Z€!^ âß¿#!ñ‡À\5tµð_½ˆ+&¨ˆ1£ÆC&Yø±"D‰õ$‘ªVE_*)⦡—†ÿ"¾X³&ŒkÚ\hèÂLpþ3$©Ð ˜:ý'áÓ J%Ú´iÕˆQ£RÀ¿Åü3Ëæ r%$E:Â<óè1¢÷/Åø ü 0Ä¿èÉ8·E‰_ÜûG@  ÿ^á¡¢› LèêóƈGcl¤±ÞÎ… êu)ðâÄÏ%A T)ÐK•H\ö6„Ä'Ç£!}~ ‰sÈΛ‡øDÜxR «V4kѦW­V˜ ~áS¨ÛÅšŽøÈö Lš@XðÜ»Œ‡˜›Q0Á÷/Q™<,ÈC Áþ„+œ ¤@ =$šÿi²ÅvžiŸµÖÑEþÓZˆ•Vψ'¥’ÊB¾ü£Û?,·rGýœuÀ GcN« ^-EQR5åS!±yÚ)9$Eãe¸‘ì½%áG×?uÍS˜\„ÍU˜|t-V /$òüC°y„e˜9˜„ Ý9Qh#eÔkPò¹PI‚~˜À}–6ÒN´™dŠ*þS p ݸZpÎU7\=íTãR\éTv>FjP[m•SÚq×ä§^ý©‘%‹p—Ô,4O® €Ÿ•†å<¼ ÄB þsì=þ“ÁdœD°µ ÝùOhU‘h¥ÁšÚÿE2–æá·Ûz8ˆ'¡ähn+R ÐNKá8ªMó åcMF†ZTPM•ê«PÉ+UU$)­ëL‘Å€»Q;EA%A\¹žÀÆ )&Ð Š}¼XÆ-œÉš%ËsÄ@QÆl³¾PB´×R!Cf›m={RdîˆÍeI•@wç¤x ƒ—Õ?lMž¡[@ ±Fg¢ŒòciN¿Q†`D‚àÀ?¾Ê¬™$PûÐâÖZÛ­l$š‹<Ñ„NAi­d^tl³Ê´è(âFQR)¥UJ€V¡ˆívW»Ý)pvq `Ä&6©¡M`ík ÅàcáŒô¢¬.$2*#adH(¸Áa@•©Ìá8s8.†ÖâA=}«Õk*xFQ2Eâ_Däõzšm5ûÝ]³•OÖU´¥mU:é$_A‰ F….B!KÊürŒamÅzÐÿÜÚR©oSÄèP x3Š¥WªPÓpq´¹c.iéšP…Ž Gç¡ íÁ–}w#j: e Òî ²-•åN„ó6’&ÃuÆ:ñ—½wµ¯‡ï[ZUõOµòì‚5"ƒ59h'‚êvÕB%Ž¢d‘p"0âÊk_Í>K¬PŒ0®ꆉ¡t V„52h±“ÿÚ‰‘wÆèõ‘r:ñœ®Ç«…ëˆÇ/)ý)ÿÅäºñ×´„•OnqŒG)þqù'@˜‘öûÝ|ÚuabþŽu3B‡#·9"´¡+È„u¡wÆ£©&’P¬eÒ4ú3rTÛ ÿ¯x_™®t êPt] ™±Jdä4ÖH§÷âoQ²Æ*p}2¿•‡GC¨YÔ¼î5¸ºÐ´RG©Î–´±ÁØ;$H‰ÖÈíIÙÀ:,Øíðõh¤`íó AÊ*a J›óg«Õ“Vàâç?HtŸ›µX×à f·¯{[8)¼›mÌs‹fqèÕc#™f'w¦ÑÖî ‘t#Ý£ôÕ§e9iŸ¬NuÀ»Œï|c„µ!ïŠT'î-O'8–ŽWïÚw«t3Bº ŸÇÂGSŸ|_`0iÅÚGod µIQ·©W·Ãá© Žz „”`é$P V~ ļ}ÿR8Ä€gΉ´ ct¾óɦèã·;X×Ìîç~* +ÝY%^ï;𠤔ÿ`D @{÷Üýé$`ºûžnˆÕû»íàAÒËÛ`OMÏ^_ªàõ+Ûñ¦8Ì/PŸ Ä¢ ’n_‘à‚ň-³D[Î…ÕÈ6YËâCÇÔ%bT*¼Íî«„î“Ï4¦÷„‡{OÐÎÖÈ\œ.ä7~ùà2+¯ÿqÌ.¿žý|D\a¥àýè‰: õ¶‘ï.§g¾ùÏ3{C ò)ñÅÔãÎ\,ŽÄJqvð½'t‹>.tß;h‡úÅ"€eÂBÅ¢%ÐdçW…¦ÿ€¾V{–.']`%Xq!w˜rQçwuJ‡wñ}A7Qz øé'K {Øsñ~òe%À·‚õ¡;xƒ €Øw©çT€%p‚%aõ,èTVÎ'j2u*Aƒ™‡€¡}˜…}GJqá=1uQçr.V¿T& Q\ð]’ Ne/À„+hGFV*¨ŽuP{b"èõpŸvt5x4ø… A+ƒ`XdhJE89GP‚C¨w' wßå.pRÛt/pE ™øÀ€²ä„£A[²„ YT{ŒTƒçfƒø7…R‡n¸nêæwõ‘ÿ}¾ò+·nq O÷W)#„ÿ ‰D¸ZÎ ñð#`c´<à‰N lV‡PRŠy¨4¤y`±;Gw+º¸nVÒµxŒÐƒá(†}7‚µ §7–pR‡ Ȉ¼ ˆÀ“ƒ7$- ‘7t8sðX£HŠxèT©xÙ÷I}µzPGJPWõq †èçF‘.çw¶t…È37kòK%s%0’åwP (éüðù h.ûðCàUg‡+ `pØ`a5R“XÚ‚3ÛòMX4ƒUÈïwtWw_XˆåèR‹ó°‘,Dz∾€G ^Yÿ7vƒ|ªGŒ+^ PàöPùPmIgô»%è0C@-qˆ<,HÿøXÒ˜!Ó2? .›È-;S{ùçI Y‘GטŒ`Žæx‘OIJ†S9Js‘•©·Ž£bvS2fØ1Å"‰É') uçÑN ¬I*€ö`¥Gt@¥lö®á Þ¥`w$Š` m‚Ã)K²ðˆW !ƒ´-PB/uPˆEéwº³¬ˆ1'wÛY‘X‹™nX’tŒ¸¡ÉžÈ•Ÿ‰K7’#iap„á’¡ ¡@ö—2Lm  vðÿ†3ÀñCq®àQŠgGœ€ XP F d!`*¢‰õWç#èsCéb39Ý„y’öSVr r'w]‹±Îö~æY£?Xw£W©—™iu´&s’±]Ñ<óÀPZz‚q*üð,ù*ÐÆà1ÿÐ'àŸó&¡ †wGy 1Là¬ÝãQ7„‡ÆÛ²×™3…ú§Ùb·ÇË7Zw4څ÷®AJŽåÊ}Á ы¤7zXy¤%Œ!I¯^I¹…õKÄ,’áNëxÑ a ô¿ÆðŸƒ±&oòÅ bœ080e[ÇúÅYœqb Î ²¬ÿ—[,·#kG7ÙŸ1-uM½|M~Š-3À ³0*Ì'Ú¼^eÌ;jˆŒI‘]ø£“*ÂçÚ¸'L†ZÒtZBJÒž6LÃ,`¯(ó°%L”2G°ê,Δ¹ùI—ºa°xq,#8…“Lcaïsý«ÅÏ2· l¡tj¿©Àw”s»i«˜Ì€ RŸQq\‘U”wÛÆmü{b¸‹uì¨^ø‡è‘äyÇbx™Oç‹:ZÒšj€|ÎuDà TÎ4L…åÈ¥?µþi°Eý¥-@ùŽÑ,*”2ú&FðL“ 'þ§Ñz¡LÿÑñb¬<§y$CkMÎÊ„@Ãb/vгœÖDѼØDDI¨nHæS-¼˜y?jˆ%̘4È…¤´®áÉ‹˜ÉÒaxÂ1íÍñˆñˆè,=*V21­Ú’ö°–a°ôÄôðbJLÏB²daFàO\†§ ‚¬)óÊÍÕl=»¿äÀÔR u8½Å¼mÆÁ„{{'[çãxè8ÇͭÜ3%BHÉÛŠäÚÇC[™¶xßë˜*÷ƒ«gw$€Ù}Ѥ;< Û5L°Ap$ô7ò ‰1ç–+ÔñÄ^«^úó@ƒ³Êr´Rí eËÚq:­ûÿ¬-d¡´Í±_üÀ}ôG4‡lëQ¼MLÈÖÓòGÞÕØôË´ÒÌÌz+Hm'Ö4ƒ'n‘âØtüÜ7‘7Èp>H£œ™tîꮓ¸©ä›F$èK…5¾¾”¤®úmYÿPäš}Éx1ÄV+ăñ,Ð&•á&a/Åv-ž7È:¡³ÌÖúÅ~äÐÕòG¿ýÀ¿™Å&ûÆ%ζ²\á…>#1³ˆ#Ž5Ì¢¡¢Öd^¨˜|®@‰Ëƒèˆù·®ç9zA;½hwõ‘ŠìãèÞ€³Þ|3‘,Eî ÙyqÉA«VÛö@Ÿü,Gàßàź±›‘åApGWŒÿ½¼¼ËàøöàÒ„>gNËÔ RámþQ̽,ÜÐ«Æ ½8ϽÑÃŽ>äJ•uÜêjŽ…;•æ¤AꃌʑN·è½¸Ø6å=>]šaNë–™¾–•¬Ÿú¹ŸNpë¿nò&¨n`¶CY ‡qê±Êš7fMÑlýÊf¼ÛçÖ Ë„j=ìqM§èóëÅi»±.˜ ÍÜz¨Žƒ·pm-5;|ÿ—}Œz™Zuçö®7~‘2ð©÷@Îæ\î;íÈÿÀî‘éïËŸÆÐH-êZ{Õ”AføŪ¬‡sœ¸m“µ›à [߬™([€ô!µð ñÿôÈcM×DñqøñÓb¼8ƒÆŒÃÜ;d·Î×Ê{I·‹ ǃsgKßmšq†Aà îözóéM[QPíÞª¯—|lBþ{ïÿýHwäµ+sMYÎð´»Ö\mGÖÀÏøQÞÕëÖbÅj Üm ñÁ¾ÅÏÜÁ¢rŽÌ¡‘ö.ËÑè£àlƒaU¼ØÍ<¾ž_¹7 !ª!ò7LOkäPßœÛé—üóô!&ƒ'¤\ôFG?±Ðäê½J“´ÕôjÆ –æ öõ®ž‰býG—O>®õÄNì©-ÒDÜÓªàÓ¢-ŒçÒ¹öQïß?ÿ <0ÿPáÂ>„q!¾Œú÷ˆ%Xx”¨PÞ‘…GXü;2òß½{82Ì¡@Ê“ôæ»é¤@>'öèµÑ ¨Ðô^È€áÈ‘ ÁpaH \q€áÅ®‚`=à ¡Â„a&<â`¡C±XÉþ;` îÛpÕ¼dìA¸rÎ5xvì?bùÂUÈ÷ «z7&èø0ÁÀN~ø2dHŠ2+NÄ€ÏaS†'–ˆÈBÞÉ”&i®xäÙc$p›À=…óì9aå_m~Ú,N/ÄDÅeÕ(o.Ìâ«WH²²,¾²$Ro³0¸¥¡4ûg4Ü5ˆLcH”FQµ”P2%Þ>SH€\lH¶%ʧ€(v"t4Î8åæ!))Â0È ƒŒx@*ªàÁ•¬¢žðà"1ÂT(­ª**¬-/ÏÒK>ýìL¬»#M43H®¸ø Í‚Øtì2ã ¡¦„C 'Ü!|šj*Â…NòP$L‚m¡I<‘¤™BÂPÄ›pÄI!›ljA¡å0À ‡ªŽõé†8ƒ ®Ê¨®! ¨Ë=¬ÜÂ+Î…Ôªªªÿ„fU«Jþê3Ë,²àÓ3Ïzó0,' ³‚æŒ Y8ÏÚ¢Qpùs3ŒBˇB ÍÏÒ¢IÂEGbI\˜ýÇ&àBêt >(Až"zÁ¢  RTìꪊ‡©Äòu3\?;ï<»j¶¬±îR¨°Õ\²‡æóÊ41&öXÊêTì-âó!C³]È[oIúL© =™!Ôe¹ÄTBéf–Wd1"šÇ&}þ‰çÒ(œ(J^y!Ð7©B’„!.pà‡²Õ%«LÈWˆo½•½ê"O/‰RY3Á>“Oz¬âùF¾ï ¯¬¯~mð ùÂóê€0÷T( !ù ÿ,éÿÿ H° Áƒ*\Ȱ¡A~ü-‚kƒkøþ!¢°®Q~Xðˆë£…ZQø'Aà„1úWáƒ=F7í!ºÈÞ<™ö>Tø'Ñ?Fn(Õ(°ÂІ(lT*U !C%Th‰ÈÐP­>}™tb„Ž@ÄoDÛÊK·®Ý»xòûÇO__~ùë“XÒ".JRoXLÈÉŒ¸€Â·áG„Ë+¡vŠ4¬ÌyÿæýÌ'64½ ºìê–-izÝ)pÁ«š•’°s÷¿ 4cB˜0AÂ6,H<ЃѽøÅÛ;ý_õë{ójßνûܽùþ…ÿ‡ˆˆÇðEØHä¿øHâÂg!•®êŠHìO¤1Ìs ,œ0O22Ï­°•Œìô”@By¥•!JU¶"\pÕRÞ&q@Àˆ‰Œ\€H?t–jLE×^ÒÕ8ÝÅãÝŽ<öˆWv4 Ô×>$·€D°ßÿà"„e1Š“,GA~0…Á?AýSh7‰Æ‚<þ$Ú?ô µblõ!@ETX0¥v#zxà ü°Ûµ‰ÕX]“KÅa•äÊ¡e_q„ãAÙù˜W¥á ØC™ )> ªÝ¦|eJ*DÿŒ0Bª¥”j Pÿ²“U^ù>޵ÒÊ?ŽÕwå~†|Á–óÈ#f‚ˆ6à=dþgÏQa­yÛ ÎqŒ8õrXMðá¶? %ç@+á¶Òˆ#ÒôÏ•K)GÐZÑ­Ê—§|é(¥Ý™Š©švÚ¨Bê+P`°¯¿·Å€ªÎ Ø_‰`Û +,’DÉ]¦ë}³ò·›!œ( ™'”p#ôÌ3¦<ò0ËÂ?1Ð)–ªmY‚@3…vRÀ·A~H“êÝùÏùYeÕm²•Ð%'.¤•ZG©½“â;*A#$jDL ¦iÀ7P`ó¼)õõ+¤úè?~!°ó$Ð ­ÜÿЊÆ_i”!úÝRXZÎSÂË)¸ò?Ès”²¢Un&h,³h¡ý$|jÆn|ô}ô•ù] ƒwE“Јðyú¶¡#²Vªªê¨Ð½Zs×µCÏ=ôiÛ‹dxhs6Ý¥–‡û¼|Etƒò„HßÙ‡ýúÀ$t>Sš  På'H~Ä=÷hà˜ÿ܃Á?ë!9ì¿|怢fÑrXY×Fn…¥¬ëtH¸@‡vc!¡Tà¢ZðaVÙŽ/n!v¬FJé®wtéTÕv÷P¯UÊËNx ½‚TŠFãáGܨ7¿¬< ÀÛ V0•]½'ë²Mÿ °  Õ„!+_¾$ rì#“<ÖGäÀŠøG ¿È Œ0Ÿ< ôD‚ÀªÀU(€|´(PÄ^;„š x+v}Ûe6€´ìE^2š×ëEÈÐ.˜’‹Qæ=€õ‹^f{ò&$}æ#S„¸åm9³À/C±`UîƒéÏLrö2•Lr÷È=ìÇ‚{@[$€@r \B®ŠG8hò·  , I< l0ôƒø ÄoøA¸ œ‚G#JÏ?,s´µ4¬jºë`ŽöÂÂCÚ¥x Øè–ŽM„ÓTÕ à DÌv [$ØÐÂÿ&YìVõùG}l“,Ñ@à+0Dâ8×9µ¬ŠYû šÅø²—YÄ@ïq²Z2ëѺŒj°¢¨,‰Qñ‰Ïúö ”ÈK?¡Ð.P.¬X†QU×ù! 2œÕ1ç¥Ä¼MjjB®‚¤Ã&©BãfS6Ô‡ª4©I©RÏn©Ø(#p ´â$š€hв¡‚‚ÆdbY,eIEùAÔ¢á%/B€XšÌ–G`A¶¤wƒš´ä%°ËO4ヌH“MH@‰J@‚Ÿ§7Z ‹n.ž¸X­#ß u!üú_Ø¢T-z3Úø¡Ú ¡–ðKvÔ#ÿî¤bLº 飀.@D„@Qú#šÅ™ï•,3Dm©K-f—ÐÍ%ž¸¬2‚4i ALÆR”•l>MšŒ4Ù%±²€Œð5/ §f¶¨V‘\I_ˆdí³§gÿ5Fò *0’µ€7[ÙZ¢Ë[þ­¨@ Kb]²¬e´|Røñ›ýCs?Q#Ò¢òÕˆ÷hÿÀ‡ë’ØÑC­ØÀ6‘Ô Õ EUÔi¡ 9Hü’ÀÛ?ÕÔ;Œ¨”DÕ[n·¡«Æ 9'™0>„¡€²IÿX)Ùò2•àÃbÙür˺NÑ–Î%ˆ\9ÉÅe'#Ÿ‚ä1¿¼‚5+!TT¤’•öͪӊÑõ4$ßÔ½Lš^[¢Ã;ÝyÀ‘V¾Ë~õ¢)£èÞ)DÈ KõßLÉ–nªÙ‰Ä|À“Á\FÉŽQ³3¹ê«8kAÉ’œ<^P¬äò™Ðö{(\-ºEW±ÐSÌœF6Å_Ò²éÅߦ&¾a¯)¼¹ÓV0´’+µ"\ï¦ÏÏ2‚HÑ‹³õº×–SM),7d‘ÌSHò’'år®í©·ÖÅþa1ÕP`>£&Ü$Pø·["âX+°¥Ì‹Š@ÉTËT4ºÿÿÈ@1À²õ!º@/û³·Iî9 q¥ëZ‰4}è4`]¥OgAK‹¢ ŸøÑvò*õ¾YËo¹„Ö!®ýKSüR6>ÌS{) '3˜0V±Z¨(ñJPÄI—¹•c,Φ ˜ ¦ÈþÉÓºÖº–x£$«¥.U¬Å_»åÌš»²»}mú‘I&ÃY‘ÑQ÷ƒù +OZ”ÌpF­K$£˜’(1)‚({pËÕ)À¾›þôºo( ýØâO¦‹Šê~ %·Å& l J—9û{Ja¶S Ì>_µ-™‹òsYhLv„çVûù)÷3,©ëÄXŽé‰ø‹6™nC0i29ßÀÿG, ((°8ä£HÆÛL\üC2gñ@½¡g‚)ëãF¬rÓ9…—¯äÕ¨–)«õH±ø”UF‚QÂ1¢Ä7¢´v@tïñU¾2p2,)Ólú£2±ôw+b¡F%'r$V#§>÷2.“>³„Wsw3_2íQ~bí‡TM¿!ƒ·¢dBÇ&­€S ÀÀGô&›5e›Åtñ zMTNh0M¨5jc6r{¨BZT‡T§R6z6£7AvL°$'7\D»ÂUËq(s0g,bÂ\ug/ Êró#r*–µr³$w†gKí£8³4]‘£9^ÿR2§¸p ¸Ð @#ƒ¥];ÈFntï“–× l_ãÄAø§#ù  áŠÜ±e«ÆØ¦‚N42q³b1#D¸ Jp(A»g vìñC·B>ÉV Û–>¿tÿÑ9ÊâPƒÈˆøÓb]dhôcKóS|…|O$ œCD€ ×0 â7Cv(/ñ@Èa{rCðH`Aˆ × á#(Çò8xw\cÿÒ±dK†Ö‚vX?³Ôr ò["Æ×p 5(Õd@÷Ø ÷ÁH0XŒ øÐ Þ„„š‚5¼óN(ñ`*å$)eI¦5€Rætg3B¯¶òB¬—TÑÓaÊ’GBIÒ1û±½¸!ˆ ÀT˜Þ#¯ö-P_‚&a”|e’"Ö2UEšƒD‹Ægxçr0™m¢8 ¡ HA!;h¸ð øà&ÄqMd;ÏônH#4ñ† ’±ªÁ6ÿPù¶Yé„`™„ÔŠ|‘–áNfjÉBp kœä…myoº=òb1g!‰Ð0q%Y8úpbdÿQh¨’ñ! 2wö)#Äw-sbÌ%r’“&(Ã(†w‚3Åçl2qÏ’&a‘ý#€”¸€vdé¥ZÁâ¢–Ñ †€CðW‰ ? ñ Te8bœÔ«øB«(öÒ±%$±1u0O¢‚T¨uoYO"°²b˜X™Q8^±aG\œÃ5!V–³8’I$F,3¢VtUxp§,-Ã>Ѧ?G‘&5¹|–Ó8HaÞ·Ê$ 0‰h-éÅ®C+¡+"Iûˆ¡ï}ÕÁ&zñp…#LÇ;å$¢K°*°0³H)Ìÿ¹œ{ј×e]Özo[”$hh1%±Oñà±JÑ(3fÅ9É5&?ñ,èC2#ÓÙ¨Kx²Š¥5–# 7v>MdˆqÖ9IÁG017àpaÀÑ Vᦔ4ä7ëÒÈ€ £ 7«â›<õ•–«GHÄZ† –‡z\È–rQ°†"†|c¤¶’Ã8 hÓ¦KäˆW_k°/¶“uUwø³ò#K{6·òÐ<Á%Ð0²jdöXû¡‘ö†,ÿ"„£€ ø¸ú›Q³ø¶„œU³cù¾¹P³HTèZ…´6kâ1,T0¥ë…#´¸òƒ+¸ ÖWÔB-Ó¯WúþúbŒ&Ÿõ¼c’»yæª|×b‘½Œ¼%ø)h2†VbÌÅr/Á‹5öš2v‹¼˜’¸ÁOG,R ãK¾Möš$Š«#%*³ûö¡’K¹ñ ¹•R¿OX)% [cãZÒù–ÇY5Ëš{‹g£<­ò*#ÿ ºüê°#9´dhëüoõ¼’c>‘“Â%–};ÙÇÌhuõD/– vlÇ‚Ì\Æ’Ž7ÿ(œs"ó8(Fã·WáWPãnÒ$„¸ Ö0§f¨× ZºƒœHˆ³zT¶e~Auñ´¿’C™)#z€6«Zª‡‘ƒÁ$! ½bŠY-8/óD²„Áìskµg K±$¥+6¥ñ3(Vw…Ç>ì³s›h¸Ê2&ó21‡h²ñ$à%èÈ3vâ]‚#†¹nkäU#›ËÐ ±5t#ê§J|¿ö¹a0k–5–:âÏ.T²4áVì*ì+¢§6Mq¿ãÑМ²)·uì„+à·ÂËõaMF\0 _b€™}¼Ñ¬åÌß8·€ 9@W&EÖÿ¼Ì½KÁc4í9·ºêž &"£8ÖØC1R\±%u!Xq%) ñŒ•¡ÃS÷×§û‚R8º“Y'¨âŠuËS>[¢§ÅF¿«Wz¯u‘NÕ6³%PÁ–åYP_ržzK(Ý׿g…b.'Uô\$èªPÔ\ÇŒh²* -pKÀ-Ð9^[æc2;20§?D4gPQ²‡)4Xq˜CqC`É‹áÔË =}êÉG,Ðó*j56+´÷BÊ zÑ™Ð)Ë’ûæ f,¤Å°%Ñ­)Ä- ·Ç7Ïm-¢1¶âzÿ=ŽÉ§KöãVy¼nåbÉÕ\͵gyØ\²ä)E];F’sg:‚guÓ§Ä™QMj,›9§+Z Ȱ ϰ ŠI-tÄú¨YM7ºÛóô§ÝjIÈN®.{ž÷{¿¬eÐfIçl¾Å­r¿bB•ü 1··<„'èÙÑM'%0bºÔ¼ž)¼ÇLî]DãEé€Ö¶Ué~Í; ïq¥#FÁŽIÁ­ôMêaòØ•S”qòMþ¨Ñ–ÜL?|åþ]@Fѧüà ±ŠS]œØ:Mèy¬x#žUÂÓ¨ÓùÀÏ5‹áqN`{Þ¨“ʼH ²ÒÝ“^Ú庥ÿ2€¼Ï+ÂQˆÉ×EÍE‚*&ÞfÛgÇ<Þë»E/ïÞ¨lðã°H¤2ûùò`2/9!C°¡Æ€¥Fkoîø¸ù±>­k±&ÀÚ6b¢D¢õ¢#©—èۛà ¹ãô­l=u}[PÅCq´¬/¥ÁöO`¼¹Z þ¨Õ~fbw(!à»ê85Ÿî)]‚Ûô&ÜgpÂ4r@y=ï?.ä÷>ùÊö=äs»Ÿ@, Û»v\9×4 -áWjt@Ì4¾ÀP§`ߎë1_T½/Ç•°mñúGq.¹†Ú5&$—yÚ˜¢R‘È6øÃùTóû¹“4p_7ÿƒíã³qýéJ,cb±QÈ—Ì9ÏE½4mȬK/}/&wÙ·-PÞÉõØ‹mB,þÍ›gïÃÀ%NTøo༌>Hø'¡Â‡ +T0„È! ?p9¶lÙ³g×Fý@4‚Ÿ}ñdò‹G“æ?~8kþË÷OŸÃœæ‹ç³f¼žBùZ ¨P ~ ÕWÁ'?~ù°òTŠjÏ¥8µ†-P¡lN­]ƒ¦ +”-VD"n ApÞ‰ú>Ìø¯ï‘{ÿ@½GàŸaÃü ÌØab‡ƒ¡>ž|˜{òäø×Â.½!è…¢î<‡-6s>qBu ¡òþiæÌÈ¡ÿÝ û„ q‡‰V-þ3ԑ¿!G+ùå2\nŒÏC¼˜6¶…úÔáÔœE½ƒEZ”©N¯PéÛê'{‡IóÁϳ,P‡–f-[€ÿ?ÿêc*¦‚ª,½¤ô‰KŸºXgž©`yX Ð!ÍD,0Ìkl2$ƒ*1È»¬CÚ<Í4ƒzÊ'ŸD­5‚¢‡BÎäQ­ÂXhA¡»:¯†n#èƒ ÂÈ!‹¬" "øá‡Q€ù§¹çVúÇ¥<øÇ„íŽJÏ¡óÐJ©˜¦Ï!ìþ)ª­x˜B„ö*˜3¿9õK+*¨r23)¯Ìrr,Íô“§°åÿ ¬÷øYïz^h-Â|î¨/ñ [l1¡>¬ŒÄÃ,+1ÆÓìAˆì a>}zú)WémÏ@»q6×&h¡Nm6…X·š¸2ÚÈ nˆàŸðåJ,¯Æxqó§0m:MrÝLÊ;›¼ú)¼uË3°ªïš×Ñï‚ÊJ,®¼ºwPÿúåçƒqÃúÓ@?ÙÒWQŸ"(Œî*ÁÒØCõ±Â»§Ó9°lÃM¼GUÙh4ŸÔG¯Ðn„ÍFÔ6c(µÉd¶52Y$ú£Š>(Ž‚V6 ¶JdJ:é`~˜«K7uÒŽ&ïtZ7Áˆrÿ¯¨žjr j¯¢oª;œªOœ ÏÞEÍÂj@Ë&SQ¦Öªª“ü)¢fC” b“Ô‹;3ÂE ±ËRý0?öpUa][øÕ¬Œk½Ÿ\­«³[{\¹5ú‚J¶ y ³þadõÕÿÙy‰$€VÊF©²v“PÚv.€Ê.\+{*&¡ŠרÊx2:ý»+苬üúÛ@ Ô¾O¹³òÞ`;åBD‚‰ò !jT CP×?œ²ÄOõÐâPÊ Ã ižÇÖÑ’/®,(VˆBh„‡$$!ž‹Ùè4㣾 ©ûGob¥VP‰$ÿ@Æ?r§ÿ’ã´ä&O —×þá‚ï´ÉXà ‹.¢ì§cé¡Ó Ô§|XÅLB±ŠÙ–⤂åÄ‹úWVÌò¬$-K¬@_„ˆ,`ë‘€&¾ Î#‚øûÛ=G¸Åq¬Tö£†f³ªU5 Üßþþ1²¼ˆ .+ø‡c•@ 3ÁjAk‚¬…T¨2Ãò‹í2$ åFó˜Àd4 VÏXÆ(æbÃÈjM;aÓŠ²Bb†åáIÔÔCŸxQzÌ öu³H?M¹aÙö#¨{}O+P”âÝØåÆ/‚tc“˜OÓqfÌÌú˜À`áJG:òã@l¥¹ÿØCAtä¦ä#Ñà X·H"Ñ•®˜¸IÁ¶ä&’°“ùZawòa‚î¬ ¹]+%Š:ýRº…Þ~öc6'}ô‡ý:H[°rð8 Q8Y%"Ð AU”H#O!‰ÎA^ü˜a01Òñê™müìmµ¢ UÁ/‚"Š@G) eµ'Ãã AãÚg– tšYUûR:ÎlUv^Ò(:Èçxðר*À%§•Ð&& EyžИM.d”|ÊcÊŽ­§®ù¡óC µ,gÿÁÊ,Ë(Àžç>×C”@‰,V¾ôýÀ<#’_3v‘‹¡_fBÖGÉMðº2 ‹>À`XÕÍ›FEêHªŠ^zód¦a™®ÔìÚ÷eÎÑC§ÅyH€^m…¬Åœ~zPÅøðHq¯ûЄ²“ñhî·¾rBSfmQb›Svg¸ô%QÜˉz›’” ª?±,@ö月tx…I‡PEf‘f¨ŒàË?–à—%°€¿& éh³Ç!½‘ôpÕ?4çª5ødsvS›TüÏ+÷j×#¨ØênLY‡$ú¨ª2›Í¡i'â§Z6¤¯‹4Æ•ÑNÿñ76¢¸ÐMš~+ Âp±]ú—DÎÏdîã–๺'„¯¼¥CÂVÀVµ£¤E‰¼w|! ˆë€ÓZc ­VÉH›¦ŽÙ ¶™çŸUÂ$Mª*Fê’¾b¯@z¹W ”‘fdyvŒ¦ý¡(äG¥Ûp…Œõ°‰Z­ø>~pâ~¢xÀXÀ‹Ûµð ÍÍô'ÙD”¬áýÓ8žu±›É!ÇÚ^K6K}øÃì•×@HDb¿bÙ¢â7 „,@‰VxÄŠ/G„„ìaÖUSS˜É¬IZk[{¨ÉúG^ô9]ŠL'z„_礢Ü”XÒ1ÿ÷ \t€m& <ã0åh©Ð $RC Áö´VX÷)V`D`-y»ðHÈãá™káËUx)u¼ÐS•w Àüd )«Í?K®^Püs·â_Ž¢„.Ÿù!@C  p”‹°Û ¶@¢ŒÂ€œw»&Ò°ƒÐ?žx=m3*oS-o3:nZ¦‹Üû”£¤ƒ 9꼓¡ˆˆè²Að ¿`>a™,{#ŽŠø‡À‡êë·’`±´"¸µæz®‡3¸5y N3—$tŠÊ@-÷8Ub¿ôH²fé­Ð µA¼+ôªB/Œæá‡Ø÷B+È«Yñ´+>ü¶€êÀ¥ó@U AJ@9‡@JÞý‘œàÙp’»)y»g1„MôD*)‡0‰Û€`{‘‰—ˆl®çáš®8Åú‰õÀ&е ¯&ò8yA”òÒžý ¬Z#“ȳ[èîч )ÞC+Dh…Ø‹aR¶˜Z•9œG¨pea°ƒÂø‰§ÃÅÚƒ0¦ûÃ+ uA¨³)²£Ÿx¹ˆhAyA…ˆÍY°³ˆLœ¾ðG°²T ±,.ã2ÿ‰?N"M» ò ál“ãñ‰—ñx(é ›îŠ•áä!XòŠÆ,š¨Q±ðÅcÄžøàN1› *LõH¬òÌ2 p©Lù›± Û€”“OiÕ]‡Ò‡ ¬£ÎÄR£[B™ŽÇÙÝ&„Uß­ÒÑ3é-zðŒŸ˜ »ÄÝûÃAè…ºdQî b³Éd‘ ^â5^jäÜyÿKâ>ì:É¥ }èLr S EóxŠSkúëLZèΤŒæEÁ„Ñì¾ÙŒN½ðDâ€õëé¶÷÷”³`@i_€†õah…_› 5nÕ©8XUJØá5ªºaÐnšÑŒ×hy×;­„ ÒöšXt„ŠËƒÞÛë2FŠFÎ ];Ê:ú…P…K€f”À˜Žð`Š8‰“¥8ñK](&dB29qïN¡5KÅTÿÅ?!Š×†¾Ùlk›ÅìÞñîöp‚L5òìöë"geìîQŒÞ¥(côVoön_xï—>(ž¡”,m Ó ÒØ‘3Ú‘Ñ6 ÿ Ûo>ìO^[m @GÞcÆŽ‘$iäøœÄêæÞ[È?ÿ…o†±B d°áµAq¿.e¹G[þq"‡òÁ^rHôʼh[&l(r&·6]´‡ML'uQ·¶QßôM¯ë펃p”’²aæX÷…È~oùºËøˆé·tp$gÓ¸°×БÑ™×ÛC‡ ÒWÄs¤tö8ð±Ä.3çßUJ¸„T…"È…pth¸†£!ÅY*óÈ $ž! st‹ì!§èuïí¦kk3ò"(P›}?òó°$/òýkøHõz—@iJ+ñ…ÿPï2ö òÉ!4†‘’Aã·Ü³1ÿ>¾bŸ:·•©èCA\º6Á¤|öK¸h¿ÛE5D,2ôUx…—ï…_È…6ø…^€J‰K¬¦™_wOz¥GŠ}ßñMt¡õ€u‚wzS"'hzO?u]„À7£€‡G1”Žl p`‘TcD ¨Þ¡°ƒ ムâ£ö’O…õI; Ð@®<˜ÿ{ ¸„Ü$Áq¶Ye±ð+CJU Äÿ'p‚^¸Aoß¾‘‹‡_zÍß|¡àz)¤6PzhzÐÿÑwÒoú6P60ý6òÕý°ýX}‡ðzÓû±ÿX—x,o†Zx…ñ©8Ÿ Šð;M">†AóWi=ùà‰±qíi©eöýû0†ù?Í3Ãöá güKè…^¨}q¿†Çj‘«Œ ßwÎOz{ðüø§^‡ÐQ àÚшÿ4Ðû§‚àA*hÁ lóÏ¢ŠŒöòIXaA´Íš «õjˆ„òU ˜ïŸ>/)¬Ió_¾œ0uæ[™óg®Ÿ9c $úOÄŠ¯¼¢IÉ!%!ÿ.Qªº`"˜¶ü§R_Öª”Vý§JÕ¥K½~µùÕ ÚµgÏ€ÝhÏž=(óÚX@ÅÍÀ‚vX°0ˆ€ ÿ(°‡ G†l0òa ‘;f|ù±fx)¼ª%l$I ­Ix¹ÒáVœ}Rá¨Ñ˜1ó…Èg/pàÿ Ò;,s&X¤ÿ|(¥xé%ª—,P¯êc})_ê3TáƒD+\õAñ¬µ½rµ…ûïÙµö*ôÝ«—æ}Ïú=/fÜ_³g1€æÐA x uÖß~$%Â<ÓŒ/¼ÒÊ=ýƒ×†+­dÏk[éSVúè#"'–•>9õ‚@ÅœN4—‰¶ý£”yÐ T•@LG%ص¨’ÝýcX ôèƒ*;eZk9ñË/ÏýsM|ô-`}-ÿfƒe¶™~›1HS ‘µ)šfÊé™fôäCÚi©­öÁ<}ú9=ö7܆ÿôöZŽÉ­€"(šxd G¤$”âL©(PRü8]UC‚zVú¬Þ’`Wä?¯ø`ÞYhUéD[—ÀÕL—^ιk™“Ű&g„Å)€¼+˜f1àØJžÂ`('ÈsÂÿ´0­µóB_0Fc޶é¸(Y&ò©a†vÈ[Geeè¹$9®RM=õ”ùFWd©)u‡+¼ÀŽ”¨Ý«ÿôR¥•¹¼u ®?lì±ûŸÅ»ß°S=Ø6’jÌ#<Ý#Ï=ÿ¤,ÿ¶†à¡‰îÚ6ÞŽH™øp2R h ó\;´CÜåV³rIA…oZÐY‡UЍü“0«Âæ½Òt/k¹uë5 Á¡ÇÇÆ™¯ N Æ—ýv£fá¤LÀ=yçrò´pÂßÛn4Šd­pÖŽ‹ÆB¤‡ÑÓÂßÚºÌrÊ!ZÏ0†›TsM-ýÿl@ÉuÙ1ù"ˆ´²@O5µ–¿DiV/SuÝVí[6ƒ1ývƒ ùJѯhwÜë?o¥pÿhÂSëy äóD+`ÎB)KEJh3*hOè§*ªeÔpf™¥@¢øÐ5ísÿ¥À?"@ѵJEøè/ŒiÌ’vmÀà>"ÈR3f ñi9ÒÇF@¡ùUcŠÇAp „*á!3 ˜jg2Ï["B0I@õÉ©Aû›´ì‰2‚«‡Ëê«–²UÌ$Få ê²WŠE–³3O´Öý©H3«@"à©ÑQâwí…Hÿq%’Tl É3pqƒØHs°¡Çšb:YÂd3hûOg:™•½îM¬ð2hÞáddö@%Á³yLµ{€ËÞÊþ¡·ëM«ª¶a T–s–Ee'N0”·B‹Ød&ärˆ,¯êàB奈XȲ€V¬ P®ÿ-÷G:Uð‚¤X*¦Ö ëB¸ÂÅMHï>FLàM×bb>ΑYÛz5˜ä%+¹ÉL~rB~¼6…äã*–£§÷Ö·½— ¸e ü†C Å·À]@?Ü"C¡ F¯É¦u”¤¨"aæßè’K ]ÕS"Ž+Š/ªŠÚA×"W2c/^a]acKt©@W(Ò—8 »rìîb8[Aa}l<á?ˆ[Kˆ›LTa¤ÉIèà^d˜@xé`<Øc¸Ûxõ”ÓÑ„"^Åœ’AÝCTY¿}„Àˆ–CHN¶LË ´’O¤Ž†ñD¹Š@¬p ™Ev€‘ŠHzðp „–HÇߘU˜Ï”Xᵫ”™y¤¬ Å ýB ü>àÃû1ád…+¢êð"È"-f-¦Êœ0ˆÐI5A`°ݦ½Þ5DC<x-2*MUÖÕ^3r]§ÑCPB$I€D€X@hMRòW ½@ÐÌLŠàÛµ ˆEÑì¬ˆŽˆ@Œ•Y™‡éÏßáK%:͈‘ÿ™x"ø¥Ÿ ˆ€ÞI¢@(4\0‚ø’HÞ ,$¨”!àÜM¨TVHd`dá~`ÆÈJ-ÒE  p†”!L¡ É[ ™äE¡°!¼5’ÙÜX+|Ä5àB¨Dþ &œ5b½0T@ò“Ç¢Y䌜9D;îâ˜cV‰…tР@Ø’XX YP@+´‚çxJUøÙCMb«\H¬@ŸL€!œ".àÃüRCþÒ?¨%"ÜÀnyÆ,FPVt]Ù^ÙÆÐµFŠxA °ŒÐf ÒÖ…š`~ }AÙ9™Q]qŒàCžàB+¤„åFͬÀS4JoqÿN@>œpõÓ‚E‰Òˆ‹rD™•`$d³MG‚ÞV*³Y@àfU,ßYN²=4ÌC €!˜.àÂHÌBÂ/9ç[F'[F\ZŒG‚×艆AJL1òëÒ12Äx6fbx'xaÆ»mKª$8Iàࣉ0°Ð$%…£ åWá(_”¸JpÉ —áÜÌŽ$ÎŽÈâ@ÔkÞ‹ä‹sìOž9híàþ¨˜õ-Dz%4@ƒèCA’€,@ÍÂrÂ\þC\îŒÒÄ/E'1!\MÏÐ`¦vãC0„FÒÄajdœØš”×M@„`¤ÿ'ª¡eéÛ ÔX ƒÀ•Ù顟|€ã½h^š©i¶J?õH†åG•UÞáÚùÈs´i¾ µ"³Iu”æÇMES44´2 pÛY.§@¡@¨T‹úÒ»P„/©¨C¼åŒÖ(\²euî õEA|¤¥©á¦!fa†Ú)#’Þ¨)¦zSqP.ˆD3 C-\fæÄiý.<^—(³]”€6W(ͰÇ-åšÞÄpýœþHÝ‹Ðiœzé\DEH\€‡Ÿ^À ´Z¦è? A[.$ꤨ/ñ’@ŒŠŽk£**ŠÌ‹ÊI§N ¡PÌݧ&ÿæ1Šêšª¶T9„`—ž W„#øÌ<äHPÂ"Ù©«¼é@¬yH°’‹ø”•oAÅ«È ›2››N‘lfÕƒJ —!¦Ä:ž0„Vx|Àç(!Z.'´å¸Nª@ D¢kŒ!¤Bj¸®è®`*IšhtjÐ…Z¯ÓBDC˜Ó»9©dhÀ<è.ÈE3ƒIÏ ¥PJüë5¤ßÆ1h®¢Ö˜…«8Y\ìÅÆÒ‚¾¦gI6NÇèt5Bµeã…Þ ¯òªÊ^B>$”¼ì¶ÂÔB- 2¤‚Äœk["*Кkt Ĥ![Òh[¾Ë¢êŒtÿ‹¤-iè é~$ýʯdDêD›Ðƒ€Àî2’ª0ÞD›P­äÃÕŽ„0H~ýƤÇ%<4¬€U½VÚúÈZÉÖr"Û:„øÌYC-ߊE²ÑÄ›ž>â Éjo¨LEz8ÞãñÉ?@Àü) ‚€Ô‚/ø2üxkä¢h¡âæR„+ÀL £šÉKôÅVÄѦ:Œ†ïÄÀa4„RÉÏpüŠÓÆLë dÁ‰’2°Û¸Í`D›ÌÃ\í„C*¸w}îÌÁ5 " *¯½0ÛÃRç°fFÝÌÍøV”<‰È‰SH„vTƒß&Xs]‚«<‡\‚¿iÿ q’ ¸B¤‚⶯/ÔB¡Z.ML åÂ¥ý*ÿ¢N\êVVhîœ|l°ßÁÚCÁ2Bìj ÓóqÁJÎ< p§R VŸ¨€¶ ðÆ-›è±|€ O•R@J8Äo¤O>ÈÜæ\•*¼ðh^Ô OÜ ›¸`ØáToõÁÖMÀéá}ßpu¯§È)”ˆâ%A>ü ”@ L@P³oûÖBü.É ¨”Š6$‹ÎoYêòºÆˆ#$éÃ1«±2Ë1#p2ì¿ñ±ëqò,F‡€`-•fM,r# A5QÅðÃ=ŲýÓò™ÕjÊYôÆRZùÿ&T m`d¯ƒBGëìO÷ÆUsyN”áùx# @@A€€âþƒ/,ƒ-;D¥Â¢`˜kYî/]´EÛhD¿ 1#xôolHÁþ#ðp3rÙ%ÏDÌüEÔ±Lóq3ÂfÈtMSÄD „ºpÈoèUüƒYÕYu$›à²ß‚­æŠ ‚jMl©•çÜÙ±êsrÍ )ó‹k™H‹€qòÀ¸BƒK12ܲEÏnuîóôÅG›I§tóJ©Ê#°ñ^ÇÀïÁqËÏ3pëõ °I´Â/¤Dlp ·èCUèÃÌÔL┩@Ÿt<ÿlRܕܭc±ýBo€ºŽoºJ®:…S#…êí?ð-52Q  š‹Cð¸B=œµBÓòZ#ü.ɸjx‡r·Är7wr·õ`ðw|ÀÜÄVðw­t™üž;Ä1'OLÿžxË4Iσ!€£E˜ 1Kvo@‡ñæÂ·Ô ƒ± ÝE>ôcPº iõm°£2Ùi甌ÄZ: Fœús!‚u ñæC¯Ý¶NÜ!YóÀo×CBwû¾o7L@\@HtF‰—¸Cè²!L$𤉿RÔ5NÖµW©Å|·`”s·vËt H>Cï^¥©ðÿƤىÐ6ú虹@¤´@Þ@Îù#óùcYÌŽmäk*¥ —\@l˜6¥òBEí3èl%¿ðÃOÜ6?°÷?T7üÃüv$tZOqüz«üЏ@Twƒø¹CL€‰«”¥Ẍ÷\œ@:O€Ù鸒ô~ô¸¥·xÆ«R0•¶‚vôÄo‡=ˆ@èºPJ¯UXßä8A~”jªBŒ;êC;ÂNi'õ—ÜSDÊ™¹këóS(ë0€ñ…‰¼ùÀþƒÌùœ×ƒ´ã9»oÍÞ‚ü"Á-è¸`@zœ3 ÓÄV¼{Œ‰'ú¼ÒŸ7º@ĆŸúé Cÿ@JdA2Æï•7¾ß»¾Oú`¬Òd¤ñ¡CFþ‘d4ïßÉóF$9˘1ç‘€@ៅˆÚ+è3½-Zü“פŠzQòýÓ÷t ©ÿVPUµ¢HUUT¥þª*¢ÿê?V·ªzõŠÒ?¯RJKi¥réFP!n#T]°€"~MíÙ 1!Å®ÖûW¯^‚ jÕèË×2_?`üïVHÑ%<Š6MÐPĈ /¨–(°âÀSvÈè4A’Q’ô}7ï’ÿdz$Qsž„}õ}èÂç@zôÚü[béPzЙ>Õ'µˆˆ­V‹ü»:žë׿Dü¢ºâ<[”^-øgÿ¥½[}èÕ›ÿ®þäš+‚úúZ`…i®° >"‰Çû̱$!•*«3_ ÏnÙ­ r;H‹N|ȉZû§µ+øà‚&°‘#FlÄMÿÇA ¥†dji¸‡P‚‰„ˆ€‚æþ zþ±g:z’ºRºéòÉ绨ºj ¬ÔK¬°VkøÒdK ´þ©/-½à$®åZ²¿%ÃBpDò±ç(ƒàW\áa !ƒL²RyTÃ:¬„z^3ˆ´ÓŽˆ´yn\ñD$&bˆ  &àS>%Êàúq Fˆ,‰Ç—Rz ‚‘Zb¤„ (@°¹@ ›’X40¶) «2.õ ¬Ês¼òÆh¬k©zo«Téï[»Üôa…¹âÂo®üì«Ó¿ìBð†òùÀž €P± ?{,2.ÌЗÊþѬ–B à}Y(ó‰"„( ãRt`KyÄ­‘I[æ1Oš®r´½´¥hEs“»Îu;ÿäi7è“>$БdM1^c„'\Hl˜!r‹¸ðÎsžA 7=‡T¯ IMŠ^äSIDcãÛÈàtÕ8ÚÄJ}$B™n<²+ùݧ9!`=¢óÔ fU¢â?šòþE*hÊ–ì’ºlI%[aÚÖUÈE•µx‹-+ÀO\Ü•'¸¤ëNâ‘7R)QôZd&ÃB°¥0`s„øç-ì ÿ´¡rÔ´æ’Hk&p)‘”E<ÙFDr+W¹ä|Ї‚è³*ª€ÐâRô·¿|ôO.KVv6žª¤ ˜ÌY耹•Wì%ŽäBPÒ’VG<ðŽoyÅÔÇH€\«G "¡@¦_e.ã ³-FÌ+ÈÚf(CèÕp’iÑUÃC‹e„“5H#2¸[mdqð hp”8œÝ4r©ßl £¬šÕ –ÓNSöçÅfq‰QÅF}ð­÷¤‰*Þñ·¥•2–%ŽoÚ–@곀Ύ/ÌüKŸ¦·o„qE……¡GeHR˜Ñ"'ð#¸0SŽ”dÿ<¢"…ÜÍ’ÙÞ@Lu1RÆmŸGÌ*á¶ ¸á¡YÜùJÒý‰Œx™”d”í|t¶ŒB\ðeå<ÏìèGÏ$Ò‘mäl`Õ"GÃÊT öyé’’Ö—úðÑF<€7U}í«Cø‡fÿa~9*lb ê‡à ‰xr ikÛANÏ „! ±˜Ýîy‘Œ8$Ñm®fC¾´ 1ém‚ÓÚÈõsˆ·™"ÎJÅ-R)³¤\;BQ/ε)OA£x²5•N¹i¶~é­î¶Œ*¥ŠK™y¼Ló°}ú€d/ƒCUÖØæcôëýN†CCdÁÿ€6!&µ!KeêÜ(–=¨ÖV XŪ܊{ÜÌFpQãn| ÂO›.•è1‡à[òÜŠ”Ï»¹¨kδ²Ñ¾æ"ý A.œµË_ Ö<æ 3ûb9hšoZA+hÚ;@æ7BˆZ”~=;ÈÉLCö oåµð…ˆ˜LÕºÕóž¦'-ÒÉOº*¬ YÈ,ÌÚ:Ã*W:b®>‚ò*ÎÃÄ&ÎGš:ÂÖcY©(‰‚@tœ 0æR¹|ÊŠçúñ>+ZfRæU–™;Míuö±Ëz娤 à‹<0À„*d*7ÆB… ›A–€E’ÀÀÊÓõÛʬÿýCoz•'côâ¶™µQvHrÊ Ín6B,œVŽXJfÄ 6Àœ¦J!J²ž¥E?É¢ü vÉdRÊ‘Mð~¼Y:j>K²“M5”íûFH ]3€ Î 3CH‡RqÂø"¡i­ oq„µõznÅ.¶=‹­6“2Ù<¢s)ç¬Õ¬F~ ‡&'çÌ‹8%žîAy$ZÿhÂQZ ½¢üü-¸¹ôrÞ„ }Üýãß–þJó¢×>ø¡Š‘´Ò"âÔ7%¿U½¨m‚“àüøc>›bÈ2˜Érñ-à3ò6i^·½óâSαö«ŠG#ù"Z± §§fÑµÇ Š~ÿÿ?õˆ¢ô¤ô.ÇZ ž„pìY¸ˆéšn ÀD™Hí>vÏ]ʈÉtUî%„ørJ ú«ë³éXá¢ïQ*C…ÿ>×tmy–'%¶îîÌaxbzò¦î&Eøn ¢üb#6Pë Œ ýr«äºª«8¦µv£¨$€@L  (mN` rîšàô8@þ¢ AoÜZJ°õÂþÁÖP ² KgököŒ¬¤Okô-à^­Ê¨l¿n ôkBø¥Bí0ƒ3(à¶Ny qÙ¢#^Kn,¢vè ˆpÍjÝP p†,±øbK*A|&  Cð¦ÿÑ1Àõ {j.`¦êN Bâ¦zXƒnè©5ÌïŠ F0â4Dñ«ÚÒ«¢¨d¥“žeøJ®p(4oMïô0€ ÊpÇ.í)ØãZÒÄ+²Å ½#öh ¤®¤2’*îA\‘b‚Bn*â$=‹Êvj_ï ´±³Œ¯Ê íìC,Ë3  ˜'$Ã_†@TLkë.À{ʬEÂÎ,]£ ~è"T„í‘*ïQª*Jìå0æ§÷Bоÿ¤‡ôJo ÐéÌsÉ=BÇ*È"Çb¼ÒHI ?übÉþá¶…úR!€4ÿ¤1%;+‚À1ÇÎß’ÏPï^ 1nQ Eùb í¡€(~ C~Àí,#CRá@ /…R³8QnòÆ--f5Ôl“ï´¼o«î+Ÿd$n„¹R JìÛ„Î(rnÜ‚. Z`ÍpÇþŠ=VÀ+¼Â9H[þêZÆC#—Qu~ òPJ H¢0 3&cò%c&UÒßCÕ2ar&¢Ih2bÖ$¥!¨$E 6¤á:3'Ls8+ž~P){0$n«“pË×TnEælŸ<‚𴨧ÙTQzOÀRæZ%~nÌp æê^l®ÄkÆ¢EÎd=ÿ¾"Ò # ",\Qƒ(@øˆ$^ GB<ÿc_*Ó&ëS?Ç>Ý®? ICð@Ô†2±ïDÂ^ã¶æTܯd¼Š6rä/8¤èTîƒ,ç7ƒ„8’åçè¡ÅîtD='glÍdµE*üФfÏ>~ 'pBwz/õÁ^^€0=«0µñ$Ûó„2‹H…T2ãÓkã_.`‚C¨ô„,„Ð.C´ôa¸ôD…Tį¶8)ð¨ªc~mL;æL‰kÚª­Úp1Š*kæo|Jb&H>”­ØjDÓ DT ìÏ Úƒ¤p°Kÿ^4½þ'J $³¥;(GOR<à0}T&³R‘TR €<5uÕ˜ô!ú¥§Ðî24¤xFR†§QÂfR![·ÔUí׊í5/ŪªjBE…Ÿ>ɫگÎx~ O7>h˜+ò f¤£fÈ-ÑJJˆÂNwL ‚¤Xñþä²j¶ë!ªQ©‚'ª"ö|ït4<;ËGâ1ó1Ó*51ÏÕÄ5¿ 1³4KUÍnx| ¨ B´"¥ Â&l|~€©2ñnòÎ T6ðÉÍTD"ÜìDŽÈäôƒ:1$BAì7²M:Èí7 âç‚âÜžå;$ÒÆâx‚nõ'NFF/ÿ£Å±•A GIƒHÕ•HµñfÅ•f!sgó ÊE ˜ÏB·!PðE#´–3£x&‰@öR$bª61*×Ì×âð±!LnWå¦V‹Š¹üDCçA–~Sm;VÜ`fÜ–¢‹Øð;0­xèeŸu*¢n "iÔ·3pk´B •G 3fÏU& óÕ:kìÄUxÌŽ|`X¨Ðׄ4wxNœ:wA5õæ u– òw“ –u'ÂVeók5ÂýÔov⃆k®é> ñb9ö7­(¬ÄJB`‚Ïpxµ«¯¥n_v*ÒDö2u¶s;k´FI6zÿµ‚à^€…eÒQ#7g â{3ËìL†à‡'@ÍNU( áæ÷ Ôn–Á†ÖqT²§6S÷GbFªê5ÜlR×6ëÑ^>À¤)ŽÄ (8H&øb%ꢆ×)®¥OÏÄyS'L¶³ŒZQx%\x{s ^àgÏ“12 2…ùÙ_,„³4ˇ¿IU—ïr (ÇɧҮˆ‹‰')u9Î5­Š5tVc³U?‚‘®xE‚Õ+ (äô‹=cɘ)¶ä5X,º[^VEg¯jÂb,@L —$°—…ORù1!sàXR þ˜ì¥S•/"Ù›šÙ|ÿÍ_eMᆠ؛“Ø[5Š3é5#b³üÆÏ›E™ÂFžH¾,•M#Ü>€^9Œr™osy„ûÄLH8Z¤Ð[¹¯…m{c¶óß(³IÙTÍN™ö›…™á•¡O5¢’³93âiªbëj[5Yƒ"4Lñ 6ЙoD?¥ŸDJŠ5fŠwk¦\ù•O'£â–kôLÎH޵Äú¨pÂQ‡Úg zìòËøã{sá™ù 2ë›úk|*J btI÷)E%—ò–ÒÁ¼º‡¢Š1b|œ ã&¬m¤+ Zd«(J\Ý之48ÓH*hô„ —ÿÓˆåVo;7Ž  õq[X‘ϲғ2¯¸_ º›NuÖŽ¸ˆ¯XèÆ"x ^µUÉ$Vƒ¬ËoŸ ²×Ôy#â†laÃ9°HåjÀ2(ÚÖ'ì! :¢•° by±u*nY—O6ñÖ8È®)!Xà{ ôg=˾ ÓÓ¤ƒÇS#C,Úª¯š©,1o|nØQ5˜ ÙX£%B“ã)µS[µQúPlrt9Â9Zº'm^jû q[¿Ë„+ÊD€¢¤¤y¢9È9>h’{S 'H!Ó0÷‹¿n*¡¢©Ey|i`.zá¦{b’²—2¶^ÄžJE#h„Vÿ»VkI»¤9BŸNE/å /‚FpäoPÅFj¤÷r¸[JlÃså–ò›‹j:€Æ$Zƒ†µ#{$ÀÀ#&’ÛQQFŒR-ÆÕ ˆ2ÂÅ9‚6më"HEoè¥{'ö$ä9VѺ†·ýz,h”e UQIvAÿ„ɇüÀï%ÁF!brö$›;]4*<ËŸùº)Û>™ㆠ›»º!^k³»Ú{â}ÍÿW*”#®Š“T.ŸÔì‡,âo""þÜÅýÆ’èg؛ÈïÙÑÅ‚Ùû›z9X—že®æWsS’{ ¶=I½÷›Yº©ûÓ‹Å2ÌýŠ×² b³¹Ä7Û’<É©ŒÒ)ÉÛßisÆó©“&,Ï}ŸòÜo€ÍÅi ÷’/ú¢Iž®šCºÈŒçvPíoÿºµVâ{^7À0g(ÛZØ{“ï1 »äOCÜ»ì0$34œ (@³(€­‡€®çîÿÙºEì^ÝÕ}³Âÿ@—2)ÿ5«'Ñ“§xFâ¶Ÿ¬CÚ¶B[ÍŽþ²)`Ô–ƒ¦Ål‰ êú[ú•'˜¼ažÅºœ¤ˆf¢*Ý‘6er'W{×ShOÞ†¼î_°{ÃQc{Ø ò~ž°UT쾑¹ûr[„³ß®'5›ÿÌ£_ 6›æ×³mµ“ø¦FÌûû´¤I:¤Ï;FBEf [aI–ƒœ^ Î¢ÌØ)œÀbž‚T`΃8Jvà ‚Å GŽüÀЃ yüûçª^Dˆ+Z´X¯b‚‹;züø±^Æz @¤ªõoYE_ÿPbè%C1ÿ ¹4ôpæ‡; õäéó̇8ƒ µùϦ! % q õŸÓЍ^:ë¿ .dýÀÑ녪Ɗ}˜µlWµ\ÿ]½ða‚ †n´Š°€‚> `C„øå_®ƒÿÓwø£¾Å?8Ë(„“éý›7ïÄ yÿ8WÄ ðà  ¸šøÐá?Õ [»¾˜qHƳ9ÎvE[d‚©RqdÙr&…›0‡ÇDâ“‚ÐáʽØs§ÅOa^}jêÓí\µZ6ü¦U9–ëöaÙ­êÓ—g*Õ,؇t)Ø9÷â‡À?äûXìEà€þóA þ%™ea†Y -áÙÿA½ ÿšáöZˆ"‚´S®HÛl$‘d’o+ù"“KHTÔL7G“Q8U„"Q?U¤TKE1eÈ;‰d‘â¹U–ã}W”½Uzë­gÖVRZôdzsÅDˆðAóüõš!DB>!èã_> –Ëœú(èWHÆàe˜µP òlöñ†º¢¡Crk«TÛF!öÈ‘lYú§DQn»•äâ?,±TÓ3g”s- •¬(î+O=UÑ—3ÒÅ®´^ä$“ã±çäzô¡7%SÃzTŒÍÒñ.\U^GøI6Ù?–Ùó·`9Ö˜ÿ‚ÿˆ;ß‚|Vv˜½ ™<œ¡ákzˆ›DIÚI›Š8E¦”@=Cpj©‰›º²ÑH$ífJ¦¢z“OH=7T­E=‡u:vŸvNý:®DrÉ|S†l°#þ“.Ê*{•ˆ,5AV—1BÏf:؃~M6Ÿ–ð G܃ÿ<€†ñàᤎ`Zˆµ½ ]§ÑVð§^ƒ½"§ Ó6Ä'A‡r±ò˜ÔŒD!'÷O3éVvEÒ÷”‘OÍ5ÞßÛ9Y¤“†ãzѰ]¾%×é²wÊIQ ÁÙ2òeóÐC´™}FöOd{NFôe'z‚ ÿPˆÁÿAN#5C«U­¤¦Õ¢mcoíøl ÃÍQÒéæï«º©ÝÛC0“t¿Ú6­(ÞíöàÛT®Nm÷ñ¥‡ýânn‡ã }GSåÙ^ægEESV‘™ÚBÀyýfVB ‚¾°4B…f¨aˆ!ª]i°†›Üån:hKØ¿^¶éx SÿÚÍÀ,˜›‡ E‹•ŠÂ$¡/Iƒ\R.°,ÂI¥)ßY”Še-ÉÐpãsM%Ä`>üAeR!„r‚œ 3âPÊ’öXÈÃñÕlJíÈ!HÌоX®h,°ˆ<Õ‚¤E±"ƒT%9óI õ¯ŠÉÀ õ‚‡Œ&®à¤\q/¬MJ_ùž§˜Cáum# PN+Ø7vjE°Ò¢Š ‡.Ø!TôÌuGYQrä°hx,—¥¬f×sü ’ñ…H»H…" ¹‹Pœ‘b:9CE 8í!È)±¨JÙÁR4¤! OóÏ a¤ŒñÔËx§ÆNµ™ùAËF0 ²1yôÁÉ“ ¸‹à$dOÂæª•ÃïtE+^ Vã:ÿŠR'ᜮùÎ\âR‚vŠòèTçêhЦé4§­cZEœVOS¢ò©LT*]Y‘ @©¤ÁZÖ@T{ ¬VcËalxÌæX¤—ÇL…C78̰ùk#`mQ©¶³ÂWydfy‹[tÎ’f¥¤% ãîúò±ôes™ÌÒ:sƒüµ";-lN @ÅBµî!Èÿþá€,„v°$ÍR š{%CT‹ª@ºUóiª˜ ]ã?”̱}¬¿{ØùÞøffT$6Q¾ñue®#uÜn½–j>ÄWÃ%J—öʵ¹H(Áþ!…'A\x@*Ò?Ãú´Pô,Ô) …ÿ@×3°C]‰5¥ಢ©nöp…üWølA¿Nƒ=ð˜€íÐp…+ â!^Ý /‡L°Ø7}û ãCÃa•g¤»­Ho[ÚšÊ%WwR ‘ëoZ¤ `FˆäQØî>DžùDkHѺªµ³K•å?äë,€#")ÞˆPá “­$ ^0‡_ÍãæV¸$Gàz(c/qÃÅh‡Õºc–™¯XZv 2ÏX‚kc{• gYkWÅËf°±Z¡è«è¢d‹²õX+L¤5[áì¥õ¢훈×ü #‡2à©NiJ:èÀ| À,iþYlÿÑ"ê18fL†Šz…;™ ÷Ô,?:ø5RN ÅráÜ.«)†F§ÃÒ@€ÓÄ€í ÀIÌbZv·î´ÀÉ„OA¬Î¾)Lð|>jz'†ÅöRGòG<ûùe×&ð‡½~"°•ö±×,õ¤¨ökêÑ ‡Ú"¥Š^Þø•M{Û®®¿o1"~s)J«®2`€ înÍÒäñtﵘ®oÃ/®"W¤µHEó’’HeNn+Ü›E@ê‘W«Ö,Wù]Ia[‡¨QAÖ|éš7Æ< ÇcËÀWäŠÒò%';®› .úˆ®s×PÑÿzÑ÷Ÿ¿ícÌÌ­¾3m Ñ•k™¡‘„¬Y׿ó¢Çlõ¸³”热Ö)=S7}äÊxÍk»2¹#‚/¼ù4¨à^H‡ã•œ7nRò VÜ¡C-Ãk~óæƒâí\p¹-Åm®™¶wœ‚vHæ{]‹ãÎùØËÞ5xÐI^ãàëñ™|<ëÁWp¹Óá2p7âЈ,·{öV¿Âñz£xmýn×!’v¤ôÌ–dT¸•_2óãw§2˨ö÷=¢›!Ü%’Zw„„!à1*ÄMú¾/{¿Ú’Û±°u b^Dç,²6IQ´b23Bÿ};‚zø¶2ÁG€! DànÊ¥Wâ‡hoh¶·6³½×ÞñøçÁUànò7‹b˜€È…ÿ0€)Èc¨%%f±~,cWs% !Dx p„$0Jè8ÝðÕÆN"kf~È…Oˆƒ)¢ƒZòQ»Å°æ†²‡DDH€ 0á¶fU—…·Öc»Q*Tö^8‡=8W±‡D1¬Ð†}Èj¦yo[~XåäyX†„¨ˆÿl…§/T­\ !‰Å(—Èò†¸ˆAxYˆèZ{µ> WIh>vàbYvœÖˆrwƒõ†Q‰ÿ2‡—‰Ž³‹%`î¦Yö CàkƒYŠq·@º:À$$€9”:”p¥ø}óPI+ukp€sCÀ«ˆ\²pŒ;öŠ®QÉÈR¦€;³˜‹‹ ¤ƒ9ðŒÓH€Hó>œ6¡ 6­0PŽà¤/0¨èUod9s¨!“!‰Œ0y„÷øŒ‘‘·`‘L¨yJtk ÿÀ ÈÕ ýÕJÀ†à„!3hŽfƒ\ ñ$Q†„øx‹?ÉGøYñhu§˜DHÃ;– ¡&P’ÀR– *àhf,%Yÿ †Ç!õPÿŒk–@ŸRYAf©!ôÈÎX;iŒ`‘é‘@y”q‰B”ÿp H‰hLĉ"ÉR(Ðÿð.À¼ ¼€°\# 3yiãg>Åw`œ–¯KàÔ _PH–mIš@y–Gi9õ8”¡#”‘·8ñx ó@ïÃ‰ÅÆES†ºù‹\ÃkÜR‘ñ üà&!@âø0™žUŒ á²ð‰!’W2"±˜eµ5›9"ˆc9Fpu usè‘ÐX”C‰„q™žC™Ò¨!ñ™„%°—G´—ÿÀ·†4Mä>ÁÚéöÐ*@Z Pÿúö0çäv ag@–â à ©‘Y¯ñ [5a‰O8YF!KB“­Ñ XØiëY”jÙšòéŒåYž¬ù˜cžw¹‘!Ÿýè>ñ¨› —:›˜ó)pD@ÿÝò ™c* ÿñ ™ùn†L` @Àú‘I«K”é¡q­ˆ30ðO£:÷•žõ)_INUžîÅ;ý‚ïh‘Qžk™–>*ŸñÉšù8¤?j%@N|Ym½DþÙ–óð-Ñ S Dÿ` ÿÐ'PªÿàzŠ+ö4@zApÿ‘p" KZ´:a‰!Å(lϹb åx·&U~ *ÜicèØ;“q4ꌊ„æ©õè‘뉩úh·€DµY„Bj¤á–aœ„iô ¨ºKÐ¥zªTj~S±b­Ã$&‘J 0` ±•q™p Ac˜Õ:‹Õ:P¬# 5ñ —¬}úF%UZã^ %F†žh!—Óª—l)‘ñɨ¯y„+û“ùÉš´i†ú©s•ÔªJÄ­èZTŠªÑKªÆ@ ÂÑ:!J$±P«C Y®ðà˜sD%µÏùœAð k¯Œe§b§‹ÿÕUak…Š6+ún‹¶ 9˜>ºžÖŸ&:°)ŸQ›—jŸEyD˜zq§Øª­¡-pA´MÐ…k ' ö`ù0•Ô:„«’5µÊ @<`µá«R«¡ ¡n –Ïy§…ºÅX;6ꦱö¥¢Ü©¢YÙ8YFñ±ôøwi­‹*æ ¼Ùšï©!j¼ÕH–Z„zy›wN &¨j =˳¥Zªöðüð¸aJ­ƒ´—ù*YW¹¦Øy™QT¤‹¾Âš´PºÅƒ¡0‰£+lcÛc‹¿QÕ¬ÎÊ´;U´1À;·pk£D ÿpu{À=ùóà‘D¨xË·¦x–qNœê*Dÿ°Q¸ˆ{ Ý"òа !;¡Á¹ÒKà(Yð›´\ Y[éºX˾A¬áÂ~9„Ï™°êæTû«¿a[¶ük> t“š¨1y²ñ¸–)±9²RÌECN÷Y©zix7Û¸ôàÿÐôð®\¥ª!€½!Ъþcµü㹑uÙJ’u°³:öZŒ·Ši”éŠà ѡApŽ94º+Kb»![“¬l¨J,‹ 4¶“L‹i¹²ÓŚܣÏhžÉž,˲H®2Ë‘¦œ”B„9À-„‰Á¬ÆÐÿÔÛ‘IØû ñ’³Z ±PÃa2šº˜Yþ³™©äº QºÃŠ4湎sõ–6V…p/D<úûY bóF`´5µa­Õš£h!Å”Z·)—(++ëÀÉëÀJÔ¼:'A”®AmPADª²L¥mâ&óÀbû«`J`0­)LT­“(y|ŠY~üÇå°¢›sÛÐåsŠº˜V…±±‘i’Ò‘/·k»’,É[c²×ʶ!«£óY¼i¼Ï8ÏeHPpç™ÊEÓÊa«ÆQ¥Æm’ $lE€(q§F ÕgJÿ ±Çˆr¯1\Ò¼ÑIû°Šiù„5æWuÉh~f]²°˜æÈÞœ•d‹»‹œ°¤/ËJº ­è¼ç™ÎÚ*©O ÏGXHHÏÞZ”†§ÏòKm² ¯šIR]4N“D±›Zm®@ÇV{Ã/P-,¿;Ík}Ö YËT^„ÛhVÒÏŒiÅxµk×Þ¼Ò£û÷{@2=U7 )‘*3Í×Q†¼Ë\˜3—»K” ¼> ÌØEé­xkÔVX \A Úre<Ðù .òÚWmJOhÚðЮ`µëÛã7~ °¿}ÒµÅÇýd×56ÿ°Xûõ]Ò(-ÛÑ¿ÕÌs Äý{È6£ù)Puáb­‘w‰žHÈ‘YÁ¶‰jÝzI·K¸—H³â䤟ßwúÜ&ä-¥N@ýìÔïú®TJû wÚ:A Ð¡ýF°OØ ¸!TÓO¾ž+lX{ÖLUÜ‚Û6 å^àeÜÿÛÖÐÙÌɪÍN–M ’;¿•ó˜-·:‰º¶8 ›t«–ÚÚ²·XÏÒH„–ÊÅ0Žq0\œÔÝÒ6ŽÞ¢ú-0ÆùËG/4¢±[°Dõf&Ym°}µ°ýhÖÁTÚìE.êR.ÛÚÜàÿÄIkÒs]Üš[dÉeä×NÄ;­pUºk;údC=ryâÍ•¼Y¬!€i™XI÷¼W4ESÑÊ ÊÜÒ™Dªm@¥Nà&•@¢q@äÿ ÕÀC€´ A‚|µPTµ-Í»êq,¢ N™9—ê¤Á¦± àeMënÒ˜Sµ^vÓi*q“/-¶ÜÌÒµøóxש~>ÔBzžš¸‰ÿð·YfñKà^LÝϰL¥bܸ!ð†bÕ’ÚD®ÕÍ´{œJ`­EòniöŽàW¾Ûóni5溻^m*ðk}Òæw/ÚÜ֘徢.á,í§žÿ5ž/´»¿*Pü£0 G)âÖø“ÆÛìy[4‚^ˆ»X!¿W„n\Ù«œ‹¾íÞîèôðô@ (C^äF`Y;Ú¦aßJõÛž«Ñ¢þµö Ö¢±™hæê.ô¡ÑRåêÿëåÍ|ðÜ)‹±õ3¶ R¶Ÿ%÷a(øðS,Ön¯X®Zˆ¨ òHí½ŸÇœ6òÚÂ-'Ÿ–ý)¿òSªm0ÆN0Â0ã¾aóZíñ7¬D¹A™­dû¾ÿýÌ‚¼T «J^n×´ È—–ð­Þô4õ/º>»ÊšC CÜæÿÍñOà@þÃ5ÿÃÁƒŒ…O D£<J«ôº$ÏKøÛ¯Ìýÿ¶»«.)›L4âÌ ì|jAƒ0p(dÐO4zè E¡ ÿ9tÂ{FQ zó„^jÉDZ$ȉÛBxa!Ÿ| ê¢0â‚ ˜2L¨ †`¬Èë² ¡±–Zj,ÿ«‚pËë°´+˾À‹K ´²ä £º¤ó½d©ü¯¾3Õ\ 1hýˆ‡ÂÅ2ƒ0Km4†*:ÈAr2m£’ާQvè]Õ2ižòYé  ¢çÓ uÆ‹€Â £ HJ(¦8[êGx•®£[ÿ,–+"Ç X2õ*RÉ÷Ê"Kã-õS³±ÀÄ S̳Èã˸ƒÐdìdl“‚q;âìÏHºóÍ觇eTÝÓÜÍðŸEM’±éàpÞ”òȉdÃM `A¨8,!Ô 2p`*øìË þ¡ªHðòØÊ7I: „^¯ÂRJ`¥d‹.'µ‚Ž+ˆ´Šïü*™?¼º,ëïN(Î\n쾌ü;4­Â6 !ù ÿ,éÿÿ H° Áƒ*\Ȱ!B~ˆnÁõo.\ þQ¸aá"¾ðá†k> ÿ~D @‘! >|˜0ïÃ?™Œæédô¿;?T@tSè?Fþe(4©K¢ nH¥0ÐÐÆ—V)ú7aÂ? 1špQ„ "Høo„ˆ#ÊK·®Ý»xþ¨O ?}üVlò/® -)DÀçÑ‚…QK:áŸ!¢ˆ\V 'ÖÞFÿX°81/†M ŒèÙ¼AfØR+Ø”yÚP [#üˆú7…Z­Þ0´ÕfXÿ L0”qwÞmGÄ-ïgõ׫ÇË˽»÷ïvùåÿû©o<"h)m˜ŒHñ?`ø"„$|ÑÂóVÿIS¿ !èÄ™=óœp‚<£e`j<Ýðœm`‰•ŸPFy•™lTpÃ*QuoTeÅq`qÕÕ†Üðe,€ÈˆüôÖtzgã8v××?ãù…È -°€ˆµg‘´ÒŠBŒ‚dT[rèôO£Íó=9i)‚GÍÃO "¤V3Íã•mGõAŠjåÛ†?Üðq–mEU~ZÁäŸMsÚ‰–DÅå?‡ÄvÔåèè£x‰çW>“*úS\qý¤éx¤@©¥XH•))}|þ£XÈÍÂ<¤eÿùA€'°ðÏ=°ÎCÏM ETKŸíP¨•ùO|ú}€¢bølÐ K,„Ûe#&µn·±„–‹ù°—@Ûa§(vßBjî¹ QúO¹êjzÞŒD§.`™}ºÑ?7´âàÿ¬ÀÒ ¬i´•ª0ͪ“<-EZŒœ0Ðv™—Ÿ}hj)áN¼y,p[¹¤¢Huî9â(Z&fÿá«k 4K(Dm‘{Pv‹–‹îÎ6îE©x›ò8îÏúŒÀëz»®ªn!" g¶v.ð,ÔÀž¶êŸT9O ¶¢få=G܃ë?1¸*Ä‹&Ú?eƒ9P :ÉTÁøpKío"9ÿ»'¾­wÁÿÝöÏ·‚VûnpŒJûµÐu§RËuR“¸ê¢'xåqÌ@!¤&3óøÁНĬ¶ÄÏ0âK¿S“†ìDCÈP%uÒ*€¸9ðNø!~@Tö¦_YÌ”¸ækOК+)~yªU…¶Êxæs åñ@ÿáZ!H”¨Jjۤ˜5ˆðäQ™¨í­Ä RÒ9j”™!áHÈ ¶4@‘ q…÷;çáËN,QÒ# ƒ:òþg#­ÁqbiÌ^‘¨¥ Û¬Í R¦Ú7G>ù~ï7®¥ò³GíªŸ?W&@pËLbý‡NÂ`“,Ô>C zë%ʵwI.‚ä!BBSÿ ÎôàñþÑ;ˆÁjÌgÆ_ ±à†¶+‚V+8¤<±Ô%ùYÀn¢½‹ÄX”< ?ò•P…*“ý«.Xþ… ™©ÚsÚ#ÆAHb]H„AÇP @%H•,,âÍÌe¦ðî|„‚䚨«Fé,ZÑyØum›˜Æ²¡õTf#ŒÑÞ`øË šC²m4J 3Ѝ¼¨~ÔÉY<6Mi¹ÒRªÂ*¸ë‡¹UÚ£ªUüKf¼ø#ÚRu mQ‚‹TË$ ]É$µD7èK¢Q›ž™Kb\é…zÜ`°óx<ìÚ1AyÕÚn廌}ÏÃÇ(øeüf+]ÿA#y™ãcEsè‘?À0H’·yë-GLª<É]î»@ÄÒùÏ55))šg‹?j‘™ˆœ!õK>±O–p P T*3iÔÖfeÆÂ¼-Á]åŒ\ᛯÇ>›_“w ^#Ï¡qÇì„‹FÆp±ðW@ Øé#JÉJ~ r`\+ÉÌ„,¹yª¯çßÉ_Rø!ÿ®[]ú\Ú‹X[P®Ç,BHË ÎrÐ!!)¡ò) ë®À+M  sð¾áâÉU‚¼E)rõ˜=V¼Îg‹.Ø{‡<a i“ Ýæ Xä£H¤E~€ßÓp……ÍJË#A†=‘_>¨“Îÿ^LO}h'ŒJâ|—Z€í´ò‘b_D›J©."vØ$\è[>+á gaþ‚=à/J!V­ ½!¹‚RwåG:a mRkBÆ…L$ÆLu1,+ÈDGs4fZ2usøp ×`¾a7±V€’"ƒÆ8¬3H0ë5ЗxÿJC&nAgFF„ðt1¢øeQ–9õÇ„1 "V¡×‡q F@âE¬A"ÐRóÀaI†°*6 Å[wDœ‚²÷%Æ#]kS{·rLÖB_CGwUk*9A%Ë3ß701È1#ÿ=+ñCÿ@! À€ ¶yÓÑYâ†~ 9Ÿu„|1. È9L6E Á’`YÆ$õñÀaTR0¸5P1Eqù0aGб–Fw…+(¶+ÂáYQ”ê’TìèxðçJäщM8ŠöäJúp>PÿÇ/ýÆ/·tQQ± ú …É „®‚{º‚;·’1Ñ0tfAdóA´+\‚;ec\~Ô;&ukbr%Ã2,—!s¸}ÕǶãˆT€ÿSVC:D’­€_q}±æ7J§‰£ädë‰ÚEØA)E.QÔ~è÷~<Ã)±„öÇs¤´øå"$¬#á,Q†ÛØBÏ:¯×16чˆu¸S- +97_Ò;iÃ;xUR9´‚fËÔW‘ò*¸'6Zbp©¨c1wsx{âÊñ&ON¡:5ds37 ?#IF.Y¤Tÿ•šˆ㦎ì¸(ãFdíW„¡µ.”¢„¡X¸•R•f‚Š^$±/¡„ˆp#Þæ[½E!Ö6°"ÂE7œQǦ0sU%HLr0„Il¶ÿ" 9Q+(öäŒY"<ÑB d1*x;B!SÑÒ…,a'¤=@4 ’ˆ øœÒQŸOCF›'•£ô3ðx•Kõš;³iI–i÷X)놛>1êÑ"ϲ¸`¦c7ô‚/# ¯r‚ô൲‹Äö"&œ±u¯²az]’Q½#]ºC'W£|·—[÷<70~w,€0uNÑ÷r“)R4Ä^â £`'’F~ñ@”R5•¬©DKõxPI.í8›7c›Ht÷Cn£eyO…òœƒaí3B°´Ó+7Ñ?¾•6Qtl"\?ªŒ.ªq%u£pÿcW¡‘‘pSZbl¸—ÇÆLeãŒò0¤@ËQ7@8GÁˆ¤z¬QªQ¢vR*?€ ÿP?`*"°>EÆYªÙ>í¸ FÔšQ)9P‰9”)¬Ô¦ï§pj HȰL"Ï6$ @µã‡ñ˃phƒž'8‡vDg4¨—;w„L8GuDlÒ5ž.š¨-Êq¹aeSqfƒA°’"¨#&! ¾²ƒB}‘Sù©P…!þ) £‰‰¢&ðY²‰~ëC?]:¦®ù Ñ~¶jZfz.Dw¬Oø3Oˆ¬ñ§KG³Åt¨b2\Â%'`6Gð†µFGÿÔ‹æYk:[£æ*’èzWöú¨<Ëqueg`bA}´òÌqPaÑCIÑIm)S–©£$ºaµàŸu×IfEè¸J¹³ÙYJ)g ·ß›ô¥>:—í4˜sZoZ?›Ö„¤ô‰^ÕBH‚jxF¯(¦†eÓWÔkȨ‘D¨Ó£w Ëq#<·Òké;Ȩk4W¶V `’¸"´*ôá[È‘d‚HTÑIkñªª$=ößtü0«Tî󚣄¦f*›#‹¦Æ«(X‰#?3U@si#ût+1¨æÁB©ÿwG_÷¹|D¾:›]z?ôƒ±ÝEnš#ìPÙ#tltÔÛ_œÅ]Ô¯º`¬“Ιp5q]ÃÿS|½&Bz¦£gÔdW2 ‡Ç•W#øQÆqá0Ói ÷k_¢;ßY¹¤‘žº|p©-™!0q1Aƒ=?P Ȱ b ~›÷xq~Z" ·í“36“Dw;4T”̽‚Ç_0ÂëbŸåÇAU*o7@ ÚK 8"S‚É#×EbvÉÙ‰L}”BÀÏÄs$¿{¨L<ÛrGgH<ʸc¹DjQqa£˜iô”‚!2áʇ4š‰=$ra¼ È¥âWšÕ ›óåÁ© `Dö h¬¬—Æ•L¸T“÷Ìêd6áÒ̱D§¦ÂœZ, Püvz¬†Eòÿ€²!vy!l ´Å×u#‡ÇÄLf|½ãɹÈXl—¿Ë¤ÕÔjb}½"QXÐ!#Ñ‚c‹Ë= úâ-šâYÚ¡s£e~M”Œ7ыҎA÷°´„ʬÏÌÌ$,)UY¨%Â`”’ǿɱø(o‚¡eø`è@°ç*-Ä%ÊÔ&1Dl<œ;‚ôŒf¢ºô»¾-ª‘Â'w Cgó ‹?j%Áå¢Zb%ic1µèôH!‰Ëð Xª=Þ²xùÓÁdý‰×ƛ1y&,4’Ò™óÌQ„_ùP•xìÑ=¡™–Âñe$O²ˆÿÀÊLAÖä[•ýÈ´u¸‡ÛùQn¦Ãõ%xuLA]Ù ­®;º—£í¢”z;å醒U¢’Uý')‡H®È:„÷ÈàªÏ ÆÐ!n¾YžUE™OáÒš *.eº( € ¸©”×{̉Î=Âv|×í„­Üñt?Ñ# @ Ž$™±)çœZòƒºÃt5gé}Auèk›lÙr$Å…äI’–ЍA’ÀUÔäÙF ‚0hÆ[µ3^ˆWÜ]TŽïqËÏ€Ûu¢4á»Ê¶B#á½­*QÙ¥M©ÆnýQ¨dU½Îͱ'~ZMI×Èý_œ•yØ-‚â X0ÿ•‹‹;mÆæ-’aWíQÌEqJ>G"äÎÊt‡ù-^‘êêéºåRÈi+/`+ÄD, s²a8Pµž-ñï± ÿð ×@Æòá¾N9F).›Ò¥á¢ÖBhD?o½.€ÌÔë„r›ç©9¦"[ÂÆ 諵œú†”ò,`ž—lÙ•m|šlÙÅg–ÄíK¿N®Ô•Ûc™módf—±Ö;MÍßÙ‡”À{ÃŒ1¸<æàg(Ë(¾º#"ËáîÃáíÃ#tÛŽsÞ9I¡„óg¡Ñ+/›sâO´·üЕ¢3Î.ZUBL]"÷{¹‡É?ÿîèDL¿ÂB gÙ‘+îl³‘ß»ôIÏç\l 3Ú{©ïx™—Z2f«^ŵÓ1zwzw×óH® aœë¸¥¾kŽ_ºŽKsáàbEÅŽÖ꣱ì¦ê&9’`¸§ì·(~xü·ö×n+.Jb¹ŒV2ò“*{Yót¥‡¡{Þ9¿BÓ•0Â+¼2+´rô¹×®ö>]>ª0ýôЯU=UO-”s¼‹ëc¾ Ýöm¿±ÃÚÛ^:.úõ”ŸÆÇ}ûvÎÇûT)ô#ÝP)EÀŠ¡QDíqoòÔí™Áí\ 7X©—GWBžøç½½ØQ½èÃß)°ÿ‡?å{ô°+w)áÿÕ®pWEMÊÞ©êþþÚ@Ú˜–÷BT£À»ZŸú57  üþåû_¼xÿ ò+ /aÁ| TÈPáÅ‚*j¼(Pa=ê#( AŽ" VÈÇï? ¬,ù¯€GŠ&ÿéÜÙ’âG}0õ}˜÷âļˆ*Ì“w”…¼ò¤ÞÃH€÷²fýw„*UŒ `üª¬V³`›¶˜÷/Ä‚IæË‚ÞÝóN(œ×‚…B¿~¡Jªê_y%N$æÛVᇠÿ&|¨`HÂeC(ü³€²À€-{öìÚ¨ˆFÀÜiÐõA„=ÆU/îÿD} : ›²ÀCŒAƒ^¬ðO8NŒ"(.ðæÍÅ?>Wè“6Ïœ?wöÉÏPô¡ôæÍc”oé‰ã/J…úØï­†½H j}¨GÈš5 •í¼»BÈ'7…AD’>°‹žòúG¼OhA1ü ‹= ýúk¯ññ‘<œ@‚ïF4$³,øg”QBCfÒžAfø¡5Ù^㨶ƒxÔ-,r›(¢qÜ)¥øAD %éã‡À‹âª@£›¦Œ+%Ú¦9‹|ÒÈ:›¶lI9&Qð >€ªñJÀHýôÓ ¾ýè»/«©ò»Gž=ÿ¡j­µ¤ç-~DD¤ÿ+ŸÔláñNÐ;þ±ÐΨž’ê/¾èÉk¼;œìD ~PQ!Ñ^„ñ`RSm5;] ‹@ÞhÕ ‡âG„"Âè@&¡4ÓŠ’«§)YbhJ~ì©%æÂ‚6'“NÌ–Yá†Ó”`7!Ы°þòËê½{0Pè®àC뢳ȅêByØúOÐìaTŸCÿ9ô@’BÁÒ¶$¬P¯£þÙë"Äâ´B¾èÅÜTl<Ð̬•Fif`Bm™k®ù[X_SY¶Ú(² " Š9fãt]H»…~{R.'ùµ3®B‚®$ ãyé& ™c¨P—œÛ(Ù™¢ÓHÙŠèÿa(0ð²ÄeDÜ85Ì+þæd>ýºª¾%n[BK ³taO8~EXa…VH4Á'Œ°¯¶ÿKl¹ ƒ˜CŒNˆ˜ȃ€)àŸ®ùFGÆn‰µ3æxhžù¡Û´ £—¡ÛÎX ܹ"aí i阻)¦#YÒ}ÙÙ†~6èŽZÊ‘|Ø›‚ËÒlÔÃåÑ”Ovã£*«êß‹ŠO> ëSì£ÕëÑzÙªÀ죽=PàHËKRõ’8Óy·_\qéÿùKÔÊ]Nd™[†È®”Ude*»U®~”šÈW <Év&»×aj681žÐ˜5ÿåèÎxÉàÒ¢EœŽTkKOÒÖZ±‚ýã2 ú>å8Mù‰lðJ»üä§üù§mqƒÔ<4ñxÊ1Jô”=ò—õñm{k"êr,Ž-‹Âˆu¸Ho/ÒcäÚ¢1Í´£MÈHSÀeŒ"t¢»ˆÍJ'³ ºà!BŠˆ hSǃìÈNˆ°ÝÏ É4~ä.LIÓr^òô…IhÍZmÆä³D@3CPÈ /"½l**`‘“}ªG'yñ‰PXf»91}tñÙ?p*,}wT+ÅC¸ðmˆ>a| ÄÈx˜OQŽT–ë˜ÈHöŒÍ]?A`Eǃÿà W4³‰CºaE)L¶1!y6+B"ƒA»q<òHJÚdYJdÒ—ÈçPò%ùø’q´E‰ÀÐ@ü=løFŒqù‹“ŸîA§û5È—­¼HÝæDHÂr–Ò‡py˨bŠˆAÀ¦º=ÈS¿ìK ¶¨ Å ™‡‘ž!Pœ™jTÉ€±€W-d9ºãu㉸€#¶)ìÔI,ÖÔŽ>T ³ŠEœÝ®KÏúÝÔºZ(-íÄ@+Èd+Z1(5 ô‘BýW®Ø'®êêÏ^µ—û}Ò+U,ÃyNBòí"ªX Òö­ `êFô˸tÿ~ŠÑ…± EÿÈL©:ó™ý£¢)>¾3‚Ñ©uÌM\b†+!égÕp’$sŠÎ'Y‰ —5BhI‡%;1aq õH „‰"k^ñÂ!lV2!j”‡$¥0¼>Em_y¨Ãšrñ<ˆôðë?Êû(æ&†ÿðhXn‰Ø¼â–>oûLŠ‘VÎc` A~ÃW1‰ F»#e8‹¢x#ëÉhM:Šó.Ø&ëü¨aq3¿:§£ÖŽOjAZ¡¾tšHY΢Ònâbyêã  „2¹‚!Ð0‘1QæaFFÄ@RÝ»Þ=Ž@Æ}ÒSèÿýäìÉ ˆ½ì;ì ªß¨Â–òõ%ºƒ 7Žì4(ABz”£MøG™pBbûMÔÉVÐiRp6üaÞÆ„_bÚKð9OÚFË#Ã2!Möí–|Ë2—‹]l…<Û˶Œ¶Ì4°Ò1’²Pÿò‡Y¤XF ÑœŠQà™d›cþ‘Z@.0.ù ¡mc‚`¶,ôo"òG}Ӯݴ$mï©;e•Ó¡¤Mx}9 ’Rû·p°J¤–SõöË…N»ëºõžtÍVù.Õñ ”t¨ö†E°S é± +_.ÇœØÿx¶ »7ö"¨Qäï§~·b‡‘cDú.s ´‚3¦:w4K‹²?Ovz¤™mÁÿÉÍÒ%Õ&~†,Gç›LÔqÚˆq§éé0DÔSW¸Ü¯4}BRž_+Кó±°=ÍK®:ÌÔxòuÒò2j †ò MùGgy”à›|1ÒùùF Ø{3‚6Û(‹s½p“¸™˜°©˜y˜Œ#Ž1ºZÀ³ÍùVÁ¸–±-¹p ªƒˆ£"4Öá L Žpª¥|§ :¡`1LÛ’|¤ë4›ˆ‹ô+”–ðÁâ¾pÓ­™ÈÑ.¯Â?i ŠÚ¯ ¢•õò(È;A+#,JHžÍë²b£1Îó<‘ê›DQº8^²7q¿pô”ýª€øR‰ÿÚ Íñ© ¸nÉÖ —¹ =⣠ڭlâ?òˆ‡5}hŽÕ9ÁbQ âùOs™˜»®â§?*HŸ¨)€ò:–ãYð ÈÌ¢p“©à7Çx‹ŒJŸÅ“¡a9sÊiÛ0Ð#,‘Z6ùš9s¶‹ø2Ââ?ã‚h”iŒëò6/2Àñ˜ÀûÍØŒ7”ÀžºDÄ·°à= «£ä“ˆaˆ‰%)DD´ -ÙH’>å bä² Æ0±{Z޳A¹!¨!Ø»¥ð.8ùìBE„º(œ›»¡õª%s¬G›¢WÈÂ*¤Îûÿýã¼($¶ý£jˆFÁ¨_’¬„¡…±˜ C¸4²€CÍ)ÒJ¹×Ø·:Ò£mâÞ¸ ›i™’н£º*Ì µD4sÄ©Q1âB±™ˆ–›Á¨Y¤å`š0Ë™€y82ÿá“=YAýê´Ñ›%W §"’š2·$–,;,d3,…°?bÛHÏó²@,ò?FéšóIÆ·¢ÂwÔ=Ù€Òâ‘ù”°«Ry‚Ý!±[Íu¼Gÿ”°’å-{œª žìŽÐÁ4á€ÅkËÑO’Á“`ÙäëÐv³ÖYD¹(0‹Ë`ÃHº$6òÄ”síKbd¬“²qq ¿“€½KKÅ - !ýC€°äX BÃ%Ýʪ۸ i9–#¹ìØŽĉx¢¤ˆu±U]@šè€¥§ÜU "Í¶í ”° óÍ $DèQÑ-aà Tcž`ÌéR¿û«29Á¥Yì@‹™¬b ªšÊ‡-Y¥Øÿ¤d±âˆ;¨DǧœÃØ?¢Á;ú·§,i…çêÑÀ\Ð@a@5˜FÃ%½(“®m\ c\ˆDNÁ*©Xä(<½¡¢½9¬ŒL9úx¶‘ +Ú¶°!ýò;HBI€²€Àu&™Ü€}Ý•‰ø:Ö‰¯£JCKˆAÕ\;ëKJ× J¬'-[L|M Sp1»Gú°G}™Ê­Äæ…^IÜä!O†gh__†fØ^ÙK“¡ ×³“2~é(sbÜ)³Öm„$œ("ˆCé(D¡¢øŠ0ÎUµýú\w¥‡Èh½àä‰Â½¡Ô…ÒrLÿ"åWâÑ•~¥`rÒ°0ArZ&¡4šã°‡â Äƒ;äí+L «˜€¥ ˆ;3¯]ÝÕf¹Çfá§ßÄD›°¦òÊäS}¡ máŒWnhø†íE+×3ŽF1\)±“#¾ò™Ž’2»‘¨‹h,˜©3ŽŽÊ²æÄb2.)3³1¨¶‘¤06ó}p_¸\@ãM]ª–ð³v*¥‚`oþßo® ¾Ú"±¦5¯G®G áGÎD¡[ŒÈDzVáÞ€¶#±@žçMŽKÓþÇL²n†ZÐah@èW@+ €W¦¥:•ÌÿУ}¸6L©—O:)1C$^a£ßû;TgÛ)‹¤·È¹Ïe2JØ€ø¢UЇ\˜éh†hˆÉg˜C~e`pf¾ AŠ’p&¸áK*í§è5Ð껫‹d|¦ä§VPØX†[K9}îç©&dóª'¬!²²ÞfPQÎaa8«U›:Ä…å°h/ êši&èžò”“ú#`Ü÷¥¯ú­_€rfºhÖÑsâ ØD ¸„éT…_p\p'ˆæfˆIÖ•U?ãFL¡Û js$d¦d|þj{®dNó+©æg¯†‚‹€‚1u‚Pí×þj×fíp‚‹pm…Pí°ÐíJ~²ÿ½[Æaö4®…xh˜.4ée·6¾ÜÈΣxKñ¢]?‚²ãTéŸ=Tθ„Äïg3i zŒ9ýßùÛ€K(¶Kxï^hl'p^¸i 4™jÒº½ÏÞèlb±j~Þ‘ðJ~jÔÆLÜjÕfízþÖ^pMvÖVá pŒPmXÂðï+¸Ð²þ_øÛíÝ Ë ÇÅ#aì$w«‹hêÖeƒ ‹(ø€(`<öUˆÈ³â@=ÔKPˆñîqgK¶’Š‹“R×ô±²Ä.QUx…÷¾„^ø'È…^‚…6 |ð]õo-ßr.Ïä6øx0s17/Ýfpÿ{àmÛfp'Hó4Öns°í4ó¬6 `VáN}ˆ®BdÅ.tÞÙòPùËÇú$»áØìÆñ“‹_ÎÛq^ !ïò†¡È…s~Œã¹%¼ÓBUPøîˆìK¨ò8 ärV°1s…s{PY—gúP0§ð  ‡#òu_?"…h{hƒ]õ”Âõb÷«c?v1?¢/s P¸è[^hÑ‚†ZhhçiX5„¤¸ð^úÈ­C‡²ýšq·P¿¯~tÐûnÎïWy·€ …è‰ckt6å"uQïŸéúvÌÆ¼–Ónu…·aïìºñ8"ÿ 8¢ˆ§øø0Ÿv_ßu‰ö‰øv5vŠŸx]—x§ö|°ÞoF5‡½kQ÷^FX ³e[·Wˆ¯ñˆ‚»©‹ìfË÷KÍãEñïÄVlú#fp/DVk!ºìÖòøþ‡6ø…ú¾†ÒX· PÚöz7·ð…oõ”°†?{X¿øµïõŒWˆi 'sLyû¸¿øŒŸv x €†ÎáçR5Ò{Vu7;ºÀ°’zKG+wuÇ »p ¾º›È…0¦ba,‹TlyïqK?W]2\CЇÑÿdÃWŒè…Qì_¸é­·ÆY×í:¿º{.×ø†_{:vÿa{¶‡{Œ°øÜ§áLj~2Ÿö^§‡¾a`ùíV€{ø‚z2ì¿(ú+bËXÁh”r^ö%â»Ajé/úWz“Æ0Ž8±²(\¶™ õõ(Çú²ˆkÀn0Š÷O…½ƒÿ.Tøï!Ĉ'R¬hñâCÿ4`Œ£#È"jPA/…Wš5f¡•„Nü;qbÞÍyôþ… "aˆòýÓ'B"W$¡TŸ¾\¢}8ïŸO¢P‹þkª/_ˆ *ý·âì?J”.¥½dáŸ[µ”0Õ'T"D)øHÛ÷Õ¥K>Øö‚Û«p›_— ÿ5»†ëF†#'S&ù/†Š’˜5pļ‘2ÇÊ¢GrV1–0–µ^ 0Ož¼±å-©y“n{º§æËUï?¥+ÌŠ@•(Uˆ-°âÆ­Óg¢E¿R'köì«Wi)At W­ºÓQXáaU¯V¨RßKUaí—zýrò«ãgcHíÿ"giÄYh }¤ÁGÿ)àAa Á˜K­• ÝóÏ…÷ÀÖÂmÐÙÓ›oJ § ]×}ÅSU-ì4lòœ@Na}ÀÓCd•…vjýc[lÉU—>†t…H¨Ax"¸ðKL×?‡ý¢cýÙ‚Y>ô‘g*l¦QFv„ÿ ˜ZšY#ôPÀ˜0MHDòÜ£á?MÄöO :é”ÐPH ÇÞ?ITXx>ÔBžyZ¨a !œçNa… A.F]÷Ï+}A =ªµ@q\‘÷Ðø@É "䲪 KÞ÷”¹,öOcøT`æ–Ñ®–m¦H VV&®¼6HÏ ¸¸D°±¸\ òpxè‹Ym%Âp üC¢*©~EUOó$:X! ú‚†%äy•PYwÖÚE¤V¤¢Z–^üsÞ”Ùm.NäâÂÀ¿@TØ}‹±tÍ(UDl±ífI‡©PÅ™e°yì˜!s´1É#›|ÐÉ%;´ÑÈ>Ù³ÿ‚ˆ Mÿ¨{ÕøÐíQàâ†(tP}àÚ¹ÿÂYUsµT{Qò½om^p§í­ÈõJ.<Äj«…Í7%[UâÒ –eEÆ¿~ößN¥A4OfôP¼1E&uüpDb–IìÈÆÛ¸e¯‘à¸}°‚+HàšÄX‰[³lxºøbÐF±ÂªPrj·+@¥4ž>UXÈÔ¨sI¤]·FÊÝCouúÐ+P ÃY°À¨õŠ*ÿL¹¤ÀKFe/B\S%0 H ›ExxwÞ †,᛬‘àX…¤Ù០ÈõJx⇗”ÿÕ ”PðΤ£‡Àh9©Í†n㣰GS«kOª\ð• ¨:E‘À5)laJ[˜2ËR¨©í¤eGlÙÎ\΂ˆ´¢Hæ±€\¢×¤_¬†{[ܪ„C€/q“ Ӏħ!’|ꃂ T` ál'+ŠˆÆv%Å(‚©}óŒDÆ··ñêq’[Y¯¶¹<"‚ËÇ (™Xå‰/Ê٣ÎcJ!Ñ©üâƒõ8EÉÁФB ±DAPÑÇp&Â@ù%"ÎÛ”6@(P€þLd|C„ˆÊ2Ó†åmÿˆK4Æäúæ«üém{KG4 Ð¤ –"I¼x1‰Üo~ÁTÙþ^ª êDjŸãP´"' ͉QòÍYÂ<£Å‹.G± PÄ»l¥)Id¦:²–·øèSYÁ þ±"YÀyjQE'§ô‹6¬Ê`‡L3Hy TR€•ƒÂ?Qˆ>„¢ÍÅ n¬4ö@Hç 8]–ŠÄô’F§>”©Œ~­d\üÍ„L3pÄ“M´)‘ €zQˆ°Å­‰VD#‡EÈŠçÞ‡´czs©e+«ßü^vËL|°}¸†&ؤÓkbƒ9õ”šÇ‡„¶£É+„H;ç?zÞä¢7ÓAçoYÔ¢ù¨„Â;áÿ¼€G’í;’ä?/Ÿ^¸êU¯B‘ð dX Ýå‡=â%†”÷¼ä­ë‘ ›×%#ùNˆ¨z)Š)‡T± áH}EÆËd1cmÐØ—KfŒ¹Ì`>³˜Ï\9.†Ù"ð>Ìõ(,'6ó˜‰<|ú8íù/úfRþ‘º‡œ*u”·âG_í!"NôŒ¶:ˆp'0kð`lO³”=”«\Žƒ…2J¯¸î/(ðƒQŒùä‡\  Ã:¼Yå\q=‘¹ê5¢öxrDÞ {´Ï°î5‰IQvú.~öK6ÉÌœæi“ÍÕ¦v˨h~„Ǧ9ëltÿ@ ÉFN’‡Nzã§ 'ò!¯ˆ[çÛF׈+.%é®xœ"UŠ)¹Â‘áX s°^\B¯ÐZñVGü¸¬»;#~|€ã@Î0?zÃï€(¸NòÉÉ[äŒÖ! éBê z@4dÌþ²1•Ì]9»¾YÆÕ3ezæÌØc>ˆ = Ð „öxD¢u¡èƒ½.w|·G ŸÅ)jsWQŽvl±'ÒéK¿/¡£áPÓ`C^"ßR$ðœåí Ì _Q]aሸX½È\¼ðÿ¨@á¥óW èxÇ…’¡P¾CÉpb2åÿþ|+\^þŸó—Yd&ê£mmi_»õ¬&K—Dz¸¹¦®ÁÉ j–3mæ‰7‹ºí2´xàFƒàQïN}H0ìÁÁ颧âϳGñš¿?õŠã!ÏHi)RZŽ*¢á}Õ]Ì%>ðC¨øøÁ aˆ¼Xœþ]H­ññv…<ÿ÷.Fl•uÞG%‘€ÔÏiÄÏ-Û)ÎŤT}Kñ×~QέYÆÐž>øÏã}"´"<5IÍ£LÈ£ˆ› Ue %ÈËê¬N_DOÕ8Å?¨ Þ›£ M ˆ\ §\š×hZ Gò0×¾  Y \ Æ%dÿÇ?@ƒ*@ü]+ÞàåSEè…Þ_WX]D8ž]ÀZÈ…a°µÎC´œ±›ÎÙ±´É´²û„>ÛîOLÚH0L@UˆË<Ðýžúù ÖìÑïPÚ×Ä ZH Ù©ÇÑJÀÅÅ<õ›¿mªHÜ ¼BnlÒz¨Göá0"äÌ Þ(À䓾<„.r¡/þ¢ÅUÅ=„qxáCäß°iC `J à[ÐAˆÞú@ÖÄLŒ/1Ñdý d}ìí’ETÌI4O+TajÃÿ< Œì^MäL$Åo\ÇpÄ“ŽLß8­ÿǶÊQ=ŸpœÎ¶HšÙ]Uõq [ÀPDlRà#D¤b*ÊÅóèH¿ýƒŒ’äCÌÃÂ.¼ß P@.ÒbDŒÀ?ìâ.FpÜpÇüUbM£a ˜¤¡B$QB\£ã@ÛÉPÄùà$²]£|¹¡á@Ö˜ÉT4E@Ì0”R›ÄDPÀÈåIPlSРµ[…ÍKxhJDÄpˆÈ?t¥r¢=–ÐpéÈU™¥ù‹vä[ÄŒ(NZ[Tš$LÜ h¤Ž!Ã-âb.êK.’Œ@.þbaDœ¤H¤ÔÇ`|-D|AãKêa*PBLE¬ˆ8þ—8þR,™L˜Mÿ ™Á’çi‹Rþ2DˆLÐCšTSÎ̃>Č؅ VQADë” ŽZè[mŽÐ É…qA„AÃÁÐ&íH(Â%×Ð`¨…¬„0ˆÀæL@F¶>h×ûµ`Þ€HBÄ ÄŸx¦Øè¢x"B>¥§a®ç^tÄ6#HÁÜÄtžâ¤c"cÅ”ýÄW!ÛKÅÒF|™Oø€R²„0¤L"¬ˆ‘ %à%Ù ÚÙw¬Î+d]·DOXú–SˆHt˶äȶPDUŸZgq'öñ›DÆŒ$þÎZƶB‚LÀ\À °Z«ÁìÅGÆE|d¾èEü)ÿ¦’ŠÍý!iG”ÑÛNÜ$4®™¯0ÑZ„O%6Ñ*Ûg¶gÎ @­ø‚0°†ЈÐ<ˆ.@Cª¬Zœ ² ¤Uiaº'EH†d,åÀœ€ÐC h@Iá-f\EÉêáÞ²Þ–lIÎàˆÝ~†—\ÖfÜ­ÉBCʪi+ µlLÚCˆÀBQ‚„M¹~M<=ÿ„Ñ1RD€%ôAiâ_pâÐ\¬èpnͅ¦n-œYS ” €+ §"ƒ/o-´B‘Ò"û¡§ä I’-aŽ D8ïD¤dË=ÌHDX/Fdž=ÄíA÷âíANøŽoÉ&‘øŽ—|Æ<€ïFËÝÈúÆ/‚@‘NTÊ( RAlXœ)šBEÕTëµBj âéR€Xö,E_¤‰•êbìíZž‡ì®+“e{—#È ä. \-ÔB-üCð"Ã?°ŸIê‹H¢g¨&¯¾‡ôv…©Ù"fDÜJ\Á*õöðD[š¤ÉB0B 1kJÌ<´ÿfkroÛí

„Àãá2Føpõv°4&DÿC³¦+¯²Ý ±N òG,1V|ÄáR1?qh¬/KÍû®ïÀhB /¥ìïOðn,€¨B¥è£Å†fÇ]ÚÙèl×9Z 2ŸQ|(orèÊO„Ž'ß'¤²ëC8ª Iª¬@x]p|ÿÅ!—€^€+\@#×Bð.C§V&GD@§0A³ßü/&#´DÈ0 ÅãÅU\²D‡òHLC„#|*cE+Ãr¿òUx4+ï„SñNP±{„÷N1K'±@ÈKè/2/DXAæä‚ u³ˆVz­ÚåQ‰zë×q³ôªÊe dh5“3½ôñÖ ‹â‡±SQôÆŒH!às= Á€@Öò3×~-DtòDì0&›õC ôX;tY{òDƒ2DPô_„EñŒlôC|´^çu5I _'1o±'1D0Âãõß‹UÌC+,¥K°†þFDOäéÌL><3¶ÄspüB7ÿß¡e •ÅC$TÜ›SüÂ"eð uÏË‹&ªqeßkÑ”HmåÃPGöŒ\lu=$Ö’pðúB+ äëüÃq·)sÿC›:7t7÷s{òD$oEÌõEDt³ldôh4x1±Y…aç5b³r§·a+¶³²Ô”w`wD`çŒ^k›P€]€íù=èƒÚÑNN Ÿ’è7¢„@Ü[{$øø•(Ϫ 7›¶ÏÒ¬¶"uVFD`8*Š ZîHmÓÅòm³ÓdPV÷vo'Ào5?wê-üÊ[ç8÷‹ßkŒÿÃŒ¿xr_E{²à…%Çu\gª!T¾¹¹Dtÿ`|÷­|ÀÜŠ=¼¸FÅ‹»7u0»‹agyzÇ·_çL H@t¥怅ånèƒ0€xPÅrÌIŒR Zp%ši£Ó Ø]‚RSÄk³hÒ¡Ò.*óqèC<E­=·+ð A=Lú‰kíp§\À- Á-L¹DhôC€:E49”_ÀŒ 5Et?¾:÷­djD ùC$7(·­kôw3Fc/^_yGh9°«wz£w°[ùF'"´ÂDÆÌpT/°5GXÆVTPø†Õ!Šx«´ jsqÅQHÐi‹€Á ÍCb…°ÒÆ…¹Êݵ2ÿó0ÅâUµtXïÔ@Ĥw*XzXgú¦{:¸wKíÁ'üÁS¹­†À:¬tr³º§'y»äú”3BƳ²íœ·E6Èû{|GÜ™"BàÁÐ!3ûœ„´Ë¢@ Qܹ©M.DA¥ûøítD¶ô0Põy 09ð¾|Ÿ‰ÒÉ™?@ÅÓOÞ?ðöC@:¿ÿÃo'À¿?ò2øB*$LÀ-Œ=ÜBÁ“€Ô”€Í¬½Ú«ýŠçu^[g»4tHÀ:ACŽ«õÔ'9ŽOºK_êÎK -½ì÷-*êÁ œÈá…½N¼+HD=`½Ö|ðC-$€+€Ø_Eî®ýC¨=E´}î–ÀUL*O÷Bß}Zôá­ú­‚Þ{rrW@ùW„”Km^.:4P  ¬¸APâ‡<&ðàáêÖõêmMÿDªZ¾úZæ«W·HøW‚'‹rYÔµ+®Ä1xö5ôÏP…À ^ø÷_$ú.¼P¡Âã ïœÀˆreÍ›ç1‚À¨ñ<‰ŒDƒþ Ä<(-  áßÁ 鵡÷= òZL\Ò¢En'ùòµ„ SåB’"¢„ùQK/ižD¹‚俜J%¾J§PàÇ‹¯iJ~ù>Ø› !3òÿ YÈõkØZbkýóõ?•\qK"ºæZèÿIðÜ BžKì¯Á[ ž2KìŸ >h 3Ð>ŒP3þ)í³ÎL$ñÄÓT3$‚¦ô±/„n;¡Šþ .ÿ7zBˆ¢8–LJîì°kN¤”Šî¥—KIìlÚN'J¬|…’^YÀJ¤ZO"¡¶Ü¥DàG*{0£ìªû$⪫¯ÀÒþóå‡zÖ*°/Ü©Á@ñZèƒ þA° ½°Ã-ÌÀûÇÐÈú*ôØ<ìðFF ´.cq'ÑvZq!ÏT=4UU;]›1¶…²7Ýjá\{ ’ äTb®ˆDiÉèT ö“ŒŒÒU(ÙrZð’ZK/Êt:)ž’ê«2t¾­v‚³žü@¨¥?;}A„=ßZH®ŒÐÔ;¬QÆ#ì_‰ìÿ1JKX¢É*ð²Gíp´ P%UA› ³…>+·\UOLÕcÏ> `Dº 7„n½MƒÜÊ-'Bè1`Ÿ3ÖØ(ÿ)¶H“–\IYa¯óù•WHÂ’Ë1WHª§ó"ê©Á‹2‚2‘JTVtE¾®Öe·ÝvÃòÏÎeÒB‚À{ëZP®ój QRý=8²¿ 5DC$“`t+›€2Ìj§y.[qU‘wò¬/Ä!çIrI96—q“H…¾rk£D'Ž%a³II‘’CN¦˜ ¥(UÁÛ1“zÚ;zú§<«…R%ëôD@¤‚|<äa6 ÅŠ¾ÆÄ–ó]ÿîDæÿ‡ ;¼åÞòú³¯{_¶¾ê&u±ÀóûŸÅ$ø ¥±Ö‚B\üU)3wòúY=Õ~ÓVåéb^“À ¶‹´ls¡Y>€›å,HCÚB’t’d ­IϚ쌤4`+8ÑÒÓÀ䪙[ÿÈÚ (  J"òi^eà$9¥¢,fñ`(Âaï,(Ÿó žŒ(|³`$e>ÅT6øà8T -db—Ñ¢ÿ6´8‘},dëÐõ¢ÏÜo@DÝR H„fRÎÜ$!©ä$!1–Dˆ¤$ä讃ÝÑŒ5&£d;D‰QPÂÂ4å-ÿ”¦B#ûÈÐyøù6 ‚³Ý©<ìaýþÄ{A(n©Jây"˜À$1Іá‰Ã(Ó>Vbd™ùØ.ýǿ̀QU@ø1›Û(ä˜ tˆB>ä# vLŽ*Dr:’\Y 1Néœ4’¬À<Ý#ƒVÎ|ð‡Ï–š’2D] ‰2¬Ç ûÂ.ûp2g“^(롊!.ˆs×f6T°%>JOÜ›Â"ÓPÉDåŠ}¹ëçE_’Rc`¼X/ÿg1­±Sá Ëàè£B“8¹8)uŠpÍ›Ì.Z¨»ÎJ$°Í']'œE gNx†vú<_2 ÁÓ”J |Í£§ÿ›xR´+©ªX¤ç‹!aºEDK ¯Ä-•…¹¥få„9´¬›‚Ð!w¿1®È¢ ™/ç±TÁg4Ÿ&"òñ9ž¨€¤8+È3¡ù\Ø$ÅÊŽ*|“˜iúÈ…MUÂ3Ùy«)@éi:—²¥¢X Y®©›[]¡•…ÈÇ´÷±Ï›žZNö§NUMp‹ lu«;K*‰8V쬰ÑÛÂÚ0b~Û"å&f¸Šq¥ÜD Ý ˜¸áËNd–+ý¨ÏR4]É:i&{¼‰”ö˜ щ®%3ñæf·ÇædM;Í*ϲÖ_” â…<0‘Ubÿø¦…`¥+bÛVðCÕ:¥^´ÅbDߢ½|åk!¢¡°oÓ÷(õ)­ {§ D™ˆQlDÎ…îML2‰J.—9£>žšÛÐ#!èwsö^ÑÙì6³Y4S$¸`y\I.¾ $•:©gé´IIŠ”BÍJ¿OÓò+xöšr x>`K—æãÔ9µêÂÏ',[¶ ]”Á^Ö|`ÃëÁÚgOF"ˆŒ  ZÑù…ˆ­ ¬‰CUW»>NC½L#Ôˆz0!˜ÆEr3œ} 7<ÊUpxD!ÿ( ïÍ…ys!÷ÆÆÇ!˜¬|!›Î¶ó‘šÍ,íÈ”Nÿ[¿°\®€€U Àƒ{+d>sV˜½“üP•,9œW½¬7Ü‚m1å-ºVGt‰"¥#8C­’RµìЈÍ¢Ck‘”$ƒwEãèSÞÛ+¨gvéÛÌÃÓ!pp´+àüàô µÂNê…Wt©yå"=ÒX+D ~%B»ë ÌÌ›gºœZò3€Ìô©‡}ÐI:•¥ªÈÈgGÊk—ˆrñBÆg·H9&RhMèc>̰u;æC5OUž·ØtRêKãÔ#­¿F›h#þ}‹Ìà 9šÈ?"BöxO"ßÑBxÓ‚{¼ýí ¿‘‚øvÿóâåÜ£–Á£eî½HˆxHPl2§|+È~jØP®§û@Õåü‰¼(_ ™Ó‹mMÛJyJKˆBB·ßB,0¸¬§n¸¹~T->c*ý¡ÙdØÓ7ÂEä±{Dä÷o?ûBD×›·s€à pd½’g®ZgÔ»9§/5žÜÀå ÐÌ}«t…ñ >ù²]Á•!@/,SU¿TÇr–¸Bp[Õ6ç“zR=Ñ|¯lèÐc=ËXjÐ „õpTœ«b¦Þ6ÆÞžÎd(`kˆÃ˜¼.7b 7š ÷~¯ îÁízƒwä»ní"F0¦£%‹tâ‹H|ÆXÿŒ"ã2®(š£š£…ÞÃk$Âð¸¯äȬäÙȪ„2@e6Tf°DC4b`N@Ðn!ùÒ®{ƒezc6H°]àª#:Dð™ŒCú6«1N"ìË(¢èCnPÙÆo!žjñ˜ åPŽÙŒ]dÍ`®Nî¤zÜ{–°C§óL© Žêó#Cþ¥RƒÿÖÇa*%p¼ÒH%Åð¹2çT @T %n¯WÚÐìàî2`!”ñ8`‡ø^­/bâ:‚HÿVBû‚œì+«ìf°Hn`þb‚ÀkŠ-]äãðvpžÊoÙN®ã±ä2‘ýä…^JK+H`@ðq@Ú¢-6¤o>1úFp$Àÿ¬¸& ¹PCðm~êÞvÑ2ÂÐÑ 'ö ÀfÃTx¥ì„šq'8ðœ‘ùRM›\À#ô¡YP'&Š„HQƒP§9jr'Àq!(@'cJ‚`Ìx(Q"Ê/µ) ‹2õc,€!\Á„¶†àü( †€`h·ªQRÑBZ±ô`13m‰ÞM"›n#’-73Ì…öaoÓÚ0GÞP"4Pûb6Z âÿZí#‚&9x¦Y¡u`‚²ñúr²H‚±Ë*ÀL¤¶oûþ!23ÿ)O*±¢´¸åà^`(“Ùʯl Š?òÉ“~ ýð¡5áeª~ @€¬òV+÷ŠÐC²Š°hĆ Ô’-Iä-‘SѰHÑ€: ï¡÷zk¥fB0GP:L¢%cg¦~Q†G›Jvb³j²ËþAë† #A(ƒ€ÌH(à”ñÐ,À83õdÁTNÀlRáàeÆt^þ*o?ô*´¬Ò·Øg`Ë’ÐÐR8}k9—+Bp—-3ñóî)[uJó3Uÿfu*»TéÃ@]KªúBWÇbª<é6ª`ë–†Dè”8ÆôÚ — í]êÄ0DèÞ.£SÎröØ3ûfF4d&Ô^”7N;S­Õ¾âü Çå8i“¦ ¶ÂöÁ$”òÔ‡,vX5#a01ÔÍ`Ìj3$çYGVULYL"D[áCPMÿþ¤¾•ÓF¦ .8lf²°ÑùœD& S5"é‡fꆅïP¶¦4QU9³i à>4?“RJ?Îïü&n“uW÷‚“<É“ÔÏlͶa%âNîDzÒB46YïTÄ:DYÓ­Äê¶p¨Ž•êê,õ-ðòáeODQu¥Wks0s&%{T›~œ/Y4H\’ÃLˆ€øèS'3/€r3›VJ#Ñ}-±ñðƒk'¶2ZÎÙê#veWb½VMm÷vû"ÚxWmy"C¦ÕcËCH±Äøôx›•DnOo%@µŽú¥¤DzCÍ Lͼœ H%1_Â{w"rÙÓ:* ÿRÂ^s²^i•6?«´_OŽ>01+³’“f7µ6‡­ò‡'6u儈;i“"¯x‰4¶CcYÅ —Î’‰)Ç-Ÿ"³HP•b‡p.ð>@ ¹ëÆîðÞ¨G|!È™w!tvIJ¸„•DI`R#E5syÎ .L3_K“_@`³Bl†kW.+ã$Nl]úbkå„~U÷káe'–AÚ”¸1”®æ¦¸ «î“}Ko­«Ò†±‚GŽr¥z=ÇG$n×|£ yQÊ„ hxŒQÖˆoB ^ /X5Jÿ‘’>KKl‘¯Ö@Õ¬åÌ@£¹+ÿ2¤+xóü jN’ø,y'8”ƒn;x¥Å²j8¿™EbôÁóAº¸«/œ ßnf6ˆ##¶—hznT 3…qÙ|ÿÀ>@}•6™˜ÿ@=Ó(ÓŒ'ìס鷚 ì>šYÍÌ™ÍF?¼w5úb'%¡#¡Œs':TÙVаJxÑ™Tðl=äXhkLdEn¯1D'~6'âÖØÆç8š„çR"ÉR"…Ïs@Xeª_˜¡‰¹}ßÍž*]4ƒ‘mµ>º¢WŽ‘y“Á(Ö)‚›qW,cRŠ,Ǻ•ª Î2#aUZCàÇCHe B6‚¦w®gC¯1žÿËóP„fuŽÔ–s9ðÈQ€Ôâ…LäAXu'`˜4ËŒy™¡#„ªÕå~1Û> Y™¡çv¿:m Š +嬤È茳“-”°­Ýz°åD…\è…š‰knØÕ™ìšøÖ*f9^ƒz¨É·n†§%Ð0±3E*ôøO„U–4¯‚•í²v¬l5Nn5šõ ´Ñy +d´ÁÍ )Å Ç{afq2­µÇÊ O̽ñ p>À† Àò©ØÃ¦‰øbûúžwö$ŠTh Óhi!†À…\¨ –û—{ψbV‘í´šÊ­µÚyꛣ§»Øÿ,EÜÀoÄm M›oàéÿ`c¼ÓºÜC ‡5¹îL®Ž]ÚH×H{FàG6bc©¯ã *,†º^e¨ ü°µ 6–ûäá0€A ÜUé³ÀÔ¥MhȵßL¹;ˉ5C„Ë/BžÅOüÄ/À‡HÛ1žX9©SF‘ –H±}"ÆCl‰S`C'ÔÆi”'|;È'¨²Œ´ÐCõ$R˜çŠš%$à•—ÛA˜ôØ·`ûÕÁfžº³5Ã~UZüäWÃÏbL»|Š¥Ì‘ aÊûèÌ» MS&£PÒ½?pàÌÌ'ƒŠÒ ÝÒÈÌ!¦} Q"É5ØD‡E?ÄÇ_YH}èÕ$è5Tÿkr— "Éõ;[_àäAùbÛ·T?Û±ÌX©Óݺ@ÃÔ«»\‰*ƒoȼaü&‰$×Ï›aÒÛ2¾Rx GS’îµ­¨ÎOœ2rýÜê@Š£¿±‘Ú§19$w„)Ák 6œIÑ"ÄÿÓ'Ä ¡‡üèÄŠ­/$½…þÿd½}ÒO±ðèÑ[ òy]éû£ž…BàÌëV-ì}ÙkùPØY#FØê½¸ šàæÁÉ´`µÔ4¹ïJ¹Áâþ–¶‡¶9ËiÞÂí¼AœÄÇ|N1ÍíÝ`b–ñ3™Íë½Ü'2>D!¿éoà" ZVàhÙ_y%ÐPeÂô ¾?Äö`-ÃÒ¿7²½õwâ?5ÓûìíoiÜ];Á çå¿ÙšàÂ’ 1tÁ!‚‘HHxAB…ˆÿ.T 8Έ*þû`ñ£Æ 'f¼xñä•7~$ز"Hÿ$P ¡"DÿB„ø%ß¿(rå#ÊPA}J‡,ý7D_ÍŽ=«2bø=‚óþÉû‡¡ /þ‘0`à®êýkûV-Ö¹Xë% ‹7/^§P òå;×m=»vA¤ª¥7±b¨ ûí;ש†“kþkLIDÍšM†9Á$H“7Z\yº¢ÊÕ+Sš~8¶Æ5 QXЊ‚ÔÉ>öìT¨P¬ÃÿMÎ¥/_ˆª$'„˜k‰y%X¼öÈ‹²lyüKk`-WÿÜòp»8=Þ»xÑÓÌÐ}ùÁ êVÿ²ÓýXd(A 9äAJàD§]„àDF´ „²•DÿF¥1RHÅÔÑdVXÛ?7äfÙ?Î-ד=?-÷A>ùèCUOú,—Ëd,çAËE‡U ,|•×x‘úÄP.…àÏaÕ•ôÐ\N8Wµµ#Ê?t(V­ÿFâVÔìe† "Œt5#ô¨ø›Š+ÆHÐõ†=]ý³ï<óXçÕa”Y/@P¤wÞQäw ‘—äb¼BéÖ“¼ÚUß®Zn¼å®ýZ—÷›Ø²—=f BÐ^†à²‚Ôjô2E‘ëÑdyÒuó— yXE ­‰/¢ìÒãî¾êÑ£V'üÃÂ<'”åÕ?¤ÿlDât*ØlÅ¥•$ëšÀvÍõä®n·­¥S„,r*$ã5ShRVÑÏ}'$ó™Æ(a‚jÚLîÎÔR&áÝé=Dsm*OÐïUþnÕ¢ü†pI<.Çô<-øÛB SCýÏ eÀzÿêeuMPÄçJZ±“ÍÚVºÍ{~i7™vÆ ÛJ—]f¼ñÛäÑl—Ž ^Й"„‚<Ïl}ßš|2€7W›-Í=?•qÜLóAkNÀã?'<ý4CвëoýþÔÂ?¦cuD¨Øý“5’j;ÿèÃŽ¤0±¡ÅpñΫâCŠÉ*=ôÙU­z‚oƒ ž“<ˆ1ã="Üõ¢>ãØlf.áÙ…V¸3 UË Å VÈ‘'ÅÕdëú—u¬ó¾äo:ü⊄(D€ùˆ òP]2ð€$/ªfð¼¥¶KË’"ø6Þµ ?ûÉ †`¼â1¤ÿøÿa6¨1 ö%dÍË Éd6ôh(†*ì#ÎèäãT¨4;ƒPb$ðâíCÆÔ PyXç+,8Á$™ÈDªäSŠ!@³V*–e;acØ hE¶¨R-µã¢ZÐ#˜N ?ƒ{nbG3²ÑŽùA*|é<'äŒã/ïF=꽌!ÉSFHÂG¾•d\Bßâ˜Å8ºC‘xÑYõE9ºÉ+£Ò=Ž€°Üò :¢µ<€x€v^à®y±vV<@àO´ÐΕßY•톥1R°€I.É^¦â—©&B#ê¼ÇŽ…Ö‚#MMiedq4ÉÈ÷$ÿ„ÒeF¤†ÜÄËšt8•„ªjël¢WÎI'òoëœKrðÓ‚ ÌGpÀx2ž´øÓŸÿ¤ÝÁæJðÄÒ= Uϯ*Ç]jÐŽÂûGEݘA'Q€=f„¨ !ÒÇj©5¤ÍY VØšžgŽä¨I©]熖âE\ i8Ç ›¢“VìÀ°‚µÄ²®T%HW\€H«ú@-Ë0ÚÅÅQVî2A«ÎGKqæ?Ôøƒa> ˜`Y)¾e¾u­iÅ HTƒ’˜èºuœlõJ2@|Ôe510 .8âl ü7ØÿYí=%ˆbŰ…nä RÀÀ ‹$ÿ±0-ÿljZPá&È‚ 3@¥ Á&Ýíª uè]ÜÀ9 axdýªó0öZï ä£à›­øÞ Òæš ÎHåªÛš%{MpõÒ…°‰ñÂ?vpN Ì¢²´ÆŒÅÌ  +R?›êO<È"1/¸Â…#XAl!=‚fEÿkL³6²£†“&]&à¡gê•/“™…³ÈÓ… 5$±ä*y`'º%†)ÊR;Û-ÕL²Uë ,«KnlÒÚÌèÒfÑÌoÊ´² =*×ô`„Æ^‘ÍŒ•c¬Dì“É,å‡å)&Ö Âü‚S6Ðê±1ÉPGÿÓnÆ ÎHXCZÊ ÖËžOM¬ß2$z­a5(­$ZËèdÃó¶@žDúŸ€µ¯)L.åe2ðÙÞø¢Ì’ÔÉÁäHÈÍh£FÉ fÜÏBê/=³[_® Ó~¯/öµ¹y².ÕbXÉbÌ^ > _fg{¢ö\&€oÜb$¤ŠË– r8læ$„·Í›ÚZ‘[°âaîk:z‰Ý!¡ø"á½îCyni!ûL×/Qùy½né€{JˆÃ¿À –Ý(n²‰(Dz›Ùb*Àêd»•|Ë,ðµIÖ[b•¡ ÀÀ…®r3&Ku“R÷>D= ÄÂÿ9GðEFÜòzø‘ÂU’ž.€}ìÏsƒ`Òí¥§C¯¯3W!Æ7ÃW­¯Z‘Ò&‰ÎÂe𠧇 {&»ßÿnC,¨ X"”³dq„<ëpªÌ¼ïþiUÇU5!ÿø* ÷ÅÜðœï<±JxN»ôð&û™âc¦Èa\3Ðãٙ䮞æ˜#ºÍ¼b ð-Ïë~÷‰! …œ4É!›‘<ôŒO¬B’Œ ´Ú¡W#€¸jæ}¬?&µ%œK )|¬T=1$˜ p~óyöÖ'$ ¥W\ØŠíï=ÈxY½­zYã÷¾õèšGÿ{‰Á#çw~~Ñ¡€ ±ÿ€øñ ó{f¶,H÷< kzeA°cõ§tsxxÔ, ¸&¢&zqMÄòL{æ9}‡$°yŒê’<_%)À ”6sø<)×RpÆXA-DØ6ŒÇQfv$®€Œ@ŒÐX1…$P$0¨€Pƒy…9:8ÈG2ò§W=ð0„D¸6¸uu{dh-Î4€ÉV~Y‘Qh}·yTØ%0Xx…ìBZ%¦ƒ7\fØRe†Žèy¿‚Wç¦|„Ä` %ìc~ègŸˆ}¨?T8ŠÕXóPržGpa3àwØy’ˆ!¹åV„†ÿÍ–®`{÷V~È/QX¢ˆJÃ\khŒÇ¡…`ûÖq_mzÑ>XÈ‚y0PS 1…§ˆŒÛh}èq$K·u·st¡‹wXŽA—€Óˆ…W8…éQ?„:×ÈõÈàØR샠y¨êw žè‚$`… ¡ŽPÂÕasñ0\RàÀåŠd§†·_옙ÇC»È>z(Ph9¤H,:¥SØÈÍgfr`ŒŒ¸z›Uɦ~ Œx¡.Ñá‘é’<Ä€W…žH…ÉM ©?%v)i6ÈMDE dç –ÖR{p;îa;êX€úÈ[êR~°y7 ÿƒaY€ñ‚Bù68’¨C—T”¨ó4ïxa) €"ŠT<‹°ˆR™thCw8ê‰7ì…Ÿè•aÙ\ ƒ …]Q“_0ý“:jùCÔÁÄØRrÀ ÿÀ "Ð6´CÀC€šF§HNyag€œÕR,ù0ä9YƒÑ•ˆù“É/x–{”ÿ™É)z˜…ŽÃªó\—ù¦H6ñš¼ Ï }šC`<˜Ý@TÿÀ—cç—6äË3›xx– Áµ©‚üˆ€ù˜ Yƒ?–Qø“·™g ˆä“œP#I’ÄsÓ—6¤öPúPÿ.àQJA2°3¨YAàWP‘_b ¥,5v;&S`Cæé*!{¸I–…ù›0x~`i›\‰‡öYŸóp Y˜…5ª‡‰QuÖáDýùŸóH€ø‡EJ>*°(NP‘   rðjøa_À ÀF¬tPÄÒ –PO0O™ háYiñ1198©ž<’ ’ø‰Ÿ2J§‰¹™}wšϹ–€õ–¹–5õ–!ˆ¨ (À¨ÿàP° ü ù0SÃL™XðCPEPA¦™ô7}0Õ§pf8O«zc°¨[Àˆ‚a;pÿ©¨˜¦átÉ[»ÅCuÚ‹qê•YÅê•^iŸª;:Éù#ªÓ£Mô#| ü5×ÙÀm`‘WUð~@[AÆðà>Æ`®m©úÀ! S !0 Åð36vp¨IEõ0VÚÙ5£$[Ö†54O`ñXòLjð”v°$^]ްù^h1A‰uñ%_ù‰÷I“4)œI^ÉCÆ*œ^)™4j…W“‰DÙŸ'÷C 5€Š_ñ\SISvÂÿ )áê>ÿ°'°X¡ê"ð/N`ê$ÀC@SÐ C@Tcÿ†øäµ±T q°`cÁMéƒÄY[“±ÄZ+·#;x¡‚‡…Ë[òiò)Š4‰~zGœé“.› y™táDAª–xñ–D…ñSDÄApÆÐE{´Æ@®I[ù P:U*$ú©ÛÁ¯ P;s1JùôXÿ0»‘f†Àªõ´fJ>XpYk‹]„c`ã0n;+í;Xñ¦ÿ8‰¹·…›W–y¬s ŒV˜…Z£‹1…>zI:­'W³Ì™:X¦³úCŒ°¤Ÿ+´ðCKp´ÿÐÆÐÐöðèRúÊ$0à W Yðÿ©<@ªSeq P³{»¸«°f˜¶h(·yÁEpëYs»¼8{æ÷¦É¼²d)Ÿ2Z¬%Œ…·0½¿8ʺ£ÏÙ£å{r=­7¬e‰ûŸ”$¹ 1ö XA®ô+¿™ûùè?Áð#Oÿ{º´»»§I@[[¡eñ´´[’ø4»–¥°Ë’|Á$SføÀ—õi1A²êYDA‰m¼}Ø•êY~õù¦êò¦+š£×{½Ôa…(;ˆ$Ó?â;­;ÌDØ!]Œ›ŒÂø‹ÄD»¹ŒJô )ÔDaQ0U”EeSËýªÀòWº/p¶£kjœrc<a<ÿ0g|7 PÕ¶|‘•å)¶óºo˜<Ù±ëÉ[}È«€‹Y~ÅÊo*™Rè‚d©¬{Ê?,@¾7‹NýóNÊY5íCùàÑù3›{¿m°’Bœ¥Y% k`›O§ešTDòźK»[óµÂK Ë¡gÛ°6´Æ•r¼ _…Ë<·ºŒ$‚ÌìG;©‡ÄÙÌ„ ¬¦&…´y‚HÍP¢:1›:ÉÙD)½Í÷pNç´8…e\1älôàô`® ‘¹˜ûÆÉ=!)ó :ZSº¨ñZ*¥¬¯TôXÚQò'0‡e–•·»Ïòw°$s¯Œÿn+f,¶ Â% Feí*qÌ>É…‹ÑWÑ«öI¬ [½uz£}x…5z Õœ%¨?ŠÒÜœ:-ÝÍ÷0NQCD|ØäLŠªÓ–l¿Ð7í"!ð÷À:XST/P© ¦`a±µ®@EªœOÿêÏŒèÀT=iàI2ûõÀT}JåJ·|\Ûm¬YŸ·²Óž$…l=ÜË,Îqm¸f%ÒúÂÉM•Y¾5‹³€ÚÒ©O|ó[/Œ’àöPÎÿ (K|Äö BÌ´¡Â:‹µª\OF ßA¢­ÏUEø$k,§$Ð qJ­-à—ÕT¨pÿg „yQrSm¼ªM±à»íƒÄKîQ·=ÑS%½¿©Å½ž1ŒjÉ6§½%ÈÆê›2-’êQÒ%yÒ:ŒSÖÕÍÔØx!â­(åÍOÙå¼´ïŠ5­£¥ßFðCÐ ¢]E§K@VD@Ð ®<ªül^%P®È—²y}¼Áll¼µÍËÉ[žßQ¢\dÇè!²À‰Ÿ€ ’ê‰$KœÅJÂÅš…‘ ÃÁHÈüY­6K]+}ZãNÛܸ‹ÂâÍ(NÀ¨÷›?èLÞ@Û7Â$äcQOó$ß/@[ük;§D5³MÛŒøßû¼»C%¶@¸Ð¨T±Ö ÿÖÆÛE°™ «ÚjšÛȓ䑷g­ËnÁ‚{v›Ã•€Ò蘘\t Œ\á‚ÁŒÄâ£ðúŸÜüâÔåN‰›í3íÝqÓ q¿öKîÿÀÎ! )ðQ4OdÑÙ!߯ Y°ÃϺÖÊ­ ÐþýêÿüÏh{¶“F«ÞORÎ „M]۬ƼmY¹>6jÇsQ·ò·[hz÷ÇrꉽêÌpÍìÑQí¨½¢¨×{M³þ¹Ã6ÕÒÛþ?Õ%]äíÝÞö Þm°Ø-PîæLŸû-¦òÛñðò=ßÚ™ÙºKê›´ïÞïsÑÅ´‹ïå•r¹þÿOünõf˜Ûþ­ë þX—Uñ@8æßHÇpÁë%мiqÑ3x“ –ö9Ìy½Ã ×}œx=¹Â %4»È9¥Ò‚=óyqŒ "6KZÎá^®åŠ®ÛD¬ªìIó”OÒ—ôŸ¯´Ûéñ¡ŠïÏý¾¶cÌ¡uúSÄÆhñOeætÁõ nYªÎ»eïT Ä˾lÇl?èAëîá<’ÂéÙ²$K§×Û‰Ë×ňf!í‡ ³zñŸÓZÝÖSñT’pÞ/´‰Í7¯èãŠ?>ôóðPô¿C~°Jÿ\Ë5UËOêäk,áàß@‚þÃ0ÿÐA/ràßÿ*2|qÀD)N´(‘àÈL†< ÑÁÊõ*V¤hòd=‚®*ެçª$M—.Ò$äP¢Ix  FG•’˜G‚)‰[%’Z­:Òê@ÿ¶íJòÈ?yc‹’¼GàÞHzÿœx[ Š='téµi1Rƒ†6öò囇ÀÂ/`ÈáŸ#. ‚!†^ ÂÃà ’Ô(áÈÃ+8Ì8P¢‡ xT}P áEz¼¹úuÊ•E¾&(Ó€+šÄ-7NÜO’> N8[.|'{ÿòŭˉ6þic/ Œ°¿>xáž0 ̲#Ê€1#.»À x0 ƒz(b³…bÈ¡‰âè ÒDêè!Ü,ÈÄŽ<ƒ¶èn:i7xKi(áZ*é§tˆÈå€$©"ôê»/¡¡œj©îéA‚ é’¬b᫺ 럱äó½èðÃòÉ¢¢(@®òùŠ‘üGÈ'„ìKìÁ•PŒ1 †@!\qeψ¨'ˆŒF|T#ÐHRÑ´Šè&Õþ ¸ØNLÉÓ W;ë¥ÝJ)Õ‘d:.'—’ëé&çV=s äir$ÿ*I"`»úŸQHh”ðr¨/¿ɬõâ#ëˆöÂ, -^s h-úê |à*àê$(¯6öLÄòˆ#e,ƒ † á0.ØÓ Ì8lHRIAjV ’Í3‚h `‚ÿx¢l$*Ç’t;àßb*òÈWq ɉ_«hûlÅeת#ÈØ¢´ åûÒDùØ4µ ««­Â"Ó¬øÊro=i "àbÿÉly%럶ÞtÏúw tË?Ô% O† LÐÇ€‡D1L9Œ’í,ƒ2­àÏh»ÆÑf¸î_²(S;©GRW=©¥#5 òHÿ Aþh \FÁeJ‘k- ‚„zý•ÊaU&à+®¶bÖÙž=“L1éY€L/hÛÚòïÍš¦“ΜÀ3 Þ%ìA Ž8l1#æuÂ…t"ûWxè÷³‡Z¾#†$5øyÂabøßº;‚$ÑΜ¾z˜×ÆŠl¢UÖàlË hüL¶•ý¢ÅÊ+!¼üañ«µ+ÑÛêYùFo•ŽÆ+'É#0qߢ4;Ñcj¬ûƒÔ• íÔ\q„<`!(Í 4S"˜H!«QD:Ó™ÏØ&aœrXÃzS7‡MŒ Kج‚D£ˆ¬f{8 z"·‰P/(Ù•±ð,ÈáïK¬Òýf¶¥þå§L>XD‡ú` u§;ÐDGztë.(€>àBré§-A ÈFAvaO„qÀ‚§;Ôk%Æ“äJCÆ”ˆnÙ¦ztÂõ&{“ªs’2´±Ä$âT¨Š‚Ã& `Ð!I²©+U±>¢´âYʲ3ôü/”Á–óÔ‘„v‚“ þ4‰Œl Aò!¥‚€ÊÀ"(W@&BA¸J„ã©”šÍÁN“<× cÉkØÖéñ5ç'+É%U2"E`;:1’Oh2¼©p$" !ù ÿ,éÿÿ H° Áƒ*\ȰáÁ úø-Ø dC!øn ú·°âùŸ…[!’ ¡Â?}çýc£y,äÉcq‚£ÿèÍD´ ÂJ fV¸QáƒÓ$¬ÀÒп~Pøwá‚U VRk)Ô¤ÿ Ýø‡2†µ#þÅ•ËϡݻxóêÝËWoD¢ÿ6P l¡Õ@\ÿ„Dˆ€ã(!Ü+á„ó2ø©™‘Ð:å˜Çhæ¿i‹Þ°úá„a'øü'‚dC&¨½arZCaÿV–QÓÞ0Œµ÷?DüêÊÈ/Þ¿ê×­W—Þ·»÷ïàûòÿ‹¸â%É‹'¯-¡U+ ðO¶¢€¨ló ´Ð9ï„hFöÈô ÿÜ#O óØãÔSˆÜàÛø‘ÖšO³5ˆO[g?à“ÕX_ ܆hdUÀý¶áZ0p?ÕÅÝBÖ…gã8æøÜ+ÜÐ#¶Y°[­°X RßJú\€Ù<;É¥k!üÚ=Gü3€ÿ´öOõmVÞDÚ@Œa˜""¶áãá|cˆÄimdH}”¥Öd%2¶"#TPW\Ø Ïvͨ㢌2”@üÿ0ðœŒA* #P°ÂF‘JA{ŽŠÈ!°Än>N1@,ä ë­ò`€å=àß÷`1S\ñ¯j‰“”I°@EÏÕ©Ö¡<Эh5ÕT0Á\@”ÊX $Ù FwÝ?á†Kîv5žk4£uIú³@JGÄÏZ"Œ ÂF˜*éb£ÒGA¨óõ*}–½&"Àùõ—p³@q åT±ÅÈm1@<“:ÿ€Ú·¡xçDþÀò?óýÁ†LàxnŽÏ\"XXáÃm·Ð):.¤Eí¹ŽùH'ièqçî\u±û4¾Ùû‘ò!ù鿦¤@™á Ún¿M1Çç Àð/|Ýü“|P¥ULàLdTZ-¡¸¯›n8s7\`°OhM`;p7`e¸E Š¢u ôçðï¥té¤Ï?ÿ?œnÄ®’åé¼€½­ˆ|Ør’QI@@/qà$ Ho+Æ*öº  ‚)^At‚#`'­aS’NÔ—¸dCÛÂÇ(pŒ«°åDtšG PeÈ P\Ið!™ÛQgsCÓŽûÿâGÄ»`}‹ˆÒ6)%m„®[L¨È–­F% ÖD»éŽ@¿²Ø@,FA $ÿ@cñ.ˆ·N K2"Õ‡CÿX!0F±e%@$°‘ií«rY)™A„V( ÕåˆEŒ¤C*…LQª.ñ"ô±‘üäHï †Ð “ ä`bãäeØyQ£@–—%å¥1ƒhœ›- Ä@¶ Ä)`úi„Å—ˆÅï±Ü(,ç,9ÈŒ(A—ºâ¸iaë*BRÓ¥Ó9ÎiN’à,¥H—(D&ñÖÔ^·¢%l¹ÈcG “,@*P‘PBÿ°¼€­ÔI–—A¬My,HB•Ç1Ö2AŒXÐ<8–0ÁÌ™ÀÙš›,מf~©%ôqKŒã•–>Î!ˆvr¨xÜ/œ0•Ñèþºšš"3ZžSžw q Â2x’ä‡W!¨=^¥åmDHÇŠÆ VUƒ ùG–x¹¥ÌdF£h¯&РÉb[ÓáUþ'­<•)lÑV:jS¾è‡ÝÌN#aÊ×GQFK;Èx`$uò¨d „[O𱨢̢@”TF„†Ò#Ag¹*Æ îd2ã¼×Ð+gã6ÞøfU'©•¡ò}`íÊcó˜À¶ ‹S`¸ØÀVLÙÔf a™ÑúdH9#ôÑk–;ë"†ÂcH"LX¬-@H[ö?Ö‚$Û€¤€[;ˆC–›ÕpÒXò¤¤»Ì Dm¶TžÜBhƒÂ²bRÿ’ àûÁ3i[†Œ870®a9!okB­É rˆ¾ÅŒòŠr3 L°ËP Ú7ûm®Ð Ü ’ŠNW×#(FÎB(ÊIvº˜¨Ä^íA+ʃ$ÚLUMµÔ1ÐÌ#^% Pxrnëmyy´76¼Ía ‘&1ñ3ÈŒâ×`µdC“¡ªA§¾ïhƒÇâÂávº|¨ í¯5’Žç€3ý.ÿNˆ1Í)ŽK1"VÌD¶eÉÜë9ô¹ÓXÒLʈOøüxÇ€’7)yæ&·ú•ÈÛÆ+(uLÐÛÍÃvÒXf‰¢±ŠèãdsQ\\14KŠÿø?üeeù^w”‘a9KM¸›/@qµŒùŸ<üX½@»!„÷NÔZÛ²cGÀ.“ñ/W@±-1Û¶°bÔY™Až1+u1“u£!°´!H!UL'9†€× 7ð8QCU{åS9tÈô ø€eÂ¥W-õ32„›wž#)1A€5õQ2n‘fÏ¡*„t/RQ 2 ÒäJÄKËÆ7d„7$gRƒhüAUò™•+Ã+ÿ`I±A~у ÐðÞcŒ N´!á ,CHÀ!-´G(ƒñÿA“tÕ¡4Ö!´g‰¥§„9âù§3®'¥SˆNæo÷!¨±Ee±°âU9P™+øl÷6øAr‚Öæ0¡ahp'+<á@’0Án]rn7Ày²BøP>AC¥±!$ò,qR"9dEøÐBÈ@$.‘eüàúk\†„Ê…(OW4.EžGSÚ!çR¥Çògzœh)’RœÂmAg¸ñúÀ —fyèq¿$L^å*ÀÒJ‚¯ˆ+“UzsA¤7}#1¯B1ÀâU˦làiH}™Q!30Ì‚ˆ@C¦ñ%[áL¥2"+²8Š“ £ð<ÿÈXaÕòX.3žG4îØyšSK§„CiN„ñ:`—]² &#À3ûäg1(Œ|ó*¯’0»Ó£!1<Ñl´PÀcŒm'’ #1¦Å|Æ%A;±+pF!3?¶Ã$ˆ¿Qƒ&3"qÂ,c7¹G`2à˜>Y(E(zˆÂ9Kót]V'ÄU÷¨zNÉÓO­@ðÖ’Nafù'LæU‡frm¥cQÒÌf^$ØvtC7â0£v’+cé–¿b ÄI—•7á‹¡‘dq xMÈ÷% çðDHºÇ&˱1 È€ ?p;â\BÿèŽ@I‘ŽôX#dž×!H‰O÷™‚uS"€öÄk˜'›áIá6±Ù†]ù0¼ –V–¿%kG^0¦7ZuJ‚² ¡j¡ySK» ¡w#hR" Ô+'’=¾±VÐ2y"†µÀ<˜oü„ÁeÜaŽ“¹R²F\D3‰ç):íù3ð?šóoFúC«÷kÆkŠA¿ä2A‚eZå0ƒ–w•æ•#Y…c䥛"—¥a^ˆ¡ ›É+9q}’7@8´%Àx\hLËá “³T*Õè*#eÞY2áèecv‰@c?Ch(ÿg„CX‰²v.JCNa–zé’(ßrN(—'J.QC=‹zó›K"‡1Ûæ‹YU^ÙKUpª‘z¡b§º‘Èl]ù+ƒ¦gR¤ñ—Ó`²§“óQH˜V£Ë°G½åˆ’eïIižÃE )›˜„Ih#¤š›I­˜Y?‘zå*.¥st¼&gëj+;ögЧ1„7s¯£œmW AD7 •˜(3’„Dã\öW¥#f‘ŠbV¦WJÿƒ²P—.Ü1NÂI(Aeq&À‡;Øx£qЇ1KršEFñ¡[ÕªaÊ …‹.Fh!¹Úc6P"I›!hh2¤m†Öxr$[#òMaÑ2/º 8é¬#0…ZŽ?³ŽŽŸñ¤í£·E3™ gòC”Ô)2µ³L#::[NÔqt"ppr& "¦ù‡­" ¥ÁrA²d²T†Z§Üv@^£ëbx÷´¡á–c¹O•;^þA–Ùw<—IM± ³Õ%uR˜¡B›G’!·å\?Y:J§\Ýz·{õH1›ù0®ÑáWuA³4«·7:ˆK©Èu?ƒ¥‰ÿ%bˈ³n²;!Ð4Xzµ ‘<ƒö*¨JFuA£+†ÑWr=&1´ÿ°¢¡vf œµ‹;û¡b_B0 =-¡‡Â&,ª2QöË€ £  vÚŠÜš-.Þ‹žŽ´b³Ý‹\à‰auÑ›‰ÂGTfM‰¸åÚ”!)ø2Bà„ÿs*s0¼û%€h ‘Pšœcª¶„ZµúAû1K™Ë¾jQl¡üÊU-𺱥°wbùm[Ù…£‡T)ß’8ˆioÿð á,ÓaÝ”:Ù)GùÖ‘Wݸ–²tJã‡û%+®Ñ;³3¬\‡,fÈÿ%fˆì~/ñkò±-À§*h³pÕ¶cz«P%r¼äJUw·m³Z1-ЭÔ|¯X²²¿t—oHh1•ŽsB/‰[y„ -ô ËàsQ¼\¶\9Ü·†ò~?Ó“PG„ïÃÇ>ó“ôHN4[Íè*ÈÆEN‹ÈÓÌ4/šjgcG”ìø‘T¤<êå܆¥:P ºPys´ê ƒ1€¡Îv´]êl׿€ª+11À@ †ÂýY]‚ÖiL9ÔËÀÀÆn¼pâBÌ@iAH>yŽó¨£’bç êš4Is½Ôቋ¼zôhL6«™‡ÿûtN÷²öl!þÒŠ¯°âŠTÛª7L<<¹É´£ª›=ÐY+ÀÙ1[,,¼2R zÀ2AC=ä÷%œ[Lk,eÑÆ47 A­-Õ9Äut¢S#ây­åHz.+(ƒõ꤫÷W1Ìȧ>NwÓAZN@šÍç¨Óøã¤+A031!=f0þÑÉRŒÐ'AûbÑÉËÃ’ûñ€¤=Ú«Ú^OÕ€õ€»3•„+hcT2_Ò§+WЂ RÖ¬± í÷ûFÌBˆ²Ý¤­aó(p^8ù22ÓüFS+¼\°Â‘rD×kBƒl̈법ÿ2?ˆ»?ÖúoèŠ$X}²P¶dÙT¬<CKè•›öœ¹Ë³PRý£‚«<ô-ð€±ÅZ"àÎ&»cq7–IËháÀÐCwWña± Ïð àHÌJ\x|ty\aZF‰@9©Åå4Ü10™ÎyKÓÝžÔšFÃ9¼Ø‰;hì.]‚øÁ…¤vÕ xJP›kFãµY£‹œZr«üßô@!T0˜å1®åÅw8q»?´áRqa‹ñ7inkqëMÅüM{›`…îH\B”©3zíÇ€X×K­ÆŸ5XeÿÆÁÈ ¢7‘Yó`fþ|L˹_cĹaß§»ª(¦bUž¾CaùVþßPž¹ÓJÞ6ì–2œbüŠQ,n€i±p†S¼Ìq+­=z­\ÉõŽ:mA¨ç'»¼SÁIŸøìHdS8=ÈÕœà%èšzvLè”jÌJ¨±R& K˜Ä¹NŽìqls´4Y[LöP¥NêúPÞ÷>å±íïÂêÂê—ÕT¦‹ù%ã÷p)"@uÅÀà¶mL¾ÐaÒàÒ>ý>GÇ.{βԫÈ}ÌzÐq(Ý̃ ØÆ»„®ã–\‡^ãâÿ„²'|NsÜ5ÀúA]ªîœ5FøìK˜ÅȉÏê2Òû>Îú@0U.ýÝ–^PA~« ™)ÛéQ#>¸QþÕ27Ùæ8é¶Ï Ì×±oÃ~„ÆÞR)m™œ“ljb<ÊI:-((}aŠk̘rD€/fÿ¶ÝBšÍ‚›Í(lfùXÞ]ý¦îgµ^'c©ªÄK«é¾TKÜfm­JÚ©>å¨ñô›2úûž÷žåAbÁ²Ê»ÒJ>?Y“F3&¥ÂB"RVAösÖëË€ái=mo÷‹´\Ø1©×a<šÓZöâ}Î\¦¸ÍáÖKÈ“2®Ý¬ü7}³ÿ:JªUÖ Sì¥cI«¿Ö†ÊDoœNc¬Ýl!PêÏ!ô¿Iû^ÞVþ€ººÊ@-Nü#X° ¼òXükÁ¢ÄÀó$J|8¯"„¶úX3‚À€ý l"Dÿød/¿—ÿô©ŒG°€Ìš5eª$O_ΕÿòÌç3¥ADüô%ýw´ ¾ ùøI:•çÊ *ؤºÕjÔ‚ü ¬K•êT´ù*äS›ÑŠi”¢DÁyÿŽ$L(ïÞÞ{ÿ0ü»Gà†Â¾˜ðc‚åMæ›ð^ y'浘G//½!>ä[ºâŸKõåûBb †[Td!ðßÿÂ…•Þžl[â ,€ /‘—‘Æ"XøwmÙ¿ç"—]ûwƒàJ˜ÙcÞl‰Óû¿š3u΄¹slÍò¡6]¯êL–ñ·4K_%Z¬ÜµªÌÇ%Ù¨Òšª‚ Z`äÒèƒ !¢ÜXò‹ À ³ð¯‚s,2„ZâŸNXB `ƒ¡Îè¡çŸY a¨bŒY-„9;3ÎêDÝXPh2!ƒ®!!o Î"‚æ€ þù™‘–±r‘€Á‡  Fˆ/,–\o(1q¯¨3Ñ Ï ÿx’)(™ŽâÎxj%³°‹¬¬²²‰À¤«Ï²² L©­ÿJª¥6JC$ø`Ò&ç12²½ö"àˆ¿ÛË #(“Œ &| q³¼NåQ¢óúÇž>°g4LCðŸP³±5;C•³y4N ˆâ­6…’”Œ2ça„A(hÅ‚QJ¢î™ç–… /iÒ.½‚tŠGÌxŠ¢¯¦2 2á§¢V*×Í/ÿCÊ °ÀôoPÿúp¨ùæ,˦ëèãçþàœïMDŒ D†Ð'RŸœ¢…üŒ€ špTA„hEÏ@öUÅ -V¶:j‚bÔ5Iî,¢¼x¢ÆãU<5ü‡˜Lp(ré„kwêšôUÄxáò?‰2"?âfAY%‹ØK«BŸ±\ÅO~b¢AX…¤EòÓ$Á"œkÿ.Ž3̆@„Íøª ¼c#_…Ç‚ †2d ÿñЍâð|…(á ò¡áç¤&5¿3*Žy‘d¼ ’— hC8š”z'lýcÖ—*ÉÔ“èÐ ãSót"¾r•­y)ù[|®gz©„™wjbŸ®ò½(Ñ¥y¢=’}Œ`”°€¼% ÈoR"Xªœ qª0ÿÀXAN5³’ŒE”Š•hØ¢À汓 üÇ­b¤Š€U‚” kYY:ÙH5«ù@æøéª‚4“™¹dBÂI@0Ä´:òPèDi(Qe¸b9éÕ£å*"¹ÌeÄëìÿ:‘…Ó-5Ÿ›P¥ €ÚSYöƒ*f'W¼ÎPÆòD• døè)Ã$ I} (©€=ÇFØö62 l÷™’Ù‘Ž¬AàU±v”?d¯° ™ëƒØÓžÿØ@YïÉÎ\Ñh.¬‘&n'¢7‰ À¹ÍÍ&0½^@G³Àj±­æLK?ðÒœ¦65«õ°&må»ÊÄ®½ <ñ(@€Ž”6,‡òJXöc¨¹Ö>þêÓœ¥¾Ób‘°²›òø‘0æDà} BÙÁh,Â(•©ù-â9+XÑg42F jb°Âåa§è¾d]é"È45R Áüù ÉÁ53™ÿÉÍÍä!‘g ÍB¤ÔßaëÍ1å?R–üÂÒ‡“x´¶&ðÜd–’ý’LZ=E±Ô¾É¢Ÿ²÷/·‰Å¥S¤s2ÆL¸!‚¬qIN‚`;2ÚO!'Pˆ§¾¤¸Iµ5SÖ*0“²%W¹¢SEs[ÝzR‚%>°ò=ïÙÕ/E¬™tDhv³Û”@²†õB€ƒ‘ tòžŒÀRA¥çlùø`À—ã5“2¹¤L‡ZžKr¸Jý¥( pMÊÖ¨7ᲈšeÛ•hÚÒ‚v+ n[eW2̺ýp%O [><º· .AÇdüâ—Åæ‚29íQÇ”Uš%G ÿ*ÿxð®FwðŒntO=j\eWC‘ÕƒZ¥£ÝÀZ’è•P|ÜvÌm8´qkS¡N‹Ë‹±,º}a¨.†A ˆºà°¤Q9•j‘9B™Ñ€¬Ô(¸·¾ê‰B²•z"»ˆ€é"” – ØÊš9WKq»£ ë9î[†gèÁk… 9Qª1—2"Ó€qñ¸š±‰¬à˹”’¸Ñ3=k¦ë°› +­xá*º ¾éajžX`™(™€y8‚PÉÿp¢Р‚Á=Jä°<Ђ>T%ABµëªW@A´+Aè‚.Q£„:‰›*ÄÁ ¸²XC‘ºÓŒg‘–ø$Þ©–‚Ø2¥)ЯÃs›rщWú‡S0˜0—ñ+ìp‘‚ÂãA dŠ•Xù¿tÛ0*´°á¿þ¸Ü+€³)* 0T !¼ÀÑY{§‚ q$«ÀûְƬɕ(¤x2 Ó z*{Ú©®25E¤¸È}ø'DrµÐ šé¸‚b’¡é*+£d¦1ˆšîÑ¥Æk%È˨:°´¡¥oi ÷ˆ9ãBUÒ ìˆ ã?õq¢W±Bÿ:;·ø(Ž4"Ó@ñY›9ù°„‰€¹°‹Qq W12 J‘4تG“bA9 ƒèÃøðF\9+ƒ.4Á@µR£„.RDC:2šœSJÅ™ ‚Y+‹|À*é>ƒÀ”ÐŽžˆ!qù(j[¥f[¿ªY¼7›?–ˆ3œã,:òòáȸ1 ˜::ÿª”É›ÌÚÈ)Ò"¥¸`6ŒaXA:ûPåQ=ÔÖ9 mT¥xšÌAâF ºLS#Gƒ0Ç2ÊÔhùqµ&q5Š(ˆ'a‘õ‚J+ÓG‚x‚x†Oê""¿Rt®A¶Žâ€°à3Æ ˜¬‹ÿÊ3ˆ«Šdj“:K·ƒ º®8&*=0Ô9aìȹñ¬ªø¾œ‹€xŒè$ ½ºC[\©z³æÙ‰Z)8óÀ–)–àFM[;x…³“.Q+IJêËut‘Ë9Ò¼:zp4’Dh+aPRž 0„V<Â0Y,ƒ¼MqiðhÂô$"³T7ÝLKx©)8ÉÎW=a̹aìÈûc-Δ¸¹¨‹×šÖ²€VÈQ ЫĜ1°´ëÑÀ¦`OÈD ›¼Ioä£"Xø#U µ®’.äÛÌ‚ +[]€“+HÔR2ªC Xæ°a‰-‘b3Æ\¥ÿþ ˜ Ÿp ËkÛZäB«X½!B›ÍJ&1b"%RŸ'ÒE”¬ѳ)µÅ½‰1ïÁ“dúŠ£0š!˜ah†fa†ZH=×Zµ£3Òx­6ÃÀ4µIuÒ"S+С$\sl¸x±Òa ÑðÏø˜—„¸(J!€h ×,¥”Û¨ÊÍäÙ¯ú(:‰,jÓSDቻ¼Ëì)ÑŸS"]l“'2¦»!@ñÔ‹„N1ŒÎ9D"Ðë%µhŠÈQKm†gd¨…MÕT“¤*J[µzÔSk´É™0R›¼±ÓP+z‘1.Y§>Dý<žAÃÒu”4¬c‰2š”ÿ|0}бyJÖ¥yMS:ÚÔ2i?lÓ8K>[E¢@?¼ ­Ïë¬>ÍŠ‹Nµ©©­0:Ô:˜ó½þ€•0äG=Q¢£Š@ù \YæxM_øað‘(SƒPŸó| ÂÉÀÔH L‰”ÐÃÕ€™Ðèzhá'=Ú£Z pT%²b.D`µËá•ÑäU‚œ¢Óù…WÖf¼g˜¨­Ùªù"Ü– ×ä¦#¤¶¶¹E·ù,[|~a‰e½ÚÚ°éÌ"›JTaܰ|¨©Ïm“³œÎ9âŸýÑ£“Ù*2 ¦‘Z!8Kõ Þ»F™`AÓÁ ÙyÀ ÿàmá§â" #ý£³«ž‡ú'Ý’;‚H¨Œ5«W\¸Þ\è…`Ý2‚Ø’ŠR0Ä —i›ª)Šw‘Ó–í\X¡ètT?IÔ ó>Îõž[ü!Yù\ý%FŠŠö½ bT¥ÍMÑWéHî8=¢l…Ký_ÚfhÚ%šySžÑªÈÂ@ÓaAßs‘ÍÀŒÉØ·&@ˆ¼(¸ªô´I à#†e‰¥]Z´CÇøÚ–l^zª™à©´{Uø…\p'p^€†Á<+¬ñ¥61AâŠbÜ4# ­!ÎtûB##:6ûDe G½ Z-Fñéâ%`ïñbƒXK·Øˆÿ2ÕÔZpZ7š™ÕXYÇÈ"OöPH [NˆØ76®ÓhÏÒY®ä5ˆK¸ PdE~aˆ T¤ó'}ÓE«WHäWèðaíV.«€ Ðêùʯì‰Rf ééÈ*N×@ýB¢ ãuãÑ ãéìâU>Ñã™e{p‚›€^†(ø‡_NQ((€_f“]^ÑÓ½”h!øƒ†NÝ>ÝYWª‚Xá‚`äEnçK@;A¢€™•:Ìx-åxg¾äDî…_ø'ø…K€Ж(ôžÅ=èà#]+Æ\›Ú¡-ãøfÿñ:êåÃhXq‚Yv‚µ_Ö»â]V]¦è9b D°2‘ðL ahñ,ä8r¶ã§H :c‰‰pаªPMÌ>oTÄ#Ÿ*! FF»@ 9N¨6Ð.Zä³yêghƒ_âÁÃë4…ëQã>kÎhV®@šúh¦£`¶h‚°h¹.¹®kŽ>ѺæŽk P'ì0éYKõd‚hÚ‘#˜K‹C Ub«á~ò7<"g=:Rœ,Že[!hd£tŠó\CU¢„á_PÖþ‡Kè…^f¾°=Q&kÜÎmU lÞVÿÂömßnƒÂ†áÆ6 ‡ììh“¶hŽVîÂn{h{  XÐpnѽi!Å>¡!8ÌyóÓÜs›½É:ùZ˜i âb5µÖ¹2Þã½±ð#²2ˆ¥Md   ¢3 ¨äS¢œ§Aü£ú|gMæêKزg€†°]Ý®ðà[K‚ðí‚0i5™ÈnîÆîìömìÎðíþð¿>q“énìÖn /ˆ6ЂÐÿpÏpî ÄVÐزfˆiM£Kâ*Oú gõ|гU ‚e G^ÌÞËž7²±åZ.ýÎÏøÐgчµ°XŒÅX3ŒÒjíu&ˆ_àêÿ^⨙o Ïmä¶pyq—qß®q ·óg :ïóîË©ñ·ñŸqÀ®ñW}°Ô/#‚qÉiT” æ®êáZ– GJËa‹(À*°5[Z'D.Dv>¡è‚X#Ó=£y‹.Š {:5¸èzí­ÎÞa½†kø¤W¡ë6¯ðW°í>tìÖðÈs¤šn;_‘eGqßp/¯q2îþj7™|h×.S XIqIÐø7sÒºÅT™AÖ®£ ~B“y‘ÊCÔØ§ÏU+ç)Ö}g׿w,• ÚM¨,Aû\»D¾Uxm×þ‡^h\×õ]ß ÿºfó_ǹl?<ÿ‡ÈölßødçóàãøBö=·ö‚ óXy‹¥eì!ÈØl ‘pR‘F¢ç(U­Õ•!ãÚuŒ‚F‚ÁˉšŸ•¥Srô…Ug×®d}WD”àÑ]3C¢´€n\ÖŽmØ6ˆØohx†fˆ€ @*{öŠ?h²/¬Œ¿vkG* `û/û §qÑøþ‡òž‡ÀÄ·}›ŒÑ š—܃e §`§”`‹Íñ )‘zóàßM‘Ðø€\€|Èß#áûìK`êþÖò÷YŠòn… è)Eì4Èøg†moø_h޾õ^¸·p¶×xW¶§ö³}ÜÿЀÿ¥]hhŒnj yaÛˆ#Ù”QÏ?Z€&5ÒEBüšI|½—‡^á (·E}XýÇ«fŽw®ä €.®%œ•î)ŸµÔpÒwÒßz†ç~¾ýAPÎ}ݦý ¿qÚ¿ý/ˆþ $8ð„ 2lèð!D„öèé‚0‚>òþXØdcÂ'Zh˜G/Dˆ(ô)\áÃÇ? ?„ü7!Êy-^üà Oç<œ!>äJˆ(¡ª”(!¼DéRB¨”®@da+ D ÁÇŠQœäÊåÂů^ Õ^kv Ø ÿ D¬k×nŒ5äÕË÷à]„.l"½‰%ÿòŽòäµ`ÑBç‰ 3¤w!Ë„/]®X!"´â ÿæ¡Ô÷!D‹Ø;[@‘O¦ýÒ­ÐSàJ™&$îcˆ¸)´ú·!B ÿ"¨:ë¡Y´ÿ öJûÏq3`ä._Wƒ}ÑëU¡âßû÷…óòÕÛ×<þºôTг÷Oß%¼2ÄjÿXvPž Ùd”`’mÿ!EÉK>$uZ> %ÖÂgúèó@pÙPúè¶À+¥©øÊ?I½´NS””–+Ü ÝtÒQòŠ¿üòÏud]‡Zl!Œ@á_~Q"ô^béY©Â^ï †%—ui)Ÿ”a*¤ÿAb!Â@‰hÒgAm4BžàY>ù˜øOXIÙˆç F…b«%Â?|ˆRkˆ„¥B)þÃ"LÂÁ„ÐRÅ¥`…µB+<ÝT?ª’Ö/ו‹wj½â4nácÈPŠQz‚±7O—ðÁ7PbXNÉPz‰9ÄÞ¬Å.Ä"(†”g ™¤Z ½é =Þ©Ê¢©¢Ši† ìI(©ôm†ÞɧBܦ(£MQj©BL•ÖtÐQ¢ÕRªñZBþãÄQµ 0×àB\²‹W¢¸z% ùʘ 奞Ä]¼0~È'¡&­ö H«¥üO´÷Ü3ÿ™Hš˜§q–&ÂiQú-¹:ÿç¡>ˆçQxþ¦LÄÁ8c¼eûÏDàœVJ½¢J’¿´ñYÞ½²j3ÿ\ó.$l±^t…‰eÃëz–›P­ÁZ9¬­ÔÈQÒÞ$óÜÂ?)S6Yd.GF€Ëòœ ³naEú¨…ŠÎ„"¤R.v²Ä"ÉáŒ3B+¨BaM?Õ®B¯ 85ÔSC·”`Ío¿eü ¦¸CöE+,¥te©«Cñõjñݾbyܵþú«ôu÷]Þ~*ä³Â,A°àHšI¶ Ë!D¼Ü¬rº¥ç?/±Ø­>€ÚÿÏ:gøÿsУ“î>Ò”†©íøˆF-AV¸’ÅÈB½x  ¶öÝ}GBÁÆSY© >PÈX`|Õ°NÉ=íR•v(…´á=-ÜÏ~‚U1Á8bw»žyz…%z0€, áF’Â9ßËæa;)Çt(š¶4u}t®NÿÀç$ä¡ät‹‹ª˜Tür‰è)S)Ž£8åœüÀ+Œ¢Ð%`¢"¬¯ Q+ð‹àc(€=üS؃.ì ]TpÈŒ™°=$$˜„ÅH„ì'‘íˆó0‰Ãà Kö%‚ °à'ÿˆÌOæ!#2Î|§TŒmú'¹w•.ÿ)ÜšâÏꔋìÏN§QNñ´­ø ç)«ÛŽ”Ö.›ÝˆO“BB…¤tGHsä×?„ð X`ÿE\R€„ŒÓ€g`™E®Ó=ñ9–„EI´ð.š¼}ܶI‡ÀK[kƒøBµ  ÚkÑyt¤#÷peb2:¨½bR¶{Z‹T¡ qÔZ qÐÚg:Ó½Q€”`4‹ƒ'(ÊS]©BÀR„^PóªR‹0.a•<ŽbàG*P€ n!‚4'R ȹ²©Ozj!1ö{@r˳X éÉ¥ô´«]ºß:¶Oˆ`bðQAà}„h5 ÿ1h¡Jy¼¬ApJˆ,6ùq+~¥¹å/CŠW ‰®–a<,8@¦`êE¡sæ?¤;éÜìªã%Ô’Þ=JCÈÊ77 ŽsƒBý#Bö§¤BÉ?®ý:§ú$x’ªT%¤CüC Jné­Xõ¹ZÕ³«Zõ*r«\ã7Xð‰aÅø3‚P¢d5‘Ì<‚2×8-È&CMèöµ¨ÓUÈB‚É-Wà‚ä 4îmâ¾TÁ¢Ã*SÊ4ãB`ÂREÁ :Óé“ö…ÙKÈ÷QÁ qƒàƒ 8 PaË( µÂ  lñÇ| sœžê9%2Õ O’¯Å-ÿCìѪvl -Üa¦VZ‰ua[ÛêqC‘¬à4 ÁD´œ¬2rálã9`š·˜?’TEGz3Òæ4Éæ_¿H˧ÄH:N‰ì½*˜P`§+˜¬t"ð –,ª)P¹£cr 0G:øˆÀ ŠT¢•!þ?>°á 쯜ùˆ•jÅ)ÎX±Øb¶}Ïmw[â†È¸ ‰ñ±n¬ir:¹Ìí´r+ ]»'CÝ»@†Ù&Ù]¨4 _¹4>`Ñ|)œŠfT7þÃÙz'¸©iÞ:¦ÅŠS–‚lKÙ7)âÔ™#«•4Û()q„É€-ò _@Á?Eƒoÿ@£u!Ї\"œò $ÝD ô†á}EÀ¡cº±V¬ÈÖÒÐ’—~› –%VR1öX% Ag @£l°*ÙÉæ¡íJàŠfESW#×–z ðÉ'x¼fMaŠj eòH)În…ïe!àk)¨;yd…á˜EAÀlÄÅ(6Ð q@Jñös†òÔ /"¸åÔY, 4ý!×Ðs³Ý^õª¬*Ü:|>í0-%Ä+°@+²ò;aD@¯ILb$¾  èÃã¾rRU쇼èâMÈ•}“”ÒTôâõ±-E­È"U³WW¤3s ÒÜæMÉõw¶mÿ@ |$Û(~𠌻ôˆ(3D|ŽÀí܈àºÿˆs³¾ÜU­‹m§'‘^ÙCz^´¯B7W5ë?q¬DÐ\ΆšWBUI'ÅÙÀQðž"e²NR )¬È…9ÒóQǶ|¥”#!°ŸæøŠ|ÕÚOs•‚‘QŽ¡„$0 \€?ðBŒÛ? Á øÜP€!ŒÛéÉž:D¹ECÈEUå¤ÁG£MZ¬SÖQ• ××ñÊsQI*†’àCdCôŒùVØ™É?BC-´ÂLÀ?@=< B0Ë ÐÜÐèQ}ÞÞu B\Ùá]¼W~±ÿ‹BÌÜ9ßÌá‹ú)„µÜRLŽùAƒ0 APÀ\Œ2€B€À?ˆ[2`ÑÝÀ¾áB`ÑØÅNZî9Ý M„ÖÉܬÐpÅ`â "™ K zà?Xš‹é…nUD3 ¡Hž¤2º$êÉaŽ[L^c4ªäbæG€PÙ!Oßb×9—>iÒ˜ °FQ"„/X€2ÿš=„ÀDø‡>@Ã50Eh÷‡K¸N?øIrìËW‚%L@ÊDc½ ZÆâA$CêZ.VHS¬@>ÌC (ç<€+äe*x¦/ LcJ£HN#4Š› fcŠä¬dLÓ= Ñ ØÍy¦ç%Þ¤9æî‡ñm¦|€ŒMB AÅ‘ ¾RˆÀ5@CRÜÉ `^üˆÞ÷ôCèH­WoÜ_MJýåZý½‘t@N¡ã% j›h´TX›šÄ± ”€s*„/üÃ2øÂè!f4*Øéµ$K–^JBcÎ(éEcâGÕ5„þ à |à Å=©zìÿÇÞ ÅxL'áJI¤‘þž}T#GØDhNC„@p!×´·ÜZX‡Í^R”2(Ь—F­À/˜¤^Az_¼¬†:ßCB$DÎßÔ€å0éF B>$F °B¸Â‚@- ã?øB*”ÞŽ–daâè5E™É¤QljßxéCÄ@ˆ*Ú¬†|àJbˆ*ÕåE’Î$©N)–ÌÃ_« „¬ÞjIÄ*_˜DØ'Büi–g$ ×è¶ÐéšG²…Ñš&ĸ雉nÌé¶ä&ñZßÇ´ùfZVBÄ¢t€…¯KéCrþC ”L€+üb€@*@êgŽÿúœ‚!`.f*ê(Àz*<öM¬4D¬0åˆ-e’2‚¨"l«æà},„\‘ª©®FÄÒÍ<„ÆDƪÆ<´‚c8ß{)ÌhÒL¬@H@.˜HrpK–½å²Ǩ˜ÆGyhlÑupnZùŪT8ŸzèBÄ"%dË›vÔkpðÀ/ÖÃ?Äë¼£/Ô2ú22#"$``ì&A MØC¬Ð#Ð#ØSš-Ü•mÙ6¬ÙB ò-©šDÛ*†\½G àJÇnfÞÒSÅÅf—!è0À`+|ÈkŒ¦=8ä% „@.„ËN™FÎ0â-¨„¬¬›>ÿèH=kUh¼hÅ9pú©C†¡k¸)B|ÀÔ†+¸ëÔÃHí£úBÕRÀr*DŒäÖ–YoÀö¨±ˆ-Ù,%±mB8¯ÙÚíRÎCÙ*,õúaß®jPÚ±,„ÇNý`¬€0ݰR’$K…çHM®äÂiæöìˆHIH™ÈzáLop˶ô£±5—½à·.[}Žj MÅ…€Óþƒ+PbÔCÄë?P­Õà?dãC‚\GpðXA#øX Ÿí ãóJoÜÉÕj ìRÆíô&éõöÅÄÊÕßfoÞîà}@@+t(Ú]‘mУ~ ÁZÕJ,ÿ‘èL ¸L´@˜Å¯ý¾!‘€ÆÊîïÌXXšŸÏ>D˜eÓCÞ q„ñÀ‰ìñƒZ¡<ðsþÔBm¤Â¼"u`xDH@ø1 ÿ±\ägCXˆIø˜ ®ÖR2õ±mÚHàðöRÒ"Sfòó^/SÞ%OlÇ&ÄrECçZ²=øTìO¸D/¡«æÈF ÄïYôF•†r°DQpÔ¯ún«á9„ͱeËM‡ËUÊÓ0Kš ÎklÛ/ºB=ðÀ˱ÔJgt"Á- #ü"BT»-8Š+„‚:o-6þ±”|@\€%ÿrØàTÀ +]*Äõ6òþ-@¿°>w,o2@S/Bç- ós Ðç(XÄ+¸FâÊ“”â·Ð²gÄ’‰äCY”KD±‡I²þÝ/+ƒRëÿdTB€¢B¼”åµ4SLW ÷ˆÀ(>üÙþQ"SsBL°ÔF'‹J*^À-üb9oÛ|].rCÜó¶ÁsÅ¥3ò† r"#ÄR׳ìÊ.þØ †1DPôõ–µ ÿs?Ç@Ac²Y#ô'Oò *ç´‚‡’Œâ&¬=l=,Ô=|DlЉ‰pTƒ¢kQ´¬”ý‚T>äïðot±æFDWÄtK7MB G¼e†9mßÿ.%ÈO#Õ¶(2„ä-h5S¶Úa8õ¬²+Äij\@5X/ò>#¬mYÝà ‡#@ ¯5oOopW²C ìßB7!sâ’&MöÇ¡¶L_/‡Àr{ázíïW"DowøÙl°áŒidÙ-6‹ÈNBt¹4츞ðØ lØ¡ÑÄ<°/#D¼>ê£Fj‹‚@= Ü ¬«AýÃ-w]xu~òÇsÆö¶áÏL`ò"YÙ=`8õ·[{øo/´[4BO¯j³u\ ì$‡âRŸ 8gL„lHFá4gÀòÏ¡ÿdTènÊV Gžo€e?Îÿ‹ È+¼-e Fù@ ˆ“3óQÄ k£2*C@mÔÊëÔÖïN'¸‚+ÀBt—aìó?¸syx°ê!A£3„Ëö„;2SjÎ"Ûà<Ø #ü6C™v-%ˆ t[»°p#p7 Ì™5ðgŒ=jH<±ƒpÈI,ÑÝI€é²éÄ—ß©Hý m>vž¸L8[£8¥7…È4{ƒEéðØë9Ëìò™+„–ƒ6W°¼Rm¤V-$µ¢*êaœíº™y¼6œ#„„'„S³V3#€j±«8qßàß·B„pãp«}@süM4K F ,AlˆcF§„û]mâI—ÿŽŠ|·Í伇ÅyŸ·@ÊB‡z­)Ä ˆ€\БٷOßwBÔÃïzCꯧB8BºÖŰ€Å›èöº~¨ÞÇy»ýCl—|=_€ ÖóqoÛBßEˆ·?g2Ì#zøöóÎ|#+w8SÒ½ ††„NDŽ+Ù‘Î |¥as7àµ)ÐÐlä”é? Â}Í™µ¥ Ö{”»7Ô舡R8ç!„5Cð–7|óºP#D‹þBx]hü?X¼ºŽu¡D‰‡°È“<´·›þ…5jÓ†M;kC† úË'>Ì7 s^&‡ø J@X¼gT Üi™°O¸ ÿÄæ+1Έ@Z1bãÕ%¡Ñ¸ì£,9l¢:(N “3Š”§¡ì©^»ò¡P³­“}CÐqÔZpBøÂ2Ô˜9‚—GÆ#rB¨³/l;øþ…¡ÄF;Ëó9µ7Djû³Ä"l¢#þö÷9&Ï<|À¸eÝJ9^b%_ºÎ,îI¼.Ëþ $àéÃ/ ÐŒC=®IyŠÄJ¯ü3x’À>VDøWð „ üãñÏÕA f<˜Ä? Rôå«Ö?$$nÝbQbcL÷Žücap™;y¬€Äп .¨48ô Ñ sæüá£QŸîd$Õ`ÅžOAè*ÿk̯ý“0Þ¿´5ôt’/_ƒ!œ„ȧï?{ÿ­(²¢oß"VW_®|¹ðî%ÜWÕŠW+¼RÕwe‚ÿ|DX°4¥Ð)Sø§O‡S…òpuÑUFëÕ2Rdª”}¥JàªèÖ˜55^•(œgPƒ† ý¬ÐÜ $D% ½0¡Bĉ¥JÀh)O¯ß½n?¸tiWð뵂-¿q‚¾Óôèa]Ûv'½öìæ³Åž¢¸ë "þQA_9p…È  5Äs,°b(³‚2‹€²<|È3Ñú‡ ‚ B¤, x¸È zk±¶ÜþI¥¤|™ñŸzhéÿŸ[þ©§{:â _”);œ;¨¹é$p®(ê.ø ¸œ O§­Ô#«¥* +½÷zR‚÷ ¨àD>@ë Ò`­ƒè«K@ó1( Æ 2PúTe-ÑÏð‚+Ÿkì À<Ð 7[ 5$ѳWú‡‚Ô.PÑ"ƒxp‘Ô˜f«­¶f¬…UÞzûíº° bማv"λ,Ü(É *À¤Š’È:¢”ª`‚¢¬´ŠËf·Üò¬¤zoÚƒd•)¼§(¢Gü'zT˜ç ð‹‰¿ü»®óqÁ}(Á ÈJDpÈèÍ%„»KÞÇcè2À0Ó ÿ"‚+±²†kŬ V<È•z2rq¶ƒ† Í€TS¹ñŸ”Nòå$v¼àFn)ÁÇj5èe°œÚ•Éå”ln(œúÇØb .¦ð¼Ü®¢lƒæ '¤£­*&3Á‹¶¼,ó™'†æ™Îrµ>—¾~óq⟷¤+„<õy/Ø óé·_~¥×à¾ZD„æðýv0 Ô¤ˆ‡ŠbãqØbÚ˜Ôz@ ùÆV}Y¦–ß\™à–¥Œ¤•sâ`Ί‘Ž£™§'‡2ý¹$ƒ¾nY™×«*L2±úr;i™³8ÐÏ;èÌ’L‹žª58Áêˆ?h?úøs¢.úœ§+вÌsÿ1ÄË%úôƒ;ŠÆè¥ÛQÊ +hÁ†ÚvhÒÌ â!(<#iûÇú[ÌØÅ@ÒÍÆÝlì )Ê-Hp—Ô ´ÚˆT€FºÒetÓ)VQ°Ã:ƒ´Ž)OËàw8Ÿi=K=)Ïx 5²èãjKWñB®@-ôiœZ@܇Îs^ [Яòð†q*›¿îâ˜-L|éÛƒ 2™Ê(1Rœ’@ÊÄ"WÔ/GY´ŸêÇŘèo$$aÕIL‚’$ €(+ FlÅF›HEW䉓~e, ö,YÈâ™y\÷¬‡ƒ¯ ZXÂâC’‰waBæ1… …Œÿ@ ¹XøþÐã8Ôä&9ÉIy´à÷e >…D/zpñÓ¶É8ŒCIl) ŠL¬#£Ò¥‹ê'?.fìCxÜHtCFƒÔâ$ȨÅ‘€¹˜És牣c2º 4uÖñ ¯ãÀ?N`5Kù¦TVãA܇vDó +Iãk䚇=ìÉœ` -Èg@Ù„ð3ˆ-øG Jpà†¥@Õ®~uÏ{yŒ£4R¾ým|CE²bÔC~õÀ¢HÂE‹iä6 £njA#—"Ó£@# œù#–Õ¤7¡¤Ñ¨YMc ð¡ Ï–¢Ç­t'éá©ÿµøˆ-´ô€Ê?±Fœàj™d„óæAÊ%È£ `kü)$HO{ÁÀ@ Ò¹- QQp£ôR¡YBq#€‰%`Ò4ºú½Æ£<À"ýHÚ1‹ˆ¤0JÃHÌ—"sÀ(pøH–½H-©ˆN€ÕÓ¤è¬XÙ4V'€¦2%w¹–µ–ŠZA2ë¬]BÑT3Ðöó× Np±Þ£¬2™G¿ô}¬æšôW.˜+! -æNâ D6K¾Aì7ø‡rþAù•”‹]Dl‹è÷WÅ.Vé­O²ŒT¤q; iWfÀƒL“šØ4êžTl)…¨ÈA*O^ÿËTÒ'ò‘Ï0)'Ûþ#”>è(•ûPU† ˆqcn.~!‚_ f0§‘A¢Ë(zÅ0ii4rÀ”¬`ËkÒÁŽÊ°ö³Ÿ`kRT¥*dÈD¦~p8#pÅ‘[Â2#I`t¤cŽ~ýû³ŸõLÇê&Xv·N@~¹v­Uª3fäR"eqgWyËÛ%Hø 8¨B§ïdknq?ü ï&1w2]놙»lØ]°+À$<ðî`»x#®Æá=€6Íi£j¼Æ?@‚ؘš#K>2 P‚í(‹géxº$EùÊ×! QºÇÿ¦‡;ì —yú4c‡Ù;ë xBà”Y¯F 'Ç üiTQ¨Yåa! ô¡¹q‡ûÜʽ÷4áˉ+ÚÊ(¶Í4XôA }‘Áþ#ÿ8@:Ý‘Ž¸¨¼xA§; ðŠzÈ@FI~££ŒÂ Èaøù°û®‰·Aä]NµiAX£‚Àu~ì]üklfö}—ô¤ù±ãö×R—¦â,Å«t÷€ÿ€CŠ6FÍìˆ)BÙîG;,­µª 6˜³•rc7žØÉF )BÅì¬@Mj¹ZZºŠCßnR#B›¸Å ¯_|x¢¯ø°^¾WWžZ#¦™¥ì©JUG— ùæA¾sŸ{°¿Àß·=êQ};ùö3¸Ï»X1*ÓÊDFôQ¢LV±êÙoE+òîÙí2éâ£ûxÏ´yžì¨n'Â~üë¬~–3ËØ«¡­#kIúL“h¹Gô¢ç¢‡ò„1â¥/~á P0øbÄÖ-Ýš.¯¢Žêú¢,hn"æá*‚÷ ‚ÓÀî ùÀ®ëÂ+<0ø:¢b²à.G`±ÿVeŒ† %n%èN$â.ð!$¼o#ï(vð<¢Ä“þÜÁ^ëˈµ%Ï&B(@»^nóðïþn‹M検Â&lä*º:ÌÃ\É ¸°õj¯%Š'hO¢0O ?ñMñíðí âH0ø†ïøà’µHÉkíö‡¥bÐFG@ ½@¢, ¿–C"ˆbïz¦Ê˜‚üŽ;„ð´XëÌÁàc.pB É"MT·ä·à“lh t(lȦlÄ / p>Œ £®äå4Nì0úê–î &P iE¦(ŒÄ ¾øØð Â…oÖjÓÇE6¦ïÿTÅqHMU´wdL"%R!$ÒËqrгœƒ¿’‚ð´ YÚ)Ðý<ÈÌ0Ñä†mÀRKñÎ*+>À‡* xè¡-N@ŠÚ@† ‡zþAmè&0 oñÜØm4§, FŠâòMùÍâðHr/ÍN;F˜Z2( â q$Tª±¢F„,%vãúèŽFD7¼ïI$"(èŽO(ˆ"8ŠÊIGh’MµŒæZÐcw&漤[jÉæÔâ\nËxª EoõCó¢ éFÉpÖÄP&f èEö N†@'.ð òm$ï ¹Ž‹ÌNß«cÐ &ÿA‚&[a$³àî.ŒÄqFz²FB&È®odNbÈÑ'”cä°¬(Èebä˜jµÈ 'V«Ø#œ&@0O'(É XS "-ª  èlÊ&môwS/Ô†ªž.-E`Öβ®0 é…æ .$yoàJ_ Ò ¤â³‘Ô>"˜r0·Ñ hÒ±ÞîíÊh2¿QŽž×p-Í/<†êhÒÏÇd.ÄI*Q“æŽk’äD- ‚+ÛÏÖÃÄò ŠK/€s´-…S8]ïö"ÄÒ’"ôBygJ€$ómàæ0%MrTjc¬óáNT˜H-EÿIåá î:OT6æqƒ$BbóäÞïý¼éh ‚þÔ¤§4@µÒ†ð¬óLzã O sQ^FÌ"ѪöâBÉT/4†@> Œ1ñ0ùðPÇ®b.PûPWÐ6XÔø´ïdôEÓk1qôttГšÿ¦ÃI4‚ð6ó§„ V+ýÖÉäšj»$*Kk5´¢ÙJK'Œk57ÂM`ST±Ð Àf ÿAÐí7{Â-Ïõúµ-/tÄÚg. ‚$‘ø|uàþʼê‡Oc„sȶSí 6býTEõ‡»‘7Õ'¶+u‚ÒŽÆo†´eR=¶§Z‡"–¥¯©5yÂ6?q.è•îU¢pq‹K>ãBÓ Ú’S"/ AÁRc99ô ÎWå:³ˆE¾KbÓ¼4Â60¶T*öbgOYP¥1ZU¨°ÌÊÚµ„â=ßS%?ÅV[05ÿ¡Ô„ж"@Ê©_ôQ.4‚U%ŠLÿOÌ4Ø4-E ÝŽÊò HŽøvU#¸Hqªóbe«¶Tüpb­öaŽkáÄÈ tÔc5:zðHðHH·ÃlÝöEœB'šm"tÂC@5>€?®°fùclòl@ìuÄÈɰ®2”ªÐðAKB$ BtB ƒ Û<§iõ­ë\£:;æ£d¢ÁÓjçG{«–jUí€Fnt5¨¦#Xpd‡¢({æÊBλIR·Lu…#sbJrBtúÊRƒ¶ w÷c5þ#@ââNºÇé%0.R¢~¶mÒ1W"øW ÉEà,X#à#=*©·rÅV¹6{÷ô{Áw7Æ÷ÿyåšpæ|Õ7X4ÂWÏ´H+uç÷lA/@Çh»åV[—?†Ø.NéN>à.pöÄ cM9…ê*Ò‰ƒ6Ýò!5XcJ€VÖŠâ9ïT—.æE²Qû0&RŒJbPXu…Ò×:kgxæS>Å,†rÊm£$pø‚¶£Iuâ~AQ"‡Y`e÷¾D.tgeÂQZÏ4 ã"#_O#5$à^'ÀHò´¸/1bE —Œ_{d”­—bõ„q˜9xe:¢£:Þ¸:f9ŽމÊðäWu—"ް5™9…ÑMp¦Hyí•¶tålø–87ÄXh%$Ýÿ$bvó,[0 &^À“®ëîT‹.æ”õ9:ÓXœU¢ã È,`˜Rq™t•ò:â™J–JYhFJKðÐöž­„Ÿù“ÑZáZaÑPc#N‰w“8A¥x#9Åg#EP/ ‚§"K €Š©ä!µ¹“K2ë¤^#œ­·”õ8W0ÔÒ˜ZYY(ö(¤Ã €=³(¦Ä×tMRñK#¨d+æ™u”å:$¢)ü8K¦$5‚¢" >£PãmðK>î/,”_…Öx#šŠ‘˜¶E5²“!€^@q5Ù“sÏ‹¤·TFeWòÇcûŽ'R…íøÇœÅ9u ÁšZX:hyt¨d¨ÿ’$Y¨ätõè§yù¯¦›„:8[ùžïWtœ0";üq*ìB.]9Ïóè…gÍʲZvGœºb¸®†< QƒsobNЋOÙ­çwYÇ¥õç1Yyc‚"¨x¨x›9®I¸[øÊöHH/ ž“"~á8%HãYîùc£CW”wJ>Ű«oNC5ò‰YƒÄTÁ´¸ŒWÄ—5’¹»ÿ¨*®fÂZ£»M¬ñ-×ÒÔNjÏy'Te¶ËØùr[¿ƒÉföN#òZ¦eúdZ%²£¦C.Ö*±±÷ˆX$1ž%õt{Pupm*äøg Ì åvn7ÏXÜìÕÄÿùv¼óBÜyûo™-ªÈN ·ù^`EŒï¾ïçH¶q¤Ä­UåD©¶¿ÿsqÛtÛôîû Â7âÀª:H×'Bmï+)+ ¨üd·©Ëo—['²ÃJ ¬·¯–*{ å/QÄ .Ô¼#D;ò¬«ñ6ª`¶…2Z‹79Ò\°è‡Æ¼or©‰¿µQeTc&öÇÎ8É•»–<Ñ™¼fôNÁ[úg¦o:IÈ|*ˆ§ÏÏ3…0;Šj;h)î9ËP³:Dg–£E{ømìÂNª‰ u"$ Z×u½d«ä‰\໣1Òb#jï à„u+|¼¤©) Õkÿ| EÙŽ$TÒŸ¼f€j»†(¸}ðì:¨®iðÖy‚¤[)bY)©Üü:=Ì…E‰EJbYŽ?Ê¡­Y’ÐÂkWvÅM«Û\5v}´i+œ¨¨Sµ‚,PºmØ?rEý"Ýß’]r5{›½ŒŸ\ÈÃSÈu&µsÈIø{ÍÑû˜<(:NÒ­Ñd:¯íZ9¸ËÀüÎÝ:ôÚgŽÒÊ‚4Ÿ°g;çµi–w›+bœ>Tƒ?º{vMé©•w´7‚‘8O+ä䡯5âÆ#MÆ®ÈÞtŒ#0ærû;œ'FÓk;«F Ú³½L¾§”CÛ¼ãZÒy{梦ÿÏW:œÃ}m§;nUXëXIjú(öËÃÞ ß§¨;pk«Ê‰ºÚ”¼»²gת¤ŠMºr8„„ç÷#ƒ Æ °&ÐÁÞ›/ž;©V8H¥YE¾±Ä1îÂH$Dž„5VõŽèm¦t|;‚A{ŽÉXŽcן:ŽrXäøïzpÊ£CŽá@#Ä Ø[gyµ_Ä)À®É£5ƒg«¶ê)Vã ÍyÀ)…4&J j" æ“é»ë䜔 a§!¨Ù‹A½JÞsÄ_÷¸úê?Q«)$XV;¤0qyf—Ž…)&Ak,Çž1T)ÈÕôHŸE¨'IÙm÷oA#}¨R6 d³Pƒo;Á‰ÿSxâ|€b£ðŠH(R”=US¶å!òþƒdÖY¼$Ö¥3‰Áyªg€Þÿ?Qe¾n©¥–»žÍ¶Åklíe/Ë]ÑC#Gp§‚¥Aûà³È[Oç}nDB)Ñá’kèA?¥!R1b¾ÙRTð”‡4!âÕ¼ŸN-ÐèY/IÀ_²Â¥C/À^ØbaÀØafƒ™¶^ýjKCøš…¬„"a Iè•Q+N'ažÏ¾×ºÃ% ‹@A°»RRO¡¯Ù& ÿ`ôfªØf6Ùš»'åé—ÛÂÎ[tY-ζ³ïÒ–Q7­RÝà)$$bÉDËú€R¨Ÿqš;kÂU@Ãâ ¢§ÎáRÈÓÀþG[ná’sg§%MSmÙ03\ó+40¾óÝÙëUà‚ü²¸½lð[”€„¦ªK@Œ«|å‚ÔÙB2†FäpâVxKl>•u³|ç-¹8Ïo‰Ga†t ÿº€‡Þ„|ä#o  õÄnfÿñþùϱmõ-;¤-Ÿ68ã¾lp.ŸÚχÎqn´³ü äÚ.H¬˜ ñïþ¤j€]:T5² ®l‡H§äAìµX óŠA+OÒ5åÎ^ϸ¢îFSº@¼<ã¢q}ëj!]Æmìk>,—S¨$xaOkƒÏªol=|~@º½cí7XØÉuÔê>Ù§>5á –[?ØÁžÇ-è¢ö—q•GÉOa6øqM aHá0€}PÀ`Àö™7æúáɺ§õ%Ec„þÒË_÷€7ð‹¾{ã›ç} ÏnOgxÀÿà=H@…&Ô†90ðØ×z˜yÎUÿ²÷º÷e€Öep~à{€7vºç~Ø{î'nóÀ%‚!ˆM¢òtÿpcÑ|×RúÀ"`"ð™`4–Ô #“%Vd4F€ðXbãw-+ä€nS=à–jÀw~¼jÁöwàÖËö–ž÷„ö¢wMÓ#óÀjTÿ..€z¨÷2'‘ÑD H!>è†F“d®Ña/3#,jÇVt‡£l6"nE§wç¸{È6jc‘l"èlöw@,p)(HöÐÿ'ü`†ÿPÈ^Ð"€5ñh›Ô&Å Øg%w›‡±à}›ÿ]O¶.³“`0G!5tŒ np ˆ~ç„ÂwjÂ'ŒSH|· nÇg…w!r¡·‚ëâl<‚‚Õ8mððPàùàÿà7€RðŠ²¸BC 6­`P%©Óõhw¸ëåƒVâØ·ŽàCP{1JùwGkz¸JŒÃ˜lÃhˆ„3Œ~è$0ˆÉ¶$÷M3cØ”/ùrn”@¬`Ze@e „@ƒAÞè-“N  "À!`*G:AÅð_¶ò%C€ƒµb5´6ÿðX–p@Ø\Q’:ýÈP‹MVâ%Äöñÿ+ù!–z¨-‘‡-1;iù›Ç8î'Œ6rl!5ŒÏRÀÇ„ÉFhÀWy'xì¤Ê*&ˆ‚’ˆx\56“á(0ÙÆðM°Æ Ü“ü ,àxJÒƒ/À$Ð0}hBÀ&ا$WÂ0}q§øš s•²Éÿ Øôš¹YP_rwÁ"–l’EÅ¢/ñð‡tÇ6—ˈjJ'Œˆpg—zys‹xM¤B*a‚ò'€xÎ9b¨3öà'` K°M™Áÿ€™ˆ0ùˆ&/€}<àŽA0Òç0}A>„ðú%_"›®sНL®ÿ@^²›úQ1Ôux&é EwR63xȶ„æ'ÂWtàöwLRH%GÙ"ý :‘/\%‰ØH‘ùP4º˜á¡艞éi iô°˜\Õ“øã†®@š#“a%ìÑU @ Ãf®Ó”Ñÿðx(W:MX„@¼¡D‡#sÓ$xa'—6ó_—†|˜Wé„ó"{9Øq@ð©ýùùù žãi;úK`é’ù …A¤3…îq?WB%HyŸì‘¤ññØG YŠ¥ 3ª¸)&Zä‘A¦‘‘Š6M™–AtjCÿ8ávloÉ¡‰«¸—œqÚaÑi‘Y‚Ä™œù÷Ÿþb!…z¨¡£Œjm ö°˜`q?J%Øõˆ} 92 XÚAÐ[ZPŽq%`êI*HWªª¬ú &¼Â›©j¦ 9ycÓ€[‚pŸÖœ¾h~ r!yg—q©ˆIEWM>Ö©\ÕCò“¨Øyl!4©ôУ’™Æ€žŒz‰Ø%@›p®3/Ÿî¸ñ­ óšAPP:ëWZ )D lÆ;ª‡] 1î:¡°Ú"Ùj–q¹Œmi~¼7—sõÀê Knê&ÿ.0Ÿ±AP¨…Z­2‰¨èi•i4Inaoá ‡ÑƒFð<@ˆÁ©çʬ  -¡´.Ñ“…Û&U¤ª.á 1 ëj¦ÁB¡ñ¯œ¡6šqŒS—éçUjîç«]·N|f|#'r§›BøÂ™ìÓõ²öâlöÀ±ÿ`4ù’>Ô*NÀ±Tó$ØwWÒ‘F@³€®h™@¡ê:<  =û¥S‘¤Q*˜Ó6 ,ï›»I{׋ªq“–Wµ|)‘'‘uiµcçÆ7jžWl|v‚ÔC0-ëx³*faØ*âéjÛÿ£Žù¶mpÀQP£{5õ5[êƒÿ`ö‰®8¸ÊÑ››`c¯]Iª’j¥áªN‰¡ô*L´‘;¹6µÉfã%Z”¦•;M“·‡äÇ¡ åG|ÀÊBì«…‚"G‹H…‚¬Çú‘~Ñ¿?Î[¨ùpÀrkiua‘m¡šèñ²¯ƒ¼ŒîX%Gj•Ú &UR½ƒ»®öj¸ ÃÁÊD[ò€W0£4î*¦ŠªŠ_’½lö `rÂ,¾Byï¡Ã¿5…q9WpzyT§\‡‘Æ)%Àg¤ËNÒ±Ämâxª{±ý[S-ëöðX,žô@ÿ—Ø\œÀ2ùœ ùó:¬ó/ ³¼È«DVÃ%žÏë%wl½lVÂîš:ð½Ô%Ã%ñ¸‚ÜD®¡ÍI¾–à«E¼Ó€“¦Kœ~8j1v:8|f#‰—Ënów{b1j"Xt"—¿+šX82S0¬ÂÊR×1»aX,ëù=J­mp»â™;ͯb¤ja³I<°¥ö9ßz½ƒë: úšÁŠ'}õÚüúD® &VÊ;ˆ Š¦ÓˆÌ•©Ê6å{¡vw1g2ÔL[Gƒn_rƒÃN\ֹ쿃ˆlžÇgàñœçVʯ¡Áÿ> ª¬5þû…Z£Qôà/ ` ÿGÀaÌ“­s€WBÌ\sCÐËŒ®`ÓÇ%fÓÌ9}Ò¯¥š¥*¡ª+P¤ÇÚ³_’×1×ûàl "ü+ójÎkC@À‚¹°šßV—½÷ϘŒ¥M8ÍH|ô¼ˆTM¿\¬r[ :Ç ʪʄ!Ix1Ü—(”™Àñ¡çƒ0KŸæaÁ‰‘¤®ð¼Vr×Ñ%õø¥VúZ•Ñ=‰hÍŒÇ2]ÒŠ­›^ÙÈûê½EÙ'Íf3¼%åÛ1ù¾—½ÈöÁ´÷e˜‡yÄèrÈÄ^ºÒx¢6·ÄO'ÿ*8'uªË¬û"0íóÕ±eaøYl/ “0éú0¥t;×GÌÆ¼D0 ÝôÙ³uI¶‚Ý=i _ªS-¬ÓŽq&ãÝ”óÙ’½úá%;ýãayªZ”´;–µ¼ˆmò„ àãæß1‚á–|àa±&˜$ìã/ùRÐüK ãº-cŽ·û@á=Üí@/Ûè±ÑlÁ‡qýhÌ«$_⎶ªUrݺyŽ—ÝðñÁ/­^ò?MÔ³½ úÙÝ[¾ªjÈ”mÙCþ¯è›1AÈ%Ú&£ê—ç„y‰ßÈÆÏþì çë»å[-ÿu~QS©Ó:_ޱÌе›Å·ÝèëÑËG ‚q€³Òæñw 0G1©DǰÉ0Ë00Ž .:éŒh²éâ<îÈazPí­1ö ¾ä~lœÙ>qþ£ÛªÓ¡æ_#ïQ‚ºzàͲbË¿ÈÊå×É¿·^0ñåQ»À^£a8À¾ÞmÐëQΓc0F*âQÒÑ}~€üCŸ¶ÝT’®J 5½šÜÍÈŒ›:ÅîžÒ•MÞjêmƒªc¥0Ik®:¯›ŽEL;–n¸çÁ“£PðöþCKÜ:ø0 øÐƒIÿîÜêwq‚­NŸXö:øÅòîÿ9@^Sð±Þ»þÐï’rëáçq0X¼y»·Hp̾ÌV)6<{ M9í=™½8›ë*M/6è …>íŒÌ¸çÝ6`j¥Ú•¼9ÎeÚ7 ÙWÚ“ ô-Ñ“ø°˜/•/ï•ÿœovù뮎õú2Т²à~±õèÁõ —Ë O£¯¿Ö`ütn0á*âÐçJ‹LcH¢#4bEi+ñÝ"b‹´Üv{±&eºË7˜¤‘6Ú’+Š*/y¬IǤÊrª­€CrÓƒf›­;¦‚TÉI—( !ù ÿ,éÿÿ H° Áƒ*\ȰáÀ|ñ[ñoÁ7,h•Ÿ…V+ZEø! ˆ é“ð!„yóäÉ;qbæ¿óN°9¦½@?Tø‡Ò£y%þÍcôá¨Ó ˆ,à‹`èŸC†ZIµðãä¿'±V½Ö„ W«b¥ðÏ‚@Dùýó 7žÃ»xóêÝË·oÁ€ÿ¨O.¿|ˆD$þ·…6Ž4I¡Õ”p%èÃʲiNy,Jœ€)p§Ì{÷Xʧ´5LFŽÊdA“ÑQ˜@ÿEB4åÉø‚S{‰¡ ˆtë6TÁ,¢Œ¿7à[ðŸÜvùeß^»ßïàËÿ‡(ü@ '/ÏOŸàÆ7z'_Q¹âÆÈôYj6Ûy=%Ðv‚R¬pjòñÏhóìt÷xD‚Þ âöÁ?øAc޵Åá@ñÝðXV¡UZü3ÔDÀÑSÝ0ØuØi§c<:„£x@)äB¹çc ˜{ä)¹F¡tR+Dý#ÐIÂH PþÁ¤Ó€¬5è þš<÷à&9@@nBH€<ÿ¬VÓLólHܰž@†DàW™xâ?¨ÈÒ ²€Œ&J¨ ×ÕÕ£@Úuçév?)ê¨ Æ)y8ÊåÞ ü#‚r„!ÿ‰–=6©I%Yd•Kó„"ð ÓN9‰v&÷Z›g³9<û&šóØó ¨±ðψD([f¡e4zôí k"U´û»byR¹}U§÷Úõ¾ñÈã¾’*ðÀ ¡úÐ?G"²ÂJ&W˜>’bd_+jAI#õ†nÏ%ÂQ,жàg¨¹á@GÀ)ÀÊζ 盞ÀÈ ¨)T·¦TÁ†U=gTÁáóÃ?CßpS°mË¥!e-ÀÕÐ覤`>¼oA=þ‹/Á\jž\äåcؽ#x ¤bRÃ5«FHf1ņš$ÁK„ AFÿ0Á€´iÿ{B Âìæ?Ⱥ¹rœqþãò?)«9`›©ýUYBµbJãF€Ï(¸3JCS Áÿ@PŒÜt¸H°Õ6Q£ÄÏ`…Úõí·_'ö?»óî;bº)æ^bpŷ­2ZüÏHÁ ¼‚PpMP, -h{­LÓ Ðà†;{÷ÿd{-jG°ÀDp½Û”m8fˆcš .…%V”PBêócT‹2| .SCw´v5Ü90< ÈîzWž¡ m„¹bVp<ŒaÌ£øHe¶‚ëA€K•‹I ²÷Èä@oˆœÈG>Åý#7”SÈ!mEÈBK˜Çÿ~¬ ±`)Œ`Z|(©Œb\YŒÂˆF p¸â³p¥,Të×öÀ2É<‰à½®Ó°ùÄçU‰%,@ “hEøÈϬ„º)eùøÀNv2ÓÄð{ä;‚‚n(Ä5RN„³ƒDFÄÀ6ö€›&2!~%>†`ž…–®çÅ `*)³0Šh$¡‘[(˜e'GV«šw™ æ—Õˆa6‚Æ(lëY·X€7´ØGæ–”B(1‘ÉL'i!$A6#'>e©‰MÄb ß”¾Ð0br™’ŒÐ%&žåJ¼Àä5ÿ. ŒD$Á±2ÃØ@‚Ô… üâ¥B¶ƒIð^ÕA`‰4bÌImà™¼±R[:t1‹Qà+¼Öo²“ ‹M‡$ÈB6r6²†ŒÃ“²f¢Ó ÔM³Q#®â´EÍ닆@ÂPæÇD¬”²é¢•‚æ–ÐekÑQ®c—Øå_ ]h…‰¯T!Ì:ÌEnPÇäXÆPB†õøµv”$Ô|Á …˜ ð„O‚¤AR #ˆS†ÜáËǸF[¦™PÊ Î#Úf(Ò¡‰ hO«üC¨kѹhÔ•smŠÈ4›@<ð kúRã?¬ªZ­î’„ˆlw/÷ÿˆ@#Da›  5©gâB{f[Jr±V-È zÅž±AÝl–8“•¬s뇻᳾' $[Òæµ !ï &ÜÚþºB4üQ QúÜVuƒ­xÑ-Kµßýì%¨úÈ_°Å¨¬ºZµÖµ¹[#§64<ˆ-`Ô©ï(q’ ·Mü•¤B’’pn¥{‰³ šë®»†í$iüŠÈ—Í0’xªÙ‚Ø”¬¿Q÷@£ vz\ä‘iøÀÅ¡ÏvÁ¦Š­èÎ%pÀ¨ÈzDWé‹Ð€W«)~ŃÀF0îf[5~tŒ”ÀGԨ絅ÿ:mÂÅè#Ç‹d †pIô„5Ò ô{ò(L–’4‹pàK)› ;!4òžcÿÆšÿbÀ¸†«2£Ù¦]X¬oþ¨#£qèm”u´vå-ÿKª¶³” X'#y0o€?ÔQWu4‰c”Z™d†@!PB8–Š OÞ³ÐÔ@h‘¨I L6™ žØææ¨ƒ>#€‹gŒ+h1òMTgêsÁù¡l¢ýÚÚ ¸d ¢Yý÷Ø`Û¯©~y_ürÔ îSùˆ‚TUDl§ ÄÇ$! f¾ò¤“”^Ò‡­àþ®|œ%šM ÂM3œŽÆ69Ù…7FÐC61n±šJà N‚¦¯a„=˜Ò%0MàQ»†ÑŠ<| QiùÊópo|¦ Èø.Ü<‚Ù­š´RךjüeídÀ\Ï/Ñ(¡ìޏmÔÚ&Ç ùIÈD E2©x)•’¢€>¸DùóÊãÿ€¶A!µÆv7°3*´!Œð19áBò€³!rK12Éè75Á,âIb! ±'ÉÒƒÓx41Ù˜c‚¸‡Ï¥spÄ!ü6¨“7ÍáWH˜³¤·YnñÈÐÑ& °‡PT§ñþb`üBUÃ@´$ª‚”ð[×<€RBÊ&ùÐ3Pr78y9Hb{èq¢Q ×2 ’}§á=ÕX!²&Î5…ö‘2)Ìx ÚÔB!ÿÉ‘:]Ddú×%“óÏST=3“áEÈ!HwPWuccu0 ÷’u­XUu‘ i¶ˆ0P± gôÑ Ò±*ø1yµÖ6u^'õB'3SxrrߨŒ:Aè9›s B:±¦s‚ 9F˜mÂXíWX‚Œp dÁJ©³"óS)#1Žñ¥Ô—( £ðJ‚e®Rà^õŠ‹a稕8 ‰u[Ù³iÖpÄE ˆÐyC„‡÷10©QSÚi„9*^kbœm¢RÜå=ȲH‹·‡1W81g“ òˆv’wJ”} fgñXÿÒ6ˆO¸H¥Gµ€!ƒÁ€<¢e8’š­ˆŠ;¢FkÿÅ/¦¹uc¦;´ å#C!–n! ?sŽ,!yb²~Ò&‡5œò °m@ˆ'siÑ©=(‰mˆF8/W]å3˜Ôé=ÞUxéB3U¢¶!ñDŸ&0XòI`¡3^bjl‘. ôP6‚±jT†0ÿ`ÿæ;¶—5fr‘u ‹þYF¶CA¼3Fá`Â… z1br„Óøœ76ˆÝƒˆör³!S1w!è§Wˆæœ„S>Ý6-5ã=X-E¨c"/„‰Pÿ³(ôÄq£á‡øä‰mÿ Ø ¸pŽÕAec³ššr`PJâšùÙšQꤷ§PZ©_ã#úp< ' "¸G)wÃb ’2Ë !ÚÙ=q 3hºh‚Á‡fCtJX 9ݶç¤M5qôÐ{‚!ƒvDÚxåÆÒ"UˆRÃq."CPládP¶ Ív€Aýø#XYª˜5ñŠ©pîÚ©§©Ÿ„#Vjc+à[ gnq7ñ¬÷4c¡‘T8àƒ~-3ÉC*yÀÊu°!GÈZÉh4Aôð›<Á§£á—¤Ñ Óˆ¯+Í‘ó£²äéR ÈÐ Ëp?üæ#¤ÿåeVWU [¬XUõŠ<[`²v¯Q¼H‘ÅCO<Ä?4§/g8‡ÖÉßU¢ðŒ,2Ù2ÏúlÊ2uWÈ)^d²›RSƒnJAg9Ô"; "D®PÖË×€ ?p#zÑ€aGZ†Š½e¬‰PüÒÞ\ÒÀ{¶`j¾j„Ç«5Ûœ±%Ãÿñ`¦ËÆÿàÈÍ]m§„U*I§Äú=œ,§ ‹Hz¥Mø,-ðÔóP¶eKú̺4eÅ®»‡!vH’!91Ø%½×"*"^A4Ü˾¼zŸ9G̶Ó) h¤u¡î*6qܺ£ xÍôj¦L}lÂL>Ø5AÔº1u5/q‡$fS,Wò[¡Ò=«8/&¿-æ«ØØsÕ‘ô§ªíÈø¬,eë—àhœ3¡=ËJm&—!»™Ð.”e lñÐí·Ï Æ#×ÄLØÝÇÚÁUÑûÖé”!=ÒbCÝXÆ)Ìǵ!©b‹jÿtǼÓ‰mP“Ë)Ãóüàe‹y3“Ë9±2¿ r&Óœ„I Ë,\›r<1¨½ÚA‘ŽÚ9XÅ ’ƒ{Ƕ²ÝÚƒF Ì^,4*«X²YK'ý «·Áǽ;¢Ÿµ+Wõ_ɵ´Q5Ý© ÂÛ\Íi$ÜMÈὃ`Z)Ò38M/h¶¦&ƒô±!Êœ„U])mrŠ’H<§5D¬ÔeÏsÉ!`! àúúP@qÚT ˱ÞxÅjË’cr rˆÁ‚7ÆhñEÇžÆgw"ÉÁ¤pmŸFºÑO'Ÿäá[&L6†×MÒÿ(6[ž)ª¹%öP½{,à}0O:Èñ{ÖÓ<\ ÈhG!åâv° 3%zÊÔuù|^Ó3=íÁå].à-qÚ{7²f~ÅÒÚ7ÙCä=¡Ó¢ÛúÀ"æéY¨‡ü @zŽýE½È}¤ …FXõܼ£uKšK±¶¦*]YÞ±öK'í"Ö‘î"ªåu§È ]kŠÞÖS:AÁ-”ŒsN@hû^8Wû]ƒI] »séºN듵ގլ4ÑYÊEËñiT87©Ô£Ÿu‰áì×°¼´S™~UÍÁÈ<×Í]ŸŸêÇœBÒX:ë{ÿÃ1U`[ÕÇ{ÝÍJ$^‰@œþ†ø y„dN—„%«hâï¥û=L!W<ñÚÊŠƒ-"°³å_Þ—9Q¶}Éw]¼xÛ3%‰‰·qRÈ%õ„”-| ËÀoJR6lɽ)¾t̪˜¸¥GbfG"ÒøZ©/½ÍÂôÝkkÏìÍöº{Œ~óï~Ò ƒ@‘BRIˆX²ýCJÔ'J¢­Å:“L-ÕVϱ;³©ð ÏÚ ’=¹Þ—»nx"û]숣¡}×t•®3û,×à…É‘S •vq$­‰ŠÙŽ/ZÃUüb{á×lÈèøBfGÿ‹Ÿ¦éøˆÍˆm†a³óß{Ò»')OÒϧsŽ}K!.w2È„ªÙQ¬&K»d òZl1ð_‹y'èÍ£Gï_{!Bè±Â¢Dõåû·°Å‰ O$œ'ï„É,þ¥\)O¥Ky(W&dqB%‹yÿý“`ˆÂø€][VtÙ?`ÿFÝ@4‚¿x+¥NåGUª¾•ñ°€ú¯ª¾xñòѵêJ~¦býʯÂJ¶üôÉ…ëU*GŽS¥ªýÇ5Ÿ_~ùª ^ù÷©Úª|¥V=+µ‚`}ˆ,X¡" ÿ>|!%‹—/åùwÏtiÒRO˻Ǻõ¿˜Mb`°®þ¬€¼C‹#ûН@~©ìŸVC$à<+!¡nŠéŸ#H Æ{þÁ 4ÖbÒq6tS¨·…š‡7 5 !$#³è‹ša£Ž€\nÈœ†üèŸíüL è¨ké¹=뉂•ðA—¤–yæ™ô€ù‚¦ªŠjÁÆâq¡°9óú«¨ò𓾰S°­ÆæÒ«©ôLÿ豮 x+0·0½҂pQ¯Ó4°«°ªlàü§Äw¢rH•V:¢Æ•ndÇ"ȶ y#H‰$Šèƒ|xÕ'²Š@•I‹2ê5„Þˆdh¥‘>*á:é`Ké:yJpé%i±\Q³Él塦zæŸkþÙà† FpÊ+ý êªÝ°ò1A+;ïkO;£KB}É*À>©DPà餯1NÏRl´0eÌÑ ”ØÑ³Ó3>DWŠ ‚•D5Q‚&`F¡‰º˜X`õk”¶˜ž $ k¦Ù\wErç_­ÈáTY@苞ÌÙ(““æZ¼.%›ôº’%ìršÿ€C†ø§• þ9(ôÈÅçu³ÒÒÝ>WrÁOµý›3*ÌšJ¬?ëº*à€3¶JÂÂsKB‰5•¸/H9别³àsŒb 7u%ó‘`§¡Çd––@Y¥{V%ÀF˜²í¶šqŽˆžˆ"â¹ç_E¨¨ÉáTùç•¡s¿h£\WJç›O§hY2(e©N(áÆô‰k|ÌD¯Ír—Bw]´³×OøþçNüà†‹îüð•s,±2´Êг2®ðBú´”R #®ŸÁÃ5C냶RÈI†–ˉ43}`'P³‰M–ð² F¬z‘nÂ{øÆ­ƒˆD^'ÿ;Ù5‰8>X¨^±‚Ûí> „ˆÃ;‰<ä!Á g"‚,*ý#;NSÉÓ\ò4åi¦'£ÚZ×6`°çéB–â·ûðÍ?Þ«—`ú%'JE±}MôŠÞ¸h±Š.0ô»Tbú"1Æðƒ+ዹ"©EAJ0ˆ¸Á,pG˘èpÐ*PäD%ó0YmR%•ѽf$ôÍÍZ·{-’IÚEà:^¡2°CE0©ŠÞ®„¯XÉ^¡ JüC”¡¥ ‹&;ãK'1|¥t”W¼›Ôd&%ø€! ñ H ­ÀÇVrž£‹óøð‚ÚýäƒÜFφ¤á¤jéèzãSªÕE-š¸‰zc7· c$Q*0ƒŽœ2* ïåÔQ]ÂÊöÑÕø3ìô";©X¤§Õ EWòг¯äì“Jà5’V©tf!+QimZŽ¥” ¸€Í[AøQcM×Î6ö¢ÉmÚÂÃHwÁ¿5᪔^Cv,¡;¬—­S“1™þßÖÕè¯EMj*’úK‹Wÿò°«%/„Á2J¦Y‹ÇÙŠÙH†Œ¬û¿á¥8Þb'‚`Ÿ¾Ã¾æ{ ëw¿ K/g×òyŸ„Öc-DÕÞÙȧ—™+†¸A+ ç5ÍëÀ8WOiË.´Ù¾ˆ—bŠ¢º€"Ž=Aã°=a ½9´A‰£®†±{CŒ|À:jú ù qº¾\»1 ˜‡1 —2†`„G2(Lsµ=ù¦¢©À>áÀ>ä;ÜéA-Ë5QšJ,‘ã){HŽœÀWйg9•`  €à À‡8—5Á6²)›b&Ø+7°°® —(B”º±‹ŒÑåZ*ÿÜB·lú0ª»:ÃàªÛ½ ô*®â›|Ë‹(€oÁ8„œÉX €€yà1 ˆ ‘‡!ÉœŠ»ƒZ‰@”Š;”©È8ÚA-•ù‚¨÷¢„ð¥±%9¬ÄjžX¼!q¾W$‰œhå)0„Ë‹€ ¨¶ü[‰ž+›§ð´€—®Èð±³¹Æ0¦®&²p@#4¾SŸ¼xÆÑ ¨Œ·à5ò¼'Jôžƒ1:œQ °,™‰UÚŒUšéÓ Î˜:ËC¥²AÁªÓˆ²(O:/-¿ÂÓ(ÆŠ€ºŽà Å›‰%’W Dœ’ Œ‰¡@ÿ_Ú<¥` §F­&3 ÉrÃfÂŒ™“§x°†jà ã;M=®¨4@¬Š?¼ÀH{”¿à@uªŸo„1á‹´ ” ¹¸OCGü‡Ð!>Š©Уͻbƒ‹Œá¬œâDô2,ÊÈ÷2>Äʲ+BÁÓ(P¢±ãÐ dsEÊjËyDlJ œQ†$* © ­Ò=b˜Õ Ÿ8FٲقŠ9‹º1”ßSL( H¹¦2z‹ œ˜È’ÝÂL« }óÀ¾¨´ ÜI´ªª0«.ÛŒ H‘–²¿V €! 0‘È> q¨S*ÙÁ¸•ÐÇŠÐGN²µ}šÁ¥ÿÀ;;‘Ó(Á;È'13½`’¡Ø ;4±6±`|ƾDÆïÉ p£0>á9A”m“½³¡¦Ób Ú 'œ”ÚÜ‹KùÃáâq⪜ìÌÕÓ°÷™£à°!0‘!ˆa@a†Q¸# XÍÊñž^A”CËMŠÈ íË> ÕÁY£µŠ(Ýi!-N²Hã4ΓK¼UÒ’$D §Ô*¤ a€†•عL—ˆŠ¾<Ïc*¬¸—1ìŸbB)bªø ClÒKYŒz£Ä|«ºz›”´x1=䈳Rý¾oÂmJ4³9³²a¸†g­…]Pù˜ÿ£Ë ªL7ãÝœ m(/û;ÝMbY¡¡(’#ÑøÈ¨Œ£ÍUbũеýÀûhHŠ©X uY—õ¼µÉŠKýPÆ“,CvÙ—¯è"ªAܪ:„9£6ªÉy£lÔ&ÚÄp\@ '3ŠÃnª€È ŒÓgh`@ÓZH"ah…!P+¼ ;ÍxÀ7Å>dÖ@’Hì ž‘5L ¬?u¢bD8ÎX¹Ä{ˆ§¬€ <âXKh€†¢—Sgɨ◬XÃ4t0DS‹>IŸßÒD¡“ùQÅiÒ&Í·†™˜GÙ·¾M6 M™ÜOJ¹¬hµÿ4e“¤†a5 c剫€Ý“g…Vø•£’‚ ‡XÙÞ8òò”Û9ÎÓÚV4²1C¶w¤» ¥ïq\ø…^‚h†ÍsxÉìùQzÙÔr³TõLzÙ¢.ERmò«˜Ÿ D*ã’ßã­ù0X®ËL{¸Ÿ?œÕmê=„™¸ †føað…Zð…¹µ€×Y(ñÃ?³Ç©X*ã /ÎXŽ8ÜÙp¸\Ù+JºP¾Ã²©ˆ»Z%ÍyGÍ@„¸„æ¢UZ'Ú^S2E O€×…—‘L]± 7»pº°`½È3ƒáà AË\¬Ç#±U­4=ô*ÿÄŸÌ7©ÚÕ‹¤=ì½Õ•o†¹ES_[d°€µ%Ëáˆhm*½x@”=ÃÝ‘Ö8ÜÚ+½Éˆ¼¼Àc.æÒ\õ-K”•ÜûbQµò!‚KEÎýp'ø…Kø‡Í“T«›Æ´É¦æÿ =ù“x`ÛÝ«4ƒE*ƒõ=ÙÉmb#øpà}Ä @Þ²ýà|ø`áÍIÅU )[L㪄ê˜Vp^_8P_€†Ž€!øÛ© >À¥St;dÉ Y‰–—q¸›Ù™(P² ­P©ˆ€F• Ímb hbã´/qÝ#à˜ßˆÑÿ}…W¸.æ…ïqG]‰kXŠtqFDy&ýH@ÿ ù“¢xÑQvaª±0=ù0Œ@Ì4â}R î*XMáŽÏ©ˆ$AîC¦Ä>.Œ²ÅÒŸ dá]²¥;hÞ¤À[¼åØV€M´’WS¨£»&/Ã!Y¹ …à ‰(â\xì£/óZ’ô]‰'þ'f_½À¯Ò ƒd_>Ýb.î…^ø‡ ýß•Àt9ŒûŠ^nÇmŽNa?goÞ½½D¡1娢m†çÝ[µJ[ Ñd…ÂDì!qˆ\¸|(bžù&cVá –jeö}b‡fPÁ>T«ÿð½ßú…¿û‡_þ…6Ðhh(hX" [ãy£öh†fif#iÎ:ÞO'ªŸHbd6RŒLû&Úûf©øàÓjäo¶(P (8g©j'8dÞæpÊé|˜Kàfxaê=ÑdÄ뫪fD7ŽÈð¯|8庻Äätܕпjbû}hZx7±7¥€Š¥WÐhUP¿[‰ÏuÔ»†x‹º‘õìÀÇå;(ˆá'ÆÞÃ¥^½ûtìsÖ`½(j6Zì²MêoZìÆÆlJêHjLc'PÅ.ê¢V€Û• ç£Ö×|Ê뽋ø,¶‹ÁÁ5Ô”$Ãíÿ"Ϋ(î(á&îÆåD¿ êÑ^l0¶‡ÿÈéÓþ&Övˆé¦„`ÝÉé^ª£îÔ‘ˆºÓˆâΕë[dâá|bTȹŠ!¨Œ…Î(PYñ‹Òn.^‰6øÜ^(—k‚6j÷ž (PÔŽò/WmÔVo(HíÔFmW_rWïò(ŸuY¯uÚ[pßY‰4wˆ*ŸŠ]×zÐpˆ4׋_§‡6Øõ6˜rú&s‡Xv ó$§‡^×õ4gm{hpç¥[ †`Á—ý&ü›°¤ÝĈÂÈ«fÙcC²„ÂÓó{ˆ(àÛ 5ôÂKßÏ( Á>0«aÅ#}§(^þ_íæèø…`æôQèñžp#ÿòùsÿTŸøúuQ¯vóö]ÿ Hs`çxŽ/v©(vÖö‘ÇøjG6Œ÷*y$ïø*W4_.a—M8 ùa·Ó •(âl2'È«v¥’*ˆGœÁîf‘ÅP&9qb_—tÖ‹Œ¹TPPâSP_öe¯¿qÚîtDØ ²U¶­öŠßòQ{3_r3‡i—v‹×õ‡?ojwyúö$/ö0y_v–Ïu'|fy½˜rb_4ߌWp^`XÐCLA×h TÛ ÷€ÙM> ú:£gYX‰xYYÄH "©ÞA{ϨÀSts ÜŠÑ;%Uÿ¥ûßÿzŽîè^¸hpW pÁïï/׋úfû2—û»/ù’yê?òj÷øë_‰À?rî?ï• hhax…!HǸò±‘`†˜k ¡5‹ˆZ‰\ñæˆY!óZ@ 7/B}ÿ2ü÷êÕ‚W )]²pIÈ?‹|¬Xˆˆ…V0þ£DI•ˆ\Nr¹hùë_/†¿~]‚ví´ì©€¢¢áOž ÿµYX”èP† hР”)Ó?5üLjUéBªR¥:U¡µêÕ°bÇ’-»Þ?D  i%á†{îý»'ïn‹-ähq¢ï zôB|ø§O„ˆ+TÿùXàc¡}ù¢„0èw!Â^üãÌBB}‡Eëû•X±*Ç&ÿU\x‰âêLjDüëØjƒ…%qád%K1aþ{YóÚ?`*Ø3ë´¡ÓçU½RoãúV¤f±gÿ÷„ðÏ@/Ä "ŠYxá+‹h% ]² Q²À " ÒJXÛnµÔÒ?N,ôÒŒ¬ÝÔÌ5ø "YÔy7S^ETCmP¥1P£‚1b5…U ^‰çÜxSNi–YÒ³ÀŠˆt ÍCÿOAcÚ‡^ú-ôŠýà?udX> Ò§`ùH h 1(ŠQ’b†+d¨JjvÈP‡‹¶èPmµ¥"%+¾©Ê/½ÌäÂ/+ Õ‹6ý“ãŽÍ‰uÝuY]$CPýÅV*TõXQ.¥Væ×ЮYúêÜA7P²‚õk¦AðšxÝ÷OÿˆPÄ›>tèƒ* ­à‚>Q,”BÐF‹›]覡†>f­£”lð¡E”6t!Šà¶â‡1ÓBNtºPL45ƒã5¸P°Ó«Wuu$K9ëB°)UQUó\SMù81wÑ•çTxYý:²“ !2lÆ&[ßBóüóÿ×{K0ß}ù(”¶Å¦J‰‘y«à`˜FÚa§uäæBëšÄ®‡tXÑ%$ÕÊ ¨˜ÑH ©RD/]ÏT œMÀ,Àœ¬W¥z•uߤVÖýÈpR?…CU¡åñX‡ü#àZ >á>¸áÞ©z•>P€™÷ýµÌò,tæsá­ÔZ»î€  „X>™…E>ŠV!m­]¢ìZ;QCPwâB¬‰(‚ˆOFùSfºÐ+k |r†|p÷PKI%$­UAüêÛ M7+“ÐÓã=»~w®?}O«ö¸Je«â²~7UÞŠk/ÿVïÓÿü¹¥ÿ=ôŒ@‰„zLnYË’æä’9Ìe!öȇ ¤å9U¼‚ëúϤխ(PægQø€ÍHC›Ù 1 QÔjžæUd5 ‰ˆn§¬ÈR®qTr¼™@ÉAα“´aGVk£Çâ'=‡5¤IÝÙŸû¤´6íEga AËý¼£1Áåí}ƒW7”Té:Þë_>S:—õ%?ïYæ€tùGžŠ¶˜ÚÀI[ú· E™t0©ãœaLdBÚ0¦QÖúk0ò!“¼FjÚú‡îP¤›–DjpŠ Œ2“ä±EÀø>(P»ÕMzII",Q57ê4)ÿcT9.§7ËaQhÙØ­~%öµ/‰²œUãw?ûÉïpÑóŽ=¤ȇ/ø±‹<æÁ‚ºÌ… \ˆ<øc³Ùtä1qGã&Ñ .Ñbˆ! Ã-Ñhk1œ‡ 6ɨí&iº[0y/N²æ>€ä/"(Ê—°%ø.ðqæü£9×›_ÄbåŠmVmözÒ™Šo·Ü©¾ÓËŒÑOmÒ9 J÷'F™¢´+ÏÔ@ D°,Ø !4, !Àåâ#N}DZü£èÑ…ÌS2îŒçPDÁÚØ3[y $ jÚY’!A½8Y)ƒ"j8Åÿéš×.!ŒÚ´¸E*ÀæÀ<˜O`%£ŠÚ …­è«z1›žj:ˆ5+û¦ ¼‰qaÓaXWäF—¾ŒkûJ!³„àN,@`6çñl³Yv±Ë c³KbËQI³§…´J4¢RZ IL¤jÛ§µ&^%ymI(L‚HENsÌ ŠÀµÇÀu8BÆ+ !’QŒ"ˆ(Àw Ð×Â’×'}5,zù#ÄÆ¨'‡=lü†TÑ»é,XËuª$%'!±¿˜õ/€ÿ«?º)¨>`€fT‚µ>ç{€Ú‚"€†™Èß5U_ÿ‘äY³·ÉQ–õBÎ[Ѥװ 1•P°h§Èm²FáòLÍ=‹¹ÙÕyv˜¡=f`Z¥(ü»œ‚ |€@™òÿBŸËøå ôOb²e­ ™dCÕÝ Kè­"fÞ\ݺE‘ÖaŸÉÀCÄ»Ú`Z7ІUÆÔ5 •*B üx°4«‘Ì~äã»uú?@žÀùˆu’£U€Â@ ±´6•öxÒ?èɼ <)œÜâ¶Y*jù¦èû•ÁŒD{ „Bp!oo‹õ¹Œ^‚ÈtÛ“Ç»iò8’ÁÖZZ§¹·€ ´(H®Æik«Àw³€AUj$øPOIþlAÚḇ+˜Ç àI†à‡^ÿñ]–³:­.àÁò:åãÐ"ùò–×m+B¬=¬“yÿ¢ü¤Ø+œd“r2Ÿ¹ôѦìù#‚P@H0,ÐzÈ f!Ë*ƒDø Ô<äœúö=¶~ëT¯›F1»/±‰™ölj¸ð†#±TŠRÔö]w‡ %õ*¶L @ÅQ"-DæÇBÐ_d}Ù0ê¯SàÑÏqW'9äé·Çóo™«æ$Š©x^t˜YxOç!“µ!±)N6 ýX–eÉ=ðƒIˆ>Ã\éÃLÀƒ¡Å }„À ì”>P¶H„W¥ÐP0Æb”H‰Ì‹´ðL¶,†ÜÍο1Êí@ÍH\—zÔP¥´zà^kÌlüƒà%|0ÿÂ÷U2àÂTÚU ?À®š"B 2ûÞB°_‘!àñCŠÿåM–YÇöhGΕâTÌ^™Õ¡™Ñ‘ E>lÀua`*Tšƒ”ÉÞ0Ę ‚਋ì$ź]Rt]Xqøj`c0Ö%MܽÆqíàZ áõÕõ™’Ò©Ð 9„\!Ç/H€LÀBRªDZüÃTZ-ÞÀBÔ¢ÉüCùiá,΢> ¦?£1þZs$cÿIEs,#C$£Q˜ÊøüRß@V2á ÆˆŒyÅ-‚(ˆ>X€04ƒ/ÌÕ´ Æšað#$ú^£øÞ@ÆîŒ#0C[‚FLç\qˆ‡”D¼%i1°¢!œ#¤Âxú‚/˜ÿg@‘CŒ€}6ÄGœ§aj!ÆÁgZ4i¥±§Úœæ}úO …ÿ ™*L åN¢)šåe‚Ïe&TúÒ-å}£ ŒÉ Ì?ƒœ#í…ÙC †€ ÜÄ+Г›ÀI }ŽD8ÌÉ ®h§)ÄBH×ÑøfqÒí¡òäžÂîô¡¼ ÏB|šzø€>¤L}À@i-(©/üC*ا|¢çBD)zÂgz¶ç®®§zbY4‡—ÖÍhnfšBV±ÂaÎROžVà’5Fká@e},À5<ÃA¦B*J\aj2"UBƒ>Ÿ1¤p%:Š 2ĤŠF µN©ÖQÿŒþ‘me„òøÐ.F¼å[–„n ʇˆ@>0‚6±@ \€@-Äê2øB­Êb@¥çyÚgzj,®ÎçªYšz†¬HTaœlY€4ŽE˜îÜMZãQGœòÒg’èÌËPåÀðéH€›5Þzy‹¸rßÍ”jÕ•¥Š!—!J¤@"=Á«×­ÀKtÄC ˆ£œÓòÍsêé\ÍUŽÊ%£Ü¢gd|=” ° @€+ A€’*é? dìb¶'|–¤a¦{¢'zj,|~ìÈ`‘e^E/µì²nÇÌžæeÝÔ›^TbQ ÔÇ TÀZP‚¬@.äž#M‰Á ‡•j$RÕŠªSÇ jH€`jØ…íž’îæ( _Wëj <ì´m$ÀòþìÖ€ÀB”_®Šl–bHLi·Qaôv›°>#‘ÙC ÿŒ=|+Wø–‡=ÄìŠù%„(Ès¸ á¯7Ä:Þé?ôŠ;¥Ë/ÿ¶ŒË$]¿hàD ÆHeˆ€ŒV¸|p!Æ/ˆF.øòeËè@F¶\Æ¡íìpå›4J¾îIì.’pÀ ë·páÈ é<, A=È°ÄÆêÜþÀüXo¥M¯IŠ,÷6D- «·òš$qøþÃNܲ=0B.‹©±‡Âþ#t10ÇÀSBÈS3=0ÂSþòäNîúN.#ä¯ÏCxœ1„ŒÇ¹ŒZ@g+! ªôOÒà%ˆFé²×ùLiÉG DAKLKñ%¥ÿ’;­(mHí¼VPYV]º† ErÀ ÛE¬@I^òšp '»B=4t)íyÎêȰ”–_wòbJ^´ÞM/7+³òB´_‹ôÐ2‘ÆI‹Å3ÂBè²Ùóÿ-s2'ó.·ôL/ó2+Èä†Z3¯@ÈsLîÄ<°4 H@ˆ¼e´ñ¯—` °/hàdåÑa¸@Ð;7Á„­D§Ú Jjê’ÑÈdñ³X@FXФ5 ï,€r­Úa ßÈ­"'óÀ?´í'Ë0’Ò0­R˜²! 6YX4F[´bóâU8#„K벆—x†cY†ƒx3³Ë¨¶jƒø¡‹qRÌR¯H­– ’¯Q„@ìÅ=4æ°³8!ÓÛ¼ín-wÓ®(´H"ipº1­Xè†ÁmwRD@‡ÈuG0&sÜÈmà–¿0Có@zÿƒ ¿mÜ2„Åšò A7»¯/ÄT@³Oûúú¨9'Eùå÷?pûš“Å×¹³ô”ûž3ÄŸ£»—Vx‰ó {±2ÿEg»;ˆwøk¯É‘ Bø•øZž`4AÈC€“_8Až²¤ó« WýV¡a°htŸee%*2òØ:ÆcÒ ,Æ—“‹‰w¯»Y¹C¹z«wz—òBûÄFtrÔB|_@º2Ï<0×| EK{µ'±‹Å}÷|CX$~ów¶ç·˜K»´û#ˆû¼£»1?}¡#zK·{Í_Õ'ú¡¶Ë@—¤xf\ú7 Æ^põØ¿L^ðê4„»`ìòcÓŠ:¥Bwª×FW¦uCDÄ+È:’ŸPRDÄ%YáÈ êŸ?l”׃'3´zS4{Óê Ïj²» Ü#”€ä_Å-,Äåß<ÍÿÿCžOöÈt'ï÷—>}W6çQ1=lº¶Œ6=!:ú/‡Egwöåÿ½6ûB"ˆÏV†‚ˆ³ÇôT^¼_Då‚èY«ßsXïÑÑ(F õV+D<óŒÖHÞgÿîœÓP\È®ŸgÙBø€[} ûy3Ê»±+iD#C*¸ÂB”@îÏC ÄýÿÃå/ÿÄ¿1ný»Åè#FþIhøbDˆˆ"’xb$.`ôñÂDFT˜ðâ¼>BœÇèeL˜3e–ˆiòŸÊy:ÿ!Z@A_{!þÑ3 ñ¨zþø×¢…QzH†ˆòO_Ö+ ®àʵÿİ^ÿ‰(1ŸÖˆ\ÿ-ˆè¢[®>.Òõá.Ä»wÙ®@ÄïÇ&ð0 ±^=W'H"•/_I”¸X‚Efÿ6kÞÌù³Í„Zþ³XãiYÿ»Àñ_…‘J$ a&n–.'¨,¹2'B–/ƒ‡(œ&„˜Êç•øÐ ‘`G§.ýÇ”ªR©ôBtA/ŠPˆú Š0ËUÄŠô[˯‡èâ_¾|¹éS¿õ+×Wq_Exµ"‚(Y€’Ürë® Ì‹=D¢ ‚y訞«°B -L ¢Ç.ZƵJ8"3ÌPƒÈ3Î|cÈ¡‹(ŠÍ NC-F$P›à#bˆÿÒb ¡ÚNÄ7”Š,’¸yH@ˆ%Q.8å ø‘$àŽF쑨:¤NØŽ»(ìq¢;ˆ¬¯¼²î+ͳÈ#/ŸñÈ;K¯¶TYà<õlë•÷äÊ-¼ Üon@Ä&a s…‡ #Zì¢Ç@øçÒÉ Z™*³ŒÄŽuT‰H•…QGÅL¥ >hQ"Ù†ÄÈFØZ’MÈ H«ÍÕßf•èI—""nX$wSò&ÞÔ‡©Šú¨:©†²'¡ÄÒ¬4WP…­Tá–[®´Ò‡¡\°R³+o÷Ë3O>õ\€À"øG@AÌ“,%PÔQÃxpÅÅ&øŸ!8„ìÿÒ‹|A  JµTÎ"ŽèÔ–Z´¨D+ŠHÖÒd먵×DþøƒŽv$)¤Ñþ É×wóèI‘b."šk~r ©à;‘ì™êºˆ°úŸ¡¢/1£Xš¼_¼Wuñô!On·Ò'ŸrÑ+µÒµ³Ð°W€w»äM°-ˆ(á³­ 3D‚x(Ì¡yø'` KK%È$ª%€o)HD'þèÎŽcIHd4 ÆÒj„ü5CF~-g#"ÉU”" ¡åYƒîeœLn¥'U¢ЩÛ;ìæ±¢i¾]¾\ô1«o}ðjʦäÄ/„ù´öº«o½]Áx=÷ÿ.¸äÝ¢vÿ¡Q $ð÷0 C,¢ ùN¥MG•Á²,¢T?ƒ(ñÄE…~Œ4þuV 8’@d™“@ÎF¢¨Ñf!¸Ñjf¬˜‘d6š{™J0¢:*­Œ[ŠÁ?6È¥ "Øù‡ò±%¤-+ðùEWz‡½P OQÃJxºÃ¢ÌécÙŠñÜ56¶-@Úž" ¯<ès;L¤˜ˆ!ñ 1ªEú4õZ€ pŸûR%±–Øos‹Èþø‹ØÈ"0ÄFDæ¿ ”Ì€<ÚBHÒ£©¬%»A`‘ ø2:þ(f©óD&à ìdv¼ˆ(HÁ%i#ÿŒS$—¦»êÃæqÁîÐSdÅ;VIZZì#‘¯¼=Ù+Ô?…/ÿx–+ @ÜÀ‡˜ e¨%Pôˆdjñ7¼‘™ßEJuû± "qÈŒÊ4®F¬Ùˆc“£ dî¤!EÂ9: ‡Àñ‘Í4÷ÍÙˆn:SŠ=f'’y0’‘D«Q¶ä{DÁ ù¬ w¬²´äâŸÿ´¤îráϪxçhXÉDÂE–®¬²+Ed¥¾BD ð B¢Þ$õ»mToJß$SEa1"È-äw„%DŒŠÛI3=‚13Fî5ndÉ\s²_)ð çq"¤–ˆD7 Lÿ•ò1Ó¢ül*³ËÉT‡"•¨%*PÑ*T¬ŠÕ´à;`Õª< r&«$ï\fÉÖW¢Æ­°ýg+óŠ‹·R(}H@BwÛ…Äw7üã¯Ý«HAPXôE¤ŠÈÁb\¡«[”à±™¹ßü:CTWÁЦ©ù_D`õBrDsbôÈíÈG;õF%R)Á`Íc¸šG ؉žLe(ÙênyK­úö«`ýê=ˆÛ²Š2>W‰BÊžm±®ô"K_œÛ“Fe”±j"`[ö£rLa!ÓKˆHD“ùAØw$"˜ •Ä:c™…†™Í”ÕÇ('‘˵FVsYiÏÿYÔÍynœ2»Í€Dݸ$©-O0;vf0'Ð@ – Õ&´àÃPùð‡‰B3å"eB 8 U¢äiÿ|È“­æR·/b¡¹r $1,ù( · À»Ý…ˆ`3d0KùÍŠÿðÅ­8ÅZü€ ßJ‡¢.;e6˜Í,ädÄ‘ùÏlÜ)lb›#BŠ6Àò&Å’`¦®t¥¤8·ù |`*ÞÉ ¾4,¨ÈcÄ÷hÁ=šp²~…Y‘tŠûÈüÅ’–tœdü¦‹¨Õ[¦L[¹"QCÉRå ˆ ØH-Öå¬^#EEä|}+ï?–á‹ÿT°Ïa—ùüšÙQÃy‘'1„\Q­mNÆ}nâÞƒ-vôS ïRqºªpëmŸ_¤Ç<šžkœÊ·ŒmàmùJ+ Âõ†dÔÕ‹!²w¿KëVSJ°y³%†P¶?fŠ’A†Å‘Ñ äÿH¥#\ü wG1Ù³ÐiGÂSˆˆ,6±íiiØx;zf(Y`KèTÐ…à‚ qªS4pt7èÈ@qËúÓcþ*Py¤U2íôXš§'Zá4š¬Ž‘nµ¢[ÛÓ½!z„A¯ o5’™|K†#Ù¯%{b˜ï+–ÔŠkŸ+Þ[ý| Ç!l ñ¢1ÃÍ5:-ùšyÚ‘”—ƜܞóÙ¯þ=ÿþâüf£€S%‡„€Â'0n£9@ ô‚îM"M«èÁ d¬õDÀiVà?ÔãÞ²EÒÚ„NþáªKë"⽎¸g0^€ïà†O"ˆ/» °  ÿ à¾ë»˜¯ùFªáÖ‹£aæ½XðF~naW ÇØÌþËrO64§cž-ýN‚¤M ãÏ$ÈÄE(y©)À¸â¦£(ŒÂÂ~‘¬v [@   j 3)=òã"V ñ"î£%ö°'tÏAzâ  º±¹« qÀ€[°°„Ò–òK`È"ÚÎíÜ®°¬ !îæ®éñÊ~ Z† ,i ÙbÃ5ï#ÈïšP´oe>B"ïñðˆñ¨À¤­Û6t…(ü¬>¢Yÿšå¬ê‚LB ŸòÉ\œàsa“”ñ”^a…V¨,j ö"â2›kŒÖ‚D€ü‚ñêxrÁ‘(Ç"–r(×WP5Ã1`#¤0b/Åʦl2$Cʪì|~@½R—ÈÒŒXcðddÙÈ/ñ¬IWÌ’ñV® ëRaf$r0Pn@Â#âKf‡Ð¨Ã0»#Ÿ%áw¶B†ÈB3+0]ÖÓû®“":ÓA(¯‚`'}OáNsQ5€“r)1"^P6Ñ#8A7ä1ø&}¤,}¨"*±°þAfÌderŒÐFþ ñvªÍoÌ oÕO.'/ÚÂÁð«'ÿ⦑ºdܤÂ)| L¾ŠL–&N0É<(s+(“Ó¤>Æã2e#VH­x'1³'²…" ÕÆ µ[¹Âû¸Ç3)Â2 ?—ÌCÕ®_øÌíÊô%® +_A`_-€ÿU[5BkUVe•ŠJÊÊÐ4Vrj§<ñFb!mÄ!¥sXON›‰0T†"˜¥OUb*DèÒ¢„.m„*-Îåé"ðÞÐä%q¨&ɵ[u{¼"¸§QF³'´;u@/R˜oKÇ+_‡ ¦C¢ò£.1i‘S +×¢V¥¬¤ª¶›ÐšÍ³>³/#FB6Œ•æð(æLgHˆ¢WŠŽ4¸§Z(hŸh µ#Ð$¹c„ä3yô"Èã%ûÖRÿ»p½µJ(b> Î&pÖ§ô5Ñ£°Ôq¥2Nõ–l rëµL·ÔÖÆ‹Uo5×bõ¼zMaÿÙŒ°ð¤ÉCmå,ß”ñ’ÍöŽdÎKBWî”vƒJîÐÄšUh–BFµÃ0†(J¡øö“è„R-U\«Ä/&Â,äR—S¿'pÖ÷>µ=ÕS ñ»bS5äJ¿w*cd“íœsï`VuB%¤x M-bFòkC=âüt¥cÖ’<'"U&.ùWòþ÷-Ç)w§dE?B„ªCd»ä;FH”f¯x¹Õ,ôp›÷<¼HÁõ, õE¼ç^ FóI;u(³·(c_ |ÿ¯Ô{+×{ùJon-sÆC0…}7å¼B׿zÊðD#@ ñvØ5T·!Ûï΄ý6’WbQ$€m'àÂ<#Àó" UÆ& o‡„HD­âó&ë£> A.`zŸt@GX)­7Û‘»*%*+„CÄç#º·1š¬ë’Ö^&"Ì DB·Vͯ é×k/àü‚åû·‚ °¨‚€¡ÍèfÇ‘.b*ón;ÒÄntNæDk²[«¤º—R%øMôŒ%nãƒ_`4S³J‡òL¸"eÖf“6›¶`,d|¡*H|qùáðx7+tyušZÃaÃIG –9ÝrHì”›€…uÿ[‰íle:'YïЉsw/bKºKL/¡¼&ê`/‚Ë£3ýbpWÓ²BgLùÈXùI©4{   ‰˜¯…Ù8Cnmrã¸|ãÖ’68[˜*wÍ}q˜ÙˆsÍLN-AF9ñWb‘Àˆq¸4”xeBQ0òE¤£Ä"b(ó¬¬â¢ç´¢¹l̓ҙ"Žˆ\Áµ>$àMÔt_æ™^À?û³Jå5`˜È£zùá—ny6ué¨ßq—zC^£+"äÂFŠ¢1§M¯ —¢ùç¢Ë(æEHC÷îʦmZ0VÏ;–«Z&i”&°=ΓºÖã3µPý®ïʬ³F'ÿå•à^y@[R´+ K— ú"té yy©Ý®iݸ|ªRÊöXaýØ¡!Bb‡ä!cë!£:³2§£/kŒ —\c(>`KîéÜkà:eÒ¡êÚ¡¸uYè³!î*0&àƒÀ·ÿaqKX–f©»ÖŒ­ÉŽZ|¨rj-û²ËRðÎì,ó¿üë‡RGÜ ´½úÀjn{¡õE0lh¼ÛšÆH‰“W6¦a¶3ý­&IY-‚¬!d^àžÔ0{Ñx{gY»úù#»‹Û¸“Öo,Na™ÉÌb#ªÉr4âÁ—c0Âdrû¶ÛØ.ótÆ/¾Õ."k²&>8m“Ûã%ÿ…Ô¡hö¶³â”"¤W¢¾}û0 °ôI[°;Ê…1MÅÇ1"Ãâœ[W/Â"¢ÁáÆÌÚèð#èM=ˆij¬wÄ#:úð%GjÃÿ’Êã#¥‘&¯1Óûð°3å³>ôaܤ壵Ûü‘¥9Ž@@[¿?uIû;1‘ÖŽ;ÀC—±‡äŸÏѹ,ÕˆÌ\c( âZ6åtuCÔ€2š4 ]"^EÀ.^¸NÞÆû‘äcü3ô¯D>@Á(„½!>䣸/Ä¿ùþü'!_¾3~¨Xñ!„•ô湜w¢‹ÿäaÀðïE®\ñøg¨<êÕÛøÏÕQ¤L7&púoiÓ©TŸBMP/Ö @xõÊUëV«KËjME5­Úµÿ†r»qR„™J@r×Ð@¼ÿ0páà ÿ*€ÜH¸ð?Á_(Ì8ò„Æ7~løBæ“=žK‚„æý3mïßĉNZ|}ñC®“£]“þ÷ú”T=ChÿÜSͦǬX“ ¬É&Ÿ·¸”'§œ¬VGýùÌCøU}u­ Ò˜Ù^êÅ—úÁn*A#  <'Š—Á º¸O¶ hŸ4) TÀîl'ßic+ FœáØÄ&¸‡©°°< Uo{šG”ýã34Àô&f€zä(:ÜQܪó4¼l{FYáHÖŠ(Œd$KŸ‡,_},~sé µh†¼`1<ûŸžê·³¦0Lž¼`w¦3R)0¨Bÿ}òÔ´ÉTÃñ|G¼áŒ „zÔ£ @€#ÜmX؇£·½°mCAÛh8•åb<\ÎQ¢õœø½/+¿BJ”’ÈÄ ‹q)Vã®t¹ƒT !cª–\ôw­ a®‹l_zv@ÿ½.r Ýâ¹ùÎiÃ\#Uâ0¦íÏ](ÁöØGh‚ð‚Ä€ ¯iMk¢…Ì@ràÍ&ÒmëÑN~d·J¯)Ã’Ä(iLªlr;!œ'-p¸`yr}Prâ”ær¹ûà…/Lè™ô‚P\¢q/&/VÅ©d&3”èìò3¬.žM!G`ò0„ ¹Î?ªÿ)„%ŒšÙ¼Ç5±9Èžê9øG!1€#r:`'£Ûr"½º i¨:”äO&fø9Ë(£U”h$°ÌdÀZŸú¦²&jÕ \¨›ò =U$\ ÑšÂËb¶éM -¾˜'ºÀ†€€LPÚ0k¾t#÷øG_UŠÂ†•ʦ3]!Èy„úD¨ÌÙÈ:™r1W ²“Ý^–ÚÚ2ñ!‘ª¡ËÉ¢:¬ÅÁ'M×ÂÿjÉ&½ô%hi¬ÀƒÄ–Ö~bm01JV¤³®ãåaäš!C8deû‡ ꌃôëßÀuÜÎ8€º'ÓöLNÑŽ\7ÄΖ-|*¹Afi¸HÄKžYב˕Èwè¼É–ô%ôb°%ÄÄ)ô¡ï¥‡Ä oû=ã•ÙoiÉHÅnCòT¡ï>øÇc–U0í×ö¶bÁ²#™\bŸ¡é²sa¤öÒ‰Nt‘žâèú;ëѨ¹ì?}KCþp²¥½ÿ–—uÏÛ·ü÷b§|T¾ç¥Ì90¡þë塤ˉÛG_=a]-&­ó2âGE ÅòPÿÕ0c ð0À~“·,L¥%TQ?m·°gEùVo‚.Ð7t4rªWi!H`b@{eÀ å¦nƒ¼%Xñ=ÃV&!¥|·E3 eFL¡m/ó|z’€tQm’Gå†~3vx1ˆxHRÇ7-sA? Õy8Ÿw(‡qhTT@ âƒc¥/)L˜H†g(ƒ[¢E‚t_´yµy³ÄQ¯ud³†‘Ccˆ†{ȇU’Ó?[äc Å3úµZCÂfV÷{l}‰Îòo‘˜³ä%‰è@æ4 ض 5c¥gL·ð‚”¸%7cVgŠ‘3Ehƒïq µ–Â$ÿeéA@°‹ºød*XŠ6ÇCðƒÆô60w`h@=[2‰”(d-_•UõÑUÔHtyRŒéñˆ»¸‹Á‹Žm%b'àdÖfg0cl|«?=ChsG!ØQ8“ú7{G¼8$pq¸¡5¸1sù2šFŽÄxŽÆf0cäŽïè<¨ÁT„×b[r¸mÇ“å ßÈ$À‹÷‹G%p’0ø2\Pr7ˆŽpy`=P‘±':–1!Dw@emˆ–wC†zB¶wÿ`€™’Hq %`Wv5$`T4Ž7gfÿà{Öÿ<ÿ°Q=É„”áZHÑ ”á[ "dØÈ" gÞè”É’(?vÙ‡ÈV3f~àÇ„ÍØ‡'zn¹m”€BgÝ·/¹ÈzW+¹’x‰ZÆ‹W;aÁH–›É™‘£i…’”NÉ‹aõˆ·™l*2!™MQYÙ™±9€y†J?}‡.é!I¡‹„1$0‰¹¸³w$€•{÷)(¹x,  Âš[R[)›ñ Óy†¦—öñˆCމ‘Ki’V¹’rI¸§uΛÖÙ g†isy£1ñD¸wŒð .©wpq·ðˆ¦‘œ­9™Í‰“ž²ž6Çÿri0†:É„¨r1Æ[÷¹ù&i’)·)Zƒ•ÉiŸSÁœ”‰0GðAZ†ž-zŸÂœHQ\0ÓðÕy`–ð€£3†ŠLxt晷ࡹ0s¢Z£¤r9·÷¡'y’èA ”¹uVZ Xʵ³¥ˆÇ ™0c„èÃ[4°£pdx_‰Yû€  9¸)â!L¹˜b’é‹GÊŸ%)¢UsqJºuT1*À¡e.ÇšŸR; i"àa:us6‰Y;J Ö ê¸%Gæd§wsЧÃ¥ã‰Gú¹wþ0ŒàŸóàŸ· ÿ«ŒªUšž ¢¢'•¨ ‚ÂS™ŽÊQòÐñ°‘ÚV p<à6Í£™ñC/„–:c›ºTAA¡L¨5t:§Oº”ªÚ(üi/r™®Ú(HQ;X•˜Y™1ªu,j Ä“«z)µCÖá&©EÏê,ïÐ g&­äÈ?L@k ‚šº~èñ1nL¨pÞ;^ÞýI‘—CãÄ‚)ÀA"éï×A‘R=ÚþìÅáꪵK»pËÆùßÅÉ’/c žf#ÂLÑW¸ÿý m½oýÓ»æ>«!àá)tÍtÞÜF€´žöàpM.ü|¼ë!j¦¢“7¡ÍÜ4ì¾÷L‹>¡SC€¹A±S-ÞâˆÓšÜ Ž“:}b*æÄAŽizíçÝ¿kñ#£sEmÞä +’tÙX"ŸG!Iæ)Õ«Ší¾îVÕ ™êZ—)ûÞ庚¥Sð ®à€ÔÿZFPáAáH1Ò·žæôPmþ,ÀM#.Nlcç_¹Å>H\1š AìX,íþ‹É “Ä8Í*'ÆoC©HÑBNN„M‘9^è6tóØŽÓÙÎÙ”.ô˜MÅî<ô‚Ÿ¤ÁhkôQÊ‹JÎßX½»YY—«jÇÿ½®m¢­?¯]þW~H%´à=1°m®ûî"r¸H‘æ„»áù@\¥²ByõÓvŽ€çÜÌŠtOabl–δVØLÜa‡ùÔã;âfK<è̓óŸœí,1*fC88iè—ÍóXRé8ÊL!ËøÙa<ù}ô¾ˆÕq  F$þœwÿË £ƒÿnýûWâDа8"ã?-ÊûwïˆHÿ0ü#@àˆÊŠ1B@ÌWÀ‰½™N赡7Qÿmì…È÷‘ Œþ{pò#F&fà1dé &18òÏUxñÏXŠa±*ÖÁ× `üë䟰ÿ´5ðVmÅ·î01/Åz S ,8qߊ 8<÷ßáÀõ6@bBCA(¸ùßÀ‚ÿ’vÁôg$ <¤X‚D F²K<”Û±c;îF ñÞÄ’Ñÿwâß¼Ÿÿìåƒ ¥q c4¨p’/_ˆ0x"†°2ɰO,ÿW' Hõ>‘XAÖŽå;ö*űrÁÂuK/»òÊË?±¼jÌ@Æ$› ¢Èl®À³k" %LÌÈ*³p² Hl‚ÎV‘!^{!‚VülÅŠj¢[š!†p«¨$ê­"0ò¨" ‰3®"䂛ȞbŠ¢±&j"' j)ð(îŸ#–:¢ ."ˆ“‚àALü걯>²Öšh¬·ô;i,7ïúЬäšH.¼ÞD¢µ¼kB„°Ë"”ÁÅü L@ ]±ìPÁ(›4/¿Sm7Çjˆ"?khƒ–»E¢ˆ4åèÔÆ:ê­‹4ÊI‘0¸'KÇ@¢Èžÿ( ¨È‰Šž|.äÁ ©ø3©K¸†pÅc_H¬¾ èzMkíëNj³Î¾¾ªëÒ·tô+üä´SÜI «h°ŠØq¢¾ô1^Ã$;tÃCýºUG Í5 B6rˆ„yâÍßÞ`e×WG¢¸VŠlÕ4¦|²K¢64hãŸ9ž‡¨“Ž2.¬œ‚ >“ ØJ,¶º¶M;ñ‹ï>»ÂòŠ>GìN?ß="À‚.ÔPBl±¢ƒæ·ÂÉ6œ+² !‹°ÑûΤ)¨¢Q³,ÖkS'*dzuì -ˆq…U#\/>‚Ûc‘BUIˆxÈ&Š@¦'»æñÎ(ÿ,ÿÉ$rà‚fŸu\¬ \©v­ý¼úMnÕòË,ÎÁýO0¤C×O6ö°Á)B½NK¦ ³C#ÔRww+yrÇUFõŸQ º;GˆvìѸäaåèUŒZ•'8$‰Ë¡$h•gîÆ ƒH…EÞi¦ XøÎp¤Jrà…#V¾ó1“ "L¸x k[¯ã‹o<“ä< "¹ÌíYº¤&4¨íæ\Fs—ìRטÁŒ«tBŒc"• ©kt9Iï 2<Œijx¼>0 Aë5,Ug£È«·ã§k(ÉJðÖ%i¬»âN>Ö†(ÑC;! ʈT­•aÀí¹[ ÿÐÊä*NôŽïw•#ð Omñ}5 jŠMd¡WaV÷ ÃhÚbcfG51fkŽ)ÉI®7Šëáâk2¼˜AðA:Žâø(^l bª‹Lï#ÒKž–îñnå@1Ür*B¥)9Á{¹Iࢠpé98xL¢>£¼À}F1ÂUª591!%ŠÅ2Ö9w‰È¥+]!KµôAáÉ_ü³‹õ2A1²Ëhª¶B×!5bM2ŽêK]¸–¥:f›ÛÜxJâG¤ˆP„ ÓE´ç£Xs8Ùtd:à˜'M’{ÿȉè% …XE¡ÈI¶ä¬ €¨XNٙĒÿ¼ë(†ÛÜWJÐ9¸ÜÉ-ªÖ1åe4_N$›À¼àÔˆ9¨ 5ph_ c(ä´7Ýqƒv´(J ’©‹}Pƒ(ͧ7GH´M¤mÆ Òׂc«uÆpÿzç?øöyN$ÀP0Éâ$.%ðå„xWÀ¥lm:J±œ%'¿”@gnW›$MÀ@ð_ø!Õ$x´‘ökhöâׂÐ( ·6&õÓf€7´”&ezR¤iŽn±£AÚÔ7+tI éȦ¤óüÇÜbB‘ ©MÝPž‰Á ®¸€³þÐ0k[Z-^, úZê©>:k¨_Ú2Ñ@ ÍhuÁOp.*4Iý«/PbÚ¢xF¸µGm‹Å‰! !ù ÿ,éÿÿ H° Áƒ*\ȰàŠêû‡Ñ‚ÿnPXÐjÁFQjÕ*‚…ÿ( 2ôOŸ„!&Ì›)OÞ‰òþÍ£÷÷zÎcd¯Ânh¬Àhæ?FŽ2zú¡B« øZ’ðÏ…øNR+‚¡³7ZÝ@$᥄³^o,é"¿»Æû_ÿ€ L¸0Á|-Ž`ÀÑÝü&"þ'Ñ¿kmTûoÁI›écËõßËèׂ͓E‰óÖÌ´ÄÐØŒr£Žªó牙¹gB°÷A !¨ôZ¾ÆÞH‰äìFg+Ògh¥¡Vÿ6lÿX€hÄc¾èýö嫾={ÃðãËŸo0²@~–1x(âîdŠ#Ü ‚€*Y6IE Glõ"Q…ÐÔL%àäTO@u„N3ý´¡ü,¶"kQ$Ð á(dh@A>ècÔ®f¡NÊszŠÈÂ?{ Pÿ@‚Þâ<ö`ÈÂPÅE „‘ÞYvƒaý€#?Üðƒ¦H¼eš@T@Áb-ð>”:vÞ^ëÿ´Þ¬Y²e•¸æJ˜_ÿ%VÄt•!I‘\˜‘¹BJ_É™Z­°Á<|Є!<ËÂMתøÏO{þƒÁ="j(¡„ @Š ,uÂàÎ3Áˆl DJˆTÀ•W`áóϧê¨éèë _1ûVãÝ`×yíå$d99±Åºf¬ñ_’eYž#Ü"¿Þ€Ù ¬p,‘Ô7Hpú˜lÈ3ù¤"lÿe(÷%О9 À  š( ôÄÀBзªk高:÷ï§:.`„ZWc…U‘?Ô嘗LFy±¬ßzëÆt×}XyYfß™&Ïÿ¥3ZpïX'5‹3ó’ ¡µóT[l5 è@Ýš+¡]~¹äP7µ§<óTU³R†TPRp}eÁ(£à²µHL#³‡}©feĵxBâýX’A9·ÝÄÏO¯øY&Bb–9Wd±ÜÊ­`êµL„ -„3ÍÃBk–(ämh.¹—ÿS´¹lxϵznºéyG5@/W=>£L¦Z1‹Q‚ÙÝN%H¸ŽTŰUÀKa’˜!s«‰Ý§x̯ “‘`"– fD°‘ E€#Õ‚¿n$©äHÀM1Ñ^B0¢Öô¤B5ùÔW(qYîh˜ËÿÊ((("ŠAT*`à …AÙT׺Qü‹$(¹!¶·låHà×ð±&ß Ëm{O׈«Él@ùPe.³‚¹Xàe)tNáþQ¸69E^`DM^ Èéi‡ÀB„¨s¥‡á\ˆ¢›0‚Ä©€÷üt‚0")JÉÝêFaOÍ(%(˜WRy H •œÚ€Žd©ˆ˜GIÀ“˜­2<6úò/n<Œ_ò6ËxÄL aYJÂ2ò‘ mJàš̰5Ç'(„€¨PFCZ$…h(pýIhº@tx„€°h¨geq`‰R¦3ÿ¯œ [kŪ6‘бœ¡ÐÕÃÅŠOQ1 ´•¢èž„–€‹kŒÂ,?À.´¶° ÙÉY‹òhoôƒQ ž®KȶLÁ˜ÀIúð2̯’™J>3Å$ÚëÉøú>¹Hx„@‰éà℞iïPE‰± ¢$@Gž! ?ù“¡±¹'¼ï’xšÊ<|"ãr QˆtqLuè§}ëCï<ñTʲk\#ÉžêÔÆ6'– ¡àðŒf#:qU”¸¬Õ…®‡¶¿®ÛY/È«£èV. HD}Ñ;ó„*ÿš ”²ŽhQ{m‰ÊjrBÈœ*^ö¸dSzò•³²ùÙäJ/Æ>ê]A+ºkvþm>gׯ †À Ð ºó²Ž§d \C  }õÿN»6ØÚã]þr„1>[Gx/ >vÆ#Qƒ”xøYÀEƒô°añ›J:c2ÀpLm©ˆG 4¯ À騴‰PVÓ-› ÅëöI…Ð1bf”¿îuᥧm=*ò%r £ Ý£¹Ÿ7ð·¶bõ£åtÚ‰ tTu#¯ÖÕÀ…‚F°6õèCË®õ²’¸<¶'øírŸ;|:X÷ÛvP#˜¶ßPbQ auÌLÿgè2 Äœ"yɼ ûµÆÐ8š‰œÂ­oEržÿ‡„(ÿ­nÆôO‡¶IÛòDröu>R€×€ 0'dÐÕo3A¢*'„œR ¸Ð_?7v‘Z°‚%sc`Ðç|p§``å$Ï'}„Qw q:rqB(·f¢¦ ݱÝápQä±QQF1;Ý/†8Qz=Á8(‰$^N1Kx1õô sÞÃnÀ1Pô"1s:à?Pjàg^D0£#ÿ²5f1} Í€ @v27[Õkhç‚Ås:H¡v5ƒ*lÕ'Ý'§ƒ”ÿgkáGÚÃ2±n=GNág–Øs'zæ‚]#"ãëòc±q(Æs9‘NóÒ"ãáE7€d©´o]¡±O!mQ–­Àpþ“ù2}‘kîÑ`ÔvD+|ñdA€¸0øåxÑaB‚2ÿðwÐ&·'Zrkq3ÞÓzu¢y*µS:¨xb8!n1%9ƒÅ'Òµn@ñKNO'=Ñ3Ø=—ØŠÐ2†P$[ATD¶_3Pa*š‘am€“ Ðñý|ÃÇ6Æxms`³%ÊØ+ÑkÍWkÑ(»€·Lcaã`˜LDFÁKÿ:²„±!õSàÒ“âóò·!7 xE#Ð)©4;¦“7 KØÁšq ª†)È€ È`Zj©Zqk ¶Òm'A\ÅŒ]æ$Í©œ[UÔhdÒ/Êd7À"M±sÄÑÜÿ²-ã•M‡R(ß²š;…„³¡Ž£(=(÷ð-â£c4þ7tçS…ŸØI±@ñt:SA?JØÑ#*‘vÅ?®†^&ùZÇè$fÊ©`Öœ)ÉK$)&¸—÷F̧x”€ÇG°7£…'6O(¢R{2Ÿ=t£:5=§Ž<Çbœ94…Bz¥)Þ”M¿zåå“óyòbˆð´"W“ Ê¶_¤¬&P£„ ÂÐ)Åw1Yò$½&<êÑUЉœz©¡$ wШ‚')-ag˜òwvH$ 8“37>‡´!î/ýwž±.ä³£=69á…ÖÿuŸ“³.BICÓ-1Ežá™yÏÕñó(Æ‘JSH'KD&eSLJµ#"P 'v£°x[¶Za¦ëÑví¡`gªKºh:—-¸Fuƒ_ö‡W3’ÒaÂÀ¢ø¢Ïâ=®ñ,0™Ý´.‘¤4ábEW©4–.éÂ…©ÝŠŸÞê£ýøö4h'–bžt€G‘®²DD8»™/nQTW6¿( À° ÍÐwkÈ·K‡%ntlˆ`Iò‘º«)¢k”$"™ëx¼Õ}+J$(·@œ×­@C­€ñ!ýפÙ$0X4F9×UH88!^ ˜·„†ÿö8q!:cÀ¡==Â#–1ˆåw ?ðjüêsœcJ[oYA´¡KR°µÚ°§ÅC}Á´L{`±>ðwÇWˤˆËêS³sƒê-ñY0•Ig…”ÃMG“²ò¹²B©³ñ<ó-ð²ª(*¢3Ø¢M¡3×’N`XrB*¥S\±ÈÒ^ŸÂpͰ Á÷fvAA}Ø‘~A¢±µÊK"‰œ¿¬ÀJˆˆ`g†U /13¤$hC—oë­ÿ":”ŸÞrG š44’*45Ñ™Y"H$K°”ƒ›Mxâ†Ë§á324*Ø[*ôÕeÓ^Q¶:Èÿ° ˜[#c±òªU‹¡·rlî1`„àÿ”H¾ë­À­ô¸SÛÈë\{;Á0‹¼ð,/p3A8ƒÎõßÖÈ¥¢/hªdŒ¼ü Ï0vd×¹¦›êkº\åÇŒ—ÄL¢Sw7üF$IlÁƒ¦¡§ÏÂgU1sêØÀòØMÞzo3M>‘ú‰jƒýÜ šü„„'ª‘®%Å“¢¸„Dý~ŒyNÁóyÿ\\¡½P ñ/°¶¯½ìËøP¾Ä˜|ÒØ$¶’&ÐŒ1 [µÊHüÐ(¸µÑ¹ÑwÉ$ÐÜA¸Ò¿Ý— Bd]Ë:(u‰=9Àþ7YBzÉ䓟átÓ”<4ÙTR;ÿñô<¡a 7Ô:Á°aÁÐë·’…ÁÁ¸A³³Dk¬/gÁ†W´˜+¾Zýou¡ZlÊ|1¼UµJ‚%-áZéÒL’Æ‘Û~˜¾íÛV¿=áÔ̆ &ÃÄMý=,Ð")•C‘%ðöRÅ!+ÉÝô¶.ÅÉ7ÁH¸â½""ªùâýØú'$¾-{u!,‚ÆQQ:¦¡8ÒjÀg´Z ñ *{ìÂæu9ÑÞ` ¡àõKlvÇ|Ð ÍôE_m-¢Ò¾ao$ˆ£Q,"-ÑER‘磗LÓ…NÁ†MÊãÿœí¬ÑB‰=˜«K™’3xÂcJMâ˜É£©êÄ¡ÁNHýÄ/D† ¯&§Mð¨µÚhªÓy̺ ›ëg ’£ÖXofŸáÐü¹vÃý°õwY+½²q¼âxj ¥)q8Ó\–˜MUtí©L²7šèZ\" ¼'æèàM³ [«;Ò!äó@7ï<£-6Ñéîí鲟gÀ-ø)ÈuËð¦ý×ðÀ¬¡ ñéÛUg=1Çl||ÁÐïÚ Ñ—¥ ¿:¾Ñ[Á=[Õ©v˼áÌ·ÃIRGÁ¿[±¬ÿ-À»FºHBÓ>‹~­º;ÁÌÿ˼'ð·¼™~<¡~ÐUòÇù<ªqÁßÿî)Rïþ8ïàÿ"D!¸$¢áǨkË€-Sìßµ7FLäï_¼Š1b¼¨1ß?A†©¯ã?~'óm¬øqäK˜#¥ÉÏdÍ‘ó¥,À_z¨°ÓeO”.]&ý×s©Î úø!Z°`Å¿VˆJ˜b¼,äÉy„ì½{ÿ€$pCZ¸ÿƾ$K¶‰¼-Nœh1¯Å?¿óø¦God{¢ü˧oÅŠÿ(ˆ@„H_¾ôæÑÓÛ·ïK±ÿXÈ•7zôH-XÌc}‚…ë¢YC˜7ÿ…V&|öÏ!0|+ŒðÏ"K–H_ÆÓÇœ%c)[Šl~±zÓ@cÚD„ÒfL˜.¥CIT»ÏŸB½“ÉoitèîùE­ 9B„V ’Ð?íÀš‡…Ðä:"­É­ɒ를:‹M3ÃbšçŸ / aCèôAä±È^²ìƒ4¬¯À@Ò‹¯ð­4Rƒq¯½D›q5F ˜€ Ü𘄖éÍ·àf"®¢æ4Ò¨©Œþ¹‰:‘rº¤›¨I»(Áû§»ö´ì2 Æs/'ó~ò騟Ê3©1w Š1õ)(‚( @«þþù`Ú.M¬±ÐBp-Ži,ÿùÿKÑ7»pBÂ`âð{þAì#}LÄ«®úG.+±0À0¼ð¾N(A5Õ@"‹@AzAQ¹` ‚²3·Q~\è™Þ®å‡áˆsnÊí¢„r¥ErÁº)WJ)¹Þ+©¤î<¦¥Rré”P"JÊÔÓi>¢v—ŸJk2 ½-=¼N †ÀS‚>È‘‘S] ¬ Më-åa‘VÂ*Xø J€ÄV •>6Ä!Ã\†;Uk4ø¢ÔÈ@ò®df¬À.v7[ÆC®œbñÃI²aE–3’¦Ç:Ô!WK¦”¼páryTŸ¶¦Fž1ÁäP~ÿÀorC# îÁ·¹j,'†@rGèä£RW¦^¸‘hlrÿXÀä¹R‰LäãñL4 ùÚ#,eÉ‘´ 4!TMlDBþü €ÝAl6»RgˆÁ k4ï‡GSÊÑ|¥æ/\ÌrLÆWµ*µ)¾$*ú¨À iŽÝ$ø"!"* ¯ ¶ñ@jIið²F &1zŠÄ wVŒr~L 1VÖŒ©Â>ˆÀ?(ñV˜üó1•± ¾" UÖ¼ì5¯Z¨üU‚ T ¢0D,Êþ?˜"0b/¹”ÿtÞ.àNˆà8(€%hªˆzVI®Izµ1VÚR§A5’ÇD6žÿÈØ+ ‡È}¦$Ü­îÆ*f™ô1™DŽJkô"N‚äŒì~°¼eúI!uìø6‚ŽØ¤$AÖIÙË‹èRÔÏÛå´c&m¯Š¦wäSEv::? cæcUeŒ”:“ -â4Ø+ø¿­2¦Ðî|ç§È8XÈQàÿv÷ ’¶ªí»áÝR#%P[KÙÃQl”2 J6š)“³½„ÕE_G_†x8<ËݘÃeÃ¥ ÝI3šðŒ–´1&É{³—|éÄ:_\Nɞؚòs¤lïÁU¤”™Ýa.Š`ë–¦»oàè°¼èoÉ¥P ê0~¤Æ—Áqt?=Vʉzrøü.žÈïêÓ«¬õ„é eð5±1™ÉȹšY™ 7 À ^‡\‰…ÀY@e˜ãÊ ïØfÖd™¶ãФAšµ"Û`j;XbŽŽÕÕ“ž‚Éy½…Õù¥¸'{õY€ §y˜¥.,ÖµÆ7SÐò2\:I¿sÿ|“€ï¸SÁ÷RˆXÈC<C;HðùÏW§OO™aä8)«Jû£ û*`'ÜüÀRÎN¹‰ˆàØüõH›ö’6çpJ—%0Ì/勒’K™NÜ Ët¼ôÀ¿ž°Òû’ãi Ȉ •¡Ÿ¹˜·×øœ¹¡Ý‰K'ßÓ’Š ¾Pë/q|ª SC$·â§ZµÇÑ§ç›ŒÊ ?‰ Œk‘U Ñ)÷Á ¿%dàg¸\@?â©pçQ6f;00W:9­9ö8—º‰ñèaò¤Èž4Q½ÓÒ"—4lÎ#&£p&¥k:xyø¦³À€ÿJ›Ñp¹#MÛ#-!¾O!+ÓÇi J8¤è§Lµ"s>CªËÁ É«Ø '¨ÁGŒ >©€ÀØ¡/d(¿ÄȯŠ)ŽÈ‡‘j¹É‹ŽË" 3ë<)Ô’ü“ ÊBóØ” EõH‰¢ø9Q[—u  (½©¸J¸ G{ H”—±:1¨‡É—ÝK§Їh (ɱO 8OÑCê:2³šÚ'…[>}Ç?¢„X¤ÇƇ‰;„ ‹sÄ )™™ P!\ø`Yj¬ —~-Úz¥Í $Q‰(T›û%3ÙŽè rƒžžÓ¢)‰c:,ÿkË%çÑ D¸¸D(±yPC²(Бà ¯ /rÙ½L‘€ÑZœîøºá3«=|‰ÉI+ÈX$Ç1ÇÇi«~b¾ƒó.Fbªá—‘ð/á h…ûЖÜCÀŸðœƒ‰c©9RLEc f!3èqÅõÈ n™šv)0p¹"ð ½ð“ÕB‰0“v)Ñë t«Vx›“,™@·£\qF€˜|x¸i”Åñ\ » ‹§±ûÆ€+B Ä¡ÄxJ2i$‘E4¥ ø‡Ò\IDpJ _ÑD`ˆÜ9¼kLøxhCž&ùÜL6)´<Òò<éèÅÿ) 7ÓjK§x(ÂÈœj˜|žà–1éÈ;ñ­õYÍú¢óÉ·É¥pÉË M™ô7l »Ê>óì@OáÉŸ„  t«²‹‰ÊQGƒâœ z «[Ç|q7/²a¸Ç›ˆÀâ`%ª š+i9bŒ7[E¨)žÞQ&“ø›ø&ªP—'b+šEvÉÊ+ @â¼’ ·†Ô¤8Ѥ°‰ÕÜ0¡àÏfh`d‚Z€¦Vˆµ‡“ÆXŸÞë:¯»Fkô”Mù”Å‘ éú'@"»s4Gî"2ð ¤É («Ûœ¼‰¬²¦\aL DJ\€†ÿ̪´J©@݈›¸ÿÈ ‰¤q%i "d›–íˆPðd -¯"* h¦•ÑÀT_ha°€ÁÌE¬e PÒ~‹>Ý;ÿ¼ø »P‘:¢1tãÛÅaœW`ؘà'"KÇÚjÆIʪ¬Ê•ÊøR!ЧWpp‚\p¿½%YÞœ6úkŽä¹Æ‹,¨I,Ëu’vÉK-C>%:>ÍžJ©{àߨ_¤Ú»ìÜrýÂÒ%ÀB%ä)¯S§0Ô]~(§†ÅT©†TX|YUˆ»Z~U°5%ÏQ(–‹»ø ƒÍä% <1³R›†µ€Kè§!ÃÛáUÙöCpŒ‚ìE¤Kð"p\p‚_¸hßk°€@&4\]|9šS<ø˜9ž ¬ƒ8^ ›îßœê©réßÿÕÓÿÍæ:§ÿJIŒÎ}Fk®2^`JŠvYã -0l®¨à-þœÝˆZ`xÚM}O…Žgü`k¼š vĹ·¨1'É…„-R@ ¾å5A¸–a!àd¼Í[YÓá·ó­.êdCz…KXå^0b¾ñm† ˜ ô8sähŽ0÷]¼,¾š8Ñ™¦.Ý¢KÝ´<§Ÿ{à?+ãÿ…æ_ÎãÈ¥ã8nŠ5¾æ2C( ”»Dà‘HZ×ÍT¨Q £‡‹Š¢`§€t«Râà ÍÛ„ çÅØ4wÊ< µU‹tØKøäN¾÷”Ø[%Rv·V „NÆ«XåKè…ÿ_p6HâkÈh| n3ŽÎâen‘ÓŸ[ ÷¶h³ˆ’–Âu²c8¾£*ºËs²æ9ެ8þY/¡æ€‚p{èf'ø'ø_(êž¶‡ nŠ£º5ŽÆq.g§­]1*Ìþè`òp j¬Æ‰©­ ç q˜U¥d+qéú4åh"+èàdµ‚ƒ¶ŒNÍÏÅ9LO%¯§PaÜ(~–«òÒÿ~Zå‡mÞ°Ì`Ì6„ÔüR~j Uhn‰nå‹îhèë¿.i”ƼÞ¶Ði<žl–~l;5Éívéæ—(jóÎiõÎ쟮”nöl >'h—Ñnƒ:îéц±|@„WàObm_‚ü0gÔÝîÔ‰’ÊÀT-t‹^ˆ‚8Œ$ < PÍ”${Œ2VkN¤ávëü¼ S›»}œåmî´î…¼n¾]âûZn#½ë.ìì¶¶ô&9ö’Ñn˜ùžoò†‰ð¦…éæù¦7Œ›oûVö¦(¨íú¦‡60r+×Ñ~‰ù¶‡ÒvÝIQ ~ÏŒ¬¢Àôÿær®¥à7銓€[°ßµ@ÈðH6^~¤ÕŠÁp|z+ƒ–áý¶^5Bª«hdL§\Mv«æV…^pœ¾=â´høv¹ßÂ^fÍmËVͦ”÷¸Ïî¯,7r ÙqÀòU§ PWWuˆu-× ˆuÃxõ[W]o^¯r[v,öÀr)1 ×îfxÑü~y”‘ 9§”Úڽݵ €+R/K) ?)Þ ÿ´è}¤Ý$C2µ–aJ˜aƒF‡û{qÝ/*Á’è²›èt!Èèkˆ€§"@¢ëf‚o(àt{ðtüÎò„ÏiOWøƒøÿ‡¸(7'‹Ïœ˜àuÑfusâõx‰W/ö‘Ðx˜Øu‘?ucgõ['vðØñÑVyXßïÒnÚfO…_h‘¹½œ Š1ëZû"…5ÅEÉÿYúh4 Æ0œ„ý§LnwNt¸ÛEêö!!øá/z«T…KPåM^åø…6Hë­ôK¯ìœ.ê(G˸x‡u)Du½_u‘?ùüÖxXßxXy^§‡ßøY ^gõÀ/ö—ÏòZ_u—÷Žçøó·!x…mÇy±˜·¸ öùëª^UØ«€ R¥1{(Œ¿ Á Ei´” ‘Æ\Ø×< 5ÿDô?Oëv7Gʨ ¡ ¶6Ç(ß_èGï…—àÛK¸†f8%þ1 À{òÞñ6¸ñƒ‰´W´ÿþ‡Ëyðàøüv|Ç7r–Wõôßq øx,?üÏÿ¾Gü—zù>DÖLXª!!^ÜkxïßCyÿ&þkqâ"½yöB Ì—OŸ+Vü[ Ê¤}ùB„ø@Ïb‹óZ@ø'ïæ¿ôBÌ”ùe.}ú&Šùï•J”.Y¸Ä”醒!õ!¢`Uˆ ÿ”ª‘+—‹°¿z‘½4ñׯKО]ÃWáƒ=rÿÙ£Xw¢ŠP(ò¥˜WE›y5ðU¡І6y)ÿî-<¸/á‘ žŒWƒaÃÿbHÞl¹/èТG“½ñÃ+hЄ½ÊDžC›%V”wB¦Åôvrür¤*>þT¹r÷Ì%Z°œ÷¢†{i²œbâпDNDªtâS¦)ùX!‚‚H ­,dÕJIU‘\Nœ€u1–ìÙ_ª›]…¨B\r-6še‘Öf b¦X‚…öY‚™EÀ}VZgœa¸!‡ª PÂÁ<̃Ó?'$wÛ<µÀÂD'´0Ïn U”p”¬ðÊH)±ÂK3þ$Á=÷Ü?„@Uÿˆàd_I}÷OSU^ò ˜GÁ?­DÐÞV”Qÿ„ `ýãÄYd‘5–Zü³@*Ø|a&™„†í5à^ˆQvg…¢QHმ*h†‘]Ø!£ŒîöX@O,°H#¦-Út‚<1Åxo¾…Ô+ÿ¨¢Ê B­äDF1±$Ô!(9‘úP0Ò+ ð8ÒŽ¦¢*%%9õÔßñÈ]’â£UTð¡õ‹}fªÙË/ÿq›à_ ¶he†gbY¸§^jð-a†Ëa»Ê;/_4æ³€¯HÁ šÒr­ÞDEK̸Ó"œ*\I»š§O@¶0#KýÔ ñºE¥–êRaGÉO55^°åÝꥤ’fEÿ^W½Ø–¿äRV/Öb{ 0l«Ýz;Xfä"†îƒy=™ ÆÊ¡B[ø4¢ ¹K½Y÷Eχù¬Á ²fDn-Þv[ŠSDÛn$‚IRçªSEüÒÅ×™O­NÞjh¯œ4Üx¡™ÕÔw¼þ“¬²BŒG·šÐþâ„ ÿ¨ù4;ÿƒ!Ø dx’ÝyØèš!Fô·¢ÑóY…àv¯è§]ûí¶ã¾ûMÆ5"” "ö<ó\$#§Å·€ÓCÙÔ„½ ®T°Ýu5Õ|å”PN>é‚yN"BÒ s'Uø?f¥o%âä}½B+ $‹VìqÕKh¹ÐÿF.Ú]. 4øÓ üLjvZaЦÂìI3ÙËa¾å@ß f†áZU@! ¼/ŒZ×h&h®?ù¥3dš Ix©mm”A¬0%#Ä„†ÿ8BCøBH§ч B¢+º‘‡<¦2OJò±ìýãéÞ“ˆÂ—ò™ªzêS•¶â”bUOWò# ãèç8¥ø Ó²Y`ÈRªf®-7Øè|·º>0B¾ÓÓéе:IÈBYÌñ4AFi°@†I åÀÞJt}Y$Õ>$JÜ †/ÁÉl&rD";ä@C˜#ªòçcï!Ž*¼±(Dá'ÉÇ?„"ËXB ÿJåá‚e–¥áp[¡H°t¶.QÉËrܕޣŠ5í-øy…ÁŸQ¼.syZ„"ø.Ñì)ФӏV Š“…ò¡%D¨-Æ›"ôãeJhBsµ³2[S><ვÈÈ6š”Èmp¸É‰àŸ •H@6¤ 1•S1N+ÿ±((ñ‰CIIE’Jï /}â æ.)âÅP_-sÜx.áƒKDnrþËÙj,0 `à€£`ô­>¥ ¢Ì Aó4Ÿ*Rv!ÄŒ» y™ªAötd#{‡È?&Ò2ôà‡pô1K-6I*l8¹ÃðÐ&;y¢FIõË#¦’8.ÿèžJ(ú‹u/ˆ)J*s4%õi壔8Ù/µ´DÈOYÖJ_úÞÃR™¡ÉrÚ¹„0.‘¬Qà#ç ˜9)ÍP°‡€Z„–.yA“Òæâ'†¦œ²L¸0ø¡ÙÚ1\ë jèÆõÈ 1Ò/Lûm 4`/3âÔÀhô°6Îk^§èáÄ„­—!; qèFœ¼µ{°¤HåbùÖ'­ §REÊ”*…ô;$ûG–F‚ˆ0®e[Îy/—3í¼âB ~€Qàã(Àíá¹Ïª@³~ñ\_êòYŸV´î×îBq’M0!a:ì-*°4yÊæÿ‰SŒâÛi7"ØÀ 2R¼ÀF%˜ÇuÛ)¾ÈÇÓÕXù8 _“¬ X¨*ÕC³CKïUî7¤Ôkõ.(3ÜžàíÿI5E7ªAYÀò1–H€H€¥{béQÌF7.á êóå UuKÉP€ʼngaRúåRÄ3­äÚµr–¬?ú¥>@„©Åì_¿BиÄ ¡ž˜Í¦Ë?Ì|¬|®àÇD Ë•ÀÁ)¯‹Í표¦Ïr’ËŸó܆>F3F/z¡…[*†ÐÞ~z·£T©óª¡‡=²$LÍBXs¬x"ãÚÐ[¹hy»cD2~:Ô¥B•÷þð’¤ZÙNÛ—²>_:ådê{xJòµüU£ÆËÊ[¾KôwãéS ¥. ããZ®@²“-sÿ~p^å,gù\aþò¾©Nœ«ÎmšŸ;Û´(϶=†îáÙööŒ¶ÓÒ©âݯøÄ¶Ýš=ÐH BÆ?+ÐCEA^n*FœzÃP¥x‘ˆÀî'‰¯ôL#J9™ ï² ø­œTD¸YŽ6®wÆ]ÿÁ*»^>óÁ|_ NÄÊ%Û+5ÌÙÌUÀw5Q̵Ü#陜àÖÕÞ¸4Á“<ýT¡)} ÔMrÛ»(=Y+¨‡ ^+B0ÂØ½MŽQŦÇŽ(Ô”“pO-E‘÷ýø…v”Þi`Y JÙ×ÂQÿÉñ4¼Ì•bAÖ5\ƒ|À Ceý€Èi"À\h B£`òQE”!ÆýÃV@Æ’`š–Ïå™_Ø×@AÓÉÞëiàn=Uo9HÒô"îÞ™ = ÂHŠ0Ô‚DlóÏEO‹ìDð¤ÊÛœŠà W©¬ö™ ­]OHL[åø—Y`Q”¹d‰HŽÂËh…VŸ0ÐÔMá(šŸ0\4¬€LÀüà P0TÞ PÀ" üÃ@£–%ßD a_`#_d‡>ðÆqÞòC7ŠFŸáE]äE†MàÏŽ›ƒpÍ É–ˆ‘›Pq :ÿ‰D$’4ÇnÍLhJòeuåàÚÏùD‘GÈE˜WùT×§ŒõS_XÉñ50ˆ0“þÃ.Bƒµ8œ/‚ÇãAƒT"\@~!2T^+4ã  ¡–Í$Ðä¼À\R„î$6²V 晳MàFF‡šQéÆíp¢Ñã"bÛ5JÓAÔÂ+ ÁÖÅJFhÀmìF’„% $U®P¤ÎZõø›÷ˆFšÒ/]Éh0ÅñÐ?CGÖVÔG*!–¬Ô(zœ0£U\€!´Â(&>¤þ¥ L"#Œ—Ì$EÈdU$ßMÒËFnÖJ9 R ÿÕ¡‘ ˆ¹#=Ú#Ôéƒ4ƒF"D%¶pe6ª†':YS[ª‚Çœ"I¤âhðJ©Ç§µbYäÂÉ¥4ùÂ.6ƒâƒHŠõé&E%|@ÈQ@‚€€Õ2 C-àŸUP€dZ£6fc3NeÎ${Væ¼TQ¥9ÊÉ<ú ¥ÐïtFR’Û7ÁcfäƒT6UA.HÀFlWî#Ìà £'ò %gw¼”|•„ö…DÕ”4ä©À—wèRp'-œÇ54øÂDD'{€dH¾Œ.­ã-â… |€‚ÈQ¤2øÂwþc’çD\¦5‚F{’'5ÞÿäM²çdþƒ’r —˜Æ€”ce›>R }æ~:e¡\aäƒ<k C+è‘`g|Žuè=Œ©0 Á½é¦¬]ßÛå ˆR‰W©eÔDhßFEhE®•h¨Fvd±‡ˆDgE^‚˜uòéÃÌÃ-L \€+$ÀÔB-ø‚§¦XE46#4^czR#”B#‘ö…LJizò©ºN ’c]`n\ÝliØlÁ#hö*¶ýê–²ŽïÍ ÙÓ\K™‚šrÄ›]Ç\é .\Ã%”‰vŒe„þ’[†L(ŽZåtÏ]uqüªÌ('¡RÄ F®†µ, >àÃ^N"¨¥’˜õÿ1ÒC ”  djvª/,C—Œ'2¬cRÄ”F£zFf“Bi¬F#RæªÊË9Úv¦RÞ*°úê–‚&:þ*Ò†8P=ýªL¬f3(gU¶›­)šDÒƒ>¨Fk\” …RqÈœJoŠ@·¾vd”ª© *nžëв&k‚$EÐÏ âBG:ÌÐM[9* Í ¼ \Àü«§i*ˆê”¦ªÂ¢§”ªj‘2iÚ6c“ž­¢Õj­¢|RÄgj :þÖS•ftPdÌà °Q—(v›ºi Vè÷ŒÊQè&°láø¬ÍÝ,ýCÿÄRù›…ÿF”-œ¢¢¨]î¢èe.bNMQذ%Ú%ßJ̃¾’À¸B¦&€Øú0”-Áìe)”Zf4®ªJÊ­e ¯JÒE‘ØC‘PDó>ïD4¯¬òòábPÈ¿p…XP pІ öj€‰¯ö‚©@âÅøf¬dÂjFg%ÆÊJìœäã¨Â…PðJ[ùÊô,E”}(w\æÎ]ålq˜Š¾mŧMIèfG¢¨ÓZ âýe!ß$–‡À½Õ[ Õý]ÀÔÃàn*x§§þ@¨Šê5©{ìe&/“ž§e¶ðÙ¾…=Øðà°ó2/ihfki¦†´‹8Y ÐgØ*ÀØÿ­oYH÷v¯0‚ÌdHñ<ˆïX4l¤œ©>´lõ²ŠÌ .¨ÂJdÌÛìŠHTK÷…Äy-Ôv=IÀ Eÿ|×xÂYBÂe£ë\ndGƒáMD-8òa™'‰ã@x0‡ð'@”ðØB©vZÅ?B‘b#"ŒáB©ÈáñÎðdþG‘¼Åþ¦²ž2_À…ôšÆ­N Î2 þ#¸ =Ìòf̲†pÆ‚qhÄ@‹ˆïü£nà/H8.K0‡5VXh¨å†ÁR+©s?Ùyq”{]d1a…V3œ—u5ºeYJŒÀãh‘Ô.¤u=¨õ?ð[#$Ì5]KhX·!H@d÷vW€vBwë¨hÈp*ÿ_Eïu‡ö?L€=0#|À{—´`Ÿ4}Ó LärJë†bë÷1 3Ôì÷c3 r LÀ—dÅ äüòá4¿Nx€ÀÄÈCL oÜH:OX8.,é9£ÊZr»€GȶͰäÚvh¬_1m5áMÄúýöv‰£82àLÀðÀ@ÿCr×ÃD@r$¬À¦t#ÁLÿ@w[·uÿŸu¿.ù?h·v;à*ë¨uoò&ƒFCù*—·óftãxcó¾·,‰³†´`¯¹-ã÷~ƒÆ~S¶d§4«wd×Ë @HJ+(_¬ è­†ÎWltŠ«ø"£К)ÁÝ?AÜy«:ç’¤ãqÎ*‹wÔ….Nõ º"|?níJÀ×Öðør/w-ÖB‘#’#y){ùD£’ù1ôF_²]‹†]ëh’{·±_2E‰)‹9Ž#¹™Ã7|{4Eä·¦äw½Ør‹,(¶ßr1—µßr_´È<èƒtvñš®)Þ*ÙÔÅò4AŨpÿ„ÐBQ“‰e[Eä·b‡JðE™–åµ.ÎQÈO”m5hxº­ÀÐܯ÷@븪û¸»z$K2Àú>@7£®O€çºG{-´@(Í4_–A H˜mÿ ÚnÛ Èrò·ˆŠth $ô(É Ò(¹€4é$ ­Š%—À›I&¡nɉ„ynù®$X¡7zB€Ï©ú’j úBpâŸ|Bˆb (ôSk çB+À°¾(Ÿ$‹®Uyð 3´Ð/ÅÐðA ' DD‘`)&8‘ÎTÈÏ-hôe TX»VØŽˆmÖ#®Äˆ6’|Kò‡*r£_‰{’¸^?ªÀI*E’oR¼*Ob KF ³Ù›š¥é " ‘§šr\§ºlΞ|ì¤óΑ ÀºT‘÷ŸyÃá«Báê ,xš÷Á€Òp¯ÄÛ°ÿBD ‘ ÔP9+ÕÅÿá!¡!ãÑj\æŸ.¸eXK€m ZY¨õä+I‚Þ„ë-¸$…“Ù8#™¼ùØŽ’€JÝ>h–‘z~ö»ëÄ;z·mWš‡Ú0yK*\¨¤ÓàÜúÜt¢+=íkJÏwWPe U(ô!BJ| Ì?}œËϹBÅ 4ìDF{0J2Œ0½DÛ[}xÉÄË~XâÝ.NãU}‰?³„1o›•hÙRrW"%*N¸ŽŠSn¡ D¢#” ºòéÈs©Úh§Ë¶¥.õÙô©p›jê½÷⌠>{˜rB]¦ÍEŸ_èRù>ɦ’W|p~|ÕÎåÿƒ(²ž}A…èêÏA…v0 ÛpM%8ÿÄÌDøEÝBK~Òl\Ü$n¹àãY¸ÅV”m}è÷P t’ÒfÏBq ñ$üƒt½Šˆ’Ÿ%ägשÜÐHb4˜(Ä%GcĘæÑ² €‹1pJ Ú#zT-!¾+T¡è<éÃÿpÁ/æ²=°mïy ˜× ¾Âçä).þ‚[]"Gõ‰Q{y……Và-†ð 2ÛÌf\*… ÁT0"M*jôT$ H¨ŸJjóÊ d »ùß­˜:%="x¼€!4Ò‘ä\ %?+ JšÅÆÝDK<&y‰é¢HE¶d[Lÿû@RB0§Ä*]ra›v‚äO Ô—žˆ÷•¦Åû©ËZRi½úX¯NûáÏCìUÁ-C qŒ^þA¿}ŠZë ãnÀX¸‹Ñ¨ñ2p 5þƒ!#HäÜh¥{Ì1uºù•'ˆ„ˆ§!œÓÈD"¸³e™:l$¤Kz¦’DRi¯£–é`‡¥Ö=D†°Ç<,.KF%N–œœŽø<±‹NÒáŠAm˜‹äB!`1”C¹•#â) ƒPB5E¸åDKìO¬H™, Îa*êŒ6³"ÃÉï4ÿ¸ÑÕˆ¿’Ü‚µ9É2GfóY¿VGr‰èì¢ÃÜÿCÚ™wÖ“<ÙÑ•øù˜À ¬\MH 4@ÜÊÉç)!¨«}”ûÓÈÃ>ÁW¾"Ëþ¤e¯P„›^@” |A8)û™z<6±ÿ@ofۢæ§áX-@€Fü},dcRÈßHZ+!ifÇÙÙF>ÿ7?’Ä!RÒJ 9“°D‘Ñ"ät\G%je©¶V!´°æf'É?ÿ±Oª´@>òiZÿq£Õˆy > J]åb­/ˆñÔe<År@þÁåÝÛ§ëö )0éÄ,SÞÇ®4!ëØ¨Dƒ1ø)®²ÈèØÐh¿ °† –ûǪI¨úw7¦ÍÈæ là‡Œ„ƒ$ƒ Ig Å‘…Äm=ÏœñäùxŠˆE[®ÊÄ*Ï}ñ‹ÑŠbär.í ä“‹ªº ^^Ébd#9PzyP+So…€2C,Å\tÞz„ÊÉçU/;c±‹¦¹N¦Bh„ÿ\ ~ÑTHäle24ß s £H;çf¦.ä$vfÄÏžÍÔ ;rª®ê.<;·ðS hU°"&œû÷hºÑš\® ¢‡ƒ‹<ä³PâñMƒša,ÕŸèY7­xH]^¾QÆäµŒ«[D±„¸š¼OÕ?BóÞT˜QFñ+ÍLs”£Ç½*W%ó±c¦Z& $"«UmrÅu¬Ë®(|499Åæ1 s ÔÎu‚k^ö’z¥+d]‰J(‘-æ;yäDÿxF]–Zö­òõš@îõÀ3€ÒÞÒŠMb"­œkp¯”ÄbŠ(DøxCßÂ_®.ÀíÀîz©KªLÄëíÒ+½ g‹è®îÿ‚îÔK˜D#ÁF!\áž)§r*vd6Jàf%6b€&à|Hn"B#"H:‚ÚlµÆéþ¤åtâLÎà)iôÛìP òÁ|*)Üæã¹ÖYéZL /®äÃz$P÷E!~A.B¢‚A€¤Šª¨—zcSxà‹í / @½XêÕìn¡/À‚@½*Q¥Ü ×!™  íÎ5±HàXãfdSÚÏ¿hXÐO ÅX†Ã$˜ÄIäŒq©Îz±ƒ8 ÉãÎfN$4,‚ÆŸ¤C R,ÝP>X H*RéÿŒÇx(dŠúƒ?`æëðßv£‹7þ°:‚€)ñù&ñ"±ë±JE3ìαñQ½qp çT~Ìc~ ’ Aà@€ÐHGæìWÊ/›’"ïñ§ÍälòåýÉ Y Ûx;HYœÌÀ\Ò£)âÊ)m ¢Q!PÌÒ÷vìxH,ŒÇÈè°{CAîðmK!zìú°ÿì” ÑñÛñšò^ÀÖQg *1–OTøñT0qFr•éL£ïþ!™’† ’ã|È!S§†µâB oQtx…#q+óôŒž©tÿ.¯Œ‘$Á!Ö$\>€MŠ%ã„+v¬œ÷Ü0÷ŠÇxäÐQüƒ?Æ¢-îåÈ$ø°5å( ±Ÿ/ÿÁ)ñ *³½J%]ÓîQ[Ê}@ƒâŽ ,OÃúŽU’é,/®øè|$€Þ²r†#ý–°ñN«I.2ªv®5ï­m#Ét„†%Pͼå;hÎ9¾J´¢Q+°Æ lÈ Z@oèç"s²;SzäB3q©QìBS*â’òâ‘¡’6›6 à T5›²¢˜0‚»¾t­²~ó7Í~2" ÒÒ† BýK88gýb±.Ÿ%9ÿ(o©4Òþ@r´3Ϥm%Lb’Σ·Ø$®àÅÚMæD=ïdÇä2é¹q,„'ñå?¸»6ªG<{)K@+±AŸr[Ó5QÙ1*£,ãNT8q+%&U*4™‚Ckqê+F2&Z!<°w&å6Bå,/#’¥ªhŠvªÓoåˆBOS>€ŸB“b=Bè#Åè¡ "“"³®°†@ð 'ïÅ&ùT÷£7üDŸMЄ7(@ÉñPs ¼TcÕ@»´U­Ò5qL5Ëk}8#ER…cd à´U,t,‹µ²Þ´âbäþ¡Î ÁÉ€®D©î Iÿò2+ç/‘ƒPï HD2[¸­e(à„,‰« "7¤‚¸Œ+Ù%­°fH½æºèp£ì-à fF$zГUyC_Ñ„g !®4+QAµTTÔ61€6«EÀŒ|5U<‚qâãt-׬„Uâçeͨ!,g °ÍðÁ”¥òàoP·P[Õ‰["[ÀKB ÿb"G»dj裸Z²¸žB:45º¾Â&ó?AuD–¶ëÞN•?çÂ^A‚æ!)öUÕÑ*1½Ô*Ta%ñ3êôb.†YA 2mq2cÍHã„“c9¶Œv ÍŒäê’"˜S#ÿRt •ÃI@g-³“O?’Ïî/þªðþ¼°eÎãÿžNÚc 5N "¡˜Ë†ª >5,ð Óâi¯ëmžvi; Þ–#¼JàT5gSK á‘úâmA`.ÖcÄv3FF.&m/ÖÊà6d[Å,WE¦’5oÀ eOVp™JgÉJ^Ö/›j¶¦ðþ˜Chz&\õaÿ©>àd ÈŠNÖjNìkôã]’t?:­(Swj¡6? f.Ð"xÀJƒ ukµA[õ%q˜$6l­€y×bön7-Æ€]J7ƒc0îAÖBY…c–a~Žm4â ‹jX<'eOnp)¯gö´Ú éòÿôS˜f¯sºLbvz£·x vC­Ô× ¶®ºúåsçu_SjûC~Gä³.ë (‚€uŸ2_õ*£òŸoY¤}ˆ¦Š»²€÷ÎleDm1Vã6æ!–c˜·Wz¡PÎ>ÂOoM˜qµ5 Ÿκw$X¢$Ý'|‹MÈ·Äþ]ŽhMˆ}%Ê}É"u±@>-IùÞ¼M¢Î'‰Y·u"Ö*US5˜ù¸Ò3RåŠ!T]*U(ŽØlëKx¹×r­Œ0x ÆøØâòsŽ„kÙo[Î#TîÂp§3…ëO{1âÂ,TU sÔ)¢=ˆ6™Ùˆº¦ßxC-ÿ¾1,Àn,(ë„s©A ྐྵU ’¡òJŸ’5ï®Tšì“»2îX¤p®x”XDG#ÔÔ4Ƹ²”—äh‚ˆêy+2!¬ÕZ‘p3ï:Yxª¢*1ˆ$l–ÃXb’¼%fN¸B:n=ÕD¡œ zÔE?º®7 T.,,¨‚ôÁñÀK’"*Ãô!X“¡ïJÚ§èY!pú48ž)®BïY,ÿŽäfÌòþY7òrœz™Œáo9lôŽ%îbHhé¡)˜b¡` AôD]ú3ÕÂiË—úuD è‘DQ_€^àZ*uCMÄî^dLwckZ7L¹ÿ,fl' Œó™y9g8šíŒO–$ü(z¡äoÙø©‰†{“ŠeRUÎÇ]”‚+n' ìAkì”Fb;mÃ"_EÐiOûï0‚ å Úº­[¶¢‰¹ò®ss“G4Œ^dDq{ï"†wq-ƒ‹UŸÏ"NnýR´ Qkz¡¤a-×Ì#à,ªC‚!J2ëÀ("”Âwº»+êä³A©3 ™?$QD`?94Ù‚^%@]8%$ ´à¶8Š1Y‹VÊùH+¯¤TØkEª¸â4ÆFÆR°‹ú›X"ïäìÒWXŽƒLâ¹[Vº—CW¨ÛÂÓ/!Šù^}‰Sìʪ']”b†Æû^ÿ‚,°Ð»Óü°—°Žš% ²ótªœÛúj3¦•r B…Õ¬øYxûÇA‹ozFlŸ¥›JÖ"6'#Œã#ö¨ªU/Õ˜—+Aœ9x†!ôAì(€>ô[Œ´G¢ ¥-Àâ”Î#è;p^1"Æ)Bhæá€ð­¹#Z7±Bbþ;›ú»bHŽb€Œ ÜÀ+¼ZC!$€žð#"¢ Ó/‚¦#*¨EI‹J¬[$69ŒÓ©$\o ì„˜ª3ÛPÀ»3éU-øÕ_=wãG¢Ž½y¾ÝÚ5oW5ybÂáÚŒòÚ¦Ñ̼®dÀÉHŒ…û©£ŽãƒÏ¯W ÿ(‚®U9,(ŸËwú©Ó»}Y®U$¾sšuÜ}I2–¢m>`ßL\@²+_ûÐÛ\Št ¥9š'ÚúÇ5u#áZ7­ÜJêrB7™Ø)ƒà÷vÒhŒ…ÑÓÏ8, ™#±±]t@b …$xA@ç’jã{$Ú7Þ¿“Ô¸ ’¹b†¾š½Ù‡P×êˆ'íŒ:S2¤ª•1Õð]×mWñQŠ­ÈєѬT~µ­ÄW÷®Ðc*á# ‹D å è. œ”PI” 9D'$ò’g.ÞÓ!èã/>±=gNT %ã⎢/HÊ-ìêˆÔEkÿæá7!Œxv$>ýbmf.hè*é)å^Ç^ÚaÅ™wÐãn§B§‰æéÝk¿$M£~ê‘›ê¾êI§ §}o3ä9¾ýR‚nƒþ¨Ó¾¡?¾OI#’ÊõÏ~¾³î=\Ìõ$AøþÌ©9ð#*"Ͻ H¢’èA'd‚ußñoü0Àa‰žífÍ-_7†“­¤}&ô¦ƒÝEÜY7žÀþ±C8êò8êÒ›®ʵ‰z}EglÔœªWVôrâ„ ÿþü@°`…‚'T¸€°Â ÿ(j¡ !&„øX0ʇ|"sý3©O_Á•UV¬˜ïÇÿþÕüá£y,ÿÉ“÷è‘08‚Ô•‚Kyü«çª^A§=Y&(xõ_©U»áúoHAWYµ²”ŠíJ°W€á+®¯®tëÚ])ÖPA±ÿôR|iH’¿õü‡„å„‹/¸ðßãÃ6B\)2c– JÐìxâ…‹I˜ù‘ž½š¢ü QòƒK•%äÓ'A_®Óù^sü!Dðóxþcq<èP ,_¼àAõ_ô¥+£öä‹•+X³vË井n‚ñ ¾Ö;ÿ4=÷ñokÅÝK1C†èE2¿>ý¾óíçõo€}‰…„^z‰…`†Œ&˜`\f’AH¡ÿA7M¶õ¡AYöPˆ’M`È@ -fEB¦ Ç=Ðó=6ÙBkäÒ[>!ôvG½É´RG g\A%°“D õϼÄXt¹òuxÕSYjqWWZçIå]Uä‡Þ—f±çÞ\,Õ·R~Š_€aÅ7`UöµeÚ÷RA†-¸à‚=d¢Œ]ÆP¢UVaA $YW‹„)¢"d‘i@ã<ôŒŠc©9†`S޹ì˜jU‹í”=Iþs +IÙt<¸âÔ±d–ßqWO™XÝÖx{¥§]A °ôÃ[ ´…æV_’÷îQ€Ÿ}óá ÿ!ø :.Ÿyzõ§ †…Å’ƒþ5š¡HÚÙ„A8B‹j(¢BþRš(…! L0…ŸQt…0<Åãk!ÐRA¨ÞÔ“pÄ7£Ã+PÂOÈST+1W ôºòT= »åSWiçÝvt ‘µÊjõì³ÿ¤t¶Òb…&³D»U‹ºÜÊ)'}sþ³tbN-(»ë&– Kƒ%¶¡ !!A!N$)a£HY¢È®¯¤]F"0âp’¢Æ@1=!0‚*ªÍ´ØÞ ×È/ÔŠ÷ücrÌ1÷ÂS­ÝX(ÌZ‰U,±kï5^| ´¢U[k”Ê©üì¬ÿUÕ¦™©à×íºv‚k'·×QÍn^,…;'‹ˆÝÛA 6¸5Âý¦h°hŸ‰Ø!fõÞõÐgÌšðìDxO²æ4ªÓ¸’ÇÄ) 2ÈÉCÉ`òãUùϯ-/eÿS<Ôs¹z+¡‰cU…-8KÞÒŠ·ð¬*« šÐV¢À¢)vP P~W©mi]ìÚ ùâ;À Æ]RŒ¸õª­$!«ô܆°žDFíÅ?èPbˆA‡9C¼¿H`ˆ° Ýæq‚l¬8³BVúVâ$Ÿ}‹ûÞ¹ÁVôó•S €?ê`‰d¬Çþö—Ó­eXk£Öÿ{æ3–<«ÿHÚêœ•Š·= ‹aÆeÙ‰% 4W†7È®æ%‰iÛdzYÏlÄóL½Z¸Bë}n%ûx€¤Žg(uéåóX XP‚ðD•ç£SÉ‚ÄRÈ¡åqä%(Ýe(sÜü´ø*ei%@ R–‚¥§DÅÚA£TÄbº­°+É,VèàȺ<*Pv«Këðø¬=ÎLPܺ]Õ¸&®¦s%‡ÄŽaFcBn 1hP¼yÏ|,“’$È>9ÄMVåø …ˆ“y0‰'`(ûœÄ>Ÿ@ñV,™âŠ²Ë•àØhQVb+Dî‹,‘ܯžÿÒ?éH¥šôŸ@¡É®du²“ÝÏ€æÍžØtZ{ôàÔ‰Îi@{:d»3=¶õ“0#ô'„“¨çÍ‹0IÕd»’*О,ªž) ¦8E\>”–ì+ëîA2Ÿ`JÿØå=°K°$9àhODJ¥3óUÚë¯ÌˆdêOXõ€fAðU¼(K¦sìãMSQ‹;ö„¦zÜ™î /¯ÑS\™í¬f9øÉ΄²lÌ hÀ&Ó•I†rµš¬„[—j01ÐJ²)ä¬>Áå=ŽpVűµ­Ì¹"Œ[ŽšÌŠžü‡¢Ì à:{ ‚ä€U?¥Ô¥(åŠa] Ûÿcõ,›?Z¶€FÇl=ÖYz<¡Q‘§ y,yôE^BÐæÏt…=1mU$i—Ï´#¼w1ŸêÙ_ äÖ·Ì9+o£´8áE¸rEQäJ—#<÷'é?®Û×—ei)üsŠ–Øb3Ø.Ö¼7ã7ÑÛ:ÈJ6ê’ZgC¤ú©)L‘‡2ƒ6„l åó0UIþþ7ˆ£Å 7Ê/€ÀOΚVẕ·«\+ü¾åÃÎ…åš²][³*ÚuŠT˜ÉÌeëÉÿ3‹yS'Yõ6° „±¯jPL¦…ú¤—%#T— s¨!l«$%ËJc•ÎvÂñ.± ÿ¢D[’w(Ø•R¤{¹½òU‹³&Uø·]ª¸Â:œ£´ë ’@žÕ‚.¾)Ï`\ǰ¦"ƒÉçKX›_»L —j¥®]í®’‹^ äª¯\OQÓ§!% ^ðÛßR±­Äs…“ÛQÆ=ɹÎuø‡”¬ KÖ­Òu_ëa³YßîJìÊb^i56h>s  "é.­‘Ú,Aô´»r‹ @ÚÖÖ6Kjb¼@±°à=˜¡þ ˜†@(+ˆ@QP!($ûôÈ ì`ãbX¹ÿhng€†!PŘý;@䂉¿•\áLÀîZ¢’b_ðÿxØ®°ô‚(#Ž oøLïxG÷Ò“.¬ežÈ9Döº`Û2r[&«¢c’o2zµq$µì@¬¾(»Ãüj ëjÖ÷¯øZ¥ àA4° äÎÆÄÎA½ §ñLí8»À¸C~Qê?)ƒ0F+f·ï@44dÑÚäÎ äéb=N%V ((+»Ëê÷ðÞßÁ<@Ó_|–0Á WÁfÏpÙŠªÇ,ŒÙª!ÅLÚ ¥ßÌç°¶ægÐ"f~O€dr˜¸lk¨oød*ÝèÞ‚÷ß_9PPá7­E-|7wM_µ’RÔa}+¡hsW¬wOlUð§d”Vÿ ?q2òàs†Ïõo ø~L@á448•',R Q/£ÕH!¸(‹ö˜%`œñ6ó_‰uqX:VUp"U2è}ÊâBÓ@÷w`F%óô_9†mÇcmHˆ„t1K0óµlf¬€"=PpÝ0\ßV Ï•u:ø~W€38#lt4HöqOúw<Íf.p‡_˜…øÕq]Ávw¨‚,´Zl`ÅPŸyòˆ÷{bh<S@ãN=áTžÑc¦õ kd*ˆ"—²(Ew…J~hˆrWŸ(оæná@€ÂNµ1hø …Â|‡á_ƒŒhæÿ†:诇Cç~£ø~|A-²ZZ³cÌF…£ñIòP5Œ¦hUmþ·6làz¾h×øz¦¸6(_ñ²}Íf #øŠ”&Z¢W/Ù&P$À‡ØÈŽí¸Iƒè:ŦH âqÆhŒóò Ë6}w‰bH%àŽù93 ìñRáBOõÕŠ}1/‰1/ˆ±ßÖ„‰%ÿP‘ï÷ÉЧfrw™XeB„d.éD([㈎dª‘›!z†X»è}6X w’C $×’Ȳ3ü5=÷¡ld×lÉódÉ´q†X} È @r’ã6)wדŸó“’aPðeBõÄ5"…Ú×ÿdÙ„$dy·tð=e™X)À ðgF<¾æQ)w@•kSˆU™6÷UÍöyHO-™hX’”IYUq $0déz [RïA` $÷\ÿð‘r× ~ [ 10¥ù_Öƒ(mCiŠÆ%°”®É<™<™—^u y@ðЋß6F×›¾&•¢ [Rm–ÑMx‰†é„$ ˜Iù¥÷˜Èb›ÄùFà¸IgFðVhÞ‡%Ô‘bCæ!rm™xž”¶˜(™ÿ”ÕYK²MÄqù÷Y}9Š<‰,rˆ‡À—”ïIÈò‰ŸŠ ”ÿLÁkƒ‡Ì™Ži¹ÐIò‰ šU0€¡£¸kdðyq¡º¡e%:ŠQG` йD¢kSD €“yCðç²ðzŸ¹6n|P!p`±=°¥–:¡€z1º¤»u¡G` ¡DÿðZÞg£rBš' F±—„ÈŽ*Ê¢=ᜌ qtÓ– Ú¢Ça›0Ú…·Äêƒ[ôIraÀ ¯y®°‘ß¶EÃ)ŠüIgBJjZ¨¯B–—2î *Ç$ –t³”ú¨t¦¤1º[U¥Ä©ïgEà7Û)»v'úmÌñ¥|ªŸÈ2$· N¨‚léžkYÿ>µªd)©‹édŒ°”9¦uA ,ѤÐu¡õU,JÇÁ© Jg’á¼P+``OÆ­0¼²kÿ@”ö¨$·ªv¡¢°õ\åj«+A7”Ѝ¡«–hÉ•ÊñŠò ™·™ÄQ¥´Q*¬¶EdEÿJ%ÀK§f#ÿàñ "€úÁ)P_€­f„j¶™ßªß†Èòfõ0Üy”È’¦We¯Â²:áz—– âzòŠ–8ѨI™= ©›4¬#zC%˜*¢Ç y ôÐ=Á ål ¡›D¨Ð ­PU¢fö\²ÿkÓ ›ÉKe±$õ0²‰µRg3ÎéœõJzgÊ·@©i¹qÕ*©?ë®™$PjZ€Û—¥Å:6¸ŠK¢K²JþšU(ÀPMë11Râ§fÅ ž4­<àñ\p/P×5µuá~ž4¶[ª£!»]áF¦®$‡"• E ¯gJz”ê¶ÆË {û¨ó€–ƒ«¯G¡U‘¬/J½¶D´!j´]2 U4:ŸUa '` ÿ0¾m@Q0/ ¹æI=ð ` XðZÙù<ð, ú VºwLs3pg€\Q¥VÿQeûmp—¹]ßuL±|T¨ðiû9Éôª9¡·.ë*•j¼”¹øº6<ñ¼ ›uѦN¢[¶7EÙ;št1¥ÿ°Rª£,°¹Eñ­/°˜AÌ1C°¿„ÇNqºERf+Fç œU> |ÀÀÿÆLÍBbêQ²‚J®k$&.Ù¨î·êZ¦EÚ¨ìJÂ=a¼$p %ƒ[J¢;QÁJ¢ÇºI0 $]¾QÃÆÐÿ0*·µ¾áI>¼E~ÊÀAŒ¿ñAºI|'sºáÄ9hˆlÉ o¼]çg'¥&kóª‘ÇÀëœgÜ g¦zk¼È{¦Ê»ÿ·‘Ùší™ ¸­ÙJ:´‹ëxüËÖ+QuÑPOT#wÑKÐ5ÜÆÐ‚Ü%°¿ð(ã%€¦E[Ä8º=Áj/@@laô9š|WUÁ¹7Ù`dR¼×X¦|+¥LBº z·eÙ Û©”éφJzvk¼û*Ë€ ©Ç+½Kr™Ã*¢KJ°C»Pbõ¦ÃÌÐÄ1ÿP‚\ôÐÇÏ\á—;R"% ë\0x9Ìa¤ã[ä(ƒ%»Y‰Î›”7‰É%ÕÉL!˜LFöª)Ų?K¡ñ·¬¼·ŒÀ{¯¿KÕ'¬¦²©ÐÕ¤x|ÿ¬º°‰;\;Ÿôð û8Ò´´Ò-PÒù¹šËQž,m+8í8Fñ¡;Å´›5Ýj®Ð×ôF?ëGoUQw‰2»^6™ƒÚ?†ÇÉIçÉóL²¥œ9c²ЦWz«Œ¤œ=в,©¯ ¯i µUÑÏÌÑÀ¡ÃWÄ͵±ê‹ÀQFy­¤ë"õ\$°qPIÅ:}Ø…mɦ[ØÏ%O)ÊFóoT FÔ!Þi!P‚µf˜Ã²fÚ˜:Ðz¦J™†Ê†ZÐll®)›Õ·”kC½Ð…KÇZK`UE8·êvÿ´]öà+È+ÑÌ-И+%¾ôQTâÔ|ÜÜ™ÜC@®x<0ÎÆt]‘Ó‘UìÀ•̈]ÓôöÓYÕt-nÊßmx‘ga^Šqf¨9[¦ÎéÊðêžóú¶¢ýÏS¯ÐÉÆ—©ÚÌ*½l5$JK`j]˜nŠÛ½ÛM¹ÍüÍl¾>raÜ©‹<œÀÜùP\D¾’ÍFwÎPÜ‘öaO\RÖ]RœL?‰ÅhðÎk³þûaúöfKÑÉWÌfjÉô+˜SΩ˜AäMÝ{û»ï­·vñ˜øMQÇO.½]N^àN àÀÖUA—;ÿE±Qw-RUò­h޲ÕÁ}Õ×ÎÁÍu}çU¬çÕÀ(ÓçZtuRl×…èÈòØeöļ ’#9iÂÌtbÃr¶ãÍ– š–MÍ–¬\–íM·ÊÏD¾¼ÏëžU¢Þ…¶'¬÷°8À[‹ƒet‘íÑ$Ý€ìÌ‚lQP»ä8ve°ÏuæFë¿DoÔ‘Ó|EÅ$ÎÀ@\ROŒç)Þ™FƒÀ´fÒUKw3ò…ÝìAÍÅv¾„nè=ño|4FÕóÛ•tE Õs{¯íÔq›·±<ÚíMä‘Ù¼úªî‰ÅÕÃÃQWd¶¸JÄ«Q¯êª^ýNõÿ möpÿåI]U‚ë Ü‘xÁDÍG¡]Öµ~]ò§»âDíVö×¥ow/ìvNíõ“»ŸCm¯ñpvíŸÌè`´¶þƒk*Š"ïúÏUäZîtóÏt»˜l\Õ‹ ôÄÑÙÎËäÈ’KbmƒÈ‘nG ô8÷[°Íù^#¸Ö”Ëdë<ܯðb¯f‰%Ìá £ÚçxŽçxØoÿÖÄ…7ØÐÄyÎkvòõÃÕ}—&•»âùè6sÅUÔÑÊ, ÐêZ·zû»’ÿ¨áOÕÊëž·Üéí™ÂYµP™¬6è`§/jì§_€å nÖ• È¡!D2`x€ÿáß? G<È`ÄÈBŠ.P ²Ðƒ ëÈØ±ã¿/þ989åJ 1 <f1I’âŽ(ÿe¤i@ç?¡%J)OŠHë]èÊ(ÑO‹~„úo„%±•ŒÊrý7¶lØ·¸’hkôë¿y·æ•`TÂî­…%¦þý+Å‚ÿ |DžbŠþb¸÷ïÈB'ћ꤀=£mjhAyœ~ÀðˆI#'Jü÷bE®‚l4ÐÊèí;}¾¨yòdË— ƒÐ¤ù"cÒŸ8mjŒ=µ£œ±Výg5©È›7 µ¾ÐvªãÅ}JqÂÂÿ e§~5KÑl{µf!¸uÿB~ÚõK/À¤L²Ä c"ÅŽ¸‡Á#xp*Çþ‰¬2ÌŒ* ÍœXȳÚ0FzB˜§¥ƒ2€¨¥Pr@.ò‰  8à¸3Š£…b¨G”€ Ⓠ2i)Š8≻‘žм«D¢0œ¾Ónªô("¯<í„2.£Ö#ð¯³ÎâË-î[hžàúÊ®þø 3ÌÄþA0±ÅÛ±A"‹s®2t"À4Xˆž>hÁ „þ! †J0ɵ‰Œûç…‚˜M¡ì†à¡#à|I£ŽV2J¡ž– ©(«Ëq¨‘–ÏJª¦*T’ªã®¨ÿ«<¯×¦žª*Ö8‡ý¯½û¼:?4ëºë–7û#ö¯É+l2É £HžïqŒÏÇ4ÊÍò) €( XˆÃ©B°çQsÉ“hR‹vã!Mÿ“J’Ç“&sITn«iHéŒ$©Ÿ˜£ÕJ¬¤ü®V¨&ØXm¶c·¦B+µ…b´cJ˜–NÄTl0ב¿ý+›Šb!{Ú § x¶'y0-5ÇŠ´Þ…dã!^~üÇO}®Õáh餕†ø$š¢3ŠÉ0aå8»hYâ01¯J‹;î´þŨQðûÿ£Èå–­],ÁÈôŒÂÿ{Ts\s*€CÎ01Z:íŸ&|É]IÿÉ€$,§¡ƒm‹n%Ÿ¨^‰àªU’¸&G–K³Ó»ØšZRØ85f›U.;Âe¼ Ä[B ùðÁ€ù0ýJÐ(Âä)ð0k­§žÁ}ÿÊè©Düó\rµ§ÈyáƒÉš™òÕRúE|ÂÀ• ô5 ªn*¬7ÚOJ ×m#SùtÂä“(a'X×ÉŽ‘B…#P …mTy`­¢D…-d£ÀÅ?ê6 ÈKÛ{JèAáædt"L¶$ê©lz Š ˆF€Hˆ@Šû¹÷zp3#ZD*ÿG´Ì"É€P†„LIÅÈ—è(’5.ÒOkÏáÂP5”ÛidaJ[í"h;Ý• &á™]yŽ"0æ(äh-^cŒ‚·Ë-Äy#3Ùœ¦2ÃjáÉAj¡zø—üÃã[¹ÈEÌ| “+ZûŽ$ ÔëERÝ \±¢ äë%XŽKZB?¬9ÄDN’–’¥Ñª7T+`ÆX^ÆjWTà_Ƹ¶î”ds¡H„¯x 0á A7ŠöÁoxVdöõ€E.¤› gâ@ý#æ š>$ 9ÔïRú£—:(:w•r~ ©ÜÌB¹Ôœ²&žª-—V’PQ§lù‹ÇC»ó¤ç;¬êÎ¥̈ՊIoìÈræ6¬#8“Q ¹^ÉŽ·¿æ‘XŒ‘LC¼%£`9`é€2„¡H$}ˆM&{Ä N4Lù#ì`<˜_?§B²Š¼„)›ô˨ns°3"$µZÇÊ&mÉ9Q’¨”š¢Kƒ*'&²;@@!ù ÿ,éÿÿ H° Áƒ*\˜Ñ?‡"âG± ˆðm „Ï ­"àÂ%쟅‘Bð ëø¯•@CþM˜á„ ŒJÌcdoÞ?òXü›÷ažQFó Z‘ !}@tC‡1%T Zõƒ¡,Dpù <ûpÖ«–bĸá¢GŒðÀo`ß}ÿ2L¸°áÈ/äWß ½ùéû7Y?DK7D`*öF«'qá ‰Oˆ…Žc)Ä Ag BµÇè߉Y0Bz5ĪìJ:¡‚¾·2½‚núT…¹­Ò‚4¤z Úä&¨¥° ä uñòÿƒÜ7žÀÀŠÓ«_Ͼ½ÀÉ}E0Ð 8ò¿ÆWÜX¡ìîŒ"Dª‰A¥õO@T @Ù&nH Ô?òµÓU\…ˆY|ÕQXýÃR²>øÜ`ˆÔµrZg}ô!jýWÝ?q©…ãs-€Y^ôô—`î%©ä’êõ5Ù ¬0ÂD‘å3™˜ý'Q++D÷OX”µÂX˜éó¢SWM@Q¶àn>e8†HíöTZYõÚ„;1ÃP!\eHE÷aK§áóÃGŸ©†Ô¡õ¡Z7‚ôhøFþÿ#Ÿ^S¾:Þ"ìg™UÐŒ>ôÔV©å[RF•áPCá=ÿá<Ì”„ä šL˜Ö¶Dv‚8Ëe0G€ q@ ß=¶u=”Å8RKdšÒç6CȸÆ(:²(³¸('7áŸ.0„V„‘EÁ©@­Ê˜ò,ðjl ¦B2¨AX©qŽÄ4¦“.‘‡ÈjeÉ‚¢óD–D‡, €ƒÜk± †È ¶\vÂa‡=Hç¸H (J™mìÁ!Dšh7»ÙJliÿ)®Ò]?øÇY²X› ,í ÔãÐêâ:¼‡/Y³Z©„IQÄÀªÄ¬ e˜ ‘pPc_B^wl$„”ü1,_ Q!rkÁS'Þ‚dA.‰2iU?lç˲¡M²àfV9´v Љ.šÀp$$ áMe%fh%À¤ñjÑZEÇzÜ Ä˜X#HÙ&ÓÁ‡9dx[ÀñL3–.YÀ4§ ©@(p·n}2/ð–m„r„ÇQ² ñôÞ÷xˆ8ñÈŸXV†eœcÆ¡§X\܉Áþä6à:ÙNƒ"CFlåD»&?Ý•´÷¢%iʃ×g«ø(Zà,\EãüÑ´N&·d5«AÈcþΙgY\Ý&W嚦búAJr ²|à±ÇL—¡IZÏeˆ¤vS¬âhÝt±‰[œ; —›Û(……l¶•O äëiÄGZ–Z}«íª"¼–Š Ñ,«ñ"x‘5Ë@ð¶Îò@”é[ã¼ucqÝ "ÀtW\¡%cúGI‘‡ ?z ÿ(ÝrÓ¼e¹G¾,ÅŽ}\wÒ8tªó’YœÊ²%> ÝØYÑŸßn6ßxî„Xj¦ µD&žŽbd¥@Ú…d¸h­< gžÇµXSàì´L0¤~¡`_z'‚¬vÌa*ËwWÒ!wF ÉV Í$+YrZd ïÜ2iîBz±ârðVò3‹'† ½í=™“½:!Ñ P9 +þ`¸øóÇÅA-uh›¶¥Ñ \‡*­m¦×°ÌjVó3¹’ëw>”ëýœt)IMrÄð=fg|WwCöH ²Ö5ÊŸºuS³øq-¬`¡u£ŒóÆ1ÿØÍN|Cl×ÅG$m¿üÉäF™‚å’N_yÌÙ&Â58°ßÁT°2 òŸáQÂg­X€™7ƒhú…“%¸’áë*¢J`©'qf[N6}’w cw§¢1wÓ[Øíéf7&²ÉZðqkdªŠ7¨€Í÷wîjhCkÅ ïO·ßCÿ‡Cÿá~˜à=«Fú“X$®L¡„šÿñrŸ1ü?›&£˜b(à O5nY RÌ›^½lB~Ê{³®õ²hE7[29ÉUfûl ¥“)ÓÐ?èa"œtl£ø¹‹ð”˜¼ei‘ c@½ØÙQ ££x2ÿ}|¤NÁGó%¦ççxÇ¥Pâ@»þÇHðAõýp']+øñ$`&Š .ù@,!p-/!ÉIÐ2ô€3>ñ×2'‹ôÝ‚€˜2<õMÎrÙ"-7óöÀM<"Úñ}P/âU:?òD“aŒ’ KjîB5¤†@ ÂoèÇF‚ñ[1f{„ ß1èòzųEÌñ† J”`g-¹Qr|.r=‰¦bA X×cCYÑå.Q.wB,ó"—}™B:3QÄò>—’zaWežtvA¡b@WvtçaùP*ˆVë·ƒˆAL³ÿ£¶Æ›‘B0uò6€9¦7lVá1q"r"!'°.×U9‹$2’]ܵH hYÚIⓆ*·cGñ10X.K,Na:ŸÆ÷˜H2q³' ™^Y˜2åOBšb›ç•g7UDÙO¨xŒ42¿Wqþ)-?=Ï’-ûù:’H Ö×DÏÆ91G³TQ¤(yy+ñ/·E*‡Ø@ÙéžR˜e£ÀTˆ… ŽI·`äI^¶kf aA ˆŠ>T Squ†*‹‡•X‰C‰hwö=E´=„“Ÿ?KS’-‰Æ «y=)Ó2ùYXîvò>HFÌUŒ—â¡bä}ÈPnn#®%Ÿr5¤˜§’¢ž+¨òÿày 4ã…ù‹X;eÿ£Qjž1&~”)bñ3ëH•%;QšÙVš×ƒ]؆=„Sq5ä©ù-Âl—äN :IMš Ñ2-CGÑ7yYæ#K¡µQnñƒÿñ.aTÅ? aKvùi_ÒA’FÇoª“§Ò ´@ÚØ5¤"¨çQ‹AŠYžå™Vgåz9) l†H#ÂH3‹æT9(“4óŠCùIg•C†””bªF*O¹]'«Ú"W¡r ˆ†%–!Œà›Ái"}ò«Ä‰T×qO±WÇÚiÀ° Ë0Ev1ˆÀª–§”¡¢X£„:®×ZLñ`°v; ¤¨Û¨$Êd+ÿu³%®ãšVK÷KqWæjf麎é”I -3“C»´ š|…#OY(Yüª]3I²X¯3F¥ß2Yô´&Ò•N¹E“9b'éó!ri10b„içFo›nù]3“áÜø§ ”²+š*.j¨»*e“³ýÂ~Èä5ˆ{;‘ ´B@’ȱz2)S¥©2Ž%¥*&«« Ð²ŸO*è5ôT!“õjW«EeŠ(;*/˜11y‚#ÔvɱÀ€ »y6%ª§†š[Q„*Vßé)†¸’ñà’‚³ÓÛØi$áY`A‰Ë¸ãÿ*JPfkF&˜aCIQØõ8V»´‘h±Êl³Šm-6¥Ý³ª¶9†ÚU¯ßÒàâ,8¸Å'!X¼-)*72©ˆ»éC,pÑ›ïCÁÜ.Þ ϰ ¤÷ºÔ@ZãÁvœ·uˆd£†Š€j¢Ý+bSȶbV@‹ÿȽa:a0ì½Þ¾Ëk0ˆ0Wtµ(4,<1ÄMÌ´ÝCªÔ{H½'¦’ÅïT¦¬]§°KJ|Z¸¤“e2j2;A⢸ñ”RÑ!`–f:Aƒi¶ÄdÛ±î0x ÈvüK# ˜|ê/Ô:ù`: !6àÈáÌÂý’H}ÉŠŒØày²çñ³™Ì%`“”W”“]-ƪArîÔl2uIx&‹Y8é2+ªÝIÝÐiÅ]Lš"³1°€ÔåMp"R¡?i<uX<`Ñ.|ˆ ü ©%tÕ<Îk~ |LÂw¼­Ïª¼¨ÿ¢·Eú`ÞÜ`½ÅáœÎìÇ[`Vbƒ¦“ÈÅ`ú²ŸWaé9¹XQšê ³lx31ʢʥòJNHܹ™ë ÷àÊ¡*ºÑ·ù©j-'´,!ðd!¦ø…ö` üM;QÁM¦sÔ±7/ÌÌû 1GÇÑ\Ó™WÙ»o[s`Ò9¶Å[$ü¼áȽ•·f) _£ã1ÿ¾ ¸pqÝÕy¬¢H—¾UÂ%˜AÂÒú:ȧ%jó½³~žF58Ë[á©`³ö<Ó–¡¿g𠧤[«äÄÏ .вLµ¥»¿Þ.n²&Ê(çþ->Á|\âßÂ'=Ñ•®É2œ>â6_œ¶±-Øå6|;1½ ô|i`áé-šØ:ë/9M—GˆmÈÆ4ÎCÍ~8ëž[žƒ ˜Ÿ>1¦:NµNĨ;¯A„HüÏûKµsBá çq~ìr€ö`ÏnÎ|=á,€3!Ñþ7&.ÛR»+'¶V1ï³Æðã4bÔ‡‰ÿ^näѲ¬Ýy\½s„*‰e7“1Ùþr™^CAúêZÉãlA‘¸º…Øq`–Ç1e9 žLòc™¤ ß{V‹Ðû,ËiÞ{y&ñÐr•šÚôo%ú÷‘ìÊnkâì¾mA!Þr!¥(CAYgÜ!õâD2§Ïãx‰6~Ç‘®¼7?Q¶%£åaùY#£šoL2jç}|~¢Îy¶Rë×Þ.yÈï^ôçaä(¡™! HÁÐ…•aJ32eCŒ£àñ¬8¥´}ëVÌ,mìqÿ[½£ñuï•¶!N ëÛù!žŠBÏBløqÿúÆßxaó ‚ó"ü@Ø8³éŽ‹Í@åÁ—£õ GðL‹ +C͉¼­ùî1„ ùþ ÌÇïŸÁÿæ« ïŸ>Dˆ(è 1¡¢„%Z°˜ÇBÞÇ#ÿÝ;rï{($pdå¿•( Ìœ óåHy÷Fê¼'R§¼@çý£7^ˆ‚ú Šˆ¨4߇!Zœ0:o^‹«CKü;Á¢ÅG° å)ü'ϪUFŒ>|H›vÂ$¢pã>dÈ€íöïÙµÁ_¼Ãd/VȯÀaÈŠ "V\ð_¼|”N†œ±>~ ÉVxøÐ`c’ó¨pZácÖ³>íº6ÿAÙ¨I7D´ ¢!ŒK°(qõEΰeIžÔ‰ÁäK”0¥£49Òúϲ`µý‡µEÑ!ì}ȗ⊈D8ý`/DÖA©rzbcØ,Ä–G•QµÈšFæaä-ºZ¹ ˜e–að¯Áç† ƒ ±xÃðB1C}(ÃÌ.;H¡ÉŠÇ! msíD BäÄÅXä§ ÔBèà (6ÒNKÇøçˆ–L¯©§B(Ê>>§º*> äñвÓo¬³ ´ÿêŸâæi‚ ¡ë‡F¹æš—ùÇÁ +Œ² {q1Î04a³Ë\@1C‡XT³ÃÊ1…ÍÖ$i•¬y-’´"{=(5ag3È1aoä§Ò–\ ‚Z‰HŒ ÐQ3µËR§0¹Üi,Zúh‰øâk³Ü©üŠv"/ÑkrF<ߣ+û²:·…€RSMCÿñ謮N¸«D!€ "À‹ÁežipÓQ(0„0Ã"KŒÖW_ÌÇ…x@þp …D&yä ;Ã,ØB#K´Æv%+ÇÅûñGwOdM±#ÿ±çÆ <³ŒH ‚Vž®Ú)=a8íJb®¥1ÿÁÿ§3Å]s‰tóUŒž†2Š(vŠŠ<%åýg…þaJ¨ŠÂꪰϺJ#<ò(?A Ö»«3Ç"nÀ &`XÁQ€¹†Ág$¾f”n(lg=V×Y_ùŸS9/±D‘ENÕ =£‘±9¶Ô˜ƒå‘,›s;H6d[HY†Ì‹hhWlD¨…KѳöɤåN óÛ3j“Mƒ¹ [@¢Èn7*ìã$¯Vj²Éµ›Ò“]£ŠûÞîúË{£½½ê—À\!ƒçA0A‡õ‚¸q0DòO¥hCäP®2£ª’-FU³b•†fF"ŽEðe‹ÉQŽv,ØüèX>:QÐÿ,Çmh@;ÏÑ’&˜à`¤"*P¿Ì$µå äj=ÉTºc.°U/‡ìҼ•9=¥„÷ 0‚@ ŠÞÀB2­„†`‰žŸÈ¶ñU/*'Ó‡@ZUD#*„I¯X-•Ø$ôØ *8JùÚE” °kJXq_Á5¨²è‡+úÀÂ$¢ <,SÀøË„*D˜xÿˆ —yc'¸½FU®Ê‡ 0c"_deIÝyº…œ® žqL²¤PiÒÞ[,ˆðˆPÚaAòœ#Ne>ÑSˆ=Žb9¹g•ÛSˆ˜ËÔR!¯@ÏÚj¹PÂk[A+£R6=ÍCOPÓ{šö´§JoúQ¦B )IBAwIÄö²ŒQ"à‡ à uvHª$ê#éh"9Îj,²àÝÉ1W¹†h§ °RÈØ äF¬ÙÌZËš ÝHw °€*­!¬“{Å$#:IÀ!O&bùH|¬r>jÔãˆQÔѰ”ÿ,>x…BVzRZf6¥”é ÖCSì­)y:è{¬Øc L?aÔ 5I5 ³ÕË20e[\,€ó€a6ôÕÒ„ó24ËQS¤"‡ ðC%®dT÷"Ǡʃ1óѲv–ÂU»›é„`×Tr±ˆ*€ˆœv(~ J—¶T&¡œ,îib䎒eF‘µlHÿQYYþC³ôÁ(a`Î=ž%"D”"<(MãWGò&(Ö¯n‘BDP4ÛQÔÖ¶šBã`buÇÈxˆ1+™ ’¹`SLHRªä£>ÛòxHV0×J–‘åïHý«DïeÁ”`3gû+/ôˆ =JJéA¼ø,~ÊÜ ¡ U¹H`c¥DÜ Ç-cºŒoIõF†h9çˆR3éW¥†eú•™óhbÕæ­ÓëÎä”U÷G¤áà¯|T†¬`v’¼Š¨…“„2Ø–N".¶éÎôX,R²½Íäq)Ý[p™½'`ÿ>[µ,ð?(±kg[¥GÄåœé¬=¨Ø­ÜkOð‚èˆZK£” } þ]#·’CLˆ\C™æÂ˜,ª ó2EÖ8$òÿ±,H²µ¾èH-[M©=¸›ò8ëNX´$5Ž|2'ÏQžBJ²L¢ˆgNð3Aœ+ff¯Må+0Ür5«´ÍÑf³µ ç·AX¯š$عu*0~ég+Ì„í¤(%͈!uJU±£ãØ¡å¸ÅÜÔ\iFõÒÌtgŒet4´Ù¹ !Á¢ÑfB›´ ÕrZ ˜%°;D´‚I¾™Hµ<"5","‘)FÛ#'Ÿ-Ä<æóŒÚ˜ HÛ½ªk Ë}3‘cá[1«Ò¤“ ${:’Õp«Çø™Ct¸µƒÀ¨ˆÄ~*’êú'D`  „ô¸> xøY”ðŒÚ²0ˆ! DÅð¨&Z0•[?%ü¯Êc¼¸¬Wp¼’¹”:©³:˻鰉­èŠÁ ýˆ º¸¡Â‡Z`œ¿À…  Ð•Þ:ˆÞê¦7¼À~ˆI»#‡5|k´˜‘ŒOk cDܹ Bèò‘„xµ9é§HÄ‘!êh™ˆ è—#‰†ú8Ã:,F À À<"RE²0”+)2S%ZÂÿŸÅÊ¢,jÓD(|¿”Z©iË%"‚ŠÿÆþ ú7¯HÉ­ˆ”`F‡‘¦ÆI4jD §Ú&¨#óŸ´@‡ ™Ä8.tŠ }h xJÊʘ™Ä ÜVû‡· šäû²`±Š.„c§80D˜ypŽ+1‰¾9¬£X‹ñ(E¬$?q•î1?ôsÅŠ¤U 5«,”B7K°¾ÜE$"IѪ ”,®à3¼”Þø°€Q(ªÆù‹¤jÃjÜÆªC§2™rº*Ë¡ |ë•Óø­‡ˆ‘†pD¾zRØ 2©\¾´kŸÁ¨ 95WÓ{5I|>ØÊƒ˜>›8ÿ+±’HÈ´ü½ "2¹{¬Žr›óó,2«È‹¤•WP…E’¢¬€¢¥\TŒ•(+l©|ˆ“`Ú¼³˜GѲº@„£ £ÄA†ˆ‰ÌN!Œm4Œœä•NÃÌqŠ'pÒ#ØY#ê´¬ºÍ¸ªp•M$¯ë4 õ•Ý€ù9VHä‘ĵVÊÒP­ŒÙ™Q;ߤ„º²ah†f†Ê­Ü½°Ím¦ò86!BÔ¥•¥%ÝÃÃÂVz ÷8 ³‰Š"Sw6Zj³šS l# ô ]Ñ2ɪॷ  ˜9Ïrø…K€†kh5T4ŒyC9Ô[Ø`™•Ùºå:'Yá§yÛ·e®×h»ž™§ä³ç‹ÍŠºÇ_!ßô%¾|€VňÍsV&NßIä i{”Ö†¸÷mÌø•ßZ°ÜZpRüÍj1¹ðß!'ö ò}ô¥gß›‘eY.’g ò€Ïnµù†Êíbúµ€ñÒCØ_!"2]”ƒ#b¨°­%D‰ãåô!W‰¬W€`ÆðK•²M΄ ØÑŒ€Kø.6{p\p‚\èa€7Õ3^ ÑCàª'Þ´Qvá·U‘Wiáöçx`ÓgbzåRœÖô­Ó[fè„0èóÅåÿšqbŸ¹G(à˜…~™Y’ŸEØfð…ZøaðúM… %‡`;y¥2fŒ5ÎvQ°hyh6 dí(ÄS¹öK…¸„°€K „CV)ÏÒ¹>~ A(ïÊÄW¸©îp'a~! qaÇxa޶áOÎŒHÔÒÒ9k—­wºå[žh¶vå‰âÀ36uë¸Nbg…ÏŒž/(°‡¿ìì!äŸÕÙf€†‘6i_†V°$ý%ˆ§€ðصÈ9Óµ ‚]º¢ÁK ©ˆê©v6p^¸xƒ†h Âõ籋Y&nÅ0n'‹ã®SŠV…pñ€q˜qZqqg Œ²ññ÷™ÀƨŒ^¬ŒVêV{0òéþq"_r '‹hfù æZo¥ïý¥rE\Ë6cÍžìq/+\XÝ>¼ÿ:–€j³C–j¢êC–¿×9óš øü®ïj"UP"¸„^ j'Øpx» (8ظǴþ£¾6nñft(xôÁvtñV(Ðñ·ôKÏtM?òÀ3r#W Oßq O·‡6 6'õÅjŸ!uŸiƒ#gS#gu\¦õK'‹6u.Óf÷–߯ހí0+9dïr¤}ÎÕÂ’ó2ˆ‚|v0Ó‡2Â_°“ëæÍbó7GpÚ>0,| j±ÙB®«Ú®pU°p?oƒ«á¿°DšH„ÙÅ0ò!ÿë‡ôF§tJwñß²P¿ôJ/øê±tJxRtq õT—q¢¸ñÿ[w“×€§‹gxP§u7iƒ†ÿ‡Sgõ§‹ç2 àø•ßɭܤ¹$:ÉòXæ’ëò¸, ß+2‚Ï-ìQˆì)2$Üvd³6Gp…ÐcÌkð¸;÷ wκÎè…¨÷ó_hƒ_ÐíjB/­¬wäl¯øqN¿tY¯qŽ©ôGû¯éÁ’/yK'õ†Ïx €{Œ÷) ˆàR¹{ŘûSŠñŒÿ*b{ÏÆŒÜÆiìWhyÕ+!j0‹ùÉV [ñ(Éçž,üï¡Q E¢\ðù2XÖM"–êtê/êÙÅK²µ÷ÍĦ¬>ßð’q÷^Øm!X–­ûÿºVFñO—qãÖñ‡V‡ñ\× €‹_þæqˆñxþ¶Ÿ~ëñºo~å¿q·Ÿ†¯þ¾'‹‘—{Àßqò— ’û%Qo¦ÜZPüÍ3Ö(ð›ù9V·1¼õðÅ/zôþµ"D¾|úŠh¨ïÃÁ\ô!j¸âÕ ”(]²ÀÑBÇK7®X±Ð¾!ÿ"àba¥F—föºôæ¿_¹þA»vm¢ öìA)åŸQT0mªâŸŠ£PŸþ«JÊÕTh°ZµÖR½víªUCY¨f·Vm˵-ܪfµÆû¯nܼz÷òí»5?D­,4+,ÌB«!!JÿÈ;qB^‹yŽçÍ(ðƒ½|4+Ô×Ð"܈æ ñOà¼Èôæ… wÐõæ|õ…ø q¡¾’%_œ òeÇ DTÔGḅQ.#øX°B•ª½Tõ’y©×?mzAƒÖ Ú ÌC¡=jj[°ÿÔ«— …mÙ÷ZŽõÊõmUcnÍ2e[5UØÕ[i•õ”xýÖ?'ôõ „Ò£Ðx×L-­èÁ<òÜó< †øÏ'¨&=µ•–E"¬àâs a’> A$Pd‘ý3ˆ-@¶c¬!¤Ù?¹èS•E%ýÛG3utÓ”øð""U †.XÀÜ‹ú¸ÀË/¿ô2ÿæu½„É“OÀÜ ”=Nå¥ÞZVµñVViðžTkQåž1GCÕV[ ¨Â hÁ5\V¥h[ Ú•—‚JÚ—~ÿd†ˆÀ4#Ì+­ðàã=¡Šª<¥6XYe!d–Pg/–´À”%-tPk-äÈcU¥bP*A¢úÏAáWt7ÝRH 9W%+PÐ >Âà£es"D… .üà ™cšÉ“wÐlÀfSè™k—øUõÞž÷=E_\xj¥ÂŸh!Ê ¢„ΫV[ FV]ŽÞ5©WC¨=)êc᦯ðÁ ÷` j©÷”꣉-hUYŠQlæŒ>¨«¬šµFO ·Ð+=/´ÿ*‘™Fk¸1$Â?1Jù‘oOF«³+´Â’0BT%².8±t¶Òy{¦w׳ÁB©@SqŹðqE½GÊV×]ó‡ÞST¥ý(ƒâ5×½ËÍÂö,,ÌažvHª<,Øš2àŽ9vb…샩â­(›(ä‘-¸üd½R„dÎm­ðO±µÅóçÿPR"BG`>£¼´A‹gûz¿8]&¸Í\ƒ"C1…ÕÚºç^ yí~.¼p±k(ÚópE‚Ìk0оF(p¿qÏ}=\®éC‰K­Hä,¾cU¸šø£‰'À¦P’¯ˆ,rI"ÔØZj¶+ÁCàë_ÿ³;A^ Ã9ÄmäXÇòÍH¦TºœN£ÀGU(¡Š!L¯s‚ ¼e¦KôÄv£X“îÚ”µCíG-_ÛÊžòt”´i  Á{ Øò³'ßê>Úô —=,ÖÞ¤ø³~œnßkA PeTÙªT#Qƒ\â†@qy΋\ (ÔJG"°Lóf½ê"º‰Ž*':JÄ%$!‰sJ2´iµÄh?S·\ð‹Ø9A:eâ`aš‹X)"Ì žÎƯ¯™«?ëº ç´.;=¥RÉšòô¼"h‘±ÜøóC úeO™"°‚ qh5«Ù‘dVcª%8±ÿ Q=RúàhLÚüP&1þC3ÃJ’n’iƘŒÄ€61V3u³-9°%kT…˜Ìô äb'½xŘze\ƒ!tÓ¡ÊÉÞg^l©Ô½àiÃv¶…iÙ'ÅCf.„J[]ôEʹu²*±Ç €ˆ´R2 e%"Éc˜^rQ¨¹É/Nx ­Š‰›Òý£"TÂŒª86Fð€ldã3WUžu4ÚFD¦MíäBvÞ$4ž15C|àjå"!ºè©Ïèë•ÒSúô'ý”e+ÐSÛžÚDI½¨+‡rA‹Û¡vqõAêÂOÂV@‰…i5ÿkÐ?ü6"}ˆU±˜ú ·ËÄ5:uA>¸H³0ÚL~GúÌ?,fË&6a)%<â‘%%€§C&:Ž)LK“Î+~ÁAhCjøÏPt‡N«`ENÆKTXÛ°E…lT[ÛÎsžzZª·–b^×øeP²ü=hÑ×(µ¦IjRN<œTÂDàD@„2)kŒ©@tÀ¬*øÇ=šÐ„€ì9‰KcUðŠ,®! ,|Û² Iž9£E§—f²TtX€ezÙ–@#R¢Ž™”¦1ݤ;B0>ȦԒÇR+¼ðnßÅZ¨`E*Öðè°˜g·SÑ­ÿo]‹°û8aZÛ¡&ÅòÍÓjgðºBPb œvá⡉m—FQ^o–UHiI9ó«CXUš(”&Ù‰|‘£çðÆs9àd)¥l@siÅ?´„:kF&½Ð£Ûò ni¸Å* ž؃Ï&Jy2ìg±ºµhsK‡Y[ôð..ZMØ«bõ̳Årq :¯çB¨=o"X èÁÄåúâ£kc(##³ÚÈ¡’^3ê>÷59:% «¨œ¸¸À°8{ŽJõ[Ç{#ío)0MÔY@³"‚·é­œSƒÅƒò~ )(.€¤Áÿ >{Ü}¶¸ÇBžu:+ï2ê£Éš°åžf=z銧årã}%7.ù†Ë¿'¥>7GôœvÅÖtÈC«d¤2%ޝD9 LÒØ,;GÒbbmEˆä€myÉû»Ò-@ÍÌÆ)´«3íoþâB‚³~:|D€z®·¹] Ï⮊¹ °ëp›8FG±¤‘â–£C¥MV·Ôs/ {0oN[ñú}ÀÎ5~ üÞÒ ¾Ã‚vá%Œ>ÐeTíðÊìȉvŸ(=bs_óRbÖrÞÜ9/Í—¾òÜÈiÍRÇ¢ü+sµñ¬»Dt/*BTá¤ÿo~“'Bø…!®=Š¥ùz1‰~n~|€è»Þ¶XŸ~“DÊLf”n§Ç…Üq1ê^ i)°à‡=l3»å–öåÛ›ùy =¤ËÖ^EŒr‘‰;dä‘‚¤ZE7™ûxy´)ýcJ‚—Ÿ ¡EÜhÑEœ3¯ ìLa§¼€#yª$Ófc6J" u8 hÙ4PÂèÜÝ@éí ÐíÕží™^VÅé%ÄÀfØÃÄŶE>˜˜ÕŸ¤=ÅnyÕzŒ_Ê<ŘÜ\_Ÿ&!ÌŽù@x„#Ô,qHeDÆ ”€Æ˜È ‰^ío¼e•_ùõÿRàiûy }ÉNUT‘ç´”±¤ÙÅ…GlÄÉiÉ(àè$D‡“ØÄœAƒ0ˆ@HÀ³Ø>´T@éùÜV…ÏÕ\ðÑø!êýCÓ b âéIR|`:ðµ ôLnÁؽqšXýÞ×AØÝ×…'vâ¥éÓóðƒs|@"¬H­Äà@†ß¬ÏaaÔsHIüµÅÈa\$VC$á…ÜûQV/è<Ó3ÁÅFüFš Ð?8i­üÝÄ%ØÜ%4Á†\@>ÐÜ€!TI8¦bU¤bêa9¦ã? "F9b}ñ!}Uê¼ÁÿÛï­ØÕ´VU½ÑÛ$–¿u¥õ›òQ…@äCs°¢ ™DuM€9ˆ‰4ˆÆH\y=Gö1a/ÅJÎûe‡¶ä ài$ Û3½T^hÉ3ªYdQÂéh!ÞHÍÍåT/QcUCwPÂ÷L€!è2àÂiå_þ­c•ÜÀ?Œ@I5¥Á¤b*R„>" úáïÇÕ´…V–àðu%ðAO¿å‹U±ÐŠ $ZzÍi<ó&‘¢  ÆrHÀÐ]ú¤Ìöy_FV‘û8™ÊÁŠ_i\/ÂÅ/”ÄÍZ“£1ÂEHüÞ¡K¸œf ƒO<ãHhžÎÄ+4´ÂLÿÀ ´@>üÀq‡äI^UP¥²‘l*m¶f^#9:¥SÚ!ÔõE?îÐ%ašŒAŸ]0Ï%Ý‹ a¢ºPR(jEZm5Õ–PC¹’àLe‹Têt›FcU(!bjœ^PPwj„âÛJÂ…2V›w@0M³à¦d£±¥‘“pƒåŸ!H@èÂPž&Ç äß2 þƒR–”k²fnŽkÎ 9®‰ùã#N¢Wþ^)­eÛÐÉqÞX º“ y¨U™|XÊ à 2àM(Æ ÆÁY„ÀŒŽü(“%ÎÑ43!Ž_ÍHaÆæqYø-æKÍ„~•ÿܱT›¦Ã?@X𹄴àÍw`f~ÎoŒÖ 8’&> C-àC*üÀÐa‚2è)åjªflJ¨j¶¦ä)èj¾¦š*›R6¨o2×] ôðéŸòqŒq®XYZÚYriR‹¹%ÑCaC†À(¸’àe "à‚6¶bvdxFÐFÌZ2!\4ÄŒdÞUoÛM€'•H¸ç¦C”ÊgšE¦” Afj¦MàèÃH<‹™Ö2ˆ©™¦æVÅ‚Bkk¾f𲿛J«R>è³B+"èéXi¸–àV^R[ß'L¹®% >ŸÙÌUDŸ¤nŠ0´"°ÿ"×Y¾V=Xȧ¶Åñ¨ß…'&ÎÌâg̈_JÉ«.ic9&HÄ«¦äêaAKÓºDo¤ÑœA¦´‚å €@+ÔB-ƒ/ À@jºæš"(‚¶E›¶Åƒº¦QJ¨Ì›2èµÂÅ…WJZŸp© T­_0ÒÆ…=½ŠŠ.§ ]¦ÑžôÌÃô%,DéÔâJ‰Žß]Ä+¬×æO%¯«ì„‘œðÉÚc•œÊœ'×-„Ù0”F ÞVö®íëS©a ˆf=ÔÃÔrú6n*´¬!à,–4V"ÂJSSR@IˬQN1\´ixTÀÏ}@!^ÏóÅAÕ5C#ô =0BQ{áî@ÌC57õ^0õŸëĸ—tãç•í„ ^à¡T”–åÏ£EÐb}ÿ§¬:£èH–~y¾~˜s(?œþéûλ‚»B=¸¾JXy*ý-ûB-€Ü‚Ñ;½Óº ïû¡³}Óÿ># =Ô«}\l=—TgÇE~›ùþ'Sý™s;·7¢j‡Àžïûï“O\Ì}¢3zÜ÷EÀ/:]Ò늜¤9',Ön<Ȩz¬«:cÑeÎà ôÒ""VY±â•ªW”þQbH)BÈ -P²`!"Ä ªú·àã?DùH~øðo„ <\ÕûWæË þHUËWΜø@ ¹5(£ ÿJÜšwë_ÒH•.mº”ÓŒ¦6­ðë?CW•jjÈÿëV †$X½PáÂГM'EI5)\p›2š;Ï.#¼êâõ«ð<¥zKèyq…¾öì…°÷Þ?ÿ4$¥×âÞ½&÷þµ8Ñ‚^ˆ|úDè3­Ïj¿ªrýÏ£ÁK—åÉÚWü󱂒‡“RzõŠãð†…s\@iÁ«+Œ4ù( ,_¬7äßãmÞÄ©³W>ÞŠZ‚(Ñ%N”`?éüüõ‰Þ‚ßž¡²zŠ+¯’ªÀÀ ÊÒ ,´<‹À œj.¾æª‹Bª4¬Šª½þú0æ‘.¾ ‰ D>pÌ1{èQ!²¤4¸¬yš°Qž–hÿ²¢-—ÑHsa ƒ\[ÁµØþé¶L#)Šœ$·|øg¡…ŠK*ºç8Ú¨8Ž"ðáËÞ¦³»íVr¥¥î`/©ñ„ZÎË)•.påúbá¾Aï;´ÐA‰bÐÇÐÀ “Š +¨´Ò < ¨*P«­ è .Fòʯ¼øJê®O½k*ÁàÂëŸyHñŸZYAEÇèù•+›ñ³ÏšháÆ&Š¥ìŸ(~Ì'Óˆè $“’­ˆ¤BdJ}r1i´ÙV hÉWÈ\ˆ¡ÆD¢t¡KŠL†®\€Þ@‚í’j3©˜”OÎRÑ)'dRñ‰ÿ?ýSŠP¥Žøçˆ‡#vø©‡ï %OäV¤¤8–ÔÓ+•ð)$&¸ŠÓ ÖÂ*T\U)ZceÕ® 0J¯ 'XÅZ Ff5¬²b—ølÇÊ, !´„4m ¤zCrê%iè´~ŒB[j=J ]à’Š KèÜUÊìçº\ çë àî6ýUÊ%—fïŸuZ\ñðùgáaˆ -ôˆû ·Øð¦Vr—ŸJPS¥6=y•ŒÔ¸$ÇŠ.Vë²0g»£DÚž'¦VFAeôÌ3¥\-J’ ®RÜl ÊöêÓô)éG'«DR:㢛¨·/ÇüˆÌZ’ÿì(@Dìxx[Bïþq¥;¬æ¤sN½}Yæ|¸àö'`êOû‡Øðù)~Š¿ʪ n#AžÚ ¥²² ¥|@eÙ›v°ã–¡<°fžÛÐmöU©ª‚¢#A…¡(f.zÑ<”Vz(MhPšc¢`'´N4O‹šÔŽw«•æ4NËG³LƒƒØ°!X¢—tÔÕ<‰xéJi#âA°wðnuŸL¨ø¯!Ð ‹óE*Ö“¹Ÿ8%) kœä 7˜ì}€“R ´r §Hà*X`Æ@&— ZèŽ ƒ™RR%¢¤æ×a°sBC 22²LRìñ#ŠæG»ÿ‹š {›ß¨â 8^>´æ£ÑP‹’¯øˆtÀ’.É9ÓsŽÔ¬—½Àßk‰Ýž§¦”/6ÉÉ2|ñ$¬çës_~ü#?Â+÷8g’"»µDê ‹æ¥*G2­Œå,Ùü‡¹IG9ÐÚPVRÕ”|UÈœµú?F„ ¯«• #sBÊØ³2ŽÉ×þá­M ”ñHB‚£Šà,@ÓyR>D£” ‘¦Z•T )AÂ¥è‘R”Ì!ÛZ}H@p{›êKZV±_JX*XJ0Ô >ñ‰¦$´9ÿ.qËÌ 3›b@}Ž+“»”¥ 4Ô¤H-<Éÿæ”¶ª›c*TS5¾lŽtYÇ¡"zÄ3X‘Q #¥=†¡ö`è>†ºÆªð¹æ*œ¸"´7ú€á?˜†›ÝE^QH—À¦SJ'"¢¤HWò¶ï¡+¶¤yìtžÔâ`ÁŒ©¦~r‹/>õKÔýâ²U4N®+]¡¦W¬¹MM9H*Óœ›ú¦Z•ª¹ÅjèèˆÎ¹à¶‚‚‘?VôU¹ˆY'œ°ftÏÆ´Ð‘ûÒjJµˆ&¯9Id˜Æ×HÒ¦ZO©èÚÀêRjlÃBKÔc–TŒ%Ýàd7ÌD—:IJ-^SW\Àí!|ŠÿB”œ>…™e ]4OûOŽplmS?E²Çqª´*c3ª´ERr¡K>TĈ_-7ÿHñ°Nx‚Õój Ôú£ å#5¨IÍŽQ£Úœ&J¡²”"I¥©Iôk¦lÞ Ì[½.QÇzúØ^R¸SÒ“Êä½sK)~ï”^Ö¿Áôìûè(üü™»G¡xëS—+ŠTYFö ´$E@LeùLª¶\H@{4§/´ª­ê£‘Añ¯9#F“0F¡1‹^XéÖE)!ÈE¦7ݺMçâ @Ó:¾r7ZTÁ’$ú 3}„ɰ®(¬YÒ·±Ä¤Y®‡àÛ”ÿ,‡Ç_r2Á”’'6ý—=?ñ“RB‹f48+Œ8‰›?Ç`¥8È¢ök_;ÇÏmxÿõ ù\•{˜B!0„>ì±è¯Òcð†±¯€UÏòÈ2ôx¡”š"%S“ºF™éQ”fìIUK¢J™õtÌÛ ôr)ÊÛ»5ø\Âë§ÜןKÈSž;ùâèë[Lù>öy*60|G¿§è¯Á’²Y´F;§BR½pÌiöÛR(ƒš@> ñz.÷tC;qdcHAµêQÇwSH C‚wº3I¹hr³ÏGFA’ãjÊx¡ ñé´‚Õ½Q&ŽñºÉ„×qÿGÆYâï`ÿÑ&vÒ¢/Q‹¤ô$¦ðIgyël–?c%Úü¬Ž@,.NâèBÐ4ì Á:æéämcDk$Y¶në²®Œ˜ˆ ôêü-)¢¥’4ixBMwŒgI”"á”"ñ•B>€íŒ¯ÁgŠdB•b¾2ÎîÞë%È#`ÊGïpbF!‰ûØ%Hà}þDQòÃT¨bÛЈš&Eý$¬æØˆ-Ð"ϸBe®ÐÜ0¬eÜ‚ÿ|ÄèBu=ª¸È=ã3äaõîþ!3n$êpÇ$ô¡«¨C¯ü­ÿ¥Ô~’DÀ£LãÆÊ3©’( )®j’¢g à,¤]ðø^"×àË{\ð(ÑMêÆ;Æã&´h&Øäßg‹°‘¢˜âƒxëcÌ/)*Åá()\Q›P&d¬ Îv‘ò²0þ>̶Üâ-$UäÈðF’$åA32ƒR’r$êZGºžÆ4ž¨iø-Z~á)®Æ£H"HšB÷ñ)€H¢±å®)âŽù0î¾ì±;ñkÏç~‰ø¤*oáoHÀ&ag>\(*àÀBñÈR)¶í,`Ñ,¬ý®â"AGþäÏçÆ/Ã~ ùŠ/$@C€çÁMRÿ9@s°3~ÅÔài\ÇÔBM[~r6VMxH¢ÿ7ž‚;f­GuñŠ2.ùèqî2Ž×(ŽâJÓ‚à@5]Pãì†NìÄ`vOŽÍ¿þëØ²RpàãTrE!SKAÂb€`«"ñ¬Â0'8ùï-=ç›ü,ª(D/{…ámF2à”Q“2#3V+xd¯@ÍþA{Ãá,p\V­9p‡"³’òp6X E‚Wòj{X3)LS)\3)‚ùOáÑ4À5ô^à¾Z¢UjNø‹NþŽN~€¥(4~04ë+ÅÍ!—s›ˆ AÜÌñÐ"çd±-“çÿ0.72Qâ·& <{Þ陿:]¬F0C[ ´®þ¤Ž¯|$ Rí´‘ DI”þ02“BsH'‰>¹%(í3mg>s?K3€5À”B4´×æî^ A½Ô4É´iB)èÄúì$)úîïê4}üC‡`R(ži9 d,¦²&…ý¬%î ÎÂD™3ttqÿàBJò!ÃÄšîWHoG£îôZ u^ëBkôáHµKÊÅ&ͳIÅE[2i>­tÕ<†Vm{Öñ(Ô@à¾\3L[S4´5€XwUa‚QÊMi"ïÎ'þäž³’Âÿþá(`}"O/ÅP!3+n®æŽ*sNfÿ8Ìü./.}1Ðøj(¦Ó$ø’£»É/¥®Ô˜¦Òœ ô5Ô6-5VÃÕNµgˆ§d™TjÄŽJ¹EuÈÅB`YA{Õü³KÿXÃ@Mó¾26) T@4N&kdËc`ôZ“ä0+—ÜZ(``ÀÂ,y.€Ä·âPÙ¯¦œ0¨ÈUñZÆQÓõ-ÛÂß Wò¯uÞI„âõ‰Ñ~%_g,Š5Ž”’Ö2ËïI¡áqjÖzÊOu>ŠŠO?1®K_À5-6Ld3®K‰U)ÂT›Â–ðñíêAØÿâ4Z§/oÈ'kCe,T§[YQP£PRjªÂ¤p\'ì© :qñ /Fet›â°àÕÐÞbà.ã0+ÍSû5Zâ<)ÉT%%‡XaމV —c$@DÔ@'öm´b+–XÑtîXóWûsAùÖî*&.q|.KNS¶)r‰|j¢€n6æ „g¥pýÀ•SŽj ¯­\ŸâýÂéýrÑrYi($@øB2XnG)0vZ@xÄÞú©àœ¥&/ó l’ fµ)ô¡B äЀgn€+SB  @?›ïwÓôcï ML30À”o–†Àoïæÿ±èï’Â<2Qe¥·S³f³Za{33æ¸ÛÐB,l.-oî@(/sŽJœ,%ÆòzB² a,v:cFL¨ ºØ»šì|ŒZnR)¸%‚#ØjòpVϸ«:ÆCJmÿó.LÅT)]ÓmÏ4cåVãÐñzç$ú`–ñ‹ÿªÏ©…Y¿ÐG)ø‹"¹Á¼BÎÄB,¤ÎJ”rï })—h%ĈVCž3‰3&Ô¢«Ú‰ åMj#ÄL¨ŸøªŸ_ÈYÀ.ÇXãjbõ€x÷f×jjµ«V-¹EsEDÐTK…ùŽtc•’c]<( fÉ'{Åúf¹&®W…MöoZs"äR–—ú¦›•P{êÍ"©ª0-h1c(÷Û89Äø­‰'À(`VäëYš‚Ú@)œ Y Ú•¡å4X÷jvo>"E VÉц´Z—³Z$<*¤J€¢/øLýLÝö?T*<úüöÜônfâ„/úÞ4úÿj¢úLVïö&äx }já¼9‡ÙÈ+’œûñ„ödvºýÜh(j*æÚyó0„-¤$”¥Q1¬SÞ€e2P¨Ÿô-F>•È`’–çs†~*!Ç‘ âPêRâдøZÓmÙ:­[óc´„ýöÊžÂnöö–f…Åãn¤9B§¹…w)ä¢u~0fAt±C´gÅ—ˆ1G›†˜ ‰¸’kË\Uªl§‚h:'B{jï)ÆüÙôz„¸Z`2jfÈ–iye[ì¸U×Í£Èú‰^À¬s[m4A“M½´4“µ'ÄMÁÃn–5ù[ 80vÃY€¢};ඃ¹)Øù^¢ñslI²„&0\{ñæË]Nõް_ø¥¯Æ]‹çÆ7rÐÅQ „âg‹ø%g-±þšX”¹ÅFÙûWŽ+4ôµ1flÇ¥ä=yr6¨ä)â0¶gèeõcÊbÝʳô¶¥c+xµù<+$ N$k¸ï–FZ¹ûý¬°¯w9©éA,ò¢PhMFBبś³Q'ÏÏvže²Þ“ß8 ºše-ž+Šü1»š\Vÿ¹úŒ‰ÜIÊBU²ÔÉK n÷WíVK´AEö_¶ü´Àc¯'||öñÌA¼F<83…æh®R˜Ð,À¸m"k˧AÔÛ¼mA¨«ŠŽ¯®cEáóA­H‚­ø +Z_Õ¡iH«=ÊI,^HB,OBÛ“ÂŽ@Ó5ýcå–Êì&YÉ]ñJ])DÖ®ûåËýz—>\º­•ĵ‚‡éζ©Þr0eÜR› %pîÅ·ßÏvNEU”F¡Ò×mxLâ1©‘œÆirÃI62'¾Z Øz ÕÊÖ¿µBs£,BÀ¬W¯ƒÁ=n¡¼_²<–b‰Ü»œçT¾–ħãÎC›ÿ£•…­;µ®é*È‚!³ -`qdÜ(›B†¾²#ψ¼hްé9ì2æ$ÖB/¯çzÆ:{ZG^žáýá¸2¯ôë¥]“ük­U^@í_Àc7ݺÔ@Y“MË­‰{Í]¦å_þ˦¦ä\º°a\-ŽýF†æ.€µÐ"¶Ðy,ç¨*ìS*ŒòÅ•ñÛo©rehkòD©’^sô§›¹ízfFA_4 i‡Þ9p[h(>%j[ØóI´Bß¿ùþ}øáE‰#ÿ^üsà€¡ þ;ÄÀ?ÿ\ ¬Çâȑ$KšYïãÉ‘ Z‚HåkÙ2_ÿÿhþ[Vk¥Î" ]ø'១|V¸pTd…I<(ò§ÿ¦~ºôç‡ ‰”jpT±@¹V% èAD´Z±`¢膰w°`Áúò øOD`Á"DP±bÅ?Å" D¤oÈÀ!ú$ôÍw°îÖ†ò^ñüð!†Ðlìø/å¿-ª6©ú5O‘’SÛN)»ö¿¤ªÓæÀe³‹—DÒSr †”- ÝâÒ¨ÒKV˜Ê,u ع[${6óY±®r•жÕV(èûðÁ^ˆùðæÛ[PŸ~}. >ŒX€…QðdºõõAAðÁ÷Ï|4„ÁgE4ÑÿD1®hˆ›H!­$›H!ޤÛ?º…8"K-ÁäK‹Æ½hÒPÿ 7!†ÐèœOåÓA t”yR!5¤UNMp]y;ruTMBTPåMi^X[‚{D°‚uÑeAQÜGÐ@ñÕa…V "™ÉWeï…T]ÍÇ%¼ /P8PEb¸¡kµFR‰"ñ¶Œ®5:Yjªdoõ$ðR‹.:úâCÕ6;"a#©E!¡\ªN9•ÕwGUpYÓq…äOGM••yQ–U$Vp'AyÌQ°e­T6_Q|°ì}Îòå—>"昛>Æ_lûtYôÿ#!ü“ç<|~vD„‚NDFy”)I–⣠ÄVœløÚvnCÔÛÀmÊ©£ŸÖh"ÂBýOʵã¶J7•W­ZôcYLa—$D"ù+Ègök·h—!L0nö8 ó}ú¹ -`×ê—-e^Þ©ÙYó<8Ð<,Èó„ „E`¤Gõ´ïj'Õ 0¥´Uzémý¦È[׿i*Ü?HF!cS€œc›=TÙžzj¢!oË-wÜB%<#P2å\Ã!11Q·RkXÜIÅÝ«`]dUygäuûhÈzíÍyWƒu5;æ˜ÑêÙ~û錳xA­<.óÌôÿB}í…½‘<4­’+(šd)I½—t"I!¶ÔR=Æoõn˜²HpO¢šÚCµ\Ù“ÉxõÁK&©=Q…ªÈ]€\VÓ ¤­JJ~ÖR\M7ÒRÉÿÕ¯óxr+ŽÕ%.=òýŸºtNtû±Œe ˜ ;‹eyÐXP°À!£IÒ@;‘p„‡²î,¼Þ¥„Q:©ÍñNØ›VŠxC¸—ñþ¥5FµäÌ£Iô¢¯ŠR\ /}4D !\ßœ=ÈHF{œ1Yv53ÍuÓ"«[KP4r>iÈÀ?(2 ­F#R}W'qÉHͳkZÛIZèIMbŠ„©ø?SPK*o ÈSžo4%”²Å„Ûûru=¼1G¤%qPP%£ŸŒ/*ŠÅ¨2Rdê’(RzNIŠ!]@À˜”“©!œ¹º<²î¦œ=£¸xú¥d±l\ô(jQÿ14ÔŠó©çüÇF“4?CUÕ`kêa€”tÐ6’éZ‡T©“àxÀTqÅ:’T”Õ"/¨&/u'XÂü{;e/rªc…rÄr=³¨¥¥ÇƒüË:ÕAÀ¨éÕ›:¾!;Ü{³Ó¤dk¤¦jÿÃkq?2 NâtÃwrwöÿ`ÇöçÔZÊöx—rq2Hb;·#Á4¡!…×N·£;$Cd×B˜ô‚fVêænâ§n¿áO‡P°t~ÓW¹¤ƒõ#€ßAø+®—^#¡j?h„Ÿ†0–vã$r ¸fk|Éæfø€MÅf¯ÅÀçrvæ…î"s X(…§g¢W&$eš”V’‡VÌ%t.öO-vh‡&Ræ•Që·ƒ·‡‡ƒuR†z"%„ªÆ#C–dò…„${1qª ( R \P (}²€ÂÇZÌvNöUaÿ€90Š0/0†¶³¦!†¦ag¡1ÿ`¢x­dÿèW03„I]€ ÿÐs€½cá'‡ýTtñõWG˜ƒ±G>h´ÂWcz½bzö3ˆóKÖåí—ˆ'AR tà+Á –0 £q€s÷€AàT ³¦;&(1xÝ# а:q¨ðs4ƒ2XhH1Eu_g„^a%Qz+q$ÔXz¥WXR—^ûF{ú8äzRÆ l°€£‘løÿ7Xà…'moö±È‘ÆÁ/2ët0F‡‘g"îE³‡ê_D!"q Uñ#‘¨§HdJu…“#q ç1@ã(Rð÷€‰† :Àÿ)3Ð¥Q[Q“¹‚äGCµ`‡©@DôfÑq7ñ5>ñ'”T'z&A‘Έ8Qäoû&>y¨ŒÅÑ 4P0c’£A4džñ(eÿx‘y†i–f9Þ7y¿‘Dg7AñQ€9p^Gƒ3”ÏO+¡”ösi^áPù"ÎX™'!NŒùý@vKãrX›f9“*ÖOlItسtU—o:’psYK9錩I‘|µ~ÞSX±y $0€€^rŸØj[p±›»ÉO5tlY"¡‡R÷eœýʉ—HY$0²Çyˆ@A±)Ö‰„2ðT0€„ð á›n “÷›µÀiyƒÿi£'d÷e:1LïieÓY·`•ŽR‰¸OˆÁ' fÙ5Íåb97º*¼doÛ²yûÆpŠÈ‘¨‡‘ ç(p4ŽB™Hˆ’H !: ðFžv#iÓD¶-NG>®é ­v”9”ZtÀ>J¥U*¢Ê“™Bz€5z¨ÒiÐá¥ãõ0 #T÷Ðxufq”ÆÁŸVê¦o q0ÀUËÖ;!qØUdövKH**/ÒŒ%¡Ÿ$¡¦Pº2¨pЍ‰Ê}¾Án1D U]O™¤á“¤I>­Öi™ê~ÙQ0¬c––°àùƒ÷€g ›ŠZ.Ѩãµyw“†æU^%ÿ«ÿ¦ äƒˆÆAœ 4E©ŸDvŪQù<ÀÜ qKó(ŒÅ“‰Š)ÓA‰0}:d™FK Y\Að«¨EÉ»Z•å SJ.$0޳ñ ‡Ê‘Æê ³€Kó¦3 ­¬ŠRF‘‡#A#•š18Ž¢‡Ò­Q”ÿª% ° Kãúê­ ÄÆ! D`–R% ªZÙ¶¬Ëj '1Œ0Ey°;a®Ë©Ö9¥Òkµöû«Sê¹ kÔwÆá»å; àŸ‰x¸Ušÿ±f™"\q®çz³³‹Œ¡ãÊyB.纫õ‹®ä¹"1¬ý;}ôv;¡qó ºQiH<Љx Ðr«Íšˆ“;ìK.Ñ[®;ôk8û ûŠ¡`½Ué°àš°ƒ{¾Ë½;ÒÆò®èаurD7:¯™®ø%èNgˆŽ‚/¯‘ÖùúùׇmÉ\B­ò‡ŽTv\çL¸áKñ$q£ï{¡‹äÿ&aN0ïÞP>ñ ÁÕÅ×AP`åj]a­ðU)žìB!hA@ÿ¯bï< \{3¹._ì’BÓžâÆqgQCc9}®{MÆdÌÆÄ(/ÄCLã~ÍAÊÔÝØ{,ÙæÂMÙq·ÝÛ-xaQ0ìýÆ ôÐT{rôþ~³EAt`ðMEÚCÐ µÑ’\xÁ×’co¦Zá…L¯¯HàÖñ$¶¯5¶ßÒKØ-.Ä è'÷^‹òD%Äb‹¡[»ØIÝí;ÙÁkéG³Ý³ž•5óGÞ Âéõáó ê¡^ï aé‚…».(£ñ'ž_cU!ô'Iãw^Èõ©NïÞj’)"aàŸ ¨Wÿïß *tQâć]94øïÖ„$þM¸õÑŒ‚äH‚#£’6¶|ÉR&‰y%ÿ•€p³f‰†%BJ,Á‚çÄ#,²(ŠÔèyGþÝkxjÃ{N›.ùw"⇆ùœ8 цžCc-ŒÑ A† 08|AâEùÛ:ÈðàE‚C.ðò êl®CF8øßŠ•)ža˜Ù¡Bˆš |FØáçŠÿ Z–x1õÀz'é±á-—(=Ú YRö¿Ú´;Δ)RcÍ[ónùD}S¹D¤Gÿ)(Õ¡T§U§:´'Ñ^¾ìÿÚhhñ¯E ´ôÖ²%ðÏ­ƒÿ riü Ã?#óh5䟫À‚ÝÎ âŸÁ ; ±‰“Œ¢Õsà€ ¹ÊÎm¡‰8sè± ÊH ‡B«G5‰N‹H!„TK(#‡` ‚‘6úÍ¡jÓ‘˜`œˆ‘hº…„sh¨ˆ‚"ò9§˜;r"y&ºîyªjÈ$®òù'Ÿœhˆž±ŒiHƒ6>˜Ç-òR¾‚∷2ÈÀ»00`¾†â½÷B¾Äl°ÁÔÀÇ4ÐÇ>T -ôp3G”Ã"ˆÒÖH,Ñ4ÓDœĉZŠ¥—x‹‚Ý\rÑ7ËX¢É¦~²LȈšsÈ(#¡„²²ÿ%å™çŸºk(ІÂjȬ4 ‡+¶ØÌë­ÿ{€²æ‹È€VZù§Î3û;s°:árð@@°°·$óð€ Fˆ¡šáŠB5¬ôB‰b¨±‚ ¢¡„2­è41„¨µ‰rÚˆ¶‘Z®¤[FjÈ&ÝBÕ!š:êuG + ê9ç>öØ¡%™ªNºéHÒ!F’í®{®´g, þ™Y°^` ¢mƒ3—¥h †ÐÏ€À|¯@ö+0ê…¬¬@s +#~ `ÚP@%WB£%Û¡Ð,|SÓrÅÄŠNíÒy› ' ‰¥”$2•SUmib“JØÉGÿ“’Š(š’‡Ö§n"îIï(­²²J,ÿqBfòÐ Ó-ʤ}àˆp®Ï͉^ÐïÁÐ ŒOÁ 0[ª%4²ÂÔÃ:Ûlå:]Ñ4ÓºÞF;¥ô1˾HDvú—í†P<ûlÓÌ> oüï5BÕ$ØtË{7ÚίI$ŸŒÛq9 yRªñ¢ÿ‡)­KåPæ_:æQÁD¶‘Ï¥¥9c^p„ÁÉ€+ZqÃÆY…Y×éå´?-ª!:ÖT»j½€ êà\è5)Ëà+QJÌ`Ì60KA"Ÿ¹”õª§¶Žp„#9rÑl@â·ÀÕÍ76‰ˆªzÿb¸è($°šÕMl%2£,:QiJ®*C€ô@éó@ËË",‡ÐYóHËZ¢Å3gÁgZFÈ}p7 ð@@$0Ð ®­ËO™¹ÔnG(õ0(RÉ;!žÒõ Æ‘”B›‡:T¡ò1D: Ûf $‡<$‘G´W·ÃA‘%¥²‰‹îv>Uª2"‡ëH&’8YF§)ö«Ÿ§c§Pä(›J«T€|D˜N(=:‡0‰é;[cïràÀ8ÊqÙ¢À ˜ÉLΫ‹ëE5È-»S—º2DÂŒtPœä B½îÉI5*†ì"ÍõJ¤³qêBž„dÝ"’ÿED%¬ô)£¤±âȈ9CšbTlÕ¸¦H4"PÑ_!}y¬ÌÃN`‚Ub%+çÎzV‚¹LsšÉ„oÖÎE㚃ˆGÉ Y¨1oa Ðä:uÅs!âÚԪƨvï^B›h4Ò¸m3!â öÌ6"ªzè‡ SK¼wÊ(‰òaë‘q|+Ä-i–ô#Yäê'¡Ëýƒ˜Ur1Eª¥*AgyYãœ%ú8Žÿ¨æ (àŠÂ°Î*$Z=ФӞ~ðƒšAÐÕÄ¡N„_"á!£ÏD,S’Œ¹<I†è"&’›V¡ZPÚt7ÛŸ{– ºÿ/HSìØtª˜²ˆ0î)¿lHåK€j ™v͇•¼Ò9_Aà¢ão}æ—ª®g® @§:a D³ãŸôB´èƒçÔW×kB~¥3§QíºšÊCGÝ+#ꌤŠX“"Ó~¨4µ­Ì(’ʼnŒ‚ÀÇ(€åBÑV‰‹hC GQǹµgSiîþ$"%%ÿˆ‚W¨”‹ì„ €€[Ú"-‡` ÉÀ4½ë:¿ló±o9o  Bwf1å*¤¾òEä⫽–‘&‘Ç ѳl‡BíYÓ¡é3µ Eo“ƒ‹Q(¸21sDtæ¬ý9XÂIDpt¬HÑ#ñ2ÿ9`nzðüL‰ôÊ Ñ¥RtQ‚K tÑÚYz[55ð° Éèt.ð€0‚@(Böékë!$#3S&Ï!$DMej=þz¨AêúÌzQ#°BRENÅ™ÿ Ô¨´2%Àm p ÓX#ÇîÉsàGÛùå¢oQ.b²ç>ÿãÄ]qArA¥|@§,Ïí³¹DKÇÿÚ\a ÃM=/pÅc SÉJrz=XS^OE]»}M*lŽQ¤–'U`H‰FÓ|$òÎÂãÑÐÖ© os»Ûž%·9ö[ŠUÌ•Á0OdeK«¬~ñƒCbŠ`)ºw¥ÿRB \ð™”‘øÒäèj>€¼=3/cnvZ2ì>º³îÉÈo52ࣩlTœ¡ÏÜRa¡Â› C¦VS’têDÊq^‡9νåuCðañ¸ù >Š2¬a“‹ ‹õ›ŠJ«)€‰``*µ’ í™ÿCÀY`ãèõ€x@wÕsOÁyœËØo®KÈœ Ò—O•ºÙ¯5Õw¨É€-cUª—zªõ*k<ÏCžú1_e{î)KÔ6„˜:En1ÅÄ\ÃHA9U¨‚îV3ŽÎHåИ}üc۹趷y€3=†˜ñ%p…SäãÀ@?£Ã€+7.„Â}vˆ9'ï@]®=áI¿>EP€THåßáÎ1Ÿ‰7MY½*³§Á¯…àDA û#ž€!ù ÿ,éÿÿ H° Áƒ*\˜ß?‡Bü‡hÁ\Bp]B¡ãVøp²AȨÂðY ÙÊ A`³Ä‰Œͳ÷áC~T˜Çè_ODˆ !â'Á'" VPøgˆBÕo, €õiG«\)Z•Pæ‡ ݰ°aÁ ~üFÀ —¡Ý»xóêÝË·ïÁ|ÿçã8â¿ „(Îh+T ¸€ ù‡o”0\˜’\`¨³K³9‰Ú+Zôļjéüðoê†>% öË—&ý¸à_¬CþµúÚêÆ?ãf'(G½€m7䯥;ñð¿xüâùÝν»÷ïéÿ8¢¤J B"L¥4`Bb‰K¥ï©†þQ@Dö,ÑyFÅ0Ï ,°pZÌCÿ\ "­õ”–m $AgIUÀÞ 'ÐG_wœK®uaD€âÑÍ%Ù TÝw4Öhã¦#\…€ÈBdŸG!ƒO{—¥„IXYøL3ѤQ:(@T¨Óý@AS1éÇŸlg1òÚX?´¢ßX!1Õq?Ü€Èu!T*n¢ty ×2>„㡈&ÚÐxñX—>¡AsôÆ^F¸„ÞyGF0\S„ªà?%à4ôTÉ‚@ò°š™®ÿ¢gMU‚®Å„Ö 6(Á†l~Õ‘œùÝUA(PUí±¸\ƒÆe¨@Ú)jíµ7ŽGXŽƒñø+,°@+ã.ðT! ñÑJ*ªØQRgA0M,´ª <¦ÑóÙKOO·^xƒ1)˜SLEÅ”æøà³UUSÅ·A7Ô9l±ŽyvUG9ü,u-…íÈ$çDƒ 4¡'S7‚#he'„ŠלJÞ·Ÿ>û傼ó¶P¾'Èó_¿÷Üà9ÙãÚÁem/•šéS{Uq|øx9œ— a±ž=©&›ëâ³EHÁõ¬\†bWòÜtØAEH÷ÐŽ"0ÿpƒv®”cµ"é~äR ÏmèÓ“L ÈB '”оWþ#Ï=ÿaš‚,”Pï­²@ú=Gù?ó„p–!‰màfˆ?4\çÿxùØ ÑÙmU­DnímE÷1?Z÷òÖ¦,`L+‘>1¡‡ñ£?710„û!ÕŠTR>¹­ B‰²Mð³‚7ýS¯i¬¯z¨k¾´<›à¿ÿøîaš0¢h¥ê‰>Úc¬tF?­XI×Z; @Y$pÖ°‡7\c‘ñ2ë0J™Có¼ˆXÙ¶‡<ï­à7 _GVЊ–ëãr\¨ÿŒ"›LIhü›\©Š6Ô݃ýHþA€øï~JÛÉ<6g Ù¬EèˆÆÐe»ÝíŽM†È rÖ˜'¬P€‚*Q‘[b˜„ `ŒwIc 桜ãPÀwìù‡Žtƒ jeq37Š”ñqF-œV²D@G}T€z‰\÷•thsRO‚Z—õ Èr …ߣ˜y àóÌAàyE¥•` GÀß²Dô¤'®ÑÐW~0 ÌØ²MÃ<"ØÈÁ—@—ÅÜÏÊb8‚c0â¨Z•5gæ¨ Ûj«C”…=}Tä8â’cRÖäÒVü*—™@¨fˆ¾ r‘ÿÖ9QvŽs9¥†:O¢vu­ÚÜXÇÔ ¢’ —v> ŒÂHlÚÝÃ:ƒ˜\À%Bq·ÿ(E†Uæ?°‡=µ.¤‰A¶µ-Ýì–""ˆŠ¹)DK1zc.94™| ÚÒXw*ÍýŠýGÒ(ÙŸµ”È@Ÿ8:,-'>qœænj+®låXËj<30Î\@8ÄÉe(3G²Ê0f½Ì|‹B“îÍÁ"Ï`&‘n)K-Šâš&£DDP*‰#`[IY*Z½–¶*y|¼ÿ0/é¨ÙÈJ¨T`fY¥:ääù3ÐB¡!c¯‡f„ DcfwžªÝ(Fb§ÃÌÊ2Ž L7HAD{?i«aú8\À R#"ÂÕÔp¡Gÿ1êѦ¦8< „`¡/h#œ:<_I±÷ƒ§:©HTù¹¸¼8j¯˜Ù+ñKª=—VšXtMmBò©b€ŠQºlŠVñ ‘¨g`+‹N̾E¶r¹dpTAÜ*#FA³.ÿH¤±š:Åàc2<ìŠLë›–¶/hA½^ðÅÕ+ŠõŸ  MT¥±à‘•§#;E`Šî=ZÜ? ȯ@•6"jǦVÆët~ª²Û‰zw‘)(ESÍïã”UyÒ©Ö«¯åOBx…†)”>ìÊ6š‹×”ø¦HíD¹l×?ô!:yäyUØéŸÏ*‚÷Iÿ¼v<³ ÔŸõø¤s`{óePEŠñr“„£ØQAˆZçORÈ€qRk6)×RÍ•b”P.ÂÂCí‚úÁfN¥Aãm™SNoH@D‘*2n›ãmªs/„?‹ÖDÖV?É'?•ÆNãeÑy¢£ðOÊa&ePja,*enBAg$Zµ20’p¡pCŠФˆŠôxŠÁѳ„«ø„ñŠwSˆ\” "”K”€`¤"b1>.†³ŠÓ8Oq†Òw¦YÔdžȇ*Œ@‡L¤9IEEF“ôׯI9†|3V¥“SæøVÿ#+¶ñ_ÿp ¸@Žhi…¿ñãòdñïˆ LFô˜VÙáe Uü(7A„!7VÉŠ;ÂùVb)ú@vfx‹ñCéRÇ‚" '/‚Ug±†šCÒ?IÄ:R/ŒÕ/¦!©Â?÷@XÔ*‘*´*6¢1Ýxi[‘€0ð•Ž\aÅ1ÄDL P;‡‰Å!Cñ0ñ" Š~TŠFˆH¸„•€•ýø¦=(ÔGdvkqR1)ù¸>O±èÁ!´Nå:Í/F$/R Wòû-€}Wr1@|“1FS“XÿnT2%ã–Xô98†à'°!+˜±…5(&+™i”_‘Ú„©`¡‰]1Ùrñ‰×ñ.\ýˆ„¡èI(®—Ч¡H¨„W™ù $ãL'W”í¸+ð˜Á€.Á3” 6•r…IdR"‘S4X ŸÓ]¡%7ÁIñ¤’q÷9ñãh‘S’:e£èyt9ÐmY ƒ ò¹F²qË¥KA즔Ȁ‰TQ¨ˆ§÷^6S)\zŠüx©(#ªŠ²9\ ŠX7a)¶†2aWèÑ!R[Ø€ù@°‹[a'±¡ I•³c‚ÿW/þ’N7?<úSÈGwŽÊ^Ÿ# uÈb¥Ci2}Ù¹40)/Úž P²Ò ó0û±»Ó5¦eKã>rÛ£«`J„²V›!\ÕB¡-$¡J¡ÿˆzJ8ŠÂ(Nˆp R]ܤRèÑ–®aé˜v%öp*®ã€w)âU£‘*©A?9O–ŠJ (˜¤¤¦A£™nÔ÷lƒ—s'Pm¹0†@N®‘MZñª:4†cFP µ„‰QVØap!±õ J›DHŠÊ §G„Ⱥ¦Ú‘„¯„ñ`¦‡òšêGpÅzÉbœpÆC­ÐœñFdD¨ÿñT=Ñ]®B‡žš‡âõm¢*PôDûR/19JU$ˆƒ©9óº?àÆ99G97ˆ¢£¯ƒyµ­ÂPÿÅ Ði™ œ£œ†HFU· ÀÚæ)Ÿ(kX W%k„¶©¬1"¬-ä ôÚ¡•¯I2_7\\Ré\ÔÊ.lÁë3%Œ`DfR™c Ò)˜âu¹I£¯B;´Pd%ÿãXTÄ9dntG®ê„EN45E1®›äb­‚b&Pã:90™9'AT Ȱ j‹ aT ºJ©©È:²Ã#…²ÿs{ê¦#óu®'öG$fsµ ¹MÑHNÿõ¸ðƒ%ð3µIn£{‡Këm³¹9ç^‚ùN=ºh÷ÃN˜?¡‹Ep¸«ÂÜXõƒß¶*i²Uò€P“ÂÂJñ@SIIjÀà»k[eÈ4G¸= úø¥°Y•#Ë ¶I·nj²Šbo%²·&:vÕAbÂ+ñ¢%v*•“Ãñ;µO”4—k&×NƒGxW¢¹ÏHhêdrt‡¡›cx˜¹òÀ¿âÆù€“7q£æ‰X°2%¬ó¸´›Kóö@o´;§¥¶|Lv4ªÉÐzws„Yi±Ç{„ÌÚ@½Î=)ÙK¸ˆ»¸€q-•‘u˜DE#ˆ§ÿtµ}ˆ‹¶N™‹’í‚ICT?OœT¿&GäZsó*3Ux<*Uóc6Q*Tâ œ²¤ºkAg¼ ÈDHQw± z±#lãñ·"õ·nZ-U©(_°-Çüƒk¸Ñ3®gf0 b¸XÜ„òB£ÛõlŒÕNa^ñ]UÔÈÿ0@R‹¿À%‡Î0‰?ýÂ?âöÎóÀâ†N*0 Hº/åÄ/ò­8\*¬0'Õÿä^Áô Û»×`$£‰QÙ„¹Ìkçe³ …¼º Äš•6â¬áuÊ\¡pÌÎì•Ïc½†¢2¬„ì)ûò":â¶?Qÿ»^}¸É¡Ä%÷]™S¿…Jì ž™lwãìÃò@9ù’N™#nEK?L4¯68Y‡CêdòTdQ‚ALS–¶U'/Bn»¬¹|ÖDH²…)V©«:¬†!Â8b_†ÂI˜¡HèO ¡… ¢‹bç&’³è¤?.ö?œƒÓ8cIü¹à•’VDEJê nx‡?>ÌÄÇÈÍD+Kp-0BóÉÿ1ådTœgÕ·ÒËò3«[ ϰ £à#PØá½ÖÀM›„[„³ÉÖÔÂÖ‹ŠÈz²'s×{ízàÌdæ «Z¡!C)ì¢"é“D´†ÿx/‰Ý—&xŒΚŒ?QûÍÖØÎ×ÉNK›4šOòýI“|¹ø"ïü9fÂûB/Z"%‘Ûß(ày’»pÔ°ü ¸ ÖÉýŸX„w¡¬1„³ ¸ÕÒrÒ§±4=Mw„Ô;ÂT8wýA éÒ_²>3%GÞJ cåmÞ¡‹Þ1màuµïš¿î*s‚9´”üŒL,xÙ™XÛéßÊbÛõ¸9áâÞ˜'z’»SUKå»Ïð,R#@ ê¶ÁÜ ¡Ö×ÁÖ£¸qsK¡¾¼)c²fÊ(,ƒFkËœ2tšÂÈ3€í’>c V#?£lw¸¾“wï+ºWÿÛXíÞâåÃÿÀžÄÙﺹ“Jšs×™¬ƒ˜uSâÏNîÚýT6²­T¥¶Xþ ÀÀ"¥#nJ-ÿ8¦­i(°n›hŠî‘×TtÁÇw“®WpÎúeù°fzÞT//8y@ª :vgYxGJæfnN„¹›•Ó–JÚ>ÎÁ¬béÑèŽî“sԜ۹â&´û’XæÈÏ@zÀðU•Ô””M4HA¸€êËð Y \æØGz¡•Å} Cˆæ|ۄ˪ë}›¬y¼7¿×H¨-ÎW1“Wʉ†‡H â¨÷=swgYâÞDÜ~?ÌΗÿJÍÎ9 žü#4én9‰!Ð’èNÄéôî™®é‘ÃÌhbòn5nü€!OáO6 ê”aÁð&Ã˾:ñFøðP¨×¸ž²nRÁî<ÆnÒñ"^aqÅBHˆ€s†ï3/ð(¿Ç·÷ç¾-¿è1æÍÏÇXÇW—¦1ÚñLôÿàóù€ô¤óôS×ixLûg§‘XJÿV³A¬ºïCIAñ‘¶× ðË Ç”«Ã…Ë¬ßÆjZëf•"•ŠzÇy:úÀ†â„‘Çгzp1Òqµ7¸>\ve'‘„SFƒ“y/{¿÷1_¿7¾É=êØJýlÔñÿîóÞ]"ù?¯ ”³Œtxé4ªb†Æbï¼Pˆõ†€×²Áªcôdœà· øn 1‚ßA„ÿâñ[ØáC‡ ÄûWQ¡¾üþ峨°b‹ 0´øpdG”)KvÔ§qcG~*tä˜1H~âäò&J~ˆô!"ú‰òX@ÈÇ脼#ò¤F=rÀU¬XÿÀpƒEV+^ݺU³¶†eÖê½{O´øGïC{ùôém¹÷nˆyóZÌ£GxÞÓÿZ°÷”Å?©O+²`q¢ràÀŒ>H¨ðÁ³Cˆ I€ˆÂ£Tc½ìÙµQ?DèRåÿíÛù(V¤(ñŸ¾xoÇ´Øpãnܸ]æ³mÑçÎ:3VÔÈ|:õéÖ+ê«€Qhˆò^´Ðü!¼R©éïUÅjU«Ú·aǪÍú^þÕ·põ˃üïĉyþ !„ô1P(¡¢³gÀÂkp®Ãþ ðZH¯?©,b¡ÌÊólF4“à3C i%|A†5`–q Ùªí ã:Š"’ ú­·{ô¨"Ý4 N!!‰Kî¶LÉè>ª.¦ NÚ¤^Ú®»¢ ˜<³Œ…yÒÓ+«ºâJ,®Ê:¢>6ݲH¿{äKÎ ý£‹í1Ð@ DJÏ @Âþ“g0 ÿ2þúó/³™àFþaFæ‘”4 Zù!Åk–i±Åk€ùáƒhó€$äJºñU!)ÂH·«)âH#ŒâáÈ×x&R2#ᆵÍ:~˜Ë陚­‰ÙŒtÊ)¦' ¼aDFœÔ3;á<1£¢Ó-«Ž°ˆ=°è£ï8ãTOL1C4@õÊÇÏVðÓÀ|¸mÀ§þý/±Ãž‚½þÀd„ž "Í3̺4„ ~°`”P]\Æ¢S‰âgã"ʨÕa]øõ(J¹¢\ »`I¦™ki$&©Üé '3²‡YjOâˆ#DX€¨Hq0çW\õªªª«­ÖÜÿJ¬7ñ#÷`x-<ô¿ÀèOÏ6ÒG °%ÊÀ¿ x.€“Š1ôæn”гìKÀt (¶xÅP3®H  h‹Ç 1*vf…VrròÉ;Z#òyÙÊd±£N¦*`®édª(ʃv­IY~¼[aVh…} 1êÛÀÀ W*rÉüÇÜõ⪨*8Fì¿óZ^± Ã+óA$ߊDðS¨|•B 奰yô(SŠÂÇc:±È.ër‚Ó<¥5מÙX Ùj#r¡Lyfì8¹ÂʬÔ*Šhghü›Ùãh†*9ÇITò‰”r2’f±Ž9ÌÊ hÿV¬`£ùÀ´ônS)ÞšàB5‹4 %R±P˜—˜Ð@…‘aÆF} C<[E"ð¤ [€ AôzØ Á*LsaLÍg™:1ŠB™ÙÌÄN”"Ö„ê¯È@TE#ðÊ8‚·C*ŃGŒ¡èÒ‚M¶`1èÙd…(“È0Æ?‚@i¼(¿ÖŒq×@Æ Q„ÿéGúð€TÀph¼1 px‘gAÎ6Çúã:7 N'Y.9È 4Ädµäz“¤†-Òå„'dŒÔâT¼°Xxªˆ…„ ¶Šìr•¯Ð],K½h/_¯øÇ+ É|-Q—¼äeô3˜oª2‹ùR…ÂÓ‚Íc3¦œð1¿iºèÿ86SÅà‡þûѰhu2¬lV»±Üä€%,Ü …XžKŽÿa:«rZ„¼q˜ó3(m„QÂçPÑ JDà &=“·¼yR)-t‹|Ä„ÌÑE•¬â€üÚ¯!Ö@"@baÿñÑWPbE¢V°—&B@ÿ¢Ò"!¦ }‰BaÌb%±Õô¦­)06pT!bqŠëUsF62×Zär&ø•ÉlDÀ•©Œe/IY:?G,”x³$QdO.è’‘|@u?yÒHiÏ¡¬`’ ¬ä6ó¡`JSL3ߘâ²üD2ÿR „^)6{,(½ZÐv¶3XíYD­+à¨GK‰ø`±…l+YI †ZX ÓÉÇx–où€!rgšVàCÂ+r©ðWŸz€"&®Øè2•ìFr¾ÒÕqL¬`Iî·ÃA‰vÄê:êГuÐ!+ut2’]¤%"@«@Ø €~¨„!ŠÔaæ¦ÌO-0ÿmLØx9=¼|àg!ì5רŽ,¶£á(—÷K Jø "ùê¯_ƒØ¯¿ ÀÐ&¿äY¤<…CM‰†P1 -Õ2pÔ¦j"à/ö[  ÓJ(Q*£#g@f )XJJç®CCVé&¡ãÙU1˜H ±h µZñ!\rR ó ¥(ó¨ÿ(s,ea— +âC¼¤÷.?«ˆ”ûÞëö°ª8l}iI û.ÌÿX¶bCª=‰€_mØÂNëÓ?ò(„º8/þàS.íiG€œdC*rD62de*NIS_²g"$.U÷˜’§dY9 ÿ“ˆë“Dâ¸u<Û ±V`!øÈÿ¨¤¶>PÎd l¡L¹:ÃÄŒÍxâµ-24"jN8Ø«±µÌØŽØ7`ó˜}ó"[ûê€ï±bÓ˜!Xy@OY,Eõ›fÕ]}€ìЯ}wp)§2ëV!­²•‰çý¬ `ä }\1nN§‘W'ÆÍ¢–ÍŒTŽ …@%û™­¶úa%øOEà2k79/@ö`õ~ØŸíå‘!lH…=ìZZ$Ù ³hŽ_üæ7¿>éžÜJ)À`‹”9°bJÀ¡-]¼DáŸKeî¤[µ#0AFüç2þå¶¹œOÿÞ‘Ëñ&WtŒôn»[ÆØÒ*ñ#” 9VÔ…ÚÓ…$xÂÑ®̼v¦© '±–JE?0ùãT! YD×ùàõ#‰viÏ5Þñ(Y,}Q’lÅ^žÙ4÷r¾ö5mÏ0 “³{5ËД™¢€9‘O™ŸŒ†2’‘†à†X•ØŠ·à`ª{´š }÷º ‘EB¾A´+CA›° ›h–*qÁ• i$&¢ ø(Ó°S#!§™ ñ“²h†"9‹j?³A ªBíq,Z6b£¿1Û/b³Wt,&¤%Xü‡'ì1óWXÿýº/ð[4¢Š³ÙÑ%4_ 0 o‰µ”$F§ù˜€ ˆŸV°©ZpÆk¸|ˆFlâ‡k¤Fã ^ÁÚF[ªëÈœê0± Šu®YÁ4hÉ1ä«è€’›‘ š «›‰{ìÛSË–0O¥ ˺‹Rü½=ñ&Vl<ƒÈÇ{¼ÙQ…ýâ<Ê[€, 30ËBû?¿È®?¹0½Ä ‹Ä` ¸VX€5Ä©1‚À@+ˆ üŸ†¸z#'ßÚ&ALŽg;?D–Gœ‰hÁ8$ `®DbÇ)I'—ˆ®´Â–ú€ô—õ˜››ÂûÿR§÷ïø‡†dEdzK‰´ˆ‰T…úZUXÅê(ËëK‹³ÃÒBµñB5;Lõ)ÈW“‹n  ø q`#2z:ˆÈÌjäœÞCpz£Üc † ~#™ß@ÁC E FªGmå"М9$®b§GÄ+¹ ¢™2N<‚ª€Š9i2[Ó²²IÈ߸$I‰¹tH}™?ˆÜEò/‹¬ûÂÂÄR6ÀÌÅZIïl"ˆÁŒôã›é¶n‹C¸ ˆ€‹Ù3g|  C£¦üŸäð½úôLx«œoMÚê4šy'š( *QÍKóÒƒ»*OK™ØÊO“ &±Çv,€ÿ`GKŒ¢áG£H ØÍó#”H‰2{pK¼èž¸ã‹…ÄVDNä„Hì9Ô‰lN/«/f³¯Àœ¹ý£Bü²Âz,½+²íÊQ —tÉyœì#Òù‰&ûÙ%½U¡Æ6Ò‘áè­ >úÌÏׂ· Ñ•ÞH§tü=ѱˆ™H#1‰xŠÕÁ]7ÝR‹˜ÄÉa.8ý(Ý™‡èÍ:•È”»`µVÛÓèYÚ“…$,%Ô¨Vd¹]‰¤¥é¼Èœó¨½ÅÀìˆÌ³ˆJ•¶4ó¡ ‹È®Â›€ÎYRh USQÒT™Ýƒˆv‹·#É79¢•Ÿ|*{ y²ÿŸ52µJjÉPc;¶KÍäÒ™xœÇqbÓMk$…Ó‹ëÁ¤ ¿É®@ÁVÏ,!2¹ßÇA‰A%Ô‡,¬šÎ  )Œ”Î|Ñ/ËóË0³EµÂx•W‘úz(¼‡˜ô‘€¤A"…8\Øfpk »F7b>Ò„4ZÉ•¦â´7ŠÞ* EƒA‚³ØÓé­R`E¤JŒ>fÉ1ç(ÍúÔiÓ"YBbŽ$(-y 0€jɵ¨›í—mýŸ BUBä\ÂB%Ú‹¤/¢Ý|Ù/ÊCÚ¿tWÍ£¿|ÉÓŒHÏé’Ï àȸ€[ûÁ‚eÿ d£Û–ga[hAâM )MÄ*‰‰Ó¬Ç{Th6’4½˜‰ °ÇíÝ^åŠ>åÎÂÓµǛ°ÇöË 5µ‰Ä5K2O@ˆÃ¥ š­ÙG|DoM‰øëÜÎ=Ñ1{H¢u,%TÂ-]Uà¼ÅâHÀœQܨÔ”Z0<ÉO ¢ÐH"g£NÝ…h¸†1º0†£@ÄFIŽÊœ:\” áH‹ ›aQ.h¿6e?°‡í5VîÜC2\nGŽŽjPö;â6\héˆý+:£©Vˆb †fhaø‡ó'¥)!²\¿pe¼[šËWÞžµ‰Kÿi[ÂJ-Ý|`þ»ÖE3j;LÀ0:ðW0‹Ðø…aØPRù@'=9!aŽ +»‰I‹4ÊY4㚈_¡d‰e–õuŽL$®ÂUÓO^âÛ`^*Iߎ°(ØdfaÓ®Ú§R³d¨bd¨!H…颀ÑÙ’ô cãd¼UôÜ%„¶¡Ø‹Âl%1›³!àÙyw]¶”À/ ¾Y)ËÓJ¹êÑÙ‡0{ÈpΕ~†fBfˆ}Ó ö‰&ä`^… y^¾SVb †g”àµÁÅdh1ÂŽp‚ÛåHå6…OFåôòäR+~¸W®a g`ø‡ÿZ°ˆ6µK½Ø­ÑŽî_ƃ¶%\fië9W2Œô IHߢ%…fxÝ?g:.›H©ó$Šn3UpoÎ…_‚  „Ø7Ž™®Ägz~ê¬üFa&Ü€þ'@å¬&èTîg55h#Le( ‚Þˆë!µW˜â*†Š†è†V°_¿"¿à‹¸i‹ø_iKÖ\ ‡ÆP yX‚C9” (*¢\Qªê(ý{Zx¥„%òÂV+¡Š #R!¸dËÝWøpè…¾!8¾˜`Ó<"Ž®„jÖV #têÖþ°‡ÙVRœmÙæµök¬Ömÿõû°k„΋³²€WH*ö¶¶è@SSC0Žàâõe¼FNÎÝVïñš& )ê«(X¼ê3ìI,þ» @oÍÎE0{¬¹ÆßVÓÙN³ˆC¶W¸üî þc!¸†rFêÓ6åØ.ðß~êÚæ5ÜV zHpÜNp{h‹˜í—m‹hÚÆÀAÂðÙÆp‚Š(Žõ´âT¨…¶ÆeÒ,Ì@¹ëëΞ^ÃQ¯!lŒ¾"Nø*`WlìôNoõ¦„ô†ìÇ*ÉÉÖZ ÀlˆC6ú¢„üæÐçk€†ÐÓ†gƒ~Ë ÿÜîj¿ Ûž™1(ÙÆÿ 0s•Hó ÿ6×zÐ (ó8s9wó Ÿó:s=oƒ1§í=͇NiõTqa¸bå>j¥1¤!*ÉÎY¸èh¢¦‰w¿»vHfVZšÓìKÈì"goþb›Ï CØæˆÛÇøUP…üî…_hƒ_íg€†¸ 6µÇTFèÚ.€2_p(P0/ó0G OvÙNsHóºówvgïov §v7Ïv7göаí4çvfŸöºPr'â>t`¨_†u†T‚\ ŠýÅÀâb"’qáØk“¶,1³|ˆÁÚfÚ(O¿yæ—mÛëŠðó~êo|–ovˆfO|kgüÄ\vo§ùŠHsñ?ö—ïÛÞSW¦brfk»Vë šžz§ï­‡ú1+oF ˆ!è ñ!J”|ú¢„ÈõOŸ>D"VP\¡ŠÆK—,\¢ñŸ…ˆ¡OÂID­,Œb#L—^õ’ùï—“^B®]Ã…¨‚ {P‚ª€òï(R HUüÓÀÔé¿6M‘R­jõ*Ö£NÆP±µéÓ©Y“Ž-kö,V!ôQhEIX³gÍ„YhÕJ‡ö…a/¯^Àó& bI‰"ÿ#Ѝð‡£ôþÍ£G0DÂÃ%!þûÐW¡â¯¼Šy cÈKG)ùX!ì¶B„¹Œ@‰´ª—z©ª¹»×¿\¿.ñ„F¨Š¢É™fUJÕ+S¯P¶NÿçÕºs´Wc,í •{ôìW•rGƒ‹•DÕ ‹A”OÑ3dÿôÙšôØC–TÑ+¥qÄ‘j«aäÚb+PÐÖ(¸X`m ŠðK¿ô2£F3þ¢[3׳@öeÏrÖ…¥”xZ=R×!)Tì!5™sP" –uÚéäRXVTD+ÍL-¯ ñÿòÈó gžÐ òÌÓAƒ†˜D®µ@ B4à@ô´p„ÿ°ÙŸ•õeP>¹xv˜…HùÑFŠ´ÁmÞðCH”áB.ˆú‹Œ4í&Ü%9B³AD‰XG!iTrfU§¥dЩ‚wôÔºž•Üi lyÀjÇsÚÑcJ1]H0 ÷ÈsµØšÙ‚<„ÂéW>*4ÑD-КkaÂ<-´¨™fÞó‚ƒo¶Á¡¹h&Â?+øðÏ£”È"G¬%HÁ ´Á(´¹DÉ .8‘‹¢þ3#Æ7 Í|øô裫ё5ÕtGŠ—\’_)®*LöÿäuT59žUÙù•Pé–XÎù «’)[§³ÐÞÅõØ*m¼”¹{‚V®¿ ô«J‚ öå'¡BA /\‹A·ÌsègŽØïQ+ˆtÔ‡}h0E DK¸!À Š*jÅ.Ð8#Ž×4# 9T–W¡\rÍ%k`ÔäºB÷Ït™'[óËt.ëV<çÌÔË‹.³è©SYe“a%›¤Ìž­`4ÐÔ‚Ø÷``m¼ñrËæšûY b©âÿXG¬®eïº{(¡/´0ïÙ‘aÊïMTå†üjºqtÔi"A\ÞBŒ2 >«©ò /¤þ-Æ3rl8.<*äæVQîÿ¸Ð OeŒQª£–EWÖ¡GèJ·:˜MÅs#ûÇyx³-ù,FŠÕs®´3zä³B+†‚4Å‹ÿзþĦÏ2*ò|ð ‹PÄ$ ±L×¢ÈHï^}úE‰Wô«"Ç;Þ£¢¹m$|ã[ÁÝ,€!Lqo·éŒDÕ†_¸àb¿I•á€ñƒV©Vɲ ¬–’²YÅH1†ÈþÀÉMnŽm|Ž=þá+çØc2htÊ]f²™±Î:å¹ìjfÁ *))ÌiÒ²V@ ê%Þ N ÇýJ“ÿhÂ?¶5Ž«\1üÇ+°f’|Ü0‡!ØáQtDPdÿ4 « _Á½$¾ $ 9 %DŠ,`EøÀ‡0¦ˆô‚½Nà‡±ä¬Ò‹€$$4åVÝœæ”S%Y…Žß´·”_óeT ÍFçCÐ*Ìà•ìI¥›aÇ!@¥V`6w½IzКLÊÞÉ#“:„Hžõ(ÍPOáÚe Ò™ä%Â%HQy.˜)ß‹[0[s·à%_ožù‹-:AFÓäXŽ~pƒlÀGèæR ÇvZÇ á ãZœ%µfiŒcR† ¤©ÕeS’eH ÞÓ*R™ÒQXf%“ ĈÀ"Øõ¦7i`­úÿyÓšþÁ´PºkYÅ;I‘§ UŠ€A‘P_¢p˜Æ˜„–.úè?.’DéF`¨ÑH0ƒùŠücÅ\‘pÁ)ÅÔF¹pA.j2£A×ÀÇ *ð¬Öø)U`+T(À¶›®ýÑl…r”=G©Jýæéž“¬¡FÅJiƒ ¹¤&Ò¡{®XÊ媹ϥ®úh, ­nÍd& Õž [rµV r˜ˆJ”52<ìBÐv(¤h)ü2ñt‰¼Èꦱ&¥ÄÞv®Œ¦¥ÇäTÁ: ¸Ùhc³Æ(Æ¨Ú ô”ùiO³’áÝþô¶þGO{šÛó)F¹Jÿóø²ä°³ºh”Šx`§2ç<ÒdÉ‚qsØÃAPBìzÐ ¥¦P.í ÀQÌ´¬|¸`CÇÓ%¶×’ô•• aȺò‘¡£ÜHGAìÛb"°ˆ/#%­ì [á6ÌšoŠÿØÀ%|ð.’Š*³Áú\Q¸1…kk• °õ°;3¬èÝ"%¹Í QªÂÎ6ô±ºD Ž»:ºë–ÇR‰®Yi"@Œ]˜\‚™’,WèÎÈàÀ‘ï¡ÇµXÈ_þ:³¹\´­½’!¬Ô²—¿ü~‰±Ê#‹¤ÜraÆÄGKÀÇšãÍÈ6}æ+ ¡šV0ÄžóÿáçðãÃ=ÊÊjÃņZv7»Ù BÏ)q{˜2Õ נΧ>.Ý ¹Ø)Ö]ÒÁäN†"ØÀ >Þ%dRinZ(«kÞ-¹ÖO–á™S©ëÇü:!¯$UÖ–XàU|pkbH”ÍØ;¹Š˜eÉ- ×ΕÀ¡Í‰"íëÃÏF'·Ÿ1lôu[ÅÝN7ÔÿQ¨(@ù n€Ø½aÇå‘(]¯´=(ª ÇþŠ>£²pìœíÏu "X®å5e2i'24nñ3Üã2|Tn†¸€½ÖÐ$. ¹Bó.Þ÷Ù«±ý+Õ|Ï—Ýë"Åÿ*¦Ï%)B&ß š¼bcÉ´QkD‚ˆàìÿÁCF—}¨’{©›é~–½¸™ÞxO=Þ²g­–«²ow"«Ja»>-ݸ‘qs`1øÚ±¯ý¶¼áüà.»Àk&²¹ËeºCÏä&z¼pCƒgMi¢|µÄþBŒ‚Èáo2‘¶l¿Çö^-QøÀ0%HæEK4L¿èC“…ÞäuH¶ý"|@[üÀ1µÀÆê­Þ,Uź!BU€àU¼Þ– ŸíV¹m Uñ[ЉÝpYÇP5 ¨ñ ‹}šÛíàuAŲ O>ðÇ<È‹<¼ÀÙäǶtK·(ÔÙÿH¹|±%lËñÕ…ˆ £ð‹—ÝHn@ÙÛ,‘HØ™ I-¬€³5Œ0@>¬D©Âä¡Réi™œˆâƒNÜö!Œ@!Å¥°‡!X…c¸Þ!Ê^°…ð1ÚIvy ê[eW!]Ðø;=•&'M&~"ËØƒ$}ÀA…@ØÈ è‡Zµ@ de¨_z½b<¡þK˜ÅPk•™ÄC^µMn ‘D…aY^Uð‹P¬Ô?.ÌH¨BOjÄZ@@€!Ü€¢Ïd 8öaæâ,ežv #:"… þC!ŽàôíV¤qÝd„]'ªÿèLIr)‰¯ìI¬ØS‘´ÃQBZá `lã<˜MA ]ÅŸˆË°=áßÑ~ý‹.*OPÙ/›%À,Óÿ©FI…ÈËY€KÜ%ÜœùÀEOèòÌD²ÍFí¬ÀL€pÛùŒB]œHò¡–ãQŒã, "Uìaæ%%®bŠÕX—¬@¥ÌäÌøàëVêéHW‚âuÜ£exÀ¬»@ÀJ‹ga~„ݱ_ây™ñ Ò.­F1bä ä‰l$¿#Ò*èÒE”$UÓ}ÈllÊlÜJ>#\<ƒí,ö—F@Ã5Ã~PÀà2D˜]Ü€Ožÿ:"å?€fi"‚QJ`ŠãU¥k"E âJTúŠTâŒ=×AG í¦W¼ŒoöæYemEA.€„€dЏaZ>H'ýI\ÍÚ )Æ0ÊÐQà¢dÙ¥E8wVÅ]ZÄ^ÅÌcU&M–0ƒ0€mÔ¦ ×¼DœÉžÆ³\ƒAJKrþ2 þ`à‰˜ækî!¦€¦(U\ šfRŽc#2h–Emj•6iSV²“1”,‹rõ£ õ#q(7!PV©=ÄÃX@æ9[ç6T&击¸‹@D)Û_Z'À”ÙÒP‚X…ÛüCžìUi€\0…ÿIFÖi,Ñ60…zÒÆz2æ—AFìÕLèÆ  "!Üa-Ô>Ô„ãè *èi‚f›>(–æQ^ ž…kÎilâJmúQÉ ‰šèTª¡r%Uhozq"ù€–Z]DÀ]üBÑ ­ÕQTÈcx\Î¥ø£ndUPYž€çß L§´GФzúB3üƒzÖÂl 0H£–rVœ…Ï l) €€ÔBþ ¨ "h¾æXìéPe òéi©–hW=ªVZÅ&&ê†fe®4Ü¢"Ué¦ãPÚvmJ­Þ…gXê xÎA¡>XÿÖ…<¡~Y$*½Í¿L¿‹°õb^)”ùI6‘ËOHȇ”bnÊQÌǬ®gÑ„nì Â×L#L ¸€²ú‚/ À@›*è âi›ÖiV¤,jþäOJ ‚e‰ lžØåË’Ïö¬U‘hv(°œL’lâÙ,N‰Ð0BóDí)†íD€B8žEãQè+Hnmý5žÀND5b.‘Ôj€áQXanŒÄ.­nŠ­>c®ÎK,S¯v4µ” ° ð@€@*Ô‚/,ƒ/(«OÞ@7â vc!vãPâ,œÎ)¦¥:V«FhgHݨ–^tÿF}®èæ‘,Šù=Ëy¤nrtÅà4¼‚GUü…\ÿý¥­)O/ã9Þ/”Ö@^ü­êFcU”ú-cÎF-ü׸*k\—v„èÛôí”ÀÇ&@+ .É.C- lÊê©:îV."e âlæª&¦¬¦¢æQäžõ€èÆ_T0îKåéºS ¼L±@ˆ Ð.¯ÀSí¦®eô®u  €ŽçÄ"@ƒ\¨g+ ^è…_¨Ød Ä<¼Â5@à ŒK-‘ÔÿÑ A õŠ@“)ÿÞâ5Ùç­À/ôhÀ¨êöR€!ÅlÌÇ2Ì*0 bR©”>Œ{U!5Š™´Iý’À¸Âî™’¬/°é‰ð¥èaYè¡:ºcjVèQ>häbçú)UüÅï!3Â^˜Ô2=I (2R$²¤)òd@î^…¯,­0¸k¸øˆ_4ˆF±Ë%<ƒ0Ük ñ™‘ÆßAžž ±âá•Q’fDi„Y/Q…¤¶í¬>£{fÃÚäQ#©êÃÌC ¨"»à®þ’ìÉÞ@fÂ;"Å4WE!‚`5c gÏp`5ë1çîžzDð¦ºèNÀnò:7š;CP"çQeüÿC"«°áGê6dã˜+eè0Ä0˜âE'g“=8–ÄN\‚>8„>ÔR“TÙþß¿$È/0ÊQ$Š—H“ùeD?ôãò%D©ÄN镺§0¨§ÜØòB“ÞÕí-¸Â\@=¬±à¶±/X@P™J³4S KÝXô¡¾cA° NXg0uç>õYL€=H5#<í=O†#EVÛ„4È<@-edµ õdÄÀ<˜5~˜µ’œÀ<‹”nr ûEøˆ;9Á@°Û¶‚¾ ›E Qiˆ$I† åÆ^.»#?ž ýõ%Û-›Ô¦Ì‡¬6ìQðMK¬ç0’ÿ™|L»BM×€.áúB*ðô7Ks Ak·¶Ô‘éKÀXÐvÐ6m_ÅãRë…mÛöRo*“3ZLµd<­o>IVàU|µs+"ËQt°Y;g”Ö¦„1‡‹_8AAKÆ<èÃÞüJŒKÿå_ÿ5dÍ2/Þ‚vfÞö>^x>6cñWy¢äI§gÞ>ãÅÝ "(„ ðCógÏ4¸Bv$€i“ì?  ÁL«ó¼vP……“ómW@†#Eˆ_@S«³îIÀ‡º#QGÆm_Åÿñ8›³U¨³U+òÓ"wV?²VCÈŽÇ®"5Kw¢ÎC[Qÿ"œô¦0ãcØÃ\ËuÉ’*І VÔ’,ÿ%Ã!`îÕ—É!FkÆö‚ç_¢²øšÔan ĆÄÍe¹!bð‚gÀð@׃h“ö?0ói÷¯…_pì?\Àl¸:ƒ8RDÆDFÇ5R€8ÿC£ëžŠ[…! 8‹«ø‹_z§£…õp¬£›xY87=«0~¹#£uX·úðC^üƒ,8 A=6Ÿ÷¹Èº12üC*¼û- ½OÀ-гØ3ÂØ;òØã;„œ} ˜½ÙÇÀ-ü¸ –mbn/¢Ôýv6W‰[:Ut,à“úQ@€Ü[#þÄ'~Å/>R”€¬ÓºójÍw;=Àà‚Bo )ÿÏB J× B`/¿‘Þ%•BdYF’L-ŸR ýJ®$UPҫ¹üèëå¼Ý$àyºWýÕ÷9„7sá"C×Ëôׇ½Ø ÌCÚç.Z”@ãßôÓ³‹×1ÁƒŠüoxY8ü9ÿßC€Y˜ù5ú[…ù›úL†&ýÇ΄ úrå a0J‚úþýñ¯È ˆ+Dˆp¡/_Æ(!¢äû§¯bÄ+T½RE %Ê”þE Á%J +ÿ­t¹€Î;W ÊÇ/߇&üsõ¯Ò¤Ik&H"U-©¾¨"K•É­ ·.ÜÒz ÿ­bÿ•¨ymZµgYÌûÇè߇ kéÖ­iè’þ]¨YÁ/à¾h‹Ö„{‚a»†!0jìÖ1Üy‡ÿK\Ö2 " ÉÂ^>{ôœ¨hóOÿ|úB´w¯Å’ôBpÔr ¾‹»ÿ¹hHRUð"5+"º­¯cÂÄ+®ˆ¨Ê‡J¯R¢ŒP3u—hY^Ï™Sâ‚"2 ýáWëë-òïý?§P£R­ ‰+®^I¤%›–…#þ p@ D‹…³Ìú. æúÇD ”/´ ©à 1¬ ‰¹*Ðk.¿.¬‚¢.j9´(«©°ÅT¬É­·,£kž[&›gˆÍ^aÍÿ{@£‡èA«5yš¸§ #O˜6Ün»è6‹šS…¤*#¯¢Ü2Ê'¡pi$ê| N¥›^q Í|@-é$É'¡B J=ør…©¦äsê©úìC?ýn!¡¨Ä 0‹¬ \TÀEË@».„p. 'MkC çÒkľÑ/SA¨Å>ªjA"+B %j,VÍJÿÀHéJ°V÷ªp±L!¶ðŸÏ"qÄ *ø@'`p(ÊL¬1K&ù­ÆT†‹‘o”`VùàV u¥Gœ—<¡‰lB6Ù†­É£|ryR jß$éYâ>Êí6Õ>86JÀ\à[¬Õl »œ¼kiÍpZÓ‡uoaf B8‡{ëáa©£â;‹Ï§øµo™Tô»`‚ ü"êF(+A¬#\U´äªËâ»ê2D/¾üÒk¯ ø:˯BM«ÔÎ;Õ®È*C™dFHxu V0¤¶ÏjcÈœsnaÉžƒ]â´hãèƒl³\ZhßÌj†ŒþçØ|š«RìWœÇºyñPÿ&ëÈV“§iéxζkj©£Ôªg>æÃÛ—ö»ïö/ê?µŽ'ñ½*®ÿA‹ ¹4¯³øB ˜æ& ½¥T,zªJ¦@Â¥1$hYÊþ "ŒÒ‡tzäî'ÐÀ’Œ±¤!Hµéˆ²ªEœ_LkZ#±ZEŽÃš|`#Q‰HV.qýð:â×?È&ž5 \;ADÚÎS¸ÁÍ(vBŸ@•~¥"+YñWÚ‡–þØEavUñ‚ˆ‰­/‚\Å.4¢ uHôŸÆ xÀ$0¦ªaD'#ÄDF‚—1Ä ôñÚØL¨é`j<˜3æ¬& ÿ Á?ŒE´ª=Äj`Ž&‹·¥³¬&“Ì×wv".¬MOk> "õÊ&® n˜×¼ðT¹­…)}JÅ.ïæ‹Ô`s…ˆ¦¢þ˜AaÜã2ÓòÆÿ f0 ‘5GªÏ!pd)•6#ã¹jsF~¬ ¬$°ÄÌãG(Ô#qö›1²&öp—<Â»ŽØp<ÍzHÓˆø Pi$Ç)ÚFþÑDðp$5Q…K)êýãLáɉ+{²½Iþã^Hb¿wË\ÒÇOÿHE \‘Ÿüì~5Kü Äú1¦˜r-÷!in΀‰ãæ»ÙÇš”,jQ•eæñ%†€ƒ©‘Ýÿ 5à°ØER4Q°ÇFpÈÂP’Ä$Ó‘NÙÊF¥‡|ySK(ÁD%´@k];(D ½5­‹†€÷îUK(æé,x¥TzYõ•´+|ÛÊæº¢ DÈp†‹éãÔâ¡À8h¦ÃT`Ò2Fžn³tÛä)S˜¡ª V¯dbàÎÔ´³&6›Ç:mF´cIµ#¹eð¶õÏF‡cÊíB)¤NrH÷ü&Ñò v%q`×q•»U´¢‚j+ -7ú¶šÌk)H™[žà'ª,C¤ (é0ù¶Å¼p…§_déb™ 1 - UßJ¤@Ëz®(…ºcÊF––’©Ì0úð«*ÿVÈyÐÃNd"M›šÜ-2gNÎT驇P ÁÑd•d8©Ñ&’µ*˜¦õ´Š]-IîŠO\“ Ò•ºok²Kcðá -}º¿Îò$ $ìX8Õ—•’€· \MÆ^üAèbâ ^6w1ÁðíA§úÜŠ~º–ÄF|‘ªcTC8M¥ÇjQÂÖvÁóœ*…e«,ÜùúȳžùÌg(%©»#MmTsI'T<)¾Nx¸V‰üƒúh›,ëDc|à˜Ö´ŒÁמ=u×»ßýG-@Põì+[ Õß´R%›E™NFc^,_hª…¾…)Jãð;²ÿ^ã7Àaί[ÅߢBpYóš!Â7µÍC’¤(<Ï„(¤ F3šA¸mÚäâ,÷ÖFjCššè3ž´ÄØMkÑÍ­ cÙ6W`Š÷¢1¦3}]í» µ/þAð` @²IÑëÀ$JA²FUôW9)ÛT€~û”ƪŒë´0‚AkÕr‘AäÁ%Ed®LÊyÂyÉ-8›Ç°6èNÕìNàà UØ:Ž´ÜÈ›ä=îA€$Ïç¶ÁºcØnuºÉ¡D¶««§mõ ñ]1'~ײ^O øTì#•ZD¥?ÀO~›RAüŽIÆŒÄ]$×3nÿîŒ,êT‹ŠbYž¶J¿¸†K~÷ûq–ù!¨CܲŸ%wŽg O@ôjHC«‰¯þqô£ïèA÷Õ |%[Œt¤uVµ }–t¡Xzí^Ô&Ë Ø[ëpkÜöÍ~ÓºoŠØésö‘V£FFúòC‚€¡·ÕÅ„û›œ õÊZ®sЈ¶¿–ŽcùŽó8—éB~´Ê2”)§¼Z Í£ònvg¹{å+ûÛÿMè™ý[óm  !aÂój$jˆKTè’Z† ­õÐb  º*è< Å|ï{8-)~o߀O)nlùêf— n€ôɼ"úÿ¾h'@îâ‡X™èîbhŠû‹sÐ"Tè«ð~0¨ŠÂ×#À¨ÃìddDeŒjfìæÍrçÀìýh§ôï ó¯ þ!X‚‚ÎÑÖ…/ªŽîh^ÈZ®… ¢KXo- ‹jâ\ìÜbéö.ð(ÄÇÆò*£€¯ëð$¯È‡OðÅnz‰*@ÉH@?þAÈЋoök+Æ‚úÆâ-Fâ²D¶OnŠDXd×v-.è"¨.Ë׌К„Hå-.ÊœB` —­óDÈÜ¢v‚EÜŽÄ5†ö"ÝTG° Yy$àhâ"Œ#0B¶ŽÝšcŸê,æ°ßDu(Ðêÿ,€ï(¬ »²KÆj¿çm¬Ót }Äë…+‘,’Œþ£mð/ö‡°,†D:$c*¦0®¬EÄ0°é×VDØXdËÒÏ2Œª\ O òvæŒä5jBÿ‚åþZçÐmn`D #=ÂWâ À L²DBn£Î<âi2©­çP"à°&$‚ &ýßÐÂw|.Ðù-´î'É)Ì‘ù)É ÀñÔÔC±à‘JàðlðCÎB®(ÎôQšö 0èˆë«.ˆMðö« ‹-ØXäØff¡v"R$’è8À.o‘æÖ†j2r‰ÐÆjãèÿâ8VïѲÄZŽF%KŒÄœ†âÒPi/j2‚ &Ž‚'=Í3Í‚à<34ƒ)²kìj¡& ¤È ÌÔ®@ 6)`Öƒ‚àtº‰ÿ"ŽÜ(€jjD8‘ã4ÆSDSøÈEðHdPñã:'ñ"¤c pÍžpg^ãì’@8À5¸pþ y„y@ì ÜVÏÑ$Â0kH5˜C††§M>}ñ‚B€J 2-ÓƒÀÀ2ÿÁ?µOÀSó0íÒO6 àîJЯjABGíð!` àtˆ¢˜$Bòn*ĦîB;.-:å~ÿx0¦Òr-DîEÊifJ:rIæò:µ“2€ˆn.ƒeÍîIÀó#~¡Y^è1©‚>ÂZˆƒ"\òIÏâ{¢'°ö^ &û­ßBó@ù“)MÍÔÎâà’r4ŸhLé†|T*–BÓ‡*þü*üJ¤Za.ÀÚÇrøBBèbcD¼ÒÖHEom™ú«üòc̉X\qÙàÏ!]ã5°Ógþ6`£ó.r’¢ <õLŸ ª‡ÐBIO2j¢…ÔóI÷IBVïU)à!B °ô@=“?‘²?1ÍþÁ4“)™ò^ W‘òL‰-ð*äcOxiÇxŒÇFíøjâÿÔŽÎo$@[‡½&†rÔ"Q9N0²¬¼¯~ÌrØPq­‚"mj pFƒF3OHñohŒÅçœÛDu~aˆÖÊÑð܆(¢õö!|Ñjdu<†Àê^@?k"Wô)‰u4;ðbÑX¿ÑN< ÇÎBàÌŽà NdÍ'Ú£|’o†@cö'Pe-µR€ cöQ08‡rµ,ƒË‚°Ïâ.ˆuJNƒ@Ã:(„rñ"wÇXôÕX B‡\À!šE"Œ ÷‰IAbkY“–æÑföÆCBÔ†°Tß0-4-s4+ÖW»ør•XÑÂDøŽ qo?í¤7פ¤™šMКYÚ‚ØëCö§.gz00ÿüTE)ùESNFßuÙ »æ†ú4t®’HY5Lù6¢Z SvÏ¢"ö•OuŒ—Ô8Ô&Jb-Ó@3«ÝƒC3¯:*d]$e›‚»>ÚŽíø£‘y­×ÚYûe¬÷ÀËZ[š†¿Õ/ôºrÿ"TêË\cêœEñ¢& "ÄÀ¨ Û µþv’X±Iy#2b0+¢j)û,ƸZ ð8ˆÃ8$ä< 8?Ï´´)–´)VKï6-ðª4sì,nIOø$˜ƒYOÜí¾«d§Y¥[áZy{±²òjÊ+œÿ:’ŵ{-–c’dTm$õ¹£ûr%Wtî;}Tk(»XIçMl°ÄÿsÞð Ù>ÙÎ;A BÛL{5A½´bMûN’ÂmèB¯j¾S[A÷d£‘¢‹ï»À ·—|Œ¥±r*E0þç+Q}Ë·\YÖ–£0†B.h9 `Rwnƒ@c”«ÛXè Êsv X•»Ø1-»ÄT™ÅY\ð¢ŒÝ¶X W}—}·ß0{üÇéf¿ qŠìzAínªùÈEŠ¥Q¼[ï"ûöGèûr¶‘;…²†“Êã¸wúœõa† éU¤SH6H*‰S—6>_ ª=Ɔ@"ÝÈvaåSŒ`ù†$`!_€ajÂLq-ÔÓ”£Rû=òdnYÿíâ[çfYs©|RáÈ‘<·G ?Yâ:$-ºW+0äH¸C„Ë«|ûUþFq>Þ—cTäý€Rde9ñ`ŰSHÃIyªrhª–£hÎ"¥t<ä³é´'  6Pßå#†Â³=»—Ý›nƒ ´ùMëÄ4£ |-D¸(£]„±û%¥k!Ò¹Dy0²z³Ü1G( E'YUTDeËó+Eâ]Fmˆ!DƒL’rE4BÑ#> è³Z¸6J±‚–†ÄÐFvõá]ø¢öè窉5«‰ý,*3ø0 O¾-ìûÙ×Úí¤.Þã–Dx>°ý¤‘|š¥É9~Ü€$ zó7/ €ÿ^~œýñ+÷€¨¾/ª‰êûf(ø¦šP¤œâJË×æÃ ‰fz$ª2¢”ébÄþ!Ô³: Zê1¢c,㎠«õœn‹×?ÏbBMå¾yíÂãç£Ñ“\¤à$]‘¨&B¯0øþ.'§40꫼8Ç€ ˆo”ÿc–?.~;9Æ‚6›ÅƒÂGh&ÃAƒKz'-ð© ){>³Z*jIØmH(å€ôùœÏ{•Æ‘R?tÙÜEÊþõá»ÙÃ~¿"@©|ùZæëŸÂeÿ~€ @A¡Ä‰+Z¼8ÑB$ 5bü'ab…$\ø7’bÊ N~˜páå¿ 0ÿAJŒ sÂK :'ä©P"ˆ†þCô!Ä{Ióýsú!ŸÓúžV­*B„D+þ­øº"«BDõIÐwUê‡>@(ñâÈ‘þÕ•x÷À þ¹rUï_àÀ<*¶xø°Å! Odœ@á`Áÿ üWÐ`B‰µ@܈X94F;Š>­°æÏœ`~ éòdÎ-YÇœéÚf[Cn¬€Ø ‘„¤Iíý3ž/„T…W¯ŽÍ ]« \ÿ‰ ;ѳTŸ¶eû/Dˆ%:˜{äü]»ìÿõ5àÊïáø¢£Æ8$päÉGV8P-šmÖÐC Ý‡šciäG¡r!!‘ÿI(}ÄLžÄSk4¡DSH½¶ÖpBÝÐ Š P%A>ÅçsT¡¥ Ö‰5W:^7-†Ðbq!L0ä[/` ì9P×z P|ôIVeÙg€)xõ$0Ø~”ñG‘~ÿ€  f ÕòDÞGZc1Æeh'ͤPKñ¢O']Ð’ž>Õ–' „tH>}ÀÛ­´Apm%u\xöDñT>Í¡%‚ÐYwTXèƒHUÝ…4)xЫóÈó‚0\t*T«zé w쌵§zΓ"»àD,á@íýs¦¤-=æqJê­ºõçZY\V¡ˆG$\Guõ ü-d"Åå{œØ,üjŠõ³™ªx,´BšYJãL1“ŠÿZ@S!ãõ"5ù'-!¤2@=êQ#èÔ£ÖÑž»ûàEþdÚÜ„wlmEü{¨JˆÁµù!&Àµþð¶·e¡«ZÕ*"õ ;÷X ¾‹N"‰ô(­0V‚Ð%—®8\w8¿È'q¿jVaf–XËÔo˜¡‘¦´ÎDÞ™^k±âÍ13§‰9Ê$MàT`;:A÷Æ÷©À^j€2(ó)'òÓÓ5;ûV¤ÉU-‡ l­'øál[…ÛJÞv­fA ä‘ay\4®ãËè^Ùѹ(7¹É­e‰MzâùX0Ò­G¡ãÁ0ø"ŽÉëØÆ†w¼ãe¦ebê¿ÏÿYDîµSá‰G‹6T®L˜¦¯=1MÔ\–H?¾l‘‘fk…Sy‚´ ×-`k tmQ9 ;I÷n\B€;ç‘À ]è’D`™8{q®_Ú'ÝZJ—ZT©å=îvqÇÞ­iy%Bh†125õ…‚ÎZÏ2Ù¿X¥òJM5 Ýwj>1Ém€rÏyúª°¶H &à7àž€Ö ?œß+aƒ•Ã.6à4Ëò-›ÙˆœzØs?§ø!ïsŠSâ1 †Û%Óý|FFq3öZ45÷¹Á{SĆ×Èú‚ã;[ídŠÈàúÎ!‰ ÜËÿÇ'þ‡G¸ÿrþÇÄß*çá&‰ØtÜD’ÝlºÚ™pé‰ ®$¢íÂP¤î9ñ”“mÊö墋¹´(nHÛÔ±ÍìqÎÅýH‰Hu¾Ñà…šê“|[$ñvÊ †ÎÔw®±é•‘À[â,g$Éã ÉŠñ6¼Òˆ­Dv³Å—Ñ*ä¬÷è6މð¥–mß‹{l/hÁ4â 3`(®€Š°Ü>0#ìajã†ücs@ƒDºPóšÞ¸¦µXÓMGÃ+^èôÆj•He| jݧZ)_ ËEV÷ÈÃ`P)(ĈÍ>}ê‰ÈÒ 4²(frõ’D|Á 1Ow_à[€~–#ÿMÊ0±÷²pL×âEæV};÷]CÐsÿ%U…„(f!øejq ‹gtÿ…6!oŸ•tèwp(naQl÷ñJ€ƒªçJ@ö&Ôö$N„K.ˆ aXr‚`i6•cÁ-¢&4‚äx"Aާ-²Ajòò_¢A‘7oDXx¯!ó Úâ7˜zµQ5ø&L b$×gM†¨‘s :†Õw{Çw¬Ó-zAôµj«Uªa'ùÆx~‚ì´dLG„5Ñ®¥sƒ3%7˜lŽk{¡è‰Å˜wÔW}âEs!Z´…U…MFˆ§1Û÷ÂZx¢ -@8l@¢Á ‡kÌ+õj°¶vÆÈŽ á|^µ ÒG@³Ó:«Sõ…U”…7Q[V¸³ð´Z÷1äsŰ7ÕÐt–€ök3 ‡íÈŽëpwñ8ŠAèS…'z~M³_~BŽ©v^ø>x{#:œ‡~R` èwÙŽ[@é&òˆ¡4SµjѨŠM§…þˆ°ñG¨†dØXŒ^à‚4°èg4ÙŽ¹cñøÕ7:A¡dQH“†Œ÷ÿ![è;÷Á,)•g‰–ÅÈi••áMtÔNð$_T÷¡Z÷v‚”ˆƒø&ŒŽi ˜YpOww=vslTO=!±Tt’†'‚p"):äx2 ˜™©™u7dÉè3à;Ñ’³s$…¸™ÿð—žÈ‡ÔtR0è‡gšW”Ȉ•FåN∛…d|˜tKe’I>1®`™µ9@‘*ùe‡´7‘ʉ‘[F…G;‹ùF!ÑF‘—Æyt$0$æy çù%ø$žèç—ÅÈ<“M°f €§1š-h"ÂŒ^øsŒ _£65y9ÿªAj©±7å91$pa$†@`ŒŒÅ@†³Z×”“ÁA­ÕTåG~J''A¡ÇÙžP×¢-JåÁ7ëI„‡PŒññZpPrŸ_Ɖú¡ * á—}´GzñÁ¢¡¤ qžOJÿÀ%ÀžAQ%£ó ¡%ðóðøä‰/ \ ¤ÿ@Œejd¤“ÖÈx„¨ ¡‘xÆ ®ÀPç ¥ª· £¢qa/º¡/`.ØŸhÚŽÖ™›àIyS²¢úfž{Чѧ¡Á=D`¨—Š©È’^hÉ’fYžêù§±J¨AQ™jªQ¨©Ö)•åy§f™ž}:©¢QÿBT«·Ê³zª»úL ˜{@×$¥FŒPžD¥°zž¡ú£zÎÊ«ÿP€/I„©š–»xiÞe>ÉÅ ¶7xª§bV§ê­%ˆ¥X*ƒ º:‡Fà’M7_€~˜GXŒ2…`$Q§}y®`¬Pç­ Áæ fÙž¥ú¬e/`€°€õ°_VŸ:š–ƒjŒ—Aç)fNú[¬Ú¯R éy S¥{²í9¥óP¥ëª-Ð †eE±ÙÒš”GС°¶¾zÒ•MGX—11Q‚аH uS°,Y‚G[°S ²N+¥z ʬ¢º¡[PÿS²ýš´ï ¾&»º.®.ë®a¸¥‡òP« W«ªDa©€¸Ç¡ÆPfô—m¬‡ÃAÀ$¶ ` €‰Äz<û«W»x²d‡D›´KâƒÈJòö[psÁhgÏeR%Sà|8ÿ¨Ðk2Æ· H ÆÆz ûZÁ»lÆyû gìžk\².K[Â[˵¶+³ñVAk%Pf*ñü ö@»¶f¶ÑùÄŠlÄóûApBsÕQÀŠ!€íQ8bj¹ÉkL2ÏôŒÈ†#çÀ(5ï!]ÂD9Q™ýJžæ©ËwÚ¯wJ¬¿Œ§L°|µ:¾1º¥€»®µ[pf»>BÔJÍü0ðMp-ðkIÅö/°ÈvqŽGÀ)ĸ²Q03tâ bJéÁŒ1kÇ$ÅK‚HÕ£_Æ(æL]RñóÔ)F&œcôÑ>QDáj¬ ;ÿì½ä µU{Æ]²]MÜÓ§K¨a»¬Ô¬pvQëçÖÐZu:Öü qI'`ÒµÅ÷Å@çˆ/0PÄs•êŒ:;DL¢1ÿ{+"Æ£EíF++Ý$¿ k±ÉÔ"ÙF2qÇb*kŠÁxcµ,{®]M¬©áÕgŒ°Â«Èl>èzÑCdu >…{»VWlòPlƒu‚ûCv+ÆÑÂKÐJAØMʇýÒ¹ÒaÀ¿ØOÌ¿Œæ ÊEÏrqÄŒkÔëˆOÜqpvGDÏ.%zb¼Õµ¬ÅîáÁ:,ŠCc»ìª,IÖë ÛŽ:ºkÁÅÚÿÁÄ<Ñ·0¾Tz¥?tm½1µ Üpí¬raDÕÂ[N m@ưkJñ¶âapÎâ,|ü{$7m*eÄ’Ý$ A¼HLÏ<Úš]>âƒ\×t„ð]RìÓÏQh’Á,÷aÕ¼„RVR§ÛK!‹ÐäùˬkÆnÌž$ µZΧlÂÈÝÖ~q]l÷pìGÜÆ-µFSÑBÿÐK@ÉÑ»öšH@Ê¥â+^Óã#€%|ÃkÀCÔ$Gl3^Éã£è¢Šuäza¹}Õ8$£Ê4VX-L‡ÐvêËÆ:µ ]¬‰'ÌâÛÕ.Â"¬°]Ž_gÿá1\Sæ¿}Ì-M€[–'¸b+8ÔG‚ð¤È-þÄ/îþ+Ù…SÀÈE¼ô,Ïá1¸2èž+:Mr’^mMmßZ”b–¾>I?‹3ŒªÐ^­7x =Æf,°ìn®YŠ¥¬þ¬ή±>†[æ Á~n͸ž×ÑB2¬=$^8èÍ+Òí1tqÃà‰<`Ä>½$ak–éˆ^÷ÅI-:ïm¹·gR¢%Õ¨-Q¤ÅðahSòä껼ºLÛ»Œ½{z·Ç ©Ü󲢡¾ÈÝÛ¡ïG@)<Ü£JÈÿ ÒOÒ2Ì,ʺ¢çPLÞ´bì/X®PÿÓ…­$6¾ãté;{Ñ©è²d¹¨€±•A ]¬íÇ’Ÿï%)fòC~òU-Lh×Kñ-2®*£îË{ºÐÚ»ËQK¡ÿzÖL;¾í©ÛõN»é›¾ÓïnæEßlÃeDÐ:àöà-¤2<¹’lOœ+zfã&ºâðõÐ ü‹£C­+!¶1…NrÏäÖ.–‹\__r³×D@~…ÚŸ·¿ÙÞR–€¹ÿíOä÷ô8¬üÐQNÖ ÛU{êeœÁ%{êþžj­¥&Ì´¢3æêùô7D@)<öðQÀÜN Ïý%0W£<ÏGÀ+áÁ¿9þ ÄÀÿcÁ ^üs€ƒƒŽ8 xÀÁ=j„’ ÁŽ'ެhà!Ê%YnDià€ÌŠ,ëý»y³æÆ™3 üûù'N Yº:ÔÕÏzrêdI#R©BÉÂ-Œ&te9áÖÖ­#É–˜GâÖ¿y·Ò¢,UnÔ#,‘g·î‘{Gþ8Bà/†‘÷îd42ß¿‹ÿÑ#ø!\&LøE døŒ2ƒƒz­F:xqãJÔÿ‚8è|€$D!aÊUæÏÎ@ R„HQ8îžBåꄼ¸Ó #ÖK>zRW7™m„ ‰ÿM%1õß‚]»’ǺuÙÿðYÃs%x‹k F%nŹvî~y(Yèí﮾ CI°‘ø:á±òi,Š|œˆâ'ì¡çƒy$ ÊáÂP{A  2ø‡D”¢•zxèJ¢£‹hÛèÜ*ÊÈ£šN“ë€Ø~’7à0ÒH6š»Ñ8݌ӈ°|ú©š˜Š.ÊzºòJ¥€Š9¨¾²ê»Ä´“± «»²¨ÒJ¿‘Àú­î«j$üö›k¯þðbA¼ø*p.úbɉ$h±>€ Ê<ô𠃎x!ÄøÓ‘öÉ ˆ…x(‰3Q+]­¥×Z‚ ¸ßj;-¢ƒ2Š-ˆâf $˜’ÍÇÿ¹„ºéÆ0ªÈ')$è¹ä®‹2Ù꜒’ ¤”üîïÛ¬[ÎdäªPú ͫƒ¶¬9ç”3.7Y*Á.<ûT¯üòsÏ{“4Ï%L4ŠÆr"„è² }µR Œ@˜ M Â` \ b"ΊˆÈ•h42G} Ö kå­Ö¨pëÌ“›ÛÏWȧì’ºéšò²Ë¦–ÂÉ€ê’5‹¼‘|Æ%²¼ ¯+öØ"(­Äªºïûà ¥?ÙÝÓÏ#ÈÀQºGžé±ÇP¢p!Ÿí áBÊÚ0R (-1‡„1Ýg¤( €‰!8€0Úd•ÕÆšl¼ÑÈÿÜ(ÊÌnŽˆõq· „•£–8ž2&‚’¬ue"OVÒºê {Ö9éœÊ9J¡š•˯ ñÁ…Û±Öë=iÕJ‹„âjëN–XH7ݨëòs¤þìê °y 2ˆ ä#ð1 *À‰DC±2ÌP £Ï‰î .P‘¢ xm x0ÙîUs…)ª‰üþ°p×ÜíòŠVz²¦’}½X./—Iþh¥ DGfKJv˜•g¥O•ùË?ðA™ƒ@P.àš¤ü¶µüÌ¥wAËK^Xò§=ª XKZ@Èücl.hŒòy d n{—ü"7„Éíuk‰Ã"–Iä0ÝH:ÿRÃ]nHØ£Pt•’ñ…V(ÁŸ®Ø^qŽ;zRÆ‚d²œ”ÎY7A –B7¬¡\1j9Z÷FïDw¤Ì(þ¢G<ÅE]AÛ »T<Õý%y9H…´-f1¹È£â°¶!1z€äæC”¡ˆH\኎œ/@á G8–«üùjƒ"áÌåö'²ÙK}¹J ¯¬C*ùÆ'&Ëßãþ·K^f 9^Šê('>jíû¡ 1€xjQëS!Ýõ¡…ÿÀH’÷.”Ø%úø‡>þõ(d-3°Ù!Â4•º5ŒûÐW±! ¡1RåŽì‡’ÿaD"Q±ÑfŠEœ©jd®cR²ó2%É)á_úN&2…9ÒI MºÁÀï$(é¹°7A–:mw×|&J¬˜’Ž$œà>  ¤Í2ÙÃ$—LrS ‚>Ä"–e¯C åä.f›ŽEåTÃåY…9ÅߤþìIdDvÈ8²ad£"-éüç›é˜µK}&æÝ‘àƒ+&huçül÷.ñ’K6øÍ›r.`û@>8›NPeh¨¢õÐHЙlS˜zÁÃXvÎDd" i°„Ü”%²±Ñ%VùÙ²GM_ÉH:* T&›K_n{¹\ôÀ½qŸÖÛž¹¨êC‰ïÖ;Ãò®°rÉËŸþ ¿kuÀ>î;ÂB†³œ•À$"Ì< ¯!+ŽP_M&ì !ü6S’ŒòDÁ±€±º*Tí$W„ë’ýb¬B´qDé%K€y¢ÍµÒ9Êýâ~ˆ¸)!ù ÿ,éÿÿ H° Áƒ*\Ȱ ¢B"âµDˆFü»±àß ?"ü³¡ä‹†.@˜¡Ä<%þÍû7áÃD78nÀ·`¼!ÕÄ¹à†¾$`¼Q2BG þQ8yCªÅ†$HhÈ@­&L¸ðB„ Vð«PÀ^¶ÿøý‹7ÐÃ\ óêÝË·¯ß¿€ãêC´@ˆ0!Ð(^¼ºmH FB&y‘VFæ‘È\Â%£™ö* }cƒªB? 5„1ª„¬),pÚjªmª7Z4ªT©^³J¨YSt|Nã²-ðá­@¹tçþøºõëØ³Ìh!"¾Ä­,^ÿÜ0 r ø„Œ6 ÉÚZÅf†À¨‹Œ üðÑDlPÁ?ù!õk†|PÈæ"XrÒR­,ào!µ¢[…X‘%–XRíTRQT`?'Fç\qy@v0Æ(cvùðSc鳂iBXŒUý0Jbè Þ0õH]yõÏ€ýÍô=ÿÐó H‰ö”JpÑpIIÀ[e`%UA“N6u’Y¿m¤aUÃÅgÜ%mPÔ°Å?ÏüÐÅ⌄jh_úð3ÂGîY€ÖESá 4£DÌDÂà‚ä?"1[‚5å'¥=Œœ Ï©óø ó´ [7€ÿ5A R°`Rü£Jb–¶ä½!!S?Ü•! z5U+gÙ‰ç'îÙg\ÔzèµØŠãsÿ¬°€$E°¤EàB¤Âs>¸§!"Y}5A~5µJ`«,°pªL¢¦*"NY6œð&¥ZX0ÕÑp†´òHºõ&ñ›Á¡)?xCü5gíA8]¶$—œ—µí¹í@ ,à²SX•æŽ"’aF&Òk,µô’<2½tÂ<öÌs‚©@ÿÃÂgþu,áIÌ›*qþå ÛøàsѼ‡ÏRýPVHät1kÃ.PÛGlÌ–Ç{²(·ÈqQÉxcÛ'Ž(¯ÿüO"Œàm·²9•Óq¸ˆÔ d% tÑ@pB 'è›o óÈÓ*=?ÿsÏ?G m NpækR¶šßêU²€yk.‹>º[›°ÂvoW´â¬? ‡H>zò¹§@v¡ü^üØ•÷ó3Úøqà¨,WÜÿŽÓERå´6ãR1“úP !dÖj -ÈsŸ©öž 4÷Üço¿B½tÄ=îmïLü‘Ö6 ±©o?›ÃȤ ðN+¼A`—µ‚ˆÛžL ºØ…:rûGòV½FO`€F%­=¥BÁÈUVf9*"ùÇù È3õµàîkÁäÿZeª{|îpŸÑ°t* Üãòpâ=’ȪüT.UaùÖ,•«p*kûÆ’’ 0è+f±PƲ«ÑX/nñ8 µò¢êŽq¹› ÷¸åc 7`@àâ¢A²28„ Ò R 6j$¨B`°´j.)yQ  @R¹JxŽ1àœ¾4Ç€ ¡mžâYÀ˜À~­†øX>àÀÛ2ØÈžØ’êJŽÿ€áÈæÒ¼<$P|ÌfClÀÝà&ƒÜ„°‚2šŠŒ¤ÚÉ‹ø€¤¾ÚW¹MjÒ”®4%ç§ÿJ¨ò9@þ‘J@‘h, %®fš $šºDÏ(&:Ї‰ ¸#H 1E¬a 9NÛ47†ÌÓˆFª‰bS›Ù’#72ÓçüqP#"øaN~$êEXª²ó)…Y‘y¤I¹y@@K³Z_¾Þw4|¦rŠFÜ@ÀÕ$• Ÿ<>#ú± –³! DŤËÅ•Èpm#ÖD—Â2ËÃU‘ °Ð¥Ç«[4²º‘yy ,LK†²šv“¦7ýcFN},ŠœU)ŠeT!LÐ,&\fþ«+UsR*b*=ç¹Ï‰ò\¨Pÿøós¨JèO  Œ…c¯áOl¦bQ\ª]bë%"4ziÅŒ¼qØ×x2š 2Œ¦R&ÂçÜ- /x§µØ è Žéã"ÃÀ±°œåäT·X³¸É´Xârè;i…KN¬gX]i#Ø6 \(mWù¬–R«¼åX" $z=MC?2âš@«+¡‰³‚„Åõ’ºyºî`!´]g/§×»ž] ^ð–—PÇó«u²^jÝ”¦:TFtÈ ¤#"1„ºó`¡§"óA ƒJõy¸œ;•( ,°•m`›W”³D3~F÷Õ°êÿ’þáˆÌ(’F¨AL¡€5ÄÈzÍJV?`XCΜ„ÝîtPh­ðÞ¸Pr‘# ÿÆ-J³¨Çô ÑÙ­ŽpŠ7,zÐóHFfP_fücIù-&6s—r­Æv¶ h™ ÄA J¼ŸjL©4Læ§A‚¤ØFR¬&å¤*]‹€ECò|LЬgÈ02‚ʨTš±±ýd¼G_G;.º·É#ƒYo]Ö´Xˆ³ÝɳnI ¬ÏÊó dæöÅ*«˜À³%À© ,[ŒyÌë,ýf{qŠP¼O þÅ ðÙwÈA“o"]¸ëÆÿ½ÔvÊŒDó›8éö <0Ù•¢·Æâýãxk\½xô‰.66·BÞmÅ® ÓƒÉ)„¼uoñ¨GáØdH-.NQÀ'%¨2-·$(ÊK¢ô'A»<[4‡=¶É€ žDW¿K@Ý(§º4¡Üà˜Ò(€‰¬æþº^{Ø×8`ƒv£‘áb¢"M˜/"àãqØ„ è—ú^~Ê­­dš ~Kz9â2yd"ÃbdSj!„R“ÜóxA ôõ ;sfxAQ [»/¡ƵÃ×Vþ…²L¼¾ ú{,­ÎuøÀ…Ç}gž +Á“+dÀV\`\#q†ŒÿEÀ“ªÐm:‚¦K©…óñ²¨Æ4ýyæç?nÍ£7!3¥a ä2 ¬ 1 ”à6›Ò8ýöùRe6 ×?ûc[¸–p©„|g7[¥k¡pû"•wKÔu@c?—ô†@3Ògå¡+Q¹‚ÁS)`“@¾‘r\¤;ãrN(t$íGcâ^ä•EhOÂnƒÒc>Eñ…S!­ÇN%Ád:£8\÷¦Â”Ô…A£/[VvôãDV&ú|³%|!?¦4‚¬õf]÷DVÆ:2±P7€ × <3L5Ò¦}5¾cx6Ã$½‘ƒyEÿWG{Ò~ÕCM>‡M—'ÓÂ'HHG1(ÊCis4h„±¨ñ o(‘!Q!.LÖ Ñ)©¶>³GVû24X’J·å>@Ä*a4¢T[g[«:nØ ‡/O„[k6ô0/Baà}£]1LRæ%9‘1!!F\ø€ Àˆ¼!HЦzÔhõgM7U‰;'=æsð§y;ö‰ŸÇcÚEŽMÐuŽÒ=BCÐ-%Ñ#á°âoô¡>WJDdDgöfü21 4÷ÐJ¨q«•UÆç9ŒúôDU-¹²’e±×p ?QB:Í/w'mßÿ¨!ÿðµ°awŽþGhÚÃ<ÝGÕ~šCXÑÑs2‰ñ sš8Õsyù`Ðs^•fi9ÒmÞ.­G¨×$!ãSjWèz´a!ý³r%"èIº¸e®´4ôŒÀ9ô“q,À—föD÷k@´D^Œlˆª!bÿ ‡øð$Tà bbºQÞèzB‚ˆ)0är×#ƒ¢GÐtMîQ9}BydšWéhòxšLyyGx-5‚nœwMqS"°Þr@ ‹3 œ2AF¶ vŽÄ› ¢ú‘9XŒ3±e…i%ô hˆOhè?2QV¢4@ÿ´?¾ø3÷ Â1Y‚ BßLb‘ÿ/#6 ðbÄ“ä8 ›‰H2¤i„E-$äSÞ¥w$•Ô”š¦ùÓ"(“Hn ••˜yÏó‰?&”5³A ¿YЀg+ȉœ%A¢V/¦XÁõÿãÉ?h(£¤9Vb4ûBlÀ–*¤B% åD‰†1†Så/Âl–0ý§+yȇÒ(xFjSjTÑKÁCŽqUHƒÖAŽ(¡&À6¦s4›¦iÅ‹˜UZö9¡34G¿qGl¿FžX"†sè¨pV„A˜qªÀ Y­ž†ÊrwÒEŽËpx?pŽ;åS€‚±·Jš (Wé]M©”wt=N tâsÖô V"{Ã]rú¼¶Ô#4ÔHù¥s¨±¢Ã“+¬²%”vØŒ@EÆ×­%—»hŒ ‡D§ô9`feGÃDñzD¸õ9$Ø*ûôeÆgãTýJ:Yšd~ Ö­° ˰ Wºƒv1Ò!•NIšËš ÞE2©ùc³)=Ô‚Lf§$.¨LÃAAI¬ROI㣎ÿ :­µO{JJc*ék[°5v¡ÃÉÈÄt¹O÷1:ŒP4ñ* …["®©!À¶Ñ=\Ñ  T blxœ"!;!@籉õŽø×~q‘yMë7¼lË·8¦'%Âcz îfS¹MϪ$‘Ajµé“Ô¹:ðz*úš4–|—êÈ„é9¥ÄO\up;£üɯe‘F„%¢Ó¸GC3†þ5NÕ*ôQKÛ#‹á$›‰a? À?âP2ôÀ5v7C¼Cx‰<Ç"¨CüHM9‚sáV(ç…#ÕótA<%Ò7Ý$=ú‹‘‘)ŒcAMµD“ ¯ìëZãlvJfhJÍÿˆD@¤e»çOCl‘K—£„ÉïÓ*¡aõ´9â:­3Ï©BI¢6“ÉVÃ%ÐÅEÐ;yŽ ã¦~rs ÝÕw³~áÐwãÐLyÁ Ç4Š šA¡•Æ“AÎtÖm=”­­'}Iõê³Iù‚ÈOäJÌe!Ø_5EêZãé9:mÉôsŒôCθJ‡|4ó ©Â9— 4C#”ûâZ9”ó½yr>q:ô¹,“@a¼À;¹ºëÁâ&cúxœGź~r´ i»^c½Æ2’ÌO’šÂÍëu=|;â¢$ÿ€$Äù%­ÆÍ“c*9LÄeXkÈ{³†J"IÄ3MP³ÿÅåÓ®¥p= ¿óÀ9I¿ê¾›¤Ò1-ŸA91E3 [ÁV¦ Äò0¶;Æ»1²"= ¼» iÛA6B®ùÐ z¼ÙÁÏÜ'Ì4 l!á72Ñ×su~d¾Á¹UO[†Ø`öUÿ0f¡Ó³åDÓÍZ0Ê ã}D\&?' DH#?0º¯óІ¬öЉ/üÒ1H®Î ]Ñg¥ÀËÐÚº‰BèÁsÜücŸ9‰i«ÖúPÛLÌØQ ª'zòGyË'Ël´£ $Ÿår—$‡bVz!|¼Ó黥U½§p>ë£eÅZ—ê³0ÿJ±I›9”—Dd?M“5¡ †Â5\»$ˆ· Ï0‘Õ@ø™kàCç»ü¨~ G[­”uû”lvŒi̪¬x¼•qÁá“¡Ü¿!&-Š/Hݨ»'©„M>êOµ?'ŽâÓ™O®žI3JˆîZˆMlG$—íÔþb£ãI7\Eþá‚,’¹^±&CР¾ ¤»&0¹ ^KInަÏdGBÈ ›Û:W•»lêõ¶3-Õcájî« ç«Îú›°ÈgÁŸäøRVÅ>ØØ`¶Zü”Ý\fDè:v JÐ?ë†=®´ñCû"D—d%£S*ÿ%31î:ëW¬Áä‹”yç}bü Ïà(U^ïZ௉2õsK?GWY¼½Š(µÙÌŸÉ„Á½àGÏñÑ' Ív œ]¤×—ùrI@Ä®²æç*N`¿fÄ5]Éf6Ä6-žŸ4M`ºí#í“÷=,—U…4@ô®÷œŸÝAŠEM£â⑽å@¿ ø€H€"à”¨Õzñ”L‰MÆŒ²mÁ¼LërŠæ˜8(^#{“¬'ÅN±œ;”>ß”tɆ(ÞÓZå£]ÉØ}Ɉýà}Ó@³÷ÿðC˜ƒZ­’÷8Ò>ÿ®ôÀ1ÙÉ%ô*„œ'ß:³S‘¥ßÿ˜rcôZãm€rïäO„½\Gè ì]³ÝXq"IÈïÓR+S„Dj\o •8!OÞ?ÿþa €@…%þ#@àžÅ#÷þQˆAãDŠ 5ÞûhÑà‰óæµø—òß¼!d† ·ÒàÁyôþ@É‚åÉ/ç} ÇH¥Ê*_2bôA‚> $ 2dˆ*¬~àÃÌë²gÏðµB„h?üâ©ý¯m[~ åF\ 2Ûq#ꓯ¾µó¹[ø¯B½óˆ»Xa¾¼ŒóBþçx¢^~ùÊ®XÐùŸ¡_~˜wÓ࿃6,¼@ÆŠä ˜(;$ÿÅ‹ eß;©’½1+ÿûPùCˆ•(sßyò` ÏYtÁ¤ó˜†ø µÂ?ïT ýÃÚjk-d_ÃŽºAaÄûÀlÝΗ¨ïÜñëºåÛÖïüþ"Ò«.Êêâ§€Ö ©1Äîú‡±|P1~¾ƒ,³úBäD$@.©¤Œbáž#NÛˆ¢Ø²-¤{0È"o‹HÚj‹(ÆŠNSn¦òqð±|ìAn¥œù­ºçNHºèäQ’'žœî¨¦© 8…*°R‚ª(0o\ÒS™8D„4Ñ”ˆ°5ík;x ãO!þëï¿{Ë>\PO¹- ‚>¿«lÐ>õdÿŒ²¸ø)ëJháy`ú IÓä!‰¡Øbûè\ÜÆ¢­Æsc1¢ƒvÊ)!óÑgV %Èç8šŽÒ)¨xR¨ LQÛÉ'ŠR»¡šúàš’`§ ñr+¯¾F¡ °:+Í·ôÓ³®½þá Ï8MPhÜ|\xlMqÛâKÝÀŒLB?õA$ܼÓ‹²‡ÃÁ4 ¸kлÝ7¯²<¤Tž†zÉ &K䈤N;íTQQ É6Û8Q!’Hù#^ƒ®ÇYíED„Yo’ž^sª®¥‚Ö4…еYžéŠZög£´SZi v™k–YæZ`ð13M5ÑÔÏO‰îÿ°-uéT7Àq‡#Œ2ÅÜŒj|«¾lÂCT›¸ oQ„ìBq˪`êƒxÆô4Ø*ÆQUp´7ÔR)¢äéU¨ßb’uVDV( ¨Ž#m%zPâɺJ<çaBèX¢&°'h…T‚ )i)øÁd’¶}i|´­jÂàäç¯FÃý°·¼–sî·\ˆóÜxâÉšÎÆŒŒj@ôw¸éÑ,ŽŸ14%Ôà>ÿ©|Ðè mYF€ý»Õ‰=ªHTÙŽTOY¢ƒ2EÈ V=zŠÎgÀ–§:6±YK|%º›D!Ð9È”õ’(eg˜€¼ÿ|ŒI îÈr&¨ .ñðb.ã-rý#kê‚— òƒ5±Ñ‰2€! câQ>ê• lõ¡Ì¼g½Äã;2Tf“&ÈhiÊœS>`â¬!³H¨pã¢×H$7!oâ84¶ “™B¸ó˜Y­`0Ëôq«št®½JÉ ªÃè ä4ÅBÍ^b³ D'ƒóàŽoð¥ji¹£€!¶µ-ĸ%1iù[ƒ§s½elÅ %ÖÚ’.¸ä 0ôZ^‚~w/ëQH1ùRÓ¢þ•§xD¨_²‡ÚìÕ™9&ÌRAJ$c"Ó ñˆýHâÌÛ0s$ù”“XÂ’ÿô1%ÖTˆN€Ã|Dáú €W@PsùÈ‘\Ò’•D©%Æ2tr椄Î4Ù™@U¤Õ Љ„Ë@F{Ê­ÄÄe-P'«79)Dy•‰Óà5Dw’M>”Õ:Z™‡Î‰mcŒ¡ÜV(Èl/Šøe"ЊE ˆÔ¸ÌDd ¦39²Eþñš~ŒˆN"“þ†&à Á¬D G`þCŽ$Ê‘r’Í•À3žÐ¡`±2È3%e¬Bé "Ê£•Q¤GiH#*ð4Á²¢ì »U¼ÃÐI†Î“aD pQ65ï] ÉFÁW7=}´_ÂŒ÷–/4ÿOXå|àÒV¨“*ËšÀ<"…©¿e„šÏ¼H‹Îh¢3¶ä93³Në¼™T7ÊDHÁÌÊþ±€W,@ŽR]ñ‚ü&0‘YJˆD,'D}ëÛ J€ƒ( N1ë´,Â&mÿ°À 84³Œ /úPË*×¢Ð6V"ý)aü"—Áð%¢£¤,Ũ}U¯w¹Kqv—¥’±¤B†ìµ—ÎñCè—¨’b]§$"-Å8*ÞhJXÉæ Œúa¥'&'ëQÄI9(„‰gÎi¹;"‡&GzIL#”ãJªX:¶§è˜{‚éj©º¸nZ¡´küƒ=îÿ¹?Ä‹~˜Àš21ÓøJ9N´=Šƒ+{ÜŠVÿË"}Û´xÒ*Î÷+|@ Jø@·0žIÿÁ—u+\M`Ô¤NŠ<‰E3çúñV±Êdw]|¨iÿØÀwÃk–µð"ÊyÉM=<™¹Ø†ý‡¹òa®þüÕ•˜±×‚ˆh½¸ŒO2q‰P–£¶\’TBšáŒ\úÌz›Y!0ÊëD„©zT¶¹ k|U ‰mÂiWDê½[‰¼â¹Í÷ r{ö|Åï­²eÉäÁ¤FˆŽ#«„l0Zþ4ÏìD(I`Œb7ï{Î"MâÅMš\á•c—Šö•¯íÛóøº<úb..š_ï\†ˆ!‘FĈ†’LÛò¢s4ñ73A°\ÿRD a¦!˜@Bæbº/÷Jÿ‹?úæUZw÷º¸¼—šKdª°ô¾÷[è«ýWÛÍiÀzsš;¸2u€VŸ” !ÙYÅ=øƒÙeiϸ>_ø{9™…&'f‹—Ã|ô¢Å› Á¬á+€!¯RJ¾‰0³uI³‘3´‘3D™y¥×£„¢ šΛ(™#‘…™×Бåø{Љº•!òYQˆ{±‰À­Ûz…‹è{€û· X±ˆðKósœ;Òœ¸; ìPb‘§'ÑŽ|è’ªè»ø;Üñ.Â3¼h¡(ÓùеŒò!º‰03¥.£“æa¶¸à …2Gч%:Ãÿ¹` á²}y¢^C1¾Ò3=r² ´3:’)p»"Ò@(1Å ‰Ÿò…°‡E46có‘v±-©RˆsRU˜Á‰0»\€ËâÁ£K[»Jk;!¤©"„R+&y˜ç*¤˜.C §!ó»#»†¦¡5+ü‡´h¡ùð©y/P’¹,Û¿bK³ÈÐ$úŠ/óq!$YJŒDÌ6B¡Œ#Z"]òZ×3  5C )¤¸T;R•Åñ•¢ ‡ˆ,¥ÄBûÚ-\¾J;<»éóû·}ÅK»4s¢J ¢’•`® R’mR‰Ÿ‰/±€(¬ÅÀ¼*<‹ÿ¼¯"¥ck¼9i¥¾ZâÙ¡·6“+¶þÐ ´+³I(È¢¡¶0"~襜+ï!Ÿ¡Û3+#‹pì,EZ&.#PɈÖw’â€Ä”ûJ±LJ´4„¾K»´Eê»´€[>ÝʾYù™ea¤£ ÄçZ.S³ Ï¢®GºÙ©…B\(ÃCNj9’óEµ“¾œ½Ú?R‚—P2º0/üB¬;Äq¡›±[Ã͘¾ê‹€~œÁ¶›S” ³„ ¢:N'ùIAŠ ˜. ÀO"º†õàÂK“x9/âB7|h8²°ÈI©¡šQ²Ô ›åùÖm¼ ›÷BOQFÀ<"ĘˆøŽ‚ýÿ#jÒ¸` „u»@Øâø¶-U}ÀO €”èh& ¸ØJѦ4ÁãØ:,ɇ§H¹(Ù“}±sŠ´ uÓJ#;Œ>kýĈ ÙÉB à4\AnÍ\¦[–î]¢Å…ÐÝQh…I…2¦u“¥`"˜œ<Qù¢@¤ÒúŒ`2͹CùŽ^²‡HO Ž› ¨O Î้·ÊpÒ½]ÛšŒ›ÅÐ`Ç›¨u7yÀ€&‘å*ŠíÃ="TAb­ m¶•´6MÖˆPV±³47ÂIãD~¼ÁËÚPO´V”#í;Üý³tí‹ÅrEh¸†f8Z`ø»´T@AÃÿ3å¿Ìˆ!Š*6‘¹ù¡ù¡F›y`™Éš B‰72Ýàõ,2%©–Oä!S×ä"*[,˜µ•›×ôW{Q'T|¼1ˆéD¢8h!Ë»•P2ÖR’Ê{QЩ¤Gñå­ë3§•팬¸~¤3~›‹>ÅœŸaD¦T¤R °R£„“}0>Úg¨Ë³Ø–æyŒ`£мü@/´cªÅc:Ùฉ AÆfA^DÑà™`vÄBçH– p6Á! p.çUŒ1+H З¢¥«½ÚÓœ¹é‘v§þ8e©4Ùduå¶«·²€´•Aèå3»­ü7é+ ÿ›Íœ7" ÌUÚKÔÊ©@Ї\ÈP0†QhˆG©ãÂâÚ¸YAþ–lö+F›>ÁÔò”ˆµÝÛÎ霞ˆt¾i‰(ç‰X['ØÛ€‚‰€‚ ö‘ Åpœ©,a0: =¥ûÆqÑêBÖ¨¬Ä{ë-ÌÂ;â´Gûº§2' ¸‰¶åICYvüÜËÙÚ{ D !JxÈ…(é^‚k¸\ ‹±ã˜†àujÇNê@ê¶æÖøæžê¢Fj'€'°¤öl,ê£6jTjÏ®CGùF̲€sm`0ºVh…!¨"¦Žë¿˜ô:‚ßËÿ;Šk™È#ÁízKk ¥³®œ‹:£bPŽ ˆ ê*'>¼€{…"pvK€îŽNSiLÅfÊ~l¹lȆ Bjõžéˆjò {PøfD0ÁúŽï ¶ïwVoFüìpÖŒ¼v=£†1†ZH ¨¤3Eä4Åè^…èFez³;  ¤"µ”Ø#£R4NË…e4§ékk£  >a6Èe!Ðh©"£À±»ÿÀî lh°€jïñ&o(Xo —‹u®o€‚"'òù–og”o%¿ï`ò‰Pz`r{hý¾ï6¨òù¶r ï&ú.d¥6AGY ŒNwmÿ H…@p!©¸6³FЮûÞ!î:ȱk’‡&¸»1“/q4òÅAšµ€K0tDñ0 [!š©o4q!ø‡Kx…WñKè^¨qíc!`C Þ`ÏŽlÖTê§ï'÷éû¾o#W"wuXOu…prWŸõÑ6o[Ÿ )ßõ)× üžòÚu[v‰ r£ªo  ‡dÿ Øõdoö\'önªozÈr{ˆ·WËfð! ¨…Z@ºÌÙ¯!4k”yŠ@Ÿs’­ v²½ŸØ¢zŠ-“å­HCî;t~7t~Kqùý™™š ýÝëCŸ4U¸ôLïpc\@ÿ#Z[ 6õž6ò[wï'÷ìú–l /ò[¯o0rŒo#×(hv ˜ egvdùˆP•—y)ùŠ ˜ Xy—gö‰€v…Xy‘çyúi7}ˆ©m«hha@ðZaÙnô¦D÷üÜÜ—àæ#kâ#‡îRbSS¶Ž~Ÿôo_*ŠØk  ôI{UÀô^ø…6ø…_chøkoù6õÓnïVïxü.íÁùT'r…hu¤nƒú–|‰Hy‘wü6 z›ú'zèðŸ—y‰˜dŸ ¡÷üe}—WvÑ_y`—ow#§Ø¶`púZ÷Z†Z)ÿ¬ôǧòÞv÷x åP*…`4­wAÿ:sÂ-µ¸Dß÷¹çëéc« ¬àFaØëêVð§ôL—¡½¿„k€†hGÁ‡õWgÿŽ?êþ~üŽgü Oyf·+?ýÒúY P4hP¡á„ ügP!Ĉ UHÔC"ÆŒª°GV,†L“BZI¯‚>˜.óý“ ï_¾8óéë©‘>D ?ä a4Ä£öîÄ©/Ÿ‹ž.DP­*bV (ù äõ’…K`Á*¤ôoEÏ|>H  Ò‚!Bþyý÷JÕ«^b:É•ëÒµk>س§ŠŠÃÿìÿ)Dœ"E… #&ŽüXEÌ–ÿAIØ¡1(ÆTƒhð4Á1 ZÌxâ_í-NÞhcm‡õ­yR˜0_Í| ³0¤¥Úä4Ÿ&ÔaOŸ" æ£Y½:QìHCT’/W¾(OõåŠþOU¬X¼òJIlX åÓ¥´(O¶ˆZ Á'WH]—¼2à?½üsÉ?¿¸ð `×X`Ha†AadµÐ…ÿdøØ†°9ÄPcq”˜l4ÐBm–ÐE]ä‡*\´bBµ½ˆP .Þ¶ãmôØ“[p ƒŒpÍ #ˆ¬õNü¨õ”KO]WÝMÑÝÔ\tü¤uvÿ„€PG}éÿ¥QazÝUê½²‚{ï ßñÙw”ˆPÁ(—{bùЋ{ýÒ×%Ð\#…%ÆB+ƆÑC5¤bd'æÖh™ØÐh¨}HÐC²edcm¹]Ê#ªÙÒ ­XP‹0Í<ÓL-´¢$“ÿd§\N½NyO> u¥Pˆ•VNÿÐC²^zéx>…iT.6¥·Â+]}õ^|dyµÀ "+pFàƒ*+àÕK^—è…Ð/AÓŒ07T he0b¸j§Áæ/C*þ+¢‰*n¨¢ˆ¤/Œ‘A¶Ú¡FjÛª¡zñDù¨[##+0µ¼ÒÊÉ®šaL¢Lw»ž‡ÿUˆL'³2ãW”QÌþ3OôxGeOUùôOy֪ǦWa‘…Ð%îÝgì~®â‚Ëž„ë‚¿Ê®»D»ðϼÐÜ@˜aöLHcÃNæ)¦}†‰Á(PÀöÏh²ÑóÐ<•*+ñc<Ά±iÿΰi«bå*0³× kͳó<ó,{yψPv@ÓüÏUaul²—k¬yÏ–e%y:E—^ºí_B^…{­ZŒž{ú B.N|½  ]ÿ ¡ÀDp¯¢!¾Ð‡scöa¿»ýag(^ïöÂû }dôäxÐC•R¤=§Ræ!á‚C›Æ¶BI¬FÖÒŠ><Ì#ÿO 'œ ÿæÑ‚yœÀrš[Õ”xR³û d¢WN¢ ¬´`g i<ø÷¥r:ƒN•@·»ü£+bKB6Àõ, ÀÇÔü³BøÅ ðÚ‚´6 0ÏlqL¨ØMˆ|këÛ8šµæ!¥‘Üþ&E­/!„Èjþ•EŒ-¬‹çûbá`cô¸¥~€œö'{¬qÜà èaÀ¥ì*×*á±Á($E€LÈ 2ˆy¼€ƒ!h¸+NtÚËìê.¬¸Ð0D \Òµ ¬¹@xZÛòž |Œ-Bù:ßûJ›Îø n AŠ&Õ©Òxfÿ4Ÿ¡^CtÆ,/¦¯"skÈfÎ"õ¡ª{üzßÄè‘C„$VÀøG+>yáÖ¼¦53ÀøOŽš»zÔãÑP\G¡+X£¤3›/°\M^w•é(D]I|T;¬'”°À(¨6ŠX@ªÐ/°Ö†_$H/Å»F3š‹V0Ï B[ÂÔ¦)™¦ Â\ù–˜2ì w«ÑÞ“RF©M7§ê¢¾¶Ø>‰@˜GtH°èG/ %¸&Ø¨Í Rð5þóúè” ]Å>xÅ J•§dŽ€-PjÖÒ‚B²‚hdÎ"V„¨¢„qBhwV³`åÿÿ‰ª' p¥€bh.\°P‡êe^ׯ dÊÊTˆ3žÙ^ÚFô˜ì…‘a{%ûhzE‡Øƒ!`L)áÙÃYl¦ÊŒ¨‚¨åc?€ÆJô1Mj €'À`_»A8zðGAS—VþaÐr’'gTÝÐh›¨'eu BîâÔÜŸ”{Àµ€Z2OT%T±µ]ˆxÅ›W3€±Cä#B†u›= `™³}æmaŒÙ£ù"¦¾†UL£c™Ú°´Q+›ª¦×¯½¤—F´L‹ÚF¸ÌDÏS[ H^±§WH'`ÁQ_óFÿep ÿLJ¯ªT¦éžOåçÿTÃN ~ $:AȘҤr¶Õ.ã4ËÌÒ-Õåau \`ˆ‹¹ H»€JPr¨vùu”ˆÈNÌ&åŤWʈ)ÀbTP€ M(!VþrG¸Ü´îmÖK#Ø(*Ì—‘z0.«g›ñ«6> ?V@מ¶ V–åæ¡ÿaÄ Yÿâ¨L˜Ùóž\9‹*RÜ3&„≎&V¬”Õ©}Šˆ·ÌB ¶0¬AÕÂB‰»J¯ñÚ» `ŒÂ^¨@” åèz×XÆ2Bvý^‰¤wØÀ^Œ—¹l˜*þ°#iV…&›™ÉfÄ|^ƒ¯­°~6‰ a=ôÿÁJD@µ•›œ î×TĆÎ`¹ÎhKÔ%L×T£ TÔy $=ACAg•;fËÞ"(·¸uÖ³øxÔµ$ª1ùwõâxX+БQ â/áGzwÍ(ë(¤¿ý 6Nx]e•c¹ØŒ:ö?, ó÷:ûäû›f¬™‚t›Î9bm#ª M&7öÁ¨U+GË@“  Yða6€Ù쟼ÑcÐzÛXù6гøXF&D\×Úº½›v 8´ihà$]d|.Mg/ê†ÞµP¯°$>6pƒŽ†üHÈKòÁ,þð(À½ ð’Üú%)_¼âqrxÿ„<Ù-K]^óØGªÊr¨¨¡÷µ™Ì¨òùFè1~ê#~#QÝM D¨Ë"1½ñòT³  ß,Š™ZüÂMäQ§iKŽ]_}xÅÛáØ?€Kîlßù¡Úžd×ÖQœ¼Â/¼ÿ‚ž¨,>ŒB žú^¬ßú!İhIþÃá}aüÃÞ„Æ’aM„¡æ1ž®l^° 2̲• ²9OD<Š›ÍTÑE`ê±ÞAÐCt"’ÿ ¢ÝDZÀ݃ÕUÕYÓ‘ÌdE¶¸B8ÕnMUtüLuDDP4’n¡‹£1M¨ñX}¼BD@¸ìG%Maï„KœÐº¸4\"B+lÀ(üÀ @±pá?F#1"„!HDP,#ªŸ>hÉúÅÄæ}BláK,Û°Áˆ6îMdlˆÃ|–/Í ¶íȆÀÞ96 †øÈ¸‰€íÀ¼Öñ^å´ ÜÿƒJ¢"ʃåP ì\â‰= z¸HÉ• èüUèV£=Ò|A!\Dá~PÝ ™ … Ðâ %×?4¨Â Á ü@àýP€±Œ"°d1&Ôp¡KŽª cþ5Pðƒ1nf ê-ÛÍ¡êLeVûŒ–n$%R–)¥#­€íõÏÿ´?†Àj±Q6}àU-U%ä8µ¤Ý›ñE…• OÙÅéÖôÑ…>‘EÓ bDÒÕ[µJZÆE¬@ƒÕP…=udBÈZOµÅ˜äÛ¥dJþDÄaãaÞ€aÚÉ?0&cJ„J6æOÀ¤F8㛳ýdGìMšé KÅÿFêÆ~–iZ`œA‘.%ú#?íŒM%UΗ0¢6Ù#ÿðåÅy¤‰=­]”Ž?Ÿ¸DYF…¸¬C•ÕoÖNõMœÂE¤{@— Ä?Ð0]bG‚…œÖy@€”äùáC`f± Œ@dªä ÜÀaÒd{R¦c0¦gYf…¬Í­€&¥¾ ¥Žqe³,å‚6¨€j„äƒVØ#È‘<  P¾–ŸBdÏP ôIßSÙ…WŒ“YéÖ ÐÜY2”ob‹§¡è{0ÍÂÑ}ÄAU }dgý<.ÐW¨Â[ˆ†¬ÅPÿÀŽÂù¡$ä&d"D0>f}R@~¦$"ȧ|Ú‰cîgdfDÙx&™Î¡J±™iúäi’Ùí½©AÀiB„ N×Ь œÛž.ÝÎøB°›—üH°øf ¹š•S¡eY…‹(~è¤Kº˜U]ÔèCâSXÌ…xGqì‰ÔÂ?”„¬ƒ{Ô"‘"È%)4PXH€!üÀ(8é?f+D©~r)•biJr)~¦M£®Þçcn©—ª¤±zi•«˜BƙѴy„BìƒBÛ.5KRö¡dXk£L먨@0€H€Uf3‰kÝÞq“kñ Q0UôÙS{ _}jñÉÿ¢DÀ¨ºlЧD Ðž\Âi54Ã3J„ê?| Á )%èÅ+¨]¬ Ê.vœIþ"AY@*¤ç®Jcêª|&¦|"æ}b)°vé°R©Ppédî'±™ža¤ÔD8(ƒRDJÝ¬ÍælUØ·-›ôÔ<ð€!x©,Åäp“ U5…AôyXŸpª‡qBâVÁ™ÐÄ嘿âSxÎ ïDïG¨Šj3 Ü{éD¬¬­€ìâ\€!¤$ü@- 2ü¦a¾'DèjD„ià.áîdj©~¶³À—²0h*JÌ*eƒæ¬álJëhñR >=¬ÿÀÀm Á±~@ éLÐy“R¹kY]â¡ÚŠT£"=)¾AeË¡U‘ö‰|ìÀGB˜­ÂFÔN}…vEìGÊ…>L€L€ô’ ¸Bü€Þú¬ömašìbêç­BÈ*æ–§±Bæ±v©úžï–>¦ËªFx¦³5¨Ïn®ý¦bŠÌ¨‚ Ñh€¹ÀEPÀq@ÀÒ U¶ëÙ‘¢Ylíô©‹×¥åYFê¾Ü×"ÈõáØ[ÆxìÙ&,Ã&êG ƒ*„@ Ì HÝ€€@*Ô‚/øBÈØê?ˆ/a.#³g˜«—&D؉²:¦Sæd ÿÅÞÚ­­ „=±Gqìu¦©ÀäX±Œ ÏEˆOOÖ‚ö ³€ñùL–Äm€ž<“DŽíy9lN„@PÈ“Œ^⋚[Å+¾ÝDT‹ê®ÖzÚ{pp‘âèX€$ò&DÙ"ćšpªžÇPÁ”ÔC+Ì0‘øB-p/dŠï2)ïðdb¦F´,1&¦³'sžÂòªÌrÊÐ2-C˜-¿DœœŒp± 1K ˆ²TÌ_„= Ž(KkäH0;=X@Á†—­˜ë²šÓ™Žé€¼§= aâ]UºÜ=‰ èLEU0äëj &Æ …EíœpD=ÿÃ?ÌJÙ¢ÄÇ<Ã5GÓpÅ%”X¬€=L¥%—€+¸Â$€ Óð2øÂ$@Jf¦Dó°! AÛIÝn´*sá±.îO+DT€.cŒ.ϲF€[…®´øÐ#܈0k #(ËL#Ä<sÒ&sßÜ4O«@,à Ãý ÁL€G°îå0Ë/jIGè´³B ËšÜÅ]`…BN¤&:ßëËëôÕhõ)„À"ï282§†*áS¡è,"BQœ@5 À¸B=(ô ×°CC4TtBôðFìâK&D_÷µF EÑv_¶D01ư”.,Ïô0‚=T(M_¶Kk¶eÿhM»ôí…±0[N ôMgÙ4=0uD…ê­0ÉæøÈé<îG)%ø„šè`rá… Ÿ¤NÕ?dõo÷fUHj'[FŽ òÊÊÂ6²#ƒDÀš¨KLEZ0ÂÿÈu L€+\@|÷ Ó°/¤BJ"F/#@T*_fÿõ1¾7 6,¡B4I“¡cã÷­mDQ¯ÊL‡@g¯´LSÑJ¯´€ÏÃJO#0øÎ”v…*8OC¸0B+@ì ɨL„l޲|‰í僡¼¦µU¥>p‰ºÕSݾayôDyì_Ću?ÿëð¦í?„ïoqD@+X…‹W0b üÿÃAA=ܵB× C*$ÀÂTTùÜZyTù•où–g{³_FX£eJÄJÀô‹åw~ÛcèDes»tGDƒÿÃKDƒ—6Ÿótƒ7¸Ó!¯ÄZäÄæ† 1Ƙ:4(IOpZ{´ÉZöóZ§‹Bš‡u<rV§ÕóÞhDØår§-Jxª¬"Zð„ xÀNäv¿¸w#ô’ãµxÿØ÷HoL@–Ïí?\BT9¯W¹’özM$šO@«~€°·jM´*´#v1~ÕW¹}«9Z#š÷wFüweW¶ÍEDÒÖôÎüù¹Ÿ;„K¸¹+DiëJý@ÿÃý,IN؃E-ÆætÐ  –_¼ÌU´‡[õ³ìl G'’ÇwM° ‡Bb‹ðm ªb_Z…gI,쥮¢ -€\Ç×Äv@ÈϺ’ÿC=üƒ­×0ßÖCwOÀ?ÜÂîúËÿ³K¯B°|Ì4Ë3Â5Bì<Ë—tD|Õ¯"š[{BHûÑG;ª0BQëDä¼g)xºßôLWŒMŸ;%,pàÏL„‰½ÓƒEUÕ+àBmÓq ¶^àÀ×â{dKÓdËYˆr¦Å™x‡>(çŒH)RŸX/§ö\ˆŸtŸ ~ˆ«?“L\0~É—|˜<89Ê'¸Bz3Üÿ‚ô²<žOÀ-$#Œ¾çëyÏ+DM·»çŸùF-™´«¾¾²»®0;BÔô<=У>»Ÿ»ÔÿþLK=FH½fI×^u,…Àö²x‰ÀBå— à8Kª¤¤=Iª£äSx‡EÁòqúîJç¼.MZÅÅȇž+ž‹Iã?x@yå HÀA“|= AB49CÄ¿Z?\@rëÖ…ÿþ%¼ÅÑC†%þQ¬ã!Å[UÜ(‘!ÄB–,iè_…(WžDi¨É’T~HùoÃ9't4²#„Ÿ&!0šgéQ¥IÿÍk*Á‚0©ÿ(èû/„{Nœü aïÿ=Ðp‰"Š>}"D¬p«êŸ}¹rés!âWU¿ØŠÉVm¾|Q ®ëâîŠ_+T©¢téÕc†”LZøgÙ‚e†¯þEù*‚ÿŠ â§/ž¾;sòpu¡Þ“ h§ªå 7ÃTH\!LˆsÂC‡ÿQ$Qò„E —#g^Ò"ÎÕ2‡V`Òz̘ ]Š³Â…’löÌɨ¨P ß‰3TßýÒ¥M†  Dª…ªùÀn û¯+†„€æ}°:K-}[A®\Zx°z¢pÁ.ÄðjK¯¾ ì,¼Ë/ÆT‰Œ’¿³ÌDÏ(‰À³|øgb ‘|øág5Ö.àÿ‡!\ù§žŸ@¡–"qæŸÝ\!Éà¤û‡„ˆLjŽ=öš‹Î& Tª’ËhI¼/«[ͤŽÉ©½Þª(âÒkJ(ôÊœ‡Î¢Æ‚r ტ§+zb!VÈ',AS ¯¹B€°…¬B¨‹!¶T)­"30ÂüL°­{E(‰ìÊJ¢,‚SmñUSàlÒFȧ‚|>Ø ª؆¨‡¶@°­ÈÛþA„%I¸…I:î‹¢ûçˆåŽ`([lÿÑöˆmC:84eB%tÿAĤì`zwK”¾ ï» rÚ§¤;“ß.‡b=Ÿ|R¯#§.hEÿ!"@dWÿ¥Çž6èùÇMCpê„é !FEpáºBÎ%º(\ SÒDÕpÃ(Ðút­¶Ú‚‹DÊLì,¤VWÜyÅ]¤dZk­QW› €`G -ÈÙ†´ 7_–mÖ•à&€ J„®ÚŒžÛ–q»õöÛïôÅ%ëR‚×;îT‚i^šþ¡Iî&ÀW'‘üÝ»¤5…šÀ)°@ˆVVàó+{UAâ4 g°yZ¸çŸ%Z8acŽíúØ.µ,DìŸÆR…±ŠˆkÓÁ°ŠâŸ˜Ûz«ÔM´9Ðv-¤ž#ðawÑD»u×3{u…ø¦•þG6ÙŠ56•¨ª%ÞRHÿk÷Ði¢ŸÀw(î‰Ûõ¦.aZ ïŸÄSI¼’$¸ûêÈCÓ¼2»lsMˆÒ;Ó©£ÏS‚ì abý=Zð§ÞãòXÂ?4¦9Îyns| cB7AQŃZ]ë\ç–Ÿ¡jg±Ú]g^´VÐE¢aÀ F°«@`<ò‚d¼†„6ÿ8–ó–½[ØË^À)ɳÚÓµå„[C¡ÜOæ¡êü¤må+I¼h‚„ðX§ndϨӯŸô¤~? ŠOúf&†§"ú`ÃÎbÅMÌqÿÑÀåZ &ÜQ Ì ®’ F¨tp¡ éHê†!Q°IÇÖâ–øà³ÿ:•Î"i;¦j”‰Ñîv7šÜ€»Rˆ¯~$ •³1Ö? Ü, @ÂìUµü(ˆ ¹ÀFB‚=æa‰I yþñD.±ä:@Âu˜97ëS'\ä‰ù…&2³=÷뉛þq¿n¢­°ÊÿÅ ”äqtœ\ìh¹<Ð h)L碕²R” "ÿ±:Í5Ò-‘Í+ Y»YÕŠ“¼ëYªx'£Ü@ˆèßBÀƒºÆx4DžI†`¬!éÐyÌ¢%§—¾¹…„hjH È·ï‚]0åÒÛ¢6]bqniKÉÖ×Si~ñLiò—œìçž}‘q Àÿ qþÇœè¤cƚЂ\añÓ`@%*Oþ"$pYÙ¦ø‰¨³ô3f£Ù̈2¹€ÐÐJw¼ËdBƒ&š0l'§<¥+–VÊ*Õ&:üGÔ wÞ‘7 IN|y-* ¥si—”I>šÀ ‹mûÀvÒE•ÕnÝ”ŽPrF0ö«´r‚!"ªòA½‘çn¶ó˜íncK1'ð+dBkpƒëÁÑQâEªXéäèÁ$²c¦s¤I\,´œ1·V@«Õ $*ñ옯¿:¥7 ^†€•;ÌÍ?z=Ä–´ÄÉ,{ ¥jÍ—lICîÕ6ÿüª}Û¡—I•Ðòn¼*<àrÇŒaÔ "‚@ì*”¶§ç°«Ïç|måÖ¡51£¡Am*YTTV Ÿòç´zt*n±hœ‹;¿˜*†Ð1o™Ê_•Äx²1‰ªCâ‹e¤bIÐJoN޻˃~?¡ ¶Àñ´¿&“—BÒeó%ûIbæõ5Ñ<à3{Ñ$<)*}&€ˆ ô©Îæ¤Ç< Ü €Û$³åØÿòñg’©…/ªxHGP§CRÑJ— %ä•~ºlñdIfõ„n&h+h…¨( £ýÃ5¦®ªGÍÜp(ÈZõ2Š\â1ÿ‰ˆHx5övi5jYi"N 9{ÔFaû—&÷’õf•]füžg›ëI0ióÁ0£ì\<œžÁÝg‡¤+ä=¢,Ô–ÍŒAŽ$.`°²±‡蟆\™'-Íïά€ß¸‡Ùu,”¿=H¨þ‡ð‡/j¸ÓæiC&2Ý‘A$ðf½¯þ{ÐHDú~k[-Èß”X&éëïÒ»)DŠzûNøå'FØäý‘—ßà\#:íœ×v =Èu‚Çñ¿$Å+ŠNuJf.*¤B(‚rAë"âA6F«Â‚Ü\‡!¶Îë.È3Àe6†Ü*Oëfërf÷¶÷F£©dH¯~„íl¼NÕ€…‘/ù’%°@ •˜EïìG~ä‡N J „ +"$¢MÒoo¼o§ŽüJ1 Ïçü* Ù6q_VŽc®#âGNÌ'ôvŽç¸!0Gcn‹bøìa¥œ(Q.Œ!œê¬ö„ÞZ¤_†=æ‚&­$Æn÷ÿÆŽGãÆ@P¯Dß.‡Ïƒïxpȣȋ!rH7ËF!ž…kNÊ!râïv=|| ¿´d¿ˆpKHb䆉½^Q~–­="OþO(üD&ÏIó¾ÍÛþã+EÜ"Rl«€6rÞZgRôaÁœê^ Rê‚SÎ"žB€QVÆ«¾cÓv¯E´K† àíÀ±HðàŠ¯ø–&•‚Dù †!Z Z|ãÉ$bH`úR :$,‚—Ú‡$Øå׿e™Š é¾àØd=|BÍÌ çÇMÎ$Îøábîoçpëœ0絈€2f#!äØ  È©rFƒ$ÜÂAÿŒ±.ŠK0¢ ×".Fãu†BìB—Ša ÐŽGlíÖ.øL°$„ÏøJ¯ îLjä6¤¦‡à %Z ®à Œz"‹—ž¬MÈcK¬rðž ‹T‚$d KÑ™ÿ…,aŽKÔ£'ü$Îÿî/Žþ„ç%·Z€è.óˆ^Àêúb©"À,ZÇ/^`OÖÅÃpL-È -8<õÍ$(@¸je©BÎN3wÌír2Xr²àx@3Ê>mÈxŒe4}¡êá !JbI†(wÐ!ê‡'8‹ûB®;Øf%´ÄØvóË‚m '+8Ò¥B¦T'·bp‹ŽìÈŽ(ÿHr6æôa©D$ý¢¶ŽñK‚¬T‡ÜZ'1/($0!n€!ÆNì8æ!&?ñÓ27³”ì•ÂÑ„ïÖŽ@`äGjCYà4à8~ hC6Ô³£àˆJ‚à8ˆÊ$Òeðfâ¿O;Lj&ÀÌPn U1æ¤pC»d,» ŽÓµr·pKN :ÿÁŽèðH#áÈ&lÑ‘ÉO"Å=ÕÂGQg]ZF0¸3T.ƒ8!Ô“*ÈŽ]Ê^ Ô?CÂ&óÔlÒî€%ÔÐÕÀ:SPWÃÑ”nh(ë> Öqja"Y`X ÁGð†ÆL+IÂÿL5N­ÃûăB‡p(²Wq+…Šo ÐÌpb!ÀqŽNJôP(•þ8 Ž"°Cƒ‘²®ÚèÞLRT8Cß³dÊMö|”]Ô a9Í“n,$3IUpøô¨4:³3§ï–šÆ:Ô:O­c£$ iÆ«HkYÔdŸ§ž‡¼~ z& jT åd*NÇg§²ƒ&¨ÃNå4OU‘½æ† ÷fCƒŠ¨¦Ø%9oËDõ8@žVu#½‚údÞDòÙ‘Và€ÔÃÉ$ìÉ$¶îÃay J I'Õ‚€@G’@­³b/Ö»ðó€!Þvby’£XÉoÿ[éX’7Vv°”eeÉ ~ ˜Ë¢Ö_XK'K&r¶-Ôy-½téüº„hÍ5ÍÄ•\¢!­‚ÖŽ”¶Q Ài[—H¨€êõA´ŠÞ.ð^a1dLÅBlÿ‚AÓÃ<¨/×åT)À/† ä–m+vo_`oßÖ&6‰çG&ozQ5M-dY©•lÕLVYtcHZ‰X†¤`&N[©õTãÔm$À;LÑ~)N•ÐK(.hêI”ŒfÚ(þè&FPš“.èué•r(GêB:äS\¬T¬kÿƒŒ—GÉB$õdòº‚—AÔÓìÖ¶bÿCâdõmƒàoW˜øÞÖ$  J1v6pˆXZ¼V–pKq•< yÒ«}¶C~§ü´„‰Iîå'ÄÏ|ª$ãVÎÀZQý‚‚;¨­Oø€èõRîA‚%eRŒqRZçv÷ßþ­wÿB54õGM¢/C29-¢üâ=…b2euøÜ–@Ù6oax{y5{ÿbØíráZ|IveQöy’“dHеH~€‚¨*ajr¯²Ní7 Á ˆ¾ˆK!Åò C«ñN·!) Ø€üG.D!¥vXRŽ+žã-/8ceìk‘4µ‘„+õÔ3ëvT% dõaÿcu…ß–3mø…aX†ÿáyz ñ'~LˆqK6‡@cpe#† ‰­,‰ç×¹µ[ÿ·ñ„ö;bñ §ŸŸ!Ò!ßÏ€a+,lYrxN.#$žœ â鸢€.ƒ+è‚‚KƒAÅ“>¸R–]í…‚Uû8…™!Ü–…ôo¹›.4ÇyÍwC‚ ׇW-$–¡‡ö‹§Ž>™o¾¤;¶ÌrO‘ž¿hg5t•õ™Kø„Úb™çü‡ÎLŽœ¢vöœ ¢c1ؘ!¾úÀ*$Ó=×…¸Ô3¢ââ`‡¢ìxà¬S2cÕ†GR{÷öÿÁm­ó…ÿRz'ã×1‹U°Šõth슕°)9°¾#’‹²(}Y üºƒµ’¸;” 7o6©Ç#}(ŽŠýå<öå³†ó © >&怡*$œâ" ¶$ Z %»zs¨QTv7¸¬R_Á³%ý¢=Ù:ióÍìÚ%–›™3Kz@ï†û׷ȆBy[°¦[‡{¦BYèn°¼û†`™,›ƒåW³ÃožÚ¿Hù·(žÿ·ÀÞO(ŽS. SWç|NŒk4$üäÜ/†«JØ¢£û²Ž©Möصׅ]rì„õ:I«Yb¡z©7aÕ†ñy:ª$† £v˜XvXˆްµ{ÿÑYmÎázH¼-»Z‰ûZÃ/ŠªH”ùÀ>ÎÍÞ›=Ú‡‹×’çþDÈ5Àµ…¼¶„±+z9(u|=C¢ÀÙº¢ãÂZCD5¼Vu$)z;¹§·…c²Ô<ü;Dö'Ž}[‰ÃMµÄ…øX"eénù&;B Á¸x¼äø†¿Êgså÷šÜÌ'Ä,&FC©9›SÈÿdÏÄ @ÚÜ|¹súBƒ-z(D@=C8뢷׺Sû‡Jà,¥§†§—!L¤‹çV¹dÄ¢»pÈoY)y3ÕH\ùè¼(é°Õxe¿0 ^ŽðŠvsË/æÜ›=>û½“ÓÙèbÿð/èX;,œ»"+Ž‹«4•/ú¢˜9xÓ´x$ëâ˜Gœ] ¹¸¼tµ¹{û°7“nÓ®o©{ˆýåL©âÕ‰%Ðñ•æîá"”·ãüâ&&€šK”}‹HJÙd­³ãÔÇ2‡ªöÌÎÜ+z-å·8ÕÒ…+ë—£#ŠÚlÊ9šWµcSZn[o»üà:síØãÇÙà†âÕs¨£bÝo·Åç\ ª•%€Ý¼‹‰%Þy&ö CCû¦Þá ̽#¾$TNÌèÛ+ÖõþþÛêÍ?ü$ôÌ¢ýÈÒ=z4:šäe¦=ýB_ÍýŸ­Ö¯§÷ðöu5¥S˜!ÿ<³V9ªidDyJÍàn(J©•D6ñQÕtš‡já§cÜZ1; {s$°ñ˜¾ØJ}ÀÒá±Ã”©>æôÅ\¨måÙå¨?þÃÚÁþ,,ìSDŸ6˜ƒMÓ1ýÉyTpÏsŒåíïïöêk›ù*Ôà.‰ ß_DvXvp‰äœY­T‘à§9]Ï‘ÉûîûH±òu‰$€­nTj}öün˜üM¢<È$'H‚˜ôå eê,î¯9û,€ ÆÚë €ü‰ÜŸBŸ>D"þý±b¢ ü·чÿô¬`ñÄ/JtààÅ¿ ü{aÒ®\Õ3ÈÃÕ¿—ÿi1XïæLŠ5yR”ùOçÛõÐä "•¯eË|9ý·ì T'ú¼Š5+V ÿH0dèBXC_Å^pg…Òþ«paÂÛ‡¸úL«ñá…ÿêêÕè¶ïCˆÈB`bÞ¦Zÿj !¢D.¤Ïk±ý<»½ðHW™D’2¹²R=<erÆÁÈ]Œ;ñDÓKÈIU uÓAõuÙyWc‘ʼnÄCa=„ZÞ]W[Pö5—^kñ×WX]û©ç¥òÉ'kÿcˆ%hA•…À g˜ý“@D!iaø)‘fVä™A\AP GØÛ?4š"Kõ¼”¤FÚÈQDá¸ÓŽË=”r ôèÓTØiwiÊ!ÉÓyZ…å•ûí÷^ûµE«AZ¶uѬWÚ:+_b~E•kì}Ðf¡•ä™EúÔùh¡Uh!A{Jû!ܾÆåÿˆî¶Ûmæâö¨A@p.õ”ê¥ $iÔ?õfUo¨ÿ¤ÒcT!ïv‹G¤«à‡í•WijÆek`ZN¼VZké^ºJP¦·ÞºvlÇÚól>)W” Oú„ÆÐAD"CD¡>|±uìló¼ ÏIGœûhºÿ°)N@É´¼ æ˜C÷t‘ $EêCSQU°ª† ñõ×A…ý«bçUÚU€Ä—³êºW\bRì“\íAyÁ}·WÙ-ôŸk‘i­ÉÁ!Î{¼PB)4PŒÜÒÉ—=(x˜HG,:ôG=ÚÛo¿ÕãÒK¤gZœ§F…ãÿŽCØD‘s:^­”¿È¤"ð©]s'v·¾õ;xOŸÞzg9|_ki¹×zmµ÷ÜÌ/å­{awC+S¬É™µI'ÔrëBi¤š¨V4^‡Æn–bŒ@ðO "b (é¦{®oÀQ¤ÐFª[½X7„ÞÈ':ÒšRR‹­­owÅ[·nbÁï‡IcqÒÔ–1¼Q‰z‹›­æ2¥‹F/ðÙ W‘VÜ "ÝKÐ?ì…®"ÒŠÐ/ò²@Q@qÐÏø¢™hÿ` ä¡9 \å6í"»r$#Ù‹S ^êfòº€'÷úrøå£Zü@`\£ ÿ‘¼6á¹ÅUç)ËXÎö«‡TÀ.°²RÞðó–ÀhÌ-vƒÛþ’½D [%»_Jæ  ¤4¬‰HD ´Aƒ˜,Œ8“AóD)’K7É‚`+²Ä“ªTqr“{E>Që‚òƒ€`Œc¤HkÙ@¥øH‚n,ØâØ­$I Izñ`W–¹Ìr…p–×#´l)ÛÔËzTØ—&Q`­ˆ@+tv9ÍD&‡âcдD˜Aè!ðŒ÷.×B&„ö;Â=H)ÅÏå&&2Qp^dwyq–5±¥i¹Å_R¤—ÖÑš§n *Š<0HSX1·ó•«LÓ+!ËXÔÿÃ$” ›*¥È}Vxö¨GÿA1 "ƒÐá@€Z±€I@@ô¸œåà$¾(èC©ð„gEnÏ›+3øÔLšè÷°àAsÔ?yò‚ 4Í ¢K¨¥¨æEœ8ç•ZÁC# Òˆ$¡ºÜ×¾z™ÑHM— Zѵ…ÅñkàYx–ù$E±†"bçÍôd -|k)–ÈÓG´Ð´F09¸w9ùAfpù¨'[ò‘ Ä5•†šÖÎvfÕÄ èúìêç…Û‡@À *!ÉXÿ‡•¢°Ît[Œ×Š«5"%©èå^¡ó@dDЂ=wÀcgf“¤$½Ë3³ ^ÿÊ2ÓP+¼J×c†ÝUA@J¤G'” Íx¦ž¹ø@Ë,­´Œ"-LÓ'çáD’ 0°B‚±g8¦{ʸEÇ‹–cL…]Ku2—:·,wÄ¢Xe¶°×µ W¼“I–f….Ýã ]êÒ&yWvp£¤z¤@l2Ü#ɾùND™y ‘Kp‚“$hÎÀ2Ðtµë7,R‰J€{º%–Âí”Z÷ª)àõ*6H-ÊœÜ1ª9EÁ‡ÑÌhjÐ<Çã Ia•YÆt¼WšÒ‹Éˤ˜ò-Ån„A S ÙP R¹IDÇŠ™G’[ðDÝÿXÍ@)©x‘ô¿­É»XÙ:ä¢õ£w5ˆ…Ë|fž¤â¾lht–b0h¦-»A¥ßw¸»}îû”‡ÝƒöOÿƒæ|‡ò?Ðͨ¬’Ú•ìÚ¹^G÷á7v·Ô"wÄ(ë^.ýÂvz]=åæ‚m²ð‘8±ÝXŸñÈ%¦2®³ Õ~ðÓÒ¬—ëYþ‚œ ßÎtÐî.¢•Ü5€AƒÏ•È £Èp‚p$Þ,¢I»ëqeÔC>¹Í<åØt8 ïVZ~õËÞ'кÂÊ-|âJºÔ'â-,‹Ã^ð£eÙ¨  øÄn·<Ó,ØñŽÀ(wP1n3—Pÿnèv`a Xà¿Ñ4)Rx>}зÁ€RÓe®ÖoÊ€h¶KvfN×\öNWGá·RUgrñu¡zÝ_÷M7zž·”p¤wzõ÷04òàD]4\À ¸i{÷då6s PFPîæ?TVg }FW0hÆ/†5‡¥uëA0‚–u ·ƒååç×~aÇ~ç%n#Uò÷;Fø¢`w\4¾W$4°wQn– øZ/"1¾ás~¨ž2—²ayWát`AjÓLg#cj‘7£×}Fâ6uhŠa‡YtlKB‰º•„tÀ ñòÿÁ€†nÿð ]ƒ"þ‹ÆQ5‚ û¢}U :1MáQR¢ˆg”ÕpoÑBsèuåçpª87ØÔ]‰%gÁhäÀ%Ä€GýàÞ8ŒFÂ\›H}TGCS ÇRã·BûáyÅSo£Šrq¼¢A^á$'V0·òèèFOfÝPLÈŒéH‰M·/±Va:qÞñ$p!¤Gl˜E z)¥wÔ$*ôÃÀÛq ôSj»C@siWLì"‘Þ˜}®uSGÙuRŸ‡gæE]ÇqÌhÇ–‡FR#DÆjOð„Èj&‘“±È\/È“¨CÀ6€¤ÿ†u¦6„öydŠAXõ¢:ªô ÛQ `¡FE!p€n´ŸÌÖ. zû¦}eÁ‘y#Ûˆb çkj¨A3È_Gr1¥/JoùA[%`EócEW WÊŸúe ¤êb$—蚢R†=Óó] cÁ©}1¥ÿ`EX…¥-Ú¢\ê/z ô3$0¨TP$\Д~xnò@¬Ö(¬ö¡gú¤ F$ us˜zÄlí÷¢ úçWŒ ¥ÅÁD:¨üIO¶ŽŠÌö”’:¤gaÔÁÿutÊhIAyj¥YЧE2ªõ¢4àd̶ª°ªŽ#š5 3Ê 3º¬_J?j¬Yü$`Öú«Æª­ÛŠ/[ùXj„ÌŸ-zdPÉfÙÊ­ëÊ®…5aG‰Ë¦aJd„J%P£íª¯ûZ‰c䎌 ‡áJ£Œ@÷ ®Wa­Æ Ç̆üš4¢·J°óÃjaj±j¯ÃÉj"ÁOYÚ¨~X  Àqø±±8}½ŠUËú–rq°¨Hd{roé᱄®‘d±h °°¬61éF=Š—jz²±uºÒIwúbº ÖIÒ¢óC°J[ÀêÕª®Åÿ®²9«vÅð(-YLû"š²µV¬ÌæJ „ró3£2ê© rµv«JW;?z »±§J[·p¯¥Š [#¶%`H†³ZËl0ð¹ñ¨nôº;CSÈqHK™(»cx:Ú4^ª[}{|j®A?yú´óã§b[0™F†zû øC"á°;FÀC0´¾ñj[0ݹ¬Ö¶ERŒn+±ª{·§Ësû©žtº;¦o¹º ·4»±Šµ\š]«G°³ûT?óPè[L ¸ëúãpA`“F •²&Q"É›*C|Äù˜›*†(ŒžÄ´ºâÿ²+££‹§{}ë½ç·±‡¡[ŸJ?¬™®1{)/÷DüÇA3{°[$^ ù‰òú3•GÀ°´Ü!E-²…1¼1\#P.E²E"ÀÆqHAœK0›º|:}û©-t ÚĬ™Ä{{¥_J°‚»cékEâ»A#`Jˆ°M²Å›B$¢Â¾÷®àÂ)Œb@=¬²Œ21é×5XÄk Fr\#vœa ТñÙÄÑ{ÈOÌÀ¥›Ä-[±l½K¨çK®F"`»ÑD˜œåë)ð¬ðD€T@Z IEu9ˆÂlìd€AÀ"AÀÿiÃú_€’àÆFð”PÇ¿»J`‘»n¥tð°?ŒTi´ÉJÍ,ÄX±npÓl|l5Z¥Kì¹V4º]ê´;µÜBoYÅóp L$¸ZZ\\ÕÅuG—\$ÊS(ž 0An)ü{6ënOeApÀ ðdSé?<°,bEµá9ê‚q€=*E¾P¾÷ªÌÖn?ê4ò¡:\µ–* °¬ºÒÄ}ñÄ*}&yKœÄ>q~ƒj±ƒjEçü©æœµ‡{­¤ôrMÔD¶4š¬oÉùPÁÆÆ¨Ðaï›ÐÆC ®Â‹hðÿ7§TJD­.ÃÌa4Ç›“ÍŒˆ—W$=p7fIü¹Ülº+®‡¬Ð;£{Î$p΂;ɪÄÎXÁUÿ „»ÑÁˆ­"bw¤¤ÍÂmrròÀiá{bÐɼˆ#¼óëʋњ¬Ã½¤æ²?É|M•j×(Ãá £ƒjTÃ`𡎷;U{Óg’Ò/z·ØÅSz~Z±`J[‹Åè{ª"¼ÉñœÉ,"‹}˜l[®#GÏrǢϕý+Ì$ÐÔNe=´%‚nT#òn=².Qý98ç(®Ìh ©Æw:51Û¾xG1@¸½4¾‰`2ÝÿÀ1Ūkº¬é×Ü·Q±½j³ýk{[uÉJèÅ!"_ÝÿгÅ'n8çÊ/ÀQ}Æh\Ð'ñ¾N¦…¦s¡fÖĉJûY4}…ßã`J!0"Ò¶MVQ§´æÖuC®Ì¢+·‡ÌºÓº±©Y£öê¬y àÛ5[õÁ07Ýà¶þäOÖ}&:>”¡cT,ð¾*ü9ÿ,Ë* x®0}n iÀK¨«dJv}[è2EbíF‘ËsvÌÖzu)@q 5”ÓÞÜÈOüž1 ¡¬yåSÌ·àl°÷Ú¢]»ˆM¾\L|1ÝcÎá»aÿ[–ãN Ô¨œ($žÌ í'œÂS‰Ñ!ÁÀÆ„è4\Aê3|5ìÑ˼ÌÿÀ]íA~45¼Зä5#ENé/Ó‡A¯rÈœnÁšž¡^Üå<ÜZ ÉYêæ æòÜD­NcîO÷ ê7$iÿPö@ëT,Ài·Aˆa%¹N•aõ¾îi-âË.ÞÞ­šU&ñãñ£Ï.ñ@žíÅ!Ú8Ñß—#¤àEY¥ãÞÄWÊ×Ð;ÅŸŽ½};šأjêÛ!Ï`îØäKØpæ¬NÝú„2tâöt pë~÷Ý—}ÐSmÖ¸»çNÆËÀ#Çɷqð¹Añ†nZÿx©ÇY—ø¨‘Zí&‘|bÏE\üMV ºS*· ¾·™ÞÍM[ܼ}Á<œ6ëסú©ƒÍŠM|è*ïõnæ:O_EIÖBIí c—CÙ{î(ðûϹ.Eï›ÕPö¾æØç^íâ€~$±ÚG³ë¡†õ¤/ä¥d´ÿ,¼G£|Õ^Í>¡õ°ÿÑÆ—?êÌäY$Íìÿ¹žë½­»Ä¿M%Ú»×N°óÊ· >¨%`Å Z0äkáÞÞ÷p:ïU¹ÎhŸŒxa  ; )A…,kÈÀ CŲ̂ÅB‹,²¢ ªp ÚhD‹"2h4‚PsE#‹‚ñŸci%ÚLrÉQG‡’FÞHŠဠÒ(yŽˆŠÈ ëî§‚*"¨¦cÇB€òŸ|¸šò,ÿ³ÌÂÀ:³Ø:ÂË¢öÉ /½ü’°-Ú{N „“΢l ¶ôl6¡k ÂÍ=+K-‡Fô!W:± ƒ ªè³C-ŠÅ‘lJ‰Ä™€ê ^ÆL5r©èœ"`ºr J:‡ò) …óñŠ]ÅJOAôØ’O®û⃠þ"ˆe_ðx ô;ì°Â®uȲ: 7¡n9rP <ù€Ã¤¬OBz(´r½•ˆ(Ô0ô !Cõ%ª&š2¥×¦o.߉b¡„ª•cʹæt ਬsÈÊ{LÕž|¢H8Ø3/¬‡ÚsàäzHÌȤ€‚áƒ+½¾ú: ZÌ¢­LÎÿe ‹Ø/ĺ͓#Á ;p•‹¢C¿äô³³rÕMTµr‘~h+ñq ì‡hzhR‘á2="¤¬fìˆ!g?²É¨˜‹(⩬‚Rá\KË]û¼¹éÓ¡\áOY„/ N…0W<ܸ5ÃüÚn+D å›ÑäìÛwý\Œ³>ÓQCŠ8J­è¡ù}”°µ(¸HG¯¨®6Jª–’#Yå½*Jë– «üC$O¯Ü&- ¤}±æv7‚Ù­Lp\Úed™´„½´¸; 9 edz”/T™ÈÐH£3Ë(QGcЇå-\´îm×±iŒÿÈ* ð/cøx¡Ž»!%DkþjTÄ‚ D` éŠ>r!îjW-  0p¼‹É0@+ÿ<„0¤b d=‡Dq@6ƒ¡Bè÷8Ék"𔺌¸r}®s‡R×j,´Qà"‰® ›hÄ1‰¸dr,X5FdTËAR“¦³D©Pð,8Á ¢ üƒ/ Y¬#A· „Ð`Ä!D „íqEÈ0Зs!K Ø{fD¢X=a.p‚ÄÖä"÷åL‘9$J6?W™¬FQA“ˆÌ'¾hr“îĤ&ÍEz61qB ÕJ¦œ²9RyÊ=Æ*ÿ©ÀjóAVrñ°çŒ¾:Ë \1°(A €!´•1ì|¨2Ü §4CC²…”Ìf|bHei!¥C:»f¶sNE2h"Q]è£;ø¨dB.‰Ñ¡'<r8ª&9w]³RQŒ €a€T±šÕ$ÀÐ[–Å,9€ËYþ„ nöÙàÅíÝ1"+–c°S˜n O)›Œµ”ã&ª¥…t "Ï7NA¢Ée–ë©…S§*(=_k™@}´£Q"§`Ë1`vžÂÅPµ‹S‘Ý! >0úðoÞ„‡Mú÷ðÆ (¬úã‚V­þQHáF«D«"ú÷A‚Wˆ6Üà—ï_Ù|öò(kö_üâÅmH·®Ý»xóê-ÈÖ,?ƒ]!%h¸6 2TAê #XÀ÷ï&å­0~˜Àh „yòX´Ôù¡?žÿ64M©sçÖ†¼BT5©¡‹R‰Þnåñ(ÞP,øqcê¿ I0tcò‚7¶‡ºì[µsùyø»·»÷ïàÃ/ÿÜŠh®æq-^Ÿ²›Ââ‹]Âæø7ÏÛÏ&½'œÐRˆTÐÒDaeŸnQPJ@•!·ý#YXý ZU?høƒ@LpÁr7<ÖÑ œfÚk±(Ð\ñÀ£x4Öhcxõ•`!"ÂBàÖE‹Ý Ä5¸Ü„Œ019zeT ~ŒÐÓ=öTy‚<\ž°S%œÐptÜ}×j’™lx\qMEСm°ÝfÕFl ÖŠ1qç–Œ#üåÁˆ&ªhB× T– é3 ¨vÔݶ0×34ÀÈ÷ Y´Xi0²ßK=ýc%hòÿD#,u¦\‰ ÄÈèS~ÿLðY$¡TüÓáUõSÝv´C…Á¯سæ[ü¼%Ћ†+®Ýr÷¸š;‚F¡—ìÑv$4øD “A C*oà÷Ù~[ ð?ªnÉeA³æGÕ ¿¦ÂN¤=BFPv´6Q¶ì?H !VX'•U­ü€ÏŸõ6‡ÏŒ}ÿ`ÊÐ2Aü¼æ2͈'þòÎf±%h>:G§ÑVU§ÔD´BÁ…QiŽÈú !ÐJ-°Pº<¢.PÖ±ÞsÄ?¢Íš’ªó¨z„(†Ý4e#ÁÇH:dQH ˹€ˆ.°¹èÙ o ÛõÃ-ò¹¬pÛ Ÿ ÅÅ-¬`úØ uV”­€‹rÑ! oÿ,´¤Ô?0±Ï¿Pw°Õ \R ¸öºÈCŠ ÌÀ°À)ö¤J,Иàb/!`%6‹)Ù?F¡±Éx#jÞˆ ´ß˜ 2(BÄÊ ¸Æ¼ˆ!OáÎ5ÃBÞ…,„ë‹Ëv$j+"8_Q¼·>}ÌZÉŒ@⨑‰+hÉ ^À¿X±àý»¢òºX-0€,ðä€ d³G rw„€@ P‚ÒœQŒB£¨ÅHZ1C\ =dA/o* ?´õGé ¢g0ôÞ<0NCš³;æ"vÄ.DäpR7h§ä$ ùÍï}MAÄI Ùÿ®¬jj¦c‰¯¸@@€Gx¥,ÿ‘[ @‹õ¢˜ÂH²•"”ˆóÖÓ”5Ê T(€Ü$„Ö4•e§°ðíW\Á™ ¹·=r ĦÜÙÎŒÎÉÓ„ ’’ÿ¨€¤VÀ­€ðºÁ 4Ú•ÍE7T‘À¿z¥OUA1kšú ,S<(-B˱„k¡Aåc6¤ü ?ö9VA1 ÀíC‘ò$Â! ¡„Œ~*ð(¶H (ß|Í¡b–=Áôô±adÏ÷¢ˆR?{N}>àThnI³&À‚ «@¡Deé:Ð+b` ±\ ×* ÿØòÐâ?Ê@ÆêvŒÈÇø±‘ÔN'`£ÀSJ†a îųÍ0„œ¿ú5NªÃLã?Î|çû˜@DÐ3— ²è%Ü˾ÉNw&è( èÈêçT - Á ¸2Á“ŒR dc¶”;®’u¬^4ˆY QÝYñvKè#VÒòg?›´f&ƒâ5­*ˆãœãᣮbaàrF”R@9ozg쨿±…[ê(±xžÊH,€ˆÏDs!ÐÉ~ÒÊ«t c5°mÉàÝê¶«Ñ]ÿ¾h Ø4°#ˆ„Hâ]†BкŠò6Ü¡oÿFÃTº¥Í©Ïpq!ÃÇÈôÙ < ï@(È$å!­Ò79’Hµhi_y˜ÖŠÿ€¢ÍJVÿí––·„mC¯Ì5Ö DL1Øÿr—ÀfÙ©5·âbn&«+Þ*3ŠZ¨@¦YYŽBÞ×€ó Ú³ wä8Š ’>¢M|ƒDª¬àsIÓ`²„ÀÈP@%àß–¹ÂˆÝYQ«î4({ÜÒ¬]·@ˆi+Šf ¬SàížØª®`Pƒ"AFÓ<æ¼Ø°ƒÔ ÉÁ©$9(¦$ B¤oŽE:z&ÈN•¸Gš(¹vn(e/Zˆ ÿKfþá©dÝ·Ò/ØÝ xæ×xÓé¦%C“PNï·åêl2ÆÑam ¥}"†‰2ÁùYÁr&@×µ2Lëõ5Ž›µÕ!>‹á÷\è}l'.àåxâ˜í²‡<;:˜…– ã)"ñ&Y£ŠŒ…2Si€ÎÃ>Y(lkY®¢бHCiËÛv›û\ZìB#𳵄L4n´ˆPX‘:ˆ<»BÅ£Ù« GJ~.Þ„‹öl,µ‡G¨Þ`ü\¸×`åÚ­ QìE‰|ÎBÉIËßõmaÉ#æ¢ÉG¹, +&ž\:ÙZ«PšÁé~|ÿ˜wW»–@°ò­IÉOðÁ)e…ØàUW.ÀCW* µÀGñ¡¼Ù,f6ñB>Ü!Ú¡r±q¶á+|Á—>ϱJ”°!s‡ ñõ´”àö…4­°†”+dFövj›¶[ºãw¢ôi»•nAƒ³@¯“W4P,¡0!À+`ÿ€ ?°Ÿ7,p'v¥1SøÀp£Ð B”Ó=4µ8fZø1¢…µW{ X3BEè(‡ãz"àR×V#As' ç~uz#A*‚RMø6æjìæ?"05ýÃERösžöUT`u ÿEyÇõ+òÇ+èqøàL÷1,±Q!v‚u‚"ñ8…£N%bEs§’1*ûb>Kz‡D!0ñŸ ­SoÖwPp,ñ@ÿj¾UP®35;(@÷ðZ\ã:Š1Ðö¶¥!7±Ñ@¸.~ÔSX%]ö6µ°Ð2×zS¡Nå#1:3‚⊠X­è…[† 8†/â+Šôg’_ˆ"çaÄ4 q1­PO"amð¸Ret+Ñà˜Vò t±S%ƒJUŽ«@ÿÅ56Ç%¢Á‡ýÃ?ê—&‘&åA±qÀœA0Êá>•3]!µL&óQ£ð,¨Põ‘4æBY\ø2¡€§Ý"‹pÑ€D¹÷2”Br<ö!”€A<K¡´|°¤¸Túô?øO ÔŒ½sP¥æ4©;«$F)‘%ñZ²eJü ³¶9#Û!c éŠ_É•®X ùŠo±Så#À)#€±x#ÇùSɦœ9ô#è4îr(sˆ°öÒÀ²=ú°Ñ¨„eæJ®Ã5c´%«„K¢Ñ;ªFEi% UBt•i+™Æ:¢ñ0Ÿô3š’ý²+ËA}2t’&“ k„ È€ @-Š…B›°S](hy¡ Qœ¾ºS}:#ê2ºy›á’lÌ™e¡Je!mÿ©aB 4îA*if/ U<Ñ+!‚a°ŸþE‹(ÔÈneõ‡&JZ5ûA©Æ‡|;6F°²:=! tDŠ—‚œÑ&îC4Ä¡<˜4]ŸhLÈP V™ANˆ€`bY‹}z†·9¨‚ò¡­sá-†ª(lj3‡ú"}‘£ðõT¡‘B€’çhÔ£¿ø4p%,ªrJ˜v;q;§45θ;UV†‡VÚh“Õ(J49nejþSJ \SA,7°«Û©\}ò«R1¼!P ½&pPÇß‚qa\Ø2zv§é›°˜Ѻ¡Ú[ø(`x¢‰R.Ê¡pÁv‹ÿÄ•’T)¿&#8ŠMˆÐ'%/ÊE'Á`øZoUÄ“ÚØŒòús²”xSÔ´ „:E ÓŒCG@Y“;¼´‚H1ø!šÙNñU1ô• · ÀP ÐR¤N‘äX!cÓŠ§ÆÙŠÞbœ×úŠlá¬eœÑêÏ:.„¥ˆT„¶³?“485ib‹AšKŒàIsÜÇJ]%¯åZÙxEU´5C§‚µDƒ”`M´µªôSa^¢!à“\’P÷ðEw­‘1ÐQxÇ<ÜYf½¶ Ë€ ÏR!*(1ÃBwœÅ9½¡ é¬f8½%ªq1»#|åÿÒ‡”@*”`—²”`ŸÑ”W“C:EåWJ¢ËnRÔUTt¤[óZ6׳•xÿÀ3hPøú¯¦ûs…µóPT";ªvª S¶‚y)•¬l+Ră È Vùš¤(0’êµ·z›4¾×{J¸‡ ¸#0ëŠÜ1\ÝŠ¨lø<ÖcöE=š ³BÄ›,|øx»™úksØQ¦{@gÕ%»CÀR{Vø[ÓxS4@²j\a³2+XS- ,–ô´Ë³±Ü€skG­ Ç»¦ñ#€†Â#2r¡^hë8Û;œ„ÚÂ5ŒÞÿ2\ßKÚ82³ÖÁl¶XcúP¾º¸mKƒ£³t´Š ‘;J;žO†³5Eaõs¡k±dÅñé¿ßÈUu0T, ÿ‘2ª"²ó@û™Š s¶Dq¶ÿW$Öfù¸ kô,xfcZ¸­üÇ$Û-I_I­^ÖÜ· é­ßapñh)ƒC>Ü(/D½²£/H¿+1FòšÄ㹺ú‹ˆ‘üU«ËŠè¹ÌEò¶¤ßÈS# -°*bòÿa6>ÙæG™ö`&%1B5A šIôÈAëÁ ‚ôÇØÇÒ;Íwêg¼§fÍ_¸…4[{ÖÿÚ*º#ˆÄ¡hyÃiIÎÚ„³rA•ù@r™,¸ £Ò/þ•5Y3QžÛ¿.HƒúL>Wƒ¢¼Uúkneņ‰}øksVt- 0ÿA}Z+&“U°ÚÀ§AŽ«²21¾]ÑÑ£8fö„À€¼Êë4ÛC{‚¢S[Í ÁÍ1¬Øk²\Ȭ÷Â/<#4›ˆ´b§1(ŽÙ,mÚ„`Ù8†P¾wx/AQn­öDLTÏaÅ[4[ðÖiì–ʲuÏ–/Èn;Ø¿M`-€µ½ý¯M$y6Ž ¼&*‰Ñ™TÍ=ô˜mù¸×Ë@„Ô.„vÖ|> È+-–´Ç½0ÿb&p/íg‰›gÞü€|ä-kIgkѕ䜜ãµæËrÈ%Ï–&¯Q$Ë |\:÷Ï%ËKZ¤-0 V°;@Ü`TZ™’7aƒÑöy\jIOSH!Óòš¹öQl•ˆ•34g É//^Ɖv2¬Ê-3¢Øx‘#*ÊÜÂÞ+qÕ{ÃMòÍcy¸!ÜG6¨“5^UƒóÆSV¯á}ä邪SÐßhshå¯ÛHËCš¤­2 “™=!nü@H ˆuIàÁÈû ÀÀ¸à•œØ<؇£Ýlç8«€Ž#h_Ù21^Þ|Qc`©¢j¹ÚÿD³?-lB=håËcvXGú$6>)&š†ÏuQàþÓ9GÚWƒ`Ež~àûÕÛŠÙDh-«¯*¥SŠdÑ=Y;”è¾óH´QÑfœ² Ï Ìü/DA€æcÍ…’Òz–!ê…î{Ìú•ær3‚â‚9~aëýÞ;b,\³é¼#l—Dô∑!DÿZý°€ï2ËžûAÁÐ?~!õÅÓ'¦M›üâéä‡Ó'Ìx?ãíüW@`¼|7uþË×ófÐ; 8ý)°‚@~5³ötZ“)¿¦I›‚-z5_«h§&ýùßD"n\èÄyy–÷ïžOª&p þ·Øï?J¾'¯o‹CØû÷Aßç5Ù2Ä)±àÀ [°°Ü—Qˆ…yçAxýáƒÿÇ«ÿ}”ð¿ öOåµ–=êÛJ3çNžÿˆåUçhZ 8ÿ7ÓfRïÎôÞéÐÁ1a†dLõfR§üÐæTËÏmÓ¢Táþ»±‘ØJ`/†X8¢/œ ³I€ª0(L Álr¬*l¢¬0Êü’'³òzȶ|>c}üç¡yP¨ N¸ !ÿaM6¾äY(„ l«À¤^Ëñ.(ˆà‡Q€fãć—ºs²;禣.:ëª\J(›Â“Ϋ f¢IÊ¢À¬j+漪j´¤ÔÊ §³Àšj*˜ðãª&¸Dè ¾^‡ÚæAðŸ#î ôˆÆ~:Œ€ÂsÿL±ª&œl²5è2‚Nh³šBŠëôÉç†èz2¨ÃÕZô‰…J÷T¨"P+Hª! ZHC( `®Yæ×^G¡À#~4ª‰Îª¢**òº Š©¡\ØÊ£ÌHZéž S>˜¶ËçÙªÌ䇪¬ÒÃʦ܊ÒퟫÈÛ›B2Ä=ÿya¶ í+1Ã"ôI2¿8Ñ{"µP  ýxÒêë„-½ÔìêZŽ)RÕyLe¨…?mJhVYeÄŠ)ò‘Ùr”€‚"À™kþyæŸâF¹Á%CjÒȧêÈý2è*͌Džo¯u2£ØäîJø˜ŽŽ±›vcÿî'÷Ä" §t›î©‚ùœÂN V0ÄO úŠ‚ƒ,4±@ÿAlî¿¥»0 ýWaG-«¬ †1ƒ8E›B•-YaN?µT‰lâØc‘š‡ Z¨¢¼J8í-Òõ‡™ôgdZ¡`ÇØcìK¯ª3:vî‚r!¨°=JÚ£³MZ'ï’:jâÍ=WÍ8sŠbu;W>øv[Á¿ðÜœ¡y…QPÕ‡QÄTì° ä§ ÿáPýSÛOQÔ˜Šÿ§†íŽ-Á#>±ãQ3ƒÆ‚\® ™ˆçX0£Í} /»IŠdœ›-c?øÙÑÃQ$ˆ‚!ª—¹†Ìˆß‹b”¸(I1Lr£òÐ}2?e.óQQMìœWü#§cìNüØ*¨¸&7!æ9;5n,ÁàáhŒÞP‚>Èó :`tëæ¯)ÍAh{Ó¬¦µÚ‘Kt‹Zôv%øPÝ<'âo‰(7ÿÑÊ󥇚)2þ–³δ( OZÚíqñf]”|¤¥yfa—’Ÿ·–óZ`°Ãê@ð‚Xe™{H\våâˆÍ‰Øc3 ÂNMŸd'jò0§¯w^ñæ’Vܦ ÷Ð_±‚£›;çù0œMDeMê/0j+ESà™™J°*ÈŒhJ *Ƨ °‚H´ïÔ<>¨)i;Û¡iÙ¢ävàTq¬¼0¡mâYœrk"ËPqØu¯)0 V™Ø,›&e˜]" Q©ÌÈ*s¤ÀÇÒ‡g<ËæÏæ\§<„æ?È­sÒ*Øô?±³ÆmIš!ótmÛ@›H $ˆ~ÿPÕ/‰#‰¿Eð–FÆí‡±Üq—¸²*7¦û·LØ;wÁÄ=9™ë«2Ÿz<•²:rÞ¿}Ü€…@ý- ÄϽz‘Çü·e/êaôˆAeÞ™Íb t¸=²‰-H°éQôâ6›·ü‰Ä¹Ÿ”!ª36AËrRˆ È=òVÈ(áðd€4åPRà Ð'{b–³Z -y$èà ¨p’º¤êz ,<¨±yµ°8¬@ [3«ð˦Ð ·W’^3,PÑ Ö¦‚a”ªŒÚ¢ÿÀ¤•ë}°œË6Ô9T@UЩ73½ÿ:‹ ·Œ"·¤#››J³‰•@ƒ#Ïá‹Ï™ ‹@'r%Âë-¬b’ ¸ ˜8¾£°4îê4é‹Ô±iIš™X¡,±§¦—§±®ÀŠíŒO¼ÑP‹³82%ó °q‹Q <Îð”‹Ú2–|¥þ‚¯úãž'š/‘QzàÂø 4Ï‘î ‘Másã©5ü‡5<ºÑZC¤3½ðjr=7׳FfŒ&HÑ8ŠÀ‰ #™bÏÙ&vÑ•‰(’kh » â´´ÁèÐ’£ˆ¸C¡T ÷ø»íûÇ4bŒÁ³›¯¹+…„5{h(n©5˜ $,j%’ÂÿaCÖ€<½Q˜Çƒ#zà ”É¼‘Ã'‰‹1<Ɯ˹edF›hÆÑ7pC¯p½€@2Jö€\¸¢Zˆ ÓaÒ°‰«£€À |³ªQð¡D$ÂDzÁ°²Ç¢A¶ƒ¥a8³¸HD.°˜¾œàŠìÓ>¸:øàŒ4A²5‘¨Pº ·H½2 ‰ú¢žPœXJ  ²êi¼*¬? ‰"-TˆÍ9Í˼(0IœÃn¼)¥ó‰f|ÉXC<›Éh ·k 7ã¶q;@odŠ”™‡@“£tŸÆh ÂÃaÀ…#y†@:1³—©¡.‹{;¶°1¨x–ìúªèy¤ÑxÁÿÅ4+±8ÈïC—w ¯¦Q‹t‰u‹†ì8P\ÂX´€ ˆ ÈÎð“,ó›ºù ·Ù÷á/‘Ü,ÛÄ 2´ jbÉ—dU`œ£{ÏŸó£³p˩֣I×›3Æa™4ذ”mºX¢„뤀Ϋ#-‚q–J‘Í(L‘Àó¤@NQÏ*ý‰÷lO™œFœ:ô9ÎÔF7䵤#‘K ŠxºÒMF`„ 0Cˆ& ah}†§4„:«sÁÓ¢QŠr£ø»S—ÜÙ1>õ–géÖ*€"#²PZUæT“†IµˆW‘ü{ÈM%£×}ý¢‹j½ 8”ðé2–úEzxh›ˆâd¦)9 dÿ2ìOYÅ <;Àh¢Æ40š\=Íœ@9$#`½c¥i³‹hôhø_¹†ØLDåÂÖK ¶¾¦p»šøVsÝ©±»";71 Ý,2‰’¨ò¼Wví¸UMW׫ðÑv•KÅWØQIuQµp p²îà¾@ŒÈ« ìyˆȘ©Eµ´ 0”ÒÆqL¬ŠY]h4½Éì[û¹8YÌü‰œª‹Îˆ×`·µ Ú0œìÄ:³€…ÖkÐV¨¯zž³#×¢õVå±çÔ±"[N¦!Zt=]Ô- Ô]]tUÝÓíWý×ä±Q³Û½]¯ÝÚ ðÚäÑWŒÿ¯µÝÙMÜ^ÛµKXz 8X ðI‡Q)³ˆ­ÁÁ`3ŒÃdˆ" ‹õÜXnãÆé-<£OlÂåUÖÛI¯ˆ6buºé]ÃÐúhh†k± 0¼Ò‡Ó=‹0WÕ=WÖM×ÖÝÓWÖuÝæ1 L2^ ¶Z«Ý¢Xâ½Ý æÝ§]U(øà^Îø`¶ø¥ÑH?Påù2ÒÖ˜í¯&ݬÃÉŠ"Ÿ¸© #Ñó Vb2ÊInÔÏm_!6ÓO ǧ«±D,q[ø…W¸àߌH²01ÝN`0^]Fà0V`6ŠvQÿuÁ]]Ûmãà}[ 6a6aJµÚäQÎ8a:~Úäq‚ÛåcàÝàÌÓ‡úÉ=Ñ˘7=LÖ—zÒÒaŸpa³|LƸ6óÐ#£÷œÌÑ«ÉÁeŒ{Õ’›Ÿ*«²€i{Óõ›3ÈYþ,¾hˆC(–³@×]`×]àæä‚€c>æc.ft%a¶cvfœ`fg¶]æc=®c;>ak¶c¹¤Tmîão¦kˆq>aˆ6 çŸà Å™Hä WÚKi«²»ˆŸ’ÀÞ Æ’³–Øä1ªÒæ”›ZOQ³1¼X2:½À¥åÕÎÀÉ‘ÿ)3!80jr‚è…K°eJÐåvàÖµ b6i4a^i(P–V˜6a—vf—&æaácvižÖc˜FaŸÖf¡–éQq6j˜Nj¤Vj˜~ gqn£Ng ø‡60azj¨Fꨮcð X*=’µ€V6=”è³êgÏè ¢[KÖ(öOÐø¢(9-úEÃÙ<Æ#öí=Öc0ŠÕû‹X’*!ÀLJ(‚_È'øü… @R*²“fæbvœvæ–~éϦéÏmÒ®ég>í6ížFá—Nê£Vê£~í¥V pm£®mÜVyЀÐÿߦmÚ®mzøí§î£&îà¦íá†éªÆõ,à‚³><Ãæi{+ h¦¶¦šÄá᤮ϰ&óÏ )¦ ÇäFœ¸ Àbœ@/;a‹ù±ˆì¬_Œ.ºKèï5”Éþ!/jÝžfàé¶Î^pcæéÏî鞎ðÖvi'°pm¶j:6gàfjÛçªÎíªþ÷m?ñá6ñà>q?ñ¯êjâî][쌪…«â·y&91ì^T쵉c¼)Îû”˜+rÍHïÎ2I*=C›ˆo*ÇbùŒÞÀCPl-epë…ø'ðhhÀ(ÿ5æfV©Öãc¦i¸p §m(Àí WjÜ&q6Ïpžns¦j¯s¨ísqC'qC7ñoqïíîG—ñq'ñ¿ôI@D !mpPœ±p%Áz%ÛØn6Ñ»Æä”f¦ì柂øž¿È Ñüš:JRèWž÷,^lœ`°Ã è(²!RawÈî…˜ý¦]pÞ«–êaj«¦óÚ–êôOç:ô=×vª6qþötß&ñA‡÷powF¯÷ÞæmC/ 8wy?áwøC×ÃÌ 9W’îf†TèµT < @ëÿ|Øç ‘4K3VïÆc¬ i»¦7bÁ ÑD3õþŒaï^jÚ©€ï+ï=ø&òjëÝS§Öü‡ÂCº+VyÉî…Ŧ{Ms Öæ6§íu?w=ÿwo¯s€‡wàömsqqgóÚ6yGôxÇ÷èí¬­xyo[¬wôo[xlj~÷‰·‰´WûA”1ä(‹€ZxVa`4 ¨!E뮶푉Í^);+5µ,ÑÜ¢| )ìi1·6³‰0ö*_ù'Ëèn”ùHl©ªù¢Ó)U๎þ‡ÈÎ…`¿kÑÞã wé¡Og='úª–zæôpw=×€r§}Û/ôAWcÐ}ÿÖ—÷ÿiµï}Gû²çúágŒ³¯zµýxß"ÃÑWz…ɆZ¸{e¯… ?{+'¡˜Iª 3µ–eeâ,OÁÞ¸®|h?Œï)·y–˜Rú•*ÂÛ¯ÉÐz0ˆ^ÿ~åúu š ôìýƒòöT8„ø/"F¡Dü§‘c›‡"ª¸È‘£H (²ôh¬dI’aŽ$©A#L5kvŒñŸÏ…îŒi´&= CèkÁB-aÿ| ‹úO˜…C>pÍ—ï_¾úþI;ö+Ñúû°ë¯\ݪ=«Oß×»zw®XñЍ‘úø‡¨." O…ÿb¥—^R5ù_/‚¿z]ƒ¦/© ŠF¡Ä ReÄÓ¨Û|ÌøÓdËYw¤ù0ä¿—%5ðþ—tÞäcÈöÈ[gñä#;3-ô´ôÄŠhõ ªÔÀš«¡ÕØÿÄç“ö«×ó"Ó?Ô'bäݺwóµÍåaˆ!ö‡øÇä"ŸH}öOd#vÉ`…­À–ˆ8…0XQÁ?¯Lv‰@½L&PA ƒ#¶…&QÅt’N yäoPcN2¡QHyÄZNÕh=$Å•DäNÌW›L>6yÔPQBp å“X+\U3W}׊y©'ÿzã„VM" òžjªÙ~ Ñ3§oëÑ_>üÕÕæ?+üsà%0(™–E¶ÀCˆ`Á(Àà¢e+ˆð‹*½Ä!fåÒ 4~ÀE#U$Ûqj7ÔÚnÕH’ ¸‰Äj‘O΄¤N¹*9=»'Û¯@59kMÏ ;¬pþݹ‚u\>³Œ0 ´B] q5—xfîDßCïuk›Þ~ußC-÷WzÕ&[cí—Ë]mö¥ŠH2hï?>´Ìþ 0ùFðŠ.üKbú fZPÁD ÙSnEÔÒ?§±ä¬9šª ÓxãsïÔkpõ†¤M@JÉÿÓpÈ5¬±Äû\¯ôpµù Óe3µ¼žû12çBH‡ çÒ …EÔ{ýöµ‚{HÍÓBþí7ûIYú„ðõžÑ+Y¾—D6ØöA?°– ¸…ÿÌ0‡—ü²4×ȧ¤‘vbJKùЩ)átSͫޖqkPœ¦‚1(«s»A„k’#™ìP߃‰2õ“sJæ:ëBzQðJ*?sgA+ˆHÁ<'øþ{ïÌÃr(’·~šÝžñþ•ûÐÕ/´ O ´€u @ШÖ?"øI/%—‰$èC ôõ”Œò> … ?ÄðýBÓÿŒ7@ ÆDűЍÄs#+‰ŠPcÌÁH622ÕKn2#ØqÌG Q•Í„#œ£$K¨{HP\׺XMn(G¡I¬Nh¯fv?ÛR+†Èãò¸¡ §G½œà\AZZ¶Æ¢?­@F|…¤Ú… )z©á?¬§½íekÚ ŸøÞ£ŠJ‘ÁW‚àf|Ìí!@⤠V?'D2™9È5„ˆ©®XCaãRx)©jT±©IæTò’Yq¬ub“N1P‘$G½âœçbœ޼ìGE²MèDºL*Å#IY!"~1„Ô¢KX¡€æQ‘Üã­üGlÈÜ@ÿx¾¡óDâJøàlÆÛ­Hà´à÷xeöö£—6eq|zʼn¢%J´âìÂû*dÍἸ ò†¶†= @"ölj‰‰†ƒ¨N4ªœ°„"‡«'lV”ÂZÁJ"0 ÒD©†Pn&NÎM4”©îtÆ]hxÄ#ÄõsJÎ¥¢Z!î#†4tå?PÑ–ëz'0—áS°¨b—êþ¢ÐDz@zÿÞ þѵ» Â/ê#"K[ÊËÈ$(mù"”ÚJŒQ*ŽzÈ_ºÙF'Ô¯C‚Æ3þ! б%Q$<Ã:1°ŽÕ! ò*Z Éæ¬ÿ‚åÇ$ Ô( Ae¥œ$…H…É•cP>†’¡“YH‚$¥hÀ;[“F›0éð†¯üöhy‚ça 8N _Ÿ ê$ú N!h=°–ú„àjZËÅÄGD_Ò˶*ee/AÊš9*>pQF³õâ›™!ˆ8E¸ŒÂøG ëØN7°îtíQ]†¤s¬é„ÂwË:1xª o•ÈáVEššÈi 3ƒ nöù¤Â2É„|Îs6IÂ(ÑÆ’¾ vùÁ/hI ЊiCyôp³æÎÕHJ½üð!õIdþŸ\Œ®?aO×ÄÒÓ1yBÿù.(B!ÕPbêH´)z}³ ¿hƒ¥ º¿àb¨Àu£d°=+,2’äë*ÙºKÞnwµ›N‰h—¬b ë°ì±Xú&±%´ß—t¢qlu9šÉOö(+Ö€FU±[“b„ñŠ!ðŽÁóÞð‚´JÌBq‡"ÙìHŠðL—ú¥O¿»ûÃýxåkkRòØd6—"µ|æ3ê4‚¡ A>0A ò^¼¢SÐÀÅF` óƒ`ázÂâ•|9üˆ‹WŠÌ躚ֳžu­ƒÝÝ8ùÈRÎî”GϬ-¶$!±w_í*J͹Íã`¶Ç˜,ô«ô¡€–ZÿQ¼ЃÂÁ!f Xð¤ô$u^Dò #´÷a"è4a‹|òVmuiÆK£o0ZAQÿÀ@#;*¶°ÞU™ñ†øÇ­ÿñÜ ä£°†5Ç;.—w¼¹­ ë_³œåq!öuiml~{„  ºyî*+š%®eÑI’&!šÐW 'Ú"S)P¼ ùzE)A*XÒr$ïyEav9Úm…`‰äj^{Ú"Äx·”Ò’I±n…°bC-õBZÂsé&’6êm3m¼„0£ð bãüð¸>Z­ ¾ðwùßëVs¼ÕO9ÉQþñ“CžòHöµ?úÕÿ‡Ø¼(ŒMhïÓÙuJM¼¬XB*eß_M±çàÍÊãj´"@úD$½GyXÅïÿÒ—õø' è A.hq³ ú@gç­`´J µ÷A €›ÂµÊc/òòÙÌf2ô !@CÃZº"ø‘~E±_ýìW”!aˆµÐ?ýêçÇXØ¢ÿúÓ-ø'<áýßàµZÇ žÈ Þ•PÐ0`1ÒŽX›ä€ž,ÖMô_=~ ÝB|"0"ÌPk=ÏMOHÝCî…ÔC\¼µÅ ôÖŠ3ÙÍ-Ñ÷€Z\ah]‚LFõ=õÄõÕ>d>`ÖyH½¼ÂfÿCGe Ü-µ¼V¡^!Æ[¨Ÿÿ±Ÿÿ ááQ¨Ó¬œˆ=<›HXŽ‘œÙ^©ŽyRÑ™Ð_±^´¡‡=èS‰@k í¨`p¸Ò ‡X€ÖÕÑËïý %QiéËå’H¸Ÿ‘m¡˜Š•e \VU“H2@Ã(DJ›<œŠyŸd@Ã%ðKÀÝP@bü-&ÆûÅŸ-&Æ-¾úa!0V¡a`áZ°S@ižN‘¨“œ¨Ó–!Ic)”løUpˆD_Y#ììÕÐÕ Ë4Vú€¬@kƒÉHIOîa@ FÑ™ XÀIMl]†ù$J Ÿÿ~%¾‡ †¡…  †Ú9FoI¡Ÿü€–4Šdñ>ü‚†È[†„èÃ@áL Ü€-f$PKGzä €$Gfä?„dIzäFvä.Òb/£0j×!Áäê)…æÔ!u·ñÊ]uc«Œl¼ÊOF›jã@1…lÀ |@¹•c À=Û‚T+QO ©VñèàÙ`nõI/±”ŸÌ]ÔÁ¼Ç…õž*(OQ}QQMÓÚ´O ¸ÝÐTÓSà24Ã5CôÞCŽÄA@Ã/H8…–ü€(vdH†¤JޤIr¤-Ú¢FjäI:fc‚¤H ŸaX&"h$.²¤¢°—D,„"-ÿÄ@i™&`ä<‡ÊtËT#5ÊŒã IÅèDÎ8Šã¹@ òoHÏMñg{ÌXaÌÛhñÒKÑãYÚcÄ!š 4¤{àKýÉ?^†>œ–Ø‹è]ûdûÑÏ<Ã5XSX†ù†04œ  $>üÀ@¦(>„F¢¤IÎgI–df~de&d†$/J&I2æ|Þ¿ _Ïx¦"µ“"ÝTc¹LÖ0Ò8ÇL’®DÄb‘ŽPb£=ðƒÚ|ž”H´@ f]Ïõœ¨ˆI^t ½ÔnÖÀdrže¿…%îKŸœ îúÕ@ AÞ†c8EÅvdU`àÿ–†iÕþA~B+àCZaVS5QËcnäböŒIÞç}j¦a:&K’ä€Ú¢ŸôKd¨F&(絕Åi•Áéyý—–5 qH£'L'!EON#†‡ b("l%ôak­R ÝY¹pÍ?œ fa–¹Eœšu%@Ó íËYÚ¨ ýÛ¤ÈVVBF4IÆõVÁ éyÎŽc8!2 x6ˆÚHÆ`8ŒyDH¢aþüC|¢äC0fϨ¤+™"«–h¿td~+± «P,¨œ&¨ÍÍiæT ¬IKÖ,à^õ©o`¨F NvDRä%lˆvÍ~Œá‘ÐöÔÿI¬ËòŠVžXðQŸ7!ÏŒ‰À‹š]M\'Qå‹yÚN34l…ÀêÜ$©VõÖ§ÍùA%@&"üÀ´g+¤Â?Ô‚HËHp$b6æa—Þ'Hòg ‘éÎ'²äI~©xܬ¶X+œ*è]ULj—{¹q(…·¢í^-”¹&Ë#]`ÑåÃ.‰Í<äǵˆGkÅ«o¸Š$?./©4ý…ó$JÚHøI?ú‰†Qu©¦ ùMÃr0Ìv4ƒ’î ð]‚†œçVùφ! €[- 2øª|«Ê†ÅÕ'/¶ÐfÖ"-ʧÊ:«GZnå¾ÅÍbÿKՆ…µþl ØÃ¶*=lëD¤îœxPR¤®ëŠ#ˆD•Éqô sh× XÀ lŒÍH€~_¡V¤ÇœdËýщeêüE¦fjP©­Pôcð辞Ïn]ÂÕKýÝ.CVÝ­ùJ¬ÁebDæ8VÀÌ#”À+üC* ƒ/ø°î/²ÊŸÅQÀÅÙâÅ]Üaà"d^¦Ê&ðVfÉð.jܶ˜ÉçZ0^QÙé ì ÿʶÞÒ¶Žðê*–ž®®4JãÒˆ€ léƒð€~ô×6] hjå£Å›óêk‚HïÏYÝ/(Ø&ÜQÝÿËÚU‚t‰øþóh0Äj—ìíZ†Vá%| Ì ÈÔÀ€@-ÔB§@ˆ„!´ñËß?¸1ËpËŸæ®äf–é°¦¬GŽ@Ïà¬xT@2!r!îÍÚCèþ#ØCí$¯îÑt°#;r —0$EíÆ@ O ÔîÉ'ƒÐœ B`ÌN* ôÓ!ï0Í …½kñà+’-õ&œ/ýCxËNZ?F§K™oá‹¡Uv<ƒÞ> w˜oŸ#²Ô†èà É ÜA ¸ÂÔ2¤ A¿qDZ9°.ºñ8»q9W@_®HÐlÛÿñCµŒÀCü]ƒÅ!ÇsÅÆ‰.ŠD<2#<2$£nÔî%ÍAO2üÖ.£ÎC)ß(ƒòê>ª ̃–åƒ`Ev€É8Ïê™Ûê-o€ ˆ þã?ŸØŠ_tú2øˆ¥"fotžŠ¡ õ­˜½ü…T<PgU3øÂÝ>1x²ô%ØV/}Æf-AÿÃ6»B”qÈŠÄT³ó9ð:£3W³³Wµ=ƒuÓñÅýØClÜY#²Y£õ>CÌ>OÀsýÃH3B¶Œ´#×îAÓ^;´CßµCÃ/ü:ò09t ÏFÏÃFkô£~%àÂC D(~X#.Ûx<ˆÕA†- ¶ÿÔŸ¤å HTªYÚ†н¨ô™ÑCdUV-C3OÅC8qøÀ†*ôò]ôÎ1 ° \ÀÔCMøB-PÀHÀ\€<7t?wD·L÷sUwu‚ug·;³³¸±>€ubh÷YïsY…Æ¡7Z¯õYCpz÷óL#› C_ò]×ÉA`3Â'×w(Gôj~rö ¼PUX*å6ŠDñ0Ñ ÔÏ¡‰OPu"ÚlÈjUo)33s4tZŠoS_A/»€WÐ߃6ó7×Ã'À¯..2€À\@47\9‘yuÿùðºouÃ5“»o'yu'9WHw?·ñu¿÷tkœ!T÷vgù­wyõ\3²|×.Càõ%/4~;2p0üÇA7tœ?ªšKô£ÒìX…øîä‰Õƒû‡¸¢Hü"±¼ýÖpnnEzlø·‘gkª©º¥n]§rA±HtI§=DÞù®¢0“Z„Eï€q @\@=´ºH€ì?ôxs_ÀÐúÜ:®ßº\ãz|O@¯çú¯ßz|÷ú°ûº¯ïð~÷VóX‡7áa÷uoœyòÆU»¯»o±Ç·}o;Cwû£ºy·Gt`Sô•r}ß"ìda[4O0DÞèÿ›ó¤UÍÖÓÙý‰ßF¦Ú¨/Eò©tY3ÖÛ^F¡¬¶¬ŠÄÃæËvÂÍà…­5gzÐà Èà ¨ú?÷Cp¼H,®+¸B®ßú-äzÉãúAß:#¨|~ç÷¬<Ì¿¼Ê<¯Owp\»3Y¸su?DÏÿ¼ÆA»Àu”c»\K„|[-#O}Û”?ýCÀ¹ÔG}Co;„I€0„§Æ /‘=ôÇ9¾ÑEÔrŸøðuâ†p¢ß†-YžIòQ*}p8h‘K­ån±öck‡†ú4)•úèƒx¸þE×0 ¤úCܸǯñH$€À?ÜÂä—ü-\þÊ[þÜÿ ´<œßÂ<ÜB~Ão įé{~Ë ;v—s3»!¸¾üÅ_W€î†vß~Ð_÷ çê°ûóáëu  ŹvMŒ»Ôöñ?¡73V¸ ~Tã?8¢¹@`ˆÍ ö ‰-ð•ßJƧVhƒ}ØÇ ²É¼h?Q©Šñôù˜çU8FÂ^È ,@àcჅvñÎCðÄz®þ%øWDªƒ¾R@r â?$nQ¼5ℌ݂Pd‰%XŒ ’ÅI•óHÌc4áÇ þ!:hÈ"CÿvÞŧ„ŸC^¨ ¡‚Q£0'T`úáŸFÿA JÕ*£y!heTUÿëA¯[γz aÿÖZ8âC{QþÑsb—ÞAz"„\:˜/Ÿ>ÿV.¬JÕ¿W>_Zì7ñ`“]ü£K5J`ú*‹Xñ1%¿W)¹ýg¥ÓBP[x¥šR„ÔVøXàc¿ÀüDÈg-®\Õû7ä`=ƒÿ\V++B¼õ/"Æêÿ@ÎÉ|xñ$ŧLÒå˜7k^¥ú“æ¿£4 Ñœo©RªM›F=øá«ÿ¤ºª«®ÈªŠÀ°¬ri«½ZðŸ„`ë´W†È' ¹¢îŸ»œ¡…(„€†’\"Ìç}~ñ ´ÏVXñUbLL•"V¬ˆD¨ìÿ Cø1 STq²TyͽD£Ê¿JC-¶W"PR±PeDȇ}t³ª¨&àáû§ž3R¨_þñ™\9 ˆ(";Œ¢"a;¹ã®<ðŽ`aÐB 5tPðJpi= ’t¯'G… žHª‚K•Jêƒ ä[ïŸ0'`D½ 4: ¬®ReÄÀ¬ dU«³TE«!&´ •ÁäúÇzB ‡ž6òúg0!Ѝ+„Ìôl0s¡§…BÈ…³Ê8;è0bEЇªd3‹bYf3ÒØÜ3­´tRmÊØÃÍ6,&ª„»À8ãáŸZü]ˆß‰$šè+&Xÿ¢?=ôˆBÿA´ÐˆÃs‰£G¯ê‰= €:Ⱦú.¥ SLû«@½ƒ˜25L“ýË=WÅÚ諘7z ,0-}âŠð®6þÑÀ®Z(BòùØ"ò³©ŠvZn9óLÃ>Û¶ÇË’E‘ÛÂ<£Ä‡W,¦Jµ«Ú%›±Ï(b/é@é«Ì<èLä¸;¡ƒÚ|*¡"Šü;x«4ºÎ½†XñÆW”Ñ &=È&‹í³äKë“Ϩ*ïÓÎ÷3u½5‚µ@÷ žV´¼úÇ%« €€‚ƒ\“€[¹z­ëg½ò)"Ÿ Õ+ ¨˜]6ÙdÿÉÅÄ|6«´lÿ³Ê* +·Ü±e›2‚îÿaŒ+ãÍnó Õ¹Õ÷îøuóMdøMXL> 7U"S!Bé , JÃw6LQ‰{xÂ1ù<°>‹ }4Å9ÎaêM‘ÀÓ£pX؟ؒ+dT _®´1`m UøÇáäŒúºJ=؈·ZPŵ0Ÿ.B:Sé"£êÈÿõ>Ì€4 »Q¥r9iàÆâs9Œ…&¢ÿûǦ’Ÿ”‰ip+›Šì„ÒuXaW$P+JPÀQr‰[°òÒ«h ï÷h‚<^é«Àk3¹⊚F˜«¸è ƒabñ®·¬(Ä âAÀ%,ŽO6ÿX@Ù³6/Ž€P ªÊT¤é8ÉAšà'¿7.äõ˜Èðt0vfÐTð¼ˆGnAð€p0©2aÞå¤uQÕ\ôasS©lª¡â ¼xƒÚI ÊfDÓ7ýÛp^%Òæ¬4œà ‹ôÏEÁާHǧ;Õó;ü¼'uË*¡äÕ”xåSA\O²?p•hWÖ›$Pjy½CKLj÷Úh)=ÜLfÇ>v.1¿Lf’4îļâÂÑsÏâBº0Ë=µa7ô¸(¶eRIŠ+ €>$ ïƒÇÞ%N±šÈi7ÓÒ 8@àGº‹Ô{ÚÓÁ*2jÿ‰x\¯‚©ƒTJR‹òÊT¶†ÿÐp¢¤{‚f–e±@àˆ¸A\‚œÔ='ÅáÓü«‚¼øêztQšìK 猡Š4O“CòÄê%\­sÅL©0¨Ü­pâͨGœ*g¿®â † át ‚rGVèÞÑ€ @²°ëîÇ¡k¿ØQ ÑA¸*…?Uų̂³ÓE4„ÔÙT ›º ¼Ðä°“¡ËW®fóN/N Šì‘je§vô 9›(®R¿—ávгÈE`JóšФ ·œê!ÒÄ©Ä €S̪îçèà«ìÄNæNò“ î`ˆOÇüèø‰TúJùê&æã0ÆS0È)ÿ>eÖꎽî.„j ³¯ãì£FB€dÈKª.”MÙÐW¾ÅýPDˆTä3ÌHŽè¦nê3˜hB¯§öï—”jJ®"‹BËJþHŒõü†Þ  õÅoЭ ®ŠÅjOo~ ~  `÷,¢"ë`$â"üƒ!ÇŠŸDÐóJPÈ8¯ŠÅ*)8† ×$ªú°O¢nÐÖ*q?æ!ðô‚húËÍ" ZÜì±6 ©Â©ˆÈælGó6c[¬E~dX”æW” ›F{"Lж°šØMl¡é¤®õþá Åé›Ð„Ђ9üÅ¡£!Rj¡vpÿd ø:ðtL¦ñáÌã*⎈ù Þ¨BSD†àŠ¢Shðâ&±î&Q° Oûacèaô±•®brèÙì DŠý6Ä Ô³¢@!9‹Z˜gy¦% òG"2‡î!ÀDê->àç|IGÅE²P©@ë3vpl¦ óe°Ñâg9& «Xr¸jjaNNBƼ óÈÖ´¢žvBÅ ñR&e¡ÜÃùŒÒhïÄâúæQ×+û’ätd*Òg+n¨e4 Ù¢Ù|E¤nè†BÀCÆ2B”‡ß"Iä8 Z>àh°ç¡œJÜ‚.´@‹Ù y íÄüF ÿ‰ñ ’±Ñœ”oî1å‡ÒÞdá¬12oÁ NÆúÇúðpîoÂQ*§™/) SÒq)>e×1 0ŠîÜÑbt ;®ÖØê‚,ÂŒåô‘Íòb¤(«Ì ¥Ìâ•„'/ÃDCRi^ BœŠæÈ&lB2’Ä‹¤‰Ý€é3Zá3â†Ñž. ³ sö¨"0“£Ø=ø~|÷àTâ&±ƒ½ôÇ;bQ¨ïDZ0e'òÃ?r’œ¢s0®$Ÿ®)_sT2Ñ6Ų.¸r7a./¢Å7¯¢ÇЂ#2V€¤3«‚"(E¼­Ç®zé:ÿ©•þ¡/‰‘0Ò ÀhÔFõ¥0É3¸°S9ØN"órHi”8.À Ž” ¾JL²Âúø“»*É&ÎíêŠ*œo¬ì.(_†½$QãT#¯©†…DOàüë*õq©B¥tÈB·â‰ôAGÁµ(!“²š4»ENÏòIEk'‹ôAv‚`0c݃F‡ÅÐhFe” ©ª°ê@ €S‘(«~á~† ÊQÇd&âJP@wbSL³’€LúÈ5kí)a“°üC×ìn#F%‚-Böý*ÔØò" Œ²fi–¢¥Ç /$À3ÿhcþþá&Á–ÿCEÂíÿHë.IØì[]´Rý†<é0‹£8Ž‘Ó\4÷&Õro8†£õÚoJ•Òœ‘=§ÑöÚÄãZah¬pøUÐK¼úÕ2…cêß.ȯÜcÑ=jÍ]S*ƒuf(ñî<Ï&v»Ò+B¥zìî!¥†Ð‡¬ç3^A$ &‡*„d™V ܬ'>@HŠäÚ¬0è£rÞ-x€9]T<ÙQ@0çuIÂoè„ÀîQ‰ã8P =¯ŠÒÖöÆvl 6 v\&‚cÑ+¡±ÈÅJIÐSæX‘ƒ€Œ&8öwdÿ+ñ)»ErköñWö‘,2T­î¡-9 Ç†ðGxª±J–(† òÖ0„)Î(GGºuô|ÉNûT’¶*µGƒj)jU·Q¹– 0î•^€*¢8€ M@9”ƒÅü%Ž‚wo QSûµ(€9m*0b•ï?‹ŒJ¿+A;‡?2¨(ò6ôãÔdô±ÊBÙäAîÚò2@e…°8iQ#ãBi  M—çÌè°¥g«ð—°E2F/:EÏh‘ר"èik—Nd”U7kؘÓoˆ#_ìÆ=XrÒœ1Žhï‚%ãª6u^5ÂQ^uí0ƯšOcÇFÿ[°zkM@µkW±ïî( ¬B7…'euˆ’¤)³´2Z‚¸¬""‚ZL1ê´@³‰òWô¢h±‚©gyV”öÔ0T—i[k³6÷xR±–*˜]9Íœ/_Z2«°ê_…—ö˜«à˜)-‡@#.…>fJ d•ÝÎbšâ4×ñQZX*õWuß‚U* ¿ôÂÀ~Ò¥Ä÷vx‡ÿ8 e ÈB[@q[@ýR䈱炪\ó‰E>×3¢“g½°&x·>à u82­QÓõ˜RíÕv1y—½s^… &'mŽß™%™ŸQxá$Ž(`O'ÿöX4‘@7›“o±T#2¨R<6ŸYd7ö*¡6©‚C”õiÆ7–.48Õò-„¤ÚZá¨Hs-O0<2tEÀNù¹œq+TÔ*¬ö Õsïx9‹»ø 0tT_† $úªØ˜¸.š¸Öä*°n™—l—¤ U=¥'DÕê»X0iÕdö5œÇ6£òW[ó%0hÂäzì¡§¯"Ì„3IL$CŠ8.cˆ­žðè #{Ž ª£º•{–´( }4"‹Ý¡™Öo[‰ôr/kú l7ß$š&ZS±ª6Úÿ!!²JŽ1º õÆ£AÚ@ºÿR'©yCs(çãš1…je"iíj‘¹T?aª ,¤TiwnÎÎ2 ÔO!éB!»ÍDhŠÁê—fGo:ÛE‚È•ŸWY:k"²­"«j#ó*¼š^«62³V¶)1Û:Úú%Ó:¿îç嫎ۢ[ŒÅóœ¸ ¤Ÿ£S{"°•&BØsêíJ3 ¹)€ƒ¤Â™ûh0*‘ï,ï* 88’£­BaÖ 2Û[Üóê9é¢Ç©ßÊ=RÙ•[™ÛüÛ&$¶sy0g;¬SR³ú j“‘w•C¢‡€¢©Î &º˜åǸ;Ã[ŒÃÓ9^ì .Mb iÿ튰±;ûâ4¢#NœûQHlú6"¤BÊb åñBä->äC”æ2ŽøEC1\¤#ŸšX¨Ús=£.í”r\yƒ`ûž—Ë—cŒÂõÒS_¸ÜËÙhÂ-œ% â Û̉ûb«Ü¤®ì–?gBsôdŒ‚V?'ƒNØÚÕb=Îó& r졾(;’!¹B¨?äz®‚[ ‰«F{Ž|µõ›•ûwsívôÁ–³²zuÃzi™“ s¹F¡.=MýËy·êÒÓ Ô¤Âãç*ÌÃÙäMàh«®»®þzÿî(¼*>ø£á “¾ù׃l{?À`„>ÀØàâ²ÿ#ùä¾WÑ-ã/’“H@ ´Ek¿¥x$u$¿RŠQ[l^ íz—½8¡m7¬ ^‡ƒ]¿éËÑ“œÂ)_Ò„ËïÖc} ÁxÄÉœ>¬ú‘K®RüØ ÏSÓsbúħ4 Œâ5±CN+3˜‡[\Ý0øûÒÉ•gó ŠÉU[¢ˆ[ @€ÐýüÀu[ŒÃ:«¹V0…#»Ü8ªJw»V{·wgo9äÚªð†¸"Ä_Œ95J¡Ô ª×#–ƒô=‡ˆ=o±—œ÷ÎA…Ö•æ@¨wç{É2Cè0¤¦ i*tËù3~$E µÓ§g¹ mb›ÿ˜“9Ó]ÝZ€˜kmÔ=ÔPMÔèL†^œ8èóý *<«(8!ÞhàŸéâàC3 ;)*¥nU\¡¦¢ƒÊ»A?*>âÔëòQZÙÚ{† ýG,#ÈÝÏíÒò®¦µG«v¶%}ÚÃ&œýþ(kKÀv ¡W÷ ¦œ!˜8Ê8ê8¸çÕ(¢'˜Ì<=Ϥv b­3ÜÄáÄ!r=âuý(<ßY0IœïÅ;g):ÈJëê».ŸÂÿk|i  ‚Þ¼ÿæ ,HÁöBtø/Jˆ( æ#¨O_E‚6þ[ñ¯ã DĈ(cED†þAxQñÀ ÿÿ,|!3È \ùtÅã_=õ<²)Á•2­7„)S¡Bë%¸Ú ÄR @€¨µpÁTHZþ3k4­Ú…- UpVB…²*ºp·B]‚-/ü«°Ðï¿ ôN¨X˜0à ÿuLP0c¿p'ÿƒ;¡±}†ÿ£§ð3BÑ 6¤7‘bĈsýs­ñŸ¾±O–ü¸BÈ‘ÿH¦Œ}ö2I—%`þ£yyEœ; üZÔU=C7%¨”*Á¢ÜJš jT«T¹‡÷úïj×T¾<"yoˆ‚¡ákë,[Q‚!¸— !‘ðŸÂX[~X`Æàb }0`5&Øÿa˜AxÙažýó!ú|ð# ¤ÐA 9DŸ©E} ZE¹á¶Ûní°#ñÖ›>$y˜ÏfHðREy\ríÄ“+Ï=W“N>Ù”}KawÝBâ…§^zå-tUE]yÅ^EÈ,$_}Ct”•g[ûµ4 _uáåו5VA†æçŒM¸\†öerH,…pXEó xÐ?(Úã¢DQ\t‡®U$Bm3Š@"„D©ˆè&›>^¤¥ó¼pLØúFþÓs>E·]Pöe©–RHMÅe²]&p—Ch•Þ˜©´Œ/g–…Ä ó¨þƒTÿ¸Z¦ÅŸ·ŽÝ•_YCþ‡—ñ×`¤Jé^YöÏN@/aƒñk!F| ­åP>Q|Oc ç“KF±wÒ©»ý#B+¦Š€HJ¿i$Aà ƒ(AÁÆwòqº.„NTV%›õ둲ꅩ]³bŽ Ö?b€Dšh-´YÍí¸àbÇ_p‚Áåß~ÿx+žè¢KoE– bûú×× U­`žB8¤>rYÊDBÜ 9Dѧÿäó¡ÝFUŒqª{,ñÀù Î0ˆ¿dÜÊåj¤NAüãœP¿$¬v2{'f´êyÅW8#›Ýæ©ô|mYñÑÇWH† Ÿÿ·lv\[©ÏÞ&ÑqMmûºÃ…„^Ýéew6¶õe‘%šo¿‰Fˆü ‰~0dpÜv'šV£¯I¬O§ÿü‚:ÆÄÛo)mV¸á†CÀ> /`ð>Mºb€r-àkONå͵g¾,)å:× —z²Â9¤ÂsȲJTÀ$­…¤)ò1‹·àD!˜ëh° Ò2˜”ÕUD„âZÚœð™ýü'8u‚Ìbô²<ÀXè0“QŒdC¶;QŽbɃ"¢| !–bŒ±Šh| ©XnN•’!¨M# ¢Ûƒ¼@´¢U®èǸ[5Ç=U”2¥¥] €kl#ÿSþ‡«tn©X W¦"¦f­,ÈèYд¥% ”åh"ôÏë–f,ì(-;haR¼¥;¢hjU3×Ö⥘ÉP2—ŒÙ„<þTf`³3^È,e‡Ø#!è”JTB_(Q#«ÂXǸw(õ… !mcD·x„ùÑŒq@Ë Ð“2J©"Üczh–šá‘õ‚æ2[XçT¥È,»Å]dârϱéî@eí'dª¦—ªéIOeeq›öŽ GGi D"Ä»aÄ{ ÉÈIô!ÿ¤Äæú ,¤ …Xƒ¤,8BIç÷])’õIP(û–úÊriaÖv¤¦z\Ü” S Å9*¸¦õÜL\ _Hœîl§:[â­vbË?V-d›‰ýk?ÑÛÝ}tϪî¥i{YnsóÃÜC1wÆ‘‰^ôB¢£Ö¡sƒè¦Z5QŒ|#RÄ«ñ âÃ@ ‰Mì?XP÷ ó­ß èk_ ླ¬ÒØèE3µ^Z–Q²YÚ/0=œó¦„[{Ÿt®Ž¶¾]'Õ¦æHãiõŸ`WõIV}Fh1d»  ‡– J柿unX™ËÂCE2-¹GàÂd5ÿFrÄ>¥½]Æ5p D&°dö©÷Éì}/ð PeA 2)—ß-GîÖY"ÖxÊlžÐZ'ÌCxVW(-‚påkF³iwÊà:Þ±ÍdBÆ›§.HžØ1~Ð ëÄ.@Z¹Ë-·>õJ ú1:´—X)#!²É‡0ÖsÓþA1üC ÅÐ÷FÚª¶‚)É iØC ÖR/$¥Yɪê‚d%8A äñÆ®lÖÿxÁ•[ö[§q!úm©°¤ã”!X…š 5J#¦0-zÖÃ_Të"¤š·ò„ÃÝ ÷žú¼ ¹Ñ!umêÿêFëÓÎiá±ØÑ£œñ½/Ç „ ‡†ÄN{J°75 rŠC™‹%%À«eýYÓúq·²¬@@1K˜ÕŽTŠâßšK)£ÍùX¿°<[ÍÒFi#,a (O|f´Z?¿\Cé3ùÚ—é cú}åë’‡áWƒºznã Æ•{}€PUÔ3¼[§B †ç¢ŠaŸ¤ž|’ÁîxÀc¯«Zµ 'ÆtŽs÷8‚ÑŒfdi~› ••?e¦—£Éu,?œGžç“7­´áe¼“j]Ï!Ÿ“^5§‹[ÐRÏWéõ€ÿ§n¬Ç bõ[ùAo÷×(1vÿa`{i¡'DôÀôQ¨Ñr£e^ !!wíõ^Í7kñõXµre3q+Ãc}€Ç}C1f´?†Gãv[Pݤx ¡@!yÌÖ~î—s¤%aL3IxR'æFcÜFS×zQ€SH…¨nþ’<5v/¿S{Zèbò€jqóð 1p0f7Á†þ‡Xÿ`qÉ'sL@@‚ЗqG‚eÄ+¼â2A•ƒLÉ$D!‰wƒ¸ƒÝä%:·?yÿà~:ÅsئSî´yN‡VÊe\ŽÁÁ)UØz qŠ©ˆzør€—uÂÓ_†ö1ÿŒ@†dXx‹ô d.¡j£Ñ ÁE÷pŒ‡Žu‚·’+ñ“}ùõ86q;±Ô¡L‡ˆLƒwFØrÃòˆÑ¢lé‡m=%AcQZÐv‰ Ö…5†tè² ³'¥xŠþç©x¥—/þ²(~0Yzc“uòæûP‹kÑ ' 8q«ö6!×,Ð%ðdÿ G+ÈH‚ð|9@?·¢8Š£+'#,͇(Òa}ƒ×Š8lÎ43;¸ˆFàTG>¸f„—7:<'„µ B8„C³h 8Š¿ƒõhazú¸¨ø„üUPgxrÅpõÁ ‡ÿÐÿ'pÃ(ÃXÙtGRqG°ö9kr™r_´"?Œ½:ñ^f}Ý÷Ö×’†xe%øˆ›£l ð•‡1-Ðmê8:£Ó(Þ–Cj1{ŠFŠOh{S•_#!¡Ç\ðg[)3sˆq—|É,ðdî3‘tç+ójpY—»Ie²†µ’—çq„x’Ô¨×eÐAdÄœ=ÑÖƒ‰¹˜èx’X„™ÌÆ“’ma9?Õh–e ÿ ¡ÈÄR…wŸŠy3±¨@(JÊ™Øäx˜É`ÑÆúagëÂg³8G‡.çF\è„Á#•Ás…ð‰õwšƒ¡÷é&Ÿ`‘‰q€qtðn’›wx‡9@ šwÿP Ÿ°[ð¨PY aœ.¸²@iÿpJÊLUÑM]à¤Pg ¢.Z‰–øx©Ð¦ë´y£uHV‘1HW€@*3T§z¡WUÿÄ.ã¦kQ,¥Çx–vÌ oJP—Ηþv9=`8^6©—óˆ¨À`' ‚Àlt´ÿ1Ú3îäNÔBî¸[í²B¥é„yÒÁ ç锥ˆŠ…FIJ‹«ºðMši†xx r©š3@¦ §ªÎ*mZ‹å8-¶£|š:r²s¡ŽêŠ”d¨z–'ñêIâF¬‘Á¨þR!¿E„z`(3^°ÕvUÀ¸·•…­qùy{¹6á­`WFpŸ ”¶Š«í'wvAc;xÁ.}‘£¯HG¬æ­7¤¡~ñ„v `0’*3Ð{ŸWJ§÷ye÷³K´õA&Úi«ëT”qÒLçt‘45}!;Vɬ)» ‹b@еWG ìéÿ&Æ—t t`%ež:ë¦0ªÎªvP´ok´Ó’“1ZJL»U¢±£·$J‰¨Æã„ ²Ky4¬UÔ2Ðú€B­Jª• »ªÑ·•[èá¢t[J|'ÝUTÕ[ç4 ïÁ;ø!J©i”ö †È*…SXz¨÷Ý 3ÝEµ¨ ¢à¬–à–Ë»o‹¹r‹mNÅz[Hp¢t£;IåbJw{U…Oˆ…¥˜ž“žúÂÖ«/^[Rð¸†[५º»½K¾Îê×9«ØöT]o±½EO«UÂﺲùÈŠÔ éIû[¸¦¨½õ1ùY¾kÁ³ŒÿÀÉF‰Á«¯Í»®Xã[î!²‚ѧü:zðö[ªG…ù¿$@ŒÂ"Ì"\°ƒ¬a³V"@À Ã1ì¦r¤@ ¶€eE¯{Vnš'ðHVóºe³Š®«/$0 ¼¿ Â$0$PNÂÓ‹j.á$,ÃWŒÅ½KÃÙÉ£ƒFCw²Ãx„.”€’AVR°ÿ7®PÄ!—Ä!Ç%p %@ÇsLÇMÜÄJ¬Ä!Ì>+ŒŸø·2 ë¦F0sY âÓ3¬g^SCLȭ뺃û5lÌÆxÉJÖ¿ý{ éy @Ç¡,ÊÑ*"ŸÜ¿x| `7d ·$Á½nª­Þ*ÿ±ˆ\ÚºÅOh…Œ½ ‚¯QÇÁЋɒŒÉ÷¸ÉIÌ¿'ÊɬÌÈLqg{« ·à(]馋ã¦ę́6Å5ÛÇì³É"<¡ìÄ%ÑñÌ^ì‡P¶Ìt v [´€ Ï«Ð÷Ùm:¸ƒ¢3 …¿ÿK… ]Î(©Ù[³TœÄ'ìKó0ÇÍѣܤ±©ÔJ=›¡Ìj¡ ¶ÇÊD+à÷ Ðÿ@ÐJºÿ¦0 ŽÝD‰5]Óÿ "‘ÂÎÀ8Ñ@m|ÓëÆ@ÝÖúëÉÊìÔѺŸKm×wm×tMË^*»“j±àšÀÚ|Å3=&ÁÖl­Ä ‰ÂùâK¾ÄÉzLÖrÀ×ÿðÉO Ê£¬×²ùdGÀÙ‰×L›ÿ@Í^mÚaË193íý‹p\ÅF ŒýKÂ!lÅ&,“-©ý«ÂLìÛݤI Ú áÙ©‘ñ|×iq§Íܶ'؃̓‡!"J\Óí¬Â¹íKzìKŸLÂÚØÔ›Ûû+"±ÑtݤÜ¡‘ÁÙòüÙ²Y)Ímá+ßYŒYÝ”Æp SLÖ×­ÂÀÝéÉ©üÝŸlÿàpÌÛ‘ʾ} ½Ÿí–á^ú™‘ ÁÙ—õír0 áÏ ÝW1Ý.aÄØíÁ{ÜØÞMÖ|Ù'þv ŒÇ! D%Ç£aáÑÚÞĨŸíµŸÙÞ±ßEû ®šŸÐ Ö ´€­áŽˆx¨Èü/ÞäמT®Ä&ŒàoS>Nç]­ÞúYÜý‰q7›y¤:±2ðô}Ÿ”ë¦zC«¤p9€äD;ÓÙ|<ÅS ã¨x ÊûÍÝ…þÓQŒÊDݤD½áéÞúéŸ~æÈ-› 9±9`L)³•3 r« ¦ºp®šx.3Ýê¦ÄŽGìÿÁÁsèp,½µmÙ°럜â$œXº¾å2žžjñÑ_žq·ÞOVá±yì³Ò`>©ŸÀõS<à½[¹DáСª @?[=©g°ê¼{"ÂÛFœÊÝ]ÊemëºN…>è“Måp<ÞÑÊÄE­×ÄÎjéŸÆ^éÑ– }p®¡ Ê釩†40L¯¼ªª.3EaäªI3;…¹]½é>åúmÙÛ) >ÙGÜÝ Îå ,ãO,Çk1ìÄ­ì$ÅÙþnò›¯™÷i Ð }Àÿtð¸`÷C@F-è‡pC9Åà|ÎÇô嫃w>lãâ_0~î&ÿàc}èbà"¬ß{Å!gÊ>ã¾íà©,ì'›6ïÙÿ ûÇ1& ì±Áþb°[ KŒÀ£({ðF0»„æÑð2ÏðÂì(Ò^“Ç(…2 ÖT\­5„Xpè{ìù ŸÛnƒ@žÞª:Ф‚Z‰%—`≇ Ñs€§µz*o=‘ŽRé… ¶»j¬«Œ’J½ª@âÑ4¿Äb¾*·ªÇ¬zâŠË¨2ËT+͵à Î/½š`±:kп{,A® „ÌAÂ:l³Â>üŒ…¹ ­¨F:±Eyîaí&-¶yæ‘ѨBЂäñ’¤‚ÀH‘HJ)ƒn$,yPrˆz¦¼Š=ÿå¶äh>*ÉR+”¯Ô>™3¾)þ9$úârÅ•ÿÎt“­·¸úï˳Îúê°C±Âã °Äö$Ì(+p·Ì4$A3£5qÞzòRµƒðeíŸ~ý]Ò¢î)ñ„h³Ç¨(>@ŸI5ÕÔ^(®7VE’RBj©%°ãÁ'ÊËÕ$Óž¬/W`Å#6W¬€‹8ÙÏ® Ø·®uK?kÿIÓ?Ÿ÷Ê–+û§/<CÔ(F¾Œé@ÇlÐÉÜŒÃâõjDzOC-4¼<¢ÅJ-øˆ%VlˆÓNÿ !}>˜2H‰IZ̧UK2IJ s‰nZ¯sΡ¦Zï£ÿßP6opš]v9¼+a–ù+,˜åYg£òÓO­ÿ,¿|Z£ä Ú«ÐéD°@;0Uo/PÌq„c’ª¸¤7У•s†pîùÎIì»ÒxÈr€Ák+W"‹wŽÿb’±à ï; }.×&ú‘Åc–Í:×3½ð.iZšbV'…1AQ;Ѓ"˜ÅH+%ȉ¶µÓÀ¦Ž¢Á ‹¶<J FŒ0aÂÜ–è9¥É‚éal:FP_t^€Ÿ !nS²ÊG8Ò,Çu“xiÖw5ž î}“ã™ùÊ4Êañ~\Aþ´Õ4µ…[JkW;t=ˆñV!4µxqæ2šWMä5ÑfD_ùþáAT„+bÚ‰¾ =4“’õZø ÁœÈ!Ü  ž¤‹Ôäv>2Äù`E•”ó ”2ð\ñ.ÐýbéŸÿÌ5kXeYË+e9ËmÅÅLoñ–QÀ5×=f+ ŠŒ`Ð(˜RˆC·àP-“µ:eƒÉšQ#MNs5iã”=”‚ÜM*ëáÈ”VåS•ÓœçLGhõh'o‹<@ >’8òõê(cb°®ä%œ–‡Ÿþ¬³f–\«XŒ%çx¶¿± ÏbËšX­£pq?öá™´Ôt¹v…€¢ÐÄ(®_ŠBRŒ¼:$/:fpQ)QbMjƒ°†¨æ4«9ٗˆ&,@>$0ªãHl}F GzêÓŸõÚØ°®âxZ<õœ§ÊðyÄ©X…YC|ýÚ:Ĩ*ÿÇ|Z„å\Ó¤ŸÐ -n™-€¦¸•[J‹[ø¹eY!04¥1ÐBUcv+úKs¹niFÌb>zµ yæC·(¬ïŽ¢;g.65x1–Q({ƒ]6aoãÍ eÕå§{-ñ©OrNP-Ða–f˜`óåµôTåʼ·¾ùÑ“bÉ™UaN–§­bÝÜX{†Õ¡ð¬”Ã\tEüܲªéLgŠkš†öÝë*ˆOQÔ=ÃQŽ¢qjó@ïÑ{™¬•à™Î\ï¥ E&EšÒÜãT<¸¢h€NÀÑJúfª‘tÙ$AØ[tJ[ÚìKChÅ ’ç¬D8 ñ$xÀC>«ÖÇ|ÿAì2±Æra°¥”<+_=EûB×'/òsZS¹?Î]+snJˉђ&²ÔÉBÓ-ÝtÍ»¾F2ˆbcÒsµÙ.ioôŠî©L1ÙKÓ4Vx4Y‚-áôPÁmòÛå–py*™€+^PΘÓ(F(ó?Í‘PÀH/‘{`€¢Æ9”Ÿô­˜Œ¨¥‘TÉÁD-W¤ØTGÑ­^qëm3 3z?k¢âpû÷bä¦ò~Ù dÒei2æCßE »”ÆÝ¡íæCr|¾†/†<*±G d§™ƒP¼â’˜­q}›#Q%=žuÄlNŠ›ù(f~ZÁ3‘,r”´ ÿŠPȳ8šY)”Ün?íÜàû•o“ 6îž“û‡f8Pžìå]®Àë"ÝJÂ3È5®TDª>ÑJ1P<ng;(•¶Ú@Àyè‰N©&6F;û°¸ÉÉ„!8›ÍÅY‰r\¡f—oòµ=èËÒ9›ÇÏ÷Ã0¡Áž>3ŠQàò@ùöúV€|Ìb¦÷2F62¾Ô»X£ÄDÆß 5w‹³x»5à °*–py†ÉaNß—ìc›ªðC8@{†¶%Â;GÎæ âSÿÕÚZ…Ãæ±| ÝÛ×J5X=ì[ÛÂ&úsèÎC.Óã"ýQ·q3ŠÚKi’¸Ä:]²+,Y¢›² ÌP”‡¾ “j8ßQ—z¬¶k;£€·c»’‡yØ,^£Q2 Wà!YéŠe£4Û©x0Kz¸íؤlË6Uº R _)òPÂ+b¨²’–QÙš«½Ø™ýc½ý¹'wû°Êy±˪žÉÂÀ¬‹=õØ ô‘Ú“¯¨=|˜Óø&‘°) ”R²a;Š+Á(Açó  é) ᘡ©t³e3‹3‚rÂ00F¯Äÿ3‰µ  3®*É•"äg¿`–9ë!®Ð$ÚJ?)ҲŸ¶Àªõó¼¤û¢ëBl=(9ŠQ@¤iв”7ÜŠQx€Q b܊͸@ R¯3<Ãè—°!iziÒC‹ã÷{,Ž(”€ß0D¼Ó’縻é5®HŽ À4»šŽhSî©*Q-T4+² ñá¤Ü2ËÛ0Q²¿a1y³ÏÙ )аx‚wâ΢¹àð¦ÏŒÁÿ: rjD‹ëÂëNÂ90ËÄøt¡ùt¡Ú¢ÌTJõ«M|Ê­§b?®à•ÒS1¼ 4uSÊù½ú ®Í??» !ù ÿ,éÿÿ H° Áƒ*\Èp ?~ˆÁ'äš ˆ Bt㟠?âû'Dˆ…­U€ðå¦4ô#Ë–_þ›ÁÍŒèxcÂK¡!6jD*aãÔˆZ»6|8Âɧ\µÞøñcãf%T aƒUã7òUXÀžÞçУKŸNWß?}#Vì´ŠkÁ¿Œ}ÿ]ÿû˜àã´a ÿ[´òLz5gÊ›?ÏP%63š€(‚Ô ¬q„‘@í)•‘a[ýÁa7,õÔ teHa…ÝàU+|´[ØSA>öàu$–h"‰p ”?=´Â X°@q `d˜Ð\3 HÀ@ƒ‹@ÂáQXT“u-ÁÚKž 4ŸL5ýÃÂ<%ÐDÁF%õÁ "Y@ý³@ƒ´öUn9HÁn XØR†E€Ï`~P@<ä–,žè矀&Ä\#Æ%Њ^f7ãŒD•Q¸\ÍG£@óEÿyRJÿ5@,œ Ù KjöÏ“4¹ÄM†4EÙ–?ýÿ£å?!py¥ŒhDœiñöH 1Õš"l„Z]êÝråè³ÐBËOž+d?؉`!/†•¦¸ƒUBìø‘GYµ‚¤”R>)Ó?¤ÎC©÷Ü#MŒt:#9QÁLÿ~K~Ð׸iU>øøÚJ±À&І¥5Õ`)°s,ÆíÇ CÇ"\üŒ€È o¡œrÉ^uˇ%§IKy¤0Jeôï?%°0Ð|¤Ê#ªfóÝC€Ð5ÅT§Œ”€êL›ÑôÁXƒ´Ô3 Ò?¾þЊ±]0Á¹É9."4BÎô!Ç rŠùŒ`·¡Öé‘TßEÿ¥Ô ßaô°qE}õ°Sú Qæ!üÛ©§Ê3%}'ø,Ï=G`ïLP÷ÌB NÿsòDÍHåóÌWB`å`+½1LÃ?ü#¬\RŒUV?h½`‡:çVŸÿ´ÝçÉp_çqññ/÷ó&BT„—aÛ§¯}÷]Qß !3J·ßËÚx R†>»¥Ï‡Á@G‡j9éðÏûšÛKj ó° ÓÔ]bÝ‚Àó”Þb$¼©EÃ÷ l‰bLÁPÖæŸ8ÇÎIÈÉøöüCüHÞò GÂçŒìPˆ`@ΰ‡묅qMQ$ð”‡Mˆ+HIR ‚H q›ÉúÿÖ/xÍÇ~š;Zäì÷ ÿ€b€̱ 4,° B€”øÅ[­Ü?FAÆr…C0Ä Pì * ×4D™>ÝiDÎÛ`ñ<À7> Äy% $Aª¥"ç‘Ì!ü\>!‚“}çE€Vl2¥d%p^!SZÂ%Æ]f¤ò™”By‚#í~ö’ÿ‘ƒ p¥@¨x0",ÐÜ &ž,ÅKº²Í?€ŒQøÊ+Xc ó! á)\ÃØïÈæýc„‚ g]i·½(|Y·^֑ؤ&’(Áqj„ˆOÍ#5úØ*çÿ¿œÀŸTºþRÅzÕб|¥b™úåo3'¨×N0šG úh —Ò;a C ëZ=ÇV aCà(Æz£à© |3Ù?ÖæŒÀ#@‹)Ξ„ùΠ‰ˆEJÅ;bòîhˆ• 8 ’Xƒ¡­òhÁ J÷’*]îM„Ÿý2ÇDV¤•P¤bé*w„ÍM#ÞBJ{6 ;^![kØ &´ \à™Í”#¯6ÐUemoÊM>Á̓>,BF†²Fb+*|R#°€ŒèãaÙ3$#• ªGù—tXî/œ©Txê1¬ëåUô¢Âã¼ 5»F}™TVC¤&†É±àF²aXå$Õ…@éZ-΄@”¤ë–³ìDÔO‹§Œå—aÙІbÎI’ƒ—•y+ºÒI `8ÌD"„ c@ÿà’œœ=ÞàÄÿ”v§kÉœ ù2½’g}³ÞŒÎÿ1†41Ñ[/±%6A°‘‚ Pbó)eBWµC;¿’ £pW¿1!á&ÙC#Ä'&0^ ±<:§~ÁS],òm'änÓÒM?Ø16—“ÈhÔR‰+B- ñØ¥^D˜]ÑH±¸u¬C »"$'!sKñ!ñ©ÇYKá_T`¢†S¦Ja'Jš1•3poXEhçPû–JFc/Œ`¹tö±GÁ%Ë1†PR·WÃ"Á;©0LW"6ˆh–×1úp~ÌñMß´xMDD÷@:ù9üãûUù 0E‘].ð‡ûÿÑr!}W;ƒrÈð+á£]؆yÕTcõ(áMqy6Vé÷1ç6-ýøSFXy(Sa@ ƒ.­ã±è2>)GY‘CNáþâòŒö/cwp¢Äè?mÕŒ¥`ˆ`a…9›³*¥4–ðV3‚!4„ÐЇX\^‘=DBÖ”(váÃcn,†×Myâ1,â,åUD(~Vt‰X®™]בXö÷y2ò0‰1#ú§z'±Šƒ¯`ÞŽï5Iabe(Q›Q:ù£{ÿ $U?Ä!'°uU¤9¤cf 1/lG*Bÿ‡suˆbeÁ%Ìt1aÑФ@ˆ ËEƒ~óG"p~§‰H²‰IYš‘ššÈ<Ú1é(û˜$óëçR†Ò'{³©× Þz$ø G@ö¾ u€árÅ„ÁE«—Üy4evp@3ØY4b%9¢r—SÖŒhfLB˜¢B¡vœÓ)!Pºøpbhã´G¾A–¹R# yÆ\ âˆHŒ·SågÎršU*yº”¨-‘VMAå6ƒ´MpQ~:6(î!:hÄÀ7Eö¡ù&á³Gq†SÖ.õRP‘V{)üSJwp>*'£_ÿ¥f¢2ÐYDÃÕ£óñkœ¸Ò*sÒÒ%qÂ+Ã)»ÑtWø53 ؆ü`ÖQ(Í“Ÿùn¥¹xš¸<š¸x•x~¥ùGµjšþIp±" j•“EsÚcA C¡Á:<@0jICŸg†P+Œ›ôOÃu[÷3(ù$VNäPe(?ÒI|Ÿñ‘/±¨ÿCc9þ³fT!7 cRûQ7!ªØ7ĵc0ˆ™ %1lóÝä¦Ù'ýéxTùM©I6G±ê«ÓMê1"2«uH‡ô‰óQ]HÁ@Žl!TQ!Ä£ ˰ A '÷yÊN«Ÿ»9ç±ÌÃx½:yUúƒï("‰ö~ØtCE¬}û·„Bs)BYyŠ ± A &ñ0E‘²­Ó¶S&P!%©%ú3‚)¨i˸€c'²U´sY/Ò84±¨Nb/·>':Z©4´¯ˆ]R3Sá-o²rra µ ]“ƈǪ£É¸:BT¹±¨Ù¥Ës¾êš×t Á,'4<Õ’è· ëˆÿ#&Q…8D¡ƒ–‘ ‰‰Z3yUœá¬+mµ)ÙŒïS:w*¨ £—ÓDD»Jï#˜@9䊑¶¨»Ö>Vô£LáÏx˜á ³WB°óµ¶â’°Ú%ß^Å”á¶ÓbÂʼ©©«¿úŽ&·Á·rძ2$sXwÄ  atù ¡C"œb#+À8–ñP&5ú`ùð)ôJüVï³Å—N"UD®Fºbõ†E()ºåìûô`A JN³Z©ÃËñöa " ê1,¼ƒËPL}÷}Û&.à €´¶»Ê±ynšsóH¥¨ÿi^8—Â3 ±×²CE-…R‰Ì±S/õSγSèÔ‘z@f”PO!À9/á?'@¢1Q:ùq*Ú9’g4\EØœMËDÀÁõc€i÷€I´®\FõaA„‰qcáøÂE9!¢D¡¢*âX ÈÇA™&9s-8ø™tAyô˜hç1g¦Šf‰Ñ‹”F ¸§‰'C•Éí|ÉÛ,¢ùÃFF.A2$?ô/¤T¯?1£cF¿úK6KÜËb5’qø¼œP`ÇDš#MôºN/ó @qÆÑyÆùÒ£"0ñºa²*Ñ%Ųb¥úyüÅ‹-A˜·öÿh~nK¹"¦­š«y;š,½Á¾:HÌr(wrÉæÏwÔ" ê KƬ }¡µGNSJO¢¨÷†HP|ðÓ`¨ESVº|PV-4ÿ€>Ä(*ðž‘/?{Ê8{£$5þšQ²òªá%“Ù;µ€Ç/ÝÛ\úšÌ#Ȇ,Î>ØMh›Âñ·Ž×¥Š†½ 1<Áw¿p†¬ûá\ͺ¦2:ºI²4¦cX!}Kà( ƒÀàÒá­éÈ7Ü ¡ïøØlûÓCÝ<ƒ{H–w«ö •äEycºL.(Û‰•ì6Ÿ(Ô}ÛcaÁ)€o¦úð/7m5ÜAÖÀg`÷‹{™pxÀS|´o¸>^/«K®¤9óòŒ†%0ó‚‚M.¶&Ç… ¶Î¦°|ÿc ëçÓ˜ýã7æšÀZÂM©šë”Ó[tGí~&[¦vrXÜû y6|ΨWn‘ÉrH¼ksŽv±DæQvau®÷UkvÛ©¢¥vD„vÅ-r®?½QÏ-/ör‰y:‰úr…/n#–ä òÈÐ .ý Ïpè4nåöLiMš7v¦ië~ð˜såméK·1Mß;æ ƒËÓQ¸ZÉsÖTCnÉ+¹` NQ¤í1/ôá?r¾ÛáeJo˜[‚‰?w볇[üæah/-Ð>?#Ì^/§ò¨ aÀ–ZÑûÕ©4“CÙ•‘}ËÿðÜŽ º«=zÓ'ëŽh<ïèè¶ÿ˜¼)Ô:wš>x ìW„‡uÔ…DäêåÙ–|GÌâ,†»y!¡5²2"°zÞ)&?eVJm…ËAvÖ`~æ jèZPøÅ¥Óñq-Ç-÷ÿ›JÑ Jh84!`ò¡Î¯§1\Qҩ騚9™ªøµa[ó "CÛÖî5]Ó QÏ IΠÎ÷¬é ×e9Q„2}y‘f^K<¤“·ßŽFY^ÂÞÁ’›G¡Í­fM¶>ֹ׋˜»ÞË Ì*šU¤{-Ð,ñvó€>×óâÜ¡×%ú£(Ïù/ùRUc1ÿ®&Rª`KóÀÓÚu-”̓U:°Ú1×"nñT©éÓÓEøôÅCÔ‡¢7ÿÈÉÒ üþý+0¿|*@Xá?~ò±bÁŠ Ü8aÂ<ôæ±xo ¼{÷ ð¯å@˜1 ÜÀòß“ÿrÀ“'Ì•3gê8Sž¼%Zü›'2L{ÿB„˜·ôßÑôè1úwBÞ‰®_åu7ï½h™‚ Á(ćˆ"2ô¯.] 7ZYÀWk0`Ëž-ÃG¡î?¹úþé‹w&cñbNž,™²ÀùÿklY²bÏ–5wŽW@qbƒˆøéS-Ð5æÉ NÖ¬PáÿÈ!øàøÆ7,Þ@ôH²%ŽÞ;Âb,Εÿ~R–N€À‘™81”,*]zË•º•®2åQyeµÒ{ú8ß{ª-¾ªÙÕkØ-HÊcqbžÛy`bk¸1ðŸ$` Éë‡pùÀÅ0¹TÓG Æ8ƒM2ب‹© ÊHŒÇ24ˆ±Æþ™h³#Ñ }*€M1k\Æf„m"oK(7…vƒH³×F‘à@D‚ RŽ…²žƒIœ¼û饶ÈË•T"J&–€Ò‰ñÂ4i¦{Žj¡…¦Øû ÍÓçÎ|Î p)­šºÏª¼ë**ÿ‰êª²þCÿðCèZ®&p‚ðh™À–Y—V( q5~âÙp²PE¤.DE"M5 Xµ3A”Q®Åp]Q®gS&{Ý ·Þ²7‚ ZmI©À¸XpŽJFX0ɤ#žKÉ:—`S(šÂs2nà º39³¤óø tž©>xWÑ'Ÿ©˜(À²ºÒ×_°ÆâÏ¿‘¦ENÞ ôùÀ €€Q (ˆà ¯ ˜QZ¨ÑÕ”¥5FÌ" uäÎBÑ2QŽ1¦Y9C²Å_slCPaÖfYMh!r±H‚Rìñ!‘tÌÀ¼zá¨þa$ÀlQK§#È]ÿ ëØÎºLu‹ªÐy"<†6‡T$«:x†ø wÅÂÌ‹&I‰Êðò(À¤hÊ¢ù9ózù_þ¢©e4£v‰®:¶:•d$SýÈG©¢ V ‘àl\ó:SqЫ{Q>»’¨¬„dÈÎ ôÑDn5„ŽS‚c¡võaÕ¶Cž!º)î‹ /c©•ɼ% M#ÙW,à¸\Á½¨ÒzÀé{æÝ“1ÁR‚¾åÌl)Ùø ¾¯ Äcå;Y}ø‡|)AjUDQaùÊoIcC(¨iaÙÏ´¾ày$x.8­”ƒ±x 1ÄùÇìh™8‚ˆ¨™ëŒp93Ü:uìmiÐy[aaÆu—VÎÀzN$*D:HÿŽiì¢ Ld°@t;…ˆ!d²aƒ£’r|8<œàÄ «Õ9–Ìð´„;¸«X µës@L2‡áŠyÀ..ʉ*# ~QCa"ÅÛº»Åè5˜°<ù’¯-[P…*ä²þÛ¿Çâ?¶ù‚"(t‘99 Fø%ÿˆ‰¿é"ÿfŠG™³°€ZÀ…{=sCŒàsãX•ËX7¤š*Dû=Þk•œyªU¡7‚°·«.Í`$ƒ«ÞØ y$}à†ó'D8£=(®çpµ1‘¨ h“³9?{H?ÁÉ“<‘§Åc©›BÒÂøò¨ùÚŘ›9/œ Í#¶Ây’›’Ú•’–þÀ(ÿ€‹©$½ 3dÀ”§7©;ˆ¡Ê½ÑAÔñ·q+šDû: 'Ðñªx{1>wú­L䙄³ ÜA’ ù¢Aˆ'ú‡ ˆ9£p«.ãhi¡šV -9´™‡VŒŠÂë&Ü;!Ÿ˜Xdû‡Š¤¼ÿùòÇʲ‹ð0Œ¬˜ÃaÓ2É)ó¨Ei‹²H ’&Ã.f* F­ˆ¦JA†fP­=ÚC©=ÕÑ79ÇZ•§ÒºB\BãÊRA¤ëO³;Þ€ ‰°h.Ÿ‰¤÷à§µš.‰Á¾êš€§2ñê øA/{ˆŠ9é±;±—Éé5ǺÅÂÅÇ¢HÇ[Uø¨BÂ$Ì.ë2‘,La¤òƒ‹|) ÿPÀe°}1‹Ã‰€œJ#Æi#?ËKAs•yJÕ ¤ |7n$ÄE+X)¤§,×lÇåêšH,>»'ã«Ü'Û!š¬Œ¾ÿ„y®RãÌ ,²O%tñ«@K©ˆ›¨xY<ÎH[´HÇk¼ø¢ÈøÂÅǃ‰cóþ«<„¢fy›õš º50ýH ˜8Ž €ø†a@†jâ”Ñ‚ˆl¸€¨²,¹!¿úŠHC“cÈœ¡ŸëQ_ûѸH‹Œ¿˜«ÈËÓÈbã2ó<ÏRƒ,aÜÎö¼;ÁÉ—Éà—d F0„À‡´3ÆA†=˜ ½ ÄÔÄY)ÿy›ªÞrÝBu»jŒxz'ƒ’Ý šÉÀ°Êå ‡° àK¾ŸÙ{0Þ`’ª>O«’è!¢h5¤°µ%\?ŒÒ‰H󵽼ʼnDRËÏû Ã\ì2 CU¸<(rLìŒÅB¬Ìì^‚‰™ÔÏÒÒŸf \p#%±4 û‡ « È@‘sŠˆ§Ò H{ªB=ªŒÕ‘ ‚€Ÿ)æë4­ šÞœJѰòÐ"Y¸ŸIˆ|ˆË¯ µçb¸0¸˜yh(naž+I)3SB*‚Õ&<Œì„Â[’ÂÆk¼ÁôÎŒ„"-LÒÂ`„»)Ê;¶ŽMßÛg1Tå¢\Út à·K×d)üå *‘9:S¨]CÁŒÕí‘sÚÿL, ¶`  Ž (˜ŒÚ­¥'*ŽyXšOÚŽ–¤ŠO©Þ¹‡<[ó_ËNµ]["Í2‹(6\ºˆ*ôê%¶‡®cã[É„OÀÝxгå¿_ø…K†ô… p–) <êJ–áPS ãGŒ‰C`LÄĨ0Ý[Û1>cê e(¬a.f_fÚP96ˆZ¦ÍרԔ¡.!@ãˆz˜)[œC¹À¡´2lÄ€aDŽaÁŒ O¥ÈbLÈRÌ.Ë^ê8¶É›¬·˜Š©p‹0@©ÈOOÉAJÈ…\p^†k€† ¨zzY~C®ZžŒeÎàÿ9¦èp‚‰†Öå1[Zîå®f{f˜hf’ž ‘NæŽ&é“Öุ$ëj’! ¨ƒ€(É1·ÐµÌh"³íQÉì\dî¤ \")zaÉJ¶UMUw¢92¬ÎÂÓ$MB¡J0ÜÊ“ 'pSþU޾\‘ˆ>‹Î`µÓ1(`Úµ^ëp‚‚ˆceVf >éˆ.´PzP½îk33æ°ëa¦ Ðë6H 8ì½¾`͘.’šîX!ˆ€ˆ;¹( î;”÷`¢Èd´Ÿ() U¹€ Ôxñ‘‹•‹dy6•í­/ÊR?H¹€A5 ÀÁ꣄K „"P¬ÿ\0eh€ˆKØXæ²Næ9¶ëHî’–c –ëŠFkäžëGlf•†‰Â–Õëø ¸îìÖk lòïñön øîôîkÂ6³µ1,t¸½ÀÊŽ8MŠyѾ;»:IÞmRmD†RÑÆæöøÚ[K<(ÔËGÖÞøaíÍd€ö#[»È þ³€9ˆK¸„^ø…hƒ_èhÀ…ˆÚå.ŽcêPfC‚a†ñŠÛeiЦkw‰Öñ˜UÿŒñVïÖëÂJoï–U GrïNæ"grï&òPï)ßëmŽ;¹¨¾9ìØha¸> Ão©È1äEÅ åÿ[ðr†#©³/´hz”ñúž©ˆ‚ÞYpíÌEÌ €pÿ«¼)"@Á) ×p!x,.wñK€†^hà¨XfåÎå“.fGiw2îçžk(hò(×ãN¤Â>o'7rS)ìèîî.) orYOïžêJª¾ëKaÈIaH…h…À>r¿|€›)s4ßµ}£º•Ó©PŸ±h‚«p“󛥘á5ÅÀ¥=‰†ðL>dœ[‰|†ÐòWà²ï…^p‚6è…G¿œ+¾æëånñ‰–u?u( õ'õSOl‚õ6òƒ_ò§uSŸr!w' ˆÿˆGo‰‰AIo´0ïövxŽ/,ô[yA„Ĺ>.†_§8# ø`P>v—·²œàY_K …‘ŠïK ‹J‰7I; ZgªãöºM÷ ?ôKPôL~«¾p‰\ÈmV½¼vñ\ q!ªC±n§ŒJ/éÃþ÷'ò±÷²'éYçëÃFïd6”fõÂîîˆÿîWOõ®¹û%—õŽïûYO$˜x } €Ëk^o“O…W>ÿ`gÔ¾y$Ö>²ÃN¿|v²¯È±x8?9;Ï…Å[¹©ƒ"ü;¶9üvÝîót§„ù¢€·Ñ>#y\†êë¿û»„ÿøð_pÇÞdæ|Wîa6x‚x¼/òU{ð&rè/ìÃfõÀ†{!‡~•^òºu˜¸û‡ï~»ï‡õ¼Çx¯éš,ù_×:\ùZX„ö#óÛ,TÎa<Ïócý³§!þü—+Ÿ¾ú\$$(âá¿+øˆðÁKþ Ñèñ%‰ õ¢!‚|¸pm¤DéÕ?Uÿ.]êÕ«“^Єð ¡âŸŠŸ@ Ô@ôhA( ü\êT…S‚M¡*­êŠÔ‚Æ”Õõ«×F5x5*)Ú‚1 MëömÚdé…¨‹(B+ µþùf!•°ÀZ ù—ï߇‡?ÿ(TL0Ÿ„ÃùLˆèŸ…ú(Óû×™h]Ãú6®<ÚEAˆ+þ½ZðʇˣgZp¹`¢„†D˜Ä7j”!/Ò|Õ‹¦Mƒ¿ A[Á(è?¬?±¥WìӢРbµ •íT³Æº’-êì÷ëH®}ÛnÛøD¡jˆAož½"Zå²WØ^ÀøÕ  vàd†Ev`e“9XPCš‘Fc“}`Ï?ö$¸ÙaQLvB£=”YDùpQl AM”ø°‚ˆT +X$ -Í4“L3%—ËqÐøÀX g¥” m€U•XT ÕÆ|mM%“ÜEwe|dýd¤ô¨0vE¾'ÿVAF¾Å%Qa UfVk õ&›ôÂú¬@Á+9ÖX3Í“J+úHÀXbù0VÁQŽ%Äáa:tÔf‹æÅQ TÐ¥åRW.ä¢D%¾Û%ÿ ·‘F¶!’­ü Ž­P„L2Ù„œrÌ aHVÝE÷SÔltaqõæSQ]™$}é U”M‚Õæ›mé¥YizéÙOŸÔ^{j‘©]“ã²uÔ˜åš5ðÓ*JÿãKŸ©¬@à &V(…¥õ`j˜ý“f$Žfè?¡Ý÷Ù@—ަ§uÑ©j+¨²€K”¨È‘©-Þ6py Ì(9¸Ð/¼ôš¿äòÿË%Ðà"¢[^Ù™’(Ù¤WÓ…å¬Ya©¹¥WXEËlÎAGÐxc}öYy`ªy]ºé©P$xG5µæ|æ™ižµôØ#Áh+€ð `}3ˆȘ=öˆ=†Ò‰Xb†%¶èe¯¶ª{(÷}-´@W ~‚ˆ¹é³i]?$‘*¤ZRFµXÐ+ü€ 0ÈàCÉÿà„ .üòËÊ5õ²ú?×qC@A·TVÐ1{•WÑ ^ÏÚ ],WIý³s”æI%'ÑÓ¢•®gQ–wµÍhÕ<ºÈ%'Pb#„HÈ󟩼2„>Üæ<íÿ3=tÅ_—=!`¨Ød£=JÿâjCœOâ7Ã)~(Ü æA)&¹0ˆ(çƒW¸¤T¨êˆm"²”ÀÀ>,#ƒü#uªû‡M^÷ !@C àGÍÖ³¤³´EIá!ZñÔ¦ã‰%gJjÃÏ´T®ë™‹ Û"—Wž–Ä®­HX{Ϙ„ößmje ¢–04 ä…^8j…&0yñe”Ç Zp‚yœ`aö»PÂBD±‚X¬Dš±T[P0µ@}Ä€<ÞG´@ ó”f&·ØdE é$b ŒtÂB^!^”ð¨;áÊXk°d²Ý×¶c»UNÍHÛ Jz¤³ãm…ÿ,AKOYŒè0ÙŽyÓ‚Ê%x‰˜Ø)Êô´Öl1 [ÿÑ£ HpÞó¨ŒCV‘˜ø ¯ëØ#I”¤D–‚KŠÂü NøEAz!„gÈîÀPâVÚ”³Xñ,g3$ÒÑå¤Ö LCª,êpE•JP:»Tè|†¨À2b· Â¼÷„‹(Oóíu‡[5yEC» ùă«à*A)]±þãiœŸY×i1¸F"y\]èAÀÎ4pŒøl@ÈÆÎÒÑq5ŒÜZ.'X™P%ø†/YU¨¢¿@M !‹Â_ÏpaàV;fÈtÜéf=:ZϪ ¤NÊ……9`A‰µ¼³Ž‰òZ` Åw×Jbÿ¶þ±–ò š!.SÒˆ»;¡$q©ÖŒQ+þ!  /ˆnV­+ö鑜h4gýB$‚"¸—‚Þ Ü¤úÖù!¤.%@ïÄø“ˆ0Y&'òA©þ:›™„ù'ªoŽT22¿¸èD)Ì…^FÉn¥»,¢2«gÓQ3Ô$Êa¨©¡SúYÏzælfìÉzR´r¯‚•á2QÄFª´Î¾¢®šÉ,^Ú–—|HÌ)¢'Æ¿\jøqÍc’›aeÁXÇê¾BªQ!£Xé’?v~ÙE¯xçÃòx¸Ðì«.uº  Âd±S}%Êå:†ªh#õµo-@·“Œ¹5.›ó+ ÿÌœȈù(cøQ7~ fÁ¡ŒƒÒégy´š©Ý‚ýg>gvÂPp‚g‹¡¯µeàPzXz'Måíð(Ûj†LÝ;ô(\xÞM^³\X rŒ Y`묎b«ÓCŠðš‹ôõ×Oà”ã‡8ÆM€ó‰ÐÚ£U{G©M˜¹{í4Â!AV÷2ÈÚd|ÁG²UuçÃÜTG”ÞÌM™Ò8(Aç&Š»SÍs;hìµ»ƒ °`Ù¾ö(ö0 Q…I(!O¸W|ÖY¼e­Y³Ô~‡bWÄ7„¬ Gˆà?Çú¾Î´}ÿ`At¿Šë$.‚Ïvɯ_#ÿ(KL~5ÍÀ’rþšù‘´)‹P¯VŒøÐ±p*¨Šä0…½x ƒcÜàS‡! ó1u¬ŸÝ3ª@Õ“(ãÿƒÝê´aìan ÕŽúHù‰M3„ýWÚt[%þ>Pƒø‚l«ÆžªÄK ¼©äG(‰€> p×öÅšC&ˆÈÁJ€pÊCäô@ˆ"•F¸†Ë}̽›±AŠf¸ÀˆlW¯aµuLGËQÐmDJŒŽÄ†ÐA¼Â/„›p¤Ä,À5õÍe`ÝÀ¼Kè5_Bð Ù»! êû,ŠBä  VÀð! !ÊaX] ¥ÅˆAݽÝÜ}3YÑøIÿ…”pK“D‹’0Ó6ÅÝ—$NáQ‚ð=Q× é쟩Qå ”^MЉÀD‰@YÔOPŠ¥LÊÖå`"ÑJé™ÏQ›FdŠTĉ\ ëK`Ä+GMdÄëÄÌ%¸!>D@²õMAPb%Wè]Æ5×eÌ`ó­ öÍò…^ä†óýÞÔ„óYOöu…MAܤeØ0Åzè,2ØutF.9!}hÈ l%0AØ_u™QtiÕVaÀ=d@‚)’­W˜Yk¸ÜÉF…¥| Q,„v9A€Yu„©`Ä%LàpøZÜKëá0Ý:þ‚*Ðê%â+ÄÿŒ˜„àÃÜ@²%RðÊó© jb)Ÿ&†â ΈG œÀ‰XôdŸM-• íLRQZ|RùMIùM‰!Sý 0"Â@°ZÓsÝCr@3âÚÅ©¡³­Ük\L²ŠþüCÆJΈx#õZÐEt„G¸Ä:Þ‰ç0”04>¬ÀB¨‚ÒkÄŒ0¼"äEY@v%A€ÏÀð ²Ä$zå@"…%¢%ƒ-•¥ÉZ؃’´bV„ lé–¦iäòŒÚb¡¦…²¸–= ‚F˜$/=ž1À‘<(£2f]Ô Åt5Æ´œæm^fô¤i öÿU©`ÎhšÊL@àŠ¤JlP¡D-ŒB3\ƒ0ˆ<>UÆŒˆÀPÀ¤Äük’å €%%¶q‚" gÛ E²éYž¥z˜I÷UË–H$¨5œ19a÷|G:“.NÅGò H‚‡ØˆÀX€´OU !&  YWE×zêRN8²Œµ-Rk¨‚wé þ°ŠC4 PÎĉ€„|µÈÆp„KÔÆIüƒ}5Ô2P–¼é9BƒMŽý?âRÜÀ?üãsŠ(Aˆ¨‰’hÛ(§r"牧?ƨˆR€‰¢(X~ÃÕg`ˆØt†ÜtÏ‹ùèZ,•}é|„ Á"ÿ©œ4iY”…÷ø€æUÿ’\Ä•…Á=xÈ7žˆTº†‹¸FéÕÊ.ÄC¤ÎB0 DÆFÏAàhZ@p\’‡:’È 0<Ã34CލLŒfS6‡B+lÀ(„ÐoŽhAÔè‰&[Œ‚åˆNb¤ú£qΨ?>ª¤"çŠ&'È€‰Bçf-•Ø œîh tV‘|†ØÇ‘©’âÔX„Çw¢¥åÃlÀ ÜÕú˜QW‘\ã½üRu]þ|£T²ÌE¬FpAøgÁä C@„ÎMcÏaN´UD`|k`ÔŠàWTQÖÑ=[FA¡¶ìæ?à¢þÀ?¸JAÿä?Œ*ŠÒ(@§?ºèWê+²g‰êkYNª½’jƒ½VÝhù­ª9ÑFê¥^2’šß§á”·,•ÁjÈŸµä…ûPü(^XŽ®•ÅTNÀÄK°Æù§JÄQˆþŒ0Ù 8kÏI›j’Ù9’OŸ¨Íøxë;6ƒŸê–¹á+@C3A+ ‚!¤o@(ü@-üœè½ÅÁrí¥Ö+Q¤è½Òèˆ&çr.'X’-¾E܈Gé¨}ü¬öV^Ñ2ÝNvr‹.†ÔÄI.@Ð!…À¼Ïà~†ûD¡,äCÐ,8Â,FTl,’ÌÄjLTÀ´Ó…Âÿ×iJ[µ5èD3,ƒ6½#A¼ã„>m<ëhÞ£¼¼BÔBIÜ€?&À?¤2 C-tès,Ú‚¤lZJ*È€ ‰Žè¦îëÀŒjÛº#üÃôRï)uß«Êͪâ1õV‘L'¶8“XÄùŸ.Î ?hL7Éß]áÍãV—͘*’LPÐæ0íKø@ÌlÍÌ’­ì²òaÇÌÆ%cƨëêþßþƒéX¹þiŽ˜=â9 %JL#@ A Öú‚/  A²‰eA”¯P€!Ìè ûëQô¥ª­½§qÞkZžå¾äˆ0bHõfÈZØ¬Š ·Ìÿ­—&ü|IùÂ}°KÝÊɪ~ÀplûêÐI?ÁÏâµA¤Ñy†Ä`³M‹TîÌ:çþ°SLÀ©~šãåtDB®øDŸ´.QDUëbÒ³‚™ì Á/@˜” è“@¤B€ø‚Ö®°X²° ÿ _F £íWnêˆ dZg&vò ¼°£"l~œ²0ö ¡ ÅÇ1‚CØò1J„Ñíâ̓ÇûØ\ñFä ýƒ­üð’ué‘âÉ\ÚoL¼,qŽZ‘Þ¬¸1j,Ù’ÑÊL–$ý¡AýÃ\Äå#í3,ƒŽ9p?mmD3M„ÉiÕÿA=PÔB-p-$ ð ÿ3AL­@tè¥pI`² ç?'ôÔ:j%G¯Ô ãDõ¦ò¯ÅÇ­ª‘JE |œÓ¬ŽlGƒ´Çy†[=,˜¸òP.‡`PÀâ,Þ}³¬- ù”×V.çĬÿjnÍBIJñ—_UHx„QH(0AøiŸø7ËNmé©B>œ@°zÕ3l߯ÿþšŽD eFQ«ÕjÌpÐF:Š4èñŸ.ƒê:T ­ÍþÃ…GŸqßÃ$7\ÀÔC€µXûB*PÀÄïõŽc]w#Ê€wuƒ7vkÿ÷vo7¢d·!d7’ Jx4t¹{ij·ïMÀ.S4ZTogöô2‚.Sïû ¶Çö˜¿dã÷X€ÓúÉl&ýdJôq´@>Ç‚ïìj¸ì³Â„TzCe¨(C,Ä€zî Þcå¢ÞQ"(%4eA<ùƒ·>&µÍ =·)·+Ìx=ÐxXç30ìóŽsùøø\€«·úëµ^ ³0÷x‚ Š0Òzb|w‘£5Ây’K‘kùáÚC_¿÷ ±Q…y`ö0B6Qt´ûHûQô÷S€+¸B|S/ EÆ3B|g|A€¼­®ÇoùÈüãaô2y’yïxÈ›¼­?Ÿ´×|I{\š§ôÍ×üûL@Äù€ÂÄtñ(ÇÏ%\CåFÐÎNeé{³¶œBF.#Üdg»CF ¼¥ÔOQAšI‡ ©Â@0ýþº,Rx½Kð/ŒÌ»þ×)ú›º×¯»ÆPeƒÒö¿—ýÏÕWD„ÄfÚ >TÓ…ÌÃ7¼ŒČ˽>ƒ@=€+Ä-lüÆßÂ??õNà×S=Q?õ×S ”@û—€ûÇ¿úW¶–K~‚Ô¥ Z„¡ÿ U0tÐ`… *¼ pà‡ 'ÒcôÞ†ÿæ1âèñ£y!Gй%JF%>(LX«!4†°çÄÉœÿèÑ‹"—ˆ!þéÓ·âÒª^5}E‰Ò¿W—¦þóñ꟭Eõå‹â5ÿJ®|ú\èû%bEZ¦X)]‚Úö_[ o-X"ÄCJs`]°@D×üòý³÷Á#„ <\ ùç¸^½ @¤úçËW-HH¸µÅ ŸGC(ú_Œ,þ­fýz ÙÿfË.q»ã¿ $,D4P`JàÃöþï¿Þÿ>T˜Èœ¢p !œdã?ì¹…¬Þ‘„H^Öm¥yˆ|Nì1ÌI¯…¾».ÔÝ:ð•ÚWª˜ª¢êƒ*þÒÊ(†Bøª,£D8ëþ\È­,¸$¯¸òºD¹âŠ` ¨þYÀ‡Š@d,~þ)L7clˆzrq2j©3ÌR©ç€þéŒÿ&ºå– žû¬5Úº3r£×dc¡„yv›"‚|;8…ZÈã JîÈ'%B,%ìª«ŽºìÈ »#êH¤y$Àç%JÎû {lr‚ž6ò¤OzTÁå}†ú —(-®\ø%+þ=KUV¬+¯:P,®²Bk­0ìP¯¨¢Êk.J8\ÀCVqÄ| Cº ãáÅ$›,•Zþ¡Ñd~på€  ÍÇwDm!Q:‚…#þav!g¥uV665RK‚¢„È$ ’ ‚‡Ä 7\(½dDÈž iÌëÜÕÎÝ‘B¨£vÉÈ$®› »ð±à¼ålˆž…z¢Çÿ!ŠÈ'zK´&ý%øZh!¬\%+Ò¤V(‚@Kd.MEhTPŠªC Y^(J^ù+¿þá·J™ƒ`‚ÅxHΕ ûçV*Óõ2_,CÖG'(ö:"uœíÙf­vöy²Hž#¨ÇÉu±E‰J²ÃýçlçÈß…ÐNL¸ÇF©$F®¢_¼æ´Ožôô»'D`˜'‡£0*âIs!j Î¥Pÿ§U$&P°D,D—zå*O±õCJT&=D¥>þÍÄ> ŠÖ\$ÚÖ[qE:3 è »‰°kZHnaÈÛ¨eˆÚ{RþŸ{އ5y}#èÿ·# *H8qÑFî윻V¸ ÓÍÝvÙ…W;ºIš×$/ò^×Éž‚5(¼§†/>ÁñèDï,FÜB2%9¤H*)ªH æ\u¢¯@l+‡RYJbÖ!S‘ÎT * ”"0`ˆÈœïtC«ØÙªvD³e’V $%$àÒº Å1­œl)Q=g¢žŠžJ E=íL CϤL0Ÿ†üc_¬ò¡0àˆ Éµ*;ÖN2ÿ°Le|qd$à¡ÅRφyI 6´q–*¥Õ'1¤lA\ˆ·¨CŒ‹&*½À$@Ù‰³mèb×ÛÄçu¥é:TtºœÔЬ€&—jO4ïg°œàŒ×ŒmÖ.æ°‡Žp<£Æé9tžl ˆKÝyÀ˜óL =’\C>wf3³YZõ!ßñ€V­$Cf™¸¦"•¹L-vF‰2Tbtp(µ…°ÆHðõhD;DÄ ¤àòÖCŠˆß‡ ‡7b%£ÿÃYui–Šã›Wú*:ö‚ ó=ZKá´ µÕ¼p .<% µpšSO¡¾ Õœ%Q |ç}‚{Õ¬îQR}9;ø¡ç†u éà¡V e"&<¡vQb€È”W®–Á êCOz²“>JΔ£Ï DYñÍ(*"åü²L,¶Žóe)m©7+Å,¶hJ‘}¹ë9¯L1cÒŽ‡Ç¯“WÁþq `8Ž»‡ùWhÇIÓašûÊ7w2´$pª“ºâ\Õ°¯$.)RYÊŽ¥‹ª™AŸQ©ñ (àEоul.j²d@°«¤!®ødh>$ÝÜš½¡ j²ü^ÿÂ:ŠÝˆA2$¢M—Û’¬šS‚`Ï‚$M7MŒ¾¦è¶C©ˆ@LÁæQM ßÂáþG59< x»=…Š¢› ÀIeEuW‘TZNV W5ìÅ^RòÓÜcŬqé ?@ßÔ4’‘È@¹[É¡¹Õ¸[¬p€aËGŸ¹À-(úœé|FGÊb×´/ Û¾ A"¹Àef”°Ô¯j"aq=Åñ ³:î*ßz|­‚ñùÂ>4Ðm0‡ »m]Î]帪J‹/•?ûQIÉq¦WÀ!Ï,.é Ì̘ Å®  ò@¬Bº„F EBÅ…u¬Ï¨ÿw²¤ñ¤Çwò#¬†!ÑóÛ„=ìåPy¤§vUbmg·MÎÞ™ŽÇ<ž[$;@×ðBÀÍႵ''²£ð£8Q\•T|àËuE#;ØXõ}ó‘ëûî RºzÏ”úmeˆÂÿ‘ð&€á ¹äѲŒÌ$ÀÑ·8j€ÄF7O«a‘L‰å{å·ðˆI»4Y•*„ðQœÈgßS“i”i"0œ!‚ ¨u#âîI†9|¿?='JOs\Å(&G)ÈdFšâ¸è­+¦ê²jSlOu:è´N‹¬>$ºé˜>cx(1ËN@Y(Ë寈ⱤäŽ %B "ئ³ ÌÍ–þÔ…‚¦öe¢#æ²ÂN ÏÎ&¢é\E,¾+¨®@Ð Kæè¥ˆßz‚‚3íCâ ¹.„ÿL ŠO·‘v$‰h_d2¼Â .‰2R|árä6î.ã‚G£³†‡!DŽH|0ü B Pê¿6q‰6JoßæHÀäZÁœmð DÛ€Jšê§Ï„Êqøg"Í ä&f ð(ÐPsÐô.Esàã8àäPß.-+~+%¢ÆάBèÇ‚ Mf1`(»LÐÈP(UÈ»Šf2TM¡ÑŠ*®”@#E7ˆE$n!.*‰z +K²’m\b"ì‹KìK ©ð‰Œð’h˜Ü„DBÀ}ªpMÊ5§=ŒNš¦ÜžÉ@þ±J2àÿ.&4¬®@jÏö„c&='Ûxঌ †\¡Éîø$É'µQ(r()ã3€¡–²°&GR½(jP£*èZÆ [* ®\„P{\n"v‰!ÐÏÃ/‰¤¨³ÈçR®C® ùGæAè’!M88,8l?@(ˆ"0ørÝ.†Ðã@Ïah £Q먑!rì÷;q!ÎNíŽO"(CÐEÑ “tRXàôó,N2‘ †àà\a\¡3H€gìf^Ä&+ç"¨7’ãËökS*‰È’7{³m:‹† €çVàÀ¦mjñ~NàöŒ(ÿøl¶æZ;>RrAV *Ø(? `µã#‘Â(,Åpô¨z3&âþ¡VÀB@Xx °+!S'S…N>/(âÂq!NF @—¯Ë1¼~`3† ú¬LHBã¦6t#À¥‚BËÏ\¶mÒ²ð ²Àhˆ|V ˆb$j±'æ!€®' m!ZÀ¨¸æ^à†¢7ÈcRèIêÏ(Z@R?rĉRXÒ è%äH0„¢= †‚À‰&hjÕhÅâœìàº4»àjA`FfŠ•F<f$XA€A÷Š—2ü BBÿ +Å¥lzæBROçfÀXÑ =4A´ç8Â-y9Q4EïÒQµÉ¨Sk‡ÃêO:u ÌŽBb´G—‘ÄêH„ÅR. 1³Ž!:ð%ÉcI%€^JQ¢î*®K‘¯$S2'– 1*Îà b‰l3qÅ2<3i¢®êjW*ZaeÀYh!ŒcZç”7…älÖE!t³;8‹gƒI Oò& ìgEk±qÐÈ"9ªy^tÃF"ôÒ‚Jf(8µxà#s’À‹pF+Ô–S'•/sá(àâ )r—@øÒUp ¸Þ ª²‚Àóx–mOHa5XúsoaÕgzÀz=–c«% £íb„ù6¢®4p7FД@“ƒ²ÀïqâÔ’ƒ\,t\žãl&Km¢ƒm4‹gÐgS1ñD îu¶c]QôŒä›þA˜2 Qk˰j!®VÄ¢P¥¹ê¨Þ 㤠ËvRPµöÀlB€aßöma5cÿBR%ÕzŸ×'Sx!Z˜.®f'¡ÒÑ2ijÁà ¼R!Ær}ÉF9”£'7mÒü&B7”O—Pý>ÀÂl ftEåÁ€ €XV—y³¶ uÜ“‚Í+øMÓöílˆTá C*„Î6yWum§z¹toÿáz=– ‚†ÿüØâ†ŒáÆ‘í’L®wLvW†uF2£F’’´qoÉ5kB_6»c²}17ˆ~³[ŵТHøuÁ"†'øç]â‹OP2^9ìE±“(šê%?Y¬ÅÐC_ÒÑzì mÒ1%•!p•!àmÿ+Î`nÝVš1¬™vbÚÎhZ­Õ™‘-¼†œánWZð–aâ(`@x“µòz’ã±hÓ+‹°3T7 [‘É[{SHxî* &FÂ<¢a5©´fŒ7;¬—!ÇÝØX*4·Âöôàíd¤ 6Ì‚Ï=Q†‚åVM8c9ÖâèÎâ´Yš ù$ã›kZœ•t *§sZœÍÔœw¥#ù‘ÛÙZ­ˆÂ`Ð…plžÃ}¹'”Bñ*ê hƒi¯¤ö!WT#ì¡. ¦'R¢GGÿ¡ô wÍâÄNL*̉`‘¹ÞÚ)QŽ×£%æ7zL NakJÿM8n›W>UØâbšKg'Z¡¼Za ûbÄ1{§yZ¡&;u¥u3œ¯â9[ŠX>ñ¶$ŸÅÅŸqóÖ b”»c] $œí7…#vƒn ºæÁ ƒ.5ÑFBF3Ò 8,'>’(‚/™j v×·ˆ­$0(EbÀl Ž÷ݲ"„ïz¯bn·bác @XVÚçs2¾9¾¹’ì¼[‘%Zí§¼"e[PiB8 îqñ«ˆ÷5ÓÒü*9Ökgqm!QyþLy´Z#rþÚ.!: &~ʬ©ÂðvWRæH< 1Ñãlç-Тöÿµ`iÂ4´zŸ{M¸½tíZd([D…ºq ›½Ý{œñ¦“l’-¹—!(Šhçåø«´½2~Ï!jîŸ;tÁ¨ú …v7z¬Iiq`ì$%~.ÄL²`vb(L¯@ĉQœȖ?º(íÄÑéÄ«)DHL#$Un©Ù!Vc…%2‰l{»CÕÈÐ{#Xˆ… q’!Ùùtå©õNùmZ.Ÿá×!ÊžîOIù 4Ýf7™cý¨8­Ft$^Âó¯qØ5¬ùDѾ°ÝåèÃÁLvqæè×ËðÄ{L!Jϧ¹? ûz[ºKEz!i†Ýª»¸‹ÿI%ÚŽ!ć}.câC‘|l+ÙLjÉ)÷6Í}¹dÊ& 8W±Òo"fÛuzLD‚Ïž©µTÝ$O€{s.Í,ôáÄ))¾x¥{@~cÎAÜà·âlÕê9„Æ©Y†yWý¼ ŒŒ¨4ÐݪáPðV”Ú‘½ wìÛe‘È =ÒasÌ,ÔÒÇ%C¡,as ÷´Ý)‚7zN!Bzºã`F†ô€Q¸h@4Z'%¤~îõ_Eè®õ¡I!€:6RcØcúzÁûÏ;þ P-@Q¨í}‘©]‘Åù†Ãy/£d7‚<öûz†cªËÏ9Ü—‰e^Ý£ S¢—ÿžçïOÌ-‘ö8á2¨Â|¸£À¬¿°0šj·¨‘lµ"„çÜsPÜéƒk!ô!Ì$@^„]W{!±šA¿OP»\¤kß ÐCþ’#ìÛìÇÙ{3‰¨¢ÛÝ6U;7]~ÜÁ’[ƒö |C)Z/k %êó; •^èèêòç*ñddˆqD¼£å)Ž7¯çüÚP„ 6¸*ëtävµcõÖŽ@šùVýÖÕäÙ…f#wÚ¿þ’›þãjVö¦"ˆ©þý[æËƒ†þjh0¢Ä‰#"©àÐÐ… †$T@Rq£ÈÿM¸pä¿+KV8i0eň2ÿ'Nø÷á¦Ä Læüð¡‚> !þ…˜GÏà‰¤éÙûGÏI{N 5å_Vƒú~é[ñUDÄb‰XAáY kÅ‚ý‡Ñ? õu¼jð…ƒÿDtø@ÁA pUÏ•aÅ3 Ö‹8äßcÇ<¶<$A‚@lN@aóãzšÿ 4ýO ˆTµ"L…$g¹kO”]¤G 5~¤¨Ñ!Í’:M^˜P!erä'_üò¤ô”Šœ@7æu  QôÒyÿÈG¤Ç”*=ðYÛ‡ˆR4_®ˆúDèûwV,~²g#Ší/mÿ ¥Ï† ÿðÕ`fb®0ƘÿD“ÙDfèØõ<–YjyVÚ?¦Ú@ž©XÐ?¾,3ÊB‚HZ¶Ý(\cõ¶‘HHpAG;¹RDÙ$SrÆÍuFÇåtANsáTäJ7¥åMØéSPÑCR‘‡žQO]åÄQœ©•šùä3 >÷‰ŸZøÁeÐ jQ _€\¢O>À91(9pÀ/ð¤ÿ ‘„^hÛdfø¡e›¥µÐ@š•(YD ¤Z*¾T H2ccCÌ8DCâHÑoé–ܽ²¤’Dt-GlD0I÷ÒqÊB‡]³ÕA%O<}À[!—”˜P%ž=N…'ÿ^ÿ¼ùÁ|\ùןZ+ U–žš%—]pöµ!¼pÄ?ù.ØE/¼p @8R„雕ª©‰©-4„Š(R¦Y+¨=¼Z-."óH4Ú8QoG:TkɸFD×¹’F>9×]ÝF0™”,³Ê2W]Ø7]qÐbgàCßÍs”Uç%eOôÀ—Ooj%œ\ÉiPŸÿ©ËYY÷4h }ÇC yù(Ú—£ÿ10„”FØØÂ'/,Z©0¢Š$æ=‰­ê l±ŽL2g7"~cvFîº#Ø,ûØ’r5ÍTtÁÆtÜJ=3 s”QÒU­„˜ŒUfÿÓ®¯EO¹¼¨|Wxg~î’¥§DñâDoD§CP Šâ«¨ÚlçEÑÜŠQX›ÝvKÄ©…’8q¨©¤ršhÓ£ªbkÀpDZˆGfHÉ3¦_ۭɶ²C2ï8ÿ‘+¹œL(é¤Óqɉ~è§:< ´²D¯îª'`* zÖÓ-'4ÍMo²}°v§ÞýG6‹>†pŸ¡˜ÙGú è[Ó") 9ÁSxàÀó!­ ä¸o* W1”œçL[fÀ‚µ­ýg@ûÙÆÉv*KšP~a–! "Ö½™êT¬YkAfÄ‹azU:Ö"H¾H¿òÖFŒÑŸ–W†œá°²¡“Ž ‹_„;n "†bãeø9nJ%uô`æ¯ßä`©Kó ‰-’×LV¤AäOƒL{Úw^Àö„ YR4¬‡ãs??ïCòÔ oؘ)DéDW¨fÜw*ÔdÒÿЕ¼/Öí­êUAŽYpns¹™`ɵ0ƒ²m컑™}ÖWfûc#€“Ĩ‘!rr”ØzËLWÉÇ{FÎ:†€(|ô= EâÍã,ˆ*ÛðÈã–m B`à Mj[Ð?§á ix0†á­ÅÿÀîÀC¡Ò¦™ºÕ]ÿ«Ww{5ÍÇýê^².«ˆuäk&eìŸ,÷Æ”À;Î# 2æ¢<å³>59PæCø¦Žiû ’Ç= rçȧí|)_Žàl Ï×ö3p¾З*2¡TôAFšÏD=êÐmQÕ×{%DH$Ù1$q”X¨F_ ÿ,Avµ¡%ÊBÅñ€¸ReaÉ72:1ŒÀL1ñ`#T$ÄJñ rGð}yv[’ˆpC…)˜$h•b>÷<”AcõQ•bh…«ÁS÷\0önµà„H{ÚµokZ¶?ø{7"‘{¬fp¹W|ɦ7R ’`('P1ð%öð|ÿ0}µq-¨sx‹Ç-IRuŠ’wö§6ú“”~…¡U!pI‚6t’1hZÅs 8cÈC(B]¡Ru£„ØÎ¥‰ýÇ>k÷F¯†p—UhDeÂòEõE¤SŠ’8œ æQIÿ&e«Ã-óàlÎVŒg‡æ‚À‡!~ (ù‚~Vƒ0äg~†ˆÝöˆŸôOS=©t8ùg‰¦ñnÅÁVÎå„›h¬Øvè¨jx|°H?MÓä9«X0ãlî8R[,€†&)H-[v¨ 0÷rµ•‡°‡yöà”WIdzsŠarˆÑ¸ƒ<0ƒ¦ˆ?zö‡+Ûè)¥Á"Å„•v1ÑUŽÐÅÔ?VVjôu9¢Ó9°˜…h%gde)QX÷VXº‡µq Dg'ð‹âQâ¡”Y-BòIys/8m9g9y€Œ âû²Œ.´ÿUZÕ(—4:)!)‹ÑˆÞ”¢Ô)%‚‰{ŽÏE{ØnK˜^0¹{Ƨp2q%W‚¸$­(e…ù2DraЖµAÄêZýöu…Šº…;Q“2)@u2_Z¢ðÖ‰#¬àl¬º˜Ÿ•¤°Ç©S¥­–z*–È«wª?B"çj§j“VòŠÅù{€ªŒà¯h«Ïùñ¢Çɵú¯ÛuK|FÖEôj©–¡7IQücœ¸²{2/›¡@ ³–j1ªQuKXðÓQõ2ˆƒ€bÔ°mIK¡Á$@ÏIW*³5‹«­€³›êZ|Ú2<d'E®.#ÿ3aÔ–)kp !¶‹)ÿà®R˶m›¡wDÍÕŠudâd¢2 ¨2Æ“µ!¶†ò|$¸dË‹a(÷èTg붋˸¹ N—*û–XÁ1´Â6ÿö¤@°¹@ž ¸Z¶ÿP¶žk¶m÷ˆ#2iÛ¸¯+wL°¸xpG¤©*ë$z9·41œ3á ZR†Â¹¦{ )ë¡Qó@Ê º‰š²£{2­‹ªÌðíУ»˜gð¦°{z¢rk,",e•[F€Ÿñ¹$²ÊÛ†a6Ë»¼%ÀÉ»¼Ü qk»˜yœ=–8"»‹ÛU£¾¾×ÿ²¼ûŽ×!ÍC7&q07±¾†RŠë‘¼ÿp¼%ð´Ñ뺕úP[WzÏ )Œ#4˶"YµeÔoðˆ¹6á{44¿çTŠš¨c{¿,P>•³¨Á´H‹Ü yàªmyØ”…Â72ÀŒ[„¤òœÂ«¨<¼¾µ&a¸Å[Á ÆáÃðk wŠª!üO¬ÄPÂlj 8ˆ+Q,ŵkôtœõ”á¨}¬¾ÊK÷;ÄÊ7‘¤ r¼EŒ+æ™Æдm™r|œ‡¿!™múfõ¤Éêe›²\É=úQ»˜¤ É¡Œ« \©ô¾r7Œ`(ž\ÿO°Ìɦûg º€|¼=úÌʿœ|t¼Â¨´5ÜHrG¶9,¸NeÃ\œÃ†ò¹· ¼_ül=ÄÀŒÍÙüÀŽÑU}lÌ8˰| N5á,¸¤›ºžì¾È• I¾¬ÍñÈñì¶ ÓUÇœ¸'ÎdKÎ!¸)ËÏÇ,¿ÍWe«ÈW ô<_p«ÙÌ£¯ûIõ %ôÍGk¸ŒpÎqÃûÌÒ\ò‹ÑM»ÌËü(¯–  Cð×+ $|2¨ ­÷ ÍÑ&Q¶š¬¨m¸1Î!ºd›²7ýÑfÓÊWŠÈÝ ÐòЋ‰aF°Ô°Xý\³¬¨¯ŒÕfûʉ ÿ½ýÊËüÓ·Ë€| ôkÖ¹:ƆZ ŠÒÏÉ<0m¡ óŒ[ðÆ8tÚª%ŸË¹·LOÿlºÝ†çœÑ‚݆@Òò;ÍD]©tö‹×¼˜0à·|q×–C–§ìŽlÃÆ5[¦‡«SÓ=Ë€ÕNu °ÚêËÚùìÉ@ Øò{ËE]ÛýøDgeÚ––ðp <0±Éç!¼…™°hùÛ›¡¤’5»¹ÿLO«]¶­}Ç`M˯Ò‹½Ø€<&ЫÁ–jÈýØ–Å` úùÒÐw‘Ç ‹LÀ6P}¥€z¸²Ê•ªP7ØÏ§@mÝ; ØÔmÿÜ­Ã!=bm6Òü¼H •ù‚OŽŸp€[߉%Àñ}[b°¯r×Ýæ ø¢/LŒ# °6Éc¦ÉG 8’ßzƒâAy!MºœKÔ›{à¬Ç\œ¸!ý×=ÎC.¿<ÍeKÒmé•PÉäiK‹#û°R#¼<ßh£•­¶ÕA§ÙýÂŒyñ/A v=[`[†gWÊci¨÷~hÙyÝ£½6Ô§{ã³Ýɱ¬ÝŠ{­¼ËNº°8‡Þä1!á•e€(`’þ Æâ[ h$ˆ¡É¢< ¬ú¦OkRàC ‘Cà ‚6‚è~ÁÿêŠrÚ‹3­jCÉ€ÁæmÊ(9ˆˆðW* ì")2}*L›‘²<ÝŽÓX-¸«ý¹7Ö<.ÝË[¼ÏçÉÞ’¸/u[úrúr.¨/úÂä\jö'OQGWžO/@–ƒ“÷à ªn<0mF€ %Jå˜ùò/n1ðºŽ62Üm™ð«ùŒˆásî7µaéë{¨;ξ÷ϳ Ë÷@.¸/´EáHÁGãtóð/†[“—²|AɹÎg0¸å|±!MŸ6°®ë˜ï¿žßBöÒÇIŸŒÂ‘¿þBÀõBé‹û¨ÝH°OÝÚýÚµMû×ÛÑìØ]ÁÔ,‰Á‚Å‘GXÈû—ÿPÞ‘{ &üw/"DˆöB@Ì÷ )&ÄðB ÿ€¤ˆ!Ë%3døçà߈<þ‰y¤£ƒ/<ŒùâËEc¦liTéÒb€ú¯žÑþ˜šð@Ö„V™~…è*¡X'€0áF$’˜ÀH-E¸ko1Òx‹#v?Þúç/ÄóÀ*øO â ? H¨â„öþYþ'áß y/Kš!H™?Å`deÇ“l†½Y"¦ ~ÎnZ:¡L§McÖ–IÛ”ÃÅ:pŠk=P«FMÞuªW¯Å³’…XoªögÊÝ W.à¾jÕ–_¸­Üÿ„€!<Ï-`ø$dÿô¡¼ƒGä5„螆$ŠÈ!„(Êè}&àè%˜@*ÉÑ0hí4ˆ2P­¥Ž2pàµ\ñI ˆb©4¡þqªÄÞ”:@&¢hÛMB&ð;Ì©ä˜ë E¯ jî#弚Š&°®Ëq;²&xë,¼n1ï&™TO½¶Ôl¯¾®´ ‚H˜ç–- +ŒFŠc!!ƒüêÈÖ‰Àšg°Ì>€@žÏ8é¨J *)–(Äð#Tkíêl²í…Ñ‚ÄQ;‚¥žB4¡]׈φ@t7 ;"h(­yª_¦öMÊF­^0@áQ¯˜Òy“3X©æ„cU*æzlU*Q?´»b»K KïäBRÎŽÿÆR#ÿ¸º+*¼.]ÖkYfËŒV1ƒ(ú! cŠ@ ÊçƒX3éé£eZ´A ;-jŸA_håÃ>qw7ÒH³·Eu+ê3ÜG; ¶µjÕ`Üãn;a 9Rɲªl«(¦iº¼Éªxºê³£˜"^ã*ëW]Ý ï¬Áùʰùꛇe'»<–Y„JìÍü("賂ӲBøÜ$q‹NHžŽWü 9@ê@#¸¦BªÍˆ`¤(Ðn3Zó Šlãå}¤4š×Ž€·¢|iP+Å«ÛTX5*ä”Mz ÕvFż®`GUFa•¦Ä–µ0"=¹ ÌÈ”ž·¤oe¸òhÿ¹‚ôÇ1Š hþ±¦’,á1¸ŒFt‚'\í%”» x„“ä€)FxÁZQ½€ÜŠ+xà;äÐ.8ôÚg(d)ád3 BsY­8yCy!IÅ”àŨ7Ó‰[ĤâìHr;ËJuØ£«Àn= ‰‹x¬, Ñ=„qK Væ%/á(ñb`9³ü”1!ÈAž²˜,B€ yúâÑ‚y@%F0ã?°Š0A"‰hæ(“’ cDäQ2å5”XM›Z;!D™8²¤7~œ—qTÕœã çw7jÞÞðæ·IRòy©àÐ"2*ùpX# DÚÒÿˆpé;÷±Ï)e9ÿ0Ñ ;Ðz6Åàò#ãºÇìá9û}"˜KÒ„`F#¨.! ì‡@zP30r€+¬ùǮիÅ3 Øó:ù®`&|JŸzªâP‡¨élÂ(B±Lšê`Ù»á"qÈû}gdä»ÓC'éJ• ißaTšÉc–hkD.—§d&sŠ¡#8¢Ë`^ÍL®IFŠL¥`ÀÄ ¦HóŘ+CÙ ÁŽc)àxä¨à´QÙ)©ã¤È^¤ŠŠV.©*®H6G #Õ«B‹±ë¤:=B'ýhÔ«³”rJmOËÂê)&Bä¹B$Ñ¢,ÿðn-‰@æ1°d˜^Ôc.ŸÑ­Ë¼ÐJþÑ W8 v­¨–A}íÆ»Éé©ÍÍ”í&öê`¦”ç;±µy¦²Šh»’Y§dŸ8²žR]ÚE¶ ù/Rðã=ˆ¸Ç~]|«Rd”©Á»Äí™”ˆVÛJË~9ðíI[ ÈMÀ—E)žŽÀƒ \/(£[öE± A¯àÉ·`̃zÆ6ñâã/ZšÅB*Ebûl!Û†"?Œ:\é,’=k•¦sU÷½ Æ&I£2Â~£xLq€ÄàÃ4ÿÀ°Œc1x—f*D'“‰ˆ¦†7ì[‚”ÿÞÚcîð´±p„'*QWB’É¡•V7\˜²MKd"òv÷+ˆ•—Ò~l²õF(8U/y¦ÔKnšGo !T¹"ýÊÐGv3j:ÿñ_`™þrB`M£Qt±Õ˜ór˜)â¥û8î>ý¡ßa(BÆ­Ìdæ-oË‚yÜy[ÌsKom§—@ypÞŽ<öècrÉU€>üŒ€È ìE°ÂUNMe4׌â^~RŽ´XfR}–Sh þÓ%=¡ ¤ < ¡MÜÁ f!E[…¤“7„…ÈY(Ý÷ÈÅ!1Õ?7´’âmµbhøD°™=ÀEX<7tפ„ùh饘¢Waùà5‚‘Hv…‡áL­XP™Z‹ ·‚J0yÿ)“LdÊ#˜¢‰© "¥ Ä AKí¤ÓlÜ€>‡¨H{Žøq[s†h5¢UÀX¬\q…gP¥Ešé¹è6 @àIDFFE{P)e.WQA¡ûîKêf”Æ‚®¶ÚÊB˜ ÞCÀ=d µÓöLPAn1Í4öØÓNâ#Dr°E Õ²ÑJ¢@Á]p¾ø\õUË7|Àè€Ùö¹é欳_âÈ>ŸÔó?ú äÔÑ%ÊÛžIC÷Oq'Ý&k¥ý£àÀ ΃5™ ‹ÖL6E8Ïÿ!ÏÀ±¦ÓÑ$ŠRÈÿ,»•@ÚR0ƨt!Ñýÿ@Áˉ"âVŒÂeóΈ'ÎP¥xý³ÂEãHd¥"Tx´åÿ áTt&V("EÓÆk^ZMæ 2&Ó=÷ü³ðÙ²Ž‰Á=G(LÀìˆú<îfE78>£lµç?ÅS€ÄÞ–eV]ÖsÙƒ³âØçLA„;? BXå…ésƒ¢æ¬¯¢!Ž¿}ç?! Â-°€ö‚¨›þÏ=³ÃÝÀ(@ 90 ÂÈDÐê;1ßp¡™æä©xËBÞ@ •¦M`6{ó—W, "¦t¦ú‡á²ÇBíy\xy\Ñ>%‚"z%Ê›ÖC‘*8¡ÿ‚²’€ÁDWCÝiÈôÙ°uòh]ÿ!€TÑ€4[ ì1(!àÉD>F*¨L%Uø@0F‘Š=¡d Êò4® Á+/CQŒìA˜¶ðæÙÞ@º7ÈMq/h?Á ~V¡P­Ip’À@Lö¶á b ãBšĤVˆhȤ°Rήuü‡©¨JUÞn b,;ƒˆ l€1™ãMñƒŒQDkDÁâTš3$ç+ÓPŒ #@:ÓR‚ÄQ]:…ˆPsAÀͪj'ð£„þ3*]Œ'°Hþ¶».J‹ àsÀJ+ @ÌâÙNÿÅ{Œ–UyŽnÌ⬌Ș›VŠs`© ow+Žôž³L?>ó¢ã‰&§¸G§üllÑ{0²J´OúˆNÒ4÷T(Bô˜Ú äñ‚ &]\Až¨0*Ò“Š÷´bx6YšM:™ÑR‚!Ö9j2”Vz©-`þm:déJ‰Œcâm B„³(FÇ*¾«|ñÒ"jx¤ˆÓ* 8ɼâ1“œD©ú*h†hNðSu b? ˜Ï{â³l=ïÉJ,’m€IÔ -?@š— ±BXá]Gä‘Ý`’$HGqÐQ´b~ YW»³zO “ƒŠÑÁžßÿÝR"+X箄D Q0„Æ €Ùô]¬Ý@°xO:ñ€‡­"ÿ‘2l`µÛgk8ó™¨5(ëßZ’eÄ9ÏÁ[+¶B< ¤ÂTÀ>ZaÂĉµø%aŠ&ôA…¶  „Ç®´"} á#ÿpOž%y” ´úèA°ÐD±±®ˆˆzŸ¶¨Æ¢@V÷@ˆv¢)ƒ’b¬<ëMkΊPjÐâÕ¢e£Pã5(x§fæâ[ÈÐØ¥Ú!Ë…H€ZѼ€ üã2WÁÖgè0&:îiÅl:Ó™þ#cQ®Ö¤xØ ¹VS.+{Ï 86ÿ&²4ÍhPGʳEèLÌi>F„\ø-oÀÍ&@®/n$Lc|-%ÿ{?s4ÏT+MÃ(ò‘´åJ{p |g}+° VÜ#ÌœL4·\çƒ1±ÌÐUà£èa¡¢YÄ;M,IãI-¦¸²¯¹W¢7ŠbÐ@ùà ÍŽÍ0­!Pøhìµ"å“ô`Œ´fìB~ú3å;fÆi¿»Jt‚&^ÍB÷=ê¡[f×ÐV¨Kåš:T $ÖtLœkP§?Ù¤%˜ |…/Iºi4¾OËÜxÇQ0†_µ³§š¶!àÒ(AŠFn ä‘"ÿh%Z±!pš‚î{E‚«¼“ôV¨.›—sò¿«iMÐ-Ƚ6fŸj8èö&ȘL³ ›XM&¤É‰PÎù˜È< Eƒô‡´ºY¿ý­jdtµ¼çé!AÞ8_:Åöwµ}ÈÛ£´ ù1£Ã ¸B·˜$‰­¨(±¯šg9§fÁLÍ6`wWc6à=&ë²F–g¶÷3`ïî/&ÿc˜KNpTý5h'-qIÂq±ãØTàƒ2 Jõõ2Žè+Âèeqž’!ÙjJí ¡tB‚Ä®¨¦.1—_H—µÒö–”` m×ßµ + ¶›fû•™äà\l :ÿÀÅXûó4 Aêî‘|š™ Î %í¶0€yþKª…,qDüà×ðÿuH‘E(µg< ðj„qRb4#|A|p!$èá.íÒL¡|ØöB›—v”É÷ò1îñð MÓ +0eúr¥WÉ¡3,FT6­C6-PtXD&’6¥¡\÷v6 ÓD¯saòÇx‚U;²] Ga€×€1¢³![]¡&ÆÁUÇ‘ ÿ_ó¥"?De…#!؆Ê7HrQwbÍt…Ñ|ÏnUÁóârŽv0øiC”ð4JƒÁ#Œ ßÿtÖu6îdo÷€ôP¥1& ô*v1cÓSa]ó‡S¢a.B#Pq)B Ôï,"²/ÑR føgjXoçvÑä(nx8@BÉ·=îBw!rpA$k%zXRú‚ ±/@x™a"`J†%M±§E?Aa åwJ’È5¯c‰1`aµ„ù‡‰LÔD¥T+Bèt¦±]ú—SÑƆ±/CÑOÊÂá/(hiDU½¿H‡H¶8wsQqR›ÒLùZ•Ñxˆß¨()(3çVþq7"*°:¤°Q!O¥1 âo ƒ^"÷ÿÆ00+óho’XY6AJ @YÓ ¸r 8UYš$ùEñŠðz„'ÏqxÏñ6_qcÈ@UôåA)×CV$G4…‘ŒÁøvi|„¤BÝS)írwa8îb>¡¶/,?+ /…7+§V…&&¥I G06b@P$§dyí¨Sù¤“ºF2±0º"†‰^B/;‚z(h±,0²o2€"(“R_‘ 9–P¨âòhûU‘Ã3ãÂLv8'|À ²”@xºµ—Q1p'pˆ-c†PˆÒQö30~O'dó?—fQtSEÿTC7+7ÙOf“¢1„‚D¶Â€‚hK7pC±öÒ2ó«¹,±ÙF[ÛQ|¦›0äŒ$Å7 g‡í¢Bsñ–¢)Gj¢œ+à1ZàdOC*j%ÑWí&'ôð »ò?fS¦aT•ž ÂOAbVCyHd:rF±çIýs6õtP§?PG1R‰BJÇ1O-d¸ ñÅYeä{à!œcÕGDÒ)d +~t_k9.æS‚!e\jB° öºoúù Àpzí&~VsJ•7;Ý©t9ºO²ä:†…™¬C6èÿ ¤±R£[Jb"+hC6¬£ /ÀÈA1³!1Í‘"UÁMµh-Å!2  ˰ gÕT!9‚mùEw_:#ÊY¡qiH=“BÊh3ÞÓ)Ú‘i‹a(o+é !À”<ŒHœ”~eC`“ŒŠ¡Ç—Êt¶ƒO!¦o•Ç0 rDýsa¬3¶ada´c]C'La!Ç2ó!(ãõðÃ"Ñ#©ºgþi H& vØ« qÄ8å«ÅG.!džÍ'ÙxnX¡r†ÐTAQ ¤1D;D1ÞåIbrd“ð7”µC6ƒj]1a£±a×D.Ê?è: ÄKÿÐ%3’“‰cR<‘"1Ç  )?Bx¤FËàK[å[º›¸Ù°‡ÓZa8Ü‘µZHîrµ›M” ˜Â!N{›Ô§~eSò¨·57­/Ûy#;²Rä:§t@cÒS‡Åæ:¬S·þã­ƒ;§q ÕAY4‘1ígó0¡{J ®q¬Ø$¤bA€¢&{’ L뀽:D#.a¹Z?CHa:|¿#ÉgÀJeê3ù2±Aþ±Aá5tv0“+´#&þ6EA²f–X˜ù?X¤²ô‡t!Ö:*‹­Ãë¢ Ÿ Â([Ò%B¡±Q÷0T#YHûFÿѵ¸']Å´À` é‹…ù¥›2bw Ñ(t§ÖÑ)ªÅ­#÷…Õ¡-weªâ?°úÐÇe5»ÃO×ZyËe8ša#ë ƒ™yK@í÷|ë·f©6)E©s“ãzö&vŒ@aY Æ‚:xVê3m Ãfä´w`÷VŠo±%“²¥ø%«nùqá–Ú¡µÈè›1ÒGÚAŒ·»²Ëœ¯`‘`W¡9 &JH¸çJqX¶St‹EŒ tT”ÀX~kf΋M°Oÿ°™ì‰o^“~è—6^Rô01[ÒÂÃ.¹A…ç^±,;ÿܯQ#[$«åb]ê¾D£  Q‡â=)¤ «öë ÊˆúÀ±Ì¹'±G¤À ÇDï½ÁyÞZÞš¨ÃÛSÉ t‰åÆjüoèˆÇã*&K@& „o¢$'¤s¸ÑÚ¿B±ç%/#D<ÈÀÃËP ] µ° ÉvÁ¥ÎÄŒ6CÉ ÁÉguµÅÛC¿U+9?sÖ aÛ¥–Ê—H¸5Ý™J€+¼Ô}ë~íZ²¯$yÍ%- ÆἡX+‚ûÍ?¹ò]'n1„ ŸÑL"c-‚€i$©: ƒ"[Øö(ÝŒ3'Òá¡Cœ8<|çLd†óÄqÿ2ÓÜÁ–lw‡±—p€8¬XL äjjFEÿFËe,t»<¸€ë~ ó\Ð:’J4{©¡—£:ÊO-Š~žI½I¥C¤­ºa˜¾?þ‰_ÿð Ï€ '´?s‡…Ζ*íÍ>’Z‘!wºê›sȆ5Ýp!¿¯µØ±¦j †2󓬈ût\MX Áy;%Á`6¬³ËùDÁçzÐ~ E”g“»žIh:K”Ç…ë™cùp!6em§6\Fo3¾ZªË×÷½v]µù0º奥Krúp¡Ñ3oé3¾ Ìd3y œL4 Ex"j‡’ÿ4D8AY¹’\¨4ËlƸsJ³ó?Ä«aõVÁ°¼€ËРJ„Ê0â %ÌÕ>ZÇS6-h³!ØO#±mª¿ ~Óu7r›ƒ¤×`‰8ÐXµu ‡Â9dli!Y«ŒÌ„‘ej¿LF[™q'¹Q?+ªßW³:6™ydüÀšM‰¡¸Þ$»\3žJ!<™R”+L„”?HÚu–®`ÂÇøF˜(»”eœÔOE³•´ˆ,2Ë´p½ ¼8HŒÃ†z!ɶJ)™¢  ªÜ‘[:.èažÌò+Ý*44ø[$ˆàH2RÞFŽF\“š·}»o ‘Ôj¶ÏKÚ¢øÆcÿÒ%óJ+Jœ„Âö=&_†ÂçùWú}z`ˆ9lÛLÃJ1B¤…åM+Q!$‘Cá8bá'­=Ü#ê»Íµ*4"Ç.чÓíÜ•Ò(Õô—æ8ócD?hÏÙz²’Wè0»\T;w{Þñ~Ç뷉ΠG¾;A#›&}`ríH~“ù(5ñ]³”f„+bA‰›ñõÛrM×íÒìëL¨.>jU>½¾)˽)oùºqùÄÒ­Z#n×KœMF’r,y?ž4S¼Ö®GÕONÆqŒJ‡~;;å­ÿÖ:|»0@¼—Ÿ4ë[ËM#÷s-`í—ˆ0­}SID œÿT NMÂð³u_A¾ܲåªb3®>)‚í#×–ôt—Üz¿ëÜ›…ý)¬Ê|ÝQCS-àðˆ)¸žM6fVoþ–¼– Šû ÚÆñï'E¸cÐ+Ÿ¸Ùþóú¦Ž¸èD¨¢q+oÐ[cÌœdgç~Ö¡õT~FEVŠ '?¥;C|›Eæår)ŒÃ×jN|Ñæ+”µ*ä×lr“cNƒŽÉ3”fóõ¡§·}‹ËòfÞy™çãò^òƒ—˜ís_›œ!­æ5vŸ÷~KÌ%Y 9±Â2,x"2w Ö¼F8vØôŽ_á{ÿ=)M kHö¥±›R{¿=ÃGq±ÄÅ÷ ;¦’&Ônfóæ`Vm©' ¸Oÿøwï†.L8p!‚ ÊûGñÞ=yòZ´8qb=!ìåû‡HŸ”&õ}ø"ļó>ž øæ¿,*VdAÑ£<,d.d™p#F! °4D¡Õ|È>{ Y+ †UøGòŸ‹„üâ%ŒÇïŸÙ²ñô©Uûol¾±k×zeX×î]¼úêý§ÑB~|Ã&¤k—$¿ óU(€ØìYÈaæWAß )-ñb„yNºóÁ{Gîa¸G`õAØ [4ØP¶ÿë…+ÊÃ(1aÆçý âC>}zW HeKzmnÄYâ߉ë-f”7ï§Ð£-ôø„šFˆØÔeÈ~P@¤•ß}fך+ÖíÙ´ú«¯Á /LŸÀêzÌAÅøÉç± ù›ŒŸÎZŒ¤ÌpÂùA$3ç ‘àƒ P|‰§šR-5ƒŽ­ ‹BH!Ül««¶²Hž&4.!è±ç8äüúg&™ÓG}^Š©#Žp‚‰&ì´Û­;¡XÎ&ïx/„ $À©,˜÷¨f>C´rîŸ<`!¶ôCP,Áþ‹¬xò1!P·MìO·ô*ÿ ¯ÃòëÁ¿êSÂA$©±«1ÿI °ÆìahS¿2ÊTMD‚…z¢ˆ"Õ2’QFØ:m![3ˆÇ‚~LH;ìpÂɧèùˆ8zŒ !Ÿ’C韘¤OfC°)¡´¤‚˜ªÄŽ& ¼N¨t:¡àdJQ+§"€ŠÍf–yf™ùêKÁoÑ„Lhô.±¼zìO’ÆrÁ`D íÊ­ÇÐÚ3¯Ç&]ˆ.J3ýÔâ…?E¬‚ ½ê±‰ù¡`öhÅdúÌœ‡ëtâ.FÞx[MW×JM¶ãU£OˆŽ›¤óh8 Eú ’’\Ú„˜\n%—ŒÕN; ËËÿv¸Ÿ^;dš¨¡;³] ðYs´¯å‡8Kr[„ÈÊ2AÁµúJ ®‚%Œ¬Ä=.³ ³+RˆÿeˆR¹±± È0±LãéðŸlÓ9ÿ‰`„P &*(—+ÂhV\ÿÉ•µˆjkñ·4Ö( ‰‰8Ür)Šã’Sî(ÉÌi“ [1zº5v!˜®”çr‚^&ëÀí­Z¹á)³qíeÞDõÞèLô¬Aùñ OÓº+®@Mð Ђá’ÿ¿Ùgt/»¢tcŒ9†+]Á”Y&Ó 1+ Y+:—*3¦ÐãÉŽh¥ºØdFuyÝuŽEÿœ!1¤vÿP–W2ä,&E@sÐzÅ^Á$@-„ÃÑ Aò¯UÄ;^ JpДœÈ{ÿ@Õ Ò4гÉKmÚ#Ü?D`'´Ô,€ ТòÖ„èï+ÿTüÚ–úÅ#P„úס³p¥aŒûŸ=îô©³T¦1Œ \ó l€p`I†p¢Ið[AÉ•ŒP“]ñÈ5¼aH줓…$+wÖbˆKø×—“4 x”ð #àƒ.'†-±–”šGô¸„[ÃùÚÊVÆ5 Vd‚óhÖ P…¦î}o^k£€Û(óE3⥊uã Iîç–·lQa…IØÂ\P€±®‰&é_ȼÂOÿ f1šãÞ“¡³th1+ „Øã¹˜)t ¡žG‚BÖ¨îfa]k.ø¼G…H$Õ?ŽäOvÅ+p#Ð’–¶á½"¯%B)ÁÉš$ª”$Q(‡¼m-;_»N«bÙFœ ëQÓÙž¡¶ô²|%ÁW¿Ã/~ˆaX<^À¾¶j@ Ó[HÒÄ‚2HZL?µ) ¬‡Q\6ÿAGÊ}Ó2#²€VЊ‘š‰%øhl2A¨&76sMD^´éy'XÈ3 8)ç%ÕeŸta]J>Ô¡MJ¨%P–ï«9WMhR‚ž° ˆ¨€!ˆˆª4™íÿ{ÀÀ‡-µ²}ñÃ_E ÐLÔ ýˆñ+ŸŠ Y\P¿,*lax“Ô‚ìb8ÅðTB{ª•º±¤ÅOµ""°s¶+CxRè>Àª®bMV¯yQ<Ë:ŒdÄ(´KH?c»·,fÒ s]'3ÓBðrÎLKÈC÷è´<+†}%¡x¬åµ/i'[^zÁ¹>ó9¡ê)©2®± |ŒÏ—p+‹Ó* HCÊ\ì–@¨ ¢°L)Ó V³2kdLÒÈ1mj!r£¨&4"ànîTô1Īûê錑¸á‘®ž¦Ü%ä8Jš^èr’¿tIžôÊ4ν¼”ÿ^]˜lÞ¦w½mIK `,™|)#BñIw桞^f¥îŠJøðÑ Ç&d¥ÿð@NÜÏHQ9˜2+Ü•d&s´cI&¥yÉÖ"hBƒ¦íáâÆPyˆrºEL‡Je ¨ðcÆÊ‰&ÀÕæFÓ !Að‰; UÙºù@N_$°0¾,m!N[B¡U×%™¡*üä?6ð‡F@¯œ[|weLÏc±¿U‚ÏäCNú%³1 [êË9p" Š'Øžo!y&Ký%(gú‰@‰É­’CT ¿62Om\£ùèÉpÄ!#à QÎôúœªòjP\$CÎh6®ÁHÿGŒƒØC$h©1ë,æùÿxá’–¼†ª"!ã½Kð Ú´”$‡YUvIcBë ;<óö¸‡Œï+,ÁšÔ0ÈhÑ?‚rpëv0DÕ­aÑ$ÐÅ­¡¦û.J¹ý—È SšJ Û©l.µá"bà(pU¬€î¢KˆNj¼²Ö¦à'ÀhKtgÝ®¸5µAv¢&W0ñ†–wIw¡*\(Þò2לž*–&J“H ”k #Œ…%dGï\1ñÚ ±=>BeËPÛFP¿Œà/bIð¶3ç¢Ö…P„Âó^JK ´ 28¿äaxº0Ã怕áíÆÿmÅ.ƒ¶P–JêÀŒˆd›û£”2êÁJ)«Bdsc¼üSî÷2÷½äzоwwš4Êñ"t¼ãÝ#®ƒ<§=Kä:V%L"ïAy€[êjÊ~pÄÍ{\˜5»… 6@ói=2ú =‹K”·Ø©1¯à³‡ Y:»`#¨Û”r+àsœ¦kœKaœã›-a–Z ‚”Š Ð ˆž‹Ø‘Ѝ°‡#‰„Ëe‘gá ¸Q5!³¸»ûÃ[Ë5ñc ¼[ˆ‡Â5W[¿ôzš'©–8 ÁšÁ‚ž°£€€¥È£ªê/d—÷0„ò½ÿû¬˜‚ŒÃA 1·˜ü *¢C& ô=¹6Á¸9º°=È8 ¨ZMA5‚:ÇXN1>Qq#}½Ø!°€V(®@—Y¹™ÞÈ×{5…{+À"‰4Ë®¿ º[š‰Û»»Ó¸/Ãk!¿›¸ºâ½£¸‡*2ƒJ‰Ê…¢PŠº–vŠž—€€ºÀ‡²a7©D0‹5CÀ÷q7óŠû1˜½!˜;´¢‡ŒdÊ­K™7ÇÀ:O¡:lÂ&á ‹! y|·¥bœ³0>³øIäA¬ç¸H‹D¸€à8‚é´ ’žŽJ–¢áA€:Ž®85Ñ ÿ”P5†8<Š[{¡ŒÛ;’µò “NÚ.¾úbd«+« ¬É–®Jˆ¤8“¨*a@†x©Š`Ã)š¢œ‚½˜³/­ƒq°µ8fb= y½ d¸*Á˜yLl±«´‡LiGOy7¯äÇ ÑÊI\4Q)­„#³D’Ë Jh…u’0$]á‘OûˆR ãðÁ‘#5ÁÑ‹Vì+#”«¦1¼&”E†Ið2ÉŽT!õ¼‡¯&9k1–cœ.™ 2)Ch…ª6¹d_ŠÃÔš”x€&ÇðÃqËÅ hª›ÕCŒ;Ä.PºlbŒI¤Ç¨ƒ£²¬€~úÍÄHÿ{ ¬óë2¾3K´ô'ã˔Ӝ ˜>Ö˜ˆò¸{p¼€•…C¯°ÈKú æHˆ"\ˆ&„Å¥ñò;Ìð›«Y£BJ˜¸”LÉÀ{(¾r»¤xÉc” °‡)õ3!†÷à<ùxªÙSt\΄œÓlNäô©Ó\·y»˜ë"·à|7Ý2KßK­Ì£Q'QÁ&ã©àô'­ ((`Ñ$µâ#}à–Š8! /a%zˆ€º¨„[´¤Ù¾¹c/¸9ÂÔ8%T5Ãû»ô;¨Ž”»²O'ÃÏô‚RŠa™`„9µìy¨ý‡k¸ñŒ¥ŠPÿ×$ 9MÑM¸€&ȱӼ”q¬¦Csœ{Ô1³´G Òß„»ê Òà\ѱDÞLˆeQOɇ‘X X ø€ .ÞÀ€#Ð š´  9Å·òÁ¸cÁÁ,ó$Ïôª»´‹`R&á8Uh!Š<Â#/)4¯\‹¨•0žñØ§Ë Óì³…¢„K€†3½†  ËXGOaÓfPÓÚrP ­P=mV†Kæì'DD³”ÈêBÔBÕÊþQ„0Wt]Ñ0×~2×Ë#9 X ç›NéÓ –x‰^‰¤X8"å1†€’½p–·IUŽ<ÂõÜ;»c’‘äE¦±R޳‹\cöR¸ÿ¨y12dŠ¯Óœˆ¡_ø…K0Sd5„ ñ ­Óâ„£k]Ù…hÔì;4ãÜÖÄ@×u­ hךÍV»p‚p‚›…Y˜½Y{Pz`ןõÇ‘ø[’è{𠛤€SÛB‚Ž*[$)Š»P‰ÒTUaòJ/æ¸ÂÃ+²#“ˆ½ (ËÒ y[óP 24–Cδ€ñs\Ø[…hØÇʶÝЀá(ÚuEcàs5ÝÓ]×4.]<àRL¾4'œü‡fM¤€æ“^y­HRÍBöjÅÔÞ(™LVê–˜H— 5߉¡IMÂ[½ ¸Òja†`¹3áØxÁ‡²!ͅñÒJ÷]ßDõ§w}\ÅUÜŸÝ\tm_.f÷UÕ}_c6æNæ0þßÇͱÍåc†`<žcV u`sm`9]žf=®‹£Åc>æÁZÍ 0ÐB¶¸¥Ïq¾À¢‹lΟòlŽä-ÍJ¾‰ym±– t–O®«)LˆMWÆÒ,d<ÊQ‚FVV²ÿ ¾„^è'øØ€O€:³lß,nYžUž½ 1žbóuW`nÓMæd&ÝÌmƒÉ-ã»Pà&Ý7æczàæ1Ý7vf»Øæœ½éºHã…àã¢e ßÒÄHvF†QNŽuËI§1 R{dVÌ ¢!GR(ãȺ¸)ø…Wd ƒ^eQ¾!b¼¿çxè8qŠÀa¨ªùT²Wî…_hƒ_8b!°Ç]6fÈõÙa>×0^f €‚eN™fˆk.]¦lÖÕçp^` ý‡Î^×lîŸ7~c=5jžîfÉŽ<Ž^zx…Z`aH…ISh‚t»‡^´S;µRm­ÿ}Ƥ-åbá™°ÞRî }°½+BY]ë…eW‚ñ[').}h ÆhÈëö»»WxeíuÁæÎåâûµ‡cÞÜ+>ê&]™ŽlyióUÝcnlþæu5˜†im.Ýëx`¿cü¾ ÒfˆÏfÙÒæãÓu }ðaá †ZøÚ®sÆ{Û|Àaä Öê¡<áV¬–.ÔŽæYâè|@šÔ_xƒR…O"ÓU~n¸¾„ù\Žtºn<®uÆ…Lj†pìmžÜþÖãþvòÖf)æi(0†F ð¿æÏnàø_Òs£¶ Òÿ3_Ù2/j>s#i DxΜpa€ð„Èë 7Ž ¨{Î-ÚÌ"!KŽ£±$c±$^¼¿‚+PnU}Õ¨¶bWþ‡·Žk÷‹ì¹I| ¼ù¤8!¾„_ØÞ¾%ï&‡Ñœ5êÌ>×Ì®r™žòæf—õšmlû¾ã,ÿcˆõþÝsíì*¯¦>p¿Vßiz˜`á*§¨§ó¼¦j£È{î‹Ëa¾,M‚òRÓó ·XRË SF‰OžE‡šÂè¦ô¶ÆññÓg(ña Àkh Ÿê•§LÿõÕzEÙ³"ˆ´b[¾ÄÕÊwý#Ï '°P!†'´R– öOŠ1æØdÿ¨F™>†a–W -@ðf-¼Ð‚<3Bhä"˜ˆ¨­ Šª´æÚ?ü#„l—ضB”è† o ½âX. çBlet 4ª4çßRø4ÿ“t(©×Ô˜þ$uI¡Ä]}'…àœS‰DMFET})éçßUþ  OÓiEçT?ñ§=öäƒZú¤âV3qQ ^þs<œÊóé§-œ@‡fØb$®ð¡xfþµðÏ b O !äA‹8z&âdùà%I[k>@–›n ƒ”¬ÀË?X:äDD½'4Ðl`ˆ=1D&˜+­ô’ ÚE÷^v$ ÞTõý…P\µ R zÊ/X÷$•¾ˆj5’¸3eTO{ò¤fK@¹DVQŒæóO‚CPÒ`\¾È)K÷ÜÃÒÎZá?|zjŽý胉+ ÿ=³n¶Ù<šÉó÷¼×T<‚”ZË+ùO±ÿ$9›m 0;Š0¼!dE$×FUô‹×\cAGÿШ=P€Ý¨Ø }$vÙP¨¶¹/‰d¢P´¡vus?<'Qæót!Ùƒ(uŠ**’T}‚Y0}{üoWüÕôxKseŸ  †¯Ó 0B´"Ï›‚DÀÍ,•þÏ ¢rª¨±ª-S–O0ƒ´`ºÖسz¦ÚT©©¢Ê?ÃíÚlNÊftm¯4i>£à´”¯-rN´aœEY?ƒOG}]öÙƒ‰6ß,™ª‚©|ó]@uóºíļõ['XB}Åÿ>ûþ¥ß]ÄC¸ý±D?rZÏzŒ¸;Ý NtÂSÃÂÒ(Æ$¨ÿ¨”\xpy€\¨ÓÌ„h”º” U“)Šw¢Ê`ff€ù€>>À+…†@[Ë$–åph®iÍ%@­â-7B”zÓUX$Û«’–¸—VT 1_+üàg¶,ÂÏ_óšAR±uqŒ] ØþA?'¨À N= ÀFëà(#W€èÁ·;å *éAÏLh"B¬d,¹à¥(9ÅË$ŽâÇ ÐrÄZ|Žg,@ÝÍ43ŠÊt¡"auá-@H>xd~qš¶€/–‰a¬j¨D°dÿU& ÖVÀà ¯HË3m~H f ÓCH´ˆwœ_l/"¯è·®‹T`0ü0Ì? #JGesbù(À7'–Mnz$ùð":±èµÁ|q%N€ŸØæˆ¨¿}¤=ýË`Æ3–…)@óáŽãÖ¸ÂõÍ+ ëÓI(g~`N7âU ™—þcVžÄÕ¨B9Ê׉Xª@¥«R‚q&”ÿHLaPSKÇ„&4Â3^/•çË™²ä‡¹ÁG-šQDËzq¶0b‘WÀƒá8?Às¦œ,Á¦×Ä Î“š3ªSõ¦½άN,‹`Ì<étǨÀG^N^ñðk4ÿ I¤-Þ0=!ŒB‰—l‹ó‹‰H!Å´m4k\ÆT@%®&ÿcþÁ3f–,æoQ\â¥òC·ÕL.p½*ÆMåv*Y>ò”“|÷Pf}¶{°†1’%ÙÝ®!Í¢àu/‚‘†RÇÙl*À @*¤hˆ¾SÉb33OÉc/ö})„OI<.†vž¹ÌIåÿ<•Wë„ Ö§b¬Õ’–Î[ÀðjQà#Ja"E*ra×nä®Ð‹Àm=j–P€àÿGÁ)†iK+\Ó›†ÅJ¬˜jN|©°öq¯ó· Ó‰†„2[Ù—]·"Ô­ÃÊ›hRC*sM0›Ü EA*–€ÿàÂŒÑP¦*5«Zd}€ÃW( 2§!w7¡Jê‰À³DóA0cãh£ÍÆÏ²%lCyK¯s ÙpŸµ¥_X€7µ-ÂÓ¾pµ³}* '×Ûý³TM+|áŸf(":k;]<;öpÉß‡ëø‹ð{:˜TœB§ÂƒœqzÔ.A]ur 4§Õ<äæÿ{|ùaž/îP%]‚Äݧ<¥š]%šÅV‘äÛ%¸ò Á´‚1Ñ›B®ÅÁa_Üi–õ-¡E !-i¤þe¦"K Uär1á?ˆ‹úÕ“I2EüÞá!Ò.*Î}ØdND IØCèC´Ü…²…ÿ#`Æ•éJÉäÅDuRê\VÏýÑå8Ïé±ÌSÚUŠ@D°Ôë¼fM¥k…`kÌÆ±„@: 2 CÓlÎ3,ƒ4 2Ï+@Ã5x]PÀŒÂ(($üä¼]‚‰(B$H,aÚ-áFF$>GbPJÅça6#@¡äËßä‹Hè'ö§èQ¾,¦Ihe”Zý =‚“ÔÅ<¼H !†gÔ'ŒTE­&`8JÊüˆ ê~±Æ)£SR¥¤# Y%š•^± Õ‘nß]Ð3ø‡/4ƒY6Ã(8g£FÃ+`ޤqŸ! ÁÔÂqÖÂv’ æXŸó‰ÿbôÅ¢+ö¥ýå¤ &KT“•Æ{f©|jéI†=0Â|–L¸|ÁEÁ˜é«ÝRä ‡ìÅ„‚¡}Ä©`…£èÆ+ð€Ï€é̃„ž¦†LŬ¸Ò+%dHVŒcía]Õ¦ìÌæñl lŠ®e3¼(^ª00˜år&İ*EÑ%HÀHÀ¤j ”À Ô‚/øÂ(l'Ò­î !Œ@ÜUÁ}¤Û‰§¦%\æoY)[¹G€ÉLE`ù¢¸€i”¡äÉåK¾Ôg€’Ë^l« ̃äË·ÊÇ<¨@ E@Æ0ÉçüËðÌ^lã&݇ØEë"ѼÿÂGÕž8’#‚A£^`‰†*Íl°ÄÀ¬“¸¨@Ö¨/\2ÌhVO¶±V%:aYÈ\, $@*ÔÂ?Äj*ÔP@¼Ýø!®œõÑ’¤©¢­+a‚ÄøY_Ä}@UÅÅØ¨&J!+H|#xDb€‰´ Ù¿LÑ(T0ÂG€)©h}îE¶f†I­ÌÃÊ!Ä?Ðct„`,Û»²ëv†7ª9~hé±h=Ј(‰˜Èë Ø ÍÍ%lÕ¦^ê>òãÂòÆ[|*^ÖGù% ÅÍÜ A\€«Ö¬úB-$@È~˜„"„øýÃÊÞª!HÚÉÖÿÝNš¤]®Â!«•Ò¬+Í®®êRÅí`ÜÒÒƒÒm…‹eÅ@¶2Â^0B}ò.íÒnÍŒIIx«¸\«=L"ÀÆYŠÔPɸŲ jJ¯e  ;‚D96e~ãSŠ(˜”Èë”h9Íñhå‘Ñ/쥂Ä>¶/0ÌèÞnªl bäß~Êž¸B€ÀÆv,2ü ÁnýCêÒ„³Äø•,æÂ¬ær®æJ€dîåšnÐþVêÚì¨ñ¬Í"ÆéRœÿ€é—þRünðþƒ„ÚŸ‚ïNhèô)©Ä@6J«†€!p ç<½gè^_X휉È:žRZ"ÿñ|”÷²ŠmbIŠØ:¢hQÄ‚¡/mX@[@ƒÞ.§@rªÞBó-@‚©BPFü§A ðÀÔÃü¯ãzìÂüÃL@äñT€S\'0 ²#0[°/0#2å"rêŽÚnEòKònmp•zD³ö¬Ò²ðTHè滛æ#\”2*+›ïâ ØmÍ@ÀI{×†Ïødɬ=Š”Yù²D ²Š÷ªnº”ŠZÛ¾­U.VÞñõƒÐï?ðã2ø0d-X> Ô¤F£ˆ=lÐ=\ì_€+ A=üïÆZó øqª¾ó_ÀWÿÓ|À×ó|ï³÷l5ÑlÏžÔ ´ \`nç*Fø)0 ŸÔ+”a2 «) ³D)ûä(³pè¼é'Ï06J€xq¥PR×@¨.Š©˜ŽT>‘«¨Š&ËG}”~™£KA1KèC9êð4¥8jåÑPó°û $çŒ%2u"Ä…^Æ p^@ÔE=œ3?näʳ'§ê?4+Wƒ„Wƒ5³žTªêsW›µX“µ©Z0cX®æòæš_CWS;ra¾îÏîµ´ ­' Ö'÷uGWô ó))“ò?”ÀtK•ˆ‰»9ÿ`ÙÚ+1ÿ‚*×YP Ïl ùn1k1ÕÑ#q5lÉàÆ ˜¦È7ËÃȃT»B9×Ã?X5Çú2 +À?ÜÂWö)¯²ïF·t³0t³D³öõ&W©AÅÙBw. ›˜!D2#2Íæñ>ësbä3b²Ÿ^™ºŽr_v ó®`¿²ÃWvN+ÄPÏÚCtý¨)=øÀF¼ÖiKíae!ÍÓ=åddöYäf1Ýëhh8–^l03Ö1ˆ_ól+"nDÀ Âa¨X·•Fæ½ÀOõ?˜sU£3¬"Ô 4ë-üƒr/÷äø-0‚r¿^äø£®ç*\B#´ÊF0w_¹•2%ãu>çs_ß²E¶|ØžòF³Õ C@ HÀnd­0|N. Fˆ˜ŠÙ hCÃ%„€$øj¬Æ8n »!Ë…‰h[‰>T‰œUI. g-1±ðóµ=K0¯„EKA¸cT8œ¹ðªþ6Uƒ„U§3än§èxŽ3BªwuW+÷-9K ù%±@D±Ä%!ybÃHDe tˆin”W)$pkîTä1$­Y/í`ø¬Ô7»Ž¹a vãvƒDÖÊÅ¥€€ûÇõÅ®@ÈŽc.(9^Ø…Y‚%ëy“œMÿ *†:Šöæ"‰“8O¤‚ÄFFL b”2È3ȱ¨7:7l©»Âèør“ ÜBŽïøª'öaeü?ÌúThüƃ„bw¹—,ÈÙu–O…ü±©žµ>W@³J4KÀ÷T¬k™O(´Û÷´›9ï^Y)Ï"0 R@œË!ÿfÄŒ>Ll` JìéЪ¨ÌL³„qüÃ/¤ñ»×Nd=f žÝ+V2‘ ‘k¨o6I¦gÝú@˜8ªuº I5ðÀ‹‹zU:Ç p*8|D¹ú)ƒÄ“µûÇüÃà>K>á -{“ É´·æö±ä³D=»< ³0Z²_ïÿŠF«+¹¬«ÐîJ)¯y@˃ø·ÙЃ E8ÁHу ‰>äNg¦L-½VíPø/¸€ÔH¥hצh`SíŒ{Ö1.11˜l`O lME€ód‰,DFÛc“`LÀ‹ô¯÷9kì?8îŒÿ€Ãƒü-H<«CsÃw­þà³ÀVâ{ÿVüÒ—K` ¥!rå êB„UD‹D …g”Xó¹Ðç‚ÿè Uª|ø9’ÒÙ”"¤m»vDÁï¿|>02ȃÇ?WÿêýRøp‚ @¤ª%Ð2ƒ/N°èp­ÌK”øÇ‚Å¿#¢Y ýïêÑ£åÉ»Xá?Dg'´­P nÛjy2x¡Â„ ÔN`hÜ/o5ŠTþœãD­þY DAß?{ÿ9¹H¯æMzù¸·ð ôë G™¶øb«S.æŽ ku'Ö­LƒFQU•^)K-•²Ž­ÚZ€¤J=~ðúÀž‡"Œ‡!F*L á1_"KÀ"!3ƒŽ3ޤ[þñL Ð\m´³îYM FJºÈÿz¬­6+0dH+@B!$y îâv©¯ újί’<¢2GµDšgG¸üç–y$¢`¥fû {è‘©§š.ÒÀ¼Ü“Ç3M4Ô.Jm$b5’¡ €L¨ÇfÕê‘Y"‰l²Éá¸ßXÌ5KË,S®ËˆBò²$.?Ú¨#+!€€ !"!{œHó¬6èèÞš¸§ y–¨>¡¢¬Dëÿ—¡"t*BÕx§¬~Z”Ñð•‹Újë•·Ô4cÓ’‹ÓNEЋ¯ Ö… °ZFlCAp™XI¥['0ÑÄ[L¬ìçb¤ñ4cHíÆÏXȈŋ”åÑǨÿvj§¥U·á*`¸‚ÃíƒÂv(ÜåÆý6G‘Âen$µ»œˆ –²ƒÞïìýGzàlAž{üVê„¥BÈŽO Àá—Fë‡W(Âàõ‚"ü'ônÔ‡¸"yRÓ¢d…`pó;]áDøIyÝÀL}ްzˆ±TD\¦$ ¨LÌ.˜`°\EºÅ³ÐJ+í¬ÕR[ZWÚœ¥ú¹uó‘ÿ¸ €£5¶®@‚ãÆŽÍÛ䪄ü^_Ërƒ"X 虉¦ž4óÞ\kâŸ&ú•S);µÊÇ)_â¢R±4Nq‘ûÇäò¡•‰.s)K|±ŒQð-YAƒ$(¢¤ŽDÖ%˜‹&U#L=VÕ˜0¦¾À]ó3‡,Äz#±Œ _44ÔÈXiˆZ‚T> IZ!A˜X­‚(ä ÎØÌW*‰„[#)‰ÚxãœËx0Óo¢¦ïÌÏxª˜âVPA¬ïA RÆ@¶ÇÔéYËÿÁª:$vHv.|•ˆrw€eE$ø]ób«¸¨‡ÁBÞ?ãÏ”äZF¬šZ¦G+‚ôˆ8†¸–€C­³DQE²¬LÙ´(®YÆ#)aDê—7¼ÝkoâiAàä$jâë=wZàW¢R„¢ü#qÛ£üøGºá‰(¤þ¡©ÐR ¢ €.‚º ÂàÊâ ×ÁÎõŒX‚8&†’)Œ }–WðÐ!·ðÙH`d<Ó J#ô„©Z‡—ÉÍ€ %'1¤KX$¦ÙÐv.öÊ2™ˆ!€„”ä^õÜô&?9@jÔNÝ ¢(¯ìaé\˜ÿÃ(?jÅN‚Œà\,VÕÑQ‚j¤J•º|Š0§êhaºÇÄʹãÐHL¤­æªgéLŒ.êÊy¤¯£½Ñ¨m@º5CèRk±Ì–@º›’dQe€b“c>ŠÓ9̉©_$pÏÌã&ØÄWœz‚·8¥±'ï‹‚=òáøD)ý§zð–µ³Qê™Ü¢€›D!(ˆ€\=éÒHƵRô\U±#ºÌŸ.[ëYV3LÖÃ…hÅ<é"í »£tÙH€Ê^Ä5§Éë³z³Ä©çzZËV¡¸›ØÜPx$šo¨Åo½”±V„ÀaÓŒÌC®ŸNŸÿÙÙ³¼o<™IþaÔtRU‚SÉÜ€ÌÒ¨?fS<öØY$2Ne}ŽÆJ†ã $¬(æPËc€ÝUò4Œ }V_Ìês=ïn‘C\ÕŠEÄs‘g`Ä)N/¯¸ùëô†¤^'£·±é¥ëK6ƒtd²¯‰,I[Eæø¥¿<ñRÞœ9¿ùAšx³[œžÐ–Á“Xà © *?a&›óˆ>Ö“ª®ê?8U莚S#,¡©xP˜À•0ÿp±ZXc³>&VÿX2~@«ÁaÇ&º@u•«‰ª¥È¹H,ÇKË ôˆ—[;’“IІ8‰ŠT´o—²XLÿóñ:]– ²ôQ.k6îáÍûHkså+ÙËPb»Ç‘ÈÅ* îl†ƒ9=jPÐ…f\l·>D„@$®[áË^vP†…j B/ÂIüàµDÁtœž1¢»6$rÛDÚê½'7¯þ‡-Õ‚Þ['DŠTæò0Ã>¡yë,h‹¯Døëߨ$¾É :Û‚ùõd; nà?ÜÜ•§èx$g¦°î>>™ØEþ¬–@ÏEÐa1ñ¢]&˜6š0»[«‹_L˜Ù½ðU1¬q-S»Z¤b°•DþIÍ H\Þ¥(FJ¢VwHD’€!zÉ5®! ÊJŽpœFenUÿ©âãké1'~L]¹ã—¥Gȵ“/8*[ÙÑùLÚÜ`–G+Ê9 Ë›2¸\È‘Ntb03ǃ%Õçaç‡ëé’ˆ¤›Ñj!h= À‚Jºè,”í ú*ÆÄUµ@†dHàÉS™­·Ú P‰ÊWFd—÷Õ¶¦Ä'G8èý]õ¸õ^`ç=|õmì¨ø®+­KY f5{/Ìž€$Ïûœp¯íÀç"E¥c.˜òž³ÀG)ÿàÜ“”ŸÇŽf£çxKƒê)¸… VæŸ\ÁÅ(£Ñ\Œõ8dÒ.‚Ucf.âC"†–!zï€x*ƒw€øTæAÈvlˆ”¯ÿl¯Î!‚ƒ8°†¤2.ãðï⦤¤ïvÍŠ¸„¿ŠÍüâ/§H.prÊN৚܃ 7+ñ ln)²©2à^@› *ªºÍÛžã·8l†Ýœ0ãݰC^ö$°é(‰¹dÇ1ávRárÌKÀ“`ï"~&”vçáWŠ•ìùÒ ÊzÉI /W°×`G|¼Oã’m&âRGüÔâ&ä(ý0ËNî…šHî9Ì£èhp^A B=ô "Fq›ôáÈ¥ç8l$ØiÜ%@-ÝÌð"”îÝ’Ž2z‘ \ow Òvgõ2É1nÆò°FH`0h(†  ÿ~g0t&32b¾8ªÕÞNÖ¸¦¯àNkjÍG!èîI:J|®Œ”ËJã!&n@ ³v$•ðÒošÎbìGND"&g:æõaôáX±þd+bzb´,‡Q ƈ¨ŠÐØG\ÈðÅšM¥üI9„$%í  Ñmoá,í….‚ê^%ò­/àTPÄ8öní ¸Z€HÐË—*c½Ô±IÔñ½x1®±¬ {Њ&@(`uîJ§oš _Œp$äRcF  æap†¢É~ ÿ°Ð)fãa"†<œ =üŒ·¾M9( Q(àZàþ!@­eÿÂ@Í“°’Xoâ$]ìàP²U%Þ,ð`å¨îj¦Æ"b2ß~`@¬ÀnÕXÐH‚27¸ÆHÑÖ¦lútÃÉ'\ñ[0î5Â'$ÀÏÂNÈ+ሚæ!p\ã¼’_èä"&Üòž(^à”3È$, ’`QL¯ÿIJš "€Ú©­óñ€¢6f;iã>d#¶(Ý^ <Ëó"@íPÒ“N’=ÕP¬v§/ /¢/q­d§$?Ä21-VBäê JöhH@ ‡rÃ4«¦Yޤ‰ v ‚IŽRÑ´y”7jÓ8èaNïêÝc úæ"ö’Â=üg> $’^‚/õL šâZá¶ åPTŽ"©êrH(€Q!/E@xàÖHÙs=×S @í1ôÝR5˜T À>sÒVÈé U<„J#†0-­,“Ve̬òí£H5ô q»”£znú.LÇG‡–òû>€n@Ñÿrê®N`8ûæàÀ[ 8]ƒNâ+•¢ GBQâ5d(UrZn,²(ðžæ(€ Z eÐS= ó"˜ÔUíSH]LH/ÂUï3ÒܰU¸ô…¢ë27S `¥1jï "fÅztÉM5jű˱ ¦ïMRùl³Ôx#Xäžb#¬8ùF[ûTÿ8àøÔo’5fd)üèÖ5œ5.lrøH=RQü S©ª¿î "þò<Ùó`ö$ó0a%­÷ZU 0 aÛp…–‹JiçU.3Ó΢JÓªÞ–w(€VšÏM‡CíKkÈñŸúÒ±zÀTùf“âÿtHJ(@/‚K6ÔüÒÏ[Ào¦8ŸÐDuÖE§°QÖµ8bk…Bƒ*ò"ðÒ?P6LŒD‚=KõÅòP=ý’I3aK—kÀk]—04DCCÆnÏlêê¬vB2Ø–®cm âX‹Ceð(‰£[ÍïîÊŽc¿òu6 "Mf~O`]|Ô/6`‹Tów“£%1i)°”1ð’÷¾X9ÊÖwkŒm£A‡÷íxƒ8>ê"®Ñ—´«î–µƒ Ρ’[VV7mjCñ˜Bà§ߣ~–¢NtÊ P €ÿf¸žõ"gÜlt›.g6¨ssÓé}ñi]ŠLj£xH@”Wõ`3 \/  ƒ’Jr¹`Œ|ø?SŒ£ŽŒ7s†¬‘X´4w$fYB{‰IÞø—ú6˜ž“ã4t¯~RoOä˜Ð .ú=þ'€¤-æÄ©Q ‡s-™;5õ —ö^Û‘—Y È3‰Ó/`Ó“\?ûé„xƒUÆC•G‚€+–ö`…?ay†Ä´crÖÜ®n 1[ /á¢%¸M…é«ZBJHò3‚ŽÞäÀl"ñØ Qb8µ§µ,¤éòÛ¸³9uÔÏ¢b®eÃ! ^ IÿR‰ÿ]µ¯–T=r õð,. )‰VÏâ§'ö€_h%£îvdÈÈd–ÔjˈHÊzòV[Lv iÐø"¨(N ¡¿ìaK¾CÕ(zÛŽÍñìϳ£µÖš¼S©–¥Q4ui»p‚¤¿Æó 5Y¦‡T”£°×Ó0ÐõX°yZ–JR±•ƒ1¸TŸ3m|Á *[ùŽÄi³qù9¤O½°E +t¼¼§˜+`C1"äNŽ|2k+ +Â)¶©(†Ö"•6SëU6H‚D(þû¿GHÇúò1Ñ™7Z÷ ª ÛP9Z…žc ÷æ™v$\-.ЬΠ–±Û'8n©eAµ»—uc³‰Ò ÿ $´ Ž'NÏ‚´µ§¿’’üX[äÖ¤;¥Ü,­aζ•Ê"Ô¤‡SG"sk¥ <Лܓíswàí¦óS- ;ÆH2±=¤ÂqWÆ^’ËkǺ}ᨚ'ݸàlY9ÐT(±¥I.´A{(cx¹§ Âæ A/&`ðV{À.‚ü /MèFÛ¾€üh!ÏB~ëÛêš6þ;^ÿ»h1¹‡ ܯ͙Òó/p0Ú¹|vÚ’œ»C¨q¹ÔÂ30º÷sñNÄ•ï¯xÄ,˜£D\nK¼8 ´· —Ùtª{í¤’o ¤„d£ˆ/ á®=ô¿TMµ O&Ú/㛎}|Ò©ÿ¹ ¥Úúk›ˆc U—D"4š4Á<=qz0ð¹SeË5¤V«¼v€:[af¤ñ° x¨­»ªqj¼Y9¨|IhZn©–ƒí”n·½:M‰B}Yl¢¨2º‡Z† TÄk ðø¿´2.BÊ"R.^´ ò~b í¨Ð?/¼_ Pˆ«&;´’Bà4RM-¹e·C‚1ÊUeËa Â+)±á™ÝUÃcŒvåöBdÓ@`(À´‚:©ó’REêɧY’o‰Z]zî²>¤`M-b MoMl–מ¤ ¢°ä\Šäœ è\ØÕ›pµ}{éåÙÞƒ' BÌÿâµä©mWSMº¿ u/øb =¸½¡x`e¹¡´Ñâ3çóʹ¬ü°à|u•/6¨C²; ÷. aéùŸË(‰„á*x'9ÖLuIzbo×ôAuP«§|Úþwºg×¹Ç÷u°Î!‰/ä>Ï¿ã}þüø•0Q[n ¯]F’/u€âÕ©$ÀÍPøÑM kä" ¸UÑy‰!ðTBÒ„Xpê;]vŠ^-Ã=DCtÞ¯;¦qÕ)`é‹Þéž÷jÂп þøïÂAƒ‘B" AˆJHXáß„ &\Ȩ῎<~Pòâ@“ QJ˜ რ†ÿôÅüÀ(ÄN Š1•ÂyDú±-!_ø¢CD!o Ú‚:rÀ\ÿ`€^õ\×?„ýEØcŠ$A~VOÿ= 9¶Øa•€!AŒMFY-¾ÔÒÊ„§!¶Ù@† !Úi+.ÄÐh1žøŠ1Ò†#D ©x‘JŒäÑräöÑCwRB0‰ôÒ?é¤L‚ˆEåôvÖaWÔuuÅ”WG}÷KUf¢•™‰écšMGuBX91A øõgVYz®5Wÿ¸R×]wVvd¢‚Bh"a|%:Ä£ŠvØ?VZØaRšŠˆÈ¤²Ù†ˆfšD-n6j¨'„«2$*h†¨4ëCSÎÖÚh =yd‘`×A% yÛ@! 9Ò¯ IIeM3Ý–P]†ç@ù8¦xí•Y^šœéãÿh6¹YPX„@ç<øý#Zx:ðŸt:  ŠdÚ‚xù5¡¤÷âµj`'Nø!A—VZp†úòéa ™úb¢Bqµ(ê_0þ5šj0Ò4޳¤PFÉr$ä°Ë©\°u•¤±;4• "{Vf)­P>)uT¶ÿ©zß1ĦSÕ~9Pœè22Á<% t„AýÅeY»D]õºÂ—B|/£>È*Ú ö °c~1ÆPe­r3üC¢+"ôPb¤8Ñiœ¥†šDY¬#C ÕŠkl‡¯l›p\”‘J3풱ȶ–¹É)I0"$&º>üØ%Ïýÿ™‘çÔTì‰×cV©Œü3ºí2o<訡†ª×Ÿ¥)Hh_}ù«h¢ÐlaôdÙ@•¥B·‡w#óƒ‹C´*‘¨9dÚÄè”qÆ0Ñ|:¾Ö£@¸Ú/²@&ã&¹EÅá†'•ì#%K–±$WœÚ8‰&£ÈÍ´R”`IË`"H˜ôQ¦¨pK²sÊ휖%؇NÓ)<ªFþ<à-/ Áñ†—5¯i-PŠŠÀœ· IMO`hs_$ ý£–¢ö¸Ç!í…È Õ«Vµ·ØHVâHúJƒ‡L dNHDPb,MQXT‰[ó¿™äIþNÿÿþ÷9ø­"¸}Àò¥(¬ÎZùÅ54*šniÐaQ¢3µTízZá„ç W ÏP¡¤¾øÒB`º¦™“>%Ú?XFþƒx@YÚ¢Ÿ HRžõˆÖøb<€9Š_ZP¢ò( 9† ˆŒA0%Dì „ˆJ,¢¥ˆ«5FD8´QŽ.g62“©GNÚ(G´ö$û3©2-ÒÆ3- É á:¤atA–â0°Ja—€’%{äô(QHJ.âsÚr… 2á™}¦©µ?î"À2p[·Ä%ï„Ëîâµ®Ù“X=›%#•ÏÂLý k¤:D0»-戵`k*(7 Õ"Š!±•!"2ÿ"‘H匵›åü¨$‚5HzƒÄ?Ù±,©JM*Š~2dÂLDgˆ˜òŽAñ‰ha¦Ç¥Ä)<pŠ>òa%§Ù‡'¼ûG ZÀ‚ ߣ?À@‡ŠþÌå,p ½ê2—>È@1<“4èw/ 0 ?áVPí™’ˆ<.%v BD+ÎR%·ÙeKZ’ø ¤ðÎJž\ݰ·É,æ›Ò~VbÆý„AB7+²ôŽÒ‰`Ó¸#Á°eÍY‚È9døò12€gÛ¶ó,vZËnO¯à3ÌK= P¡ºhí†ã$—ï¥É N— Ö-h§ŒhJîÿ±T] \J»×‹6©½Ù(䢬±ôŠÄs÷U2áø0õ¤lQ5€Ìe4pWCÕ ‰@ȱ.§ " ’\º·†LË´üÐ<šÍ)H¡MÄ”¬£ß«µMpìëÀPœ°u¬Îž<Ì‘9ð°úEÅ ¬[+TNgbmçú30>uáÇû±fÖgûŸ +Í­MÖáÙ àw„7¯MZÓ5MÄa ÎàûÍ>]¹´\ !¦*(¾;ûÓ¯ª³… ¿U|ѺwB, ×ÉeGT´A€Pí°qŒè+ÝaÂÓÚÖvÇÜ_€ úv~üOXý{L–A3p\Šbü͈pÑÖé7¨rèÿ׈†h±ÅÌõ´+ƒ¸ª^BÄ?ŒÓ>ÝÁªÓƒº¨±Z°ë;®/¼À©§Àž|ÑJE5÷pK€âï{öâAhgÕâýAPÚnW„qÁpÕŒx[àÕÌãÇs=èa=HŽÑ¸{ÿ¹ Ù&]/„×x1͈¢_[üPØcÆ<<ɱ¿¬·›­ºæÆ;®?­¾ËMÑÁìɺLm(®çŒdv çAb¨€ ÙN·e–faÀ𲈰~LÏ?N5PéqñúÑäåžîÒF»ä è€Ý–CØÆWH?2æ¾-«k^ÿŒâ»¯<ÀòÚîv“n(EŽr'm#ßN|²)kAÚÌæŒð¾‘£®w¢…ĪU<Oçå+ñ¥AëZô¼ Ü®>Éã Ø GÔ½žÂ4ûÁþ#Î&¾ÿTÈîÉ€B÷ˆ1à öÞŽg‹[íy‚ãævúQFÞþí0î°BOb­[þU|BŽ„nƒväk¢ˆó¨žêˆmŽïm#nwAÛ¥f¦J¾9=Ô€Uô*ù^ªÓ¯¨Róë ¿<Ì>¸â^à9{13¦#èo§í!b˜è*åxfpéÌF–¥ m¼åòÐV5dYø£^î2ßä¥ åŽoì:ï¤î5Nü*g^sh[.¹ á¼=µ=áEÿ¶–ɽĹÞ×oLÔÅksHˆH…ºÔ-‘\Ïõ@¹â-Îk2ò¸ÉÚ¥-bÕ~éñàŸ‘FŒdø÷ÿ ƒÿþ á䟃A‚¼ øâF‡A8ØÒáÈ‘LÄxd"‡΄S&IO’¬ç0ç5ÿñy’gÎ>‰Ât%ÓQ¦ÿêMIbÂ-$þA`dõÖT¬Rÿ‘Èú/ëX«Ážeäp ª%Ø:¼UbæÜ‘GXüS)Ï¡¼#zë¸çÀ¿ÁGÿcqb^ˆ‘äaÈ ¥ä• _`À d’BvP¯ÕW/0b)ñâÇ'n¼›$Ș 1O4ùO ]Þoþ$™tdÍß4ú,JrHo™êù„ðU,„©iGN;µ:X[ÑvÇ.–Dw³óþ• Ó<óÿ¹wëò½wäÞ`†UŽ$ ÿŸb öìM(!³2{`°0sƒ#*Ò资ú‡³‘<{ ¡‡$¢mÀ×^8À´h;É$ŒB,n6Ô4)·Ö‚·N°`¦ (Ñ'çœsª¨›L2à$çž;޽£JÊ„+r‚´ ÚJ¼éÊÚjIëÀr¼«þ¡j¼,Ç:ï¼²’‹½äa/ÄTr¦øê£?•ó«±Ë:P³„XºM¢"ˆ ˜öˆ% º,£É¤èׂRÑ$JL0EÔ@ªiF5: aʰÇ“ûmÈá ˆô&£täéH˜rrN¸—rÊ'#uŠj‚èÊªŠ‘ÿ®°ºn¼¬r•ê¬îx5‘nùr=¸Ä¼ë>¾ÊLÓ¡5 £+¿¾XˆAz®0! ñü'–@ªê2;G´3(H€‡B+JðÀ=ò(D‡4éC9µmÜ|g.ࢳɷ× ˜àšŽ"¹Ü~5¹¦«G¸Šÿ1’¨UÅÊÖ´ÁκðHÖ!ë¾ ‹;ª¨Â2ºµÌ L1í:s/òꫯ¦Ì[’sžì™SÞÌŽ®SܺÎ$ÜÇÏ 3m0¨è¢52`ÆMz”¤g›ˆ2Jƒ¨ÉÕö´`GÃn°Äæ€n¶“’ŠØ§åꮘ(‹ŸkÊ)¨¢Óõÿ[£3-,¹ ë×-µÜõ–µŽÕJ,’n!©b† Z2íz–/2ÇŒ/°ûz–Ú{ûçF^héÉHº µŽx@ê˜5â…!Zá!R´¯É•ˆF”HnGÎðè–îP`OÊצ=sà›P£ÇOƒÄiaÀ½O»&WI¶Õd^¥#Ë䳸’Š<˜ÎúJrÉI˜óc9'é®hÇ|ÏÍâÄ‚»/ñ!@›"”@ÎÌGz™Ç Ð-‡d†vbI.@2FxÚ?0¡@UM"¨‰ˆm‚0„!tMl`ÛQ‡ŠÃš%%?áÚ½Ž“*àäÆ2²]l”œ’<Œ&õ`rÌÿ×*ãäGN4™CÒ‡¬ NŠTOÇÞ2¬_ee=$p –Àh¬eõ#¹™Í>w3‘ä Kr@€ÔI(Ž{ÀäÉ`P âúGí2ã€p„|I2ð‚VP ¶yÚjh€!N¤vÂ] "€¨‘d!Á4r /! $zT‘ÐÆµ!ɸl’"ËÀf–B‘ƒêi*šŒˆ ã'pø)ªÿŒa G  Bý™½‘tÑŠYÄ\–JcäŒqÏæbrÌ‘ÄI&Ô$‰r0Âf:¤/ytÒT' Ä*yÀæÄ'#4“ (à ÈÖ*†q(ˆµÁ5óe°Ù„ŸÈÑó>ä ž”h|€"I\)*-åF4ÕÂz"7ö€”=ˆkS4tÌu.fi]ÿD—³Ñ°g"i„DÚL È#Â5Cçæ¥Ì‚ðÁ˜|Æ„‡2ÍG0c€ 8Œ¡ˆš*I£êÈ'Bá”o¾Vº”V:±QT»æÊ…ÆŠU9¥qÒÆÐ»2tÿ}Fñ|´ÿ©¢ˆ‘ËæîòÖÓyÔ£äh™™ƒø°@k̺ÒCmR°äÄ3 ‚… 8N_ƒç`9 R*Q¢¯G=Š'‘%YŸçÔã`•.Ïù©€C ˜jHÞ#m¬bõ½˜`Kðñ3 Ü&p¤æ-0°`’àÂ#ÁÓn‰IÐá¥ìQk„r°ÆÑ./€.pÅÖé[ò¢kÄu…t&1À ^ ŸF–œÿp—˜lXC†6E6iØoö5_»©è‰õ…ÉÒ#ÕÆ$Tƹjuè¹¥Ké²'f&€…ËØ?™„ŽfnÓ`”›ŸÈå¹ÿ*F,L`\”†OHé¹"®z´03‘!gOÑɃ“€OC®`¤ü%’ê-/³‘4o‰ÌêÃ}µ6G:mjƒRU­F¡ÃåBY æµÂ?ó»’«1ŒË˜ØI ¸Ô‡?¼³cRs>Ô,$}r0l¬É¥AP1Æ~bë úŒH‹’éH q&¦¾ç tâTm"äZ¿Õí–x­È¦Q,…6LõF_'’Æf_¨j²&qÊs~³0ã¤r¡µ;f—qQæ¹ÐGÐ0Ì„'|p4žçÒbÉ}“Ÿ‚tâ^ 8¢âˆ`,^â&‰f¦ÍG €4‡öf… ;Ÿ­œ@}ŸmPs›–Ä|ÏaÓ$ íÖéOÍà#¢Sbyœ±jÕ68ÿ‰D¨Lœ˜ô&JžÑ¢\+F|ºº* ­A>†cÉ=š ÿ’I‰FÖ"¾Ó,r;ŠðÀ-äš ÷¼éÝ)® ÁŽb˜²d=ÍfŽ„ jæ7¯S·7¥§¦~HE¯‘ yâšíÍÅÉÌY%m˜®OÉ·9]«T*!ù ÿ,éÿÿ H° Áƒ*\Ȱ ¿ˆø!Z DH„Š º—0!,5R˜I ZQ0ôa„Í›ÇBÞ@ˆ9ïƒD†I0J… "u ñé?”*XøA¡•Ö n(A…ÀF°ôÇò‹û0^ûxóêÝË·/Á‡ùþ=løŸDÙ®½¨1|ЀLØ¿£BFh*á_¾ ÿZê<1/„Ì™òä‘þWáíÌ›Œ1–àR‚¾7šê¼T£¡³?6¤ôš»ëãnH¸`è7ÇV­Ön¸Qá³½¸ˆg؃ßïàËÿwèYpyÀæó ˜ðá7()¦5iÇkÀ,àM ËÂhF>†TPà[éd=4ýs<,”ö ÿ”pP°Ôeý†k~ [TltÕ­ü•Š'Ö@7ht–H Tà®=¢ÚEw›Öko_M"9X¾LæSÀüÊ¥¦X~˜‘SNEn+C¬]t)5¥T "ûf°m¦æàƒ7™æVL×BP“…¥1"Nn!².ÞÝÿàƒÏ·Ç§*rA‰ ÿ“RÌa Th¥ò8ä½H'í©F–'ð_†10AI­"–MUÅQ®]ùüÏ ­ ¥ÏR0Âf %P¨1šª@á?ò`p6™ […¨ýsDjÚÿ}Ó[Imî¶ké7ó·1ãsƒ¸CÐÆ¹FgxX,Ù“c¥rE$¦JwÞ9¿E¤ža+0ð>ü`zÛA†è«>Ct•âÕÿ@¥Ô!”)'M%¸É7Ükžì=݃M'¬™Ú=G0OrËS›Œ¸=hIýcQT®G÷Ï(Þ7 > $zÁì|îf^¥»Áí~À¼:J‘a‰`?Þq'¯çôKÀ>µ#S€"0Ì?DÙ|m )ì1„¥H\¬jÑØp7Ó¼æ-x[jlòáɃ!ñFˆ…ÿ@áÜlBêÁéB>„!¤ü†ßÿðQ‹Q€k\t‚À˜ã•MaW’‹=HU˜Êe·ÙW·È!9ÍTžzšyD°|Œ`‚AÄ nÀ*µjl/atªÒ —)eó€@Ê-„ðbJ^jT(Ã#ÀÍxÉ@"sC4ö@óX€CP„‡-jÌoÖ… `Œ‚f]ÂHÉŽCðJ®Ò²€©ghEðÔE ûÛw™£¡ê/_LêTe˜`Š"`£b»ärV²D|–L‹lmš jò™pn14ž ƒõ<‚àœÿx!ž‡±A…,HÙð‘!ˆ áI‘.€ÿŒñ f¸ÀP:ƒJ !v¶ÚÊ2"¿õHSEÀFÀ@^ÔÅhÿã¥F‘$Æ^þEˆHàaÒˆÆÚQ"9c“@+^Q8 \š8“ˆ U‚Ô¼c%œ‡ ò<ãÓ `¤"U(7b±àÌ+Šª´€ÞÅ,]‰ÀF dÌì8[Ñйz ’Z)upÄ pN¢ L«\Ó?&ùÏjõœÕF•ž‚ Ž˜ U–ª´–Í|Í{ºú™YÀ²<Þ$d'xQ×T§šÈƒxyáÜÊ)F 䜌ì)„(ÄLf\iÎYR4.­$]©˜~ðÑŠ¤·i%ãpùa‚[ÂuÃ[¤«š‰ÄÔ}hÿþuµ—ú(E¥Ú«w×µC@ Xp“^›)Éø¢ç,§ñ8NË2Ró­ï‡µÍ#Ÿfol‡¢¢.t±Eÿ è¸ ¾QÔ¢À£è$~, 5F*!ч2\&•ù­Å=3š}´fOÍ5I±^ã«° àÂ# —‘X +(Aónj“²¥¦y6© ¢q|Ùçíí§ñÍÁ9‡êHX¿r °M¬ÞÍä– ŠTë⨼dCC˜ê'‡’TøX‰‰ £(1¦·`Æå-B ïi¿dó?P§7C¤7ÐGŒ^õhàÂÅL‘•PìR+­ÀÏ,ÿh!µÍ$ÉDzÉåé¤o·Q¡{ž^Sü!¯"ø Ô¨â* ?B%Ørå³í²¶P‘À<^ÐYéYŽB{ÃØ Í^sÒMz0l: dæ!+XkÚæ¯(M½<òD ا×>>3Õ¬“W*÷Œ(C07¼•è‡z‹L2߆^áG®·‡³ÝG¿Œ¸DT̪½¦:ÿ1I†‹®PB ¬É®šòç`í­ÖrPjzçòÆC¶§A?êÿzqþhúB ›5!%c¼Í ãÄlôPâc€qZÁï|o) T¯åC@µVõU^Ep²b×?¨ã?ú€keç):ò{õ‚*¿dq± …FA ÿ±¡=°C0`1ÈZÑ6!67u71=C†<‹—hhF§SG€NÛÆ^‘†B"hÚwÊÓMb&b2–ôøA´>€“OR5Dfµðý¤]‡qa«Ã?º×…¸¦{Ÿâ{È)Tcƒ¡F`q]q¸âw›!‚-"‚ 5'ˆà+"/ S‘xgóNéÄ÷H«ñGsÑBêåƒ2<ÿIöpBBfC4Ã3ô·;C„F-Xú3âÃO\áU1Â[F3Ã¥a (†cÈk¥ˆ*Ê´”°'Õ"”€ ]ÒÃ*¡l©µ2r [q¤&ÍÓˆ6¡1“,5ô10ŽÕBãdH#NŠøX‰gÕBÐ=ªÑ—‘÷<ÇS!Љ^“xýUC ’SöÀÆB,`!f‚"!7 ¸ÐJéY"Y²§Ø"OÈ`ˆ 0Ó"1¢*æ±/ÿ㊕¥š•¢™þ“šWùpIÒ¥ :R¶ˆµ"lQacc+‘ˆRÊ‘;~’9„ËhÂÒYÚ7“'0Y‰F7£yÉsT¥˜Ðyd£!˜qÿ²Mk2`›aI uþuLÊoø„`õ˜PH…ÀP ‡2{“kµ•XùVXZ*F¢#òâªp‘¥FRvT™ŸI€!aÁÔ4Âįâl å²ÙBO@Z®RwwH„à)2yjHz£}“è’èG<èYì%Õˆš‡_y’ÁSƒp#t›µd,7!RÇ-‘Cg‘+ïS¤óº`£° Ë»É[ñ?PšªÜÁŸ¯Š9«Ùª£™•Ö{J@ê!?¢òaÕÀ¶h]¼Õ¬!H,aÝú€G{ô|7†$7‰§²AÅSÑS:ŒHåô’Û¸mÿ ha½Å£7⻌öÐ~3ºd:A—šŒ2cñj 1Ñ5X•”ÿ°¯®5M¢¹ÊU)¥H€£)$©ùºb¸lÀm÷Á»¿Ä»ûR %?j¼Å8¢Ù2Ç'¡=Ë·ƒBŽ•,6¸ïÔs‘µ^òÅm: Ãsh‰”ÃØZNÔ“/H!-ð¨ó`öàA%´&2ñ+¾Òxt$ƒøô!eA4Ÿk¤[Ñ-ÈpÊ­wŪ»€r¡Kíº[Y 8•«c)SŠª”WÛÀ>‚ ÙQÑsáËC“+4K2:¬¡qÙ›ŸT8a£:AdBèƒÔšˆ‚|Íñ_ìåÈ×{<~ÿÚmŒ67\³×Jô£Ü š\B?§SF–†xô+(“[ìø¼Õý …IÙ´Ëp+¡9¾'•_ø…XJµœEjk\”ÂÅBƒš= %¼»Ö½Ë4†QѦBET¤—$Mb"UlSÇhj0DÍÜlNí5ØZ¸w¸ó•h~]˜B+Š&>WÎj2®;Qî⿲½dŽÙ? §¼ Ÿô™½%ÐÜQZlµC2¡»¬Ê•‹š”Ò{âÑ»E“ì/¥²Ö¼ý{N‰awƒ3rIÑ"ä<Þ˜BÚËSÐxÐ]N:¸8¦Bâˆ"JN=ÿçÂ+É€6ƒ(YBÑÓŒ`9¬Q6jÂÔba*IAº]q¡=Ú¥*Á±ÚÀ–bдL•½'/}ÇõÀö9»åáÊé1$kÛdU¶cÌŸ¼«µkÌ4¨C¬c’b*qgÐB“ÒÃÇrcÍ…)@F_Ý*ȈÎH5ؤÝÏ“ÄÓÍ YxÉo²BÙ)ÔÏIÔ¯QCšd31Ïá%B;ŠRÕ £@ÕÏð Èð"š•a™aýEb}:kgÁIb\uuµÍà¡[¾ö)máHæ/Úa‰e.:A¬ôQlÃzä&ªnEͱmÈ$É2·s2ÞÿC’œ^ƒã/¾—ÀCBÂ3=m· Ë4aÎþu-¦ãUSF3¦» Q®¤¡º =Ð̽{uu°b­pñ¢{]¦m†ëw¨µ ®# 1TÔ$ò3‹lf¬B%À)MPx{¬Ó‚1Gˆ9¸=e2 ÉïU݈DN’†~A¾ $,'D £Q¢‚™ÉJ±lâ+D oùÄ”B™"û,Ú¤þ ­×"N:q¶ŠµN*¨­{¨ºš`¨•Ië¸Lf®ºÊ«½Þ$®-*7ºŠj»/ê!Q?¡"¶ØJdc6è^ÞѬèÔ ÝˆX_ßÖ²Œ”õ’ ¹ýû§/A„üþÅSˆÐáÇù"4hÐaC~1&üWà¢>Dü@ò«ðOa} UêËǯ%A…ùz|Éß‚%qr, “æE›ˆÝXèü'^°`ÑB y÷þÝ;"ïÈ=©ü#ðý®¦ŠýšõaW‚[¹N•JÀ-Á¶RåÉ;1½!ò±,ˆ2_Þy-èÎûGð‰tÿŒøÄܺôB@hQâß¼y>| ÔÐ?Îÿ*H@áF+|È€¶l²Bê+HáÿÂ… 52äÑwßÿIlXð íx "—Ó¤p˜}E*Xœ6m“eÊä¨Ò?àù€ƒwI¾@à3µ›¤}Ãè<ò¿øažÕÄ­fE»µ«Ù®þ‹ ¢µþño*‚8@ !¬æj¡…ÈB°çîþAD} ÑçÃZ°Ë0ÂB BùKŒ.þ±gžX8¡„yBج 6ƒ€‘&˜ 4 ~øa”Õþq ˜Q~°p¶Œ°‹î6/š¡äLȈ¸Ý†Û­¸…+î  J $•Œ<‚¸û 82›;o¸ˆ°¤ˆºôày0¨ê2ò«ê‚®Ë¡Ý !ø$°+8 ÿtªºGžšŠP/ 0üG¡ô‘ ŸB@ˆÅºZphDõƒ ³HåÁ ´*¨àF¡çF Ø‘ Zù˜kþyf"Í…ÄÌí¶'›LîIìr¡LíL¨ÍJŒzc(½å‚J‰Ÿ ±´‰#‡¸+Ï#š€C½›Ò+ÉÍ—ÊG @DFX8âˆìCÊÔ©ŽèÊÏCáúŠ©î¢ ŒJ?¸¦‚t±º “ŒÂ‚áb 7 aVí:ì²Åšb8±cª.Ye³X'ãÌ "øŸÖ„ü™b¨ › ʨÉ&†2Ÿgq#èÙƒ¢,àY¤]²M"ÈÌ.ºm±ÿs9‹Î¤óÈk ÛáÀC8°n©¥­Æ<ëÓñ„;ç2®«®ÂÀ-· +¬¬ÚâÊo¶\øžÆDEè®Nó©TLWXA6M9 1DUE LÒ‡ä»ì„W¾ºæ©u3˜eÆ`šñXaÈg cOîgîž”i"ƒŠžH8j.°§}H$¬›w½óÈuškÐÈVè¼–vÍ¥wõ‰÷ñaI›0‚â£;1>Ë«¶®"Ÿàÿ4ëQ嬹:vè®ÍòÉÃ./ª ¼#,0ÄØÅC‹aB ó¢¤(€“‡‹2## !W?°€jZóŒgCX†øÌ@FàÿdùŒ7©nŽ#-™¸ H«n ²Û Ç8lJN—(’Ú|ë"КÚñ8r¦ç½+=$yLr¶’T€i‹@ð\B{„i`|ªò¨‚íé*ã ŸÀ²>õ%F.ù! ˆòã¿Ãy*/©”VðèïB ‡På¿Y¦‘‚`ºÎ%p0ñaf¶gDLЩiÆj~e(ZÈ$#(ZìÂÄ&Bé*ì]mò¬ÞéF%À›E‚v¡© /;Ç;[GÌcDWŠÇ•ö0 zbYž–XoNlÅ?N3¬eÅ_[üÓWNDÚvöTBjÌkwÒÚ‚€¤Ã°…ílŸ˜TÙÒ– ¯h4}PâoÖÆR,á ÿN:µ*Ìhõì{ÌáÙ™àŠ‚ø…ôyÒ.­µ»¥%EˆHä8<|H]?‰kÚ5°Aå%9r¼Ä’]ÍöèpÆ“<2ã$ygIÜÄVdm)à S4ë•Ø +²)]vj—A!ØP Ñ:"Ĵ-qÖéÙú b÷B$ýD­SÚ”jUÜNÇȇÆLÙ*f Ïœš‚µ@Æ5€H"B»*ô–@³&׸Ұ¼Oºò”vå`/˽ÅÉäå{DhaT‰-!NÆ¥DèaÒ–)·nð 8ÑÃQüÀ p£¢Ï%é'òbÃÐ÷¨Ñ ¸„þK¸äÿKÝ:Äq1ê?¾nï}ïÛÑÙÀC$í8ŒÑ†Sy.Ü;ýÄ$ÇŒ€xJu53dk±Š$MÂñ+¥?8019m:ÙøªPLq¼r\P6øêx;\y`]B® s¥æù¿XÚ¹äi-”à  „3«]R©ÖÓ—â—†¿9q¢Z"ˆ ™¸Žåx-¬ËºáÓº£:©}ûº8ª¤±3»“2±²ÓLÉ™F®vB‘QcíÃŒ®ˆD :ÓA†F… û‡<H)±% Ž$ÉŽÜ9+¼+( ¨¥Y(h±²HΣ( ¯ˆ€±1ôh‰ t%°y¥ÿž ½ÖB„|¢’"°y•<ñ¹˜›™‚ È(Œ ’é‹/ Az[|SDôÚr­3>~+;‡¸­“4ܺ˜9ê=ÁA©r©«ZŒ=b™Ø˜Y°¢ ÕЧÓ[Bó;²•+ˆªµçØRûk Ã{¼ÁJ TÚ?Kz‰ 1"/K%éùñ=ñXžV"ŠX€h¢ÇÑû¤;a‹Û+A qˆ¼ €ˆ ± ¸„PÄ7Ú:Hã7Eô¯sDxüJ¬DÛZUpÇÜš#}0´¼à-ÌxQ¹3Qü[чVˆ,]#\\˜§’@GŠ µ’;"·ªÿí(š-D9M¢‘ƒ€¢2.+6696®ñ6yC²~è¨ï`¬¯)"Œ$³iÛ 9l³3°R|ŠP³ >ѳ„ñ³rZ7 Q#Ѐ·ây-ì@DzCü:ÜrGIü7ª´­²³Ä¤šÁ¢ø…9œÈAÃÀ¬¤ˆ˜’™œyØ‘Óû‡™†¾{Øè'~†°)œ¡T’!(‘![TŽŒøZ,“Ûm‰æØçP‰ðø¿Î[“ˆ"3kI±!›ôÉ$ZZÆê‘Ã!°€О`² ™’»‘9‘ˆ‘ŒBû‹Å:ʇ¸‚¸ˆˆDu|UXÚÔ:U€ÊÛJÙ2»{¼­£2¾ÿKy# ÙêÛ ˆ)¬ò6[‘€Óà €.`À `p2à+kÉ$­Y[´ ’«„º«R"(ܨ'¯Š"Iúò?8ái¡âX˜(€ÇŒš ¡Ì4)°‡žàˆkDà튃™½1 ‘* £%œ¨Ÿá€/ü>tä&~ó&¬ÍܬMà&zœÄF+±ÞtA¨ÍÜ:ÚÈ…¼°‡Þ‚ÌоËðÄ‘€'Z$!†êÌ V0í¥í¡ºœ¹r%ô¼«ÆCšÄÓ¬¡5Ý0ÀJ°qžÃŽïh°¥ÑK.-3,E“ŒŒÂÏñ¨6” ˜ ÿ0·ñ1‹‡‰ œº¢,“qDˆq¼M”H¦DˆH$…´¯Û:´CA‰­7RÔ7 Ñ7‚JÇQ…±SG3Ñ«­ÇJœ-|Ý kº‹ÿ‡`)Ð% (ZV(1!€h¸†FŠ€ê€ßc/(|¹»Å‰õˆë}«·jVïýŽÂUˆh,Çå^9ZÉ%ˆ™µÌµ‡Öê øÌûð ù¨ŠÎõ¯½´í1¸2¡pÅš é°à£€_èSØÒ:­+;­Ô[GÄJ‚Ðݬ¸­ GäİáŒ!„#H¼aèThøDP¢ÝÑ^½¥Û© žîRóµÌïý^š$½£ÝÀòå^'ø‡õµàagõˆÖaȵ‡™Ýa š|Ù`):yxè C[±…'¼è”l’¤Å‰Jq¹CDÇyûˆhÝ&qœxt` ‘`ÿ³8Œ1ÊqªËp½Í¸Ék{}pø…KX^hXza@dA>_™õáN_È}YóuÖCvˆn\  ÐzâÃiª ‰VC‘׋â°çÇ À4T­ c*<`yC+Ú(©Q¬“Êt”¤W†-|¼-}{á“Æà›:Ý› OÙžÒ¨'!1Úp'Ðc倊dg~æÆeV 1äòEd‚°fKŠdjNäH_ЀH¾fIîæ6ø‡*î0^°ú‡„‚è†V00Ð(EnÝb¦âbÅiM¬YÚ¦ý1&Ý*¿ë·Z¶Mnú7K’´8Ò­,´p[ø½­b¦ÿUÀc'È…^PÞK(õ…f~áCÞækæá‡Ü£­dçpn’J~ÙJ~iJ¦d‚Ѐ˜äÂøfšŽdÉä\ê¥ÎÔÔèja°€x‚ÖǽØÚ º C `÷r£¦Å:ì8´ûÖ§ö¦áãÞçkÔæ;«“šèK¸UøÈ…_Èh!(‚ Äæžëó5i¹FDæ×p~éÃÑén¦iKçq&p¦dÉ燘dÄVɇLvn…Z€ìF"êøy>Ê<ÕãLe/A+-“È×Ô-ÚØ‚<®È&Û¦®.ÑK°ç3±­õe‚à °"ˆ³­ã8ëÿ^ø…\p‚^Øc8âõ¥käæ^À>œåF왆ˆå–从åfnl6lèÖ@$¦ ê° a¡N° º [S¤ÛÈ¡˜1 Æ™·«#ˆ9:8IŒ C·Õ®Pmjo3.QÝŽíØF=6Ö£|™˜¡8œ<ªWx…³VÔdVf[èa( b8îä¾ðž‚ˆ¨é ä7_ŸÂk@žäH–D­K…èaH…H€^"jnËgLbjÍn’ í‚Ø Na)öiŸmc-üvø…ÜzeÇ‘4JÿFˆK°-­ëeÐ ÛÒù\êkKW¿„^è…hƒ/‡!ŽÔÿÆp5¯iè6_ øp7wf›¦äADÈȲ€Zø‡ð~…Tx…în…Ò6Î;¥‘BT‚MþA-?*£ rÐÈ&/@Ä‹qœ«¼­KX>!èm Èô¢@¥—B À2çí|ìòßn1‡†Kà…Cöf"^sY×ðY¿p °‡GJW€la†ZØÐZñqœÐÜq’ó’ŠÙÄ'.sê»P­vCÊp1î01†Ä{kòksòå»6Ú¾DJ$™uaèÌ«Gÿí_hƒ_ sÚ˜• oóZ—up†sšŽ|Ï÷z§îyÐæÍ0^?Ïó_ÿ‡Évl#Þ¯qTê|n!àë’ÿŒÉ…J³0„"Ÿ? 1r³ö¨|¢K|ˆNwò³8‰‡™°èêÌ6‹òKà·.ÿdVf^'Hßrþf(hÉåù~GîéþùlFšžäL°b@GUø ­¨Öâ‹_«Õ Ax‹‚JÛ {ˆœØ‹šÌD³‰„Ä´é·6CˆMorÛ1T‚_Ôøué„íè….÷ràî…äU\'ˆ&盇ˆrú÷è7'ú ¯n[ïæÃ‘ ÇF„!ðóMì´öxîGA¤4Û”;¥DÊ×yŽ(DéË⦪ C­ÿ@²Úmïm'—mÙîí]ÞZDJHšÑòÙ‚ùÿ¬óu÷g1fu”e|DæyÈyp.þ›çùœnþoî÷ç_éçdDnîlnþk~nÆgóìlÅæéöæõî_H[Ëž—y.Z->ï_ A‡p£K‘·xËWnå×ÔúV ©´È…ûÿþ­X¡êÕ@J”^òÏÂ% ”|¬ˆQ«£€³a…¿Š ,y©W¯\½.A¢Ïž=(ÿd–T!Ó¦mT Ü©B…† äú阮6%—2mêôiÉ <æ„ú4FÐS­6•´¦Ð<«z”žŠúDPÑ „aÿžù²Ðª•> J†€ù¯ï_{!þåû°w`¾|ÿôÿýCTRà D!ë+"=zé]Îe >Æ!C ¡v-dŠÿZè¡ÂˆVP¸á0aB,¬¨ìÄ…‹_¿zý{…2ׯÐ.!Êgï¨Ø¨BBAJ”èQ Œ•:õ«Î’DÍrý‡VZª?7—êu ÖœñÉ7»Õ)ÐüUÿ)­™9ßZC´òJ\Í4#L*­ "Á`óÌóƒB¨™yƒõõAb†QöXHI¶b˜ÑÓ„=h—1†HhŠ™FY‡+¼²%ýÑ%L´A+D`¸ä† 0æÄ?À 7JÃ)'„<7v3‰·ÝuCq'UwÔq¹O:%%ÿ^y9ÙwÔ¬v#D)DÉ+,ð£øà¦[¯ÔS’KžÔË/B\MRNÙÔXKi)SUä1e_U;Ý™eXÝQk^I–ËfPçqû&U_E5V~yâIgXýu9é?"¬0¯c ¡†’zê@÷ܳ”<-œ`bfÿF؆ùÊ)H-^F¡¨©ÊóÂ=ÜóÂ`¥¶ð`ŠÁØá+>(dD«ñZÿ°Âƒ ‘ÁK’½´Ñr%¡ä,4HËf›P©©ítBU¹ÒOQ¸&ÑÒ=¥BœÿÌ·Y¼*¨+/OöºÔ~Bуž=бHÿ #L+†²pð@Lp'Øèƒ™Á”˜>.@¦J­=z *f®ê!‹vl³vkI}ô«Bà# G„F8/½ÇŸ²Ì sÍ5”èeå´ÑAa SÚôO³Ïd“MV…IeX½OM»Ãµ;µï^mW_Qì!k.ù…7½½m”vÙ‰0BÚõ ò`ð3uBÂ%Ašî¤˜†TÄ ¶.ÔihQ\Œè<šÖÿ‚â/¤åR‘‚Tä>8à®.‘¹ì¿úÑ(F1¬ÝPBÄÑÙ/rá„äüƒYÐ` ñ~ü£À+ÉsfG‡ÉD&Ä#•b”6@Á…ýÑ Ô˜B»:í^Wà5µœ E)Z;Šït'qÙ'Oî2OíVT›aEÀP‹’‡ú6²‘a1Q‰‚Ô¤¢P€|øM_¶R™àBs±Fq¦d•!•ƒ.#ÆÄ<ª\EhÀ[QBW-ËQl(,!ŒtÀ  Bš„:áô⯸)P“•ð9ö(@.»JD†ž,€îJ8'{8!&2tÂìx÷”ØMe“ó*OÓ £™&žÅÿ‡ažŽ8Ãéh­lùˆ„QÅC•„D'Õ?Ži·,áKHØ 2S2é‹ ñÁ+:µÂ¥Jš*MæÀ¡šY€üX£\-厂>F!$BYÀª`Rrœ ’âôbuÐÆ *0~ìeŒK‰Ý%ó1F:§$™Th&#úœˆ4“šìá¸:‰¼öeNÔBKµVyõ$k¹ÏØöV}´b7+ÁÝ¢iµ OAU4÷æ7øPe€ëQh"72i:l0 Íd XÀ|­~L§’«¨®†GøQ< ¹›K,%møÅ‡ãHa@øˆ"Ê…Ž0vÿe %cз:åR(T &M¸ÊÚyt£ïú«tžH.$–”)îRŠ»pX^¢‡§i©†˜>HóˆfŽ™±`±`ŠŠ&=´ƒ,!«ÁfAµÍ\&Vg¾ô5+î*!7bÈm'ò½3XòÌ .±¬ä,©ƒ½&!-pCüƒ ü a> +PÄ@w­~uè^âz<½B…xé¹®œ’†ôü¤úQìyÈ-­±woˆø% %ªcĘšGåa0óªn¡EMU6„d$žúLÈþb“‰†1¢‰­A®©24.%WBxMU_ÞâCf[}Å=Qâ³â¼ÿ¸0ÿ‘þÁ\~è£$äÇJWÚ\}°¸Æ4Ö‡cþ±Òç–„’u±ŽIøã|¨•0 uwÅ‚;W–‡Bö:oÒÂv.öªw¤ç½ž~º´I©¥ÈÃJµ°Î–D¿#Àø öYz©³’ŸÊЙÚ| )ŸùKaž‚TZ[vbb˜Èmà9,‰¤)¯øÅ#MŒÕ ,€¹ie"X š‹”$Çüp c>ýiã˜Å9fÌt3]ÇÈÈ\Ùa_‘DñZ…BN¶‡½4{=^fŠH©HDp ÊЇ0òuì` @ùîÍi–±€hD-­è—˜Öâ9 °ZJ¦DÿÀÓžºŒ5æêTm[œ)‚À¥„Aˆ£@á>!¸‚ÕŠ8Å1ÌmL§B#‚È3„caiQ9ÆÔâa{˜Ìëz«“Wf¯ºÌ[–YQle[ÁnôAEª$pS”ÇF€ p å kßžI‹3ª"¶2ð†sç|€Ü}{ßu벆<ÄF ¡êBz•‘‡Ä…#vù… L+ÜŒU.ˆ@‡#pƒÿƒßKÉñÀþu®7%ÇMù·ŠK‚ö¯“P‡|eÓO @l…iâßõݬӓžŽF™'wo^í>$LQ*Xù^à ,vŒ|ÿ8¹ÂþCÍjÚS!)« )ÿO1†2q Mr:tÏÓN¤F q  !²U—]•WÇ*èš!„Þ@Ú$ôÂrhs"ý`ë¿AÁÅ^’°<ø8Ùÿað°‡=à·ŠÙ¡C¼vøÂõsž6e°`¼P4/¾bM®ªpãì%¢vèÑJ‰`7ˆ8úЇEüÀmðŸ×5ÅÖ9…ïA0_ðñÛ l žà vðí•dŸõOõÍ’­9O¹€M~dœ.éZßýú™‡TpÿÜyH“>P”@É=ÓãÉ ”M¥‘™Ýp†güœA`6-ÀB¤Ìè,€æQŽ €ˆ0•AÔŠn•žSpêaHUÌÃe gÉà Ìj©ÂäTbäƒèÍ\­L˜ ­N§„DzŠ 0Æ/$UŸ5 W1Ðj´†p9„\ „nÔ‚ÔÂÚ€6ƒD¨Û°D3@âFàÂþÀˆ'B¢ò­à%*ÿŸc˜`&º^ñ…]'öc×e">úž ‚—-]ßžÀÇ’Ù’Ãh…¹€Ô¶´¢DžØD¤¤äÃ̤ȡàW2EÈ.ÎT}Ù qa¸Y1‡1ž^Êì§,…@´aüXŽ:=EY5nCI¬ Ã2<Ã2ÉD(T)Ð5þ`Ä?àÂ(´Æ?´ÂT„!4âRÜà>vòé£òá`òÕã ºSPbôd/ÂÒ)¦¢XL¤[ÑT<ÍÝÁ%Ù¬€]Ü"©˜Æ-Já”ÊRØM LŠV„ÖA ØRÄ=Ûch ŸÑÊOý™žžTÙDUIˆOâÆ?2ðä3ÿ£BØÊ#UcYñÆ?ðK‡ üä<.ß Ü >ßð•D Žåñ _> ÜlÖ&Z6Ås0{`ÕLÊ)'D®ÆÙä ÅZ†WšÔDšðf}"‰>lä_ Ä0B_IÖWþ´ÑäÅ¡9…ÑÅÏl5E‡ðT1Îám#DD„BDîe&Q–GüËP6ÃY àÐáSsm Aü@- 2¤ÂR¬]V&_?j¢mú&$rÁ¥ EÝT@ˆî…@QŠÃì…‰¦(Š~¥<Š.f=G)ž…CjMRˆV8çsä¹äBˆ T=œbÞ EšLŠ>\X+„ÿ€>P€!„؆ÌÈÑT4€ˆ4 ¦Ä¤Œ=Sh¶-SDMÚ“2 ËÜVkÉ6þC3e3 Ã@@ƒ/ %QJ„˜>R0!„^0Â0B  A* ƒ/ C-´¦ò‚“:)>Z…šÝYZD¿$nVê@ˆ¨wnqþÃahTŒ–âŒÚCt©Õ¤G)«Æ@þ¬jPð(f™HªjÀ¬æÏH@gRd-)©Ü„ ÊÈ,ÌÈI žçA J. €!Å„S$dîÑ­ Ž8„^£†f3¨/ü'€†¦QúŸ½]‚>ŒL ° üÃ+€@*ÔÂ?$*,ÿè‚2Ú9*Âék£BêÀYÚWÜ¿¦Ý‡"SpêÁ†¨S„¨‰jT'…êA1«2BœØ(\Z͹ „ÄBȬçÈaÖƒ¸jVH4ÍÃÂ@ÈW4Lg AÜÓŒ`S:‡BÜ“*@ÆSèKDŸ™V~ÎÛTéÊ®ì$OÎ… „/È8BàQ–æ%¬~…ÏtÌÁ$@ ›™<¸ÂD¯ôú°/ü@§`ŒÿÜ ´„`Ь”V˜æ,­ì‘ë:f‚HhôûÄ!Bà[µ.WmrN'Ãi3læÚìZ‘Æh$F ßp·J+G/¼Âr* Á Á83EIGîIûr0ç²0³0OÀë¬/s-3?P(÷¾í27ñÂøBñ[sˆæ²6nÆv³ÿ†³87®RÓ/RGnSû/qj¡´ÆŒ>hÈ›‡sF<ûÀ5@‰hUVëéZz*ãdl“>䂃`ZaY?RB°ÆÊ4ô›jfgÊkIsPÓ3®#ŒÙ @°r=´rð0,׸Â?ÜÂ- ñRL Ð/Tà/qf6#¨ñúÿó@4ñ2«˜@¥UÚMWpo‹Âiƒ¯#ñöö2Ú‚ªgG 9ŽSÛ6à6õ9›´‚‰W^(†ô…fR‚q$]†,ê^0æ e}§Dc:X.ÀÊ@4zô¥ïz`DwæÚHUkH`s˜‹UÆ„€¢°ÀóGÿƒ+4½:vßÞÜ#ÜÂðwç÷8ÿ„GP@.˜†ÐYÈ„¥Çs ´Ÿ¹^†·eЧ¯@4>f#sPEü,çFÈx[“Æ/€DÛJ5ž£’S¦Q"ĆiEÀpS±Hhàíz?Î?v—/Å|ׂ¼~뢒À D™C;Sð"µ·+SÁR èÐ[ª2Ÿ¾Ö2S¼ÎŸÇïÒ;}ã¾î£;ãÞ¹„¤ûï‹sB\X´B½ù` ‰R ÖÜóÅ€áÚF‚¥ ‘/FpðÙ= §üÃuÛõÜZÄVŸýÙSÜF–Ä­Ûœ¯ø DFt ÷üzÉoy—×Cjâ?±Ãk¼Ä?_¾j%põÄ¿ ·&¼µÑ-‰ÿJü³øÅ?yïùçñžEGX”˜ÇèâEC)SVø·Ò¢!—/]"ùwA&’ *T¸à³Â„fZüpñ£ (S2ýÇ¥S–SŸZ”:‚„V„´B”ïÿC{öþ‘ýGï¢zôœ„ ×¢ÅÚùôÕ!Bß¿\¹.†Ø«Ï…ˆ+TýSµbÅݺÿòý‹"Ê¿¼ÿD$^±àÕ?,)]ìhÑ0Gؼ`Åà"ˆøåv‚ÐD¡‚ï½ †°@}Â"K¬Ú8° ´Ð:¡Á{6‚K®ôáÐ  l°Ô #Œ°T)ÃK²¡¢ˆ‚.YTerìì³Ð|-ÍF‹H{ŇR2¯&Á"jãaˆÚ.R·ÜþÁ·Tš²ÊäÒŽ„„& %‰J¨ˆ2ɉ#X€ Íð,róÍ7mº _ ò-/Ъuï8ýษfeÉÿ©¨²ƒDf¤à(‹˜½ô¬Kl!Áš°¨ y6ú§…yèIQ¯ºãp…_V-̰U-LC£ø 2-JMJ0»è•Ð2“±³2ÛõŸÎŒ]Xûà(ùh3îÍݰ(•ßRh™Tlz(%¡.¸àŸ‡ J¨"‹ž{Ž:‘Ü=i‚£Ú¬wN9sª`%º}2„¨Ÿx;(}Ó³j©¥R"4P‚áÆîïüþ™G‚"A{˜u‚,´Lð,¸6¢nãOãú'„¹r,ÃÄì°›U½KC×K‘õÔPŒ¢W ÍFÐçYhcQCx¦™uöWx¨çxÛþ¹ ÉÜ@Hz"hÿj„.¸å²l.šÈ¹‹Ö éˆKB<Ð5ßN¦ŸtÒ“' $8ê°ûíÓ"ÙÜ+²)¡œb/>U {¦”y\Àq EÈ’©1è- :È6¦‘,¡A"³­Sª!Fe- Ñ`Xw‘º4&tt)a‹lD‰ŸõnF»2h^!;įÊŠ‘¤eÞ°äxΣÚÕ²†„ÜâJZš€•,b?-•`K9I>²4Í#6ëƒL€Ò>»ñíwYçZÜÎLfÂ&°ùM&ÐÉ?|"<¥ŒhK Ç¿8æÏ*ÍBâØ¸ø,å(^ -¢ÌññbôàÔ?&ÈεX¤1mqL>F·Õ¨ŒUÄZUb`&™e.¨JÍiVðÂÞéÌgÆêd2ƒ b~yZ*©B-VºÒ7µ’/~`èÒ"Þ ÛÖj™K–ðòlÁâü&Ìzñ¤:ÙÛEäW”ú…Q6~»Ÿããøì0*kºµHΞü¦ïþÑ ‡–²®FF¥^«uGjS#5ôj1hôZÀ©E•¤œ¿(~TÖïyÊ–¢ˆë˜‘×p¢Iüð%fªtÖÌedfÁÒÃlo0PÈ ƒõמÕ"âw^œZ¸  an€ 4¸Å͘YY„/, º^B—‹<è÷Àð×I˜)7Ç·;]°TG}A ʳù7^½»]P½• >Ȥf‘ßü#z¤ïoj d$à£ëÕ^Ãâ¿„8ÿåçTÆYâ—H }r¢‰žÎã÷< ØÀl®—ÿÝè¤äÁŸ',2 Û#¶p£ïÈ–GþÃ@Š ³˜5ô”„îè÷È€Ò!c\ä6Fi/;ŽeWïP Ñÿˆ²+ˆ jUºÒ•Ò2@¨WYvli7Pú2¦÷ƒ„kÖ³¦u¸2.ÅÍãóH“®ùn™2“<ÇÄîÔÄîAsÀ’=öv" 8å8;ò@ý‡(±} ‹Ì£×™ äÌòÿcø©@fŽ‹YòBTô!èŽNXÏ/Ž"2Fæ¶2ä„IUnOjƒ>„ïÉ.»º®ë<-Ô(ªzD J4Ê€ÁZ¡°Ö¥ÿž÷5M\Æn>Ä¯ËØd'¼ho¾_Œ_|"ýì'(x =TNòŽ”âê´ï:bÀÏô%6åRâc´ÉrŒëvD á&ƒY^À/ )/h ŽBƒHd;f§Ò,ÂÞ’*èºB­•xøŽ'øViø~ˆÈpC[ÉÓª%[ÜμnáŽàˆ,b`@€¦f¾fgP”%Œvm²Ànº§ǚ̾Æ'F®³\‚O”£* l ©IþÎÚ¦m€'´ï,îC&dB ÿ$Ä"äáA8æ_ dh0Öð2rrZ€‹n0á„P¯ªÌ êÿ´Hv¬Î"‚€¸‘5 HÃC-Ô^`øR£¬æì®….b¼4ª ç@`†ÀÉ\ÁÊ"b8q²èÆx"™.ËãþËNÀÏÌ<ºF´XQb1qDëýôáø¡Ždk$cÈɱfóDå[röÂ%á‚èFÇ"J1ΞThu ê& fRb¨•†ò3 Ðk?°Œã ’òœ’)à€¢T)ùn;B[Ì7ZÁ/à H1Œ¿Øä²ˆÍãpÐ;l¢K1=|×BË¥”*’Y,ïÎÖ©cRâ8à8 mžŠ&C_" ‚Ž=à¢ôF§·¦N1à‰Vìâe4ÓtL”ºƒEvò²nýíBm4•òß,âɆïþÁ5ÿa5 ÒjxC7t£7¬æà‚£à¤dGPj@ +»ðÆ28é$ ÃÌÌ Ò6b îþAp”;5¢ €$S$,˜…˜Å1mTR¦j¨¡RCMdž$ã¬R¥Ð¢Ñ2ºC%ÛP²Ž=DS( k4Gs@_ )ÿÍ»xo4/Â\S)UIIVÉì|ïÈkBÏnIMáêq_ø®%`%ÞÇÓ2³ÀoäˆIšÊ’EÌ×aŽÍä@'6$€:sYîÿ&é²ó"8`õ”®0Ís*Ì3÷~!èžëg*p2?Ì=©BÞè…u”F àºñ3 Q÷jÕ"Ћ)_@E³°R"M´L©‚7¬å"žç6'” æQ[´EÉ‹zî…9ùŽãzPÿû‹Ì.BšÈè8Dñ8<Ë!³‰*Š„Žbð¦”4e/Ù©/?òF-‚;CvÔ"ˆ1$”$õ2SCIá…,c%p s¬2öÁt”Fivqx`@mA q@ aÓt?yM-"M½ IðÅM׎j>Ö á‘ °2°~{BOiêïbŠüˆ³ï2+O:γhä°iïÎHdC;ÕOxVŠ”è>*ç@,.¤Aš*¤ÑøbHLeT¦Tÿ!„º*%Ü“ŸLU%o2aŽ=‚à>…Ñ+Ê´W «)M]ó0 bµëSbj´eàn+£dYõíÿnÓ"°N­ˆn#Zy -é„ZÕRfoÖNžÉ–šˆfá\áL.yÖ)vè(àæÚºmHjŽÛ¶ðÂ0ÌèL_Ó-e2#y 3# &ý‘R’D¢ô¬Ža¢¬4Ô ëaùóaÛ–)1À0cÀ o×"Þ1%Úqàì”%Žo÷áÂ"–¡ðñfWÖnþá¿8ôPË’|Áƒ[Yt*àïrÿEòŠíva.Æ•~$-,ŒhSj«ôŒëçôÂR¦ H¬0úµ2Rfb×tÞñ$+C< V% ¡”."Üöa´)W4_3m]“x_£€Ž[ZAà@¸„ߤÿ‡Èo¡GoOp 9W¶×ôæe«5—™¼¦ã@gÙ ÁTQ}}ÖÑ–eš(@&Ï-†Dr¨b-|ÔGAæèγVhøõeTÁŠeO2T$& 61ÚðfÄSªk=¾¤V³îbÖßÒöL‘—ø’¤zñ6xƒŽíÍíRxzÑNp"°–ç%œW†_|cÖeË/ýün* U!Ï7.Ó·Ù‚)˜X¢›æ¬ò$G‰e.%I.F¦ dd@§-fëbT°¶¹Zæf Žuv’nw`i·Œk¢à¥a%˜@™’m_³Wýí?}ÏŽáfjŠ%FPŸ'N¯…™™UJ²÷íÀ÷pÿ;1&Œ³‘±uüd!Œ„ %¹}UQPÒƒ~bã(¬nœ¶~ï,Ï@FÞâè.¢”g…ž$#„Xh X>¿‘&Ð`K(v`FI V·‘luOby9M·ÑÓ° j´kI„Õ¢ô˜{#%ú6oÍÎX—p}À&€3ãbê²Bô©ÉZý®P퇥'—*&9}×GsÛ¦M`nq Î‚¶¶£-HÃäÉ1€Î”„_U†e&̀饕cOÒ V0¤oJ J bïÓ@{y51–4‰òë(*•’d*:vX§¢NUíH NÿVdQÍ£!9ã€0qm8¥sØ–ÂÏPgÖP y*”å(ÿÚð¤1bìA¸Œ‰Ú1fE·°VH kO’2b’„”†IA‰2¤±`%à ¡ôŒ Ôª6W}µm»Nóë\)㪧A©"ù¶ãø²ÅÔ÷–G8»o%æ†o7ت5=²Ÿil Á&Üšý´Hý:xŽËòG‹é""Ä‚n CŸºjuªfT¥çe^ô!x؃—V3—§âWŸÒ÷6£FI,ù:ÖcY›™­ÆÔ+Ù{÷åZ·í:¿Â®yÖ¸Y¢¯ L;”l˜F¡rœÚ¹E7·­1 sTL’Ä”‹ŸÚP²™4™:Cš¢B lv¼ ô"ÿxy?5í47-½•‡n¿kIÔM‘Ù7X­Á+ábi²æ yeû´¿ õ¿€°{½ •¤Ù,…išø$g6Xª$E¹ïo渰·p˜…@r//V@û%OŒW¹Ü¤.ú ÑøJœ@]SMA³c[\߾ˢ."µ×­CXí¬X™N£dpaX¯-âû^ðWÑË™þÔN¤i™Z¿¤I_òä¦&@_4ÓÛæ ARpZdvzTÀϨêuä)·h’/‚®Ü.ä=u,UÜ»Ñ\@jÝÓ%`@3ÂÍÑtm@¡†Î+ÚŽ‰¬õJŽ(tSà˜y} tp[ ÿ|\OgÛÐ3'‘@™p-WB.Ào|ÜQÔ¿ôT×r [oÊ(>@ðæ(:™»¶øOrZE$Üô¾ü²[yߣ V<º;LDd=X Í¡ƒ*(ÖKÔÈŒ2j9Ô‡õŽMø6Z»n—÷"÷y îd Ú ýMpbCã-O¾Û»|åg8¼Ìf¢ÒOTš0[eÑ™Èý(¢IY\ÞàŸ°~9Ùψ-æt^Ìç8¨dLRÝIŒ¹[J#)ö&Ã5†‚¥^U|Æ»@ÑTÿÍ(c“רe•ô6PûAûÏus+5Zɲ&DšäUBã`¢ÛÁ†Ûq¢å»Ç˜ÿE‹°~¼æ¦fâðœ‰ð÷ºŒ,ýk4ñ¾º#,PBæ°m-ºÍ-4 i…êÙ„&²Ih’n©^R> )JIË0Ö"Œ÷Í›Rƒ{ïÜ›×Äq½+¼"±Æÿüøz#Ù§‚톥=îy*´]Û ïkûî½/ï¿]Ü"[‡pGΙ_ œg+ýÛçÓ§< ‚)¸l,äóDž0Ä4ää 1²{u€'V$Åæ…‡=äÁxÅ”LPÿxW¿•úpˆõM"Á¿ë üWaÂAÂá@‚ &Vü1U-_£@ 21¤È‘$K4É? !/ d‰ Ê•+ÿUºP Ë 8/ ¬0ñÿ >údùïš?\°T©Ï¨$Te‰ÈЇBÌ AÒ^{bÿ}Èõ/Ê¿|ú&¶mûOÄŠ"þ­˜K¡®> ú†èûköØö¶B€pâ†G`pì@ñ?^2ÐÀ?W®êuÞü‡É >L´ÉÔfLuq`‚V b‘ʲTÿ@Žþ ¼÷¿™3êò¸! Äê\~ÓèÒ¦ÿ€N*”§Ó¡H“*…zá(N¢<‡ •€uù‡õ‚ÅÒ³Gx,½ùH¶E«ï¢_ëÚý——ˆ 2±D_[‰Å#ó¼ G`pÄÿdŠ96™—a6‘¹‚\j¬™f›lýVH!ä[¹8Q*°ETbmiäK-?Ä\"â[o@)äD†È4“2¹¤¤’7¡O@ UTÕ)•Ôuá¨%uVÒÔR 1 "oiEXð)X}öý¥—Š ‚>†¤ôµ#\ð‚bF¶ØbÁ¡‡Š‚HR=-ŠdЈ$dP£ŽööF1òö"D®Éøn¼ùHêDA'HGŽIÜ‘`>ç’K¨ò4l·TK åÝ­C%Õ”O8]™O¶&u•!P€Ò€úð:Xd äæZÖþX\rýµÂ€½µåWÿ`M)ÖVó8X‚<$êfš šfÿxš+Cx&܉ U*¿&&$bo•„Ú‰ ñ8o£ZéV*©C ¤“CȤÒpèULJÒ$«“#µÓS=MÔ°@•W°>M‰²‘†¸," Âë‚…À¦PÕŠÔÖ\üýÏUÅf`!L0Ï@ÌÃÂ?êª;½¯+<ð 5¼òrv¢jaƒpÁ™Ò©‘©lÑh’Œ5ô޾D\ªo/ §êQ«BÙñs…jwGe«±-¥ ¬”/Û°Î  Í"„»ëDc V[×¾E§~ØÆEà[ñªçƒÑ3Ðÿ<%° O…U+öX$Ô ¢×›ÚgÂù–ÚA+fjjA Ô"¿oW´ðÂÿÔÛÛuãVËFx#7äĪž4qÚN~Dx¶>¬­OÆÝÇ,“|ò±-ƒ<‘û-Ùšx±ò£w'€"X¥ùõ¥ \èãgn ž@b ¤­®+M{Ú<äñ Ücv¨f@"ÑL$^¢aðB‚¶™h4 ¹AÚÂÛ”„7Ð ó4R‹ë•HØ3ÙHÈ'Éai:)‹ŽKtR–áP$6,PR"·“ÑïˆñCH(°‚›!h)c‹ÿ2@¶ä‚€x* ž¶BÅôn 'HW… ™Tp"$BÿÖ\¡ш¦ò‚ÔïXC)ÏŽ!Úc4UÜ<Táõð†>’¥;0+‰TB§e)¹Öl2DÄ‘|6\b&Ë¿Œ!n‘,©ÿ¼2±l€ú@KZù´`ñ>B{¸ÂÁ4Íu‰Ð € `€¸P þ„`k¡™—3½ö™zhp"’ú—Ùü¨š‚ „ à¦@>uŠdT +d!‡È$Âdpô¯HEÉ_M’cåY¢&ã÷É{þ¢(ÃR 1ˆÁ$Ì)zrÙ´”+ ŠB>0ÀVH¢;‹åκòÎ#1‰‰]0ù TÇ|A ,ÿ¸‘Có2ï"/ifS`gó×€#)†tJ…°‰ÑóÆùSŸš3b ßL7%¢g:¿RŠ®v(ðŒïXòûx&K\=7Ûʺ3ú¬)–«<‹ráÕ\|Q0 „@F]7yÈÃjh|@1ÿI¡ jPí"ˆÜ8Ìð Ž0-ɾj±!ÇEtɨZHN  2bHIË8¦T,'*ó„d<ÉÎÃù(Ÿx+("ø7z0‚u›Kå`v&”×¢u0ªƒëZ×4uÁn˜j$ÀðZ™ ³v»s¢™™i"d°2 IBT”O\¯`¥‘žcƒTt¶a=:Ù”¤ÄÔÿ‰(•TS!œx¿T«é´“%œdïýþaŠ$̱Š[ç1zÄ`ö¸m*aKq)tŸ®ƒ %;«‰¤ÀýÇIs(®©tÂÈ<À3G°:"g¦ò [‰.‚0BÖ-†uñOÑYªc•GXM”œ )II©L‡(ÇêäU©jÞ‡„¶ ï.S dÍ f"óèŠmß:‘À.vŠ!ÑxWÉ jB”Ñkåu•Z83tô3á(S >WÇmcˆ6N’4¯z[}ܰ«ã–LrñJyKÒΑ6Î+±R þ‘Ü&4¿„¦Ç‘EÂËc:‚G¸G¡$cW»R(2ƒ2&¢%/w]ÿ¦C˦3?]Í8¯6p›QÂJíÊwXLä³Hf<9÷ˆ½釫ER•@€%hA NÀÑÐ#1&r ðë`%«+PS‹£y 冴‚&Ì„&£W7r͘¹Œ…·üLÑQ$p 5ÉLš…˜ù6ä„›‰!*“xÖ6>"œ]c«šï):‰•oM’ èÚ­bAÔ¢64-T äQ‚S®Ræbž,‘J¦B̃‘»»ÉXX3Édé@5/åüÜ ‘M§pcÈÑ4¼ITgK¨ÔYOòÎã%âMÚùó‰Äwå¯VÔ$>y,ù°ûxHÔåh¨ Êÿ9(æDîšW =¦2ºÌëÈ!p»”3šI˜y§á _!Ψ ŒÖÍ05R#£ù9‡hO¢¥ç«¶³RÓk^a­·ß5&úHCç @ /‰#žàd J^1÷pô“‰)«çàêbÂ?,‘ÍÏÀjƒÊv–áödàhX;‚ E\ö(¿Þ©FrÓ\á h@º0îžsÞ£Id{¯Ïbý]Æ{Ï÷Hv^,A…%î%¼¿ OéBòˆø?èÀ…ßxA ˜à?ýfÀ·V·ú>FÓ‰ ÁÁFéêéo€ÜËØ ˆ¹)A|FÂ$þ¶H>"J!±ÿ|9gU È|;Ç1M”€Aý'ne+\ÚG*æÄ”~90P¥2%…L˜RÈ‚¤Æ#"FÌ‘c/¡Æ8.fU£}ÄYš¥€Ã+HÔ‚v&<FÐa‹‘~Å”R2t”ám/à0„$q{q†“…j$!JÅÑ1Fq>7!+ÆÑw%ÁwŽ”g¿‚7Ý1A@8¶&CÌ „Abð~òu(ÂnWhx¯G<î†b"ñ hM¢ý„5HƒðOEÔ$FD2Ç@^EèjÃô¾E r(_Ÿàm~Ø‚LÐX 3ˆ!‘$+QˆÈŠá3>ÿ1Ç1ZÒáƒ&ÿg=A–è#là4)ÀtÀ‹À¢‘…I¨Fy¨c[€(k'Š,w‚3K2†±"Jüf+Ö‡²òIµ'^xóóP‡¤b ¢A·öÿp3pOØŒÎõç™ânÀ†Ý³Ô˜ˆç‰ÅwƒŠto$áVYâ|>Ò óp;×ó°rŽP +WŽñˆ} 0³a<Ò=F26*ÉÁŠ?w²˜ÿ¸Y=2×ãyT Cbà “1)¨P#.r„È‘‰(†L’ˆˆè|†cxgt “Ei”ò…i‘&`˜DÈDë¥D{6„$ |F”G©•[é#÷r)yÿAô2ˆ†8¢X q$·À•o —Yn78O•+ê58ÿ,™•†#ÁKá )y=Þ×:VÉ–n —éj3pXP*¯'“ó0þòóD8Vf¡Y±æ€!ñ—›˜®ÖxQ$P„ —À D··æ¤™Z9—Iǃ¯†’Kñ—n¥xK!”†—Ž\É[—!qÁŒ)“¤à\4wCC^»yoÒ ‰˜òE˜Þç}ZE*eÀ‚duׇ|vœ>›1iˆ³y=Bù™N£xÙ›ÿÀ–À–õ™Qò™–ƒp£‰7ĉ‹ž|VeŽykãYœ$TÀÿ Ê ŒàV¿‰›ñ9ÕYá ŒPŸLu•…9hòù¨Ùa)ð–R€ì(žþy Z úŒŸ¿éV·$à¢2º¢‡Q·P1Zšlt=wûù:Q \ù P‚®f/ÀŒ)J‘tF¡,ê $@g×¢+J£4z£z¥ª¥ Ù4V™Q¦ V®vš,ŒNª¦À¡œ2‰/i· .:nu¡ûä›NÖº¡Cá–rÚ¢ 頷Жò¦på¡!ñ:CjG@5kê¨×Ó¦G Žq;.Š¡U:ê›+ºOÊ¢·C†9ˆ£á ·¦”Z¼Æk!p²ÃŸ —p2ðÿ¨µZ«JŸvº¢K!¨Š¥lä¢}z_Yz.”š–¨š¥%Àié}eJš';!¤¶J* @­Áqž†7©¦ª ÜÚ¢¿r.º¥Ns¨ê¥ B£¥9ªçB£c¢×xQ3­"Ѩ²*Š@«‡¯©¦Ù:nð¤ó)Ÿùž4ªx¾ú½ª¥!q¡ I¨¦©§V©£p…˜`Õx­öÊtE©UðÈg²C`…2©,Xšj¡Ó˜Šw û² ‹¥žJ©rÚ®\Zq£ª¬*¨¯AªtT;K±ª¯¿åj–ð¡h:–Žñ/gþºÿКWØ›¾š«Ncÿ©t–§·ó²·¨áÕ– ±ª¬·`˜ꪈúª;¯«tF«±ØWAC§cAà( Á¯V²Y “i§c%;nIŸ ¨¹ê©Yª /˂갂 I×™Q½zŸ¾ª¬iÙ®ßú³‰ŠšC+;L¦t&Q¯|Fœ‹QA<ð nô$÷·×#µžç¦y©tª¸”ª¸ô§•J¹íê»!á° «§%€¬Èû¡$Ч Ú rªŠÊt»ŸÓ+­Kwº¦Uxõ[°5¤¥òp»&…ÿàzh¸n*/xÀ‚ ±ƒJ¥v ¹nå–ŽÛ¹2¹3›¿M³¬†É¼òé–ùy ´’xq ÿVS3ËŸòÊd™ÈŽªKRÈÔq¥òè0âlà±ÁQ ÖZ²®F ÀœÀ±vt4n-Hg~º cË¿,k¼Y*§\jªWYd–Ú¢ç‚_¼”Qµ2$†°÷¼BWt;½ÙWŒútTÀ« [ tP‡ª‹uA°x‘ÁŽÕpÂ#Ñ ‘‘Á

}xAAîÂ!S¤bv¯†˜TŠ¥ö-Ÿ—ŠÃ4û§>M¹J=ðÈ Ïóìü= ï,ÿXnÚª~à Þå 6Ó¤P,­ HgîÉ€¦ó±O/çÿ¤q%|!ÍýÖx5H¨ç&n!!\(Ìè!Ñu5N–®æ˜ãiYæÂ.Õ!ãYÍXx=øR›Cþ;¶Eí¥¾«¥4̵êP}Ú|3db3+±žåª¾åü`& Îà '­¥ÛÉæhtæŒa~ê’_ù`¿ý[x¥qi$(Ç]‡¢˜F€„Á„ò‚íT(ˆBiÝR‡®Lß&[†èÝ «L 2ÔÝ}8͉ÝÒY6b÷Lóò‚ôŒò.>:§öý»|<‹³4¬¿Tº,?Õ¥ÿÏd‚ê/ëñ °\®à î¿vp»¾ÕkÛ»ŽÛh¤.1@[1!¹\¢Áý[9_;7ÁqLÔÞÌ»L©óRÝ–1ã]÷´4¾èiÒ^*ÌhaëÛî`6nŽè±eFG1u{ÛjéS›5š»½K£–í©øÞ¸-Ú«g€õ0 Yn¿,Q„ð, £ðÔ©ÚR‘Eù Z„9šeîÉ„Ûé7[f}çÏ®÷†2ÁTètÑøKŠ¿\„‚m%{L–?ô›?Ý-èŸè3pEjÒŘäMÒ„ûRãFGšïç.ùŸöáªÞ?‚ÖsEÿÐÀ@ÿýƒðïAFN¸5‰‡· p,Èq#F%&PøaA¥0–µ,DhÕjšˆVX"L +!Ò§¯BP}ùôÙc4ïßLå±·´ #­$ð¯Á/0`x@¬Ø þeë jA^„½zuŸ‘ <´rõâŸÙÆšuÐ÷@_(xÀ⌠öëÃâ‚l`\øß•Æš RNüÏ@Á…V*Dì ð­¶Fl ¡éƒ"´*°ÞÂÑ'€ŒH±aÁŒGœ± E.´²€ÏB-–„¸ŒÙŠÂÏžtîlõ("~A‡êã÷!é‰ÿªLÈ{ïÈ=©q±þ»'ïDòÆÂ5k,‚@K/¶ ð ®‚ŒØç#Ä`ˆV†Ðk2·Àš¬0¶ô 1½þ¡ 4«4ûj²ËØŠÍ1ÑTl,.ÖTD쵫FÃì³Xëm Ødâ„Z‹ë´ëÙí¶ä‚KN#åF’¢‰(ª(Êæi‚ I): XBF•"xE¦íô¡J„xI ‚2¤¨òˆ*J½XhŠ«æ[*«û®" ¿ø;â¸ðªƒ Á­#üÊáA´ªAºxaü2°/ ] ‚0:-¬¯ÎV;à°¸&#ÄY{³{CìFÕ®ºÑ>«z»Õ±ÿÅvŒk´z<ÍGšM Ù^sÅ€ˆ*š`‹þI"<úG$Ž¢]n¶‡ †ÀI% /_â ‘!ôAD„W(‰`}B *£îE/ŸèQŠÎ¥žzo>ªÊa@«²’gžJÀ ¬A1T-,ñ« &hŸG­2Â!(¨Ç«Oy ÌÂ!’%¬Tc¬3S?ëŸT=;l4Æ^|U3ÿÑëFËlµ/¶Ñ [¬´IÃUÆ"K ·Ýž&² g™åhYæ6Âz[FÚzI‡¼¥@%鶬.•—ÂaLvWˆW„¢îµ7Ò7)øþ ¿²ªjo¿/>++ î™gÿ0È*,BÃ2« ¸Hð‹ñÆ4R‚20â&4@².ÝËWNþ¹-˜S+5ÖÇt -σ±5SMU™  nÚ*Ç€16‚p<-GÑZè6…®ÚÍ*g£eVjjÛº¹¶…@©$%€‚ÄNsUÊ ØeW„|Ê'}>x;n£Êûàƒæ¡à»>‚Œ `ª¬":Zd¶Æ-Î,øa„À†5ÊVx„($3Lf8À,5ž­ìe6 ‰™uð2­bMbV£*Åt 1·Ë]¯„¥Âƨˆi¢¡Ñ ’<Þøh4Ä #°…-ûLŽ"¹EE ÿ…=ìIèKÐBu^"Ÿ bMAi™ôe¯äÂ}r+ÊüN€7‚D%UÑŸž20•5®Q)# ·—\ˆ@TràÀþ9è‚< ‰0ô)Maàõ¸f^öA ™h/ ú])£˜Z¹*’©SL[2Y«H’æiÈ;iB£`‰f‡É²lJ##ßôíQ‰áU,‘ˆH† €„ cVl¯{ÒÑNÚ~’+b1(ô A.â÷E£¼M)Oy¥|¶—¬ä üó[x¯8¬‘< ÂX –5úÑq”P"‡ÀpÈDÉ L`b ÉÂXL5ƒÑˇ4Y³Pf2„,Já­€VJÿQ¦(i;lšll,_…’wqÅÞÌ’| îo¶:‰^P‚ð C‚^pKR›âÊPŒ2žöÉ/!°G>Æ¢ÌcŒó©Š4ÑhÍ‚ €§k¬ã4Ú8Pq„Rà Ùºr„.‚z€&ăšÅ-õ¬`^¬¢Oû@¦q€¹Ñ‡<”ºß¡W-b‘fvÅ_õ&G=ìá‹jh³³zRx¡4e¯<ô\X¥¯X9‚h•ŠJàA¸F3€!@ÐG¯q #a죛½à”(ä# 2ýlg;«Y{Ñ£ò}ú$•¬è‰ Ê ð- Eqƒu\`„ÔqÿLfeÑ + Ã8žaõ¨œ'$cI•… fò ì´]ຣ|6Ý¥T ,°k4F'@= Q!NUmD¨!Õ„Kë :G6yñÊ<£‘Ò(¬"¢1‹–WaÕǸâ$Áu¼£áÕÕ+2A°WÆÙ)¢¸…k­¢Ä«lù½ÏxÆd;üX`Ë,èö+.2ÐzØÌÍüo™C@fQ~'H­œ÷Ž’à«#¸ñÝ9AíÛ*©‚ã!xCä…œ{Tœ,–§ŠEP•4gm⫤e”« §My»{ó*÷ hŽ´‘P¹•´d j+ÄÂ9‚I^ ò¸|ä!V)Á¶>FR=A£í´éF_p‚Áí§æ3E6Q¤=·(ðœçh†vÜÜœZü̧ŽpÅol7:Nù¥Sí6X¡³Û#Œî&§ã0@ÒÂT.s kBtãdÆ‹ nX¤ ðF«7xlE!¾ZEøaáÇC$ü«ð¯*¾}ø¯À?~üÜòûïmûxóêÝË·¯Á¹ÿòݽˆHD\þárñŸ¡ƒ<‹OXD! ©šœ€%ËyòV~`ùÞ¿yøÝ@„£ŸC¯•€ˆÂÕ† ‰Í¸”®P[ý(›õGâ7 ]p Uª@ <+äã÷¡\ëuázð˽»÷ï§ ÿ0ys'Ô7pÅ J˜qŒ‘Â\ЄY‚˲@aÿ`U`U€Ó!@`Ð '° Ïi¨6Ïi®ùöLà˜!JI@ÖZŽ1•TXðUL ÔÊoe‰Å”REZÿ°e?ÙÙÞŽ<öØ×y'ØtDê( +ÈÁG ÔfB\Ì( 4ÿ3 €&ZP"†ð=Œ|&Є >xfŒüÃ)e„\k}¢ZbMÀȈtD"ÜY?ü@SH<ÙŠR7thYDÁZö\7Žp T—œv žy€t^zsÅ…ÞyúŒÐ,°€‰ÿvÍGYjù‘ÂÌw¢Z²™Rƒ1Ís#ô€¦¦›2Á9á?ŒH°ÀŸk¹Æ§@ØTFàó,†ücÕH…7‡V•œrü€ÏZiKãäHP¨žÖko^ê™gW¾Í ×tÖÍ{TîIµÚsø0gy»Ÿ@+PàK¥i¦<Þƒñ°Ö‚Ôˆ)±ÁZ†¢N=Ú>„wbY#ªœˆä¥ºÚV`Ouq•ú{ÿ¨zïÐDÄo¿÷ªz#X:?L $‚E®.å-Ëÿ ñÑ’ZùiÑ?(•&Æð< ¶¤&ÏC¦vγ§›Á$÷iÌ~PA·ÄÿÇÔo"±®@ëŽ+º•ÂøÌwCtJ0`ˆÐ[ôåöÒ+˜åÍUÀEüûyü "4¤­¬0"­pÄ[+°Ç®IúH²g« ÓÆÉ£±@m/ SÝòqñGÛ¦K|òÏšýø(ÿ¬;Ü(£Š Z•Â"yÛ¤tÐV¨œc®~@ë¨Þ@ïÿu™²Ç>ìa„AµÕFÜÝ Rט ÁmBòØïÎô³±àÈÐÆ‚@!À@0 ±˜Ä@m¨©m6 èéI¯Â>RÑ•êeM9<[âÒ…•­€D"ã«Ñ[Bµ¿õù°SP»”Òÿ" B0ªª\an Â\d(µF4#¨Û”D 2™g@ã¦=&ôÝ=þÁ¶Þ=ˆÌÁ?@€ ü#e< Fó@9î‰CB‰R.r¨V° ÈÀÅHþ¦ Š´Âœp‰äÉÉ×tJ¥ÄÒDUs‰G&3ùÃN6dsðKÚ@Fpƒ ŠÀ.jTojw!‹ a€Ð’”)A jÆÈ’ñü‡ñä¡Á5Žj,ã=\rã-“ù0„|,Ð$Œ EQ‘0jQ(vµh¸@n¸•µCÉèyàYÈÓCÓI"à‡F°M¥Ï“ž ¢ûÐ3ÿžPÎEM»ßV€‘#Ì=+ÐÍLÊ¢•è È"€Óµ"Ú’Þ9Èn'ÀØ-¸Ñ1¢QÉHÝH/ºäBi&Æ$¢Oq‰ ddÏe'RNm·¡Ç]äˇF‰‘Òó”#PUÓ4©)}hrSøT_z ¿òi¦ÓÇ\’:—$! €ÏÂÍþA `Ek) "k¤CÜÎA%ÀØ„Äf62“ lÓ IR “mÜñ˜‡“>Õ¨YuRÔSÔ \p³zì²Í’ 1 0…)À1‘¶ ±Î­ ät#ˆghG[Ï·dªQ]_§zO¤Ù%UM¼ß?šHçÿTSUéÒCÅ"£Hhd‚€ƒäñ‚¬»«_Éø –TÉ@I¢±áž &Œ ‡X#7pÒ„Cú‡º¨$C1E8eYzË«®@Z€[ùëVBšxJôlgSOÅ”&Ý’Ú¡…J«OúÞ§UŒ8‰Ò£„G"v¢Öué)ªÙ(à˜ NÿxÝ t¶#Ü•¯ E£J@â7fЯmlë覘ìé8©è²Fæ›§xk+#iň¢BÎtÙ¬H>´‰ ¬p¶‡¡/’¿ÅNÕokûË#œìp ícåг?÷ô $” Jø°õœVÉgæ§Œ–àÿLÆú(s×ba~¤"å«5ÈÁžn§i³rw\j …‘°³2`Æ ¡f”a™FŒY"9c!HŠ 2€^jø5­”OKeïÌ¥r?ÓQAp2åÍmŽ=¡½È‘T·ÌPóQU¡Þ€¼T3!¤-` ^€66gÔ¢ QiAL*]x¯ÿp£¤«Á &ðAÀºu¯2Ô $ÞÔ’ÌN¨\ÀÔÃ…LéYY@7K&Ê’‚¾‚0S¥î‹VïGV·o¨p™êè’µS7%žIZAßúƒ™’xo?^ÚV@² ÌÃÚgsÚ",bštº}e›£Mb5N{pÿ,¦ÆŽåá ®Å3nÚò†ˆI_å£À…¡”ÄqÝ£X׺ž2 mâ#–ó¦÷þ<€£…ä#;rùGÀò½¸ˆ,™º”ý2]U~ªç}ùXb’0Âã…÷'C ÍG¼ Ž´*# öˆÍ¬|€æ?×(çh[‚}È]÷ŒñºÕÕ¸s…«¶Ù< ômJÂÁ.p; d‘6§Òp´öd:îV£ð2§2½É£¶g¼âþR]!ª±nÕSÙþµ?Óm™øž1GXŠÀô1„W,É#Ú-h0覘,®c|P²KÊÆ þƒÜÆõ Rý66—lÿJË$l±É-nó@PÍ®„?3aˆ ^%¸áP 8o¬¡ Õè/hJ4/¨—_ù59OåLÕ_G$ Xpý"d±CBe9ü°N¶'pB“$ @P±”P3ø ÿ°Ã7q!¡+K2‚†cm,P-,†6q%g{GF´Æ5bÁFÒ%]'å QW÷0öÐEÂh@¡' "70 ×p ?œ!ñWÂÁàr"í… Gq0ŸU@MÖdèQc(eázùÖuAr)ê!c$™V*`÷ù“ @MIQ±X¹’54Ó &##%ñqEl41ÿ‡R-@LÓµR»$`2‰xEËDs6Œ`uÔ ,1"”!`3Ò„ ×0 €r–—Or8Ö2‘ ž—=ätdçAOW%jû%ŒØ!u¦Å_¦"U h〪Dú$TBôuž£j…1ˆ@ %²ñe´Öv@|d‚“‚JAQÆ‚@'}™8]Ë4!R,½ãa|Ö\À¤RÌ·K¤Qô‚ö0Læ×xì(&†ðRBadÑ=ûcÂÑBY¨h"h^í„eªŒt‘z˜²zÆøülèCú¤Oü•’4:™c‘uð“Á%B J±üqºÂkÿ@‚¸å`fÕÜØ·C<àE̤RÓÅRnƒ7½cAT]ä *ålt+Â-!€ ðfgGrušMÉdR,×;|†”AÈAÀ$}æ;.&,f31`y9!C±‰aø€%0…À!$>‘åS+Di…iº'@Ã’@ƒZûÕtOGwÉzœ¤PÿUŒz!úät¡Ps‘©!‰ùH: dŒù“$Òã-”ð,‘q"¯b"©£`­v £`Ô$p! t}æ’hA D,e’QU9Åú@Q‰¡Ãƒ,±›e‚7@§-bÁøÀp3ˆ´¸I¡"XX ‹¦‹n9zE%[ýDj£¶‘ú’ò"8Duñ©e©6˜LÊOŒÙ—ŒIo ؆õ9`õªS“´ÏÁ:Y3a€‚ ¢™„ÆUA„F+Å L™;¤6ÊF]vÃm"F„1Wù­),ÌB,,!6o!fåkO‚ˆ1)œ(i"Xÿ±i…¢YÐÙ/Ò=D†üÄt›T—{iZ:—øµGZ†wuVvC‚’ýd˜ó2¥±/\æÞ’ ÏB“˜‘“2)ÂW¯`"bS b Ô„AÁ$Ã$¡Áb¡Å$bóaP‰wGè6öP&1Àq¦Á,¯YAÚ&~X ð<ÆObVÙ‚eÑ(ñ.“æym™£g‘` ˆXŒÝi*EÊd8RUóTœºjC•ªU7pOC*ëyª#Y‚D $Iªp®¾V†ˆaÖVZq±v²PèÇÃÅÉŠ¡ DÁò@wm-f6j‚61ñ×Zܪ›/ÿñEfƒƒeÁò,Ð,9a¿±…²igé2€´ ÿ€ ûçNo±?ôbZv€–so¹)é‘Út0uup ñ>ÎX¥QG$ì)‡Btž ·1”Y †¦õ!#QaAšÖE»ô .XA¿Ó‚ïȬ{µRÑçgfÄÃrtóEÁV<~¶L.á,_!Çi'{s(´(=£÷(P1?€‹Ë %ígûƒjq?™Ú£­ÚùŒPUžxIžÇ¸zu¶8¡U§ {E²ª:B®Æ°ç`‡ ÿð ½ñW!=ç*ÏR;4£p8%ú–;r§Åÿs<ÇB••@.»w$&bÎ~˳ ÔE·”eÃfê ÆÓ;é§¼ @'òz3‹I0ÂZÈXJ{º`hjR*LÅ—ÿÚ—Gú¯¶[Z»j𹤃4€AÁ ŒŒïY¼¡¢†¨šÐ+‡²}ˆ Ò¡C³ˆ/BN³;ìB£"È´)’ºoqJd! #®ç3Ø’¡Ê—ÞIü”ŒM7è°ÆÛ°ièZrŒÇWF°ôâzúðdÕ¼cfN@ ¶ca¸„H=ÿ7t¢ vó”jr÷H]t¿UÉ6Óof”Æ´gÀs›ÇògEFã6zCÅŠ2+²YÉ'3¢Z©7¶†¶Q®>E8ž· ^ì‹íã3woS7žù©=ƒµ ü>]»_Ø)Dìy‘rÜ37²À—r#qQ>tÜÁÉŒ³£±¸ê“½l¢.á«£á²`„1Ç < aÃÀ¤L…‡F؇}ÀeT^dxWÊbBå+zZe2c&ª”Œ`29±?ÝbMŽ¢…Q € ºü^¶eõ:e A€ÝÙOéa†ýºÌüI¡Š²u?_g4€Q>Bµž* 0ÖLR×Ò壒ç‡ÿÿ™‚B0 (¨52u1Ý/1=9vÓù¥XÆòqcUr“ï…‰¹³;5,ÄÁTLÌwbÆ´ƒÐFÚÛÖÎ%–÷@¬8\Ôê ~½c6+ÇĽ”àzÊ&-Õª g2‡ÓV¾Ð/Ó^-£ âva†—°®ë×–s4J:ŒìáT¢ÂѸÁ<½ÿ›>Ó3¿‹uÈ–'Í“>Ó7-^Þ‚"nUt§KÉeÚ[~Ô|WÚ|å¶YƒAÛ׉ ô;úä}}Ñ—Û¥Ü@,Ñš "Ýëb×R#"ÄGý“"7àME§´ÿ ËÑCJÝ {+n†‚^UÕ‰LÕÛMo[Nf°§ŠÞÓüÒÓ\ˆmą́˜÷#œBÐ:•évTa½Å‚1bÓ‚ž¼mw¡¦&E•ÊUƒ5œ]F·¹ïôÞåD<ðlÊRÿÜ&0&Šƒ€EòGY=sþ ÿ ?€ݶkO­©zìT»u›b*Í>ÌR—#d û–i?nU‡ÿY)qÁÒ‡4EB9Ë;f·z"ƒ!èˆÕзåuVLnTêÃF©¦ø¾ƒ%uW´™;B¼A¬ò€ä}-¢¾›rEÈ'ú ÙÜ Ü%Y–®‹bCüñšjÛžÝw¡úµ/¥b†ÓQ"—lŒýš=Äjéó°3-g\#&?pm¡j/ÎÑ'ªá Ï&†•s6ïqW…wxA6L]à÷ Xß-l„ƒ ázÊÄ1A& bˆ@'lFlâ£i'ÙC/;8ÖÖn¿ ;‡°ëTÖ}ò áµç¦%ò†~†Q·À­í‡žj­J¶W%æÓ3ëÿDîx/A4P Ð †±$( ¥ |:¹võq¤îw‚'¾U]›ùNåêQ×Ç6d-'æý›G‚ÁôæÍk!ïßCöÎ;ñÅ?y þ“‘AFÿBÌ›ðïƒICˆþ¥Lù‚Ë­~àû7 °eÏjR0dhã?}üâýŒÇïçQ¤E•ê ô?ùž>̧´ªÑ ðÛÚ)"}ù5ÖèQ©gÿI¥Ê/_ [7¾}*nV­HW,X±¢•Ë ÿ&ÐcaaEŒÿÝÃðÀÃÇ‘xÌxã‘Åî-Þ(éÃ{›;Þ¬XàÆ!>„Xk2õù6Ò®¼î¶ÓN©xÆ<¯=µ„z*½þ†Š'ŸîÖ2ï)~°«@ŸÀÂRɨ³Ö›ê,·Z À±²zÿ+@¹æšJ¬W¸‘ Jš§„xkHžÒ.£ìSdì±ÑþiŒÌRü̳ÊJ䀀 a%  ‡~¤{>øÀÆÀzh5†Šq Ä6²…b’7ßN`á ÐU‚=ü‡]'€ò¥jjf™è¤³îÏ ÄÚî!ñ¾;ª+7ŸÊǡ؜3Í7ÛƒÓM®Î}ô¡õ-ë¨6¥:0.ªöûéÿÆ /:‘òs…_!pöÙŒ ˆÄ£(cÑT[dl³ WeVÒ\Äp1yÒ1µ]õ™øÍg5…6¢m ‡*áÇN0·ä©hlù5é·kKâè%ç¶Œ—.}Êó)¦>ÿïL3ËLÝòŒFWЮÓJP¥Æ˾³ýü ì©Òr÷!éÜ*>·uË(:ñûgO•ù¶Øb.±{,ÌXãÏJ­L³OÕ5±EÈ1j¡"Ýb Áž|hTI„¾Ã:i¤Éwœ<7Š2U6SŒ’ô±çyt%%‚ ¤!(ˆ`&d®ÑiºêZáé=µÆk(3™ªš)¼‡jÏ©ªáÓù7çüIª­²b[>ì¾lSxý „»zDÁoTo€ËEd/ & y0%(pÐ ÏÌ1YÜìÉ4,QÕÍ88ŠSÉ£ ‰MnŠ%#]¹ì"X8–™)D7@ÊÏJ0›É)Æf¥coLrÿb-¤0&ÙV·ð œ<ãËFÔ¸§–ð´ë;UA Ž2H%.ÀaÁÈD/tm{G)W¯%¨†éÇ`ùªKØòñG,âJ|ôD,ÀoHÖ æرà©ÐC,d¡‘jc°dH&+U!EƒM¸Glšº¡sR™^ò˜éCWô˜ D‚CŠ\u6sŸ@†–3!±ÀHÆ™’Lþ¥éèdQ[P‚²‡<€I=M1 œæE”òà'°áØÞ¶‘%–ÁØFØ–ŸŸÐÒ-qaË]¢H=¤@onAÄ @¥ov(N…†t±Ðp*Uò`ÜO,Ä¢Rÿ}è(uÜH ò#2B¤y<Ø?rÑ2þ#3b>B bõ¬r—:ÁΊU+H²¹à@"9ãø„J?°>n’ÂeŒ"9*yÈÆB{ù‡ïi <‰‹ÏŒÍý0T!•ªDšá˜þR²ŸðLG<›\Ï„%’<²EX^±¹Œf< C ‰,Ÿ9‹GÆò $YgŽ ¢7ˆ@Am®\£:/¡À~³4Aå eyÀÖQ§pTzP=Èîr¦òÝq9ÃHò"d¬£-¤4¢ª2‹IÕQ~4¹åÞ6! yçÁÜ)¤Pâ*¦ÄƒØ©Uµà <ƒÀ; Òœ%kþ‰³j•³âÛµt¶´ÂQt  ÿ¯^ÓtËP %,åÚa*[Y0ù:ÅÊi˜œÚ“ÄZ~'Lb ÝÖÒ&+Þm?j𜈷±Ì‡­ hƒ“œS>vf§Ô™Œ}¡ùsR#D£)'q¿ØYÕW÷!-¾êõ‘‚„@7¬¡ÇnQž]Á,Ð l¯dë1 =' MÎ3 R=|ÀØc·ªaYÍ<Äì!‰%^A {[ßÿ(.ÄééÝê ­«©qÿ<ä3Ôò,g„€ìÊ¥˜­â vç={§”rŠt‚\j‘ÀwØbUˆ±“s.“€»"»¹_¤ƒÎBV¦Ì*-!ÿä©èî2úƒ^©DA|5Á Û•µ¥¤Ç+]Žo~©"ߦ„<¾©ôr_•½a+˜¾¢¬ø Ϊ¢ê!@Á“ÓãD „ P§lC×û€¤[ˆ=»ˆÚ“ŸŒa­§*Ö`´(À:ªΉ·¯ã·W(®z‹´ v ;³{ˆ »yˆ¾¤°ŠÏ9ˆ‘’e±±â ÞÀ•P5Â’fH2dò$»žs¢“`¢B“Û?øÒµåÙ—ãZ"â/0; θ(‘ûÎ2‰ã¬ÿ­XÃøH=¡£3@ê‰ @:¢±3ºÓÙBË”{'{ §™ù­õè=y>ˆQ1«*¾9»¸·âc>‹Àã7yˆxó•ê;‰N;œ’H– *E% 2!£’šÂoI2D?»¢h¿ª™ c,1ášZÔµ’"é¡ÂUj¥Æb¬ÍûŒ¼1BÊò¥»H@XJƶh }Xk[½ˆ‰:3­Âè¶?·Ç‰Œ¹zøu3 ü½£<±ÃÁ£ Uø‡(¾ð±S»—ð•B|ˆÐˆŠÈ§ÅÓ ]2:컿k¡k$@„ö{“ â/¤¸ÂZ¼Â*c ÿñ`<ûƒH< в(F€‰¬5[´½y6´º¬FA°ŸÈ,‰˜™,ÚJx5´C¦ `¦ûÈØ’)´ÊÉ#ÕÈ•­›*Æ‚xŒ¾H\nYAô:{C;yä/Uà MÜˆŽø‰ÚÀˆ r–ã§¹ ²¨-a¡ @&‡r((¤(‰$ЦP¥+{›{! [ãšbt»Ì“€©FCÉ[ E1êé%A˜½X'*©/™ª á”jzœ ã½ÊÌ¡< ú Ê·£\ÁW»|Çâb>¬º7¤®åSÊš¾b4a25Øø¢ëc„¯L=‚ŠŽg ¨«¾ñÿ*Äk42©¿õ6%ª ‚¯D¥¯ðÈhlšCú”çÜ›74Š¿D‹ÿøFùΘË"u2; ,ØÁÅ(:>Ì#‰äÂ:^9.ÏÄÁtZǤª«òMè7zL»§$>´3J¢äˆù¼–ƒ¨'Á}:ÃH:Õ@ ø‡‚`h†¸Â @”-„?‘jNPÒ›+« ‚ùÛ½´¥ñ0 -©åÄ5µˆ‹TF:9 7䥼؊$&ýÈ›ÌY  ³  „Ö» ܱ1zLN¡°!ª#HGÙÇï¸ÏGSUX¨\Áÿ;Ðü‰,;æ;P«×H„@ ÿÄÂ@Ï °Ð  dˆ«h ˜ìxB~ 55¥R‚šj *ýˆÁqf ðk«‚›Ðkèºñ€óà—Åã8Å{}h?Ã"ž|09R‹]t z9 ͥ̒‚™ ôÔÀÀTZ"0Ý•{U–TC%*€–Äži¬FD¸€â˜‡#¸&ý9|™ËØ]Aÿªø—ñ‰`»ÚxÌϯc'゘WØÒâ[Á Í⢴ G(>ç›ÇHÓD¸ã4µ£‰ly!»P!À½†e°€–ȵ‡’²mËya“êñŠ•Ë /£—SZ¹äÙ—Ã’%(¦yÌ…)É’”ˆÀø×ýøW‰€›¯%ØÍz²Í ²]X"°ï|Àzk…@:Ò°Ç#eIË‘Oû½ãÈLà›J£>þ¤ª–5.]-ÍISÁÒ4»D¾`»Õœý¥™ª(© aàÐehm-‹ðx“í›îX¹y‰¥FY¥`rÝO]%âYKý@[¶ÅÔ7ÌŠJ[Üe4­€ÿ%0‰8°îÌ`¢]ÌùWäH=Jh…‘x4²ŒN94ÂÀ•N#G‚ü½ÖÃÏ8A}èLÃMÁ/mÙÓ„G´C͘%PS{77Õˆë»Õ$dª’¸„‡¼è—•›ŠÀ"c|ÝýhŠXBGÚ‚XÎÛtsœì<àã…%{PÚ“àª3‹Ñ öä°%0«š™R“^+5‰—Š˜ÙðU—«2ÙxŒÇ–]±“•Á²3Pöµ´ÊõÄ­Þ( ½3_°»a€†‡…ˆ%z`ÚTÇq]Î×µ][µâDbX F ý{€‰ÐZ—é  hrRª^FP·Êí=ÿª¤  ý‰Å ‹,5_¤ðÏϸÁ—]€ášDb]±z¾Ï€°˜ß‹M{äh+« ‹_ø…^†‡É*®dKæ/áU Þä¸b¤ðd‰ôä²ýätkƒM†‚‡pªÀLäX}€€õ¡¦!iA ‰qÌ*ýs¤‘w_‰¶{‰þ ¯_ü\ TÁy|>^fÇY' 0­tCÁŒp¸Vè\Ôß2§^€†k¼dr®bTÞ`[uÑdv6@->`{hƒŸeMØNÖÐøÔä,¦‘WˇK‰€0ñ›Ô8’Õ ý$ÌlhêÓÌõÌ„˜ÿ_ ã¯ ûd ’}ÇWàãç;Š =ŠÎ ‹|7mÙƒì܇Pò­_À_\X½„*.g›ÆbvÞdQ®g«ìäïÈi P>Š îd¡6e¡Nj}¾b¡~ˆ|Æç³'°Ì9Ÿd2-@„ðÜkÓúœÊ¼X4­ArÎ d:–>-Äp7®xóº2¥Ýe»œ2é'Y‰h+!À_üU…^p\p^‚y|ך¾iÅvj‰àéÏЀ€ì j§NêÐgÇ¡ÌÆì §È†jÎîlªÊóyÁ¡ÃÐ …ß\¯6-ã8äC´Ò#ú ˜ÙœûD‹a7}ÖRÿMŒëyŒÙû=Ò@vòa4ûí–Rµ7üý‡^¨h'xihØ`šçžnþòl£Fgr¢lrÂçÀîyíÉÆ•Ìч­6ì¶ÒP- €!hmB>UAbè–ù ÁýmyóXà›ºµ¾Ó‡°€K@pÇ7â^Ž}7(iŽ"+ÕK\±æþaûæKà=ç(ol¤€ì€ì‡Àgí~ì†êË6qF´\ÁØV ðHHæP!ðßi T= Ì ûfã¶£mš•7°á RŒ¹c 0ü…ï >´ »Kèk× °È)ª¨­Æa0l{S…Whî‡èfhÀÏ„ÿzq5ÿŒð¾ä_Ë<Š vñŽ‘=’jm…W¨…f¸‰ZÀ6l:DÁ‡¨JËÄX†hÇŒ “OæÑÙ΄Ç”ò Mð)¿ô7CŠ H nÑP\ îÄßWÀðxiçæâœ`U^sYñÏgÊžõu>Šq” D0.lƒdé°hPdfõñŽ˜™Ê)û 8æXÞžžñ*Ýàô-A±¡J__`'Õn¿ÖtÇ_ÿT Ÿ˜*U´H^n™U…Kó^xˆ6è…x¿„ÑVC >g ¾u\_lˆ~ÿ :ïw]ÇvöWH…`ïZHx#½¶A?Šÿdoc&r-ÛØcÓº„±Câíã BÁèö¯+SKp Õô²S± ?)¦‚¢ m\¤ˆ÷6È ÷ð@e˜ó6x‚WìzÇ¡s¡N ÖHJu÷……¯uwú8vÞË1ôBç_f»Ûf ÖA®ÿ½äÞ‹Šö:]•rMïk Gùº.tÉfHžù‡¸„w¯Gç®hé‚|hj5lTÖy¢'ç6x[_Ë7ˆ7|5‡lÍ^ ‡{…l®aˆû…‡d;UŒÝÞªp™k±¿x4u”ŠåÁˆ©ÁnÆúÖ$Y§ »žûj¥Ãæ·–×CÐΕ!hÁÿ仄z¿ßx÷f!vQÖùŸ‡‚Ÿÿ‡ä|Ú…j¾z‰tqOúËžó+6ñëwêÈêNs™½{#mz`¯ö]sœ2ŒÕ^u9k?™2—? ëë[gKc\\p¥Dü —(ýøïÒJ> ú÷…ø„ýÃçС‹"¿.öºÔë߯_— ý[‘ïŸ ‡)Qþk“Ò¥C gÒ¬ió&Μ3SÊT)SEOÿ4ÄZT(Mž+c²в§ (éý˧‘¾V­,Ô¢ø¯™0+~øâ߇ù֪͗ödU¸ÿôéû×PÄÌ"ð^t¥¬Ãy-Î~ˆ"÷ŸºÎÿ:Ô··ä?U¯Ò¼$ò®ˆ0 ˜°Q"ˆÈõÏÅ?^ÿ>¾ºòW/’ªøÙ[ EfÔ”@Þî­JLà(¥JEj|*PªO•/Ù§Ò˜QcìŽÊô)Ïã£öTAÏÝZ_ýæëb+ˆ†Ò¦µGïƒ=·iCØ !­Cüˆi®¸Xm>!(ç=Œ…PVg96—[Œý' ý©B™kB„B ô·@ÿD€ 0&‚ NÐôM$QÂO>K­To7UwŒÚ!EÖáVœ=?ÁÔ†P?å¸uA%e$.qwwÕáŸ>ô×J*^‚C‹ÍCÏ–[rI˜`šeÿO\h¶ßEý9ÄW>¦Í4Ø–-öB /pic6Ax‘”]øÏièáEAƒ”¬€ÚEÕ44B ò Ï]äJ.©Óu—.icN¹ýC• dÒH“u5‘Úä?ERwÑ«;ù¸›’HÉdP¸B]CüÒÊ+µ4Sž­è#A%œðÏ òÈs -D;Ï [ŽJ_Y'ÕÕšù°f]¹ÖBMòüc®<-@йü3aÿ¡¹Â+}dÐeÞÞðÏT"2ÂŒ¦ŠjmdÚG—\"IBì;“©5לp9Ul+,w™µý1Ž6elÓ€5}JTqÐã­,+¹ÿ)vM¾ÜÒn(ŇˆfC´"L3ÀœçÍ:ûÏ=òMô¹äÎ3êw!8_]| ºf–Q\´´`ë¾à,ÐéîYæ¤Ê”]fP ”P²€‡þN„Ë?¸XTRµñËݹ|Ä4Ï@³|ÿàÐÅö@AfŦªp8/NøLÀ] …nCIþå?ÙS›Ço×iJéËReäOL¶4ÔÆ+G숴"İ3¹{ÒD߃û¹ËÒ¤œ©ü0º‚*ÿøP|cÿD!à?ä6¿tu¶0ôÒsu[Ó·©íÐ@Ý (¿ôöE‰¾R7F-¹ùÊ/ä=L öT0øIƒ`ÿÇ‚{>ÿøáƒçï©6'¸R1îNP‰ ‡9ʵ!q;á\©šã’‘ …8HÚŽË^¢Ašáju5áÔL¢R~hF<<« îA€{¤ÐYΚž´–%C1ÅeAăÌEc–™(§,˜Ss½ëO{49BBtÈ_BÅ?B„ EÆ`.¸›‰öö’Ä‚£MUªR€“ÔOù°ŸÿêG¦Øã~›3M$GÌnsŒsBÇ p¹QÙ„sÎUªBÈë¬lT)!ÕEpµ©–§ƒÞùØU63„@h… €.ž€ÍsH X@.tA‹*ñ^а‚oùàÈ»ˆÕªgÀœ¥ÿzŽÙLMV€¾…Øë"–ù¥@¨h¼P"N„bˆ,ä§‹8!ŽúÇ+ 1,|P€¸È÷¨%?‚#£Ã8F1ÂE.dlcõ§N:¶‘ü˜n ˜?扂’Ndæ²Ï9'*.Y™?k¤²1F  H+†xÒ\ÐZš´"Ê‹4”'(PUäƒì)$BÉ3‹óv¸˜Å\vÝÒ 8Ê=ƒ¬ô—a[‡Æ7“)þC!1ÑF´HŠ,àš,úi>æ÷ù„1ê?Ê¢¤º…œ}§CÒ˜Í|ÄÇ›bD'Çlò" =R'ۘƒB çÜ*‘N™ÉËüÉÃÍIà!1ÿm+³N ¥ÑƒwšÞÐf4‡R…ªû!ÛFkÚÊné#@Ê)cä‚3© 12*=÷ "¢š Š˜ÆtÈ(„ \(³&n‚æ+¼‚@U .×ÔGi+À~ –µ®­‹>^;£^s¨¶*‹j«Ÿ™LÕª-ÚIN *Ÿ<å&+Ê?YÖ$}.wF» =òÑ+“!eÖ­ Ë!æjÞEó„=W¾¢?xÑG‚ Öy%/R+‰*²'XJ¸T .ýå·V@˜â£Q´R£rÊ×8Ä" @¡Ú†ÀÖ±½JC`ÇØÙ%©Ó…í\`[—¥ªVµImòÁ¨6¨PåXÿ©l–bxæ³SË-.X™RÈ Œ¬ƒh5«Vó%µ"îbµd('Á” yCK¡w—0ªø¸u“/y¢ìŸ-ÏD!X^>$ ¯‹¸ jÿ@Ÿö¶ç|]D~i/b‘€ 2¯¬‰(b áãaŽ0žo2ÝßùÎyFÄ„a‹‡Ú¨¬ªiµ1C^„PHîê`¦{)m°WšAMs::RYJ¢D !PÀ]ÙÖE|·WÞá®»Kž ^V ÍÄ7/ˆÑÇ_k«Í¥&:tÈ+m*"ËøÒBÄvyÄ'LŠŒ"ä©âEZãa@ãBÔ òšL×&Ý®ð¶Ãÿ]/BÁÿ(·…Ëu£»ÍyÎJ(ÜáÖÄc]å£ Og#%çfZA¬U.‡¨…ÿÀÀ?8Þ1k&±6^­'³€z/1uɇÕÂ6eš¸€/ßZ¢krf›ÀÎÛ <íè噕¡®V¨øƒ™l&ÛÁ%"6Cœo{ç:¿9ÐŽó’}ñ"¸k²bŽ‘ÊѪ¤‚¤{G¸ Ã7N„#åècÔ­ø€» e®%-…[Cø? pèn&gž·´÷­â½bƒ½5]s˜:äÉQ}éL—r¯Í/]A+Äs(öŒÓ]&4/á $¾&¸$ôåµýÿl?l_Èv„÷uƒ=_äa¸4½¸oâ12E°s¥‚à‹x*n MgÙʨR2E gÝ7ŒVvD°?ìMæ14®w/4e¯!óØ%ֽ¯ëâò*R¦—óL,$L‡T>?°Hˆša5Ù—ÐÆ+$pƒ™‹hæ—ßWÎ9ÿy›Ó|ó:çyÍÝþÞæõÙèéŸþ)ÝÿÐHîÝX¤5ÝT4èFïá^Í8Ū(L@ ÊÄÄ€ˆxŒZüP(= Ѱ<ÌúlºÀvùGÇ9VMÅW½Ð„^œ—àE—ñ…^Ïô=Ê2ÍYMAÞ?@ÑW8„ÄÔÈYÿÈN!‚ΔÏXÐùßLØYéùÿUáÍ}ÞçÙç `þñÏÇ¢Èæ|ÇX¹G©˜=Ä€{¼á‹@ Õ!…wôªÊæäà —œÙÜ?xÒ<†ô°KºhW ¨áGÍ„dLˆ|mTÝAÆy…jèjˆÀ/Dò›ö´%u¢d > "CíX }Ù€aV^ÄåáÄÎÞç‘¡èÕ"¸ÕœÏ! ½Õ[V1Ýǰ^Q|þ#<’Z PœŒC„€Am€>À µLOÑ8`⻤ÚE8\t\·,‘ñø‰½¨Ö„cÄ`ßÝŸ´ßß) }YÈEÿÑ´!Ã?ø×L<>ŠÜ2YH3Á/HÀ$9ÜИÞ,^ž/jžCØV˜è•žÏ=LÎå_/R@YØCà#Él#Èæ^3Z CPGÈðÖ—=ðAèÀ —H‹7R…,I´ š\ ¹ ¶Ò+Ô`½DY+ÍJqÙL¨Ÿô’È ›(^ˆ=Ö„f EÃ2ø£0ÄT"›=RBâQÞBÑ` ý›¸M—çáfÐÉb…íÜC`á¶5„]zäE_ê%MøÐ^ªWþ¼ÑJÚC |‡32 a]£ ÌƒŽ°ÄÒôÀb‚°Çb€ÉÒ,KD9ï‰U<²!y´R´Û*é’PÈ&…ø á DŽIÐ0„È?øBí”GÜM†´Q„€!HÀÂÜ üC=ü@- ƒ/ ÃY MÂÃiF–T/ž[Clä.^§]Ìÿâ‡ÙVˆ9DmÝ`ÀÇ™L€CL€#‰]ÙÃHvU!KÖÕbMd¾á7RÅaJ¦¾½ O¨!" „²L@0–ŒäLtcŽÈ‰C$MdÏ›ÙDñÀæE8åLÔàAÐ×/ÞŸ\04Cí[÷Q…jM€ÙßÉÿA$D½~…n^4øÂ‡.ƒCX’/Í&£\Ä\Ä\„ùt¨%Hª*ҩ꺉‘˜\Œ§Æ^l”òjZX©™ ™†—–ìH¾á2ÚÕaÂáaÚ#ð騸¬,­¤rE ܨèÃAYÀÎbR‚TÏ6Z£‰IUmÙ„ (4±&eP³¡Ôö¥‰.Ý4dDUµÕ‰†¨ˆŠA´¢·ˆ@| ¨Ð?” ¸‚C`ÉÂþ@ ìET@[µ•ÜJ€Á\ýÃÜêÄÄ:„ÝÚ…!xQ”j¬ßB)ÇnNë?L@y’çǸ,Êzi]]2VžÒ„]½ËHÅJB+™BÿÀø‹f…Hü m`¼`^Kž¼ö<(4©#b¼’—¡f¼ÒdDØN–»¾íÐİœÇÏø#4Œ´ÕwÉÃ$/¨m=ü¤‚ÂþÃ<¬‹..Z\é^V@Âîåh¯ÜÎDÞæmáÞ­ªÒm«ÚÞFi[]lö¢Em±o`z){ íɺ¬2B#௠æoþj]NŸ†%M›âÆä’Ì!YEÞ!†„0-ee¡Ê_¸ãiÈ‹.áÅj~mqþ]àI–0íkÀÞcâ¿h_œ‹Cl‘ÕÃöÖD-8ìE€,öÎð€ [¯õŽç_^@Y\“|€œVB‚ùÇÝ¢–ª^ÿÄÜÊ-qñâêð`é(®ýš.{Úï<ðéÇw ÐìLÁG‚èÞürIø€˜Äšôdz=[Òº°Áñ 8J—qÜ{IíLÐy ñ Á¤‚¨P BÁ^„<Mˆê>tºÂÜ‚MŒ$þޤ¯¾¬2vf–X)Ì¢–^é”J€Ý&Ø5Eé¹É-ÓDm5ñ÷.Çð—Å Ç,-;Dgάžær±.÷ò̪à xE×Nã™0ëÇ0b>à4ºþÝÄÑ„°1*ßìÅ1Š;h|„´}íŸD¢PÑ¥Ž(_DD€¼4™ ¸ÅQ $×Äó., €ÿ¬$Û²•ÞÂý˜CYv© Nðéð)èb)\E)?Lgßöh‹®ÞJ¯ÞqÂ1MP1Rà/Ml±Ew±v¨ ð XÐ}H}(λˆ4@ƒÔìÉ„PVȹFŸ\B+)òüZU¤ó?¸ ÏD/µT¾LEÔÎ0ÛĈÁ]U,•'½€>_DÔCó^Ä2¤BÈó?€$×óE0ÂŒæ¯2Ù²Y‘íó<ðs Ì ÌÃ-|q!ª`FBׄ)Ï«*‰)ñ5µ0OñKöéHv±þVn'ÛÖH€4C%ýC*Ô¯ÙC•=8Á€˜´àÚ¸ñÔŠ@¦hmŸÕä‚UäÿÃ;¢+AžŸ$JøÑ„øMVåéXÒÉ ü A=Àö? Cˆj*À³+€CÌóâÖó-ÜðŒ2K xC·D w‘yÒ *÷X{ã,'”ÚÒ ñ[íD/.`+ãþõ.ïõå^n`x7/·.Wî7šÐ0·\ÔÇ<Ñ„I_‚¶äÃ^¸±£hȵSFûÇÅYM›ÔÅ5«ÉíÖ„à…¢d¸»Î+¿,¥MˆMÔÃRÏÄyÔ‚Û:„$S5 `uŒB>ßÄÙÁ"C&W) .ÄÒ\}@÷~§2Þ0'×ÿb´V/©Y"6VRÄ+Ðöbä9¶ÑCÑÿ+)Hƒ²®dÂqñ¨Â|Ó¯…Ñ8Æ®šL§ÖK¹«áíeSÊAfU“*ãƒ;mÏvSC¯Cø‚/¤€"[8‡OoÇèE|õ þð@ˆû¹ÁúÁlqk4R$ñªÆ-w/DkïP}l<7Mà¯¥×ø?dt¦›÷Íyoz!êiMªà‡ÈYâÄYX 66=´@>¸†Øªö|ÏôMç&þ‚&jâEH¹”ãDØ:Õìº/ ûdù 7'JLÕÝBù?0À‡ÅÖL€ÝE¬¹C4õE¼ó>þ2@upgø•ÎóŒN‡ïóÙþ¹D]„r#¯Á"¯¹°ÀXÿµ¢Cÿi\S·MD´U÷¶ð®Â2è ÿ^:ÀwòÛø§o1ð,W(Êc m_) £$ºN¹ |žàôd'*_¯1ü\ráë.M”Ý9dÆjšK/Ð(MÈöµ6?ƹµÿv¸ç¹•&õWºÁ ¢ A»{úLXçÑáÄ«%Pw¾UO@)·¸-Çp ¤•î,ZÉ´ÊÈ7^b…HÌE.$Hô †ÕmdÀæ\ÙÞ)êJßD‡4{ÈF±³Y~ Z$u=¼vÌW{mö›#¨í-XuoS}@[urÏ„’ z ãÿŽ¡oñ_çDÒÓ»ªVÀÃJýML@ ÿ* ës@tÀ[´-ßx.kîy/Í^ïøeEÀ·FÑ^~DU° ˜`ÜÄëP.˜†>˜ÆgK|éñ óZ3;â*íôȃùÈO"Ù¬@à‡‘=oúLX{µËüµ»9ÃÒ¶$ß3ž[©+üöTgº$w k>ÁÛåŽ'$WìqÄ;¾Ä¿ ÿJ¨pA‡ V HpÂCFÿM˜HcÆyÿm„ðÏ#G‚ÿ‘ü׊à«!ùì…aÏÉ¿˜þÑüׂ^‹òšèüGÏå?}ÿDPtñïè¿_EªÊˆ1ß¿(!ò -º‚à‚þ- D‘ÿR„°_#ø X­¬ñÃÇCõžfñD-‚¾j%¸âß ®G$ñ·Ä?ŠŸ¹wdç¿Ä""h¨.F‡þ;XÁàÃÏ;?ŒÈ(bæº&±VM ‚,Xh5ôÃK'öÒû׆žœåݼyÂwˆ(ú†%x• Ó×P RÍì#ìñ^Å.ˆðŠ»ï Ôjý7bDÔŠ% ºŠ;}HŒzÿ!£ðO6FW©ùßš€¸„Ä«ë‚JØ("D0›Ž¢ ª Ì*í *üçƒÐžú #‹<œÈ"@¤Œ"“L¨µ‡ 0¤6ŠZò­ ‚bÌ)§þi‚¸&ŠÓiÿž>È%Ÿ\˜sAŸ_b*#é2Sîç0Ï)Jxå³Äëî¡´XaËŠr«D(â¡z¨gºBó.‚èCÂþ¹å‚ ìŒèÙâï0ÉJ`áûg ‚ƒŒ…yPËÈË|ÈÌ ¬ÀÍ<»@BšÀ! &ðE‘FB­µ!°h$ØF•6C„`ÅZq” {|£gÆŸlºQžulAG‚’{hH˜rJ:UÖ"h$1Š‚Ãå˜}h-+¹úg…¼2"ó¶\í=÷0¢‹L¹Ô4óújñÅ¿ôÄ/5«“·H8ì–0ÐŽ(n±‰8|43#ýÿ‰Ë 4È +äÔÂÔ2“˜¢EaóP¤36­U‘$ðÎQzxëí§ÞZ°‘8‚ õ©d©‚Äh)¦ÖRòµŠ IU´ʳª¼V¼¯2ŒÃˆ4®‹L5ÿ¡Ë̼B&•Œòã¸Î ü›‚üP1Š3PQ fTaÐ<3h! 1Сú”Á NmmDIñ-Qý®Ö“Š2ßhŽ"zr¢©…“Yv) \.ÖØTaYŠ2 ¨åhÝRºxîj« ½+¯H_–BŠÞˈ\بú¡Z~ (¿ HÐ]L1ëŒè?Ýÿ’L²A@t² >»`‡Bb3Ùv^ÿ5IZTéŠP¥˜UÖ(.‘0£g£]sªé¡]wEÿõ˜Œ" ¡0jöe³zÅû‰j. õ0Âò ‚l®–Ÿ„á#vËW¾¾6‚œà@$bE6ó6мPC,\§êTîqL{Q!G–FT}ä4JCM ›•,8Á9â|œï!#“ÉÀ¢’‹ºˆÎ,øóÁ+,‡gQäˆuÉ"—RÂ¥lu@1;‘ÊU¤BUßR•™ähù˜‡o6’>õ•L(Ãoú‡‘¤`KJ’Îè,÷"åˆa$ÈAø%¥±+kÑÊF3Ë40.o|äH5€vôÁ`ºþñƒTü ‘M6ñs‹Ãì6#,ÞבKŽóR”ªÜ Éѵ†f«‹ÿ<™Š±Nî"ó>n›}*®”+ÌGL"¤¤,%fHbÊUš%X†QrÖqÔ3²%­˜±¢¡UFæB ‘ ÕfT?Ô_‹ l"£ÅPDÂÿ¸=Q1½ª-¥MƒœØê& 1¥,á+^X*™Ñ ð‰Ä9l}\iE’º‚¤&%I£û:ꮩ\d² Ô.HeŒÂðSbh BÃÞ‰ òE {6J-DS¥Qòe‘|)ÏôîÉ»ØÅÉÔ¿¡èD8Ú‚ÛO^þ$'ûD"FR‰ÕÈUgX¢uå?r‘‹0†à0ŽrD{Dÿ)°¸¯á–…à£Å®£`=¢;AŒ`Žstš¢€ÒZ #]„qÀ?t„ àõ@‚¦‡pÂÈ)w‡¢~#¡èQd¾ª[ }zç:EÀ[©8ćÌÃ2¨-3E£“ÿ“‰ÌfŠÃ*E|b3øÖ8DAr!DX‘Íi³rgõX¨ \â"G9}ºLe*ôC¨KÁ»Î1ÜkªG_kX$ A^Hh´KSQo—þ Cèô@#Œ)$ÛO–@ÂØVϤZ3­~òžž,1yVÏÕ>Ä$llV´Q¦$<*Yä‚kœÆÝ¤òø8Il– èã+Á V‚L›$ú0ÖC¢à›ájNÄÓùh>RR»¶Ýà&7At¼âÝP¬ë]ïZ<¾ˆ:¤ŸþÒT´HðôÕÄÄ©€¿ÿX’ë‚ßMyÆëUûzš ÚÌh{­i§–1D>Uíÿs¿FV_k£ÆGäÅ)Ëþq‚´âË~÷Ñê6#öˆošó¬”#k¤ÈmîÉsnäÒ¯š+HzJá!Ž.U,X—Öç좻ôÒ×¾ž$doE~úÞèQ*Ê*HFf¨ÎM­³÷"iû<¥ü” ^äáM’_?ÉG¾“‰Ùî'xíßï16io„ø¦Ì‹26ø–Ù¿ @qû?ùQ¤(˜àSÖ²–0~þ)æúrù/ÒÓŸ^ÇѤÑîÜ$ööèLêÁLäãªé!¢a¾îA0E ,«àìk†|(©lH4܉¿¬ ÖŽ´–CAŸlæÌ|Cäÿúîµïî¡ ºï!ŠÍ%ôXnô!x@'T¤YòŒ),ƒôaozõPOÿõVì™@oÒàŠî)$èL¶K>hç)´‹ ¶Ëväã"¦aâ†É.‹³"Pb$f3FÄ¿l­ÊthžvÈ"B`rmz¤úæA þázå‘ Ä8zD*šãär9Zà äã¢í>XŽ‹à"üG(`¬ŽÄòr°¢Ö"™œÐ–Ðô *è€ОbҞЙÌd™²‹"Ö#ªÆöPÊébFá.šŒ‡JìÚæBЉ3ÐÐ46åø"Î4hmÊ–15ÜNâ>3,cym'ÿB®@:ìälCÎãÒ (‚BÚ¦­«~L~AtR#†âe,1˜EþVÀ2ŽÆÃœÐÅB#PoÒþ¡'è EO‚¾P ÷¨éæƒ/0H/žN/0HöôhRaÞ­œ¾.R‚²Òn’Ì!ð$³,‰ ²fââð5žïC´GbTŽB`#6eäA9€@&#£ûîÁo¢8lR^î!p [¨¤Ÿ"çâQ5aþ(‚Û,mÅžÐMÏ 3BÒ¦Ò¤ä$>$Èöjç!RŠ¥ž"!kl|á>†¦S‚j!ˆ±.h3Ë-K#í8FœB¨bæ©$S…Z'%[æüðïz&ÿ3Îî! 1'ÿ Ñý(â^¡1±‚€>1çˆ ó2'ã#žðÒ8s‚šð)  ð褒 0À @ßrO°P‚ n/š‚ ¹«jh玲6YÊÂ2öÚd"Ša.ðà0Ò!<ð#)éAUÚŽyB2¤ðF‚R’:Î/#±80#~‹; O)(Ͼs-œä9àoþÊÊ(Ó³((À2x€3GÑš#‚N‘Òîó4'íè @>@€`³Ñ\Óð ‰@³+6¹ e³+WÊ~À"ƒð‘*åBЬ}‘÷x/kÖp$¡j…žóN+ŠX+ql"±£Í.,Eÿ)¢H¨1äh†(–…<)b ï(-1!ê©)íó ÒFq)ÿÁñâ“u,º,H߬KÆd¬‚èB>¶k+_/(b6ÿ ,}³ %4„o$×rM£ÈîÒ.¡Q5øCÙ%1Äf¸ì)Z ïælÍÜL´*Ìã [ÐQ(Ÿ€äÏhtÐ()“E-¤þÝB“4 MÿQŸ©\\áº#õL¢°‚*¶ ¥Tƒ Röè"ò7ßë!Üæy>Cñ«u| $Ù0ï"˜ïlÚ‰ ´Œd:?€7>lͦÍ×ÐÎà§«ó!¸(Fê2+ãýf41Ç2Šb®Ø‰ÈM4ÿpŸô>ͪ‹õžB>1BJ1â@ý*A1è!ÉdTKí¨,kÕFx>2³>ãAܲw  ?I‡¢Š¿¦ƒÀ†VŽ(7‚kؤ`§Í ’c1 J€€[†Pf¾h(<#4qçQ®ÖôF“ ´è€”ܸõ!ãPa§õÂõ! »¦´\¹K¥òH/"òë Fìé²R5’DcBhh^9ëì‚BÊ´bd`RCæ*%ycd¨ÏÀëV|c*â‡Ú„‚9”‚å,jŒD€ µ.rô*Æ*P«Jàþ±Ò@–Ò€PÅžºÖ¶L2eM6n/•¯fó Ûä6ѵ/Ô2Û2… ÿ §ààÆ¾îLÕéRføöë"( 7\ ­4ÀË2à ÄñfvkF³v€¨eF»6Ps0=ŸãYÃö5ÔVm/ ݦ‹Æ& Ñ…nùН¤”vdѯðh¨i]™BP­BŽjp‰³È&¤ÉìÄp•³.¬T û ‡`öeª– ôTOÅYŒR·6tqP(%Z)B4€)¢èšPN梮-#àÖ¤Æe©´Ñ^7#,¨¯nf㣠+Åf3òëVÍë>(ùœo-qˆc’FȬ|:Ž &WXxHôÁ–Âj¡Ã2ÿTYåcÙB{Ãä^ c3âZÿq¹.ÆMn»•™¢”"ÿ¢©¯ëuSA_³jò@Š,Õ’V¨46ƒUÓRb4ël”gÀô¡QôÁR ¡”)⮵.Pï®ÐØöJ5–i–Ïåm僢”Ll¯ŽPØ.òƒx1 ‡àV)` LÆR]á6¢Ù˜w?²‘.Ù›yà$àm‚ ”ùB2 à$•G¥ØyÜR!>E¥3B !&@ÀTƒ`mFò>`*¢8~~d”0‡ü./Yg#:ïÃÙd($@=B‘ƒUà õ£z…Ðä!òvSø@å—\ïHê².3 áVswL¦#aä («aNZø˜9åÚB,ä êÄS’QÜÒSÿª™"fº¯ÛÉS²ÙaäÙ›í®.ìœmÆý ªŠ_:šEË3ƒóA™£"TŽà8Û_2Ãá“ÿÊE¯‚0MèMX8˜«ôöæ6#ê­>+ Äð$Úº,·­ko#,"…® ­KÃN¸áºBˆ8CýºV•[ ìÕm"‚zHƒ¦ÍæhõCªüÔLXF†µ¬#~&¬}j4”3‘( /=p¡ºÚþº$:û!®5‚Ÿ)¨ô®Ú„ã÷™,HJ+u¿¦\°‚âx+]˜"˜.¬- / (`­Ü¢ÿöV£Ó¬ÅŽ·D}áËy&pÅ.¤†²bàFHZLÿ8d¯—[¥÷Äm›Å•[!HºÄåÆÂg:ù  €:~ÄÙìÎ~a(†ðN5c-D=ÜKivR;WY|-;Ë$ÓüH邾յ3#Ƭԯ\6SX—c /aÈ$a¼ÂáK]¼Ìk›£Ë3Ê*:Â…»BÜÚa0e¤/à¤ß¤áµB¹{¸ºñº"ðz cœˆ©§B> :‘XØ"§%Zâ%¤‚Š¬èæ„¢¬¦7#˜bôA‚>@Ô}¤½ ¤³1àPs¾Å7´YìÑDM$(ÀÇenÕX«±<Ýâã}_¶[›\es]|aÌ|,)ºÂ9ú2*R.ÜAâ¼Ù!E]ÿ…Ïë:ÄKüBJüƒä:³¢{#Ñp³â&©è&ìâ¦h—](BÔE (R«V|$¬ f8qZÊÓhš£IÒÝlðPÀú)Õ!ƒ ôyõHvñÙ×¶¿iy ý;­JévS­´ÞÌ5š \¬}AÍŸÍ<}-\ÙoÎ3z«‘=Âq»®“»A*¤Ä‹aîRÂlª9L}‡Cܦ…ꂤ¡sArÍž-d`”öÃØ±ò¢—VÄÊÙ@](>½ÑyÞ½Kbå³MõJO¯‚àÛ®¿¡æ´Ò¿gl¿¯<䟦R& §cS›Ž ß×éh±¢ƒÙ¬•]¢R"ÄÙá¶Î-Ú·'r˜›™™ÿ;¼BàÄõ|º“sÆÉ ‡7Ê(é, ÂypÃÔ¶}š¤*žb(´væÎ;ƒ…"C$*7‚¬Ë2£ýÈ=‚®Ð¸ºi²ë¿µ¿c=e]e3õQz]6kW/Ì:B&\ì"$÷Uaêü)|_·ãaV>øËEïÙ™#Å™-œÄ5%¹eÉ¢_à ÌÄ5ãBN-# ÏG^"¢> ÇÍ !רª(JÙar#7ì&EøO2Ãñã=î*¯¢üi õi²ái]½5Æ"A½ÿþû—ÄÁ… ¦ª•*•ÃkQò’‘:8äã?C éÑ£Ž+WŽü'ÁãICÿBš)á#Í›z^@áF+š !’SÂÏ ÿ~6­p©R˜M§B]锡˃SMR8HQØÈþ öCˆ¹òåÓ×páŠs"Z¨¶ì¿ !…øÇˆÞÁ%XÄ}€ÁÁ$þñˆ»Ðz®ê´ r¡A† BŽ+0FŽ‚PHñóB‰#¦V(ñåÉ‘G3ÜH²*¥†˜úFr¡wˬ# Q s'ÍÝ1•æŒáÆ×£ˆzöäê4ûVÕU};¿°{éT§[QXAAßÊ¿fÏš}«>÷ÑáÔ;á„…óæý+!Ï?44à ñ+®8vdpÇf ´™ÿgA(ÐAž0j§9„ÚBµ[‰®Q$Q*H\T\Hª5US\môÒB]1dÜq8YÇ£sXðƒt'éƒTRQa…$q7ÞÈÕB"yGUWFµbžzù1ò=z}[oýÓÖAö-¤O™ÿè‚zeå7Ï~ü&Ï ò H€€uþs‚½p@®†èƒˆzÖ AA+XЊz´–)zJ6×RUɸ ‰QL1b9T5t—ZÐó—`ÿt™Ï?ùäÂÿ·dæ"¹à–{ÝA!@àæAó°P˜œfpb8ðO/¯>èƒz6Tσ“z¡A›AׂÑ—€g‚©¦qÅ6bj©p8Ûn½õ“§Z‰Ú”HTUPj~MpËMµjžuµúªÏ<ÕÊ»¶"A­ÁÎJq!;×ÐVD3ÌÝl”%Ø_1„`O]vnšiÞW3¹5ÿµÖY„Ц»ÿ d€Áô.T‚ Ph¾2d@=ƒZf肚E˜!Hsv™†¥mxPˆ$~6bâiERN ‰Ç©”õѨL¹,yä9·ROe¬!Pµðê묾ÂtôÿЭOÅäߪÝõÑ~þù·PÔùH½m·gù¾Z+©uе •ð qÚùOÜùÒ×Üÿ]”[‚£†è|ˆ3Iç—Ñ~~ÇFm, ì táJk™n¶‚‡Z@¯`m¸¢(¬Å¢ÛI×´.ËìÇ@†i6ÿqÃ,¯!=ˆ!ït¶˜æ€!ubä  CL`mìeêa™ÿžŠ×§>]Þõ¸3B‹‡Tc)u$hC«¨0éwŸËíe! ¯töª¥áv¡YkEwu:DìŽöˆ‚îÊ¢Ê(9«ÀU »¬ÙÜÏpy‡‡1 Xy`°0„"ÿa„`AÅ+Vaô¹˜ äôz’4@r?Qö2íl/pÕû9Ì¡ ™XOó!MŸ#Qs@ÕX"‹d]éJ‡ P-k™ZšvV¼âU ‡™±•[{à¾6òm…?S †LÅEÚ'þ1Œ/$wÊÀtÿÓjˆa/ÀŸòÕ˜|)Zï´ƒÞÌ,L!¢¬§á*öŒ8ÿNŸ>1YÈ>&²÷5¹WiU˜-å! [\úÀW7`¥('=¶°Õ`½°Ž+X9ˆ´ ­šÇHóÀÀ H³ñùφŸÓB_À®v\˜ šJ›Ò{ Ivh¢Þx*<"‰IqZ" Ü`gµÌ¼ð# ¨ŽÍæ!%´ gðÐXg´°ÁÚéŠ:鈭^È@7îLG&P›!ØÁ!ô¨¡Î¡Qå’qÔ’€¬; ŽInrœ¢Ð$'´¤šNzf.#‚+@H[àáØ5æz‰’ Águ²ÃÔÁAÎÝËR²ozQ3KD‰N¾ÿ#MIFò)q¼dÇÙç†TÕF@Ö¢ÛwHázˆ€"P =N &ìÛ¤<—QªàÈB “e€ mÜŠôç×Öƒ´d÷÷¡ž¡È¦i¼§ã§“8ÒÄä9(Ì#A£è#”ˆÀ\}̹Ÿ}]"ðÍuîay˜”ß fÏÊV…QÒá ŒØ0{†‰B“n«ðŸ»˜Ã;;’Òè4ôÓ`2[ÏÉÕ{žƒä,Ë?ÀüQhÕ Jôj]ûÖ9Ìo-‚šß<õMPýÙYm÷½è¯“U¸E'¥pĵ‡„4%‡—‰_¶ŒoE(ýÞm9!»+?€øP Õ™‡ÿc§`c~sRh¡+vª§z8§sûÖz*ïdqï_i–ð†‡+ØC’‚T'j&á1ñI‘u¹b:«%Aµ‚+ k»3wæ7ˆ&! :wx~]úÁ‚qQ Çö„SH…òhŸÔ!Å×);ÑË$*e9cB€æqÔáƒE¸s·o`“&6gWkhk1§%€%Àízø72P…\Œˆ‰2FUÅ2á‘$%×La9³D9Ø ×W&i68×}¬ÇeU“vgvf-Љáòy8‡ú1gX";~ˆ­èŠõ ì^Œ×)Pÿ?(S?‘Ó: aP³u:¼²R" '¥z:G¬‡-h¡[«of¶„iµ.‚Äȳy({¯¨Û8>Ó@ðÔùSEST,Ä2ÓW d(T"Q²¦o‡„ʸŒ›H\öŒ åj`C%€‡¶“h²3¹ÇU()&;@ö‡hpN›Eq!PÐkó#%g$ §S ¯:³âƒnw~ž¸‰·–viç!¹Œ¹¶·Ã6#%;Ű‚t¹hÐ{0ù7³HŽñÓKqډ cèyeR&ˆÐvè‰f6’R³‰I¹jõ(ŠÂUg#¥’ g¬xq‡D4ÉRZÉ0œâcÿU7ÁR²nö‹×7+µ²;i5#éhgÌØŒ!5P³®ö.,`,0RVù7Ðt‡ôH\¹Sƒø•ãÆÁúSPt`ÂÀ9B)”`m 5Øò–M‰-º•[!‰Q£;kù…±R†1p²ÃUÐthl…SÀ…÷Ç•ÜÁv؈+fˆàjŒðg¤Z»ò“®n[T—G‰vQC‡Ì˜&Òˆoyuð€“ÍvYð#\‹W›„U·Ù„@@:Õ‡y°‘uj©0[iå]¶;ÐI’ÎioùŒNÐ`öà[ó. ÿð’¯èÿ&Pš‡wxp€¼¢+B+°UB¯€qÙZ åeFÉ¢G‰ê™g¥Ô”M+u9 ¦aÊ ‚yˆ‡î—‡ ¡øÀž³UK=S[ÁR{µWi×j–ú‰-¬'G5.ñÂåGabЍb:¡©Èz›$0Dʦ§ o:¿P&h‘L!5hqŸ'jžØ§fÆo¡ 5¸£Ô xÒ\S¦â™¨Ü!ˆ'ÿT¸9gà~xøŒà kj¤°Ž=‘ úšÚvEwó(Îx”|Švf†ªh•ª¨\Úd­'à—Õö ;Zaú\:…¨@…ºª«X’žiÚ £ ì©+V_EŒ¢fRϸ‰ÐY¥És\†V‚*¨÷ 6Õ Þ—‚—­n ‘•Àe ²°±úC‹ $¤x¨ŠŠ€Fš++ i%ĈÄ6¯É–û™vê¬ú’͈ªÿZ&oa¬"³'€L-àÖ¶bàúNg '7\´áS…36|ù‘ž©ˆ›¦¨¦øFæ!™ ¯[³¯+úŒtجÎɯÜâ¯0Z&ºõÿvue­ÔÄz7 liSa€Iÿ |°˜ð°À…¶\9g´G± ‚¨¸¦_„KʹEØœTk¯ ™¯Yû-.»µk™R‚‰ÇjfŽPa– ˆQaƒâ ¥³ôBÐbÛI·¹¨Ñd®Œ º­‚d¶‰º•jA’ûYµ É™Vê©Z; \k™Œ¨z,€ŒH™ — 0$¹ ž?d72ÒBÔ·?¹ŽTmp|ã ©€¦´w† 3Cá†ÒoPÚºöÚ‰z ¥R£œ/û¯Óz²-PWè»sü6’ý9° ¼ ¡ã³¹a½·B‘ "Ç'¹¼ ó¶²0ÿ¼HS7+¸*·p«ª*,7PoýsºÅœñ¸«ë”kYø8»»£. ¹^ˆé;wm`f'šØgµ—ÛŸàУ,5 TSAÌ0 ýÄ/4ÀÝêÜ wI,‚{«iZª\æ™R“Sã\²¬&Ûº!Åä¿­sM°P~ê÷pBøŽïò ïÉÓ©{õàÁ Nƒù†â<Ôáj“¿‡bþÌ9àüb.Dâ”Ý-®ÜCK7BGGnSCãÍICÞý²ì \C!ïC+_==Ô mžªX·úÑÿPÔtŒlØ‘êË¢é`ÜÛÁì”Î9ߢ®oO¾Ö÷ŽåXÎ÷€sYnH®žå´g Ól/Ý}õ‰ÿCÄÍ/Äÿ°7Œ9%Ó`þ6þ¢‡m#¾ÓØÕâÿ ®XÐØ Ñ ¤P=Þ5íFÍ=Ò €Îâx3ã™Ñ0>vϺ_  ÚQ|%x8W\Ô$ßاô85Hž[ì~¢\—·Æ©¤Jª¤ÇõžêúNúüŽå'D6'@lf»±™6áüøÒå&}‰b/ð=É­Hû‚ z‚Ó7µØqÁ¼úò‹Qð‹qì Ô1&mD[è-?mŸAÔÍ®X9D•” Ü= Á詨èQ¬asóp‡¬ÉJ²¾l—›¾îÁ ¦*ªúzRLÞ'úåøÞô¤¿õ@=1ï_ þDøÿà_Á2tðâEG*:D˜ÃÈ¿}ÿeàñDH„18øÄÀ¿()"tp å,kþSè%Bš_0@³ç?”;Qöì¹áJ¥7…sé?¥@ëý«7ëMW]]5P¯««° ü›p–QÚ ŒÐþƒpöì? èÍ;1¯…Þôüú Xpˆ( Î"q¾|QÛ øïäyôZhhq¢I‹ÌKšükòùÞhÒ÷ä9=A†ƒ bp ûã¿#lÛv€!Ç?#9:þàÑÈ‹!þ½ JáØã/f¤)•èÍÛ8eÛ ‚ÐùÒ My¤ŠZüÔ…ÓivÊ}+Vÿïb™"¬·2~½ hÝB˜Pÿ $Íý.{æÁ넾þ,Á> Ì0SìƒÄ³g2 ï²Ì¯þáŒ3ÍþYb‰{D+í…{ÂÉ£¸0È€×Zƒµƒv»­¡†Úh7#Œèh£‡¨§•²Ã9VºÀ'²;à…ZBɹˆnÊm§ƒ‚8à%è zj»¡¶ƒ.Ìñ¶Üj(¢¨ ¾ñÈêj«°âkÓ²ð›«-üZ+5þ› FÔ ÃÊèYð0 BE!ì ì+3[§ yF$íÒ{ ÎÅ‚`{@FÙb,õ w4B!süg7„2È ˆ!ZqÅÈÿŸ{ñª”hBÎL¢„­é$è°4rºd¡:À)‡u‰&,½óÈ×§j J&›´…/¬§¨o)8çó­³ô³o¿³øûïÜ>(pPC`ÑC ST± é%T2G…tÒ[X¢RÓfí!d=nžbq!†=*uÕÞpàÆ›6Z誔ە5BrËìbB¹¦¢h2¶¼˜²ŒH§&¡–%gYz.Ì'W"5°À ¨0©­6<ªâëög£iJkL„ ¢íyô ´_Á kб( ÍwÂ(íw²ü­ R þ’”Rµåa»mÖ‚Û­Å 8"ÅKÅ;FUI…1·zã­¦lmeÿ^‹ÌNÕ \áÁIÇ[r:7ˆ|Ê.,gfiÙfÇÄ|s.¯=2\§6§Iéõä<Ú+l‘Vª'·ª—ñp¡¼­ŒÂ³~W±Â5l÷FÃvÔÑHý¢ºÃ¶ÛÞT#Þí…3°1!Te´ÎµÝ–ÌXûUå‚!÷Hr£§+*rŸVJ&·¥Š&ž£ëI§é~S<¤ª)ó ¢–wÊÂk g7ÚMpAìaà%8 Z$zäc5÷À@ BÐ ¬¦,ð æá;}^c›¿þ!Èï/É3¥.ÅŽå € ›–'o©Â›Ýw4„a[È­\ÿ!¹R9©5%)ŸÓ`rðGfºêÎM G¥-Ž©,W)àù6?›„'> ãzÈÄ„à{ªB XÀF|A  0@;7ê‘«¡ÝïñE†xÅsÔ ïR™²e„ò` XeÔíÂeÄ×èæE'¹Àø®³›Ý8%ZaÑ‹’E>)ªÌ#‰kä‚…œÏ Lâ¡"UX­ªxgŒ1i]wÆ:om~R…ìj’Ì(óSŸU°@ ÜC÷p#¯‰ lb@òÁ?˜°¥Ðœ~Q¤Øt—¾¨/˜!, $HÒxINZï5AŒ†0ÿ\ç ­jÈUx›y{É‚#kLµ·…äRIíÜJ~⑞qÔ{òøW€ßÚüÊK·®Ý»xó\ Ä‚h‚ ºd„GP<²$£—óV¶ȈžODq-Ø@©„=yV°ùŒH#"2ôO" °ÿ-ø1µ)âKi[Pº¢! ðm¸¹Ñ{ü>@žV`\ñFÄÓK½ºõëØfĉ Z„Œ¤oøÿýˆŸóø,4ETÂ_²÷чúô^ÊÌøA?§ôÁTð[V”öO€úÁT6Ð ´ý°ÀHHÀÚ -ÐJE7T?fµµÖ[yÝŠ,¶hй†ˆ}á‚KDðc_À\$ÄÂ#P_Teh"š„’@!øôÏ òÐ7h(ÍóJ¶ h jTA‚V€Zý¶˜z°Å&…­tà ƒ=U‘!"ÚÃ[ÏñÏsñé⟀z§@ùüShŸùdt| AAF¿m 4ÂX 4= ƒKŒdP÷…™“)E)Ð SFV‚•!ÅÞ€Œ„ÿ0ÚP ¨ÏyÊÔÂý@lC ñÏ ­À©Tš4õCEÈÜZn *í´ÔÞYh>üè‘› Q˜+@º.×\“0™‰K_àÖlOÅKÏ}PÒ'Ð<ôˆ Aõý´¼X‚æS¬TÀ>.õ>éùZC2Sp"aðJÕ²ßrœrÐ TAž#TkòÉsaûÏyª,"#ˆp%|[“MsÍElÊî(}=e\ Ä O¾ô¾VšzOÒöq9Ai¼7ߪ0-M5Q ˜ç!.˰¯?0Õj°°‘t÷!Șœ[Ñ*—>%«ˆòÞÕòÿÃϵq©¬?%k¶À …Õ¤TÏ7~Xi»Š{å<óEi/ P.ý’½ÿÜs„<• ŸÒÿÈó¹~÷2éDB›ìb b¯ÿŒ„††\Ðem­ð*Ü úT¶hÑ}hB~¯¬<ßÌZ(ËÛmh\# GR°BpB4õa‘O­‡ˆ¶óý¤©ÿ`^ú Ù{Dçò^zûï߃A”'T–> Œ(®{”ƒ,0ŠQàƒlµ8`Ä.P’ a¬H½ó >†õá©åoÒS?Dð•¬y ÌŽZbæ7l™0[~Óˆ@D²‚Ø â{MYJUVÐ miå>EkI æ÷¤ÌÍ{š<ÿŽÖ¹àˆ îqy”À2õšÒ¼².­æX¾#`± H än“˜Š‡,„‘\T¤'¸LÇO!Œã\ðÆ€äÅ%[p± xTóšG½†XKYÙ• Ð|€_‘™LÓ7y0ñðÜüžöü#â?ð¾øÙcGhb @C €%{ƒMpŒÔÂW €þ35Côn)óUÛp¼û4§OpÁH(L8¶QŽÈ¤Ë Š€mÁÅOày x5«€s˜ªÈ–ÂZ `™œQÔ.úäçVƒÔµ•4‘kŸÌ$·FffF £²’æ#ízÍö#’)ÿ8Àª¸y’ÿ@‰r¨2ìÊ«IK&ñ~HLç@r€ÞHº³œ‡…‰•t|?—¨¤>SŒ UˆO•‰5L! +'X;t]cõ DÞK—ÃÅ zʇ©Ã¼7l¹¦dÈU âC³ ýƒ†~i3bšB |PÂ(YIdæ!ªìp³¥C¢&aœÉ›f€ÆéLâÛ7D£‘œŽ|ß°_’!D°{?0mJ½ø¥ ø( ÃRñ^!ãÀøÁH § K·~Z+—!¼'hÅ#ªnK< 0³š..Ë s —Á D bΓ˜VÐ8–Êt÷ÎYšJ¨Š¥ÄH¦sÙ™ÿt§ÉÓÔKJ›ÚœÃ«”V9¬-í$!0DF |´¸uÕ¦&µáCNÖX+@€VŽ¢M¬Ñã†P#¸î¶5uŽÀ\ß:GÇËs\fÛÁiKf7ˆ sÝ[3…Hÿhy"2áòx –Êô½óˆ7té@Þ¹g šÐG¼ì?îÇ9FFiU>!"LzŒ’ ± Р¨/pŸp>Ó CLÙÎe\È(@ùIDîíä>G:ÚÒ“>øêEgËÀ¼–݇]x «m7Øgk42û2‚¸íýè•¢€>ž»«é0d‚Þá?ÐÌçsN„’ÿÉ9€òHÆr@§xBÙM.ñ»ö²éÒìDDöI±'u–À FqÌË’èCaRùÔ6$o 𣀠ÈPi†PE!¡e•oÏD{—Q ±j†-< õÁujÅ|‚q…!HÝ ¸ðÿ0¯°G$Ö$†Õhòð}çHR%H´IöCIíU*•E=eQò]ÑDŒ`'àN*a]åFt?äò^Ä¡!¯Ñ;¼ò_eƒ øtž’=¤eXöe°[ ¦ÓÑoz²'ûvj†¢¬‚É#Vt¨FÎäQÍ'OAÛƒ ˜' ­01ÓUFB"p!ˆÿ)%ÄV:C%s%§~ð#N‘écrF”~é§D€>MäH@t=ÁƒQh¬A“ †ððF2_¥±°6c“´ÃJí&qeo_¦BÁzC‡¾µVªpÿ-|BpzvÉdB‡(·u(®à·&Á )#C@ á±…aˆð‘‘wí#DðeXTY÷°*ôPVR/¡XŠÔxM„åTŠí•>ôñ0KA&E.àE=± ×ĈS1øÿÀJÀàs#ÁzX†Gȸe´ama…âuuóŒ×Fª¹§{ç¾·" ÿwB³PÎá2wD|Q8Q3#Å5ƒ+B B@ CàLMq&O!ƒ‡XEyÆ¡~¨r‰ ,`•ÑàIád4D^‹×D©³4“a>Á÷Ø— Ð#55³RLÖn¯å…¤€äG¨qÁox(o¤Aû&pÎ1ËÈeèuª‡q{H³“Ú87q<Àϱ¶E\6A·–,4R3_Ñ:»M1dÒ.QYãc“cD£X:,aŠí“?!EóÑDÓ6DYóI-F£8D¨r)qscH¦áTÁ±&Å8ïÈЀI!e#N±, ät§ÿ·zäY2Å…GlÕuÉèuб’uc7 ¶Œp(‡rH&⌷ç"Ï‚"xjÇAÑÈ“_vXA œñãr‹Aƒgqt H‚=°Tý±-f?–cŒ?–±4¦IÑD/ýâHdù9šó–ñIVùÑšcüÒ5]tJ1 <ñ`óÃk²,®”€|ùtyÈ` Æu•©¤áŒ™ÿv'ýöŒ)yWÚ"Ør¥Ã‡Á\ÈÅ-ñ-‹s#x&ÓU$K!‹á.8ÒB ì#K$¢ñÓ9JÔ>úQ/Ó6ñc/ñ„L…0–ó¬b1a%Úÿu4w` dÒ5p‚×@¸aoºt@ hZTÑŠC\«‡V}ãsuaj¶EŸuXpQêŸa[Т{R2Ô“-'D‡­¡cº”?â-±©ŽQC/D$Ó×%ü¢HI8Æ9O£–'Á©~Gr4µ•7ÕCJûx¨¢9͹9‡¨,@^Aÿ³S <Ê!!o`£0dÓ6¾8 úºzÆâP`f‡^Ê`¿pÕŒÑ3½õ¤¾¥¤Ò(h[ Yo1‚vsB6Q‡óÚó|Ú•¬©­@ ­óŽK5S4JsXQ?”m#š4ÿ*hÉiÁùM¬2ò·?ò§cI¨cGsóê12_®Ra!â—UE;µ€ ˰ ¹ä©<± 'ŒÉ{Ñèu ÛoíùFj4€‚«j+“ ¸xX¶å‚ÅÚ bw}ñh–š0d ÚqûâR¥‘]O‚4Œg/–³¥x9D¨~ÒÆDðƒ¢ëƒ/š¸Žä§¡4”ó}ƒ?€!+¥áŠ`òR!éšS±OUK†i”YKQÀª3Y¥q8™ñ0ù†“[6±ÎÓƒ±üIÚˆ(‘hq4Ô¬ø°Zq&Œ1Z̲/Cq©à4I–³D‡F1 râÿ7m/÷4¡D@¤œ~ú]•„¨b÷q/1%õƒüS Pöi˜J Å2,iÓ*Já+© V‹ ¿’µ{G³;˜»!S‡Ì‡½ÚF¡IÁ7¹"<é7(¢±~òY*ú-ä|ñÎ53à ]ˆ8¤aS³9ïó>îG–ÃåDÊùž¸~#j?ðƒ”¤I27/†Mbˆº¹ Ç Qö Fq,õTONa_µ³OÍ`À×4’¹‚lõ'é[_;(ñiÏÈ`òɶ¿[Ÿ8™»$b7%d<z°ÈE3m&MUÑkìq]~C¶5Ѩ‚ã$‘´DÿDIAJK´Dî7xã$¾@~™”­ˆËƒAÌÈôÑVBdQX0a!O|%3J AuŸ‚†¹Ø;ˆQ ÿ@Àµ#ª*„u™ q.––à‡§À—•D#j­à|/Íy>÷bM’è*?”!ú/¤#Z£&ùð)q DË Øºc¤Ë§æoÑc¬pRª-¿5{kµj†'¦Vp× Ò¸|[*2Á·ˆ€²ê¸ ì’£D“g†_óÂ*K¤Y”ÓFôbë—^˶È2f:ˆœ^> „/–I‘ ¾%z®ô®™›®Q0""*V!¨"ÒWÔ*OÅ0¹ œv~2Ñ©¦¤Ç4Æ +ŸkeÖÓC(Ó{xÇì˜ÙÑ™?™Á…‚" ¥2Ñã2Ú2E»q~q#ˆÑD£ÔÙ{•’Ä99­I”•D@ÿ½N™4mö³lœ~‘„¦ÈÎa*;´…K› %œM:øÒ$£ûÔ'Õ¦Q Ù «a ¢&¤€¶oKa~#éi˜n,Ñb«©o ‹QkÑVEpnÝ»Ú'ºk"í[j<£‚ bLÁ£·Bƒÿ°)·CP¡ÜL´ésÃ>ÙÅ~VÙ:®S+×>;ÄD.6C%Dœã4ò°-a¹K*û8÷ñ%¢Óü¼ß?áÏ¿ñŒhd-Í ¯ruGa,p¾Ëž ¡°* Ú2‚éù†6é°\öÖmq-†2â·…«‡b"tóLjA( ç}á|²ÓUª1–Ã>DDšÿäÃ('ŠgÔAX~JŒ?ÇImìLê]DñwK >zš/nY0úSÜeÏ\ЍjÒnBµËðÏp úЇhåLa]Ÿõen´¤Îe¸ ŸtÓàÑv¤Ê}(ÇãÁþutˆ-ŽpÏá¦T$–4 û(¢2DÊ%ïscàµèÈ©Ø1Û99 Ô‰^§òðãvÚx>îΚ>?¨2ßç£!`'à„Ì¢õá\¢«åƈT… Ͱ Ïð ËPi=úv`úá™îé’¸¾æ+ ÇWJñ¨F‚Ø»±¦þ¹P!ˆ«nA¼m«çÞ&w©•­ÿÕ5-P9@ŽrˆmY¡è€—lËöÝ5Úx-ïóÐ'pôš¾Ù=«ÙIÓ$@£QXûâS¢à¬áÄb·‰‘n¬ðÏ0 !ÙL_Qy’˜û¶ëk-‡ˆY{1ÒUú¤1«ÈnvxtG|¿e|¦Â‹ÜÔ.ç l[" ˆ>2Œ°CóaSá^IéuB¿x4KÓå.ôå}c¹y*G¿4-P4ž¬®‰{/ö@ù1Né£ôý8%`ûEð[H˜–&pA=öÏo¯ÜLaœ[¼Î0ÒÛû6{´ ¥‡™ÑŒ áyáižæ½»e¥À÷¾ñ‰ÿ)çy”×”'‰qàCI}*H³SäžC^¾>œØ…ÎúKÓR-uHÝ-þý;1£y–hÁâÄ¿yòæÍû0p"½ÿèMøðA"††4D¡U„£jý¶lÙ3`?(BôO_F~ñræÌ8_O ufÔ/c>£?oò+`â'ÒŸFãÝXà'S£#ùéCôóŸ× W¿ê«às`…ùþÀÉ–S¸ùø…u+÷ëZµ#-X0R ÿ Iø0Qå±`ñïÞ?HH (dÇ–3q|9£€Î–ï=~œQž<‚ÿ…ø÷A­}j?„ ±EÿAzO<ø°ñ?ÿ$ÎcDÂÃyþqô’ð@‘‚)ü°€0dŸ=Ã7“_M~.¶NÝ9TgVÏÕž¿ks`<¨è3²u5©ÕËdm¾íÚõæÿ»ÔR‹¾öÖBë,ŸðãG-³æû‘X‚"è«£Kl·Nûçˆ{"h2Ì*ÓŒ ã쟃 ´ž"ã Ä{0€,Do3({\Ó‡+÷$Èg‚æ)2·‰B-"yŠèŠ !yš(*ÐÇŽ&Xn¹†¸¡•ð¦%`Xº¦; jZª'ö€*oÎóäÃ*§©²Ê“*£¨â‰Áâ9)9Gˆ* ýÿÊ®E½Z©µ˜*«‚Åb4#½V¸!ÂDBh"ÅP»µBŒìE1«Q³cô Ff4µÄÒè„#±Ì'ŸšÁ¦Øf«Í yN¨í¡ÛnýÍC‹*a±(rMJ9L¹  $2-@æšgþY†%|Z1D¤­~˳¤Î£óN©¨Bt*¡*äÒ‰À˺êÉ«Bÿ´§­’ë`¶ ˜T½§ÄÒ'Ón  Öæ)á„hO“ÇFï9‚²RN4ál MÄË8hFË4+Õ4  j-Ÿ}ýG]} 6s»­ dŸÌˆy *¶hˆû ¬>µv5<2) Fiÿ)Üe€EbüSê+€ß‹*§¢Š²)Þ>у^ÝãÓlù¾*À(BƒZ àšˆ `µ+#´®2øQ…­J«=4Õ'ÃhYxážmE΋ìò V͈U—3R9Ö_.MžÑzâM£týQ_)`ýÇ|f3"àp]ˆ Hí)I( b¤¢‰Kˆ0·½á‡”Î7ëQdÊ{ݯ}*=½Û44{ø]o)z³Ò—úýž×ç-œÚ~ê®Gó)'~>P¸ÒÂ%E_®óAºá*‰†21‘D¨d.g ´Ì1)"€åJt¢ §3¤qLŽt]}`uZÁƒ‘ÿ³)!‚ÈOð›¡Æ! IíB´¢MäwØÖIÊt&—¬Ó’À–]C„^øQËx€NqŠ|Âg¶ ,‰y÷¸˜Ë³õMnv[×Xdy™õ©'RW)Kß 7 ´„.x”´)Dp)rÉ@ž%6°Ž¤çcLf£Ñ(¥Rg­FEO‚ˆ° Á•=ÿaDÁ54»‰#)±€WôÅ‘.9ÚÔ&[šd OøÎ‰œpIùH`þA|X £;„eFzu³›MÅÿ)úÊôÜ“”˜€-l["0 •½|U6ŠJÄõ¦(†é4l? \ßàÒ¨Òî@íÛ _Zqʤ†0ó c:V@tVf^5Ù8;3MÒ.‘©Ã+±@uð‰%þÙÁí,¯á]^›J,[„! -Ax7é»Â„L‰½Î¸®ñJ®€NDjžH…'é[ÐÙ¸G/µp¯‰„º óD2v_v»©Ó÷R¨pS^$ŹˆWê‹z£Ôø†Ô]OZ”>:fTºCM“PS¤„Äx5YîjòÁÖ0ÈfÿxEuáJ‰·^7»´€q z°f¹ÿIÈy¡%öö„ùn7Ķ÷%;”Mö'‚·Ä£¾ç3³6÷À)Í+}öŒ‚`5¿g‹‰b&PÕ·²ü#,ùfXÖß ¯6Ъˆ>n°€$z¨ü$0‹`1§a£Š<\>6Eꉋ3²\ÚäF#8nÍή˜fêþƒªî±_þG®`qÚ k2‚-Ý0J+lp¢UÐ݇­Úu–×¼ÀÔd!Á}Ç#½ÊÒ©(<) ¡êæ!S{H&Pº4ãTµý…\ w–„Ù/aº‹–öb¡V0ºÑ­IŒÅvÝ±ã®˜Ž›ÞêcJ¼$ä€uXjÿZ˨+#ÿô?W­êU?¼á+x>ÿ›Ø Ÿˆ´ko $¢=I"Iû°Õ[¦Q c×XF¹3ì_‰ÔÓ–s.é4Úì!±lj£ ‚‘Ƚj»)½œs3S«>.öM~`±ŠWª)0…,4ÛË_â=ìd(x/„aé@ôõ•Ƥ•퉑µ"³pFéê¸>2®=Ž«ªí”Xg„uAR+–êп§w kDÓ{òĶdM? É@<Å8u³â†.3çô¬­'ô¹6NdÚ£ì'n©°ÜˆŠv{QÏ{‹>° , FÄŒš¡Äˆ— 04YØ!ÿ¨é#"˜±=x4c]±&¿z;\N‰Xן>`õ[í¾‡ÿëvä@^§ñϸÉ!~!ƪäh… %1,JRa¦q¹Ü±#½ö §9s .zò­hLaB µ­@a‹_š3 º @¹”žj”«pŸÙ²H‘Ÿ=£0´Ø±€ H´xD Œ €´Ü+¯Æh1=Ò£VÙœŒ(+îJ2´²5:5ï3¬é‚+툊Hzµ2»Ë¾¿Ð¾€¾ê•›èÖPŽ"!hiˆÝ(–háŸ`;¥˜½,cž.k“‘9¸üÒ%³A³œ{³ýK"ãž'¶÷è¶pËÿAË©ô)½<»'Ö’s#œÕ ‹  1‰°=Òºz¥q a•Œ¨‹8«Ü؋Ӡ#ì ›é>ƒ¤¹ã±ˆ[WXµWðUÈJØ>ê龄û ð[ÃpÞ¸˜û$„êˆÂ“ò–kðè(Z ³9y‹ò 0ôH)© =‰39™c¬©6T@8D³Ò= ¬~À?3sS²àŠ€=œ x4ÄH’òj'Q zÞ  ‡É·[8û'¸²ÁóRµèS5Qоˆ;Cù¶CÂO©§ÂáS€TªÂ¨«Y\ø+›%±‰¢#¢ÿA F¶¹¢jÛ›dš<˲‰;º;³CaŠ C´8½ kŸÁyÉIy‹Ð@Œ·h“ 1â9¡¨z™â—ˆí²5´œé‰ч„ÛÁ·›.´®‚«Oä± >í›.}¼;W“«b’ÔQ2J Þú‡“±åPH” !06`Ø€®ù(ô™<,Ú\º‰ñ1Cb*C³Q½xÀÄ©d$IÁq”ùáEh„@áÀXº´@IÈü3á³wÛ@Tj q´ Aˆ[Ò). (ÕØ™A«ÙAýÃAêù'èû'†ƒ+˜Çº‹8~¬DÇâ;¶›ã˜+iŒÆ(/ÞIÿ°€a†Vj†   ú‘š,Ô2³Yýº µ!©ëtºc”þR] ÏEz)§ó ú8= ;« +‹õ¬ŸhLF÷1E™ÜTÚÃÛº½Ä(ÁÒÐ4[±"9«³²5ÖX»èܱËÀÊž.í[XOì è»ÊU³Ê˜®PŒÐGÚ»`™1åàÓ1È„8ˆ)‰ ¨Ž@ΗPΉ¼¥gË `©—B0 "&²“?첩¹.J˜F­¶ 7jÔ³ œ¯@i,ù $½vƒºØ!* à‹ 9‰NÑF ¿‘ªÒ9 „ˆٰ¸Œ»Œ¥t;5Å;ÿ×üĸ‹+U°GÙB u5ŒU¨ÊîK£œÉ…º*!ê±5/ùD šah†Vº†¨€ ¸%±a$›)R+‚¢za3–&bÚ—µø¥¬ ÃA+´ ½÷I€)UMR=kÕŸ°¸Wµ3{8œé)ü ¾àC HHˆœãŒ«•Óˆ½ µZÀÔt…cÊ í‰é’.UÐÄu; >Ô¾ ͈!ì‰PÔAìš5[3« (/™€„4„V NDm†ŒŠ šøò¨È»95[›õ°¶P%£H±—„Ù—ÿûË¿$@+« @´b:#­Õ­€Rõ¢Yµ‡<“Ÿ©ŠY=«ÿ„)U¶À§ø‰¹à‹  0£¢6òO`…™ÓI²Ö8Å™)´‹ ÖQ—w\P·ûD u;{ÌÇ!|8„8l XK#$„4ã`²Z㈄„Ž“°!†kø‡k|8—¼›ÀŠÃι颢››ó"A¢=+÷ÁX [ØŠ½'¶xØmL¶˜ÃªøÓ¼Ø  XýÚál´€€ (Œ’©Ë •àÀ ã{Á숛YI|ÇíÊ„Gë hVO\€<唹‹ÍM¼ALÜGÏp$Iš [[ÂËÀŠŽè³€Kh`×Ãj“¨@©ðÚt¢á"HÉ6vqÒÚ¢ÿ]bۇ͇‡-ºRmØ-jLêA^{P{ U†14Jˆ½ìUÒ Z±¢)!´3>Pc»¶a\4}Šë ™ý‡©¬D5ßéŠÖª„MêÉ>~üÖÁµCÅ‹ƒÀ¨¿hZhxÚQ˜˜Ñ=ÊŠkXÃ$Ÿ­-:ÕËè%Õ¶åÚµ@Þc` €‚ô` pÒØ`^DØÃE§Úuj ‰!ƒ(â1M‚ë‰v”˜½ Iz¤óµM8­Öè ±»ªŒ€íÅ ¾;ù¥®"\œÕ ]QS/˜’¨.º‰_è…^øß5¹óéK Þb.Þâ†}`ç ã³òàc öŒ †Þÿž cí`…Þ]©~²Vø7S‡°'Œè,q š² ñ ¦_©‰òm¤ÕœÙ¼»ÁØäÙ"®.ê‘Ñ5¸`„" s刘I|Ô}ú‡_x…ÿùÚ.>å® XeVÞ`F+3^cÔQeêqÞ5n7æà1Îezpåç%UHÜ‹Û 7Â"€Å˜,9,SO jGT{¥„ÏSäÐ…¬BN8óˆÕ¾ ž°ù…5€|f,‘¨‘¨R¦Uµ"p\p‚è…K€\¨TEe}îâ~c6þ´4.c 8ãô  °‡^Nh0h{ЃîåžÀˆUn^ÿ{à³ S#&é&¨RæŽPfz¨ˆã›™¬Ë8Æßçñ¥ìÊn†¬·ëʽû ša+n$J´®"â {”¤Œxá—- PÙ¸JP…_€g¨bh(‚ÇÌ(0å}Žê ð`WÎåŒXhЀ…hâh…ŽzkX讎è¬îå²­Vk¶~å¢ av£’­’`HE•U”ÿРä‘(Åe…$þÖ]ABÚØ™ˆIÊ›1_é’ßK Λ–š8Ó¾Þ–öË鸄腣vz††K ^Qµ –jÔ.èæúçHë´^c pmâ›m¶ö ´ ­~í±.ã>ÎÿÀb„x((Ôh1W¹¥•°œæd½™“f>¥ü•e¥¤&+;CJ˜ý•¸òÁ`]Ö²é%êXž^»‹›ÂtÅ‚ ¥Ξg'8ê*¾(Þ\6m‚Nmÿkâ»_ÜÞ¢Ȉ`í·êÖ®å^Nc¹à§®¡¡ðþh†Ä2e»|€ØèëØùè–Dë~À¦Š„§x¼žˆÔÒY‹ÜÎj!ˆloäÓç&“À\µ.Ux…ùöì6hƒ*Ðïÿ^ò«è(ðWë ðËÐ('×î`*Ÿêv^¹@„tåÛð¶a8T @%ÿ Ç„Üpš’Šxï‰BF”Ebà •¯’ÅV”_ù¼óÙ _µŸñ@Ç®ü­€šŒV0a€ïÉêUóìúm[Û€Vp&×çØní×Öí'_ðôˆ®¾rOGmâ›òŠ®€`Z$ó`×E%ÜÒ™‘æ?Ó|ˆŽ„, ?#É‘ Žæ¦½ûÇ6öø^5â¤ñU£ññ†$SÌ™¶!!À×ÁWr!ïP6òzöXvòLGmª¾j+ÿQGwtÏm ~ít÷ÿVÇ /TG!@Na°‚V8‰ÛÂ`ÚpAþ\¾^éÙyˆ1´K:ÏðsJüîÿÍ&N!(✎ÐJ*}@¥œ6Nø~¸Nêyî'hÐm(èe´‚÷.&ã¬ÎꞘmvïò¢Kw— y¯²ãn…W¨…ãÌ÷~_ÚøÀÓ©œ‰é—MÊÏ S OL2‹‚g>}ÈuYJðó ¾‡3oø¾„Aÿìƒöi¼t…|øzgålnÏ*†!¸12nÀåœGå®6èßàµfãRψsòLOˆÒäùÙ;Ô4© H ˆü '8|µXœ‘ £b+ÇõŒKâ•ÕpØi›\€èÊ}Bc—. íÄfïŒXöñ¦ìŒ˜= °v|èYU»„ÿl÷ùˆ_{h`¢æmò½×ôDbãÏêµ¾Œ-7~Põ–—y™Ïå®öà,§1㻸~§D-sȆ•P@‹¾¸ð¬žÔLÊB¼œLɺÄ~fµ¢úÐ'šáf¹EÎoΈKþY¸´`…ˆ ÿEÀ‡ > Vüú§ªW/…¯.etÚ¿"öì)TÑæŸ†…*W²léò%L–*Ò[8óßM”35äŒ#%Ê1zÆL©hÉ 8•⬩‚ž½VDˆ ¤–0aµ„óE°•> !þIÍ—O¿ùþI0«RŸB¸ EÈ•›ðŸ>¹ C„¨ùž_¾úÖ*Ì÷!ßX¼úÿ®Xañ¥—^"(Y!¥ƒV´ZÐ °#ˆpÅÅ¿_ÿmìU±È"ˆì©€b3&îܺ]òœwÔæM¿6"m‰t¨BžÅç<ꜧNå¿QÖœg/" ­ZY°€õŸ°À²ý dY jͲ_ÿîÝ•"Ý5å_ˆy-ö’5;øìbp!6ÖYs9ÆZd“ý#DeÿlÙA70¤> "‘÷ýƒZj-äH RI Ù¶Š)Æ4“ 3ÕäW‹:ôTJ0×Ór1 ÈSÓñæœSðƒ"ÿpÇÕ?Í€gäa‘Â#•=!TyÝa ù÷c ˆP^ø!&ÿÜ<ôŒÕW-@0_ès˜ydáÅ¥cª,™d $Yd>(´€e„6Ú ¨9ñ.¸ Z/Uâ #)t¢Š•Zª’‹= WÒIá´œJ) …¨¡þsRJ=ò˜“tÊiO*èx}ÛY „WÏÔÁ? òAŒÆ&šPñ5V”×™'"‹‰€EÍiÖXe¶ Ÿ~/ì÷<û• =eZa"0¶Â+>P²çJüãÃA „À saªð¢¨B.äâ‘dÁv7T@RŒ—*œ"mNÙ´éB >Õ’¬*ú)Q TªkÌ=&¡¤=X©O³Ú½R H¾ñÿ a­yÂ<4Û|‚Í€™Õ²qqùÏï:F—>¹ðE϶ÿ¨Ù‚<òüƒ›Õ¢¤V ¡ÓM‹ÞôB-Ð\¦±ÊæµÐEˆ­ÊBÿ%6Ò´‡Û‚¶Ü£ôÔ¹üCßÏñÙ‰ÙÖäY¦Ð@>PEÙ ¥Á+«UÔ†¿ªý“4Ï\c"`^>ƒû=>¦%‰/8¦Ð-4ã_=ÝT±âÈ¡8ÓŒ~ ”ý!ׄÿ2C´Rï’Z¡yÈjÿØÝ=vÇ­œ@i¸–±œ°½ª\C¦½è‡t*¡kò(…Ø va ›J.±Êü‰¼úÇ(„ ðátݾÚð '¬†5B¸Æ‚ ––¼å£E _ßô6>’”¨94œáÒ÷0’ç&®JQ[åœN='9c>þ× %)$N <ã=F'\Ët8LàâR¤¬-DZyÒþ2¸ÌjZÈfH¸×9ÆOZ[ˆž ¢Èù€l–Á>„ dÁ”ðA9„šW\nÐ(X*0Dµh‰0º ?Œ¨Êëï<+ÜMìQ? ™äÿ7¬¢X©h²’-òrUÐé˜.C€ìdŒÂˆKд3ŠŽ´£ ”Ö­2‘Ä- qÝ}ÀIsÁ% iú‡¸s&ü($-YìüdÃâUF‘’B×ÒHäYHPi³!&5¶Ãëi¤†e>Ê€še ¦Ì *KTDµè툪 ŸCº#ÚŠ³¸\DU=Ç$ÊYJR˜ò8›ØTQtœáŒ¸|Œ€H°@VŒ$©Ž4[H ب§ý£ ' Yʘð]¯]øÒ‚¤iI=\:ÐâS'?%¨ iò°ê'²E€<†0*¹.~¢&Ö‹ž@‚ P úÿp«BøÁQ⮺ÑË(éªÄ•ìu¡*Ùë+AºËNÕ'öÙN¼˜1—èÏ~ŽEéc56±ë ÉHáùBÀžŽL[àN› 4œY©@EX:ßE t(/}QI•&¨9ÆG%§ÅLdÖ5Vw^‚A–ìÚ^HˆüYµ ‡R‘è½"¦B„!ºÇÌM·YÕ¥ Kº%¸âí=Ý}Ë?æšV  …á‡àTÅÀ©78P´‡QŒ¢ª¥°¯$¹\ ¬žÒQŽJ‡¿u Tìá&D¼< ÝMé!¬p-dÑÜi›Ö’]ÇY €fÔ)-º h,Q0ÏaÂ4—Ùþ¢4^òÿ:±zU=1ˆA*áä<-P!ð„g ^ s/ÖUhÑ]Ø›æ1ƒ.Ä¿ƒ‹‘ãÚ,DÌU!˜#¦Ò‹0)sJ–$9I Ì]z&-¸‚Â1O!U¶ÔŸZˆd |n? LIÍâ,ä°`³òØÝv­ 'DêTº…Á||XC÷Ñ‘c· dz“±ªBZO±…M^ÃE›8©änzAиDW#"ÀR‘&à`§By%Eêt¡û»Yÿ®ÔOVoùVâÀÁ’%…]ìßÖßÁA®Øž²_¨&•Åtõ3'´ÙØÀkqkttéL6Þ.¥Ö†ª8jcèÿ¢{|ØÃæ v¦×½‹O’é­;Ýéî•w [«Z!‚_¨«É­adòÜÀW )8”‹—T@Õ}¤J²Ój˜”¶=_EÛ K\³Qµ$\®!F14ë²rÅ Ùä‚bKaX"!XS´O€mÑà8 °;ÿ¥Â‹¹­FîôŠ ‡›hj¹aÄ’ŠpéÆÄ+V÷ÔÛãÍK¼’± ²‚ÅôûÅ ù$'žï‚ŸÚÔŸíÙ)pb"BÕ(µ¯ þ¹—SáEZ{¯&ÞÛÀ’Êí—ÆMÒÄÊùÀUIô§_Å£ÜGÿÝ¥ú¯ Ë+€@_h·óÿ’.7çPóž6°ÂtòóaŒ. 5!FO4‡ôr[u¢2–\HÙ¦îBöªøF cŽZÓ+©¡$@Pü£¾ÝþÁ¹«DH2õ!.!µŸ]áÔ!÷c‚ñó´*í£M,C ì0£tEËoÈœóx}¬À’ú€@¸ˆí3–w»#èN–™œ… ˆÀi¥–Ö,€6¡ÖE•b|ÈB˜ËJ‹K4Èž Ä­À›ñ¸¯D2Ã3üƒÝ@йÄ+ ÁòUˆü@´Â©QŸÜÑ]Kø øÑÚÙõŠ«Éݫ͚ÚeÇڅߥ”ˆ=@…žÇZ°Ä@îÿÆâ…ù¡Üß•Œ~õÇl€è#h^PÍÉíDM%¶1M ø€0FºÀNº¬DØ ÓШ„ ¤›E,D·m ÕqMž(DxpL->ÌŠÇí]†JC3@C+„€!|.àÉ.ÄöÅ Ù©š ¡Ù­D&Ú ¡(¶R`•ÜáØƒŽèFbJÈPG¦¼JpPØuÜ@ !ÂXàŒMí舎¶N ,´ÅцÀàP€:*Ä`öMb'â „“;.„Ý…ÿÙm¢ÚEEà˜?‚˜œ$ˆ ¤œ0@žG0aÏéH‰K ‹$GM@dã)^ä"P‚´Ý-Ê\„-U-H.U·èTM„ˆÕ‰ …ºhÓ<`ÐôË]0]´°FKØ^e$Hƒ€£J„x C.D3âdä$ ‚G+ ‚CàB$‚@+€Àô¥]¯H_ô•L€1­„VÒ<ÆD”ET d‘EœD ˆýcá1B’D*2ÞE•ÏM̃Ðe*No DîE>,€¬@bØu ™A[u¬D¶‡JhMº<¦º@¦JK8FLÚÔy£AÚ@8’‘BØÿ‹O*Ä6å¢aFe@Cx¼ø-$¹àÀ¥Â(ÔÄé Á™ZÜÅÄI܆ŸÞ±„ôa¥œ|Ow Ix¤œ gœ,„TüÃ𣮹e€Áˆþ …â!#ÌD ÔÄvÖ%œ=E*ÅLhÞyÔßàŸA†K ƒ½ˆgŽNáÇ¡äj¸QáS4ÊKªì`MK°Q îMj@ âB<Ã2€¦’,Ã% "W\‚ ©A +I*ˆÇQ€!€(Ý@ˆÚcÞ©#Û§VÚ Þñ&þC]e,g]Á¨~×YÆ‘TL@KÔ„Õ …ŽhÀv‚gÅ i™Øe¸¨@™°ÿD**©P”LÈ„"XÒË#˜%°XͶ˜Ž@`ØC^¤…chšñ!ˆczɺņդ­ ‹ „ž gŽ Jø‚O*Ƀ’Ç}rŽ Á/`Þ0#LÀ-(Ä A €è$Þ £Î‘¬™ÁÕ(*\t­èV’Þ|ÀŒ–—Ztªy|—¨.D]ñ(r&çB°¥‚=ɱ"=Ü¥BèÈ«†Ì<‹o”I Ðeƒi”>`!"@°‹TKᦛMXþ¹ #Ð@ã%iŠ¡Pj]æJX¦¦ËX]Æ"ÑSØxæJ( 0ƒ/4ƒƒŠÀÉÓF,Y¬Ñ?ÔÙ?Á»’À礂 ÿ\L")R¤K˜¨âSu*Œr*§jj¬JÄ t ‡ \i ,á«fgvþƒ°€“‚•ɶgÆú´é’ “U,¢›ˆ°jÞ’r)Î(D²šÉlÅÇ+@d^K¾Âa˜*Ô–m R€ž×„oé!=)D3Ðé?l£J -F#}›Ÿ¸=, ,JÀ«üýv¨BÐæ? !à‘I@‚‘-[‚z`Š|BuئØÂèÛ²­ÜìÛò¨T$Þ~#ëv.![VìÃúÅ•náàR¬Ph¬ZŒaä ¤vä›X¨ç35PÍ„ ©„†ŒX:qÒ³2íJ\ÿÐ/MmÅeÒìJlfKü¡Jl#Híƒ AšæÃ HíÀ«B|ˆ²2He\@¤Àª‡zÔØ^ÀBL€S1çw±Û"ÂõåÙVßB¯õÁmð–ÇŒ–QÞ V,IT,Å*˜_<“Bn­ªí\éKÌ„” A%Õ˜-šê_gBŽmÉÏp®FX6} šÆEB$‡°ÛPÕe„ rkg‚æ3(ɸz¨’4ƒ?Õ!»-„Ôа@ ˜êç$€TÖÂ2ôî òþò®0Þ\ÀHÀrÆ —Ç Ã° WŸ>ˆmØ>ÙÇ…Ø*Ù¢mõïï쌚êLÿ@œð¨‚±ûž/§ïú’gn4±sJ@½„GÚ´ €™Àѹç|ØœØ!ñ ˆÍ.„éªÄ]pÈÚ$jr’%Ù yM‚-Xù$.œë™Ë]ÀIìÎÁÔð@=¨­Bt¨/øÂ$ÀЯJ|ï#;§B@²nÐDØòC×v-ôY‹­(‹2©‚íñ/Ø~€ ¯„CÀr>qåt,8]iúžï£/.§ïþ`qh€•€_xñ ‡†Ë˜ aÐ:a¦³†Ÿ­qRk\À…³›Ó-D;í!"-Èh.Ähn…e´ÖŠ[>0‚Ó¼ò€+¸ÂÔƒK¤Âçÿ¡Ò¯$W2,“çBÀ.ÇN@(ñ “ÚwmK\ßYØŠ²¨‚-¯ò*ñ?ÃòKì2á6Ø,Ïr­nt.ç*ûJ€´®BxNsú£•èL€ýEà%¬1îñ‰6Õ³²ñ[øŽ]|.‚\ ñDZ’í!f—5aÎZÔ¼€ +<«­ÿmÎPÕÒ3=®B*?¯/N%kK”À<§*Lüf’]_ô¢m’eïCÏp¯µœX2XSì-gt-ëF?;§Tpx>œ‰Ä—’“d\CeÄIBpî¤ñ©Kܘ^äƒïà}ê‡X Ša ›âyt¦óXã3çç†øÿLàÈÜ?Á?¸ó!ÿC=Ü+K¤B=ìî-À?¸öLµk¿ö·ÌC xðƒ½„¯W‹sÆÉ‘ÚJœ5©Ú(7oö®Ä*;™Ý*±AB U³ïEÏu]«DÀg*D+4‰˜‹ÐÃwÛÃwF ùÀàtÕiÿò)ž\‚ *— ˆ²†5ã,¯ „›&ü^p72Ä Œ=&DZ˜‡mO òÂó?|ނ߫Öú‚Tî®BÀ-ÜB=ß#û~‹o·«Kà®K&U§ÈôZ §~¯sþ3%«ÄU3B‹ó2´å2.·8íL  "ú$XˆÅZhHäÏ¡DA ¹ŽlI '¡ÿ ÌRBºT†{ûÉþŒ€ô¸ZäB˜`z£f„„×DF5¢Ð˾ ÁK€øt YðèÔ(ƒ¯„cí? C-€€+€JÀlÛ9Œã”‡+D³Dnoõ\«HóêFÃÁ¨D›§ø#»8áòó,_užGzc4\'¯€R®ÀÓu„Àx+ÄxÓƒ Ô\H—Ðlͺ޷ñ'–X‰½¡-Ò%†•é¼Ù5V#AìžpÁNx‘ÈIêh³óB0x(øBx…/Œ‚œ‹vkêT*%ox»¾@4u°¶; îò¼ÓDÓWç« ñ ïúŠOò#³{µ§yK˜ÿ¯úJú3í3ŽÇT¾…_ JŽ÷¡ Š@ƒd®©WBøKDAü d𾑮=KëFnqU˜w›0@\¤…™ °Žö†®yi+ĽJ¥›Çùh[¸…£ûlW²á~K4e»Jò=€x·{-—ZÅíF'ï0ì0ð¾Dœ¨û™êŠ+?ûJ\©Ó·¤f/ÃT%åÛ?äBøÜ‡Š×ûho­€—1jÔÖR-„ïüKš6«¢0)«Ï` ŠÉ®JX’#tÀåÄ?0À˜9a˜ÇL€+ðÀ;+5ƒ#2Ê;µBøB*$€›ê-¤p$»6…ÿ‡÷9Ÿçÿ¶ ËW›(¿ÊZ÷(´«ÄÐ=òþ.K}òº¢«8¼3zÓ»xžÓ>ŒK±íç>„mR ¹ô©‡àQM|üBáGÂ/¼5 ’|x6¢Ø/@„ÆtKìžØÔ‘Ç_yíèLMá»J,µJ8xÑöî†^@¡Æ6¡ºBlÿƒ…/}‡+„qðBĽ#ÿäýcñÑ?C†* jhè_D‰)Vˆhqb… 0þ«Àq‚Å Bþû`åÉ Œ&Pt1!ÂóÎCHsæ?1A0ÔÊ‚!­ô}øŞĤô&æË‚^‹ô¨†ˆ’Oß?õ¹ø—ëÿŸ¾®"~Q\¡êìĬ­FܪuÅ?U (ý«;1ÂÝyõJ|µÀÇŠÿ0ØÊϤ½  H¬ññËÈSIDÂÕ­Ì/´ü7ÁUÄ $bÞúWâ‹Ô/ ”wPç?‡ _Ö–·ÆŒþIøwáÃ!Göþðñ¤J‰;WÚŽ=±ñóÆ6—'¤`Áe”TDÔ°¢Ô‚Sé…°šu«‹¬^mÝ÷UD´h'¾Í÷Oû}­ÿâFô18¯‰êŠ@¢¼ˆÀ»þIðŸ[!.Dî#©'xø'´‰ˆh‰"*!"_|ù‰ná-¢IˆÅÑyÑ ˆ2èÆîÁÑÿ  8 "ç„”¨†.`‰”䨂à":)" &À(“’‹¨1æzBh¥&ŠI&‰Àôr$ÀŽ?”Bø§;{ºcª¨¢ŠhÇ&äia»ò°K°Dpá½_ÒRE®´\ZëɯîÛªˆˆx…U´Ë‡W"Ì.)9.ºþ‰/¢"n@1’Z²CÈ:„ìŸÉ(ªåŸÊþY&$2TñÞ. á‚[&àÍWZ2-"Õ"Z"ljXÀI"D†´-É 9û":ŠR8ß–¤J‰<ƒi¥.=Û˘¢!/% ͈’Jj¢6þ9aÎv$ÈN©Øº* DÿT"çãPÛrù ÿ„Гh.ÿ6}x…¿œ¸À¿^,¢dˇJνձ %‘¢Z¸åÅ^yýM×Å&@!ÿYíFc'*¦oŸ­6%…#Ò78’àg 2ºÈ£{¶¹s‡L¨1–£€’V" Áž5C÷y©Âó„ìlblyì û„ÖÌ'—ûu/®‚ ¥¢·&Zs­F –¨ÒGðû.º&¥h°¸ô :K ]qu¢zV•È€VcýV_jIq"Ï^\ñÛ–d&¶J°Ñ y:(ç_Â(iá aÑ%ß~Éh ZCé%Ä… Æ ó%r¡n6«^s)ª¨Ò€)©ðÄsÿ¼°ñdª<ü°òJ¢²âžhàýœ}éªýÄøÓçêo¢} 0"ø3Þ]ÊÏþ¹ðBÆ)rܱ ¨‡DñÅ?p‰ œhx‹ÑIDt”ÎT÷,‹ðFZáÈD€ˆQé@ÄîŒÒ–@ç3‹‰IÓ°Ts°…†XQN‚½8y'"×£‡Ò6½L%)!p‚Ö"’ ,MhyE¥$b·Üç)é×øä2ªŠñ;Púô—ˆP@ëÖD@F‘Çõï €•àŠÐ[ÿ ÁŠ€µ+ûÅŒX§öà R$HÚâˆp²U$²7ƹÁ 1üIùÿPÎ]f?—]Ò3‹ññDYM`ŠDv¸©Lå;hTÉ”ïl§àbÝìV¹¨ârK_XŠx”1† |ŸrÐ0÷ò>¿y‹ÿИ!$¼ˆ\d ÓßþÒ(«øb¾Y‚9ðêWÄÒ¤hZ2¬ Ö¨F6)Î=¢‹(ÄZGJdŠ|COŸ"7ËÛÚ#–ä°$!åÔäb’SI–Ó~N‹Îb± „`ØûôV ½W¾R"u“=´Ä—Ì/Yb|u–þ¬ImWãåKæ*¿9ˆ@˜º”¥´;§9'2¸ÿ\"²T¬ñšüÁ††àŠÈÝñ%/š£ÿŠ àÀõ ,¹à/~s{ÙÆ‰ì{Vá¾(6&C<(#)rTKNϬGˆÖˆÍTàßä°m:L£S©ˆ:‰®`µEH«º;[-¡€ÆÊ…(`Z,TÚ.¸z³‚€Q"5 »kI"£´9ž>ô¹”ˆú5£ôH›l2Êw ã°÷£Ð–Ú˜g"-G8p§!•ù%˜rZá Kë„<ÂýNëƹêÍú›Ì¶C” aœ¨t@DPë¸ ¼ hF09zÝAÒMq…¦Þ¤u«ž1ÄdˆˆpÇMNÁŠ$Q:|RâOdù´>š´Nµp…oM¸š?€=êÀÿ z²¶+`Ëž§½3ÅÊNhÖƒµñiØÓë;J«**û%è#P\ü xR"Ò®Íÿ YZÇì4´;5`äŽ ™Å HæZ‘ŠD¤±w}ê‡`« \(\ä<±;ÝÉÙY+‘¡æd³CÌ£•N ®År„J€j ØçÛq¸I~÷%]Zµ„$J‘W«Ò&ð*%Fõª×²Å<¹hÅ B4}@ <Á ¾B×'¦TO\q‹ùRÞ ³´x :‚xêÍPë³D+2B#C Ž,ï°ÍX…€ÒèõÖÈ2^+V~€D( CÜÌÜ<v¤êªBê8âºÿnç8²å(M¯Ú`*ìí*Š¢ì£À¤Ï)\iƪä—L¨ÔJšc®ø¥è!Ö{(O0ЍC"D.ä°dðN†@(!.B Ì0ÀüøO":®ïà‰Ì¢6V B^ÐŒjÚ",CBc2ŽÊ€‚à†®› ICX¥çb¯6,§2€ÒˆD†à\AWN¸â÷‚æv®‘8"«n`–L•¤Â †È)–Ç7HB!6À$¤mlŒOÈ®sR î’-øîôNÊ¢Œâò„:z¨ äaGÆôjMü .ˆ¢èoï$ŒH-$â—œE¿(O"$"ÿœEcþ¡µ±AôáÙìð#âq#£\#gqèþþ0dô‡d±DJ¤@@dêaÛ"¢l%J®…>¸¨72Qw²%ÀëN*l;øEÈ&‚6`ÕC,fMº¥1:'!tŒ$>@cZ”¨CâNù®p^ÂÆNè„ "âá¢D¶rAÀ¢ÌP*xÀˆ Ïþ¨¬6ª±Û‰V€Œ²™^€íô"bæf΀SÅ#bè^Àà¨ôcô1\²2º­rîÆòV…KITwp§úrG˜© ’œ œà)Ì£3ÿTb~ÀÒ bû¥m42÷Â…xt  ŒÂYŠâáA%g­Òæ–ÀltäìdGôe°¸…Õ,’1"^@¯r¡,ZábœÀøƒŠ\ÂYhR«Q„ÜÑ“bŽèœ²*ÝQ"†®ô ÀÈq"²²›&C"â+cC*#¶Æ’r,GS:e¥r2j¡ö n÷ É.Aí ‡PÔ'¹ðéò¥¢*®BÈÚ¯7.`SBà†;ÌÃ>÷m%PQ4äNÇbcT&:Ê‹zïî8O"ê<¢‹O@î3S,(¤lƒ°‚2¿ø£ç BDŒœÅBžr8Gtÿð^ #Ð8ÿ1d8)þ!+ÛŒ+ 1,Óö"š&¬,]¨"¢ÏÎh÷""DˆOÄSÍGøôan`ÉZÀ’ã$I’¨„ ïßBQ•”Ï>#©0Žh#A­%Tr.S 9“@"8`z¤§¿ B*ò*ÍOØþ…?~!>@…òœcOók(¥qe£Y† qÞÌ)GŽNô@óÀŒ*°kT"Hä§(ƒ:cÅšœG)§Ûf¥(€ø‚ôv|Cy,à†®ÈÓhf¨îÂJ­â)ô¡ýÖd]"`— ÷rKAî#ÉJÝbq á?[*lb| MÀYïeGŒ hZÿ?¥êt&™šHHô .’m?âBàmœ´†è>Q1ßêÔÐú aAÌ®0Y¥§ ˜•bö8böØ¢5‡$Âí4Cëƒ}¸ì) å&Be#þ$â8KÏòð8¹ iqèµ´@ÄÎTïΨöèìLÃ(‚R)£_'âS³ITƒÔì˜Éƒ(àpøÄ Å¢7òß@ÑjWqÍÛ(*2õ²WQ* >€dÿK ;ǃfl\ì¡<ìªLËô ·PzJóü¾â+¾,MD —Ü[÷n´Q¿Àˆ(ewx`ì°›ˆ3Åñ8‰Îi» E…“‡+õÑu»²U¾ÒCìLR-µšöu"8u"|¶`q)ÃB,Â*ßV-"`Æ7N@Ö „ìb‡À6€ä“%kð>¾ÐÊ~ÊŠ’ž$: ¯7ˆH)Ö ÏïLèZƒMØr¡'¢,@%OìY6W(·LPë£åþ\‚8cÎ$‚)P%'gwÛc2No"D„Dtw)'¨²éwÉÖìxìжýŠÔË\Àl7@y!J•â¤<øR’l²ýÿ®c?@*¬gðÔð)ôó1»4û¢ÔHb²&kÀ£þjÑ·4ÿKkÖ$î"ð´,æ£?úc(µb-Tn<”?8×-õpt¢!pæÄñP‘„3RŸ¥Î‡v5dksך*ur$øš^‹D€WªJ•Òá!Ù&’ÄN,,À,MNœ‡£ "×ågÐIÆ•B6aÊêúl E£ýBè¡æ!â)˜ ±0*$™-8?^3+vO›hŠ€‰!ÏYÞb®<7B¼•"vg‚àL×EUTkãB”ö:HGrê o×kרÇ`} 2(ŽqÃ#æ aæAùú2ÿâÇÄ0 7ùÊCV%)­> ,€¹T©c5‘ó!“zGHb1HRkLâïÂ#zÔF¯†?¬ÌÞ†­?%bÞÂnP®‰¿ˆ²ÒDÍ>Íä:¸ *û7j_bqh.Φ‰“Ó€•SR+5DVkwõÕFùU_ŽU§#nÇ™û8š]€šóbE î¢z‹/9†Ó*/,­LOÀ Ù<|)ajã—Å$¾%­BH(3§Ûy¢(îÕÂCˆF©;@î}»ââ·BßãOec+bsÿ¬:PÅS|Î)³x%âDÅz‹¢Ã¸g”U XCôl_u·˜ÊD¨——Y!–¹úx/ €/ÿ àpª±(œÇ­â*ÄŽÇÒ¬Õèa ZøÝ·¨»åJ% ­tÇ$h"{àEHP*ˆé¹ˆœbØè‹~-wC­Ñ¥úôO6¼Z"”R¬8Fc4ôØP©iV…9Mï%NoCHÄv;5S+•:çúõ,XH‹D„šÔ¯Â/Bˆ"±Éà 8Jì¤tÕÄÐ<.ó¦W©Þ>…„E [²¯dƒÇ¢î&B¢Î7©Ù„MÖmöä_ôaïôŸ…RàZ6X¹YV*+<·™Jà+k™]‡nE'b§ÎZ¢|k7D­ck#X¸'Œ[¤óšb…¨Ê¨y®[°ëÞNšcô!Íÿ¢ …/Ó¢š±=«Ä7‚&hZFv~ÃIZBJ‚ÚK’”,Ù%ö¾´£|^ó_!ËúT"Q¹?ÄSàÂ‚ŠÆ‡„Z¬]âqæŽjq⌧j£C^7¢÷‘Œ;dC¶Q£kSeE,ae`?¸’[N¤›ù°"•Wz°«»(h•jªwb[º*žbJƒÃ÷¢ä3êç$s²©î$xlwŽU½]"&±ç¿ÒÊÚ†[߃[!ï(¯òdãˆêR'"‹]µÑòš ¼¢e—€i÷C$•8Ûl®åú2Îø%”™hWª!(€¹æ¡L¡'kd5­è{Z<°æž÷d¬V»ËÔÝ„ÅÆÿ;C"¤„Úu¦3¤diNPø$޵ûZZ½‹ïF‰³ŸH;Þ·>ð÷(ßÂ(ûC̯QÓ-‚ížÈ7 ‚^ Y¤rÐѸ]eUΈ9‡àÑ2,kôÎzŽ˜E¤áiý‹vaÝ)Hê2,LU¥y½˜Ì/û…OZAƒ›©y¬òaÀ9»«ã®Â}ÕêWL°Æ;ãÚ½Å7¦äW‚#$æ‰ä°2»" ·×¤ã€Ü" ˺¸Î‘ÁŸEÃö1¿RvÀ^³íà=$£GDD,§¸yæ6’sâû"B(¯[vÏû¥ºÿ8´®œGˆ8JØøDa¾™ý$Î¥­Â»É0aŒ8hþWp~ÆqÞ¶t^ò«Kßý¯’:ˆ 7)B¥p°ã$½nˆRC“œŠ8F’zÇ(Œ Àö}"DÝ1p{ÚzYÃhÝËwî—+ð^q4í+Úš,UGÓXH#þ‹†¯çM„ž~„n3“w¨b©ÙCáÄÁ®mÄî°‚(¦CÜÞØ&adç·ŠÚ'‚h°Ûë¸^¼!ô2# YUÒâ$Km8ŠèïOQôãˆÖ½ŠâŸ@ ˆéûwP`¾ Ñ yÿ^8tàP Æ Aþ0ðÏU=®2šü72J•)ÖSérˆÀ#ÿ3ÊL„CÿR¥T ÏTA¤ò… ™! H˜:ØtÈÒ!nüˆÐÊPÁˆ"º¡oÞ¼-èÑ 6—ÁlEä3ÛÂ^ˆ(!råÊ÷AßD”"è A¯…†³s?ØÕ—ëà J˜p¡Â„>\x|yò¿Çÿ&pîÜy±½ÐÒ›÷õ?zÍf<»o®wi;qrÅ?܈tÑõŸ!† O2bôEGbp€áŸƒ$A‚Dy¡Þ‘%3ÒüS`MñáQzw³žzð8…þê“gÑŒ>}ù’iˆjÔ2) ´€‹7 BV\iÕ "b•e–så£>C¬@Éÿ o•‚öD‘O‡xå#‚>„Å =r˜O.I°d’ý#Yd” $#Œ“UvAdž1$ehÅâ! ¦Zj¬… —=g5”bl‰)ôÏ/ˆü²‚¸9„ˆeé•>ç=ÿ ''¼Ð\Eÿ<Çæ?AÐQw×uW“H24žJ,•§ÒM#i'Ð.™d}>u(QE¥R‹RM-…„p>*Ü­Œ‚Œ­èSP§œR -œ0’æeå XèD` >˜D"P²Àôœ ˜Yg©˜‹‰±(—õØã›Õ8£±54ãf1«•^hApšk¬ý#—@Nü³ é“¢ÿCúà¦Ï ¿üS%p+”ë•c'1Ä,#°0QE4×&I<ü³ï¾(‰’y2:ÓKà½ôgyâe” £'”|îùÔÅï9Äh-þ5Åq~ê÷Ï£)"£qa¹œÆà†F8e+¾åêYQÜü²®ðÁX'èŠÖ\*z¹˜@ ÛŒ5Æ´±JËXÁgÁ6t"Š˜keëзÿÄ&иáÆoÿ q‹ 9ĬC!02O½Ñ]„u¹bà­÷ gç·z0¥^Mß ªçÀß7SPŸT Q:ÁWË?J%ÕSå׊0ÀXª—\Xc•B>Q¤Ìÿ%"è—YAw n¹ 2¤%:X—¯!lFl³2Û£³—ŸôŒ\VY ]™Ì¢bhýó»˜ï~ýî/ãžëк *Dk—Æk=#W GÜ›Qtì]Owüæ½/H5 ú÷L¼’y Cü’!ÐD€& ã®÷ÈYLQ£UÎö¦@?HÙç6•/¥Ìd! ‹Y\¡q á¯@D>Z¥+'pˆCl‹itEzDÁ.Á*^FŽw Œ-xQâ—ò1–\7eT2ëë(z×ùó¯stc“¢¼¬  m–IêêÉÿ“ÐÁ$ň.Lê4TöT™=¸¶!nÕn6Eˆ[½äVwu&Ô*ijþ‘>¹à^Ó^ EÌ:€#%¹Ž›`ú~…ön.[ò<à”´êA˜þÚ8¹o•¨BÜm¥ÒG 4ÕrúzÆ\ÍIR"„$p:¥B©J×ûD2RýDB왋P‚=’ÉzXXº†§p hXóÁßÙ³ªÜ2Œa|u²ß}É0ÏâïLúË´ ÁëûÇ*kÙè`6M/øˆ3='ôMÏõ8æ¾äGÚ Êìpž"ÔoÎ6œ=‰\‹ªâÜ¢¡0Ä R3\ ÿI6V¢AB i³t5B©rînÆe%FöS{NÜu‚DX@SOvh”3bBz)Á¹Vk²-‚2i!^H¬þò3;5,Øâú(›ËS:GXF^„¼õY ï³›2÷’Ðn$<Ouí7ó¤¤=!žÏk}¨2*#ÃqŒŠsT¼àx1þ=lì%„à.ÔX#5[|l¥°ý£Ÿ)“¥,]mØ#CèÂxH‡ >¢{ãIBb÷®Æz'¤âïÚ‚5¤4BˆXJÅ#ó¨,Öôf  :ÐÁ¶=n‹x¦ßæ—@¬stŽ“—šdĉJ&7×2ÚPÿ EçI$@ d:¸3ìËðbF޲ á$Ïžp&¦Ìª ‡5¬gs3Y #wñìM™\+Õ Õò"UÏzÖ[y™EÊ_4Ÿ -€ì?d¾¦dÀÍÑ^Ó à€æ@ç¥vÖÛ>o»Exo Mºé÷¾au¯„ÝØT”Ä䈱y çÞ–sHn™çCT %8{ Ó¡ xw¢ÂЮHmV¿Ú°ÝZsamdÙóB€†j ÒHe¤¨Ç©ÞSÓ‚œà­Ì*w~êýŽ¿É1©X2Íøo1ò6ÈäÕ„¯Ëb;Ûöûu`úyÕá x#'ÈnÎdÝg²ÿní‘…r@ï¢(›“[ºE)Fo†`&¸‚$öIàÒ¶r\evÎÕpG.w‘"'ÈDïô5b ­àPîR<û €$6Äo¾'\Ö²1°©!/ÿõ~c¡fÍæq÷ð77`•g&ñ,axc˜å¨LÜ1nzòƒ?9è†s1í±8uµPw´76ÔZÑ3þF\8I4uQHB6. 6kWUµƒRô5ïô ##Ug#O6,·F†! Ìò~1–i¨Q-D"§± ŒWÍ&s!3·&•õ9`“÷±RÏ¡sûggð&/ÐRnr7"qÿ€!a?œUZè6† ¸Zhˆ†#1c1Â!’6{·×#`5 R‡vh%Ù¥‚‚ÈH?ˆúp3Ý¢"ªÓ$Mrߨ­ s—}(,aðˆˆò0ã7~™vò€+ŒÇo-`ÍŠ[„ò@s@ð7'mp`™‡ÑqmÓ!‹p’Lñ>n¤÷maZ%A0é8BŒs1ÃX1•‚w›)s,º7$¢æ2 ÷Oµ!wáO¤CjjuÍ×|2Òe3!­ƒB€9ùA#ܧ‘×SÔ3% ø~1ÿÀ2•&A¡ˆ4ç„!`Š¥˜–@ÿ ^P X` –0ã¥A€m:wš——gh€ÿÀ9e£‡€¼xn&1ÿ03pv†¨¯§(Iu6“vŒÄ"&7TÅBœrvm×+ÔØv ·+4P܈3©£à¸1( þTŠX”85h7‘4P pÄ RYIsO8y`Š÷‡SŸp Ñ–ÙÖ–€h‰z² G׋è–FFu!©G»µ[‰‰wº÷t˜:%ˆ2ÒÕp{ØvaÅ-ÜRöp"7ó+Ä!*ø’ú@ ˆ¸9Ëyš&AÉ¡†Ý—•ù„ÿ ¨×–!‹±(mñI 'ám”†Éd ‹8Eè¶[ 3 ¸Á:;@€2§MuGLÃk;´*䶨vn÷Ò—߈Z²j%~%U!зptŸ…kºE ¶… 7±³ë!JÃs4XGJò^9é¶zžßb¹—‹¨+¸¹ÒBÃÛB"`0‹n(0¥{ºÏÛ}©[¸†¸‘rn1É#|UÑN6ãWºe¾ú5{¹ˆ±´é “ÓH¹‡B£1=Ëk³² ½„†ô«kÒ+¸W ÒD72/JØ«r7P+C{ÿ3¸‹3L[² !†‘2JÔ-‚"0©V"ª¢¼.k³ ˜>Z¿ Kh„[¿Ú—šq=“¡ÂàW"x±Uõ»–Y¼Ä»´©cc:üuV¥OXƒ€ágœqš°!ü.Þ–¿! 8€3e4_Ñ3@“ÀܘWü‚ \¼‚Ø!ž‰¼.ÙÅ0ÔN-à6‹вEé:ª‘:·qúû¼(|=ÈÇq cÅVC]%Pê!Ø#}j…¹a6¸$&'¼Ü¢:5£+d‘—ó§k|Äé¸`XP”W ÄH¬tÀ“{œŒ@¢Œ©ИCBvÄuO6VÿÈ qÂû!ïpz‘§ÒU—ž:yBmЬ; ư  ütðf§9Â$üˆF` gÂÊì`È‘š“A£,¨¬Ê{1Å#˜ºZ²ï¤Qa…ȹ,¯ŠÔ-A"Á B-` ‚¡;dÑ:Ê>z­é(AÍaKǦ[Ö°ÍAʰÇò­œ‰„±e²H…|cæ|XéªËÍwžr±-áÙe¬ÑM ö\ÏM Ì+ÍÒš© ÍÐÿÊc²Íð7€\l Æ…LÂX¬¾yÑiöä΃¥~2d¥Q $-`ÒmPÌôÌÔ--Õ¨7Ð}¤ °Í,,ÿÓ£,/{d<ÑY!䂵œÅB­‚KëÑtqž&²~¼“!P-õLKÐg<Õ{ÍׄFYÝͱշӿÅP>@ìÓ‘dÑÌ’¹°æešçYîŒ-q4JâP-Ìôl &݉Ð×ïò°ñ¹`ŸÕLeUí¢Ù<&ÚKñשÌÐòZ‘’e—µ“…¼´y‘6–¨™ÛÅ[ÖÖ—¨M@v} ×1û¬Eù C0³¹P³£Ý}&5ÊÞÛ“©¤œÊ£¼¹m"²lÑ_VJDÜ/¨D¿mÜ” KJM=¢!ÒÙ£BøŒ×ò°qÊ/ð EéÿY§inF p\¸¦Å0„Õ1­Õ¨<&ã Ñ@3ÑàÂÞ9ƒËLÛ§ÂLÙ}~H‚$÷|+d+M 0®ÏšGÐ 8õ±éH ˜‡œ\¸ÝZ «œ¢¬Õq Yý×ß=Ê^Bvé½OÂÛÛ![cBÙ4üÛžIßI½!JMó,j†+1næ¨MÝlÐsÿ0Íd¸C7ÉI†ábŸ έaá*ŒÐÚŒÕòÅúðƒZSCí!†n·ž¨Ö-_ÓÎÔ3P%¢ta f–Þf¾E-P£ -ZY>—ƒX@zƒqÒ¡Ú{GÒVÄÙ xÎÿ­7ÞÚ©Œ©©,áK.Ó«Ìy±2QÞN "ñVnc/ØÑªs¥ØÃ$s±!ÍžÍ×ZEæM\¡°dh WÐfñf0 ¾wL€q0îÂJW^ÒÖÆ§‰œ„Ö ¥gÐqjÊ{<Ó¢Þå­ë‰U3CÈ6éŠzñïÓ¸HKKÈØÒe A´ì\â͇B•Î.žé'Àò0ÝJ÷ lpys3 à®pAÐîèF;%QòZ²€æök <'®kvNh¥ªkðã!ëp¥½wµ.Ó©™ßš».|HHÆßþNÜñ­L_â­¤~yXûÄ”C˜&¸ÿÏyÀºÖ 0ÂÍ‘ <БRó[m/ ³ªÅª8mG@¤°òtÎ&9ŸƒuImÿ.W0¡uSÀÚ§ÛÝœÕÞ<Þæ]Ÿª¡+NȲœ¾à’å¿}ðèwQr$;IÙ¦bO#Hý%âÇo¡ÈúÁôy÷‰5G]$Ln¦ñ9—AL’÷é` §êst@Š%6<@tÓ–UhYÒ& +E€ŸŽŸg7˜÷Ÿhg.Z£Wx€‹Ôz=©|ï¾TؘE?vQnðý!"¾¹Æ~¥&—(îžìílIAoÞ¿óNü“—ÿP¡¼Gä±8øáßÄ(^¬hñ߃J@âƒÆ _¼øçÊURïßP:8Rñß -xqà@ EšTé‰Lÿ9zÀ€«©2]ÕsõÏÀÅ­õ¶•©4é„[ÿ ü# ÄŒÖB˜À£¶h1¯=¾ÿBLüBb¾ÁQ>äûG8׿\ùþþýg2ÆôB\!óeË•dP¡Ã#÷>$8Aß¿ +y¡ÑâÈ\¾‰lj%{¾"Áæî z™I3Ê"›Ÿl>ÒОÓRì9Ñs±Ý“ mÞTkk¦S lÍöŸúÿ‰_½{g4aâ-¶ŒÐ’€Ûv­}ºvõžh ¾ûçÃBÈ'Š|C¬®( ôË/‰&â«2Š*Ì 3Í.ó«³yôb¡…‡º§´{JüÇ´ÐèùGŒ8"»‰,â¨8 àA·J*î ^ˆñŸ-²í˜H9掰(;žªc Jñ=+)bª'§ÎS¼ó ¨'Ì­¾S«õºË #ö(*K.¶ € ¬[à‚Ó¾ î ‘¼NèzìùçÁ <,±‰# 0¿BtÑ'ú«¯È6« ³ ñyZ(ñ :íTžƒìùÀÅŽN¥ˆ#7z WÎÒiGÛ,Š-ƒ°Í¶ÿìxžNâi" Ÿ{J»Ö0ªò©d¯ìn:-³ª«3Ÿ*<,ËlY¥`(®Êúg-²þ‘k.êbäuO`‘CÉCð°DA{1ƒÔϤÚÅ Ãy>3HDJñÄOKKñú|qÆðVuéÜHÐ ƒ\3€í$cÛȶ¯bjn;àPzÒÖBê¦C»ðVÖ–Y÷´ ‹*™¢ÊL®Ìœù=«dúJ>ùH0K¾9åZË,sÏàCu ú'†È $pAD³Ò~eñ"˺ηRÎøú0¯åùô5:µÈ!‚.Úm6Û.âm$Ü–‰"Z™´Øˆ›»­ hÒ æÿí–kn9•wr*¨b/b9<í0 %fŒHa*s­ÎËÖ<1 pjåÌÉ|ü«z£(ÍlU?³gúÜŠ/Ü;÷;kéø>0h݉ú|·@ E”¢3ô( †”/Bø Mfè´Mût6ŠJ@kž)YÕH'ŽD o‹}¤u¤â(òÛâ“3À9ž¤; ¨Ö¦sœZͯ3 ç,¿èŒìŽ5ŠWØ•ódÉ:N Ó謤º«ehh¡S\ÎR:•ëNŒØA2ÌH¤.ˆ1T££¾pÍB'ìd–'Ïä¥!Rˆ§&B€#€¹!D5`ï(¼ làä=Þàä~;ŠqŽÿ4Äí$6äKÜDZs“¢ *šÓ›sºç$^ hxœVðG‘2©§€úÓ˜(•©P9¬KÉD²2Ç8¦ÉNòéV|òcs•k.yʺòBÊ/0XÚ½äå5R_)ˆŸþU™•íƒÁ4ÕIŽÛDËDäB¨ÖV.n²\œ¶.>Ñÿƒ²ŒfI¼Ì4’]{qa€òBւ襡ÍZBZô"sÀV•*½¹dG¯¬pDÂÊv"]À§ö›Fÿ±äò–W®xµÂ÷jÅB6J!Ù ², 98…(ÛÁ/TÆœæÌù’²ÔZ¦{Ôá/ÉÙZcj­´®¦6J‹f_ÑðYôØç6áÇ>EÛ0#nñ}||z»èƒ¯]F3Sk$=û¯ÿÇl/œqÀ£‹°~:ÇrÍ€ê*ˆý¸">JõDT}DÂFô"­µq†0„Zy·5eJHæ·8¤ ['¿ivx˜#•Î>¥gÐ4ÿv2 Lj‹GgäÑŠ5¹äZisû"ìKhº#›†´ÅM"@ÄÖ•â§±Py…Ì·¿ÉôÃPàÚt‰ä‘MÓ°†8¾è 1ð¡"74»IU÷Î[k#¬¬{%¬ Ü>îíÄí®^‚­T¥gÙ¤uÜVZ>ÙÒú´:9š½Bó3•G¥[r9ga2*•™(Å?B3 \ øøÇ(0p[|` ÐG ©ÞÛKý«‘+€D$"'òðT镆†`?ø+€`¯G;I¹‘Š hlys`«Ç2g¯ÁŠÛ²à–”_²&Xv_ÉŠåž­(SØ>ã˜ÿÔl1»ü:½özÈ´xžM¨3ü.,Òy½½Õÿ¯É‰ˆúX°!Qã” °¡Q@yµ±"«M‘@Ú 8éÁ½ Ô=’žMûºMÊÈ}» xâC;‰KŠ +C;¸Ë€òÊ^ÙŠ‰¨)“µ³µÓ£ˆ,›{Ò‚¼þ¢’‰?m’¿lY´ÌNŠ«ýÜÏ ²#‚ MàˆM£»ã똳3€[ŸT2¯Úp€>ÜdW›¨†“8!Ö‰œÃ`¡¸Eé ¢‘2Š´ŒEgr©°–Wü%l £j9Ë0j ìAF±€&q#è! ˜‡€ÚqT@RÎ|!ÈDÒK’µ8Ò¨ž¯‹+ + «®)¥!œp$¢D5VAÊœ>W»€ —¶9WÀ€¸“Ê Ý͈2U1¥¡K0û2âtœ  -ª$È13å QÎQ3ûs<ÐQ¦“9•ÂÅ“2)ð!ù ÿ,éÿÿ H° Áƒ*\Èp ?~"Z`aƒ ýCDáÆ? ­"lÕê &¨œ7ïß¼%~ø¸q‹æ1ˆÈã ÿ$ü3„èß‚D¶Øqé¿¥7Hž|Zò$¢ %H °ß‚ˆ >hï_¾øhȶ­Û·pãÊk0¢>DþQÂ%¤à] C )Ò‚IC&dá’Q¬+Šþ‚ïÆ‡—‡~¼QáƒÐQ?Z}º´`¥­~XXJØiÖXóF8zõß{üfþ³W _µ=ðó@·¸ñãÈ“ä—ïá›yû8Q$Ò²gÿ'’bFÀÿÿcóDKFô}X?q¢Œ&„ø§x#bÍo5ôY#É#YðC¡åuƒVÿ\ðYEIm°@nfÙ“=e•…?Êe¨á†Ç%†êÃ>FM&4t„"†Ü`A_àCÙ?£„S()¦KÿœÀØôÄ '˜Õÿ„_~)æ‹ü­'GC2Ä@?P…¥H4)hP¶²Àp&PDh¥¹†ÅÃá›pÆI‡iÎ ‰xáb>ÐD0]O7â2™0:™@­õAX%F’ÿгÓKå4PxÜydÛ3ý—Ïg¶U·”Vˆ”åt›…t˜FšncÿprÖjë­g17"s­`^ÿxE"ó „BslA«ýÇ¢z;íä<’dÞ´°A&u¦Xä3Óz¡æ•‹ ýJC ’k'EÁ©mðÃUXí¶Ûo€æ­üáœlšEPÁÍ}8Bfíºâ ²-@‰¼-öuMÿ@ƒ‹0BÃ1¢ˆHBNó”pB‘Bþ_Éã#-mzæ äeŒÄ”!yY°ÀR‚Ѩ.SHˆ¦)HÜ%—D Y…üàÖ°C-ÌÏÂT ¬5]$ ”ðÁ^‡mˆ¹~XÔ 7DÐtiÔq÷Ï5Ш˱ºBD@"4ÏÃcÉÿÓ#‘¡ì·ßóÄßÈ;ýc~Ç$Фº!£Ïy¤Z°7 ô½ÿ¸;!­à34v HpÛC¿M˜O>ˆ'†a…%"Ðb<ü¸™ûîáŽûÖ[|PÙ,ü@]ÃþÏ ¬àÔ\á >! ‘]ׯðŸ!óýߣL©ß÷¸Kz³ ùòȃAùYÂPŠ´A+¨þóÃÓX£!¸Ò.°™ìIt7€ÈÔ‚•æ8PaTCÖþ1Á¸élÒÀ·µ¯!ă¼JHˆ@S¹ž`¤(¥šL†ÂØJB™ KNà7ðHEºAîá7õÝC‡!À?ÿ@€#܃Œ°GKŽ€Ä HÀE¸hP$³”QˆNVüÇ€BÀ Hà@YÊþþ‘÷`Hufñë0H¢ØŽ#5h‚ƒiƒx¼Ð@<” Š yWÁº(PT%ƒi…öd›¼õ¨ê;Ÿ<7÷±ï:$@ð üC9ÀdàtÂ#² %Ü VŠ˜B=á™ B@D=E;ð£f’+Öщ¤Ž kGáäw»»`9èAƒo9Í‘ë€  0…#'qÞt€ö‘Ì6âÊnHCüp ™üÇ&JPVˆó¨!asƒ ¤h?¹Pðÿ ¨K*õ!`T䕚¸TДL5%(H àwLæîhµL9‘èxcûã@B`ÂN­¢ÒŠ6‚ˆçqä+‹œ B0“ù˜ìo5ŸïQDQ œl§: Ê ñˆ/‘mS9£€ ¡!¹Q?³¤?xI#ù„ªÝÓÀÕµ®9 æŠF ~ˆ`¤îtç®UT`cãÙä¡‚y5#’Ì]Œ‚ˆÈ([ùˆ`N"&üé†SA‘á?&¹7Šrˆ"M;Äœ~Ržâ?Ž R¶‰«œnèÃÒ/¹M ¸¸Ñž8W"PÅËŸ¢sÚ¢róˆÐÏ]+Êì!ÈÞÿ©u޼[Žï0Xežõ8ù"Øo;5 Ž ¶#Ëò0ò‘,2 IRDB%êÌRxË–ßZÀ·—𠈌5§A8¹Sòþã},(åP‹¤˜%q; ý>+´ZÈ)\¢Ř%¦âÃ+¦›l*€ˆ¹Z“¶²µÝ?„£Lß~ˆ¢½ý­rÆÒº¬=“xÍ¡íCôÁU #ÌMQ¶ò Úm‹„1’ þ„ }/ HK„š`à 9¬'ÑɲÉN2fíI JÖ¬`„0ª¡—!Xõ-Î ;©jñJÃH 3ahRWÚÞ ¶ fSn Ñá®·^“ƒ%\¢“ÿfîrÂÆ¦Ø²©‚%Ú%Z!}¤ðzOÙÈž" ˜­ç-i‰y¢> `Ç‘,B8I^Ö‡6Ô #ä·>y 9e_âÒg[±Å%ÓD#"É¢}kt \üÀŒjÔU¤:,/Îñ‘ïrç7¡Ù×lfȈ""}ü ƒ#üP[·l·™yØs[Iý‰Á°Ðz ÐÍ<²•­Žp‘äiAÖ©CyHv¡\çŽËM”¹„ÄäÜ­8÷†"2"ð%'%H(èç?j±?*/ƒFúÁбCÆ“®H¹f63¯e"Þæn-n*s°ÿa쇄(¸!DÀf'ŒZ³m€ÿ©È`l,ëagbÁ²À ròxÑãHA:ÊÄ]ð&5Ä©@|ºc"Né‚ÃAÒC0‘84£#p#À°?0›:6òO 0À0 ¯f"Õm4'Äq\ngmùÐ| AQqbrsæ5bÆ&€U±Fg¤V¼²}W9+à!–x¸€ qã'Ö„=ØC(`7‰2%à>~s,UzãÑ™„y˜ôc.1•‡ìÆhæt—AcÁBÁ):"ÌüA‰!PmøÀTKAeØÁ{ñ­’5!GnejvA#8G|ØGZó|iÑiˆ”0y70 ”|¼" Ø7àcX}è2-’/Xqš’%QT\¢.ÍP ¨”fsgË™Çt™¦*f|ø`„°º&İâH\ã+ájq}´ˆ}×GRGVMIF|‘(G–ˆÇfJhò1¦CC¦7:k:•u®–ÇI—zŽûŠÖ’­9wSHUˆ†gÈ(ø(&¤5¦r#g,ò26 ˆ<ªJª%qÆ;¾3“f¡;°ú¤Ûž»‡l¶Šä(À!¶·;±üy0y" 7p”ð3Hñ/£f"øF"°uSŠ!2P3ˆ;–òÖi:T9ÿ;yG^÷€œ¢$ySXNA—£D9T”uG0SBBqhPôºMQ Ñ É¨"~GPjµ»´[YKf×è’kf§‚l”ºBQÔø@ \<ÁõLv² ÃJ‰B/BhC¦Ìˆ~bu"5óí³>z^àeDé³åÄS’¶C“z°È½í3œ¬“ÝcˆÚ„ŒÀ**®B ±ŽÄ¨9ýtp®±xr0ýª¯[|±[|më&JêÀfvˆ¶K•»E¼q;'ýÂø“iÂl†¸<ØaòRï˜"0Iñ#Å<îh+3ãc/ DåÿÛ>iïÈ@ÄF§¦Èc╞‘‰3ða!Eòx'›|”=i!p‚`55Ø&8ɹ6Ë/¹ªf—“&·˜ÉÔ³JlDZµ ôÀäØ/l;r‚¸h›«}$ŽA BÂLqx„îµ"pªVs‰¶7äÓŠ5ŒÈå;–úŠ’ËÉeÉa= ®AX‘Y1‰CÍ Qé£1Ë0="fŒüÒ Q¾4ESù„ŠDCäS”öإȽ4ÿ‹’&ÀCfI§³KÀcéÝc:7Ùó`Ùg±2áY[()á™:˜Í pTr^…ŸÇk´¬ºïÉÚ³Ük-Ù;#8Q3»±{"òµvƒxÌvÇ:þ’ÑCQ¹""}vxCxxs¨â#ÓJ8-kDçÎ1É=wÎèDÎÔŠI’Fë˧}c³áK–,°I¹‘"€Ä N)3öÊ<1©WLƒÙew;­L¹C"f¼f]ÍF‘ùµc| æ–¹6rFéþ‚Äö3¡+b6×ýÙQÈSås#Öƒ…泑ÍÈïóç7N㑦ài:tÿÀ›\hN‡;TàE>~“ÞýxÞh92ö0.í†)økw> !ÁTƒy ­G†#@ÀÛÇ|[›q½Så¼ËɃ“Ìa± Рλ¼6‚HJá­Õ5Ñ´Û[ç½;±iÇÞLtR`#¬©\¢Œ—„•¥>‹ŽØ 1ã|Ú»9èï#- Š—ü퇑{‹äÂðÓÛÊQ—På’9ÿpp>šßG´“Û&/9GfÕ_\<;á á:âV‹ˆw‘0„È@Ë&”æXïKx.—‰ÝÄ2å$í0îŒÕs…>9ìs†¾Ó3Ý2Á]ÝŽ¸@œ–-ÐAÍ€;Ù )+ÿu†CÁÙqóø˜%þ+Ïï™3»ÛkÖWŽ[µ½Ë{Ø5[ÍVmAl«q]}h2rúpU¯Q\Žw TÁÈ6×~h«bfÈȬ/4ÙÕ9çiåó„ 1ÉC„œ7õç@ÜÃBdãÜ›sÑ/€öIþ|Þï-$æA$ùwÆöbŽ!âQö¤EU×óÈ€ÊdÕ4ž÷¾ËGJШkžḃMrNßlÉ;—¯pw<¿dŽÄÛ/¾ýƼm0$B0W~w#_©­=R¸Ü]е>èœXžg^D$J#ß2EÂ÷ô$HÝ‹6C+ï÷8Ä÷-5…Ý&‘?oÿhý$UEñŒWÞ`¡ºàΓl§‡èéÕæÿ`d=qQú!öÐʳŇÁ¯Qe±F üËGAƒýûGiÁŠ"P €H‚„>„ø7Ož<òîùG $C”)Q¸‡a¤J )Mþ`’ÃJ–1²dØ‚á¼ô2j,˜/߯-äý;1Ï^Ç”,PÊ;ñBê?(v̪‘>  -”@á_«ÿF!öoÙ¿kiÿ`ˆˆŸ>~yõ¥ŒÇ¯ï_•| 2ôûO_¼ï=ȱßÃÿûå70ðÝĆïVÈLØpg‚–ÿà—/o>Ò¥–fX ÂAÒ*ù!b°àŸÿYJ7,Jø0á_Fæ] ¹ôJeÆyüŸóç'iμY²ºÉ{,7a”㇂{ éÓ·q^‹ó@é¥lŠž!Õ÷'‚~`ÊhWúÿúGÿo 1K-dþf`®yëþÛk¡ÆP ±|þ¢ÌBÉ.,±x R¬²Ïü*¨¯ [í/ËôYˆ¡½³K6”<Œ1ÂÑâŒ3Â\«l0ÖP2k"Czã(«yä[ê‘þÑi%•fRºÀ¨#;(rn)ªÜ³'£ [(L¦æ¡‡3Ù“O9©é©;72¤ú&`Ä·ðü'|pY憅¢… mñ Æ:óÿk1åúFü !C©°xCL² ÃŒÆI•-0Ò^«±1~8+-/Ò<Ü0ÂXÀ"7ç±µ»çŽ;âž&Mª)¹PjIÊèD¥é¦+³»§º”šDÉ'†2 ¡PÚ+¿õš‚ª…´ lÍŸþ *„òã+7ù3K.†ÞJ‰¿ÙP´±L3 ÑÚÇ X¬CÉ\ì]ØT²½ó—Þƒ*$­Ãx^DiÅKUŒ8¥NAlm´ L#m òaõ¥)WûI Jp´ j%ð#J•ȃ}qÒÚ?~`2äÿ@F+0­Hsé‹ ™ÇÈ­Rû*‘¥ €Ã|˜À0Øã¡„*ôJ‡yF{{Ó[Ž8“ÄÀ‰/ƒ+ˆeb- ð#H"äyØjéK‰sŽ#’/>IJÃr¦I\ÒL4ÿNv YQòŽDA¹øÇê^jÙí7hŠ]é’ŸÜ*)Þbœ¸À5¬ô‡?7¸Aï€ñ ðbˆø‘ŠPjF«¤À¦E0Ǹ@_›eFƒ)ìye–A¤åkZ¥š¹f52bž˜ÃÝFq ,\ЧLå#=kŽ“`rœiФIÐá®Ü™Çs¡ÄˆÂ¹P÷:ú¶)gòø¬ ´h ™¶"ût«qW© s÷Á,„À«ÈÃfÃ! F•g#[½7˜¶eT†ÿÚ‹Àœ#†)‡L µaŒLå©j‰±ŒàC>ƒtæ+ ˆ!.BŸteÿ\ÿ CŽÓ,]Óš”-–r …&Ðbí7*!êÈ™ò¬n¯ØJ^ÁÔÕa˪*ŠoòØù(>ñIHê™®µ‚O‘ü‡ïþÙ ÍE7sÑÇDp»’MT bˆÛìêоþK¢)±k ·;]ê^æ{Þܪó·S¹Æ4ØØªRC)DDÀ!{jE+1„\ } YJH@÷œË˜³(¹¦æÔ(ô¨%OïôÊV¤„¯¥C|`›¢ &ÝT GBY2„qKÉ]H™$öég@gù>Pò»”˜…x¥‹dúR˜ê=%8lQ‰%°µìy ³1JAÞ:ª¤–£ÿ «r´Dï‰Ï«rp¬\ߺH+%¸"J\ö‘–ÙtW.ÙÒ–Énå‘ÁÞH~ŒB&Îñ¬Ý“RY‹N†,À,‚lÁžÿ(M!äUü8Y”H`?ÊiË3€A\M:w!t¹‹ôp|<º‘á@æZ¡ë¾ðºÞM§óñ^Jo2Í.[>¾5‡™AŒXØ&F‰Y$0¬0Ž}Y,VLã’Í:çuòù©é’†ÚÀ !x%¨;O˜Ú xÅ…÷la ‹`u„7×®;|¬Z~VôÈZ Ã]"l¬nœ/i»•…™Nw%QÁÔElëëÿu=¥ÎYnO–¢ÂåEùAŸÁv CÄ ä; ´‚"¾ª}þ‘âbi‘$ׄß{¶ùTpî.ÉC*CrN:Û†©ÿX%¾­nÓ\uØ«VTÒ¸Þ&¥>òa}Ÿ³Ë]c‘q¡(íV]Ê… 磰›×€Ù`ú’aAü%š‡áåà¢:ÔªÒêþ¬¦?ya¯Gk²õz/ áZ„5Ž_Þ`e+ÃÁª—·Xg6+0BaÈžbC;š©q~Å 2á W«!ÿèökY;ól`ò¾p:"s§ª{:>Yò|Æ%ÄŇYÊJPØëEÈ Í ¶cN¡­_lcÔ¦"ÿƒ˜ôÒ²ŸØÝDå=M#d‰„Û˜â7TXÓ(ZòôýÇX¾LÒ7Že_ý¸YºÃǵZfË[Þø˜³V–—yµ}ps˜ÑYTá‡ÅužVm=‚pJüÔ–¢±…@ ¼Ç(›·É±©¡ïj‘Èðž¾H²Þ[ÀÎ@5íIá[*<‘©Á¢i¯P¯”°€ ¨/³}À/B‰?J±ÿ©¬ÎjôX/q¶ìê!qS‰ÆC§Õ¢øk<`¿n³¹À¨°Ä¹ ¤Qœc$§±dB½6C:ÛøTX=†9¢QéÂÌH%ù±+é¡(N1OË}I¾UzŒÿ#󡱡îYÑÁ!œþ˜‘Yû¨2 ýX®A§V°>‹ÈŸ“ ’°2£ýj³Y:Ÿ¦B‰Õâ6ÛðÕZ-U ¹×Ò90B#t¹Ö¢U˜9‹òPŽôBÊ&ôÙCáÚs G‚âù•Œ 2¸Òº:;¹R›}‰Bž„Ã@9”C©5ô꘲̘2¹CÖ …X$ÄÛȸ…ª­ š£™ø™Âs#ÞÉ«ÄIÉC¿Mdˆ9˵N\-M¼¹OD‰=ÛG•¶þ ªÛ±Ÿ{E© "áÀŠ <³d`‹kh‹àBÊð$~³¨´ÿȈºÏˆ¡½Œ)PB”I› ¤¥ÃB‘*ðÈÀêŒ|›`œ+´—Pª¾8ŒØ`¥Àð˜¹(ï©–©'z¢|Ih»`¯Ñ¤Š[€ °^³²ê %‘  lDlJ  ø°þª½Q òhª¤t-•¼P…ø¶õËD}”¯oÃ<šÛ3ù;šÑô0 ŒØq“àKÿ|À!h‹ß!~ 4Ó Œ Y›ÂC™Ia%IÙ«E)%Rù‡)ãάX³ Ã\c•@ãеéÂÅicQeyÎz ÐÇ‚€²Èæê 8’$Ð æ±íÕ?þãA.¦y­£wtÊncˆK‚Àýê¯öXý€kicu±\ø Àˆfèäè…Êe¸Þä.îb˜Îë6(çYZ`öP w6å.>\wŽgnú×|P‘ø²Ì$¶`€WÅ»‹0£½ÄV'2Ù+X1JÉ Ÿ8£!M(F _dŠF ®¡„°¦dѦ.džZ¼¹ßý…’v›ÀõO¦ÜÖ}iÿSe߆é›nÂc^/ngQfˆÂ¦é›6l‚4lÞ 0K`«ˆ²ÂˆÉ¦æþh‘¨^¹½X±ê”ˆk*]É»d•¨è±Œæø®è “<×^Øv1¶æÁ\qo|åëÞfg¼îÏk”î7p†Ú2.ç å»vÚå6Üæ†nŠ1ëˆ@'àš˜À/ù4‹63 -»l&Ü‹°Ò줼–P¦ß±#Qq›ésfÔîoWU‰Œ.«QHnuU‘îØK¿_¨kÿD ØkQIòQÞk.ð ÞëÁ¾kßNç)g缆g§5¦ÕrÈîšfçsîPÀNn _rÿ‚P4øE axH‰È\eB‚(7ëÈò#;‡õŠù òS4Œ:Ö\‹ÝW ^>ù\°€Ôë§dˆ’þ‡'¾„"H\™Nð½–òºnáöô”0ðu¨…é+'pcøéîàŽ˜rT&eååés>óïf^3”H ¨…‰øðd=v³Q<ÖeXþ‡(Pöh!§¢Ê…Ûd”¨0!¨h°ëŠÞ€ØO¦$¦\¿þöj”øb€ Ú'‡ZÊ nv/ÞWàÁ–iŸîäšFð.®i3Vgþiä¶r1'Ü ‡îr~Š ¿VàVaØuÞ“!È…ðDÅq¾ÿžKh?fÃ(Š "Í¢`‘ðÍÁ³…ÝVï±Kø£ˆøþ Ëÿ¾ôÀðW½„‚p`$_nQO )g+~ò˜&ðWßô¨kQ¦ò¥­à†ð›fZ2W3Ž*§pzgpfð>îT‰…¯ah†„ ?£j㞃‰ñ iÃsÂ;õ¨õÓô‹OæbgÖÓkªLœü!Ùvˆ&w”¨í¿õçáR¯ùÀP÷¡ÿm,cá6uQ†c0õTGòÝŠ æ&¦_.p§eNzms%_rã @\^ã®ÿ¯B\E"~¶ù¥ÆÝ„FdÒ0ÿP^'+ÂsWPg!¨0ÍÃäÓ‡ðä¿‚æÊÇñåÉy(_ü“9o^ˆyô&Fqi%BJ—þ]²p’Ò?¤)ZÀ‡ ˜0|9é䟓_¿NnýퟄPþJ–¬ (ö ¨@k¶lYþµ=Y·†¶rÉæÍ‹p®]„*.blO¯ ½ÿÚÿ ¤W×lÞm5ê8o—UdîÛ¶³\¹”GÓ£;Ï^>—'[¥rØÌ—…V­ôI¨iÛ¦Lz¥ÿQÌa>Âf .H‰PßÇô浨ÙB&Â{äµ€ð¯EÎæ!|Š‹P%B E‡^Ú0ÞÇ‚L… DÆþBñÛürÑëßý^CF¸è]¥YkÈ–`c¥•˜Xu¥T\ÿTF×a‡–a.F˜E™EW_€=`»-ö¡„ŸYöcÍõÛj­¼âš0± !'°Ð 5wÒ <šxIÇ•Ò >À×ÝO•ÆsÉ3å?÷¼ ]úhyä‘+¬ Ê>œ4ÿžxe–GÉ+aþÓPFU…ŸV-…Ÿ×|ÅJ¨æ_ÂÙÓ'B`hž… ¨=k]…•=mØãŽIøá`þ æ`…bÑ…c™ ”g¡Å0i^ô”Ê]¥¡Š*JrºØ^y]ô‘>Cˆ@AkÿøòO-¯H òü#ì‡ÍéÔ#GEJIú fJˆ˜µ\ ºñöMÂ6'>"x‰”*ß=û´'‰§”Q Røœ„‹CýÃË}ñɇPWI›?zöéås¨¡Â”a*Ú§Áþ9à£ÿ)xVc…]:ciöÙ^™jj]£šÕñ^«ªÚêe¯þ•jhkôÿ"écB Y@Á{Ò=Uú¸³±fý¤RqK†¥o¿ÑS­H ¤>Ò¦ôJ¸àiÖ%J¥.%Z¯‰’0B.¾÷öRïP׳€! ñSK„Äì?r7ÒžuôïÁü °K.Æw–V8¢Á ²uê©“ –"ä~ýµ±¤(iÀا–Ÿ”Ygfñsô?­8Õ+C„PJHùêÿyuA& £IÞBKIAà¹TZ Ú‘oÜzw’JÞ^ºã­y {A-ൻÿàÒü?d»@Ÿ ù^ÒÌImóÿùÀ'BäW (¿"á™~úŒÿžxž7À‡ÚŸRxÿiFþQø¿f@ÐØeBs™ ŠœÄ) %($"L¤º46²ÎI¦Ô#ÔA Y«ë‘EŒT½â‡Тplã?„L¤6Q‹N–/)E((*ÊQ"àvÉ ! qP¶r•­ÔË+Bˆ€ñvÕè£úx[+@¾T |Kä‡I°øð5ð`—áS©U‰0™9‘« g—Í”¦Ek c&t’Ò\$0<‰0„Ñ ÓñhX'Ð nZ@³4¡9»q‰Þ%ç!"ðntóàý#j¿H"ñÈF® (B`žòЃ’¦Ð ÿÛ%.¡I³ÁçÐâ >ÄiÍòÿ‰åË"-i ³'"bŠX¬"M"L'âé'ÀÙá4–Ì0 FŒÎD 'çÉùERŸ’Šæ‚ÍMÈŽÐ kd:”ÀX¥a„µ^·#)õ̼AIT(…jAÚI(Þä [é– ¼S•t(FQÞ'Š`ªš¶¬eÁ¨i,•!JÄ$¦¬ÍI<ËÏ'Íš” %=ÿ´2€!„®YõlgÛÏ%ÂÖÉü€!ýhCêWD !…ýPÛFÚ6C$‘†àcxÊ)™ö´•k‹c6–¢Í0îžñ”^vƒÒ‚ÄGùãC°Ï(tõ$[KA¢5¡P/( ÅaAž¦üÐ^ªÞ˜Æ#ZÀ(8,Šü 370oyQRX‚!m¯ÔÞû?»dªRIÌg.)aV§’¥\S…‘ÆU“²Ž90=–¬J¢Ð"à= °œÒ ëåÜ™<ðhXJ?RMXÂõ %‰ë;\Iÿqóö¡"h²\T«'OÒÃŽòJ!Ðx²W®“¼B_iÅ×~ðÝ´—¤…%ìy)d øUÉMFÈ šŒdõf4N`†¾ø¸MYjcœ¹ˆ¤ÎÈeÉE² ܘR È™Îtôø[oüF&ÜY‡¥Óá§Ò6„ù´ •&ª…kxÇQñW»¤ ±jLáÙØ$Ê.ãÈfM£Æ3,Ø­À§ªCÑã×t%‡÷¼f!õ ¢|J«£ë5,zc)^À*†¢#çËå9*ð$€9[†æ‘°2¥QjÉJã˜íP€ÖHNV+%aMiJ÷г†Ûy¨Š¤vå1¹¬ÿêƒ$mòCú¸×¹õ‘¯p©Â„ DŠò"ŠÃ6áCÈàÞ3ŒòŠNg×!B0I+Œ=&…Ô¤>‰ª] åtTÖ x”« ³'9ÉçM2`#‹t¤" ÇcP‘«`T£ºL_ç@U]D(å>àœ1‚Ðyí?Àz¼€J9—-mI'ìI"&— ¡µ€N«¢ †v0åãD†U)û Êš„Òµ«#¤BÀ‡FëÝ|×ë(qe3„0 D€M G8ÂË^†³—ÆRK¸”¡ÌêÂÚ=–å=xÆߘÈÜ1…GȨC˜Xq$Àà]îxÌê‹BXAÎìÌ‚ÿ×b@XËyê §$ÈÓ†PK3\4Bø0½âKT5 ÔEÐò§†æJ îmhö8_iO{€øLïõ$¼‡Æ5„‚!ù£ØÀ ¾Þ(S?î(¡~ÞÕ;^¿KùÈ'©=>~Á üæ/®=áUÝ·B1U¢œ(µ ˜.“ÙÍ<Þ¨@9Jê7ü !%ÁÎS!tÐM\J´€ÐCOœÄ·%ų¼‚R( &PXH]J4&!× …r™]BüBp0 D žD¦µÒqàœ4%Ü"üB¸K”ý DóÖ•„y^,ù]ÅÞÃ!Ya•HÌŠˆŸb„øÿ šß˜_†Ä€EˆÌ?À_pG„ †M”ÜÇh>† †©Õ X%üJMHÛ” Žký=ÈŽ€ÐIÜKõÐBˆ šÐÓˆ¥I®ÀÓÉ*Ú&yÍY!…Q …F‰ UЇdÚ"ÑY Ã+­‹óáÃü€)É`ù•¬a’•b‘Uœ¾Ìa±šÿTÀ¬LúÏ,áÜPa¢Ð#„_j€OIô Eì†n¨@RÕ1ÒƒÈ8ƺ2F^ ÂX€>ÌCùåˆ<”Ó H˜M ;GlDíL ‰ýC§ív}‰·$Pî`͘¤UQØPRXž2Ä2pÏI4ÿÃ2 _Ù!%…FÁ m>DœÄ®ÔÂ}“‚«IPzÍÚx1¤ÄÖÄÅHPÑTÀF~G~dG:͇L@aØIŽ_F¤_~"Œ@ÔðBxÀ Œ€ü5êÄM.‡GÜä\ŒÊNâ—mQÂü„DDØDpÄNÀD ÒôÑN¤F8.𻕋î¡=ÅY$’J Þ‡ Õ~ŸFÙã?,Ã3¼ –¥>f=ñ¡]rDD‚!\ A=üC*˜0ÔÂ$I¹×Ä $c ¤{"fbYzcd@6¦Fj$?l¤ø %¡„,‚äFþI:Íø}ÿ€ú]#„?0ÀL&U0@èƒFP¡1cþ=Iiø¤“ä_þùšG üFL€D€„h*‡NœÖ¼ŽüFI|Go…"ÏêýCU(Ò?H!B瘘 Œ­‰kœåðQB"„$þƒº„[D½´€ÍÍÃ- ”@=PÔ‚®øB*PÀÈ—à‘J$¦ašEaŽBÔ†KTQg‚G:M‚žD‚VÑgR’hЦ=PÀ¢ü‚*d¨* ‚o¦.êÄzÆ:Õćêâ_¨ßmhÆD@€‹ÂHprıÜ\h€1`%Énâò#š€Kî\'`‘Õ) Å\ E'1âB ÿ ùYŽ`w퇤R*}@slž<AÏ ä%P æ?Ð¥TÑ{é§!H@ÛÔ†`¦é€¢Ä „|¹©~bfH@RÕF™~„G~„ldŸê1ù)H”&#|@˜ @±XÁ#…Àˆ¢Ä<ØÜm¨ßrŒ¨ˆŠhMH Á¿I€Äa‰2µœÀN:ÎNl‡ y‰‡ ¢DÓýx€•‰9g¹\B+• "ž’kˆg=Úc=_ÚÇPˆI†Nã ,µýpé?¸Â?$¤}Úç\\Àz똠J€·~€äxë?H›*èIÔÆb¹i¢!Ä¢ÿ„ITQ™æk½î)ƒæ+»:!ºÖœ¢.Òœ["=jVWYªÍŠúÝ\nè"›¶B°G+°!t|^Tå†eì“O˜X§ýhêl†zÉ›t—ÈX Ô·m îÕ~,Í Ä3xç® „Y^ƒQ„‰˜8ÝI BÁ5º‚+x©^Ög-Äé‡T@¸¦«¹Ö¾žpj™è¸Ê驞þëVQ×¶kÔÒk¾zf §G."|@K¸@ötGV©ØG=¬Í¡h ̃ˆFØÐÌ̲‡Ôd&¯•Ȫ²j·he¸ñŠxKWÈǹ­XA¸¬re£…‡³Q3œå3Ôc ƒæ.XBœÿ,üÃÀ=°ê\@= —Þ )i·%M€úçgpšíb&P,?ž,–,¾éÖ~m×(¹®+òžëG ­påC.°­Ûâ:¡hÍm=lˆÎB@E¬@m$e®ÍfíÄ˔Ħy¥Ùã*ëJîJ4ÝBÁG™Œº(“VP æQTX@÷š„Ô= Ë=ðÀ´*m=X+¶ê „ë-L©"„ì¢õþCÍYð‡D0B0Iþ&JÄÏ\Ò«Õi,†ë?¨kòN@ RÑ ¸¦p=ïóv "ìS{T £ä`x\¬G€ÙˬŸ0æCXÄà’#"j]Æÿ*‰¹¬0åÂ"§‘äÂ['áîÍ#$&}ÿö¿= `À ð€+°êV+B¤‚®,C* µÞÂ?Ü?ðË.<,Ïê°tÈRDë˜ÅMXGíjm“šj-b9añò)»²« d>@€4¯óv‹k~&Š¢(qðÈ®¤Zp¥VjWêI@Q Z@éLÔdÇ=ø€0ø>ÅÓÑär Ö@ Ê.‘Häƒ äÍð¸ìY‡"2"B|…CèU<»dU% Ïžm‡«—¦1`²ñ?€©üCÀ?À-Š>0BÈ1  N ˜.ë”À #ÿ„;ŸVëÀ3Ö.cMä~ÊW™êCatà+»†2a)G 8ô„ù"MRNðDôÔ²+£jRþC[oMBópOlˆDùmo\òÁì„+‡Oà¡ %äÂê%´eJlÅðü„·„–àatâ’”f]'… {t—Ö´Þ?H×냞X°<¼@ÿCœ¦1J\+}òJ˜–3J˜39“ó-@€ ò?lÞ°ÀÅæ¡ˆéúñ~j&½0Ýé,‰£t$G2c…@ï8ÁÐEM§Ibìší`ÖÛJ#œ²ú‘* K{4ÃW؈>ldÝoŽ äBH39:î+ðÿjVx€Îžô„âbàI\eîKÖ)â‹u+³ R,@¸(Ò1!tð€ê*­ê&@^æTû2¤BÀ „9ægÒ1P”ÀX£NX‹5t‡uXËê|µ ¥µ|“!Ì%\Ç \Ï5púBWËB3tjø&Ir0#HÀ  íyyI\ÿFaÏw)SoC$ ÁljphÄU oÔ´IèhWv6Pì´³õ4t©!©‰q0€ôR/}Où}h3B@uWëµòJ{ÔÂp[5 Ô.9ÏñÈqW3÷IŒ5B”uÐîL9?gÜ@ÿévÏe{ûÕ¦q𠦩šškªµV ´B÷ÒøoppzC£´°·À÷ [Ça[ðcôºFC¼Âl€DDÁ¢(Çø4\‚ÿC¶¯‚ëqÅr.ÜùÔÍ„‹Ä>5 ýÙë™Å‹Ý^OS‘K#1€"Äåϡ"0Jð6oí Òç2ØçA’3IfuއkŽçøŽ3wYO·Ð¢„–Žu¬r÷¦G±õv×eQo€_]¨ñ"»’©C"‚nT9y¿¹–ü¦G4F/€l·xˈ#Š“ä“y{æAäÑš¬@œöF>-ŠR2OAÀˆà2xXܹHx…ŸJ¨ÿ,¡+ì‘T…J˜#Ö9›ÙM¹„(!„ˆW’üÌJíRëIxi‹Gµ7ëJ*äå;»V›ð[GWÿl÷¸¶ ‹ÐÚú{IÍbú§™“×Ò¥ÖV@l@Ût‡­f(D¤©Ë£­NT‹nWjäC|D¢þuDãcÏ^w0j(«7¶cð¶CÀi91ÿïiÿªä2»4Ôó¨‰Qüˆs?„—s:B¤.PôöIHµ/,˜’€+²U;Ó3>õ–n)J´tHËb’p‘<]N~z¤F@-ø/@jIüÿ«yéñ/M^GCKÄÐO€!@Ÿo¬mV94Htp_½¥JSˆšI|„,óÚK<6ïüˆræjºýĹT ‚UíWP5 šE M¿…ø H‡ê®kúŠ#`*íÝ‹é?¼ø¨×@Kð:_IªºìÞ8ëX·ûGP„5*‡ðx/Š0].ÎôÄ/¿ôéûPá¢úÑkцž“(!òUÌõ!Ä¿ 'Pˆ€(DÈ(.HêËâƒFFþ1j á_̘Eø'ÌB+}2CØ‹é„Þ¿6ÿè9 ³É¿Dcæ‹90¦>’2W¨ªºâV¬YeFÍU1ÿã¿"þù·À¥1)ÉŒ@ém×µÿ|ÄŒ ª+W}þ}ØÈfÞõb.œàâTÿRÕú· W1oÍÜó„ 1‘`T¹ò?yïý;bšÅéó výú_C³ÿZ2D”\.DtQP¿ ún *Ú¢hÄ(ùrõEÉQãùæEtâäk”(ô0²ôî½å?.y´Ši‚Á>ÿ•TCL‡IKÇ\úbSbeþÚÊõŸW®¢ê²¢Êçƒ(>Èg§­V@ˇÔúç-¸Úz+"Xë­^AkW(ŽŸ|$¥®&3 ¶z¡1Æþñ%2$\!a#W¾Ã1ÿ³Ì4òŒ„[n)A´˜F“éyŽG´y\ÊËØ`£M  žÜ¤òM òA‘ÛB¨î:'rë$üšàƒn ç䮋B¢ì¹ ¼®Æ› ¶úŒ) üì9*(BÿiBž{îYŠÉ®ÎüJ,ÞDXÁ@®,p«Jźh9þÌZ¡®^I‹®ÀP­ éÊÐ&ªnø‘”XâáZi•’0dª™ó¥W~܈'ÛìȼŽLMžÑöÌëO)_‹ÒÊ–¬ÓM*“öú@錣¢,'Zî¤üÒ¨¶ô™§cª¨üZ7ÅÀV/¦šrе§ž""ʉ®âk¡ÿ…Ò’B´&— Š¢‘ ’I„"V¸ô¿Lõ©Ô$@a­8¦¹B~å­­N½ÐC 3ìê†Ah]™n}ÅÂë X¼Ç ’N3Ÿ5‚é„ü§„#cRòÈJ`ÍZ)£¬-¦Ù¬”€2—Ûí·.Á­IŸä”‹8ÍîÖ óƒ8ãÔ zë/E—Rœ`_ Z¡D'ç~ÚÛР–Pêy–Š“©¦¶Ži?)ÅK+±Òt'ŒÎ܉+«Fñ¶V­ë,J> q­ûô«5™óB,¯!vM ÇbŠÌ•xVv‚ɺvXp©Ù®Ž8rž£ŽÚ ±’:‡Bp‚9æL’!qÅ^>ÿ·¾B ß(X ¶åEب¢üÊnÎÆK1V ¥˜ØcꨇcŠïŸØŽÏžêñû§SþžâjRVy…UW ¨Ž( 2àZð’‘…duá\ˆ&¤*—±M)âA=6Ø"›%¦0¼rÝ넘G8âÙL2#<Ðí¡ñÝhXð´áÝjÇ»Áà‘ܸ "ÞJHZÂV”6˜I;ÿHJx’ ˆ)NcÛCÚF0b<ÓÚgXšL0ôЀÉx?äÄgŒô+˜=%˜±Ä„R“PæÚ’¹ÌQJ,ËQLœ¢)+§’ЩêB2’Áñ6ˆ8‘Ìf6˜FÖCWRÿBÌ}±ŒZ Æ$8€L¼3æ…%»s‘¶ˆÃªuej³A>ði' úøJä¡~Lï\!¸FR |^-˜"Â䔥  ¨”\Äb_ ®´//Ay˜0Å8¿ûˆ}‰Isþ±Ÿ¼`%- gLîØ±Ÿ`©2i C™ÊC2!$ÉVЊ ¦»­ÃOHꊃ®éÕbd² _¤ M@=n´™àîÖÏ|6­" £1™»L %™ÐÆJbÿÉ ŠÜ€"Û²T')ˆ‰”€»æE׶͇!x’Löõ¤Ñc NØ6:ÔBEÓ¨¼¥Gþ V€þ7&éM¥DPc™Lu'¹K– ¶bâZë¡YZcůZñÀH¾U?ïz×¹NÆ+zcÒ+Ô±îŽ1èê1ßdög=l(}ö™–Üb£.æd ¡HDïÍ 9ø¬cà.åã>IøBB`ÓJ®/°ÀÂ6Fð!‡\¹aDHò²¯°ÈMÃÁ‰`|žB-E³¼µ‡بGæP–¡Þ”T7eÚ¸’QÈicF(2V<ºf-B>˃Ìó{ª.& ?Ã;ÿHþú¶³ë\w…:Ä÷E­«…/|Q Èî„·0¡Lz÷PÁ0¢XÜ×~­=X‰%JonóÃÇé 2¨ XA؈"`Š8¥"‰‰Ý,0µ!º\æúÀJøM7º•ÒߌHˆÒtÅ'Õ”|5(÷yŒ\Ænù$RÂÚdÐ:Dc[†ñ#Û}Ïv4YˆOª³p¦lÿT©x_ñkbñöܧ®„jw‚Z±çÔöëõ°”Wkª+#¯î\( Ò!9ØT¹Ëíêdñv>æ0ÿÇ`;–×£C@LB ›ŠÔö®Cì]  Øõde‚„~Q`•.7ûªnˆ1 ¸"vÖGÕ»ÊR8Ø“\@RTC“1íq¿ù=[û΃8±: Þ-ŸßÕÄC… àcÂ}H,“ L.®ËkºÿŸ”B$Oy^¬Z`"¼¤,ôjE\ãÙdÂþÁ@åˆÍf\$¡ʯ€aFf„Ùh/°l¯è\A÷€ÆÛpˆ/¬¤8VøÞ¬Kb¥Cÿr#–NJ,\?Ü[¨ $§&V Bm¨©^N ™n&6¬%NMà`åÇêå=~«~ºÂ¦b¨îã5B@ÒCÝàBÇV)0€I ¸Î€v‚Àðƒ¸ªÅZˆ**^¦x@W„í„:ïk†¡")tå 0؃E’-ËFg¡Ð«è@ Œî%À¡n(÷þá>bRP‘È ŠbŒLùª°ùZÊ*¢k `ª$ÁÆ„mN  lª¥2"%m&àξº/!Và–6 ïÚí~‹·T QE^À>(‹ëDEÝ^AZ£aZ@—¦‹,d A”ˆ?&òÿ°¢êgÖì©­Ö°VjÅRN&òp“6é®\0ÐQ&  cb“^`“bBSÏEòFJ0š-¨,&ãPç€/†G +`{Ö¢ÆLЭHQ¥PQÀ¤ "²êV*K:Íy"2rB`>ââT1N4±(%$†º‚%úM#ªnϪƒ%Wã(ÐϨê§æîQ”9b"%ôÁ<(¥Ktì0à^ ð¾0ò ¤«<Æ)¸ÎÇ€$1&ZF{²BÝ(àÔ @×Lhf"ɦ ó+ÿp(cÂL¨ƒÀväp0ªfþFbâW⡊.{åfÏ./ ²†‡/&ñU$EøÿRpŒï·Š‚½¥ ¥¬³$’}ÒG/NŠ@2$¥}ÎG¶òbßPB,¿ˆ¢Âdr5âd Å&{ ? /!( +NNp0a¬gª°‚ªà´Ž7gRàhRXÓe.¦*õLˆáôæpôàÛQWR.âQÍqe‚c¢1c1–mÙf$ö‘’ƒFZ `/£ ZÁlâ$2ê&f!ÊÍÅbù~AÝ(²'²î 1Ò 4Ò]°D© F&&NÃbæ5„%T°pJ¬Â¤0N¥&c¢4ˆr)Ϲ’òâš@(¥0jsæHsìÆãqd‚¬QƒS{ÿNífN0ž-:‡2Ï2Y@(åCõÜÒ}EF¶s;ý H‘H—aR÷pÈ÷"ZáD0&&L¨£0£€Ð-êlíb’ƒyšG" µHf½Ô…39C'å†M3$+¼‹¥ª#&%Q8à8O9@ YÍâ¢tbs›þa~Á<@4/ /þu71¥O(ê€ÏòZt(»²+e‚ôòPFÇ’ÍQ:ùP(7 1ŠîE„1j­Êd$/*„Ôuj úê1j¤£,À† Äú,"+bRDjÅÐ%*&åWK6íÝf‰Ô”èT(òWóG¸°”3öííf±Ñÿ\(!B£ZrpîãOc"ãìC…ýbOÕzšã¨ +–+ò^btÓRüêT²5ßì*[4÷5&¢“ôÆÑ¥só*õlmTUgTƒT©¬W–.»B;»V³¬  |‡(à"@6«À ¬W{(’)Õm(XÛyÐ#ÕE(˜ÕLV6Pœ"%Þn%Ú‡Zc#>àxú‚b£˜°ŒŠI¥+8 \óTQ儲·©C?”ªì(&,@ ä1¥7 dÿúEhåºrÚ"©-ôŒÓ®¢“w¥` •PU§`‡€¼ú1a¯ ¡|ô5´ö0Рÿ.–IaXà#™Ã¤–/ 3A ïb¸fw°"WY'FÖ³ˆ~ð$jÖûB]8 t9I'ßT{rË%Brü²F kiñjí# 0M·:TuüãChž2SˆkeŸB%É‚5Ó+ƒ&4uÚºB:C/F]  ƒn}muê6„ˆ-aSUoa£1úÖ¯, pmx¬¤æ!˜Z*ùH1sé—¹N–>(–g} L=ÈÂ>ÀK³T;„—Lò†JòZ‹,Í ¥PêT&V—˜ö§+¸‰ Õ•6+@,…bª޲R/Æ7¥®êN¤5¦-FM(ƒ yeÂvÚ’„zÿ‘Í0 ã:±7o!Ö-cõWþö06j rxh?]´¶£^>Y…õd•196ÍÏ>Îz>`6€{ Ó\úç«Rl,sÚç2C„g] ¢cƒ5ñc£ò'$Nøn‹ù´ô³?"c¤)µÖAR,êõÈB‘  Ú^ ,›7©›÷Öò±j-Ù.WÏÊ^Ä-Û³ïqÙ ñʆ§8Xrr ¢«žÎž2K팙>'ÅÖ£ øSqE`-ð·‡’c›äs«Ø–Ñš%îeÂ'\'ÃmLìn~¬e¨ü›ªÍX,¢D/†,ºÖ ÿ»âOÚX&¦ôOv‚xçáš…óXyA8f榭Ene׎-1PÏfF•a‡šÊÒ¹‘c¯ã :ê¢:ô("›kùžI)°.ârAü7ì¬7ðû=Ꭵ¼4ºUV(|/ÇZ·ƒFÍ…G²°¤%³Æ ¥¤`üÎ2¿›ð›ªš’DK€;*¦”¥©•Z¦‰qGOû5›¹å8È„Á7züÇQOuzTa“íaAˆ.+¾‘!2p(©"KL›)k{vâa&X¯¢ BRf¬ÆÒMb9–'5“¨w»& 8p[3ƒ¦Š3ˆ}* rvY>~6êü(tK¸ÿº‚ë¸üã(WüÛL°_4åÄ¿hœ,ûXSOO¼_×X|ë1&ÒP yÝ‹œÓ‰Ë„:†cÉoHÝ:¶:Þ-ÊrÕY1$R/&Ž6æþÆ"ŽŒ«¹’O;ÄÂæÍZõR3xv·%>ØÙÄx ¯5–úÝ4¢]ƒ ²E[ŽÔ-W^@æ]£SM(‘ìm ‡æ»œç–¼„jíÊ:½[Ô1›Fä¹íÔÝ@úD—O%‡99^ªªžÄkëkkk¬k8Ñ9äíÌY¢â5¢âÙ¼/6C3v[Øgí/Q¸‡gÅ&wd#®Ä(cpÅ{óÕÿdPïoLøA0\>zgæeâuiTSÅ2C§û‘f¬s…Ï{®£…‰z¨aXUÝ™HñpÑé" žÅŤÊÍe'xS®~Ök] ²¾ÖGqbÆ?~=6Ø<·ƒ&8Æ3(K·j' šXRÎ=¾(޵µ#?”èÎGŵ–*¿–>+ÞÄ–!€I^àˆñ4pT&`úRíjE.€¡LXü×0–üOgz£a–1è=U1›¨cdx~6Vª£=1ÒÆªP@Æ?"Ê?}"þ­8ˆP„} þBTp¡Â_ 6̧ï_¾.\èø/ä¿ $„$)å þ¥äøÑ¤„Œ!ÿCÌ£w3'½þÑ£g^ˆ !6n(2äFš! \ñO…ƒN) úg(㇤!·~øá…¼G^üÃà†BøçêßÛ¸®êýÂ5d‚vÿõõ›ôï¿}ÿâ­‡Xo‚½ÿ@ˆL9Õ?É’C¦A9U­¼œ±2„èüQ06$XPß‚ùœ„øWã¿_QŸ®P¨ðtF†"hãáB_p†òå{½5d…’$G^ ¹µyóËMþ‹´õÎóDÚúúû¿¢9[y[ÔÚD\ ¹»ø?{9n 1‚< eÑúwðÏA¸E—®Ôå×a!á5Daƒu&c|‰d×ÿ^{Ù…Øb"à˜e‘}(‡–mÖgˆ„&”qúäÂÛ/¼¤OlÆ…änQ¥·n:æ¨cF½L+]PÁJÔµddG\'RK,¹ôÁL†xN8ýsSH?Õ4Gå¢ÑFìöËme†tTP„CCè#å}Å}ŒÌÁ<òqYgå€è †ÂÅC=tMH¡^NXÏ…bH؃:êc‹íÅa‡VöO-µ„8™e„„Ä]†P0Ä©I}F!Œ UZChFµ€* å²Ô@¨MDE=2ÄbC ¹xZy¹ÔdH-9;³M.¹$u0IeHmšt_–!Ý$ÿPàÉ7|+ŠÄÛDNI¥ÐUú¸;“²]22AŒäÙßh%%(\þ¾Åƒ+¨¿†!`2Ö—„6HX æÅ˜ˆ–q6*d!elÈ]žQ€DÇ"}6h(Ò“OlM铿 §•ûO¹á¨²Å‚Ék±5ëÈk¹Œ™‘LÖš´µD]-‘Ó>ÒvÙ‹åNZåSW\ÉÆTF´55К"¼¹ œò&÷=üs' |&µV òUh<l ¢|áÕ¨…ƒE Ø„;i¤CDüh‡†—8™¨‘‰4ªÈ%?Ι«Rð#ôDQœlᘛ­æ  åÃ"FÆ™6¬>3æ#Bÿ°d’“N^»K-)};³JÇÙtv_…@ZîdW!ŒÉâ²IÑ´îBÚ¾ë’êÒÚ÷Ô÷– ÖZ}†„–€Ãu \ÿ37}ß}WÂú-’Ã}'¦)"Z¼¡§\U6*‰ãÕqÈ ò¸U!!N'úð4R𦴠7axÁáHÏt9UWœX`Û±»òÎ ᓪ%¹![Å1àxæsŸñE)yyÈ­ØD¸K#¬ÔB’§e{"é^‚0°¹¼e@o1ùÖǾJ9LBî Ì‚ãûUÆ~¢ÚÌfðªÍ¬ oÄÊ?BfˆT•D;–‹‚ÿ=Tˆ@ éÙ%˜,^…)e8;¯0òÇ(¨Fp‰uxG»Drv%i$ï¶Ã»!\%+ðñÊ ?@Ÿ¢e ¤ËKoÖ³6EÏ+ø±—õð4!±ˆxÁƒp€¶È|rq‹ùhIKÀ4ˆR˜:_/¹R!Á fp›âT©Ã8Œ…JTf;hFm!b+|áx›èñ` ‰ ·†®¦m$!€Àÿq‚Q,}Z µÑ ¼@£ŠKG—ˆÄ¹ æÃÀ€©°†] q…A Þ³˜NÙo21½_R6#Íœ’0&©'QD†à17¿qàHÕÒ8¥©mÊÔ©‘› „†3%0„'euzðdP 1$W b º*²´âu[¡Ç¬ÄUœÔšî\ÚÌÈ›r!§ÿ™pä5³ÂîDQ¨ I –²øé­lK¢Ûщ.õX¬bË__âSàÌ;SºÒ»HèpÈÜX¨J¥1Í *ºX‰V¯³Æe¨³Õ¯Ò”À¾gÏnK[ÛþL»ùGo '¼=I&^¹$!Äé8$Vчh˜Mæ,e!X(éL²¢¯ðJ h“hD»“ʰ@SfoHðøèÐZ‹  Q@µ4ÐbÔßÅ̰ŒÚñŽ#¸Ì6fΞMff$¬–°žMûˆ!nË.# ̈B@¼ù*8¾*Wé~vâÒfÐqQôÑ !@ÿÈÀ‹Id\–L lp³Ž%‰êŠäJBqÂjûêäl$­óÁÂúàGjßš þ1å>ýË8Ë «/c»`ým‹~kÙ_òý¥‰l6µ9ƒ!8oJ³¥ÊâÅô§±ìx¬ÂjŒÓ³ZògD¤(e!äR>¬çUDG"98oûTy „Å™†‚{!´$U"ùJ¬­c‚¦cÂëN»âFÌaN$?ƒx'¼o…D½{:ÖÒÞd-ÇÞ}]‰D¸ ìƒj ÷ë/F™¯Ú¦Þ‚Ž+©M…¤Sy©ƒ9;2ŸQ¸i¡ä nl–Gœ‘QY3áH½éÿ\éYæP¼¼˜Õ¨Lh†o¥Åg—ð¡¹GÜ'qDÔ‹3Õ}’ÓÐñZ¼>™‡ÝYp‚ûéøë°ü'³¤åä(O¹À àr9Û‰h.³Àb^v7“TCƒQˆ<ÕYI†$¥DÉÖ&„ØfRšò Æt8Zô*œ'#2G7¯ájJqi°%TNÁ5Á³w¼2,5âZ"ð šf{\xñZPŒÖ–ó ,ÐÍw(€ÿà–à!±QI±÷p2éW÷9ÍE4P R€v j¡Q,×J%è6oÁr=0Yö3€=(J$>ác~¦Vˆ# íÕU´sH8ÿnÓC*$.‘ná‘@,¦:La.0ó¡ó9©3‘.@¿à‹ÐŒÿæir¹cç%<$¸\ˆã |ǘ|÷W}'`mRp\1Xèøb6L€8_€8À™¹„pY©c¤0ëà(–Ž] "9ÌB–ùvh%ï&TyÁ<©ç=b:VØ#å²—€ g(  D€‰pgÃ=çç˜g1l@Þy"ÒJÀ™Ê¹•ew½g!”gŽqyÑšA÷€†°°öMå[AU©‡.©H÷Ö–ª2Ã[Æùž&Êijg#AÀç×’ÿÀÿwÿ@„(‡Ù{Lð’i 6§œL°jm ¸s–E À?"AFâ&nC@VCA®±VËãZ\Á&ºiAùPÔh.êT… À`\¢¡:FKÐÅØwÒÉ ’¹(=úŠ•=êRÂx62"ê1ô·žÀ#4¤MBÅ¡C\ã+4d[ÑVèR€,S ¸°£!À{Wj‚y¡¡k±m˜C‰4 ¤LZsJª+nö€ˆÐ ÷çß±¢,ê– ÉŒš,b"Na²<–V 1U Œ@'p^¢ t`jeÀÑÊ РŽ¤€¹Ò=êÿ§ˆóé>zC¥ g깊óTQahnYó £¾)‘§2”J[§Ó:  Œ Öö¦½'PŸ ¤©œ¨KŠpÖ©¡xƒã•%"–"qß!5Ʋ.Å ¦ˆ£¦³,Ù…bö–pMBQªC^`m[€'( ð­Jz•«°:&1Ãd!E8¥]µk$!0NÆÒbœá‘¶²:i…9øÚNðmð)«Gjj–0¢ F ­=Z €Ê§ ‹³XÛ°yU¡Ç;÷¥[A^ú¨APóê#"!q“Ö¬öà-Ðô U«ôð‡¦ö©9ëÿµ_ ¶n† 3)ž'€ËaB×QÖ‘j/䃦֟aš`¢,ÇãF)k­ÑWk mÐm` -P¸p:˜a«¸‹ ¶Ùg{±$¸Ó,Q4L¢-  ‹Â*Ÿ5—»Áb[1q¤ñjÆa²ô` M`¸…«€‹p¤JªŒ+»³{°žHLvAËa-ÔA+1Õ2o{@22,¹É—ö›lwi%Cô!in4µ…+¸P¸‡km¤:­ Kðƒ´kjc뽑—~cÕOÌyÏA@€æ!ðGºÑ& é–øªm)£?3qÇ!Cq›Rk‚Û­KµT»:`mÝÿ±«°íP0³á["© ÁâÛLS"Í¡f·ïF—åB²ôÊV²Uº°Æ¿¥ Ðkµ|µ' ºÌ€p½kÛ8Á%â`m [Ãy¾:&¬A<îI©Á)¿K7#Ê#^Çk”ü;NV{µWKµ“yÇ€³3|³;Ì‚æ¦ÃáKš"1ô2UÆe¼Láì–Ÿ°¥ð1NÖ^òâc+†o\qô¡µ'°ÂÿÐe—c8«/P³*Xg ¡=àÌÅçw6‘|/5˜Ì  ¡ÇõÛa¹9{¦TjåU¨t2j[3°§À-‡PvbPl »ÿŒÈpÈÊ)àkjµ ÁQÆÿ@Œ@ÌÌg3Éð.6á@ânò››r2É¡<3¢V¯†Ju[„MQ`±)[5̸Ã4Ü£•ùÈ´Ûu‚yÌhe|^ Q6ZbVõËÉ5JÏMÃ+&ÒŒT(¶¬L\[©œ²[RÎmÐn˜I!<p ÍÐÿp Ç Ê|®qʲTp2:ã4&J‘NÅÃÄû¶%#ö†¥=|­Ò+˜" =eÌ#q "Á!!|YZº££É¯8&Òü›å‘@±†Í#|¯·e±ÀÃÔ?Ã,-,Û£R ÕéΑüÒ/ýÐÅÜÿÐ÷òˆ`v—²K½ÆË³]û¶ÆÆ!j%£¤3ÂWÊ¥Qº-´ÔÝlw›àµT­œ«¤Š ¨¼Ì¸4×Î Î03}Ø÷ò-!Ðݱ%ûX#^ž³tÑÌ+k-²[q „om­NÜ\×91гÞ* û0ž©¡0à³* _\Î=ìdƒÆôòÒÀ|/ý:ÌØÍã„dœDC}Tºš¤I’¦¿|‹ÍšT6×”Ýxª°G¡Êi;ëÈ) IÚ£²M»4DuƇ=3¸@tÓ¡ñØ>a9ã2Wö+TM6šDÊóaß$ ·ÕB1Ú8aw-0‡Õp°Þhÿ°ÊI€â ˜msÛ]Œ Ë;öF °ÕfØè[ÌÀlØÃ<ÌYÍ_-;=Ö“-ÇëhúŒA<ú‹»a—]×uý®&Ú™$0K=Þv‡ãò°æ!‘’Y ŽvÚç  ¨]vÅðÿ/€<0CRàpœ¹ðçHZv‹õ½¨g3Ì@TÓçEd¬Ð!>âÒ .(cIÊ_hàÁ®ôQà1)›Ium@|He¢.êØ|çRàˆ|b§ÜcC¾cFðUë®pŽ nm• ú¾c[ìfJŽ8ä>ojŸ@Α×І}^Ož¸ýðÂC'Ù•.ql]¦xû3•æíñÝÔBáŒè‡ä>îå~îÔ©cŸ@™>N_†(Y&ëøþtðœ±Rð@ï/°µnë—É=30ÈZÉ//ÿ­²Ð3€ëIÑ ðŽR~=ì…Õ Ÿì•œÿì@$ñ¢‘wxØnÍ7#ztÄÇqÒ(-5'íè£.5þØá.êSvòçΤʔ!1‰%qÞç'è”ApaÑç».^P Å€tð®ô}¾‚D8< Xý¾0ð9†–pkÑ}`›°±Ô K2èôȉ•‰¡à Ym†8ÆÜdç}^-<í|Æíüu¿%ÚÞ·kI¦ÕœéïñmU‹‡|- ^t/÷0ýר'ן'Õ2Ãåˆlló'‡Àƒ¥r^lŽH>†ù"—ðóµ.fÖ‰e!ôhQŽ’úŠÛñâÀ¿4`ÿàŸÂ\%tXïßÃzõZ\˜ñàFŽ;Nø7áÖ?F$&€pQÊ ¬übÞ‰™3éý³÷/„NŽ¢øŒÂ^ˆôŒÎ3jôŸR¤-ZЛ×)=R¥Ê{!O«Ö#÷ºv½÷ϫ׃'X” %ÁG<þ{á_  yܹ{ÿaxÁÕ„ âñûoÈ x_<â@rAƒÿ9 y ÁÍœ-¿š –‚œ 4xz¡«Œ§*4 Q#ÂÙ¢CO˜ÒdHÿPžÞ²åJF>@˜yBùÍ›DíÅÌ÷SºN¡D—&…úé<‚N£~—UjÖ­òŽ˜7?Ö-Yÿ‚^åý£™s‹ƒ{íÿÅO0î A ´ML.òúç… .àÁ  â: ņ0à %dË2ú:@ ‚:³­CKK ÔúG"Œþ9-!iS¨¶·$b-´[@ò­%“V:‰‘ƒ& ·|b‚¦©˜Ê:Ÿ†Ò©Hì zÊ)'­¯&šX8¡<®¶úêþY#¨´®„¿`‹¾ú62‚®Hx ¿¸2 ë¯¼^à!¯ Ò4¨•Å‚ ì€ÆP”pÀ>5ÌpE7JìÃИàìЄPÔˆµ‡6rm¶`{´£;ÄÆƒHÐѤ[ 8é —@@CvRNƒí–¬Î¹r*©èyêÿ'ÿ²„|}¡yª´½­¸¼çžû”U/,ŽõË/2 ºóP¢¹æŠ 0; TpA>ã²ÇÎ TC0t@µ:3”4E}í G+r(¶Œ$k÷]J3jѶa” ÞtÌ-·QAB˜8’HE‘|RîWUHê:Z«³»¨èÑU×'YpJaµbaXV–'åó^&ë”%ˆºúç,OÉ$S®ºô› ®p뮿ö‚3Î÷JS/Ãèâ! ê,Ói z,à ׅôÝvŸýl^ŽH›ŒOCKÔÈ"‹â·Òe{M¶!Ð>ÈÄ€Y+˜ ”pëm¸é%½!^‘ÿZ¨øÖ[±+ª¨¥ŠÂµ©·J9ÄMƪØ+Qn™KÏgÞÒf™¹œùˆ 8έ1 ºOh¸ ì.ô‚sh¹$<"ƒþiZhúöÄú1Ø%›3ú´F±ÝãUÛhvƒû&2ëºQ]„È~ûÕW¢z?”M!W$b8ÇÜ~˜Fô¹ežn d|¢"¹bW“Ê÷×ÕdËÍ:™Vî!Àó¸=.3çdæ–-‘®+~¡Ç¸sþôL/YдúóÚuK/šïŒp4 Ôc1Ú« ^,t™ ¨PjWˆDÔ™ÊÔÇ3 …ØÎPš ùélö"HøÕ¶K")ÑÜÿ"›¼Õ 4ê nŠsª¡„8&ù â§y¤¬JÞ ÏS ²È]®J_$–æÊƒÊc€)+Ï?´Â™9ë ̺‡˜<§Až‰/¬k‰^öC&À<í»;Hš2ð‚!´ÂyqðR¸¢\—¡Ôg´ö5Lë3ø‡õµ¯a¦#£›½T伯å-{N\ˆøV£ņ5)!Ivã©áì¦$5úÇ ,°.ž€W“³ “"šPs[i£˜¬d¹QåqK6q¦ºli/' _Bx4ÖýÌA`Ó^†ö—#&‘¡3À=%¨?urÞ†à >QJ •‘¡¡ê’¨ÿ~BJDu¹Âd …ùËC—ReúE·Í@d`ˆÚV£a¤Z˨>ú’S…d &#Z³þýF cË3Mj2‹lÄ€´NÃðÇnÑVAŽ0Î ÿàªF0BôTk-…C¸@ ×µæòkCWƒžAøDí€yQˆfJÃ'Ì8´#M\ˆÚõê„Dƒ¥eÝ ¶¶ð¶$¸!‰pHº¾Þ@ Š&@ô!“÷,áKðof­Ô* KsÉb£ig–Óó@S,9Íè6òÚi•`,x@Q)xŸ¸í ·Ý_d˜xæÀ[Í*p3ÐÈz8€?*ÌX/ÀÏýÓL>Ô³Ü ®È]bCú…µCùÐz´q"`c¹D†¤¨EB$,Ú‹¤ñý”ß±’Q-Ì$¸À "ð ðW+™mc4O¦+_}癜fƒ™…¥÷¨ö,ÿ\2Ïñ#³×z„;êÜÖ³¦UUB:ªp9Bat‡H_u0ÀbèßËä僬1žeÂæÉ쥆ùSÖrÌijæÆï:›¾ÂD´½ëˆ—¹Ô)3µD„´(½z{¯Gqé°]’ ¾XZ¡œ` rD³š©ôfK¥™r, ªÙÚ$µÚb)jQ}{Ó?É ŒšQ64«íƒL³Û]<²Õ4‘Kd걋ûS ÒÜ4š6/¨¥k¡Ⱥ™ÜP ûUзtÕ(Rs7³©öÚM¼ÁH¬ý¡#¼”-ó<4.Ú­X㟇KB®—9+Ë™V²EoœÕyŽñÿŠ7¿èƒÈz·ÐSÛq®S„qç!µj§‰¬C Ï‚ö(ØÑz­[b.D<‰PaÈ[¨GD$ÃæàLFy¿k¹Ú+°1mð–‘›ÿžûÇ(òöƒŒÂîøà0ðü› €¯´B`‚ 9È ¹Æ‘Ó‚””@J¾b{ð ÷:¯Ö+ äˆo €ÛA wÔºQ 9&B’ɪÀ5B§C8BÔÓÅ„ ÒùˆÉ‰¨üt$1›v¡†®–!ë’ˆ6×íÈfb¸"­—–ª˜s!ꚆlF£KoøX'wD•ú\ôV/“zè” ò˜¶”Þô/ò  UÿBpø’ƒüã/PÖ^΃¯¸© $ˆ„iλݥ¶úÉu¢4 ‚žßÂÁ Üú6Ö[F‚¨"·Ï @ûˆ*¾¸OÓš ¼13áݲ#{‹íq²ë¡* 2Ю½‚5´ÛŒr¥{;™s;¿ 3±}°€øhx}xx»·“¹?aÈ›ËÅÓ¸ðˆ Ç»¬-6ª?¸;* ³*ÞÙ½3Ì«*=uú¿¨–£KŸã¿4y²* ý(´䡟ù°Ú4S”{ C¸† .׸±ë"òº”>Œ°®ˆ’¨s—ó"Tª5$#ˆëÛ‹Qÿ ;-y|À øû­"¿ ÈÄ\À!¿RTESÄp ª9Ĺ”Ù’;°X ›I°ü»ýh ÍãÎ;‚»H”Ý©*¥b R*kѧ €t[à ¸€xr#Ãϰ k±­h5óâ$ƒš!zã TR¶Â1‰*¢[38V ²› st>XG)¢¹³Dºó&|ø ¼3‚NÜ3‚Ø|8ÀQ‚¥Ð©{PÂ8Eû`E   €ÅÃc<÷cmÙ©’?v²£ÑQÓÛxZ¤ àè0³*ós'Jã¥ã¹qW¨@yšHr¦!·ý¨×¡½qÿã!¶Ø{Ã1¬é ë …讟$‰âžã /ö—€IÄÌp.>É: J‘ Jƒ’¿ë›;¸°€؇ :ÀL“ó#Ee1Eñ3E\Â4 X?™ öS¼÷ÈÐ)óøŠ^¼Ád ¢"ߺª ¨8¸€!“Úª-wBžiÃŘ1Izš¢3‚¡!+x£‹ý¨½ÔºBžæĵ‚¤\J ±èj›B,U³›¬LÄíɱ˜”j‘1x;¼ÛN܇OL˲ü `SB\çÄè„ËUÔŽX‰XÔËÄK™¾Ì)9b-<ˆ¼A-Ñ¢31Ù “´˜3ÃÜBeÜ‹”*:Q Lk¡¡A=àú‡˜$±µƒpINû™—™Œ¢L+ƒÂJÁ7Úó4Í(Ä´ãÊß »ÓHÐò²‰5ßÓ«ÅX ¥ºvc·0<±µÔŠœboº‡`Ñ‹ýËœÊ)ì$ FhœõS? J:¥Lš‹›¡0¢ ¡EŒKŠÉsÏp³=JÛœ7äj¡þ˜4Þ M2Ù§Ã!u:Û§»JÇ|SЫó“G1¯|žAœMH4ĵ©¨# ‘ÓàÖàŒÇÖè§€!ù ÿ,éÿÿ H° Áƒ*\Ȱ ¿ ÿ* Z@iÆ7Bü‡Hàn,¿V }ø7Ѽóæý“ÉèÃÿDâ²a¼š5™ÄøA"C#ü³ ôF«VDheÒ俪¯v\Yt… ˆ2æ«PÀ^‚ùÒ6\˶­Û·pãÊ=ÈO_…|-þÛ0ÑQ¡[-PzRéT $L€ðÂ<%þ€IïƒÄŒ(ýãés‡š†n„E4AbX”"A"éôÇ¿#>)øª!r/Ð{ƒßJ³ æ+°ò¿³ÆGě˼¹óçÐ >Ôǯ#Oh`3 ;xÁH’J™^ÿ•ð£™,æ`1ó³eDùøeÜpã3KF„Þ0¤XÒeÝFÁ?Xàšk Þ&I€›!­àÃW7@ÄYÈý“Öq äAt$–hâ‰ñQ§ÏD¸l€ v!qš$Y`£øX „xÿ¨äYKÉt„,AËõéì³z ¨]­ ã8Ž”‘!.^s¨0À)¤øUDKÚGÏOGy ‰:Ϧ'0Æ¡eøÁb5å6Ðy²n`!b†ûO¹¹"FR®=ºV0PY`•=Ùh Á ª1´wÌ ɉç?úpt¶ªJìWÁBüsMŽÀ@ͤÂì(ÛQdê’LÍóÁºìɪLEn p¥Êä¤=™þs^•Ø" q‚ÓXJ°Q0 b»¾fÁH Ä´Yt „lÉ!’'G·íöAË&+Pu#¬p%ÜD˜Pàÿr 4Ký#Ì(› Nã „'ÈYÐ’ ¤^¨÷Ü#»ŒÊÀ.Aþ“ÓN¯„Ô9vÃlA…XUkòCŽct[Î Kœœ—Æ­vG#tÄË#üüÛÄï· f¯ÈyÓHÿm 0ø´òèŽ1…xb+½o¨B7>äcÿÈsÏ–/ ìýÂ<œ/ïºùœç¬¥kmU™ÿþZ¹­€nC^Q#Y"ÔJj(@ADy½†÷¬­x|²øÁ þãNñáÝ?¶¡Žü ø(‰õfÓ ¡LŠHdB5y„φ±œû„v $~!ÀÿäÁ‚š<†ˆ›ŠRÔ ¶×ΉÅ(~ @mä\ˆ"SIJÀ;q/¡à+8·Äã‚LcAg6‚¬­cÌÓñ–¾ ¢6U±^ƒL8ÄéÃ_˜Ú Zð="~ï}ÿ¸rò™ïø I䀊¼ÇÁž!Ö¤ÉH®Â°þÿ¨…k´v ´ò©úÁ¹Êe5´ýƒi ÈØfq#R£0ÂF9ŽŒ+`@"¼2’2@ÿÁPT'˜V NB)Ï‚FÄÈ5®‘><å$id ’Äça¾{Ñ?#¹Hؚ؊D #åžvÿ©L-pL¡@Î>èUd¶ô‹²<6k˜Âœ#Zœ¹A~x 7‚ªNž$¨ŽXE(«{ R3 ècS,)NL'ö i=æÃdå$‰¾EJÿ0gNéCwqˆ%°LDÈj C0Év’¦•XÝ?’:Ëlæã7X›øaˆõ…m"èàˆÐÑa³)™¨C·Ž„enŠ_†UÄý *w\U$à˜`Š<Ž)ß@à¥62‘Aœé")™SœR2’˜"L-W‚ %'XCóš×…TƒÍÖ(0Wøg¤ \R¶ˆÔÅ«Yh4ÝXÁ‡ÿ–¢Æ”NKÆ ªí ȉ4obÒ`Ó\=òÊŒê$YÁ'°Žš ‡¾`’ä$§MbN즳‘ï³ÜNpL‰fSNrRM$¥àóu ºŠW ˧‹FøÀF&ºÚÔŠ#¼°¨qôa‚Ûxnqk "|YæQ'9^;b”sѨ…CÈâ(à(!‚q"Ö¦”bvÍ)€K @§×- ¾'cšlªI †TšýŠj6S°D›Ôý#¯“âU6rPØ2¶ FÄ "H²`¸x»TÖÈðdKêÄQ;ÞQUbô‘áì)eI@ ÑWViÿ’+AL ‚bIÎÙ .¶î)´ô€.&쌩|š,NåS¤j}•G|à£Ky2€»$yVY1Ù@z·1^¹¬¹õPž6* Oʃ‰À±¥`O6 ªã4¿B Isa³[IJ^²‘G¸.c[LIÆJò°¢@Î#“´¯›ìùÉžÀ¢“PëÔlÊZÐ(\È~Ó¦’eåŒf4º?­§ÍâÇr$ÿ§xÜ©ç#»Ë¨å&;dƒ»{ëvVà à¢e‡ Õ¤#«MEóxƒo=îŒK¤›žòÞëiÀGÌ˵a– Ä?+>dy’rQº@=" ÿÉþ›ɧۡæ/Ⱥ1ï–æé. :m…®")û²ZÞY€„‹¨ChCð ú¦#9¢-T*ðóçì*éq4I˜„IæÓMèqÀXØel1†{DÄCAe,àN3ö9ã6†Ð7×pm†pÙä/ÿ¤Z?€ (Ä%‹2ÿÅË#<·ñàx!„’'2eFdÅ~A·C7(o„;x2ïæK €1Bj8‰‚ú„ñ(s0C/Àv¥ÒC†Äp‹eS¢m~Åp/f]w]‡ÅCå£Hò¥‚>BSY–qX‚)°äÀä‘R·!~üS§D[ÿcövLcÈrFðP„nrb[JØ@¹óh…VÕ¡"ÕQGvs…«FŸ¥]8:¢Z'ña!æH?ëtg½W/1á4+%â”v‚SÛÅC†EYó`rv9¡$˜FJüA£p p'‡FÑ!ñ…±}©à?Vc%‰ÇKÌ’'œ¨~sG›HyF¨„®%(!Qžg£6U¨wc”@ˆrz+r¿"_!0$P‚á*CòH9åNq$œ983q¿8ŠÄHµÇllW^jÒj"9ò&PU¹’4âùi”Vr•iãn>H9ÿ7jŽGyByéw‰Žî¨e…,MvVÛÑ;KçR&e{1:R3#¾­ 4’Ec‚8ž‘!g=ÔH—óMAt9ó ‘“s‡×ÕMGbìtX&&?3V,ç1$¡ã(…)H¡f%!w¸ Jñ#Q!NñS4X!1EV+œÆi¿¥“æ·“–Yy‘ŽA‰nœ9(–è!“wy³KY&jg,~ÁÁõ5&Am§;¨"€Z¯`Rýf€æbTŒQ*5DN>t9ºg9—S,»˜€èSAÂÔeSò/çaޱIžBbJ³!Eަ5JÑ"¬2*)Â"Iÿ%©`5x~Ñ䘎I¨[!c~EŸ–¸ž>Èž"c™í8šlDLÆÑƒÁÿ°"Ð Bðš­7&TaMŠF¯ÀŠbMWIâ3&]t8vd>1QXÒD½w‘„Å3Å>CbŒÐ.JÓv¼¸;&mø±Ø¸°á‚ ¢¤:ñ: HFÛñUêirrêÆ“ì¨nDzAÈ‘¤>ø'fÔ,Ÿy~@™~βAXj!²L%S79±t@ %1‡2&6ÃoÿP›-”úñaž‘4ë‘N^vh93vÈfg‘ãR4&*œ"1À)4Æ3èÑMêSRÿ@: °/J’æq˜Pžý“© M‘¿59wFks™;‰'Í¢™fT‰VÊŽ¬Ú™ä6r”'Y7¡8júßáJ#¸@ ƒú¦z­—~%úÀ=à.D$¢Çö›$]òb–’ôb‹$4†„H‚%4ö.2ÖRðr­Ì×R,0'#P¡ñTXB@¿‚˜MTS.£ ¨T ÁÓQ§6‰hCª”gª ‰„è8yËÁž›n—¸—øFÐr¦iL › ø¬å*i>{f–(v‚U9ᣭ4Ë‘ˆD$I¢4ð‚>çã3R²/Ä—Ü‘”šZ¥„ ×° À d‰—iãödrÁ“>ùxèV‰šˆ„Y[ŽÏqy"'ȱs”¥å„ Gz¿ «#x'+°øµa€6ò¨ž¡Š#â䋌TS>d·ç£‘y+gÙÅŒc@„Òuœå3$•qP9S^1ÿð.,0DóS:)e¾çB“a¨³¹WÛáV£ºeHZª9jb°©™’„’7º>”ZÛźÃ1jBk;n„±•'8+ J9cb:©y¶a{ÉCÌûC3eœè?|(*8q‘D½Ç¶¼dY6U]€Ú\!²>sH(§pç\uTsîúößG:È6?×LÁ[ Á“a‰BxFªz™¦JŽí 7$-"㺚ÇA_¬°t‚À]¼L¢V+â5¿"k ¿Åuˆ³$Œ$ëÓ¡=D²c™CͪCÙúÔ›À²ä´‘Œ½ÿAH B$w$3Q–’93hø‘t ØèîŠ0À° „£0¼tA¡šÅ ±Ž<7(%3Ÿð6yñö¤À¯ê„¥qâkôyb1¢æ´ t«x#¦Ö¡KaTÙ”30¨¹$\'϶Ǵ§`×S=Åœ&S@È÷H™”ÈÕlC/õ ¸W!0¨†úg%%°R^‘,¹†+ΕˆW¡4iËà£òkuÅ–©Žº´õÀé–VHØ´ë÷ª\°¨L‰ƒÂFXJ²6Mj',PØ!eúð S#[$ ¨!%>á%6Snq]0q1M–ÿqÝÌ1Mg‰ì>’qÎ*09´w@ ñjÌ$å%mÓf¬*Kœ´å2iÿ0¯©©6L<¡zÊBè™÷À[mñ±­¼1ºÿ[yBiË{¬;n·¤pBÈj$£Y•Ùó>ÇŽs·ÿPS‘‹$êp2D‰?°]g9ˆ¼Ó±ß ¨K œÁ­†š9.a‡˜Ô7F°b\†wUQmþ£¹R#Lëi©ZŽ6é°¼K¡é¯Hz¶ey„B±6M¶F='Ç‘Q®k6 |ã&(ï¦x-3&¼:¬™Ò€sÚMG¤‘Á†lk8‘D,ÿ›bàd]•”H‹ÂYŠ Ùˆ•HdY¨xÉ)&ýWö¡€3ñ³n¶&šl V!iHk&µ²;n”Ö  ÅmAÐéÈx‘ׯÇáx똟¡Ær=Ñž—Åk³@dqܽjlâ±9²#[±>;D¢wXSÌ v‹u)ŽI׫Óì]س‡­5/ÄxX‚»‘#42ÑÈGò½–Ñ•‘±¡{i\Þâ1‡V ”¶ .3 €·ñ@s3?ßÓVôm§‚+¡mruˆQOK”ö Ëð È5½ÐÌråÎôį½Ê^™­{ªB Ÿ ñ¶Ê_ !(Åñ~¼Ý@ÅAæÖzÖb8úF²ØVÝÖ<ãÓJg{졆%Þâv¶xœ5k­´'³gš$9y¸•ÑÙKÒ$N·–$þ¡G#ëjE| ÿ@ê3M¤ìƒq!GR o­ÜÊ÷iª@ùà¤Èïš·êê¸ÖNûà® ¥’e"€-¬)YIv}ö-.ÙŠ Ã=µñ½Û¥Xi7¸ÿ*-Ð)’*‰—íBbÁl`>ÿÁÙñýWM6Nñ r¿™ö©ò—ëú °ò™[@hKAÖ ‰F>é¾êF·KD§À¯*õâÅo4t·,G·ª»j39ñaÆeÈ´áp ÁS¾øì‡õ·ˆýñcSà*'ÇôÓY6í,/ö@îÚºcAÒ¢˜²÷r$‹óš²%?·©P‘O± cÁàGªÕn‹ä)Ë¢µ€¥´¢ú } A䌚ÃHCüúad #l°lâGŸØX³i4T“ì!ÎKͲÎ,{¬´Ëfƒ¯E„R¼I¾‡p¼J ùdÃ,¡ JÈ·ÌŠM!‰ln `…Bú›à’Gž{ÒBo<}òòŸ˜¸ó‘£8 Àºë\Úiº§ÖÒ/„òÉGŸùD¸*/ƒô‹J©XP¬L¯%-YâïF0ªÿ +1š‚ (l¥•ðAæše®ùçšÃtp>is 2Ì C2X<í³›oI—EÀ¢.›”%_b‰ ¢¸ä+ATIß "ð|Œb0ú@=ÖlŽY¥)eLc›Ðpfr¡Ü?^9ÆUìf¢¡v61]Í(D´H’*"á¬H§ ‘!8·‚èã%àIÕÞ¢6³DÒhEû‰L`"¼¡üî&MñNÕfø½J]ëùŠ’\äE¿XÁô`;)2kG´Ön½|uO,fq¤´)ŒücRÿL†ö¦Å!¼Ï&Lb&?<ð”æb¦bUG”±ÿÕÑc Qg8&ÇPYpe·‰X°|•‡ó9#Èmó‰X ON"‰Y^ð"ÖNKG3ȵBÈ¥ž(å[ßÁR w¯¸$”+äÓa{¨…|`Ä]+ˆ%(AQƒø,¢TIÖô”5»d=h1 I²ìË ‰ªÀŽ4-ZD06)ŽkÆX²›Èl5‘¡Xe4VšÈÅèE³a\ª4MÉ T²!Ò@ls8`õF3â<`krÈP@$Wi¤,BêprPb²HÒ`²BÌÈP^¶” UrøæE#q æeVð Jü#xÍ«ôNL°ìg”왊!•¥e-Š  œ¸–»ÎÿBYDƆ*Õ¬X&>±ÍP¥i#ž’q3‘[j"‡ȹ±E¨ùf¨zô¡›P¬*BÒ•{„³ ÚħoNÇ ‚|¤#”Ræ{æI›hë'ÜRÒª.§ô'¡ñJÖà ×@4Y•A+}Ø¡Š¾â•>ˆ€¤'‚ËàP*ÿ GBª4Ñ,*¢–t—–Z䥡JLH6G¸ÊØèD $ l%6ªÙŒLµ¤-g(—*¨Æ–¿/[Y±js†DÄf”H‡w£,cä8iELü°øJrŸE+áw²U®î`i:1ÌÞBu0æÁé=ÏsWô~¨W¼â•¼xµˆ^ ¥dÁéÿý€> Â<¸ì‰þb‚ y|ÀAÌŸ Ähä̺˘闢šŒe¡QmâGp~Æ6—ipƒµÉTqþHŽ‚ ÌxÃ[Õa¤"tjoR—ßP¢Côòt\(êk…@)ZL|RPŠ”%Õ5eŽOÉ@:EOzUô+VPê½RB¼¥„ycK§« >b3J¨¤®'ZD—U®²¡ Q!ca ¥F¸»,X°!ÑÊvJlFó´à4­7œ?Ö¦6©ü Ù/LpG+¿=ÈoœÊ¹Ó"”zVsò„ÒHbI'þ|ɵ~w¦éŠlo²”Õùj&YÄ»?Võÿ^} ÞWìu”x%%6`Eß5£+°“e LªP ŸDÐqå;FTÀAÏ \*c¿=K1`Ü\ŠRT²w¶/úX‹Èø`V¥ê¶ù å–t«MxW‡HUòáb‰JfÇšÈn[(Y CÂÔê$ Ø­ˆ…bP*ùvkmÓ}“{æòˆÊrÎУxF¿«¾¸š¼‰Ž»A^ájºwÙ¢Sÿše„¨F¸•?,1”/Õ²õ hÙ"B 0®æøQ 8ˆ Nóiš¬q)RH¬@©¶bñ°so¥*þV΂äðù±Ûˆì¦6¶íó!D,`(±r†ÿP™ „À$ÙúW©óO¯''‚Êáì!׊Õ5˜3µôL äƒ_ô‡xåÈ‹wÙôÕ»ð¹xž8 éè¨,eyË’ÕÃ\ȲȶÈ<ÀÙ‹5nÏÞÒþÜÇÄY•c6Ô@ü 'Ê ˹‰ '|=~´œ!! 3ˆW’º©[<™€çàŠÚ‰ä ¥™È¢÷À®é·P³‰»¢¨Zƒ;2òº+SóUÃ;ðƒ8#µˆ¥¼(¿”Øþ_Aö˜`¦¨…ÊB|ˆŸ1cÐÓŸ‘³j²9™û¿Ôp Ï0•Ù –Ù¬œB=!ºÚ£ ÿAJx2ÙCÒ¹* ›‘è«Å³:ƒÐ äµY“jj –ø OÛ‹+<f S»¾¸(Uˆ€»R(©Á/Ùø>U;2Š» '±*\ a‰1¨Jù Kq|¸–âf#ÙP3y™ñ  Öº Ð“ — ™—ó_IœbÆÖ@ÓyCÞh:B · ³˜éC„Œ D ­Ê *š~¡—h¡r Šå› {  ÷Àˆ(` ø5ôª>(‰ÁšÁWˆD¿º¨›¸;ƒh54#ÃD(ˆŠGª˜·X²ð”²‰H¡ð*¦fXÿ|œ\ü‡g²¹;*°7£¡É/œÐ„€9V±*^Ù£?Š0Ùû°ƒÐ™Ì`ˆ÷HÒÑ0? Ìèpüˆå@  q,¢¹rÉ$tÁ竊>œ3Gµêó!ë“8ë[€ŒA´JM„8ê+N|ŸèÑæÑ ¸²+#¸!< è!½q˜k…Ìb–‡1l6ÙRrR­²4B³+알!º “§c*žœÆÌÈ­ Û­‹@ØÃɆ ˆ^É 1óÉIéˆÊ€y¶ •ê¸Ñš &uаÊ8{´‰³ U°ÁH<5z%€²ºË+I Â;™>ö¢‡² ÿCyŽ“˜HÀ8`h†…‘Ë–cáEeñ¬ÇÑikmK–W!’ý9•Ψ¶ð£Bþú-p› i,÷@'‹ÃÀôì˜|°ôD{¨Ã…› °Dž½8‰Ôm©ï˜±¬q(²dÊÛ+Xê{ÍŒÂÄلЈM}´Í¹²°‰òòGXª (s+” F@‰¬ûŠ$¦ÁPÎg`Nž ñ Šá¼î”39¦Ð¢Â¦lR#—£•‚Ø­wlÏÌaL”Ñ !MO{XA§[Á‰púÔ­Žù&= ñ£I|ŸéûÌJÊ7Ù¸ÿPÁöXÊ¿rÀت8ãð+Ù05]ÿLô6ÍA„ÓÊò"HE#H;åJ¿bá Ñ› "晀ᓀ³a ŒgXQ[#3ÄÂȨ=›!=›¡áŽ+”ÉIˆJí#EúT÷Èœ(¥‹P%™ˆN•OxzRqSù”Ï>Rˆ|Ø‘‡‹«3 -m¤-mŠ%h‰µÑ¯pÒ÷8¥%;vÙù@¯øýÇŒšALTŠÍã¸J€tPº Hé$ë·À“ ¾¹:C˜ž˜Úd°E+D‘K=`q¹Ò«3KkC PeW‹pR$‰”aÒVmÒ"½ WÍ-`õ‘)U$Õ­ 3!Pö:‰¹Ž-¹’+ÃëY—ÿˆzªU…ž€{Ù J»cS(áhµˆÒÊ›è«VóUkŒëÊ ‡À›»Xⲉeð› i 5:{§(ýÙŸý× Z)5ZÌp‚£5X¦Ò£•Ý:=¿²5y¦©+9_Õ!{˜vŒ¨¦¼‰þlYCe8k½¾”žØÜ‰ËÄVÛPÄŒ.#È© :8>˜Íº…h¿ µÃhø\X€ÍÙI¤M\ŵW(øY&eZþRƒp÷\ƒ½‰ÆµÈÕÜtZÂYŽ(‚XN’ØMû z˜ëòͪxª“¯i»Pk½‰ã0¯ñ⻟]ÙÀ‰3·øÖÿÄÃ=Ь¨›_Yh€† hÀÅmÞÆý(Pˆè…{ˆ^'(€ç-Ú§µ‰ËýYÉÕ­îµÉuZ{hÎý^)EßôÕ\)}Þ*ÍPž¡Šj ¡AD—5аÛzŠ-QÄŒ¨ŒÝŒª>°ÉD =YÌÈ«ºàËp/D^æÁ½…K4(É…\ø‡_¸„ä¥_iÞĵÜö}Oè­ÞPzM_Ì`_þ¢‡ð• `á—•R ø^þóõ‘6Èa¦ÝEâkÑ–µñŠéZ&ežÚX²&s²PÑØŠ¸BÚ B3µ¸ü™žfíAþj5Žà‹'³‰¸¾€! H ‚K ÿ!ø‡K@„߀Þö`Ù€‚n_'P¥¥^(øÞìå/§•Šd‹Ð>aaCÞá*ù^ €a^ändC¾ >dƒàá9Ù}˜‡p‰îŠ·Øš®•Ò¥+9™“§šµQC)¦âóê®eU$&<»`\Ábܵ(=Y7°µˆà­¿h…¼ZcÀP…^08f!È3v­Þê5Ø=~æÞc=Vj~^Émƒìý^h‹ðfpÆáõÚõ½‰ržd›Ø>‰f×rN=zXä1mþ@! h$™‹,k¯Š™E þb¦Šë®ü­ØQÊ$‚“9™˜~MJ°€ÿK h °(ŠN´.cæH ¿°ˆ3ÖCd¶a6††^ÐŒjžfƵæÞcþj>Áf>±æöfD†^š†B.aržat®äˆt.d£½iyáÄafÒ»–€ j ˆI DÙšÀKaõ)y”¥"Y#?ë‘®~ % x¤åá8[4Åå56ˆŠNã‹Þe¾èë£ °€)<㋾‰_p6ø…c¾„Ãáf¤Uîcîa®énÎa®d†iñdÇ6vjñêw–c›øéŸUj ¨Ï2c¯ˆjAŒåhYSŠ>'kmT*ÖÓ 8:ÑŠøB"5 %ö ŠÃù…ÿÊø…–Ý€»û‡cvÐ`^@çÍæ/ñNoïòĆo£nlHž.*ŸïóŽẗï&Ÿò*OaE¤€éîFb†Áðrpl›E„À:/ö»¾=¨°á@hç™+~Á±8é)©Ç´F[þÊh½SdkDôQPq®¼„WHc›lhðP6ò6òP?ïïnòîFïînòÃFïoèÕa6êvä÷.avþôó®áwÖR/uxÎÔ†n`À˜ðJ SjíSzè\a×&Ë…Œ“ê‘#Ÿbbÿ6o™_è!‰#¸Š¶‰KXã5Þ†›ñ‹@é¶€‹Î+i—v6¶k÷„;Vw%'o:F_sïìïÎqñÍùôÎa#¿y `w÷6l>µ\>Ùé(§r¤Ÿo}O½r¦9Áˆ©ƒnƒ¨aJ“§UZÛ3'ÅCxˆæjòƒ«d‘«(à(9ù‡\˜7ÊË>çø·&¦Kà,ö \d0yVKã|\ù^èëÀËEßlÎfñïnæñv–Üq·án¾ñoüt_o˜ÏùêxN|Ç&lëBêÎêuÞ饗 Üšhönì2`ðT‚‡õY¯&ÛK¶¿pU©GXk™„$Kõ*Kÿ´¯ ³~/ÔóXŒãFãäî™VXäÔ"KLVUÙ7ˆ¾—ñ@_:FòÉ÷™¿ùœžéÞawGú!ÿçewƒ`wu.aÍ}«õ’ wÿýˆrõüŽç6;¸º JˆTBþ´ ìŸ0 ­†HÈõà¿|!êƒh±âE‚ˆŠÁÑ£>}ù$Ò£7¯½!¢|H$Äÿ*zü·âAJþ»´áŸÎW´Š`a°QB,¬p±ˆE‚½þMŵÂÞ?Y jPÑõ+ ÿ DUE+į^!ªh›UCm²Îý׆쿮f ¢ý—Òž ÀYSnê·mWzZUÿ(›Wl ¯1 S®l™mW¾Ší}0D0ÁZ…ùjv°ÕL N™¯%A—1VÄÈqÅ }"…Œ"½-þÍ“Ið·aÕ¾gw\ñO•ž”,ü³pÉú%J”]Ú 0\ø(åÎõÏ<Á_T/õú5•ªE¼†Ñ†Íëõl_¾öõ¿å{®c\õ%V€•Xeq)V×~)-¶Uf˜åw™ajuÕ†cŽÑc?úPð¨Q"ÚAÐÔÒ CèóÁ!Øã"Œ½(VœÅ6ÑLÕ4”½éƒœI¥TÂp-¼ÐÃSæ…ÔÜ+ÑQ2Ð%ÿüd%PByW>¸LuÎYäÿ‚ µ74”ŒðVBt[PØCÖ]o–ÅV‚„Ö„|Úe™`lNÈ–ƒŠ5Ø—WkYT A RØ(Ds1VW_!©6„FôÏ3ÍP·‚ŠÐ#SJ)i0›~©TcD-åó$D+¨²€*+ìVQÀ¥ÔÂÔ©Ò /½¸ÐÆ/ öòЏÂÜðO²åcOù”Oö¹æ»d¾eç¢Í&ùíÂ/'ºtÓ=×Nøkÿ‘¡BlO\¦ªŠ1B‰²V ä ±”j-Ž’W*$ ¬¸èUÿÁ0—-h$„!H*3ºœeÿ ¡ªeAa>p!wl5“Û¤W!ÚNr$z@ y³|;¡0Ë…Q±%¢Õë0-Ö:J¶¦”èHå.ÈE™pò qA#ˆø@¹øÁš×àèFï« ?jt.‚ m|åƒÈÏØ¶3fe_ ó_Ýôcª?9FQJTa %±*ŠQsØ[*†}lˆ @æ¦öŠ!„à£#ˆé~%Bä¨Û¤_ÆšˆÉ”ˆ­j!ªU1‘€n46”Xͪÿx9AZA.!„ë@äxÖª…15|àÒ"mhU^1hà(Dø‘ ¼ñFâG>¨>lò›ÿ(Ÿ7Ó(›o’-o=à>!P`‹ ¤÷xA \¤´rHʈ€úBæ„q" Œ¬tš$ çqð u&ÛÐ(Q™õÒ&ˆèQ>@'œ’X$2 ‰ m"Ò AVE´ …bBÄÀ”.‘^X‹ÿÀI/„q fR€ÐG| T¡JSÝ_7ªÔu3¨Ûü‡OÙŸNu›¬yÈ8-²/ýô++\˜a(•/ÌXf1† XÄ⢵r­ÿ¨>Fà àD’?²¤ÎˆU`d&ëÙÚÊW‰À¤ÐŠ*pb“Üd")¹!kr´,‹VVT”´vYˆA'”ˆ€”@ó|“ƒí U´¦ž©¼BÐ×?<UF2Õ"δ­4‘[ÛTd#Qùit T£7ªÁæ6ǘå¶)P‚ÒL#ØÇ!°2Z1v—¡?Óa÷4Œ>j‡ˆ "d’ªá¤êdÂÐýƒ¡ %°à{ T‘%t€rˆô( ÉÕ?Xr݈À;b¡sš^V)‰»|0¸dçÄD zG™ÚR²õ¸ç4ED|+Ûs’ø2žA„ÿ! ÍU·å:ØVõµ™:®Æq‰£ÈÅ ¦Çf£„OÃäclÅRZÁz©¯&A$q ßøj’WöxìžÙ%–G"ÉhÙâ߬Žé‚&5eƒ{’aäéR—½í?¶ô`f‹'Šé+ò| h¡Ï%þ3 c»ÙúªaãÇþþˆÎÇ>cýã{¬0H )*) œ±ò*ވȃIB•IP%e“,t8¢#|›°I¸JôÌ7åò+b׋ Ë7AOe`·ehx³J´„ßü™‚`kj”P,ñzžW\B<ùǾG BÚ†ùÐ#³MlS{Ûqˆ)ÿƒb‚8Woæö›xHˆái`hQLc£¡Ic7×í‹= Ó—‡Â9 $ÉT'eyˆZtÿÀ@éBxº{ Ž®3s~cgÊY¡ò‚ɇìߨè£L$%žµ–øžXg³Y P" ”Ë¢1Í+z¤Ã(P,u "mYj¬Ð¡À¶­=mùvÛ¸Á‡Žnôïý‘—A º¶Ê˜6€‚zPÃå¼d~5ŠúÄtü–xV(ºä›s(ñ9ÈäT-p/D‚ud’8ݪGB“’Z$J8Á¯˜v‰dÕ61)%¨¨/ñU¢RgçD øÈV3 Ñ ÿ}ü*¹³_ €?@,™b¡}Ú²ÔyÒ¥-ôPé­GzØH¼\ý ÊPÚ:»[ \yªæÓǹö1JPn}¼È‡(á[ÐIÙd—´ˆé8@ºWù)YásÆ•øÄû]x³üLt3ÿãbJ6j·Ù–òÄÏù,—„ŒfüÃS¸‰Òç5ŸjTÆÑ!ÝìYć$ A´ˆà^âž]íýµZT`DÙÃÀGå #Ð"xÀ  ²Hp ¤¥…Üœ•›Ìf°Ixm€xÐ0‚”iR°Ü X÷KüÃø…X™ ÑøÝÔ¸tâÿEhMõÆUV²™RN8^üËãÄARÔÂå0ðß3ƒhEEŸ½–ÚQÀXuÜÀÐ^‚Èb ·]¸Ñ^µyÛV[îa ­Å„ciüÀ#¤Š>lÀ @ÇdFÉà Éô8Œd"ÔUÀ $Ï‰Ì ÁWé ŽÎÄ—é˜Z ¢_Ôšú=‡N$½P”Ì ñx^z„S|„¬@Çe-Øñh¡vìˆM ˜€ A ƒÔ,§$uhá. C浂1YÀé …EÈj„ê! Ò!ošÑEnÄ6b`x 9aÅ!ŽÃ1€¤ÒD©B­¤`$úÿEdLF ÐCd …X,†$NF`8F‘MÉ ´ˆ_„° Ç^¥"ïÊD$ÅŒ’ÅYV0:Kœ½Z­ ’˜pDÖ´Ÿ¬à=ÊNšAKÈ!kYÿÉAH A<2LÇIV‰NAƒsB+Ó(,@´À €@RÈ \ þáQ* Ò¶"¶ T²ˆL€ÐŒ #Ø#|@µð™XÕˆ€D0ÂÔå#?–eYî#ZVÌ>jZÐLD€,ÀCà`(j¨‘Lb ™Ìp|_ÇÖ«UÔ±ÅbžÅ e}¤™½_/&‘aÖuL‡JÂD(#D€‰2–!uè„Ò$‘k ƒPLã?àÿÂ(@‚ÀàC*PFЭfëiÛ9™#¶½Þ9VDdÉ›@¥d%gÐCpG²pž ÚÊüƒ$~Õ<œJ&ÎcL[:†á ÆÂäà l@äp Šè ª(I©ðÌɨJ€ßHBüåD³ÄNÅñ *$a1ñįUÇJBÄ3,CK6ƒ1r 0dfbM ÷¤‰"Ä¡éÝÔ2âüœ!P€!Ü€gH(„ ¶eÑ%ÝF4eSΡSBe<„ˆ>Äp‹HeV.ÀŠ`uDGTÄ!†à!B'sÎC بqâh @gY:Æ Bg)Ç?à ÀÚ“ 9D®ÿ"EV—)¡aÛ±í¢˜t$D¨‡çåN(Mã% /Aæ~ö_§”†/€ "#ñèé’0\ÂnøÖ DÀ + (¨/øÂ? ÞˆÈˆ9me#„¢˜·EÅ#؃ÚŸUk0ªa€ÑU A”‹ˆšèdå üH“‰ÍÚ¥Ò# eŒ‚ª’ê!f…¨©€2'ë° "PÂ`Äz±o¬aœ' a(nˆLäƒÙ=¾BâiÙ±Dƒ^­P–Ç!˜çÉŽE4#„•\K½ä?\&~#e>CJ«±þNÞVNÀ@Á ÁÆ #0Ô$Àë9%Dôéˆõi¼ÆÿÖ9ÑoI@¨Æ¾–K¿:j° ¤#äà TÀoŒ§uª!ì<ÐeŒ>¬Ä)ĪNš¥JäÃÁF̃¨\ªÐ€Î“©Êpp'©„ µb`޳ÅÚzþC³rDIAñl™f:˜š%M"‘A@ÿÅ$~ê)~Æ$ÿyÖ¸DÇ.}À ”ÀB± Ü@=üCƒÖÂ?øBRˆjH€F…rxF×Ö«EŒ­lÙÆ¢êëØ‚D¨íkŒDˆ2~@I8Àè]°Æ  2Â^ )àŽ q¢¨9Ö>æ¦P€F¨F‹‡c¡Ð µ€H.+!‹Ú„°âùmî´<‡zZÿFañ=)PxV›5¦ÏZ@˜Þgÿƒž­L˜ø9ž>ÐÃè°Àè ÚÀ?\€a°+A¨ÆHÀ€è¾²moñN€ð~ñRjðþƒrtA‚rxí9è4é+øp¯mÂRŠ]o`„€‘¸:R´@8ÁúæC.¼ÊHbÄ(ômý†À<ÄZÄ©æ¨_LÀFІ>HÛD¯xß_M¢c­D²žñ«Ù²fûñeÕ,AÌ¢±&Ñ³Šœµ¨dÐÆ$A-^SÈ=ÚŠ= ÁýÔÀ? AÕZ-D \XÄ\UþÃ|@? ‰ ±óñÿqù®‰Yo¹x†l‚WÀ¼:ÒEáͬȱ#}ÀFÙíxÀ—}AÔ/C‹ì«>ÂküÆÈL,Dôí!"‚A¤dBH£Jä±E$'q=l á ¨¯A¼¤~ˆjàã@Ž +BIß fñ"·_D#^Hæÿ¯-^—2Þtd &?C§4ƒ~ “0Ã(D€sXDÐ ˜ìî^ùn=œrTÔ 0BÿbàÈ”ò©úí3×/»²aL1.Û«öÞ€u:’¸ß cDò>`ú 2+³k´ˆEìÕÜÀvlóBR†E¬ôªnÿ!„B|Îq”º@YIÈ„ëÆÿ}ÏÊŽ°:«¬Å3û-Dû?Ü‚ ë7D¨9¶Ãp𓹷yõŠ-äJD§v„ @*-"ô J ŒµˆßÿàT€ÊeÔJtjH°) Û¯E¢P‡vß1FLzo¯/ŒT®.yÄ9¿úM̳GÀâsX© ¥úX™pÞd½§'QÉ1^‘»aÊ㎌@EHSï•+Ìu={]G…ž"#E@;;ïŽë¾÷õ´[}Ã&ýµµ;刽ù÷ü†sªST£JÀ ðƒ®Ät®ðøo¤ö^Ñ;"èJ`‘S`rˆ+ûís´Ç¶‚—õ {TÆ®8ûrÍ\´€à‚TÄo¼ŠÊJ抡Ç;[ÜHÕ¹K(ìËpÄFöbNPrâÏ_±n-@ 1€néŽ\jC[y±»ÂCÓÿµ*D™ÖÂ)ß‚+0‚³CDé1`3B˜ã%ršÃp& ½xR«ƒ bh¡…ú-„jñE"~kè–ŽH 韑ba‰„PÒ%yÄ+N’(XÁæáɧ òYÌ(¤@„§¦è9ˉ©ªÊj«$øs°ZhA'xÂ3«†Þ’ë ¹ ø •,Âö Áž(<<ˆÄ¦L,Qž&äy´'ÐXá _TœñÆKÓŒ3ÅJLDDØì²`Kˆ’!ë:¨.#]+͇b[’„*¨ ßˆ+N8JÅ8_jQn«è”®·0A*¡%’ÒüGxáeiž8ãœéŸ ÖÓçNX£È%Ÿ¡¤’êJøa*ÿÒʺֿ7U*,H5ÑÄE(-„´bä $X¶ò¦2ª„ÚàðCï\-Ï©æ›V̺,³2[aX[LaÅD Õæ ÿ9­!¢‡^ ® šÉŬВW J(K…ª'o‚h™ZÐHÀÞ>Úè£èn!¡vZâyT:¨„zí}鼄¹AÝ/> 2Ìç}"ðŸHDË ¢° m ‰ÍÑJl¡ %Ð-ŽßRk 7­Ð‚C«d„Ú8L¿G›øçž{Vf™Ïö¤Œça¶¹!7û™ÇÜhz òÈ– µä)qí•‚\’«ô*EûÿË„„Chê¨Ü­‘(üæ:šàËt7"3ÿ)!»íÚ?Sí„ð»!òò†µ'²ü¦Ï¾ò!1TYÜâ"PhhTê&·7zp,+naËV À1µ t+@B2v¹¦°ìMhA¼ö¶:y¼jUi ˜¯C«ÛÕlfŒáÙABóŸÅˆ 9ZÀ+’÷ŠÁíyÆóÁàG‰Á!$699Ïô¢fêÑï©àš×P&ŒL`$9Èoµ‘$;íC æ7(§nö#ˆäEM¥ÿû‡~\« œÓWö&1zœÎ óhÐ5G/¢m#£ô‘z؃)ÿDˆä„¬¬"”Sþ¬Ê¸°XÅÁYBˆb¨Ä/Z;T¥y8¸"µæ¯ ZóþqƒPG¹XAxp½ƒøò—WK€²°m$L9ˆ¹’¾â¬d%ì²àóE|é„e(Ë¢ô±€ ¬@’uü U„ ¬ ù8‚J„*±s!hK5¦– jÅcHCÄ^þ!I” &!¢ä£Âr‚Iy-ÿ Œbñ‹Q®(Gªx wGÃÅȆ,’ÖfT=„ðЇÊsIV`KDâZ‰z"œˆãËz<¤!U4Ss”I¾²ó $°à›°£z!rnç!KÖ3TNdO<“Àÿ ((z°Ñ,ÿI(¶…¼|4Jr§KSBzlnsœó"Æ(° 4ì0|j~Ø:Çv"D0(;Hzöü‚wº›è+v%›æ‹gþá‰|ô´ÉlI±ÁQÑ˜Š´]ÝrŸ]½¶€Yó—Xƒ)IPœ’`l.Á¢2I²&2ÞbšöÚ "XÛZ»áÒNx’ eö¤ié#P’óÉ ¤* þƒðÁ šºÓMŠœŒ¤ é–«@ +ˆÀãõ“ŸqBªD‚Á.ªìÁŸ„þd(…Åk®T!ÑÒð5–™(†DD•ýØ#7ÌÙÌ‚Kè qhÆ›Vò"@¬È„ ½,Èõ.ÿ›) 3kÿ€Bº†W<Ø—í±¨Å‘èt ÕI 8ÜLAsºAQ‡ºÁœP%PÀÚ“ôq™ÿ *>é¤U6‚!,À^ÉÏ&'•„Žõ‚^tËF”ë1àN·ºl}*ª˜b ´Æu?þ)xUD+Šª‚|Ͳ±^¼ËÅ‘tTíþ‘ùd‡êM³›·$ Ô©cYi=lÙàd/8Û‹b¹d¤Â[ |[3!aÂÈZ.¬ážbgBô3Šó`Ë˰–(@“þ1ƒæ)¼‹ÙôYwâ㨜e*þÈV’%‚HÉ=é‰@”»K±†u#›Ê Z©Ûkÿµb—’‚jJDžà˜¶¢\å²VŽp=›¢9™»ù+¶T\ !Ã௷âÌÏZl«Ç8c=Ù“°dcØ„0 yÒR,ônù[‚ ’ÎNº¥Äá`Í!I ­=Ao ÈÁV]¦‹%êb!I n1FÄ ÈöZ€Y5z#heI „1xå3Fÿª?ŸØtí“ÀWúɨ¸K<î^ÎmD7(ÜÈ›δž ¸L~ï”¶ÂÑn(™_ÌBó´à«jÊNì‘Tò.w²I³ê¥5³Vh0cãî%¹Ã}s{ÃAˆ·²”%$TíȈH*\š:9Mˆã’zÕ^7øÁŸ7^škšI!ÑOèÊÂ×7 *²;‹>>‹k©Gt;!¨Ä>X²Œ!rš„”ÎUBPÖN÷‘œÜ O"ÿƒ"ä) ¥PŠ®º¯ûb28Ho€0 2:oARä%ZOItH3 xàèì @jⲞÎâ7\ªNPÜ~À²ÿHà‚   Œƒ¸¨ëBb.¦«<†à,€öâEîŠæƒI^í¨Vhgr¤‘:Da %`h,– Cîäš ,Frà+cxP:R+S:)šdäb7ö $çÆÉ ÓÊ=œ¢ŽÒ¢«B 6h CnŽuð¢Ä,vLÏ…Ôn£bãõøi xÉ7bƒƒÜ:Ðb¥ B-ë² Š€ãKÌ!¶'ZAÐ~`ê@ñ@  . Þ,#ÉÖŠ#¸,€*6Åf±1ˆ"ñD€¸˜">ªb1‚eNCáè (nqžDQ|(°j´ðpN…¹äoã8&-)ð¦Óÿê0˜âæ*ð/!بx-6è¬$`Xš*Zà¦Qì?j+Gn‰ZXHâO4ð¥d‚ÜѯçK Ì*Ñà²~£©æ À¥Á„oÁRÁºÇj‚‹in‚«b+¾ˆ¢YìOÚ¾èŽ+l¥S)’ÀËò~Â*ò¡^a/ eRK€œp¹¾s.Ež*` ‡äæ‘2†)¬pïCÖPr$'^ÚI·(cZ̈)ÄôáóÈi(Fé¢ê(E hèQ3n!:eÛ‚0‚ €z@°SζHÿ¡Šd°Š² ¿D[´³Ä"ÑMݨîÿÌ©|èG_þ„ÂÂ'þeOüfpk ©Âen†à:eAž¢„(ž-笢&á0ÆÐâT¾ÈA:ŽÈ4†kéîDnP¥QÖ°^šL 'Ç;HÈó¢3[!š‡7E@oÐb„"ƒ‡¥¢ˆ¢ál¨°td”ff¨¦…õd#dBàÐò‚€$nÏÍ­²;Í-À<!=P!ƒ£¥¢÷bÁÂ|Ðôì F‘8~CæNÊJÊèQÈ"Cô¡nÃ@bÅ3B£X¸MáxBCÊ>öÂ>ã È¢TÎ"1žæVsãÂÈî¨yÆ5S…Dd“)"G„öÐ$^OЂ<ÿ†IDà1@ï >ñ !.ƒ½ŠÍo„gQwbèÌtg?_à€°s‹:ÐÊS.åòqÏ7 ²Š^ÀÅ!yÀÜÌê´§!úÒâ=Á…9ñ!Óœ6ò&ÀÓZàN~(V By¢ô"Ó8+ó4ºO…cïòÁA‘çð$ï(TÕhíB£$ìPSc*Å'¥«Ó‚RQë,üÏQB^ºCLboäpOÊê26è<d4rá~±!èQMƒeVˆh6-!ÄrNDLx@m$±c°-«HJ²H#,<BJi¥Âé²,Ò!·”K·´¦\¤è!ã †€™à¤Òaÿ°j°LO6° 1ü&XÒ‘©Tᢢ»ÒBB B@„kO#é)dŒ€ž„…ì‚tì0+@ÔÓ,ÉÿB(^îö0eòD1G)lS¡nåºl¢rÚ Ðg,/#gbfÓBÌ€Ž.!ÂóHwõ:â ç²ëò0À.=ëazø†5!ˆIÁÂX"gUë’cnFŒ¸²Ð)\fŸbÈ=J°žmX²¬/L…®Tˆ>ð4ZA]‘+üöC*§ ÄÖà"S)îFºî¤!õU&µ;¼c’ë3b26µÒâSÿÁ¡bi^–ph€Âex'fÿng3T•¥Ž·fkº"ÞÓÿLånPø$E¸V c2s®h/9P²¶a‹‚*ôÁ6સ—œ’3-® !\8Q¦°+f‚z‚ƒÆ‰l‹ƒÈ5!æ–(V™ný*3nÄ%hE¾æñÙ4*}o§Šu¨ÌmIS¶¢mÏHCÎ.Ò% . .™øvoÏHbYCwKsÖ^ÈcO©EBç¶9öÌ¢{ ‹©DÀ?' é#4>@\c]JŸ3&öv +Z±8Ö"Ä2ù‚Ò¾HbœÃQr8ä_BX¡~8ê¶Fkt”h–Ó8OV¦ø`ƒµ6(~`0¦ÆÓ—m¯¥dÜàN®ÇéÒ˜$´†XÛø º¦™ÿËãþòù“ª°X×ZϺôy`f&Z.Êo;XЏ¹Qþ¡ ¤ -(ô+!²Â +¹!~‹<ò™ô¬‚“?h)ß 2J‡®N2rᮆbÓ‹E”-†b¦°¼r¾ª¸BD`Óxõ˜D ˆ-•4IÅ3I«3!«ç‘šôò£;7!Øк'+rÁ|¡¯]Q'ê¥*B-}ãÅMgkF|@z‘(\ E@’uUO%EOPºû\ïè¨%ਗ‰W-xé“ TúÉ©ëˆ{Ñt)ŸJR ¢,ö9! ¢º¡çk¾z»Š3fZ¸Ö÷$„Wmu<ÇÓV¡ô]ö²-o!ÿ`–IÏíj¨†÷¢™˜˜þl¤ýš¨UçþÓ¦Y}…Çj1ªXãg†œÈ+$(ÙY,Ä"Æž‚*0/TvEºlTÍZG†|”gX7"Wr‚q_PJ½Ø¢ 7ÚįƘ¹%ÅíÚ¤ xºkvKÖm#E¹>À±ãh¥Çæ†pc‹<›3¶1d'Æöƒtü­4;+4[³3޳7+0Y Èö C@P®lG/­zFn•°! *w^Y£0!|Û¬yFXªx/äæÎû :ãš|*`+–Þ·è£è}ëè›|Ô?Àþö¢'^!„²!š, ®¦ ¢¼ræ*êο†ÊW Oðð€ÒÆíBJÕú.GÚ1Ků™óŒ86KA`¤mfMžº·!ü—ååü ª²*äÃÃ02Ã3JõEræ|cÄ"4nÛg|¦ÝAý%ì»Þ\éSÿâà '|ø÷OŸ¡|… 7Þ¿yèi@H¡F„ôœü åãÇ|QBäB¨ï¢_ˆþ­ø'⥗3ÿ)ÔT¹Â¦Ê„ôIÈ—O£„ó6¾x±Q£ƒA ü3`À•«zC4ºJú¯ªÆÿ¨"ÔÊõ_X„^µ’›D‚±ÿ@€Ðè6)ˆT©j!4„—Þ¬†ôþ£€Ñz!’ÆLI’@óés¬O„äÉ”õY¾|r„–Q:þâ „G_ ˆð¿&´þ×Zµ„Ó`4¤ï LjÿNLüwQƒïéa¯$ÂAM~8‰‘¾3Í”Iáå DÔëk©0_… JøáŸ<„H:ظ4S¨ÿ®’µ¯±Û®÷o¬—Õù‘5ÄZhµõ]½•`‚ Öõ×€m4¡ÿFÜ@ÜHÿ×L1ÁddIöÏ/ŠàBˆ˜=–‹e¿è“âeåå“Ë!$ÁhȆã@°Ñ6Zi± tÁçáfÈjEDQQEmDBNF^aËÕ]B/E6L/¹ô×_-u8Ž·,üóÂ/¼÷Ï{ĹÔ?A ÕTxµ‘YÈŸ~]ùÉWaé‡(Vq%˜Ê‚ 2Øà^HDا…ÑcOchzÙŠ–¹"—’a” 4Ò˜Rª2ž¤O. éÂPeÎFšj°¹¶QA¶Éiý“$Vÿ´ÀpqdqÈ…RI!$im†PM$Ê$Ýf9n´éj %ÿGa'¹âÑT}NáWÏU~è_[É+èŸ^ºUX‹"Ôh*nÑ5×F©T5D_Hè•dÁ"â—•õ¡uœuzÙL1¦*Š®> gwÔ©–iÚl;´#kBÖFjvZ™¥„D'ÌóäpÄaZX”}Åc§¶˜±u]r×¥6½4¦4ëö³C|+›Gçœä¾0ßS®8•§»gÍËßa± °û%PocA*,£&˜äÁ†T5©Â†ÉÑA·$™tO†™Ç‘Ú1P®Å*B'1N£ãNokòìhù­?î[q‹FšÓË=É‘ÎÄf³öüÿãn€BFH!^ñà€ ð >W1À y•jd⓼Ē6x¡%mqK@ ””³!nX¿62©ƒ!`y©Š!Vf…ŒZ©:Ñ ä‡‹ÁhŒ)Ù¢¦BB’Öª‘›Žÿ( ˜iD5tLÊåþÁ¹¤@í.)ÍA ò›ë#ÐJKÈ*š¡dÓ™Ž:$Ÿ†<«kÈê€Wâa !Æ#ò®Ò®âðkÒJôâöC"úQF|Û[ & ¬.v _-&¡¤$ XH’t˜E¥iN#$ê¨f¢*Ç%.$!aPZÍS1S>xãl®)3“áqŽžƒ i¾‰# åŠe*L ©, g5[Ö´d?ÁUEw?ÓD³yAxîù¹O:L[òÞ ¨±± •2%Ù¸ò&B„í^€*$ÛIñò X@J ùÅ¡é:Õzë'Õ„¤U­ƒiëü’ǵè€Æ(Î :Â̧ᄰjO·àb5+ÌFŽ»š(Zafd¥Á×¼õjrÂ3ùq[øÄP p£ÿ`….’’£–dNcÖqþ‘º4'¤ESÍìfº8Éæ€8sñ ^| d€xÁ·†”#8`kP© Ð?Å)í2@=â*¬ þc xøGǴݤԢkA²«›è½‚iE·þèl%°€ÜÖ¦Yn 1oþHþ³~3é’î\‡’D~ŠÄ+ˆ60ZQ&$LØe8a%!# Kœ•ÿÛú‹ŸÓó‰”Ä‚ˆ´yf[$Ђ(üÇŠ{¬|2Æë!ø?2ð€»©\äJ) €ã;´ W)µÅI‰Ð© ¾‡JD,5’Q]"dÂuc !`fˆ ‚}AAã03‹L/cE`fQcn$ôÃÁï‰i4N«r3¡Ð¬wL&ˆ x"æŠ ^_Q¹ÎÐîŽæ5"û âaf9ä^.BªÆOd àlr€Â.®´Ú0®L¹Ž)Žý‹ã)*±Ï¸°jÝ•!‹åm ,`›lÅ^Ö15ß4Ä nÀu´Ñ13«V§2Kb«Öû÷È^Qƒh¯ ÍpXÀR0~4Ç‘ÙÐÿ}DÛÂnë3DÁÌQI™Â~Ó>¡Q#F\㑯,P5‡€wp5G±pÃs.ëÇá<:4qox Hd‡B=Ž0é…^‚,ÆrGxT17Q5b„“=—sö¦Lýw?UuLƯ( p¶(d¬ç \ÀƒDÖÁbèQ3ÅR ±:QIV"Œ¶b†3%à$¸Oÿp(ˆqwi.ØI0”VMáwx'òjaCqxò5!w†Swq°drA7²6[à,äóMUfA«£8&E3‡ƒ#…ø',¦‚ûUL.ñ 0€G7vÿv€)ôÀ€“èjA28C,„:>s[?#Pa‚½ñ#è\Z£*]nÒ&r‚p]ó5'qÿ°wq dP^³ƒ“ȉù/|ÕWå/±G9QD+¹ÈM—÷1#?äs»uo—±_ü…"בSØ §:€3Æá ýÀ‹D&Qç1ò0'ŒÑ3‚Dƒ1| Øo'0‚òàŒUc8>B™#07y„‘º58Oª!ô1 $,@JBž‘— ”`À«Œ-à·7e ð„À‹O€—x*¬°P'HñÐ ø:xΊ¯D­ü¹„­„‚Uå©Ac=wY›§Š®Æºå0Üb* +p ÿ€ ` g:‰~Ú€$ CÆÊ‹Ÿ œƒúvŽ  ©w ë³ ^b±¢`á™R1ss ÔE¥ˆJŸÇhTBáN`SÆAM>à™Ù°Ðÿ€Ð <¤#x2û€@³ ©ÿˆp¯@ C·º° 8q«¦p3IeX!eêã©ñŠ¥#Oë_o-(Qùà²I­“ugÚ(Ð}tVO zr¬‘É‹:0'´ù³¡ë}øêâ®æ`’a¥"rsÇfoøö´½÷:@So$q´mÐNpNÆ¡ÛÐ}œ0–8˜ O—jú¨¢Ë¼XArK4~‚7{@¡H$1-‚û>J¥Tí”!ó4`‚ö,º«»-Ð` çk -€ ±çøÄ‹Ýv«Ã uÍ‹¿>«Ð±C;GEóee¦H$f®ùÕÿ½Xê*xÈÌÁ:‹ÛM°¾-p-оî[‘ÌK0¿ ¹¨ܼ”*~òRŽDæ~†À¥ð#»XJhüó0ƒväë7$q\NÀ¾mÜ?ü¾‚G¹"|rLÄG,™LÐCÒƒ†PT,÷F,Ýä`ñ¨,ÍTo ;¸»E#ŒÆ:¶[Bís´ÐèÛÃܾA3Ÿá <˜¨?+Ó`Ä ŠÙ©¦F°ÕS‡“<+¸ê;àôP‘±k7ò´eDO1UÑä0Ñ$Œ&›…ñLÒÐ}صiÓô«Øn\Œ@¹ <¯ý> <Q`:rxÔ Ã3r&' 4v ÚÎÔLgRfÀ-À{©­ÜËÝ}aeÖµ±ËÄÇ@Ea#˜!<óÑçÈ],h•ÇZÄ$a×SUyKÚØoÌÍÞˆ­ÜéÁ¦ÊXÖ¬ý­½¯ŒðkØoB o~Ó¢ƒlíäß$‡ aÿAD¾‚h©c%-p3ÆÙÞÌØ΃§«é¡«­í;$VS êq Nݺªðô7£Ï\•àY6µ"ÑñNϸO?Ÿ!iýà)^õUï‡ J.™TiÐ'ÁïSgÓÎiØ3DCà i¿–7ý@ú¨ôÎD–ØPaqœóF^÷v^ßÓ ßbEËn¸JòÝÄèâni}øá›ÃßoŒÎè-@‚|øèá ‘¯lÀÌ x4 +O<ƒŠýwĄ̂d ð&Ù—0ógú K`Od[p©ÿ³ŸŸÀ°aƒqî©­íá!nÖöç1a‚„Ohø‡ÿ={!B4Œò!b”|6\Ho^Á‚-þÍ£÷^‹y$Mœ7ïÄ y,ä½lYðˆ¼÷ŽØÄyó ›ÿPÈà"ƒc ‚0 ò¢Ä‹#þÃðoHAQd õ¯ F0´ã‘ÔÁƒ«^y2Ä•ÿ@ý÷âÅŒ3ÅŠaÁrÅé§}ýþÜ÷íÛøºåÈ×ð?põtÆ?&T_~*ð‰ œoA`ÄÙ)èˆ$Ð;áTÃB‘ô6 !ãÃŒ [œ0é±…î’=–Ä æL˜ÿšÞ¼)ïÞ=å5,™Éâ„Eÿ=ÀÐVnÓ‚8b÷ÎcÇ W½5êBdÿ/Œ’}à Ú!a_¼ÅàÀÁ}Änðê0Ì l°‚Ó¯°Ã0€AŽ €°žµ\©§ z{ÀÀnù‡‘Í ³ @¼e¼§C‘RÃí jÉ¡ª-£PëèŸÝJÚQÇJh¡%\jIž™þ1r§{T9ãœZ’9šbû ­¨³Ê)HèÎ(¸ ªê\ = Êò޾°Äâî©·þ/Â,›CC;8ÀÀ3 CÆ Â*d¬/?íìk<.!ø§D ÑñBD„}J⨠6Ê(„…hó8lcQGÜtÃM:"wzÉ%WŸ,HÕ‚š\ÒIœl¢©ºÿ0ÈàK ¹Ä<þx}!ˆ Ì,È#^˜/- ƒ+®þâÍ<D4[7óL ±7«§BA± °ÐÇ.«0²¿<äl‚?ãŒwÿ™”à (X`•äñèjµŒLjñ¶Ýü.5éäaI¸V…“µ©$wzŠãrb’ºñÈ**¿îŠò®¼ë‚°ï:¿2¸òxàõe¨§•´ÚÛïhm.¨­k¥ý–Ü ’E[Ì““¯6€P =p±BŸbZªA³å2´ B”÷ѪÇóRJÈçšøÅmÅ ª-¥ƒ –'Õ [DRl‡_bÉX[øbédÂ)*ްøï¶«ƒê¼ÿ+Ÿ:œ#1:¼W¨²³2©4È ­™ûkë­ «ö¿½ðüö[¡˪¿¸œ>ðÏA/ÂÆôcPÀ <0B-m<9ÜlÄ-È^ ,XÀÛ|4¸·4"i$ü R¸&^Zbn˜îÁ€¹žXÎȱ,ˆ€{ø[|Žêþ€+¿‹*ËëÒD9gîP¹×£^è5>÷þÉåz(H îS•¨ÜupÂSêü£@ÓŽ#xÊÑ~–¡ ±®1âjP‚‚`˜È°®OSûËínç”5êjÁ›Ž»@3)Q  ¸Tjìf°lDG!Û¬'%åÐ-Jvó Mf…¤# 'ûGàdÿByl¤&KSËú’¸Íq;ü»ŠQÜÓ2#œç:x‹³ "²äçMÅšSê@;7q¤Tã‚Р¾ÊOv¤c~ ³9Ö)ÈOS™ î ¢. PD\c!ïL”¹†ûZBĆªßŒÄT:”’ö–³ÉñaÏ“âK˜$±'ñÄ{K¨IA–”Äñ%q'!Ö¡x8Y:…KEqœý²cÇÄqØ1€Ì΂h=mž^À-þ&tŠ~â•-d ,Ú}5¨ÑQ?xºTG!Žˆk*ä?ÄYñ|‘ Q‡@èFZ`(‰EÉòÊøR’m1—ƒVæT˜FNÒ,Š®¥YÌÒŽAÚ1Œ2ù²Ahah›}1Z=œºrapuåTZ„À…UÎÓDœá’î P ­ÐÇóü•\º– %)À‹e ¤yŒ &Det"šÝ»rg¯Ü%@¾‹L€ïùÇw§è+·x©;Ø©J6ºQ#¼—#û0B@–Å',»ïØòÍR8š¬JUúÚÁh6µ rp‚ŸY˜ÍmާÿO¤9t´q}Pu6gÒbÛGNÇБ×f¸btfWÀ×ôÁƒ”¬è6/AXJBNC€1Á‹[0â”à%(0§ÞršƒÚïª;¦vŠŒÑÎ-ï MµB i ¾ê—ÈS>û؇^€oº6 ׈¦'àX~:º‡ŽñÛ_|ø ôDb²¾8wXpœŽ¼WU9 ÿ&p„\zç»(O|̯Ì?bòÊøÆv|”M÷”‘1û#¬Ér=5‹¦91#:S=qkš¶8—£i#5"7<;Ö±#£á©@q@Õ¡¤17 Y¤Qp \à| A#øâŠ€؇ C¸§O 5¸k¸MC»Mc8Xš‘ì#¹yp1ÀÉ€# ¸˜™0ž˜˜$jŠ+™2Ê3´Äáˆ^ƒ ïˆ?—ÉÄóŽªP²} 2eÁ€!X¶÷ÉŽjŠbi‹¦H3ô@/-Ãàl¹¹`=ps0Ñ;3=qš¨¡½Ý› Øa#  !x+,üް€ã‹€ÊC¾*C¦h"X"/ÿ¡+!–@,š>”¨;zrŠ@(&bŠ½Ã•¦ð¾(9ŽÀ;Ê«2# Ã{Š+\2“é ”º3¬ŠÉY,™Ë€`c¢¸0&ïH&ëh×Ë+m =fb£ÿ8š¨c7Æñ r;—:* b£ùC@±Ý›š ò½ ½Q¨Dëx0AeQÁÊû,û\ G  yHœ¶À!A  G§ÀAF ‰éÅ»#¥3ä¾»ÅA¢¢°µ*Ã2˜“E§H¼^,(L²¾¸FÉsEìÃzpõš¦ö9FÁ²Šöúk‰ g*Ð!0?© c<7a£§«-,”8ù¯nÿá3R·tGŽ0DD$ÁãSÁ}ø¦Œ˜Û‘3 “ aHG!ŸB445O5Fy" ÌDˆ"B(Éž#½ŠBþñ®WÌÄ¥À“,‹¼Eލ©Æ¸#pEÊ‹ h…ýé”AÉjù¬ø ‹±‹“ü¦Ó;3ÕbºÿkŒÍ7l! ü&qǧÚÉÅðÆÙ‹¤¢C¿ÐCA\8“øÊ[M˜³¼äûÄÊ üÔäJC Ÿ˜¾ p‚Ø´\+ ð7†1ŽYKKì¹ ‹Ùãè5[€Ê[,F±ÃÅr?[T9)K¼,ˆ²T–òp,™‰ ‘A²”ÿ¬4¡BŽê©ÐÚ ?ìgŠ‹eRŒ9:0›„‹ËÜ,pâ@qÙÉ ¦;Œøà/pkšn9€@“½'ñÇC¼ ÕIJ§4Ad,ë[³­Ä¸TÚÊöÑÊN<‘MÎ\“vDÈ£0ÂóYK%D"“ ²$’2¾„Н*¬œKŽbOÂBWÏ3Q,”*WhÈ€ñ$¯dbÉ”ƒqÓh2p£ 7ì“=ªÆqó•ÃÉIsÛÀxCÐÂð¦9› i$M Á 0™@/|°€°ü§GüG[[%ÞäJ¿)/Îίb?%#QËñaH« 2ë5*˨!¸&{¿ðÓYIW þ £Èø*a„¿ˆ/ x ™C)•!;L©&E96ó‹ýÚ“eâ™LVe<=)=pzšÚš©r°Ç@5ZÔ:ÑÜ ŽHS›OU—yM—»þA¨ØL$2r Ñ“Žê 9ßÎ8‚*»Ÿ#`‰61©ïˆÎFÝHÁ`”©€!0üP÷4™s™¿pðìŽb»Â W8OÊA)WP wµKP'RB$Úb_ÿd×R…u'Ñaâ6Þ vÍÁ!øÏÕå‘’ÙÁ§$´ýðCRHÿp$íWhª&Ù£ b·­ÑYkºùÛœ鯡È&‹g„Üž !П#`šH¸H;Š0Â$í^)}Ðk1mGL0=âþSB¹ H›¸–!R™@*ÕY¬%…¶_iEàjUµ¢tR«&=D›la~ ¦˜dyQšÅúÖæA+«±qdæ)aÇéóÐ ƒþ“ZE=áó§*ŒA-®$e|p.=”†“<ͤºÛÅ„kâ2®Ââ²7GøD0š@øà3p_†tv«¤Mù_E¬Å¶0my2‹‘]{¦y?R6Qÿ"íQ™ ËÀ@ ·Ý²¸T’•}Sa:‡p®@,ü#<' $mìUà¹ã†1r›KiÕbE ŒÏ(@I=)ö4”?(E"º²kæk ·V!?ˆ¤)Â?"Œ ‚ÄwH¡œdOó¹9_æólŽõ|Æsg/PwGD&B 0Ç"vásÍ5ÂX Äበ‘­uˆ„*a'œP¹ºÿd޳ýÝ# çb—¸':ý¯\çšFj‚²üE`HÅÀZ…’ªåÅ7ÐLAP3AHWЕò:¼ØÅxIÛ"´µM7ÑÛô´GÆÀÅcÊ!X ¼¸0…)%1Éúÿ VX@‡ÒŒÀåPYŽgaÁnd£'öìq„aÁÿ´x#Ü£F œGhUl 4¸Ú«þ1ŠT@í_°ûdž‚*(Q)j ƒ¿7›ÚhH#) ^ñ̬çÅypúž›ÞTà yl„y¤@ò–§fU,[ŒQ^4%|à‚4ÜL_n–$‹¹æòdz{DŠö“G ðYþþ;Œ=bY‚}€ÒH8ŠQ°èµ0æ@d%«ôGJò‘÷$Ä=ù±&51!¦Š7¼IÊIXo»[õÊT12Qïz´SÝ"9!v¯µY E²†d©úÌtøÿ# Üˉb¼Ñ@vV9(ÖR G¸Ü=@€ €¡ €þáEwK‹¹ >ú„DŒ¦vÅDëBò$LTñWh4S¥p0ž®ùGÇò4‘Y¤xäã"<0‚`éÍbA¤LŸ§ëµzØKgZÖÉÎ 5‹ž™¬ „ÈWÌ.Ö¹ _V •´k¦ü‡Åz¹üI‘‹ÁeBeÉЇd¢9-yƈu1s–”n * îÇÈx™ÔDs'bûÑKE"à#壚ÉÑc ‚ó`³xj’PnÐF|øÆyÐ3§h‘ªTåé†ü`À "‚¸Ø¤›5ñUí¨Ôÿ}FAjÌBÀÄRŠ«4«,ÿA€{%î?â W‰Òò”ËBçA›ËP'+C1R“,0 \ˆt°Pɬþ!•! a©É°D~ˆ"ÉáeÀr»á]¤‡xË›°zÓbÅ)1-€ŠÎÒ²å©ApAøQ»’"¸ÁmmâÑš\„+¸ IÁ%Æ„ TbˆíÆy´r  å=+·.÷%ˆ+ÍJQyPטTrRöHU­ãîËÒ´`é1T!²R|ô]ñc"`yÈ<'Y<ä€1pöÄqNO´E%­-Ä!—°XREþQO6Weÿ CÀ'u@ò4 HY˜ÿŒåZ..¦X®´ì_A&*€‰ ®·¤(ÿ\É‚|)G·›€aó%ŸüguÆÄãUP7¤ÄºªEIiEÍ’s›ˆ<Ò£ˆ™Ì†71~¬ð&0VœœÊ4Ìç4jRÇlÃG*Ø×këÙ.c’¯0¥&FAò¢™쩺0eåJ ©ˆ±¬Iq 3 ×´5Ю\e-'ÐÎI@Œ”‹‰‘æÃ—Ú¥ÂuUó‰>ÕkZ ¸Ø«”ïì¹ ®<ØÌìsdm,76N·&j®wÍk_IÒ§nV çãÒ5êǯ`Ñ”bu‘Y€mz{‚Øè;aÿñ[[Ü?äÆ¸Åˆ4‹El9±V132±Xc’Q¶.4«ûz-ȯ¼@ ™ÊÄÅXÙHj!&Ü §}ô×m»y"A[ÔWOÌ GÈÙÂ!I2"8$ÚñVý¸Ã+•ÖV‡Ð –}j0âRoMÜZ.Å/'È\:DÞ ,˜1ÏaBíʹÒ;õ›{PźVt÷£™UI.@sR2šÁÆÔ 6ž›rU|–ªüêž-x‡®ë°7„Ë 6äsN«'a“o‰0‹*B Fý§9‡Êç@,€I¿ë]ÿ0%ÿj.VW¾\¢0®%F³óšú©,Ìÿ< ¹#ܯ\‡‰W1‘‚Œá+FÐxâjáùÀê%I >Rl#›ªÉê¾§7sT,Z_g{ñh#e ÆNñT¾72³6¡ÒÒ"ô±Ç' Ф,’†V˜CW’V9§ÄsÿÀƒ–h4Ç}„&QÜ6áEùCEñˆ!Løà2- Ф1òCA#µTÒ~£p ñ…%‘F‡UG ‡€R HM:O#´!ÀaÃCl†-‰6r—>*bÑòðò}Á3:7´ôP •KZ„}…Æ\Ø—VàwV—Ã:s~øâ8Žñ­€ ×ÿ€ RsdMHw$öÖ ð*À€ ? ÀSäó4SÆYR—ˆTpÿe7³÷&ÃT­h`ÀY ôk·fI$$lÄ£$Ãî# £P|F¦*Ma¦]•ã3QV6ÆJ2V\Æu9%ör—JEV²t#Œ Ec%y¾¤4`=È")*ñ§WÁ%­`oQò%$et¶Höxug…S×= O‡…¥!­±xM¦fjÂ{2#aU+àqÐ -"á/j¨qaÐÈ%bÞøwé"Wýs9[FÄehÎÅPV\<£På?ì1]F¢C!—ðcæÿƒ AÔðØ“óFžÖ~ETqaoÖ{Ó!Šôz²Fkp=0t724{ÖCNHTÎãYâ47]¸QIÞó;±H>4q[L±ÿðI/Ó \¦AÈG‰>R"9‡ôДÃgah6F7cm1zØE+¶PÅ5W²$KÀ30‡ö€ Ei·Q¨–%7°–7ùtúç@IÁ:nÔ~œèR†jG‰M&¢V'L‰=±÷MÌÃBþ7AõYÿ(TJ‹ÍRй'l|3>çq_‘–"q”€+,âqU#ÖVrhmÅ3ÇX¹ˆª’r \„'hµäE÷4öÿ F5b“$t´‘‘0 ×°Ow“†@‘á*Ÿ¶µ X·C>Ayq_À'{Òš CpÒš=3uo“H_örS7O™›l—”0>- !‡RˆÀ+¥8¸Âa±Òç.Ã%øãJ{øç¢' ’ÆE˜c1PÇ…‡6 Ô…–R@¾DEáT±/CJ³nLáSâ"­ME´zq€e'æd…ñ'üupfÒ¥¯ÉDhé:üWŸ=¸ ÿÐ~xpË |œu1¨»°ZÊ ª ‘ä6º«Ååt«Ó=PS²»" Ñú-Á/šÑ{U©»%A"iOÔJÕ ’V$ Õg2«‚P\¸De5£7Œm®ÿ”ÃÖ–Q»E©k¸ w;ö½rÆ3qÃWsš £° Í€ N“M$E¬¤È&d·CÌB¹C±j7°—À¹:Mv––R±”0õ¤ôË|>¡2s‘qú°E“EPäEÔ›\k5n²$Ãßú1H\3+ˆy¼’3v\þ#&}ãaMŒºò8%P#œ’$¼òIrûiAD?¨¿˜‡A%q$T;ÅúXŲfNs]J«¶ë –ul¦®1gHz„Êš5æ7 Ða°‹˜BF‘aúà[@\$˜…Ã[K)†KÈ\0Èz(*èÿa\þã?K€È§äK;8#¼u•#ErY~®tÒñ·®TQ„ùŒ›’1¨b„ÃŽyÖÖêRÃ^eû3©Ž‘g9Òa((’‰cój®âŽDfÏÛC>’š xº¶žU…p‘ʪÍ Wp¶<ÂGòddÂ=)e²``(ÏŠÓð N±'¼%|j$O†ÖË3?ÌÇÊ%x·¤r„\½è›‚´4ÈŒÿ]ݯdmô@–Í?&WÃ5l‚)!p$½rÎZAþDxV¿µ5O+œXš &bЯguÈÊýµÛlB  J,¯«pOiÞã;cÑ=Ís»qZ§%2¶!™Aêc‘@[E ".×–Ç‚]Ý •‡|œ’]*÷ŒÀÜÆz(cÉ%’’]³â{È5˜? £~9•ñ貃O7`qÏ Z;¤08¶@þg ±šoÓª ǰêÕ±º¥Ös…ká1®6=´2rvbBÀ-}Q#Ñhm0QV åŒ á}†f’É5Ø.Zh%Î|œK}nÈ%]Zÿ”½5,® +NôqÑ+´ªÿÚP¢Lÿ ¿øÀW¦çßgK=«¼šªKÛ©™ÕuÃÐV`³»U®i·`J)S¾¶²™{¾ÆZœN! %0»ÕÙ‰Î^´âÜ,xÕcyøPãÆb]K0Îs“4.ƒµÈÆUKP¤J<“½1q.aÕ(ïÜÙßUãÙA%Ê´ ×° ›ŽcžC¬úµÚ¨‰º­ûªe¶n“Ê^OÍsË\åz‚vgíG>hS&À-Ojê{(ƒÜ-r(Š`¸ÜÈ?õ­ q}Óhh&í¢Ô©ÍÑlUè3¶’'ÖçÝ®½†±J¼%?·á8éÿº ‚´yM3ANü Ps0ØTðå,‘Ê{©H¡UW…T¹X*¦Ò¥_,Î{ IdáÑ,wöHúXùÀ¸Ô*2Fw#‰NVÐõ}…\ÉÞVÚ¼˜à¹r~Þ£ÃuPsy˜$Oòã«ñ~I³|ÏE#ÏêñãD|ÉQXaõ«O£0dú­©çé^ÅþzSÎeIZ¨ ¶aC,ßÓ&ÿ:ô‚BôŸÛ ø¯¾º ¹v2þ’|KA|CÞ³Ø]èÉ®Í36³ hí/ÞØ- ÷Ãyó`r’ E3ˆ­1PÃöÓ`”Þò\ $?>3/·‘$FIíÿ6ÈÀî< ?€¦G6Bú†Ä”[Šf°lô´Í{J¯|˜@£gÿ…˜Â?Dÿzºð{èiºK`A@ýþ1ÿ‰)¤ÀŠH‚ÝÓR0 $¸à­¼€Ñ´C o0d‚s‰ÄË ;ÅTÓ,&Ãî2Ë2{ ÇQ R­µÔ\8à$ã­ Ûhˆ·†bÒÁXàŸ·"èȹ´þ¡‡‘.”‡:¡^s½íÀ SMë8€ &•ÒËv'Ÿ¤Bô©±ô¹ Ý…6)¤êI?¥"2 ÀüJ@˨9Ezn0Cƚ๠¢àÂZöú‡C CE$×K­Ñ1È6ËL2R1#±ã|\¨ÖÙâÁ8ßRH×QK;HÁz{ˆXÉrCM É$‹k…VXáŸ>š€ÚþHºvªkÅ[ ²í0˜‰œ‚ZÜñþQÿ¯Mö°“ǽˆ¢h·(w÷ IPA âߤäIt*«©¯æy. óAphÈ,À™kâ¹*¬´‰;N1ŸoÍL1‘=ƒ32YVÉ’4‹q xa~è7Tz® œy#Öæ !.nX€Dž©Ë‘¦º%êÐ\º'~Ò.¥ ~‚L¥òŠOMœ|’§‰‘ á*<}‘éæ/¤þ¸ ߪô›J_¤Jê*¬*ؓڰ²œ AL÷&¨/ ™õ(0D*èX5Ê;æÇ"b5´Ç rAØ0“ª†P&4ÛÑÊl%¦ÌÉ,fFÊBÂ4IIy×΂&ÿFnšGw¦âÛµI&¼ O烙¦s'&-ÁI Ñ„4æùÇlE³à/}ìél\’Ê{H2 ÷m$`IÔZÄ‚®„e ’A~€\ãaAd×9êÊV‹A j¶ŒQ¦q”) ç±ýyFc¹Ÿi<÷ذæ!¬ V¨”„A-))7¬!¤‚F*ê(Š “Ot稩0'2Ñz‚²¡X‡åAwî4Ÿ4ayjË—Ù²ô=å.?ó\¬G¥¸Ç=I‰ŠV¾Ôü”„ ÒabÿÁˆÄBÒ"Ä2!‚|‘s´ù‡âáLý•ÌT–ÃLÈ>CšÿMnr\£åCšÍHsBòQiÄD@ˆô°!¿Â Y³¤Úd5Âa"B·é-‰:¼ÓH›@- B¯í Q" Pí–X•¯”D$\Q›KªøDàŠ~‰È_Y±L/§­9­TÕÎüc€!•e"â‚FF£Ž èÊsB°!©d± "È V8®ñ™! À |O_ß³ }‚Ÿ\R(/$S¶ªƒ¦äA””ZQ›VìÚ‚Š®EPùˆBB2úWDàÆqsœ¢½’BG)ô¢k]ïµK°lÿ_Ï‘€]Z|DŒSøèˆ\<«š‰!Âüð@3˜¸ÊäIž‰\þrƒN‚ U¨°}È5árÎÕt†T÷+ ‘ÜI@ ò!¸QBžƒÁ_q!­ƒ‹!Bò‚¯”`)Óá× §ƒV”j ^#uÊ–‘–úI —êô¼,… •pVð J,k?;ŒØBˈN`©–€ö¥¨DÍŸUIGrƒX CÓÐÞ!µfb" ­>L`¢Ì)Fœ—ÙæŠH$2X%V&XÑQ鈪 ™óœ¸ÁfdN‡"™« 0Vkò:D@Hà1æñ%š ç;×úä$kÒ-tË%rÿR×]»´_i™lòù@ä=}ˆ ¯¬»€WÌW""Hï«=³H‹K÷âÊV~üŸ^Ë$Gi ¦î‚‘.¤oœÑmwDŒ€&HQQh™TÕˆ³êj#Ù®qECÍÜŸ£*”Mu7·™à’d£¤2 ´aqVPŽTê²WºsÃ#˜0"Ÿlë[꽩ØÕltÊžSÖreõæcOîÊr+W@ ÀRÂñÏD`XóÖ‰Kò¹ Ÿ‚(ÍY¬ÿ9W1!þãBî[Æ5–‘¡æÞÖÆÂñ…h9Ý.î3¦‚ÕP]T—¼ÑÄ-f&dHÔ¹–ÁvH.³êÿlþHºI Ät5Ž"n@´Â"Ú]ýЄÈh¥I[§Ã¤É²*t:¯öÐ{쉃îó˜W€—ÀF Ù‘Ò”T1ß ^O>õÙ}îÛF¤@‰ìÏW&0!L‰;³"H†ÞBφÞûcL¢ËHÀkµq[OÈäÚ‘Õìs T±Šã ¬©rœþ\AXÇés¡ï”ð‚‚H`÷ʶo®>;\[³½~ýkúŒEØ+o¹ŒsìÀ¾—1÷%”dWþñcvõˆ}™çdIZŽIöc]D,†¨À[(€—ŒB‹ñsÐàÞµºfŽ€D‰N‘ÅDÿŒÔÊ”8©š¹ ‰)#öÏåÖ•>gPWüÇw ·4HV‘«$óÝó&Gb·÷]–ähßÁ]MÐÚB„’ètrJâÇ‚ÊØÄÆ]ÿpì1¸.@Ħ…ã†àˆPˆÞpxbÁ˜’ ¸‚ Ù!éâ S!t¤–8†"/i”I! t‰ú3Žœ’03-³e3Xì?Ë;'úª¿*zŽÐû¹íI©q›_J 00¼³dТQøú™˜"(­Ê¨ =â½”áºSñ0`ÕB >”•Ä”’Ò†$ಚœçÀA¼àÁ ¶˜p‰£0!ä$s‰¤­ vY‹µà T›Î«;U¼ˆ,Ĭ÷R—ÈB*,ŠàÂfS˜ÿQ页p8Û òB `j˜·Hš··( ! >„ˆ8š#R#tš7iÌC¡¦~#8Î;tr'^I»#q‰M3®l$vª4„¸äÄ·¨ç+ª2BA¢ ¡TÂç)Ÿ;1–3Žú¬†|¼ÿc¥S,l¶*ŒeS¶°¼Xús‰`Ž]”nëž.‰¤¸Çd‚¸¦[Ã∂(­áÆ’y‹FV9*ŒˆV):';t<ÊÏq*Ú8’Q+E$Qþ š El’ Ò¦´€ˆÀ‹!¸úÌ鲉kùúÄPd?´‹«Hæ0ȸ¸ŒÿT$¬†|/ÀzH²¿WPšÓ¼ƒ¯ÿS6ˆì­SÌì6£ÈÎ_²Ççx¸ˆè"sÛ PÁ~à…iZW™‘ý´ªÆ) 9AËQa#ùÊQ[Gä‹„èÏ׺>ƒ`D„° ê뛩yGÖÌAÂ25½Ë󊈸5¥A­DDþð9DźĎU,ËPKãP…Ÿ1Q.üUШ¼ÁÀ̛ˈ¨p ¦˜Í¢Ø ‚h‹{|¼`Í<û‡kȬ #ƒHLRé=ˆ ¦Ô°-ÿ9>‘Ù&it£:>“¹ÒÙ(ÇrTDÞM¸ ’Ò¡Ñ’C4Ä|8Äà{¨™ÿ3MÓv’ D`P׉ˆ¯Ú¥¤á¸l餉,±ųKÞ¢?²û™ÁŠ@Àf 3ã$/»¼MQ0k%BýM„„ŒÜÑ ¦t Y†Ì"¤¨jO'µÐ0ÑИѨ&ψ;œd£+ªšY’ÈÕ„8DÈ`;„(S‚@G~s‰”+V R|­‡ˆÓâ ‹—;5ƒÙ%kÁ¸²¡OÚšýxúP9]<ÅÛr< ø…ˆ$NDu YdÔCmÑ)Ñ<Í£K¸Œ0û˽¬1¹Ç„i Cˆ ý‡f ˆÑödiŒÑHØh|­WíÕȨՅŪ cÄÿ1MS_IV±Ë@Ð5¥±bP1QSŒ­X~˜žV² Ð;‰š Ž¤ù5¨ª8¯Þtˆ ¢WŽ–³ÔsÎã\×MWY³ÿ‹øJQÈXŸ:LȘM¶p¼†Ù#UØ)O œ™•ˆÝŸ„½ÒWmXVuUpŒ*DÌ MSd… D”Œ´-Š5DäÓÐ×Ú CºÖ¶˜Ê‡Â«Ð\;A fµË¨šž_Ø@,— @ˆQÉÕŸ±B-ôº<Û)Q•- F@¬ûò± " ‚¸aг!ý”;£á« …UÖ Ä†Õ\·­™5۹Ŏ[µ]—€ÿ@Q{^p‰âýà…D6DX Jx‹ù –›À ´’’¨Y—°W°6Cè˜<)¬;C]Ú‡Ì\¥/ ©ÅÿsΚ;Ú)ùx©ÑÑÝT *¢§ýh€†¾…`1;¤-ß-à.^Ñ8Þ`µÝá[·•Û‘^DD`È0u˜€,ù((›p _Š-QÓ—§úW„\W¤=NHUQù‚HçäB¸„ߨºÈ¸pŽˆPÀÐ= @÷ºŸy…KHÝfÀ…®ÞVæ](Œ'FÞPÞ'¦â ¦àà%E Uà&v A!ÞˆPzc¹=Þâ-^(^ÿà҇㈒hÙ”¨ ¨‰«#ú\¹”²ñÁ¹ñÍqú·T„,ŠC=TõŸ™/м·Ì<—°a °áÛò(Ÿû‡–í±*2„Ó•ÇsðÀÁ…ø•SÁâÜÀb~b{8åš!eìà*ÞX'˜bä5^‚Pc2VcÍýâ. ã0ã6ciÑz f ø‡3¶‡VfŒmÞˆ}€3y¤— ˜)ëJzØÐLˆ=I\êy\Ç#_Ș/g3dsžË0[ÑŠ¬Å¾41«D—`´8˜ƒ9áG^P¥ø…K€ˆ·- (p~{å3NVWDvP^d†‚6°‡6àâÿ¨¢è.f1öe æЀyØèâÕ€ca& 8i³ÉèZ®e‘Þ+ >ݵxy(”ø¤š-iþP¯Ã}1ù7û#,s~¼Ç3䯋–s¹¡fNçt ¸Èð2<“Jñ×xdUøp‚\àç¸܈ÛTVÓ.k‚ bäM^3ö]þhƒ0~hhVöbd¾ë( Dœ6éƒ>æ@ôëˆ@é¶ökÞðŸÙ1ê8“Œ{ {@ ÇVS‚¸“Å»ËÃÖ!Ôú«?|.j|þŒTLÑK@ް~dd{d/4 ‡Ðá¨"mЬ†ß^hè¨f€1.5žh‚`håmhäÞ4žëº¾´äEi‘–îÀFf¸&eÞh—ЀØîê¶kìØkÈ î¸.^eV/ ÞÈ™¾` Ua‘ØéåÅÙ‡Àp- Ç›žºt< bo§ˆ¥#¹øˆÊwY\@6Žx…êÿkJxjDu<öÂaÿ|@·GÎB‚è^Ðç¶MåüJã˜hä†hd^q €‚=iä–î>çs>ßnà…ë:éc.^çVcи¦q÷%‚xq1¡ôwñëŽñ.ÌèȲJô±h‰‹ç8Aá$H}ètUAÃ(´¿1 Nw¹ž|AˆÂ«øÈ8ׇ_X6^ruÅÕ¦!Pí‚¢ÈÜKÖ‡ÁÁ \HÝ}/dçj‚Ðm}l4>^C÷ó<ã>éÂæëçóôç^iB‡qF_t–6êé¿ô.¤t“¶ôs²÷.öez¸Ë¸ ‹(ÝㆊЇ¨d U»ÊFr(t ²KÅߌòÿ©hŠßŠgо’?_ËŸùu.çÂK8öd_íÿ.y@«"g¿Œ×«¹ŠPÑÕë}Þç^ Øk,fñ06t‚@îsßóY®ñAßî@wô´†ñ´>f(0†Â&f¦er×t¨Çî(£›)aM¼¸!ðgÖƨ´•U¢›ù 8@ƒï×Ö«¤hP ó Œ('ãø…átê/§ˆWveoÑ ñ¬·"‚H])ÑÂKà²Øú ÿ‡"(鼿ss·è¹¶è•îy§|—0¼÷(Ów@_úŠÆ}zÈ8/Š€½—¸HÝdo…!ø!ÀËýf/=ù˜ÛÎ%ÇEÊ’ÿhK/·» "•ùÆgaod‚0ùcWvÖ4ù¢ŒÈ¬QPþ¸¤„‡êeË…6Ðç^PfìèsWnçsCôÍ/ñ£G÷äÆëíVôõGq Ð|blAì¶V÷@|qÊÇüÏÏôã ÿþ©(pà@{þ!Š`a­Í¶ú×êbÅ…ù"Ô÷/_G ú<òóˆ¡D&An "Ê—!8ŽÌ—o$ΜúDð\±bà«W”^²pIQ!GÿmÊp É£€ýCúa¯W—Nºè…ÐÉÉ6B!ئ, i¡TaÌ-c'ÿ©xPƒ ¼jö57íÀ‚'íV!˜Ay ÿ¤wpîØ1Ç€l™ ÝÄ/>)ž½ +VL˜ÅV,Dˆ !懡ÿy9¤I}7£B¥=’¶MÝoÛ,3×Ç›ùr-ĉH„ÏŸÿ|Pºt R¥'¥ÿ£@¡5²¸Rzé•*½¶töߥ„ ÓíŒ×àÚº˜Û¶‹·`Yž ”Ö^öOY†Ñ³˜ ö¤b˜Y&ØIyV_eté%ØAy=؆ŠÙµØ}þ3Ó@¼b‘¨!”ŠEpb>! wãeÀñ•¾éÔÑ0Édã‰2‰V£KÍñÝ A eÔuÿ\…t¬PÚ@¬ýÃS½ô¢Ê?+ôÿ BB˜„V‚'¥™–am¨ BöǦ]™ååæYõÑÕÆ]Fؘƒå¸áŸ–iPg`™øØ…búà‡'9š=6êƒ%>„#jW½vŽ´ gSo¥î4—§ö(ªôÌÓ‘ì†C-øG=þ䤔ìmµÕÓu'ÝŒ£H%ÄŒ¹ðË/_Âç• Aà HýA6àn&jZ±9P~˜­%¡_9VØà‚—©° ›é^–!¤Œjæ¡›xÕ롞¶Ûغ}`È•ªI)LDÀœAE )ôÏB²Úäpq6ñÕo¨öÈÓ©ºd#=- 6dLIæLéú*Öm…””ðA6ÿãUÂà“ì{cÎåUU>Lœ£ kŠ`ÏÛ]ùV¡e?6_AóÍ¥mºû2zŸ†¸n[mØ£­Xڛ؛aÿãØØ:ŒˆwªÕ‚”0!E¿ U:·l²†G á˜*O[FwqrQpáýƒÏ?+¬ XÍ"D&BˆðÓô?N#d°¿Ž–ì Ù~[êÞsÐÛØzƒæ{ð\Sˆ4c˜EˆØ›È TïÓ™éE4A Ñfã­Ñ?À¤Â"8îªáô˜o=!س~ë¤â(zèM$û®º:<'½ÿë?-ÌCþÝ~“+&!¤(ð™ÒP’åñpî”(B´¢õ6tåYd‚4þQ„È'!8É]׺t°eéà\æC˜Ø9¡A`±G ‚¶ÀIxq€Ä"–½ 1îR—ÆV=³ôËk⇚‡˜½¤«  oÂ3 ´bâ›Ç °Ø‚pñ\Ìâùè¡‘ÐèJ>ùÇÒ#},ÄF-HœÿÞ(yÜùƒÀ? ‹èFð‹ŸO|à„…(i 7Ç2BRbEàE/$ø nÅ+Ð"ZW€|Èg“sÙämB¶O“öèä)9¸Â8Á†„QA G ™¾nÿ‚zgäå|Yí–¶Äš-ïS< “ˆ;”T)ÿ1„+™¦¾ ˆG^5Ç9ÞƒŽÉß 40Uj„;ÛR&1eòQ[Ì÷ªôA û«f —‹žH§žƒ$y ˆ^"X  ÄUF!ŒñHe:`âÅ@à䕬 ä¸A6È€#$,£¹ìÁSr•ääG6šN’0$KÓ”Ò¦°la“—ˆæµ<„ÀÉiK|©/©ÀDh7ÊÄR–þ!BðÆý5Ž@Y€ΨŠ r, {࣓8¤*£ÿ@UZæƒ"(k’üÇ/„q$kgÈù‘¿~Ó†¬`+P€ÀæC°ÿì(óAN††0®Sšƒ2{ „îÇ?r×…86`¦ëOurM5(§!"“X:ôÑÎ`àHê4™š¸/n1‹#,€>øÑ¤‘:?Yc:†>êCc“§ß&îLŸg-¤Ñz•8å*ø¨x„0”A¦9 H36Q ê£üxïG¾ ÷Ò¦$ö îŽ4xøj°±z«€Þ<ÉAŒÖògÁk] E ®¡T1‚ò¡¤8Lz‘˜!ÂúÀ§L)ÃmUÄ#R«)ý!óHÿ‰•ºEĸnUeõÁ+~²ÝhÕQ Y˜óŸŒ•;'Cæ ¹šª¨X¬N[¥4`à¢äuê°r Dô°ú@„!®\+ó#“åä2C&¦:sñÇEÄ–·Ì4kðƒƒ}óê4 ™@±X¥œÝ¥žŽ'(;f]x)T„*lÄ ßkl¡yô·@£¯ @J0Í7.îÄŠã" §Ô%üƒÓëb tBéÄ8tÀI§ù>F$5ni~–¢!gÝ>ê@—áu.b‚j¦jØa;“Àò?̜哠9¸#Äå„ö¼ ]6Ï–—ñ¡d×§íõ1O_XûsئÿýRz=Û$hû‡0„a ðò€##ð¸ê¼›×§Íç>ºJ×Õ¬6g: ÷Ÿn©G¨ëÛ\F} €ú*;G¹DZ)Á]€fI§!Šz,s^„P œ)"öe:nXd—sbffˆ!Œ¥¥0xLãa€<{ŸB }nª\|8!Ê7Ð?;h|!$­Eˆº[œ”Œèœ‡á.8üÝ›ƒ'ñ˜(AÞø•Êœ•"­ZýoȘ5JF1ŠrêD`Þ-Ó®ÿá%¯¬HLûœË à¶èî0n™ì8àÑ&øü½Ø9ùIN^ÎCÆÎ…²¬›^yç'ÊŒ "éHÿ"¬¾=Dý<3ˆAíg8xe ´âm<@ˆ¦+­8W-®ò`5ó÷&pqÕ(Û:Œ›$5žÓ%­»[É,³#ë’§e„´Ü“|0#ÍYt¦qà Tá,CÎ%Y¹ÁÇ)pð~ïÞAø ßs?eÑ‚ÿ@<޶¼ ~Ø* A£ à±Nò–AÌåñÃø—¨Bz¨‚pøJÑÖ@¾€ÛG¨¤Ý ĉýqQ¥åÖ4ÀQÁ޳ͬ¡‡SŸèÔD>D=äœÓ\¸€>D˪ æ…Ô  žDÚÅÝ ÀͬRÛ–HdtJüB¤_Šødˆÿø}ÜIüBöÄP°Í•$YÈqáÞñ]ÎüñŸøÍŸ—Á_&©È O„tSB€Í%Ä,èC.¸À²´!˜°úèÙŸÏ‚˜Ö…|Æl´LŠÖ dšRå5ÕÖ?ppn5Á»­àv€ÉÖ!ļÖeß’ÔmÀ <öZèLNYÁÿGµŒ>‘±Æj8Äöh zQ‘üÌ{Á5"Ä´*á+b!DN™ú^Çž.ràuGE.ZEî¢ðX”ÓˆÐ\|€çÉr‰ä¤Jr5‘ïˆVŸE£‚tÖÌDT¬@0Â@ØÕ)Õ5ÝC â8¾Û@¸àÕ‘`y„‰ð Dñ„H¡hɧ <Ñÿà äÏ=”æ6ÚÞnùbT‚ :†Î=fßq­ÑSÂ`JŠ%.P>þŠË,RYÜi¤[xxÎ@¨÷•É3XD|Ç(ŒZÞÀBz‡w$!ÞÞFöÝÎŹ=äFa,öeaZÖ æÂ<#|À ‚úDbÜç¹0fÈhÅ=Ä€ƒÌCe~–^ŒH¡ ‚lÀO@½ñ¤i²Q½Ûþ$λâWŒ* ˜P¬ýDkB† ¬ŠeŒ{ä¦QT‡óYU'Xþ20œuœÄ5@à HÀÌUÜÀE,Õ”Á%_z¤È‰\üÕ¥wÎE|@¨Px2ÌÂÈFê€=8zº@>Tÿ¨ Ä=\úÐç|ºJ”Š–}ΧÈg LæUYš>Œ%ÁOÎ!DSÑC;½‘iQŠ•=`t°# ÒQ®Ö™uY]I(ä¬-œSœ"d4C3ÄU<Ó@çÖaR°ŒP@®‹Z¶‚ZÖÂìÚ‚ÈÝ€¦¾ß°edáååŽæÈ_!Ä_ÖëXT|^Ç8’*éSÖ#ÜdBÄ@elS ü#|Æ‚lÓdNé–ʧ‰ et&jD$€ )È!ž!,–áköeF€1l{—ûÎÑuÌ‘:rìÆF<©àä“‚FÝ #èjeäª Ø§ÉÎ']€F>¬@S|NUùüù D@kÿ(oÔP„ y-„ŠNžRIþÞµâc£>ÜI+U„¨DtX‡…¨ç”h‰ÆV–U€¦âëüC-ÄU*TѨVÂŽíI,llÛs@G­€GpÄtY>P¬«:Á’‡KÄ[¼ÝÊ•õà Æ„âìí<àäàŽ |žØö§ø0¬.ΉüÏI¼ ½mQ¾íY RIϲ#i;nkèÐÿ•…šLHG:æSË̯R¼«ÓžÄºšFÚ¥Õ@à‚ˆÀàæ*#”@ Á?@×~/,C-€@BŽªsÙ(ÛñšmHÀ[Û‰Û ÛJ€õ2Ä äC ´Á¹*Uå-­B@D€P=¥JL˜ã†,á^Þ`¤Þ Ì@N:ic``Îv‘‚ß\ŒÓ=­Uâ#Œ…Ž*„šž]¥‡æÒ«Ú©Õe4Àë\ê\ô'dAhU‰áïþƒüC= ÷xO¯¹\€P]@óVÀXo°0 ;¯©Äò&¯ÙZÆàôVŽUøÂk ú¼QxoxÿD¸¬âÑàÂ%ø°æµçUµoá6†|>)äQ„@ãIJJÊ«xQSi€¦íYÓÕí †ÉXM—mÎ…tpë‘YêÒe°ë@ j™p¶ÂX胥!DR¸Â‹ „ðæ0Bèáèá¸ðL€F²P-ÄòŽê©.À B‹™ o\ok1=ìäÂFTÊLL@yn.¸m….I&ÅN2î?ìmà2.bÄ€L ¤ ¼†áx ³z‘Ç\•2«ýD“%BŨ¡Œ‹·öTèv@½V‘KÜÅ«eê2¼ë3LYa]#–S‰ÍѼ3¸"ÿÿœ„/üÀ<Ö`æ²+ï³`žÄè!#'Þ-€±òÑ,)6×ñ>G:™q Ô-ä¤`¸²+'›QdU Îòç}šêrà‚Ø2ß$"ŒG[­›s ÎÿÉPTÕÕO8…Ý¡Lƒö›ß\LßH’…:Òï5¯eG‡ó»Î…j3œ¨,€Oðo&èä@ ð@¤BB ô¨âd.çÑ@CFò2¬s­À ¸äThJ²Qs}À ˆ@;ÇD['±l H@#B'ƒµbªdúÚ/ãŠt…ìIü ºY\U¼"ĆJã툑¨Ð#Ï–‡Ö zTëtEY]µG«•"¶â#‡î£&BÆq>ÿÃqj\¥è¤Ä•FÀ@ÀÔƒ °=÷ü ±•À<8õ<”À@èönÿÃ-äö-0ݨ 1âÞ^À-)2’ÉHBlŒßÜšDGL+[tCèƒù„€Ýº@.ÐX^ÇÛ³/Bð5%?4\\ ó‰T ‹ÉPªNú¬š®à¦Ë”G¸ RLKRM8%O … æÔàC …ÒÎE\u¡¦j¤ÝCôHc‰]>dÈQ½À!ÏÀÎE+€oëö-@p ô-@@‡×¶pC†nŸxÀB†²V²¡z¦Ï«6¥H ñO¤š«¾D ÖMyô «Çh7’¦ à¤ûZõ@ˆÿ÷^çѼ‚¡IL ÉòdXª…@ª˜ÓØñ´SlEL‡Ée,ǬˆÝÇ4Äñ´ËË€6°¹È?òtI` ?=м½Þ@ìƒÀ÷0€îêîˆ÷?tp{x ÜBpóöîþÃCÆÜžîõ¶ð”êóêÖb-Cô0ª!)ÅàDöxt߸ÝâmL4%߀M–qÅ:v¹+ëmÈÚo—ôÞ¹HE,ï|üI†õ>¯ŠœVcS%½ÚévÝÒ-÷H#NG€ïšvÐ ¢°›VÞà´¿‚°MŒpíŒdIÚ”T8TÏE*¸ @‡søIºlo8B°ÿ@¸ç$£ëä85ï6ú?85Ö0dTzP@Ó¬«zù#Š„AG·tGÝBÎL<ò KÀÀ7Õivß$Ư/ñ5Vóõ‰!j´îF¨ 2ÍÅ dÝGÔd47è°›G€«3«…®—'1÷[Lov–TÇ jåµ;ÐfsRÿlÉsx€G|Ðm¿À?¨°2ÕC¹ŸD*P€(º@OmS5#z¢7º¼Ë;Rn!±ÛSh!\úÉ™™øe•Ç FXww{9¯A£ÏÂkw ÎÇMÚ¯!,€ ¿‘1xLâLùú^4ãþÞÚïàJ€œh\ýC.8H«ÏGÏ9AÇ ˜À}=Rÿ³L c§%x¾Y¨n,‘,é$ýX&þ Å]åÙqèÄ!õ ‰ÎüCí;ÖÂ@€Ÿ„k¿H- ƒ/'¸ÂÈ6 XýIxø?¢ŸÄîz=¿3ú@äû=Ü{Š›Ë¥Ü 2ÝZ¬rÔ ý{³z[/±Oì="´À´€OPÛ‹QÞùEy.9E¸Èü ‘D'ôì üGï_Âúþ a˜PC"Vü[AÑ…¾|¹2þ¢("!Hÿ@2Ì%Jˆùþ=$Y$¡J /%´isæ? :sþ˹ÀÇ‚Š>ýC¤ß¿ÿ}øÁ7ÿÕK`ˆT©ýó… ÿ„+TÇÞº`vÂÙ ·²-ñï‹›GþÝ;r¯®Myq©Ú4”ðï?C†*ü lÑ ôZÌ£ç$J¾ó}¸A Qz›!Gqb/JÁ!&„€X߉«[ük}0DF³gSe4Â„Û !¶ LXÂV¿†N8ÐI{6[rI_ìò¹¬è‚ùÁQþaŸHñfI)‹÷µ¨Ê§yé×÷¤P› T­@t4i>{–÷þÇ£›†°É*¬þ©Å—–©%Wþa+¡µH˜`¬'H¨¬Žx‹ºäÊ+!ºè‚ëŸÕ;±¯ÄòqlµÇ"ÓH òYaìÙì1zb‹ ÿ¥>ø‚Ó(ø ÕXk£5„bcêƒÛaÊ&'£ü/!„Ù)‚V| »ƒœ8Î&zD¸D„Ø6ã²:‰ZJ©…ZH.Šˆôù¥¢Ыó¢–þaÉG=ûZàNŒ ¡÷ %ôDlâ'Ÿ nºà 0À¬*¡«J0AMrPÒ³ µi­ûâë¦%æ:ñ0Mè>}æiñ1•riIŸÀL3ÎþqâËmÜ(XHÖZká±ä˜bD¶ÙtÓª ŸšÇ¨þ†’LRîK„¾üGƒãNbŒVêXé¡[õÉ%"@Z¡>ôÐ#©Î„6ÚΦ‰nReWö²€‚áKˆÿÐ¥J(@ÚóŸ ö+ö?I¼êRáŸTjQðŸ @+-I©r°Ô[Hp«/¹–q¯ßBѦW©r´ 1ÄMÆÊ¥ºê$ø(}n<3¹Ø’Žíƒ $8öƒèÑ€Ù„pŒ Z)kKèIÙtóµµ@ >M9ª6#W»šçŸ`SIŸ‰°û‡¸îðÏ^òµˆ*É¢Í%›V aöf‚ñø>ø¦þ‡G—r‚©¨ª´Ò›´J…c|Ô•Qÿ!á‚ ÿtB°©’kľf¦™UXuÁ±ÍP’,"§âËG_“û’;Òœ^`ÍXc¬ÍÔíI¦¨5ÿÚ'%ÐVˆ—#ÈêÚP(îàV(Iåd¨ð„èµs…W裊ݛ" A͘€Êé=Ÿ G؇ ´ s˜Ãá Ù„&³‰§"å¹ulSP™éNW,³¬ÎZ§ƒ¶JÀ‚Ù±@ ሰE;Ú%&3¹£Çî€#}å ŒAHBr¶ëB†°À>Àª1‹YWËÚ“h3='M ŒpÝ?Z‘+å$Gj#WkîQÅ&Üc ËS ï"¢7õU¤N¯¨È½ÀC’‘ìip]R_B„2™ÌÄPÿ@T¡vŸ¼‚*7ÐG*ð#ÜøGsTÉUºTx¥+ª#ÁXDÅ:QEhBŒÿ(KBf»„Èev´»Ab(°É¢0…=\Ûฑ‹ˆrmÈáybs½ $ï˜Úfdy¦ÚÃIÑ“©¢¤ìY`CûÇr†)®îµ€jÿhÂÝ&·9³1áQ¿DRÜ«/ )ÊMôÁ4Ù¤>Ý’I^Ÿöé¯޳‰û$·‚TÄfÃÍS"Hf*tóEØÂ– Ý‚B·pÐ\A!H]ˆBº¼‰‰îI å+°OQ$JžhzÒ‡·¢£Çüª†(™NoÌdQmm²ˆlHS]*‘v„BVAfx“úp5pk3áÖ„Æq†qº[ÝFRF‹€ñD.Q£ÿú…ÇW,,JX×?¢INgq ¦¢ÀÞd;Q*pº ÔZŒüÇZRgžž¨ªS£(DPÄo"8ʱ€Ì\-*y‘úX¥­2%, ìZ¯Ç+ ¨f–Á“Žnšö$„®õI½9¢M>€=§„@¿ºI¹²ãše±Fn¶š bÎ"xÄÞ\¢XaA,!0™Ï ügÿÍQŽ@!§Ãrƒ–4-’’ŠXo “…ÕSÌõÆR‚[°åB‹LȨT'ªµ”Ê;™Ç}»cBÜ7â"BÅâAo4ÈÎÕ£°§Æþ:›L÷xA ‚@*0bT—(@Ç’!–]²™<‘ƒ«9}d½ 1*·‚¥h´" |‹§ ®iúˆ@QX4`ZÒp: ŽÅv³ÙÜů )!BHK®šº†m­Ùð0ñËÐè«;¡SBÐó JÔ‡Æí{×›ÄÕ-8ͨø­Æ3þÇ&ÍÖ°à°Þœ¬«bÏiêc^YÆÂ‚ÿ‚ŠåtkÍMmÒO û’”ÜŠ"L ¨Ä.ðÈQâ×÷®vp=j`× n4!Â+þÊšYɲjK"ô.K*…rí¶€úyí„(:†Ì’e˜BjâIÆ]ê«—,(Kû œ¿ˆKÌ„‘áol”\‰æÛ6ú7ÝjB  ¾¸"È“¢5¦ ¨Ïeøå?Àʆl2 kUY°™²²·@È&oYb_(` d&ðŠözcD´2åî†9‰á¼Õ«Ï(vO¹˜NØ$qåÑ#–›IRÒ[:­› ¸OÕ‚À(@CòNm´ÚIi_Cݱě-îˆDJ/UÜÿ]Œ›þǦ¾Øöå"ù"®ÄÅ[‹ŠPìÄq„*)±þ@®0€Wo²•ÕóµÝŒZP ÊOžÐ-¢7¡Ð¯…ô”Ìòxk“ÓŽX¬ÝD(z EHQ*€Ç„)íIz Û~u_Ð@=#]”—¼ìæõ~g"ÑÌßrh|•:rãC›ö”s¼ò1 rIun ©È:&+@ ®")A€C‚­ÝLF,(ÄdvÞÍ;ökKÿ* 3Ö,•"%<­iŠ¥þ(†b¸¦40‹kz$è¡„íhÂ$ÃM;ˆ böÅ€†öÞÅ á ß%†Fê4p§\ã¶P*ò$r` y*P OKÐ+ y ä`-È€LòbÈþƒ¹þáð& éj¡ó–†à‚ ºªŒ1d‘H Í*‰‚D‰ˆÍ<:©X²Z,M6ꆤæ†N4ºˆ$" LtDGTⶦc4r¡®V@3 2¾GÂ-ϬÝl³’(zŒë b©{¸!biVÂ'!nÔBƒGD %r! hö–ä¤N:n‚0 MÊÌYnk$"î&`èª bhÿ\Í?&/R&/ û %¯s@Îã(ÈBÈ0¥0¯+\á€Üq‘\¡t~Mm­¸†)\ïõn`Þf…YФ:å>zåû¶HÔ2­áV Nœâ†,˜ÞËO1%š„²¼.-+Ávð¶ò!z€Lnk3¤æ±n"\æ64QIܤ7bÃ%}Šî2`5zO¢Kê' gð ÏatFsx¬>…äã`m !/ÿ àÀ )+Ь°Sá@ç@  ZN+¨»hæn`feVfˆ:ôä"Žæû àEbº…Û†‰K¸äl¦#$ `Bp3î+6òk~ÿ¦®o#ƒ #iJüc“úbýJ‹1R ùÚ·Ž|b£M,˜àå"žíVVƒ~â!6ƒ!ÕçŒþpÖˆ‡[°q*êò‚Ö¤ÿ@Å”2Ö à^ )¿Ñ5;GS¬òì°+†ó<ï@Tކ ä±7Š%Od,çír¿Òä/#†B#°øäV ÅæòWVHX~ä†ô’lrG3”Ї"' =ï01ëBrC‰òá@âúf$k±1öíÎB5ä!§ÄÇ´nˆôaô, ÇD ‰6‘!¼%!¤î†–*ŶP}ÞI8VíX(@ @7ƒ„Ì«jó6…R(ÿ$ȘR)a-Ér³É@ŽE°RPŸNó@ +A€À+/ä L=:IÎòíªã(*Ê>4ã/ÿ--E€^!BGÊl<ÃF%(aôGü2°¸C¿’®²îÑZ¬åù¤ÇIÖÍÃâìâ¦ýHkmÀG@åAðB^€5 €~F¢xkráè§^àXò!DÂ& «µÎèo`Ñ&ÊΡLãH4¦BÙ*ÐPc\7›¬ÉrÓ‚`)åѹ6iÇjᨢ@€ ‚HÍ#1úQG"ƒwîCW‹é¾Nb)v'"(Áz¨Mœg"ñR(Ã1’ÃÛ¶ƒ!§Ã9‚ÏÿðñB,KMë*#?Ýô¸ujTÃHvª ÂNMk5éÇÁ2î(AP›@Oõ4èÒço²ÐOHÓp@ÁèCWD±‘Tƒ Öpó&˜’)ˆ6—2! öFu,¾ÒRº¬¢ ‚úå¤2 )ðáRÊ E:ÉVѤ…ôJâD‰ùe2Œ®£®Æ.û„<ýG€jx 1©uZÏÔZ¡„—FbÈkÐâ&µNà– N]/ðbGXA¢š.tS@g¯÷Àhþ¸ÉG"ã^OÄ>V $Ê®"¶©R¹JÈP4Ö‚€Ö 7]ô&6!ÀÖ&@®*ÊÈâcZ•*2vtÿ¶p;FŸŒó((u$Ôxg"a$J”’céö„OðèeuNôehèGYWGˆ§.‡EZÝÓ=Ÿoz®õIå¶2}WnŠ„hɵŠòB§–1M>j›ÎP•¥sNÎi}Ns$Ôh£Š*CéŽ %ª(pLDTÕVmmb)“,!š ÖH@)ÙVnçØv6,¬0‹,+2ï2ot8eS¼‚}AÆðŠô Áã$æµn>I¢€G2 "-ÂD J ¬xÒäÙ!ãˆsiè~‡Egw–Qu×J6$ "æ-BáМI|®è8€þªÖÞXR2–/ ÿWc*š0¶bB¶J3 ãN´ 1PSÄ–g^@uaem)áV7ãö@µ6¹÷ä¶{ 70 ¢R+:æ<¦Usíò¨óÌcth¦“nÈ~ß2ï㡼4%è…£(‘ KÉ‚»åêÔŽ_D·ir,Ç´5J$JˆíB:IÊò[Ðhãf§ª„À&îAY–[¹. uû|÷†oÌ#ðÒGMò„ OtfhšŒ¢WS¶zÛq7ç–mo"‰åÖ)ëáG7æU¥’cbÙ¦8po‚U?&ׂs}—o5Y5ƒnØ+OĬË£{¶H"V ø|Îç®Ò+:>7Lÿ¸ä†~¤þ¢¬iš$u§Ÿb45#BÉËhôN ™2„ï"„ïn>¸ dò5n¥;_8Úg}îä#*Â’©‘4Ï>¾ö†íã€Àz‡6 ¡IuÛqz·×{e-‡@|™H Ä@¨ÂÈl—Qdà—‹USGV,"¦m¾ìC†ŽC°õ"Db½2ýÐï]V룒†OFãrìH7쨇*FÓ=o`H&À#"bq\Ë„“‘>¸©™5²…ƒN²V¶4ÔO,±_njïÊšlGv,ˆ‰˜*ö°É¨‚¡k“¡£·R.e(¥*â7S¨tÔ—{d¬Ø—õZÿ—½ˆê(®Jy<ì-Ã#Ä`úËüå™5"¿¤c'ÒšÝó²Ù=× hÕ£²ÇnÕnò³W¬æW#!î¡\™Ã3oˆöz¤B]ž)ÍîPó4[‹$Ž <Ž¥«IBgB‚y—Ì&Fnˆ ”{»6kSòhÔAÂê5çz®SU=ðº/ôZ×RA®ynKB­™ýeBË$Ý‚¯%°±_²‹ ‡8â…2v'±TÂGÌf§M'-*›§û"›ÊGzHƒ…å‰nBXD›*Zc•¦º<б‹( oÀI¢ îýÌð<“¿Ö_ÿ¡ìLcf —‡CuTú6¹ñÿdò|›fà®ñ©/ðÚòÎ×–5ERÿSDgzH]äÄ(Òo£D1x²-"ü%üЇOXWö$Âï$òˆr:ÇVç&¨•!»¹›mGÐjª2ìáF¬æJ™9œàM c;œ"ºóoê<¶VJ_Hìï pºú†["DÑ:TI9ˆ÷°)I•¸1Åd4Ç«Þpsšk6:!F|mùÈ4¯H/Eg˯Â#ô*"Äè~¹FôA^ ‚Ña$2"hš™$Æ[^loņF$ p%»iØ;l8kXú¢²ó[uO®|î­@cè¶PÂ3VÉ]æd& Œf _廫/jQöa$•yEtˆA•)–nuóö¸OtÈì|FîÖÿè|¬Bœ£åÛÁuøa4¸1~¡(”U€qõºm‚2ÆàV^¼a„¿¸CA7ÓuÚZvú&Ûi¶¡€ºÞ·É"ÔGôC?¶§„Zã,—EÊ·t§aèdÀïäË39$( ÌËÈšÄüap,Þ‚É*u7›²ØÙÖ`•½7;‡Ã¤ÎÛ0®­B¬<Ź{ϺâļìT|2$"ýŒˆnÑåÄ»›yŇÛÉ»;è¹—N8yH!eT†æLïýÞ!ŒZevr&lÎD4@í¦äÆ1ÛDÊS"iz—O^+_$j^D,“u›ôÊíû¥((D%ଃ RÛ¶”å6nÿGUÙA®7U4åëa@nM=®‚åá°s Ð@ŒÌ¹ûÂ(àñ¯]òËθTêZ¼¥}¾™-‘¼Ë»Ç{<2Ò½%Ò="€f^D›þ*€ØØ›È‡´½C}›—w ¥!5cV$[Më0—šgÐ ]«ÖÑ>ÅÏ׳Ç÷teϽh¿7J(Ù“}7€zƒxTÙšFƒÒÎÍ#c¤}å åûÂåñ¼Š}¡ìNý-e“zh‹"ç;È}óÅOè?ôÏÀKFpÕ(ü'Þâ‚„ ÿJø‡ð A$4Dñß„‚$ ú÷áß<„!èAœGïD ÿ9¡wa”óåû— ¡¾"ÿD¬øw“&M„"ÞD¸ââMDú.-:‘ƒü{qà_Tˆ/rÕ€Ö®\1ý÷µ$Ä!ë‘Exb‚z%ÙÖKp6ˆˆ ü›û/•X± õ4ô¯'B¿ˆ>ttéRß?›õ‰ÐçøäÉ2õ峌ØeÍù6ÿs)9ôËÏùbа`ÁÀ üWáÂÃc?œð¡¡îˆ†!Ð ’Þo„ÁÿµˆèQ%Ë•Qr…È¥¢c‹qRÿ‰ÑMÁ7E "JTŸñ%„˜·ÑjUª\½D«WWeée‹¿Ùúÿ­%Û~ÿ ±Bpíu×^zéU Oýã×€‚vÃÿô„BbEÕÚcRe¹\ÆÙf›u†âK#Ƥ¢ŠÌ$„ª±öOk ±Fcl±!Tl°F[T `ÿ\œFˆ„Ð ÉA”’!DñÏ”Q|0šO3ÍT]—;iGÁ 9ýó]x½4^A!@°ÞS:àÀzñà ü‰…_Ze©e`Do è vHÖ v€h áµW_ŽBÔ×=QpCfødÔAÖ¡M›–”؈™uö‰¤ž("i+â$„0°6P®åHãDèˆ#m5f$AE …0DÉyä$“ ‘•QùtQgD;Q µA­Ð“wàéCäAŸaôÿÿÈSÕ /ÑDpºçÔ?ò¹R}]Ý ‘€tÕ»'žôî‹_]b1ZR*S€D~e`DÙ‚=êã‚tyÚ¥L¢Yfª‰Ÿexbi{¼Ùˆ¯à‚Ë  „kѸЎìXÁÐ6PEÞöJÜGOÒCIGVydg,-›Ñs“9´8‰‰]`Þi[^>=Šn æþsDUü³5×ë¶VtÒï~\ÝKW¿ý ñ矾åVh zÀŒ‚ WI q0ÁæWOڳĜr mMJ¬Xb%¢¨1•Wf¬Y©+KÄzÖæåXãË5ÆÆÐÔ Í,ε0ÜÿoÂm4,Ã,•Z*ÇTæ3»bºOÌݵN÷Ô˜xY"ôa†½ ϸW§‹Áº/Äç.DcÊ€mÙÕŸ¢tûyçYl¯Õï /Š(^yL0à|ï Fb“éM;!Hâg'®Tê©*¥½$"h•†p´Äs7]Dvô@¨Îú0Ì@¢‘Ö ! ³²þ— ,¨$Ô!!µªE“ï¥ âÁñŠÇ`A ÉsÓÖ€~->L1Wꄲ*O|Рú󟲬|L4"ÝÆ——(ž!zY¤ –”,@„{˜t¦SÂ..4ã ©JõfÑ. ¦‚ÿtahàƒ‚Rv³Ø Ä ¹D÷2‚$d08;ÏFŽÓ¤5lJ²»LF‘úuG'dº"€šŒÏ™#f˜< œ "øGó½y 1ˆÝk%½Œ¸¯AÅ%Põ€‚%>(6" Ÿ!$Å“‚ 0 °@• ‘|Dl1?©Œ¦Ä¢ÌŽÑîŒÃ‹`"ÈX £‚…¹ÀŒ| C*ÈjTÈ I-Ùî&0œ’¤g‘œœ]ÿ,¦˜H&'¿ð”Nªõ™ A1ÞÒdñ0ˆO’KynBÈ)ƒðúÐilv‚—õ¬7|m–J$ÐXêb¨íA1" "©ßÿ‚„¿%Œ,  "æ’^s1ökæ?\£éÏckìL!âèä2¯Ø¦«.€À#(žSÉi3×”“-+ Õ$®$í h¡R£ó˜x !ˆø…vhJ“l]ii‚ˆSÅùÉyŒò@—CO¹•JÔ<à«}ºÇ=ù§–tƒ›]6Z¨¨. 8¬¢4Ò("HRIý‹ ±€àŽ30ž ®ƒÏÅàtb¡!ÍN«©?7ÎÏ&B3„Ñ oª0oµ–ÆS$Œd¬»«ê9 öê<®ƒG`»§áV¯Tö”­ÌsƒIˆp‹w)–`%C»’³,sËpé'EéqšÄ)NxB€ó ²ÕŽ ºšÒ”§üG|æÔ•:Ao+Lùë^ØâØ%v{}òž]†0—0³—мüGƒRaßû­`)ksA(¥á ¨´d<°dÂó˜êä¹q#”\K$ 1Éø³`Úf3R!¾ñ±©²s‚KWb/µFFRMA"b2íÿv<æáˆa€æ0±ätŸ\*¡>z¢êæãÃÀú#è‘Ðy@`%à.DŽ€<@‡a TèTeˆÔÉ+wª²—Ÿ/VÙþÑSb=úXÈÞ7Aõµo-òví†o)Uêæ–º‚X C1-Íü¾¨œ"¢„"ˆX»“)*È•&›š2°…QTh4B(£m\|¶5ù0ŠU,‚)Ód%ã™ìÙ0Œ`hD/úÖ^Šbሄ§‚5 #þkôÐ:y¡„È®›çä˜+N`Ù«yûÚrü0ÅØöâO–qi=ìH–ÔC|#¨ó¡Í×®¯™˜_ÞQ†ç€».:›ÿ+1§H;£iæv ™0…Û}VX¯M€A>’Ž8Á ›ùl?Å3H„ˆ"b(†B‡2Á`dr_™4 b–Ôh™‘0D@˸AFœúäÇ5Bk„p×LFÈÉŸçë|ÍN>tJ»øZ˯ԃ¯¬ B¦ð)4âxˆˆ`K(.‹Å¾C?ºÑ!>z› ˜…zÃBv™ £ûꉓ̞‡Š"2 ´ÒVð ad{›™…‚³vG¶&ç혡 }š#œœbÂJ¿èH— Ù<ȧ'â›dµ'¨5 îñ €È@E™yU^>ÄNÑyÑzP6wÿ/ßç€h#²7{Säz€óKF"A°7p¨rn%¡ŸB1kUF˜‘!ÍBF”¡45± úvh›S<ó ±vùà85ZfÀ8f†pIaôœôÊÅ1£!?ÎD°jXbP1TdGkö'¸¦º–:¤yè¢C¨4QZSa^Âfle>8fthhUÄ{r3ØÒ ã1Â7jT—8¦;Ãc}È\Ò±”ƒÜDGhG- m€NÐEùðDÀ†ì•0‘S‘‹´Y›%9/’!¡˜‚;Æ1$Q´ÆòP…À€ kÍs0‹ÿÿ'N!eMD>D'ex'Z/‘è€ýóE·K¿ÄoÔ³t<ƒ#%óLÏRÐE?Ù4<1oÙØ8WGÍŽ13óЈXƒmP%Nð6pwˆ ä`Fòxñô3Çt‚i„%÷ø¾cákRˆŠ©ˆk¥”ÿ‹±ø´Ø…˜—€æe0†î’=‰ àŽ%!Lø2Xq7ô%EivGb$)V#Ò Ïh‰æF¤ux- -^gqÉdx·#1&” }Ðð Ôw‡¨刈ô ˆé€@hš¤%q‰ Šœ„”Ec£8;³6õÇWY…¸Fùºæ´¨ÿyL^aÃ@d€X[A6Ç=üq†DYs}B/d1>sŒ¹G‰6‰ºw†r!È!ìV1‡ç0 *ÍVi-‘§!}Ó·tåø“Æ€H’°DyK– ’SƒHT²³H¢•âW"'/p•“§•]™°‹¢¤y¥ÔdU…–)—–åål!QÅ™’‘¶Ä‘ó¥KX4’ü¥pÿp’sèhÁç!ŠSë‚ôvu‰ 2¸Ó1S—#Âp ¸@!”˜‰ˆÆ1œc63=,pU™A!U²&'•TùèQ-КÈs÷C°h@þ—ÿ5ç‚C]ˆa/€‘N––0ÇlAzù2œyeê5m’Õ†oÈ7¼å—`!ôàY§4,y|Hs8ÐÔ,Ž89£Žö” £/(h‡ˆ@Ùè‰ëyK0pišT•ñ) °Fâ³F•äˆ%ð,0.© j F®ø¥u¥5\'¡yï1Q*7Ÿ·'㥡! DÊ¡JÄQ(YU¤Œ-6dqI†‰BåÖy`aô)dT{Á"<µ„’.@ d@Š™Mpƒ §c65!òpŸª)0¤2€2@Ù rTZþ)©¨ŠU˜d ‹[)ÿÕ€¶jR°kç²ZˆJ\£¦ñ 3` gðWòq6%Q'q™©i)7c¶ Ô{czB `!V˜×"Ÿ²’ªâ„Á?!À˜&Q(!gáA@Ú–ú¬èIó ¥H›€<,€<ãBr «¬(Ì0f[£”CnÒ.P'gpK¤Ð5ì`‘óº3° *c—b‘toH)†ÁI…ƒ"¢f¨T÷g Á²“C8S‚ƒ'QŽ–È3åX©–ZŽ{KCæIâFêƒO0¤I«Ë[É@û€[@ ÛPëá°DÊ:{K¨À‘b¶†èƒ­d¡'ÙŠÿ;ñ#‹³;¥5¶wHg/!´¸ÓQ ”mPŽmð“r[Ž–Ú–ºÿ°2@µ%QÁ".í(Œ+ ø÷ŠŽð îxáÅr}ë¸%¬sq(rQ !ò†× –Â0$‚Os({K-âšDcšxp‹™rû“A¯¯[CHò€À™:PJêPÃIû¸Áû/Ô E˜k­-æ7 ¯v„—Á8a”S£– BäÚF´#³M·Û‹žw¯w+›À†=èŽ@ðDJ´º™ë¹^𩳋†l#µ‹rœòõ #y­d¢¼!`¨r¨¡I8–-‘Ç4ÿ9@ãöàm ½?j³¯Ûò0Á‰†l ¥) 2@¾ßÇÀé+§[éŠí+¼'ü¸â²ìµ`‰lôS ½2ùg1Ù!4o‘Ó„cïÚpKÜK0ÁÌhXó@‘8®@™j [ù¬‹ÂÂkµOD¹>h7€¯ÖUùCSÎ4º2á¼h‹'¨‰ËÒR¢ˆ?YƒÆ`• ¾»(¿9wó OPÅÙ SÛÇ÷B7Œ•{ÔÃGoè—Ï8m;w8ÃcœLEC<þC*;ïj–iM ·l¸'|Ç™Ê JÈ¥L”ëÅ‘#™T¾Åt—V\œ¢ÿ³»½bá-Ó‹,²¨žA£!92[ƒÆÇ"AǪhÊÇlÊŒÌrÙs|·–vȲÁ!.t²,yq¤cáˆ8|;'¢ú#9þ{\?Ó$'ˆ´ÌëÌΛ¸tf7:”2câ¿=¥²yv5Ù˜ÁÍ'‚%ßœ%³ó7j‰- ŸúÔÎ=¯ðÐ:'?²¹Á¿ùàAnX2j+”Í‘Ì͹À„ a3:Ð.QŸ4© ÑÁÇð¬ÝkóJ hµÈl(|R’·,+“ˆ`)¤[Ëå€ÈD„F´Îƒ¶1;q$Å…¶êƒâÓøŠÿrÏꤼՙÊðÄ•,¶•²{A"œ‚„("N>U£Ã,hcþ›$Iêh8tð¸ì”©9ôž™©ðÄa½;]=høq@ØÅ®ºEgøcÆáˆ;µË@£T’‹T%!r¦È·m¥óŠJA Ø™*ц©=K$†X˜XÀ ‡„ñgÂp͘jôTשªÐ‘h(£ý¸PØ™Xð¬GðΪ 5Ôž4· ÝñI®“”Ö6,jœXЕ}Éæa-ÁËSÝ€)…Jz lØ Â‹:€Ü\3¯Å€†qŠÌ9í€ð÷$ðIò·LÈ28éÿ}ÉÕ¶ÿw„@*4v)ÂAdäX™öÊ%Öì¬ßrê°ÀÈ3àÜ â1þͳŽXâ“éQ„Ü<Ù2êˆDc†±Y„³­—BŸöi¿A\èÑ/pð ŸCêÜEnäû rñqA} C–âQ•F}Ûš´j BÀö);E¸Hã jr®ƒc¾äž*äXzägŽæ1°æ$îæÔ]Š —¿Q™"‘.$9Û-Á0²ÜçTB‡Z^%tæ½½Ÿð©ŠX™é–ζÒ#'ÁŒÙÿ“¢BÙ}nï4›Ï–ˆAÍþ:Ôîã­ªò×*ÕkßNK¤^)¸Ã©ß€¬ÏªÜ>‘ÏŠl}éÿ@Ý$ âEÙIºÝœíF1>@iTï–¨ïÇEòÇQŽè±ŸÔΪ*¯ÿõW*, ß»5í"§Fðh°žŸpJÛ¾žˆ=fåŽÂAôB/ñ Ðäå ­¯åèŠÆSR4 ÿAO‚õ€õ¾­èHv퉎ve挞©Ys`Ó&IdÿoCù™C9ÿ¬àöìå¬(üq–>ñ‘÷òÇtçA¡˜mÛÓÙOÿ:‡HŽT¯ž‹òÁ¯èZŸŠ’'y÷`æ›5 ‰.7$îîeïdÁÓ¦‘â8Dµ©ý€{5ð¼r/âŒ@ôkNþñߌi•‰<“ÂAšª~ïÁ±AðJ¥-°ªøΫ ë!ïˆ<òXüc!ÿïÂ{.„QâD‰Ž8øWÂÁ‘¾˜àŠâHˆ x|ðÏ\¸BRæˆ)eÞÄI 翘4ÿ¹2sçPœþ‘ø7‰ L!e4ÂD†æµøwâ= éÑ[hž½!Ä^ýš–^‹léµ½zµE ¬ Lx„…݃{÷FtxáÂ<9ª ÝBŽ/^Y©+·Ü”€Ç‹dÈ€ñç!-ÿÍŠÑ'QÖƒð”Ù µˆ´ÿÕûwç§Öþ‹ÚTéÓ¥šŸ€чZ³Ò›1mˆ­_[\=mÖl·{—×Â.Aòwó.dÁ=Dÿò÷þ#xd‰|ˆ2þ¡°ó/LMÆÿ^yl1›{ ¥zH»À6r6þÉáŸbþ‘壠iµÞˆêéŸ^[hÅ1 "ÜDj¡)@í´ˆl“I¤‘ŒzŠF’bŠã”Î8 Ðç*…ZÐàè¶ò*­yäj <1Û:!¼òÎ$/½Á8òk/½Ü{¢#Ü›¯Nœ“ÀÍ:âóŸ 4:BÁ…RâH¤3°pÐX,Ê!Û´Â ]è)Ž<ÞÞŽ@ó‚ X¬ì•ZÛ6M5ÝèÃKS=UÆì!Êûn‰l•EÕPðÁ‡4Ÿâ‰4–É6#±>ê·Ä!ˆ*©¨Œk%‚B˜Gž&þ‰å”Õ¸H >þÓVèP·@Ô•n$ aÓÛâ­ Þ¥v|"@Ó.(T)Š@‹bÔ¼ 2Ó$ "¿ËÀó‚ Œ 4F¸Ú¢· ÔpEÔ»‘§°/Qªƒ.ò÷n¤=Šz­rÅÿ¸%ªÏ6…+ÒBÞ÷>ù-nIO€“zõ ÜÀˆˆY –P9žñ¬Z͉ŽÌh†•Ô‘t¸ ¨Æs@:BÄ/)šœ2øªç!øí¸Ö6ÕEdB¾“òìÕ5Ó¤$Fp@=ZAý§†ñ¨^Ð"ºÕ¨ƒã âBt’*!ÒDUt£‰Æ`e¤×€êT€³ùFf«ˆ¼OWOúÍ’”ôâü£_äA*×ÆØ…G/$žó´j§jx½ F$-ꡌÉ'ÄÞuJ¸þñ¥ü³Ä%nÒ“> ÕÅ‚ÐÄ¡H´“ Ä m¦;ê‹Ò*c á°ƒ”$§'PM6B H€óx®uíÞúÆ7x{]l ÛÒÈò1ÌF íg£)‘þ¶1¨^È †mz°OŸÁ€‡:c„Aq-%ÜVÉ?ð}pÛl<¦ö ñËèv€äí'Nª¯EÎU')Ÿ i„Þ¸o–šªV#ÛÆ7¦mŠÛ½í67±2µÇl#¿…¨ºJÆ@‚s°ñ}@% À >Àzœ1¸µbKÆzE¾‘eÿ¬æ\ʈy4÷(¦2´¥qp‚ÛŒS!לƒ{ ,«c(˜NáY¾D }[ •MÛ¡i>Ma"K+%;«ÁYX¨óÑ>èK¸Œ™"Sc+ë;™ àyY”‹µrS©+7 ø€É “?ãx¯É3Š-¶§X¬¿›‡0¨©¿P“‡:4K ‹È&;¼Ž(6jƒ£±j#ž¨³ˆêÉ@hó³r{!° 0€~ÁãÀƒ.FÛQA¾Ù´¹©l˜ìÿ;AEîõé>¾ó>¬ êœ!Bîy|ø(·HÅ}ø‡Xˆ ÈFøÉÊ2)+©%É2,Œ¯û žÅÚ¿…( ø?ÍzoI38Ù¦§9Àn"‰ ¬ˆ#L‰{½Ô"$s*7pËÀ à|ˆ«²F©!ãÚ!áË'u¡çÊ¡S9•P‰›€>Nc¢SŸQi˜5!»«ôEµú7ÜGEæú‡QX|à3#PÅ}PEmT‰kñˆ0 z8 ­#X,ùzŠè ,ypÃqÛ¦„ŒD@ :Ž*8¼Ã+<Ñ[3’°°MQG‚ÆŽè¡ ¸I=S‰³‰€Zÿh|‚­Kb$Ð7BRGTq4Tz´!š›D+¸O# V  »¨ˆµ´ó'ï£ êÃ>Q œó1H|è „œº>#·¸6#-\`³P·„ÈpˤsË“Yˆ²à¦1¼¯Q“œzrQÀ  Ãë8Mé œ@‰ªˆh½pƒs”̅؇=[ Al…z¸ÀD¹§FÇë“„I±ÞÚ·®¼»T’A B1Š8¥·ò(ÚDì Qô&Š»ðË;ˆÀ‡Gú…dEW¬LV4!ˆH˜”8€»¤KŠX,$ Ƀ¬Î+FøKÀbª ‚#sù)ÚqCq ·â9ª ¤¶ÿ@”Bû‡ 0£ôÃ>„¡ h… x—Dñ”Èh·áÁˆp€¦r4ñJ¼Y¡´Ú1{½E †Ò.‰ó¿«‘©Ä¯ÜMì|°…<Ë>\E6û)ºÄ…k¡ˆÐ”¡" ø€ÎÅ¢9x$õ{Œ¼(ˆ9Ì3óÎå\*ˆ¸½ÀÏ¢zC¬—¦JO¤â˜\ ‚–èŒÊ|É aE«š­ÊÏ 0㊌AÐå{šµ2¥Šé§‰DK‘´J<¾RWâéê¾ ;µ«»óGè;8;ŠA1Ëàœ:ËT âl2N!-î”KÒAGÃ\·ŒÎÄ™€È"¯ÿû{ÿ,¬“DTDÝ#uI0 ƒFMÙØc2kk*?ûŒp3 Wø0ß’³Y”!øûÌOÐȪl³Ù‹ÞJ¾‚aJ Ëå“5íU‘MäÄ» +ªÄ±9]„‚Cx€å3Vü‡€m]ˆÿû)\0H!¸Æ z½ä\ˆ+JQÈ’‡ (Æ‹¼Ñ÷ˆ9a°e3à¡#P ØŒ”(‘ )Ò5{Òü„À ¹öü‡!`7FìÃ7Ä€üÛú ³‘”&ÒˆP;K¾ õ¡ìQ¯ú:»31EsÒܾM”Sˆ 5¿!.2]•¥»Á…0?y‰ÕFWÜ%ÔyeNdzÖ ¢‹ÚÁ€ U#Lœý€½š (<ÒZ! L5׉Ø8þ‚\¹€iPªµ3s‚0©ˆò9ªšÍ€h…V0€SíI{áWЈpHÏP} àjÄäû­€ƒÇ»k¥Va8LÉ'O‹.ˆÙsì§×˜GyY‚ !ù ÿ,éÿÿ H° Áƒ*\¸°ÂÀ üþU@ƒ7é›ÈÏá?ŒÿVük5°U+C$Btã"Cÿ>|˜À(£ˆr!¢ ÿn ¬ÐRà ÿ )EŸ…ÿzÞˆðã…«††H¢tHR”3?$]@)‚ù DL(6-÷pãÊK·®]…=vÔ‡èßJ‡öu)p…+=|µB…7oÒœ÷¯e_D6P˜pBÐyƒ3–P&… øü¶ZÐêÆªV­rH&í >”ÆlaÅ|ÿ Ø+`ðƒ½àÇòóp·¹óçСçã<¡c}.@¸£@–ÿ(°ÿ.Ü ÑÕðˆC†0¯=ezŒ\‚!e±Œ ÝhµaD”…Y`Á?øgÕ?? Ø cç]EAkµ!åÐiBø„H>ÇàÑ@i}?Ä ´Vt$–hbt#®5¢rØåƒÈþmÁ #¤×K0’ÔS­ôD’a†àGÙ<'”P¤@bÝpƒ7P‚ÿLÁM0˜a¬“Y«A¨deü½6’@$ýàŒ0] ›~¨õv?Æ Çˆ†ˆ5ZÅsâž|ö¹ZÕ 4Ýtÿl$Q> d&.µ?7,0ã?PÚS¥Œ6“{óy ”1bÏ5攨$AÙ¦™TNXÿEy/]eH>©‰÷ƒS? tD•Y€O.à]PöT VÀ%gЊ~VkmŸÔE4>kaÕÐ0šÓ@7lвZ „±O•—›ªŒ0âÞ?òüc“MÆ…ð? 0€ˆgñ1"K78ÔJ-RZJ*ͺX+?l  ™föŠÄ¹öC §GÇåóAˆ!^kòÉ$~xg¶ÿD´QD7, ne}­„.N©+Œ0­Á ä&“Lñý3¤=öýó©Òó Ýž@ŒLpÚ?¹!™Sz¤ 4p¤µ)ÕJ¥_ÕÒ~ :SQá%ëØ@Ç9ÓÛ-WÇÏ£#ð3Êxç}PŠ ÿÔb_ @¹. í—@©áò.Â(þÏ(åã˜qý|F×[/¨7Í*{Œ d2!"´X!Ld,áý¹™ÿ€@`. ~µyxÁ±ý6uB;·rƒÙýÏ" âÁÝz7ß'q„®\PúL¥_€‘Ûó?Ðp¿3ã”>5ëFä#ï<—3BÏ@,h^oÓFG”ü(|þ<¢ÊSX~"ãUÈÂÇëHžÙå†@\ƒ3É(=b9Žqêô|¸ZÑeþ!‚9Î !ŸBÄN«PòAfV•ŒÀĸ¸¥ð hìL«oàÖž|ê=DŸ=ÿ3©Rš•ýì*5€‚~0»« aBNÈ*µ€ y(8Ä–=¨S@Í ;A„8ˆ<PK„x¤Kô‚Ó²¸­("5ú%0⟗°иÆ("°(a@I]ZÁIBà™Ö‹ '0šçä!# äñ ¥çXPÜ㜢&ñ‡“•,2"Ó®jñþjø8 í.0 ègcQIMá(¢• 8mÌV ƒ6Óa§ÙœGQG xzA¾d˜Á´bQŠëѺ¢â#‡Ù«hKˆ<>ŶOsŸ%'=yÊ`àôÕq29ÿ H‘)„#‰m¾6 \¦ÂX# $„ ¼Æ¡¼¢TF*€Ìát¨Á¡(õúø9&oŽ¥¦H•¨©Œ8"‡2XBæQ@$.9Œ±ÂCÎrÖF)™‰@žÆ>¥mî’÷8>›({àÈ’zÔàS•”‘ „R.Çf‡cAW‹²Õf·ø‡/š ˆ!È\ èÈFUÁ jY‘£•cBiŽT¤×A¦3‚å“eàYË öC•„G+0]2Êä›Ëä:é…Ï#õG(êQ›šƒ` GÀÀ?@Edªc‰¨ k5 µ4“If7ƒÿU†1&  oªfá ÑY¹ŽFf%˜ Dšw¼kóòzcþƒ)å· UA»™p0æAÏaHB¯ŒD$¦ûÇ”bž”€“œTšÒÞ‰ÏSzòï=êg ’ƒ¦ÕˆóÐÜT'R.‰¥%YyF! d c°{!|™”aeÅ¥+Ð,â ÇÛÚÐa‘Ø»ES zR.5û¹0àšuóÛJU#âÂÊ<’"Hb @ úú@y%KTM¾´H½‡hÒYt¶Èhª'/I¯#œ`M‘*cX CPE@£2"Z©¤¸†ð%3ç@9¾UËu¾ã’ÄÿšÉ±Þœ«HQ—"ÖìaU `Ç$ O c'Âí´ò0ÓJàT‚,õ¨øô¬¤ÿ‘ ¾¹gG{Ç4tí¡®66`\þŠ6®Ñ JÊd¦,¦etˆXÔ²Æé”æ;c—Фé8ÊY„{ i¡VÝe–°_.‰2°#–„)QÙLüô“N¥²=졌)Mi``©˜îöR‘êí¡Ò‹ ýÚcHÙ)£ Ì*3kÉ<>‹ |2pQ•Þ ¸ºÙh\2-=ñ#O8Âm2j17z9vä‘‹Ü`’ÚmJXh© )êË<¶ ‚—t’3«÷àË·¾* ÒNNù¼É—|>+o ÀAƒnziˆo´ÿӀݳó+ ½èµ.¢…—ÞZÞ‘ÜZÀn쬥T|WøäQ‡OQ)$!ÇÂ|Ÿs¦õXpø”dÀGnísÁwiÁw ˜O@Ô|ñ±99W[ª¸ N ¸Ð ´#µ5M9[´ ?ðZ£€@ŽÑvcÉFSßb!búÀu ÷!=ø~waL±GÉ%]z—+ÿ >$¡.dB&B ›Ñ>/ U'@@¡|QTžµYHõhçVTÉGd–ÖmÑ>§µ^F´>FRJ*g/4Cµ„ ›!)A13¥ ð+ZF~ Sƒ¶aÙEÓuBÿуqF„p¥‚Ò2Ä1Ça.ÁÁH‹3Náá-äÔePÁ#_—ÔTV4LF/òUF¨ÄhÅçYŸÅwQs™D/ëtI®X/üD5P[µÕ}1„ dV[x+_Ã+YLµ€ µTè‡k±l‡]7-%ƒpj„0„ùߨ27„ÊEb"ò!ÀQR8G-ÁB+ .5$ PR&~Q1åzwZs†ªDnävJ¨´NŽUF%idˆ¦ONE¦õÛÆhŒ¶0BãO“'C &j2HAf¶“ cK1 ‹tˆq¤ƒqGÚâ~qö(!ÿbÄÑuç("™b'lwQR]$57vÃ$L"@ Q Ð ‹ôl× ”ÐeP˜{èacE%U,`™4TŒ–I±xZEÒ‹ô@D¹¸T÷d†G…^ðTNåIÑI ‚?HñZ"E@£p ø0,P4¶bEìRK ” ¯… \´f´q@Hìh™!Žzå\çè~ÿà™í¨zïø(„¢‰€¥$}!¹b0 °õ =r)µ´.•î[¸…)gO—Df)iëÄ—C$ŽiR•œ–Enž$TNu_™$ÍG:Z²50Ò5 ¸ðò#ûQcd&Tÿñ®Ót؇·fB2IÒ„bp ”Gbx’'dp%#Ro—x‰õY7#FSò5‹£8Àú€+¹%•" ÿ¨0$KéåsL¶Tõ²>ñA$)Zµ81prHEO䆗OC@Ô4T²&º¯”),XC?ð…@!-APAfá9swd†™XŽ™™ 7ð¹“Ê1Ž>©MØ”ÓD‰„"7~7qÔýÑM!…þ!ÂP)Ëæ"1¤QQj]£%lf\(”–ˆñŸ÷ªªøiRzÂu9Ù“ó byD-V:ÚR#pqMBF/…Hš?Ó ’d+¸‚)³òRiÎ ‹9YBµ¬š†ÑrÀ¹S¦…Oœ”€Ùz?íQèÓn;…?"È‚¯ÿtµz¹Ò@^Â@•"@…Ø5œ:f z–ù™ —´}$„59"õù™[2 ÷™åÈGÀVkQŸF9lýòR‰‚…  8—¡;Ò "0ú` X˜3¶[÷2Z£¥wB6nqú^ YÙT6çCDR/Au#:¢>4¸A¤NìÓDMÄå4úa:Š•Z òŒ Ëðxf´2ékHÛª¥ëȤ˜ø¹™°<¨¤V‹2*W«‹‰,GÆ{ýA ¸ CYù»ú hëlb/00A3¡'Çd ©iêôŠéhà‹çö¬¿³Db§éÕ‹©t^èå·™•‘‚5QB%¥ÿ+0R ¨Ö&a&Y&C3¨w³¹5£WŸYgýÚ™AI¿P»Ž ‚ŸJš¿‘h2ÀÅ!y•-ñ¸Wß!’ÂB™b»!=!P2¤Pè®~˜úðDú}oø•”õ>™$Zóe_É[T‘æƒ+—aØ>øC¼¥Ô>BåIó00PQ˜vâ‡,’dFŒ¹ ‹ÃE0HÁL–iJúƒI»ªIŒMž™‰ W@诬¥%#<ÏrMÚ”"Ì#ÁZ: )•â3¶a,›H¡/ê‹wŠœD‹pIEõ^ï·ò°YóuJ÷„J‘öI'œ^í5Z½i~øa$,@|%À*‘ÿR4¡‚TS’«$TtCJCËàt³²ÌÄ~ÓGZÅRjãxpxÂ~Ýè7ýúƒ‚ʫ̺ûb¥tâ!2À%%0Ò1V(ˆ4; ²ã‚,ƒdˆªcåÕI÷œ{G|ðT••¡¡T²Èrð•½ÙhFõ>A¡p/øa4M%Â+^A!bÒCš à‡¹$ˆ‚;¡DYÍ…¤=¨ÊR °X:"ìH¿ð}Ñ¿oqMÏ2(ÀE'{ÀÑs°è”û Ä%TÒ$2²[vå7r:–r[YnŠÍtyOΩiòÐíÓr`†oв}¼rîµ ˆ>æ7$‘ÿa޼1Q4H20ß¡0„ÁVd¹ô˰ †@}ÁÉœ;ì'ª 1ÊžÙzªñ»ªp´“]ç¤Â| Ëı"³œ¤UÄ b™ýªºPüƒ!rÕ æ'´á,£‘FpBšG‰”!÷HNÁ3OH@IëÔ‹ôâìåI{œÁ7–F·.‡OÀÓŽO-ðÏÉÇ-ÍÇ€.²„‹>H¢?u?­?¬ÎíK„èÃE=ƒ C1¹W\WàÔ… n=ézõÉêHÛ°|á2ñ+ukqбÎå}CÕ³.¯àÀŒ£.°ïò¬™ä†(dÏØŽöY}Þr ò- ò+]Ø´È-àI´ØÇãÍØÿÌÁ5Œ ©>˜Ý!`$”=%Á›Œ5.%F”R Àp Ïð  Mƒ-sv3Ÿì¹êøÔ쿞lè8õBX(ókõìi(µÝÐtÐ á±/‘Ÿ&õ"ëâlÄ. P¡Œ ÇëdsNExuŒÂ7xƒ>‘zŒòy¢%mTõ„^8ÞÖ|§NU/-°S! ‰¨‹$¿W¨5Qú–£*6ªnég‡¡$=2Fƒ¹J Áb´OˆþýãOŸÁ ÿÅS¨_‚ ä÷/A†ÿ.ĨoaÅxñ ^l¨‘Ÿ¾ ž,Ù²äE’òKùâC‹)ÌÇÒ‡J­"b!ÂQDˆôI€pB §Pï•$ÐPÀÀ«ÿl:µê=°Sµ¸ÊA«Ø{Är;°Å?y/Z´€@oÞ¿uçµ÷_‹ô3¢·Ä?¨óÏûða £ŒêBv,A`¤4Shõ_-|ÿ–ý{¶ … tþK¹Ú#ƈ!7¶d1_ÿÆ3©ÛâÇŠ„¸› Î׫]$™PgÅ!B¤X!ws’ùz"Z dàP£ZQø'Á±â, ñª°êò­ÿ0ü;"ýý„d pÈ:Ãü®âk¨…yì áÀ³'„½ä᫤½N@ìÁyN8aF>˜ … `äŸÆ.HC1Äò~°`”ùçšÑF¹Á ©È…<Ò)ž‹bS®¡æzí ã~Ëh6áz"îÇ”ªˆŸËôaÒ¡’ ʇ:‚Ë'¥”nò’É6øÎ‚n ÀÄÆ>`p yžb¡¯#ò[.¡{ìëöþiëŸþü‹/­´êk ôè A»´ÓÿQ»øjÁÐ ûKB6ÿè…J`ì¼»ðÂìŸË*3„DÎþÅÅ€y™h¤I•”{ 6Ø ²U#Ž|ã‘!r¨Wßté¹ÜvÍm Y‘HŸËvj®$¶Th:›².%iyªh„(Y€‚nÿ¡`)5!cä.ô¤ó=>µjh«÷0À“>ùäl×,ö;+ß@új Åë{šÓçµ|òl{þ)°B ¼0=Kå9Áž»ðà PB¤ ?`d‚.·3|q™ÑpiÕ1šþ¡‘Y(|®%‰fEÈ„‹„ü7’\é¶ŠzΩÚ9 Ò‘%h]êiº™øá§'ª¥¾ÿr'…D``¸‹à†6„àŸŒ÷½¬ØH޳䭊m…Úºê*áÝ“Í%ÞêD…á` ¶ëa»þ ø.JøMÑ=…»#È‘ #™oò"h˜gžI˜VS«@‚Ž©H)P+HÇŽòhW‚ è•Gx\¨W¡q…=F2¹¡32=G¥“þùøÕ¬žúZÖ¨MÈ:™nu„À^` C&XL1§º§MyÄJvÿ•O-yÙ.ß]ðÕ×_ï½kqJNô`¿Ïô(5לخ‰%¤AÝÓÀÒå°Æ¤¤0Š!ÌØLfˆÎ¬0* «F•™I€8‚Rêþáÿ‰`-'"©MH82;¡Í7·áÙ?Zȑ׭H9š’““„ØÃZÓ’Ú Ð%ëèÄ:ÈJŠÒ5XÍ£N¹K›¦’§8^äSÈ|êU,êImÿ0K~ò¥§®„.ßkB_˜’xä5~;ÿU˜€,!N±X_ìø¸ AÅaŒ°Çy ¢©LÀ18ꌩ€±Œk d­bMúÖ$çð£w½Y²ˆ·Ÿý#wÏÒ¤¯˜œŸÙ®!RÓH³’¬Ÿ=éX=ŠÎÔ¦¶“è䤕®LȲDHà\ééË<ÞdÇðå ‹dËW¸BüÔ ~cÉ×õ¾°Üi@{“”EBp0…ÿèï`(ܤä°½„SB{Ð+tô®—dÃÞ?„âd¨Š4¬BÈ:†Á&ÙR+ᇤ”‘Õí†h>{Ým~Ö«b¡QH&4q†‹S”~!zÔÅÜüV“vö:èAƒ˜¨\¯·Öÿïyÿ^sŠžì¢v|®\àTHÀ^\p…Ìc5š;TT †·h¬)ùØ—WãVÔïÆÛ_‘yeZ{\ý2,Ö®ÛÞ¤MéX”HôlrµØ=äj¥[AçÅåÎVžCÑ{o Ÿ6ñ¬8“—»‰˜BIªA7t³þAl:"ó0û½ ÍA4àóxKxÝ"*¿QŠ‹h #1Æ‘ª; K“ )òàŒ0$SÁ»Á²WŽ¢Â3²»ºTr¹ó¥j<$%’€-³¨èø!*Tާ‘𖓬Bû?w:“\Ê‹8ŒÇI@u±"Öc@™¨º‹ ˜ÿtKÛó.#1áC´ì¿¸ž=|…­Át‰Ýâ­¥ÐÇ(û‹%z “ò¥½)¡°ù‡ø»s1“ú }èÄZq<Þx2ƒÒ+„ ¡ƒ@Çrf¿–p¿™¸B¢Âšhý£ˆ&´ꀒÁ$!(A»Ãt3eJ½ªà€=³ŸCáìð.:¬Ã#ʺzë½ë³¢Úºßó–˜7oD:ĦD‘@³û ¶{Ãq˜±ÉÒA‘“§®:ç@ªˆïņŽ¼ÚˆÜ)š‰ (Ž?ók2z–'©æ 6¡âÊs Z¼ý{%ÿžØ}X1ÑœñX ɘNCùY±@¹‡|ù rª‹r›@‹4*²A¼ÆþÁ¬ÛÃ[ÂFo,4@Tˆô½Ýò±BLtÓ €YD“‚œÇ€Œ €çr§¨…ÏÙ€h°¥ð;á®(!€ %#¼Žƒ²pµ(çhÂäé+ŒŠÆªB*lH¸¤B’x¥ÅcÃBŽ,4ñ L5Ñž‚k±l›uñù‘-i2Ê‘ÆËº0AôËGßÇDëC  Ä Ìا„œh˜HÙ Y"C§»  ༄¸`À‡•©ˆN„¬å¸¸Ê ž±ÿR}<ËðòŒ´èx¥+TNV ¢æÁJ šK˜)€ˆ|/jÁ Œd– “Î;“!X ¦83ÐCŒ7‹Ÿ÷xŸg7ÁPûYŽã;"k4ÁЬÉËÜÃA\mÌFp>JGÍÔÏO)D¡ˆ¦ CFÌ´ðw´Œü‡Ðk…±¥„¿ˆ’´”«’ ¤’Hñ¢ˆrµR¼à0Qêа˜Eél%[Ì(úzË!*¬XºE+´ë¤K(‰€îì¼\V©È8³%*û#+B­™‹6))Œ†Y„IH2¢ü…†°OúTˆÝÊ:®é½l¾p¹:­ó:r,IJ3Êy›ÿo Ãÿñù€Ø |˜ Ï‘±¥²ŽâñJ套›)–Ü82c™‰ô2Ëx(–ŒÈÔÌ:M! TŒ*Ku‘il#âK:äRl¬Iß1¯ó:ÕOýÁëÙÀ ÜIÝq1D5 $pú­æ{ ²+Cˆ2ùªfðÛ4ç¸8(›‰Úp‰E]Ô~LÂ…s ×¼tKuˆ(=ÍÜX¼.‰¹çá›.ÁQ*e×\ÑwEͤi×|àŽ Ð9 ÄÆH‚“Ñ: Õ"¸©½ ¬À’0"kTˆÿœ¬O;¯ËF`­ÉAÔLM´®ÓÉ[r쟱YÐØ«&…ˆ fý"!°ÓgÁR²bK¯DåÇiÁ(õÛYžuËùK â×Ól‰ù[×¾êÔÈäÔ*iHî`¶Ì R 93Äp³Ó £hrUCYûáŸu ¿1"µÃœ´ÌAôÒz[¯£¶ÍF2mˆ¬Á]ý4Ä9³§{DNs AˆØ´€™m†D’‘qýX*WtýJQ\T÷ ZÔ\Q…èTJ=ZË…Ü„P{Ð\ÍmˆÜ°Ð¥@fa¶xk…!I½…°8A@¿`“69µ\iÔ ¸À†ÛLÛ„¨ÌPÞMÿ®ÖzëXP…Î$Á@Íï0Á{[Ö±A'‚VP¡Ö€†khS ©ÕWÄ Zð _v5ZuåÜÍ%ßà\*£È¡’€£mß Ã¼\J €à²éd#ƒ°¨Ê5!˜{•¨¬¢"[ ˆ‹ýR­[ß ÍÐäaý½¸­[A,>@#›5i’Á¹ ÀyhÀ^\ˆ€¡¹·ß倂€‚„páa~ìÜö•_vý‡ö=__Í…áHQ6èá9ÝGMŠú1 ØÄ0°·Q&<»qØ?[ÖS:UïÂŒ×ÀRû´Ø ±ë PG>Ôº‘m 2±àÿ#*¾4 ›ʬ‚MŠV@4Ý{…KÀÞBC/QZna€HWÇÛÜÓìÜÌ=߆( õu_^öeß ¶‡G&âËíáž`–PEa xÌ@á 0jƉ¹‹¤’R…8ÄÆKÜó]u µÝ]ÍÔÉ2Gqlå-‰»eA ”Œ5™ .\ˆ_¸ãØÃêTÔ„ß>¾Ü£¥äp‚?¶ ^æÐ`_kVlö³kn_özˆ xdk¦‡qîf ˆ]…HgÔlß60â‚ 3®Cá0R ¨ ö@&×½p¦I–IÉÑ’OJ¾õ[à0BÍ’P…5>A‡~ÛP4YÆàÿ««e“‰Å‹±¤ xJ „¢p[}È’þ…^€!@„ø…_dÇd–þãh†ß6@VÍ­étfárËf®¦Nˆ êˆ¡væ9aÙô=ß‚AbÍù€Õ;º×Õ·Ó„R‰U ™“ƒö ¢Ò­5æÒcMÁ¿)ëªû] ¾Ïˆ4Ž7{SÖÇ|ÙòÍh…P½  Uppè¢(‚vÖaÔ$djnˆÖ€š®i¤^ŽkÖátV¡vlQ´æÉ_ùMgk.fRÊŠjÑšŸ‘dÂ]~}L8œÒƒl Ò4ÙP`;™Q8jÅ`ðެS†¶c<ÿ…=¿ÞK ß÷†ìÌÎìì®fr_t ¶lAGôyö6àù’”ôÖìßiï.tuo¤Ÿ÷uÖavU#»ÍiaS5u\†Ì™pÀâ–àKï’z˜‹¸˜‹½ ÚjZ.ý.NÐôŽã¶x ðŽ‹o6}a¶Nca¨ó`èKȺ^èk'8éKÈVôFÿc…˜æëô÷ °yï^ïA÷éD~ïôv÷wWê–ÐìÍ_fÊ¿æø–€Ü< !ùB ÏQL¾p*%è,ÆŒr|m4r: kX‡/  Øÿ·Ø1ÅëK°x…ö¼¶7ìˆ9G\Pc;<ÿ‡`Fé|ðçÌÕnkfw!ô!®éì¶fs×îô=ê¦wo?êï_útIw¦/±jfYñ.o£rñ j8j€ÌaÿFøGá }æ˜O߇%JT¨ÑÂ"6.ü/È!>Œhñ¡¾”ˆRêÛ¸qÅŠª|P¢4ð’œo^¢´FŒ­þáöoÔB —öº´tà/'M…ð²·ÊÎXUh¨Â+ a³ª‹õŸØ®cÛpmóm×·*Üþ3…k\¯ôþ©Ø«¢oF®_jÈKøk׸_ñÿþ‹18+ä…¸fL8cD}ZQ(˜Q Z‘æ,áƒÇ™)þkh‘ŸÅ¬:Ì÷!W¾Üºw·n(±¡í\T¾„ù¯¦MœBræTjáߥ+D ñ¯U„¢D ¾Rõê’W½¾÷èä´E|.‹–«Ù´Z'·ûõî|ɽÆ?×YåÙ~€AÖ—`:æUd f¤X^“E¨=öô"¯ 4”@¤‚˜‚j©Q$ÁB´)m‰ "Kµ¸P!-Ò…¹Hð‰Q Ó ¯ÐtœSBüc¤‘G^t­0>¸à‚ÓmôK/YŠ÷Ô/¿,å?ö vÿVFl½·“{ Èà{i¹…•[q%¦›^‰iU|åYæ@õÍe š…%Ö e¾E(ZÿУ‚U$I@Ú?Ï #Ô"Ìs ¡‚=¼ý–RF)ñ“•u½Ø’н‘8fÃé³Ò«ª‚ôFƽb“g‘B·Á%üÓäuÿdgT¥å“Ë?.t™å?ååJÉŒí –VíáGÖ@dÖÙ–€“ýÇ\‚&íWbþ“ç~dùeÙ^îä—¢|I¨_¸ãvå§^ÿpúÁ“¤Y*D-Oúœ¾DqînÃåÖZo®É­u.aˆ*Ã$Òs1‰$¡6’«+Ù¦oD.fåÔ‘º.…ëIbÔ(P"ÿ‚ ÿ8³²79kä%ü„iOYa…•=Pm•eM«ºw)Í×Ucö9aÚŽ•‘¹æî$&£åº(d…úeeƒ&*ÙZF×a–ÅЊý†øÏ¤é:ÄŽ¨Yˆ'jå‘G 3¬Ð‹¥“F94=-Ð3ÏÅ-ÌÓB -ü3Ï<#•‘€gäÃq.ßäܯ)ë¥QÂÁ ¿$kž Î2…d‹XÕ³ìÒž»PÏWñ|nî*äžQî” ôY?½PºŒ"¶=[Ca&ÔÑ·û`ñjà–=ðþÅÖ¢áÆ™v¢…qµh¼®‚Èh!^jÔ?©$$Iö€$¿HùÐÃ)‡7hÿ\g4"Îêãæ!Èã/ ‘ãw¿ ¤%.1ÎM"u ðŠWÂÈsð! £àât>(/z³6ü¢ å¹Ä ¯! T`TabïòQ€Ȱ†3tHÏf—'žñPx¼³ Îã¡9ahç™VÄ$´ö,¤jåz¢¢Ä4=¦Y¦P‹™¢=º9ÉåP‰úSÍä´‹ÃÙP$õfÔâ@j(·8ÊÍãŒcÜÅ*Ô©ÐÐa ¹qð Î7‰{ÜâZÐy4©ê׌&œËÈ—âJ, )Ù?ˆå2Uô"„É¢™Í.q hD#•orã‘Üùÿ†‘¡]í&ÙýΆҪÝîxx5Cí?õ 2µ¨ÅÈxkQ”yŒ`è’ ˆ‘| ÌŠñ$lð¾8ÝP&ð¸œàòX$OÐræñ\$²Š>b6¸_…g 9M¼þ¡HÆ…@€ò(à9#…–@ð+(BL| ÐK&E“½zJA28©Ò , Hè„. ä;Í€†nÐÂÖ˜±¤ùàGCFe(Ìà¥.=é+eˆÒÖ "<ËG§fè›;ýlYIâ¡æ’§î‰ë2_ŒW»ö§¯t//n™Þ÷úDEÄ,Ê* ¤@j¹ ¡Ÿæüç@îqÜãŸò`Õ?N@!<‘(7†ÿû‡*’2ë(${Y\9UÕ‚(ò€! ÍzPÂí„” sB‰ àŠ`øE7‹ågýÂ1SÝM>Šâ.ôMNú ð£)j¡>TºÕ$´¥ý‡iGUWê즭@L{¸Þñ”jzâ‹òؽ­u‘™‡ZædÈ7®-ä{Ë|Pöhõ! ¢I‚Ûhõ9Œfý§äƹÎì%Oñœç@º’¤]yMID0– Pýƒsª(Â=MØ "µ3ÿÔg&wÕ?õJ+”ë$d’‘ Ð(Rp¯ÕIÀ,!­{Y!¿<¤c›D_ ¼Q--²…t!ÔÆàR2¹œÏQâ9Üæ¶€-°ALýC<®Ó’glýtÿã7x#Òч‘7&}7xëJ; uFOýhMdZŒWï¸\CüF"‡ø2P_ÁB K¤l_~'Ïùd+ü@!E¤¬—ëtTyØZà? [íuFÿDë­žÑI`gÝííÄîEFíQ »ÙÝΞôTU™‹Ü?Œ"Œ€´ ŸiÁ}‘2=Ó ÒÇ4‘ÍptÖõVä]ßÑÑäÐÑ |×X Þ=HÎBÄ úuÔ%‰ÿÎz¥ÄGØCXÅÁÈ}½Ù´IžµA‡\WœE%´BL¤‘¥4f}ÇB¼®!QàÃpFѵ^Ñ=àNÔÞ»Bìݺ½›ƒÀ˜í DH‡ðBÌD¸ÀGTHU!Ö,Š$¾KØœ ì‡_|œ> ˆ‘ô å×㜓:ÕQY!wp@)æküWxЄúuLœ ̱ø‘FÄL©‰±ý×BœLrà  ·½i`Q,“‰!\íÄR„hÄA ÞÞîa.DìÝëýá@Ð!¾ÑâJáÔÈŒCxÂ%0@¼Y|ä=|=Äÿ€=àc Üã¢Ì‚ì£>ºÚsÚñ…#¾’°œŽ':N!á¯ýwEY*rWY5AZe„XßPIAübcF\àÒe¶Û©9vƶl5JþüTç´à‰Am€ä† pe"Ô÷e…p_¥^ðc>öÅd¬ SIÖhç,@¥ Âô Ðø‰U ä]Y"#Þ:µ%ËŒ¼¢±uä´©Â à'GÐLJ¸@d’L# #–Lz@C­m2CMþÃ2 D3„ˆM0N¤‡0¤fáÂ(üÀ'Yc+ ÙB<˜=ÙÓ.Ò)¥»Y£RZ£‰B`QzcdÌV‹9Z,ÁPp†Œjü0€>0 ½YcrJH'å@¥‘Ý•W8F_¬ÿÍ?0BcÄ À$…`'=ŒÊl€ ‚W}•X…_ß}—9-’"iœ¾Tá±™ä­ôœEùD=5£‹ÎH.D\haÅYF,Öa1Ø5dDhB(„âÄBGÌ¡‡=IDIŒÄáP@guÖ@¨¥B*Ói`£hˆR †£ÔݦA¬Ôlup–*Žæ¨DýtŠeÁŒ ŒŠü@çszDjI[í£¢|@æcX>icdâ îc\€6 Áèƒ8…bX…éäœÅ©S9½ç(²¢2‚“d»2Ž=h†¬€'.•]äâäÑãèÓ•!¡CÐF~öœÓcG"‡}2¦ƒÌi\QBšÆYn-Kj’‘E3Œíƒú‚2DØò\¸ÆYzH„Ä‚!\À€ ™VyÓ$÷V€ ˆúªoFH€! nv½ïû.úlül´dlgÁ¯ÀÅ Â %Dü)Äè=häÒpÊýTŽxV‰ŒÀKÌcö„eX2é†åËÂ,í“þê>ªÀH0€,ÀÌIíì²Êô¨ÓøeÅydÅ+jH¸j1¶éû ~¹œÑçÒêµéŠMI3<ïƒf„ô†ÿíÝ"ÖMàÌä0å”@Ð:Rø‚@-„Ò?ÔB xï?LÀNTÀ„ÌŒñ@€1l™ñ©:oêÖ@¸ïg„!T@gÑ13šBHÇ.À ˆ@-®@'Ž´…8A4žåBÀl@ëJ„KlÄLY0CqÃl“* ÷9ßÚ¤Ý۹̓é]?Ä^0Ž•ÕîSZå…B† ß)fÊi·îœºÜÈt¡¸eR¤Ø„0€md4Ã2„-0xtÉž³- D  DÙ ÁïŸñ\sd„Ì5GO@ȸ1ßÀ„ͱ‡ÕñÀJÀlÝ>l@ul~¾Â lÿ⯬ÀTœâ@n8AXÎ ‚˜p[‰,#æB_0?ÞìRU³°“ª€êJÓ¦/"H@$«ãd_´¢•ØYÉÑ©ï†GGÚÿ0~¶4f¹„Èη[0öÄsX^¶uNòfÅôñ3ܤk ²ÙC^ÊÃ<”¸ÂB<óRE|ïB<õ@T5d Uß-·T_5U7ô„€l•sVoX~þ XXx‘:Uœ–ѵ…„€¡F@>p_ðs´7™ý5B§î`)F?ÒUjäCtˆD€!ØÕÅíJŽØ §Ô·¯ñþW\u‡}FÌzYÇhà G´/Žœ *IN\kFÜdØÆk3èt#Åûí°™•“´ªêl""øD>ˆw>#²:ŠtÜóÇ:˜CníE`_îB·E;4#ø Z± jP.` 4®>™œ¢LÑÕÝOö˜ j o\¡©µêg•¯œæ¸H~ƵáŠeÎÙNÃóÚdl¯ûLJ’ø/]-D9IÙ DTu 5(uÙþ€+@ Ô¸Q—Àù?#Ôx’C H±ÿCÐmF°À®§U ¼Ußò!êØ??„Bá•ß@–WÜÇVH?G¶üDâ(N ÔG™cÌýÀlF3Â-\ô˜,÷8s/ô^ä"à‚vf+ÙTžO‘ž·ÿ“oü‚uàŠ W[úÁUÔš$aÉS²Ó GœšŠ›®l8ꊤOz?oÜTŠËt¬D°–=@ìvF A=$@”º7-C- AÃz‘Ó: äÝ«ù?”¬ó: |zVà¶<´üBø:¯«Ü@¨Ôm¡È tlöˆ¹$û&®À¸n!Ë5™Cn?Ë¡Ú%>7Žäæó_7ôåÊ:&O5qðBäݸK­}7æBš³‘ù `Lã¡—/žŒI¯©½'a¨ „ÈŠwãg3Þ f*E&9Ça-ƒ±­™ÁxRAõÊI‹IÙ ,ĨÇx*xS’€9 ¬ú“À«O€æÿqŽùŽ—À€¾¢ Ч»|dHê§×ðCã ý±l¢>øÀuë·€("ïEtªPã³"U{Ño{X†»èêñk½r÷]C_ôD@öÊ œpÜ_ËO-D ,œ>˜)€¢dM\‚ÞÄLdFKl\Éî6x.ë„b9ºÎõ2¦ Áhç¼?D0mØXAÄ…ë "U-_ÿpuàÀ?%nAHb ‰+Xb ‹#"Yü;r#ªôhèå?˜†* ¢°àF¾yôZÐkã$J”úôE¸$ÂO =™ò¤÷/DC+þµ°ÚÄjÖ¦ô¢2šÀÈÿ+دÿ&üc4Ð"#‹ó œeë5°fÍ Rø!ß?{!œ„ÐKïé? "þš÷Ÿˆ¯^ùxEé1¥K’/½ºäƒ’Uv ëó˜+_¾\žÿ£ªêŸ*Ì—Z˜Üšµ…Bh×þ'û¥þ-ðño„Âù}˜òŸ+ÿ†0ÿ— ^‚ jý[6ðG‚[&Ìø] Ù[e9~ið^É÷<¢DùO½GD2 Âü‡h…|ôN´é Ô¯DØ€DÓ*+À¸ á (øgµÒ@Az>!,¯Úúê,µÌè¬,²HÄ æ` BÏ„‚Ê zìÑˉxBªÐ"Œÿ*ÆTyåGÇ(23UŒ\A1áC졈r¡´"VXµWþaM7×\»7Ù¼Ì-‚Ç"øm0 ‘àÊëòxhŽ¥¢›.!…|¦–HB¢[X"á– &¸`¼8ÿ)A½øLro%öV2h>úŠtRWøà¦Ú '¨|ôA$3}xja©„êƒV.•0Á / ,±>¨¬Y=KDµ¼’À` ùG˜W†pA–üJj '(¼Dƒ¢ *1*MÛì\pA„_Š0r¸j ¨|‚ ! Ñ 5Í4ÃâdíÜ ’­ÝÜþ‰€ÞZ`~û‡–*hÓÐ! J@ºƒRIÈÿ—ëFIÀŒHÀ袲üü‡ÐñnÑèäB:o GÙ[ôQš²ÏÐÞ1ΩžÈý'PWÈ'„L›êIA¨$ˆ ã¬ZŠÔ)ä °¾:V°>‹Ö¿Ú¬ (F`ÿiE „Ê'Æ¡Hƒªf»$¯¨<õL¸)Á"„¶ÎÊj•T71põ \qõr8u1Ó­5,àÛÙê’·!Zaª:ã·ßf-k9C ¢`„º.†É¢UÐA=§Ø;F4:4Nõ\Z yJ¢ôŸ JÆï†èÙ 0 ò’ ÉF%•æb\°(J>°*Sž6Uðga…µ,\ :k¬´È ÿC,¦YÈZÉåB˜í©Ñ ­Ÿì’"¢Šª\¢ôNŸ\ÒÎje¢xD×®ÄÂêêsÑU ³8ÿ“o¤—oˆ8tñ«ùø€­H$'9§Í‘NÁ‚0†8cpÅ&¨@ t%Ó|ް„•”$%',Yœ ;Ù@AN—h±}øeT9üÝSB€ˆä+B™*UO~&#¨0ˆhŒ˜oe¶„èCó˜@+šµ"Æ YKV×(ä)˜)¨nêSŒ <33ªïyÅi¾UÏäÅIdŽGúÀÛĉ^ò*YâZǦÇ$r+ŠÁ¦ƒ_,$O®°'öF êyÿ¹ @‚Bõ …ð‰Éä)œì§B|ÍÖwôUˆY<_TвÝ/+E šò’È!(Š%iÁUõ" ›fUAQØ KSīЌv‹a°%2–Í 8òÈ”†²¦(ØŠlDnøÖÍ .7  D¾ÆÉ7ÄQ…*›€­ %Éd @Ètþ‘°¤bt³˜ÃãA‰e„•DN¢FRÂ’PrR ½")Øé„v2ÛP³Ô.•è£)U•6™µ@fKÑÀNŽ•$zåCB‹Ò@"§Ùë>צGjäµ DmMGO.‚±YË#„Ic4ÿÑ˜ÔØIv!ÿEC ¿Âô¦1cÊ£="ÎÞ n¯ðAÀPÒˆÈ ®(YA"Öç$ !©Î2j¡ÈŒù‰Ÿ!@ I+X$#”‡GT' ÜàXA`ñ)|ÉŒ1 ÊhZ!‚ó}O˜A)Ì`VÇj+L)…–¡°tVi+€_¼‚«›Ä3úG_fô”Qˆk-`Ï=îÑ‚%´`'>U´Èx¸ÔL‹JVú­o爪x š½ñAÿ¾9/pÊËcÒ͘ŠÊ’“I MˆœY'îž•:YH*p€·Rdt#Ïw2â‘[LLQ=(é "lÀ]=gañs©ÙUh/Í”tÿǕ0+×{8ÎWÆr+`d3D´–¥Cn R%/ „/º«©Gó&4¶ë‘‡<°b¿ˆf(Øšß§é‘l®Éqé#Œº´ºéÒ+L@.çˉ¯NV»`Ï„¬!Xx+XÞCQdb“ˆ@8˜4ïx¤# |èû ,¸Ø¸¨„$}ÜÄq¨ñ5×GQmâ"׬|hã0å:¢W0´Nm½P|^óœhPgLj=’2bŸxD:=ñ?XŒ•â–‡‚Ž:‡ë[$Å Rž©[>°…Î}ýF«ÑíAÆdÕqÒëœ|œO›ù]ÿÉÁ© QF«AjOó^ùb_noéȉUòQ”œ‡™)°kîòîåò.ïÖòåAÐ# `¬,PNZÎ#É "aØ  À ø¤O(‚²L"ÿÚËaÆàë#B$ð*€vú4Ô‡é«Ánñ>åæ#h2*£ìáBz(¿ ê|Jûˆ¢û¾ÏÐPªß<âhÈ‚ Yb  ‡òEvVîý`ëî¸æîœ0ãjÄI d ïG ã7¸I^øÈÑn}’DZL£Lòå›òe«‹íÂÎü‚D–£4ää,ÐZ !RájÁNéžþá,ñ. Â,ÌàJ"p®#¦,h ¦í^"€b¦x8eñA8öã{ 04æf}(aÒ 0.Š+ÂŽAVÀÿl/fHøHi°KFëÞÊ®´ÚNini½@ÌhºJ'.*N¸H)ÿz†ˆ 0fŽšDGPm36ƒJƒc§dn<Â/Ú©F-_(Oòh¬‡`,b9”£J%   –ÃôQÊRï%‘ !‘NÈëmÎOpN¬"Ià!1 $æHäòppwqkˆ 0ù¾çdJlqVPI±².VÀ ÀøÂë‚‚ äí+&iÖÉ,Æî, í4änàR.jÚJ¬˜ âÃý åEòb4È(ªÅmìP8¬Rn¢¢BzÊS¾åÔþï^X¢ÇàÑ Zád ,°ô19øKPôQ‚FžR@€.)¬ZÁJÀ¼ÿ(B0åJ#x`6(b.â–â"¢øŽf¸oé dÉ%•’ÉS¤ÀiAÄ4ÜíÏô"ú‚B|@(@ý8'YSßʯ Ë´>rÂÎFâB`ÈïºFFÂ'²"\ˆbøôሌÌh4ªÉ£Ôhöâ)ºòpƒ«j¬ÇøPIÍ#F‡Ý‘»êõñΊ`„ ­$®ã!M0Kà"ƒàa ½ÚË".r '%bg4†’'4$?´­v„)ðdHŠÀ±rŒ¸ÂqV’n BÀ§IH3„`.@5 íiPª'¡gíØÎ#> ìa'ŽÒ ÿ’Bkc)Ie)éî…I4B#+rTG"ÿÜg•æAîj‹AÖ‘‡£~|ë^ HIÏ)IÁJ¬Já²-K0 1Øä„<夺T< Â-)çj‰¸ƒ;H`]MÛ”M†Ñ.Rt66@Bwâ~æ{Ʀ¿@)£BlñÀÅé‚mŠ%@å²j†S¢ÏÛp!RóîMRYSüz’±psB¤-hóe¦-F ÎH‹i|<âÀ m õ|@ÌÅ¢Â}Hé†ÔæäÁACcÄX"oª³7˜4,wU `Pp» ". ‚»àÒ,¬þ±K " bJ…í.£uE°ÿ@à¬ÕZ«•† 4h®0"? â&ø†d²ª¦†\ ÐÐÆBCPC)Ït/|ìUdS¯©(ÁQS35ÛdC=´´˜èìúÍy0„AæC'NÀ¡â)ÄgþxâSm+s‘'ªZ€Fƒ܇¡äîB¬¢©–ê$Y¢~¨ÓPêgT…*¨¬´‹4¬¸ 5°½39‘OñÂŽõf™#Êèé#q/Ò Êt‘`Æ07¨Ë\(¢d$õa*šРn]äï¸Òç†VòeÞÇ)5/ôÕ†à°+m'à9´yDtD-ìV¾¢6Oæ¦rq©nïü󢎧ïÿpKmnª*Z€U…T†0(àôÁ*è C@IÂfäd¿OŽ%Ë4>LD‚À"Øt+0-0¨Bs? ƒ€ `tQuU÷àX ±M}ö^"vÖè˜t7ð9¢,ZSg·§#/ë²²ã»:¯w“/êhQ†qV¸B²Ï…wkl`x†‰4nTÁš Í,ÀÖöÞx²Ë¤°íBÄ¥B D¨z00¦-E»Faah nk}["Š-vÜBwæe‹zþª‚Uׇšâdn¸GÔLMI§ sÿ5W&šÌYMYO÷^ sö!1ðZ× úXoÖ¬¼4:é` 1­ê©ž<°‚Š­:Ô|¡ÐRôcl²FCŒlˆ…;E}Èh8½¨“‘ónÖ$”K„ ”ù5RUÓËfå  D0D‰x>$à)T´û2¡8ÅöŠÓxÊSZdé4s=Ü7}sôÒh1¤å+cøEšLöAn@8ˆ²†DÉX}6Ž!ÂâøXÅêÿAœ•z P—MѹKé’žÔª:"qž%Qõdn!öÒ#ðNþ¡ó¸®]…q·gAƒ&êò[4YÒFw«ZžD8ÁŽ¡OsmkÒÞjes.µ‰ÿàö'•¨n©ç¿æ!Fwy N@§RŒbÕíXin„n"„¥Õ&G÷ï¬ÄJüï[†ƒI¼rÔx¤†jÈPød‚QpŽå¸©—Z‚•OÄù˜1 Ÿ5‚€䉞¹‹%æY­ˆmƒ â:|ahïƒþŧ€P4PZlñ‹XÑx‡BnÂ%ÿ/ûX†% D®%W_…4´MŽ1R›§mï¢ìÈ6ã$?íëd潕x)w*HïX"V·q¹"B>­¤Ó—eŒó¥×è5ûI7{G R˜Î4:¬qM{Ž‚‚1µ·Y©\©a»Ÿì9†/A`~A€î²*±×™vÿ58NÈk þJd‡ºÍ¹^Á~#^…ó ó¢F' “cØŸAãF}¼ù°§»% m;çÜЧßÊÏPÆ/ý !* û¤L,¾9@²| 8à˜i‹VŒÓhk±‰”Gsa¨æWKmåJ〃šO*DÔ¸Qw´ â›5œÃ™uû¼gfÙ`('NRÏ#æÉ#æ9­ªZæža ò>nàd‚Q9y&Ævyo|†”“ÏÈ­çÆFýâpAZ!m‰Ü_¿›mi%ɽƒ¢µ—%fzêvVv‚::BÛ*vJ¾9 8`Ì…¶jË*&Û#\à«‹j1¤©0’ô«ÿªiG’ŠÛÐx8k!àH$g'ørÖPšUY—Ž¿Ô9(NšC`&ˆ¬(ˆ% ÑÐý·!]ÞÅu* Ç…‰ÂlÖ¤}¼hmìº¶Ó þ}¼FW\„ál‰\P»mqòͬÕãä¼yrÅcg€$uq >j=fk=pŠp·Ivt ¦’ÿÖp3J-©X⫨Ssk>DÀÁZ¼©ñœ|ŽWƒUèý8K×ü9N)(Þï‰ÞWNæ *å83³ÏU?%m*ßzu|†>}ë§[ÒXÆ^‡‰<5+àáïÂÕñÚ 6”se}{9Ì&N&×'l/2îáÿ´"NÐ' \z Ðð¿êGã€^^€ïÃæ©3IjþÔB›éržRƒO$Ø#(\OgöK[ÎJ^rJf雞{Ûï©`:Ïó /öÝ©l<ëuÄFÓ±à1Y¦”—G¡Ry=åzÞáÓžmkeîzøïbP>@åš`fž‘¤®O/¥qÊP²((Í ÄÞ†Ê.Œd “´¸HƒéNM1š-Ÿ¨•z%Øòú-µÔuž ¬ /=¢é ¥:Â׿ ý£p㟽!ò9t¨/bÄóésÅa®|óeô2c”#sQü—o#Ç”#EA‚„ 3ÿ%Lø€3g>œ>мðoЂúô9áߊˆ( ú0oÞÉ(Kéý›gõŸÕWÿµ ÷•^”±cD 1ò_D¿þýRõoÅ¿"+Vˆ hw¢»ˆÞûOD_rvÚ5È?ÅA xà€ƒƒ<6ðÏÕÀz®êaÆÌãd½“¤Kÿ]/iªAœL•ê$ˆØSùªEÛé D!è…°÷ТE‰wEHT Òã?•"1b Ar9Jµ)3æÒ÷Ï¥VC~VøpÓÞˆúŠ.ý©4}P›ìo¼9¡¢BHý÷{ ½YéÝoá•Wô8Ñ‚!˜õcô nTØIˆèU×ÿ?R ׄ阃ũõOh%ü3¢eÿ<öÏ9pe/”6š+xfZiCŒ6fḣj%àši´ äÚÕRAOѳPpí%B”ÆEœH(=”Z!m™VF$”Ë HÈÔÓš•O”}ÐP5­·Þæ]àQ}á'•UKíÔÛ þiu_€ò7Nt$]`nhW\„MÊÔ]R8˜†‚õ…¡<Ìó‚b‹=ö˜Š9àÀ?©R„šíøjˆ¤ !Œ¦¥ö5Y[¾ c´î¦æoä=é‚>Q$‘FÎqÒgáGms#q¤Ò?àbÁ†È„Óÿoæã‚ SþcPCÍä{ê‚÷ÏàÁÙ—R1¢•BÐý£V\å{R !¸oZa×Ö@mEXÚ_}=…Žî±>† X /á≪¢šêª4†gÅzë@7æzÚ›ÕøÏ>òJdi4“l°ÿÜ O“N>9¥›ú¸°r%çPthEaÏHÒ‚4ÝFÿ¸0&L4}@OÖk:A®`ú|GÑOè] î@x¦K”!ˆô=ŒØ·ßUbÅ/À‰R„~ÓbÇ ¥€‘VœÄ„9*_úôuøájIÁ¡/öe©zü≔€ùÉ&ÇÌcË;ÚØ²ºn†+­1Ó¬š®C¾†Œÿ°1S@‰R〴DÊšÛìrÁ©„K#wÁ™¤Öá@#Œ°=Ù7 dT.vÅ‹.Qr¢+oP@ u”$=Ðo¿óh@ R4 o‹žß^ÛµìßLa(˜…+Pð—…ñ#“ò`§(8É ^„"м U•Yˆ\ñ*”½Le< ­êaº—¡¦e<’Ìþq³^™æX@϶â(+0Ò›Ž³’–’‡ D$ÒIs*"DüÂÀHÞl’5ô9aˆ\{Nª¯¢T¯&ë²SR’2µõ„PþñÏù•м"]bÖrø˜„Ej/qá_`ƒ?¹äDHšÿÊf,bÌ?>c¶$ƒµâ#EL§Z rV'™\3º× ¤QÂ,pƒ<­v¶;³†sˆtä…ÖòÈŸŠ74â ÂÍwz´}mCr2Å¢(qNKJ¼|R(ªm äû‡ ÎÇ ø2‹ù:Zв”²„"‚#3;$þñŒkÓ?®)é)q)#ŠÜ>ˆ*ȵÊUñŽ6¸G–áHtæ¼ ç,øN–­†"³¡'E RD€7 iÚCl70r¤Y1‘î ka 4šÑ-ðøG-KÖè‘ëÉ’&Ø+Šœ.K³]ßRVæÿq”ZE˜'@iœ`ƒ)?¹HæÁŒÓ—ºF~á ³¾&Ã,ex<^ðÍÈaàTÙÈ££“Å,3]ç~tNŠ$r37Ú`:ךdH2Ä(°~ú385 D†3œM&Í$׺äÔŠ—¬µ¬ ÀhF-dÞT´ Õ,OÂQ³yT–P¬ÀOÌS”ò˜t- _V ¥•ß3K_ÒtˆPÓìÔ§ˆXè?Úx’œL@*G@ê™ê€¥~,TP5@h2Ãw~.5P"GŠÆ@Š- ^IA~«hK]vÅðbÀ†`hˆ0ÿ…S8 1ÈÄE^ô‚^È0£8å!;á‚/Ǩl#¢†éÖ†n89±@,òzw´z!‚¯g2SÓ0xðÞØßÈUSeb±GòÔ{²a‚‹¤i$Hvñò-]X£%ñ^x.b5‰Õѧ‰kBèSÿ8e¦è}UFY_HX~„fúH0` `VMq‹Õ¤ø!` ¡(‘]L"{byŽ·‚oƒ/ñG"ÿtHKõ~fzÁ1Ñ*uH ‘#§1šqh9s OÄh¹²‡5c›F‚À×\ÕsÐÀAÆ!%Æ8¥Á|ÉWSÓT¡‰šxÿQT¶JÙqMÐKÐòPY! E«H~• [@Y°6gSĈûk&¡|ÅÃv?÷Fo¤G$IÿP@!€ÿ GG@‘0ù’F[¯õg˜¡˜Ñ¢b[ž1È“r :0ƒu6Ô‹ÄŽe—A7€c¿Ñ‚‡S•nòR#ÚUs!-ÿÈ0ÕmPeeŠy–¥–¨¨°?äk…&ašúMksgûÒ•O#TÔY‹c›B…’ý5>óP%ÀGt³8à† ‚æ¶…G˜UðÖS·“ÍùA)g{3'c`E­°õÑÃá5ÊRZ\ˆ  òÿ](±•WÒL“‰Ô׿)–Kœh©–ó &¬h°hŸ0Ãg%æa½ál4dsÌò–gSK!Ió@††yáÉ,`aHИÿ°£Kµ@§—z—s:b"¤A#±‚G!š2…Ôo™VO%xš'hVEVX#•*›Ò?%© _úB ñ LcöЦț-@¡Þ׺– ê–ÐL*VšÐ–gY£ö`ùÐÓQÉ.jò6†©lRtÖ˜q‰žéy@G09ꈖ9`¢òaHú4b§¦á >rU\Ç”eWÂw¥>cÅ¡,AóSõ‚oGdã‘ÿÍÁšÔGe@QbiŠhù}@ B…'äð©bµKJÔ''ñCÇûA¨¥1†‡Š¨%žâ‰£¥G;úà†ÞŠž68®­r®`éš@SÇ™:bìv¬*ç9öÖ9AR$ ¨)x†À$ýh;˜'%¾h]lç¥çOó qƒ¸Š>¹JŠª¤–ª¤`Ãêkp"²¯5" à"7*E7¾Á‘Ô"`é!I! góp¨‰ª¨7Zn¥·a®3;¤ðM©W®ï U‘±®žÑˆF>»±ñd|Ä26vDhÅLRjU9¯«Îw0;bÀñ•›È›Sÿºö°Ck±$'Ì9´¦ñ KñeRÁÿµ§ø¡Y ñ6(K†ù5ß9r„£FEz¶­<š>Ú†ùg¸aêv@ô€Ž@‹ñ2‚–ù€3¶Ÿ»’i È”ˆ‡.L«&ôPjkáš,„|’È…A†%OC]$QfqQ`ñµÃdf銫X§—[#Ùs˜”%€1ð‡ð(@ÿ ÿ{F£(¥l'À-€£)ba÷¸Ž°Õ@°Ž™nˆn•“zQ9a sp–ð–›@!FN™ñ€î& ›¹0“Aaµ¿7BM+Aº¥•?¡Õ?tp€Š%Êáÿ%aCí£5|zY¾qŠœ#§¾¼[#p,É'°ÿ Ô l (UÒ;ÙjaFUzÇ+V0 Çð"’г‹Km3X ²àÿ0¿\#ë@$‘Æ”Þâ-Ä·$¢;IÄA• :°L1$ÐgÀ^b%‹‚’ 0…¢|j˜`L~‡éÃ¥1î*(МÝ`rô"ò`aò€Öû,—b`ª2¤A0®19Æ}<X°ÃDcxg7ÒE­š?œwj52=KmÜ]lƺºØ¾á2êÅÛ±ŠqéÇÿp ÿ€/óPÝÀ¤ŽÇåÇKE¢RÀa äÿ1ŸLËB $ „˦1|øDPÁªÄQBF:çÄO,†S¼%QWKs€j ŒØÀ0±»ŠLjÊÍY]Çú ÷Ç÷àg¹Ÿú 4Y9´ŒÎš+BaVA…LÕõˆÂlIOì$FÅ!1Ñ– ;1JË8Í™¼yK #i{àüŽÐ»@³œÎ5ò[vz?Â3'P†ágÀ¸y°Å,¨+1 ÎÁ !QS|)· ɾñʾ&  IŒŒ l 2” =´ÌÎÿ0Ñ ¢ ÕÈÕ{7ÃËõ!£6ºTY8•RÿÂq°€:˜TWAW4ŲgZ3ú°ÆÉ8ólšœpm§Õp¹OàÃLpÎ—Û Q]ŒË[ÅG}!>†å¿‰Sº’º±ÝØ×E2}°·É¼—| °C€²<€²×,‘^p¬°Ó¼Û£¼{>¼íר+·|lŒy6È^تúè$áj¶ªÏÓq÷Ë›ˆp¢éPÆe ­Í»ã̻˻}ÍÜtHªÁQahéUE¾qØÁ,‰]}°J‘Óõ4»­RSsfMÓ½!£ù0fá&n Ò Éb<Ý÷¯[€ßÿ€©£+v Ra.PÏÀ¬ÿvj1À. ¨¯w%Ö 9Ü+øÏRA†"ŒQAÍ&V,¼ß®Ñø ¯í2ÃFhbá±Û•µ½BõÌØL«—è%”g%1½‹¿ ÍìM·× ž;ž’îã}¬ßûÝ0#~ZÏWëˆØ±'ôçl‰Mƒ°TÙÊ!¦¯ôËDzÖ:"%Ðã@IîÃRÐyÀ»Fp–{¹R  É?Ž+aãEqÉ6Û:F«¦ÖÕ¦&]Ò4ÒeãφL¿¬ÞÌsRÒ ½\N"]þã Tž¼±–‹4p¹h ”.‘"þ¦‘l±Ë§ã1mÞþÈ4èÔÜý„7ž_Û}è%\ÿ' ž6 ž”.—_ÞÇÍ~¿ìV±TL ,5T¨ïédϧ¯ß8À ¼±þâ^ýoûIwûŠ)æ¾ûßþy+ÊDEþFaáò'*åÊgÆ¿‰ŒQR„‚Šõ?ý-Ðóˆ>ñBÏÿq„Å@ÿ D˜ÿPáB† >\èâD…g(^ĘQãÄ I0úaÂ’óNœÐ@Ï`ˆöB|ˆò!ÌùBÐÃIÏ^Μ'þµ t^‹¡CK´8Q‚E‹'XU:Pž<òŽÈ;hÕê?26j´ôÕá1b0ëPVZ¶ ë9„’QÜ>Å™gK–6¶ÄÙ‚gÞôý7ôÒ¥K>•÷˜à‹©U±b=ò+WÍÛ:,†á³Â}£ÿÙù瀔é[˜°†pÈ>H¨â$JœÿèÝtÙÒ Ëž8 GªéâÅò^´˜½Dd§J•:•*P+ \vÖû FW3øà_¿ÿÏ– ˆÿg>D7It¼a®!DvÓCIƒyTRÉžB8°Âð¤å–X¬…¥¢£*ªJøç:‚ª2¨*Ï8ëÐ Íæ3(Óx ƒÊjË´Vƒ ‹‹Þ#ñ¡Žîcd‘$@$ÅNÒÀ7~;p°À ‘¢–£GÀÞ|2'“˜;aª&¦ºg yÑ袴Î:ªóNË„ â!Fs ³‚ <³@ù'EÈÀ·Š+ˆÔ„oŒÞb‹†ú6bä¾ÿütüà†>X޹|šGÈÄ :aÀå:´Ñ{ž½‡eažÈ jê:*=ˬ îòl*ÓÚB´‚xáX ‚À• ÎĨŠÆ,Õƒ €‚ !#4\5ƒOÄ{a‹ ¢ñ«!øJÇp„@‚ÀZè[lÀy†JL±A%TÒ§F1xvQ­0œ§„”¹ÂP©q53;Ýì²{>ÜVu"Ï]Òý=‡ âgT4bL#Tý‡‡(¨Ç<ˆÔ3è« ‚A<´Fø½uê„-‘>:HG‰ЇyNPTÑ~úém¢’u°©¢2ªISN9Û¦6$ˆª¬ºÅtÜÿ#ý‡Ñ{Çꄈ°ƒ HEQ̃võJâ‚€Õ#Óˆ' Ú=)æ½€PQTqL œv¥ž!†@WM dý ™!XÕ|aëùæ5€F¯zï7ß3à­=¸Â ^3zfˆÖ†@rØN‘(X@Ï‹—PTÜè–Ûxã @Œ¨¡ x¬ÊT®v^øû~Š *Gôð²Î¶;Èâ·„Ì8Î*Õ’@Ó^ ©ÉD™K˜0„ @V­3ˆŠ2°A#` ]qQSŠ4øXñ`v?ã™AÔ«`ˆ…ÿ^h„–W©ÐEWCØAb—°7ÕƒVÍûöÄr‹ŽˆÄ67ˆ€> ÿp’ò•O3r_HXl !€@Ó§¾lU+}SJ à6´% yêJ˜Ì "À„œ ø™åÌxªýC4Tk×B¦Ö©ÇTAxÓ?æ…tЄo‚+ p€¤‰0«*4ˆ|Ø"#€Âÿp]¯ª¡Õ˜‡½«Ñè-Ø¢ZÄUjï ÷AjG”bJüJcŤÇ.…‰ÅŠb±£Y&/«Ò]nLrQJÊò‡©12DfT¹æâj­ÄÑW›X Õ@TÒ*ä®(¬@×_;nP=/ˆ ¨4Wª tð¬'„¡A™¦¥ x`rÑ×~:OÖ!—¼añºÃƒ¤2«Ê-¥)²ÎX„%8Â?HÀ–8ÑXb|9LŽî˜—»Äâ¨HL(a ²È\oT*•%…XèCZÙ’ã ;ÇÙ¦ NáB°l¢A‚N³¬3§7dFrÿ°×Þ3»!`^窤„SÛƒ¸*ÃÿNÍ>Ñ´B Û†V´(˜PÀU14ÞYE,»ƒ5ÅéHÙJ@(Er9"°ã„7¶¢0ÂOzÔR¤"ªçÂdà/˜Rb\¶äï,dŽ‘Mã•‚|GÀò-·_#XýÅ`Ñ©Çs¹L©šçêQ;8Ç9À‚|•ïèÛ}r5ÂÒ3XF˜p¯‚òwVÓ$¢uXJZ]MM‹ëq™×æ±ò¹œ>s€i#°  ¨(#pbíè£óx G…i…Ü—!9б£Ä±ÿ#€°‹— ‡Rk;–¦Žº¬ðœëK!3ˆy¸»„¤§(ØOy²[+ѵƒ ÿ+/t**d*¢ÒÅnZ!Í¡2 •KCˆ¤Ù‡0LàœS°¦1or…D'Ú²-®ú¹Ô%ÙlôDâq@²@åÙ¶š·Ô[Ä=ü¤Ù£ºk4¨{4 ÓœJ¤ÄæÛŠ›‡š¾ 5ä(ò¨á¸k»+ »¼[EXë»Zô öR£÷k?ùú‡¸E€{PA#ó£þүƣ¿Õ£#é”I4kÁÒ8ˆÕÊ€ ‚|qûC¡›K¤ѧÛó6‚Ú?`œÃOÿ ¢7´®‘0Fª3P| â|#â¬(“¢•¨¢¸EsR¸tŇԎº¼ .‰©Z¤HÈ(¼²)Ô/Bâ/ ÒÅÕê |ÿêIƒ»c4‚dÌüVàÌò ªú/W sÊÛSwc=˜¢Ô¤„+ ܬ<ì$x¼@©,ÁJJeMÕtD¨AÍY­xO#ø@³}èP|È\\\ ±ä«,Ë˺,§ ‚l± “¸¶B£B/ÊŠLÑ8­¸ ÷›#Ó–ƒ€ ( `K—3ˆšÌýª£„H3dä,1ë¯÷„L–D³ p !È/4¬* PªâÌOJˆ•¯rÒ3J=[Ä\JMÕ\+B[ÇÛEB.â«M„BÉÐP-}ðФ!€@Q#C)ps¹,Ï8ª·ÿáŒA²–Cη„KH:¥p& ©+ XÉ* ö4ˆ±ó øË%¿^TˆD³ñ °Ô¨#)MÉÕr ¨ºzMÖQ¹HB§²¢- 㯠•º:b! „ÇäaˆÌ !o‹·E«ÍäºÀªC €+ADAGÌ ø}ÏquÌ؇ È…L͵5’T„xµ'ìºØ sêѤõšËËH£kÒ5)›WeO±ÃÀ2?jÌ;“ÛBr…ÚÙ°‹”Õ, °€œ£9]¬¤:$3H?û$ ›VÚ{•Ѥ2žÛj'†p ÝS%„A«¢ë°áš!å™PÖLÿÍP,€HUÃ|8QàLTÇ™—ÁaÀ ”J¡›‚€{CGZ NuÅy¹ ¡k*,÷‹¬KˆÁ`ÕV£šxR’\ˆ/Ä€á‹X,$†°—h…ThúTb$3;—ýü«JÓÏ M€é-Õ‹07Kž×ÜÉ®„ÑvÃVåIo;Ó­q.ÈMU@å܈–üÜPWÀà4¬“Â…ºÓAÑÀþ’a@ˆ ‡VΊ$£ˆHQMͲ£¯åEL½H4€ `UaOª9T:º#¢òÂô0¸-£^ÇlÏÕzÏ͹vª¹OñÑà¥C]$ò©Iÿ2‘oô0¬šX$åLܲœ—U¡ÇUlͽÔ@ ¥E\Jâ;.ÝäPÞ\ˆ H‘v²ÆÙ5ahTÃ+-W5§V«ÃêA¢Nî8 *¡&OÉŒ)ó`º »OõhÌÇÓ¿=J?zϹ€}©$5Y-(‚ù¤O Å µ |"_]œI`ìÆôu@¡Ã³Ùz:x“ßž” ZÄ™=.®û3hU=w»Ó7}Ð J>#ðPtÏh…tµ€Òm×aBÅý‡Ô Ɇ Ñ{@'y°Ã ^ÅÜHÏ`#[ÌKÿ»ÅáÅ4Ç“?ÒRX‡¶Ô˜ÆhẲYÌö|€ ÈÛ.»Ý[T ³ý"3«ìaúÈ‘]Ö›ØÞ"C÷u_8Ä){Ã_ÔÆ€ñ6•Câ÷ân-ÌBâÍ”¬ådTÛ«Y# kIšW;f蔜u}Ëo²0ÚÂ]ïÈ .UǶŒÌVk˄ȯdã㲜 j°×>h”VÇKÿKá¨á¼­OÁ¬9 8^ˆ2Ù/ Ш ZQØ/® æeŽ,Ad„79Z° q¯$MOýqãG+Û·ÓÆzáB…¬ÿšÞ ¹ÀM{W°—Ï`¼x£KŸN:¿´›gÈWà ŒBp-ÿ@dØ¿¬[° 0‚ž' ½¤Yù‹ÿÑË ²â|=AÀÈ?‘U0Ü †Lð!)4’JÀAÁ³ý`m ü€mUЛ!Dá³Ab}PR!×Ö?'äAu0Æ(cŒÚý£Ý‰ÚñÅ>üC‰à !Âà?ë%¶Þ’ï‘õ˜Í3A”¢±¢~d©Ù Dú4 MG!øÒMQ`¤‘a¥”þ€¤mÄ!¹!q½ýVÛ†?`tÖöØŠÿ°•W<üúœü jÂCúÏ[3F*é]×AJPZ;òC^x@ƒËF òCA¸±ž££ªªð­`HZ~ÿ ßLÑ#Ù '”0O–ù± +#T´€|YJÀ ‘ú€¥`ikH›ª„Ø?»!ápZµ€Cö0’œ[ö˜ˆœ¥AW¡ÿ ûç¤ì¶k[Øíh£C~)>AI*4£¼̪¬&éeÙ­hûí7Ï ò4,Ï 6Ù÷OM« Û£‚©¹”¥‚«mßJølx›J*MUUœØ–LáYUPÀËl¹Uc¹/&úèÍé:„®»á@¸™†ðhLûÍJ=¢ýã°e7•0 € nD`6Å:ÚD œ´v‚ç Pÿ€qµ‘dÔþ0Ûn÷(sl‹ÝAj0"6?§³Î=g^×[@ óÍFwô¹^|ù÷Ï ¬ t{ÿ@³^ëY3]ªb®fyë}÷-,Z tOÃÇm»‚=Τ«LöD&|ÝŸ)f{øŒR¸›?,H\pçbÿl`Á ð©xŸÆÏËñ39GÐ!"BGˆ¦+ÐΚ×ÏPwy½^ÚAçЉчDF€ÅPÀ/,ÈÕF˜Ø-I ^AD °0Ê8l ÷Á•Lð##üÎJŒè•Œç°Ô¤&H ˆî嗮ΣÐ[á6ô!Å7 @Qc· íI/ÈQ‘ ÿŠÆHN #Áäþ!õ]N~ö‹"C:—¢±ès"Z‘D0|d1øÀ.®òž¸fk^,[e&+= W¾“Ç?ɰ@GhØ=0p#àGP&ÐYnДjå6©Â—ð |øÍCøGN"7‰h<=_‹å’ë#M”œÖ•3)šÒ.Ú”*S4É™e"ñŠ@FÕ””œ‘*fJ–KàF+ýƒf»ïqße°aG À=ÀLf³ó°Ãäa“ß,bIVZÑŠèŰø‚t$Ô¦zjʈ(÷~Üä[ÉiÎËzd)÷ÑJ4—ºNÉÿÏ‚PÑ ™Ys’4yMSíãˆHV‚ˆ®àò‹1“Bp›|¡ 6Z†ÝQÄTæ@î˜Lfæà9 À?2ÀLÊC4¢éã®(bÏÈ’%Ò‚!0°™ 7µb˜À.•©hE*yrÊQ>>ÙƒO5Úu(r€ä}¡_?·:/ÏeQtüP"Îü§%Ä,f2SJ¸ùn® +@„&Lne˜ÙìÃAüÈ‘™ÿh)H›VˆøøR‰ýn¦7øOŽbˆÊns‘À@F¿ g8 U›X¤´º÷½ð…ÏËÙËöRX‰F|Î>¹)ÿÞåqÛ š>p ir|HÔJ¸žÄ–œh]§„щ ÄJ\˜•–é;>ÎQ¥øGvUzRŪ´pÄ#5„ˆ É•nt“@CÓ)ŒÌnh=Õ;JHz3• ÁpïSjÅ_‚Ë;Éçû^D[žU ÁmWEG´xÀ¶ˆhVÀÛÂÜ–rÕÇ!³ÄøÅe„ø‚‰u´Qš#uUÊb‘ €»!€aËØ‚šš1аèL 4¶Ñ.½ï©D*$!*n¨µž¦Ä©¿‚WA0Ì#"âE# °ü>Y`épyséËG„{û‹€¬‰¥,ÁÒP÷8ÉÿL­ KfæèC>’#LÕ¨Øp°,J³;î úw&#ÂÇ ÐÐ$&‹I¤Âd7§{“]ŒáòƒŽâg™*_âl”’ƒÎû.g¨BÍÕ¥ÌYþ4ëÐu¹eÊ}#Ðk†M ¿ŒXêaÚélØ ïÅiWÁ¨h^jB[ݱ˜Aì‹‹ X»Úõs÷L*ˆ¾Bññ43*ª¸i Uʺ=|ÔÂMÀÆ(üâ²å -ü€’@ŠÄÄ€:"%@m}®/ßÚ#¹öÈ®+UVŽTܪ\l¶Ðªž‚ Aî) Fë,«üÄw¢ÿɳJcœÝ{ÐÛiywO ؆mt¤Á›‡®‚ÉÁûÔ¹¼øÊ›°âYùÖ×MžÙ(€q ` .?'RÎMº¸Â|ñª¢kµÖƒ¦³ÅcÖ,úú­ý¹—ˆ8Ü ©d¥n}<% (ÊzLWÅüCðÙqx‚ Ò9&ÿ GsçÜÚðÅ#uc®ÝÃ*¶Ær¼ÏÄÏÁqï\@ ¢·…4KÉ¡þCDU .þÎTDï×` i `Ú|ð…AiMÉ@Ž(‘?  ¤$”[>v´G„09‹®ó7æ¨E"n»¹|Ô¤¡·†*€{ÞÃVÅæ “ #¦ÙF²É1Ü}N,ÿÛr”D¤¹ù£c"Ç#LŒ²ë‚þ!FöÑš]ŸE ñ ù††Ð#1c#Gr$á?ÿð`Zçjº÷I;³{½w?ƒp4ÆwúÀEÂu:{‡M¦BeÜ‚KÒ 7ñóhS6sô\Øc€%•sŒ~'1Á$y’g<7/‘‹Ö ¸p Ȱ1DB% GK/!Á&K7  ØFbufbŒ"@·9 ·"8E5b| F¼–>ÿ`[…Q ‘:áQ*ìK°Ir¦òT?òP/%+ßg612æg‚&}8X…¶r1VLÿ4R #Û÷¹èåcŒ5SSPâ`{"'¶† ÀðG‘Iš2p!auºÅ(…¢ hka(?³öDꢋOD!pHS)i1ŒÂøji!3DT)ak§…v¿V¯QSР°l|1-§"}Áõ†cÑFzöWáVLÄäˆsîç]3hˆ:ˆ}¿>‘}d…C @HùÖ  §8udï2ÔS ÿÐHXÑNÑ#ì3KAs‹·(:éR#^w4†‚.4‘qá5_53ΘvÁ’Áä‚#«”)·äA NÁÐ LóqÄA ñwÿÇ:!!À¿“}>aóR1GLyM@6wÄbÁGˆVŽÅ„øQ>y¢Q Ò˜^Äq Š¡,S'G¥!!Ó£˜Yªˆù 8Ãõ ¡`¥U Í¡{¤T—j@,R(t‰‹6Ò(-2ÏVÄX˜ÆØy#íÄzf(jaŒk8pA$²wÅVSôÇ4`¡‡v÷:IKúð/`Ù×AÅô0”øWÛõR~§ã“Ì䔊ç~Å4n}”›Œõ%x<8U$ õy†5Ø™‘&r“øÅ?€ŠÀ`òeг|Á7?ÃE ø…}™UÒ——“‹mÁjbÿ÷…±{l¨#ÍA’[Š£—ĸŒØq„‘_e4ÀUVÃf7É4qÞ˜ C°ñ ”$e!W'ˆ‰MzE L`Ó-dÃAßGG:Ç~ضŽsÄFøBópÂÓ!ƯѰS7°„mÓQ­Ê´rtª;Ó~ÿG *¡2Q+ç:R%‘1:1Y:1¬Š£^!áøR#¡C I¯CYÈ…†A9 Æj=ªª[öu¼X‘_(URÅ‘q`§±ëÉ?q†¢.#|Á#á#ádñ:  $²†ýYÉwQg{¥WÞõAD)^&´š}G4ˆ¸²§m4¹_¢;ø§0åQ¹bB”1q÷y:Q"ŠC’MÙ&¦÷¨ ™@³ç©X(†n›¤tªpù¯º×ºû£àùu†âuoá°Y·ûžEƆe·+’úù+ÀCG £W6É$°ÿ‡$xWC¥^ 0x‘R|ÄX{‰fÓsÙÆ³mD‰ˆHƒeC¸’A'§šˆHRmd: •µ«+¯ñn²Q8ÈÐ ËŠXA»¶4sÁªIj{‹ªË»{i—°¦=‚žÿDÁûÓ9˜bŒy±ú#½Úaö^Z^w·‰!¾ëq¾£Â4øÀ! 1.ñ¡k¹sJ”ˆ8nˆ¨g/s`6ëH³©iÿ£ÜÇF%¾¤G}ôRG1.!/AU$ÑBVgÃq Ëz³Ô#7`.ýÁò¼pñ»w‰)†j»ª…²{`÷˜¢?XT|ë™AÊz`|ÿ™¼Ú1¶¶K pKX1²rE©wç1FrºÀšÿ0A²2”åAî'Gîë;긡ÀCÄ+®ÖU¡Oy¹‘¨¡ÀƒBYrrw4GV©©cÀ¢¨¡&!8Ös§· £p\FäŠ\èE/Òeë£W ¼…BŸWd¶Zµ‹ q¼ÂhŠƒ˜y9’n¡Ò«ÂÙq`èqº°Wˆ0ìÑÐ 69"ãï±lñÉC R.5­|D.%ÊA››B´ÒºÄ1«b[l6òКë;àj(p²’áF»Òà3%ù‘QuÈ&•D-2ªÆ¸ðn•õE$Aª$qry 8?²f°Ûÿa(ì€Ø|‹=bE$lÈ¢&ô„ÈÁ˜EÓÍ×Y†ãvÁ4$ɬSW$ê‰FRíø¡ݾ{Äm[íA¸šÆ¥6YWY9š°âˆ Û÷RÒ5LË„m2+Nhî÷r`Lò ¨Œ¨]ΤÐj­ }¹5±–>q¨™‘‰“BslÕPâ6x€Àawá×÷giÿèŠ,ÃD‘M?³8ÞÏœp³Eé=?øSPû—:£žp+q öUbøj‹yŒÆ(jwEþ­?^C&dA ®ÃñvuW°à»’<Â%ôQ€ÚL‡ØmLhÂ=­æø}…HhLIág+Ñ5–(bB2Q´ÿðsˆPr+7ªÃ΢+Aiø‚ ÿ`Ì!qgÑã­—´è…°vÞ8Íêr¥ëÒj»×( ·Ó$̼DDÁç³—'²{çÓÍ47a““Æ$6YvT,wæ>ÉF!µLeh‡WÖL•ËäÕ{ÅLð /6Ð}ÄoMô`ì'®)N`3 ÿÓá(˜¡ªŒ,‘Zá&µ°½FøHÐERØ“©Øå}Þ9ó»Ïh{]‘&@ÝY—}‰.D$@”s£¸)ê™Èî„3E½"dÒ!哌jpˆà="ør(ô@&ôQR"èÈDÐ;›‡—ÁRÒúrÍ´ÅÀ/&,õÊFn¡Aöks"ÎAe3Œ0æ)Ô¦™it“Pr$ie©³±tÀã©HÀ#@O=>?LJØ/{|Yê‘}3 ßbkDª†:â˜öÝ9–ýjD­ß {vY@7Šwu'ªÂB@Y…} 3M¸¼Ž‹G-WˆÒ^~¾SRn¾Xjÿ nï{Ö²ÌF±L­<÷ˆûÆY’!à‚?ñyòùEfbR!=ÑtúúÝ´Ëæù£ã ð=êeûØE#Ù;:™¬ºÖùkdq™¢8lxží´"B-y!@bÖ½7©ôÁA f’`s4hcÎÞGñhxpxcÝrÙå~Ã-­[½rð0>™hˆ¨Öƒ©¹0‘hBŸë‚™Á#A¹¸õy8U&ÈIÔ³tÿð ϰ ø@ÀƒÍé;Ù³XõxÓák;#ªèâ»§úÒ<¢)жÕÍ#¡ºŒÏz6b±¢cÃHÚK÷?rwŠa „§øƒó Ír2Vˆçg6ÿôí~f³‚Šh8Ä7Ƨ{*þ©ÙŽ“¿'PWÉãÑ-ލó`W`Ìw†…‘²ì±tÏÿž=…ÄP…þ!ªÀÑ¿ñôñû71¿‹5n„˜±£¾xñ*^̱âF~þQù¯Fˆ/²ÔHq¢B›%9B¤¨S¥Æ% T™²‚P~BW–l¸pƒ ޲¡*…!ˆòA8ñOÞòî ûìˆ80›â=³Ü8ríFµfãÞ»'Ï/Ù¾ò þ×BžaÃ^û•wb=FöìÍó:2Ä* úÀˆò„Œ&| YŸ¡†=¼ñïÆ‚?ðáµ âÿ3d T¸°÷I~ õmÌxÑ8FŠÇ3æƒirøÊâ _þÌ·œãć'n¬0œæFI)ò#ÿ!åÊ—Tþ$¯QçRŠˆžFh±j„¨úôIaù ‹,¶ *p'¶üçy ®0(럼8º¸Æâ¨…Zh¡°æiÿ¼RÌ«®è¡'zæqLËè ‘ ´‘Ð áŸH{Ô ¡€‚(h%‚þ¡ Ûžæ†Ý*ج!‡²ƒn;„S9åJI$’É¥/Ç3 #‘ÎCηáºûn%3wâI§’|â'¢\bÎ(¥ˆJ >D(êJð±`V(@ÿ¤´ýëJ° 5R«@DKžºê’PC ׺Pà 5rŒ²Bü‡EYÑD!jÑÔ\„ѲyB¨ QF À‘ˆHûGQCNCD7!œ ™e–yæš$RÈÞ‚ãIZ” ã²9âlZé̈¼û§$›d ó¢Ÿjši¡6!ÊK9Í"•òy‰"¢z+÷½wÝ` ð[@ÑE3û2Y½¬.I4p£¾ü. ¦P(†ˆ½4Â-ÆBŒ1?à1ŸûûP#=þç„ÿN8ŒˆhíGZu„(ÔV“ ‚Ýv²•Fù&ŸYŸpvÛìÚ;ÉZ9«5î¹êÐÿ.Í4 0¦2]J£—Öm:˨Qòɧz‡2êÞñ˜[ N}Fx 6DˆjÑ’w]™…º{Ø@*ŒúÓºàr0T³Çã‡ËâB[1³|*×§;}H~ueŽºZÙ±Gç…yzÔh]ÿ¹"Ôzì± е`è–)z©¤”2µ™†ó¤¶$wͨÁ¼ÎxqCBó=”âÃn»çä|Oí¶zI^òÞùæ9!aV¸¡îV(MWetùa¿ ‡PpŽ"þ”­ˆ3æ˜#2àÀÁ±üBˆæ©²‡ÈôˆPù e¢u¥C"úχäÁð 3±Ì·~ÿš ˆf(VÐ r ˆ,cPRHR¥…Tk#Zj‰{42¦|¸@;câHÕ¢‡žxx©j<ùÑuœ¦mu Ã2Ð/ sà<Á+ÊÈ1gÝ𠌂hÊ:šn$ðñl"?´bD®e”ÏKßÊhI8=Šï9DË=æñDÿ#~b‰Ÿ¢ø®óø©&ÛÉ΄y”*’¢+c†¢¹–j.h,hAÙÂMhŠU0~‘Ç8j*Ž%yH+ªŠÀÌõñ11ÛH[P‚ÀÌe¢•ÇÊZ˜RÍcªûUkdƒŒ¡ d­@Bì¤$ïXqÙñ€µ>:àw•ÕáhG  QWV‡hSÉQ›1‰QsÛKü$² ŒGmPäÑKÿDÓòK€Hý<öÌ{€Eµ…kã…¬¹Z¾õ¨¦ý›‰hû!Äü£©‚yêŽú82‘³|È~ì¡*zxn«-Š•c8dAÎ ’ÿypcÌJC I´š²€ñƒ!ìæ®¬ÿ‹O GÀ “ï;0ÉFMR«™Ä$ðˆLbɒ꼩]ær,O(‹=œ ÓkáQL¾U‘àoQ(<^PÊÌ#@^¹¤2ÅÆ4ÆÑSw‰TÇf â¯Þ8ž˜9U£?tr$”øÇŠ[ÌG]æ2$e +ä®ÏÎlYˆ\¶c³ª.;7 >jJ5-L¢CÊËò–·&€%Îprø‘ê0‡Æ‹H*‹­å.;ö€;1)™»çæ÷ü"öê‰×ÏJD¶¶;¹ç!åÒ5=P#…+ã‚ä!´¤qAtù¹i۪储JÕäBP’íUd8"°ê+ðC‰P‚ÒU½4Œ‡û,eô ø<›yܰ Îˆœ‘B†t Ñ† >¤Â»Ô<´Š"(¯-±öWŒdY'‡ âzMpQàUËVžeÙô+=š0Çmðšâ¶÷ÀË<óoÿlã‡>8Ä =;l0A‹ Îw‚•Þ!ÚƒÕÿ{œ* ûÔOñ×YU~ÿÃüæ·Ø}`iÊÈU;ÂLf@HÿÀ½á‹,5ÌXÐÈ ég²²j·Â¿?ËJˆ°â="'o©‡YåF%‘öžR˳´/Ds‰DÉz30{³›s‰z飈 §9°|8Š| ªIÃ#IÝø˜ñ36 Vé°¤2#Î9 ‹•ɹ#) >ËÑà:䋯S¾Óó:ˆ ÈÁ¸´>2±‘!™ƒˆ¶ûk¸“»†ëŠcži!ùëB–kÀ‡@Pb ‡Z 5ùá1%‹2¬j%ŽJ¹nÙb¹ÊÂf @ÿ|áœàòX)z—0=q =ä­‡À_ù‡Vð­ „€ \$žb#5*7HÑö™ y›œ›ÄÊ!¾âsÁªZœ4X€W`¾ä ;±ÃÁòiA,>ýÂSai.À fJ«DÒŒÕø €+W;¿úàCÈ9Éâ@¿ò+áI"“6+Ò¿û#¬XЇel—ür¬j«‰:™“Ÿ8ŠË“à›¢þbl›D©Ÿ+/Ú©ÿ#´ ±°05 ­Ê39•B±Ê±­ƒ=ª*ˆ „Wð`¾l£ÁP€¼ÁQ;O\1k'ë#8NÓ´½Ñ³$ ‘ àÿ×ø I¹šÂ*ä,t¹Ç3)û(Œ€/²²‹úµ1¤¿ò(!âˆÿc6ðx9΋—o¡"|&ž†¨›Ù¡_ ¸+a°yÀ3¥l¥ã‹úy²€‹ z ék4:A'߉žä}ƒ O¤„x…°ô~<=ŒHÈIK²ó’á¶£>ÇX™à1=ë °‡»b ¼û ¨¾ÛÅÊÂ4ùX,dË–H¥ŒBÆÉC©Z²%RÚ«ÍÚ‰㯞˜Žó0{õðŸ½xÁ6!8=ˆ €ýø€é´¢ÈC‚œú™‰•M“>ê >’AEŽàºc Ȱ„å[ÿòYH}»Á°ƒ Ó”J[±Z\ «Ë Ô4–Q.Ñ’.ÒØŒÖÄ !šíª‰Œˆ`d‰ñx?É:ŽëˆWz¥ŽH—(ÕØr)¾ÍËÎ|@JØ€¨DM¤ Ü=ËÀ¥2‹ù¿ Á;±:ÙžH›¡Ò£6 K~Tý‡AÔä#Ñ4Ô»´ÜÐcú­áØÛ$B¤TÛz¥€Ù±Ú‚b–Zb‰è±‰ÿÃS^‚Fèð•"ÂIhLÉêð™`¹¿Ýõ¾õ6…ÈÆ¨) õèLÁÜ‹íÛ¼Ì˺™,Îò9W…ˆRñ¿i£Ù’Ó;ÒÛ›™È"›|câYÕY-æNo]Èo½Á~ ]ÅA¶Ë3J"d»MãM3ÐéêC€¿†fÀÚ$éÔH¼/‰0R XÞh$=Œ ,-3v Üta¾µX è•Àå𥈾ý êõ[Á͇à£ß[Òá‹mÀJ£{EKЈìvcŸ±ŠÊØ‘Ê>kCt©P ø…k½ÖŸWÏ}…MÚ…<=Åå³A´TKÿ×=±þ Ùå^áÒ¨©°Zhh†|Ý€ƒØ[Œh¥”L&R2\â ä(_úÝa9 ÜÞ%½U‰é_êý'Ðø‡K¾d–Ó[Éx1{ðK¨@%Äø³ ”­Bª7O¶ß}‚¨tb±²ñÜ0ÎP²ìÖcÊ6o­ÁäJÃÁÔõË~¤“]Ô´rVŽž’V0b!¸c<¶ pXxi¬6dRZm†ˆâº-°‡LædV%% ÞˆJ®äKþæñug(¾Lvr– `$! „Và”‰ ÇÙ0z O>•¬Ë’|X²õ»"ÜJÞÜb«ÂYmåÊ[V>ÿçKË[Å0E‘1ÐÞSfˆ˜.†BßZ„Œfh€¤! Ífmni9ÑXoÖˆ˜ža™ÆdL&ç¼g¶évÎiœnaJ†'ˆçJ†ˆLþ‡6¸ä¤¶é¼lzhç§òЇ­ Θ3*J!Œ¨ ¤à£‡>ÊX<¢“ÝÔºáecÚßlÅVá¬*\ÎDÑõÄØP`æˆ{MÝbF »‘ÉÙå•ODb.EP…K8i\Xö(d—†¨€‚¿õæÇfU'P‰™Fgþá̶䧎`ˆjçzV'¸dNól¤MÓ[XíKîÛÔD}~MY-d™ÇˆÚt'÷xeûÝ ÿ›Å¥_Ð_jýÐ}´åÐåLJîͲæ_Þ Jsn°Ä¢Ìш>‚`a0ˆ¨jJÓ‡\p‚\à…Kø‡Ä®ñýáÆfaˆg(¸ì¼Tïˆé£.›£ŽoKÞ´žV§m{нå4üþoûîlL~j¿d ø Hð_í§g‡@߇0ŒM7ºmN >ëoiQËyuÙ#,¢Ö¨Ö íMä´ÖLñLôÜÞdݨ±€ðNÝÛ*žÐ Ä ð£dè…hæ…ÆiÈŽi{ðæ$?äõNò$¿äx6êhíìm%‡‚ÌNê6€,šÒ–>?mHp߉sÿü>p¤5Gpz8sxó3?p×ïÌu¢óyL)‹¾ìûazðäsÊ’˜îRÚ:ýÍhµVkœÍßâÃÊ…^qä fŽ(MŽΊÐ¾.J!1Q†qJè…_p6ø…KÀ…K` qÆä(×Û6`ï÷îiKÆrõNï'·uø¶‡-ò-‡ˆX?sZ—“v¦s:‡ˆ—òaß Ü†ó6d;Gpd·sj_mÉxmRf 7Ò!¸HÒ[ùfê+蓸ߓ`ÁIë†ntTd ëS»(È}p}hÁ·ëK;o±ËhýX2)ÊÔ(Y´ÌgJ¸„/SòÃ6v†ò%rÿ¤Nï¡NçY—u9Ùrjïò_?ó-W×ø5Wsyd׈fžFí[:ð€sR‚yŽ˜ó)'sˆÙ…à>? `Zq>úêí1Ë¥š’xfÛ:kíÍ´Vh}P»¡±Xi«Ë…â³úzç:U0уÏ]ˆ¸„ÙÉw±Ôë™ÓKâqŸ„^èSï…ÃöøùžÆò§äôNo èò2[m;Ojaß{:øh×r£Vó3Çmˆhöˆv¦¾¥—ÿ‡—_vÎÙ‰gWóÃGðÁ¿ó œ‡@p«VàŒÐØ ú¬óµ§GtøËÓ?Œ!ã˹±ÉýªFû‡(àˆÿàÖbdÝ ðËK(Ͱ‡q²4f†Ò+Àoa0±ûį煅ïh¸oö_çiy¾ï‡Á_sïÇdÄ÷þ._í¤ÿj—vˆ0†7_søgjÜvGvÅOyWüü?obˆÿ4 Ô A… {ùþéC´¢ †P° LHCÿ>|˜ðÑ¿!ê#)0Ÿ¾ ²lÙPÄ¿ˆDÀd˜/ŸÈy-äí”'%½QPê+ú&Í+®X ¥KþIý'$ê?JJETÐgÈ+" ­Z Äu5BLJ-õjÓËj>-Ú¨¢ –P"l#wî¿6€潫â`àÃ{÷ÿ4¨б»ƒÊ­LùŸ\¾“çŒ!°3K ž7·ü»9³Šy ó}@dÁB„±,†ËBD 9†d¹ðd¾\~›ti´¦Ñ9[ìü÷b'óóFÞ4úÏ…¥J[¾b uªS-\Âêã"}¼þá>af#PêÞë¯6‚/A3A°\y ÆÙb˜Øc –Ù^ZƒÆ„¶×gƒ©Øa†X†¤…ÖÒZh‰T= ­·€¸µòš0ЃÛˆ 1„z*©´‘oÿÜ´P›•„žé-$Ò?ÑéD“Ó ¥ÏBC%PR+ÔôSY žU—XõeV ùÿ!ˆ4›£3Š–PQõŠ—½´E•¼Ì•×A þw‡”ñÕ˜_z"$Ѐ‹5fhƒ†8=•ÑÓØ‹z8¥"z(éž'DO¬™9Õ?/ Œ0@Ñ íØÒ(ù(¯ Ä”C^yRHÓA”HBÝ´’”¥—Ô•+t÷”T—¡,U,‘"f²Á(ÀüƒKKåuçå%½ü"½ÐCX…“Aá×?ˆ†hZž„B"…¦MfL^su˜i»ëá_òZê`¦ž˜Ù¦ö(·ZcYô2B€0Äêñ¨J­ DñoüàÊPQ.ÇZ"}E«¬¡äêBQ–TËSÆôÿÏ+N©%—à.[ÞK]IÖ¨3¢.U½lK(UÐøPW]é~hA‹Ö ¢AŠýù—ºz±äo»€kBûÚ³è_’Z ÚØ"¶!Ú"TYŠö„ðX¡N%Ì?µXÂk¦««¾:œo¿ºÊÒÊÈEËPú6rù„ü6N­rT>Ùi‡ì²]fNΩ¢'72×2µ‚*>¨ó[pzëD/Ð\RReçªf²¦A V¶¶‚íV/A‚x"½œ%M—‰„V¢ˆM‡ýn‰™ˆ.‰š-ȼ=ô(çÐ?hÖòO©µSj+dñÉ¿ú£Æ€!EÓQ,‹ø?Q„$¯>Ž´ÿ^ËÊAnÔå^eÑ&<—¸Ä(‘³Tµâ­ˆÝJ}¸Àlù‡œ¼„Áf &ý ^6…µ© A~ñKaZR¯zIm„ézL_ú‚;ƒ ,2öâÚñfÔŒ‹ û ¤bÀ! qÆ_L3Ìž‚®6ª‰­’–@ì&„ZˆßûLjC•(NV)óq*G¥ì¼ŠŠI“.ö£%Z,cQ,§¨ÌŒ*㡊›ò@ñŒ [SR.*ø‹oë-oBò‘"s‘+1:QiS»HO0’±Œ …–fDòË/Ó(Hñ[KñI æ¡Ôy0é|Ä£R|঩Pâ*U‰I–ð±ÎkáÃ9»ÑÒ z ¿0ÄSÿQ¬õ¡ÿH×…Î5®vµÇ]ïjšsQÈ..Ôä&*ØNVD iEU½y±ŒU!‡¢–Ï…À[-š>am„K=S—ÊT&ѧuYë«ÄÔœçeXÁŒilj7e…KUµ£ZbmÎ'w¹”P…‘Ûò-$cpÉB¸!*P~|€ØÕ͇u«+ $ÍØ€1™"”Nýê´Óž6w[rm,χó}hi"ÿÊQÄœíBúý®ýÄ´‰Jf”ò5[_šh† G¡©,0„Ì£¶÷ À=0p–È´IÅð†Ç5.”x¬&"níR‚EÔݦ$-xŽH`¬”!·¶•FVðx•-•g1¹xð1 d Ã6W¹5=]î@£ÂX"º¢1~ {Ù<_v>vôýBß9øô…(ÝèÇÒI ¬Öi«9°v© {i· ë)y!í—;ôuXŽ].þhðPÃX…D ¥i4jD@à'g‰Oþ1Û½'‰'f’{Õ7JœºÄPÉl|’^½x–XÒRþ1ãláX äYUŸÂãÿã&·E!÷Ö/Þ‰ºÖ] @uõÑ•®ä|e¬w ­–Í’®½+Lÿ߀Þtd·¯Ù@'MCó©PÉ8òlÔ³×€ÍþIvÿpë_×— ŽD‡þ&=–¥›Ž¥Ã‚õ9¢Õp h‹THƒÑ¨~ŠT»c¥ùéc$Þ-’~4ßNžJE¨?Ë“}«,‹K ¤åý>|m€Sœ´Á/ä‚‘}KŒÐ“™I´ G™D‹F˜I ?@`™pzd`B >ÐJzèÜW‰ê9ÝÏ•ÄÎ% ^›=”`qÍ()F…ÈhŒ’Â}]Fqí¬’Â}ƽl§ Ø C-¼Â@@ $ÿ ŠQ“g‹NpßOP¡<,A>Z°xLjiGQ¸KŒD°ÑüÍÄj½Œé°ÖSH—³0Ë7 „̘“à¶ÜqÅ èÉɱlI¨hDK ž¥âdlà’É\ Â~Î ~Û`iHöÈÅõËAi]•ˆ$щì ( Ä£tÑ ÈŸ$KH@+Œò[R-•H0‚ûQØlmŸ@ÜÃ=4OE§”ÄRØXV¨‚úYÉá…Œ{ ÅPDI½1Ä­°Öé°VT—²$KÍä%ÐÇÏ ›˜…¤!É ÌM-ýÀ Üêݶ‡@"K":–cXœ#;š£@làn "J ™‚·qÿ’›1Ê_Ô…¼X’Ö1¢ ôA_ùÐרÙi„Ô¼õ’>´‚ì’ð@ €Öt0UQ½ŸÞÅÖ? \m5Á hÀ¾à¢Žä6ÅüDÛLmDãä‚ÊÄÊE‰ ž}ÉåñßLFc–›F˜Îé<ýÝ„‡Vý@–ã\Œ@†£"þƒ8†"ˆ#8º#K@¥;BQK`%@?æÐ(µ ?i†ÕEØuˆ î˸8ÈÂ'ê`£8HòÉÛBbx Á?@€hy–Ruš@U,ÀFn$s„@§xŒÇa /J–,SO9Ž=ØuüHq”DÃŤbFÅÇqÉC>K÷<Ältÿ2à©D€x 48K÷8¥;RÀRB%‚£8¶ÇTª£8¢€#;:¥Uþ&lÒænzŸ%ŸºYð“B&ŸqvÝÕ™ØøÐÀààœ5 ó!ÖÕ1 U=ÕÄQXÁ Äla€¿pÞɃøŠj©¡Ð{ú¤/–ÄØãüÆoP”$ãM²ÆÌÄMö]ƒ0”ÏBXK…Î…T~£nò¦@Ð&KÜÀ:šãRV†ÅngT!„r™]ð>¥C%gX¾`Š´`a§¥¥t*Þä â¥%ZšRi¥H>8D‹,¡@¨xŠ_m&æÀ%I P‡ñÿçS¼Â{²Öú±” …u€••2…*x¸¨…fz «mVx|SËÏ„Î3ƒiÆ$¸ÐP’ňǛ¶Çpnhn:e9Ö©mº&R¶#ƒÎimš lîédøÍ¿\g± É`%zŒÑ5_(õ†Ôh¼´AIì xR¡míyiÈb§Vác²ÄŒñ"á©…©Å§“ªB”&e2ć•Ä·jPpàÌxÉPÖRÞX€ÊÑÍ3ÄlP€ Á;Ò,™®!,%_(pJ IËQbKÜ€°É. çS°°-î2[0}×ïNÒ´k¾º›Øv\`Ò”-]àëGØÃ<àk×Ö…¸z–t<ŠBèƒìÿÒhj…q… D^†Âa˜@ ÅJ\I}¨¡Z¨ÂÌ´ªOºÖ±DüfæâQ¶€KY¶üÃ3ÿ Ä2üC³q³Dkí!%ð’!ÀÇ(,°@´°I*¸#ÍjD!SÀË&Ÿc™P¨9&2"+b=¢Ç ›ì]ò 뮲ÙîB)’Ó†`º‘ÁŒòŒÆ×.¯Ø2‰Ùîpö|#¼²@0Â<,o{F×—–>ÜF,¿)•ƒÖûE¡R}/Ý’ŸûígùÖÇy¨*eñú ÄaF¸*‚.câ~Épý§ÔK,Ã3,ƒ/4Ã2XK§ìkÔQ¶´B‰-À,pÛe-°ÿÜ÷„î;n²!ß³n B>_0@ë³!¢ß@ÝXr%ëÈ “î6íMŒÀÁ ÜßýAI01B0¥H¾Æ@د×êðGñ€½ò+ÇÀ,s-×*Þò΃ìVk—°¢JhØRyí s,Á÷&^>!–žŽ9©Y.ÃÌéà­4ÏÅùNú F8eT.µq‡s3Œó³ñŒd…—øPÂL>H@H€?#Á$Yø0øÂ$€Kð&Fî â=¢‡ÄJ%_L€ëB+4”ÛM”Ì lÀ©Ý_–ªBˆkŒH ÍòªòÙ~­gØ#˜,³DI3I_ÿ”IÇeèCf"ÀV“,/ñg[¤Nì…),Z¶™ÃÆ'„íê}¨Ÿ2%uK(¶šÊ“å‚ÇUy‡E¬æ°²±˱/´„fá‘WW.\¡-U ° `Àüƒ+üC*\Q-´ ÁTÀA·GÔ5¬Ð5î5¬B¬ð {«7îÁ Ô‘I[°)Û¸VòŸ0 ³Æ<äü‰@5+öüìÆ//#dOdøÙ–­òþPój$HȲt€„Rák…7NUµ^B@5A+êÝ÷.É„ñåG†áo8Ü}8sm#^É1Šq–n#V¨…õߊWöµ1‹³feõ5 K2°¶tËÃPÿ÷ÔC=ü¤Âq#C*¸Â„GL€•WÀìH–4—·—‹7xcù OùìáÞè†Jøó>“I>ãž?Ï÷X°ì"Û/¶¤‡>ð‚¸êb[4J//GØTöH¶„„¡º¸ê«FóRIG,Àm¤ÄI}€ne$4aS$HþPJR éhÉP϶=¬©îö4ßÊéèâ®v‰UÌÌ̼]KXõ2d5q+£©‘Ø |À÷¢‘;Çu'€=/|Ïu_2•³„Gü™Û5xÄlyG»%ã5™@‘?ç}£ðpÂ}"üˆ‰À/ЄEG;F·Qzz(¸+ÇrJSx,CÿÀGxø\ˆÖŬ€Y<lÀ”¼Ö’ì“€d½Ö…ý(5KŒzK—$·@h©2a„ü¡OŸ‹ ÿ}˜·ðx¸ªÇã?_©\øWâÈŒH0dá$ÃYükùæÇ-i²8ñqÞCDþí\h(ã¿ CE´€BQ}@WXXA*='QòéË•ïCÃáºÔSÿ„ˆ"+VèË÷£yŒÔŽ ñoÂÄ…âž|8‘íZxçAøZ3hÀ„Y «á?{oß2ló¯ =†!œ`$ûæ_)}õñÊGæ¯T©Z¨ðŸ>Œ.T/ñoÅ?U¡ƒf¾dáöm†Â6óýoà? B,Xpðô?~ÿî. òÇ?WüKµY‚’"ÞúG¢$I·HpÇÈ‚¦ËŒG‚Ò\ÉÓ§PDçWø ÑùW, ;6Їž4øG'¦¢*„ü`\@HŸ°x9è{F‰æLâ­ GB)£½úêp‚„if¡ÂZ‘ Á(>¨,# 1B(ŸÆDˆíÿ•Ì:Óì’ƒ¼$4T!«µòYò¬„Á4Ù^y…¡Î„¸¤ …lûGÞvã­8 "ˆ``x™OIÉþ¹ç.`袅áŸZ|ñØÃ¨ÃñÂ/®½¼[舕þüçŽhôQyE4¨ aS(Kº´‚6ˆ@DvìïhhžŒAP*{¢a1{>0„’CXÒÖò‰Â É:dëW¸Š+®¹äbh/ŒÖ‚+¶kšf¡W†È%++{ËÉœ°§….¹ä¬…*\ÈLÍ^r3Û( 6ƒ^[è,& ëµØV˜­³ÎŒ£·~3+Nh‚8ã´ü§ÿÌŠuÍÔøÉ‡‘äyá9頢Πj„ð$Èc„¼ïn™`d•Z*áOGZôÍJ1 ¨$à!ö£÷ÈæÓgò)°…&Ô€(B€ÕÁü†¦'Š( ˆÂ…%C€Š‘€à×b…­Ëà ÛJ/ ÉÚZÉE%£Ð²VidHJr¤jÜ#§œ3*E#—’#‹p¡«®¢*5º76U¨Ô 7†Œë—K‚¹Ü÷ŸÈmw…°FÁ…‡ùq¨… ²¢ÒîL¥–e|ÙØ•[>þHdâ"¯Ø lïî!uô%Fïa¢Ô1â yCxÂgƒ ª ëHUDÿJ„.Úh£[XˆžÅš&]*©*÷ v$°7Ü‹k¼Ên¢¿€8Z ¨]:ŸmÃïž¡íeû'2r 㢷‚_D4T"ÍàÒ¹ÔàSqB>rá$ŵksœÎBrÃÁÉYàox…æNåƒ!TaHV&@èdl!¨cÈu|±hç"»…¡vw‹9lX%Q ¤õ§? Q÷€YPÇ èìTQÜŽRxƒ , óXBÑþ±ªÇH¦A€‘†L`]bH+¦•£õÊ iì=¾"‚5.-5ã"‹­À Šà€ôÿz×e¢šýƒ*UI»0ˆ™¯h3üú×fBY¥Xaö "–ƒ‘L :©KÀEVÇ:,#H˜NɆå”]`Å"IzwžFRÂËHÍ0ÂÌP gË¡L>rUI  ÁÜÚ^¶WF´@+†<š ÇÐiåƒKˆæˆ®Íñ$)ÑBæ8œD“^Q–¥QÅM­‚ =ŒøàiøK¨è•‹«•±[Q@j:Ù¹°˜…*TAÌ?Xc .6UÎߴįO‚’¢¹× }¶œ³8h!±ÄH=PW®NO®»ŽtNv¨ Ì ˜º›Ó×D“óexGPâÿO.e©JyjC³ÇTªÂšûÔj!ЀÔ7µà Ê"ÆÙn®ÊÕšÖáÆôÕó|÷ Jû:ô“@€›\+Ì‚”{²GU •[%’IB$&£šË”F6±¹¨YÞ²« !dzÁI3£¹”zVs š O¥ ÿ0Äy‚N YËšf ¬«!2ðT»…LçkÀüdžÊ[°@$4aðÔ“LNiª' a“§P…åj£µ*=N࿨ʛ’¹èANrróºhqeáÉ>FÈÕmMJÚ  DÀ8Ä) b¢€©0i^%Zç±F¼é£sÉE®\ÿPÁjþb4¦5íBÈ2Y·) #õºW¹6»ð+s”­†­‡JÄæTJ \’…[šþ£ÕYÈENlØ.—H0À°„ùaé.»+&p…ë¨%(ÓxÉ Š§¯>&jU¢D‘±‡Ö…@t!8JŠÆEí]W2`ÌZ[ÕkÇzj®í+üÌGÐþãø@¸`E£òIf«e”Ç=¸©ß[U(,›ÄóW@¥>¯€ÂöR!rü¨ÉŒ˜–ÂUá…/ÌSžÙ2ðâ a™,¢8('NE*^¬ŽSdð¡I0TW lÃâ-¼ãôü.#lŠCjvƒ ¥ªŒBr€6¡ÿݤŒuææ bëqVÙ¬þÛêBXÈå 4†žö‘×ÖYlj´0Ph…(É À…ô*# oÑîQîr–qUAr¦ˆAÆ%špyÆ‘79In.(Μ"`&Íúøav¡pûÒÓÃ4jqœÖâ³+¡l'Ä`s·¨fuH\²–¹„ˆ yIÍHn“B ¸ÁÐ š]Ëv.v•!Jôgœßµn–ûk󬽓Ú`‹ zÅ|GõbÛ/fΜ>2´´©†/‚ qÓ?ŒVîrÿ£º]C:ú®ÈÂ&¤–y͸R³õúbŠ, é·æØÎa†¬aûF˜N«¤¶1ÿ„àÁ¥[ûL‡–¬ƒ82j“LÜv¾ÄHI|Z¬Wä 1§ÌqrË‚,üد´Åë°œæÆ0Ðè‰ ¡t—‹]h–¡rO.7¤Ë]Ví3ÒαP5š›´3’e¤]·œÜ4kðÉØßâM!¿¨ƒÁÎ|Âf×¼êuª»ý§j4fN¹€¬ 3! ±>ÚK¼g á3iŠwº0<ßéí˜-Ž‘™¬d=Å¥µ!’²©Ê"h²¢– €$ê5 ¬pô ¤¿R)UÊi Œë¼ê÷²¢A‚)kÒ ŽdŽ‚.PÚª…RNs˜N1¦.#랬œþœÿÂ+°0‰‚I5ÞÅë"J'I, ‘fÁúÌ„²¯GÈäqúíø­ÙŽîBJÍŠ%– îàfÉxl*Ú¯´£;O$¼&.Jâ—ZMX6®wðäôOSþÏò¨'h¢@&#$*6 κj Ë'À‚-·¨Î9-Z!OFá\¡b¨(#úÃù2§žI0: LqË“Åàs:þnï @¦ÓÞYÿ¥ƒ¦V?§µu ¨UZA@ZQç\Aˆæ´…âx o°Ê?N…kU¡êëmÅv¿Pê0D)+Ã'}Rº$ì ˜Î7}ái*¶kökÆ1€‚¬V3y%CCN€Uä&Ä *R%*jÝZà!’I> yÅÚX5,i_¿s‚CJÐ*x!Ô´d% àïü®ƒýŽ!,ÂÄ:ð|Ö„=Â"N: ™N„vÓ~`ÓjÁvAùvo·ð“†à†I¦Ãk¬ˆ¬ªË…”?Bn¦B_õÁ\€hÔ˜{ ‘À/æô‹!É^…®xNævèÚ±.šEà·XPââÿ¶b~Ig95dê+Ÿ,)å캸ö!$?.ì)àØ‚×jìúÑæ"I2#N…¬žŸéžCŸ¥Ãƒ_wÅ0ÂÄRç.ÙàM9’:ÊôO# ¯¡â:ô“"s\â"`!'N–è-ÚÆÖ&U1Þ&œ@Š@è¸æx³!V5­Q¼Ê2|™·Ú¦|Ñ—nM"èêˆX11üy!€8Gçá@ŒZ`ùdOvÎÌiò<À¾¯yÉ‚Ê `rè,ÿ㢠¬DŸdG2âžù™Ú…¯x t„ƒâý<"uoË­ à9 “_Àc*¦uZÅ0¢>+ÿД?ó“æ¤à¼¯棭‹«‘QhÔ¨¤è-b󡢤80´å†ù7«~@ÌWÚÆ,}U ~Ü7È0.Ú>€Ì8lªË¨enò®n{¬:eõN)6põF6, ò26 “Α%+ÒÆº‚ë9µÿá9x  ÛÆâüù9ÂTu# g¬àRcìdLÇ;ÈöÚN(~ xk·¬ˆ {µõ1‘ž©,¨ë~c‚Æ…*\%zGl2¨ŒhxóUôA|- ³á¢·ÎQ×·RPdX|Žä—F·bµ¨ä°9šêÈÉê$p©ñGÍDÅ^ô_`{ÿ^à5)í"Øë(È¿‘;Èê9)®Ô N ƒ Ç+å =ðâýžƒ® ZáÚš#S,c6Íáò$u”<¶>h«:ÀÖ ¡çÒéF$`GÔv{¦Î'áÌ›Äx^EZÓQß,å ¶|8gÆà<Ìh ÷£1L·–çì8€›½I¬â>(ä¡0`{rÑsáþLBê«IFf‚Ï$"[(N71ƒ ºƒàu=†®=ÝŸ+żÅ,BáòOôÚ†ê“>Í4Or‘ðs¡A † ·õ!bž÷-²¢5š—ɱ1Â%á#6*`_%ü —Ó|ÿÊ·`b™|C|šö@~¶b€‚|%ãN9½‹Ï9€2€àd.V3.W›hÈHýì¨$Ѽî]’d€Üm’D¥y)@’Âfæá ÷™º—Õ9"î’åz‘ƒþ¦¤•¼›\c˜œÉÍ;$Ç:?¢ç FI£mì‚Ùá9IÔm¾ËŽëRãpwÀ)„À.`ÚÝœöàœöΗ*³½…>`&ë×Ý5àÁJÊ@ÌýꬮåäÁr}{{R1}4ú 6r’ndÄK…Ðò5„Ýg¾ò àt<®ÂÓý®b<ƒãýÂ0à’-uT fa6(Úo†ÿ¬Cïqñ,|á{êšD“ÞÐ_1â,dÌ9 Ò]¼‚ ‚¢àEz1„!°§ý§rZ´6»:#Æ1˜0µyiR…£¹éêŽþÜÓõ#·‡çê(ÑSƒêûÉq¾Î£*ýI¸þI<1Ã^àCÀÆ®Ñ#6ý„šºçž!Þg`¢Ñ[hUÇ#'>un† ®ï³µ'( ²V0 ž«úéi {_ò7êÇ?IPƒ5Ö„†@lú³ï.}ͧâ£ÿ>,xðà„ H °¢„yÿ(Ò»Ho½óZx”wïß½‘-0xôâd®!rå"¨ï׊¯ÿ^­ø§JU›y¡Ïç ù°¾ÉúþuÖ÷ò¥>„P¸ A„ $¼ðÁà ² .´ýö„æ6øD5þ³‡<FŒ'›7Ü2Wô(‘õYÿ÷ë׫œ7Wè,r“¨QF Ž7ß}¢¡ë×›7âß‹ A²›ð@ý£ö<`€+® õZõX`‚!˜×A à…WB6¨×ÿ]H(uC>!Ø3˜a™%fÁEèBù|¦Ï‰×Y×™‰þC˜a¢dbBú´"Œ0¤vÁÌæpÑFo­%”…=tC! DOA$gO”ÆyôO YT¢„!‚0ôRzªÐ¤ÓLJŠTOå5ÔMí©×æ?N%ÔŸVy½ _€[¹B¡+Zªä žõVƒr)yT-ñµDNÒ3¥cäbÝŠ]²BŠùTöée,zVØ` ~jh†¥¨jPBèˆÚn»µÛoH¶vä¬å¦Z°ÝÆÐ´!rqͳáùL™EÉ“=N„IŒ/ôË?¯ÈtæQC%Ö“ÿgˆˆ÷ÏPK!…QíA„ˆ>Q ÿm¥_~ÿÔ[/A‚ò·U=Q1Ú`¢'䨄\0±ÿ\Tj|G±ÙY©–…š`GE˜‰ŸFÜ*¦‡!òêX±V@P­µÒúëo¹®†+A»äšoÿH@¬>-‚²ÙCP Qôs”Q²4íAÓföv=ñôm¹N›WÞ¹áºGRáå°óõ‚ð¨žðP d(…m©uv ¼µè\q§b×]†Pp|€åóÃdàˆ™øÒ‰ÆW"àUvت—êC‰0œ&«&dÌ»©öAÌ¿í6sËœûfH±½1òrÿÄGÏÿ ÍðFNh)m˜«'~LN{禛ìõ´Tw㢫^ºK!‚¼ððÔWbyE×GÕg6¡’=0Ào1è6Aþ·÷ úâèpm(Xu¬ÚèãËØb^›Ú!L¨b ¹¦!‘šå´Æ!ë!·)’P“+Ø ptÿøUÇ, YYÝ?\4‹0L~4ŠBe8®Ÿü$N"LŠzºcžt•+)ÂIŠB„yÈ«>õ‚ž¼r€þÃ+|òÓ‚u6´%d bB¾£$±Qÿ@†!Ñ DØã1bJ•g c¥¨qdºŒÅ“ ]ÌT‚+ ¦VðªVðofSJÿòá}¥V³ŠÙBbuÀ%µ53+Ù‰C\D#ƒôHëþ¡ƒHKh¤Nµ4sΜ\> WOê”—qµ‹cˆ€ÏyÉg‡ ‚D©" Ag bÚØ°H{Y¢÷á ”Žù€Ï 𾿑‡TGa\.Ã%y1>ƒéMB}X@3“€!$0Å 9á. O»,×À˜¹ fwdaÃÕüƒdˆ°Ü<(‚,+EéóÜ’"·&ÄQ&‰‘dy'P`'yÉ"PÚ“vÚi†á“¡÷µ«Ø+*FâX Å=¶°-m1K^âö % ôÏ’ÿv7e±‹:Laó1éÓ1E«_ñg\(5`D”Âä„tÓíŠ msƒ 8¬q è’:@Ë)G#18ˆŒ³°Dj h óhÔ!Ätfxäú'A ’Ljr¬ ìLSþQ‚„r‡mhBîs¹PZÐ+_©$V®¥mh[‹aò6R¨wÉc˜­j3äÏß<…úñ¥N°‡‰¦Å¡Õˆq™¦0N£šå5 Ý´N>,—Ç øê5ë”ÕlÔÀ¥¦s®1IJ,X‘¬d‰¤gBœ -‰é(‰$V.–KN•L¡>ÚUÀ¹fóˆk^ ×ÿ†ÊU+zúa^ÒfX1-my‹¡þÊ6!vOI¶üÇÝþâ| ¹©2\?Ë3™ÀyŒŒÐüª>§# yHFA%€qÚÝvDÛô0#›ÕÌÖ èäiûX¹£¤¦ûýÙ N0ÜâjʼnDî?\ÌÜŒEáRÎõ Pž6Ý…FI ?Öyƒ¼6ó`(wÞ=å%@<Ðnþ• ­7/E<Ô‚6ð,xÈ"°,eYF4Yá*dÚ´F.z_d4F* ÁÍF+†pFÌã>kÃj›jêê ´n÷H²ê*ÖÔ‡å|Z‘Cfda$Ï–«à ÿæÔ±˜ƒò‹¤%x3iÏZI¥ìþ!!à Ž€d€É«¼GìEaåW&€@õ€/–”= Å嬴À¶¸fašõ(ýõ”`,³Ù¼LÌ¥æ¡30~pÀw² Ò*Zl\3Ö¸lÃ᜙¬€ì+Ïõ67ñÑÒž{ÕD&dCÇy1œæ„ "Ôÿü'D¤‹Ð¤fî ñ‘! `Ý`@ÉÔ;­ëÑשåPíÍh°LÄ_;ˆ`âS’!†@ H)²d¼Ž’&šö™±‹Qð,kòˆ­ І†Ð ·€Û”NV5?\Ô„dçÔU¢Ÿú˜9z¿¨«G‚û3KG ´ÿN3àPEÌa³’hM?²j M Õ,HˆŽ ðb íxŠ ˜l ƒ¤ÍPƒ…eë¾½‹±¢ š\2@ ä·Äc2•É)Ô™ÀUL0…K°ÃGòÝhšÍ wé©Õ æìÛ ¶íQ5¼›Ù9!âôŒ!jEäŠÐS#(Ú†^ÿR/Fö²ûht‡2žãSYRšÒ”&@ 0âòxÁ€öµ+߆ûÛ? üBYYAu?¢'në¼ì:ËJ*ØAt¼€Â('Á5¦áü{g‡ ÚW$\Æ0§WP^)éˆ!5Ð †óâTêÌÒ][æd>zÔA'úañÿN òzöPu1ÂO£ò0Z'í!b hiõö$¶1ŇphkË·v eÕãJÜc ÷Õ'D-ˆeÑ^G´qLTuqµ K‚×$%–>å—~…±EæW8‘Ñxɤ!mæ7"5 |FORè3ô`&tbD2½r$0@ëäT¥§tRõ¯³0y¡Mœ¶*$W‘Ô.ëÁ&e è9«cŒ`ïôjŇG€%x^ñ/…ø|gQhak¿6qµ}¸¦DÁæ(ÞwQðÇ!P×"1ð‡L’ÁR –"_ò)ûe2- FÂÐ 5!pb|æ3”†‡¼UÿzHWz1ãT†pH†Ø?aM×È¢´:?SB–xÄô7ÄDAak5nE`WHM×€ÿð‡ˆQ‚úA(MFo·/g!w­ƒXÖˆ4xQf­7nóß“â} €M$ç1‹*GxrC˜fñÁ3-ç%-F5' 7…ùwA”öS0ÓGVzå¶$¿x@¹$]¨† €™˜MSF˜UPäar‡—WHz†Œ%pp 'Ž ‚ZoçvfcQÓçEe€E ÛWµTƒM™ƒs0xá(G p/tsx¹ dŠÇ(‘uÿ1 M2EžU;ù@ M(9|–%„@ß–….cn y¨UÁ?¼¸$ÿ‡<$‰ ˜´}#þ¥x@a=v]•6¼gAŒ0Pb'F&p™ ñöB ЇŽo× µQñ¥QGÑQK K­w1”•x1@­p€,÷öŒŒ*Ïl˜3c3–3b²\.–— ?B°{¦%(†bUøµ"t|d—×øa¼3yy×´$Ö„<Žv]ñ3¿ {6UPHñ iÓ.å¡€†±_O%€py±™Q‚S‘CA@6Η|‡šj!ƒFÙŽfa(¥‰šó…X¯‰ÿŽb†R•ˆPA²*ƒL¼É›Ÿˆ9¥8 ÙYá"p >ð 0˜-ÀgÆàn±yÁHh"N®Ñ±™Å 7úlðº ñGÕˆ<ú•†«Ã3õ“"îIÄÕxQ™È7zW%€“ᨓñWêõ1£qÿR^c£'dCQÒçp1x¦SÐS61x^èI„ÿpƒwÁ çQô©3#žR½ÉlÀ5cE³HUâböà’Ö±-` [‚‘9n¤G•*¨ ±ýóDÃûeQ{˜ãEJ X®¡çƒ:ÝH8™“°“ÞXÿŸ‚è06f:Ñdþ"qЗ=W°kÙ—(ë¥k úšOÙ—PHY ¨0¡˜Jjz*ÒñRûõza;NHú‡\I…(j%!`Ms©… b™šUࢧHáY I&¼*Ád‡%YA‘zWý:‚›ˆÿ «õ¹Cqõ<„ˆ'zµB¹Ÿþ"”ê lJ"§80ßã} °ûU¤†ã’‘$Gm•=•¼W"Ò/vmàM€Hm%ÆÀ²Kp1+à¢}9+bŸŠÁU˜ñÁia*—²,\Ù9Hë¤ÛØjóp“ÿÀˆ «ö™h7JÊ7^h±«S±ÿ‚DÑ×/fʳG kãpaKRi§GA›/D´€ªu.¹l½y´ s;f)&ôÀmŽê* ¸ÿ ¢MÐò % Ð 9›®!eÛ äàÈ3\Á¥A¯W#ˆ£!íùx·:“Ê\°*SK€ºðkŸ^qvàuJþAk €‚= 0reFô rQ7皀W•Û\cuPÓ¨Ù“>ì§­@À·XbUZÒ(f¸(Ú°BPM;‹»Jbå N@kÊÁ3œíy>ûu;!0vNŸÄ¥ë‹ºÛ ¯»| ëCã%Ò¿ßË(³„kIÙ›óÿq+P›è3Y–uc_g·\Y*«£!ESžÅ­ø§¢šHúK …ó iÙe 3È(À›‰‹@»‡8VAc’Ù2t/`™ÈGµö«ºøKÉ—¢Ôd¢I/y•®@6¶ëpd‹»ìŸLyKT †ò+`Ù$×.•õ¬uË(F;8¥B'Ћòö¨ØË²[â3‰k×dÂ)Ì(Ç,vrqµœóVˆ8s3|õ7Aqó[vò@¿k¿Uû‘\ŸG`|ѳpгõQû‘/fC^  v¬/±ôQuÚ¸H±J)]¼˜+%ÿjê h£È†-g4|ƒ²øw³¨+6³ÈBBt,bÞ›Â00E2Ø3{uz–¿ïÔ€®Ã'-ÐB|¦{º?É“,É”Œv% Cf'WGfùÄB(£ Å|¶¼†šT¬$®a•!¡Ïš–•4v«¡÷ÖfÂyÈEZ•‘Z‘'htsGeʽ¹ÌcWŠ|A'p)À2à2 ÿ Ì\ŠÌÈ%ÝÈ÷@µß,Õ@,M›–LJZZõWðg€²€«ùr£¼  òœ¬`¶0è £Êió ìK´± Q}xIJ­âW Vx^´\”¶ÿ·[Õ:OG!ÂÐ ÆÑ‚ºÌ Öò!yð00ް&™¥[º€ÒTëŸ0ŸP G†p:™C;4ÙÓ J ¨PLÀ³Ù70{€kIÔ»uºKúÌ_£R'Ü Um´0†cVJB£Œô:9cÄ<æzÖój ÛêJ(=¶×Á™Z ldà…¸ ­-¨X6Ùt77@ö€:¡5¡ý„(²˜Ê+#-%Z™å"4~®7¤Ò$‹‹tÄÍ(¬0$ÐGRÀ³O «!qŽÂ[*ÞñÝ WÀõ%wgÕe!´“ÕÏ^ü±ŠIÒ¦8Ër˜ÇDÿm&²3/–†Q×jÒ49y$ÀÝÀ³À0£«ÀÞŽ,ÀÐ5ò â´äqJ>¥’°\YÞäM%´lþÅ•$²8Ý ÖŠ?…3“:Ìs|TN±::á»ñ ÷@§û¤ðÞêâ…Bܶd{Òñ“e¼i¥uÎ5˦ ˆ!FÁ8?{":C–¬S%Êñ7€ @t¹êJ@‚ à  äK¾)¼Kîç³(¶$$bâWËrô³ìM –€£,#Á\)V/^2Žá0€q‘ `W âÆ A~~<ç¦|¥Žêv¼‘HÅa8ÿ¯9ƒ?’$GÃ3<'§8½áL:d'ÁSÉH®7PÌ<ÖËÌ(lN ¹_pÖCêÑâ¥çXE´*5é‚Po²x öL—b\y?à^2Ò‘¯,†ÐÊÇ.|š*¨7óÅÐÚò.íõÅ÷ýô˜Èm_ÅAÚ„èPãÅ)$m¿¥,2²¨™F«O9³¹%³:Èò@à´’I/¥½IŒêöîñÿ½ŒMƒkQ®HâS¤,Zdc`,­˜Ã{™ë¹9C8FKc…a9óxãhW%Ð]/¨óÐñ Oô™*òön”iG2¾Å¸A3ðeö_§BF‘ì 6cœVÿ&Ò›Ûô$Sµ‡TІÁÞlt ôEÏöm0xP¬Iõ`ö@HH¨S'Œ¾ëü³`'ññB›37®\µGáó‹Ÿ©2 ìâMÇÓ¦ì>îöŽIÉ6†‚‘ Qv÷ÏY8‡'Æ—ñ›l(F# {]ió%"$ïz±¸Ç¯Ãh¯®¶/Þ ºÌÑ Äß{Á}ùG!¬‚Õ µB\ ®`*RÕ¦êÙ3ÖH ɾ\róbäLè0ÈR-€“‰Œ“%ÐzqåAâ>L¥>üé?0g0š q3™øNR¾ßB8ÕÒ6cÙtõèÛF˜ñúâŸÀyÿ Ð+Xÿ°Ä‰,þpØðßÄ-^ĘQãFŽÿaø÷€†G’A–D™RåJ–ë éøÁ#zæÑø!ʇ|ùþéÓ·1ÏE-†( Pà‡‹ö^ÄÉ裧8'Ê;!obD,´:”‡¢åX•EÛÒAµ´mWn!9Ñ„&Ø›ws`§Lõ1Í4èE}=£Ø³êÔ)N£« qÂÄ‚ò¶pöˆW®ÿä¥`IÇ­G >¶ˆ!H1Ôs´†Í1G©S'|øÀè¦^£='þzÑç¿|NùÒ£w<¹Ò!ô¼8á y^XìZ]«ç§c§ÍÛˆßÍŸG ÑäÿÛÿ¤ÿCþÏiÝ=[>QàbøGû;Öo碈¡*ÚJž#´R;íЃ0Âï˜Ð£.h³H®ÛrË 'Æì©ï'³ˆ©‰œ@̪,JŽ@÷¢g²‹N@"‡¨«n+°b°Bdi U‚`‚"‹¼…½ö\ü0„v".¿(ê’¯âãhž¬Ê˽‡¤{A¢²³î«»â‘.†d³MŒdq3%ºæ¼Eª* éäè1D}Ëe"¦â“OŒZè¯ DµÌ‹Ñé ʪ¢ê"Z¬ˆzœ´8Ñ‚+6Y`ØÔM š€®;á“NƒøŠôƒ\z⩸ HÅÝUÿƒ,ºõÀ†hd¡¢`#šhÁ­$âŒA6$²µ}þa-T”(D •M‹ü§Ô *ÈMO='Ra {&òÉÉö³JÅ‹ZÐÑÜ-è±z¨0 V«´ª´!¯äa³ - "¶2µ+ 6¶NB-%& !Û;;AUUõ·(Y›õ¡ÿ¬b§[oÍJž¦3ììµAì*3î¾2ö<,‚¨µ‘&굂¿ÃBZ9³HnÝØ¦øŒÃi\øTôÖäE”!€]>63{#BÁë,ªt³‹Æ> ÁKF;Ø¢ŸzSF&†àC¡ç„æÑ`jC Uê)ÿ‘b÷ªÄ¯#›*A›5BÓ†rþç‰Ödx!Ì# €¶8ˈðþ “n¶8C%êis‚[þ™ØÈ öÁ@¿kº‰1 b|"D›Ðj –·»g;Èç!6؇ˆm°k‰2šÜ-K Â#0I5WÈc,K.ô`rËha º$\q¥­NI€•è¤}=Dn€]rš^¼„½$Î3,ûÇ=î‘{`@_ó(B`6,_%¨XhÂÈv²À\çmc9C ^ =î„v0 (†K\$ËÀYþÁôµä ÂþQ”ìƒ-(Á‚K"$صI*›˜A ÿ±}@€]O¼ZÉ<ä"Té.k,k`Mx .u¦F*Vuƶí`p"Dã=ØÀ ä (A¶‡óMä,®^À½ðyD v÷bž³„g6ïÂJÒ‰Öí#Þ (&Ò,Ñ"õ0ÀV2›ˆyD‘ÊV‘æÂ D`¹[‚Ö È®Fåªo^ÊÊßžˆÀ‹x¥KTÈóÀˆ´e'ŒžÉ ¿îq„a.˜× ÷Ê@Kãmø\+âÒ™O†GàÁ^°½œ.b€K5hð‰!~ÙÃ@2Ð0^Ä~ÿ Ï æ€³¬OH/(Xê,bÉï”'‡øGÁøé€ÿððâû0B­Ìà štËdna»ÉH`uÑ’<–`¼‰ .Š^zHÖÀ˜Ë¬Œ"¡‘{"w ÿaç*eë`šÒÄc SÅ,æf> ìñ$óè^ȽL䮀€PÃCÇÆ0$/°_|ªN#4̨œˆR‡ÐË„R"!t}Âó"üÔ@ë?žnE ],Ò3 É¢­Á,'B¼­`ædîiT£ús+èt4l]jH§·³m†×ÉLf®£ ^ǘœ‡$È::À§%üH7O÷‘Šm³¨1Ä@çBû‘lB€{,¤Eθuh;Iyx8¶µ•ÿ­ý<ë>)V‚NÄkH=”û¶fU¹õ\1"×#Ñ¥” ø€t°Â×w½«"y eæ1*ËH†KÀŒ .¹H¬cͬƒÐ»ÙUäKÌs˜ò€@ôHG‹5#qS§j&€Ît ${œHxŽJ—@¦óU…¡j˜U²Y¤¬ñg˜~{ž‚êP¬«êÖã¾îuÉ5kt;"#Ì(e$€,Á3±ïxK4©DFEÎqŽe&2 ‚ YˆG¬c©^&²&°Àêà¶v< ‚‹ì#HÔ)Û¦~ª3„íÁ¬ÚVŒtÕ³¸í*† !&t˜ ÿwÖ¡o‹{ÐcÄÐõsJ^×܋ȅTr-e+ô1¿eí(AÚE>0½¸ 2 €@Ad¯Fk³`º×"SþŽ êM¶[4áYªYT ¼Ø§!á/ Õy–ÔNDår Ûù’Œ M#v.nFŠæRÌÄÎþ‡­C·ú"'Ž6µßÚ猸Uº¡K’ŒT,@ÆžD„7!˜Sd˜ãø¼Ø"óx<£Xõjd;uˆcùµÊÚ÷:– ~%P`·S#Æðk÷8Ú‰tÏÀGSy&ÞΤvïD]˜‚ U£Ž°¿ùŒv²Ñ3g;§üÙ@ÿ¨Y‘ ]>[ÒÚÿÀ¤K’{\B#M®¹ÅöäA&NFÐÎAä}x/½Ý£Š x…|ðÈc¥`„ÈEÊX¶€o$z©æ ¾P¦pÏáwx‚-„t5¶q«xjÔÔ:€\vä%yà€§®<v€@Q·‚B6ç!ŠVLÂnñ戵‰ýÖ÷ÛUrD´³êqaW$ v7}ò¶ÈÓÇ™©¸€¦bUj ^.²ÜѺ±ý·4c„¿©áµQ_›kŠïú#׳ÙMx’"[윴£ÝÛh^¸xÞá†U‚ •÷—åÂÍ@ ýg9ÇŹ¹ãÿ‹¸\¶^[;Ú}DàóáS¤Bú´›é§:§Ã<÷п†x=ò´”ª «x,1£P‹©‹à ²QµÈ£tbªŠ³£åÈ -ÃBJ­ *Ó飰 Kî1ª‰¶µù0Ý +³P…n´Ž˜¶›Ã6ç4óû;ã¢0nSA!´ˆ p¿˜z}{n2û;—¨xŠu3‘Ó;—ŽÀ¨{1yÐ<02”:—²‰ £±I–#°±À€Ì*³ø½‹ #*¢z¨Jˆ“!® “ƒÉªz°1[*î‚!hôñ'8L9’ƒÁê“6•3¼®âª-¸!˜ÿkÁêë/Œ8¨Mä§<¿L¼¶jÓ6œK.èj¼ãJ½@Â#€}€ XD8F˜ªXliº+L½!k·Ô[=÷8ÈÔZ©­¦Í0Cöb¯aBÄb™ {Ãåë8Œ¡¶S;¸ãªëx?¬ªgi§’!N¹€â¦‰ˆ*²"«€Ò­ì1ŽH¼€Ò!”sÁÇCû-ís®à‚'Ê-}”¼·zÆ»†Ó<#È>œ0‚y@Y” Åп§h  x7@y+’6dEN[)†@²ZzbaÀ™ƒË‡ ˜:4‰jä².ã5Š-º‹ÄPH«Êgy°-ÿ£! ȻʞÁ»Wȧu4¨âJ<´âªÕšˆÛÚ'´utÁ¦ìÇŽø³M´¶x„§ž+ ‚ü@:²ª†y}`Å#€¿p7;B‹4»%\ìEº2.ìCN{r0䑌¨½³IIcÒ·ÐÊ#°µªŠ«FYs* ì HÌ5®2‹ª2ËpÅŸDK3¡„®0ùÀ(˜˜Ç˜Ç;ƒ¼ÔLÍ-rA 1„úA= ¨Ù óÃDŒÀ¤M±p¼K(ØRÈèÃ&ì&üšE¾`ŽVÉ ŒÈ›8½Œ„ — F.ja@¬¥ËqFb‚¦ÂÌ€–d¸%t8Ö$³-*uÿ‚CØòËhÏŸtåj…Vˆ»‚P$0Ë¡¨DÕx­Š£¡sú° û08Û"«¤ÇzÔ!š ±.]ÐM«o±¨ä6¿œóD;âI´ôI´ÌÈ7˜ÀÁ 9¦w³Q\„ #È€ù{JŒ É Ò K¹”¡³ÿÙÓÐÒ7/DÝ@“­‹P3Ò9ËЭ= Î5NÌÌ€z° RÈ;‹ HªŠ£9ÔaJxÄÄ8«µÉu„§ÍÇdó,«t$© 4œ³6B!Ënû/ˆ€°ˆ À‡Q \øk•´ Ôm  ܨ Ä·{@Èà­±ƒœÌ ŒXcá—„Ê ²:êÔBÄz>´*=ô,ÐñÃ}Èן4* ÀH*í&3Ã-£ú¤¡$Ë*>»°¡Ä3B¿«Ð¬L±ÚÓø‰9BS¿ÿªSS]€†Á‡Ò˜ˆM»ê0¡p7}Ú¥KË º;AÔÿaµ™µˆ”Ô )¦—›Íè©8ìÔÔøˆvÊ5¼Ã5ø ÍNÀ€!¨… Dç#3|ºˆ ³Œ0Ó6.£zAÄ'ÓÔ0ØÓÛÌÄ#°³NìÍ =ÙÈË´:V‚ôFŒG€µ€tÂÖ0„ZÜûwéˆ|KµHô¬ëØKë«°ƒë œrÆJEY£8zíÔ.cÁ´{0#ÀWH$ò€WŽxV°€Aü‡šðø°§ (óüˆ³EÓ´°29޽¶šC ‚¼¶ŽmÓyÜM’€+Ÿü‡øhuÞhYÀlÅ€šÀø€“p \ÈØÔ†MÓ7îÔ™ ®ÿ€¬˜B¸([µ*Lúʈx 8<‹×Z¨lLOU0˜p…¶ã»‹XÒ‹€R ˜¡N"ÛŠ#¶ÂÝw4Ï¢tA}3©äD ËDÛ à‘eÖu¼5u$€º¹}¬6‚ÔˆVhpÌ| € (\É¥ÃÉ}Ò À…{_|H5œÜ#¡Ú¦È=FÛ&yPµòN#vÆÂ, jÑ}Ã-õ(Þß$  !¢T-µs „ܼ­m]·*$Ù}5à‚aA‡­¸8[PŽ Â´¶‚‰9ÖÇg Bñ3ÖjsS B²ÇbݶUljðIç5¦^xŠÊ"îÀ=½^a/‹ÿ À#_Èõ¬mlˆê8 j×úR5VåÆÎháŽ+’+Rß“â¨}0¸ ‚A¼-«Ê²VðÚΌݸ)™”àK;5æÕëC+‚úÞ{Ô]Gr܈[?s<«Ê n3ìÛÍgŽ6Ë܇`ÞhhÅöÉxav €äÂ!ø €=­È¸åÉ&ÏhWuF S6× ˜€!pUnÖ-Û"j²M$¤¡`_«ŠR *}»ŒJ´cLj²èvBM3%®¡\f ËØÜzJR9 ½$ã•ÁÔd9é¿lÃæ²\õ NCN‰(+­À›Vgk*¶Áémr€;®ÐZrß%6‹= ^» Y¾²v’_(Òn‚;0]æ"0‡ Óáµ!ðæ òP3DDJ›´Ý§uÛcî09Ë!Ԝ͋Յ+–³¯ÜS<6È¢ È9ôK(ã !ù ÿ,éÿÿ H° Áƒ*\ÈР¾ ˆü³ðïÆÿøADôOâ­"€¤@…V }˜0oÞ?Fó1øáÆD&7¹“ч™ˆ>nˆ ¡Â@D­6àû¡…­ü¨H’ä ÿ(zšÕц m°ác…| Óª]˶­Û·pÛ}‘R!8 ¬À/è‚­˜ R "•\þcñ¯¥Ë3-ú‚kKŸ2·.ˆ@áƒD(lŽ@±bà§SAvJaj`ª†$ü«Ú¾ 7(ðûPÁ^¸Àƒ N¼a>~ÿÐ"ˆ<ß !¡QâˆñŸ_‘¤OaÖ—ÿøWBÞ —ìY¿1ß™~òÆ zBC&% ÄZ±âüðC+©‰ôÏø[€ERdU´[qVhá… !W?Ç)§a”à… 4 |Ä~`7Ñ?B g"H°Ò< Ð ,Ì£žOhÍÑM=ýc_PT0AŸ™ÄÞ@2neHVRm0•mY}dÛ !dX­%øÏñeÏWö ÷Á@¿a¨æšlÄá@"ÇÏC}ݰ.”U¦?âI‘0£´øÏ(5EŒg DOc.ùDOKÅÄ[c%´Äˆ7”eäÿH€Xú<éYP`…öŸS‘$€®V¥i(!ÿxSÄ0æozÿèÚæ¯ÀR˜¦@¿!÷arú Â@‹!ö磸\ƒÂà" AÐ1µú|ÀÑö0òè?ô¨×Ò òDêÓ<9¾4AD7 úoÉ([|rÖ­à“`j¯X–ª¹”]‘ÙS¦zøfÔWjÅìÄg'?o„ÜJq\¢uEË"eÍ@Sí?×BGS /ëØ˜<òÜ# ážPÂLóØÇ­/ùT§<ˆgˆÏ(^f¥UkÿÝð$O­öà b&œ¾}P€×nàAÅd«ÙcAÊ ”lGP’)È[A{ 4¶Aƒr ÕrgŒBÞÿh£Ñúéþ#OŽ3… #ñ Óx4Æ'Óg~íP'¸ôƒ&EHrÁ h›ÔäÓÛr_Ë–#èUöìo'í·#çAsÉåŽÈ7¬ÐÑ Þ>ÐH{—µÙ Á]++Bx72vã KÌÃ?èþsÄ=4Ÿ0ÓJ?5Ênº9ÆdO£„%Öm¯‘f>µ :ІP-м?`vyXï⺄ˆ v#8 ØhÇÀ¸,g ´XFzô;ŽpD4+¸àð‹QÏ6LI:Å’›n 6âžKh&{!{ŠÑY÷þq NÚ AKrÔ>ÐD`ZÞÉ ÿ,@(/ø Àòwû‚@„YJGnÀ!¯1ÌŠ cH1‚‘òCb #Ú"8ÁÛ!Ävh¡ ðôb‘¬8ÍÜ!Iv@²-DèC63r ŽX°„ÅØèo,¸‡ ix8Éãßà bF¬ò(o>s'÷hEˆÓj 9EtÿhÕD2Äi}ŽVùWÃv•œ$9à?v'ÆZ6$‚üÁîp·œdaDvȰ"¬ÆP AÒ™X®Þˆ{Ö£á?0HHÖl‘ȰÈi~{2é |Rçàb$1‰$ dàâ_X¡@CYNµ"$Hqÿ&{$ªW¹šÍ†²¤lÑ–´ãÏVƃŒ Ô?¸xYî§?#\Ái¢ë¬!8ƒ.HâÈ™¼5UúM• $ø7ÿ‘n‚¯]5[ #îc' dí0û9ÉF dÔ"A«‘§}¨vƒ«\$ ¼É™ÀÅ1)Œ9ª;ˆ^D ®"tv²S¨ÅÎA´oN}yà *ú‘ÏÕk?NiÅ uÇ‘†àL:œ‡! Ç—XS¥.\$¾G˜Â´°ÙÜf7°˜óÝŒ^7ðil:Õ©­´Â6£ÀÅ;„*,ÉF+¢|ç,¦¬ñÆ7WÍÕY$ˆÝý#`üêÄÈ(ÖŒÿõîÈr~÷H¤D¤Ê <¥Q¦Ü³$hŠJ 0/Og…7ärÚÍiұ݌©v§©ÍE Òé:BL*PN‰|t™í#ŒQÔ¥Œ‚,XùO+ôD§ü 4Ó*RÒ1õêLÈm ¢ÀYVG¶ÁzˆnÕÆ´ä8" ¢u j"H„x)‰B9²Š)’ ’•–”Tº× ¤Í¢Íl3¦/Í®@0pSHzïpäÄ"&ÀÜ0×'¢I.‚Þ›Š£©ê¾øËJj&â/}"Â(¼êÄò!» X[}-‚+ô!Œõ%#èòAÜ£Œ=ÐX¿Ì,­#L¦PÂÿ;²AŠ(Ò”|hdÑGxÚG«ð”ÀFz #lLj$¦…>6s Sks¦63OJo&)N%¦].¯A2%,155OŠl9ÉÁ¸Ê(@ªBÞ¢d„ÁD¿¸e ec9ÖlÄ A³Ö:s²WJ6Û"6iZd¨ÚE-¡£ÅÎp.%ˆMÍBoû¥±MÑG3T;&”:_¥æQ–3@Z–®BµK’ŽP¦þA-€q `$±7½Qu™rý)øI û¢Âã¡ðZË…9Ñ5_ļZ3ò®¬hþµ•ñ<–Ž„$¹¦nÑ1åÌçú¸Q0ÿ±&£ÐåmëÊT ƒ=ä‹ ²èq›}çy 4!y¬{qŸÉ$ªð DtˆMÒˆ |›š½×ÀÅh•j€Ÿ "Y1‰’Žòxpµá]_¸ÃÛ¡07X·ËiΙÍx±c¡…#_GD„·“-À û²ÌÎÞ}:ò° ‡©cWžíêÂ|4›ùKK n ç¾ÑxlÜ.˜Ð¤&K›–&“8O 4HCÅ…©9gj`˜úÉÿÓn"þ$½ð‚ÕaøØÆ®Ù>N¸×ZÂfDÐ(iÔ¸®…-<½oy΃oIöŽ÷äÒÙóxÁá 9ÁͰ1†Û¦Ë B³ò¼˜Ñ!€ÿ oZ8íÝìòùä„ÄôZþæ`'Ð Ï\ EK{ï@p ¢â¢EA`v%±$!Qñ kÃG{p’ob{¤=‚;icfˆ <AlL¡Y,bt+0úpY‚Ñ"¥!W }‹ñç…#z%ØT]qæ62¨}ÓTX4ÈW'äG4NëÓn™ó2>1:Ñâo¨"F(–u_K‘ ‚Du ‡2/d”ñz½A †bGkd˜pfH!¡`ƒ{h{roÈo¸†É±Zx[“&ˆ‡ˆ°V~X1"(ƒlC`Î'×âar'`CèÿÃ!`cC4T]ݶb8äWÚGƒñ7…„3„ì6“B9üÀoIt/͵«r_*ì5 ñB^Ìa¿tA²£ ×`f¸pbG,`·&¸–r’ EËa;`fÇñÀ7{¡pØ;h‘,rÇ„g 6"ÀÀC¯p4d=Ò5“.‚ÆBÅ=*uxåæsð(8x0SáBôXƒŽ·SŒàB9w)Až1¡ÑŠq›Ò)ü?´9ò©À^È€?_¡kXe‘€`dŒbù0Œ_4PÃp, •6 ØZq‚Œ¹Ãºÿ‚kSVvãk41`al"-Ѐ Ð ¹Rar%𸙈más%àRÜt9W}‹²B…æ=IÔ^†sébƒ”36Ó3óROÒz±ÑBð9C4K1ì5Yè#1%á…8Œ ’*9P.vÄav!g—"rÈ;S5@sÈÁ³Qfe„ó#nc|ø 7Ðâ'‡2=s¤OÈv(ÓÃ=™H3h ƒýØM ûè8ÜC8Š>] IÞÅXq›0èHЄŠgò)±!%rID‡†À)aPb?IûæoZ1_ÿA*nR™É[ ‘pFŠ9Vñ †Žétbg3éŒæIV½"‡eô€Úø&Êñ&Å¢±Ãƒ5…I ¢'έPˆ'Q˜Ùa Ý•.1Ré#ƒ‚D3+”mænØÇB‚d8•"..¨h-T–Œ!>àby/!ØXEóC0_b7``aQq5bLIÈ0(° ZU{"Œiw’Æxž.†±!%ùÃØžl!@mȼ<¹P|F½¦Ÿ¿Æ1>•lšÅpÔŽ ÐÃ-ü¢w‚Áu'`Hâ÷ŽXm9HH-8˜SÖuë&8´i3Œ…–ç&.kÙ(þÿŠá‰rKQÐÒ«Ø>P1D¨R0Ûé^À0 žEu_f˜‡i,g’_”’“(ÉZªÊ:ȘjA[Ádžl˜; Ée‚F··PôeÆ6Á @ LqŠ Æ–¦NÑš!˜D9`g0=zen!Z‰’æRˆwÖ—x‚ECçh‹1HÝŠn!âÒ(!8×úgŒ@Z$±ïtF2$aþ²žc:qD¦Ö s 1³FÌaGØ ¡˜Â`Ô#²Ô`[h¸SFhá5b•&Óxq ¥PrwaÄC‘…'ÎÇl ‚ú@ͲOÃLÑS­2ƒÖÿä](*M'”>7–C8‚}è’¡7(‹Ò]é§Š„:ã¡b1¤bNW·!…?ðPa%ÓR D…DZ€\Gž‡Éªç&‰p®s™aˆ²:±l¦™ Ñ!g'‡«†(“Ïh1k³³'Ë+0²BHy(ö‚‰1ÌUnxº›â>?KÓ•m1e¹éR§7DiŠBŒqnzh’h=íVÀ1ˆpEâa›!X2²Dµ EwI¢emE™uûž`:¼«žpžçÙpPj£_ºÀš&¹ÇvXõ…cµ[Äc ŇÐb†X‹*ÿƒ¬¹ŽÐ-w•(ìV§)Å9•¡5ø‚*Är/Vhàiìk¹ç±=ó u ¿ÜÃWK›.i‰¨Þ¨gi÷oójŸC S±oÏp £ðX2é« !¼LZ†n+'/©Á)Ik½±/©[…UþÉŒ¶Ê:Ö[™± e[¸<lûÁ:A†`lat:atÒÆc:ÄBá…x46‰5ˆœ'd§06M!j¹!>zõ¿…i8')ŽÃn‡ô=4ÃØY”óñÁS³Ozy_ ªRUÇ»Ë;¥!vñàJ·s¶©ªÁgˆÖØŒ[H[Oz{©†1T“ ÿø@ª¦6alAÔ¦Ð"€$@Ì7ñ$QÑ#”cy6ÆX6DcéR¹‡´b:ËWòn‹dCxú³åw3/h3»™‰À´‚—Hkn=‡$Ñ“ãI2¬ ìF“»ÀP»ré» 9’¨g£¤§ªÇÁ˜±z±Í¸{¶j,鱩[Å2ÔÜ`9i;8gdÁUmZ(zöЕ-ëüÄ>ŠqÊ.d35TC4”Äú,ƒxj¹å±}4(HIì¿€ÚB†s:ò‚—öäÂn-Š@= ǹa.Áå4GÈ(p2)Ñz&q»qDË0(7 %¿¤5øñeÿàä¤ {Íèi›’«Ÿ¼’å‰ÓÌØ`|‹·<½Zh+nx1jWÙÖQl*BG¤AÕ RÔm ™¡hc‚”m¨LsaC…ÖÊ7e8ŠÖ4E‘­“ø7€“s󲢊cyïòdÌÄ\”ó BË\5⩦ªaT²cÒvÆÇk‘ÇKÿ:’‡Á½ã’´ÖÁãÜ{:yÓšé†Q¸ò0ù0P ¦$QŸA”­`¬ÎóI½aÔƒ´òðöE<µ}ቡÏÜzciIžÈM›KË©L6²(!°>'%h1º‹8ÞÛ¢¼ºTALµȰ ýæ‘ËLØ,c1‹]·#©ªÇ¢PËÒ±¥’ê©pzl,›±qÈÈŒ©¶ÙuȪƫôù™+GµlÂ0gV¶¨9gc¨Hý=-¥ˆ~Ç9¹-tÏÀÚU–&ŠÏiËÿ zT~¡û¨Š#8Óãü„â²A¡rXÁ%ƒq ¸ø}Ì^ÿá#&;¢•’Ç!Q*Â;¥¿FÏ Ó+1Å»jhÔ[Ÿˆ|™,©Ÿï=Ómw°/²Â0-q$„)zs+FXŠÖƒO,X5%á Xd§¥üPüàéâÊ¿½àWYH ½8!m i)qË“äøè[ñz©qDÍð×° Wk@…uöçk/ÕÎ\!{ Ïð? Xa}î|!;Sz±¡ªRo,êÉ㩊&M:aÈ’¢iÁ¹æ¼þ臇9Ýîx[Ù{¨É¢ED+‡Ñ-×z3K b4ˆÕaN î]ÆNM^–l¢5¢Þå¿x€W÷ñx‚ãOÔÖá.@eÿÿWÈ8F§ÆØAKÑâÿÈðÆÖ8žaÆpG1¡éØu‚Ø=î¶zè:vôýã÷Ï "‚ú d¸Ð`>†ÿÙ#X ‚Äù ,Q"¿‹„,h%Dˆ…ÿPÐ'áCˆyÿN°XòŽ{<îäiðž~¦n¾¹#¿?¼x»¢s~ùñ±ÁŠP®¤àR/½˜'äѼy$'äŸ}bkþhXþXÚ”èS ç‰þdÑ"¦Õy좇ž ت+°ü<ƒJðO¼ r+ŸÁ ¼&Ы/„3„0Cþ¹¡•ƒ ˜gž¹æ„BÌL°Ìym6õvB!ˆVãÇµÕ âÇOíÆÐH‹h édËŒ9è2 ¹Œ¢Ä±¢ 4ª`#‚ò¹(Ê芑 D¤ Ì•dü`ÃYÈŠø’ZªF¢†" ¬ü¢R*)80詜ìK (ÿæY0„6ü€Âè!ÿ+«Îú'™N0È+¯”‚3ïŠÐÀ3ýB„ÝüŠÔ,™–ùç™eð¹Á‹BÔ-3†„ƒ3¢W[Í´xx<­µ^s”-ÊE;¨4çb‹°ZqÕÌ + òò¸°, Ç.¥Õ³þ‚" À—þaÄ Kºç&ôîLo§üò#Ê(žŠH=9¨·)üà›“QA =4¶ß~Ëç®$ÇžDÓòJRƒÔd«?âª0&†Î¬@„*ÐK‚P ùð0\€IõŸkëÎ á²M½cíF–yD-W×|µ¹µ_ÿÁ6išY8*î¡®TÚ å,Ú[lá °ûÿ—àjKQ æ]‚ßùþ‘'°ÃJ¿ôâKû©¨ìó(«„ÿ¡g¢3õùë/ƒ$8ØÒçÑÀ I””ñl*.F0fú2û`F Ÿ ¯#ø±”å$@ÖíV_ˆÇ‚ŒÍõµjc(¤QµjCc7À˜õ¨t=;Úgƒ®•76²9ˆj›zD(óƒÙ2<¨ Ì3ÏÍ=’W§:xJûwâßôšê3,è›<à( n.dÌ胷¯oÿ&´p™d 0¼ÑÒ‚Àä.™€F–d\ã1Ë2~«‹H ˆàt®f#™Éìu=û• Œ•ÿeI$g´ÙË|¶#Õ…pv¶2áívR¼è8m!‰Î• ŽdKZ+XÁ ñ–y”@M3\QÄò“œ¸©{ éSúÔ==ÕKO81›OÔ7I ( ËG>ìf;}T /àiÔ€N °‡‘…MXxJ·T©.èŠ\Þ>ôƒbŽaà(‘-Ut:â’¯¤ôÖ!òW¼rjF—³ U$4ž©U²†ƒ+â\ÒiÀqA®t´¦}Ä„ÂZJ”!†G橉{ü4Ÿ7݇!Ús[» ¢§à’ŠbaPš=ª$ŒA„Ê …ìÆÃ€Ê`ðcK€V©®¬å*ø‹Wšy¦­ÿˆ¥™‘“à‡˜’-CËð#¬¢ FdzL$ž1¤‘¹"QS¬Ó „B‚Mi^¦÷½l3/üÝ “–ÝXkKž Nn7 a»>kƒµÚʺ {«”Š|äÚ,ç„Gænjàˆ8ÊóhwV¤wØyY9?…¯X€Rˆ‘%@†É^Ð\(4wÑVL¦é?üæDàÚÿðü’½°tÜ…Â9žc‚•´QMÓ$ÜZ1AªÉÛ¶È@†ˆý¨oGïD±Š3¸bM;׬ $«";Í2xÂS‘¢Ög|r"×:#Ár¼#zþ{›±8¹‰Ÿ3ÛÏÃ+/®Ñ3ˆ8 ºÖóˆkóÿƒðÖ‹ˆœ©ž-½A³Û㊭˜‰ªÈŠè=£bÚ"•¨ã{*‘I¾e!®éºê“’zª±¶ê*{2–$L$Ù„dˆkḌ@ª‘1Jb18zÚ‘'¡'êŠÊÓ¼!(žÈ骸§!®ô~Ô‹¿ë’âˆåHž0aÉd‚¼Ñ F€ «¢`c#“ªñy¼™Ë<ŠÀJ‚ .vâÈ™êH\mS=š‚37:•0< œÆ9£€ 4©=Ý;£ª`“ÖjÅB™€‹€V0TÁI'–)®Íã¨Ñ(‘»Óà4ÕÁëb¾ØÌ®C2²âè1+ ¯Ú¼ˆÄ’†à¤z–ÿì´¤€O—·À]ã%øº²%b£C«H߈Œ®Ðã¡Dÿ :‘D¦nI@ñ\=†¨65„Æ¢L~k /ª=«Â¨› k ƒÀÛâ³€Z†f ®Hâ‡J£™£Ä £l¥™·¢k!ÜÈ*%;M.¹G‰pš¥ù;½ °({ØÈ•ZÂX€³l…ž#‘•iE’K/†)&ú¶C½ØöÆ jŸžûbäN‘D@‘4ÉRUˆ‘„3#F×K U˜3oᶈ¸9Œ³3j­¶ÜŠº÷[ªUñOZ Ô”GÚ|>1¡è3Í*Ø|âIBÿ …’UNªˆÏ¡kÙ$hè<õÄ)Ëìº[#‘d9ß‹ˆæÜ‰¤hè C¦±}´® ®áŠˆýÎdˆ¢ƒ3†0Ò”l=«¶’ Éž›‹¾È…kÌCÅÁ˜Š³8—€ìÀ `P kÈ· ëŒâr ÎøŒÔü•…°)Ht®†{P9MJÚ(’ã¤ÄÊ.¹ˆâ°!žÏI¡2¿R~´‡ŽÈˉàÍÁ3K")Τ€˜œ ú²e›ZÊ AÁ‹)ñ¥ªöÁ@ãNc4FšÒÂìH€…3‘|3[½n)X•PÏÓ,Û7¡ú=³˜€te„ ÀRÿƒ UÇX‘Ùéª Ö¥8Ô1ßñDä` Ö0–ee¸$Ì‘ðÖÍðVo…’hÙÁ+Џˆáal-B—U–mYåØŒ‚è¡ K‰VØ+€‹©“#zèl”3£›Š$aÔdB¦=À5Æ\äTìH@7„3ó”C:d4FÇì6(­9ʼnˆ a:ŽqB| ÕfP|@‚uÚÕÔè1 ¤]kVU€ÙÃýÙ½»Y~ °Ÿ5ŸÙŸÅ•À…“šQ~¸Õs¿‚QZÈûµíšü7Š`Ú³ÈØ•ElŸ_X0dŠˆWèÚ®eÆn [“T=tÃÓÛ‰Õ+[ÿ4\£{ „äÀ·5;—ƒ ÷£Õk¸†V• ÞlP T1†ËÞÊžÕÐí—m\ u\ñ' (˜°‡õˆÔa)éP!ø ø!q³ œ`Z¼2ý Šp©z´NžhŸ×‹]ÝWU¸TLýH«ÏÓ^ˆFö`‰ØkÅš3¸Ý<ÊA™Uhhqz šE ßQ½^¶\ð\ž\—Å.'€‚óu_öõˆôeˆõ{pÌhB! „îH×yX¥ðy ÿ{Cycê •TÓ@ø…ËZèÈ%õÚ„5R¯…C¢ó¹ÉR†^›HdÿNñÆ«=½K€†”¹U ¸Œ¿]a;B~ìÀ.ŠØãÔi\{p‚‰8ÝHß68‹õmƒõdhähd{ÈY}`€gì¸wÕ2ƒ(¬?¦KŸ(É¿@o‘Ñ»×|í9,6FÏ ÏnQ.^ …C0.Ï7ŒF[öÎ f[™¼ ¸€ zèÁX9K0U¸a€ã‘×ï½cgæÞöåcècjf( (°‡6h\ ‡nþ àa èa†àá“y£'ã+î¡%ÈŠQHq†É ½Ð,‰¨W:Û ¤³}ÉÏU6“TÀŸ»Þä¶LÁ, IWL¹šp±dÔ‡\ÐÑÿ7†\X|_(hægîhž›=öfp^_’~d‘öf”îæo6ˆhiƒçGö?n+ò‚Èœ89‰Q‰_.âÁé¶)&åØ `IíçU¦ÀI•TcÛl+hõ([rŸk´q‹² ¸šÎ â\È'ø…^€h(–U$Ìfƒ aÈa~k™6é™~iƒé™Niöæø˜þ›º†é—­Ñòëžg (Cš2/¤0¢{èd‘޸ɼ©iSŒvb2K°Tþ‡f'‚!ÖŒîé=Ö€FŽnžPnPnž€”½¾ë·¶ppï¹0SrñÀÀØ¢`æœã )˜ú>ž¨ƒÞ`Ûº–›1CŸøjáh'R=óTí0Odlm‘-;º#í¨mƒð^Èí6è!À…"XðÏÐæ=6n Wa·p¾î é¦kõЀÿ½†”¿)óçŽé—®pŽˆ`–˜?¸xSŒƒ,ç¨uԋ̃YÝž b!Çq3îHÿHü‰ZA7‰^×M0ཧïK ßK(: |´ÀH*|À“€hc¤Lï…^hDzã^Èf?vëPä/k6×a†s8As†àðëÝpž8 é`¿63Î!Hª+º>Ï yìØ˜Ñ\ê¡â×Sï()Eý †XÔô!oJÝÑME0ÕwN?‰K@0šÒCPwuÿ\í0ÆÞt†0𱾄–½áÏpäZwf§ë xºöõ]gî½ø7ß Gí6DÈRPqBÿZ… XE†€0 j¦éS|Þ C×lÈ$·œzªÐ »èörœTÒ›oL÷úVÀ \÷ã$‘(\0uñÜôK˜òÖëfkŽðPEžë¯‘“vnàëGz8¹uì‚nªï 6}ˆâL*‘ Uyªr‰b‚¶n«»‰;Ð.B€Ë±‹ŒÐ¹Ñfí•'ò”°÷ˆpJÐû¢“= ÷ÃR7uc´wU7ˆ*cŸk‚·úµNú[Qn Oî™Fúpv`?óŽÎ|?q¹¹ú|˜[ €ª¨…d–w¨j…™â«ôÞh á°ѳÆ(°=›Ã‘ê$ï DÿÒÎѲMm“˜ß(ÏtŸëêÚázxÇ…Qp¿h|¼ï'H|hàG‰iY/z¿6zí‡ú¿|tÉ|™–|¦‡ü‘vîÎé\wÔƒðﯯ…V ‘”`‰ry«²ïSГߠqn}ÿæû"DÁ l8P Ã+D¬Xᥗþ ihá’K(Uñ¢V,†ËÂ?J7¾êuic¯m~]‚V„Þ?(* D,J”è? ,UQô)Ô¨R5üê´¡ «@‹nÕ@êW©1þQ•úTiÒ²®®-KÏÞ¿!>Pˆðo¥°µZý«5°•„¹õé˧OD†ÿÿvhRDâ‡óLbà‡(só]^HXE‹ÿ^ùhر#ÈK0C’¼èïÊ–B"DXáƒÒM8{ýrÒ³W>¸X‡–u¨âªÎ«mÌ2oîОRz*à w1:r¬ec(í>°,Z´d϶íît:ÐË"Zµ¢TKH-aB,ÄÒŠÂáù>(L ÑðbñÙ@&9d tPUñÇ€”Ù„…6¯Ä´QH¨ 4ÒQ0Pø´„O!Š Â/½h¨QN¿üÓ“úTGÔrÈ9µTPm1ETvÖ Ñ[AZ”[âE´VC8™’-W\T[ýc~)YdÁ|Âø 0Ü'ÿA`ñ÷ búð×Pc‰ØÐ›ˆü…\ô¤×Y„'=ô\YH†}ÔaD”,ÀW+ üÃ0øXa¹¸ðK‹½ätIŒ=]ÂKpÇ%U”SB!õŸy*V¨~g\UFÄU®2·œC´64¥=Tí­ÀÔW^Í„9&D!`‰eCkÆ¥›„h’E‰€H‚EÏ<[…—é§Ïk-‹`E£e4㯥H¢˜Œ0&èÄ?.üS)¦A#„Ô@ö@ÀCETj©ªô£ mP¹0“ U^¬C•ÆkI׆ReQ—b¯ù:0Í4# ­ ¡¦Aöl{ÿÙ•r1…b -f`I*´ P-´€í?-È3P óÌSÕA f Cݶ(ºª‰dè È„Ï(Àüƒ >$‰`ï?ôÊx)o=ýYÔ5TÝS\‰\%œ=¨`÷?vÃUÀÀ ŸwžCHMg±CV^gø©Åq¬qw¤”=†U8„J X€Œ°ÂDЊ!ÝP¶GWµ•ËWæãvA6´‚*!žM˜~Û=û?ò }OÐ}~4=s ôÚ?E”[¡”¬ÛîÖ- ãè++ð"ã¤NLšÓ¥Ð_?W*TÀé§Ó•Ûáç7ÛÚ»­=úsSgÀê0ªˆOuÜç:e«­: ÿû éÓ+G€q²ZX`žZíŠr‚ÍNÚ‹\ìµ"§IdrŠË¶æÑ‚ˆí÷À€<æ‘´Å$ä1)‚m5°°!ªñÕ삵–üÃQµiÑóv²²½Âz”@„¿*À=*h Ü;âd’Øx ¤F´‡ÝV·)q}ã3âÚÞ÷޵:]¼JvŠ£±üƒŒ(Ÿs–”¬4h[#U–s á½b É ‚yØ®!¸û#8žÒÑË0 ÑGEàƒÛXDNœ¹ =ŠV•:½ h÷G ‹´.x(,Bi†·‘nÄpH»°† åuEÈÉ@v’‹5ÿ×*à/}€½\Ó/ BìýÉÿÈž(ÄðƒöàGœX™#òÇ_øÀƒƒDã,HÞt‚¬š¸Oɯ9ãØãh¥N´HÇeÄüåj“ £ú€À 仆ô±!lÁO­ÒÄÔ*‚"F¦NÿР ŸA “q¡ˆ¢| ¨"ïÄ͹~5!#1‰À~5ŠQ C6 „*,å‚6ôb'´Ô-gÄc‘=͇O›YÌìñ#uIŒbQ¥iÌb23.n#¦O MfAçJÓÑâs’B/OéJ_ANý¢R‡5 (èt¤ó)&%ráÿÂ+X",1I€÷ø Až@'&O`§þýÉ6‹4Tó ³ ‰ú¬w‘ÙC¦%8yCÒ 9„.™œr…îZé*qQÒKø–Ëq-]dK\DÀˆ0?ÑL}d¶“2iK[Ùž${²µ­>`‹½ 胸<j1ó1Ü |{ÅêãºiÕ,ÚC:ÇNÃrE–p®ÍœKËŽ”¿ñP…­¶*€@FD–@CsA :4ˆn ‚ìç?š ÐÈ´"‹ŒÉm| -Âä#’ÙBÚ@èt³à•ë“B¡*JC‰Ûˆd# á’H7b¼”®æÂÐÚ|pc©z‰m ¯èIÿ{#KC8„ÅÀÓÓ@^óâ;DƱՓŒ][âÞ¶!ÈÄžl/hUº9.WýÔS…NsÛ] Ç6Ö)K9G‹Ž=@s’!X /ì‘äÁ‚Ù-ŒˆûŠÀ†,a°†Äè?žfârAF3?cÍ"D-œEd ´Í†:K‰ŽpäÂ1yé@Œ×.¿¼+^¸É¥þ‘“š˜M?p GðKlDRyk7×îôµÏî‘«ªê€]E8L/TäV6")Êßm£8Ϻ£éäxC „|TÖ‚ Hiô`Äÿš@6!h‚¥e@JUÄ9#¯¸¶h sÍØ# œéh¦ÿ… ‡ 4‰¾n>µ’ΈÝ±Ë?Rº(||ø%‰é½R“W¡½ùzo@Dx*#"øIn §HáQ¯qS7dÆ.Ž1V“¢j§‰Õû8ªŒdÆ5)­mI+x˳¿þ!1ˆ—>x£m[{¬ïÑþj»»Öî>³‡ ƒÑP&šuUlA¢é# Ίˆ žh¤#«±úfï²B| $kööALmb©Kh¨ÂØ—»þÑŠÂ51.¸CF ^M3Ü5vxCNp‚ë]â‡ø?îéª^Ìȸnr„ª°¦åðndޕܒ喷b>CÁÌ‚-ÿ:¤¯ÉkíôKo»€"^i&ü Ee»1ÆÒ eh¶Í$ÿ½ì(3’tµ Ý9T*ã¯Ù˜D£ˆ‹z(ŒŒà—Î{ÙÎðÜ, €Ã¢p¾7<ðwxöpc·:ÔiuVF¸Â¥|×ÛmüwþÅEds}ÿ¡ì†ôõ®÷ €Ï5&A›ÐAØ"±Î+L˜G•D‚$D·ùD@„¹ º¬[)DDØEm¨Ä¯|Ø¢¬€>¸€Mè[Mô›}ü€»üÀH\D`ßÃUŸÀ¹öå ö¹Àé rÓt]‰ZíÏqÙ ýÎx, Ç…ÿWý¨bF¯-Àl`^Ð<”Î%PC€rá@Ü•íÔœ·…[„•FêF†°Žð”`‚ØHFéˆ*”á¹ ›…5DFG Ú]°ÇJÐGÉœ ~¬À‰ED¿AÃ%ðEÚÝGö5\ÆõE„Âý õáŒMœ÷á`øu—¬û°Ï[¨Í÷€â¡š•¨1‰á°Ƽ =ÄÀ±¹U̇î̃ÎÉÃxÐ%%^qÀÿ…Þþ„À†F„1à„¡Þh Þ Ó… hÙ/ ilH^ÄŒ šÈòˆC´Ô3xXó€ñtˆõ¨Lü€óÀ…ßæ]À9b&"l=Ï÷Éÿ öÜ÷9ÜUF\ '>Ç™”Ï'^ û¬ \X‰'^ÕBÇXÄ,Ž…UTEq` ,^G1!þþµ à¢.ÖŽ@é“. àÐèÕC^><£ÌaF`%¼HœMãP›I<#ÓØ B‹ÑýW¦[¡™—xIÍG, KýƒÖ<Ã3„IFÖŒTÝÐ[¼bUT=Ô3‰À t„>ìQí€d^ɶ|äSø•þÙÉ0RÄ4R[¢i”†dˆ€IDQ ˆ>Dÿ#GyÔÓ]ÔHº‘”õœÝ‡!ƒ0¸¦RþC3|c3ô^i_=ƒ åXÀ(à ÞG+ n_C`Ÿ!Ðö5çÛ]"s8\B¨¥p0B4 G\fçA.Ë™¨å²4Ä™±¥=0B]Æ€=Œ#@ä+¦çÚpGz[ 0Â+&\ÈgDΧa¦Ü“ÑôÕ ðœ_eK_•@ý_1=8Á·¬È¢á¹˜a„iÈ+˜›´Øh™ŠFÜ&nlˆÔ ›LtÄ<™L3  „/”è3ÔæG<¥†bHÀzá2àƒÂ€À "qpZÞµ]râ‘ÊØô‰¥ÉXDðÿø ÜšdOs5Ó™¤ÍR)K²tç?fçw†çAŠçE¾b^¦'[ª€}V…|ÎC˜šç?œ,b –  !ÂÍ ÔG^’@C @qžãJNÊdF”F†*'ÑÙS|µeHLhÄ - ˆj—Ã50e‰*å‰6Ã2Ðæ£0`nàF{YÀ üè¬T:ŽÈÔÂŽnš«^bü躖‹ \r‹…ÚÃ…‹ÍêI$çIü¨¦ Ss=–15Wa)•*S”"k”¦ ŸüÃHk›Vçz¶)|†ç«œ§x„›Ê'#€«šnEèÌC–Q!"@@·äœ_ýï!ÝŸ4ÿ¨ê݆µ=êhLè Í?Œ¦C,iN˜†ù^¡Ijºdã¥SÊfŠúÂ?tjĶ˄° Ã%¬ÛýÃl€ó A€@*´Ô?¤$ðèsB°lQH€YÐjQ\6F©CL+\2Ï>«b*4à H]‹!Á+PÀÈú0Ô °X\€2yÿ.ÌJ@„nC.GF„èÂìŒîÊ>²2ײú¬.%W/ésíîòIx~ÀŒç±Å"¸þ.[š§Ô>E|bkÅÀ< [ÕÆ Ö.À¨ëÑdË(/âü ˆm] * ꣂÔLbæD¼É› V›ØaÕe¡¬Æ<=Ã24ÄüþÄ6,GX i…jìÑ´þ€+„l-øÄþÀ\@1M+#è,wn²2pEpQ(Ós©.GršÔlC´ìRE„!k\(SA„nϦ0Ÿ¬°·ÆÅ'[b«¶>­Ò"[z.oQİš>Ôî"—¤«´î#ÈÅ%Û@ÙÿÉ[c¸Uĵ½dê‰/€zæ¿6úÁ’Æž›Ôè!ïeãl~ã@nŠv*/Á.ÒFl€>ø' üð@‹ì÷E\€çþïRM€L€ ÿïðn\L+"2"K+ï†0G2—(ë¦0tÚìè¶ì#w?HÈ\²è6ëо° ƒ+#˜Yx–r¸^†Ñ²ßôFDþ¡ÍÂ(.̾†™õ§`ñ•×jÀK«3²TÔ¬åj˲lp9‘貊®rñì~ÄeÌ8ð ¿°)÷óÖ:zâ0>;ÇçC@ƒ˜pIxε`¡þµ€W€ÅÚj¸uTL6„¡vq†ÌáBMÄd9FCìL†¯ïéa®6 .ý6¬(ØÙäbŒs9ŸóHîpȦÂûÂ$€<ÿ=wuGß´B ç°Ò–u kë„'>?ð³,ÒXA®N²!®æGqå5q­ð\ÌEE1`Ÿ²(›uþ #t´TœÙ|@+à‚|ä…P€\|Àµ hƒü•V¸ ÷–`Eÿâ¹XÛfn¦G¥¯¿>£Ù~ÍŠpëÔímBj»á᢬†uýÊæ3ÜRˆn›„@ÐdBu L€+ÔQ$@É^u-$À-,·C@ 0ÂsK뙉5b—€u£ X÷<”#èCq7â°x3ÂkõXŒé*§ÍuAóƒ[·wËv2"”ïž!‚~¬M`¿p¸â·Òâp §5b§õZn­ZO"œRÆË+D²`8Tä¥AŒá0¯ÀKjÄ„¡íhì´*PÄMºaµ¬ˆ3?s†ԤƯ`—Ì6á6D‰j ¼Œ dÄ¡#}À Áÿa@ ð€+ÔC= A=7;»3ÀÜ‚wD ÿÀ-À@L€’+-wG–@—óS”³”p1¹ÖA;²žàª—y1©nÏr|3À3‡ˆqò! ò§r¸›Ñ>­a×ð?ˆuQdÞòŠÎaC€!A¦Ê¤ƶ8’¸QzT†ÐYf¿H!r±œÍáŠ@FdØ KJÄB5êOrˆ¦·‡™LŠx¤ÂI¨Ž³|À¼ðÀTë¸qWõ/C*@v€CÐ3’yDdwW0•Ÿ³Cû@{CÄ1iùk]œ©áj²'{pyyË×]l@nÛtI$ï>pZ§5*'mY#oC ¶+×¹CL÷aK€Ì“‡-ÊåÍ\l «ÐÿËC”F8Ë3›ÔñÒnhF@º‡ „Æ¡'=óß!L ¦‰[³ºkj¤†o0@‚˜„œ8лÔÃ@÷@X5×ÀD9Wçz“Së®»C°TÇ1°ÁšE§½àm³yF]“IˆV¤¯öBAÌò‰ 7×èF´™‰ò™•™tÿ3¹{«7÷aö°Ä5ÐÓ~J@.l[8Á¼æ¥×ÓHˆ3¹¤­C°/û’†€­È3F>ÈÞìyøÛJîµÛñám6ZGà!m(ÒL /üÃFQ1‚í¼°:ÿƒ«û¸Ç—lÈwu Ðó@(ùV˳’ÿ/’ÿ¹‘ËS¹EÄ=œ3éêS€Ú—3;{ù¦­.àÂFéEãDȉ@ð‰è~ŸÑw´‚kCÀLD´9µ²¥žÅ,0\ƒ‡Á'CÖ@8Aé0x>Tb£"lûžLÎ½Ü Í|ÿbÄ!´¼í¾ßjªFrI6æ…Q JF„ˆ˜¹ˆÀ(W\¨ëªK@=ðÄÿê%‘ª–¯eÈR% qëH‰·’˜@bàÅ I0Â8p` ÿŽ,92ðÈ='UÊ9Òп˜3 Õ¬‰¨f}†òÕÔ÷š|!¢äsáB„>}"$ü“ðá… V¬(RUß{!ì1‚ðÿÑË‘__zý7a W³ÿ Ò š°¯†äú%D¾NB€´·÷_ B. Íwxé U#_ýS¥ê%J>^=VµB„ˆ•v¥¨R¤ÿ+VåCò%J.]býZ2¥„XhR„¹)Q¥ZÑ¿ˆø†:õÖ#ø/A‚ j% ÂÕ[ÿ¶“ð>#Æ[¶_ôøQì@•(U®'ùç@ ˆè4„§!~øý”JB ‡(}\Ðç¥>øéƒ„3Ì®Jê¨ÂBë ¿bd‚°ÌbdžŒ<üŠ,².ˆ@¹f«ëƒ(ì‰Â‰­œ ‡ž¿èÑàŸK„(ÿ¯¾òYJ³Í:3~ÑLÚ¬ˆ’Ò'Aûñ@¤‚4M²dÓQ¶Ùd³Íµ.µÜmUÊ\ 3â~ʪ ¸À9çþh$ƒªN!d°;=0ÚCW8òh [D:‚…•^"`$—Ò ¦œîC„‚V ”>}¡MŸéù,}r9,¨fÃŬJD†ËB¸‚ ÁÂ-µ8<‹ÃÓBŽ!„©’†è4ÊgüÔz³GG$jÁŸ‚L0—Zhá¢r9ʅͪ¨É'£,êŸP W„«NCm$Ûº“µºŒà2}Øì2àúÉTW”#ˆÎå†Nÿ:¦KH¡Z ˆ"ï0Ï• &°x£³ú”èE´ã÷N(ÑâKïŸ Ù‰>úV Ê ˜ZA²œH'>û Ô o „BÜóÙŠÀ°@Rz×_g=«¬qó ä²í¥„þ§gcì«ì)‚—(hü‡À­}²Gn¹U÷Ÿ_sŒ4Òž„2ŠôZÊIÍS%ËxgË×^ÛìÅWËd[À‡%EàGŸâ2Ìhàç`n ËçLøŸT|Q¨!W:k»Œýäj^ MT$’ß[âØa‡é¥˜d¨‚ÿ(ÁgD2{ù•KóYÁ‚úúǘ4 ñë¿ò¹‘æ¡§ÿ](À…|>û§«³B@kÃGRú¥£‹, ,0ü rù ÊfÜë/åé‰ ÓV;3Qs õ¢Z’³¯2ý#3I9LÞB#¤ˆë>@˜^‚›Ý€DL Hã^¶˜¤T` ¦‚Àx (:É© r‚B…üã|ú ÈCž³ c…šÀv U´.QëØIR’ @ eN1Ä  V!‰UÁÂBp‚4¡ YìQ!DÌÊôhƒÎȨ³úuËC¿zI‡ÐÒ´± /#@+"`›Vhm(1BÛÍ@Â->n‹FBã_ø‹¸€4BZÊÁv]„ÿÌL"78Áôðf7ˆ#\o–ô²Ké„ ANrF"é¤ç ©ˆuv€‘@̆~ºØ?È3šO$‡ê˜ÇX0»‘Ùîv/iJLpq (H¬Ê׃D@+Â.yàÚà'y`‘[mhÁŒÚp6î•o¦Jâ@ž¶4 ]È+È  nŠ×©!m$NøG7­yÜCMdÚ”¢$X)‘‹YÌ@ŠÀI"Soñë§’øÀÝ+_ÄdãÂ8 jp3õ1rJXÂ8D…–»“*ó‚[hG"†â®fÉC– $"â8G‚Dû,ñ¸@Ïò‘‹*‰BØ@3åqEn%ïY ‘ÿRB”Ålбas–ÐÊIS¨µ±/±[æ¸ d¥/1šHni6áë)ê “()å4dÝF2P!=ò'?J_4u¥¹ø_±É+2™2E0[@c<ÙŸÜñ -hÔœ ’!8Ç®¨‡s ‚øb:(hyx ŠÎb¹†ÊÈÖù°u± ÙIJfŸØ$7Ø.Ž9 ¢Jùˆ€|€g"Ïmöl[ës,b30Ó\9­jΑd•¥ød#žÉ+Ÿz ޏ…VóªÄm- QzºPŽkœJB¨^ $$M¥q™Œa5ØÄŠ…‘5E„žÿ‚¡M¤§¼ìK:‹'=”;#û‡H\J:¬Öt`¹ 6,‘ÚÂ'=3‘Ï„°Sæ}&{£¢Ù ôq3}ÃmM‡¯Qi…vÓ{7g‰W‹ZtÖòŒáLirkyÜÓÛV¬¬6ƒj™n+ ì\¹l½3ýFÿAÂ/Û½Á×bg=ëÍÈLß#‘rœSg”iÏœ=Èçþ± _˜ôž0wJ`‘ Gv|¸Ú¾Çéo›Ì½ƒŠQ/έ¿ÿÇ™E½´Œq|Ï@ wG«Žw}£[‡sWàìÇWuÈTˆ{Vø¨¼n*OÊdurÌ•œ,½}>T“œ¿*C Æš+Pz'^ì¡©&AP1Ó–}¾®ÍÁÞLÅÚÞŽžr*·‚ôþøGŒ°[g˨p‹æ ¹œð-6þÃ"âiãGJ&_¹ý>5‘‰!t»‚…vêj§ žÏ½ ¾¨ÀLQÍÛ„KŸ@Ÿô˜‡ fUêÔq¨|Ä‚ñP†C:­wB n$pDyFBÊbN~Ž&Z®‚$Úã$hÚ$cÚö3öª[¦*|ÇoŽ­“˜NÚfMö¦¢èÿV`>$@†OPèL,BÊêá­n âjá¸nþaX¨¦ ‚€OFB"0â"ÖètáÌg ¾BRÄïíÄol,ÔØj„&+Zàƒá ®àæAþ<íÓêo[N`‹œ%,¾'Cð ÙˆCÕxeú|ò¡wà©AbyñâÊÊÄáè/àÊJú¥4NCöCƒöE„¬ôHÞËŸ@_ð¥Ú|£Ú^ÆÚV ¼ËM†/Ü–ƒê^b` @P ::+ÂW)@ bqRaH ß …Â2"=Ìît"¥ ñã>$À`ŒŒŽÊô§[B ¨´( OÿÿZ*V€à¶EŸ4MŸ4`+ºh+‚,œRmÈÔˆãðLÅC o3lfzp¼ž ó–Gž¸ÂE>ooà*ËJP‘@b\~âxòGØú ŒmËŽÍÌêfÖº­)à)Èb ¬®Îx `„ON2‹ÎêA³6‡¦#§$!|~ ;¤ÏP¾ûF‚&+cÐ"Djå¦j‚(  R ç?®-zÎâ¦g½ôÆàBÄɤJ>€*Ί¬Hšô'o†âò`ΩM0D|®«ÁBȦ²[áò!ÑGþ"lpyŒ{b¤(ò$ìBmËFâ}¨[¸Å%dh~.Ño^¢ÿ<‰_†®0j§¾‚÷dPimPøÐMsVH$-gaÁš¡†@´H‚ß‚@,"Kt.9š0Wl²hÃ"ÀRt²?GZ`·‘y‚®SÎ~rŠn¼IbŽ/(xf*‡SäÎI¶2C´+«¦ð,Ž(ñÖЦYp„¼z³ò¸BgŠbT˜Í.þçç2Ø@âž2àZ /ž“ŸHö‚GÅ…èàCŒ,Œì Âêìƒ/#Ÿ#u0‰ä$:îô$; ,—JÀ3E"²ºC45CÈ‚ü,  äeöÅe"@,×PýÖ«/D@[þÁ)ÿ0ò‚‘ª¨ó ÿ¢Dmš¢Õ†ÓèðorÐHolì¦ØP•‡Ê°Fö"f¤Ù>åxœ <™-è~xæ0 <ƒŽT(±/ŸíABƒè*'ICƒŠx^à+³£œ#?ÿA³:?ƒ PÏôÝ ~ £M] 2g:  0‹†ÂCÎ0¤nàžá Ád¦*.¥nòaá nª"i$` Ðkò‡> 7ª(ÒjdE‹"D€Ö2‚8EiV>ŽãPFè{$oàñü¢ ìAª,nᶨGãfÔòxúâ+‚ŽÅ>T†Â.¸…6•ÔY®¬U‚äÇ¢$˜b<“MÿËÔ÷F¢#åÄê$¬ŽZ]é7 ÝVhNG¢$Ák!~† .@txÀ–:b 15Q1ÃJ&©è:åäÄæ0ÃI~m[4 lpÓ^ òÂf{~SqáNUœVÍÕœWjEÞìí !D½©GG1ïfØjšN6% [† 2þeâ`s†&1)8oÍæþÒ_b3ú´n¾tÈ‚ à>][_‚#³u$‚\â`  O#)³²Ré\¹N,Ôµ]Ý5†`Dç†.$&(€6B4#zÈ©~V/Š(—ƦIœ_€2Òè§@‚Šl)œ&ÿC¨oi*¦‹ÙAÞq¦'DVŽ¬Ø y5Ô¤+½ØâC3*‚Z!þ.[fÌ<ÃI) ¾‹É$>rI2>ÅtøH „–ã1]‰MY¤`÷ Ïn÷iÿ!h÷9¦ ®#}´Ò£XÈ (( .€$æ,að!U¨J;áJºMlÎs`ïbŠ ï¶%n—G½B¤7œ…­ $ôˆœ(²¼2CÐb«ª++3¶¦¾JzDôf¦GÒ÷àúWºŠ*­ìI,2>)]^ ¨‚•Æe3¼,~˜•¡Ø?RH>RôÁÈØb>  wÑ”wÓCh£v „ï ÿ™öÀƒ'KN.ËN§Ca:OŠ÷%êô:æ´˜Ï"K}@‰âónkøA­ŒB )®¨¨–ë)‰/Ñäü.nžJT/„àZabûöoÏb8 ÍV̧~A®[*à— çAœÑ¬øTBƤK/ƒS)€27 Á0]ìbU*#K¤3ŽGèìÆ ø,¥R\0>ƒ „σŸ¶w]Iv{×w‰ÖÀiOø:9ÒÔ`æ aR $ˆ×†iQaF•ªC]±ã*à(` G ÑFžô"&4HÿFÂ-WT) ŒCçVh¤XÉð)¯¸(#_>àšŒÿ7FŸõÑÎ+åo*@ÿö·MVÀyðâx¥T:#€Zå.}mh8¾òs;£.­ž3Ñr?R(àR¨uL#9’=úXúþádw²„/8y…A‚…A8¤ a@R«#=|!!fñ‰·ë| ^/@·n@ÿN€á)8+j ¸P~þ‚/òf@:ÔHÛÒ­bš ÕkšúB !¢9C`0páW”¬êÔæ ,rqíf,‹îI%8@=Š*D¦Gô"f·Æ »åÈ~áãoê†UàjT.‘UþqËšõ¶ ÅMDâ‘Ùt…Y¸’y ]ÉÀõ1‘Ðiÿ>™…Ó@f;‡†gѳ û%l´Š7 ¤i98Lº™‡`o‹Å|…¬fDJ¦Ô0†íçÒ%]´å¦;4olÚbѪ²F ÷3[Ù¾Bp”hDGÁhšœš8@à8Ÿ .ºþ!Dœ¸·:nä†çt.Úþ¡InN¯ÒÙY£U>.u§Û> L¿‚Zww ¨5v³ú®Ùƒš¯?Y?™ck·X†[a†wP•ÆÉ¢oø³ºÎë@z–`Vz”,€äã'Nº ó"4„8¡4†tYˆtƒõ‹Ë1ŒS‡¦ÊQ¯KŽâÎcg›¬œÉ¤ør{ 8  šQ8€QÿÊÅC­ In¾Zç*ã2¢-­¿ ž1ñ¶–„4|‡Rn«‘y·r<Ó•$„¶»oÈWx¯_â˜ã`è¢C ž¼½ÛÛª ›]ñ„¾‘‹z* Y²·™èx½V´¿ ™Ò<¸ÖEoF4øb{þNû,`Ðb â8|l¨«2›+¼bõA¶o†Bd¹B-­F<‹¤lš²e«•âZÜ”›=­ì†/ý®.Ý‚1ô9ǯ;úúÙ3%Ù3©õÔƒOPy……/ɃO’óÊ¥ƒÜ¤£ Îm°â½ß»{г<ëÂël‘Ë+ÀϦ~ÖD0C´¥xH¯7®ÿ <Í·S] ‘âª-ݲ}-À$`b¿=œºcµ ŒmÉ+Y »% RôajâÑF¼‰Ð¥Ë=”Ô.Ü[ìâ'"ýÅ!$.ƒ®@‚J¬?7ŸÊwæã0Kà¶{wew$hל“i-kNÞ”³*k$X$j‘×QfAk!°$¬éeNm”â G†4/>;"T†­-÷Q-Q]ôÂp!*bR~-‰óT7¨3lr²Ù.¥|h»‹H-7 ³GBh^Ú.Ü2 Få["¼Ú1Jƒ_˜[º9CÓuÖ²åã ñƒ`áKØ¡þÔ‰\øˆÈÁiß4Á4e¨¼ºÿB¾xM ŽzZDuTô"Ìí¥¸ðâ¥J4Ò£§X´(d´ ¼ˆsdXª;„h©Î¡æÎÃ]¨‡³‹;ßT· —/gŽ ý“«Dï¢ÞÃßó4äÆß-ýÒ) |Çó¹ç"$8tßX°Û­½»¡¾»K˜haÖ5Kø”C³^÷ÇNIOs½ãÍõã}ýsô$^£b§¸âçÜræE€56ƒ†DÍù‘Ÿˆ{*¡f>€°>€^p"]´Ü¥™Ïýv$Žešâ߇”ðÏÐ óæýûgïC¾ˆöèµøçð_‹yÒsÒ"Š“(QŽü—KŸ>¿V¬hùêá?ÿWмió¢š"V ʉHD;ÿQ ‰H„Adþ3àôáS™ª+™< ÔûÇ£^=¯Qÿ ùÊ£¬Ìz Ê‚xøVf*·sÖòõ¯’¯ÿVTÈ"ʇ’ÿò=ôA‰f¾Å…óår¬R_>}ÿ¢äü/Äå†sþGY2h”úDû×J‚ê ÿ*°&(sà?„$LøÀš5î‡mûþwáÃm ˆnèû0Þ¼…Ò£÷ïÄs§[@‡î$pf’(AïlÙRÕŠ‡={Ê z´çÎæûª÷)ÑQC!æ)ÑT­L/þ9i€Vÿðe@Xc ¨_‚µÅÖ‚2W*Öõ ÿSµ óO*mýc\}ÀœL”©¥Ïc¡öØe—=¤™f•E¡Y’æ˜ ’岂ÂD Á¯I ÛB‰Pp95ApIÖÆdp°ÉfHqÈ)Böx4tÐyTH0–‚QöË/=7ž{<Ùô“Shê4ÓOAÍ©Ó"¨D/@ŸUS9õ'U/X••Xÿl务j}uV|%¸!ƒ&Ha†NùâK-qÝ@=ö¬Âc…øa¥R&jTùdWev™]iY©žQæXa"‹ª7Û}¦OQ ‡@TkµÇì@ÅéS_r]ùP ÒÉ´eTÙq'SJhæÿ/jŽ §L4=´“O𹹓>IAÐ~ÿ0EÕCÿùç@Uÿñ—U¢g!¨`Yÿ.ø¨ƒ_%€0\q9a†•Êt—/sQ0Tô´XÙ·¦‚¦’¬…‰*jI„…Y%ÉY†òCžy6™>”#ÄÀ!$$‹†¹«’lüVÐCÆ>„n;t”1"mfÊip—ÿ\ç”o«]­%ÎDSN6m=šEùÄSQsŠ­Ïï.õžTÀ_½0èCýM +[=”¨ÀÖ#3£Œ:Õ–£Q .s.¸°¥eÝ…ŒÑEy*¦©¢&Bd´2V’a4ZV2˜•ÙCÒÆ*G•#>­ì ô•[º€Ôÿq½Îæ3ê¾ÕkG~€!½:”#Ð%'­ÿh`Q¶ÿŒD‹¥¤ÒM3õÕ5ôpº”.NsâŒPQ³M°½ö²mï ù¦hÚ¥U°Yòm–L2ë °LþÐ ËŸøÃy]H‡Ô¢¨¸`4 òLæ(#Ð9tY Œ2ö™“Õ*jvõæ„©0¬{žÎ|34'ɤ=[Ò±‚SC¢ÂÚC42mx2qBv¶u’X ¦$d Š› w&8©Ç(ñA×·ø;}¨#/(Aêå©<‘)M¡›L¶R´Ä¯~|ùÊÁ$¸µŽoŠ”YÚ’¸²¤Büóßÿ¦C•L†<¥yˆؘʈîdU«B$²eNÈ•Ìz6@¼ IÇ`G³  u¼²°vSÛÌ&JpNt`8ÊDÖ9ÞÓ4ÈSÅ(3Ì#+Ë“¦¯µéy"’Éd$NB GèϾD(do‡"cÞúæ À=¤`ïs3Õ–!l.™KþØX £Ü ù¨µ@#º:Eœ&òŒLH&ÏÉDƒû’£þACØÕs°Øè‘3“Ï&àšƒ\`g¹‘Í‘bˆNN@9iZtT‘ì€Ndcd:–5¬Ñ%ä9Jœâ3¢ äß¼™Ç ^ÿÐË{%ˆŠPyÊ¡ö𵼝‹ƒ+ãÉøi.(Ro9Ü?ò•¹dó ˆ"2È™Ï0&*"8×h UfæE&;^`³ÃÌÉ$Gÿ §@ à‘ÈÀFPÅÝnâ$Ô9iYŽ‘4 ;„¿ëˆðÏÅÏ#êQ¥+sŠè‘#šLT7|¹¨hª1ŠÑe#‚<ÿB¸G4rÝi‘4Ç3S+?=Cì @‚À…•; åº9`Ζ.Æ"ˆ„ûfßR R&>ÊÅʪˆl˜Ãˆ‚°·,9°£â€ÿXE‹iá/šÃâ_g x-Sp·˜ þ1¸§{æs6ûl$ôCB²˜÷h¹¡d¶ 溳˜ŠÛݯ€F3š!„à>´”ÖÊŒ?‹Ôc™¨õ ¿3kpç³0!¥bÑÁ³ezÁ,&4-+Kå&ž.¬•2é@"Âåå œð÷=¼S`¯´Ý Q]i¿ãëq·õÍŒ–Ÿ<¥-í¶ ç€ j¥@ßg;—M©Mý³P3k³5ÿ:1k¶[¦9²±d0’+b¶ ×YÇ[÷€^¤;"Èbw$H v(ˆ^ßÒ‚‘3"V2ŸRKuGK2ñ vÒ.ídþ4ß4d…‡ ÷õk‡—xV Ž÷P>Oø(m6Òt0pF?ÒL}ó/hDœ'ZQQ }6€(Ùtg uO#$‹±n("[ Ç€eANPÅ2´U%Éc%SúPHЀ '@J'pž’^ž$QS1]‹;w&vf‡P AJ'oä2&WµBwº5"0¥Q9VF¸äO¾ƒ4á„÷DEx€~èW~L(ÿL…ò]q>ïy b…Vhy—åfã†Z9§8c†B†CeÍô`¥€¥âœQ+ãAÝÒ"†aQdUÐ!Ð ðPÑ4‰d%!²uħ¬ðtðÅQ`¥BD!3îd1ÜØ|Ý!G¦£8@G¼–]…‹±èlÿ‘þÑ/]ÁiÑ_‚Y´YjSð‘!É\ølöGMaˆŒdhZfhj¨*²UnÈzúz£Á9w…qCô”p B ãÑ43„Os1 ‚Ö¨”j!"’AÓá)#¢²h¶v7á÷;ÿ@x,ÿl@à‘þAE'¥xa‘fùÑR`±7WäEKéŽöWmí³ Òô`Ø–u¡’d˜íC 0UŒ–<$88n’1Ý„WØñM.à>P+AJÃCÄsJdN¡ŽK¹”D1D`})³2±à¹›®ƒoç! YóÀbù‘¼¹G'jI‘ò– `‘EÈ™(+w7¢9gj!):•Fb(†;7ýCÜ,¡AtÎ)+~Õ™aµ]NP³›‰u»Ç%ÃQ1å£Ù?Çn‰ä°–e{Ç!¡‚K±Q%m7d ùò°›ÿðp_àÿH7‰'/ òÃtl^‘œaá^ќ﩮 )øTjñ—›4˜ˆÀœØa–Šæ^ 2cž1…žÐÑ›yKÐa-¿3cIñ‚êœÕÀ;aš•Vâ°&œÓMƒ‘A¹P3—A\Æ^ Ù4`&–ª ²h P„ú±x_üqâRäZA ò–|1BJsœÅ`'Tÿ͈­P3–<7q.‰)šª4##žôp£ÆðM Ú'°£Kàb˱|*§rJ Á’AHÊjGF#¾G¥é{1dQÁ`ù÷u– Z ‡wªðU~ó2ÿL_a.5L)‡(ù–hæmV·L9µ! cZj!ƒ9z ¨rj*R*bç™br²ÂÎYCÛ^làœ4à9|_x¬Ã®*¢¹3P„2q÷[³nðÆ ÂÂr!!õÓ> PU²%Õ×T¥QGNQ9n›ÁÚH+þx—1¼!5×±%0 9ºS¸‡¬e‚÷^Àÿ¡w|21–cùŸ±A༠¿¬ Ì21?5UaprTp·#R9¤ø-në<¼ bã@D)îýèB×°#±b Ëï©O$§ :«ÿÐrÚ &÷Æ ÌúF>£·È1w6–&ÆOòq͘¼(S#±Ajñ”€äš,<&§e šà Ыå—ÿ aÛ ñ0ÿ¢ÄÛS“FèÅmAº›ÉûÜ<,¨³•eïôZXä˜Qé†`B@`°,»Â¡¢ tÖÈ<ða«N±ÎÎ mÕp±Èe1àÿ;¶D@€·ÏÌ ¢U‰F[õ)UÑèòÓAMÔ»”JÊî±–À¹a *e¸#}ÕeaÈ c8Y 'ú0´œkbÃTNåT{”e+Òp!tN©JWâv§ôˆ Ž‘ä®=³”¥úž¢À×5ëªÐ ÏaÛ ‰¬”èðÆö… ùÉÜ\!ùdcM“ÔÜ}}±%¥…Ž„6W: ñÊ`Õb¢™]ïiºü×Bê×}=Ýj uZªìÕÒ"câŠÐÜ»ÿxN çOaÞE‡Ÿ¥gÙ÷”Ù„©ÜÿðÊ7žm2ðÜ×­ßû=Ý `?2ñ‚Ù%cÓìZ#¢ÿ=õù+N±tKæ .¥%rp·N¾“Ù;Ák€4H3Œ0´¢É½ü â!¶Ÿ0MÒô>¬v§põϺMá¥JŠõ)“Ó*’"P:R"> ¥z›%@.âC~Õ@ä€S`¾q®ÆO˜Œ59è®õ"6S¨}2H%¼æ!ôÐvYrª·éó@GîݰÑ+ì¥Ð‹fnW Sz¹\´ãOL.#xÄ»e±š+M:R;´è=c1¾NâÇŠ,Ð?þ¸bîæï¸¹Ò]³tÈÐkΞ —gmN±c€Ñ|Í - k ƒT–!Ð5í˜ xÙÈMSÖ«ÿª¸ùËfþ¸l¸Šm¶IhéúA ‰$2a<ëÕ<äa®çªå"õY%±CP:c$5WõqšÐ/­þç,pªîææÐë–`¸£ÝësJyNÁk71to½ýW "!²qZ¼N@1@ÀS”õ: `y¾oé¼î5;_/p”éç.§·Né5}ÿŒÖ[\ß=-øðøn1 „æb¯N Ù^¾Úží;àœÝÒè×Üa;pSÝ«ëJyÚû ±Á®X]}JËW’qÛ/£VR…É"=[˜Õ®¸éý–GàÂ2–Ôû+ä ¶RU}ÝHÿâZŸ ¼Æ=ìÎjÁ‰Ò·T'bt#2àžx‘ëÅ«­»þ(+Hÿ@­~áŸY£¨^‹½uKÿWS°»dôDü †*„H®¡Î¾<ÿñõH9ÈZ2äÒ¨…ÍŒËH¡Ž¨è Í<ÚŒ2ì@q@«‰¸KëñŒxà \iä=ì:ÁÂ¥z Mµ—H˜éÚ*@¿y48ažœtü¯0àúš()!•¢H© 5:²2…æ©,Hè¦Óp3Í”èºÑrøâ…#D;(W.ÐE,”0âŸþ9`ˆB¬ÔDKñ½NZÚ¢žXL‹Tê±³¥øþ™`.* @ƒ "r·œü;n£¤>ZBI)¢èžƒjéŒ>²Pž% œÈR·^àr"†p…»3]”ðÌü' †ÂÔüÄ¥ÿ3Ð0àM æL©`S"åRRb OWÄB#>ãšF%¸‘yx´jG :È rKˆÈ 7»ÇRQ øƒ …¤Š4ýGSë,ÒHC$'üL¥@x¡»t'‘$ Ð2V•fíÌ B\8Íz‚ Õ•fh3¥‚8HµR±câÎA²u#êQmØ’œýçY‘b”ÏT@‘`BPêÑ%rÂKÇÜÕñ&¤&•Ô\ îúž*ažÇ–£j£#'Êìh ã}ºÒ‰Ê  Èá 2ÿy!ˆ0æ²ìt!p¥»„_ý¸˜/Jà¡ßÏT8hå¡59tñ ,º–x!5ÿ°Ïû=í0‹EŒÍêM4Y4àWì¼ü <šá &˜˜ÃE•c tÚ¢v æ‘Gª§DèÚžº‹1!O4wŠr¯ŒÛn©jÒ#®4dÂŒ"œô{R>ºyêâA#éâ÷ UE¼Ô‚†•KñÌ,A{îDûpaYo­‡5 (\㌵â÷€J8ïùÑtq=ƒÀóŒ]ŒÜD”Õ§‘ýcYÏbÑè ’°Ld&ó‰Ñ(C%¥@MøGžb¦½Î*›!ȵôB„‘C‚yu„^G‚¨ê5M…Àq“ž–h¦¹¥‹`Û’¬†µýƒ8&ÿÀJ<âaØÝþ‘·!ðÀ܉œÚ78ÿÇ‹ªQÍwÞƒ¸‹}D5f1 šÀz\Î˺ŸFVÀ8º%‚´iŬ¥ DJƒiSdW"!j!I“Ýc™´¦MD‘œ:¨2¢!xÍPËSÞ=Jðº”êcù^º‚ 8`kO ©¬‡ \€¤LX™Ì‡õ=‹X2@I0àIŽ\G¤£e"þ,çPéÁÎp‹[›yAÒ,C•ne^¡dSã•É# ‹­m­¥6I0ëýó Â^ºÎäÿMD¿ÕíY1V"n«g""Þö6î´~!œägW’ŽÅ£ˆËXv5"¿hÞé~¶ZcÿÖ“—nä‡(DØdvÜÚI_€Z@…`öå)O'‚ÎÍÊè_ö2#Ûµ•x ï´ôZžG´"ŒårU¢¹*B!¼UîÕ6D^©Wû…áð¬ÊjM¿¶6ÃU®AHãôM°±SX€|” ’¢)Ó<"Њ|L€ñÐ8šØ÷¨ùjP'Âß>$…îIÃ.ßIÊ#À=Ð¥M™NrÖˆ›‡}UÄÍÍ ƒÿv*Íj„®å@V[‘ÝÔ4ER…­pÈM\¿WJG®o`Œ*w±+€û_¿ìû²Ûí½ Ð¯wº'GÁJnÒ´S/‡Ø%–ÕÍÿ€P‚Üà!*LýÃÓûÞ÷ío÷/£"®_² Õñb¤œckŽ´pJ ~÷;ƒ¬¹$.:SXÀ0_cU•4ÿG×öQb­B)ELªÝv‡Ï‰CqIýµâ”‹FÙ]òhwl¼Ž&Sr’ÃØI ëR¿Î»ÄÜÝ.Ös¼ÌÀŠ}E0 ¶ÖµÌïCû8"Tg—·ï îog™OY–ßSUF,x€Äó˜Se´U²—Vÿ¸B/¨M-Ì4”†êà\ÔLuß«Âsç#‰æ_c6Y2Ÿ–k…)2% 0"Šž´¹$œ/ª. yœÇù+¬«®‰) >ð+A›œe¹·ñB  ¤œz˜>ëÌóš}À€kÂ`ì‹™X²*ÉÁ½ƒÎš‡#H»‡Ð"-¨y£ Ü‘§Ø§q-‰P*ì6øRy½\Ú2a¾ñؼ¯¹ Uz[2¥p…! «íˆ.¾ ¾èò3¢»±5zÊaŸ6Œ4A1GK£«ë«5²1‹7”ÂP; ‚ šÌ£¹ ¨ ú:ˆ?ÿq žŽÚÀÄ£ÒAdP¾`¾ ÂC²'¨—ÓâŒ[­9X1"ƒÈOJ9úÛˆ 1#x6ÁY¾‰ÈÓøÅƒ0Ũ¢„ö¨ˆîx@ŽªºÛ3´7‹Ã „1kœÙ+)0’Ÿ Äþé½òb±û‘±‰pÀ‚£eÁ |3©9/üE¸8Û° {ø{ì  ð)}ÌÇ%Šû’ ž¸¯«H»K!¿x¤®˜@*°*A?)±.A ˆ?Å«­x°\Òˆ¯ñ°-1‚ôš2ùH‘Ìh…(À1t½QR6ˆ¹€+zÆ/úˆêâÅ;œ.òFpT#£C“ÕëC<ÿÔ± ü:¯c4[Q–8 I ¬þÉÍ F‘ìšOÊÇ¡ø‡º€¸J€¬AÿHž ' E­Ás¡è8žêP?A¼ƒ €®¹‡~¨@—)63S¹3IÉ~á܇` Æ’üh ;[É7› H•î¨=H# Ä¿>{Ž²Ì¬K1/"±Ä¡ŸÁá! Ñ¡º?¬¨s4 À:Çs$¬_ ÓØ¼}ÌøK ø\е_›Ëꉞ¸;ààž€™NYlK#¸Í«hËèŠÎ ¡KR-Wl-#’K#z è(’ÊàÚ›c6€¡«x!“ôÂKLh14%9ÿ#×ã3ô—ÕƒÌ[”Æc¢:ïÒ½Ê1’’Ÿ¾1)|+¬ÿÄ:ïº=ÊA{#h*/äB.4‚øK# 6÷Ó@}œ¨‹ªy ‡Ø ñ :ƒd[K¿èPK\£¡æy-Ñ8"#"8‚PÂH`³ÅFÌ%¸€&J ÿóÅÍ;ˆx€!¨Ð;I;Û?<³?pWP±˜ #  y lœÆÛ:+£Ýë®® >³h°“¯=;â=-ý×4‚hAfÃ#æOæÑH áPa‰ŒÁ±E’§ç¬—K3æ‰Îͼ³±*‘ˆKÂñ0@‚;Ñ"}ЉȀÿˆ€”‚ô~!=ÿ!«üµl1½Ò®)M½(Ížœ¡>ë1|›´ùC`Z£ÜS£+¬$­#0UT#€Íƒˆ€Ád> …÷Óˆ q‰PÑ0#\€ÑPEÎîx M±‹ 9è|­Ûz­lÕH°jš¯Úº¥cR“­°,“˜¨ @•ó4€­i6"*¥ÝjOe‹Céù$¢ÃŽâ6‘ºêêÜÌWè ¯”™&[éº/u†½1Äb)Eó+4•M=ˆÁü!È °8‰øSã Óx 2ˇ#Á\À€6eË·"¢K ‰¦ÒŠL.‘ƒ­L*0_´ˆ›Dÿµ-8 ºâŽR’W,ä‚°“V ý£×­qp9£{ÕØ-éáÃÜ«ëœ7½C‘2#Үƻ° ;ƒÕð‚œÁá®ûá¢îBD@äQýšh¶a­M`”¡¡EJ0\ˆS#téšP£^:„DEZSË?uEÜœˆ¶\Qy ‰-<;7³¹…YÌp% <Ú-ôQ°IIl*+¬âEQBû³­«•Ü`zSÈ&ü ©Ôë½kS S™hâ½ùÔÝÛC¦Ù®é³6^5‚V¸Œª8 WLYyØK¡SÁõHT——!ó7“µ¬ÅÁ]Ã刱ʒxÖ¨K€ÑKõ!Ú¡žI×uu…§<´‚3à+\¥«`׃݋ÁÓ(ÏœÙƒÆ U×+&:ê]Ö+&þ 4$)G«œ4òÂaäѳr`yˆ¯±” ¬tÁPʨ<uë›çh¿kÅV\íšaû¡!0„ôMT ƒ03£¼ó)W±vÄKÌ£› R“Ћ³ó*¼%•;»È×ÿÉ+írRÍܺ¾² es,¯°ÃC’ ck¦-öÆ5‹€!ù ÿ,éÿÿ H° Áƒ*\¸°ADüø!ºAiˆ2:Dô‚(Dˆ0Ð ˆBÞø'ᣠŒ>Lñïà Œ7l04ï%#è4ô¡‚„Ž76à³a…• ~D¸R ¡!þ2ô”‚ÉG+PØ`aÆ| ü+`¡Û·pãÊK·n]‡ü6®Ôiv¢ 9¶ºÑjA+‡)¤üç”#„óþÌwÃ,c!ø1š÷¡í„›Bo€ÝÊ8‚²†©fý±!ÂàŽ![µªêÚ«„ ¸*ú7_…¶ÿìųǖŸAµí*_μ¹Aã¡3Dûú?éú*ècLiWæÿE´1É‘‡ÿ¹n…ÈäO,þÍ;1/òÊ+ÿmÀL¡ç—LT˜!TÐ^eƒ¥RQýóC+ü€˜TReÒ,rƒøŒd?E±UZ5U—pÒýs,¶èbB)¾e\>gct† ²ß¸X0GÿL´€zÿX ÐHÿÁúH‘Ñ÷ ,ÌÂWêó"è¤Ydÿ‰õQ ”’bY d`FEÕš„øBPŸÚÍN 'ˆ}æñµÜãµk•YŸ/ÎnÁÛÚ j’#õ,E5+>j1¬,¯†@‚!ð4 «òžnRß°E ‡;áø>:’9‰”¹ B£¥hEí‹Îûd’üp$)¸ˆ›H5ׄ#½‹Ò×fÇ‚¶ròpà?`Àú” ‹³ÃÀ¢K®*TâÌ_@Évì£XÞÉŠç Œ] bZi ‹w³Ll{ö ÑZFI>ò›ÙNÐÌ…¾…ðb‰cŸãô1¿ „ˆUYi,›‘˜HGù±¸ÿÊ%dñè.ï1¥øx‘!BêE‚ž€U 4[nn ¿ã)f1­¨[Ý’§ª ac ÷!T“(ÖÊæZ"w5pºTF8[ŸL†Hã´SédT$3¤ ‘#)ê3ÅÅaX‚Ò 6[ÂGG¸¤ú#ÌŽªÉÀ,µªÐ^ž ƒ,p(# ´€â- s“F dŒâd²‰ž‰B ÁfO€äÐT&æå£3 ‘£^JX1ÊqÐñÙ¸"$æ ?DÀwvd1% " d&Ià1!ø¬ÀF°Hi`½Æ#(4Èþ!„ÿΡ_¬À]%eù‚˜WÉV\ü£'sÖ öÈ•nÀ2Â…³~~dDÆÉçëŒËqæRO%2‚êÃÇ?®0oN²áO­‡#”(‹nýã1ÍuOJe‚ z–WF0ƒUàØÎ²¡¼]ã= Ú“³´U¬Ò !îô,CÀŠ]¹2§׎ÀXZf¨…M{¨L+åZL´èë´}ãÿLNt«¸ôýƒ²çCŸ#nä¤<ölR‚¬HáH‰Ru;ï3”Ô·ý¢Tï}*;€Gˆõ{ƒ[®²JN-XÑëÃc³Ùʆ`®¤‹£Öû2–qQ0[û* ÎB֞f¾‰ˆ__¤–¦óäÕÞYFÎ{¾ U¸H­ùÈ‘„àD’t$˜YÀêZ0+(­Ž´ò¡Ç \‹`{ßÖª§V0ƒ®Õª–l­œ·@ÊÕ*ÑJƒ(ëRÙ£<ó$Ϥ>aÇ9Ž­Òžšþz5Ž4«œwO”%ëòB1ðÏo_>Þ'Ù—gÅFÕy6œ?¦‰ûBhEÿ^ðåYÏ㊳’‡Bkëy/–Á V0«úôx§ž‹U<|æ “wO`,ÀÐ#I4 s…!S1ºÇQ?Ðf‚ À€ 1qHlÓA‚&|—|.âWDhyA#€#åbCDYÿ0D ð)I‚,­ó܇$Vóÿt¨%ó±t U_´Tê—e³µe´Eå÷e°¤*§âzªâ0`?Bs%ÿñXaÌ4, @?à€ÈH0-°€ñŠ‘Þ¤Ý>h!‡Œt#Ù¶††^ˆt-6dSå?l2$g\ 2úPnêá)LÑÐäÿÇ-@—G;UVðG uF_s‰?8z a]j,àqçwK S&ö&12Y‘Wµ B? È{(#w 2!ó33¨ó†p˜IÖqŒŒT0#×ñ•ƒ…¤rÌh#9?ÿÀ†$B ÐÐ#ìé&ò¡bãW`è'@PSRë¸~&„*ç×oUv„1p^tœ!Pg[Ñ[øp?7p¸¢2ÍBR"*t\h7.¤3çƒiÒwÕÄ8r•“XÐÑH"8‡ 9-%C‹â7P^)(Tœ¢D=2_õ…,ùC/ëÿaŽ%ð%%°_WTK\´~òø5T¢*T4” 6`øÖUD;WÕK°2_¤z<…!spöc IWC6‹„B ¾§vøÊ¢2¾ñb3£-WŒ ÑHÉè|Æ8Ôñ‘+ÓM@$’ArE€ós¦¡.G2€dÞÇ‚¥dT6È/°EñP®Ge'õAEþ²5¥P´„z³£~ìU`„~ 70b³/²\oCF5p Z±…Œ€„Aó4BŽW À7HÊR€ñ‹")ˆ°"ÐÁ‘ré>C(•3È^y™8Òy-6B#7ãCÂ.䱔Р” ?NÔ ÛÿA¯°'Ȳˆ@ {ÒT%®g‰¡I±Ä¸Uþ¢5›ñOÿ°Zí¦U¸åEôƃ«r*O¨š˜ˆpZa< 7Rq„a b'³H'P ¼‡­ 1}eùqJÇI.˜”œÓ1|¦w…2"€Ç(ŒAÂ|ÁSw/¦Áxß‘åÁ£ó4êù‚ù"…mQ›e˜ùŽ^ÖþâŽ]6U˜Y TK£6­¤*ç/ÿpŸ0Ñû,QV`v¸€ ðLVñ2{N‘¡9‘? G±ø*b#àÑzÊ{ê({Ê‘yʧux§ñÈy¨|zyz'ÿêÕ¹‡Wƒ—ЗNÌi‡/çN ê+ ?÷òø*ÖU$ßgOreŽP➥PaLYK11`señjùý8e­ôö @öPÓ/¶¬ÿÁ†`<бeº¹pYÆ3#!øðk£ ‹^1-4büÐFlB¢ç5I†U¨zº¨wÉ3€:€š¨çºÔ™—‘:^ðÊŒìÃù0@¦êiDeÚ©æFH&¤Å–žßXYN²F©~º´Ÿ˜‰o6 dZõ6÷p@k$%TZUk„«Á:ú$0ñOtk° °JÁlãÆÖf‡qDz vÿ£,.d1¢A2ÛѨñ§|j¨Æœ4Cwª"†jœk‘¨é*¨ñ`®kœäxÛƒ@ãõª3Ô!åÅ>¥¯cQ¦­ñ)‹xó5Jë)úÐ1+€R©•ùö”* Nh™k@«±`dZþé:X$o©’~J˜ƒTò]RvËõÊ¢¦]¢\OQEâ©Ø È –8ëni‚|5r¢P µŒº‘ñ §‡J´Æé¹OË>æµéÊ"{Çg5„Ì£ªH6õc/¹9+.J"Oçi$뙂éâ#¾ÂSïön秪Ŏè±aêg[À¡é@•S·¥ZÔJ+„ ÿ×óOqV#E‘#7QRÒZ„1R¶ Ëð€Ë2¤Á¹¨B«§ŠÓºuxºjIɵ†R¨k‘§€œ3f>âô‘,•3S4µŒ‚í44"í„CÂŒ±¦ã]ò¸Bp<›E pÐ$·vZà“ì8 zU¥±—P± DoóáŸKÈÃSB 4_ãZOY Á õéM1ËÕ7²€À ¿ËFí!nÁ´û˧£û¿ƒ:9* Œœlœ‹Ê¨Èá¹'§t>rØHk1"ÒIÇ×—2„ PM1Dì± J’¦‘nJr\ò)—ÿw3Q1]PQ5;€î×@á eÞ[e 6ÉfUP‰EûÈFwFöAkûòeC%V5…,?¡2€9?–À22oÖ ©ÀVm§!ãnÆ×w*g‘§«ñ@ÌŸ»"{JÆLk¨ŒÊÌ ÁÌìŠIm!4áS[[»x"Š©1е|6‡ìÃÁ4*!¡d:r/'±‚dQ1sF²i÷Á_¨U±DÉ Û»Dš­úeMÉZ5ãü””—ñ@œ±ŒÓ*ö0þ¢° —#÷Up¶š¢¹}†Wu´{W|¹Ù)îvhA{^_,´MÛ¨|JÌA«Òê´#ÝÆ±†×±íÿ"EÐ79r|r”z—#©y|rh9AO‹°G4!OMq'aDùà;*j «K¢V·^Dɳ´K> KÀP;U”Ü“P6™¼Ä¼Uœúð/1Á/U$w.A+£ ²r+‘#Å6BÅã€ó gÒATAã‘e>jÌ&]IT»‡©Øé„Ʀ;´æ²Ø™´N2¥‡8Íà“ÈQû²gW“S·] nÀ°/hû)1Îz<¸Tô±F¼4ºÄPøœÕ¬ZYÍJ©P иe`W6ÃÎ; RVÊÁ‘Öªµ™«ãŸgÆ&ʲÍ‚×É㩼 Ͱ ËÿÖËÞu3:ц}ÌÇ\ÆêÊ®×aμ">sºìÚÆq¹2ØñXˆõÖ¦H‡ã¢Š¥&txŒ5¥q¶ˆáû$P¸_ n¼çW;µ±ò8\f±`ĪW†yLÉPô9`SÖN@ó±FõÑ=þ9¯#Œ q} ¹2úÀ+©3±B×zÅv„G{9-:«"Ä,N?›ÒÅüÅêÒJ;Ìž«´ëäƒ]çÅ%8S,ÚÙÍh‡XËMÓiç¥Bѯ£‹H Nö˜vKÀ`á³Ó·ÿfo´âq.“DKÒP‹Ø~äÑØêºÒÙ µŠãÌÛ%Ú$‘u#ÒhXVÎHh3u<ÀÏg>û²ÀfQÂ+ÐFœE—*QÉ?òsÎUX†eNÇŸѰð7[½±Do†~=ÿ)P³#Ÿz‹@!û0WóâÇ&1dÈiÒ1€´a£ÀvÏð îþÑìc ¿¸ÒEÙÉœÌ1ºŒ*NÈlÆäz¨TÖf>)7ªO~—ï*ÚM Á~yræ3}ßñŸb:i6XZo±U”|rÞo>[ÈnUž „Ë›‰—á//KÛP; 6Rbâj$ãqŧOÀÚ/¹r&Aõ¾Ç¢vËð [Ñ6>^ùRTÌ3íÒF¾(zjÌK›¨¦«ÒG[ûˆFm$S6¢>9•ÓW[ÇÏÉ¢Öá¥sù3¹@3!À@´3%Õ°vÛu^òzjQššÜì`½¼2ÿ¥X=Ã-PÖyë·ZÝ‘8ç01§"@ Þ'Aw¨³ †a ÈV¡_/¶ah©úø!â÷O_¼ƒüøÅ[ØðßCˆÿF„˜/Ä‹ÿòý[¨‘cÄ3NŒ8pàGŽúPRdI± ¿ !7rÌ2f~3s¦ü·@È ”„ŒúÁ¿ˆ2:!Ï©<Käý#ñÞ½–,1`Å@€Ö#÷¼>  *Vˆ÷0L=;õ_ ypãþ›wâmS§ÿ°ÆGž={ôê² ;ÏÝü }`4ïÇB<–ÀO…†þ!¢@á…~XÀW ײeÏþú¤Âà 4BDPåÿGË u'Ôí0¤nŒ-”h°øÅÛà9C¥›MD©£å‚Yn,_È1a‚Ÿé"AŸ”(XÀ1B+¥š³ˆú/¬×ªÚ[î «÷Õ±þ1‹ªÚê+½òÛkžyþ‰«…¾þ¡çiA®‡N ‡‘ôð„yäap©^ÛðŸæad‚Ç2«-3=3„‚VDÃg”Q€¹F5`~ À *Ч¥†¤Î „®ë-‹êM"'g"ޤÛâAh",Ezˆ¹ˆ¢ã¨È—IN?—ÂcN¼ëdR¨¼’ôñi ð9ê†Vþ‘à¡F\âŸX¸ª@Õïž#äéï¿ÉzÿˆÀ‡DK,¯îq  á¡ÉBДÁ¸âú+Áêjá¡§<Ä«‚É$ÈçEDdãL³ÎZùGd€YæŸg®Á‡‚Ø`ƒÑ8• ¨#Š–l<–ŒÝ¥DÚ9š0úºÍ²EéØ2K‚hMbŽ»›˜³'»ˆ¢å‡Jþ¡`£0óò1zøtKBñ 4?2Ýꢪ³ôŠJCP/ý`¦|îÌ'Ŧèú˯S*Ty@ü‡ílDƒ¤ÍNÈÂÒ]Ð,È¢k–ùÕ×TÖÇ“FxH¥‹^RvÉæœ<¨J㊋(Épþç·.¿³[2Ç}(»ÄBÚÿIÝïvZ nX‘"pw1 4e$F>æ«üÊÒ—¢ü¦B-~ÿá@`» àÁ‡°B ¢©ZñÓ‡o&ö±—ð0>3†hÔ¦Xh#ùFJ|‘ÇÒ~ˆE f´5WÔb^í†ØjÖl3}¼|Hg£³âÍ".šö |LH2££§Ôº€Œ¾kɲ#]ÿV'6 * fbZ:ëî¾í.§Xá¡âœÅ´aê¡ÿ0ÐF!êj,±¶º*@Šîð*ëî»SÁéÑôaƒ¼3ÉcéCˆHîTnyˆŠþQ»4èa8«À&ä¹L@MŽb¶Œkc­@BÊ2cÿˆÖD)è"ÓGÆ$ Ð#&¸r”B+É9 aÖINÒníŒLÑ¢ s–·‘Äd-2ËË?F ”¬Àk˜™€‡*„IŠmm”Á¨‚0„‰åU© £òf7»ýé,€›Š¤!‘å#­Atn&P1Èu¡ E󨜪R, ãcؘ¥¬(2¡Í?ð¡«-¸øAêÂcC€°HÑì´Ã³… M93‰ S¸´ídD'#É“Š3&ì@¤XÃÛ §æåM͇Â3SIØ„”\ï  a@Ô”E?+Ÿ$±X‘_Œb”üЂ¯«Ür|ª—¦"£F6ÿÊKLú ×àîb± YÈAyi܈˜¹Âô‰Aè¼ÓŒDÃ]=ã2ûÍJô ˆ „Fü™JÉ4P¤…LBÚ'ÿÐç­væ™E"&W*ô–Ïâ’Õ˜sµå]”)Jj“= @À.jÛ˜ƒ®Lƒ…_YüáÆE/rñoÐDK8‹UóšÑGëV° ´±§ó +%Áµ ‚‹ åôX©–tl`'gÞ™£¤f£ø&ž|j&9ˆÐ™ñXÂ3â I"U‚¡FêÞ5ÔvÏÊ’³TI4 j²„ _ay“¬Á2k/ÙYmV'C}Œ*:Á¿NJ(ûHÿ¦2Ý EØ?dz‘€SigÿÑÙ EE‡‰Âô èã§HÉÖþø¡Qµ@0õjÐH+æ Au¤æ\ìWƒä[òe<ªg‚ôHé<"ÈN@ô܉xg"0œ–yRxKS:+#*ñaCÏQU¾R °×¹½×¤fÔã©eÞŹÈc-|ÄåÊè§°<6QTQËßÂò¯¯pѲ÷‚HSàr¡…ùÅš‘‘Œ>ît™P"«ÁPAå?IHœŠmÂÈ'ú@ÅT”:gD§XGºÒê¯.:"Ùp„Ññ?jÌ;èf2†a’î6WåôYŸ¤Ö–Ì㥖°¡:ÿ¡‰¸pÓJî\M½Ìz¤>D§ÓBÀ),(ƒ(·„#€Ù`ÿ‘›Zй•i‘¿óÛŸpú>ñIqoUKøw\O¯˜ð *œ{€ê!²õŸÿPDpjë¥T7>2‚Šsu‡ôÈ/®ŒtX—­ˆÀ…þTë3bÐ+ñÎJÔMðºÝf ¤X$DWy¤¬5ÈôuKå"o“UÙ:¯%%’!€…k(´ˆ|NÑo2ûæX2ÿ-"q9ä*Õ—EèR(Ú¶B"á¼b¯øé6ãØ—zÕqÛ݆@¨N°Ôy€ìŽ" ÈJ9Ît棅0âù`üÊ5¯QJÿzWêìx@ÉÅêävy¬Ú©wFûd S(µó–é6MNA˜\hy”!‰¥,qrÑXªKH+X@jÓD,æ(å&E½Ð>hÙbÕL*À‰/"Gõ‹„Š~h„€Ú‹ˆØø,aJˆ»Üܼ°ºŒ)ѶA“;ÕR´±Ù[Eø f‚; ÒÍ“54KìÀ œ^© –WÈS+ñX”(xÏ“äŠ,9"â Ib Â%0çTNïF*°‚Ð\ï!ø‘òTó©0›P…ÂWpnfgçœTÕ–385,¡Èhj2¥Ìm¬ìíW@„ÏOˆ Š¤¨QSéF³ÿÎ*ªAð¶÷»E¤XÇT€ѹÁhðAºk¬"²i Y;%ý,„vikà펤ᘲ­q]ë¦ø">ë•Ô[ó–æx« QMR[#"àšž´Nˆ°ü|2_¨?™6ÿˆˆüº—Šy³jÒ©K™ ¤3x@É›¼W „¨‹J7 \€v¡À°=?ë)‰ë)ˆh‘C»™œÉ0‘4ÚÀŒh…£È‘]…Ð "ÙŒ`¡Ž‚’¸Ê±Ý¸ s!ˆS¡¸Ú¾ŠsSâ’Yó.& ¯g¡5(£%¿*—À"¹œX:D`9 €Ì “à?Uéú ÇZ ÀA¦ [˜»à½Ñ‚ ÿ‡y ˆQ¨<“½vñ=ã@±‰€ ü¶hˆø)@äšÚÐþa@b›­JѹwÛ­©ú€A®}û‡Z@†fتV`»/± óƒˆk%[ ãØˆís!ˆé$õ›–™€«àÉ¿Ë ­Q?¿ª5# 9ê±Bð’° V¨“‡ø‘È`9Â`¶ð‘€Y³«PÃ:J·ÔüQ#–x@Õ’<–ëÃð‡Ð³xÛ›À ìÃslô ÛŸ¥ ´¢»X*y §ˆH °Á á7`XÐ ˜È+b"kÅd9¨êJ!Ò!)q!¤‰~:+‡b¥["¬W¢²ö›žŒràŽ©¡ ÿ£ÐEHŒŒ 0¶y¨¹Á0(ê›–"Iƒá lcCgœ(À{r‹=ˆ½ë!·P…–ãÆ ÄC?Ç:Ì%¤¨0›˜CK›Jé“šŠ <Ú@„]¬«ÇµÃ‰#i’øD”0Eå¸ Ú2{¸¢ÑàiëÐ+–9èy?ùƒ%ø«‰˜ð ç)™ ïˆØ ¨“Î ¸€É`ª¢#+#ó!É : IÇÄÓ:¡ 󳌈(Š˜üUÈFUˆ= ”L>l—<¤@rLŠÍxškrÃK±¯ Æ–  Cðš‡H…CªG—‹±}¨±€ò€Ú$“ž5r‹ ¨?ÿOd’ôKHã,ˬ@UeIHýP„ Â|àJíSÂ"(à9WTðˆ%‰tæ©G-{ˆ‰èyš8—ÃX¼‰*}íþᇰ±KÊ£‘€“ùHú½6º)°ÙzÇgI-ŠàQµÿøÉ{I¤ 7Z…ÏÏ·va9˜ÌÏÉëÀkœÀ\Š@tCL¹6•ŒˆKɲsÓi•ԑΪ„;íˆT£á’šè$åDÂÚ¡’3WZJÅI­QKͨZ¢HPª€Ã0—×0—õÙÃ[ZÆ{¨Ñ¥¹TÈ@JèT ºø˜´72¹ºù›””TŽz–Å|Õ6JŠP‰Œ•½ˆÖ>Œ0Ÿ„ÏÚã@аCl¤À {…V¸ÛÓº^>2aŒ –ЫVÉŽq! †h«üG„<<$<×>Õ ò¡®¥ˆ«ÚKWIÁ®}Ý«}ƹT«„Ƈ›ÈÝР¼²á¥xC¶ÿ° ©´x¦QAG‘ šXe-¾¥ˆ¨ÌY¥\ 7›7UÀÏ>ÜI÷( – · ƒ#û™ÿ鶇¨ÈøîdÊëhؑՠ#û%Ñ$ìܬuŽ-¹W³_–8Œ­õÚ­‰ÓMNŠX]Ä“]æp{P–¨¨÷»Ô5òJ° Xï46›ó’” ©ÑA6!DÆ\ÞX}Ï÷üRÙÃUÿtIþÕ¬Ö–ÐUƒ@^ß…¨‚ˆK13 öm†ˆ>`Qü¥·|Ñ=`þMâ%ÿUžÝ¬`2q‚¥q( â`àv וÔÀ™®™`!ˆ€²‰Üy¸ÿÿø“‘ÌÔ³ŸÀ¸@‹nÁåõ(ÇD Y5aøÜ\âÆÊ¼žëÞ_\2ÑOïå&8j\D‹vjAÈk hßfð•À\YTbMÞd.^àOdàÖ%`ÙÍâˆxb¦'nR>ŒS>Œ¿Mµõ˜¹Á—ùнPþP‹IÒÉp˹'µãè°X÷ìÞÛ‹=q{ˆÈlf›´ÃBÎ íe‰È¬°²#Æe ùN;ñ)*ÉK€†öÅ…ˬÀTM†‚€‚Mn )¦'ŽgV®eíàå‡P` ÞCå,öçe @åzñûÛ ã(SýªØ»Ð€¾H›ÿjJ™æÄ'a¾ãÍx@Ì0f¾}LrVʤҞi;Ç$~… "Äm£áPÁ“ÐÑ@Y¾Û\p_xh`æê¬($ngŸþäwf‰S†‚¶çˆè£æePe£&jÖˆeÀP£`¹–Ó-Û¢ÈòÎsêÅyåñ 5Ò¡ˆ¨°Š%a=†Q£®Rjü©gŽºìíÜ\ SÉ`Yø*|Ê'£‚¨\øÐ^Èé"˜ã¥U(Pgvþi®%eÆþÄtÃgŽê¢–|._¨~¥¦‡f ¨~YÙååK­–C„ hž³ªx ŽW­ÉàŸ™x˜5ºma:6RŠÜí½¥[ÿ7z@|L’e ¸Y>aÑf;A.Ì cYö_H!'ø…p¦KjÙõb"Vb-vì|~ìˆÐ€Éoðþi^6h ÂjyðŠ`ʘ ñ‹tû‹@£]ó¨cö,æ³f­9lÞŸ„Òžë(a îpëRˆ(n>D鞨0”Á'׌]ìëKˆˆ_hƒl!à…©åzÖì öé×(På,fj¨VWeOjËþ xñ–ˆðnjφˆÌ~lPþ 5z‘ˆ¯¯@A›¢ãù>^¥SZƒpíĵÓëyòPl‘$4kÊlRkÖÒ@?4n.—eíMïArð^4 Š „ ÿ‡ÿ^H¡6è…p.‚-þ‡6Xjìfl9ïâ×ìwñ‡€j hƒ;j{–ñˆ;‡jAG=í8ôM¾q÷îÏžêÊ93„€›±<ÉðßLÿ€U…ű&ë.Õ ²ØŠ•Ƭ«áC̈‚[R­_˜Ãk|ˆ 0î¸ Dp ü)³íÕq'|øìtÓ œð Wå_lOˆ]¡.ï,®gñvq(ñ8'ñŶg0?hñÞvçs=·qï†BtC¿sÿvRæeûy|¢`•¢°—£eÏIÒkÚ5ÊwÈhÉÞïMƒ(MÀ‰­!ßW­Ò‡¸Þ¼!0n3O1[ÿIÿç—+ \À…Qðk¹¾„ ï…^€sìKðÚî~j‡gv•Ïì•Gqv9Wù=gà—?ñÌ^j¨6?å?wÍöù¬wfÏ⯑ ! ªÔ aÀ!hËz€ 6ÓZ£\ D2ÀŽòhs 9Nò‡€Òë™C—›÷ëpÄN>LЉ¯øù\X¤ã†Ï3ï… ?vì46ðä.¦ù=ïi‡s^ì¨öóz6qvvvg‡vFü‡ˆöÌ6†k‡6~ñ'tˆF'e>7÷¡‡g›_vz°Œ;¡à÷¨‘†f†½| cå)õ[R;Î ÿ®a-;Ž#ä°àS?<ëíWÖ“¦u†‡ø „û°R_Ò`·p{ˆˆ gó ßÚ­¥qŠÈó.Þs˜çs{ño|ÅÏsÁWq˜7†ÎæåmýŸ'úgöÒ'杻ÿTÐûGÏ^¾|ˆ"ùGáŸ!À€ ‹0„¢!ˆ}ñ!ß¿|þ}Ð'0¤É”'WŠ!‘É|!BЛעÅJ#ÿéiòŸK 'E¬8ùÊG.5¼tÒÂ?¦”|¬€ùÏÃVF •Ò¥°+{õrѦ×%h½4ØSqJmNª€âVàÜP4ìý§A…Û½{Uh8É÷/ßœ‚éÿ#LWâ‚óÜÞ½[ð¯asrîìù³@Çn ôû/†@{FˆððŸ0a[µz¸¢Ç;yžÔ·3ŸU *0áÌ•ÿ !\ßOž&»lù¯¨À£”¢.Ò4ª¥ÿTÝ8„µ`ÿp}u*­û^ÿÚüJ[$„=ºïžœ+—°]|ýEcÆ8fˆáåX\†–WNÄUe'TPe!6šf\¶h!z–`e®tHÿ,DÛ?øÈÿhU›¿­”PH;™Ä>üœ„ˆ@AAwR>¹Œ”ŽÃ—Pùôd¤>¹H0dKØýC –à äÞ–BPBFµÿ0Ðà“Ô+„õÊ?ò½÷Ï/¹¤uI<ö B~P̘^ ®tX d×@‹ Zš^ùù߈*3=üÑu¡i„ÉePgˆ‘&"§ŠZš i.G’rŒùJ-±y£WIùöÑj!ñv\OÁñ$\qÃA7¤’!E¡ÓrQtÔ‘HÅ*÷tUf÷J–N5´%T|¹Ei•Þ?BDЊu¿ôòÊ·+y›–"€”a†¡ V×_m,¶`†¡&ÎWX ¡ ô(f¡¹ÕÀxJŠ‚–FJa¤*¼¡Ÿ÷û=öxäPQ ©Z‹±Yàjs‡¬t·F§kÆ‘rŽ2t¬OA)ÿ“sNVY”v1åÔ%KY0í ãý¸´ØšK¹¸ðæ–òÕEä“_~‰*¦]ufW†zZW\þ7i¤HÔœµeö¤ÿEŠ!ˆ jé„ÿmȰcæGGˆÜÖ T© SËDÔ“n))+’Iž ”K؉€Èã"Ĥ²Aó(Ò°úL©ä15— •+`‡eÎ9'­'Ý¢záq«ÏÑ.ä§|—¸Iî üðueöh­ïïV ü ðr6€tЍ¾uNuÙÓ` +ÌÜÙG !Á'Æ)²˜ ´©ª' + ¡ùJ©ö‘j)*®dKúÕ8ãV4ÿSM-Ѓ·rjbËyV)sãDçNNÑÙ%°D YÿP.´µM .øE›Þ³´¨ôd$øÇ Q˜“ÚÉNH §ü°°ÃS e80(À%zË;›óðô™é-hO""¤’ø) 9l`j3Ø¥ B„hŽs|³@Æš›Ú "8 #±™|Q5ª9ýN‚Ñ=nr4™‡dZ0yäòhAæaÍ4GV³"Ê?¨t'gÛYÀV'\¨gÚ¢„ÊÒŸ¢eKи’çNˆ|€“)< BZhÃÔtÊ…9Þ ·’€Alx|²`–°ÏXÆÿ/ÒÏ× Ø ÿüå`w)L¤ B+ M3þÆ¢èñ'˜Ç ¢©ÇšàMbù­S,àEÎG”s“DŽò #äñ‚™ÌceÌÒJV Š+mG<¡„ΰ|VpêiÑÎVP„^ðâgq£"h\Cˆ0?>â#"åÇFù¤ wW€îN…£„Ø'eÃÎD̆z:¦Ì&—¶Ôe3^k[gê–¶ƒy†z‚^^æÒƒ D1ª€‘ÌZ¼b€€3WrN:ÒÑ™€ãf~•û©( HyÚ¨²þ Ðr-¸£<ìh¹Þ4®•§•¶¥d+gÿÿÖÏ ’­Q0^™Š*Ü4Ÿ_PòlbhEàÑT …-¬ ‹+ÎL´(<¬HøaXÝDt¢D*@awsêçlBbÃ2¼?ñŽØkWN¬gÚ°)ÊN@–!ôa*‰PDFCÈcSéxÜc·å|æ3yz9'¹ J ü™7¥“œ‚ào¾±É þÝ‚è;©£Šu¹’îpgK9 >,ø¢ðP"¯xá+ÒþÁPhPâ¡#ãÇaáKXÉV@²'ñÑDw’Âþƒ¾öˆ}óYÌæ¾#qlpt» ¥«<)„ò³)ZžH´Ñ¥Ö†Ä(v¯{mˆõ1„V óo¯ÿšÊÛÿƒ©t<Nœ Gˆ ˜s"0ë®ôUˆ:2ù_;áè$}Ðäñ $’ÿaÖ"Ì3u` ´Üª|J‹áJ]wæ7Ñ'ãúë5 a×TðíÑO*Ð# õHÍjæ çt§2[–7ð¼¯cû;çþ:V±ºË3*AÉŸW1.—âpNP£¯Ô¸CþÁ‚ÔË·}ÏR¡)HÄ8'&‰$sÌ<˜£<°Ûs¶ÆÎÄI XðÛHÌ'ÅMòT(ÁF‡à&˜*àrB`j d<ÊYUáä¨l@gmmÊW(‘| ké”'êõ’Y€! qg]åzžÙ6?ÿ D”YIl®ïIÔ\çç ±ÝwÛÏA8´aZ*ZŠtñωæc`ê›3ÖP£„ ÈÖZp²ÔàDíŒ&c,!>*ÂU‡í×äò$ oÄÛÊV9`§A(URç”A¶5[Pá\²ºQX`Âp9”•¶p½â’Â8ÓkFð#n{û$=Ûögº’ݳO¥4$UfÒ²ô*®ÿ´ãY=û)"n€to‹žŸê_&m?+"iƒ?Ëèä-ûákS ö FÃö Ý4ƒ‘#"ccæ\0þ#ŒÎŒæ Î)¦.á2Ž%U¼Â›-1—Ê**a!°ðŒSãq¯´¶"›)r5ävö 4gÿßwõAÞ®¨0­‚ÿøÁ `„éq†è ÜÀ€–ÞÀ Ñ©ˆøôLÂæDŠÞO‘”ÀxV~à ¦áÛ‚j]¢Ù‰h˜†M J/ ß”0„ $œ…À];Ä3IܨÝCÈQ$˜ (“1ß]‡ßõÌôQ~4 ¯äDPhÿŸZE™x@ų@EÅÕ $…‹È{D@Q¨—t_WøÕ˽ÜI¼ÆJ<V„^èuÆZ ŠôÌC Ü?( :`è™av8˜¤LJý˼EÏÃ@O£MJÁ@š¨lX ÓÀ8G1D+ _;¥ÔÉp-USùÖ9i@Dtð ,þqßuy“ß! ~x„sŒÄÈx°å]¬qÎ8>…²mÇmÈ•‹¨‡¬ìx!gp^Røß¾þ”~žé-c6cg$ãO™á:ÄéÝ4ž’À¼Ðg9!Ú¦¥Tˆ¢gÀ”±M£ Ú‰TtMH¢åôñVoí=Nß6ÿÇTE8™v(Þ¯­€äa>4É?üJ+¾Úu4Y³\É1¤±—l‹¦‚ ƒ CUˆ0lD›øß˜ÊJÀ!Â!3šá¾áHŠ\bD†‰@$J]) Qjø–†…Ož£M˜‡¨@ ˆ=|€Þh ò!UN¸oa8¥¨a€&úOAÊLøU)›ì˜è¤¸@OôÄIÄÎÈ4Ž*›Zm‡”’[ ÁÍ‘×=%E³ÉÆ3lÑöqÉI@C3¼ ü€Ñ`vÆI~5>ÄKºäL^àªäÊaL*ÌH|*E·Õž ’ÒfP]¼HJ¤TF¤Ä€† ÿ%•Ä „‡äQ©©˜jÊðÀIHÜ<4I>—F×Q`å+Ì“<ñ˜W‚%ìüttÉ$™wA™wql4ÄË…GùĆ@Ô%0L^ã„0„Ù‰ [] 4 `ÉC̤& aÆa3&#x:#:¦gT@ T@ÔiVÑQJ~Ä€ó`X}Òjè§A€¦~"‘~Öçièç%„" _R-AX4IŸTöÖôÅXA(¡Yn–¨Uꛜåu|ìðÄÑg•Ì÷©¥Z9Ë=¡[ªÊÁÆÍÝœz4ƒtR!å„<4¬€Oý> ƒÝ€_Šg‚Ük¸¤Æÿd#·Ádx‚çÞ¡ÂØ|Ò¤MN=€æIÄ@1¦léeh†}†h‚¦PÄ™¨QŠÀú!BòµÝM\AH_ƒÞQlÂQ'Ö¦K…p¨Q\ו„"Þ?€%XžÍSZæ„[­œéƒ^®ÄD2œD3,Ã3ìåIø€{,EŒª>´>Ã(üÀƈvþ”‘² ©C ^“¾jx©c*éÎjº¡  Vdæ–v#؃ó­D 0ÇPÒ˜Úg* „ó&#œé±ö'¢ÆðaQ‚ÚàRÙÑ?À4±@j¢9ñmÚOovŸâý©VþéŸî&ÉêI€ÿP6Ù+àå •ršCmêÁýÓJÔ(X¨\Š^R/ÚêÍŒ ü@*XPŒäÄ«žD¶Ul·9DÞÙ¶µjg¸jˆ|„cMa‘D|€c¡¬|‚†nT”ë\«fë— D™niÍ:ßfÌC ÀQÏ"k½5_IP¬@òéÄëŒMâŒÓ; ArèdÇn¼bå(¡Y…$”’u¡Ž…­{4ÞR¨UDÕ¦bêD4ƒ/Ü?pêT@$%4\µ€§ÊÈSøÂ?ÔÂ"ë DnNn±©Ê–É +±~FD¥ìÉžle¡ìûœ˜ Ä—"+>ë´rió}ÿî<Ã2°-óúÂ3H'>DÞuEC´cÔˆcù À€@-pÆ A\Àùþúú”@¸^àîáz†äÊ’„°æDä.¥|F®MÍFM™Mµ6j\nJ->ké~nñùÀÌCÌ>ý›Ü%ÜmÍüiZ2§^ ‡REˆ˜•‰ö#ã©¥w•ÎÎ@…¤Ò¨¦þÃ2,Ã?´- ?Å>]B3…Ðäà $#”À?¨Ú?A=€@*ÿÄ2Ô Aw#@.ÉþÃü „°oÑù”‚OeÛ”BžaqÈR1Gnâ¦[ºi~L€=LÀ7r#ÐîJ€)#Ì1gôì÷ìi´SI¬Ÿ>í«ýO4Õé?”šS¥Fx¢Y²IÜ.ž_­UêÌ“’ݘ’]²@,ÙYºk–tW¶@dÙúëô®ÄóÒp w…ÕêðŠ€ò­Dk¾€+ÔÃIð-2¤Ây Á#°@L±ýþƒ/_ÏLÀöv¯“1±büâoOIã.Ýj˜ ­Ì^X²ž†ƒ6_èÖq‡«A|€@bòAò#ÇŵM8Ì’vlåZAÿ³ì&Z Éå„<íX’Ajw1gò¶°0Ш)ó-0Ìp]fË>E²°­@>Ø Ì©ÿ-ÿCóm- +,“,#s0?sÑMÀ0—4I“ì2ÝǶ/±îö’Ddš,1ËHðrgĬMË1æîtèö´¢}€!,{\±F• JSŒA=œ+(ÅLˆŠN=c(³À+‡Z²@ñ˜q\åI\墿æSáI8=Iá@'´ „ ×å5ú GÌ‘@<Á ÀÔÃyÄøþ24ñ-<17ß1Råt§ð²Gs4/;–‹1·‰tºE‡æÄVó„OmoLÓ40#kÌNð3ÿ¯Ä6cî`÷´MÏI·Bi‚u ÂØ™–A0Hp0£&¯<ßèŽùæ‡u$ä>/Ð'»Ç³4äJHj)+1 kÑÁ5ƒˆŽV»ŒDSµæ?@Àüƒ+œÄÄ Ä¸ pÆ-œÄ-€i0ƒF;]. œw¸ò<ñg[lÆ|wc .VŒ?Ê*Vô·fMÉr¶ÐðNç„7ö?1˜Ò."Ü\Ætn(‡7ÒCR³0)G'& Q€!%@²<ŸÄYþ£qÀNKpÐá™Õ޹k wÉId¨ã1¯YËp3L2Cõ"LžXÒCDÿR]·F'€@\ÿ´EùDçÄx.#„7§±1•ŸD œÀ’ãïÓ] ®g›2;ÖöêÃb÷÷üÎYŠ#ÔôH8˜®ìåNñ<49ì6oó 3‚RJ@z@ÃD„Ǥ99r~(¡º®€vøUñv£îæYvKt‰m^?£¥Z2Þ³\ÉÂèÁ=oÊÕ=ùbgðC°À=Hå?ð€+̲@TtËp_ÀüÃÜ ÜÂD 1 @9 a/9_Ï ”[¶•¬Ò=b³t|ç÷àJ?̯e›yûF*éÆšð0¯ùGóò ŸD‚Ëq‚‡¶@ 6«ÝEBÄ D¦ÄY:nFK ätôÿ©ÁYXR0K†¢h‹W2@êJ’€Ä;«’å«£Š2=ezx|ÅÏÒ ,êôˆL@;ñÀ~ÅW¼‘ùJð­@€|þ7‰ $þœp ‰[ aÁðHÁ{ÿ"Jdxã?Dÿ*lôX‘!DŠÔgHŸ„ (-±b…U0S~˜Àq„ 9'0bÂ'£B‡„ÀQÏŒE3N€Àˆ®kÿ€ý³Ð*׿!òE±gÏÿIˆôè9¡÷¯®Kù¸þÓSÕ«r_½¢t÷nÁW>ö^áö_”ÀùþåsñOÄ_3UýóAéß%È”,\„lµ²ÊÿîF€ìc܈þÕj”Ç¿ KÿÕ+˜ê2†µÈxkà¿…/à6HPwÁ—`¼wùñ¥"5¢À¼ ¡ •üW;¢ ¸„¸\¬ üŠTóTùý¡?™æ,(Té¿§F›^œA¾fÐ R"A¶¼ Á { jƒ¸Dˆ"Ä L}^íŸÆþùe…Åö¯1˜ƒ)1}òaˉ(ò‰Ð…Äþ <Ç.º¤²Ê.‹,2 (û'A{åÿ˜ 0#òrJm\chˆ’ü¶‚–ñ基e¡„è– Z­ Wê–z¨¢Œ&:âå4):ÖJÂN$’J’ ‚k®BEg!Î .P)$D‘ =Ÿ´2ô½› bä(†æQ)¢ ˜´\„ùçR rÑ'Á 2ˉ±Ú((!„pA0®NLÌCÒR"ÂÄH{ÉBÄ"ìêŸQLì— UyŒ¡Khv3«ú›²"ðHÒø!õƒRcȵ%[;2J&1BB!…‚›ò? ºÒpƒ»ˆ‡Ê´ˆ¢2¡ch†¤›·‚ê¦C¤’ôADˆkpñ!Â^Q%Ä|ýàÿ†"€‰a}¶ŠÖ§›”j´(õ ¢ç¦¤ŠrЍ¤ 0\Œ}%É¢- A² «…´Ö:+„N#Dì%r‰¹…Æ aÓ‚z½ˆBDÄ5«™%,ˆB`1²‘3Ïd,ȳ¨}øg©›-¨†œ:*Éj±½(@(¨–‚ ¬íԾɕ‹²ü8.ã+a8ŒÈ\"¢‰ä)s£‹ú)»’•Ž<{qfN7uA`¡µ’àSCc˜&ô9k¨ž&˜G>­Í5(Ñö͉NaF)¨•rù@°°@µ§, к„Ìa>1V¡õ¹9Š(rñ½ Ædv¦ ÝQ0Â\Ðç°—hzÆ‹6£Äÿ3!ól‚P%4Çhâ'~¢5÷(#Á.ÈÚ°j2¶\¡8HèËùÅ-Lá*(Ý&ba"ÍÉC(¯æH” n€ éc¦ZA§ºÂ¼åˆ0† ., ´^Dùx˜ÆNóŒ$…=#!Rä X@38úËø¾b°ˆTüŒíè³MIèÊÊ…\PD ý….=šÍŽ˜ME)Õ\=†ä(#Ô»ËxÔ£ìD L´œòÔ|­5ÖbˆúÄö_,ƒIHÐÍpêvE]‰\áRT¹þQ·‡P¤8Yk²6@{Q uˆXÁÅ#(Júÿ KYLÔôˆ X§vU°˜Å\ðњŮ9ÁO+"`!bu& B0ª±h€-˜dAr6²p…y9Leu†Ä…Y.ˆ>H%˜‘a¿Zâ¡v-bqÉÊÞözD5Dm€xÐÕˆW´m6°)ÛÙ²á¤M77ÑÒjzcÝ0¤¼HDðÆšëp#Ò‰€©"ðM˜€fúx¤V…\þ—½ËòÑ}Ìc<ëJ/FØdc'Ô#(1’±EuN¬¼ "XwÃ]Ì–ÿht@yälg¸[ž1yE« u3™¥#CFd¢#Š`ŠTSEÿ޲™‘ê1ä‹-i‰ÕÖ7B}.5æ+ˆkÂv¤zÔÃ6³a”¢´›0¹³[iã£ç rOt± ]úôÛuþÆF@*¸ðÎbøò’¨giAþ ³E„Z¹)=Úà'À ùp¬X@iõX̤¬A¡A$ƨy\à…H¨Éþa(„j,¡éYš@^ê¬ÄàN4ýô]êÑš Ì}!m&̺‹–¥½WDj—YÖ²º×½FkZÔ:_‚΋”l 8EèÆ‚³Âs\q[onrVºýCŸÅ¡ÈCÞå¦üãwJ(«`‚˜*’'itÑœà‚ <–ÿ 3Ös¥ýhè6»ÂÌ]Ds(TÔ¤&€ˆQ€™!ËX6Œšúïòhmäb™æªS¾cfŠã¡Û2$hº»H´|;¡ Um‘|‰“5©fÈT[¤xNƒž‚DןIÖVAdƒ„Ü¢"¡Û= ’“+©7n½ˆ…óÇ¿ÕU^Q¹4Á³©ˆ™$ŒÎk X¿ˆ¸ærfŒÂž¥,ËY%áRj¤fŠå#MŠ`+¹JPð|‘þ¶ ­,/BOˆ§JöPˆfÖL{ŒHB£a€ö\ÄÅDà¸?vÌry„ên2ºæ¬’ÑÈšŒí"© Ò Ì‚ÿwþ‘ ¡R[!œ¹[pnËþl¯¼ ±\èu+‘5Œ Vu— Ò£ '€mÎú‹CýF#£ÂÜì‘ÙD ³¦Ôœ ñ÷|àÔˆ`ËKEuçþúWÛ°­ôÅØÒ©ÀôìCñ+Ò^‘=Ê 0„Ñ30Yå¢Ñ|.\Ì^KVÛ©ú‹s·S¦uÆŒØÉJZ#“°û$–‰J>¹E°Å›(µÞ†!r•˜ÿ‰Ä1º,µ¤\’ÿ£ÀÙ&ì=B€ˆgýÒ„Å©Îð¬žríЖzFT ,€¥{¾ÈYp)»‹y¶' ‡×Ù’«Òæx¦AÚ_£ JLGºU·òi}Œÿ Uh185Q­,â*+{Ø<5…ÈÛñkaEã‘@Ð$²n n}ä5¯‰ÝÖ+7\ ù’nô‹Ï‹0'$mÒÈ6Pf²Ì´ ` U>L¯mJ=Mò 3õV¥÷—,öxÐø†b“¤d,>Áß,èB™I–ÒÙ^¿˜LÇ>ö™ê— Æ¡Wr•!²½ áùéh(qÜÜŽfft/Ìñ>ð‹ðˆ‹ “xw|ÜÑ´b#2#âµzÛ„•˜õ‘ÂÆ¾‹ø° ×àæêÆm"­ŠæáØúè-ô6B$þf%4I’ ¢Àh*Tè! d°Dl HŒÄä!Mîá,øaÄîaÒ*í,ÿ2Š(‚¯÷€"Öª>Öã£%BãÈbßdGùd —(±ø04l0„ÊBVàW~å3ª‡¸ÀïfP¬úXÏ4(¤Y$n‘\ G¨hÈFC¨®˜ÃV‚36â¦øk¦d‡ÞJP#-ÒîÄèAhZ@@ÒôK—~)ZÜ )|oêât†Ï\&ÀÞMζ—0âçd‡ét—`GÃ4Œ0<…™î%Š`&º©xr‹{^aONãç€é›hæjί{ Æþ!u¨sæo)ŽÄ ÿáþÀÊ ÿÑ0† ÿáÚ¨ Øcƒù§ÎŠ!H mÐQQ¼¤s…QæƒÙæ%$°ã6`®4qµ~é$­Bð¦nJcëôAÄF¬ ŠCSf+ …¤@jÁH*>üì&Ƨ'Šî|Οp¨ hÊ#/µ ÃDЮg†é¨TDãh<‰Ñö sˆ± q ‘jše40ŒbªëÚfZʰ ôOÿ ñ"Ô(lº*×¢*äèÞ‰"–r)/"µd $æ%:àdádìñòQ¦:o,~©&BÛ4‘Û¸M,Áù+#MÛ4À@tO÷Э"—øÔ­”,†„Ô# GÑ:’ÿÁ‚TÏ4 ,S«´D0¢ ²Âú£g˜©Óv'*³ ²"gH0¶í,> KH€dajò"²§ôl‚ ¢Ëx 5É0ºôê5аÔhب žì‚ ‚\nÁºäGbE)@9h‘ù â-Åî—òÁ/F°hjþ+Bã¡òÍré— =ä/ÍnQð‡>"ì&ŽÞX Ù:2.Ïο JìJ«,4ì´LËDzçÂB,²bˆf,fbî!8àH%frêD>d4Ì#€Ä¹Fë$^ |Žì5ƒÒ‚²5ÚÆºZ#¬ÐÐÂj»Ð}nmlÿ@ \TE»‘Eq-¸¤ºøðóªƒFan`G)à:n ’²S¿ÊrÏ¢ÌXQßb;W Á|PÏpE„Œ #ȤX):Ks(«'<1“vÙl‡0 ";qIÛÎbe.Bþm!`AÉãf$³hrdêAÊ®‡p1ðN&I #RÇ®BCƒ`þÐÐ5Qôk<ñHÔ6À #Ô'~ IàРN§lä7¼$5 e5ä̸Õ4©¾z¤ ÎRì61,òÁqnJ:Ùô›ôô‹õÌ´.B,«„ÂÅé ÌÁm=“‚Æ a´V± âÓ Sì~ðôðìç˜ôbÿÄBà¯è¾ÐMC§4‚™ú­‡(j_d©Ä)H)ÀB PCƒE»¤Ö\ök»þáèõ'#u«ÚH Yƒ¬Xô4)`5¬+> Aà  A´4iȾÈô-sO,¸"Cª3gN¯JAã,:¯ T@,.í-X =&€÷®”…D±Ø^”rXJ¿ ¢ðì\Þ~!2óÞtFž©?D /E@Jl3qQwúMU˜I1zDí–± (]»I…PÂ6:”jÇp'[£K¨‘P_à¦6A{ÓÚÆ'£¤ب_Y£`£(Æ`B4HáêVa_‚YÄã%XjùL‹¨ÿò¡¾(g`j! ÿ‚À #æÕ^]xjÑp† âQ ‚PCôHÔ×zx)DÙÌæñ–¡€4\DBn||®S"SÔnOködªÄ ìù6±%mÒKv í6È®Ê\ì×\룔z±Nsí#ò±:ÿAìnêÄòtfÄõ{aëA‚È wHж‚ަe…44 Ax$  ¦8&ùkà]{“!\x“'Yk?™ ‡`lR¡ñŽR[üO¬Ö#ØÇ,` ,æÁfC#x!\Gþ¸õb'‰’¢ fêÑ¢¡ù£ eæWÉPÖ„Dг ‡Tñ XÛŒ/‚þ¸s²s@U73Yc~¡‹’HàŒGˆÔvŽ&{D‘úFHx#rò"¦öãÕ©/¢^?Îk´QÛ°N3™Y#Öé" ¸d"€Ýl£ Zè ó1ÁÍ?¹b@ ¤wL$Ä—3Ï’Û¢ô"Vƒ<ÿvb«a XÏÖvÔsùfV ï2àà›J0Mrú¥K,#jëÿ¸›ŒG1nE¨’Ö K˜4ŽºG€T, T#Õ6¢ú]§v“§Ú^ }( l€4‹2[z› :#Hù|VcÇÆ‡f- ÔþA•oµ[û³S¤­¨ήU@{g’1©H†à. ­ ÂWÅ~ÉèWÕM ÁGmBsLO`±9¾cZ¾;MØåÄn—.â‚&Ã4BävaÌvC‘ÖdM<Ñ©#¹Q·’©Ñºîïãò•«†²(#z½‘IÒö5Ö¶«ýi!2éB@ìp¢ÿ¡ðV Zÿì—¼¢®¿Ó”G2Ñ0ºW„‚Fã`CÇ Æ¸¤¬Ô\x<¤6s!`sÃ’L0§K°z÷f£ g>–!j C|1û€±U’v2iòA™Ö „Û˜žâk¡Zª£ºž§Zž3D1"I*ü¯ÿA¸ýi5\ùÈ')²–bé~é,œÉ˜Ž§$Ÿ¨hþ!EyDd0C· #ù£Iœ5@Ê&#Pq‘Z>-úfO ³õì‰z@?ýx‚èxZ¿ ->ä%$“·‚Æ ÏÙ#D`#ÄÃÝÂ6'cX†ñ×å63Â(¹:¸•LŽþéçA:u!$3{|Ž—-m$yKÐc¼®ÿGrˆx–gÝEp¡·q»;Ò‹¬~h~­ǹIÜi A=8ÑÈͰY&;§¹ÒBe?õÌw1¦|&t«›Μ¿÷œ=dÀ‘Úq²^€]ë¹µãY’rÖD”lÇvl™×Ö¾*Ü܇3bÃ3â½ €—ïÜ-vV¡"©%)h$Ý4¾µ®£W.â‡6ÅúvÇÞv¸„ž (\ŻɃÛ÷š÷Bús`íÐÛ=afÝ;ð/xI{Hë#+J䉘ɛkK „¿—QîÙ¨9à÷uÙØó’l“`†É|'åuQO(1¢ÖàlÙÞ·ÅP¯Ël` <‚ÆvÕ¨:Aÿ¦¨Sxæ™: 0T>yÓúÿû|ˆVà`-ÀZ´=ÜýÉ"ü;ÇI8â™ÇÂÈ ¤¦1';³“ùÔ”?å|0$•Öƒ㛎‘ýʯú¦õ»ÞÝèÆÌ—¢†_¸^­ëá÷5#Êi)ÜÞíÍ5mZ#>-0XÆí+™ÄÔSÕ Ý‰º£®ÞŸ~SRŒLÃv Ê})pžÄIÖþ$'¾;èQ7ÝÝtÝðV§õÄp*— fJ¤ð/äŽ/„ÿ⟈ÿVˆø‡0!¢‚ &$ˆèà?} !”xQ"Hà 8DèñŸë‘tõ1a½”,&h ³a­ZÿÿR!¤°¢Â¼!Bä‹2¡¾úòÍ…ÐhP„Q¢üü%„ @óåÊ÷ïjѬVõ¹°MÈ$\pø!i̲e'°œðáÂCˆn 1ÏöB œw‚ÞN½ÿZ lAϰ^¿ sésüï—ˆ¿2(p"ˆ5[N)""…¡ˆ$à}áÅ?T'äxÀAlŽ«c¶›rH½—¶S‚èÙ?Cÿ$ÔëÄžÕJ±:š)Ö«ÌæsòдYÕFßšÂ? ,)JDH¾¡\³ãÏJ˜`öùèéþû0/ozûÎþÏN9AÏTM…àTWCé#Â/ 4ÐGšý³ÿ……v^h!RZZ/h„PªÅæÚ?/pÄšjA€¸Ò?®´øn á¶ÒX0þÓân0êøÏK¼!”Êo €ðcL4‰×O,¹°PBXé3ÔtÕ…vÿ`T:E¥“Ô!$ BgýcB~9×ÜÅ•Þ}ô¥Ež|f]0æpˆTðÙ1Ò`ÿhzVeONøå—"´‚e$afm¶PDˆ@‡ÐA­öá‡&6ä@‰„Bõ ¤[Œ*áHc ½´B?& c2~4doÂÝt_v|%¥s.$„©VUUÅ\T=ñÇŸTe:ñV\F«•¸…P™û%Ä /,Õ çÿxè¡îzö}#æçqÌ(¡Ì"H¦CùÝd )¤ÿP ‚xâ5)TB†@7„>$}Ú¨­ýCÛj€ˆÒ©76TÏX>šÊ[Æ8ªšñJ±Îø*p,ùB\BZ·(QÒref>RIÅÓ¡O•ùQ´øRòÏÄI@¡¹P„“âºõžYï÷AœmUày?§µS~ýw îge¢I… ؘŠÀàCîËPÀ“B§OPJ€&Bª…KžàÞ1ÖsÁ­ŠÜ¼ÁŠP«´Ê*ão&9Ü¿Hòצ•]0sWa5šöPÕTŒ%ÕS!"D˜\àV•N€ÿfq“•›I+nB”UÄ¡ËÈÊðæõç ©€Ðb8ÕkR\Ž=yeg7TiäñãäÎ…š<ÿÔm ~Tªªó6–ƦÊú1Ž„‹ñ¬ŒdÓ?49d7ä„(±ÿ ;tL1õ”¦Tç^M‘‚Ê„¹¸‰£@È葵*À(hR}â4ò$ >i:Ë|Bœ à%?†Þ»²C(œ1es›K V>àÉQÎl˜fBÛ@@,(÷RÂè¥zÑ­§¾ô9d}î["ú¢8‡€ H0X(ð{¸°:àiÈyS”¸E;QØœO-ëüQar ÿžZ ¨6XÉ;ê‘€Ãu ²%Mí‘ÔÒòÀü0~Zñ’ã“´0X™bÔe ‚¤³] Sp«N’Üb˜#Ìm{œtH݄芑œªb6JÉhu8W­$•·ê‘+ðÊ‹-N&©0Än°ã$¤K­ó¢Wr¶Få1Å;?)c‚Øñ\!<ØIµ6G–@-wÔcÓÈs;1ÑÏP$ Óµk‘|AÐë&·/fŠ_‰È†ÚôtÝ'5šìÈZ²"½ýƒˆ¨XÅ ‡+n}.á˜ÇúÄ„DÑd©¨…À,°€n&(ZTŠ ÔY¬'Eîue2¦Zœs΄@`'ñTBÎÿTDzØqLi‰ ›.M¨aS¥ éfºªÆ®ÁüêJ›ƒ Yr~uF"jMC¸C&EöJOÿÐä0ð‚#8ÀøaK‚±ò‰¬”åXú—Ê }CH¥mÚÐÔÂ&c‰ÀB:瓊ÆÄ1™kÝ—¦DQŸÆ•9O¹×Gô4­¥P\×DÔÆcÁ܉+iei{²Y»ûtx)ã½¥u2AÙ&.¶4ò Ð<^ ¨z÷ÄÀG4R*~’„ˆ§2•Œj¤>¡²G-"ŸJtƒ›VB±7im ü²+´<è¼k”‚”«ä¯K –’–òhX@O'€#b¨ÿE&¦eizâcÇô6äv†SÊš¦5ɇë¢,O²år4™ ØPF¶“;~! ~rOOº¶“/0@?y°’‘¸èÁS¢Œ|´£±~äÂHxÉoˆ´Ð÷%d~ ‰_x¢ËmuN:, ?â‚¢D (qES³5G D@Àø‡& ¼˜…;M,yê„AÛ¹—-@ÂpÆ4&ÝÅצÈß ür(µÈX³^Ì”>~Á qh)j:*#èÁˆt!äQ}ªGžš¯F ¢H„h’"ô#«Œ•YQ™áÂñâipÖJbù­õ#¸iör¼ç,JCLCbܘ{!ÿEQfÊÙ•îË3hü#”Ö¢Âñ"Vƒ)±ãy‘`–ö:ù°î].Ú¦å£Y¨æë½†Â?Ð0h¡ÑA†2–ô`¥À`ÕRí!$Ár~ƒóæW@˜™ç[•Kn èùÙc/I\JL\âE Ñᙵq²ØNíW‰‚>è ã(ÍX¿PÑœ³•žýú0¡ðЇ¤Ú†ÕmZiCjd¡ØG›ÈÃÿJ•ËtÀüå AnnIŸJí`à*ßž‚`€ѦTx Ÿ·–’p;±¬:J­‚[nß8„Äê^4ºO¬—|t”¯›¶Jî¹–T::ÿ>õ\½4z´¡@AÁ.(ñyÌÃ01'pØ# „C bH‰-A=ÉúªLuR8ÎeÌ4i—ª)iÅ'‡”À!ÒNËå<øl·haýì'·M…ó˜4â“7¬~nÖ ‡8ÝhMt¢b5ÃЧ[Q 5=WK s‘ÌBŽ=t¥"!ScoHw“ðäÍrq0˜Ô­î½ÆŸ¯ÝaÛb’‹!½K O`@ú†_¹kð=î…!úävl?Ë+ü¶Ûa-+K6_Dۭùct¶l«Ð;¤ÀŠ¢ìA(Án}(—ðÁaº{jBÓRf·{³$0ˆÀMx±H}¡ÿ1䘢52#Oi¶Í÷,Àÿ  öàZÀr-·!Ñ`¡´0ß³OÝ'Pó &Ó*·‚7"KG'?&æy Ñ úpf qWQG½qoÔQ`2(°×úà-[QBà$‘J(‡‘ç é–q \ ø°{Ú÷€¢Ê˜\ ˆ¡b"ñCšÊªBG?BÁ'ÕHT#ÿ=‰ú’H@iT%„°‰p Av…‘~ÑFØÒª01|r€…Rp*'ªiJR Xˆ‚²*yz¬1Á¬‚¨a5‘öC&gâm2a‰¤Hº .³0äBÈ@ÕU †tR2{äòŽ^Ð ÈÀ€Ð ªbЦ‚8"I¹­-A ï¸y›Çwfò~@‘¨”£N‘$QxU|xEccÔiÛRIÄ:ýÈÖ‹- úÜ®ÀÜ/™ [‘䌠±=Àö“­'‡5›ê¸×H%€mHAspNÁª‰IÄ·Í-¡=A‰ÜÓÆÕÀ¥$ ³]‘"XáXH!áÛëἉ7H¦Î€‹'$œ1@( 8F©Æ.dqÙÏØå9Ф¶d©C©#ˆ€„dB+Ó,]`µWÿ{ÀºÞê˜]ÁJË´¼Ób>ë…ÇØen°ÐçqjŽw… ŒPê|RºoNüIÝöåÛiMx…÷¬q‰G܉žÞÓVx‰mÕl­Ñ)Ïš9P­¶Ñ –`DøÎn2¤€£ÿÒ‰+A• E#r‚$È›ï}¦Ù†#ðLðÚWY'[]º8±“A¦—-Aÿ§=ú÷°ï)!‰'D¼©2¿Ï`Þî ž( rv@„«ññu“ ÁÄÒ¹ ¦©ì "0¿=@ß ~'ÿ"?Dñuù”Gž™ã`z†®ë@ú’p ”Mº@ 0d'dáÝò‚œ ò m;ÿ¬÷pkmÄ ˆ©Ól½ÖëîGà÷‹Ï¹ Urs¢oì ¯ËY‡A€d"8 çûÔm ÓTu#",ˆ­ ÇzO°áÙ®gú4çÞ¶#ÀAò£Ó Ñ]K èsÿ‰ìÒÛRØ^ª¡÷Åÿ…=x;!ø¶‘Ü)‘ÍÎ霡Úb'C 'h*GßðÏëZ•ÿ’YÚA‚!­ì$q*2’”Ü“`'âþ³‘âW—,GÓ>™uÊ}.â"µÅÿaàßÀ D˜ÿPa  EøâÄ¿%ò*”7±E‰[œ˜ø¯ã¿yò>¾hAä¿%æýSI²ÄÀ–,þcqD¡ÍƒG–è¼§!‹—^|0P(¤’`ªÐé¿ ®f˜úïÁ‹!ÿx48ƒ¡:ø÷â€Ú›n¾};%í܃G ¸{Ѐ«zÿêñØ70\¸N¸5`CDÿ(\rPÞdŽçÑ{9/óËš;Cà8(3:Ý%èÄ8jPZ!(€ &­³lZm5zi–G¨×=tFF?˜ ¸w'Hh¢‹þMGCG„”&¨Túý—.VÙBKUY>rÖƒÏPh<´Ô=èá‚àŠØÈ.{,ûJ¿šà‚ Ú^Vx¬3’:»Ì@FBYYf JvAÿgíÄ`F¢,´tC›•Òð š_Ã(ßµ 0®ïp7ÔçRŽ Mn«.ë¡ú¬#Æú-ƒfµv®þg†³jm’VÜû}Ëß{×ë,wµrõ+uµJ1Œ' ¡„^\ V¨@Z:é¹ÙûÚÞ=\|—xÁ´²4ò@ÿpr›g3kó¸ÇÄVDÊ·^¿]B¢5–J;ãáßµ„ðÌŠwïrÀXÆrþã f¹BïrE¼¦m ûJR_Ìö°ún Ùàìнm €JÁßä ¾YÁô1ÌÐãÐL›@‘ð5&…+Üœÿ4³ToC%h NâpeH26‹œlhC›ƒä€Qé"QB:w“}‘!^#ˆr0•¬ð C˜ÚŠÐbî€G;ݱíÊ“2: ,9€ÀüH½P©x¼2˜ 9„t‰J¡Ša‚ ¤ÀF0˧,zØ£YÌ _(÷&•(ˈ"n(k dfц(WEe±'AÉË2§¡°@ doò$à^ò7ª0ëW…3¢TÖ($ÿ(r¨–°äͰè**%ŒªÄ@ƒfb–ÎñïhØD£pœrÌa>m,r°D8xiEZÌR#<~å½QÕ]¨Çƒ<@VE*#b›d€•Ò…lx؃­/Ô´ì]ö°,¡÷â± ”áÃH)K¹…Ü\ؾ¬ÒMІåx±BŒ°*/§ž¥XBÐG ìoymŒ@|¡¯Ù3YJsŠãær!ºŸVXà w»h¿¨MêÓ§ñ ÿG+,ð |Ei§bÿæYxÐ]Øí8£WîýEÞ?êå²"O7 ’ï²1ŒÇNþ) OHt‚@äN79‰ð!„ƒ¿µùàŸ0^ÚÛÆ7BÀ€<œFZ뤫íPNXPqC}'(ˆJe‡°ÆLÀÎb ¨ÆXr·u…BÇŒNüê¶„ÔÚMÙJo¾Ž#„;VØK ¹è¬uÚ¾öÍNKˆi¿…ì&Òª0›mÍÂ'ßÁc:•û|¸ 3"@ XÀ¿€ìàïŠV 0 Ø;¥„þ²õ+#®”{`@QäBˆ¨%÷2¯M¦Ñ¤“cÁ.xí«Ÿ'µÂá+-Ày¾æøMŠn~!ëu’Øÿ&SnR¶Ü^ûÎŽ…^6R¾ô>‹@ö5«@¹xé4&;ˆà+|0 °óˆ„` a.p­û: ‚cš‘S¡¨£h6œPÊ©8¹‹ó ;¡‘ ˜$„˜³¡‰««Èë#Ä®ñ)@ÔAà€­Bu)'ƒ‚<|#9ôú£ñ£ Åš{û,é°}ûAË+Ã‘× zÀª„ã«yÔ6­ÀÈ€ÞÒëƒz‹y@”øÓ –zq' ü=uiœ±’ þ™ÃË¥ÑY+$ˆ!ˆ9…•é+1ür›ß{Á„ 4 _úÃI 9N,ÏR˜'¤&¤l$žøÃ¹» ¦[û:‹ñ(# Š²…!ù ÿ,éÿGÂ'° Áƒ"\¨P!¾‡ø~DüA±¢Å‹3b¬¥±cLj -àIr$É’%!ª\ùpàƒ0Y>Ü€oƒÍ <1`ÐÁƒO= ´g‡£ l1ðÄ´©§ O£Buº“§‡ñøÅ+°µ€W{_ €+ÖžY*b¤=¡!Æ ·'âÊKW.‹„ 6dÈw¯ÂZG¥ŠÈ±bª‡ÿàÈx±ãÆ?ž\ø0bŠ–ƒ”(‘䑟mÖ´i&Íš¨e¶TK5¾Ö3GÛdZ¨Ï>ªû¨­¶œ:…:•8íGG`Õêµ@±e¡ƒUazuµØc´­Ë½.‹ß æÿ-H¾üø¾ñÞL±pʼn=nœ>Fû›Cš4}“?êÓÁlµf J¨6åÄS0ÛOºÙf›Q&ÕARÂ1e܇MUÕÓrñØSÁX%–X]tÓeZÛµåÖŒoÕh#x8âˆ^®!´£^>Æ™{îIfYc£L–ddDÆç${ú™6RM –šj"(Ó®IySN ìd!…u¡OÜoJå&U<)‡UŠö” wŽE]Z|Æ wKtgWŽ ™g(~©çDBÖ’dGE^f‘eÍwß“Á·™?Xàii¥m¨ý(%>YjùÚª\²Zàª1ÿˆ“Nþ$¡™½yÔ…×fqBµ”ˆXç±tªP¢²+šUÝuÛù)¨ws…Gž†Š7 ` ­wUô¨¥qôè’¡«®“7TÔîx4Ñ”žÂA ,pƒ¾úî›/¢¡–¥‚°µæR«°¾*«'a"w™E‰¡†¶(%ˆÆÁ™ÜœÈšu,êù¬ŸiiðV ÆÄè +W×wK„‡íy‰æ¥×¢é©÷Ðã^Dé¤å:‰Ñ 7bô‚ÈÒ7P@ôÓDßK§?üËÀW+çÖ\/E\À¬¥‚+-Lë­>«Ä@™À+R_ìá›Ã"§\V)2 Xÿ€'žg¡ÕÖvÆÀ5-µqýÈ£¶‹Û¼—ΜEþèFíñlyЗ„!IWàù矴>ˆð3ÓM;}C+ûŽ õœñÄþq£Š/ލÎ.-J|èZ4yº—ÛgÑü ?*@g0äG>@}0€rÒJí ø¬ê å‚²ƒBí°°!LlÂ{ˆ€²T*Õ*WmãUš–G¡ çWLÂÜBT½\E+t²÷¦#Àiç‡ì;Y ÿ–0D•±;ŠƒI¡nv³Ç-Š#ìÉÿ&—?Œ Hð=4PA Ú#`ù@ø±7òã`  Xü{˜'2à•¥ Ö‘»ËM|¼-õQ6³)^õŒ"5©PCX¡ó޽áÌðMÇÙXöøFî à»àãRÄ–µL}s1\¡²¿¿Ôï!Þj‰å .ý].Ið¹Òb7KµÌ‘+*²Ž›Ó•æð²Nka#&€ˆ˜æø#Q?5“+Ôñ¸!øŽlc ƒ6H^MˆyiºÛÔäÉ *24ÎRjxÃm¯’€ó›X0¸Án.D\àRÿ¾ø=«Égò“©ÊÁ² A‚,ãQÛÝnŽÔáŠX.èK‰ÚÎ]‰4SV‚ P`#ÁÉ 1e¾ˆm4QÃÇÅx(`SÕJÂ6â kW?AĹ<6¯Wçô„ Éb™‡Û¡<ÿæ¢ð©Àd&Ôúº³ÏQj‹~;Ï_`²žõô oƒ Ì i1† ŒÁÖó¹u}ØA ./궺šÀ¸\«14pƒxE€¸À2‡ƒÁ¶(]Ò O‘éﲉª²Ý¤zV!JÛzü’3)Æ“›P¥2•HæŽN•$K<Ç>zl2ìcŸáâ"[ÿÍãIlÜ?yô‚$¬‘ûÁXoAÜ04­é; –pæ2÷Í‹”e»ÚÝõºwť߸8}‘ó( ¾ó”ÖŒ°éJ‚ÜMüª€hš°™.è² [ N%4¦bèmÎ[НÜ$½ÒR9Ø‹]RÉÂà‚O-óˆêl§å–¶ÜÖ}Zmân ÂU–€ \ I°È$0‚¬×IÙr•»y´ø|Ð….äq‚y´‘v8Ö Ž¡P{%€W`–9Û~‡¼óX&=PºäèƒKrNàÈö(„*!a0» ­0C`f!9‘"ÚÑŽÖÀÝÄJC“Zѽ9¸ÿ:ô([Ü’2Ãí““5Šp‘s{Õ&¾¯/ÙÖ”vÖˆP`I+&ÒÌâ·ÆìÑ1c™ð" àÚMv§-ôX2=ìñD¬à@¶ÇøaÍl&H²ÚrñÖåDöd…¹Q¤ó<1àéÍÆÌ¶ÛÝL§‰ÅÙ©-ËžTàÚÁÙ¨pS½s "¼í Ϭ~ZõË^¸e¿F¹æŒ˜ÇÄÀÉE¹àï-1À ,á2¶ô¥ÑˆÆ³h`¯hqV> €¾Hº~:8wlœRVçÃÕ¥Á”; „Ó¸&x2ùf׿åžúÚ×ã\䆢¬¹%;NÿÐÊš·ç°ì­Ág‰3K_[£;GØÂÒ´q?—xÕkG‰1Q EòC0"Îl©ßXvdy° °0æÉ‚#XúÆÀ ðL È=â’êU{QÜÞ6ÚÑ.(n¯ÚÉÅ4?bÀ;!Üš²¯R€J•ßÌò&‘âì)°iN“#;Óšìü•h³VŽ1Ø¢žÙrÛ?Y¾È°±æ­êsD9î}‰J%¡Ëöe’¯Ž”0£^5d2‚ò°z¥õ-€{”àÈGÀBc¬L2ç“kígz̃ڌÈ|\h Ê„¯Z¤SNmÂÇßÕWUü‰Šˆz-ø‰¡)7å|^ÿ™‡š±Hú¤Ý+gss\Îà˜?õ‡™¯0·ßrsgí1È-¶˜Øg'¢òÿ*At­nvœF;ñætŒ€ù2dâuVG³§oò0ú »W¾·>P5]‘—qyÄy“Çt˘Æjë¶@Ä2_~ôGzÇ »Ãk½f!f"7,MaCå ¸@=ƒ¤xÌv,”d'ìβ'‘78•-'0vÚ¡y®µyánün#?+±$*qU(¶¤cCôtÄD4Pò Pi¨o@`¸‡F! ,Ã>Ò¤Õ6‚ÃçZ‚x|·e>ÆIÎ2F4{ÔGÿ${HÂ"&fÒqifá~Љ#‰·l)ò”5F?æJX˜Ô\©EUˆÇ‚…›Yˆ4³ ñä ?–ƲGý¦±ã'Ì¥¡t™’8i€Ñ9]Öa©8`FdF Ä¢†Ùc´jBe*ç#$‰\Öe‚l—ÿÙBJ!~@Šlõ'L9Š %Qd¤=HФ¤øx{bA⣕À·v,é’j›<Ç8´é…Ø‚ £%ðp#u"…õ©´“1V—¼ªo•V{tJ§.RAºdeA|f±@)*@…ùb10Fù@¼sW2ƒ\r޲qƒê¸_¶YÁÖ£t 3" 'DŠ,œº©dDFú 8"ãTN5">qö"«Æya™ª«*–~†¼HGð#—1ù"{r¦C‡Ì’!y—³÷‘KPmñ©ÏhôDOo–¬ÊZ:Fm¢¤À”P*Õze3ÊwÈQ‰D1” Ç+EÀ&ç„N´žMÿ¹šº®G•§Y•}ò~|2]Çg %¸sÁ-Xš¥ûzJåa€9 ˆ†Rè•pÕÑPt”°ué¦kiе°]ÂZ±.×:«F¤¬ı҇F4FfiÅÄ/Sžb³wç8 òB™ çq"Ç™@èˆŠŠ‡Tù™³Jš¤Ïq,dkAN5±k·EôJ¥öPòƒªZºªq%`i,0ô°n/R‚ :;i‘°qȰcK Vh¥DŽΑ¾$@¤#PU±"ð‚ëê,'ªûòýqe¾£e—U|ëY~ëYåęԃ_'w=sÒP EFP©½Z¡½^Ѹyÿ²'VY2ÖImâÛ’ŒÀgú×s›{-;Ë9°ß‘d¬V¢£¨`÷\tùµ`+W·Ôfû˜ˆß鸡+°>P¿ žûøv 8­'+S­¡¼7Q7Í 1aö·=Xl—ð5AxlÇa§…Ku¢³eQušMj°¶Tš¤—$è>†ªKÛ…3Ñ À›÷àt'^`¡¶²ÓPB†^èUd˜w|‹û14FxžÇ:Gÿ¹˜»s¿;+ð£ 0jÖX¢·£"bŒq¯’%{÷%@¹ËÓžî)f¾³ðøH2$¤¦•rÙ3IÜ»©[Á®ùÙ³ÓWÖÈ‘—^^‰ ´Ù¯ 9–Ûÿ" ž†PÉxuN·‚Ì4F¦³5—¼5Ë@ÅÝ;ìJF%*¼ªèF¼+àé‚ Àà9]äpx´%;Æá˜,ÁwÜd=ýÅ­€wW-`dl „ƒd®ö¸½éZQìG¯qeKØ1|ظLù`»ì À& |Z!p¶˜€Ï£j@ýv'ÆD¨=YË)Û½»Ë?QW‹ÚËD ZŸˆxÇVZvcÇÁÉPéÊ•Cžzñ*È¥š^IJócÉœ &A,€u9‘À%Pd¥ÿÆpŒ†^Ö‘^j+' KÒ§Fl¶fT§§_T7GeÁÆJFPeyÊo_Ä®&©2ޏ°°a*´}Í;NÍÆ=ÇSÍƬ`—ꔦ¨ŸÇ*GM2ÑüC‚8Ö˜¾€–UâVÃ6cÀÍŒÀ†’G Œ°n+ˆÃÄF|ÓÉjFüà@ðlÅg¾QDý¶D-¼æË2£UÒ·)£vh”§ 0ä¹ ²‘Ý”ƒ`mWß÷YÏCÖ6©ÅÒøéNú¹ÇAÝ1™¦I©»’¬i|&xª‡’¥_¹´Q*nò`i9 G L LöÀpÛF‚ŽíÏfÿGE§"U)SÞ*ÃJm¶gx>Sh2ç#q&Mý»{ùð ôEüÆ}eqY¶*#´MéX!¼ÜË,r„̃K}Ÿ‰ÖÅb;µÛÛß›¤n"Å:2¥ûÌ}²EéZGÇ [P'=Æëz'—ƒµ 4]G€˜Wcw=Ê^ÔÂ4ßQuގ樧ì}ã,(ÛxM ]r±‚‡ßTN6ÐWÂGYÕ€ä b¢Ð³ý}lüYÒkÖ?X½6„~8+QšêK£9æHX¢KÙňxÜc¹a‡¼?0dãeu!¿, D“L1¹m5ÆI*P°å¼98Ô¬O%Mïÿ–>-(ÀG|=~ÞMàbçßÍÅèŒþvi{ß Ôj<£e|ž Ó0hSà‰ÄÐ`=f¡å5QQ1„³²¡™CGZŠóÜx*⸷.ãÔpFl›Ö̾̽3€LI{´'0x^«ÊTd|ÞT›^Ò^mv=8ómãPÅrÑsñŠcw‹>äKÐBþã9®‚ÔfvøÙT Æþ}¨ç)™yëÚº ÛŒZW`‚;=òXZJa=×ËÛ¤™Ê`¡=oð¨uë!ã,h¤×`›™ ž‚F^U—â3°4ë“E¦‚ñöhÆ(š§gö§g±aÔæèéžjr‘jÿÀí‘^óÍuó/Vó.&4¯‚®eÚ ôpý¶<Ž\M^Ýkã„ï§Žê¶CÅêÕ{5°Ó1Þ{õ(œ\œu‚½–š¸Húbï¾~¥>§¥á) `€÷ Óì,ð† %XcÏn˜mØÃ~߆̗\sqs\é’Tvˆ¿|‘cB.‹é-ù-@c‹Î|˜–Ù8¹/¡â骂·ý!åVѼ¼Û/+l<Ì·MZEu7ZæŠëɸԽ¢(Š•$ϵ‹½ñ¸¨´ ?€ðz°guqµ`*÷àåì·õü†Éøˆ)ý˵bŸäf·»×o»ÿ/9ó†9ù“߆‘>þ- þ,Sù.¦‚·@®ÖAD7£f|ž‡ž{Kå€xk|ê  < ܰÁSÁƒ … ÈÀáˆñ$Ú‹GÑ^…âà§1^Çü>ŽäW2dI”&E¦\yr¾—1aŽŠIsfÍš0ñéÄgÁ æ±w„I3°0Da¡ŒæÍ‹1µjÕ'–¹×•ë=`ÃÞ["O^Ù%ZO´8¡a½öòÍ¥;×Þ]{ôæi`Û·Å_¿-æµ G/«¼µˆÙÆ ww.?D 6à›¼ÓòN\ø„\R°à‚† :x ]Ú´‰Ò&LŒF½ÚCØ l d˜ð ÿç„=9„ Qd¼ 7À¨‘£Æ–"G”ñ±ùs~—/Oyr%?šÙµßÔ™Ó;O|?,´2$´ `sXá…7E… 5FUSOÌ3{ïkW¯,³ÌJk¿Æ>ȇ}aЮ¸ ÓK ®2„KBÃZÇìà²çŽ “l²Í4Ã,Å„èl2„6pH4ÒF3ÍÔHSMÇk„­‡ÊÍ“…†Ôm7ш¨¢˜î¸&“ƒÈƒ¨¬Rº+³ÄrKßFéËîn²)»™ÂÜé >ê<ŽÀöä1dÒœ@*FèÉ3FTˆá°³úãê¿ÿ”‡@³Úzÿ«1}øAD™ëB %Ì0¬+Ÿò±‡Ò¬ØZ´±¹ôáÄÊZ¼LEË^Ü@2$E³ñFkT­ƒÖJ‹­ƒÝjr¡… ­·æDº«¢à2"î¸ä”ÃÒJ-;xöJh·Ô©î^ÂV&˜¶-ÓÌ n0„‘N@OÖËÎ(h‘ &ÐsOFìÉSªyNôÐ -ôžCåib­ “kA}\àÇÓKóʰT}"FDHŒxÒ¼ ;¡±Æ6Q²UCnÕ3ܘñ5”olmG{\íGÙj3hfÛjžQɈ‚«¯.¢¹ê¢£"i©”VÚærJ,Á,L›Âó2 (¨ÿ`(ôÒS7)÷ê” Fž×^{Ãj ¢p¬» ôÀ ãÒTºìq⃢P0b}VxT¿ýÁbº?å°±¸C„`\•EVw"ùU$¤5WqÔ\W ƒdˆæ™qÓmFiMò™g{z.®#Ö­6i؉^zvˆ¼³ÉÛQpÿÒi "@D(¢ŠBŠ=öX@äÝ;ï­wy²ÿTÀÁ’Þm€Ë"xãŽ5õ4Ÿ¢à>ïó‰ðÊ7…"Gĺó‘ð®Ä傌E¹ ÊpóÄdѪœ5µ–å s?’-dF!Õ¬r¾Ùȱðâ3eaä:ñ`Ú””¦4Ù̓ˆîÌÄÿ-n‡27˜ˆB7­'ò˜æó{ÝKOö¢GUô²øzaùJ¡ö!Å (CrÑø¾WÄñÏ X¢š¨ ømbú€ß§ð¢¸€Ì~œ‘Üä@ÃØÐªVšÛQŽr›^}.7¡³ošSà¨àwQ]FXw¦Aëu¤–²õ4©mkw:ùAxʃ5³E] "¬–¼./lSÉWV´R Šmn+õô¹}oSâ“à˜H T¦Ò”X%ÑW±ºmÏ. :U¸xKÉå!üëHF3¢ Tˆ‘BÓ¿æìì.r´3Q·:”L§‚Zê£t¢CÁxÿðD[R¡6Eø à„éAÊz@Àë0ž*iɬ¯,f‰ž¡ "ÁXêRÚãßñ¨¬’B°€.±KPbª\âß.Ö>ÇÐ¥7Àßãì£WŒ)»=jšzŽ 43fC€´àT„™1p&^b°3Œ„$$Õ”&KFÇ ”'ä&><ø’ð ilBáðØs T`a‹ ¥ÏxÎ`‡ZÀtxÕN"†`"Zç(!6>€®`¨4¨‹.aP \â —p¢Ò7‚Á‰`aV4=>@QË¤Š‹Ñå.g”4_zte›{Í0}u"%0V°ãÇYz—4sÿŽQu®9椤XÓùN%œmrÞꙞ2¢  ]æ<§<ñ;Í^|ºŠ¹Ò‚˜àý°?›ªÎB0Pvµ}t#.XÃPJ¨ÕEËuÑ zPV.1}Eøøòò–·ÜÕ¹¸FÂËÿuô—Á,¬@hƒ@Û€Ž!Mé2›y9F6²xQA²ì‘œ“ÜT¿žå/p^j0 ’§c aP­v‹*)Äà (9•°ÑË-YQ­o§jUݾ-TSá*) 7Ÿpm¥DA™kÖ²^"­¨tâ¦;ºiÌ-ö@^õzѾ¾Št€¯`=JÀ43FmDš± ë'?ÝGÉ~ÿšlp0òdŸ9ù.Á9ÝdñR9~jRÛIÁiˆ œGEMÊQCTC¸¶ömt;Ïy†ê“–Ø?ÿ ¸¿¹É-뉗{V„.Ô‰ªp1Š@·ôå-5®Ìqü™ý±Jbô1æ4$^—˜ê•´Ú[¶$×ÉJ¾OÙ¬|jT/³òe2€¡“Ÿv ¨@ý8o@.ôTÕMe>˜ÍeIý¼Ó’8L­n{çý€2”â³3@q>h«Â‰©L«Ÿ™{Vµ¦um-‚‹çº–·Ü¯å"FKæFJ·ecM¦}ÅFN›4"•l 4 dªPEÔò55¿ù-G€K6¾ýµÿ¿]Ún:À?ØÀă^£G, Ë™< Û’fÉ-Z²7Qahn{6ù m>BKû”¨T®µS\V„&´Ån§ØâzèÃÆ!ËÌýòw›q´£ÀÜœkÐxÞ#ÁÛ6M¦Kýto¨Ûû>T)µÁåKj¬g]ëJÞ²€ ü-›ü ñ©@ Ž€6r.8þ‘G Œ¯_ëkÌeÁáÜO·d/jD{kÐWðì“/  ]â+ŠP[ÛÏ‚B£ëC{Š™‡\(Ð8îrÆÜ:–t`øyÎÅ,ê%é°|Ce$ùÞùη[ªrï­OýOùš=S.†‚¼šƒ¿?Ȱ%È鹞Ë+sû"‡ ’Ò`½ÿk7ÑS#Ò[¯Ý@š8‚,©s=«@ç±½JÊ ±Àÿ¼@ Ô½XÃ.‹žh¸ø@„¡À-t9§{ØŒ0>Y¾xʵÔBx¢¤¨›°˜íÃAŒ¶?J%S«³ÂLĶ“9nÓ'˜< Pú«¨ÈÁ?’¯¢ Ïó¿2b[(‚<¬:’329jÀ{ÛÙëE^„à L‹7|C ÜÒ ­Ë8Æðˆ«ÙCséCLA°™¡Iº¡#6êË8ƒ¡ì;¤€òÇÀKŸïóÂc¢Ãã³Åk¹ML1c1nã…|Ðz¤‡|¸¸Œ(ŒÂ˘úA+ì±ñb™Âr·T¬NË™#[À|³· ܬ6`üµ¤>a¼½ÿý¸–îè¦Z@FË>¨HDr2³Ä“«ÆªhÁÜòµ|‹×Z'}0„ù;ÀGó¹“3sÜIò+?3¿"$(N\¿„ºOðy„?ù+D(ˆÍØ ~ô¹Tì¼Ó,W|E,wKºZ\/7šˆe*CòÅ_„Ãa¤°¸ƒª´„'¨¡C…3“Þ‘¥Š;tAŠ1{;æs'棤¬)lÉy˜Á|o\pÄA›4ÁC9\"•c%j»D´ZGw|.öc?·ÒXB0‘§Ü¢¼ê« éŸt³J¢óƒ<¬xÛ1ˆè™÷ò“|Ó=Ú+Ë8Ô87DKBK Œ©é½:ÄCÿxÁD H³I½`=2¾1ë$CN‘€ (LÀÃI›ÄÉœTLH9óIÉT±²(ñ¼Ä@[+J`°‡aJØ®ÏÄ~L‘ͯIcE`ºÊu«Ù)T 0ìŸO{:©Û‹±ÌŠÚ›HÜ´-¨"F Ì11ßã à[F¹,¾Œ+±¸‡Àtªå¤¤«Ðgt³çK6ìû€êŒG2ÌÐÎpÜNô)sôÎ0< ÂK4? ÄÄ´*ÊäÚ¶õd‹´°‡0EÐÜ<óªÂðªuó¿Ð›ðƒD/Öl§“½ØÄ ¬Æ³¬@-Æ %§á2±‹PŠD—{8ÁÿdƒÈ|9ÃR-b«>ë*™TQeQpLÌ+Æ?žŒ.TZ1}¹ŶµZ(µr« ‡´X‚yà‡ƒpJUÑŒúD·û¬´«¬—‰Å C 6ª Iû¬I½y€ÍüÅ Ì=³T Û;/=.‹µÜ¡P …—«Ñ*}a»sÑ¡1ÓFÖ£À,QÄ> L<GqDÌÀÉIäÁÁ›¹õI­LµŠ9¢\"}pÔ±‡÷¼?\Ð+¾"™TRþóÔý,/(Ý´ô:¦¸*a’ù*P2ÃÚTPx*Ñ‹¬@çÙ2™øÍÒr¸ ¨€_+—^; ±À€AÄœ:¥H@d>ÿ{˜€ÁŒÉgÛÓ<ÕÓ…ÑòI9WTzÇK ÏjëÑçRT„r"~P­H‹"©T̸ÔÍð"ªÄÏ•ÑO– (Õ´w=’ݘÞ 8r/³YUµ VMCµÄ;}Íd ¡Þ›Ð3©“ƒý€ˆ4—‰+Á‡5VæŒÍ7Ä{AÖ¾ãØåShí6‘TƒÌÍQôS.D¹Ëô0 µ˜‡"µ¿KU/êÒLW«ì‘×H’wëJ!éŸ Çb²× ÑÙ\CK‚ZۼȽÀžò©€»¬ECàFÑ6xÎÖ†„Ó‹³°™N PQ޵ÉÚå>ï‹¶hUJX¹jM®ÿð Ê»e?O`«õ¤‘TJµŒžcúô ûT™ÃuÅu %Zƽ1Ä)ɪ¡ûð^ª`ZçIÐ œÕµŒÈAÒÀ ô©ð CÈ)¡ Àº\ÿPÉ®­Š{Ö`ƒ°˜IÑýX¶=V”¶WðÝM+>«ÅV¢D¥"`O`‹ŒÌ{^è´Â×¢›^ÄMÜvõB„4¯“jºz+›Æ0ø _ t=ˆÔWý“k­.c_:ì 4Ýà°!þ`X‡Í­©ÒÆ=вEA¸hDe­É`î;¹”›Ö[ ´à Þv\¼íÄ„š`¶ØpuJr³YÜ(,#'}E¬ôÿYZÝP¯$••7ްŒ/=Q@4ŒH· ÚJCbìR œ‡„ÓÈÒZ•Z~ª?á—ü 7‹H©ÐJ²Íˆœìˇ;u!åSpÌ]‹q¤gÛØ&~Ñ–ÎÉ4L¦àØH,gsd"ñS`–;ÙC…à}ç„Ò‡¸Ð0Îç)×Ïà¼ULž]7WŒ§^c6Õ„HRLK)e8Æ@a;^=4ÐËUfxšè:|KŒÎჵ=®0ªÔ]I7ã8ÝF»n6Qÿ¹S}Ðë½½^[î`U¨é¸µQu&åðŒ]óC7C ÝV]´kdæSioÔkÚë—.g?ýkÇ\ÁN(ö»D½ÌÁB'b+slÀŸø¼?‰eƒ˜eé ˾ìù‘Y\Ü6&\L‹ãƒ†,²á–bá«ÈcòUm`Û-ë–ráÓè²)>ÝÉ䫵-è»;ÕM¶®]…oâ+‡ðÝ«™[%›þ]04·¢.£…Z.ÿæ \£ÖYï¾OñæÔ2*ïÎQÍxë41l —r,aÎê{[á ûjÕßôܲÆÕQp8#W26ÛµµËí}ý5ôK@Ìê\pHœ5¹†QsôÓs>%/'ÙPŸ¶¶êt2ï§¾ q¾"jœí¢Aqé=ãž5ÌhÍV#ζE[¸ØH)Ô{ z1µÒ ;vH„Zú¾À†Þ&Ò2ô³þ÷]µÒ¶¶& 8”Ô¢Ø4—kôf»¢AÅëá.î–†µ1rT"Â+uQ/ui¿ôyºÉ…(È{Ÿ Dqì.êÐÌ%è•‘6'¥ï8·eþLÍÏ)=x•ŽÏÊs`‡¬ÿaWa `„‡îñ|ͽ4¬${Ó2A™C—ØVt­ sb»³ØÜ5ð`ÕÆ×j”HñÆp/w;›¢M‘‹ƒÉ‡*‡ÑEG&êù¿î}¸÷Âø‹J‹ V(W¾¿)ñ ¯ï6c–uÎQø¡íìÊÙ^°Œø¼¨—ȵ†S¹ô†…Â^ôìG×W^H=!àeÖYE¬Õ–Z+$E-ì`‚ 泡 úð’”=ú,àcŠm‡Xa…1ö˜'ÕVf1^öYgŸ}i˜fËj²Áæ²I6?üÄÏoI ×Ûp1¨°ßqÇ•4Ï”‰÷Ü•i©ÜD]^”ÑuÙ‰Ùÿ‘w"TÐIK—ƒ¤ç¦›êŤSVò±ÓƒZ(€ûÑÓÜTSY–€QlÈ`„>, ŠZIé#†zêéXfñâ‚ü¬ðW`ƒe$Db…™Èع8™ #„–žÝÈ™f£íØãkAú8›d#ØŠ›’ÉÆ°$#áÑóû Ä\B1„å ÒQf—]jæEDðQH½Å`ŒBZ©ôÒ 9¥§zêÙY'{aU_Ÿ+¥¡†Úo> Ö :=Þ• ƒiaêÖYJå“`Â_%ü©§úáY#¸˜b¬ž˜˜b+º6+Œ™á˜k6âèÿ«Ž´ùäb¯«ãF™,“ˆ°ì“Ñ:I¥ÐåÙœ•!dPsË-GÑ—×Y‡Ñu?àÓ ¹"‘¤ÐIòÄi—=„0VñÞ9gM=Å7ßPøîKSzh¡(šg£Ré=ÕÅ’UÖY•B1_ ÓKžæ×~Åj«‡‘,2¬ ¸Xe*_†kg-›€cf0a‹l>È&¬´MfÙλñüÛ³æ ­Ñ-}PÓÎ)4e¶yû»F_~™‘G„ô=á°ÄòK`¥pYDEUñn%ÏM,ø´'Ÿ}þ¹ŸJÍw¿û)4ÁQ}å(XfˆWàk¨–>|µ€Upÿ]^!xÖ¤à À°Jd®"wÓ”Ùê6-ë•@³¹Ñ!f‘ i&¤Ú 7Hzp–%0>+JT ‹@¦¨XÉv̙ղã-0i$Ý¡@R€à iye»‡…>(»QE+íá |Å£0Ñ,mƒÛR6T¨ýäénÊi_T¦â¾yJR”j‹()MÑ#%úã@€Ø‚D*]iAá‚€ñ£aYä C¹YNu”™ ®f$H zf àѰl› šÆX!ìF²¤0BhÉIᵨ¤»Þ©PP‹á ÃÔ¬i­‡(!Àþ¼BIMÑ=;©JžÕ'&…ÿG!Ê|*P±YK* ¡×ç?Gù pii %Â(!¥´@=û‹W ÈB!‹…@c"ÈGòq&1­2bJö˜Å0ðX+d?÷¹u€G©YÍ"9ÕpÐFŠGâ¡$€gÁa–o 54gMK ÙÚÝùÒÉy„ò“ÞE~ðƒV$æâ×î±?—d%Aý›+­Fñ‰G¹¥>(ð‹ð‰Ond+[ÙPéyü¤B,@ÜTÂ"—²˜e-”ø)[êG  Eó.ZÐY|à}„ˆ °TªÎ=²hV–ÙÜ ÏÁÎQÆ4£[é2h³›1ÀX¶Ê ox6&GvËÿèÑJ‚--)”iÌ‘¡v”‘áÝÐxø€“LyJîRô@^¸öXçü(Š(ÀÄ["¥û#Šh½w½dúÐQƒ©0/Æ/Œ—ØÀ+– \H€a¹` Ìâ 0ú@Q(€P˜Åä1œ%sÌcüØÀ#ApF-»•:afÕœƒÍ½Ùd<øÁÞôSIk]k{%hÐhÓ)ˆrúB †3$ÞrhQ{0£4q¦þ^¢°õflÏå<ÂVŸ“F6¥+ÝWÜ$01:a =ò‹7 ¨„…¾Æ\*îx JD()rT ó8¥*UöȇFÀÍ­ê›â$gÿ‹Š…UÌ ²Å  hb†È™9—‘e=?ª I6 8±ƒ–=ˆ¦»*mÈ UŽ €¼áiD¢7ðkp”Ç<”h•êqŸßê«¥…̃?Ùoe+›”ï…9ŠbkA è’§@ O‚оvÉ—ÿx1/>p21µ¸hÊ,KAKn‘é^„·ºå-ÁéMXs”q ŠKÈÐÔª4d®<åÉÜ!9²ù„d’èñOÙ‰R¢RxS­IæD¨Õ``Ä:ýävÒ{D”ËÔçš²šœYey`LPˆ= pØè›Og³˜5…í¿ÑíPK sÄÄÛ†©b—À3‡Ç¨”\|Àµb®2¢¡t:]v¤uZÚ4`nX‡µHÕU&gýö7$±»¤ë TJáÈ”¼;VÃÐ"±~{Ä‹~ /Èè2• û’&DóS*”~ô“|‰0¿%-±úÕoC¹p|>X ¨ ®Ï”A„)sÿo;è,ÔYÊÌK¨"NЇÒpú–1•Um憎øH·‚QÌ–Kcy Ó”)RnÌj|$<òq.™', íËI2¬GÑÐ/ydâ!á‡™šƒ®“`¾¨Š 0$øŸ *Úù_˜ÓoáÄ£eæ—}<¡?óø¯Ï€£æ“Éar“{Ï{ÆT¹)•æ)• œ[j8Æ«(Z)UÁÈh芋Õ^ŒTi¤†ÑØÑFר±“DY“”rpWÚœ€p¬E͘4YzUÔõ™ £äK¤’…ŒÞx”Ü ¡°ÉMûšöÏ=ž¸Ñ_…iŠ˜I„IÿP àOE¡Fá„u›‡åƒSYŽºmÇê­ˆc0¤ŒæÐÞ‹Àç„ÎX°Ä†¦E†-àŒ±ßðù†Ø]—$™@‡w¥P úh€Ô¼Ú^EÜ“‘ öŒ hßòtßFíOhÿèɾÊø^eA–P aZTž„ØŸŸU–Z¤ÖœŠZ€bRtâ1™ÖRáÜ\þU!·]‚Tá ™Þ±µH‰t–L¬ôÑ t@e„ÎìA ¥Ýн)×ÁS"Kdl`¿Í![a—UÒ[YR´ ‡”ì‡vvD”DBÖLòh€9úƹ„0a…*‘…ÌØÛ¬ß²i"Z0¡=FÿH„¼Â+ŒH2é*¦Ü&:Œ* ,Êâ%pÛ,&dBÞ\0•Æha¢…Ó¢‘Sï…¡±8ÔÑž1R¥Õ°` =©ÚS‘@#JÀµ•@=‹òÕA, #|×ÔàÄ5Ù“}Ý¡x¡‹3¥Ç÷ÝQS&¶€M^}^& a':ˆƒ¨®À+ÐmIá(Ååu¢„dÞ+¶¢æÍâÍ$B.ä,n 6Ý@d"b—å@0çäŠËœá1vä]àXe`3ÆáÎt u \@-‰$…Pò&ÑÀÕìÐë—^ÉÝ„9Úƒà š‘•uEW¨QQiÜœ†ÑÇgæÿEÃlâ=:eÍA!N!…¡b@Þ_æ}¥æäÍ)¤A FmÞœ䘇@do‘ŒÉ´%m8RŒdd£~etU.c"½S#EWŽ™dJ’P5¶U "‡ó½d ”C½šuXÜY”™(9RY ~ßU4ùÍhêÃÜ}´……ÏÚcSBåþ©¦BŒ=¶&æ©¢+Þ\,Æ¢X ÆBúÀñƒœe¬¤¥ÈàÃë5ÆÉ4ãhÌ^ ¹˜1r2âs2#~u™¤`ŽÝ²`IÌÎu ´\‹N ‹Ú¤­ÝZ?IGF'W4ß %ZÀM%†&eâ1á15¡èI¡läOáã1iÿb¾bÎ&”¨XÊ¢' ˆ1@ÄJ¢MÎo‚áEVhJÝÔe†rÊL ÎІGŠ¡ˆþS üN§¨™Zwñ! iç³à•^•zÝdHüò$b¶4‡š ’›pf6“*%ˆRt"Q”ú}&K‰æý]„œfTþÔ‘z%Paå=d“VáFimÚ¦WúÀÐ)(ƒª›ojÄD¨¬HF×…‹Ée1¾ØêÈ¥u¨l¸“mœÕt _JFÁæa¢ÐžP66˜¼h ÊÝñüš„Vp€èð*EüœSÄÜ„ë¾(%i:e[d*(žAkj¢*¼¦+R¡¦–ªW.ÿä%?\©c ±c8†œeY‘†Ó]hÔ…†—!é^"mšÂ!²$‰_þ†›öX%‘]´˜v¢P FKôi“‘ †DÔ9¢ ¡jÔµ~Ÿ¶6ßù;žã±M|ÖìŸé=ÁD¥R¡«€äOé fàˆ^+âÜ+P¡AÞæWViý,(Z& ŠÀj¬î%ÁJšçdè:•i2ÖXsÖ°«ˆ2 o¬dÔò!•¬d HÈžˆ˜8YEDÀÔ\T¡®DaÝOâTH5Y|¾œàšÜh )>bÊ+h弯kj‰ÀçiX= ¤i$¹až*$-%¼ÂW~¥WÞ«>àÿƒòë..Z´ˆ‹8 ÁF rÅCÂÆƒet$Ã2gš>ìêà†ŽMl²Ø!©%I˜š¨™ðrì²v<œ(yÅA¦o„ó”'aY+¢5YH.¤ŸRÀçŠ+èq"»¾k¹½+æÊæO5îçuH‡èEƒ°«iqª* E€oþÅ&‡]ÌÔ¢Ê7å¯É¤Ø^-çÂ2¾“"å%=½°ÚCu᮲_v\³t,\E ÛJ„³Â­ ª—òÖdžÊž|­ìõ§`. nhfØŸê[@âò_¯¼\Š ´ßý™«lî% ê ßpè%nÒÎðþ¹@ ÂSiÿ)88õâå˜ïÿ ²Rñ‚ZŽcXÀ‰° ¥ééBq…Jÿñ°nWFî­ N‹0#oqt14ŠÝ$ýǰN06"7žW-œ— Þ)Õ-“œã¢ „þóKTE†ˆÍ|Ь¸f/}<óý9HûFSòÉ…6G.¥¦œOñŸ*üB>DM3Ì$“t5‹€Ø?XÊlr«. 4àh@q˜ã‘Ä[sès…ä'³²»ro|±? æZUc‰¢m-ßò‹2Ÿ‚§Ÿêò ÏÄ$„ ÆËE*ÿ¼Ï|DO|îñ'†´hЦF®¥Z‡Pˆ‚\å »ß [å¹…ˆE5/%WòÆ G*qP»ób|¡Úil:Ùr•)æêd±¬þÿžíJõØ.K%][YR6 U‡’a0™àÅÅ”¬–i 1¿‹µ¶ »ØEMݱ׬öºѶë6ëõ´i3 !r3žç9® ,S|JYqƒðB>´Aˆ$±KbSÕlQûï\®n]êê]2§šFjÀH_º2UÿÛëÀ2´DIÆÆNÇnÇ‹bܲql×Ý ³9Dìš›¬Dœ´ãà ‘G£0ûÙ‚k =âµ>ÌÑsMÏ™àéö]°QÈߟ©E‡<ŠX,ˆt“Êpèƒ>ÎTm7ÒÓw“FVU¶=WWy€Gâ7½Æf1Äæ˜@-Å–vœ®d6:ËHÌŸžÿXãП’µoØŽ96Çjyè„N ¤%HëÅüƒø™ùêÃ`û^Óô\dH2wMßpj­$ÓÅ6ÖÙ$À6ª€‰ è¶^7ÚÀ>?ôŠ#õe£G~ä°œwg?RÿòØ^õÇ76Jð“@·´ “ù•HDfÀ,JILÇ{ªJàvVÔ”Ý|ÙQö6hwlõÙãÖÏsì¤È qs ÅŒŸ¤ÄÏML⼺$ñ¢Ð?`7Șˆ¿>öìZ­ÿj•Ë´.®×gÿ³Ît{‡[™ œŽ`ð:Ë,ÿÎC镬uDûPÈ6"žË sÆÁɧ @)DšéÄa)ÿ8A‘å¡úÌÍQ™väÍô¾Ï´¬‹ŸJß0»fJ.T ‚lxt;=´=и:—Š´[/vvQ¿Le×›Ö0S§ò³¿åG5Èû¸oŒÀ=É£³má2 Ù7ÜJÖ|ÇX‡l#Í6š#Øöº€<`œdM ‘Q:³ Û»ü=6 §ô»Ñ4ýû]Œ3æAØ/°ù2%=x‘$Ëy‰?Õ>ƒŒ7u2w ìE1²§eË8ywm?ÇFEr¿4hOûŽ`5f»qÌrÛ¢ÛЉu°ó(IÖñй—£t,Êx¨Ç¡æüº«cš:½Û{EY(QUH‚¼ú¾áL“ÿ9§Ðt„GýS~‰_L…³>8´€=ÄÉ¿*uá‰ñ¯ÇÇ?„i½Ñ%­Ê˜Úú¦i`Î Ë˽ˆ’]Ê;ú“@K )¦cG“‘É“%/Ê|ÝáN|kö¤D•¹ÄJÜC°;ÿ¼R…!ø(JÕ{lAÞä –)ˆ!·äG†G¸ÀO}âJý»Š€"?^…ø8„  ´h㄃ 7lÀçÐáÇ ,ØÀ£‡8r4ÁË„#IŽŒg¢@¼“*=tðÀ FO3ÌÜà©&F19ŽPɯ€={A…5z©QFöb0eJ/T¨ó Fmƒ=|[¹â«ÕÕÿ+× n 2T¡Âµì±ªá„¨*èXrïöòÕ+@@†À÷æåË'!_}‹éCôXDãÅ“)çÓgØpz›[ÐëL/Šá\¢1‡Ž:—>¿V¨rýº5ë_"rEq’Ï è.ò ,àDƒ{.0Vl(ñ¡‰ 7Ô\sãÆx>EŠ,yÒÄJ•Û9vˆSæLñ3xÒ ]c<~ñ† %šþÑ¥E¡Ú“z•]«÷íá¶«¯ÂúŸ~ ‹´Öª‚öìa$¸¨ìQÁ.y𺇯 ÿ€øj! .[ÌÆ‰Ì1Õ(«LŸÑòÉåzäúŒžL{±´|lÛ1ÿ }f›mÖV ²ˆÕ\°-'N‹b7}\àe ‚Œ"!…,:¹ã˜³H§èBò žêJº.»”¶ ³ƒÀ+¯<œl"Ï<Œ¼KÓ'õˆz/¾¢ØÂ³¨¥š‚*+übÀŠ? ÿãê«CÁÚʲQ0-µ„r+¿y䢋»ðÚK¯Ns,0ä Á0Ä ¡ìÄaÅÉ,»Ì°ÍâÚl³>mIÛœØu×%sØ`ªí4%uÄL  ÌŠ4P¸…,’"å–óä¦ç\’Î#1Ç4i¤”² ³;ïdjó&ñΕ3:õØ»3Ï¢œ4¾?ŸÚϪ{«ÚJ@®þ;”À¼Á "ukÿÏ¢¢ºT(»î"C½üL0¾³õÕ3QÕV+Ã̳iMÒÆLv"IzrãUÉ\\váW—]V²å_…åEYr¹LXÁJ溂ˆ¹æpÊh£ôÀô–$ìÎÜ.$5a:w<šÌ‹&—À´Þxóœo>«òÅ—ª±éQôÐ~$pƒ(0ädË-ýT˜G… Î+bˆ7¤øyèù Âc,2V=^\ÎNhòÏ:‹œòœ°œ×\œÐ\s–[v¡HDÇgeyû­cì©Ò8-7PŽhŠ.’3ÍŽBúò[pŸF³¥©eª [uσI#ŸÖs϶èu‹^¥ì[Š{Bˆ*ÿ+F¨Ç·úøEt«QÔ¶ @ 1x-º›·/†gU Ë –Ð4¯½6õÐC8gŒ_åØDŧL3ó€œ<Ø„Êr—³œåÚÀÀ]ÉìW¿(‚*Š4›Òñ‚84`¹x¡"WÊRìš“-ŒŒ iaâÇíÆ´’q™);iÉšàTµ«í¤vu"ˆ{¼ÖCûèk?R¹Ïf¢¢î-j+²À&òÍMy”JÞò—÷ñM/›ê¨ v‚y¨å0‡[•dü÷?à†„Ü=Z P”{ Í`: ©t£sŒ~£Õ±nZDHÈ%v™ iK˸ 0.–tÄ\Tÿ«›°–C㥤=Aéšè¡Ô”²Š~´¢6ÿÈ{I,YžX>ó1/8ˆû¬x!¿i‘â‹àìQ8Ëð#Eÿ[«òa2“EÁ˜(ÛU’2÷@gnÎe¿fÌ\ð‹^¸&t¢Ë™ÛÐG¹ˆÀ!ÄD–#»£1@#.aIH\дì8%.œÎ urµñ¤‹M´S“Othw … J>z9”„qÒ(*Pš"$.*`zÛY\Ŷ¸%}qQ_¦à1[rj—'A/+±`–ÑŒ‹9VÆ^ä+hrnŽ2“¦4{ñ :ášE(‚g#‚"DÞT>¬H-Q«œØÚIÿO8&ì´ð»û’š"y5à¹ixYË¡»0 @ +XÅÚ~8¡*JÞ¶ ¶ze‰­0Ä\%àJ¶0‚nDQ\N—õÅÀð»Püòâ—{xŒÀTŒd„IÿaÆc--Ëdš ›Î´Ž–µfN³):t° PŽ\< qŽ“ZEsÎ 7‚HrL-åSí…ðUó_žK%€¢&ÀójlbÀ6…"+¼.*MF,EÇ sÞ"ÎaÔÒkQ-© ‡ó229ÃnC9Ô.Ÿ_£™‘‚¦q°pE/¥ (ÎËl²¨\‡àgÓ‹Ô”4ƒ ÉR»º27g,_õ}îBYO¼ÐBS#U#q"°.—,ÕNHêt$‹@Ol;S'–ì!×òaYO°!,€Fi´œ*âhö‰2{ôZÙ,=!É\ [=SR»o<–’)•´uæøå?Ôæ?†Î‰ÔbÁgC7Eõþ6£@íÕ+U5_?Í0_Õ5å_}ÌéjDDDDÞì–½„1àÜk} Ptõ ° z¦gò#z à¾ì2Ó"žcŸ\0¶Ì…  çHa‚3W¶[ÿ‘\c–{*Ë•I£*ݪQ®R-& ÆèÕ+Y ^7ÃèÒ7TÞŽsKïA/6-8å¼'.c9=ÒÓëë<Ë:”%AÒ NÀÇø”bÑ6o0V!¸QKČ̂'j;ªÕZ›&ð¶ÍÜ3&ì åþvð(IÅu ×4Í/Ï6Õ¹žË*ÛÕþªçT½2ç•@‹Ö^sSÉÒ0N°îÂB,¤ ÈA©c¨Öt)ké2ky¯uwo÷zµW÷ˆg׈OÚ€}òhUœÌF!ó9n ‡¶&(Óó$ŒWoÝÓåüöe=“>ôRÍ5S;Q*¿‚ÅåXI-ÿ|v^—b$wr…¢Ý¨âr±°|Õ·U?-BeÕ}0"¶V°.ÉScŒ[—ÉêB;9€Ë–!Ѷ—s”OÉÓ<ùÌnãAx o³Ã‚ßI$qå•y7pŸwpM³p5i&ê·gEõXÀAKRè˜,wsåáÒúuøzÌ£d5p@jûªˆ¦#“L˜.ÒE&ƒ/Ã3 ðÊ6uœ%…‚¨€¦m+‚ ”‹†À¸vøA‚I,ž(; àiq[UÎ(“ÒeES-õ>ƒ0?©×®÷z¥2q…N®œh|vŽéXX`Bé&FRQÇz˜ûuÞÞ'šÿ7e°Ô2VVÈ\/KÙ”~Ù› çnÄEpäE(#7² €ŒO‰ø6#F`|`Dà&K¨ÀB¹"x²N QäðÖŸ…Ò•ß³€THIPÆ0h&lplW42À^´"nà&¯ÄÜÓFãv! ¸]¶ÃúPB=£Š•ÛL[Ï5Ÿì‰ ¿uƒ=8¡é11?9ÑÙv¹Ú¦?¹ó 挎d8rû ™A-£×Ú‹R-AÚ™#r,48aµÿ ¹®ûŠFTºpÖ" d:œeÚdj…Ve6#4„¯ÓŒ•€å"zT#žmr×é“¢BrΩ5xE ª¹Ø,Ø…Ü#ĸ†d¹ƒ]zw»ZçDSo$R³„¹Æàf˜cX®Y@¸ë¸Ž¿h-€öJû˜€ì‚|ós;ÚÞ¹}Ûž€t@ªª»±ÛAtkEzЉ G¥¥G38ƒ3h$7œAž@ ®»»™z:8T !F “é”ËMµòY©é–Ÿ3Óx}j0˜4–sЃ/õ/ñ«mûÙÏ%Ê: ÆêJ}–¢ßÚ…ñ8i“®ÿaÕ£á¤æÜßÌTS˜¡fœÆkœÆ÷!òq{¤¤¶FF&ÞˆV&lÜÈûÁb M+ž£¸žÅ“Ì~ n±f©©u¶Æe‹‹÷´)XµûV¯:–½o«›²ÂíQüŒ°ýRSQúå¬5ºæø¢G<›-7››£ëz‡¥ùÄû•o.ÄB–ÀŽœÐŸ €>ÍA¿4j3fœ2Y@Hžoàâ" An›ƒ”]©GÛZ+˜êÏä‹g(ƒ•Ì«™ÒRŸrÂ׸á«-×s¬w{‰æ/-ÒÚóz¶ÅãUT— )º67š¯7m d$Þÿ y°–@ÐýçžÆ p#=æ©ñqìCú"çÉVìÁç_僾€ßB€æÎ¿ëyc™Þ³¾KôÌI •ÿ™ßuà_ù·oë zÌñó–×8w9ý"ÏñʺÜ͉žHޱ”Ø…v…-—h™¹Q¼ïŸ%?ùsKÞÿå%åŸÛSÏ!«?Ñ£E÷¢~ðÍ€.Å "_ò)ßò‹BÞ)ÁɇÀë}K<ßGßúîvËU"ª×‰(^ƒ±š–m9á}°Â¢ƒ@[Lt°eP @ƒ šð€/¢D‰?Z’P¡ÂŒÑëc£y$?†`t2„ÉyôæpyℼKÿäÕ¼‡“ÖbÐ;qNy9qâÔѯŸ5L›:MÚoÉ’&R—´8qõ*=zöìÑ Ê¡÷š´Ð@OCW¨NÛFKŠBEW{ˆؽ±àƒúZè»áï†ì28<¢Ãˆxñø1.rŒãA1AÙrfÆ”=$ÈÀO¶<™&mºôiÕ©[Ûz ;6ÁÙ³¼Mж ‚ üm_­‰©"VD$#Æ<2²ÇÜžG‘¤3ÿ@/¥O˜1cV]b”À hUhj”(NF‘*mÛjÕMNÔoqv«½!€Š N'¤EOö°SoõCÀ\ùÔe× 7àeÿa~_{1pƒb‹=ö˜ ’Q†ÙePÄc‰•Å㙀&šhžŒ6Úi6Þèšk²ÉvPm¹ýøÛ@Ÿù\AE4œDTtQ†h4tÏUgO”΄v(9—VL3ÑD“MFݳ=*˜éxcuTRK%È”|WY…•ÙÀE70@ :è°ÆXf‘g¦=^$M¢Š*ªNRMt•?uù—„x˜`?f‡ŠyÐXe’E&"c—¡¨ÙŠ «ÆZk²ª¶ãŽ=Öf›B¹ò¦+C¼2dÐDøüÑ’4¹Ül©¬u`‰%=Ìm5wÝÑT“šdÎcž™ØâtÓÿ=°w{oÂ)çÆ,1ûð o¼ýÀàH)[¡eÏ òÊ«‚öD*‚] X*p &_œrÈÀ®8êd—‘xªe+¶øb­ªæj¬8ÞH+jµ¾Ö£m>ê*äB!TË «ä`TÊv„¥uÐI']×õŒÒv×båTF•yæ™a’9›æÂgRKØ'û^Íç>ƒ”çÄXóÉU’|—„v †©`„ |XÃ#€êXdr» ª‰¦n†ªg &cß3¢öqޝ‘62m&ߦPn(ÙPãÂáSäö2s“L€%s[vÄ\Lxé"Ü—Â 0ÜáâÊm7g*žx"d˜¹ø¢h­šZà8†\Zü¯…FÛÉ»&dþŸ5þ°Ä{¬'iDY¸Ns €’æ|sÍù\KJkMÍhà:Óñæ!¢ÔÄ&ê¹ÇžÞ5¨œ |úFd÷»E@%BP‚„‚ñC"ØË]†©¾XhSlCŒÃB%·ˆQlES•£õ•†~î³­ä7#é~‹+R〃™‚<Iø°å ѤðÉ‘KF²¥ì$0ö Éÿ<40ºÑý[WºrÖekm!º’r‚j$…Ô@!Ô•l´Á…ða¤$E¡Q¨0×»Pa²Ç½€jEA$Õ‰R”¢Êψ.HûƒX¹ï‰©‘_ý7EÄI! ¹"f‚3¬áë2“ÄÈ ‚9n„€Hæqi¡:Ä|‰KÞÍ¢©I*r [ VW›„ëƒçJTP0ÈBjÍã‚ é¸ÈP+°á„p¨0¨SÛóábâ&DÈ ¨ˆüä úö¶¾(ÖÈc«LeŒHFÅ*‰–VtHƒ•¤áÔ‹ rôaæÓ¥ÎG˜i@“%,)Ý4ñÿ5 쑃||Z“òÁŒSv€Š3ÐéàA#XÀÌV0 õ’†ÑK÷8ÙÉð™ˆ2£TÕÛtÅ·Ž}M< ý`ÀÃ)”¡ å_C<ƒ™ÇÇÃê%ŸFD€‘˜íèG~¦¥gÂq®`T4{Б¥Ù"ŠKÿ• 0À;!Ô¼‘”<à´)0´?ôÑSwÂS‡h*^s‡Ý³“£º›ÅRåÙ‡<4Ym[«h´DªÚˆF|#MÛH†«\)Ô–·ôjmÇ:œTÔBfÇR+"(ð[C`T!˜€Kf‚—8“KÕ™VKàøÆ9z‡Lã¹£=Îó»fP*õf ¡6ÿâAEPk@R¬–¨9òAíX$ùb=´Q¾ÛÓ‹&1ð™j¿SQeLð¶ŒV}2rÕßX{`öEU4 ͘ozƒE+Ö¶¶ñŽDŠPàXÞð € F›…'`ArO\®çÿZ!‰I óÿ޾À÷ºðKjdoTðæ˜¹ùi>ÈÛ¬#,×ülâîdþ%>ñœWæš–Ï^¦‡×Ô̓Ýuoý |¢ü6{¸ÿuK6CxáSxá{ƒp¾·dW_ ã0ødkýu|Æ7|pÇk§3 fÀæ|(¨+Õw_ŸrD1(ƒG*›D,1ÄÇv»5m?­@9æg~y6CPFÉÁAppGð%…ñ—\ptGž“'pYøF‹puÑ` ²pI¡t±'5ÕÕà=`oP“uñQ{p² Ã{TfGTôDO¢Yp£ƒÄ‡|lWk"È"ö"t×! SZ*x&h‚Y•Y0ƒ3x}φ*›7q–e ˆxâçƒ7Ð ‹4g~C€Š­”3<°È°,óÿh`rg’RoôyDs©— æuddX b IÑ ƒô†ðÁ €=j€Õ€ýÐuh‡OFvÈj…ájè6™¸vlˆÈGŽ„Èk†(Ht‚¸ŽŠ¨‚|§I pˆ$çe1È"ü@q“‰Wö£‚km©Pâ7s p0„$¨H­øƒ àƒ 0 9…6q-w„:0–nÆ`2€(PcdPA²30•D'ÜÍ3’Ò˜^r˜XbCCvØ ÖÃ{ñu6î|oÓX*Pö@Ž!¸kçè‚Ó׎舉‰'ƒoC•SÉ"¼¶œ$”þhkçñ@ÿ”DiÃK£ˆ£Xg¦Šªs à–oÙ n—qY„y·85hÁù÷y ÙSÃ…ý€²“Ê#; ’‚Udt/à u3ùB‰Å„“Öã{°¦”ô{z¡Yà8|ãˆ|Dy”"Ø1(ÝÓ¢ ‰!ò8‰õX‰‹aƒ8Ø•Hyk¹YŽûQkûŠ?(ŠfsHP~—n‰aoIo™¨8”—¨s…éF›˜²Ã B߀BŸ–ƒ 'â/b‡£F“Ô0ˆ€’“ŸfÇ“vñR_Væ:h”a)š"qWJ%X‚7pˆé˜šZ•õÿ`öèY¹áˆ›Å7ŽXf`9”*–f–@Hs@œË ‘oé–©0¢Y‘ Z„H@Pø—2Öu0VKðAæ¹€NÁ˜>ö˜Iá P‡‘Iñu¿µ­ŸG:ôôjgÃ= ·Ú›`i¡ö UêŸsDTÉš¬™Ž\* Ö'R)ƒ@9Ž7H¡iú‡'"šÃ·ú¦eI9?€g† Š†œÈ)~$ʧ"ê–͹–HÀ”w-ÓÙb÷gOž7ŒI±cј ˆÄ'Þ°ŒOñ£”ƒ0C¦Öž`Fª“_I*vNZ¦ùYo]ñ•rA”H9‚,R Oyÿ‚.èšµ:•¹š«(’•ßóp· l:”:(–« §`åœ ‰§>(Ï ­ Òê§ @‘ 0õ…£³‘^anäa W!PQŒŒêÜ ^ŠÕ=Ú’/ùzmÈ€‰©A:Cˆ íÙ E ª¢JhT™…ÀQ”©šªöp°yÅ›‘1™ÏF•o¦º2rj«/x}ã"mhze\ɦœ(ŽºªP”–vŠå·œÎ­ÐŠaÔ*¢ÙœØz‘€@01ù:놊Úäe®L!©0€ý@•j®ñb{šª"0í vEº@دUK=ˆð´K%V"%<ÿ%k°P1™[}±û¥š4¦Ÿ`fZxù‚Xk+qć°y›ªvŠꃼ´§-+¸Ð —2K³F8ÇUëv/Wè5‹j®j; º€6Úä)¯é¤u¯€“æWµð…W;°—ŒÐ!%ÁºÏ1$+6¡ÂU ±Êfsç¶Ìç¶öl.‚*šÈ×ÿ(”‘A²©ª,äKÅ—,;¸Ñû¬Óê–Ëi½EhLÝ–A‚£‡…¹®HÛ’àéä‘ P!Sãd t¯þ ©Ó˜úðlN+¶ž:s£[º|˜óp E"1´,ðÿµz+6“Y»}H•~W±ãw^¦±ƒ‡Tüù°v¶Æ›[™¦‘Q¡¡Pòg•²£‘Ò+¸/»§Ôë§s9Ú«MÝ‹X’Ž €†Ô9ÚÆÓ½èe˜4%©âù;—ʹyú06öz¿öK!©vµÑ%p%`b[¼ÅPˆ@ÆdL®«ºÕQ”XÖ° \»§}Õ‡±bˆ¶ë»Û§•Œ·«êÁ¢âù)¶{Ì!|pŠs™ÂÓ½,ì²ÒJ¢ÕZ½Ø;dâgw•¼ˆ…¡'’&é à†mcRä±îä°>ëgaåÇW¥ål Cp¯ì°ùpß–WìËŽìÈîìËŽØþm'íѾ„~Ð[œÅ!Ah5ÿÌ¥}h”RŒ@hÇ4,½ÒËìæn…μ,ã.ô}ÌÔJÏóþôôþô‰ï½íÏZ\W|ÿðFsc/ iðYؽ?ñäâòdëPžäðð¬.ëåMë¶®Vî/Ppñåù0¥V|} ‰½òÿ}òÉnæÌŽòÍþ숽æ÷À„Ô>í]<ó5OÙ—OÙópMƒèOîA¯Òw)ú]Ø--Æã®Ò¡/úM(éónéönÕÖZõ½ÝÏ5Nb%¶Gv.>®ãòÐɸjA gAüôÐ9 ’öeßäl/ñlÏÝe±äµ^ëm PÐ*€ý?;•Õá90m‹Ãnìÿø‹ŸòèßøŽOàÀæ£?ôñ/ÿC¯Åwibö?úù_Ø“7yq« ‚,ŽDxÿ0 6LåðáĆ ‚HÀPãFŽÔãa„y%OÈCyoÉ=y÷\.S^yKšÄ<ÑâÄ ôTÐÓô½A[4qÉAéR.“6iÊ)T§÷šLµzÕf“ÆŒihÅ^*È’-«â=¶Œì…`tâ usì«‹Wï]#z÷þ½Øn…1Àp/ábƒåAy„Edy6–|9³eÌ%8° æÅG,FD=‘âj;¾æ˜`Úµ!y‘²êK«6aÊk±¤æ’A}ï©¡(Ð-’2UŠôžÔ¨Ó£b½jUûUîW½‚UT¼ø¯;wÒ 1^ ÿy…çè ð|¾€Û}€˜À‘ýûGè?$ð JKȲj¬ Ì2Cðˆ‹"ªˆ5 +j #Ø`û¨6ÛJx!¡ÝœÌÓ` ~úi< ’;ê9˜š.©«£;—°ë®«¯Ú/(cN ޏæ±çƒJ0ð0»Œ€²¾¾â£o>¼ 4b0ºÈÏ0þ ür¿þö»GÌ/ü/BÆ |ÍÍ üŒ…Nû YËpC=­6‘H·r«jª%t*Š'žŒ+ 9匂Qº¥fTê)©Êq»é¦â´»&¼úNƒ¯Œ¹)&âæ AI :컪¼ë/½¨ °,ß{€¿ÿÃ3sLU3¡ÇHãìÍbÙ”³F©Pµ ŸÅ“!×\ÓPÏÖê©ÇW´5PA_ Q¸âÆMQr$ÚEÉ<ÿ"û¥É¦ÃwNW¹œ”k÷ÝJ‰† G§¦JÚhµ»Ü)~Oý@ F•¹Â>xaÕîkì.ͤ¸¿Š)¶Áa5v³³ÐHXvÔ ~B‹†¿¨döÞ³o>‡¨gçCx¡ó„£¦R­·×˜®¶×Þ*è(5ú9¨Æ—®rxÇÏ´iÎ;ï7†Ð‡h„V0ýê¼¸Ž•k¿ð‡5K¼X'ÛÕÎt6Ùh1ÿqۛؖ»xÌwv£Þ04¼ é yÉSÞ@à<”`;Q‰J†ƒ=›ôF'ÚÓ^NŽ")É…ï)CÚRÜ•£¦ŒÈ†ýšÇû†@P ·8‚«ø·?­ý¥/ªƒ^ÿе[±Î0LHƒ¡c-4·¸#ìA»=«Y&3Þ_“‘i‘q#C¸@‡B~©¤„ÜY‚ö”ƒÂȵp^›“S*‡>>*­†8Ió\?a@ˆ ûŸ•ò·:½,±.I|ì²¥ì !B[iÔF,Ϭ Y’i`Av<„‚Åc*§!jmq£±§3•4áQrÔ^s¸3CyO:KcaͪÔȘ§‚€$0„ŒŽn­H Y«!rVûpd•²y«®±î0ºÊä1Æ µMñŠ\œ)'ˆÊj©2•­d4‡`€šÄr%Œó‹²OÈe‡hz|a½¼ÇKÿé± 7ÚT©RÄ ð~áaü(à ûéo‘‹4"çɽ` ›w‰ä$ s L‚ AjSPJÉ9Nr”%HMð¾HAwÖeíŒ_‚àê!ÅTW)ŠÏÀ²=]^埓3*²rÔÉÅ+•rIáü8T ˆ"€ŠÞ/üSØ5Áº&€9è8aÇR8©TœÁriªN›¾36gäAJÚ¨3ñ,DiQ´×4§FgGMÃÊÊÔwiG'þšÇHxpABS~iÅ Ä*UI¬Mâýhµµ÷ “R¤âJÙúÖ„¤&dòHß°õ·0ÖuŒ¯Bˆ %ÂC)ÿ‡mÁoÛ†æÕ¨U*bY8C‚6ö9‰ìH P›æ1“™ñkÅB&Zѱvw>SºÃûª°•í´RœÊ¹Z5½Oìd¥Ê `€Ô£¾³¥­m­%ϦPŠ[NpX'ü–¨„(§²¢>x1¶…÷hU?@ÕÉò`¶ÖmçV5ëÕÎ"Ò»¤ íÿB\Þü|3XJ/k§ˆš #ö=@}[ãǸ¾Q¶llcü žî´ G € à5éIp{"Ü׸Ç] ’Ûà}9¾që˜ÏÀà8d×þ@ÿ2ð€ZÔ‚æp±]ƒ,­ ÙÔÁ A¢¡Ý ù8ºBP`âÊ)Ĭ×.½÷.Q `ß2¼ä1ç]6#ÿˆlR†]hÒz¼E´u5‰vÐ’õ9À€‰¤1·Zü¤6 ­l<“Ù2_6´‘rgï¸ €¶ñüq{ÈxÀ(pîŠg•C¬äE\'ä"ù=è‡^¢àÒ˜Ö´q9 ´ÃzŠ;T_}ìYoêÊ$óºaæß˜'f2ò°‡d$îp¾|¶¼r_ÓÄ5Sqíç@ýÑsÌQþro; Ï÷xǯm€—þðÖ?€Ê½Mèe˰¹´ÿÉ·0¶²ô|=¢ }äÂ÷wýAïÑ#éDÑ%‚‚#¾Šœæj,­‹@ È*ìÂ1Xc&¬ÂªB‚ ¸ºP8˨¯Ê5\ÓÀë¨IŠ»5aº6ÂîS6™Ã>ìcA™Kí[AK¶fë³Ü8°/eãŒp@Ë»+3j¥àTÉÐpÐ%¼¿$”BУ´Ô+®³‰£¨©{*0²Ä`‰#(è:!”¨åAÃEã¡z`’Š"¾¬©‹Z¸ƒ¸’6ŠS/ÖêË>‘‹9ó‹9êKûCoû8`@ÄgKÄ»Á>óîS´Ë’ϼ<Ý¡}xBÐD&ÜDüóÄ|0=LSŽ™”Ø«7×C(è 7È€¬Ëº¸{ ˜Ù` @¥ÄE Ü  8€ ¾4£¿8¢Ï"Fûx;-‰;Ùa>»#¶¹ ˜Ã04üeS6îë8HLô¶»6—+9»¯<³¯Ã#£lÑ–1Û "Bù¡D@ø…ØÄ_€GM¼?ðÄPd:]b ¡©¡ÞàÂ2Q È €"Ë€„Ì•p¨ Dp@ XŒ8à h’iÊÀ¼&¯ñ)¹5ãc»ã³ÃlOR±’ !ù ÿ,éÿGÂ'° Áƒ"\¨P!¾‡ø~DüA±¢ÅŠ©.jÜH±Ç'J”h_É“&SZX©¢Ë—..Û„ø4ˆZN;õ”•pì–‡*e‚RLÙrTË¥•n[u=œõâ‹ÚYwVw*ä¨Â[os^]KôÅ—Dþõk­Ø‘6’~yÄ—’ÙVZæßG‰d‘—Ÿy&Ú˜£¥„ ’âó kj²&›mêôTsGõFRŽ8œ-ÅhÕŸXýôW3Úó¢u* ŠwÝy']xɵD “Ú•^y ÉWË@›¶WØA›¾ää¦nF%E§R”%~ræH€ÿVÚD ‚§Åö…¶É+k·jèáwþöQÆ–ègUÌêä“OÍAWè´Ú½¨iiÇ[rÍ…×,Pº×\—úõž’2ééa ÙêgVªŠYFRbö–˜­êX«?ÜÐ/g%QdÒJDÁ ,p7(|Cà / “K Êö „½©&m°M¼Óœ?Ù ¢pÆ §'P|>…ÜŸË ÔsñPkèv6^›£¶Ý½õh]”†»ÄvýLÞ¸,ÐX}„!”îÑô±;R¼Åï~A}ÑÃ7RÖ† Ò5"#`-ö ÓŠpº ªö&¬ý\V(ꔦ¯¶ác˜!´@ñÿVı#K"PM©¼2˹A+¨´3EÖu$Z£Z8òƒ@Nº„æ‘öe©_èÝš{™¦;X˜[âGå”Y™¾=\Áì´O0ûðƒ;?†ðãû 7„5 T<&Ĭ<ñ0¯|óÈÇÌÏ+0 q…t#i7Lªé}՜Ŏ<ɼ¼Ô³Ç)‡âú̽ìAÌÔшVu’GÎŽp=j ÏAžÐÿÿÞŠÔÑØµûN>€! »ò4yÉË#®Ã—Õ¬V‘ÐŽ:1ŠÇì±ÁlÐù(@>òỚЄƒŠ™X `¿µl‹-ñ¸ÖWXh‚¬ôd5B°Ð¯$d·‹Ýj,ê@ÿÂW²"‡)Æ9ÑU„À¾ÄeÅx#ð µÊ‚³@á,ÙÑ‘åä²?öH«ËC ø®Â”Ž>4ñH}DÁÔÉ+‚ì—‘Жüm‡r”»? °GéP§„jù ?´žì<'FxÔQŽš($j  ORã ííŠ{7¹Õ³BÆ›t€½1¢o–ÒôEE}ë»JûœC(ê -«b¢î˜#ðh`8Áþ‚æ?0vÎ[%HZ’–d$†pŠM./38V0x³{Þ ukáq~bQaX²Cð„Ëv Ë >0 |€`#9GC|„[±W·^eχ P@Iÿ>#ŠY(kŠ«ÂÄå¨ì‰ˆâŒKú]çŠÙ¡Ç޶ˆ—þ’gu1eB@&¹‡ŒÃ$b”ÉL‰8 H˜WìÑÈn+H”µ¼c(°p3fÉ3Aòª¹]N€x7A˜!ÈiFœ³¨¬"^¤˜Úƒ e%µ!Ö¨7«¬û P™heTabWÉ6)¾òPÕÜ,)‡?Õe—¼Ôå[+ʳ1*m˜ÅÌ^‘†4+=äI!EPz‹Âƃ+1Œ±¹Æ6V—MõÎWž‡¼YV§ÉƒÂþ4¶ˆ´‚HP'#Ê©ÎyˆÖœú@"ò‘$4ùx Çèö«zÿ6(N:Ñgpð$J€Îp§„JA§¢J¾ÁÌ+¯Œ¥Z#wûѦނkéâ­y€Î5y5šAØ…ÀaòU"÷¹O¿PØÂ‚'à™KcYÐØ{,áð…¯.Ïü.ˆ$IÙ•O’Ø¿9"xó iÿ±w/?‹u]ä_ØZÊ!à åºl ,Ö‘]$˃y€gºÆVDé‘T8Ù+pñ…+|É›xÏzZáП×=uµ”#nÖǪ•¦¸Ñ0š,IHà2€˜Æuß}æëÞÕ£èÒëŽ!bŸ’z70ís 3ôòg&p *аœàðµõ­O|P;šíu¯©9½AÒcÓÏ}ît Ü‹yPÿ°%…°ÃìUõåšÔ p†âmòyÀÛ¤dÊ@‰›J—9'Œn4u #ÈAîÅÊæE1M—Èâò–1Ð.¾ñÝQa²†$91#è‘Ë^ƒÅàQÖK &`ˆëmÀ%8‚Äm È!@>ØÓIÅôŽj AÈ‹cëFªXg ,îlH>Un†‰=)'¨,ÌÏ3/ΑBJ7¬(Btû³sò•e9z¶^ì[æR.¹Œ‹éårf›»Í«“†LÅ”Ä%ø€±o¬æùº<,`ÄðƒP `Äï+ÛšnŸ€>$ðfçh±KxgSs”rzäšËžÇÿÇÕûØùiàÌØfÌÓ6-OD1"•gJË!Vž€ ̲y¯t8#ÕáJFiŠ”`¦'cp!„ønÏelvõ)Çj¦ˆ$àõ† v÷ Ís-P@)1PÄ3ëAkwe0(q2ÿü@}kÁXv¡t<ò\ÊfÌöqîö\§ç?Rö3'€wÓS˜Cxƒg‹´Aù¤8"CsÝÖm7w…Å‚Dá\x8YE(z¡—VìÄR”#Q;]|׆¦‡c¦÷qØUFÈQ£¶W5 ÀœC\fRuŒPòq׈k'ƒÚ( ù@9N¶?ÐY„ ~ŇK0eüXx4=ú0U‰WmÀRRJTX>"2‹GT">ðU[¸>šçÅE.B†Ó# øh×”Eµd9–uÌøƒ®G{¡sWvx:ÈdP9@ópž@(‹4âÈÍÿ·|ŒˆŽÚ˜¶6î¸A¾V)‘ÕTE‰w„îvK5û_óÕ-*Ðqˆ=ò×CU5 ò1¶[–us³h ¹'þWh»¨"+ÂI„òñc_ba€Ž—Ĩ-`Œ·ô—žØ”Êtxo£Pu¦“‡‚áÕ G P°rC1Ãðp÷°|÷‚Ј™ykó€H¾Vi0SÞÑ—u)~!׃!ÇA³FkïeOE8Ñ ,÷r•„IÞ3,y ©'_I‹ iy=7n_Èœ÷Z{¤Bm‰‘ÆPH§¢c#‰‰óÀ{7|µcuøc& ÞÈ€€9ÿp…tèUp?_×|舎›y.¤K;ø7“EšQm~ºöŽŠ¡èü@B±Ù„6q1®ˆ‹‚6– iY$âN1P(€ö·Ñ1Yo¹¡Y(h¨-Žò\ùã‰Ó¹—Þñ\žf‡z¥)vÕW¢Ã&ða®ð“†g¹ÃdÙ3”R™Îç|™¹™íIpZYöyMHº€%—;€#êÅAòT‡çŠHÂC˜„až a?¡›¾Ù›8Wyᆖx?±·Gñ“M65bÑGTäBÚ‚‰ùC’Ó™`ÛrŒ°¢¤?f:Â-ùð6ZT¶-:ú^Vö‚¶ÿ&@*q/(÷pw;HKjqE+†降 ÄúpBù ^îUi¾c# 7©±ª+ô¤11·! :–V–Èb E0¡—·‹P+¸òsÄã=<Ñ•–¼i…$S"À•J˜g¡ k¦ŒF±ÃÚGaq(Ì™YdŒ;Xz¥WÝq„ôP‚©4Mc‡Ü•¢çÒ %@ÀlV}fæ(”™—ó^kד°™V6¤÷` d¡®­uEj*He[B!ä;"𛫄ïhBÅHf ³¶r&¬ŠITZëaWø ù÷ºd‰«Â…gésa¨¡Áj¹fk± gŸY4š!SÆHõÈlÕj’ƒiu±gÇ/|¦eTj±NÎ ®/Šz®W_KSŽtw,ÿôhlšVmê#°¹ÓSº‘+0rºÅ¨~ S&ªŠ Y9z3Zº3'–WK‹ ÙêûXÅ«jé"Ó¡¡]ÁG“ã{#Qɺ}ë¬Iuz‹u›@jõiÐ €¶vRf`ºö`Oå"ŒÆNj]S†eî•}½Æ_À&¬Òq#íú8¾Ó!kC>¥»Á¹6zô€;ã1ö[›º²g·’› Z¼™J «2—©qJÅ¥8y_6å; L¶“¥‘ëæ‘ÀKŠ´wÚ±N ¤§S·W.ª$t¼?`$@‚jkXƦu´%´jjãÂyM”¾Ü´Gnÿz?>Ë($4>Ày"À›Û>E;¼Aù0|S¦;7–ÔŠùK2h`9«bI«Ká Ë‹L4¦XÑ7 E†izœÂj¹-v©H·±:‚‰7sÁq K2²LCL2  uj'ƒ{,% eëôG¾ã"(Äyœç6”åï#E‹ü®Hš‰”Ü{t¯¼¼Κ©é‡Ö#1r³ª²é´PˆZzý+–µè¿ ¦,*£*B»Zá!„2Ƹl±q9IZKŠDéE‡EE:Ä$u˜ÝuŽÉ‚j÷’z,zaZö˜¤dABdöÁ³¹ ¶a .BBÒ¡ÈŠœÃ”ÿßó¹0íô)OWÓïø#t¾óûÎMø ’ -û׿V›Ï¿ 7º8\Îò…,b¨ì'àÝ'^iŽuå­É ºÓ`¥ûãóç´±YûÛÔ4× óÝUÕÏU5œYQ‘aHÆ¥ŽÃþy4‚-ÌM9!>½­.¸=ëŸI¶Î·°j'p`ˆàæ@ÛèwžcÆ–”.›×K‰KK9Q“V—uYÌþ‰ˆž9ŽuòÅì#/~û‰ã©Å¶biÿÂ1ÖNhCÁ  ½ó§bR­‹,cÀ¨Mêa<¾ô~(ñ“A¨€xäÍ´¼Ë {ùF±2ðÖE`žðÀ †@}¥UlBh)ûH„R6eÖEñˆžz¦çnk»€¨ è¦y-ÀM Ãï•÷Ž5eAòçL™9ÎGpÖÉ9!Ê:¸€ Wå,õ¬›µØ :õøIŽÉÁD^Èsi¹8\aS[±·ÌGÉ™ô ¼hðÖbÈhĦbÞW³7ëá˜@ìuð­˜@‰Àv}fcÏû«yöP‰e¢Ø÷Í^i%j´ök”£w¨Éìòp÷¬yMýPºûH÷×O_#MBìÿ\º3oUòŠAäøFÎéGäé¼X»¦]¦=?hµÕÒ‘ÚÒs‘^!Eô/=Š|úZ tü£ðHp`Áƒ .D(> 7*L˜ÇBÞrCžD}€0Ïä‰óR¢\j7 ëi¼<ìåËׄ‡¿€Mt¸Ãá l1ðÔxƒãº%7ö„—A‡#Lð+¯€=Ï í™3¿xüP«NÝzµêÕ©_ÇV]uÿ‚¹î^x·BÞÍþ@ÄhÞ ,îฑD7(Pø@QåõŒ4œ¼¸<&ÍïKîé\²sç “öBå÷U_û|C…ú¤ÇÔ>úôŽ×§•)Uô‚+:JèRk-ßJ‹­¹$[ ²Ë<Ы/ ÷úË ÷Ò 1¼*£Ì.È"{Œ²¼0!žÐâ±g4ÐFã̳ÖZËLµhŒçÄ3Ë6]S­!ÝŽ¡ÝŠ´€¸J@΢Œ6ÚèCZY€C&0θyì‰!¥•\ïž™f²é»ït‰+Ÿ† Fx/Ÿèóé¸y|ŠóÎò¼sNûš:!ÍHã‡æRPA·àzÿKC|0¯ ûº0À$ì ±ÄlñÐ.É&{Lˆób`Pìì³ÐF#íTÚ<ÈÌURuÔÑUZeµõÖÜ‚$r×!:kCQ’…%0ÚÈ2(!:*?áÊìèa$z¶lé&‹È”Iۘ̔§%“|bO6!J=zâ´3¯òÑg\øˆ !)ÿè;ªr ‹Ñ×:ð@ÜàQ¼,´0J3 LÂÃ,ûÐ1AŒÄËfä4Œ?#mEÓ\K ÖZCÁÄ[KÖñ!‡ ò­¡•Y^ë a$¹äîqR€}0˜€‚V&’™iíaDh Œs §—Ä“ÛnÇ+ÏÏíì,JŸ7Õ³ÿº]ª]ÐG„­EðšêwáLª¾?ʽÈBëP€”Kàº,Ã,ÒJ1¼ðB 1UìÃÉ$†xD+>1ž €ª@…Œí9­Úh„53Ì"×Qò’k%u¡Z N ÌDè¡+`dÉb™ãYy ¹‘ ž•è¡cO*†k‹eÚ»š´½É%ûêê좊òj=°½^A„’OÞkD\€OΤæ-à«AÕ¸í„ûÑÈ®T0Âð¶´áM)ñS—{FUTAE FÍEA†¼d’+/yåÝ:ÇÇ ¡¬ ?ÀÇ QÐì%²0é|à?“]»„2a ƒdºÉ=–€ÿ4Å+^‰B>>……j^Cžò|°‚ayˆxרÒô;¢Œ` (P¿|x(¸=F_¢ÛÝ,$> 5LS拈<ªPáEGžùÝáVdÂÉO6°y•­$42YQÎd±ÁæÌȲÌÉWøXF—œÒ5G˜‡!D2¢QKfBÓÏJŽC¬›„i[`ÊÝ=48žñì\uÊÓPJ8”à©pkÉ[€,yIL® ^‹Øp˜ÆÅc7˜KÛ°ç/ÐÅQêž÷S·ï1Ìa|ûëÒ˜õ¡¦pVü]üVä¢P¢fV¤zÜ䯯ü8cY3’ÆüàIŽú*æ‡õ\ábml­q‰ˆI¡ÂÄuǺL¨™Hêíz—È…‹Áÿ©Y­ê-i©àá]ry—üð¿F(Ïä_oø/K$ßO™;B€#X3Ùáü£OÍ3æ9ÖX;ù–~ôtw!Û-T^Í“ÇÏ {ÐáöðUƒ«UO(úÜíQ·~òAPƒþ0AlØEï]!ñaˆReØDõ:"¿uWp„;µÂ5°¥¯Ïãë__¸’ X³£=Ék7{Û7j”:ÓŒ‘fÌPË$Óý·&ß*ɱD:Ô:XµÞzæ¡Ô£¬0·È£9%»­ŠJúÐàæyp=¬Õr+ºéÖ@ Tœ±¼û ©Tå\È’é†â8ßvC"ù²«]'ªOà¨JÁÉ®’Û“vÕfGrÂWÿ½êieø¿'~ ´lñɲ, Vfs’÷œ™}÷»8OpZتÜLáI¸|"A¯èYæÈöòF¼~ ý…žêÎÃU ÷\µ$\P¥”͈X¼c¦»‹õ™|ë´K¢LÁ%ˆ¹:'b¥)úÀRµíp³ë;²ó=j!­í':Y¶îc Ú‰ àŸ4úœ‡(Á"‰¦ˆyØå`ŽbC³ê3Ž”0‰ä@Žc»;dë>«F`¬‘9lB›s¼@¿Èc¿ö£ªžkBŸ‚A›?L|ð H=µIºµø?+½Ñ´½¸·‡2"ÖûžÅÀ xOi@é:ÿÃ/ä’ ,­ã ';ì)=ÜC>—ãKÏI™‡ˆ€Ž°d[ŽŒ8“À’4Ž×§Ÿr>a;-ÞI6¡a |=Kž™Sä9›ƒ¡}R4 ó¶ ³¼&„¿«’?ú³¤ÍˇÎS±ýë¿Q”‡p‹ ø¿ô1)‚ºº!C#Ÿ½QÿY@œ¿’@ìØ@ÚÁÃ>ŒFiä‰g4¾\ûÃ@Då[{È, Êˆ3;+éA<ú™¬ˆIÌ,k²ÄŸB? B6¹lSžò+B2Eö#·©bEV·VœªWôˆ{ð¼Ÿà¿³‚·ç @ÔÓ‹§Ó±`|¥}[Œð·ÿ5_ä«Z+8Ü«A.¡FœFf»¾vÄÁhÜ2”©¬¹‹é(Þ9cù¯é —ÃØ!9šA­œà¾v  : ˜'Ü*? X£,ÂóÛ§}ʰJÂ'A;4'dBàâ­r£¿"¨B  Å(Q«\„7¦Ó¡Nûٷ$ò%bÉ‘=Œ‚ƒÁë` gô@iœÄëÃAK܉“l ;üCä2ùVX @ÇcƒAkšÁG”™ë¨—¨&@ÂÁŸ0xŒ9™;JlKÊš£G|dÊõ“¼oó9¬òG(Ä*¤ª ðMrÏÓ€|à¿E K† À/¬˜ )@Š,à ٠[è€ÿ3¤¥5ܫйY¸°‹ÃÒÊC–àÿô©½ì©vŒÎ–à ÿY A$̳XDHÌoAŽå I6 —qlDeS l1¶q¨}0!ôÄšKÊ{L›šƒýSºCL~ø€ „Ï7.a$-á$åÙWP®’*¨¼' €a(HdîcÌ£ÿà~ äõmÈö5½dä‹E&C‚m=×»+ s]Á²ˆ ¯ ¬–rÆ:\ ÖÃb-V7ÛbÝXÑ5ò5‘˜2…#Ñ™Œ>Рð4´ØÞ Î)’4²,2k¡2³3 O±»C8²àtüɡéO"¤ÔÎYaV4v­j†–J_ªœ<Öäª*̇=SòB²XW ŒEæ±FVKQØI¾¨JFé·+¯•ÎÖÿÆF‰ÆÞ@vÞמ‡? l5bI_ûNžÁoìˆÿ’\G]GëFDÃóààÁB `ê½ÏûÌ^~:h©Z×S|RÈ…\*MÍ #P%·øà?ß²M±^ºÒ+ëD.ŠìoÖ{äİ_clÝoF‘E2ÿ­=–¾ëÆÎÃ:½Sïë5Ax–¦yîiÚ)ø/ xT/'¥Ìo1‰j“Çï>qð¶Ïœu¡Rœê¸ã…~aP]BÒ†\ùƒÏ}YÚÑK%¦kí ÃZ=¢[k\Ý$¾Z·ú®Z;2äB²j^ ã˜îY~ilÄé—±ðæ~Î%À&ç*39-ì3-žä/î3 ÿ ‚OyÄ­z$•ãš{q¦dabþÔÕŒñ…þ6L²WD(… ÓÛt߇$&ÐŒ´6Ó¿ˆí½( p!³Œ‘‰‘­= ðš(ŸÀåDg¤rAÞŽ gV‡€&^k¹–ñ<Þ™@«Ncql™¶À5q69qrE8W~‚<ü\ÒôÆã<ϧS 1Mú*汫z‹ûæ¡‹ÓC½§[kƒ=SXú´‹|½óArø=龂Àßÿ]ðMžØßöôžêåœeZà,/uL~FE„nqµÌÉÄ>a"—Iýn7¯uPÌ6ò3 ð^ßÙaßs…77Lâ§"Ø$˜ÿ~hRCÙqóB»° ¨Ú©ud r~Ã.GgÓ¸îÖK&ˆ]ð¨¡Ëüdsç©•hQ@͵x¾ð¡‰óèrÓ‰¾1»S½ôIl±D4ßn’Ç5'\òãÄN ~g!ns!RvO ´ý|åÙ¤" !8qzp'h$Dðóá‹ïÂF)”LØžÈ#BÝJQtò±…4<Æ’^Ÿïâ ˆSùÞni¼¾C |ç>÷S)fí¬»)#¸-9­x?Þ½+'é´÷Ç>­œ‡÷œT¤gêrÂw¿yI.õp¨zj]Ü8è]E°©ÂG{´üøú<Ñd/dÑ]:…â4Sÿy Ùæa"Ä¥w•Õø ‡ë¥Ÿ¬ÙÅtç·ÀÁgç<4‰?\ÖÁަ »Ï»ãm0ÉGÉj¹DvQs¤?‘à|Ê“:™‡x§¸ HK—Dš3kîœYè!°¶8Ñ‚E ŇWË;Laˆù@‹¨½âö U+|äÆ-t¾_Ó[ZŸ‹ßúDœH‘âEè-rܰÀ:È‘'O¾tÙÒûwî3kvš³çN‰<f7¯B<{*”ÒWJÏ=FScÐÓªµë^ž0\‘ÅÕYXµ—EjY$W*øÐEÁ]Néµ_òüØ>ƒ`ˆªÉs‚dŠIÆÂ<ÈZg" ò"úÀ¨h£ÍÓVXÑcÚò¤Ö„<@úH\q2Ö&n¼-p["'Aó$¤P>.$—œüˆ°@DBH‡QEÐ !ÿÑFDÀÓGBDLßuçfQÝ÷‘-@ùpÞz>RH1ñ_}MñçÔ}ýõ'UôPuÕV]…VW[i A[ ÊõVErYðváe!†}Ý#X`Ýóׇ†™ÈÂa&*ÆUpÆYg/Rð™hXÅ&¯|€_ô”FPŠdZB¹Ðfo>èVÄ‹ùD¬”°‰fÏB³¹Ð¤>Elp‰FÏY$îtU'Ñ©SLñpçJpŠG/¶Q'žé­×Óž5ÀÏŸðš” !@…SíW£>úp£ ¾åà‚9èà? rC…1¨àU¨Vا¢šjˆ%+vWÈjÿ­3ºxœ>±îšÏ87”ORÁ"$¥iÇ {BÆÉ˜$n+üB?7¬ô81[“ùˆàƒD^F—‘¹u´€'ê®i‚Im~oKñ¸É.M6™çzz¥¦v\ß}ƒÊ_US]e•ÃŽzUà€^MšÕ¥mÅU)ãÜ@!ZC_KÜÃ÷pU‰&§ª²Ê‹½:ϰX닚¹#f9ëìú¯$d¨£Ã"‹ì”¹(k›* øÀ[mú0„Ðp8ÔtÑ"¸Ï>€›5>_Šin™ènfŸÛ©­÷ò¦½MB•TÜúò+Ýï:0SO݇0¡|êŸU…Se`W‘Öÿx¥reZ1[2Æ©»àE/|á ür˜Xål4­QkVŘyÄ*f1ZÝA#œÑHxô•¢€&¥­„DJCŒ”Þ0)FùÖ]3$"Õf6+¸ŽÖ4B=êD¯zè [vØÅwNEIÛ:à|éd_rã“vÞs7ü$¥?„ŠßÞ²¢¨F‘%ƒû"à•¹ÄSb] ᩼Pd ’Rh,EpDòÀŠ=0“º=Âhu¤Crå¨j!ïF©±Ýñr§BßýNiÂÖå8`*ãd8ôHŽ=ò±O4ÇkÓ›%t©«%Ñ^¼º÷½8¹„$6© PàæÄó‰Oÿ$ê[ß 5(„) Qð¸†ñﺈZز©V"r‹1*'Üà ô˜Íqd—š:.†+¤ËÇfRGÍ,F1Ò`>>¨£‚Åx$<¤Ð¢Ú܆> %n#¼D2à€BP3~GF iÞºÔÃrñpLÕ[)G’’í  mòby–¨§¸ù{Ù‹R¦h¦Ô‡o#Íâº̯8ŒQb$£âÜbÌM=Ž€“Ã_,GÍÜ@6³ Κ’ͺ’ÀÈP–T"šº‚Ôõq3ÀùªÚšÖ˜êŽÁ‰U)×6ø¼„ÿ^¡ÏØô8˜¡YrVèƒ"X­`£„C§¦ìš‰” ) IÜ•Jð^t%E°‰_e™'ÁöË”êu—R[¦ªŠyq,ß”•.F pÅŒ)˜)öƒV@.rPÙË¢ù@IR³ œ’hò( Æ Â³½óošŠÌàlG®¢ªZeå¢'íèx>íê=-p‰|ÞæHÇQβDPè:o)®®0i¤Ó=Ü.Õ¤¶²Ñ¢qREÉs/%½tó{ß÷¾§<¥}yëßUßúnå?”JÜ(0kLºÜ@øìYŒ‘SË]®Ùg}sB~ňR6?®U9',a§ZXx‚ÄÑh¨ÿEÉJH2§ðxƳ8"š(&.ðfF³ß©+¼R]Ž`—kÓév„rʘì^FD5Éc“êš·‰‚}¥HþÄ{à2Ö$UŠûäg_È2ê?‹ˆ¡&vL3V„³Í”œSNÍœŽ–´÷hÏ‚%{øìªÑþ€_d$ÙNØ èdqjt3‘³6ˆ`kºç}›WàS‹V¤±9o$Qú–žn¦úérÅài¢ÛDÍFdñ"Ü•tú«ž:êQ[þIʻϴéSk+ê'×¾®Ê€$8þüR³ÉL ˜×)›xÀÌnù‘·«Ø…{²Ñ£­`Ëí#ï8)ÜYC¢º,ÿÚf]µ÷‰ñù;U¨¢ò¹À¼‘Šð»ßÑÆš&“êC¯Ë»D4bÚ„àŽuGPB¨_U`x厄¥IÚøÔÀEñÝÇȇ 2Ÿ!ò] ö‡ bÅ"Òƒ°UŒZ` PHäè`H™…ʉŠaÀ?½œi˜ÆËÁœ¬d“¯@^®…1¡**GæÙ’àÆ’(MÑéŸ@—»õŸ†Þp‘¡»i!¾Íƾ©!tÄÞ˜œ2Àš‘©É H½Äx,\yy``y`z ßÄ‘à|$!Š Ôíð¢¬àôñã,ÎßÝ !”Yè Á@_ŒÖ&†AŒÕµÖRÅÿÈiAUÙÙR­"-úFÉ+ªØ+øÎn4Ú‘´’!ÿõâ% ØCö¢»)šÓ9Ý%0ÀodZºlš§m„CáƒTÇ1:™xèUQèIŒyÜDþÄž|„L ŠÔ}d£òñ’ò)¢UðdÃð]OòÇZœã1aLQÈ:âÏðर܇ì±4Ai„úõܽ˜9A·)¤m ’Ø›*Ø[Ò¬€ŠQBAà6šþãB.ZBñß· ˜Ó)DVä%8ò‚0À(‘ FÄž\a‡GÔ•2Z`x` Ú!ú˜Ø´zÕÉPX# Ê] 4_ b™¢ÄT€Ü/Á Bø$‚ÿɘ©ÑÉ•R¨ÀXLŠNqâ©TSÔk€ÓlEÕ‹ÎV¾å)M“¬À¤Ý†nØÓÝ—ðâW!¤WÊ¢WÚbD‚ËCÒåCÖå]zÉ]^ÂŒ¹@ól¤CuäÖm]ÙžIæÕ©±MÛàáK_ŽÀÄGMNQóݤRÌÇòyLP^OnfÂH˜aJÅü@¨ã]\£|LÊYð›q¢ÉTËÄØf\6Yþ}FÑçX’D0ÝpeèWÅbWÊ"r*ç-ÞâtJgEÚ¥En@“ÝuŒ’Ž= H &2F‘\Ú@J®$,q Ú1ÙõÄdH„MNf6Ì{º7¢æcgúÿ’TŠ èçßÁ”„¤"8“=| j’…ô'²¦<D("Äl$$p Uý¡›Î]ÊbodbèpAäW9K£ÑbW CæésšhtNç%¨‚^fÖL„nÚì$ñÁ‘©¡E¹R$ÙKÆÒ¦—Q@H­g ¼òàÏð`’þÌ š…¢Ä'õ½…°‚˜‘ÙÉÝůÌY ¨_¨A‰TªU‘È"ë!öjVÒ[‡&nŒa†B$EⓊ¥òÎ=-gÿhŸ ‰N§ðÂÑ5‡ðÐB±aN H¦aÆI”KBcï} «½šQL&Æ"|æä{æ¤} „±ÿàUôÒòé'\€&ö[•Vȧ؃–*›åpb'Ç<Ê“@›‹l¯ö*ü äq~åmðÆ+0†«œÚBÚÛÄÖÆ¤1dDžXs>¤‰JçC"à^¦K_î×ýÛ×L ŠÇÙ„Ç>ê–WÚÉ Ä¹ñe£¦©¬%Ÿ§ò ¾†‘"–ª¡€™ß•§´ª¯¼g¬Hn @-A%½¦ÌYÍyPýA,ÍèÜ‘èŸoʘ=Å)E6§YÖ階-ˆ6äWíitZ¤ÉRgð‚ivÅ·ZŒ›ÀJbÊD¹.&c:5®{-6š`{ÊG“JÉ’*)¾›”nÖãT©•[RLÿíY̪Նb%GlÜ㮆í×~-°§½õfYb,%Ð¥¢)> Ñµ®W†¬u,ta¨sÖ-ÝVëÊ.À(mÝÖjDÍÄH°DÍnÙ§K–§y Ïš.âV|ž }X&Bª’åÞàGhZŸÓ6“3á }$Û€Ž–ÕTéAZ„&Õ×¢ÛÔ+nÞ+PZè•좩˜r  îþBÿþNÝþ)Xªÿ='`Œ@Þ6×xZuœÉH6ïLlb`Æ›ä(¥:\GÅäº\jR8îÝtc% Ÿ Ñj‘Æåàen\ü€„Ô…±b}Ì4eÁbÎ?ËkÝÿ£>ÀÌúªm*G‡‚e’ü®*À©Dà/‡K,oö†ó o½ùï%¼¯ÞŒ!vjçVš@ÑLÌÄØ¹ ¢Dó¶¤ÎîlõŠOIÐ$H­0 O¦ XYðM€ÅfenɱêúÀ«&…ÊiéÆNU“¡.Ø¢©þvçy(nØÛÿÉ/^, rü‚£­io¨‚»Y$%•PéU±³˜qðCÞ^G¶º(ÌÆl½±^-cJÚhbÂÒMÜqžÌM¿|ë¥f*»L÷_|" óÍpßðÍ~]„\d ÿ«çrŸÀ’&¶\üv¢<ÀFl(Ký11šBl‹<Úî knÄrÇÿ2þ†îDšŒ` Å&Ésº[ééƒs)OLé™1/,‡ïô¥o'G¼áJÆá2ê•£>*y!³ 3Ù×9öÚbýñÀŸNÆ'’Ú—|Žô“†™ÅÌ…"¯cÎÔÇ€ ±ÉHò‡‰ÂVЙ"aVâ4ü …ŠeÙBo´Ò¸€r-,r1ÅÚâÙ"`>œ^•XÉ/LZ/¬ž+Û²ëáòc°HªËº¼qß,Â¥ ŸkÚÍÍ¡'H1s3ß{)_53_VÈOª2Î(èð„hFþ ÷ÕÏ vN$ iù‰±V²ó:¿–ÏÔØ&ç+v±ÇÖÆž³>˜²W¤bóγ„¥0WLÿÍ+KÚ@CWUß2¡2TV7t)Á¡LÌ!XE¿’K:¦YÛ­—Z¯õÝì¤ÇÀuI×ð 2ˆ1‰™ÉUâ E#ËÙVˆ'Zí`$è®41&†NK7¤ù£W"p“4IðL w«På‘òNW6dO‹Ô,„•lË@§wtKºhÚapõhpw½1Á5ê÷ب‰5l“uOpWF?´m¯0n´S )/QÅ~$¸IÛõa±ý×±µt&ᇀªæ/w`váœtŸÓaS÷£¹³*"'åéC˜3s¡shÈ_|@‹;µŠ –èCÔÄÔ ‡• ´Ð8?|ÄF†ä­á¹84Ã10Oÿôî±$ú”ðÎζÀý‹» …G7³H'm Ãu~=bJKˆ„ô§±ù #Ox^Äj8› æöË a‹«îM8çIèe¯"rOg£¸‹ÇÆì°˜BÈÆž/:çFm‡°8DŒKš€Ør{“ÉGÂ÷VÏ·/‹›À¸Þ•Žç¹êážÔ u±¦FÙ€ç6’šªÂh¾"j^Q:x+dŸ«Š9÷Ū€¾ãÉ`N˜Â¡>Ôf8õ*¤Eì¼qžòàq7Š/Ä´‡ž7»ž+ ¯€)GA DyW‰ð‚ D £gÝB3´z¤6ó¶žš»ØÕL,9ƒ öœ’ÝHù¨ÿ ­é$ßÜ+¢ &’:â~]ŒÓF@±¹êL\qs´=кV0Û_HRüØ*Êãu›‡ßtb »{^.œ¸°°X¶HËž³l|¼BÄ‘o µGGS'GÜG>dZ¦m@.G¤GúGˆDó’ ¹7jážD¹¾RõÊR1's¢†º€Ç;‘z/ »µ :i dVæÚ5§ü;^|R | (Û¤ð _‡`dÀ`ÈC PUp­3mÑÅS<ÓzBd‹S7IJSKÌ­H-R] Kº¶äCL ¦±¬ŽË.ïDwž¹ãª¥¤™¹†MY£ð“K\¨O9[[ÑNv¦ø*Œ!ÊÔ‰ÿæ,€¿Fxì0rH%[–!|—žyæœ `P›;1O¼ç55í3— Ë“øŒ75•x¼Ì%Wmè†ðϽq™<•¸€¢#Dh$väÌ‹RØ,ïJЬ÷3â»’¦3FWê«iѳk|JÀ’ÔSŒ4\*ªKE©Ci9n™iÀ²¯˜ÓúòÅuér{©d€<Dˆ†ôD¤ï`BEtø°`>}ùòEù%=-B´ "J.Š#EVådH"~­P%BULEЏˆÒ¦…G'ù ¸ÈçDƒ½E0Xa>|I•*²té† 60°ÚÁÈñòÔ\w]–|Š^{âs!úºµGŸ¶ôP¡°Ð­ÒJQDMà…ÿÑ%|ta ïŠKÓºêºj­­@ u0Qëµ×ÀfK5UOUUUÊb U³ý4C>è5^í© µÃ4xm›¼íÝ’% à‚# ¸ãŽ#h9çqîÚ‡²%3£ì Óðò)xµvM4Åóúë\Ì=s\ŠÄ—xÜÓ ~<(j¿û{ Ÿ§ ÊP4KÑ-‹a´<ÀªB !ŽØ.[*­8~â1DK”¼TactÑÅÇZd‘•9ËìÆ"¸Á´—MWmf»Yai[Éc}&ÚI&wãè¸h©e:Ë-#ú]£°»î£¬ËÚ:9Ý‹óÜ\ºv¡k­Uÿú•ÐÁ(Œ *Ÿ"ŒŠ;@»£˜@ìj«°VØÑH!œpp /”+CL7¬´ƒµ>œÔþ3Ld›Ûœd(£‘“ŽF(S h £Óì u(@Ç"Ã:a©`g<[R²„–yœ@ ¹›–Ax×ßE§#ØÉÉ YØB./NbÛšÖÄó šˆ‡9,‚ …œèéß#TˆØ©j*3X¢ä·…½+“ÂߥG—ûuhŽ»Øˆ0F™uì0†1•eA2ʰjŒ‹IÙ¸ÀVPà1‹YC ,¦HGŠ]nzvàØŽ8Rb E R­çœ0:"ÈvŠÅ³Èc…ÿtaN܃øÀÐyÎ*Š`Còàp‡.(PŒAxˆà{üñ 5 hR&AÁú¸ÑëA‹bK¥æ§©KÝ¥Bz‹¨Dä¿QÑ€“Y‘cæñš`9S2´Ñ¬Fa+–!BÙ„ ÌPç—È@¦Hö€ ìxÆÇž ‡YœÇ³Žc%å@Ç„ˆdNC¬£ÂœHr’+ĉ{Zȵ\üâŸnúE/bòÉ¢->@i=øJý P¬P† •…å+ “Ѓ6:)Ký2b›fþ>Ô¸Çõ…rÆ´‡aJÅ9ÈHÆ¥‘) ¬<:|„†t;’cjdV3 é5­ûiûXNÞè’9‰ÿ´®$χఠ(¹ÈŒw¼í\5“\Ój&ÿP5¡IMçÙ!(ÉË(@(‘ÑÇÛöµ °ò_­Ôù䕹ÀQ€ƒßç°¶lÊ—²E0ó·´èiD|Q,Sj"Îý´uŒ™Ì«“ÀI³)Б>$`:žÒ±c„MPZGT¢+7KºGmÂ#‰$Ä©‰lˆ¸¸4Šœi«™(»ÔÔ €þ“ ÝaY±G'@aH*hè\!ºÊ¸*CI\\ú V–„-Œ£ï‹Ã¨˜)+N Òâa‡)” €ª/­iMÎË^¾œ×D®K•|ƒN{°ÑFÖüÁJc ìêŒðJUÿ3Á Á¦6À'QËÙÇÔÞ#©ª!ä Û…˜ði‰gE.¢UxqÕy_ýíx“T”sJë}Øz箲•w» ‚ 6!'þM»Ú®¥þê]_Æ…b…5ì^ç>¾€ÉîÇy×Þ ÌL( Œ|é[GYa³˜±@+ ašÎ¢FÀϳ_ž" #ÁÃbpƒüÁÙ‡±MdÓRg§UD†æêÖJÐàÚð ?ÑÀq¹ÅP>ÍÕ0®[€°¼]ô+.À¨£6¸¾ÆïaTüî]Fê©,¦e¼E.i·d´TàÔiI‹ž"…بàqñˆ2^Í—¦`ÖV·bY—]Æ1ÿÃü:05SsmŒÑªÚÄÎX@ímZ°ÎAÊÙwñ„ç<›6®<ËPlÙÖ­o{ÜN{QÀZ‡t‡î'@Dä×=!]ÏroìÛëßêµKÃÙ‚.,W¸üaeRSu¨KÃÔ¦VõÂî>´`š7º•R"@DÀ ÌÈ K‘ ˜ã¤jœK¨c4` ròìX)7Öç K$ÃÐFTëÜåÄz΋áγ]ãg¬Ø+·Øf6ЃÔßk+ä6¾S+µ%ßÚ§W[z´Sòñ¦×u &è€ØÁ>¸YNì²ÜnáÍp·¿=6ºuèHƒqÿ{¥b,p©|‚&$wzÔ`’áÑ£Kº;a†³ôÇr9É*ˆ5©¦NŠu¬¼ð ·¤æ½ˆ8t[áúÜ©¼–^I_£Ÿ”ýowê±9’25™r@eÓ@µ4AW 6E€"+qr ?ñF |Ýþ`¸)ˆSoìÊ–’“ë”êh¯pPTE僑:§³:‡ÑE±µ³Fiô¦~€Ëþ«& < š Øx4=ñf†”2Û³ÑL¾QIW«bÀåº96±ªô?Oó °TÔU} A[*w(ʯ fP+ r2øáPC“¢Ñ0ônˆ3+dI/޳QøŠùÐÞžsOëòOuP 5$ÿµó$i”÷KGþ ÌȈšiä>&1Y= gFëÜSänµç³XÙrP:ó>óA/i¨TiR5)EÀ)ý±Ueu6ÒAmuLsuN¼GM‘@fqËç@¢nѯìDYeŠ®ÎßPt#ë²~êGSú4P=rZãPFû²Bþ¿“Qu6æFn<Åh/6¼=Ñ6nUôáuIë“å¶q(/±4±)—U É_]‚)Ù$Vy!ÊqüÐŒÿÌÔ<àˆBˆþcCÿÄ­&ŠX‡Dï47ö"yìY£³Oñ’O­ÓEEF­ue¯ÌFýËGʳ<ofÿ!“s2'óR‡”&L];uI…V3;µ6>5F³©ŒòoU—™°kSZåR‘LËm1¬Ð*ÔT8ƒ“|f +$äé%ù”sYgï OôcÛ–.ÞÖ#uZS6OïPIpHƒ[Œo¿•XnÁå g7Á wHkI‘-vi'wBH"Ü ¶<‘_çÑýꓬç_£r‡Â”g°2KN¦fÃmø!Öô¦Bº`iÈÒ"DŠ*6AjÏcmZ[TnAFë–/S”¢0½ 5b`ÊóŽ—G“÷YƵydpo¦ï(Í*ó‡V·û4‚5r‡ L³ZÿRµZà‰%b=\€9ȃ“œÙ Q7K®Ð¶‘O a×M8¥¢Ñà4ðWBp)% ^wÇú2q €¥“:Ýp€1Fë°w÷°@'Ho? ÉuÄOÙ@—Ã_V@@}˜Â‘’U¤½pb™[Õ\÷¹Ç›-™¯99 ÿWô“˜ûE»;±±Ù9¼øVn Gl<Ó#˜`¹Ç›)f6.=¬2?ȳ÷™Zðz† ßUháµX¿!i„?ÂXûj¨êʇxr¢[rÂTœ`6Ämü| Κ}ƒÂD/ôÃBPˆã|¢êW¹-&B"… Åâ›3™o¦ëðO¥ÅµŠ‹‘”q:;Å®ûoÅu}Áœx„×oã`#\XòÁ×Ûz¸94ÎM4¨9ˆì—áöjº1Ù®ùZœ»±ûœ¥•°ãð€¹5ð/Ón§ýðª‰tÇ%ÝoçŸëx<‰W50ÈÝ;=ÔñS‹\ª7sßñ=ÊáÝ—^àÕµ )'Ýs^9@꥞لçè¸é¢` s½·“‹5n€­]Ø—nCƒøMáÆ‡•»áò-RÚÛ^vg÷¥ñí¯éò.Ï™O¯³nÿ½”±¼MR,N’š8æu5ªñ¼Yàz–› ”òiyƒY 2É)^Ñ1zc§´í=Ž—ž@t€t D¿˜¡!°Rà šõïII¦^áí£Ö·ÃoAô™a ¼ ÷½ P~’"‰&>¤ÉV‰*¹¹Oš¯&ÚñÚÞþ÷º¯ŸäK¾»µ3§óPÆ÷Pâ, VHçËÀxŒÁ•½·™ŒGy˜–Á5³çõçyF¦xžèuƒèáI˜¡¢ŸÀîÛ$¯E“„ [´˜wâž9ÜãÐÄ!=zöÚÐs’¯€†&‰ö<ÙOÔJ Ü`°`C„ ÿ,м‰3æK7nŒ/¨Ðñˆ…b©Ð &˜õµƒT¶¨2ðtÕ“V[Z»zµÅ¬'°dË‚í` ­Ù´lÑšHûÖD‡·Rãνk¾½µöþˆ@A‡ >LøÀh^b,NÌ+ÁbÞ¼ŒBL a2½y›éø|BÞ’Ñ¢ï™6=OÃF '–0-ÏôëØ÷–Ä^R›ÊÝŽF+\ÒbÉ Ž-8L¬xº…jíȧa‰£Ý'1µ\q£eLœ6»Óü±a§ ŒèàhP£L´×´éÑùBMx°?µªþ®Y½nûßV\µ[e¡…`‚¦¥ \¶È…×\àÓ×ÿ^øüeˆ!èCbö$&YˆIFb!|@#ö@°YjŸÉÓšh£f‘¨ Zk§Ý¯íˆ›mOŽ5F‰¤@Ì$ÔZ ŸmdÏ !wOFªqäG`L:„d˜AK=µ$NjÞ4^Ki7»AhRö±P-,€) U ›Àa8å©QFE‰óe82ˆ@®5÷[‚VeUÅ(V±ŠÍ^3šjPtÏxF¬A:0IAÖàG$A Ù_ /õ#ä,g9Õ!8˜ MÛ‘¸Ä5Bsií„][ ØT(¶yM’ÏÃW 3Ùb/nŒêSö¨ð‘2/séËöˆ ¦C¯ÌÐ2£Yº/ŠPD‘ˆF”¿]V®6Ȳǭ‚ÿ$#½ŒGg, @8žÙ@Ö¤NA`€g8º±é@ †¦ÒwÀ3—zÖƒÔ¶Ð]zZ*T&Yé¡ +mÓWUD µ0jQÜ3è(í¢PJéÍm…ß’hÃTào‚‘L,“¢ÍX¬0©J 7Æi &/IXÜ€Œµgè˜)Úƒ2ð©M÷±ƒ ºÆ±ÑÎîÂÈ™Ød&ˆIð䩯åxJu–:¯²Q2mÿ (@ùÕÉØLAuƒÐW…(Ö¹Pª/dµ€YUy1V¬üÀGëÖ`¦E©Áëf&'+áü2˜²+f`K#›Ó´±ý¦ jÚÿEDcÖàF͌Ԁoô€ (À£ÌÌ _töC~Ô!‡ú»ð`mxèRdR˜ Ÿ†­…‘œ¤ ¡WI×ꋪÖëdÀb˜ „Õ·ºÍm^ô’Š ý%0À•@†ÁVãb1—#â û¤h×áH†5­Íp¨[Ý’‰†d3ήi¶»´8á»ùFÐxÞE dÑÉ`Í6ØAvŽ+Mœ¥‰N°ö>2…_s ™Úžg*~*~²2 AQµQÕO½ áÛ†O¬ ½ð…ïC!²öCÈÐp AD€XCˆ€cJð™V…è}QŒ¢gìºW©XÓf¶è›Àæ Ç5ˆ=¼ :Pÿȵ“@äa #gK Ü’¿ÈxBÕä9dzè”ÂFØÊaíSRËO/ÿi×X ”T½èY¥«hžð„×\a6»™]§‰*´wyuˆ¬gËÈ×BŒ·ÀåÜmŒ%¤âV£ÉF³ÄMìÉ^+võ)/áˆÅùÉ“]3'÷: ÎèŸõĪõªÄ Ä…AàJöx Cy·ºìÁÌ ²x ¡ê <„‹Ç#Ãa#Åü*]‰ÇQ€Ì ,žJð­$}Í–ë¨a°y†Èºãë”=á„ÁÉýÈÓÀÓGÎé,¤B11`Fý´LlÐ,­«Àk×™l—Ï K<õ:«³J]s:§;µÿÄ’ÄVK¯}8„qàJ =Þw·Ì Ñ<·ÍË›<•(+#Â![Ù%/ÛzäKÒj0òàJGÃ@öÂÁr¾ØüzÚüÒ/ƒ;hÓ6ÍA\9}Μ8X9°Ù@>ýGð'Ô”lÄùnû»Äª«v/É‚÷ìÚ-(M¼Ôal¿ü»Õ:À_íº„¹Jb} mÖ·@fŒÆo­ËýÐ!×z{›<Àéw,f¸ç¦§ý È1Ê ãK!uúf t`Íþàië›—Ž=m/Ù=1Ù?AºŒp·€¡œ½šßøýàÓ?ÍÓ£ÔŠÁFmÔ÷ ÿc³'÷’GJ|[#Ï!1Ä÷K1GL¹ýª«ŒºçȦ; }Ö$@%ð¥­Ð¼'®ÆÈ=·ÝÜÍÍ·tm×½ÉK†«Š\0£œÖ2Ü2Pnô`ã@kzž¦ÇØÂ­…œÍý@ˆ°L¾Þyº6=7ý´E¡š}ß9pßYžßš½ßŸýÝç ¡n᾿KÁ°ËX˜õE„±¿—<1F\11PÔ¾¿¡;¡K\«Ä•â#&^¬(îÖ»¼Ü'Þâz[¦ÈÊ M2"3…õ·y×Ýtà E’¾ÖÐjÀì•3ó7†àk ÚÊ Öã ´ðUN<>ÿN®NNò5 úÐ͈¼ÞR>åŽ1±X®å9`Fì\Þåƒæþíæh77Là´Ó.íEQÐ,¼økç·@ßq€î1 àN¯zÖá‚Nç0âô¡È«Ü‰Ž·wËâŒÞè¼ éЭxÃD9w­Š£‘hy‘: ?N2s‘”ðÔáùÐÍ78Ó‘º£K1,0F]¾°F°[®åÏñ]îÙÉÎÓŠgÎEXxíG]ÁOËòÔuÄŒ@*DMÜìå iÚŸ"ÄåJŒp >_4Ïòˆþ±DÏâõnï{«¬Q)ÝùW%ïÖï ôœŽU ;PÐbÿ#îæUOÌ¿:kàXy0§<#҆Ȋìç£[å2—ÙZ®ñ_÷ìÀÎñĎ߃õÙ÷àÓoJ„Œñí'€ç>àBàGMáŒøgÎ#Nèé\ò•s™?14Où?ô‰¾âD¿èhЬJÿè PÑý·¡ñyz¥@—ÃðÌàõýà€°°?¨X/ë2ðÕ4ûÀ O0 ÃA÷PöްŽðOàΟUÒI@Ñï÷À¹Ï©súmy¦gÄ5º£û1p÷ ÷¯åvÏñ_ìŸ÷ù€òøËnÎ'ø#£çŘ7ÿ༠K”`ñ0âC‰%ް¸˜‘ÅÆˆ M`òňœ<Be*–©@¸„ óåL™2A$P™S§Nœ8‡ áñ¼,NÈ[rOÞ=¦Mî-úª¼&KªÞkÒé có4¨Ð¶EX ôZczÃÚµi±6MËÁ©S¬r³bÍjÕX“°m ØƒEÅ`{ö¢|ЗX_…ìU€lщ#r\¾lÄȾœ=wÆüY4hÌ– Àpï”Gä]ä[ölÚ±XܨQ7쉌Jøicë”4_¶dyÜxÍ•7wò|®2A=A 4Äì²r@€“T#î¤á^“ç5^[Â5]Ãh¸u³q77‚"ŽLJ‘¦––c®Èœp’Î9$“Ôiˆx¨‚`¨E·ÒJ <¨ªj*¨¸:¡, ì!«L ZxƒøÚª/¿úÔr+¿¹èú¯ÎiãÀôÀ2°¬yTÈŽz*`ÂyX¸Ç²7Û°QÎíŒÑÑB$àÓ0ÀµÊN$E9=EÖNz ¥á€DÕEÞnD•¸•’ƒu9YmBrIè¢K`ÿê äJxá…PS»’)ª¾,¯…ÚPzÊdÍúäc«Íùìcs®ýÞª3+ÛèËLõŒ9a‰æA ‘ c¨PQÒ8”´3AÔLC̰ô4MMÜÔD7Mô$~MTíSRS4‰U¾QaŽJ8.¦æl2Ò¥[{z®Ö#Ÿ„Ò€(ƒö…¥ˆí.;eÍ|–gŸ÷,²žírZjíS Ûûð³+«û´íV/cÂú™,c¼úzòA‘BŽÄ煴èµ—ÒKKÌtÓPæZk~·FØ5S&;a†'º…‘ˆ™›xÖ™˜´UÉè6¦Îã ä „½ÒÜ“—]¶Lr9 *ÿÂ7Ï©™åsó>ÇÙ|+.ýxÎ @ï ð»/é‘ †`‹ñ²OßѨ7«šÒ+-Q_¯»6¸5K{áÖr4¶‡<‚5Vå*~ûV&çÞ)×zê1€yðbïÕŒ•'ÌìÊÛÒ¼-ÉË‹ðŸÇºKfját\-9»{Nn×'/©þ°Ò| F>@¤ ‘‚“2Å 4GEƒZs ºG•.¯{@eþÕ/­ l JQÃp¤;õæ#ˆØÄ,F±¶Y,nÈaDXé,ÏyRzZT½ì”ËKà© cH. î?2[S[—šé§)Ó!ÏÖ9údI!øÀ(ÿ`¿! £*Ý£(µ}ÄKŠ‘ŠiJ§(Ódm\ØÖ>e0ÜñÎŒºé .8$â5çmƒ›s@›Œ°ºº£‚ò‚ºÐKO¹ yàWïEZ5[œù°¥¸¹Ø¥|ö‘$ÙJšk~JlZqì¯O‹7„:+jq0`O£5¢¤v›y¤†=ä#ŒuY<ÍÑ—Ia0s•«Ÿ\‡(å’ wà·>½ÔÐ{¹Ëâ¹³Ñé‡3‹$}ˆX,øàÀ¤&ApìÏ]S›ÑÙ ‘¦u[´”‰Ã¯1F0lÜ]>#’¶ °Ñ8²Ò 刱ÿ_ÎQ˜ÂTI+r2dI*0ÄË\  òh‹-9|$#)>iò’7iwîÑ•Là' Èd+†à a9Íêô¼dS¨Y±žÁ*/cþ™hT_¼§=s£°ÜÁfG%¸ERc%Ðâ½±9ÍXAçÖ“`ÖQ%@±Rþ¸¥-EsÞ«G¯…ôÁEš6ãaÍ9-@màü‰8°Ò“< eM9ä( ¦^,Y3ª ÞóT§jU,M…T‰Ô&9aªT%‹1¨jòI%XÊRüHÿRYA{¦´ÎJÖI"rf5ó([x˜ÖÉ™ ¸ÀO2‰R•P AÀÀˆL÷™ÿÍÿÔ·§„Ú5Ü éÔu«ÙkêTÄaˆ%ÛC‚ç67 ´²’-(e1¦P`D³pÉyjØö8M7”&~„¨3Ó>‘í­ÖÎZd4„€'‚8Sê à ”0e¤ö:/+jæ]€½Ô‰Ë\Åâ³°ÄÁH.—úÏÈb×ÂkR=D¦îÔÉ*gTè‘§”ø?6«æ9±‚´qémJõ2_é1®ùÍd*J‚Üþw¢a½†kJv¾Ë¸–Y¦XYXç:÷ÁCñ*|a*ôƒC7­2òvyÄä51šPœb»ìç.i âYÇ'y´`(RâÁî{G”â$“ÿš¬‡zŧŽÀU|š#uà-²æk†í]QŸûààMxƒM­c0I(B`V9ªÇËä^ ¯îøÄ"v¨[æóêŒZgžSXG> ª™-jÁùÉ-IÀzrj“ÚÒ¾ö0ià0€+L8é¸}»KÂIž-u3©œ©,#±BÝe×)¾”3³¶Ôêj¶@)nÁô¨G^-¿´Õ1\qÿ¾´ÏÄæëÃ]·J{š¨LNÑ¿LÄ’zÀè¸/€ñq/ãã"G¹´º9ã‘ÎÃDR&)ÀßLñâ*e½†|à!_q§ DtïdéìOñ+ 0ÀÈ©Œk“Ô¾ûµ—wímßÄz~ÀËñ…/èÙ'á…{yÕ¬{g-øyœ y ÷|Þa.:ã"jæõQMÇh¢”Bc ÀÕI?1¸Á‡©Pü  ÇÔ¯%>ìßX¯¢T–¬v >º34¢ýñ»;àã/ßöè~€¼ƒ¼ãÀ€þÝArdøùµÀ>¾j î8žAå¶“›gÀß%–wÿò¡~'䣔ïy‰G-ÿÆ­éÌœëçÕ´ÿúû/h8“­›p’;Ò•a"7qÚ:†3 ¯ë­¯{¸Râ­Z°|²¸ Z;ÛI.­Q>m³¾D†‘{¹å A‘£6’«6`>ä³>ïÓ3dx€Qx€Zx|À€zÐ5™Ã9’ŽR¡˜¼\ˆȇ\ȇö‹‚÷«`ð>ëAm+¾ã;¼¿ Aº«pºo3>H€AD  ÁZ0K€0´¬©²*Jÿ“£VÐ0y ‡(BðÄ\Ї| BP?øÂù­ý›n&4“Â)\ ÿ{€€Øº³;«³/œ´ü²,ª,—ú/Ô©¢a ²¾’À+¥ÀZ¶é½fë”Ö04äê¸ÂsAT>jÄÆ`ú»Â»Æ¹£¶—c¾k»;ïC €An¤³„ÚB £4‚¢NL O”GOÅz þi ÜÈÀß»'9\`ê@oC†$ÇTÄ`D‘¤F¼+A=„>=\Aï›Æ—[Çä9’ðË HÅø…tݘGzt 1ú“ý›³øCÈ =La p…¸J…W°­Ãºa§!@‚ÀÔèŸsÆQÚŒa49FˆÓ"JÉÖÀ‹À iOÉ8¯©#ă;mÓ¶¿ÛËoóÈÂCÇ>̶½Ó¶½Ë³Ž3€tcs’”Bªª*;£DЇž\žÄL^Êp·6p‚3³£´?¥&”œµÈÇ!€ 0?»ŠÓ£ ]ÃÉHÌ5;'¯d Ù3Óé+? 2?û­b$ÆâL˵¤@Ö–‡¸Œ,›ÂZ6”!ù ÿ,éÿñý(PàÀƒ*\Ȱ¡Ã‡©þáûñ°"Á,´€£ÅQCþcpÐC‡…'Eª\ɲ¥CƒAºœÙ_ªµ\œÈó_FŸ2=Sâ|Gâ*Jó É:x€JµdW³4Ñ´«×Š0ñ*øµìˆ6ÿEd˜S#OŠ‘&ü‰TÈE!øŠ.5{ÐÊ&r…øß`À|­%1H™Š½ÊŒøx!\¸'ýÁÓÂÏ H-løw´4R£ÚÕ‹Wäƒ)aΊujÊïsÜI±î®9 b^ÙS"gѤ‘Z¢sçøì2ÜëuÁ’QÛ¬Ð$VÜ¿Ã7ÿÌû\¬Xñ3á¶ ÙÈ[€¹é~:=üij£=1Äд ,Íо wZ„”䇗€©ŽwOÞg+aUº:P¬v_¥-™ÿœ+†ÅÌBàÃÆ@,±bÆÀÂ ÒšÇæ³çÁ™@Òâ9QNØF„“µ7m4ŸZʵ  TÀ¾L+lúA kZÀÂùhOÓÅN`È ¥QðÁÿ0òÏÀÀ/¬m”® ÝNF.d$L&”1PaǯŠlQ{¹¬A '„¦Ë…#nfÌhÊù´cEþ˜ûqRË3gôk朸غ÷ÏŽ„V°ïAœRAÓöå/ÒÙãu kÝVâa‚x¼ÎRèÚ q;òüàˆøÀ±A{øNƒ‡*ÓJw@Ü€X›E˜”,’¬;„qU¬¸3+[„¬o$ËÍ ±É c©EãÞdD¢”G"iáɵ„æDo­} à™¦ði€tàë¦0¦¼Pؾ ðÅDMä0Äæ80ÿ˜#æ1 èCˆà=Tp:ªy€? š˜"]³ „p!…Œ eˆð­!~‘N¯B"Â’´ÂR'À”.fÜáоVþãóp\€~æÞÄfi \ì7.‹`ÑRÈú’Ëþq%Üc òÖ<xºNqÅŒ 4cTâ@"¢F)Òc J°8XÆ€ôøæïìñ!â_ü¨’GB' ¤y³´Hƒz%’XÉGÜÁç?.9ÿ%!ùÓ.š\IÙBÙI‚"d1ç NùÃW6dÿ˜G æq 9™ç<˜3HÍbÂ,Y’§7Órþ„[˜ÔLþêá0õdëÇü^¹LfBá`&@B¸r°©) qüÀ<æQ‚1-nqçï|W¯am`# …@¤Ÿ)ž IÍ ï6!*!$6³ß. %Òìj ©yäCú—:$p)â0]9†ªÏ7“3bG9:´ƒlTD ùŠ* ¨ð`†3†Ë·ÌdÂt 3• B°BA§üÇe5«0P"ƒ{då<†ˆ&ÔƒôøÀ¡^”N¨à  j^RƒÕ*ÿV$Hö)IBdåªÚT©«³º¡#$„”­¤š­ÈçÁP¢2`=ì!DKW¬°Ä),}ŽL(÷œ;-d˜#°ö©­}iX‹“ÇA˜ƒ#“3m)Û5^‚! XÆ8åu”¡B”Sé#m\—ö¯b @”þå‰åQg‘«Xf\“”¿ äB×ãÊobI…ü­¸Æh§X¦1Su(t¡841W¢mbQðº³[¶©rpzÉ*à_‚ŽkKX‚<$û0B¸ÃÇ!{ÄÿÀÀ= ð hP 1ÂÆßÅ«wôà=˜ûz¼RÀ‰ '9?@¬ÿPW;Ýù²¼óv) Z‘×U‡Ìðz\Ýç­úÂâŠÄ_(›H8eæb¹²•Ñ(u_ƒ‚|ô¢mÚ“:ê!ß6! Øàk‰Õ¯#™D.g6ð¢°àP–r|[ÚG+ Œ[v™¾(@ ¤.Œð®¡+ÄW +`$ç¡0‚,¬ªqàöœ sÉz ùØÇPR„ZåðdxæÕY5bùKÑá”=ú½ïEW¢ÒŸD50o‰¦¸-ø qE‘hÇðU–V•Èz(°G3#—‡1`v‚X'r,zeš(gà%0°!ÖM0Ã)|¦äTD 6N1't´Âÿ4Ö ä1¦¶«œ:ò?nÐ6%½¤ŠŠÞuVíÜ0¾­á>ûÙ—·¸j­ˆ[-2°M¥Ø”4%s¿dÊ€…s‡…ŽÍö R­ËψYO/-PõŽÉkœšÝŒŒ –,hòL ðÞ„p ÷˜‡!ÈKA–Yé¾Çè0‡ó cVÁáÉ$d•÷°ÀSÓÑÉFõQ¥(Š5GkH6  ׿zÞFˆÉ„೪¤˜¦4¢‚ÿÖUÒà£w»ç-ûSnh}åvÌé¾÷÷³óE~à'(7Âf×5úÈñÕÄ$æ¬"üãåÔG»ä-W!a@V„mÙvžò;Ä:L~gò=${^CßCfô°Dä±u£ð&ùp[g[2a@9p÷‚.fH(†s'è^t÷øˆvYò AçE™%@–8HôN‡N^ffîRƒÃ"„k·PŸrHO¸$AmÏaz$Ó Øæ ûç)a…2\ÒͱIUçâ@š’hD(~2F S›bfÀnó6:X0dfÔâ,ï39•#ïó8ºWCC|óÿà"X¤0^3;£Vwu×çˆLó@YçwpMS†¡nñ’.ñpd)$Ìñ¡£}b:š’œó²:óâ§&Z— h—›²—grxëV]ÐÈuIDÞÙ,ÀgcÏp9@|4Û·n㣜‚0sJ _Æ×ˆ¨ª ÄPWs5}j. “5ë‚.è"O2HY³#n•Z«%žQ›äi1,”yÞÒ•VaÏ*!¿‰O%ó¡fÉaSÒ…$ê@bÿJ•­Ó§Êi$G~­§xI¹)!0-5#"0)1Üé{"9a`},0ZF( «z ƒ¤àƒˆäh°Ñd>–e ¥h¡Ô°¦35ÿ¸# €`Òz#"0P5Mgfå´£Qj5›Wigí$^¥¸Á›zÓgÐaœF·…Pq§ëâ:«bj€¿ãVt)rÔqÑ™¹ã—•DÜ™o-Ç]²Ù²ÀÚHP6d°DNç’Ы;;(ÿ>c> •Y¡©”žŒÓªä:5ÕÃlS± ãžÀlùf ¡Z7@#¢!J˜Yéa_¥Oƒ¡_5‹¿ÿe%:\šTz q¸ï7ë?±z€dô¾$Út,Š’ÅòE"¹®ëÆq0)cЂD¹ä8ÕDM«†p °&Sù:„SëAaz(ø’/\.Ë¥û”@V"¦‡…¥æ§ô R# h[>àI90P(ú€ÈC ü±Š©2mg©á «’½X‹³H¸ BœeutÖªz*)³â¾ßªqYû9¼qU~œ[0J¥4·„¦[9tè’;±]h•"pw7y“(HSÿR`î¢.¨75TY^ à¶;’ÄûU|jœ$*¦Xê4òRƒa–«bŠÕö58’ó.ä¤."0½Öÿ‘·xm@ rAܸoê½ÐÚrª‹‰»‹¡Éñ¸¾è?¦)\†(YW0&QëJö˜¼o“š{MÄD>q4í5Sùú2CõM®‡XÚÀæ²¶;R ï§û"¦ ƒ@„.¿AQã4e†~¿#¦»f…tf¾ö.Q/ .´È©HiªEá ¹eOÜ»¡%–²¡= ‘­ÙÊa€‘–†’;†GcN Ř›n0ÚÁŸhf²$¯]üDæÀÎa¶,J#ÆÚ(0d|ÄÊcÖ5•lá;mõhûÉ™.Lf@[Ò¼J• ±¿£š$ýqú‰~×,BоÿÆ«ò(ò¢.ˆ`Ñ#L1®mú?l!í<a¥O"º¸í¸õL•ªÓ¾¨·?VhòEÅN9hu5f¾Ë<-,¹Ùå?`7PŒÀMN–©@Ê%GM×zô8NbS—ÿ`µWÓͯ5ƒ~]4-ðJ˜è.hÛ«ˆ·—ÃÒ õJM°Æ _RÓ§ùe7½Ó52› –¦VùGÉ\ï …äëŒ;Q±­÷¬J Œ ׿C;PÌ€|8­‡˜cq£Û¢!#7 G'ðj3%ùZG¦ACE&°ôbãU—©'ŒÛWf•5Ò «rÃ4&#é.b (òHÍ+ÿ³Œ½kûJâÝÙÝÂù€Óé­Ó›BÑ6LB[Â7#Í;Û!¸F–•ÜÉÄù²»Rh ¡Ú ñ‹Kì‹°ÍL)rSfh‚—V|´ûKxHÖ%#?p4Âý9©P{‡‚r¯TD0šlgìÑ`Ø« 8’@+£Ã6&Àâ2ÇvaFYƒ4uƒ}äS:Mpáýæfi¬.½z·üïí„3¢~ö¬EÝ$Qߢ—+1[tèÛ€†)ª:¹uÙàõEjrÅ`1 =†¥4Ã"ÆÖ'SòÀm¦(Ôž-GSá_ßÄ~gü;ÕY{í–‰yNÍèw-ÐçÿµkÌ¥’ÇVÃrŠGYß,/ü`«7°j=ý3¨"Éÿ½U• ¾à–àÑÉñì/„)„RnG“µa)_þ–ôêY:Œý«i¤kë»=ü±æÁm&ÆÇ90ÑTy0âEâphlk§^Ââ;W§Œõ–†ôhxˆWWwNc‚è.ÓɶÆ4LêULòÐÇRf}¬:‡B#G±<ñ7–ö$ À%w*êa9£>Ò#Ï1%9&à…¡¼ê á@[®êªÎÚ¿×ÏíŸrºÖæü5¤8ÉäæLŠ‚ n»Ó; KçÕRE6ÇD„»{^5^{ÑI®fóˆ+×"ÿ/óCXL-µ-àRÉDî<ЧùÂx‹y !ö‡!$<Iþ·ôû=ÚÚë7gõGü~dd¢[ž!-¨„‚¢ÕñðêÝ«‰–ðû¦,÷SØë¿rƤË‘òИ 0Tb‚>£ÕR÷Iò1dÉ•>r3´™gìòÊhè¨Æí!óÁ¢íãŽj‚ý%îòÍ·Š<Õ»Šõ·$*dh¥ÃSr¡÷´¡S¸ß›ô0!êäņØú7+¹Á{‘‚ºœÉìõë"(®Õâ…<*-Ñ?²ä¡ÆÁ½äøæ2†@AµG=Qy¾µM¶‚eáŸò¡0Ÿ|¢øÀžÖj¡¯ÔÊËžòAăÉÂgº‚<ÃÇEƒpÁ ¡ 0¨Ns¨5Ø<ðqµb ƒÑºíH‚rsIGä†#ÑÉãþÉ(#Žšû¢ßšã-¦Q¬“i¦Z2‹é¥~Øà† xbá¯ÊŒÈD‘འ’*Fì‰a­K+-¹*ëC6×âÿÃôÑ‘ìšpÒ< ÒÇ!G#µ«0 ú"ð1)¡!ÅÊ6»Ž· ²ñ ˆš‹(¶åVkU9…pk¨V—²Ì«‚]ó* "^9ÊHËGèÀØB}3á#ßZ²n¥0·ü§/ ªé³nx/íUÚyÌÓmÒY³3'O,ò‚úÎôrïƒÁè;7¸Î-¿¬î‘—jòºÂÀ+ók‚M¿›°B9ŒðŸ( B$í|Àþ Ö.Ø óÍÓn~FXÉ|Þ¬g—G­È˜•C\µå*² Û Ê¡ûQS™÷–dX¹: Ddf+FGÙÓ´\²³ƒàã?Ð#J<7…« ˜"Øóÿžtén*aVÂÒ•­ÌKfùÇ„ÜR¶º`"Xj|½®Àm"€K¢à2•¨|7ðe(Ö³‹ª4ƒ‹åx+Òd ©•n™†L9zQC0‡9 pf)œ–RÒÀg9äZ¥Sßgn`ð`e<²ûGþâNð}zW«$?ö‹Õ ¢5A)_„ÑW +Ô¨~©íg”¸„ r Jn€ÿ Ä ÿÁðâ`R² ù0Ä ‘oGìÏô—ÅÉÍJ9ª9 R££ÁQq}ùK¢KøÌý£‹\,È0]¦¹(ýã—ŒÇGš)äT`™©Åµ4“hÿMk1S+ Q Êch÷×yâ^ë=ërJZB”–¡q…÷ª`@\Pë¶€@üXÁ\%†ÏXk£dtb¬d©¸Þ„T¼$ÿ¥Ñgú‡À‰ŒÄïÕpZúR‡`Ù‹¨¹2jb¢ºnS¨oäÉnË#;ô [kR ÛÜ®Ÿa<6aX¶ö¡Þ&`‚”rŠ=Nþ£’ -« _lÉ…\â¹ pè삨ìÞ£*Rc¡%Ç¿..5|Ý4ižl›† ô!YV¡¢–Æ ‹ª–¯|U eðf™š‰Vꪉlb, @S º(y˜ç9 òV[eðô$PðËmo{6‡è*‡y$qÓvm‡¬à†ªhèª,YBäBxñ‹q¨VWW~¡G>FJ¾IG9Û™NzQ£8òzŽqë@.ñWEXŽ´²Rbuÿ£¡¨RO~Ò…)|•–úŽ7Ÿ]‘uªÉ%ž™BóøuV‚ÂàóçØçzJZ–pìü$¯´*¡C*uĸ2·Q·U¡=ä*wܨwÏÏŠP÷¦ºÖe$"&s±ÐÀ5B8™'P¤%/®U«!/lt©E‡`¯¬vˆ¢2·€=NSNKY ¡–?ÅëOgò’ Dà7@D™×äñpÂÇÞK;£MñŒehbYÓɆ]?¤_'\AT¡bˆyr¡‚¶$¹ÁЛ3—HhЋtª1p7¼KuͱˆÒYÇäEõª¶øsÿp…+çS±¨¦rs:ÿ¥ðXs¹Í©–L¤C•Hpîd.íÐà¦w•Bñqmkc;4üÐK<>aSO¦=˜àEx”ŠÑv½âª¸ÛÚÆaA6ÉÜoï|3˜?ŒÏtãxn¾A‡úSé.kiºÖóÎab•qC‘A úb)Þ©°Sã dƒ¼â;Ôh¹š¸RŽjɺ«ŽÛšz*6k­Þá×ò£„{§‚¼ŸP6{Š÷ààB1 €`S‡X€WøÉs¿+7Bã ´j¿(u; ȇQ1"–² ëŒò:À½:²¾2 ð·÷8’PŽÚ§–z ©h9-á5äÿ«€ ÌøÀ²^ÛÁà¸+b#hÁÞùCƒpŠßá>Á<Ùò>ÂØ i”:ù´‘$—X1mc¿ãÚ$„:+$47ƒ@³¢$†P´Ïs ‹óÔ; 04©³%(’U¼´ÑCËâ2¯‹*¾ˆ*™‘¾ ´‹6ü*>2)¾ê(ˆØÁ ø€e› ø¸{`é;—øp*¨ ¾ð‰»ƒ6Â.L‘ÓA¥Ø¸ä@“1‚Ú$Jª$²ê¹$‚GAË‚x¨X7ȇ8:–‚ {‘Q#t,’cµyÏÙ¢=Û³ŸÝÀ:Îq‰¹1CàËÅ Ô@ÿ6ÔÆß¡ª½ >™¨5Ëå3Ç4Y6 6páCaôÃÞñçx2ˆ¡‰°½à¼è3¥øAL?Ôà6UH‚òvüL„±p£¼y4†ýS&À(ËøÇ84’ l=ƒœ%«³%V´Óp ”ÊŸOjŽÄJ8T³È2/BD {‰6‡(!gY£“· š» ¯ð艢É{¾Ö²Aœ°@Š#‡ *wb¦ê—:Á¶¤(”?³‘!<.mJK´³²€w (·ƒx¿@ƒ.}h6q7…°<Ÿ‘Ê+ô.—€Ÿ%™Õ,ˆ"ûA°„H“H=颹‰ 3Üͧ¾¶„0…99ÿe ÎßÜ'Zû¬·K£AC¨KŽƒ§Óbjl!Rû(¹žX³\­@ ~0ƒHŠ”¹BѶÀ¹†J÷»¤ok±Í;4ÌkºKX^°›‡«ÿsˆÓT¢¼*2— ­<èŸý¹ŸŒˆ+9,uq¯¨»ûˆÐ`”IhSCt‰–"0–¸¸äÛ)nš» Ñ΋q"¹y(Ùò …#*¬ø‡pŠ (^é3µ1Çœä Ážíq¼è$v<+Ê´DL¼LÌK®Î„®|à¨à‡Ñ”˜¨LÅ—¸+1< YÍÓ`®¼:Ù$™O£Ñ•‚Щ@ÃÝÄÅX+<6áÈ0ë’ÿ©4壀 øð@‹ #”#¾#ð–ÝÎ*¹ð89˜ F¼ ¿ðT±ÌIÕðIœJõ,ˆŸ34ù£¼„ŠÔõ|®|г8|˜ \ØOpÃB‹I•š‹5õ(&i@'‹M)êÊв²T»IC³ã 5lCB<ˆ–ë,4J>²€lù&ÌÑEë–ç«d­A§¸eÓ@ƒø¼Èp|Ä`´±Vl=Çæè¶x‚ 4qSŽImOJz.}0¹°‡wc:ž‘Ž´ŒËÐ LcÅêB— ½(2ÂrȰ¤QÝK—*;¼–Ú§ UmN> X‡È5ŸÉµ0™ 7’¦ °ŠØ ¶ÿ‚È€b;ž#8ØÕÂFlt§îkIËÁ‹ (¿¤¸ñ4TlŽÇ›1å6÷SUK²Ôú;($ŤNëÊz@s×¥‹ \"$–¬\²Ó  ‚˜Íàs‰ª¨ ³³HßDÕêA*;kÙ\‹ •ðĜ֊ª`££¤2!îËUE¸«¡˜€ ‘CÀÉlËV쉹lëžÂ9Uè$ƒ°Äú+JÌÔÌqÓ…"Jðëb“yЇ¹¢ÂëGT,«/u JHÞ(‚,%©/½ŸÒ`м`µ§5±«Õ5<ˆ_F—hC6Åk©&njDø¦œP0pa°<ÝÆ_„8Äs³ÿŽì¶8—|O´ÉÖj½Ö• Âk¨I4À=KÍD¥¼¤åê¤ :¨¨€€W*ÕPE «t$«º{"ª¤•É‘5aê" «ŠàUÝZ­‚U£º8Wò<°1ÕÍ3+¶{x°zÚÆ=ùͶ ¿€á¢Öâ²Öj%σà6J\WxLNŠ^¥¬¼P…G7O¤„"°‡ëúŸ5EöiS#!H'z ¾ÒJó%ÔdÚ‰,s5ÂPµ¯ÓÍy@µàsÖæHš ýÍ8•&F˜È@)þÈSAΫPAÜ@¨èKK©BÔÅÌ6G䟄o}®É“ÞJżÌÜ94FBÿ¤4µZÒ¼à‡ˆ¹&©ŒÜõá‹á×8À|C•¥ 8œÌ*&?ù>a­Tc“N1]™‘­-C"ÞZbŒeDb‚ÕÙ9Vá±sŠ«`d6a361ÌâuDœ\LSÏ]öÓƒx ­?ÊÜD‹¡¿M,cKô}x }`*¬€,¯Œa€Ïé+N‹áæc&0ìˆÛt uQÀ»}òºÞ#Ãr–0ù²5Êæ2IFÚõ <­X°b”Þl¬A w±ÚÖ ?H‚””ÅVâÉÆcxÉJ¢¤TŸ›¿Z6·H¥¿ ¸~˜ýü^ü.ƒˆ€þÁ߈úI2æpEÿ€hÙ(’[¡a-Ðà0»—òá‚ðºÀEãäcbœŽ®ÍfyûPe Ý2,sŠcë>ÙJ¹Õ>+!Ãl”¹%˜¼¡f èAt‰Ÿd½re@WN¢ÌAÛŒ3ŽêË㌋¡Dø}("yk ¿±˜Ï¸ &K°¥©CÈcv®¬ +zÀVËÐmB†fß!Ö°ëabýM]µ[Kη4âЍê>=—ûµáãF¾Û°ã§~”KaìÁq<ÇEê{îÖö‹€1fOY&Jøƒ¿êõÄø} *Žþl#îù´Š~ˆ®N»×ѬO›E:ˆ?Y¸ƒÿ«ðáÖº®¦E 0ÓŒ/ci—ìØ¼,6s àƒøn'Bn)à )Ù>ëÁ€*êBEÙäÕQ½MDZÒ`Ì›ÌAsG¥ŒjLº$JXD((r“˜Qà ¥ë°–ˆÐ´V‰mä°º޵|U¦xø•drß ø…_Þs¯¼nÔÀ_¡Õ ˆýæ4,!™.Àè–#@ý䛼²¸KdDUY¢ìð¾ltlên=O14 .¿Íž?ƒ¼"8ºÿ£oWª·íøŒÉ¸ãè=ÈÙ6ôå(_J&‡  ?­²ÌM‘>çà“ZŒ+>03ˆ`å•XîßÁ; R3A1<ªÍí;6ÿתðìâ‚ØÁjE¿¢v¼¶}Ô! t¼æ½sOROKãÉ›¼m›1Oz›F‹"oÒT޽ÁŸzsºÉÉ’ ¯´ŽÈú‡-µÒˆâd…ýšÕ ›æÇ«‘®@Õi _}‰Ð Ú]îÁæš ×^¬ª–‹0@%óƒ0’esƒ˜ì‰s¡¨:y”€‡jÝ6ˆÙ$G±ìaö@÷¤´)˜ƒ!ч£“Ë$êqÌ5æˆ:<&rñˆ¥m¡œ.25Ôxòß¶ h¦f‹œÕ‘ž÷¨ª÷Ž,ußdÓ ÀQ`Nòr®ñ8Ô63Ax ‘\ ¼šn­A…”Húî¼Ûÿ¹¨ Á}q”·);Ÿà—±EM«Eíõ&,± ¡‡Ð3ßZ @m)e±ftåøeaE$ V$òƒè·µÖ%–ad9 ËA c¸Œ»–¶ø]äîáƒ`ØT÷™ 2„oêòß1¹çÓ  à=u'™üäªb-wnD‡ €K9?ÅÓ é*ìÂ.Ãh7 lǶãêÖ;÷ɨÁhžpê™ïS,”—çYñ(ÿ†Ä’KgU—¨2,-±œÝÎagú°Óí­#X©¨\»&bl^d_Ì0aÓp­‡Ñ2¤ÉY_ÃÔnë±qs,Fû îZŒÖ­“7 ÿ±ÁxbìiÙnm@}pjž&8²9|`JXyxMaÔ¤+éç˜f‚aÌ¥W—ø3È%?F ñfnŽÝiµ§Ýíß>8¦ŸÚ²«æ·[X ÁaMCµ¼úp)Š Ÿw<܈ÿÍûâƒ>Cˆ.D´p ¾žhQQ^ yÿîÉ»çQ^Œ-þÑ "Ÿ>"þ­hùOÕ˜+|ü[©/=MZŒ,²fÍ"E|lØ ß?¤ÿ xT >¤nXài)Öx&zø·•«×ñ–vxõê¿ h± ´õÀlçþ³÷/={1°jÀ;/††yNì=AkŒó ÿX jc|£N¶ðƒ¢ ìÙS‘Øð’{,%°‘€Ç{5®fMqÞA ˆ">1q…¾…†€ÐbpzèÍ#žñø½&G’¤¥ˆ•,U­P³¦ˆ|QBðäù/_>Ÿ.ôEQd¥KS7à{ªt Ò¦BØ Œp˜ëW¯]±víšÿ_Ø×@ky¢–ZlàÁcÝgONv ”=xÅ Â_¶—@Ýwa†„T-”ÁYd?\6‚fö0RØ@¢ @š@¦`ÚF÷ÑÚ@¬±0äóC-d›@ …@Ð@4„!äÔ]Fÿ°fQIùä‘+ˆ˜5Ý$ÿå@Ï9ñx)©EÕ{I9¥TTSQ…U ÆÓÕž&ì§~`qÅ@ÑdgZk±U–\÷ ÄÈR1ØeaqrøO`ÿv˜`Å ˜dM6T‘jÁ ˜ñSA]ž°„a2 @€<µvDKqÏ»ºöÏ'–m á&Ñ?8©ì—Ïv…`wŵ@ϵ$ñöÁ–·ýãƒ*, 4æ’$ÙE!8ᄺ'éSèL%ÄQH!Õ”œì!ÊÖ\5º•_ù9×dÙR„[ÿ u à bµ £í%!VZ #ÜeØ¥*âb‰y8×(A&eP Y]zi*ÿÐåzÍs+Žý³#VŠ%ûVG&¹”>Bæ#Áü ýANô4í4I×b»©AQD!Ñ/-“˜Í:Ý‚ºù8ñìvQ˜ÇÒóâCß{k3%'¿0@à@&È5°@þ±å`ÁpÁ¥¨Â/•pÄlIÊ=*ädáÅÀi|×`‹i̱ÏwüÏdø˜Õ¨tþsfPW ‰Áj¥jòÐ#dDNfÔ‘jý³„@'°`˜²Eb%‚îÈ"´VÊBuA1G\NÍ´ä–­ð­óÒ•Ë“ÓöŒ ž ÚåcÞJ P¢¶œQá›”TIÑ7UÚKýûOÀûá]÷R„°ßK5Ìpá÷%ÿåâ.•©¦þò1ÖNbбœ¨–ÒÇ`îs ÓÌf CµídZ¹ˆ=nV+Ù „·+ˆjÃqñÎ&À›Èê²$HI©$Ó*É×þÁœ4mIC’Î+|°€W<8ÑHG¨„-§…{#`À÷¦§§,e>I™Ûþ¹±Å{’û•¿·lq hTþ(¶—¼àå.RÁ?Ј©ÅH,€fLŒ†>@ÌiN2tZ e(@C°Št0{•GLsk¡D‘R­z´” î†È(0‡”0I‰ˆn2¡àÄF{V>¤d¼ŠÐ°$ÏÊ ú%D' -¸G®8à‘Ö$gÿ$ô Ot¬ò½{Õ©=ðI‹½•6ÀÅŠ~Øû ×B Äa‚3Ë€T–.êEB."„0„!&€"«]Ç:ö˜Pýcœtü\n  DËe¯zUŽrå°=Ë ¯ûÕŸtÁJ²&AÄJtƒ¬×6&’¾ã$âÈÐgiÖJªc(/}à•±[NwjÅ.‰€:T[Tàæ¦ìk På‚F`‚¯ô)‹Ét¢É–™…,tû!IåÅEy! ¤ò8‚l*rCm#Aú"ÒðÑqœ–IÙy¡Ï¼ $¢ùPs-“$‹8ò8kD”,„3•[&’IƒÌã8 ÿzëolÙÖ¸ZÉ–¦œK|p P‚^â•ÀX°Im{B‘ ¼WñÍ…>æ“J¿¨?‚ý)+lK8šÒšc#¡ÑâE/ûÃ_Ô˜mê€ê‹‡8ÎA{ÌL´$ucÌnvá@®6¢:"¦0‹Ùk`£,~Œ 7+(tõA_ÌF"úØIF&Ô|D$å F6Õ,Tú =—ð«DL¢%“䂽¹è–JhR“x¤i¡ÊÚì•–ñÆŠ•Í›ág­`…™µ…|9[R²üC.ñÝaìˆIÙeR~H…×N&d‚‘ã^4·;–(E©ÊŒÿf&ŒFcÀŠvÉ*VI)uRJ«HA±¤²F’!¸A븆…ád¤»÷ÀGDâ4äµÐ…§D¥÷öJ‰„+:†ï¸æçƒ-³O @âbëåØû*h¦*—²ÿ°yo‡aæYìç0´¸ÅÀfnþr©KAªêä6¦aÈo›#–m9“BªV¨“üˆä šYæ 5Ãq²¨%ÊM”H@á@‰$€ª5”ÚªÈ ÀK%Ô®®çR¤S^ œ—¯ˆÉ±À“ ˆFçEX€|EpÄ´-6ŠÀ„›RÎrÅAXl3üp:`+dšºÓL?ÛE(AH &‰jõÿ< ÅñÃÀ±Ù^26î‘‘jÄùAªBW~¨X¯bñvÿ+Y·\’]J “G¢@  dˆ|<&y¸I~Ð!q;‹*Òƒ/𬠶R.)‘èAÁîèG§ÂÄò)ÑNqJó Øç`½Ñ%§^Ù“µßr•Èžå™7uð¶¢ÆŸ&ïBE¯†­%ÜK)ñÓøF‚œÔ`hG;ÕdU«`›Ð’NRÜÕm6¼ûÅ@x'öp  t¸“Ô{qòˆ07†õ@fB ì&U¶È¹Tš\Âÿ5±áDR_š*ˆªŠdódYº,.Y,‡íÿ«0À²yÄ&¦Æ4v†ŒôÐØº-–ô¤wH9é\æýxë1ªÌ匽y»„ÐÌ«V"¢¿ ’,Þ8Ëà¢õÚ“”q¹úÕÚ{Î)ñ ‘•ôúXÎóuy§r^ùR§%çñ’—¬óJèÕð¹¤DÚšâ¹ÆÏÅ>UHÌÿ–Ãäô?™÷ÄMgJ7ˆ½e?­K…@ˆ¤ „â\ÎÿF⌛¢½G‰`EU« £€^,ÝnmV F@EüÆI ´Œ×ÑZ©P,\ZéC.¤ÐÕh ÑGÞE‡Ù)ŸÞíÕ·ÈBÏ·ß?œ×*ñB}¥¾´‡c9Ñ/¥…UxÑ¿ðÃV€ÿž@X<Œ…üìÇ4ýÍ0ÙÏÜDç‰ÅQL±Åèá…6Ç@(Õ‡%U§ŒÞæ4Ðì5Ú?@УuFbè^hlpíÄŒ„jx`>8ÄlÏ?¬UCxïÜ*íÎ ZÙ•]Ró=OK¤Òód@=Ïy”—zð|-ÅÞí@\B Á%x‚PÛÈËQ°M™=ÖzDš©Í[4aÝh…\ÈßR””æõ_U˜ât[  6%•_ôq¸Þj̨ÌVc”R¨LÕýs­ÊèØÃÒiÊ,ñ[F(G-ÁF*"´" ^’M(Ÿ£xIy”‡#®À+´£}d¢?y V˜'zbzpÿ"­ÙÞ"¾xbá ä±ÇSð×½°Åû}Yƒ Ä8á\0ˆŸTa¶-EšÁÅšõ_À^1Žgì‚¡`[ˆ™ ©˜“@¨f ÙÃftÆ X`¢Æj0‡p‘DÈÉ ‘\W "õEWÅ]_—tÉ÷…Ë:VGuì]Àc$Štt\ n@züÙõàÛè#?z"S\ÂyÔ×.AQ™á˘ÕGþTNÍ-&$€lf1CÆŸqÑ}aé †Ẋ†$ âÌV91 RüÀèQ~G]ŒŽ L‹ÁLrDH(‡ iËötÉlÜ„ÈUЬݨ‰ Púš@P¸l—ÁãRøÿÀó  <ÞSÚ£'F¥Tb(J¥À…béKH‘/aäE-^µÅ¢´ Šüi+Þ—YàßÃe'BåÛ8Å%4Å€n€áýÚLÑQ0Q¾°œR´¢e ØJÑLÙæµ-LñÃXxaè Ä sŽ®›ÆÜå¥(à5 @˜L_þ@Õ¡d´|@¤½a áŠxî„F ÒH, .©z"ÄM" 9’ .%[PG¸¼ÿ‚£p¢D-õ „uô'VX¥@´&½|¢?G{ÔI€>‘@Þb¿¨EZÞKqá€aÄtÅ4gM¥Eþù NAXþs¦Ñþ,NÅl“ê¡ ¼GçÄɤjF ýaZ 1¼ÊhÈFüƒrhDNœDtDâ¸)VØ]Z-øIÿäø…ËR ¨¾6…­E¢#Æšóàë-î?ž( ƒ•¾Í%Š%˜®_c•)\€ÑnÂbþü 'gÅiœÖbÿíÅèQˆ¶ÜEs^Lÿ”h§Ì3ŠX6;ÝžèÈ!oaJhpÀŒŒ'cbX²lÐh’§Å+Ѥ]ôÀËyˆ*—‘*%Èß-E$F©Ðâ«BO_ª­ò×%þúMQ{”Ï<^œô—£0$å\D* ÝHÞ€üp(a„¨@gd“¶t›Ü`Øåºž%#¡¶Â½!«@ Å ††F¹rÀNȤò€ $=Ä ÍÐT—ô!‰¿j¦¨®©¢ TÚc Â'=ÿÏ”fîy eÆWÂæ+\Eú¤Ë-•I=ÓÈeX|EkáÐÔ‚ ÊXbRÓè „øÙã†*PR@æDÆ™eç:}À£åC6ÑÎä`ãŒpF$î@ø=|ãB`Ò –]nD¦mxî¿‚nLtæ+œ¦þÃ+¬„ ¬ÝD ¼ä•­n¦tXG;¾ê\œ±ÕËø¬Ç)Ûû¹¢BRèXÊn²F þå¢ÐM£.îÏ„`^’ħl$É^ˆvµ[m9ßꣵL³ìVKú–ÍÆØbªk¹ÐÆ@Ù¸¸gÐVf½ D¡X‡ø1i¸pâÒ–£u±Å#Ò§%ŠÇÁ'þ¾‚þ¾E—¦ÿSœ|í…Ò…JÝUQå\›\›Ò…†.wê"ÅØEzÆ´ħ\pò¨3ŽäŠö%T®ó&”wA®ÍškŽl`§Ý]÷>Ò?Ý$ävêÅ¡•ªÒ'uÜ æ^îóbÚ!SÖ„Éñ—*Œ‡ Dòfö¾ÊW¡œ”(¨~5Ó±Ùë} 0ËÙ*̵! k(?P`ïrqâx¨´šrþ…¤X‰Q†ç¨ˆßV ´ÉéFNȱÍÂX-¹@¬Û Ç«Ð@)K„ê“*éfºkLD.ˆ ‘.%%¾Ä–&+廎Ç?üBÉ… ¾Â¦'LÛ@|p9áXHèÎÿ…݇ßhžàïOÈFNUN€$¹d…Ø|@œœXT¥ô¶­`´$=œ@ •°,Í“ÔÄ5_д°¼JîÅÑëÙ\ŸPž‡P8K–EOÚá6^gÖÄvŒËûúZ9oY÷d훌YS¬¢pêbü«ìfç‘òNçbWd1O?kÅpˆâl—@_©4Fdì%·ú-"ðC ¦=à„½Ñ5bã?ÌJo•@$ê@\Gû±DÍø2m|Ö„<®j¡D„v0[‹Ée^ª÷MÇ?´»D$‹Ú °)–½°ó˜å¶AèRÈ.ƒ…ç E¢£è‰@tçQ#µ„ÿ±Äü9u…x63ªè»QŠ)Ë4 „ïáJXëÛxT_Id^\eEn3ܧæ]Ä´ð}‡Jâ•’«­‰J¸Àóh‡-M` ›èPÿ*öù`›DJÖ;KÛ:ˆ›z‘PœÎ…>o6†¡Qò¼­Þ¥y]ô\üÀ?üåU³“³¶PuÓbÈqX@È’„“HäÒ…‘š#^éapª¶J Ÿ¿­`p‹pßÝû®„\K8ÁwdJ/¼ &k­˜JÅ{¡Æ1]Þ,j…ª8Ý5)—T4u@à™]¬2yÏ2[1º‡ØÅ2´ÉÀ÷Ô$¢ÚÿC~‡] •½½6VÑ­üw„ŸÄnpÉG3Ä$õ6жµ¨DDd@° IDøò4G?¯ë\Ml‰r«Bt„Àã8†Wø‡óâ-€)Ò‰ìùþ:Jû`…ÀŒÎV|Å-Ý””d«O>ǃ†²-OC«žJÊP‰á¸YH0.`›|¹²`ô †Œ0IÄ XÏqÔÕ´$‹z÷ÐXR÷º§ô‹@ˆ3Ѩ‹ò,™C0Wí: }Ilj€+ Õ?¬‹Øð‚@>¬@—îÒmp~ñ)3°BŒe˜,>qÙZqxçÍ‚µ¢J+OKˆ¥´2A`∘¨@ì?œXj{RCCÿ/56êã€U ÝÈ“g•< G[±€`Ÿ¼–ݧéâÕŒ¬†—Ë\M§aØþD¸ tŸ›OìIœI>¼¯†óÿj²A2§ÍœæÍ1Ù"K)ÈYšÅßäÄ4ú>?:Ámhã¥ûøhûÏGݤŒ‘CË.ôvµ(Î`ÜŠ@p@“F’á =e9–»ð‘ˆ[¸  Ž×”DI˜´`:xsÐØº^<_Ë´\¸¤þCÐÜÀØÜÀk.€ˆ3|È&š1°n¾”íÞ=k!Œ[·YLÓŸŒŽN³‚»™–Ð1ÈJg)Ž ’|<•¥6³Ü¸Œž” ý,åÌŒd,õÿwc@ „!öñ ŽcÄh šðÆñT`ê»~‡ÂoGØ™»þÂÂØx‡ÙÿCö8ÁV€1Ç7~Y÷ðÈ‹eÝÏEYÈÔal{ÞðË“÷@„OEza"É^Š ©„|Ç÷a5”@„%ÉÖNͶ@ÌÓi€ è# Ш]!" ]4‹lG³\‹`Ä¿|ÿ ü—+ÂQæÊ¥Ï…ˆ+ Vü'ÂE>zmè9‰’ÏE'ö ˆ`°`¥ øþ±´ˆß!- .ð´¡âLŒ°h1Þ?ñL0ñhЂ ~ôD§¨9=Œˆ_S­[›Ò‹aïÿ½‚1TÄø§bž é•ý7ªe-|£\´ðãD†*|èû,ÉÎj(Vƒ¼{÷þq àXÀ?"gàáÞ¼|ú*pÖGAŸE„Þº¹¡À?ÌåZßÀ×ùüLP•VŠ"Fáè„pHzòyð±€A„ +iþ“éü'ÎO êÁ“ëѤC-vøç½)N‹Lm1O0+X®M?lo‘X^íÅðêu¾Y¯g¿Š%H—®ZþùÁ¥òª ‚Þ³°ø‘o ì³§¾–`Œ€{«(²Ék!„ÎþùŒ}1Q´ÛÖHŸV « ÿH Zˆ¶\"Â-ÿ·ÿQå‰bè{è) ^DpBƒ#W8iåX¢®–„Xi¦‚¦Û€)‚ª:jÅŠ\P*Ìõ¼û²L­ÔS¯"{ñÆŠÌ"h­²à|É¢»n@¤ ,’A 0­³æûGƒ “lÃ(#È2 ä !Ÿ|$ÈÇ)í"U¬èÓèiaÔŠBˆbµ(=5 "ŠÂ~‘õ—ZErV¢p"Z-À¡ôiÃ0~F°i嘳h¥˜ZO¼ŠªZQ©í ˆÇ(/ÿé2Mð:𠩬ҴˆÍŸ(ü ƵüÓ ­´¸’‹¥4Ð úê«H‚ÀH> ØUÂ,\¬QšŒÿ ÇäiáƒPC± ÑNí´ØF\í±ü ,†V[Í ±ZóÏ¡XuÔ±¡×þñÈ6}󀤆£'Ÿ" ”²9‚X²ÊšJ*‚nJ»¡Šâî§ó ¢n«iǵè½÷þ‘:,ûì<‹ûȲº­9+¢+®æ~X€¾>˜`ê©Iÿ±šB .ˆ€ ŠìË‡+ 4!O,“ŸHmFzW<ñ•oÍñ𼢂ÄèŸ`ÿ)‚†kƒK纘Ã)Úh¥Á§ ÀäŠ0l“Þ6¼ŸlùN[2Ól/0séa¬¯ì{û>ûæ™Óë‚ä*È%ǦÀOsËUÏÿ_uã˜1ûç„«[žyBpø}TäT‰L[Q£ÿGž&v¿ ÷-‚<'ô'¨ ‚ZsBVE$Â9ÄC-P?L‚’Ò1«J‰·b‚£+®# a•Pp\A×ÓÒ¦¦ûÔç>ˆŠA Ú–ù¬¥"s™Ë?R¡³”ÍO~iXA>°¶5Ñéxj!ˆ…%™ uï1sÌ=26¾J‰(pû”V$¢ŵ@Ü[Ì=äÇÄÙ/r­yM¬~¤  isÿà…FŒAxÜJÊbIq|X€ X€EÀ®­€É($ÊìHø?€0…$—Úèt§³F…ÄÿóÚ ÿ±<‚8ïõêÓõ–µ$ˆ1ÌYÔCÄEÙ͈pL†Z ¾|¼ç3ëQĸRÅ|„`5WlÁ. g8ýµÀ À|ÜÊôç„ר,s¿øG/|°94^$$þ¢o&%˜¨îY;«6w²“­X«(H9ÊëéGd‘T"É•­½­,0„a\X6Éë8ü€ŸðEO*”U3Ì 4`ÍM2‹JØ÷öv‚yØ£Rú(шNdšgnÅ–¨ŠÂmrqªcR2{q#ô"7)‚DX*’ê %{´À r¥èüÃ&ñÿÎké®é‰O*ðD²S+„QgÿQ PT{µ)«¡Î¢1¾E†pYðˆÃ¿ð.0kj|NpcÄ  *ÀžE2”ÄÆ4”c4"ȧ¦HʲH®³¤ CŒY‡D™¿(é?” Øe¦ô"‰íbZ`}ˆÎ˜i™WÇšèqÒú‡Ð<ðÍ«`Ëh@%¡wÀ#´¬`…ñP§hÙ¶Ú§&rzæzd¹#CxY/†àK¯ ƒR¿–µ˜’­ÙÐÂÄÇ L”„B:ßg>£¹½öÕ¯ùëA4‡›3„ú€\A©S9þäšy,6 ´A’©hB1ÊÑINE‚§ºÃŠ~TÕ"囀2ª€ÿüH}Á¥ £€ ”Éz5l RX~÷"~Fn'ø‡1 %·"J†{á@CãC¾v )¯¢¡èg…üáï !Í_E«Š”¥.°G 03Æt9ÌٙţMœê‘iBÙiÐÀÔA‚$E¾NVdy ò-‚ä· ©MmëÐc‘²v+„3R›‚´‚/ñ¤›zHaàÒ¨>‰¢Ê’¨%„x¡Â÷ä‘1ˆ¢&++“tÿ±>‹Þ5!*ƒœÚ h• ö'Ašk5ÐÃèãX(5i‚¥d©"OÉìÏ0¨Ÿ…S‘RñDy”†;¥u¶ä‰O|â`ç:ñðc;¤<ÿ|ÈËô2ÄßÔ¦O*,"È<ÌzgD q ±ö5by,áNœ«Dë JƒX$} Mú¨[Å̹À!ÿStA {X‚¬´"iA(LÇÆ4JBO–VbÙø,ZÕIEv2&¡ô4¨ÿ¸]ylц礂›êHÛ“+£Éâ4¤8Œ^{²ä.d3Û~g•ðÇ“0¿¥á`›Î¾³BuÊ÷™f»kE$PjSsUŸÐ;e>‚ {»ÇD7a7‡Ø‹ÉsBÿŽ„(íñ¼W²ãL¨„Mä¤*­  Æ)Ô ¥¾AMr™Z]e¡äÕØ±ò·ºkpµÿ½’- -°ÝÛM¯H ÷¥žáÜùÎèšÀ½&dO+¥ÐÏ7ó©ž³hçA7MhFã©ÒÛ"Kÿɭа‚”ÞùÙ¼…¶äC+ˆ©sú=%gå±JH®ÎÀ9ߨìŽ}I¸ðU›ÉÕݱ9Mžæ %֛ݩNÿ3G‚ôú.záí›à·j<ŒâÊJ˜² ŒÇ3µ‚mçÒH—Wuÿö)JÑ|ÛÔmd™9ˆ ›Œ&B€bV*¼ üeê¢Fàê°n9@­¦ž¥"¢dÔHíà2 æ+[Ž láønG*¶âv®Êná„ø*è<ÿž/ïÂæî" ‡·ÜÄûï“aæ¡Ä…-䯰mà C‚ÐÙC¡,b Z IäÛnÃ|b£E¨«"$†ÐfIÿ¨‹Ü´Ð|\à3JO(ÂôP€z¬ŒÁ_8‚!ÓPâ¼bBë Cg–c)ÀÎ*€"s’JÊÚ)iÿaÕ˜„ÜÎ"ïØîà(Éú, Á^æ“þÁûÚ¸€'Bx¶äÆü^NšÂÒïñÖƒ âJ®*E¦0!¦Ðþ(Š€Œ®Ð(fôh¥„„"|$7f±Ç8ì ÛÂ0ŽdHÓ¤d&(Ë",P³$ÎKŠFƒB˵¢I°"@ОqEžÿ½¥Ê:@ilëž, “𥇎硸oýc].>~°Ù6Ñ_Féå" ÛçþÌ=bãRþáá4'±-}"‚ŽãþÁš©™r£™ÆœàšÀ˜PÔ¢ánÀ¼–†Œ&èYªcZÜ+Ãl›‘+¤ñøBí ©ˬ×ôîºJ“ÃûJîMŒx⬬$$S®¬8Œˆ† Ü'áq=–`!Ї¤p3lã'dÉS§Ðvƒ" ’"ò(¡"šéG¶E ÀB ò éŒX|±02—¥ÓœÅúî'z¯³,hœ íšÌ$ˤŸ"¥qiÆå<®‘ÿõzíf¿ÕæwØÂMèÙ\î¡ ƒ  ñ†ÈÌê!0-‚oèa|ê–ð‘ ×ãó* «rT¡™(Á(5µ’G ôAÒO`ÐpÞÄ¢F -c#cRÈÂã#m­'†F$3hÀÀ¬Öî'ô2o/‹w>°Õ“yÄïø ãã&SÎ>¾¯P\Qîc(].Úþ¡ñê2Ós1’« ú¬¹^é'šò)!«pB£  )!7Xóô|ÀŒD€¢m QT€êøÁêÐrdúM½Öã: *ª%‚ÅÔÈIÌ4ð.Ó:-Â9¡ï.ÿª/$àÛÌ·³¸Æ±jxp(/Q"ÄßÑ›$"ðB.D+ä³o ÊaD5@CÐ.B–8%bVJSÓ ² Ò 7,ƒñÌ* u³$`~3È@N-·‰ÓÔˆâu ø"nDÑ9œS¯ ø²[L0Màá°*†DŸúbü#t°üŽ0Ó'‡hB ÂÙn“Ú³)6ÓüÊê¡è3¢§ ¦KܘÔ4/J ÂGþ¡@ËACqAÏ Tœ€àHÓ¢d¦&k¦Ök²þ-Z2ô:ä(øL4G¿Šâ* ‚9ß4Éž"0OÔv¼ãvÚ.0dÁæzÔ,kÿ"sY åxpm¸ʯ FIÃä¦Q—°å,äåîAH¹B®Í¡úÆoDpBC B–6¥ÿ °*W@ÂpTâ=Ó/"e"Å¢øÁfd/-sφ,b:2ë[|¢³¶CwˆLØ´£bn%—æK00«ÑáLÐôLXZ bOF®1“’ÙÖµ]¿c•< "B&\+•à ]yÏ ¦"ص‰æ‰fiÅ -±L“S‚n"ÚͰšn gÓÞ3U5 `Û`-ŠãI`%fªŽôÍ9š'NQ[2Gbý Õnlß´÷r:••+”Æáœ¯",ÉOuë/²µû|2‹È³oŠmˆÿ*b(st\ ¢Êê΃guvH±µ-þŒvóJCó>oÜXJ4”©»@uEÀ‹ÔÐÐ0èíHL¢K"K²Ö+;Uw.п ÌBË÷L <̃ážb*L%7OA¶%.ÖšÕ^’&¼q/xKF-±\vQÕ†q´) ƒ]ÄÕÙÒó+âB²ˆR ba4¬¹æq–_qS(@bF$ÜŽN}1§ Š@#<—ñB÷ Â# Êd)€l8‰ŒÕ‹Kn$Å$ʈ ì LÄîƒÆÃ™†iøÒm­³Y÷î–y¤yÊÆlA÷Cmæa]K`%ÑCx\gÖQ½U`ÿÌOH‘PHgn+– Ï˜ð{7#S b8¯Ðê*só0"‚EÇìð€qJ9fuu[¢Båp€Ân„žìZXDNì@¡¢9?0%Â)>¶;<0™uŒ—<,8&`/úBƒCØO`]é¸]¥Ffã~ÿPøQ±WgõÌQÑU{9>ËÙ8)þ´pSÝC6nG|ÎF\ ˜¶ˆ‹B7"¥©“¡7‘ƒ"òík›Z B^h'”“JøŽ ¢€M  …B)ÎヨL—‹YKÔcAö™u‚?dGÖ;ˆY‚(à/4XF™­Šè˜ X`¤Æk4 †ïÌBV:¥S¥Íu1ŽÈüöFQ’0]#Ú,UqƇH ¢=—>qéø*NzE$B©6tçw`Ià8.R”SZ,ÀŽš#Jê°:˜s.9Î÷®Ømùi3/áT+Ìn¯±NáNn£&,/4z",Ž‹íBZ`è8‹Â'ÿUn5Úy¹7=_¥×`åÚà1]†† —q8Æa´­²+—â„QŸÍçì¡…@7\ss>`ª`2-Èb²²ü•“x³vM+²ø ¸  Îu´b*¼¸Nõ²/ñ¡ÃºNã¶YØ¢…¢-£ÿá{H1'¯÷vŽ×uŽ¥Æ1c`2áÚ°\h7Ñ…G̱÷Fqkîå²H…ûL`vº=ä*PbNÞ‡ §~óá¥tÑðÙâã“S‚¤zk—厺6^´³&~b(‚Âà~êí*¨€*ë0cŸs­q9¸ßVáþÒŒÉX÷ôc›'·*`Ž­ZC:‹ÿBš™±µ„Èq\¯-‹ZÏTú{[…µ9Hwö±gz¯ ·•¬ª\Þ¸yIp›d86ÐN€`>WtŸ­IkŽƒ¹%žóY²®:²Z•i§"N )8ʶ¯iÄîÉìDžm¢Ï:qçvVP@²OÄÏF7³•™›ùoýijõ1½ûÚC°›ûgîÃÐ{]Y8~ wˆ =[ç°‹¯ H…#Ž< ìá¾#~ß™¸Ú ž:%˜€IGu6òÊ›Xpê¿Å–+n[(h½)N««Ñ¸sy="ø;Ժ­ӭ¿£í,É0'€jtpLüF:åÜ£‡ÿºsfa~Û¦³»zÅg㳚C,{wV¡0=~Rx ¥»¬ÃÆïA"é›` Ês™\¿¥¢D%(Á7©\#™…µŸ3Š}bA ‹¡€¶¹CÊȃ‚x›:JôN%‚Éøí¨L¢Ï%ð(F.º¯Z󜺗ÍwšÐWH·RÁUQ\X ágæà t t@˜¡þ˜áž`âgÜ]ñÖqäA{´Çñ4,8bP>{Vþå½` ”Þ $£òᎵ/Ò ƒ¬‰›8qâZ¤e½÷> zQžºÓuÎÌBnß(ífgÑõ׃ ä§Ü7¿/cN€"è¹HèGâHBÉ!ýâŸÀ1-8x#áÁ 6 ´ðoƒ‡Rüw£ÃˆüÆ+ð&þA1)0ž (ñªü7Âÿ ÿlÕÈÀÁ¶têüçÉÖ¿ž…îì0©À¶”&5º“ ÒHMØ2ÑkI|ü  A‡Æ2ú7oÞ¿³O°(ñÞ‡Œè†Hž@ '.‘÷oÉ?y÷ÞëKOÿ÷ &Ì¡ñÀ%KžôëΚfkQ/3[Ò¢IhÐõÊãÀÀ¿Æ÷š$Îk¯ÉZ0»¼™3A—!PB¨¡Å¨;ÞøÇ€xK?†T =ÞIâJDjsàÏ¡:‰-º]èvž3¡–gŠÝ)ñ™µf}_²–@ ÀJø—OB… hç1¢Çˆ=Œ02O_kÝ5VüÑ%Z;ý؃ô¨ AÿbK86Pj« TØmýXãOˆþtvhMœÐ‚@-ôeÏ`¨q`X T؆=PÐcmÆ\Öˆ#Íe@DpÐ - œ@ý3Ñ??\ÄÀ%çAG-7R<*A±RHÿX·S<ÕmTTr@á´ÞNAiÇ]šßEEUSæ­GA&ÈôW^Ù—!e­•Ycŕ֒Øh'4¡^-Òs†‘ýÓª‰Ùã=5`ÏŽ— ¤-P” ûOCD¤$ARz"¥@mÔÒN$‘Ô’ /¥YžSÚ´fNnŽGÿwiª•U×Y…îUWe%ÕN´‚HXä÷Ï…žUÖY4¨V]ÝÅ =¶%i¤«9v‚ ó\:e…æŸê ªˆ¤žØ‚ŒÙ“O>ŒÁˆá=-$VáI—âªk÷Ú$¿éбKBA?4ËÀ ÄäÒ?hù%—ÓA§Üx*Å­vfžéfTs†ËÔQP1e]_®K•{`¦âd+†Ü—ŸYh 4V‹ó´¸Ö¾‚Êõß 1,ö`„0¡^™&Ø…«<ÅòJŸP¡@äƒk«¼Ú˜hNèD‹NèÈ#àÙ¿ù’R.™lTQæÜ´-E»žJF´4ÿšO%®šLÓÙÔPYe5|B]5“ÖìæÉä^‹Eöü)JÐdÙ‚€Ìø€ôÄ ÜÄAÜ– þ£‚Ãòཚjù âÊ_v‚12âè„ùØÃêâ äÚŒôDÞ†P \¹ù— éàxN8Ã:Ö|JG äg!9ÉI´Ä¡¡NL×!Š=‘“§•NƒnBOí²®’T¥wìR ;– ê,!‹ ¤—ºœE.S€Å—ÅÌ#U‚Ì@覅AÈ/>lÕüÈg9ðˆp‰ù‡ûþ!0CûàQ? /pa- • h¥#EcŒÑ؉:.‡— äsHªˆÿÕ´€ÖÁuåút¦C<†¤$d¢‰@0HðG<±[ ËÓ;¬½ç\·SÊïò$<û| d©— ÉB Õ%†º‹^ì¡–êAª-~ù”b.á o!€j€Dÿ)ñ2ö»ß!dPE•(p†h“+XÑM¿VçÚ˜¤bP™Û€”š%-/E%Z'“w¦™¨gwP×ìÀóG[å&ç1Š™”¬` NZaOž,ICüC…àÏ?$`}ˆÅAþÐ@ú¹–€R-'pPõø2ÄÕ,Eh£Œå1DÉ4 ©hTG óÙÇöWcS—iŠBÖÿx†ìdI¹³C&\S9t”&A6r´ÖåÄ[Ü 'r“s¢‡'X!—¹HØÎÛµ'OòùJ>ÉÆC~ú€Úš¦—è L1˜õ )½a mYeBsWÆÒ¢;áQ…²‘ËË,"°7x¥™|£VDAT` 1’ÑŒh|Ù Úˆ¬¨YžÓÙq8:éxD²)Óujâ­×5M'KËNÉãH§`¥\%üÒR£eˆP`R5Þð‰DdŸk[d  -“{ù‡b"UÄÞú,•ƒÌB#ZXVôGçë=±\æH"q¬±e ŠÙ•,1Çÿ5$"lHEŒHh’«iÖ’Ž{Yâ‘’h 9êÉ P’Óž¬ œ8‘M8Ø;©$UÀ7µ£@ðÑ PU?aù‡‚)0Ϲ@ @%(( ä ²¡M«j)œoý"©Ãl{™š`Nàà ©†¢“¥t/Cj„Ô°®›xsX¤Jelæ4—³ÇBә΄æ@ظãäL#¥lJ(k‚gíDŽÄoM0ˆåœr(˜u'qF+Â%›65×"9„°HÂÿ ê×ò1þƒ?Ä0õì½²M¯@?üG BÜcD=Õ=(³„Q¦-­\+sÂ#ÒØÆM;c?±ã$þÿ8ȇ]€N~à‰d±Nš²” YétɽUÓN±<¥þ"ç›V£Ó"Ýs¥~Ù¦I0kÂfä3,c™°ÝrÛµø³EcÉË<èQÐÅüE0‡îË Pâ&´æ‡=цM*¤”nZx¤ˆhZH>ÎD­xùÔDFŽÎbŠÀšrt½¢ƒJ7“Úø‘ߨ¬Ê­,ß/‘IßA3U1Òk˳,s™‡Â·D[gÁs‹V•EhÑ;QÁ©¨ÝIÁʸ”w[uÙ@3Õu±7.“„+þcÝ™KH§7À"KéIäΓޭ%·:%OfxÂc½žÎÎÚ³ÿ‡Ó!Õ#_kE&)!3J’ €€˜*FZì²/øµ°¸<ŽàdœŸ¹sÀvˆ"¥\åZtówi÷PR.oî¿‘Äð•GêHb.£Qð‡í´’9ô©Þ nVFÒô³`t`Tð Y3‘Ë‘K߉bå’XK×a’¦R‘àÕ ä­X@îÿ1Ub€(¾ÇŠ+‚îðŸ8(l ý(-4}{‰TkTN0¨ÜCåë1¤u»šýÇ,Gþ~„Jòßew§Aýƒ(u.±Bw’ç<¬Geô;Ù_J~Æ@1_ÎppT5€­×ÿ¨Ã5¿÷hç{¼aaöÂiw€‘qBJgShÁU|!hÖc Ú¶m‰F‰v%¡ÒbÞ7K—A= Þ0FœQ~ÑD5y>w v&qt±jögd­ÆÃå·ó,@Åzãr€R†zú·1!&ñ0bbÑÂpô `q­@÷5q/€®t|t6g—|{ {‘*ÈU~b}ö‰0 2@šÂ}ÖÅ#Ži¥ã ~2èƒí×¢°¿rKèL7s‰@gL­çÿ -# ¨&:³–Sp¤ÈŠHÁ3nRa˜&N¶ ÿv††Èfiö5a1ÿ0mx/p|%PiAgßÓ8²*3B8Ï8# v!K@IàŽ0E%K c1øh3XrÀ,Fƒ¡tõˆßø}åøƒ•÷9ð6ðXjN¢6:¦xHMØØôŠÎ2…Ä1VHW2Á zÔ4\3­àšç7Àf«%[¿Hh‡vC0õà ÿp r7)½µ=b "÷%(ŽW:G÷ cÿÐ}êÈ#ùpâ¦Kêð Pc.F‘(ƒ˜# ò–‰GvyEwj9³4É„tôz[·~D'G!€H1€¯‡'Öâ§#-OØÿ3ÎÁ£'ÑÔk¶8­ð¼'lC@v¿øQ‘­d8®’xC‡ÖFb¿$'‰Ð’ñꀖ6 19“¤² ¦ŽXnë”ßøc¹H$ïö9õ˜yšøn¥ÖR­Ã²È= !YØ3SæNr…¬èÿðz7õš\(š>3A ô ¡@?Ó"’…v½hˆ†Àg¿ø‹µÈ5hÙk °ZPo÷0a ðãŒ-` $w!–Ñ‹pŽÑ` ="˜óÌ ‹Iç¦~1Ùä¹Ü n/ÇŽ’( p@Ÿ7ƒ™È"jÍr3‰åX-AVfé3´èšÎ"Ap†äÿHdòš8U#p'bÒ©ÃÈú&ƒ+P`#ñ#„f‹ <òè`ÿ œd(d˜ 0†– ð‹!‰'VV¾ÕŒ|V)‡E˵×k nÿPs2h —Ñ WDéHÜÐÐ<(K“¹?v­p,ä9ž³R¥ÖFK”TSöp)cJh©#ÇñXA¤Èdª•0ÑY9¡ÉkúËÁp$'qMŠJÀÖ5ÇQH@cÇ¢)Ú \“¢+úÈ Œ«5ox!©¢=|ñwˆÖØ ¥2˜~4HÖ5—AQæ—DÜ–vúRÊ2ñ¹DR,ÏÔÿ™RBjЄ¦³&-PÀÄ=c8 •G±¦±ŠfÒŠ3¯¸¬¯'›Q%ëq¡Ò* ±›a-a`RE¨ –*j,ʨz®%Z— ð‹®ð/ð}Á‚ÑU¥‘wˆ6R`]ªÚ¬˜s1'KÔ@=HRys<¢¯²´xåøÞÙª +ÿ‰@@ ë{c±+ed¦ˆ¡B=â¶iÒ«ÑÂ#À Æš²Êúzm*€îÄd2¡^÷•˜›´&*p›Ó_iB„ZÈ™ $º ®‘âê‘<@ ÄÇr¤w)‰"ÆÀb\Ë€ÿP°<⯆7Þ€ˆ^”—a¶ën%[Q¹Õ(És±Û"@§ú&Ї•þØŠ¬(²0{]Ø• I›cù^ËAÕj,ËÛ*P;ÁZd‡¢óÈQ ྲྀˆv– Œi66¯”Q¾E8êÛÕW+ƒå£ëwºc4è Jêž:Çsa°°k$+pLnÄq1@ÿ p1ÆnHƒÂ¾ëŸþy 1¡¦¡ˆ'º¬RY:OH2ëNè3„»”¤@û1(¿È¢ji®£û³”Ks¹ZæûP…±"ÏÈh<2¤êX:ܰxypEª+K¨ª:©žûË~­Û¯û¿²å`á¥8aŠÆƒ <tH‡nBV:S{z®©"{¼¦Åu€#<£7­gË«hCId#llÖ¢’»tŠJucw%ÀÁõ—ÂÔÉ—Ñx>Ù48“0cúË€®êc®»ˆð¿ð¶‡…”óM# OÁGp|ð¢,3Ú4Wµ­Ûê» ¼¤x',{Q ÿ­Êë•ëÁ­ñ§NÖ:·v:\¯Åq Œdè½Nò¸‡$“»«ÅA ¦|0·"’s—¿<œ&jÀ#; ÝX¿iB íYƒÃÔ¿Œv†¹J«öÆua/ L9ð9 ÿ ò|H$@L&<¡ÑÒ…1¡ªpQ¦-¾Ì; ñ§‘\èÄó•ÊÀú\¨c¸¢xŒ@çê½»øÍü…aÒb0ç¾ý¿‘)ÜPµý@‰‘>º:°ˆib##ú@v½·œ#[ÈÊkËû]Ï!û°å]¾ò¼ÙÄ!>ëA©û oã¡»í&Æs!Þ4tF‡ÖÏÂ| ŒPç·pâQÜ媨vÜkÝzëJ—ÿð†àCD9~h«Ñ@Ž.IÕ€öÓÝ}±´ÃÐãŽNOâIR;¡°/†é†¡×–òýFrÛ¹zÛqòÿÏ`û0ëÿíÙÁÙó àŸÍQ~,·²Í1°Ð;1ìmî„nâú<y¾Fܽí&€þâ‹Ú¨z¼â´õPãßs!åx躤O@‰w}˜’2r’-Vk@EºÄ O0 ÃÐ8àkàOðñŽ:Ýרˆ®4 ( Pñ—bxÖä±U»úÀ0/ÔPÏÿÝ廾ëºþßu|5:7Çþ6^µm$ Î~Å‘ÅëQO¯]:Ê<Ü(NíÕYâÚ̃!wò0¯-ø)"7©m¯r}x’9D¡Q¨aåN…ñÿwU+Mïw‚Æ m &£²Q#N£CqŽ-Ù7€Ð¸në$ævoµîß‘ð¥ü)q­çeøn"øQQç%À4OÔÞçÁ½âÃMùz.¾@›&B/àÇn±p§ô+¨P€·)Ž¡©}Q8é#ïô` ’#rÒM#³/û²¿!I¯£±"Æ ö5ñùƒËN0[pÙ"ÏF°üu¿Ùµnò®÷'?}ÿª‡Ç—ô'wÝçF/wGPô |åð*þçåéq†žÎQlj®×žâó_ù”›¢zl‹2.®û_ÁÃ@% ²¸GÿàÞ?†>ü·ä¡Ä& ›ük±DÃ? ô6;±â=ÿq°èC”%I²¼sáËÓ  G *6räùïÄ zôQ@”´‚Ð#ÿr`¸ïß¾F ^šƒêV­]¹J}ø€ PÿÁÐô^Ó‡k²ýçÖíÙ‡Gäae—.‹·yùbø_ª‡ RF|Xqb 'hÌ0Á¿É¯N®'BÍ%޹W6!à%Kg,-ôDÇœ![m1²¤€¶ÿjª´Ý2¦mÛ gîþg,¸±65´¼É á-æåCD‚¡‡'ô2´úÕȾíZjçþÕ{Ž«Oÿax;öÿ#ìÛ*Lß¶ýü™ùù{6Ó¼‚±þ±Æ„h±ÃTL²)‹LÁÊ&{(!êyˆ³Jxá³ÐâÂJ¢ê0‚è8…c¨œd〶¶ê«í‹îAÑ"‘& n£6n®4‰ú : þ¡"³°¯Hï ò*I«¬ò¯¬²Ú{r½¦Øƒê:¸®ƒˆ?ýêÊ¡þ¾ÄÏ¿ÁÌ@ÆÄ 2Ê®²,BÉê©Çþ ‚Î 0t@ž²†¼G£àxÒ ¤ ôµ&@2¦…PüGÅÚN:‰$Iyk¢¢“V‚1SàŒ9t Nm+m&‰è‘‘VZù‘:Fò#"#³â V¯ 2"I°ÊòªÿùªÌª™|óOK-ïûÌ.#¬ÁÁ@8“±ÀÚt3Zˆ0““Î"(O Fsq‰×åÍÄEZ¢¦rÕÅ’RÑŸVBI&Z—¡Šjº—F/ê³ß‹x4„‚S‡@‚ J`ªVš5IÀ¶2‚IÁ¶sJb$ È¡¬³Üsï­…®ÌÃþÞ Lÿ’eh±”{HeÜ B™¥]sÚà¼yN9ƒàù…m·…¨Ü ›ðC#JtQ~g{%{M‚襕biRÞXdë¬):!„†¸±!†8ø³„±úê*ª²z(¼YN;0ò0FJ,…¼[×b2ÙdÿóY” ƒìAÿekö/fÊ(¤ðfWxà‚ä¡<¢¢ãZ·{3Eš¦Ì‚zÅ“`â¼7K]r¨¦§7W«šºþ àSž€„)sX8p†lÍîÞi­«§žB½„çËrÞõïùbÙú’ù‘š ÀÍLÍÂlv00ÓDœÂ!þ?òXà+ó¬y‹KSÿ%±ÒŠê:7`aâP%úiR^$“X¬Ô¯¡”oöG§°ˆ%ÌE¦©—ðˆ}" °X™‚`] ÈÓªXùg+“ ChCA­ÐF*ÄÊXÆÒ/ÒQLÐÓRÉH†LômÏ™9œ /C3ÝuOq3#_=ò²ý¦}À:‘‰äGPFíhùŠÚºB,Hµ³>ÿ‹K¥N0zð@(ИÇ\à3èi•U¼ÆÿµÕ’a¶´`@‰»«@,C 1uG,¾L/oùK>Ó f ò?dª¦îb(3D^e<ÐP¿¶¶›‹¼†9&ŠM¥˜ØÄsºëhùÃѦF’¦]EsòP„*zŒmA­P+à á²ãÛÁ[I°U¸cî*8Õ žGJ¹ 2?è—&¯0jÖ‚¼WÖD".Z†,œRÀy€f‡óÒÜp4`¢Éo^¡cM~¥¿õ!7Mlç1¡Brd~‚ˆÍdÁXÛºb±ß /0E’UWv×»'™å¢|;fYÙ´ B~Tµ2” _¨&Å)•  qDøº×DÅÿTŠí4¾^tµ–8D“ýŒ‹æÑ‚Æþã±7‹¬DY}-eéÝ5 Z·I‚ ^VÞÖPÕíµ\:o®Ðº,•­šÌâçtO¾i®Uf1tef²Noá'9Á Lm#ÊrÆÓR^OMDàæ-¨bx0ÈA®¨õ˜aø2¥úl, £Ê]b0vǪ´ÂNwÒ8Õ§<ôƒçMoÂçŸÆ1ä6‹œ0ÜHf±©­°…!eZQdÀW"qÍqèц´É1•)Ùg©Þ\m$ZðCÕ¨¶´ç?\á ÆUB3LªØÐ"–Ìb‡wQíT(æ^>¼ÿZiãw'ÇõÀø!w )ò´ Äš!ÀŒ¢ãkÝxN 1†gXÒ·®‰‘ŠC$¥×tRq¨uÇiò’™Ìd¿²„ÁãD0ûÔ…eˆÐ†6¸QÈ=ä!À‚q¢Ì÷6üV !Nbèvô0[™Ïa¤å°ÇH1‹©ÇÏ$ÓYØÓéúˆ¾Šµ±¢hÀ“9ÀÀËvõЦ+fÌ=Yú2¿6 Œ^³z,ÙÞNnrlbƒSÿO¦TΚ¥ÈiÄ-7$k²fì ÙÅ5nB>á>#Ló€n¶$OÕXž0bGV¸¼XÇBèŸcùGä±ö¢rÿ ã._ÿ“\^‹8`Ü£€È(Ðãm22××DÜd†ì#Ûëôø‡îM'´aÉF¿[rÄÒUy¦Zn»ky¼À±cC`†qkòÅŒŸ½>Ä’±6OÅ?Ã~6œ­ L!‰É/wt^5ÙG†øbåäö;Ì¡h`øÑ„'÷Càw†À\ÜÀ9>‚s5õü2G³![᳸¼†éùHºÓ›î„Ñã›É&‰üåÚ¨sËP½ê³† ÌúŠYd–\ÇWTÉÄlŸ”¸“àÐ\WØ'ž{œ£ ±²Þýîσ~àæÓ;lÿƒåñE·a~3ë3>MõPôökšãüãF‚Zÿ+¿Hl~OqDÆ&IŸ‹|DÁ ö/éI?jä´¡Rµ÷ "Lšrâ2ƒk…ˆ?¯ã!ذÈ@$ “Œ]$ð™)Á©H#áÁ¥c›³Î œß‘¾++;"“[òÂ>»¾kƒˆÅs€üEÀQxÉ{W`¤‚ ËÀ<¸b ñ:†È‡"ü‡ú+üÓ?ÒË7C™Ÿƒ‘€©DáI¡Ÿ-‹µÚ+À§ÙÑ"^s¥É71 p…ë‚ öp1 )3Z’+¶äÓ®‡«,q>ü3 :‚ØCâ{€Èà¶„ˆ –[ 3¢4Ú8 ¼ [FÕ4Á¨¨Â!ù ÿ,éÿÿ H° Áƒ*\(0UÃ?jý`H±bA|f´È±£Ç CŠI²ä@|©ðý“¸ð‡Ã/aþC)ß›6!BĈ±æ¿Œ@}ª4I´¨Ñ£H“Lépb­‡_¦r±êÁ¡3ötƒÖ=7ü«´¬Ù³hN$ø´ê(·VYN\;ó¤A¬u¯NTéU%Ö øÈ Á›¶°áÈ—ŒubL¹ s¼y³æÞ6þÌ›¸³çÏgG-^ ±mAÓ-uªö9²×^7DXAö†Û^ º·ïß§G“ÈÒôÓÕ‹o ¼Áœù‚°HŸ>1#ì³ÿ-`À@ywî7¾3ÿX€ûö?!uñá’ ¼½{µŸ(Zç[¨"¹± Cþ !ˆÒœrÊ ]mÏm×ÁŽ`Â?#Œ@¡„üðáxåá3Ø{ †ø>oÙt_N­!GÜD÷¤\ŒÀŒTÿäóO;ÎcŒˆ4÷OxÜu@á@<þS@æ…‹ˆ\vy]õ‰6_}ø)ø™ñˆD|ð=:ê覛ùÔéfò³#žAZXÀƒØó&ŒÚ#¨@*$ªÂ?O E#X¹%€ †^M—z©)ˆ&Ò%AŒ­%ÚPÒu·£=ó¨ Á?«ZÀ›°Âÿúª@ dOžüÊä›2(Á0b¨¡²BñÆê㉓2Øzy±·é´†‘xÓKóÑgÐo‘ùsY˜ë¡‚ÎZ€ªöÔz(­Jஹµ2‚l|E`È„À¬óša N¨`Œ=xÀÝBXúÏ–Ô6œX˜ ªÄíZ*IÔi}ß2WA<ëZŠ&šn­«Û®’ñ0*&¸û?hHï­Ppÿ¸É=ì;Oè#BŽöУ=ùð#ÂÎ~XÃG>O‘:N”©ô–tH ñŽ`O 1óÏ ÉóÏKœpB *ÐÓ¤@&¤ qËàŒÜB¶@nÿ£¶ûî³.Pì÷°Ðo¹Ba÷±È ”r<üÐG°èA¶y¸xÑ@óŠÖ¸|i2BÄ”T`eEkaêÙž92ŠÎuŽDß«O-°dàã˜@Œ”ñÄ` g[ Ôö¶Èã÷GìÜw`}@Pö@–±ÿT÷ëQü Ç ×<²¹ †Qàs†ˆç,í[¥p1˜ìIkƒ`$H÷>7Šù<Å,ÁÊþÁˆçiÈBí3œÚæA¡Pè8ü^羄€G?$Ö?TwD(1LÕ<4p°}! òžw,#=n)‚ja£ç€ËÀäÿàcþQÿ‚H@€ô(¢ªÌf „, Í‹•#Yu@¶í¡K4T±ü£#@A¶„rÞ!¼É¥EËé›s‚¤¤ÁŠÖ*3‘lÆP]< py”à´¡ÀJÇ‚`  ÷˜‡ôªlÑÀªP2vtág)ö)Î_#¸ÂÃͩěØç8’r*[!“ÖF¸-P‡†#›þŒåʬ–φòxÝóià@‚sAñlŒLAš:¶u¥ yn{ßÚN Ñ M©i Ë, 3ë‘/š5)¤ mMH‰žÓ{ÄÑÖO A€ÖÊCOZTÌ,Šˆ[ÿÔ’¯°»Ç/ "¿–@@Ä‘yLÄ‘‹JhÑb°Ô¸)QKPt“G¬Ê-KaòhB ÖQ±dî³h¥iG9Ê3­¤¼› *UÊ›L€9À<*D¬”1 1Èë@v »¾¶ö]"B€L(2—U¬:°Aé¡‚}-  ¨Ûîñ:èR–v•Û€Ó2øÕ«%„½é$x‘¢5óš7´dT©¯1üø¥%ÈX$Fù+*À¡/õ˜Ï½î— ~ýG €ËN{ÄsU 4®ªœéBI^µˆ’|Ó,óšÃ¶€Ûô„†×ƒž, D»_.È`Ê:bЦ6=ËÖxM;6“ ÿM>†p™rºb…s›[ÄÇýý`E AÉ2©-"”ëȳñM†Ò‘£ËG·i ÃcÖ,G$ó]-´Ì%YïŠÃDÞº„•ô¡ZªÏÉ™\€8©À•)“åž  W@ϯ¿±#À<Ú$½BZÑF^¹¢ aèNö`¤ë^GY iÙCYêr ÅÈÙK EÄÿð¨M²Öϱ9­£Mï¨ØZ¡óL(ÁP‚`²5´Ý^è:>ÿÃÏÁˆnõ*ðŸ¥k©Y¦²Íå¦@8izŠ8"çÑï%¨àój]D|)†{ç ©@6ÀO,`ÜFÿIñŠ?×æï©–¼¬¾ˆ!ŽÈ‹Ês¥+‹˜²È{åã^ ðZƒ™ †\TŽ”´ôXC{Ó¤¯<«hù."çvAÀª§…›.(?KyOBÊñžö¤3Á’{úhŸA¸y||ð„à±ã€< ¥ôc½iQÃV¡ìHH×i,€Ü>0+~$MR·±€_È|wX ­IæÄýéß…½#ï.{ªŸòæR­¬Þ¬(àÁB^"5ðX\÷Üu­Ý¡`WwpÀ÷@›Élõ¨r¹lVo‚Ùàu¤4ße²Bb€ï˜š¬Þ€6± {¾8y‚˜‡ Fúüÿ¦2*ÒŽö ¤/u‰½‰% HGuÎ<öE;Â+OPpSæ±ÈFáÜ·öϼÇk'`HHfD@Ät0Ä++#P PâU+÷Èw<’2cSSTæ¼FalK¯bPíâ2Äò.®31Ã0¼€IT2Uˆ'ÈPùp}`™ãYº‘J^f‚%!>ôZbän¨FvaÊÁó“ƒK”o q)£€ÿ",Œ@Pñàõ—.rÂUŠe¥qXÒeäI'‘9¶~«Hà‡ç7‡ðˆõ’ÇJü$5·OÔæp@TŒçx¹‚+o$}Ò‡Ea!ô‡|@ú`0C+¯(ê2:Â*XV0Òã1Ó”˜Ji¯r(ú@Q ¨aØfà–v#ç}Ÿ¶2íXõ8jQ~²ø9Cÿá~öVcÿ€‡­õS†CGͳ3 µs°â&yR!7ÐT…C… ¸R8•yÒ€'c+RM#£*´ã.ñÆ •u"'HQ¸1‚Z-ê‘)Xar7~1©¨„&ìUBðèrf¢†0G {•ƒó·/póFµùFKS•ù`Hx™!¼`…ÿ ŽçˆFvM ‚¤Tôð(Œt4`èl”7@)—’9Ú&`v —sI—%¦jÚRbäǹÉðÁNÿ0C‡G`<;ˆ8ôpœM†²/‰é¢$ù3Lâ2FƒhJ•T˜‰I¦YL´£KÿÐ- T-À™Z©-€‘ÑY'M7$äÑe–"åXßu7Fây³yºy~yy›ïöv$k„6úèzÅ%;IKD{ F,‚’$çé6°Zˆò3žÐåªB†ªgê‰/£™ô”€)y‘y™ÕE€9Ì2r}*%ÅúaèvJbd“–A† KƒXKï_óóŒ @`Ή<Ûj@Á¹6Ð%]6Uh3š´§@MÅTM…®g³žãù:4›OyÿåªM 9]- 'pž· 'ù Šä‘%]‡†é±õ’ kdR5+¦^…j“oÑ›Ιƒºµ{óƒB…0˜ {6t4¦t$Y{F³òÀòôDlÛ>Z i@c(èú³9¨6¯“³|[e癳-°³ìÓ•ŠÍZ)5Ÿt£ ç™øyÓ´²Èô(µrˆ“Š7ðå ]|Ô“ý$X›8±ƒì“W¼;øhñã³Ñe²Ôi92–Õ#'W¦:Û³?û³çÙç9À[Säy6W6§I#×׫©ÔEÜ6yYg‹*¹»i—Èê°1( pÀÇ£6KÿúÓJ˜ö†/+”Q…¤h]øT³=V³yË6ÐeeÉcT·¢úPhA`õ»É‰®Éƒ®èú»’•oÕ£4äcÁ™Òq!Gf'ç§`¤€r8™nó¸r>!€<ßʶ±ó¨`ÀvðhTÊœÌ#a5UKKÐSñ¹ÜšƒÆ«ª!P'# ¯" ˆP'|«-@!PÄEüQ€ÄÖTÄÖ»-@]–4áA)$TŠç¡:Jšä|ÄZçV~0gJ£7ѱ¹Þ ?‰‡ºò0{Ív̭Е­KÃw'²ë¹H¶R'Ô׉˜ELÈ9¬#û«.ÿP’‰\'" ´V=ô½ú!–\Jaf¬9z²?~ ÌeD†µ'áÁº4óà³·ÕÆF0?,>ã`+RŠ@ù¤Ç?¶g¡6Pô>Ř9ÈÒƒ˜öpÈ—‰=,ÈËÜȈ$a´cš l~Á–'ñÀ \LûÅÓò‡qÁÎ Á†ËªÁåõdø-Áb à[Â=)GÇÁÒ8%,¶l·i]‚6Ãw÷—¸å¾§:hã<‚B')£2*Œ,+ÀÐ+°EðÐÍ,=×É@J¢¯U´w†…Ò;½œü;¿Ã4U¹Ò5I¤£&h¥¾¹#„³¶ª+¾ÿkr/†s¶< ?kCa­»5 E?KGD|šÿÄ9“ÄùuR’­ +€   –Ñ=ìxÏ|€I“I @Åà&ŸèxÅ!n,Λ6Ö Ñ’VSK¹¢wR̽ޫ6JÊÆóSǼHÎ)”ñ>kKaºìÓ­6O,{ˆ™Ô9–q²¿ÿðÐ>@ –íÿ€™}r MŽ,(Ó3úº¼åhŠ¿úU¥¸y`‹FozÂÅ#@ÛLj1¦EZ˜»?@ƒĶGÀµ>ÉOmÂkt€êÛÓì#9¨Ïz+Ã{\eÒõÄèjTs¢Ð‘È=üÐüÿz Þ—`ÙüJÕX­·ë2Q&Öyj©MÌ£Úãɶ­ÖhÛ±Íŧ€ Ë¢EJŠ*±,pÒµ¤\Ëk,°/ ( <V®1$œ|”WGE5K³¼»Á{Ä@C'µ;Ь¿C³™íèq \!Þ“B WÍ "àñ€Šap‚(éa¿z£ý¹ —QstŸ# ¹ßÌh7‰+žœ& ënçv$ ­`×lë>­µ{l|ø„8ŠÓ©†9¶6|Xy%]îCÃj+²Æëp@“#øÙºz™ø;4Q—Ù” âaç—°â­ÙE°Ì›˜œW†e#p%œ†wQ°Zÿ¬áò š£+Ñ9‘ XÅ8éö0éL£þ³.¨V B,Çé9Ù›”z×µ´µ»7­Ÿ[SÈ38Ú:á#‹æÑjØeîÜ"ë³íŠ}Î ¹’ª!ð‰·±^fœRbñãÜÜ%·‰Áí.t(*À“ ‹Jl6# Ì<Ï{½E­Z~[’5Hº:džCT†×õ£Ïòk¼O¬®ÎóÔƒìÃ~ÎÌ&nâ˜Ý¯ q "Æç¿Î!p¦XöÕ¼^·}Q‚RS®®tkáJŜ̹ˆøñ+øG~æWj-öý%@aƳµóÿ;xý­—šæ*²0¤_ÐuáÎ]6ì³K4ÀDüÔø«Ì¿þ),ÿЪprâ=ì ‘âzîâÿ  (!ÀHÉ£4×#íbf~›Á2 ‚dŠÓêX¹ö/‹ãBæöµÜw,xzh·Àð'ï:äz45ë6Œ0ï!k<ô>òäÓÎmÃÆ»ƒ·ŠÝ€\’ ìÑô&^ÕÞþ’ ÿù€ ÙÅN0šôP4ºW|yAy1RÂÍ&í¿¡8´‡¤F¹s»¾ êJë*”i÷ìFv*‚±/r×ÎízX^wù¸ê%;yëÓŽßøt8TjT@ÿ£«ÀéÃ&~ùWŠ>0ÕOŸÙÿçŸOÖôùÃnç˜-.P4£ùì­¸ÇÑç˜J þýcàaÄ@„ .dØÐáC†óbH<1¯bE ó,Ψ±"D‡1N(Ä7 ßÀQÿLŽJ™!¾7V˜'OÞ¿÷È!Àç?,FÎcD”#NY,¹ÉBÞÒ¤O—úO#½yôB|ø/Ÿ>DÿDˆ`¸`…YU ^ý[ ÊÇ@ —„Ìý'¡Ürõþ(!¯|öè gQ|‰âhw ã…~2HØäeÌ™j@81áÈ‘˜—„Æ\_-–+M¿4ùïÇ™ˆ>ÔDªsçÿ? O­-ú¯·Å¦#ŸÊ~bɬŒBÐû—¯«DaE ZA6ኪئý÷ö¥¼qó Ñë¸î¥ðäÁ_ò^Ä…` …G,Ø€ÏîÉøêß/™mƒ4p@‡Žâˆ4‘$¬*>R©¤ü ÔÏ¥„`£ º N¸ICv"¨Jàˆä j ãþÑ턤 -„`è}j+, °£@¡Bk·|è¼ðêjÌÈ»»D¼îØóÁƒ4ˆïD¿“Ì#Г:ÁÃ'„NˆÁE«@jq43Ρ‘ Dµ)Ķè*`Ä)á>Ì¡CDôÌ7„HL“EÒœ:ÿŽ8ª: ÁÐ>(¬¢«nÇVXA&µÃîîºKhÉóÊCˆ[¯ä׆@VˆK/ üûT˜(†Œ¬2ó@‹jü3öç-Ú÷kf %„~h¥ÛEçð`DK#…" ‹h¦h P¥t§»¯)$-iyE«|`0¸mB@Û^š§ÿ*ö0@ƒù=nà û(æV)ôæÌ㟿}/Xñø í¡+4¬sQú23и^º™œ,oýÃ<:D€§¥A ‹pb,!FMEM!“Fh)êãBþz ×|—!MÐGk¹à]4èÆ¸ˆG<qžø1˜%Ìczø¨UbؼíÊ>Õ’ÌDVšl}êÖâr,–1¤E“¤—å.÷±Í±f5B„á¡!ØàGx Ž0Ê{p±#—³ÈT@TE…Ðc‘ªÔ@.”2„S ÑÔ§Ò‚VQÂ;EŠ#^ÈÓA‡ì;ì#Å€>V«1øÁ•c)ÍÿÅ0@‰$Páø±øŒo$Ģȱ.âgÍl^VtDZ’ Xh%œ‡PX${ÜùˆÑR‰”Š Q»bš”3Ë0—™Ê¥¿Ê6²u‡‚¢Â z¢¼‚5Ï+XâHì1+»]óH‘ÌȸyÒœÉ3 RH‚†bI¥¸'lŸjvÖ;¹¦[†ø¦Êpr“~þéا*;£ ‹XŽ#ë’TBr—#22Tª9ú×ï2eàµEHß&ñHeŒZ!ˆªŠ‚pI«JõÉp1HÎ!Ä/ü‰!˜NšË|³¥öPW_בi´X‹\; ¤Iúeî$?à–! ·+ÿ1šŠ ÒÃñid¥ÔZ×£¸’P}Ø’:ÿ€ªTÿUÕll ©àZ "JØ/ ˜'P€´ÎCõÉ›4õv*í)„2$»kf†; ä†ËU—=¡¸Œ¤¬LФB`Ú›ÕL±ö»Ð>À¸œìä'°lTxÔA”(UÎ@À’ÚÒòÎŒ“Ø2*D «Ä»K1Vž¶-S˜# "x‹-J!õ)$B RÜ.!ᣇJ#š€:²!(HVC’"îÌ5  @²ö]üÃ6ÿÈÀ(Z&Ò¨`©$hŠKHË|ì.—Á”-¢U„¨âjÙïw(áß‘–5UÉÿT•óø‘z|à´âÏÇö#É,À¶ ñ€]!üÀ!!öPûº™ô ˇê{H‡­Œ3’¬Äaœ¬@OGƒ%¡Cú%)Uty år†J*ˆ>²^^–Ñ¡ýBí¿bø;×ÂS¬£j˜òþ ±¸ŠôàÇZSø˜—$ø%lýÏp½ô/y2&ýR’‹ðµ„1Ì„ÇiN‘iL8ýÇÍ"g|ÀƱ†s®‚˜2TÊžòC*Jk…×5@¤È«EöZ`-¿¶£CÐG  ò1ØßÆ0ŒH–žtÚ0*¸}à,ËR•bÿðEËñžª!8~ÜðeV×ᘳoiE!œQÜÿÊ r]ÌÝ̦òµK"p!Çš!yæß?þô!@ MÍNjä"•.ÒÒp„/i3_û.ä-CÞ/H ð0I¬±%ÕÁvžþ¢g+ ‘•è‚9ì9$¸1i—êmo†lS¯¾!­ïÎèP#æ< Âez™’PHš¯én¤’Å‘%è¤'“ýÐyÃuö  G^ñ;Фòaˆ÷ò‹Ö19¦zì·îhu”xE`®ŒŽµ.”­c´4[¶ècµêmÐ;æÛ½ñ%!† îT'$ÖÒ‚­‹%ãò¼‘1„lfú±Þ [½!hX “Š÷Ï&ˆ bRõbË–ó¸aÖBÿ›»ÜY*G\K9C´¼W¸Ö;£Ã`«¶²2¯˜|i%€4—Þ²òûÁLæ/ߎÙéNŸ5Ç£>À%òô­™Ó@¸qç&$ì·!{npµRNeQkßDæž»-Òêºû±WXë« "9æ»ã ô0”À dJÐ9ºH!!h ‘z7>r7ñ¾ï» F ¾r6uá ò± ,(`É| ÷» ˆ8FH–Ú €Éê'@Ky86šú8q©€÷Bˆé¸Þ¡F›¯“C6z‹¶Ð¯—cÀ²ù;#ã/#c@˜k¸)‚ëÃ>íQùÊB$ÁÐ7ÿv‘“1u‘ˆ”Q3“Á© ‘ÁŪÁyÒ·‰—Ȉ›p¥Ïàf㰩኷SÁ$£^Ò³è¥4ê‘­:À½»BˆéDOä;˜« VQ€›Ñð9j’Á$# 8‰Ù²ø’0ZdC† 3?3iY—2›~cò1'j±®Ì@ ž1Ckq˜‡3 0œïr¦rÁ ›œ÷¡Š×!DEL#l9UXó ȇåh ÌŒ‚(Èǯ ,‰¼4,Kˆ°­GCM]C{+œ2ËEõq®Âè+`<б–\“ȇA_{ <éÃðyËãÄ}0d´ŒÓ"fqŸ!2BJ¹„ Îÿ›Îë\ެHªü‡&¸LíÜÌîḺH-ô¦Õ*‚SŒ‚ÁˆÑÀL}̱ïD@Z±›ì9Ñ¿(:ƒð€ÕJ\¬€„\ˆÂhÆ÷ìˆÙTѺýØ™mñÍ hÈ”J+g‰Ë… /ÿ´°³ ØqŠsiiªÐ¢¯é‹¡N}` yh?myh&hyh‚{@ÔTBÔpOî¬Ñš´¯–C­F RÌô Ћ"`‹#­ þ0UÊ?­V@ýÓÔ =T-T÷ˆ¯ÀìàQöÜ4ÅÑÇõÔT›"ð%90ÅPÒè#¶ú@¢{4TCÍﳂ諜‰†Ð· »@A›µF½rj/]ˆÜÌ$…K hÿD0JñÕ·ÒéŸTrà[6RJ¥{ÀÆ€‘;Mé št¯\XŽÍœÝŠÍ´± ÷ÜYG-FA£^¢ÌÀḚ̀ÃlŽL…›Ý»OÍ’3&Õ’`‹‘9[Œ !)ý²ªUˆíÊV ò³ zC¬Èˆ—¢bFà@•èÍÜU%â«´2Ž|úyÀNìl»å'BÄ*¢Ùf]Ù‹ß[Y ÀÎÍäËæ0Ì(èŠÍ,!w ÒûÖ(È…ßË´OУT¢MÒ|pÈÔMuW¾ „#ÝO«W§%5‚¬W}µÅ¬MM¤ë€S ±õ·—Û 8ÿba™ø«C³:Ì‘3¸ø¼XåÂÁã˜ÆFÝ ÁΚȧSª{‘ÂÝÞ À<ÝÞÂí  ׯðŠ˜Ïò=Ê“Üõ‘æ-_J-±¸ÓíRÈTÊÔÔólZa˜yå¼A°“È2Û2)0P¬ÄÊËX¹ÒVmœ`|‹PÕ‰ëÚöƒXîºØ>”5ã°[B¼Ô÷:W›ðPƒŠ¤‰²«¡NÇÂåS…*\ò5Lçô ðµÌåXßöí6JO}Œ Õ€îÄß±ÐTTT0¼ Z‘W§”<3´&Ù·/±<(ý‡­ý2Ø&ø·¯¼_¤±×\%ðZ¡CÞãÅœmY^ÿ 1S 6†7½Tj -êÔ’¬Š­xá"‹—ߗͱÛ_Ï5L"mŽˆY¡\íˆ(P)<@ÈæXÌìÎѵÉLÕ‡"ØäðÕí#?:RcÝ…hJO8®Zð»â/³…0û‡¥{ˆ7Œ‘ø#³¾â8Ðë!Ìr‘a48ú™P͡ЇãCI!3iy“›à'ȧJα€O›86-" •-QÅca™T<ÃM¨í5_óµÙÇÝŠùôÜÍü· ìWâ¦êÐB•‡ÐõÎMÍÔ¯°G!¡#m·¶ê¨õ _ù›’QUM¤ƒŒeˆ¸¡ƒ=Á¬°8¤CŠ KÅYÁÿó)M:=ߢ³ øà4†!”‘ýA¥Ù¢-¡lŽD¤YI‹À¬”¼‘gEçßrÖ ½EÌQ_ û·F¾Sìˆ9JÀŽ|TC ÒÌ”ÜÐG± Å$Öç»á ¸"5¨õ›xSM‚†åË`ŽY>“¦;Á[Ë£˜3A[°¾1•8ëÕP¸üfŒ%6¾R~ã{àXæ{ÀÌãè(´Èyqi¿Ü\lVˆÐʱ)Z­ÀYœ>ÅS„mÅÌ(kdðõ»êÎÝ´wΧC%Ô&R8OXȘúèÀØå>¨Þ¶‡àWVV5UÖŒ®ÖêY{à‚ÎP3rc6;Þ´´“ÿ”°Ÿª³Àh: 8cX‚ ýºª»fÙ œmÑôifu¯¹ë\ì`áí½ÓŸ‰šµì|\œþõ…ÏlÍ 1ì'¬ vî\}ˆ¢¾ëAåVÌÔd{ mÒN¡BJ ÿÀ2þØ-û•ˆ.èD·x@è\œåÃ9ÐÚ.?Âj¤•‰®9üZ8›På¥AŽ…ëéABÌ ¥ŒçÀY]ª­Xa²¨ê”ßiiîNgé&q³®YK•‡.ÚîÄÑZ@aÂ}K-rK¥‡|èTÊX}^R§UÒWä©•ŒÜý¬ý¾*‡må*¡ݼð¬³U³bAˆM{™…ˤÿ³nCp¬o Œ}sP7Nn‘U:]ßõ抆æp;eé_ˆlW› Aµ mõVCT$äó%Ò̽ À›HÖŠšÝÌ(@ÅNíŽ$Þ àoÉË’¾ÙO©ö}E¾¼“ÂØ<[>œ„u6‰Þ¸Õ±è„ËÍú¡\_ó:óð¨K–ªk:wîMKÙî,f›mè Ԣ̅€o™žÙB7ÙÆ'C¸óÜĬ%ν ¼`g¸aO=ÊqFÝ6Z°¾%eˆu¡Øð™,¯R«v 'Ø}cŽƒ­UˆÆXU 3Œ'ˆ«€°à‡|(3å †^„hîk—(sŽ­”ÿõÎt=]ÆöŠr.tüóVõ>EÂÔ5²&É4J£´ä#v‹V¹„%߀°‚„·Nm¨NÇhí/¿ŒXÛ¼ƒM±å¸XµèÁ Ðû7Ï:9iƬÙõ™°åÐóº¾ësvOC× "eD®èÓÐ’$Äæ®iˆŒ¯iø R’ÞÌð¤Žg ­;íxeaòó¼Ç"Ö ržKH t—×ÞºÃÃצ\-yWµÀ9|Í( …ær.?ØW_Á÷ÔÒa©mÓÀàLJ €_s¬nWk:Ç™k@[æs†Q|êlé ‹‘çXáÕÓ˜îãëàÜNeìÇ=ÊJ§ÑÄì¥ÿZ¢I—O·°î° îhÇ6b@¬#Oæôü¼¿ y^ íð>ÿ²×&†,3a,Û–¢rŠ•9$Ûò«03Î_xæÅê|+Ó¨ ^cà'Q%J¾ DUtášSìŠotY=ˆúþý±‚àAE 2áP_¾|!>D‰QÆ,((Ñ?Dÿ\áƒÒ% —NR¢ôoÃ?”Z^º$Äæ¥ >|,˜ ¾—ø„%J0¨‚7tTêôi¼§R§R­:uA~ÿ´Zý§B©½*èý³÷žY²cÇÆÐ0¬×·mÿÍe«Á)¾QyÿÅ÷£Õ Cˆ#â÷Ál{*æÿ)]rÿ{‘[lrOez!‚D¤OB¾ú@2ôHZ ¥©WdXÄ¡õ}t¸âÕÜÿr#¤Pôê>þ]réòÒKäJ-<µIAÌžCñmú’oõŸ0¥zZ½ª‰®âÇ?í@0¿äŸ*†ëµl z*âÓwOÐ-=ÆNUÔRZ+/€ÿXp‚ýSÁVe%æÕ wýãd‘ÝÓD òLFÙ?ÐÆšg dàSž•ækO±‚*%¡¨QŠ; çTS%$Rk ·€Ê©tÄÝDÐ% ôDIvÖm@ŽÖ%…s×ÔTá­7eU00‚# ÷zäÅ`Yfåÿ”|i)5Ï\dµ5ÏWÑ_G¢Ôœ~ýP`Hpu =Š5gdp@À=÷TØ„e™‘¥ÏAˆtÚ?„4ÚS"ÐÒT ÙHªðäâp-‰Ê©G"PItr9!·£Èý«p ø°Áu_BÀTuÖAž„Õ?#˜àÁ?ÄÃ,•Ñ–‡,•b~¥Ö{e.6A‹©E[NÕç”^|õ'à v`†e™eÖ ÷i°„ aÖDdÿ`¦Yˆ´–F4U§¡ŠA¥H*/*%*Ä.i”j§æ)M.+²:çO”ôÔ+u×ýD²“Kíæ–ÈFeÿ‚”ÒFË€yYÅSAmVÕ¦Î*ˆ)¦|A‹Å&›n¹õÕ<øúÏœõWç??üeˆäs˜=ˆ©AƒÉ!ʃï?††¨z¦¡”NRm³6Ò¦ÂQrÒp1¥´7s¼HH#Ù­\ޝþ#DR=*w‰'D.@ PJ û+AIÁ¨“R dÉ,çÏÊ­-ÿ|s´p¡%_YnŽ–|Œ%ßY°?TÓ5mÁÔƒñƒ`>Z»û×Àé˜ppoeeÓ£Y>­)õÙÀ˜ tZ¥J±vâB#udœR:ŽÜ#M,¾õƒo°8N= £T·º„ëPØ^ÉôWuC³ÈRûÿ¹´4C%&—Æã3šL:ûcT€Ÿûii£8×? µÀPí@ùàÒa”µ÷Èã1ÐW (c!¥œ- £áŒ@Ú&©é¦…RIÍÁÊ×0RiLV‡Ë‰H¢6Õ4,TÈ™‰ÞPbéœÄÈP~,“UÎ~/ÒT õ9+Ç 0Ö?:`ju‰1ËZ܃´ùÍ+²›ÝìpG T û¢µ–p‚¯@胗 !…”B– í`à E$"@Zª|‚Û”^ñW´„ ÌQ §4â‚LÒz ùƈ³’©‚‘B"Œšr¤éhg‰%“ÊÈŽEhEåsð_æ¬bEÑ9ÿ=öXP«5¦/¾ hÀc}bÇ:91-N‘Z¨ÖÆ䣾KŒ ¤®=†Æ3fBø”1£9 Á*Ћ^ú³—¨ÝI0†`× ó³Ä+.'ðà?U¨ž–ðW+j9ÛB£:e´+I2Ã}¾(ojØC)ÏK¥ +À Ãbã8äúœá‹ 2"YÀ:Áò•ü¨b¬»ªrYáqèyœ‰NTt¶˜¥Ê”¢Qªð#*bâë”ÀÈžnvit—YÊ¥Þ¾DÉ´Zóa /^_¹¬ >H€|íK3Ü ÚF·Ò)F…›U²ÁísŸ9Q9sñ_À°RÉžIjR|^04¼õmƒk%ÜŽXÀ ò3¥ÿý„Õ“º®R)ÎÊ[Õ¶Ò•;Ná¨R:€•-ÑXf¾ôY`ŸØm 9/ˆÝˤFAC´ñnTO—ìÒ69†ÅÛi¡(´ôÑÀ›ØÂ—¦)Ö:RŒcݘµ>)%gÒ‹¾ µßüî´oá²D.NÓØâÀ¦JÉRf››pùÀÙN‘þ#a&A¦ïÃßeyQp y‘šl±¸Áªr'ï+p?§ºÐJwÎ ¢s‚äR®et`ÔvˆvUbhù̸¸‰ðlËÒH]€,º`Ý`Í E×ÕW×PV¡dAO\ÆHÀi€™•LŸ@ä‚´7DõÜ– þ— ©VjDeh@ h€â/„„ Ç‘x›vÄɯÿ¥AIË<Ë¢Á›¹™Ï)Ź!‹é±˜¤UE^ñ_Ò…a œ|E[Ö›8ˆRèÌÔI-XÝ?œš2uïôÉ€|EÓ4•Å tÂé”5é×Ù̓ñ‘†|YÄ9ª$•U žÈEÁò„d[ODžÒŒ s1KÁXêµ³X‰é­Œ“ÌÒèGzüâ?0†Ù}”Q|E€@ÕE0™¥0.H׬żßc$ÜØýÃéÐChœV9’†¿”VW^òÑ AœÝ–qAÌÆQ„ òQöåã­'*Åk@¢6ib>¸@DÁ+ù€äŠåH^R ÚRtzyXá£1ÚDY”ÐUEz„¡ÌÀ…b”0y­Å—P]íÓ_ †“†î9ÖOÒôI4eãØí—M–ÝM–8v™>TÀQõ¤=ŸT ÄÆ17ò%øuÿßÑcöíTŠ€š=Å>ñúá?Ê”|‰A–•ÊW¯Ø\Y:Åæd^WÄÏí[*”.>eidG^Ë{ðŒë̇=úU€JR@“i™…«Å]ð^¬ d Š•eVñ蔀<ÐÃ!^PgœcfREhH˜D¸‰TpÜiÉTEä í–R4 b>ÅÆ@´µí– |…lžbqåPÇüGˆ[C½¢³4ËæE ÏuI—Däs v‰N¥mšFÂÑr®!Ñì!÷•ËJñÊ $"¬$‚\K’á] P4UYfEÈ*dŠgM¦>Âiý$•o`fÇõ™=7mÿ’þEl JXjüª•ªB/Á/¸“æƒâm/=@ÁÆ\Y¤° ‰T¬ÕŽ9KÎqŽt½ DÁ•‹eÑ+e‘‡.Žph³dÅqþ"=0‚¼‰ÅÐ̇Æ@¡þ•Óp[Ô K`СÀØÃÌ—=p™µ$bãcÜè~ÝCñ”§N‰ãDì${Â" i!YÅÕlœ=å6=©gßžÍ#VºÀ/P®Ä­n©>@"V:Á@¸@<äZ(´ŸqáˆÁßå°£-Ú?ìŸSëfhõb‡¶[²8”\~N]¶ž§1Æ·ÄÇWu°ÔKD@¬d»°Gf v² bv§d ÿŠRXÙ…£yÎC—õÎÚ}j(Uºçɹ‰=–=Ü]iì=vŸŸh™¹@.Ll´)ÞùE/xkŠ)™fäå5B’Ëðƒ›š€VT(ÆØœþfy˜G]å"*ÅþÈÌÍWRþ|èQ ¦ÒÛìÓ0G`H@—eÈ¿ZиÀI˜Ïd£JxB¡œg…†LQm!ÕxkÙœ€­iÆØŽ­Êí$N¢ÃNìÄ*Å$FàAì?ú95–iO$艔TËŒuI×S„Ç…îUâé†ráF}h¼™Å #¼ ZÄÀëEå^D¹ô…íѶÿ X¼ëãÂ^[ð^ Ð+Atª dŠ`D„¤)Ü i´€­;†îºcU ¡H˜Ú*^ïJ˜oÍ-S½FLSȦü(¨¡-…¡õM¨æœ @לªå,>³0@è¸%w|ÇDòÏãJÐðÞ¶è‡ët ›Ø¯Ø^R€TÀÐáS\à»f cˆ…ÏÔèä‹NI† Ø¤½ÊÃ[Ä*©RpTUU¼ÙòTÈfIf„¢6QFµAîb0oÛ–Y§¼SýC˜‚‹= B ({% ý wü-Ëx^-Å©T¤^DV”¶JGAÇEÔ–xÉŒ  ·8gÁ=2KÿË_˜“µËÍnS_YL“}ù ×,c(…dÜhyb™ØN„Àø¨Ä ¬UÌÙìQ…àn„P?ân?^a.ü»à„ýÝÒCŒ€Çâ °(褽ŸŠáŠn*‹›žÌH×oª%-’ÎΔX¤éÕŒt‚¼¨3!ݪIcbH#ÀQ*}™/0ÂGŠ*9ãgˆ=êD€!e]ÿ^ñ3¦Žj±/í žô)U@„D[. ܲ­„±£ï®£2+'²c3U˜¯"Àä—¦"Bå&F)Ëy¼©·áJ ”E¨D‚/q¢³þø©^€V¨‡áRÅ-ÿ@'ïžÎ&bX…bi.ºí»¾K0—Ü!Ö´Å Tã¼aqÞkꆪ¢ED U®aŠ/SR9M´ÅuجöîÙóïj/ìj÷1Lnkz)ìíq0Å0/{­©R0‰v­•æ­Ò²Ð˜”Ì)^™ó†NÑýCè8EÍÔb‚`äV|¡SÐ%ïΤÎw¥N9S…Å1 OŒ *þž…ãv ¸TVÁÁ C;E½rêðµM ÈUÁÞžy4Upâ­&³®öÂ3/Dz¯W³­\³Y•ßKýKþ)ËËDkC^¨ZZá*Q‘‡â"]ñéèXþH‘V GThÿEw}vt5dWLµT q©-u®¤Y0Â@@äFn *Î~׈µ ̇1üoCïèŽj–<œÀ[øÝóü‘ôtEª¢Æ[ܦí¶Ûª­ÊïTÎíµ¡J˜~é_[3óÚZEK–|³ ¸à£)òZ>Å÷u¢u!UìV@‹Ž-‹†JÔgwgkZ_Â!jW€ç2Bä¦\Àö—´š܃HY0ô0gVemôX\WÏiÑÖ™aÄsžÊÁàïÊñ?Œ´^ÛHjð‚>´=@ÁJ‹G@žU;’4hr¥xéߌÁ0cÓ8—HkFåøa;…-tÀPyH‰ ˜ÞÏm^ÍŒÿ€–ă’{”hW…9R`¸Qý¶òqd˜Dî[Pª«ÑCBø©@në6Al*ŽîÔoŸÀë†ÆÀÒS ¬‡TÅO[°3ðo†—ôw"Aˆ¸Ý*ìñÃŒÕ?lw‹Ia«÷±ðð7{áy,rC~o¢a«TŒ¯[Ehþ9|÷…&º²(6¼õE mcik ª}¼¶·øŒ{Åǚǚctà'¸Rð|]DôœÖ M´>8¸×*[9%7À¬mïò. Nì­šôÜŠ@º@L“‰Ã^<¼\Š#ë¡!×ü©iUÀiNC ¹9ö,Âp÷šž.ÞðT˜;¤™·xt@,^šæ±û¦÷ÿii÷%“D"xî¤NY”ú»ñ<7vêÑøCnÿƒeœ5­p¿n¬:âSH ®WŠˆÄE Õ?ì–1ƒ´„í•ÊYÆÛ !ðЃÜ€ ì·eÇX E´„·hÓxuÀ+IvzwÙÂWI5⺥OŽóÛÕ‚ÑN9G¾öl»ÉéŠ-«IB<ðñXFÂŽÖzƒ´ÚD«Ð@<PÁf¥¤†ˆÄÓ°÷Æwün¡æBÀ/Œð4µA´Zèà œpGÀ4RÌôKhû¶í„&KD n´Ê°S¤ÞýøEVÅuyBè\w…yhÑ䋇>UC¬ÿk¾tlG¶r+#PB H…5Aüo×Ѓ14AÕó”Uü“æ:F°µ@¤¹T ˜RøËöÚl@%ããé…AI¡—†F»=ˆÀ |Š”å0GX’eU$yÎñÃ[¹Àþ©e–Gø’äïTøÀˆÑ¿yÿ"WŒÌȽy' j˜gÏÞ¿-*<¡”ÞBˆÿ&Ε'ožÆ|(IŽ497î–úf"rÉrfKD+þ‰0~\ÄŠäÉ…6/"‚ßÑÆ’.ý§!„‡ nPÝpÕâ B¾Šÿ·u+Ûx#КhëžîÛkÿvðÔ×oþžèòßë×À P®Ã°Âç‡V ©À± ìa„ M´@c¤ ƒæÑ@#&[èƒLSê„–Pˆ5ŠæZ"6ŽHª­£Šn «7Þx+ηàþ!Nÿ„Š^YÈTYÀ ‚ú©¸xèi‚:c”RC{<ˆª»ØÀ‚­°ºŠKòº뇊úº!-´âáç^Lp¾¹Ü‚/,üÓÀ½ò⯊£30=Ì„=+úá $`ÐAÈ"¼ìCÌÚŒ³?khÃ58H¡&83F ˆjM,[ˆ-ŽR ë$“*ë&ßx« Ö°|²H(¡ÄTaÀ£Z`² 8mc |´“Ê»¯´ /<­*B­¾Fð`„±2>8ÃZ«Í°ÃO:(¯ýüPOÀB7¬~XÌ1Çe”³>£ÒH%Ó †ÔN‹ôDœ,Ș€Y;˜ÿ".‚­E’ø &’P­‘âŠ|ûçb‹‚\au}å'!‹ÈGM¤N‡ì) ªº›Ê*f¹:/«¯Â‹¶,lß3KçlÛ,Înb`\:·ò$=‹î$¯<õšÓ.½Ô«–°"0ÄPÇbd̸Žtž®3 ;ß}7<›`ƒNдº²ˆ"Ãz­…K}QFœ0¶x¥âºøâšv$΢„Òø¹%—hRX¦þq‚Ÿ)‘íø»ÁÊÒÙ-Ÿ@L›V>ú|®[ùH7«ÏÀÀ w®=Ëez¿¢å"ð?±åª¬þQÁã:ÂO`ÁÞybá2Íô½Ô3‹H{Û˜Ó.5øÿãfK{5ò]b½e²ã˜pt©ÇÀwH•{$Ü¢‘×^ÜÉé4°§ {òa@*Ž)ÇR ô°jVKƒÚ¸ðƒ-µ¬É.@KY†Æ¨±N,åzšë*ò@ºÐ.]DÌ?,pƒ9æö0Þ¢†ÇÉt 3 [½Â²!ƒ„(z"r›ˆ"Š,T‘Û?²7l¤#µ_ø‘1Œ‘&~k q~!üã‰EÒáDà„ê5))ÿ¨ŸF Â€¨LåJß៳¸ô¬þQ #˜é„f¸ÀIg„ æô:ÙÝ¥O”DzÆÿ½Ë†ð]¹̓ò(½ ™°Å ^/ÿÈ¥,¢/„,$!ŸR²C± äÛãˆI€Ã#¶$‰bq¢ßzô"ìhdÓcóZ '¨ ñø¢þbÝݬfº‹ÓЪ%¼ñ-Éì™ELWÀȉhûYí´§§‘Ë.‚̺ܘÜN U«Ê Ñ;öë3\KdQ˜å…H_Îû× 8õÂz}Š"'âäÁ°·„ÒãnxX+&–Þˆ€&êÈ/l²“ö‰ 8\‚ü”²{8Áú þ¬tžïôÏ+΢Ù?Â$©pG]ÝâÖ›”©L(\«ua±`¸¬¹4?Ñe›K€à¤»P wŒ@Þdµ™×” lzÿf>ÏÎÈEŸ9¨6©¢„a/{¡”Ílôñ‘R–Op{û›Ej‘˜ÐÄù0QDŒ?†h„@„Tn ¿ XÅrhË^Ó“4Àx€¶ƒ©í €­8í«›&ŸšFÇ<‹R»£7c‚¬ñ®ˆ¤ïbãIæëdd×|'™ÎBJªð¼ -¢N*Œ5(²aŠäÒ„¬†í‡¾küöïõ &OÔG.Œ‚&To– áÐKí'‚Œ ŒX‚Öÿž¥•­”ôJ©šÂ—xÄÅMn‘KV7Ó¨aSOv4ï_þ¤MÉ (Pðé@YrGÒ”ówŒè,$]{yo‘ŸyÌR]ÿ(ט¦4jË$‚'Â~Ê–¶PÍ^ÝèÐQæ$‰úÂJ6ü‘$æ# &Iœ'¤ù(@ (ÂÖ\5¡ÑèT\&1r°fafÿ~°•çþãk$Ð’I¹'°æ²Èbýò:8ÍœpxÃCälY ¶”r2œ9FÔü6ª !'JÈ= 0Ù#û ‹Š6Y¼ ‡ )ñ*)»šá:Äx @ý(ä# %›ür[r‘c>Á ¬´€,A ˜#µˆà‰ W„»y"[^jð²…¼{ÁO”íbÓ'Ó:]{™27ŸÜGÿ_så\–׃&³˜Ðµ6$Þ<&ðDUJDÉÞEäÊ5ãή¶´¯g੪¨^±hBŽ:b±££`(4z N ‡B€QI·x`ÊuІCtGŒ7ËÒ^Ŧ+y¢c‹M5‘ëžx@¡¨cË}›ÛZQT8"`®nð2«|ô<[â_E²Æ„szZìiÓZ€¦À¶üâpg‹¶EÇü ÿ¦Ž¥æºôYÁ¸GÈùÁO9 ‘mx¯ ­ÿ[–S†lŠyXXàÏÖ\2!6¼yΩ*«¶¦zVÕüklË¢—ŠÜù@ý?È}uçµ  H‰ë?¦NûÅUz’²q.«u%«] 7Û±à騱ÀLëíaKḖæ;3°}ÁK_˜|Á;]s²rü&ßuüŸ6h©ûåL"CkÑ:›Ê{aÌ1‚o_þ’kþ68Û‡ÌvŸÕã᧦ty¸Ím*Lp 4ƒ^¬D(ì:ÔM ‚‹žœd-$ô‡ÈI*¾.ÔúgफÇC2ž*ó,/µªíRêô¢ uî!øÄü¯ nȆæALÛîIÀ—ÂPÅÚ@"ž€Na;€s ÅŒÎ#<ø§c¨âUÊ»°‘ù®%&ÿ±/(Nš&®ïn­±\0ƒœ‰@ôH@x’;NâÜe1J „üëØþË¿þk `¨–2#iÿÚOç8! ¢ pÈÁâ ïlªþ ôCðoç`ƒî “h¯ âq@à  èA"è¤ë^ì,˜6ðhèHÐ%­&u¦°P/ž¦¼&Hc'ï꽦 ­,¾l!¾~2ð²ÂZåÉðVè)‹ç5º¦ÑôQ©p…Þ ¥j"šP”bÿÓþš0‡R‹N¾òÿ""Dð 5+2ÆÂ°%  Í’N ë¦â®èR,¶bàH꤂,ÈØƒ+"[bÒùÿNÔvË™ôšS¦ªIûô¨1ƒr].Ë _â)æ.‰ªÀ\Çu]™ÎQÊæ Ýïò8¤"êµ79aþáõƒ:"Jòátó^Cµ!38›â`!Âë¢ë:­Cçbì’Æ?¨qj¼«%¿ë»â.V.F>¼1šðc0õN,î('qj/>.±àk àñÿ,„kg#š´"Ö3‰^%IÍP„“2Â!bÎRd"ìÆþøäÅİæÖÀKÙ Ö@P ÖB­ösóƒÓ Z8gXofJª£DðLܤոâ¶Ñ=Fkçÿc¦D¶i¢Õ[J6,ìã°Ì[ ÕÄPNå1ü6%*`ô‘2„påÄÐB,ÕPË_hè«'J¿pQra«ÛôãÅ.…&!Â…VaW9­=¬â÷èDûJbÿ0ùZ.N>"s- ¼vwɾ‘0µ?ËNâV›.èvT6[òZð–ƒà1|g ¯TÔí1>$x$$x$#4Âf’ÿòED|öò:d ö Û:Éií/uý‚SèAd€šäáV¯v.4´ ÑC;4Nå¢Ô¶ƒN.ví8în÷×ÖÅ?îãw„x£…¦.Ë0Ö*¢~J³£Ù&JbU|‡lì"„4Ã3ìÅôü1Ÿ(âšb T i lr×"ÃeÞAPÿÁ ¦Mõ£ ‡ukÃ⮢ˆg—b]±ã&ßä¥"y&Ç‚,8Ë;ű‚ÆE1ç.[aÍ‚åb=)`ž×ð¦W³PbP8hOè\bÀ†”y*åJ-orO¤ÂBà ab.çê̓삒úØG?t5ˆûgˆ¹ö/XÅÿÊ6.®OY”-ª%°bíY§Ï\¦iNˆFŠý#;ÉKƒ6>Fùt˜É"Zá[Áø#4ë‹möŒQX_é‡6b ì…}ó%ª&BSæ'4Œ3J/Ûðõr™O’À‡çbC‡Õañ—-bwôrÓ’Œl™‰#ùçã€ÑuÈkê?\'¿YŠk’ýBÙk}Ô”Ÿc(c á=£w?ýKm®N”í{akŸR4ì¡ l«?߆‡þÓÁ`€N’@¡â Z.”ó<†8v¯ú+b~€6 Júp[4úá`ÊËz.Êkhd4±¤X§j’u´8>,"A(@*ÀPþ¦ÿkÿlökɵú Bª¨#c4?•?z '‰ÿN¤MÙlrÆ©£:\OÚPDGÊ÷6G«³‹Ó¸ƒ-À‹l!Ž´™ø»°Y.Ô:­gÇsÎ( U®-Bmé"A†À†@ ¦wkñ„/q5d—×54­Â8Ãm¢ŠŸœD.ª`âfÍÖÆóælKš²ó£#óCì%¯Ç"‘}/«Áú¹4T2ý‚´7öEÅ:‚ “.<‡£’=Õù›’ŒÄ¢M܆(€ÓôšVùy?S_èÔ&©HØQ PÍ„Z¢`¬¹ö¸"¢MEä+›–Îîa²¯[?x“N‚-=@Ü»µÚ~%¶¢ÿ‘x‘ç‚´E»%[ÜÅ¡“±ê¢µù¤Ûâ,ð›Õ\Üù[¯o €†kºjÄÒóxèµÇC€ À×1x¨&‘É4>#.*,)è)hI£˜‘k‡R1,a˜ë"øx¶½.(ÇÛOÈ’æÛ§¢Ç¸ú³ëÂÍBîÜÜÍyîÔhÉ&–ÎãÄÊôãÕÙƒÚæåN.ÜY¯[ÁJl]1Jâ”_V †êy ^‚àà!éÀ8ƒCHµ nqµê)Ò­ªø¤²ä麚»ORKÜÌQÒ¤Ê}‘»Î[MÝ_Šlÿ7n›UvS\»hüÆ£s[P{.ˆsÝ»…¦[!"àÏ÷z¯‡€‘w§ êMy²^´üÉôš"mšU ¢M³Û/àhóCÒž.^àØ¾ÛÛ¾«ßÞCé~>ôÔBsîT@Î×}w©¥Ô¨ÞûBQéÞ/øÕ…ZŒŒ=LÔ¾Q¼ö½-™èãaeþAæ+‚ñ-b(%òwgPþÀü/ÿ ØñLÎB ô9ÃS|¹"A?ãY¿?ºÐÍÛ¥ÓâŸÀÿyøW @A…*ª€"ŠÂ‚ãü×ÁC‡ÿè@p#Á‹# éábJ&) äG±@<„4ÿgºt©¢À‰ÿ Øû× h þr4A+¥ Fh ´`Ðÿ†\(ሼ'.ùGO= 'ŒX‚ö_“%÷šÜÓq3®Ü¹ŸÐ½‹7¯Ó?ôõ{Cà†^0ø‡'Ãß´W²={*~ZîIÑæ?q;0¸øÁÀ;ˆÌX°$A~4»tÍ3Ï× ¨ˆ÷Ó!n{6[Eú¯hUá¡¶J¹a¨)$(ʃy,¸ž÷5¬@²hÙ²u{Ï‘ÞñäË›ÿ0zÄ„û–KX´ã›*œ™»!ýÌK~}H¦ôÑHaT’A ]®Ý¥P<I”ÿoÿØSÁPAQÀáÁ”@­$÷rÅýÓUU%0Ä<¼ Ï ópÅZ\ DÏ?´ ÏZ_¹u^B DP­,à—@ 0ÀX\MR4Â|Mð~?ÙW~Î?y”‘æ‘H‰VÐJrä‘A-ÉáD3É…„Ôy…ѤBDÖJPGQ0 €°ÜÉ%§h‰‹¢(P’AÕAÈSÂ<3ÖXã?'„Õ•n¹•Ȧžz× +¨§ä^t-†fc.}p!•]†åB ÄÚ@|&&i’) A+ g)«×„=Ý)a´yN”PAJ5œ‡"ª¨‰Ožx(ÿ¤EMjh:#ZØÉ£=9žÀ#ZM‰j½öŠøÏ GÆê?Ș”U€!E9Ä#xÁS‚*x`™Ã~”&E-™ð`EÉÆ1\ÞW'DÕî‰PBW@+‡EÅm*zÊU”¶8„+æn*OÎ_Y÷ÏK¬Õ„]÷-¤("®p’ýÊ5E†P¤0Ô0Á?ŒØêÒÔZÜ«ÃiD1E ™PÒ›ãÉD“È=I¸“M¾&й~0‡Â…èòyІKî?˜{ Ø tÏ-œÐ„@ð–•8ÑŽ›Ä?ˆwCÒ†% °z“£luWtÍsnÕ.E}Ó®©–RÅc{-$ÿÚiÃÙeL¸ýy­@Ð:D (–wy¦bU+·2Äß0æüÏ=uU–Žj!.´½Î<^žÊ+PPyÀHÒuATÎSBAÊtDVr…¯0Ö¥ÿÃL±C™Ù,™`ö©‘éTP>*íZ;†Hp©ð8%ÒKÞ˜®‚På9åzÁt’G¸ž}¥ Æh‚1†A½ Þ%á’£žª§{öaD Xð àÈÁM0p“ðt.±#0T°xÉKá Ù˜{Uf!ìc²ÚTZÅ­øÇ¨ÔD‘è.PÉrRq@ýCEÎiJ éäLyプ§Ö24GeÄKÿ<ØœìQ„0ñH¬>Џ.0tÉ Xð‚ÈðSˆ=b€+k¥f$?<ˆƒhªŸä£ˆÁK`’û(ÑV©`™Ëz'—G« )Rà·È"áǃ`á¸ò# MðT K Úx—0¬×k"#%Æ@VC¡÷‘dî#.,Ä@o‚ð/j Ë£Kö±"ÎÄ}§bD ¼I‘IB© °Ö¨D‚ð[£$¥UJЍH),úÇ‹b${èS=£ÐÆ7$ xªÆhA5p)9è"Lå\ù€F‰÷pá"€d ÀÿHæE ²B”ï1æ?Jÿp‚yüC¥AäÀ~b“xØG6¹Ò PªÒ„Ù£œ»BÄäF¥ ÜâC=)¤Hʦ€R &:jSåiJIUÅE%8ÞÖuÕ¯-â9OtD³œ‘KòáÓV¬j7ø%Aøå‘î]ÈSY¦@8jѹ|ô+Hù iT°ôyÄae˜¾¹®éHøJ.êŠÌÁ¢(µx©n±ExÁ=ø™¼ ö¨-d,ˆ#à’¸t¥–%h î!à…ÈKô2™||À§rë/íD¤¦ÉG÷!eA™ÇMf^ŽÐ›|VËã7q™©$þƒ¸q9á‰({ÿÊ^±8ãEQï")ªð ³ £>ÙR8}„-jQþÚ¸ôÈsdëïÁÔö&:€Á&p k°ËñG@ø¾jé}Q0 8DN˜Ìþ·ÐèƒöOR™ôÈmñr“Û\æ*÷ËÝk3)"­¬ø¦.±¦ãŽ 8Ç΃t)êIY`R“~Ò%ÌAe' ÏSBu§L†PÀFÿ@?Wá~ªH£r¯[×Ï¡ù–O€“§Oåqàs¦³‚ ’à¶Ì¹-aþ‡1Ò <Ä%ôèpò!έ¿”ë°4ŠR¤ÆåAæ¤]Bá¿–ÿ5.+] Lhdòù(o“ 帨óÌlzeÄ(ÈùÌg\ Ú2ÂiNóŽü¼ÿ"Ào&\‚9 ß»Œ*y‰kœŸÿ܆†@Am0d´C€m{„%»E„nÀ ¤Æ¨sϳW¹<‚ré4`O乜p% _4™ÅOæÛÉðo©’@+K9EV^ –Y‰B$Û:ºÊC ië -ÍhWØìæ:[Á¦3€•×8€ØÙÎ~ö?¢}ržÜ%Ö ADÀˇÚç,8B ‹ËÑËøÜqáhAŒàó»8Óæÿ )]”Ý¢ …FOÂ)‚ER:™ŠÿR§r) Îj-¾ºª\¥ Kp„ò݃rŽîW¾ã^>§ù–Îû3AÿñZ} X uþø±Å7ç[â|÷ŠZþ¬cTÛypGËŸO}pi'ÆR§`QåîCçéî¨^ƒŽiˆ”Ât±yÓSÝçÝÝ5'5O_z¿†Ýè“uÔMDYÀâ\Ê[dµK´žð ëA¨jÃHp¾ ež×Ï|/îÈŒèµ[<÷ºÓÎv¶s‚ñ\ç’÷ù+Æø³÷Ú‚´`Ѹ«>@䛳8Æì_&Ïç²ó¸¨pþP¡æ?oßä‘tøz©yéýOR§gz¦Ws«vÐ; t@q±ÿoñ„"ZgJkº§{AÿÀJ/P>ÀÉVa?sÆDP‹ciVx7`{ÖgãÓ8ͶUÅzá3Íæp~‡xÀ[ ·“yÇcw1†y •!5E·yû×t"UtH§ñF> GR©7zEg€õ‡jxÑzP¶)b¨@ TYfÿpAÀ°dÇnÁÖ<ÏSA]a8ˆÓä|r§qÔGlwlˆlr}&>ô²kn1K…C! ƒ²!ˆ`œC̵~;§LBèQw‘‰•R˜æ„šAIW&…zWx…ªv"ÕGåõz]8E˜e{³ˆY Dÿph¹ÈðÀJa¤B÷Õ·„F7ñ3ìÖ†“‚|øЇxP$Ä6}ÇF/Åç‚Ñ5/žÂP(ºC†0‰Œà9ö„–ˆ”‡‰Í5*DtŸèy›w Eñ†Š(j«x€÷ujüV T^Z4‹RpTU’r†Y–eºh0Ò^ÊKÌFFÞ_Ó˜84f|øŒ‰`‰3>y§gЇg©`wÆprã3ŽøáÒ Hp;ÞÅWë&š(c?G‡\EØBF”PxŸ÷èWI¦tÿ'€#ÅýÆ€Y‘2†Yi•¨„ÿgȰ^ôÿY°t.áld$‚™<Å&ƒÈqò5goyÚÇldžlÚØ-°’ÞH)º`DöLžXW.diæ‘\0–nÃCòH"u¤ÈnïfLLW…Iù„ñˆ.„TJřޒTL¦@çµjP%•ó¤Yõ •ZéE_dUòUZîåJÆ·õҵåŒ7ˆv‡gÔ79—Ⓦˆ7@3KQVñEñL—ø~ŵޓ÷œ›hy4V˜,v÷•¬H”.±JçW.…aŠhs™ÉÈñ(&¢žPOóÄj)"†MÖjó)UTš÷é!-ò7‚£OÂA[%wQA?óZùf&>¼¶ÿg|&’dIu¦q&éJ=Óô,é!L±!^>æÃðלDèBz™X„•WÕ„NWLç¢EÙ˜|UžÐzÿ•6¥yjWYeT–^RvŸ Ô"8v[5¡˜Œ4fp6g$*w%Ùq!©–Äçq,ˆ’yÇnk±@p4sTQá $àñ4yì—Žr±G9twQ=)䳜ù\áénC™BG`Qàoà…oQI†ª6Ye‘‚<<vEAěϳÛHJ’˜qÏXaÏ7¥(Ù[—æ²{<Ð"ô4" ’®eŽ5Y„¦²LA7„žÿ€+:…I¶”妫¢x_½ªBe€ •K…JP ª†´‡¨?ZW™JÐg¤qÈF–(xK9wZwô2ˆpIFuÉ›s1/òªæbOP”")çEðWÅ“ÒéªæQcñ:„A¢/ô‰s€ÜÙ¢àéó—晄ž‰@þ•¤‰Y„Ze¶G•òô£õI{5|J}‰FÖlcÖ8p‰’ó‚lç©} *úª!P5£*é:O#²® ih:¯Ab¯Ç%„®*˜7A“÷ÕUˆŠ+žþZ‹ÙQ™™UD"°—°sÁ®ra‹>š° ±´§"C8}þD‚‡wÿ—{gS ƒõUa¥e²Ø'zx‰m^@< •éZ¬0­à nHh tEhWr¡\GXmºsAy™·œüjG‰+V-ä¸.ôTõ@¬qáeú€¨3VF·9UYšÅ*±Uá@ Á×q×-еo§ºÛø–j©Owæ›zˆáНÙêqŸu¡< @ª®à r‹š3C#‚" i+tQ€[“•WÍ›“4–L@7½46i& R­ £ÏEäÓ¸|•}úQ¾À‹± ¾pÀà À€ -{†±•ͺ®›Û°³÷žSºµ—Hà÷õfÎVPÆ PüvÎÖÿ ×Ç­aµÛ‡¶é±|¥O/@½ ¦ª‰šõ4†((à®ô÷z+${å¼í×\Õ·ë¦iíf.Šz·FÆ•|ÚQ÷õQ˾7Q¦•kB!ìp–Û²€<ŒšѬ‡J·X¬SI¦¤ëŒ/UK…qó¢ºt&ƒ {ˆ)¶Mj`uv›t&Œº Ä©-*"·°æÆCÐÆ‹¼0äLK³:‰“8«‰ky3V¢„y³èX´WR/ÌGÙÃ4츾è[>\À¼èÈÈàõpP µ0 F€¦£`ÄÀ  ÉI¼Á{¬û€ÿkºwIÀµÔÿôÐ-h©Ûló¢`Þº©¤•© +ؘ÷0/zyªõ´ÄJ,U†w[Ç|ÚW7±\z½ñ¼t1½Ñ¹³… €X”J‡t6lžH›W.$ɤl¹о¾É,ÈàÃíÛ‹`TѾ°nš\µðµ€– ¬§„ʵÈdð®ÜM°#´<*GËÕVP¹l Çl7AlMНtV[¶gÂH®¤š;ò™šÍ*·R ³0ô傸Ïé&|Í1¢rñ³ÜÙ½˜vs3ìBæùŽ<Ô ÏðLéìè‰ È0Чä eêÃt\0 €ÿÐ ÿp˜›¿R™YÁÊíÅf}Ë`qr´œºjË-Ìh4Aó¢›Óš¯|0_j¼ dœ-Y#â`ÄF›BÓŒsØ ½Û¬sËÅØÐiÓ-ÓˆûÍTÎ1ÚBÎÔQI¨Ùê׋í‹ÔñÎRÚŒ Éí»Ãÿ@Ïе€Õÿ¬•Ï‘¹— Öt1$ó@ËN Ûî2ËN#¾ÝµÜĸ˸Zl§ËqöfšªyÄ C/¤zªC3”bÊÝ«j|JRÚ[¸ *cêè\6-ޘȼ.v`7ÙJ)j\HÇ?™™„³×‹½(ÉrÏð|ßQMÊȰ¾½è M]´¬Õö¼ö®Úb^«à ;Ap¡!@QPºÝÛºíÛN ܵ\Ñr7`jÛºrͤ\Œ~Å»”ò ."ZD)a7MÑàδœ¿ ¯Ñ™‰Õ È,VÞ½ÍìØy5—Þ§¨«(”ö'Ã|*ÃÆõÃÑüX§]ߗ올ÄAZÏbÍä¼8Ä€B,Ä®@)÷žëª¨Wæ"!Nphi>á.á>ËÂË»Üát÷©M@®Ÿ¥Ü÷Þ–gÌ.{(úØšuT†‚´nõ³ÜØêt€ Ýã•îØáGP¦Ñd`Wn¹ÊWàky2¼È}”!ù ÿ,éÿÿ H° Áƒ*\¸Äø~ Äg¢ÅŠÿY|ȱ£Ç CŠI²¤É‡©ð¥B˜êG­-[Öú±&Í›53 ¼(ÐA!Gýz²¨Ñ£H“*%éR¢CŽO_¬ùfE«5ú̺³âÓ@5ĵ´¬Ù³hÓ*”*õ‡Ðˆ%V… ·àU‹,lÀ·AãÞa§þ#+—ç„Õ*^̸q™CE:”[u§Õ}1öí¹·3X¿ŽuHÔ±éÓ¨‘–†XPtå§9û>ý¡ó?ŸbwÊ&è¬aÂB}ã5\câ©ÇS+_’òÇÕH¯*]âtç¼i[ßÀ}Á†๋ÿï¨C!ø€’uÍ{0¾ß;oHμ¾ý…3! \ùOj¹£`‡„D7üƒÄ HTPÁ?ÜààƒQ@]uÐfÁ üsC ÜÀá‡"z·'â“hˆ½W}.î4U`÷ÕxZ€8ÒTtRáXdú $¡!U€D‘ÿ ò‚ þc"P6ˆHƒEðÃw üâ?#t0Â\òó%˜#ðó?t¹€'ã­ˆ^a¹!÷ž‹_f˜x¦¦’`;6 d-¤.ÈO‡P=ðA>ù|°d>f* å ˆ8¸À |É%¢†.XAñ”J*©ñTé d ÖW‡ÑÿgPbOј筌Ý$”[(K‘¹å\†òc=+¤Ì:ꨱÿØC)?ü\Jì˜_fYÁÇÆ ¬@*¨ðO©©ŽÛÜaö&œƒ54Ÿ¸Æ»qøèçÐK»É«u‘U¶ä’¨ Àÿhm²ÇÚ3!ëp>gŠi¬= vÀ_7|ð·Œ$ƒ ÈÆÅÈPØãÁ‰žøàÝzÙzaì ´™¼4—›@øŠõÕ®9޲«D#ˆÏÉŠ;PÔþ#®ÃÑ*|jªD-m´JßÀfUž(ÁŒtMOÇöÐÃh<ü@®à‡k® ëosÂmk5×MR-³ „Ó@©¼ÿìƒ7 Jn<€,p¸QKOÚÿÐ8"d‚ ¦m…# ÁÈ-%tíõ<ŒÐóèÒBÙ4ÚgŠ0 )Âi˜Š²¶k÷ì’g{¿C9™ŠØiÑH q «óSx Äp‚@Kü³„<'Ì£= £Zî¸&äAx0.—Þ5 ,Èc> чÞñ×ö„ð>"¬€ˆ=* =‚úŒàÉÜq*3íTÈjÒÌä^7™KuÄ9”TâZž<–°„{Xôè!¶äƒTãŠÇäFh‚Ln\üЇ=q‚¶Ð|KXÞ?¾F„àŒøÇ2µ~|Ði²ÇÿN§õÜéeLâCTd;âLå%_qÎd~@ \ kÑ‹AAÌ'ü£‹¼Ç?py€. CäB28„ö˜‡ôæ1º:O†›ûÂöj‰b?Bp2!=¸˜Ïhàv§ÿ)ñ‘lÍU$š\Q€Ò¢røÅtqy}´ Ž F bÐŒÓØ±HÆF0¬qùPž ¢g4;DzôÖ±òˆ,"`@>èÁô ²5±ó`É—GÊËvÃ)A|&”Ûõç ú!@G©ûKσž<A$Ü ÷8Â?H‰ ÊØÚèg4c€Ë•fK–çÿ6~ ÄŽ1lÞ?–§ÐE‹— ˆÀ Àt(O‘ê1NÜæ¤3ÙÁË™J<Œý†³Ê`hrÔ£=ø{x²…èå?2„FŒ2ƒc¼G1À‚H@ó¤ÃŒaOq1La£›ž ø=´t 9.õ(D€ÞAëÚQG*92#HÖ0Z£{m´€Ñ¬f½ ¢¢D ^gÚâ1Ë.2‚u¿té@dz2äó€! Á5zòt Æ—`gh´¥ Uz.lž<¾8ÐyÄ€ÓÇ 6%?‡Òfíb$E[$uq5^NÜ Þ ‰·ÝУ·¹ Ч°%­'Xœj—ÿZ0¦v…©@w>I‡h¤Ÿ=¡TqMÏ`¢P‡šÇÄ.v -ÛW ºV¡ç=æ‰hÿ’œ#~VOÐ$Ni‡Ö^EE4§ˆ¯~G܃10†V*…må?Ò)Æ…à˜’!Ш4 L j¸”&†-¹¤ÇKq ™›±¤¡ÅiêMò²C8BrÀ@~ ©ŠA©´}AܤÙÉ&ˆ<Œˆ|@Z¾›ž@´x6(cÚ[œ§Â†ùÂ2Ê#Üôÿ@D©YmÌv†¬2s¼Í"W“ÞS)›Í‹;è”õÀ@þ1"Aëc § 3Hˆ„éyA $)dJ[ð@–FXRÿÐG¤Â6XpÔ<7ù²"U/³7½)LoÌ3³, C3Ÿ—½Õ kòÞŽ^«qña~P‚ ²`Aÿª4ÈJƒ –Ò º)Aò*v7˜jÑ*Ö©&) z0…Ô¢VB0y܃lâÇ JÝYJ†*­{ºòž–~û6.¾w¯Ñ?m œ%@DD7º|Ì¥‚Bãe ÓC¦·-´Ñ~`Ã6î¯4P“%íÏóC"Hÿ¤,.6øàrug5oBcžõ„å<é·†ho(Ò[¼‚ /Aüão¡ ƒ0üR tÀÇt¤Tf|±pË'}y·5FÊÖ £uö y†C?Ê¢,Ó0ú1‚Äaž@ —$­B °2232×22H4×¶gkµ¶bqFþ‡ NäA%9p%0aŽ•„É30Ø—t2%0dñxBF¸u£i„,R“,'˜0ŽÃ¼~# E ‚p~>¤*™Â)À[±7cQ¼qHl·l‚w4h3|gM~7ùVM6øUîñÐ PWC:"Õ`ÿõ1ေeJ¦yPȧG5ãJit}ª‚4Ic&#&¬òEÀ^æ>À!¤0ÄKn¨°´H7ñ!{xw3~³QD1g½ÂYq!Ir íô4=r4e –0©rc€VFÌG‰adA®u,hãJQ“,a&dtÍã-ózÃ%c¢*ã1\H8„C?‰S*úP.Ž“0TÓ‰•Š#P–hR)ãAp,'1‘ò} €.z‘]¢ñ~þ³]Á=?Yl ö1N6ƒC»ófn·Qµö˜7ßqEWWO75O\†•¡7&7ð%²•$%z-ù=n©*\ˆ0ƒ–JCÀ @dm€, ’"ÔC—.)’"`",7‡/73Óõè “{H˜•¦iUödãXš&.¦Ð-ePMc|ž'õ‰-#À ÞD6Ûx£^˜8ã˜&”1ÒâŠÐÅE|hãš@ò¥\R áT'rf9ùr˜õòç kB{/JF#”B . F|±6M¥¡Û5,hˆW>05p]ô,@G::•¥ ³(Ò£X)lDX›H=BõŸßW†eòAÚšàÔ- 0ÿÖJåiV¦–Ý—)*¨~ вƒÑ=iV= ÁIj{ýf‚8ªb!Wbw-ÅBc4FCG]=%p, P˃<ãóT$#·…Íè…@…6 CJ5˜¶K¡G ®X¬Î3PFµŽJ=B:0†*~Ë¢œrf-WˆÚœÁ=ø@öé4Kâ8ã¢(¤¢–‘¥ŠŒ‘I·×–bw#0è^xöy†˜ð5-„>-4aK•0x:R£Ò}A•i ¤UæB±Å<'ðŠ_ÈAÖ<ö­KpeF\ÿÐbuy&g¢îø†Æ$aa+ëÆ>ùH‰B5¢â8Ã6*×ÿ§(ƒ³x,ˆwýá|·Ž)7 ¿$m]´¯Á³¥C\R„ê¢æ0"çqˆuôƒ`‹3¬ÃJavDed±2Ô<­±ÕKP>\CÑ3°\ëXG|`zycëºe7Í#FÔaÔÏs»Í[mK”b²Á4·2Ér*+wñÁjžax×¼´S¸‘4Cc½¢XÂQ.¢b½ú¡}'¢!­p% pEn*nQ˜gFs„Q&æ¬&P惑bC¦ ]¸„iÓ’i\!0¶nº[FM`zò€À(JÅYnHÁ¼)’²‚ƒ Š/+®A&ižl¼žŠÖ+#>KkAëDSøµ°é…R8F‹Å[µ±OHå^Qÿù€ûõEÐÓÀÐ…€»4r"-²¤peÆEW|rlëÉB ¶áVa{¬’?“%“ ‘a3p‡üÑ“vƒ4Hs=Ñž`â%Ü7 ü×s7Hø5^TĈöû€hÿÅ 0:Å—KÖLGÏsAP÷xCdG«¤`g&>´¤ÿpC²ûEl+a¤G,¤kû\;rÕ’ÊDävçqŠd°?0‹ËÌÛ%`’Æq?ë &í±o(fsöö; %>^$uÈCGS'5a˜µnúETIJ­ªNý%q÷ÛÀî,-ß÷}ÀäCÇÅíÜe'R!0Ó3ÿÝ>í#að­*pC æw ¯2ƒ§VöØ%´†Ð^B½ÜÙ㡸ƒÐ4R ` …>‹uy6t¯Ú¦ŒÝFC¹j«Û¬Š%Ñ#-Ò qr¥GE-à'bÅh4¶3ýQúð×€ )ä·8BÚ¬»¤#ÊC½ØïÂÊ,Æi4ÇÚ3mÙaÐ\g×DˆSoÑVbwhÑë´¹`PĘ¡‰Y!ažÄXeDnÝȧAw”G!‹Ò&‹6ôpC!pÊÀ~um×Q ܬK52Á•ª© ±Áš”*>‰Ðée›ÿú½ì“¸Ço­ñ‹‚1@ùÑ$9`RISp¡¤ÃyM3Cº]À" Ò8cwezºGa—)îƒÎa?ÿ~+P ~ÀÍN6K%~HÓ›&â24‚^ѼM3ÐkÞžÒÔŽ ˆœ}Ǽ“!Y¦-SýʯÄ™Ü5Å×yÇB§]¿]íßÍX¸ÝÈãö<%¤—÷(a}]Üa~+°ª°QnwOá‰i—G)"p+p1^†ÄÜ=OM3N“4h\Ü-Ü=Cã)›ý‡Ž9^¦úÒQ!”Y‹¥¦4tªmÑD·Br\]§?ìEŠÿUA>>Ö_GÊÑ3C1RÜ—\ÜÍà+à” Šªø*SE ÜùpC#ç}üðez»«^ÐJ´ ÛÛ–-1eB& H&#\*AC6ÌM‰otŒ!¾TÚ_äE€ ß1Å´+Ô5ËÞm@,GnjG]¤XöãºÝÈ‹Ua, ¤îL܀΂}Ê ?YB *hîèîéÔå. ØÆbqÒâ×_Öv%ƒè¥ÿp5˜M;ZÛ`ÖËëQ.€; 2ð0:BÛoŠ!18¥‡¢bäçîíozÖ:D|AüO´ê¦LnD¾_a$äLäÖíŒâA(O€ Lñê”à— 3—ÿ°æêÔÅ.BÊâ¶Nº"°¢,S}¡‡džD‹‚p9;*8{³L³ˆ—,‹Ðþ6ÔIõ–q¹˜’_sµ¹Íœge4°þÈ>[‹EääÖ_ÞÕû•ö¸[ò–aᾤØð~QÎéó0ó5Ï¢.c8HW†i r{AÆÁYï ±?’½æ5³4Ã`ˆW*0ù Á®áÃÁf€w±­°¥]¿c´¹»µNå#°'ð5ô¿(ÊèùEüE•lÿEYö±O¦0HN÷¼Ü êÿp BóAüÂ?óÿÐé>Ðà7Ÿ^ùðŽô>#¬ùîÏù*J?ÞÿÒýê ’i9¡Þb4êf‘1Zâ*àIš+©-ãeT«ä9Tè´ÀiÏŽþ\ø,Zük1ïßäÓ÷O"DúDHQ±â¿ªP¢dá’!E޼´’”EaÞ „ùFPÚðß?!7GŠÄµ3ä|@E.¨ù¯C>ÿ™HªÔéS¨Q£ÎSa0FÈö²nÕj/¤=FÿŠdtÕ뿳gGâusTÈ·ÿj…dkóG„ÿ(L`!OÞ’{þ ™ƒÀ‘òú²øwB$ÌÆŽû.9²$ä=y÷þiÞrÉ_¿ò`"DHo¡¾‡EüCôoõê"2.ðA êÿGÜJ¢ü§RD¾—ÿèÉ$š³hN©t…:Ña„O&’O§^ýD óbÐ{zÕ»†1æ¿.ÒêN¶øjÕ·=>|~ÜÈ[Á Íø þg„ÿ¿Êþaìªcìÿ±LŸþÁÐN¨´ʇ!×*ÊK¤0êp…ÿ± §@R 7!jBɇT)B{‹¸ 6È 9œt²)ª¢þÙÀ“Žjª:"‹t*;ñ4ï:&G22##0¹ôDº+/ *˜‡ÁË ̈Âî9Â/Ê©¯Ð -15;A4ÇC¨B{Ns‘Zé†I•P²M7wÂÍ©“X,ÿ‚'‚³‡¢t$Q$|Lħ§ z¢t¨üé¹(C5Ò ÇBšÇ R§c¬º¶Úš«JöþiëŸù( ‘¶|p?/˳ÊLõ ‚ý ´ÏØda‰e!D° Òªó† ò“Å}ð”’K, QÂuJ·.á%àÀûÒ ©§K¡ZN©!Eµ7¹8M-¶ØaŸ*SA©æ‰S½Xá¢ë` ðb­‚úÚÕËB:‚J8uJF´P¤4c6±`÷=5¡„þYèÔ\k ÏB\ÁS‘j+WÜIË©ÛKn¶EŠÈÇžììAdœnº Þé€êqBbÀPï5Èéú…ÿLàé´ŒºªŒ«ÕôZêÖ*`„ÌÍ@0O(Á±°®¢çª'ƒå21ËþM¬1‘ª‘ò‘@Cªe-6Ö0 i—]œE=ê¶fš}º„[ S¡Q´†¶QÇJáÕ4^Iw‰j©Sw*%óm2• ùÌ–È×)ÈN»½ærï¦Z+ÀuKõ#Ì0ÆJ8ˆÀ°¼:µÀ}G*^²¾wʧp‡F ñ©—µ}E[Žržù[Coö–Û/a€—†úÆ£–?$MEêqñœSÝH:xJ;í€ç fzÒtlW¦e…¬vO[-v¸e>7@Â…À{ð‡˜)ÓÛÂóÿ²¤ŠbŒÉ›eÞ”¯yL &û@ C‘ˆ€Nñ”FVÀ3‘pË[â ¸JÄÃr‘ë™ãE>4@ˆÀŸÃÅM@R¿ŒŽR )ÝNFP¯ý)ˆZb %)éy Oì>è“ÙË1¶‹ÊíÀæ–÷ÄÅô1D?pÂ7í'$‚!c2¶²è«TÅÉ¿Vî„d!ƒc "føÂíù$DŒcÑ+h³‘ôYÀ[%"‰pf³Ë…äžP?‚æ9!'~U‰î×´< )Y¬NÿüÇŸ|ÑT°£›cFªÛAå_zSÊ”ä"¶8Ú¤-¬£}úâyðª3§BU Âÿ ’b…\A<øÀ…„‘*S:dÎl¨S;шFx#"Qz²‡8Ù¡H<²IÝpËú xòÁQ1Š9(5U¨ °’–öÂå•"@ìÀNcLÒìœò¯­y*: [•v4«àU‹9A`zÅReŒšƒIÆv²*.Ý-˜!iÈÊ©—sF2$‘´¡Táƒq„$›¬Ù="ÊzÊ/¹">GÐÚ95»†³Dm¡R,E¢‚€unâ‘ÒòÊJ,´â®XÃT«¬Ü#+õ¼gG?¸•!* œg²€ûÙ JK0B792âc:æùrIµ•›âoÿî¼a BbÛÜgžô·<ÉÙra6PEˆ‘cþÐKUJª«Œ¢§ƒE"Iç(¡ò_H¸xW/jeneUbwžl*eU¥"æ”t£Eð-šü"ìúFœP?‚“<Ž ™{pÐÑj”jk‹XÖÄÁŽ0Õl”tÑ'*(ËÜèAÆÐT­ÓÎL¶*‚8Ž“\C2CØ•0î.—³×ˆF3¢‰5^ ­jùk( CœYÔ4l™¶þÁäD@)énŽÏC(PúÀÚ< ¥J«â¨Šó’lH`k/Ôí$Â>bÓú§ØC¬^ÜÇãá‘XTUJ!Ø×”yâÈçVÎEËÅÞdÒÂüc¯bjÛÆ°bÅ¢j$€[ˆöÐt9§Nœ{i³ä@ΞT¦QËÕY¡zB/ÉÎÿ–˜"Ç+*’ò“W K5÷h‰n¶*PŸØC·F’ ”g¬¤jJ¢Þp¶QÌE¹m‰OsýEç*Ñ„˜ ÃG¼­Ê* .ZÅã’NÓ´ZDVœ»áävè§zE§šî“½z‡Rþ,<¹Õ›Ä©€O€KäZŸ€ä~c¦å›CÒæ‘Ý'üPKßt»« i'3uͽðµ-sÜö]íq±ÄÜ#^Àu¯x7\8qûà©„ª°7q †÷NÖ[ù–µˆ’ò”¾Y=ÏJ™$è»i ’§ ø`Vå‘'°šEO8u>W\V:ÙtÖJxvÿ‹$_*)ÏçI«ˆ¡'H¨¼u-+¾nïœišÛ@b¢¾f2й©42eBÐóè1í y{ê=gÑ9Ô©v%øÞN„úÉCñf& å>74MµUŠŸ@µæéØ*û‰‘€%•xÀ8´+³˜’¸K’ðÈŽañ³›ŽQh X11 °»ò»L ¼½"ÃØ Ι‹;[.“‹‡€¤G"¿"µwÓ ²¤t¿{’5!°€pœ©:¤ "JЇ@š  äh¢I±Ðó‰ ð*ô€_K´k°X¢ ‰ Ƚd ‰¹Q‹Ý ìP¼hC>4bŒ~Ù‰ÿY™¹`ùp®»ú€%i À¨1q£.ë %™Ç“ó îȇ ˆAt¢ÁÌ3?üÑ–÷²$¡"‰ƒ2*C‘ª›œpù×Їð¯œpB„ wá¨Ó™¤¸BþQŠa#¶b L‹‘ 'ùÃbÁŽÞ2 l«÷P9”;±„i± B‹)–ëR›(Á{ ˜S¡@Ǧd Äú1Fh·Ä‘AòÓ ä&³¤@DYË6‚²I”'¹¯Ð‘aB'…O䤰³‰±s¸Ôé€"@3®ÚB§yŽ.º+9 Þs § RÉŽ`jÃ0Hª6e² h ²+´È˜8É =º¹dT£ÿLKAù®»'§¸Fñã$Ë·r/ð©o´¡z5!ªMšœló‘œ!*ªv„Ã…Sš‘p=—a+Š`‰~Ä0±ð ¹;™ë',+ñâ¬1&ŸXC»«¿Ó³¸®Á+ P §ðÄb° åaî P#s“›Š¬‘x=H|ºo¬/ù%œ‘I+»sá‘'꺅óIJœG)Ê® ÿ©-.‚Eµè½¹Q¹A’>›¨ƒœŠ ¬´ùiÈ,)/Kó¸´Ñ£=:¼ì‚Æ¿p€‘‰˜3œú´Ü©OÓ©íyº¦«Ÿú¼•ŒŠÿÎ)Ú¨ÕåËÖ«‰›¨‰ y´BèÇP‰½³6V\°PÀ(e[7²Ð ´„»~â®eÜÌ1R7`šÀ<ËÀ› Ê‘01º¢C†šŠ&ÔüÎ`fù˜îºÄò˜€jÔ ‚O s ¹‰m<µ—Y2LªáÄ,xàL”á x@ÎäŠÖ(˜—ñ”§•2+’zlªÊ 6{̑Ƚ§Ø-°¢ ª [¾´’Móà­C9C mK4¿ ¤5ÒO›‹˜#@ Öô ‚ͱ„ …ЇC”¤OƒKòÓaÓž²,KúžH´º|ëÍÿa2”Ј"ˆ‰¸8-]+Q)œ”¥ù¿‘°Â¥øë$’GûY³žœŽ¶S F 3R;‚Ôö$–'é-ìЂ1†d±4™ÞkRµÙ£ìò Œü0ú˜á’U õ ˆ@PËYÅ“1­Õ1ÓZõ‘°$UÐP•Ì/U8‰!ɊЇ '°òÒÔš«J.ô°Ÿ€lÑ"é4³ÇÓ9Ô¡œŽæ¹ ððìðÑñ˜›ò°(M+•ØÉ´«H•ë9Œ€æk@SY£À ‘Ø«êªLK¬U‘Œÿü ñ‰¶DPG’ÕňW•X­[ŒèU÷¢„ÿŸ nT…Œ‹0VzH¤ izPÂÏ™ªµ˜Ÿá5¢èÖꔎ,èÐÖB5@‘hýI ~ˆ‡¶S îèÙßKƒ ”JŸ` »:Â% c(“â/ Ìð˜JÁm2ñì4ÚLÇš!†U/ÙPXÔ0Ö ¡Ô°ˆ \%S uÕX9u|D"ˆe]¡HÓqG¨z ¦ù‡¼¸¢xÀ—-œ½1ËBŸèÄ-¥p ¤C¸ ðD=ëŽ3ÒcÊTìÀ[)³5J Œ}ød¤¾ÐP‘©Ñ§Í׸Ía|v ÿ©êÅÜÞ I@ Ôý Þö —0‹\*ëâ>·l’;º0Ò»°•»âCÊf£Î`ñ͈nì´çƒ>SQ”ÉÍÜ]Б8/@&oñþfoÏtÚÕ‡\8á½±ÀÚ‚~_ÛÝàì’can‚è&u@‰â¨¡PêM)Šw>»ÁýJÞõä@ðÓÎ~ ÜóøÉ=v¬ø>ß«³)é- ˆb¢µ(íàŠOC«•+¦ö÷ ;c¸å: Ø ‰((q—v¼8Y¡Á‘ }zt—!NDuWlÞåi± )Ûá…q†^‚]§PÒØá}éÌ ciá õuò‘îåoÿäˆáÀdÅ P5ɺ¢¥•'³¦Àø¶7Ànd˜³—dã±ÚŽì8"Ó{ªp’°Ê~ýÕiWÒÖø™°`Ó|îAüTŸ‡æE òVV´¤&@.æUto,‡Ðt ~é‘^ ˆ(¢„ ×â_‹y-B0̧ïß?ˆVø dá¥W+þÑW°È ç9Añ6àrßÉøfþsI3æÉ bzaÂC<&p-Š“'ˆ &ÝÀ”è£Rcª`dž=ˆ*詈Á5†ŠyaÿÍÓ §†²ôèAÔ@æ(|qGŵðã†!D†*ðå÷Á^V 'N[òïÞ=8ÿÜKHáãò}ø‚½yô&üû Ï¤ˆˆGÿCz£I}óåƒ,¯…öüõO ‚ ¶bÿp@À=¯…€Ÿ=UFYÿ0ÂÐÀ}6ši1†fRi©¦k }$b<Þƒ“l¯A”Úd' %ÿ\‘ª¬ d ý“"GÕ)éÉÖ±4}qç%NÝÁôÿÏRðt^<ÿ¤™¦}ö1°Á|R1›mžCVöœ¥'=^©ÐÕYgi& [^ÅDè?6(×?qÁdA+òOÿðS?ü–,Áab&Ï ÐÍ3Û<#VVD-J" É(cDµ†öj(†Ò !ÆÖ¯Ùœ‘¸FDã ]rQrÊ1AùDáE0ù%)a÷ݘñÅ×]M0 AŸw8ÝðOOèõzë™TPQÕg&TçñÓfLYmÕßI†xª€d ˆaL™ùÓ(2%üÏD˜—¥˜æS`‰ž0Û§÷|øa-,DŽMFÙª)ª–šD8™ZhÿlÿQh.äJÐG"…D&ë#ª´Ñ ª‡muN®À³j<'ëDKVgÝu-y×­S-Éxn°À;¥ÓºmuQôz‹¾iû·oW_õùvYg=g`¿‰–¥0ƒ ×éÈT O¥P%•cÿYkøRy0=rAqaX¦h’KU†D¼$"=Npl$òðßAž3ÆÔÅJ/”afpT‡9ªÎs/[DjºÍŠô[ÈAŽr’å@Ó¸ì1Ú!²$—¡©Â0Î!ɤÈX@’W$Åå-á-”9üZšLpϘ0o(òšŠQ+yÖ;t{éÓžWÞ6 $–¥,ÓõÓ€æ|ØERýÍÄ,¤•SMw°‹iL ~”›çHÇ4G3 3+XÆ1¥ ‰éÏœô›Ú®"1ùì²pfsE  i‹ض'ÉñÄJ¸UÖ²ž2!Qv¢CtA„†8Ѥšx‚~âë=g-ŠÿŸ#·«lE+ƒùÖb¨ç4ŠQPÄ«¤"F¡hª?öS`9@ØÆœ„ȶaËÎn2àx¦™e$–K݈ߙZk¿É¶Œ§`¤ á5òFNã² ­i„¤-k!CÝñnKV…¿´¥.E  Ñ¡¼t8”±‚˜'[å¤YÉã ßžx=Ú;(#ôóœ ÅÀ+ƒHžðÑ „‰–PGçÇc{ÈÏbòÔbИ$ö$kaÈÎàÈ̓рQf™çNrà ! „MCç™ÉÃA¢¼qvþõ, /!l5›IU$w)IªÕDÙáQnT¢bŸœ§¸®SòþAb©øÓ“…¶O Tÿ,W°8Ú•b‹Ü• Û’/”ᇅú3„òHȇiÁÅJý‘)Ūe |U”‰%p˜¥zÌSÞì+¬`ê÷š05¸íÈI o&ÀKŠ­R¢¦e綬ÉnvL`çŒ`Ûòʇ¡÷.M®ë¸È ò¾½½™óë*`‹Zqâh¶0ªw½Ë¥)…©ÀÞ¿á%BóGX XôÏ©>«à ‰(Tw£k…Ù—‘ÇJ"öít*G7î¬(NB°’&šÙ©"á¯ð  )¹’›d <¶ÝN qBòi«ëLEayQÆÊ|*ýaË~¨‚¡°8:‰ÝKå]·Û0ïîØ/Êʽæa ÿ³´RcBbšÐ±ÇäìdÒ”ìwv9—FsìàÜofyúS~Ö˯guËŽ“ЍÓ¿ÐÇ/ªuà¶¿ý§°ËvjÛ¥8WmjFu ¡IÌ÷æ÷yóÓçQøIh³_øÙS¹ÂÖ“ ˆ®^éyÙwé½ ½è-Ò× ÊbO)F"eÌkèAéTæêi ¸¤ÏD“­¸ŒµpPÛÑÎNMí„F.D™±ÕËÇq¼‚ÈŒ>¸€A/Ì“lÓDØïH’Ýч<‘ œÈPžq»|¶QŸõ€RÄ\rMÅ.íÒõ¬Ø}@š£-ö`\‘—ÌEƒü@EµeÜǦUL+ÿÈüñHýuQȤʔtF8¬H]pð ÊP]ÒHÙÏDÄÙeVìÀ^Ð\ íL¬Åšh¹ŒœYD< Ìhà/Ø2ÀR$ U¹¾D# QGÉùôxU‡}…XeØ íVÌ„yÜ ~àà‰‘[õ`ÛÄÎ=WQD¡EIÀUJgäÉodÅ<ôRVÔ_0yQdHF.x¤ž‘TÖdÑÈC´]Vl„7µÜÊ?Dë9œi]ÐÒ¼¡ìˆÀtLËV‹*Ø!™\‡(ð¨P vËuøÖ &Ï= ö׆iÛ?Ú#ž‰¼¤É ~›_Q…tÅØ£áDƒ|âPÿ^_ùÕÑÙYàÆ€z­DP†C´Tê  ‘cD(ËHàÏ N¸€´dÙ‰Öʈ†5½E$‹7„þåƒ ¸€hÔáFpÍÜ`nMxäÞY”œqbÊ„ ^ ¢„‰=ÛzˆDPârevq…u9‡Wˆ¡0Â\ÍüƒEùM´¤í üØC†”ÊŸ„Týec4FªHÇ?äÂä dàª!ÁÁ Pi]ÆŽDé9„2ÎÒ¨¡bDÀ%=´LKn`ÆmÀ5Ž ¸¤nYÍ#Ež EP W‡å“šÜ‰¡ ¾ôD<ðCÈO§ÐM`!F+þ@H0DVXFBN ®D“.ÅCŽÝZ’d.„€T¡‹ôL|9„sâÈÈLD4Ç‘õ¥Hþƒ¾× ›;ÕDN€ ¸4RÈ•GLªÇôÕÓµéS<@æ žD#ºçT˜Ç¼ P”U>žqÊâÊ÷tÞ@L€"„øÍD%D`FVTÈU H%F+†Z„ˆfHeAZNdñæù_çLIÒ%vG>8ÁZUá@L‰”¨@<ãÑUËÄ?´=X'µˆ@J,À`úŽxæK¸S·xBrí¼¸K>õY†¡„ÙÔ`Qøä}lÿæ‰é‹ø5žf„Ï€øç+ýƒÏ1 jòEþEG±ÅÚͨ<¨þéˆøHǪŚVVY`›T¤A¤”@tä̉¦\N ˸€‹šT_’¤Áv¶n‰ç·8ŸðxcM›£¢œõE&àÝäpÙRìD·uŸÚ8¿hE¢ÏKÔ#S¶Bû¼Ov†_ÜæUˆ`$Šžœ€Ìf™ @„ÖÆk„ˆd@NY ¦Ñ®s‹´DBLÉ@ Déø•L tì†r„>8A 4Á?ÃsX§ÌàáupK²qǸt bÂÙuÄ?'z…&A&Nˆ´Ì=Eà͉¦æ‹Ròÿ ž€ù˜Úzàƒž¦Eñ…nOÅlš`¨Õü) N™&ÎI@„ž”1.D`hQ]X>D.„eAÄ®˜èI¤H‹Ô©b5kä‚ Í/¬À/äCL+D`«>ð%,ÅJ(ÕÏð€ }Ô™Èýà lÛ»H‡]ô¨‰ºžDØ ¥ã'ýÙ¼êÜŸ  $ æ=Pš](©²ß–þE‹|ì Ý ¬&F0A„Õ&aADâHÆAZlŒ®ì*xý†Xb,k€$Hë²JåoìFŠŒÎm.Dä‚üÂDFêtÈŒ@ÍÜ%¦ð&’vÉר‹WAê …˜zÿö½gYÕ‡’vŸ÷à ¹±•ј8Þ#ý€] &«´)ª*ª†ZF¬¶b+.l™þWþƒ<¤ŠsœZº©Tàm‹®IÉA,Ä”@‹g´ÊƶÆàÆ¢šQP$H´A1Žª–`nyI<}G…"½ü„£/ kzÀzŽ£ÒªyžÌ¥Ï\ÅÄ€åPžÄ(ü@¥ÝNÀ©VÌTZ‘Š!Qýœmb mÂÀïïÛ²†±¤‘Q€><É®*°‡¥´œ¨‹ÒØt0Y£´ÐŒt< *nM©Bð] Ÿ²…H¶¦>¤Nî>_·*|*m<̧ò¬‹µ¥«z¾`{ ÿYÕG{º#=(%Q›*ú¨€\ÜÉ!H€Ç#|€Rzé&J+†= SßC´-peBxÆA²Ô±œÎÕáÄÝÎbŠ,ëÁD¯×ˆå,ª°1¶ ÏÎ/xS\`Þ@rþ†#óCh«"!ªQ|ë:„•P íž±`Q˜€üé&µ‡èÖ!FíöP)ŽY(”øE=.ÊÜÅM@W ~\ÆÛ¿jH©mÂBD™fâÊnŒ%_Žh0Cž„ÞîmÈLsN ÿÍ¢G¤0CÄHþ‚7'î?(î/¸À/䂊FAŒ$E:?PJFÕTpIQÀÿ O±òxX»×üœ„üêsL(1N )zÌgé ø%ùÀ2X¤_€f1PNCgØCOF§¥50b8(ˆ|ôï¶bˆ´Àdø ±4–ê½ÔÅBDÞR§bDŠ"kk„tlr†%Êb§ º@.ôôtÄè´ü†ð‚ l?ð‚¶&x ´ù®ORøS*ŸIZc²Kp]5Ql[ÚЉ*[%Vhb&BÔXœ[‚‰”êDWg$°æ’GiüŠÛ‚H0ͪ“ =”4¥˜´DÀWCxdŠ K³Â¥tr"ç?8Ar2vX†¥ôtO?6c#§“$/TH´3Ôlÿ+åNOU­Gc¢«(³£ÊÕo_OsÚ·ÊZ„…øQuÁ€É'6Ì€K¥=L~`Fed4§Lmဠ0Fï¶­0ïo4Ó§ñN…>äóâÅMK+cG6wolÌFvO«³ ðBx€ËÒƒ$këÍb±Q /ND€Èeª=á„cÒﻪ ?`æÓ`Ðw*Qx¢t…Ye¡¼²ÂÄ¿ÖÏn¾¨Uä’¾´ªžÌþÈõ0«1m‚ž<¬ÅÈLŒÀÅHÙ tëåaÅFýCÇ„ µžDbµ€´z¯´"„c÷t:GõZÄà ¼IbÏ.uñˆ‰`z ½˜ÿG0¦ в>å“üx&mß»Z*‰‘W]ffÆÄ ÊO…`ìT@q~¼Ø”ö‰U*E^aƒw†Uø6ŒdTåøB †\o‘+FÂŽôI±pÜK}ÑñT„Fk¬Ht´ÍØLÇ„ÄËŠxK69X,rhð‚ØC؃>x×`•¡NÒJòäIŒ« y@µÝ³çôËõó ©{RæQÌн¬g¦PÊštáé‹QHZ‚Lž!\€n[…Š„ì Œ…\^Y\̟艧Ü9N(†‡4V‰…EJKÅ­XoéìŠm¤Hd/v.À8_j·´J¶wo,IzS CQÏŸšÜ€lÿ| æœ ¹†gN & ×&1»8ù!š#DtQ4-?ñS´ E~ÛÐIè·¥0|}pZÀï·A™qÅdEä5%n.3‚R ;c#ĉ0ûÅÐù*‚Šz¹­‹ Ó /‹°ÆoÀi}ÌŽÐüç-´Dx'çd{÷IüB/ô‚7 }Nzçăh€=ðƒt:$}úTtç¨Ãk‡yÕºˆ€?)¶iR»_üz"máåèfȃ-–fäƒÑÏŘÅÔ~Š³Ç„b0ÆÇˆ…d”´Íׇdaì|´lw.Ütæoÿ¬âæ‚7—óbcgFDðq„ ÀZhº¶.Å5~:‘‹É·V R‰vµy=»09˱c"B„»:mô‘'û Eyš:š  &a›Ã[="^D¥oƒü”ôvÁÜÍÈÈO`]LáãGÆ´<ÌÃ|Úâ[ŸGN”zL¸”ù¿”±´Ìq:¶c‡~èo¬Ð=Ñ×b'êk@´s§‹à·„| ù‡ïŸÀþ5ŒàiAÃ#þya‚Ÿ &$r”ذ€‰!ãyü(‘ÁÉž<¥ì`‹A‡2'Ö¤h¢ƒÅœ =T¬yÒÅüâ©4z!> ÿ,P0ôaBFô¦þ³gV{1NÌÓ`ïÿC†ö4œX²¤¡Œ-¹÷ïÞ[‰oßrø'¯Å(ÿè@Ä`AÄ?6<Èð`à“°%ZìÙÐD< ‹þ+ZR¬ïÁUÊô$ûŸ­ä'mÑ4ÊÑäÏ™*MhÔøÏº‡ÛãyèÍ1^ïQ ñýˆ`H‡Œþ±·g5ëTù]¯æûðž^Ù¶ÿ4¨ýgÖ-¹ì²«!ï¢'„|Œ°“ôùà£õé 1Dþ2̰AŒ1Í&k!—#ѱ†~i¨Å&tŠüL+"µˆ6ˆ )×È‚ BHÿ¢‡H©&޼27è>úm¤"’©ƒ”ZBN%O”[rº*OrΨ۶“ˆ"‹¸ j£ž<ª¡˜Z=õ¬’Š‘¬º¯¡¬èñŠ‘Äzo­%Nø? þi+À¸ P"úÌg°$øBF'dôŸ\ø’(CÛ0C¿ÛT³† »ì2Î>J‘豊´D¸!5‡Z«q ‰bm¶ ¬Hz“H¬¢ˆã©ƒ&;xÊã>¹æ”ÅJšŒ”#—ºá)¨°ú'ª®Šó=Fæ9ázÀŽ´oÍ2æ„þü4« Aï1P®BçI°/ ¤ðQ sô£Á K)ýËNÃŒÿ²Hûe7U´Œ4 JµV#Ø`©Y2hƒâq¡,UЇ—ßŽŠ‡¤Àš4J[¤”Èeål™òd%b–Ù£LÊù#œÆ‹-§Ôcd=ªÚ{R9¹:![{ô] ÝÎêO…?›@KPO’ÇPD”ÑE?økì(\ðK³°!Kf›`Î Þ4\ðL•Rô+2  pB-}FXÕˆX#cÄA^È ‘‹‡¢îtÛ7ýhe›e“ò¸˜U’yf˜¡ôZ˜Š‘j?ˆö¨ÒV«¬Ì%í*¤é¡ܳöì/¿³–h7k£ôWÁ|½Ð/ä'ü@ÔÓnû$¸•›ÿîMÿ±Û3ÅRt¬Úhƒ¬ÒY¡â†W9Œê2:áÀ;yW£\&ô㌕™óù—£ÿ¨œñ)¯è©„¦r*m[¯›]Óæ³H -jñ ~'¨Àt%|Ñؼæ5H™yú: ÀÖ¦·YÊ_ƒÉG.òáD¹`0.Á/V ŠüƒùhÃd4ІÑЃ«*\D,`#ĽæcGäQ²4ÉÝæ}¸* t´Ó”h®eÉÚßQôǿѕÉÔª@zâã­´Ç*ٚǵf75n+?àúî$¶®ýÄ%^*‘Çôâ´¾|`Q‹BŒÙÐöA¶mC "a"1„ÂþÂ02ÿ¼á ‹P~ìpOÿhéìQ€T,5KB\ƒ8%1d°AÍDdòÄ)Š 9)ã‰è°èÅ(y.9ùc™-1§,4g2‚žô¦$&3ŠX¢ÓšÄd—¼dè-óÇË+Ñ,94)S8À óX¦¶Úc.yHDâZf&÷t–ÿC?W« ÿAŸÊE\ Á^øò (È^ˆ2žÿƒÐiB¦mCŠiç ’·¨Â+ðDl¨7ăMàOeÖb~aˆ åRF‰¾ÙÆ¡Òñ€ Œ¤+“ä¦#µiˆËÑú5įÿè(ÌîçÑ›ù’fa,¦Qïã-÷¸QŽzÉÊÜȵ—.s1m5t–¤«,¾OB€†4k‹‚*@)° e˜bÛl‘H‰¼“ª[%¨òåPfsž`Ø&‘Âs’ÿXÁTQ„ßÚŸ"p=–5ãÒCÉ%ß„ ê8„‚숳aâI¶¤$ß´¯#×ÉvŽSËï ÖsƒÝëwùË“´Å ~æ!;øbv²å× .Ûý–ÊÙÔ?¯&·(0\ë#8—ºA÷+Q˜†ÆüZø0÷¬aÞR$Ü&ôÓO=l‘i–{ƒÂ‰RZ)žÕAUÂ/Áöz1> p$RÌ-‰ ½±è¶¨¿ÀªÌ¼3‰ôò4b½-•,#˜Ì‚®ÌCM*U)¸ð+ ¨ÔÔ™´iClšÇ{¸¥@=•õfõRÔâí ×N…*¥¦ÿÂs„Ï«°=E —2=¬Åpƒ.`F 9¢úx+Ú˜é$#à^u†AWdK€­Ù£m)^qOIщ4Í^‚›à$)@®Àzï“Lö,3¨òpc NJšö‚‹k'‰ó5U½ÇšžE.­0·.½dPAzj"ܯ†P !½þˆgìv˜wêm.lAøI\M:Á¬"hÕ[³…š/VÕÙI`ã`‡$Eºnüd‚,˜LÉÆ£›ËtLîâ,KtÁ –•~p Ì»±zù§·‚êi7¶ÎýÏ3?e+Kmëû•ãe—<Þex!Xm> q) Qê0È“*`føÿP†"(‚>T V8÷PÙöÐjW±–#„­ åC4FÝ%¯(ŽH\ܬ+ý»…ÝëËŒŽô^JzI4ë±DšŽi5ÍI>ÞºKP?M9¹q¦LÞ,ŸÖ…–ÜíÑšn1í«yÿÒ¸ ¸›Z¾‚+àe¿D5`ëDçÛmÛ¯ÝÄ"ȇ±›ÐÃáöåö8ÍJQ† ñ)~JÒ<Þ"×Ix¸-œž©ÛŠ5ã%˺(‘ΑnYùýKF/«Ò›´*`¯+N€ä¾åêìaÜhNÊ¢¦pëV ‚>â÷à-°F쌂õºBµ"NÚnCBPCžj.Ä^rA….d…Vðzÿv#¬:Œ-Æ |è!ÁRÃÎR£5˜bü$"cÀï$<6âjd|eòz ÀÃdÚÏŠ~N°žpÑ>"ÝZæ%ÚJ*gIpÂ#þ,X[Fm™ kJàêîãæÄ¥pë6k ^êöÚkîÌN"p²ì³02hlRyéƒÌ& "%œæ¢ %2¤æÍv¨OP.F FVe(A”Ôç$Hiü\Î!P£æŽ"I¼­(’Ð’p4dŒ9íŠ< —vìeø§ ' ¤ú¯J‚÷mÔX ¾Ðÿá‰f=°Â\çÈ,HOôDjäâ]æÐ‚.pßå$èâ.îvÿì^4È^ãxÈIX(A¢à¢À Ü„4œ 4ò3ÞâØþ„2bJð& "쌠ZÎ|~pæ^ŽæÌod$Â~#Š’ a,J«¯èÇÑÄíÆd1éôà醦¾PMöÐwq™&,¦b$á2é²îÁà¤fà¢w¯!^ áÎŽÑÎU+ƒ$%Àfƒäø"¢ ÊšN"?Ú¥ HÎvÈH£ B`ð*ñr0Úhcñ– /­¨I.‚:¢Wrn tT&¼ˆþv, ÷ŠIò sp¢'ÌÓ& uN…™p÷$ß– ³Î- ./ã%K’.æ.ÿ¬¬Y’áâ³–ìvöBìCóA% ÞÃ#æv(£è¡ N ]X §§6ÉTN)o`C !8ºh…ñbÃÒ6Ê¡ ¯ÐèÊýpCƸòsìï ù‡è–ÃèliJ¬Ð(~àžB#±®½à+¨.2ßôm#ÑpÉXM^­$)P$ugM²{JPò;©ÖxJHî0sD=°±<ÿévðKZà2ß(ãâÍØÂáQ4™î,5eÅê±f>éü&"~ <*yå Q¸~G¬v"öUn §K}~õ#¤ÒJÿýpåæl“ +":¼²¯RMÝ´neC&ÿ–ENóÏǶõ g¢[i"ŒÒd½Äö>²ä !@Ñp}CàD!èÊ‚öìb âÌ,äð#4×^Ïn ôõ¬¡Âañâ_Ãe\9@s3(ó£ bê+ €,€çø(ø"˜UfDl³´ÝxKì“´M64FC ¡6“#%€N‹äþø–&®wI–n[yf Ó«˜ÒC=öTê˜ÎU"æ¥M²ngí+“æÕšâÂ.º"bƵ~%ÂãE%ó7ЧX%-N•g[@éнç`ÃØÚ"(˸!Pù#Ð8‚ÕŠiÂ÷˜¨5U}c$TöÅ $ÜÍþˆå(2êÿ©õ…¡EÒp‚B¹õƒmlȑ㋇!d"éa|÷„’1+U 5“ö_t³âL’^˜8FŠ¥˜ýw >«Ô–@‹ç¢`%3-ÃOìDv¥ÆŒ‚™òbzW"¤íWÕg íGFY­@™•#  Ç™ÿ–9Ö4zÑ­Jš{oÉR®—C{­N±»ÿ¹MÆ$¢uîÍõÞ áH¿d¡1^ŒÄòÃØ‚¶:_Ù§>âžuù#ö¾þÁd@ÀIg öwŒ’\%l[­"·Ãš!ºÒšU4vt”×m íq£ÂƒPþú*¹ëÏdï8CŠÒ¦c EÏBÍòœ"»¡Â[º›Q×½\çŸ>âõfü×e ö±c*¦’x.Xí÷4W.‚ܾa¿b¢a¬t9tàz`i¹ Ê`[¶i[ḞÊü#`c¢S}tØvÂqÃcã¡`m½ôfVÑ~RÍn1Ï iFј…[½-†··ºb˜ˆ+VÜɆQObo2ÿæå* kš–ÌwÐÎÊŠ ý]IRµó]³Ó""ý@ÈÃÁaasùŒ!8F†Ëy÷(°ÜŠ>é?·äx ”@5­%Ogº-c"&HøJÝvÉ eÄQØÝK Ï*¾‘!€hÆér Ÿs´l¾ÆEfgÉBë;·Sb"{\Uò.î0kLÜ©šL™¨!Ý¡w"–@«O‚«[åÔC&~»GR½À—’F`ûýŽÕ:Ö¢Yi}ãIZbèFØÂå÷W ³°Û¢#~*>»eö !u†&ëî.w¥öb\þ \òÕôD%Å2Ëò`ÿWÍ-’3:}jÀb>•"öµæo~tfûž€çá]¡Ó¸UŒ>Ú"‚‰(š6(ø6à“"¢KÌ™7ÌGÆysVÑ×kiÍufSúBÛ::‚¬Îç\Cª%Ôàš,“¤]íØwÿËÆß´ÚûÔÖŒ‰ÿ¡a•zÜ‘_ñG'6z~—åÝÒÚ«'ßèƒw¢­ˆJ„"ÖV"FÃNNÂÔ£­A›°»‚®ºqâÝæ4¯ è"Ðÿ†€¯?À0nCB‡>Ì›wBž¼ÿN8ü×bž½ö† GÏaF†-–0ü×äÞ½&ÿ4ÐSQrIÈå-YârÉ=ÿþÐÑïŸ5{2Ìù±OŸ=Xû`(ÑÞrªÔg´œ@,ذàÖW#ü[À미þ`¸á†#:|ŒW€a¼ñ Ô­KŠ »ÿøöœKÔí?OKØ*Üa-CÁ=öÀrd†&<˜A×åxš}Bù(!ôCÿ(”F$z`ˆy,Þû'ï‹ÿèÍ£Çè£={çihAۣǑ÷–œ0¦¢â •Âÿ ‡ÙP$š0rî\ú³ç·¨=ôúO÷ r €Š}꿪W{nø8ë?ùhÁúTË–a¸ øÿ\€]Pì7 `A&ÙGŒa×ÓZ¶öbÿ$Æ`ÿ È`†rÑÅh0Dˆ">}0Á<®‰ä Ýf=ÿ¨p[E9Ô„K1‰´„1%1ôÒ?Ä‘$l2ÍdN:÷xÿDÃÍxÔ8ÉÐLNùO5è-¥Þ Y1tÕ—Ð&Ve…ù 0€_OûõôÙ[~v×?o~„f Ý@¡[u}j8Y‚y` ¡p8„!† rƒi"JàhjŒ$D‹ Å6Ï?2t[ ôðÖÐ uÄœG'hÀ15áQ‘FÞ³ÿpPÝ’ RÉPêxNM “ÿPi¬zìm5ßWÍžÕ}eiß 7ä·_\vjû_€ÚÊõíÿ?@ÖÁ‚Fhî ‚ù¹Ö z€¼ðþ9™¢„>ÊP+‘†ˆj¡ ”bk±él9ÔBCH$cFÀ-'ª i@qC2…Tœs@Þ“Ä0Ž  ’×a¼2èMQ’ìS²TýàIšDVÌ]Y5ß ï1$!f؃s…ËVg N¨çbö¾›¼Fs¶4CqbGÚ?ú–"C¨UðÏ!@P LG0 üRlñfÒÁM,wI«:wä‘ËÀŒ’=9rÈÆ«_6ÝìsrxÑ °r†È¦GUöùd•|`…ùÞ™ƒ}uíµÿŒÀÏGqÆõÙœÞÚuç—Á«tºmñ¹®ÿÒQç‰àæsº4ÑDQ o+`]¢!~xA×<ððÂÅ¿Ä?%ÌSBB.iÄ›mÆê,¯€å=ö£ÙH}Ò¹¸L“öHN67ä“sBf ,; ¯rA&iü`£ᘨ»øÇ[}©È4éx»¨B':s2¤ÿPgi‡€¦¾€5yÞª\˜ÏâÈcYýþ†V†lõ}A15è@%p¨U‰¼7µäÖ§=Ðz–}žH”  ö nuU@]UdhÙê ê ³ÿ<µŽ¥HlL„¨z-…?=Å OuÙ—ÐÍ)/ÿæ?¤Ë5 ‚ˆ³è­ÏÙßtR äã‚ åÉÆ%‰l!ÝFÛ$"'Ba7|H‡ídhX ¹-v¾CM¶¸«üGZÁÍèN›oí ´v†•k­å#@Ä?:G]Ý0¢"1ø#¦©ÌjK€‹ñÀJÛÒ6CtËwÅx™.%Np{¯, ©«¾Ú'"@ˆNÏ‚´æ-:ApNŸ–ÀC@æ„°&0YF–#Û—„„!¹1}Ü´J´'Þ‰Ùúl´b(^€ã¬Øâféì#ÕúÈ*ð{Lÿ ¾ŒØt}7]†ä÷¤Ò•iÒŒ|@ñn®\¬&f¼ÆÅ(g(.¸ š–ëâÈ1[ÕõöèAÓV1ÍØI3šK[ÚX@aœLç%ø&8AZÉ$sâá?÷ Zz’±à$o,Ô'kí‰zD±ÜÝ •îÁÎ dæ“Q3bó†@n>Å{ÿº"Ô¥n\»9É@†ŽIšY™quÉl&‡ä’åmÝ’NP¨8OûcxT  ¹tiPŒâs¦â©PšA‹ævÍ… Bk\„™*&*ÁPªípÄIÈI¡ËzÖ|ÔƒfEÃ`Fßà¸öyQwW`ÿ1`QJPOÙÛÞ>ÖÍ}ûÃÀ™*V¦lù%Ò’9‚(jhp ­u-µ©Õ 0s±¬~~íñ Í%/¹½hvlt²S¦i3XpÈ…ˆ„V¨òHG`µ’5äD<9·­X‘Ðqç¼Ü›Ì Ò¯8ÈÉ9®-¾ÖÔs¶áªgëÿ‘OÁ™!;fN³¨ £u áNÃLà ;GŽŸô¤~æ·öä+h\«¦ók¡‚ ¡õ;vjá“4›SÍê$üx„Ö ò5Åq-D˜óa%ÛpTPv nï–P~ö ˆ?BQt—æŠÖšÜ+±xEÁYÇz`ÿðÿ€ÿ­§P…ì×e…¼"ÿ"H•9”Fiøa->!†9ÀÀhFŒ>ñЀ®ç€h¸†]'œV_ý‘_z¤˜ÑX7Öq8ö0šæiÈ1@h;–i·§5ÿðkðk&Ä øÖgfý5ZÈ&xëôAlÆ9ȃB¢OóD"Eøtà àIQa  L@ s=z“aÖ€sÜ` àÀaº…¦ø$ØV"ŒæVsfD]%p@F°9“ a>a€ ˆP†‘uÍó)åØuoQ§qZ¤|ðF~è‡Ïèc¹Ñc Ñ<ÑcµGv¢Ž]Lj Ñwòȕڷÿ¡ÕN¦¤Õ}8O<؃Í1 ±`>KS yÀ*oÓÀÑzSy>¡—ò&‚ô+u3¦2öS ‘.)û𘠓2)“²€d¨“°ñ,à"qkx OÉ$¨WÛÒo£ÉŽ]÷k¹ANÙkØ™ŠØk5–˜Š†ÿšKá•=áwbYfÄ&l‘Ø}¦Ný˜x´âƒ"1÷À5!kà¢@±:ð4A$àñOP¤OD’Ž0(0 PŠÿp (á‡!C ý¢Î÷ý‚ž4&R_7ÀŸ’¹0™!•9“=qŒÌ©zòP6=!·”¹qŽUYŽå(#óöqÆˆÍØ±¹™…ê¿ö…Œ°•ʃuX7¡ÙG¡Ê›¾9–÷ˆíd–t‰/ ¢=èƒGâƒBbm¶¢ÚÂÑ×ã*Õ+"‘£ÉDÂ8Šÿ£Ì‰£{‹‡«­R`q%ÑБãIñ¥„)cbê™G`€ùòÙ0™òŸ”É3YŸ—¢™©™.‚†R¹ŸÍó™A®>ù€X÷€RÉ™,)¨ªÇG@¨­ù ŠH·@šz«‡Œ7YT0(–J©2ÈNöX°ƒ×¦UApH;x"ñ°È+=AÖ&[>A$K0¤@"¯*I·:«5q+%«O'J $ÿ` >¢(ÓBõTO cŒˆ""€l‚E—R€f­=Q“ÁÈ EûmÊ ˆŒÊØzàj¨=Q+±Y6U»™ò*¯²“ŒJÿ÷ª¯k¸z è¬ øˆ”ú¯¢%•ª¡›¥lf©°Äã !§<±K+( §>¡± ‘=v)C²¤j¢%Ë±Š¸"1ª+±O,ë²£ÆÀ*~«ªÆQ@+ ¹ëfcÁÔÚê5Y“×j­¥›ðùÇ86¶rÎÚµ ¡x°û°šI·Të´ñê"[[¨º bØ“Œê¨Êh€ Ø€‘Xlõxd¹N˜º¡¥UÀ°ðÄ™œÙº‹Çº#á–¢J~„«2Ä*xé½VÅ.I²y+µú5у{6«æK±-[AØ*®"C¡™«;VáM¿ö)=‘¢[´B›!£‹Jû—Éÿ€ §'«zÕÛzÕû°!Êz;Ùµe˜»ñêÌø»Ø€è¯Ú¦¡ÛÌK— ›†aó°“)ªû¤·Û›0ß»Mð6«êª@¾’T¾p«K«¹Š¿S±57C!€¹Œ¶áU\cQŸÕJŦ+ÅòY­×š!þ:ÁN»´á¯7鬤ªOS »¡µY ¯é›G “ï©À¬–Dñ›èD°¥Å}Æ»¡ P—8<'½«76ÓA/²¶R±,‹—( +!¸ãk¸Ù[¾íK«ºZ$kmD"Ä*ë¾6<'à‡!‚;(V›=ñÁÙJºÀ(­¨lº¥[´ÃXŸÆhÿ“e(†c<Ábl+ûºqÁk¼µÌ¨Œ€ÇŒÞZÇ<°vœ©¤¥Y˜Z°cÙ}—h~AÊãÆ3AȤ«2Á°Ò#Õ‘4Îtc:Ú¯Ñ¾í «{¦Î'««'Êœî\±C+' Ä˜‹;rŸ{i/ kŒœɘŒ,¬zLÁé,†¯QË„ºÆ*œ»øžpºÂ¼´j¦Ç0(‰Ê‹Ç†°ÂÙÇÓœ<€ O9IÈÓñ©®Ò>B±é¼O-`—‹É;,Éòœ¸¬»ÎÙkÈ{ë–¯¡É AÀG¤lAˆðkí90 5Øú¹©ÜÊjº 8Ñ=0Ýz,ìºÌœ´¼ÿ ®[{ËÂüž§;Ð9ðb¨Ñû¯_Yriœo»¼ݼÑ<Íuý'\<&)›h*&ZUÓ±Û 6ŠÓ=Ìö‚¸M«údؤ ‹}²íëÎ=Ýóϸ£N¤Ü(US†ý¼3¹ÊDË<´§K796b(ƧL­K±‰»hìeMÖµeø›¹-rK1‰Ë;xzÜ_ϼfÏû¼ÿ ÒA~iØ©÷°- «ólÄ‚ý6 S¸9ê˜KñÃ#‹¾#Ë ä§Ý$냚lÃ!ÀGV“fƒä(£öÙNÍÔ{Ù¦£ë’R|“o꺸lʲÁX˼ì´p<ÐcMÖ ˜Ì"gÿàÁ}øx©È†°•¨Ý÷},á}ü#ôÇ/°ƒ±Qª„’±¼½¯*—ÜÎß¾òÓŠ­O!ÁγzÏ–}ç½YD•²¨ÄÌ •Y™MÅó©! Ðä>ñÆ <ƬíòœŸòÛ§ýžMnÛ¦j{ཀྵ¼ÀI KZÌ áõá^`m†BÇÉÀ>!âê y’$$$KÓˆ-²ê|+ÍØÂÎÙÛô <ÐGèfN;éÙî-Úó)“Fà’5ÙÊSü°|èH+ä®›™e¨·KA˽ÜŠрÃlÚ¶½€¾‰àjË•–ŠÇÍ\°qÍÛ ®N.á¾T‡„$"~ÿ¸‘ŒÉ!° Éå{«¬{¸»ŠÝd¾·”|«°råMBCÀåƒçVî¬G¼¨ÛÊIûÞ4¹è@>ߟ+2yí>nÚŽþ÷9Æ_ì€KÁ»K¨;‰Œ§{îHÖAž¶m ÎÌÌlêš…lÖÛáÁåQBn½H~¸)ÞÈ›¢è{ä>˜Ø®Š£pþØ ßÝ#!óp6<úøAWC°¨6¡Ô7nÀÑZŒ“ùÜNŒì¾èñ™!©}Ð»Ì ãîúm€e€G@Ûë>ÇÀ `òÂf)œÍ›¼Ÿ°=±T ðé<ÖcÃÎáÉoÞ˜œØˆ[²°Îœ”ÜØDÀg×|ÿBpÞýETƒà×z­ÔÿÛÞÏn´¢ÛÔP=òEËãFk“+¯ßØ¡µ‰ÁP«Úýš€È(Ì äüé’jšeZÆ«¼dùÛ¥Nï½½ïùÎïˮ;%K© + ÓM¿'«ØY«9jðƒûÕ>ä!0æµrgZàĈnl!€iªÅ¯ãñ‰è9­ÃèûÖ:Û|ßÁÛiœòMk¦ÈHó4oò-å¼-‰Ñ¯øWžløŽ8˜“Ò1òL$ÓcÃI¢oØšL²àæ±îæ 1ߤ¾÷Ðå­Ä¶œy¢ÊÊ#øøQdH›¤ bø‡ZcŽ“.Z„ùoèN‚Èû‡0Û¸‰:E ¨ì††•R<žô8ÅV®ÈA€Fo¶0†ûõ±]»r «U­YðrÝ’‡Û®Mÿ·/èñ0dˆàõ† –üBÑŸ/6di#ºì² Ô,Á‡òsH L #É:úÈ#BûG4“Tr‰ÃÔ*ú°%‚|³É—œ|ù'' rºèÔ 0 5¨„zrªÏÚ–Z.8›†pƒ  ›®±šX⟔̮I%Ãk‚¹Äbë;‚šx‹<¶Ô’.ôpKžö‚ ’*,°¢›/ ‚‚„¬ê³ s¬Àìl >7û“"Ð$ ©£ -¤h1ar¥“^ŠíŸt™8à€Jk¥–ø¯Ó+Mÿ± E£Œ[5?BÈ餼­¶ûGÿ ZØײÚª+·°dKʹâ’­õÄàx(„V˜j(Íê9®¦V›³ªZ»s27"p\Í—† ¥“±GU©¿pp‚v _Hºƒ xÀÓ‹jùg VDæSùN)§ ’¬žª¢»ªV%[ § ^ÛøÇc»j¡‰’ãš²JbÅ3ö/“uYY³4«âkeÚVfªïÚû–›öŸ©P[85‹^AŠ¢èO§\023ÜÈ´†DíCÆXãšj˜^¢Õ}ssxÄvÚ1E€²¶Zvà‚?ýÖR`ð­)jÑEì!«[RW ¢‡žÿÚ gcŸ\Ùeó¼ÓøžêÐ[o=¹è2é ^h¾!~"î¨ù„F.è`UíˆTWÝÈTÉÀsÃÝ]Û½‰BvϺ¢ªV: vGU¢·øIurE|ocÞ§³ÕNqƉÆÀàS³Ûj%VŽAW^XyZXòŸŽuÈ Ûð¸¡%±äÀr­Æ*y,·¶j™"»fÖ|«# ÏÎþamÝdU…Ý@(àŠ#`છšŸ#™¨Mp#²Lƒ6à …P5W+î Eµ©1*%(a̓F"¤üã_8rðVªÚhÊ6ȰͦF!7|\– R„è”å4„MB çæÿáz8!LìX2*º/Jp‰ŸŒ…$²Œ‹1kˆ]P¼Z4IèjB¢´i&ojE àÀÕTw®Ô2áάDO¶óÐì@ÔÀ†”€ ,°PKò(ßùéQüÐÄgdÃ’(M¢LiÒ¡K— *”ó¥Ã ø6èÜàɃ@=õÐAhÑ¡HÚ-=£öäIÕO©>_¼_ °'–¬Ù±cí©UÞ†oOÄ{¢®Ý»uYœÐ»÷DB‚ fXëaá9"^¬ñ‡ÆÇŽ#[4ücÔFÈ/^Ô¨9²Æ‘CƒV¹’$ˆBlt‰‹µÍÔøpÁƹ“'ƒÛ?‡%jÔDß¾{/í`‹8Ö¨U­*ï‰è®üÄ–§ö,Yö°g·ƒmŒ¹pïÆÿЫü]ò'J° x”û÷ïŒY¸¡eÐ)æß¿qbfŽøä7‘H (D#¥´AJ ¶T’K°¹ÖZl6ÔÚ…øD˜Ó†µÙ”R¼ý¶TˆÁ”SÇ)WUUPe5ÂVñ|U=ÔE]vi¡¥Vw*ôøÖ[ƘW×}ñUä‘ÕW˜@õ½Ø|O> >©P¦ßbýI™eüYVEh —Ž”`‚ êÄ!j6U覅®µ9ál9锕O&òf”À‰(œoÄ—âŠ*F•VÏuEã¢7êH£vÚq×]xtá%×1`jzä¹çCPz*ª`KÒô¥e\V”˜–ù­Ú*cZ†ÿ&Q˜ytæ%ý€“´åÄ+¯k¦¡„öUˆ!†mvÈ\Pº âŸ&6eKŠË]u•¡ˆrã¢×ݨB<Øéˆ]“Ê5^F²é^sqêW±1µª¨£”Z/¼õ!(ë•’5ÆŸgi„ª˜Wd+D¹æš&¯jîì†";¡@®6gl©µÖ° Üö¡žK•H”ŸEh‹ÈšsYu0‚PñÌHÝÌÕ«V㮕\ßi Þêm)Ðã±»Þ”Q6dïAñz:“Ò U¹åGÿú[ðD7d­õ HtÃÕm «®,Áew¸SjkgÈ&œÆ:t¬Ü±m0áMÊÈ|ÿHâp'>EíT…úÔ²Ë^m[£u:¢5.<ËeÌ D¹n^u½é»ÕÇä§òÆÇPMVôŸ£Ž? qƒëHŒ€ÄìHP`ˆh½@Ö|ýC+Y€+DbopvÇ7ÜÖ1Éß°Àó:”Ú°qÞçk´í„íÇyF»'àÄù0­TT*Us‰zÅ-Z«€3Îk‘ûã]Aiÿº•WŽ×Ó41í¿èÅ’IÔ20‰x‰Uª«ˆí QC0°¬@*ÀF½Ëà z×µâ=¯c#HÞsF8Âxhë9¸A›N„À ÝM6Öƒ²(4!ë©m‡Ñ÷ø&”5…8(KYµÿ”Ó"½Œ+ YYØç¾&Ž;ôðÏ&——û±@–ºË§²4zÑK>SÒh¾4/P@¡Ý+HÁUàpÌÇò!G "⎈¸îž§5>‡ÑIX 3~x`+`€šÜÆÈe¬Moz›ÚX–›fõíY»a ±r­òŽ’.Ó–ɾ›¹o;ÛñŽæá³sÉ%hvÁ”,]Y´Ï P&KršÓ¹†ÑKŸILb>S‘ÙÝ`ü@>Pf:3ö€fòAA~ "„ÇäÇsB™Dgò¨:؉QŒ "ìm,B I·¹Én ™dsx¢<}è'•#ÿ„©\‹9?9¢úFÙ>A!~`K\&7¹üeª]xqå `¯)ÍJ]Í‘*&2üRD²† ‚ó;1`„Z¢èÌ›¥E-t¤àø¡– t ‚Oì#ñî8ó+Pj<à‰~úmlŠ$¯‡½Ú´’HÑ=‰b£0ÅEß>{ÒÏå.Q]!(ÇrЗ>n~´œ%#J—Õ,M>_Dˆ-!’/*}4V^£€¿²³ïœ \c¡GuÄöIÇ¥`©Nb0ï°ôŒM)Uú@â ÐÀPq› Lžss' 1v“:é‡?Ù›/9UMæ3eUéj?ÿ‰§#ÿ*®qÖ)ë)šD1rY ÚCé"¤ylô¢«±eMFU“—ÈLÜ×nð@µ€k[ãÒŽ 3Ôƒ–,12AXÄÈÅ2‚òÐKcSÊz0bî}¯=*{GhÎÃöà‡F Ï>r©rZjöª²¼Ý$e‡¶*SPtœZ [õ@X'ø­A2Î:àÜ=ZÙJYfÑ.Œ]%cy©\·0¹ iÒD3Æé:ðILbÌbÔ£ÑȲÙÑ) PXÇÃU…X¢CAò¸Gz‘|‚ƺ—ŒÝé*€ˆÜ€™ùi>FPÔº­ó¢¤ÆL«H¨4%ªh®'Ÿ’”§‘ÿpýœ­W[öÇ3ÊLì—X(*ô­$.åÌcŸ±²ÉôÜFK…\æ°sb ©/§‹„ 0B¦êc [(wÅ{”ç-Q¤Ç ¿"N ›L¼_Q’å± µz ¬nr ÛÞZÛÃYCÄ| IÓþ¶ðm¦ÛõL•y¢Ù’~ºç‚µJ8ÚÊy{/ +·ÂÂ8܂ӷ K A,hð4VÄHÛ¢£¥$îE7·—uñJP‚0â98Ë «°„{Ø›ö–G“UJG±Äƒœ?þ79ÅKNšŠ‡Ó­Žu]Dl•2"¹Û o {0@ŸmÍ#Cû&ëÝMY‡;vpþÖC©f•ÁRÿ™­öVæ±PŠsQ6š )/üÄøe»ÛÜÏ*E<ã–û^ð\Ÿvn‹îËv€€zôRN3™§,`Á=Žp|É!3¥– £»Ý ”Y©‚yü9–â™u[ðŒˆç­ ÊÈÇZ(±`¿{¦µŠ±£šÉ‘#[“ÌþdW‹êÕæ¸LÚ3› n÷l– «}Ä6W·YâÆDÑÈí{25›ü ˜#à¨Ììl¸¡,€Ànp¶ ÙÞ¨zä1H@Xcð¾»kù6+{ŽvÊ¿Éë}Û-°»kŽÀ¿él¤ G;C×DäÛß/ÉwiÝæ8ƒÂÿƒYöÃC"æ5b¼µ·“ÐG>²²~KÏË>âg´=ñ±ÏæÏ°Ï·bÝ•Õ<ü Ç7†`6:qçeoG`u@/0ú rÔ[PÐ{¼§AÅ~³Öd ×d>C9­v|r!XSÖvÏ#" HJ¥q1`ÕW'yW6ÙwlÍâ'À12€·U„ÇUsfDÑ”g3²g†Õx©ÄGyLØJp1|òÇX›FLŠVÄ$ˆÐsó`ú Mà3´W ` 'J7uV{ð€Àà@pÔ[h u•Y~Fw1v¡oCR95_ù°»#8ôYoƒ vC}£ÿ%'Ÿ…}PU}RU8X2KñPà¸àƒ×Òr‡$HJDy¶c¨È[¦'?qÑŠ!&?ÂJô0û×EOóV¡$“æ5¢G|š54ð5#0è{UWuH 0€¸5f K`‡5Ö#Pæ[}6kæ‡u¡oâX9ôGü°ûeN¿¶qvOÉ¢,–f¼1rÁQàxÖUãçÅñFjŒb#;v„7cs Õ~oÁ3;be÷#‘¥4OR Q*©.Áh6<ðˆÐná±î310Œ7`Œò@u÷–Œnø€ WC€;ÀR¾wzè#¿ÿe‚µ“³_àˆLvåq" ŠÄNÂ⎎X=‚¦U6-£}HaköT¥ƒÞ[^õlO#3y6^\—gd•a*j<ómOx–f×–¾Ëub/áF—E×b†pdïu¼#Ð0%@uI¦ŒË¸’.é’ "@ú Ra8‚€æ3gÙ¡¦„:ið%”‡†dJvuACÉ>à_Âf/¨”ONµ{G‰˜H˜¼P¶àûäIC•é“XãE#dÉu0g–Ù¨v•IyPe å–Æ5tÌ…bvÉKºè0mšmÑ#&ä #'™’÷ö€†ÿÉè’³Çúà˜XŒ×hÝñ#°¢)šíUvç“Áø™JæöÀYž%}ê`uÇNl"‰ ¦}Â'!s•#sÌ[ H[Z1Ф3Š'A)§ˆ„ØÁ#±È3Êive7¢o‰ŒÆ„‘‹·Áƒ­PW.ØaÝY˜Vg˜+¹£äù€/ ­°ç”“Yp‘Yš†mÉéí…|Mk°¶jò@FùŸLew1´šÄÆñhƒS)"õˆ•Å!><¨…—-â4HjúD^ÓÁ¡Ù%¢“òxí÷[QädÊ•yY…* *L£Q?—9÷ Rà#10u)‰oäÿÙ£nè’;z€AºæDr–Fê#f·J¾å“™9ŸCù~X˜ú_ˆPT¦éHŒôeClS¨Å,»Q‰$SU–h‰@‘UúÔlVa'„÷O¢8S2"#ƒÔ¦Цbi¼EäR™Û˜Yf'ŸØ1@15—A'aÖ)£—VY‰E#ñpá¹£,™®;š¨ÇL>“Pg‰m5fz³¶s;Ys´¯óÐö6 @ w„NŠH=¯7w“1â7`Oå¥ ¦z(:x› Æ«?x¶Õ¾y¬£Æ±j:#ƒum56)óº©J¨„mÑò±§ÎÙ§uéÈàÙ­?£Wÿ7eå5)4Voب誒Ž*ÑÈÐب“6–aù*š™M_¨t„{0ò`B °V±°V:,ÛŽO •Zq ÎB«W¹`›güÔ«sÆ/ãàűÄlÊu‹SsP9•9¢p‘“,eôA…Kƒ‘ð2 1ë4‚‚J%PÔ”îG®™r®nè¨âù³ P뙥¬žû¹-õLÖtGüÀ˜U¶wd7>à<µñ0’ô7£ÅµÚri&› ¦€'8)~{Ú"„Å:¼¥Tt¨i“E µ‡(+Xš·v,k¸¸à)‰û£G®Äçžáÿ“«£©+©£.)”ùŒI«ªØRÐMóUú0x´v#fsT×tTf¿â”ÒŽ^ë6Nõš_z«}×Cš”UäÓƒ=ÈrFä¤HjÇJ·t[·2‚¼9Ó¡Íz“ÚØP¦“p)½ÿƒb&*¸ Üš+AG £G0{ b6&N™‚®:\¹åË÷0Ð4¯MÔ[©²Í$XÑÄš«mwµ²±ºZq΃€Ò+Òó©ÉNð(ŠÇ¦ dà³I-r j»¶çSIÚ··p«Á‡u·Ž×¬';k!Œ´*n{ syQ]³­!<(1]Ãнuñ½¥iäÿ$¾K°Ã;Ü’ø&jœkci.ÏSÑMù0ºÖ´‚+T6Ñazq&.âlWl}[ P~›öøÅÀ WDÉ!g+“OHÄêÆÆkÁÇÊ )ÛH²ôj™oIÂ_„Q÷wQ& €LA0*Ã\Ø^îçgß‚¨<»Ã@+-y¢†©á¢Š\ç¦H4EÀ‰äÎ+È "@ÁЄÄ§BŸœ”K o°Ë3‰S¹fk–ƒ½`N›°¡ÀŠ(ÿ¨±lêÆçÌW ‹JÉ› ¹¼*ÀSPVkø'WQ‚–ÃC%Ã2š^ó'š"¬·âÄ”{¾ÊHž÷ Y“ÿÜ#iÑcé|ÁJ¬M£¨M ÐÎ>à?M´ÓÊÕq °”&lã6w¥Œ´¥¶qËÀ¶*ÐRD¶¬2l{©µ7Ð^¾ì¦ýRÍô8Ê;²Ê»¤:ÉB—y»ôœvc<ÀG 2¼Ÿ²6ÂgM®;S˜†io÷Po…}e¤zÎeáR€´‚ χT@ýÓñ XiAGñë®IN¨ lú¬”¢=ÿ\{ƒfW=Ð9ˆ«'²Õ<g…ãÊ.c~~¹ÆÄÊØxfÖñ³$;§ÆùxØÜ^:ÎW1aÑŒ 7È1*£â ˆk7_¹=d]aÔíòjv¤›´ÔÒÿºƒu¬¸!_‘¾!Ô¼P˜mt¤Éõkˆžešo£T°[ZÊ‚^dúm•UÙ ‚ƒ2æ£rgp›DÃ[·vK4Ç8ùžK eדnMÜ'üÑ31Èý `ŒPU÷zí†WT‚”¥Ó€DBÚdY2צmz3¤¦ñãÆkÖÓÔR‚µ‚B?æãzMÓÔÞóõ…m×µÒ§Êýü”žPÚ»Ú¿¡ß Ö®ý«¹lx`å—g3.s5“3;Ãó:)o²ŒáÍ™4omæNó€¬+p0µGІ9`¾¬¦^",ÝÇš_Õ­M$Ä#d~^‘8^AÁ1è[ëÿ[ãI¬ÞB¹è†Ùb¯ÙšMs¤Ä7°Ôþ唊ÈÏ^&ÕY±7§Ð}ÕN¾Nq(Z¹"¾êÊ€>HÁ¬xbéo Î-àݡۑ)ËRÞ—ð‘Q!=×.ñycÓæð^R£à’Gf$méXÄm¡L'þ+Ð+ð2óÌäMÞ0.ã›Î3¥ÎD½¾™L€€FP°a™Ÿ8ã3LÛÞ(G÷¼ â×ér1öMÚ Ëm•A¦I·Ð*Óšçsf‡×ư.XNÖÖõð©ÛæMÕ¡R-+tޏ¿Sʼrendå)Ãé¥^e§Rô@­;ÝÍ´ÉêÌ_Ï!†¤±Œÿ½DtË_0Ï0ïݦ'š"Øî"h ‚ÕéNš]ôL¬Bø¾ÊèÔñ¶¡nƒN¾ÚCáCú¤Oþ« a.7A·mÁãe¼ÁœÛ‰ö9ÞÍÝìÅ=i­ð5ÆS’}ü­XaÃ!ø"G–\R2>|¸0gÞ€ï±çÇž0 ÝÁÃiÔ©Mt0ᡵ‰Õ¯=t Ý´ÿ'Üž6èÆýxwèÝ <1 =ТC{ :„¸‘ßóŸ[t}:? f/°Ò;Kï.¿ÃlEᆅ›Pz„ñ82ï¢ UuÎkÚ^Œÿbˆ«ªªŠÊ«yèÒ ¬¸¾:+,·䯅¶«ð¾–§‰%îiâž 7q©(\ðƒ|òAdÆ|ؽÉ.ÛŒ2Í6³3!| ­´RC­5×\c-HÔL£[„®7Ý€.·Òò`»å”kˆ"…02h„‚Fˆ§ çÀ”Ìë:‚î9ðÄK ¥ð,‹‰‚šðY@¤xêð§ ‚"@>ÈO?ûÔ¿¼ŠŠ°T@ÿPƒ§t,®â’K Áš‡B»zêé9åP/ ›(q Lá:LDDXà1 b¤ìÆW%Ó,²Ït$­´Ù|üqHØx ²6Û–d24O„·[2n!„ìÙê „²Ž LˆKj¯½6[.»½ºïÚT)M7e²éDê”G÷äŠ>yJ@J§yuCž”Zw ˜â/A¦Mž§ *®è A®ÁkaÝ;ÕK/1}x݇ñ+EÅa€’Çr”QÆÈj¬ñÆÎ|ÓmáÐõ4 _ó•H#‘T2·ÝšäÍØœ‡³M çºê ‘š»hËn±Ýv”Múi¨1³Ì²ZÄ“ÿz\|,x³¦›&˜§žäy/O î9"^¤J°W§4”?ö8ÕTS¢–êWPº $á|P¤Ê„¾´®uCÔ«DyJ ¬.QC¬pcõ²Îb²/YG–o}f"a ÈÓj»-·ÜŒå-çžoår¢«"Ý*"åÊ “ Ü™Ö]Ù¦u‡Z[.ñ©ZÜ’jI©j—`šÉ±Ôcïvñj>¢Þª÷?ìn8%€SðÃ×P¦Øj .ST}·8ñÄëb˜áÀ2N ®G``UÈ VÅÊ3 ñMçˆ3—ÅÌ5¢[àjfC›á«X;ÓYËX‹¤Y[‰ÝCrÿ&jQËi¿Kï€W­«%˜c“ð´ÖŠü †ð l(¶øäÀzª#æõC¨Ä€²ô8åŸx/| Ú×^üÈñ#1¨B Âæ×‚ÁaQa!à"ó!— ÕeA+@ªó™W¥1s Žv3Ò|N6s\`‘L',ÔåLu¼Òã»H9ËYyˆtÂÔ­lÍfw‹$á ‡55Y 31áNaCö°O;,[¼†h½0BˆF1Š€šR¸#‚ïK_á4Ä–·àOE"D€ˆ|,L.ºÜ¢úóËõéò~\I‘Ç2W­1Fkl#ç|f$]ÑQ6DB ’"È$Üÿì‘g¼I–˜4ÈÙ%'"Ï™?r§;pi„ÝZç"©u5ðŒbx‘„‰LZ±P€`»á=„²C#|Oû!%\Hy”!²g/ ÝÔ÷RÉÊM9±.±”%ªÁ }ôm—!@Q>sK[†U´"Á ¨>~H®ršc©q„£”©Ì€é4M4C:>0X¨Ã¦Ê&ˆ,ÒtKƒPA ¹Ò¬|ðJ#¡ ©Îb-%‘\SId²€4ï’<¨Q¸¦Øi•©\«Y)7 5å-\ì(0Gºê#¤"XA_‹°‚VQR‹¢1ý'„e2“™n| ‹SÓ…NÿH ´ãÍøXÁŸæ¬›ø!‚ý2–Ë\Ê(š–I)u|MNkã‰ðô7:Û/PÓ‰Áäˆ%žmQ£r•¡i:]êRi\ÚÒ~iK ~Î -L®QÈPÃ70D òµ„v  ôaÁ<|¸=¤e¸ô`„¢ÐŠ/TW•2VîÃ3WÀu4EQè[>xŒ˜Ta×”ðA‘‹¬ŠxW.ÿÈ(?©|Üà°,Ù«j+ÆŠÆu¬E7ÍÒÙæš«ãcý+Î’ÅŠÊ€ ÎoÙŽ´ÛyŽF°ÃYî´PÏó\IÖ"pƒ℟ëòIrðÕìÉÄp å(Y ì J_t{h+e¼\è1¥r¡ { ÝêòÉ” µ.Aj"/ »JžbT8ÍLù³ÎÜæ ÇÊ‘¾9u ñx,Õõ·4¯ ï€ä6cû¨*@°H¬”Ô†D[$É¡öШ•äïµi2Éʳ€ bÅí|r8 @B)!]¨þô«‰Ë ߦ–¸ÐúÅÒ‹ÐqŠ~i]í¢Z—ÿzPMd$Ù–¼pA\òf¥—ÖŠE¥ùR6§a¶,ëÊlf×yÉ#mv› ”l“ H,¡³Yþr—Û£x6"ò²“@«ç†=1÷WÑÉ“#T”nÔBÇgtJCt¡ÍÅ"©ê[—¯E¦bKðK˜z—Ø@‘ ‚"aúÌ‚ 0‚UÑj™‰u)­,N¬aãÎGõmàè„ô@kæQ‚=k™·2à5§ÜmØ3vÊÛ|x7¿<´ %KQÕÄãY y2ô Æ}~áð܉æÓÝ Úˆn =:½W‰Ê¹1q|҉—Q_VWêײ©nu«·ŠëDFò_‹ÿÀz´`ŒÙz)¾Æ˜rnØ\—%[ºÙÜ ›d~P•õÇ6Ÿe{mk[€t6'þäÀm´(É/þPš\ÏÛfÉ$ÿ CCØ#l<—]©”ŒQpÛËÑ5Ô©žèÓ[.LԹʫ¨£¢½ê«8‚ýÛ¸¬;5#c€" »Öƒ¸X«œÎ˜Ì8™“±÷’©øB ¹ƒ™9¢;™± [Яýò¸3{ <îc›Á5:>̨•ÆŠ \;Áúú2œ’™ò„$ѯBì#§ù&c#¼!®ü“DJ¼Ï;G¦HžÊDå¡óˆ?X¥r«?#H4ú¨›‹ÂT$@Bó¿IËò!ŸÖÛ"©EâE…\€¾R…„£„ Æ`¼½­ã:b,²ÿ ä4DÃ4 Á:üHäs#Ç2>´»˜ùC !ŽŽëF>Ú²éHD{p™Ä!dŠ«Iu,ŸçI«A¹I=“¤«ÉšpCKš¿%dBÈ—~)H“Â,ÄÂ}™?~É´Bq ƒ|=‹C^dȆTµ„2ˆ¼½F¬Ã:ˆD8Ȩá[Fœ;<¾ä{ á ùR “´Æ/31û5ä»dI' ÒÁ§´ú­ÉÉçIETÅtì ›' ” CøÂœXž¸‡ú{³a8Îd›HS¨åzÅçÈLâ‚ ª@CðÂ[ÜžâJU` $32R›À±„@aˆÜ:#ó"ø"ÿz(UÉ‘ÄÉÍðH$ U¹—‘».k k¤/Ê/¾¤>Ô¶¹D¬AÌ?G,Gt¼»ÙI 1O¹úÉ©± ´ÉD„˜ËÔ¼ùØ“|a¤¥zÁ¤åÂ<Ê<ª,˜+z˜ŽÊ([ü¾ÒJdÈpÈ!£:ÙÍ«CC ÆaD8à䇸(#Y¯QH,åôȸÜªËæ3I@œ¦#³žÒ; ú/p4¹ÁÔ ´ð—r=uô¼µPÌIt‰Èã¶Íð6üÀè1·úì¼}=b±"êǽP ž` òñ­·øŽâ¨ZlÍ/„M PHÆhÈØüÊ2<µªƉ4Cÿݳˆ<5O¸h8¸PÆqK“¹CezF‹[€‘Ì8é´Fšù™ê™仸B³Ø°u«QS*̦x±ñ,ÕIA)Ìöã¶áÙD£LFè ySRxé—¯ÑOó¡ý°!*]®J-”ØR-E*RÐ0]ZÓ1íÅ";&T;5ÝÛMS35Ü<µ­#2ȺP‘ªC,¼ Tθœ)謖UÁ/›ÕØKn$³–6ƒ@ˆÏ q,Gâ’ÔIåÉx3ÏÆFÏ›…HELI»—³Ùr“N5ÚøÔž=éLyù¨ZzIL>! LûÌy0P~Ó‡.¥Õ¾úÚ†S®tÐÚ´Í^=5Ûͺ4…HaÖÛõàk‹ÿ™É‚+›Y?Åj\Qœj !‰¾zÑô/âàˆx0°šÝ!BH-LsMWÅô¼uåÉ$­á0£E„®¸+UÒêÙ þ°¡Ñ3±ýÍÂÉ—çщ€­UDÓ¯µU°åJÚ|Ðx…íŠPT Ö³µ]ÞÝÝÝ£OÀyà‡´Ã‘’8Î’ÉÛ·S’çD jUQ¼”¬ûrÑêíÖâ¹H1¶!ú¤î#Ì•«Aé—ŸµÔ ZØ J¢C0Z~7>ÑøxÎëO>ÙßÐdUË,1™=Ѓe]¾b°[6L`²˲MSÜÕ]5ÅPÛ¥„"°‡¦ÈÿþaÆ—òȵ{;\ãÛj½F•ÅŸ9nl½õ’ŒÈ¾Ršá„4ºGñäÙóDOA™"œ*|ˆxœÌ ¸Š*Å-ø0›®"Å©,±PâžùĤ»Ùºú€ZüR&௽U‡uPíÛUf`/>¸¬c[¶Fµ%Ö"¸`ø€U¡2’iÖŠs&×i^k­;ÒÁ;>Clá‰/‹aù¤§˜üC Æu\tµIó•*v¼¹x5ÚH^~ô‰÷çq–Ï3±w£ÒÄÄÒy=‚U]„½âæET†]ìZåˆ%µW¦Ø´ÅºY~ÓS+‚ŒyPc4R¬¶ÛŒ˜Z•8NxÄ»¤»‡æ¸ÿ–-DÜcÎ ¯5Ûh!¢F_´x±ð½æñ¥DEÒÇÛ Nâ˜Z…*´ ÀÇ|\bö®HÃ$¶_ÛZ‹*eyn],ÛÙœÍìŠX~…/n`ÝË ­e}þHA„ÏP¯=áÒ2ù2A^£c0+A” ËŠ4K®ø,F" LµžfséuEdÑØ‚¼Í°ªò(ÚHné1øØ!=¨ÂÙÉÿÈO¸9L,XFøßƒ½ÅR>e¬çTnå0êcÚçÛ”e‹=Ë‹ÔêÚef½Û+ƒKåcÞÓ¨–j|^Ô~hÒ¡$CåVi,*)ë5¢¸ð )ÌAO½áÿD¶á!¤ª¹J öæ£ÀÑ%4‚}ÀG'tEÏ<¤ ìw;LP– .íi 6åǦg\%êÉN`Pà¤^[‚CÛò¾X§öcTÈ`ÆíåZƒ)æ´ >¼VÒÁË®>’_{Ù>ò#²žÙ³ræÇqdJlÌÆü­§¸0šƒ‰nÆŽªXü«×ùpµ ÀOÑcDâÎ/]ŒÆÞîyêV6êñ~`Þ,8‹À7ÍEDðWyï“ }ÆÑ&¹+áj Ôüî€"hmn¬^%ù â΢²mŽöh›í^¶·ëLuìðà~¤öãÔÉ´Üã.”;Š÷ÀïyÂÿ"DqéLRÕÿ(~ç/ôéÏâØtH>êÊ.[µe[ÞüŲäÝ dHdJ&ÖSÅJ>iÕjˆFÁ]ó€‰~ ÀÝ;BÜÛ±Öèî<<Û¦Y˜¶±fÈUpÉM•büˆä5kŠr;b™ÀHu‹ãžLâ—T$(QþRqÇns^|$‹Øð¦sÝu`;caíg üPɘ )ãÛÓ2QŒ#á”ÅoÕö•Äc3³D9‹P3“t¢&›ð¥òß–«§Zº& öæ Ç;‘žúŪì(¿ùlûe‹ñìvì ~s.vÈ|NjÜ¥e_ø ½Ý Ý€>gVuF>ÍA§oÕØ8ÿ:’Dשý†mo”ÑÿÆöÚ^3v‹áPF‘æúµær-B…. Ždç)G>17NBâ×€Tœ4ìW=ƒíéÅ`í†ì,VÊÎõ.[4ã€×]£ÏØ2„À–BÞ‰Ãñ[#ŽºäqÔ–N»+›Y’þ"òjߎÎâ ³Úè¸`·Á\Ün“–Ä@Y¡ö»¹VÀëüX³ÑS ø˜žD3ÅL£WèéW«õGœ6±}Ï5ñŸßwÜ®ˆUJèâñþâ£?KÍvio*SN„.Ñ™*É­–·®ø;rÙ®÷ÆëûV–3«g?{€)ùF|ÄJTª<7éf–u]sórÿ¨¥¤RVgUVÇW~)0¤JØ…ú­üîÙ|…Éo^}üÇÿM#ó.ìjo\¸œ„†ï9l¦‹£z|v$æÖ}m¥Þ˪v/ùV ¤a´²f‘ïÞ›ÌIG„ÄMÇxDÚ³ÇHż'–È# ‡€‡÷ŽÜ“'¯âòN°8Á‘‹%',j”Ò#„$ jÙRD`®@Ôj…8uæÔés…ª>^ ºàÕQ”–2m:ô©¨Q…úXQDÖ|ˆ|‚Ï+X|_Å’-kv¾ j7,ðÄà­#âÆ5áÁ„ݺx÷ÞíK—A·žÞàɰaÂnÿw˜;"¿‚’íŘL™2½12gž§!†g…æy$múÄiÒ¨GÇÐpߨQ°aÇ–o +0¢¬ÙãE‡%Z´˜±£GŽÊG‚”ÇÐ$Çyó>äcé2æË˜5w"úéý{U¢H…"]:ô(¥¡éŸ¾ ÔªYó…˜âƆ°fËzÝßíZ °õ`#ØÏ]x%È—]{!ˆ`\HÈ€`‡–b‚½Õ˜üðO<–‰Ø[födÆÚhž%„Ú %÷"Œ.zšm£Ô"Ö²YÐ "†RAõ¦Ú÷ œGrÉuô$HÏ•Ý<Œ¬¤K/ɤONÝÍÄÓw+,ðÿSPczW%D©ò {>¨¢JUß]•!ÐCw"BIWcõ×ß~g}µ–Z 0`(syð`_ 6È £tyð–-*–abŠ16ÂcñT ¢d½™xg›ö™Š£Æ"Œ0’¦iàSKbÙö ôAA*œ`ÌHFF4,÷TtÒ“NrtÜH$± JXº$´݉°—+Ðäݵ×j¦Oîéäž* Tå&|ñé“Ï-Ðã®=!„ •Zúê_ j؆Š:º×£7ˆ`^t`K•*V˜… /¶é‡!†*=—…Pgó ´YB¬ÍØj‹!'÷ªteÉv2>XpƒEÖÿ›ŒE —ƒ)Y‘sÊ~„lHÈÙG]–YÂSK9ué“–ˆ`…"ò}«m|OKýÞyAɇUí¶à.=QDÁô”äçg d¡%èZ°…h¢‹øh‚ .¨ „SH¡ [˜é`6ö؇¨ªdÛ£‚©˜q Zª.ªöqr )Z‹(ç8›PÐ2A0''ó°ûDtd±8÷ìQ²Íi4´0-tÓÙE½NÔΗÏ„ÅLë£îïñ ?;¹:]Ín K´Ð„»Qä£ M¯ 6Z}’V¾ca¿Öa‡Âå/¤ ŒW<Kx°¥—îÝp¥€Éå)ˆ„Ãl"Ƥ1þŸ¡êÿYÈ+¦VÚ©@3›Ù ìšó‘!øñ)Êðo!±JG‘âÇ$´ jðÔ» ýNKC“ µj¢4}è.Oóx=æÑy… ¹sÞó‚÷;©‰k]YC¡»òñ<¸ >E`€ØºR=íiÏ+g3›ÙÒÖ–¼e.å#XÜþå òù¥€)B…ôÆ·¾mªS‘!œáJT1Ä• ‘Žk+¹hr$ó Žj5 à*&†ÐU¯\$’{p‚À€‘Hg¬ŠàŒ$Åi–tzã:ieIZ¤µ”†»@à]¤i<0YœLn­*Ä“¼–¼k‰këÊ“‰œP€uaex ¸„Z¾b¯²eoÿ_j¢_Ê'·€M±AŒ'³°õñ­_‚áFU8Œ™ !glÍ©T$²W±(4¨¡Ñ/GÇlîGȇAZó9aK'œGpJ7ÈM²óYÜàK°ôHi}„”´d J É&rÆâäÖN¸»çõ0jå‚Ú)MT1Txú(‚”Ÿ±‰å?Ú;"€Ò"BmÀ{¸ÜåÜæV>*Bè|oY††é7'~(™¡ªØf.£¸2ÒcU[«ÜÍy Ð6d9àH{¼ˆ!F2g´ôLÉX,¤³PbEV+’ñTšÒJèÉ­´'è$X3Ywm­k1Þ¸ ¦Ã;±Õ ¬ÿ嵢ˊ,÷ªh-Ù¢ÊeQn˜øÆEƒu a'Í›Þv·Nb ’K—9Ó͠ȥIãjü—žÊ&G¶ÙÑæz¤ÀþX¬È æ%Ï|¨ð"N…êIP£’*-’‘œ§<åu”°°·,ÔZ'úI<å#£,жNÙ®;©¶ ò¨¹ê•°ÐU,-ËÓB(¶µ nP”b/«hE… 3CšÚÔ1¿880¦î,hâ‘U9îŸackBÀýZÀŽ>Ú•dôh ×¢–ZÉ =š…3Øê“ÑJ$c'a¬”P%½¥8éN;ÙI…`ý*[š´NE>ìbÿˆw8¼ß©¢°›~°‡]´iW¯|u¢Û@ °‘š`°ŒÁbú¶0´Cjéc]Š1ƒ¤2¦:QÇDÓ¸Õ´H:’›ÊP†äæŽà¯šìšq²"³ÍšeH‹,D¶WšÖL¶d;ÛQw:$!uòÌ»yå# ñb+W·væÂp†Ó«Š|–šI: óqÁ  ¦ Ìu,C”±EeL(µy‚m8Ž`Ûãv¼–BìúÎ+!–N,²Œ0œL7ój2š ÒéŸ}©9£„ÐCË—ª—ÁÜÄýJ$E28@€Eƒ²>#QsÏžå`xÆ’×jZ„EÃ>ÛY^ð3Ÿuÿ(/­¤¬ T±P–’\6!“í&ëR|-(EºúÁ¨Œ‘hÝyCwáÇø+°Ázà‡íCib5ÄØ# Õ+ÈÅ`Ý+&sLÑ_hX£"ɱf67šÍ¸Ô $Àó0íRÎGes "e A¼€ólèÈÖðÚL(ðȦýN”úpÝ$ó¬áÙ24 ã~×W›0hz4ú¬é¦„NôÖ~Þ“Ìóêé-Q°\7ßÛ»h€ØÒé2(Š{"IKmÅ,^H¥]d#;YSfÖ18È•UµY[Ó·Ê›Ùïg¹‰@†ùp®1¶Ê¤l—CK%)„‘I<9m¬èœ¿ÏµÕ5áÿŸ¯+wô±°oï<Ÿv½›kÆŠN|`JXM«Ì“Gé-⮇%ˆ-[v­ûŸ}!ªï» ÁÆ·ã?Q¼D>iªõF uˆ’=âžÌÊXfpô°xk®¯‹{Fz×ûõ5ÖS·"´?BD˜ìc¤ü"X|ÕíÃ\êÄëœñ¤}T"n­`™¯¶>˜ÒéîèžhJ8ÏõÙˆ•'—Ó¥Û%@ð,UXuR׈DEÅZü‰¥Õ^Y×¾mW¿ù ñÒ^¸@ÁØMø€-”—¦,†\pЇ8ŸÜYÆUÌõm­åg¤ˆªPVMy=xÜõWôÈ@€ÿY˜©€kKâ%[±Ô¸y¯Ü‰tl¡JPÛÿY›º\Í)Û T‡5Û¸mM&˜·µ–è%\‚ …ÕèßqØ …’F…¹ø€ÄX¾Ýžn×-1€¤, /ðØÜñ_<ÌÅùHH§µÛ§@†I_2­×zΨXœÆŒömß©|ŸšQ–‘…È!> 85™8-ı±\&™!žÄ‹ÍåN†€•<¶Y¶ÕÄœ-…iÍX‰•r’ì’îØC µÒµ„Í%\Bœð}„ØîDA|DEòa½hš TÔÙd”Z¨M[H æEð _#ª`IYÑÚF[$Üò¢ zÿHôEÖà̬ aŸ3eñÚg!B¢–éP1a+*dŒ†[²ý¼äÉüñŠ:XRÉN„ɇôôÜ|°Pk˜:Y„˹Køœja $Áá¦Bsé!Uø5r`,]”† FYÚv-€¡øž¢ß"2¢ ñ_„LÈÝPâ¡ã\Üàå dXßáˆQ X\@Š¢‚F $gag PùqŽË¼b¯Ø—,Ëû•ÓV}ÕW̓Í` åÐ#^ÚP ½ SRé=àJŽ -ô¤^ÂdöY.ìPM&fDÕ›ì$ÚüäÃ(ŠøU¨ _< %ˆôÿS¦Ï<6Ì9.§4ßTæ UzâõÑÏác‰RmY‹Kš‡TôhSÄ¡LãFõÜ•¾âöÈi&ÿ ŽéRgŽZù€&©¨O%~Oó(¨tbADèÄu)ƒªÈAÎf>™ ¡Ž´BP_pòÊéÈ ËÝC»u(EÎKw(!TGu¼ŽŠÆN}KÔ8” d ]oÓx‹ñ´Äq”RLãz0…Nà)¦)[X@õd ÜÙpT}2_§(e~Biñ) S²]÷ðKßÀ£\0\’Éõ%èÄY\øeþtåWrF*n™šúˆ>?€ÓTzßhÌbéXÒi&áéµ)Í7áh„å(Kêå ê%ÖÈ‹×ðÙ#éQ@ÔćŽ^ Du#{ )¥ z^‚L¦»¾d½i8âÿ›¨v¢¼Ï¬# Fé¨Å$NJ<Sß)ÚI©_Qiýçb¸Åª- Ê—6¬á¬—{‘Q™dªä™úÔ›!´â7 '¯Œ¢=hÀEÀûUìñÓ»ÝÉF˜ëœ¨ïÈËbž^> â¾ œ° øF€ãæ¬02ªÏÆœXîK ©ÑÆkNcÒNe’£×aTØõžctˆÙ±ã®ª®*Á2@¦cA†cå#UzbÙ>¬B-h~¥lZß~m™È‰–|ýM.輟äm.ÏÖ„’NjaúÎ] ÏÙÖöÊ,P,@¹À‰RÌpSÈ¡ºqËÌò_úJªå¾oW­»¦‡^Y&îaÏFÅÒzÿÛÈEÁ¬ã"ª hî§I…¤€.ÂÎ.³fá0°VVFÃn¥fd­eƬ ÐmtvlÇ‚Yï ©€È2oË©áòqu‡0fUŸb/V.4ϷȬÌøÖpz¦çR· Z½ÉRXj$«ïû iÐú€ÚÌýæ^ñ^¿˜€„2 ŽÚ¨I)Á`-ë¬ÛIÈûD dh?\—¤Æ˜J3Õ2§b!@àŽó}@Ü%XÈŠl§WaR'-ÕŒ˜0. UÉ4û\Ï92 …*°çÐfêê•’y 2P@2d¾ ã^ã­9©DÕo-iG)q5F \Q¦ÿ._@"<¶®ÛÁnj~H܉m,Çf‰ø`|Ù2.ge àÈllÀ*zSÇ~@sz,QiÀáœÀÊ1¯Òm'Yp5Íðr G³(®¹›`s¥J*æ°öN.åVn‹]ž÷2®L7îz,€ÚŒÍuѯ]‰àý~òcpfQN‘)Ç3Ö®jmGeÂöó?Wß'2,”qV&Ä“Õ ‡–@H˜é=|Qdx_AÄi²1/ÔéÕÜa¾ö‚´ ²âò›™A“±ÒÚøáƒætS+:ôlµ3„}õJ‘ôÒËqkt6˶µGúæAc̆˸DEúþ¨*\ËÒª\^u*®*)%ˆ@.¸€t OxoaÛ4#i×ᕾÈØ‘*( œðE6ˆü¯!Ÿ)œ1yHˆl6g‹3ä@“±f4m|\ÈuÓq,îIṆõQ´Ï©³˜·ñŽÏaÕ×Hc[^Ãu¸ˆ3T¸‰›XM¡. ÔÔÖì¤Õô ©*¸@.| ô$wr{¯PvÝvót’’ ¡4vÚ(W­ê¾#<²ê hf¦{¿÷ÄQLÙòÅÍ·AûÔOÅÿÄ „CƒS˜½âANô$[1·œË1Þö;Òï¶öööj`5S¸UXÅU„x ë5ÿE$»‰ô™8ÏtœDE@&{Ý×e×üÊwÃs(7JPãE« ª0òuíbavc!°?'0î.è6·íÉÈF~wÓ75´ÍI8mèàÄé)[±Do³ÑÇG»D[gù4çõƒ{‹·p³œ O¡ÊK>Tëñ{ò‰DtM£MwµX¤¹'|r²bʨrŠïõQzf;Jñ„ ¬S&ºP,o±+“–Š·‡,Ûúà¬ÔˆÙ:ô¦óÊ+ŠSÈ&[FDó2ÿ3ÎËmC³£2xöBó^ž¹ ‚¹Ì®XŸÑúqUšW7™C7[1M·Ù´Øè l·µ3þþùwågC©\L{SªòbMÊ€:_o»kBº(’"Ú†6YijLP9aá=Ö@¡}ɱ)±œ¤¼Ø 5& ³ì‚ƒ¤µN3š÷¬^j.pØîÚ¸¦—ck. ÓÁy­GMŠݱ³¸¾ð9¢`-(ãÅfŽrdgø%×4ZcöPç$‹Ã'w×X[Tü×_|/ z´óg*[)mˆ=0£“ü܉öy»Sú_5^°‰ë¨äCˆFȺ²õ‘C¾Ë ½U–«ú–K3ö}Ï]xŸ™·Š¢&êîd£×ŒXrëƒl1´@8ûC?ˆ‰{ê4¾å¹è®M9F<—H„‰xñLH0ž…:0`àÉÓà )>tÈ Ãù°çÑ£=‘#I–4i’žŠ”1è±ÔÀÒ%K2ñª‰ß7(ªPáÐC?ˆüÏž '4¤ÈŲ|?¯MìëÐ|>8ÿ¿À¾J0B/TåUŠp!Né9,•3|J+õTÓVLÑEÕ.ÚhFJyVZyŒçVZj¨!^=™¨¢àliMåa•,©Ø&Mrv&,×%jéÁ§K/w2äF&s£FB*„ %ÍúÖ“Ê=à¤ÓÎð³K®²üóS^¶àíwÐäŠ/®úâ7¿£r!L+î£' B‹XÆ0¬x²Äôágc;ÍTRK=m³Uc våWe›•  ÈF1rÈæßH§¹ƒ`ùñ9¹Ö…n.‘`ÊRÚf·V©Ê-µËiƒî*˜`ê Ê¬š‘( @J…y é„%ÎýÚM±ßã@ÿª €W?´üôo…?ã*PlPRò>ô¨¿¢?0€sÉåÇ!.âÅÔrâb|/ UÔ‘Q¹4* Íi"0‘g#³©‘B6§@Æã6¹Qˆ®H7$Šà¬H ë‚ÆœcYÒNRše4*ÉKÓ²–—@ßEm(d*J”¢DqG$*8ÁóÐå¦{À‰t"€<ðd™xÍk{"Úú…0 ÙÍnˆñ¿57ÄÌåBY´Ô…\`¨Eábб fBU@B.4)JcgHä"¬*# Œ•¬pä2˜áj!±…EzO Nul]Ð>hµ2‘$:Ö –Rˆ;•ܤK?ÿøÁ !FÀp(ö¨ZÔ¢„,å¥Ð#ÍóZI)=±¡ë>ùÑSZø”Äê(«Û}þ°»XF_xYßÅ,*˜À4eE1Åx`ŒotÈHU"ÿµHU'ÓÈ@XÆ9Bf´š#o|ÓÇ ]$#®1Ì\÷::çIZª"­£%®Ä &?À ¶ 1µKåžez’=q© MÎCÖ @*ò0›*åÒ'$Ö_Lß^ ¨{ 1; þìæ„À½O1ïi.(s±Cå‚:ˆÊÈ™g~d$sÑ,7M• Ä ÄQŽ ³„¤# ácÁi¤Çg 1gÿM’522yɃVSfW¥nç=ya>‹â-~VÀ#\ÙÚH4à¼{”=¤"õˆø-|‰E^ÿù Ð¦}h’Òë`ƒ¿îå1êIGú>ÊÔ£ KDP€Êx q¢êÌ3›©ÆT¡F5ÙˆMc£M‚Ъ§ sàÌ„êM?²&F®)ΰȣÔå¸Öœ$É=Γ–D5ªK«…µ&I å’ÝÊä&@'åãLIQ×$J¯Eå\§D(º²ò.#²¥^mûÞóeEíÅ+\ù®À8%™Ç8±”Qïasq¡¹|H¼Ð‡=ô1ÍÐt3$RcLÑX"3Òôd°QYÊèÿZǬG¢ëÀùx@ÓE„7q\í™ÀÚÚ$ )H)¸ÊÔÕ‘ìs$±‹]J’¢´,eéT:1D=í5CÚ£xü<Št–‚C(èp f=+ºÎU•Sb%¯é+PÌ"W (¢øBP äÑ"±¼Q.o`Ë;Ò_0¶~â… ìá„1’eæSÀTmæAÙ€gø€6<­•çf#oVp8áôÀqnEž ÀŒÏäÖ°Èda)¶I9É sÒŠJF—”4ŒŸ‚ó£ŸZc ×–’ãç>lÔ#(¥à–í)QP%PWöòiûH¹ ‘‰Ì^f Ø‘*¦†³ÅœÀOÿÌT.ܯ©˜yf³ªG5‚UœØÓω–´5*‘þTžMtÙ^Ý@VW€ãØ#7r PáA6‡\\³—r­N€–†ñ‡’×2!…¶KÉRR:íêQ‚º”âg>ˆ¼TË|ØÓG`È ^èW°œjƒdÛÞ_¼ïW–†æE±(å²QeûkYÐ7Ðs²«Él„ìˆÎ”öƒ…‘=¢ntͶÇâô©ÜζÐÃ}GòÜ q­µ,€wÿ–¸áy’‹û¤yœàãåZî ö­OšÇi¥µ"dñ¢G`삼°W¤èEoaÑ‹öÿ6ã½à¸ ¶l6Ѓ Ñ‚=f0€øh#MÍ€ gF¹qùœíØ£ É‚½zÈÎ"l¤5› #²0‹óómgè©O}ŸAW€ÑX ˆ€Z¤-m\ñ<)JŒÀ:?Ãü^\énžŽG =‚Ú'¯ÖUxªÝ†p¿ h}Iïzá~÷\´¡ ïË5c×X겕;e=ƢɎê²ÁqqR6^|þ;H­$xùÒQ{tœpÎ3’ºè&u"çhFrNµh¤ç~Nõ0l¢éTì·"Ò`¬(ž¤xæ!Z£ŸhëŒø²¤¬¾î¬êãøvŒºN ¯ æºèŠ»ÿî^øE@è/r¡SÖ+ûjúÔËâz~悸ìï @n`ðÇDïü<ÆäÄŽþïçnªÀr£säoe€ª´x%ó Â<ÁºÐ õ¯óx#Wþ¯ÿr…6訚Fopƒ =Ã, [$`jªÎ¸DÂ+y°îxF‚šÇÏC\D°øJðøäÁÞŒˆä˜¨ù±_þ¢¡ô¡{ÔÂP'ÊÎ+â¤ã"ÆBD‚K„ø¡”i3„­EÈoEÎè²FˆC ÄéýÞ̳è/G>Kæ†* £ ¹ð , ýÏÿr… l‚ l6'žŽ(&ÀÒ"­G¨+ %vò!$ÿ8ð÷–ëfÂrŒøü-à0PáFÄ^Qqý¢_ž/.Ü‚- Űhë¼Î ~,¥pŠ€0$ TÀ Ä¥aˆpðÌUP…ro‚¨é¦´ÉeæLþæHÁ0Ï´tq à ;²»ÐƒQ$A!HÒ$ÉÐæI'(`(ˆÆê°xbÆ>©“ø°yº±o(? Ñkˆ(d¬@$^ÌÑ@ÐFoñ(B +DmâѰ¤¯êq*çn‹@× €¶Ö$JF`HÑŒôË™'!ç²hJýP¦FV†srcG>k›zcÚLË yq =/Arg¼P$#Œ$K0ÿ;ôšn$`«ªÎíðÀo<¤C)~ÏÍCºq šÀß@í–@¡:麌2Éôçnû$P⢰KîØ ˜D p‡¶ÚÀï4 F@n,GV„²g ¨r.BµØì¦$o )ò £-#u‘ µ°6Ò.92/ù ‘óª3´ÃÝm!¯poŸpO2c‡Ÿ s)²Ñ›B)š€øz23 ‘õç(Ág!‘)É.ÞQ‰Àg¤¤²°âG×&Nþîï À6‹PTÄ’ü"‡3ÚͤI T&!଎ØpÂ*h97´W¶P wñ.ír:;Òõ2$³s} (ÿˆçc@&í0kžkJh˵øÄ¥1ÓkJðy¼FÝj( )í*$€_ØÑìêˆê"5oÍ~°2¾òAö¢ ”‚’ 2D„­˜ e 5àh8k„Ù˜Í žGârÁæ’C74D›ó.çtD§³DO4'`¯’„B!òŠ%ü4ƼG_"(!3‡o ‚v´=ßSšb‰T„Œ)oô 5®áç½èâV€±¸¬ŒA\ò­6¿²SÅ4ôGe!s"„sTæ6&ï8çMkæMµ9åTXë/l/÷rÁL€ó´ÃÑ“[üt"íOqÏEÿ[âêjFùð<³Qurøx43ŸK¡ d(Tpᘨ@öÅ.ò{âJ‰ÐbùV°-*¤Bø‘JOµ®´)øaÞˆKMV#‡!WÑr‚EB?‹B› ´D별‘#IXg:Ô9ç”E”X©ÓXõO;T4L"ÍÞþ´% u^òZ ¦1Qs¬ ˜‚½1\¡«>ˆ(ùØÕˆîÓˆlv?äê¡Üµ.V Bâg€–TïçToèïT@q³Ut!}óK§€3-U‹a%Ò-éO›”3ßtb)¶b/6cIT/‘Y; E%à·€"k¢µxþó*Z¥ã÷°Z¸"2O ¸µe™âFÿ/33}ˆÇæÃÞÎ&]íÊ?áâ,Žì?D€*dhE`h+whƒ±xaMð5ø4À<`hI‘ðbµD`UL/DÀ UFÎ4k³mku¥Mï/b½ÉCoWlÇÖ#KTYy'í'ˆnKÖ;¯í-ÒêV2•‡%”G2ÿ6ǘ‚o¿q  «÷ÖÞ„LÈr!q¯«mÐâ-Ôr%—h/×5Ua §Bì!2tT6³3`šVjuÓi]•3~-ÉT_fM_×slQv…ÊCk—.)wéTwMô:“ÕRS(¢æ“,ðXe§®+”W2σ«T¼Q¡p÷ÓÆõ[ÿ´7 ¥®°+@N­qé•rg˜|+}KµÁZ )  ×!Íþšdj`¡éÌÀišü׎¤ E ô(hh×€#D«Xë´D5ölѶ;VL(˜%Z£e0ƒ‰×0°ƒÓXzÓØÓ¢÷ØS„¿Qf{¨>´1UÐ2ÐÑàâŠm¼‡^7h1„^/¤hóÁ"Uÿ®×js5 rðð’I÷ÌB$84ò†Îs&r  `þ 2¶榇UN±X‹OT0ÿïM£Y'Ø;¡%yY@0øžH–ŒeT×ø)r¬ÉÕy~ÙßÜH/JðÃì ŽS½çÔà‘^çe,>¾D€±ÿô.³2O ¢D™KGîiM®ˆõ—rÈT7P¯V(O âeæ(¨¢ØC»öM 8X-öŠóÒXï´õôrÂ0³¿:ºb>X Z«+Ðø–'3—³q3£÷ë€ìæx93[Ó‡(÷˜,ÜÕ]ßB-~A<š.BC€ö^=ðT™¾ÒÌ‘K1’¿yüöEÖ/‰1y‰ã“mš-¯7ö(ŠE™Šo—žG4‹MôDõù‚Ÿ“þ”©Çx 7nÑX21Ø;øFZ„7Ha–øÂN\±W+F£}6™YšÃowØs¸BÄ0Ù7c•!Ãù4ÒŒUð6œíV‚“ÿMই..AÙMÁö€scí™/ñ™!®³wIÒ`/[€Ë¸ä6nŸb>PðxÏXªÉØýPݘ—¡fŸË¬ºš]í²10(‚È a•´K‰† .Ñ©ˆPô¡öV­Ååï|M™ä×qïi%y`ÏdnsÐV\Ž“o:B;o°#ÖŠs×”Õly£sŸŸ¦$-Zÿô‚O dY¼Åû;Úx›'„CX¡}9„ZÇxLO›ÇN¸ogÔìøC¿Óî\oéP6j}¬1è!ÖNu‡þÎÔBºj\,Gn’UŽUh:´> øZa—´ö3RžsXëyw©óºÿ³›7Lò¨S²\¸0иÂû÷Æ[¼ËØêŠWÆC˜—Ù+²º¡£bìÄU«eÖßæ£e¿Â¢ÊµD,Äâ(ñB} È0,à bm t_ÿðÚ:uAD (jIw¸{‡ñ„¹ût"H(Ãa7t¸‰§£;XEœ9ATwï$C2»÷ò$M`’|žÎÇY€Jɘ 7©%Ø*tü³w¹Ç9³´{¬¾gv¾!u\“OùÒñHt¶ & þ…áìFËS¢º *“·/†æ—  ‰ð¿^:U¾´¯rVÅW+ÛB‹Vš›¯SO§Û”#)¶€ãt΃zlñüNQ9$O’ ÿÿ("­x1P–ËxÆ{–ƒŒ“Ò{—ßÛ¡ë—EIÒwÌG{ü½G0f7“˜óª“¦» æ`þeÞɇn6E¬ ãØU«´ ÖzŠð­´AO#Â%ÒqžÒÕ=ðcö×{o‘\ÊùÆnòŠ/¿Jõ–nÌ 3¯üTiëã/DÜãzñ¼9Uôw~À®‘;ŽVoÃÛ¦[ÿe¢ÍÃ¥xžE\ž‰ÏO\Ï;Ïýòÿ@/«^H“ºn/x>RþT¾( ¼Ó8ðuÜÑ·ºÜAz*3‹ÿ¹á t ´_º¿û™á añõÖ+°ëÊñŸìÈi‹‡i \— ¼` ¼ º ,Á€bÁŠ lˆ°Á†… ñmpÈð¡Â ?6\À€Á#Fð‹²@¼&Dšˆg"¥ ('O‚|iƒÌÿ2ÚbàÉΜÍc¢D›Œ0ƈ1oµšQ:*7«IE·œrñx€¤’8áôk“ÅFù¤±ÇZ¹wßõ*UÎΖG•7bí˜mÊ%× e±õfnÎ3V¹qÚ‰Z XW`†©» ŸƒÉÃL½? Y‰˜U8a†!¶0‡Ø 'ÚÄ}oÄýˆB©/êfqƦöæªF°r®.ýhrs:BÅ@QLBG°‘Ç<3w5ß¼%æY9 ­ tU-™œ€YLŸi:ÓŒ(Í4ÿ=¬ÇÉŒ%Ø\éˆØ=gk=½ŸÒ/d  =-\ýè=j Aô˜fo›ØðcÀûc÷Ä Dðbª©öÑo Ôô1È% 92I, ©\Ê5A×8°Ãº 3å–{×kÍXFµóUÐzLL‹Lc1YV'z¦ÝéÁú§]ŒIb– dp {âÓžr—˜®ýîzùÌeC¼ìD-pži˜§'$Œzq›ݲW½¡Šo¨¢‘B~`pL6Â!ÜH$ôá*WÎQuâ§“ù fÖ9V•hÆ¿eõO™Ž}BEû]n*ZÒÎ8×Å]žG%ˆ@µVÿLjÑ5°uÉ„ ͸Ʀ9ÍvUûür¨À4ua;è?^ÏÙŒ8” .¬SE®Ñ ±°-aL Åþy€^òb 1(Ž8Ò#ĉ„”E’CO“xx¬;ñËH”‚E?ûÉòrûk —<š³¼ŠÔC0©µÀbÌà§LdAcê û*p¦íªš»TSM;ƧYë¦PÙcŒF2¨*S÷A€ŪžíÅ,RÐ…¸Hµ yB*b´j#1âBG92S®d ‘ÉײVJî••þžÒ¥«ìu¯*Q‰LZ¦\‹L—éàc@§p…-×¶ðDÁÿÅø0;½¦»ä mÀ@— çc6#¥>fÑ€5¸ñµA5à=ˆ –`Œ%ˆPŸæg?âpÕíéP  ¨Æ¼Ú”d£„É)ÏzÊ#ñJIðó•E/ZÜ¢Ô–íճȳܬ4·%¾ X°'\Üò ìÃ&r‘%ƒ¡‹4ä—j2›yñËM¯öÒ 2„|¿€¡æwqÄ#­<Rr“«]­@]ËZWaä¿ÝÑ'H+ÝV˜9§DIL~[“ñe„•Å(”~"È5Ž–V鳟svž‘®8%G:És©u­Õ¹e¬+ g¶åc£)“Rn„tÝu zXÿ3ƒãE/ ´Þõ*ùkLö¨!åë‰ê1I–o(±JRlË]¾Hª*²É1g¤¶¶Å-ûtëPìdMdåœÝº²•á9Š­dÙûölâ>ÿ/—)tyT‚7ûr‹.ÙC]4Az[-`Á<\·LrÅ©j·bÆ[Í牗@ ²S¨Eí5Ìæá1§NõP üc@b£ä€ÈeÖ¦¶Ë·‘Ç «X-tâk.믉££ÅÅ™¢«Œ¢±‘ÝlŒÏ5ñs—t©bAǤ¹Ù6™_!Àžç"hÖ’KZº%'£Ùc\ã"Mœ.=5 9nÐì>}ï֌нýPzü=Ô@¦ÿÏ—Ý€pð‹ÐZ‡©­dW=[! qp²BØHÎZñ!&•óÆ-òUzØÃǾIÉMγ]ªØG*t¬÷“N`œ9€®y %/Ý‚ô¹I#–LŠ.ŸŠÞchP§=ÝT»÷ÂÁõFéà\rdz å *Ê×óÆcHÛë]}ËY?ˆ×¹gëÔ±"bçXÄC²Pµ›²Án3±wçc'[ùÌ?öÝŸïç$%iïÍß[Ò>Àƒä¹&5„!(@’~@ºJcÁÖ¶Å‚œû˜óˆA!VùÙ1 ÀÐ ðÖ5¼$=ßLÌ7®7ýêp= ðOPuøruYgÿ§`Ý[¹&#v¼6ƒÃ'|£4VˆÓ[3g%×|svr·JJ‚‚P!}&Q-¸+Ãq$Úg2gRð}àwx~ÅÞ…ó!nsqn;„ âLìænœB"DÇ)F'öj£6‘ øõ5ÔðÑ¸Ú g‹££à‰|Ö8<2“gvòTa€)CÒžGš“Ÿ‡§™ˆ ™­ ð©P¥TJ¥ @C0š,@R³-¦qMä$ŠxR~€ý°a ÖÀ›³ØO0¡R×…Ÿð=PzC5–SÈ`œ’ùOd‘¸‡UÛ³{AtP¼V—-ʢڢ݈qWf ˆ8 ˆ,Ù£‡)Q'#“‡xŒuÉuHÐéžCbø9™à'¥]ª™ @¥?©°ÿ¥UJU Cà /Ž7W;Öd =%U¢åM0¡Øk t¬G7Öp€üÖ§_à €=‹ýW–×=Ð ¸Di?@I]G¨l¹²Ñ†üÀoˆ¤Ði:õ®,:ŒÕ /¸ËèÝ)8ÊÕwü`fÃñ©Bʘ‰vŽi¤î¹žöÀ°Nú¤öiŸ° «XJ«¸z« °Ÿ›yA /Pcwñ<0ô‰Äškz­tÃ…AC5¡tZ<Üö'»¡ kýðÝ*™Þ:Iù¡ D»È†°òIÂø® ë¢:˜bžÑ£Úù—ÙÙÙi¯þª#×7žŸZCºÿfËžkFŒ³°ñ°žÐ ¨Ÿ[º¥´J±¸Z¥ €± šé ÀCycsBeZt|±)ºóðoT8Tv“§×C tàà@–_˜³Ù™Nº=™` 总¸‹AD7Àð¹`¢;ºe˰J‹)˜2=‚|„I[T˯ü:˜œ ¤ä‰8jǘ£££)O€¤¤k®Ú¥µ*«©p¼³ª¼¸š­@·CP·šÉ¥ßU;~‹yƒAZ¨w=ÜÀOtðC劃{=(qz³²ˆ=÷Ù­'´WµI³q®»ˆ®²¡›XbÁ¿aῥ˰f;À ¤Â!ËÈÿ+™ZµÕ¯¼#ie»¹;Œ ,úµ(¼c2]ÊÁ°z¼²:«© Â# ·qû¼u+ó‘Où–ó¡­æBýÑ{fáóøaèN-â¨;çfÄÉßB%°úZïÎPõî!@Ö2$õ÷!ÔíÙqìÜËkéнð3nÂÏë <`öòÀ'²öÅ:I0 tZñ]¸B¬%-#è„›û  I€d°OPþS)OðUI0•¡†(°^; ²"÷j$@ÙŠ¯‘QÁ#yGä@(ÿ`_Ž}Fö)l¸pŸD„^Dˆð0)Xð ’%KÌc”2£•1\¶Œ#óHÌ+‘Sg‰’$GŽìÉ¢DJF&L°™“Ŧ"L• „Ô¨ ¬Z¥:UëÕWAtýj5A×±c‡ðxñÃ=y÷ܾmûVî½&sÝr°»dI“&'Zœà Xï=… nrØ0^ƈë"¦ËWrc”µÑ`,ófÍÆ–x>A/„> +ZÝXqƒÁ#*dÄâéEе1Ú¶a†Ž™2”ʼn'ˆŸ^<9q“zà;¨ªÄ Kÿ¬Îs¬^Ûko¬zâ BÌêòžµÞZM¹Öôs §´¯½ô¬Ó0=#¬Û;Ì?ÓœÂ<'lA´¡ Ñ €D*ø 6Y2¢R†ÂtÆLÒ­ÆzÃñÓ‚MýáR×ÊQGPnÕºW›²1N{ƒjW]¯äu=öº$+ä²x0 Ädá$ï!€eŽÎìO\?û‹Ã™ý¼‹Î;¹mÌ[Æ#Áq‡öoBC?¢Ývˆ •F%¨9)3Z¨ßi»ÔR3zª·NqÛ ±Ã{Ç„V5bê¸cJÊN°8àw=/Ë.Ãúê×ó–’O.Vå¼ãˆÿ ¿ë? ÛŒ³…h»6A²ugosÞVÏ·ÒtVh[˜'„†¢Z1-Q ¡÷–ßÂkÈ_†j»ÚÒ|Ê7`ð6â=lþ½Ô³ÏN5m ŽÜnÅ#˜2G‹{c=éç~ïc?Î;ï!†5 äbƒ8vp( o¹[?ùª°Í%NXÿ|ÉþêOgʼÜ?;–0oc–‹¯¿BàéJ׊vP^†¨—òt§5Ùi-Sº;ÈFÀ36 ìaÃÛÑvX!‰pàéÔÅjµ»éÕÍ+vÃÛz®§B‘m¯{ÞÓ Ää§”?çKŸúÃ9ÊHf[ókÐå´3mý¬1úë–´èÿ’n,î" Rƒê`Ì_–r Œn§/Ý!ä;½)[ bAQ•ñlJÊÉ-|ò$|Ä#ÞÉÜ0À;]I¯„eÖõ¸’B¾%€{/ì^±ñÙÐqKà"yEn®/çË™‚€XD!Ñ0à:bå³¾y@à$]¢NGÀ!°ŽFšZÀp3‘ÚÕ®/bH‹ 8A0†‘l¿9ãÀT5‚êkùˆo¾#G Po+YÚ£Eæ+`ñmXõ04£Ù=Wø-Mad äñDòOq‡ŒßäP§Ì1g–D'æô"tAÀoL€éä‰ %Vp¤ÚŒ^™ÅÚPj_¹ã×B(Æÿßå2—@yÎ’žÔ7Î;´"À1¯Â1-ÝÍ¢xÛc¿äÇgvtXg‘›\]/Y¹—ÆÔ/%hÁIjÀæ´+ò¤À&@62/ŸEmåì´ØÏ¥.  جpU³ETÐñ ÆšÕÍ6E«Åôêy´$Ve&S£½Zý¸Ñ³¨¥e·íV·—Û>ùÿÐ¥–kÖƒìäVKò§5\üöNÃÆÓ*ò ®ùPUîÓVƒfB‘È2#œj[x=k*^v‡#ŽXiµjZ7zÄŽÈ\íݶ´Úøfo™=ksÍ2„ (‹e¹Õù܇Ò<Ù51õ.Ïî4NÊÝt5½€;Mf2¿Õc{¥[é(à 8 ms|ìQý…]‹àÎ'†åmRŒ5l¼Ÿ]#0Á3›aúf¡q±jS‹Âùbo¾+ÜÛFáS–!˜åjy³êÇ'÷Ë¥u:pþL×ÃÆpWg^%YW·´@tÀr øÍ®(òŸk•!¸B|7ª.?%[â}æàÄÿÌìÄÆYÏbG(¯cÞl¢ÞõâØÐG°’ëK_ñÈÁê#~… ÛÞv·{E_“›à¸ÉÜOø;§•Em8InY[òèŠz¸ÂËeu‘Ó –€€˜®S‹bÈöš6$ñ‰…½b×òÅGZUÅl°64«ˆÖ1}¥=mÖ‚Ì=‘ò—dÍeîp†kVŸ:Äi¾äo1 >0çðBj-—Z¯û9îèXäøðÀÕ¬¶pYL·fþRì;ŽÝEŒT`óú"ÀS5B¶à}6ÙqëZÀˆcçH+ 8@RQtÜ?@=0ò‘@Œ†´µï›m"A¼ÿÀ•{Æd¾ HNï37¦¥®ßf™Á>_LËè#ïœL­öh¾Õ|:þsŽpl}Eg‘FPcãº$MɪCýîóžMñ¨pÜ!?€/€Œ8`íÈp2ä> d< éúvídl³<GÆ€20Î+;R2•™§Éɤ4ݘ$õÏž×¼¾å-¸€ªåId w4¶]2]t*¥¨»ˆÄ1²]êe—ݦBŒ:\ÿâ0Á.°å½ø+Æ2:ÎöŽŸ=í#‡ûÈ1Ðñ¿Vw@­0`r‘·=š#y~õ&i!»âiœAÍЀhƒiñü¹$¢‰9?-;œÿ€˳7Òy…«h…!S:éû Ó¹ÒµÝ 19³Bþã.¦âñ P©˜ƒ#ë¢õj˜ĽÞÛ=Ü[»ÝsÜC`(Á>’« ðÀ |€;ĸc» ,A<¢>–k³xÁ‹¹DªAÉÁÌÁ6h‚tÇÁn‰ ÿ7 œœ H?À€ô#õ;šr"ÓIÂ÷ ·Ò7«¸µ‡@« }¹B¤ÂB£ò?гŽ /°¹ÙÓ²ET»µëCã=ÞCä9¸Ë8;\¾ä{€Qx ¬…=Œ;·s¿2–  0‚˜ã€mú>zÐ Ç6 ‡FÄÁu” àœ>!.:©ÑDOÔDì+  }[³ÏÓ6°`Á(tÅœ=Èš3‰à—ˆà—Y¤`+¶·`Ò,°CÀ¦Ê*ó0h;9LÃÞkÃcÄ= Žkøk»k$9;„F|ÈÃàÃl\¹Ùš-ÛR?vjsLGLÇžlƒFÿTGN{7ñ­ie©² øÆÈ P.:d2+ýÒ)Ÿb¬ïø"`’ êbÈ}™ºA¸j½UY¯®ûˆ¬û¢ÒÃ6ª8²àHŽ{Ã7TÆc<Æ«˜K¶s€Œ;¹ >¾,>i”F¸ÓÆÏ;«ü:+Ò H—tq'@ÇǤŸLǼŒL)w“$khhH¿NÄ>ûÀW;+ÓI…}£€¯˜?³èŠÕä/æa±Éº­Äˆ¸®´a㚨ê6ƒ ¸Ñ ¬ÔZº7Ú‘°ÐH“ÓHdlÃXN²à8¨Nd4’ÓÈäÎŒc¦ÁÌ¶Ú ˆ‚|È' zdhLôlÌtlÌtÄ”m™ ŽH¿{`¿\ðÌPÈ;3‚ZQ®üj…¨¨µ÷›µ¯XM[µÈMq#¯Y _SÈØ‰ˆ MHL‰,:ÃÍ~(‹é™¸( Ã(é"‹á¶<‚€!ù ÿ,éÿÿ H° Áƒ*\˜ê‡A|.üïÅ‹3jÜȱ£A[ :xI²¤É“'ñ5ü×°ÖTÿj!”ù²fÃT*+^¬(¢…,àû9”'Ê£H v°%2©Ó§PMºd‘j̈Gý¨:0"Ì2 âÄHð‡Ð F…þŒÊ¶£HmãÊëRëÔ«1¯Ê”9ê_ÅŠ}{”‰¯Ä§Ý x®ã„ l=žL™äÝ•xû:Ìú/°Àª^F<¼èOµ@­¬±ƒ‡®;˜ˆýZ¶í×%7eÍ›íWëZ>|³ÄÕÿLLQ¨Y 3þ‰V ZÕBŒâõ²‘ßgÿÿ﵉â{«Z˜øáüËõÆ?û7ò—ÝÊßýBäÿ0ÝD—jø0&wˆ9[y»äš@¸TÄ?ž¬‡Ò '°ð‡¼µ÷Myä™C Ü€„ŠHT`È‹ ñO3Þ`H~ùmÆßVŸ VÑ?øOÿ,`ä ,Pä>¨à_Oú¥ay}G%z1á”%Åâ‡`>…O_…•ÓE}i•×{(Š b?ðóÿŒ0"3Þ7 ˆèwß}[ièž0ÀÀ ŠvÀ¨A¯W’ è>˜þU.~1ÈxVÂÛx an!qIÒ`~×(9ÿÄœNñYäY,ÞXAüð“O>ÿäÃÏÁK§>»""çPpCt<ê§çÔÚ9‚žÓòãñŒPMF—OÝ‘» €GÁuj…§ªS,œ P¼meØ­¥™¯UÃå‡Äu~૯öØó= ìÂÁÚC'ÀÊêÇ(\7ˆ4B<Ä£T€=Ç ñtìÉB0é—Ùq‡)§ Õ©’JªA¾»¡@ó°EfWeÊúƒšŸ©ùÊH²k,#7MÏ?NT@ÇPgˆ\ûA’^kgÁ1ýOÙÙ£Â?W…=x"·‘ha*3wÙ •’ 5ÿe³ß줨Î#ÅðO <#ëâ<õe˜_B»”XgÃ5kã®óS€ NÛ35=ÓÃÚ§ ò@Ûk<÷ÚñÔPŸ=Á?Sîtš«­èãí (‹OÞR6Æn¡Öö7yYÚ"á q‡'LÏsõqÉS¬±vu1¶XÁS­Á<L=Œ¨ú< Ìù@*pî>çWÃþ^r8Ï<òZ# 7{0¢€\>ì¡ЉÀ][À¸ÆE˜Á,)pùG#d¥¿¹kT±EΠ‡/Å€Ugóß Èí˜È"“ûÁ šõ"CÌÈL«ÀÇvÀóyŽj*˜‡ûÿ€h(¬-P¸šÚ †5Fœ@òøÇ=þ±„%Ä«l=ûÇÿ ˜D¬àù?Šà+Hx—jS¶¤AšdB¦:Ïn2ø<DzKPŸ¼æ¡>>FV”C azâf%MW:ü@Éþ¡Å`wø+ÙÇþ¡¼íPH"M@2‘%±W^’ǤȂ{°` P\!Ù7~àA„%~„`(Þ¥dV¼§l@K9ó¨8;v$,dáSÈD&í±¤8­hV³þ^Ùƒu"»˜ÚêW¶Õñƒ*¸šÈ 2ôpÒ5Üb›=Np„{˜Òð¼G9Ä>Ï1‚}CÄìÿ(=1€eBÀ›rzâ©£œ,ƒ ÙÖnÂC!Q™J 5æB(/ö² ±ˆ~M üƒ/ª€À4W2Œ Æ â)—À¡ûi€‰ä™ÈÎ32N’óc,*«¨ÓSÊCž(\aÙñWê3JºÁ p™4þCfðÔO²¹e„6MÎ$Ú‘ê)Ó)Ì“ñøc¹Úð€!Ø×F=yœ2žIeÙ@æ6$f ˜Lâ'ÀéQo§Ud)«VxO>¾òYHýS“&¨©íljx˜BI†~Yb†<®ùànšRG®.™°èrJäVt´Y`â7¥”U¸–—Úyÿüöÿòq0Ý Æ0ÆofôQ¯zòâ©`=Ä¡³­Ï`\3’u‚—©pJfŽÝ”uQòK6>4!éAç• êÙŒ ¯¯è{ _:£þD³£ãû_ÊH-J Š@NpQÞ·Å€ô=’v&ù™¾þ©`Ä|·ÔŽqÈÈX€Xð‚ÜB±Oð@00 \y› ^‚¬¶ÚyŽz³Nw¯V†àÂZA››ºÝÆ|Ø)”%HàÄ«”‡*7tUdGÑ­m ¢K‰_çÌÏ8:?˜G èÁky€/­@~ Áˆ(Jq SÄí@Û(«ÀYNð ŒqHNMˆŸ3`–éAó¶õ‰K˜"KÿLj[#¢Í剜¡²ìŒ¨= ÅMÞ’¡? ¡Ív"¾i,:¢Ž$M%šö;££­Ìp%ÿ =ÈIµ“ý˜þ%ž,u ÿxâ”{ÚÃU¬÷î —>œtõÔâùN@í´òx¢<æñ]ç2 ÅÓÔ@xy „fÛÈ·%L‡²øy g6†Ò>¥®ïl2†öHÚ“{Ñ?|CÄÑWÅР bÄÚ)(ÛvŠáÀ?ØÍnÝ"¢úA<ÇÒW”~×·çIÏõ5=§îŒb¼Nðà¹Y—j|ê¯zNãyäµê@ª*”YGнÉ"¾mܘÑË `ç—ê†Hy¿U]¿€$í¥mŸ<ýé „ñàÎu¾ äcò*zÿ½{f¸µU’ßèš?ƒiô¶•À>½x²¼¯;RZ8T*G…ŠÇ6B,&'S€G€´—% dtëctB4D£:S#‹Ã¿Ç^/Tw;Œ€÷À!•dIÝbîD}·•Ù·xñ!@+€òSy¡UtJw^ý?AÆ>kÓ!PÄ p Ц—2d.úç ¢4ƒYÂ$X²g}†{xq\WçFQ1é35AT_ö @1r"Ç8hxQ˜²­@òoÓHçp'ˆ[+Xs1}€% <ç9ô–>BZ£ó…õv6žc!PT¼ÿUT¯$6p ¸€a’2’)å’#áuU²xfæv_ÅlP…!18Å„îS~ŒTt»S4öC8&H9a±^Èð¿è_p p0ÕHñw8s nqxˆ§n- + £õölõoûv>ýÖ@ˆ&,ˆ ú =f¸`B@ ùQ)B @‘F RsbeGŠ—5LL%j#ðüNQ:<Ó€øl=“ecX†8vcbÕ8€ œ2 £`¡€9 %ðJ¹Ã9"Ã_Ù7s/©xÓXxçf[ ŒÿpŽ;ÔñlŒä“ü†h £:ÊÂ'ð Í B€T€Âöa$Ñqš%ª·ÄŠ|£•åøA $LAŠÁF0-(á“jób*`8Yf8)x¿gwì’bÅh} Àp)f‘cmø†Gu2† XN“3Çnxˆ÷ÑHu¼Å@¡Å9Mó6ÄE5‘î·™ü Ê¢ ×p ÏP„ÊòM]´P¹BY+³èr0£bépÈ %8"‘(k×#Ö' iöã“=é–H‘ry†"+eÂ8ˆ‘£€ È0%Èw@, 5ÄòÒÃŒTÿT[€Œ¶Å˜¡xÀò0”FW?¥sIöãi,Ä%,è8$B Рˆ0,¸¦,¬éš’ †Há8p&"køBaHÿpoH%0ñ2zÝH‚ñtä¤ ™çy-2 $†@d™Nú1OæX”µ$çÈ'MʈÁ¢ó8 yÓaÊñKØk96 `–Á‰%ÂDŠwÆ.§â]mv2Q€J ):kã“"Ú–m)”k#:YcRVÉ!¨=Am‚dBó `£p©'r=³B|zSá—©AªnÐXžFÚ1V_˜´D£™SœÙ¤ü€¼$ PµÄ™öWs0EU:[ ¦½D.Yx XUúŠ(ÆJ%Q's±Èªv:§AŸm9†ÑÊH!j¢ì35ã­Ó6¨…*¦€ÿ¡б?ñ`Ž*9p,°Eëó?nW?Ht©'°ñª˜'ÈÀpôIZI  ªW£9¸#,š30½â-âžà ¦jŸþú¯·fŽ•’2…Ø•zrÛXùu+pÂ*vvƱËJ{Ç ÈÊF©Âì‚1G‘²6ز`fœ3–E¹Ø&.4£yÀ³?v9p£ò/÷”eBDIïyMjsBðOð$µ÷° ct#H5Ó6Õ⯸ƒ;aû@"0ü ÿð->P¬Ó4þš°Qc0n{Fv›Øµ ¶2¸@–fª•U‚byî2Gá1–#[U\Wg ÿYÏZÔZIJ7¡%DDD­D³wÉ‘ )µ°QP¿µ=[÷p’·õdQÇG÷“™H+2mÉ_¡·SðpKNWs`tU»W£NcŸš‰; i¸¼ IùÀ à»ã¤ÿª™Ä¢OgT7AwSõ¼—‚ b™±bbjJŠ{K!"‘l»½·I^_·¡%›ÔJIgS­¼ç–š©F‚z+Â'¨kh5p6ä¨oØ¿'/ØÊDN*2ßt6W4†KÛ+§'ƒ?¶»Jô¤jÜ4‘»¼°C0UM×@Œø1À‚k3¢O]ºa(,%s«FFQ±Û«¦È¦ÁF#{€ÿg!q–VS2:TRlÃ1vÒ1á> ¢g³ÉBf¨Œf†0d|Dr¹õK$ê(E7ÊnÔEr;­ƒ;uÚ+_{'¹“°µËµI´ÁwÂÅÔ‚5M£°Äë¤MSôw¾%ftü+3à”âòfbÚ)øØaס€‚)¼PÃᕨ’¬€»Š µ¡ˆ;œ4b§Vc':É,GºX“6—l"è+÷b³[¦u¹²@#%à¨2wnTÄRâ˜:¶kÁÝv- ­Ðê¬NtºüÀ ]§¹Üµþê+WÙÀž'`¯öÐbÖKМCö:” {'ù ¥Gu µÊjÄÏû¼Mÿ˜¬Â¦·… ) ¨½a€–ØòËØtS%ƒÎÌJ§sZ:4Éü¼3I8D8t³µR†;vÑ äú m?µ¹7 ‡£Eƒ%/+Ä{sÑ ­(Þâm"ÀÁ éúÀ-ì:_;Ë߆ߦvjÉ¡ZE”´;ØXÌ¿"rdšp/½]ÚÕ·J<¼ºzæÍ4¬…žàFž€ !‹{Ù&Û¡J}SÁ I#4‚¸ð¬ÔÎJNK=#ª=L£2{³Ü %MC"$9Ú¿9€[Û!ÂMIF«¾o ϳ”й›ÞÖ+.;J»ý™ð@#p°ƒ0böÆ0kõÿvM@EL×LÇo ëµ  ±™B< çÇ z.‚<ÈÙ\Áêåv¯˜€f€¬HÙ‚:ØÄ6ëLÑ =œuZN¥màÍ ÛÍŠ1uJ§ Êċ㗅ÕAòˆ@,=S[ÿ°¹îVn%Ü+T™¸ÆÂ[Tj=0­;Ç\‹ ´;tÜ;´¬ÃûjTDÞ-ØäXMÐÑMIô 0 ‰IÒ¥H(±ø"ú§óm¸QŠ Õçá•\xÈ q1âÛ1K=§ ^ÝÒm] Ý˨}Úsš††z[¡ÛfáóÂNo(@‹Œn5/PdE°ö…OÚ[Å[:jü1á(tÇu•:XÇÿÜÑÅS÷ÐQôSŽžãòÒCù™#@7 ›tçaø·2Ëñ½½zÓ¢²¦ã5ß<-–µwq g–^î18t5ãûäyrÔXþß´¼:aN·är+±Q§%FøÊT[@Ûáq°†Jw>zZ¤P5LóJ5:ûÀžólSóâbFÞÒ0F;þVfòÞÞŽÞã’Ît“÷™D^)puvãBýغ½¿zbÛüa'åÈsÑLøTÊ:²‚ƒ–ª¬C§”}%Ì]žÒ)¹¸ R$7i,ðVåy£5wS'ihÖ\&T”ÅJ-0ãlðã?´ã>žÿsÌMçíÇkÉpMàNRTîƒåèòÐA?Ò˰t·’Ýa2ó3‚<<×¼½ß.ËIwVbú¥  UȺAÑå Oº:$Ú茖ØâÈ hö𼈵ୠ¹QÒôŽBnò"Jû+ç'™âPs04%_QþÓWÄìyE»;4oÞG¼ˆüÆoðÓo­S?Uù@ô>Þ9.ô¨ôR šàrµÚaÍk<Á).L4hÏ·'Vvj¡ƒ³¬!3ʺ¬#vMü»OÍ\^zâz²Yj1»ðlï¾3+¹r??ìM–[Æžû´ `nõ?'àqœÿkf}JñÒìª@Æuó„Fó‹Øˆû¤/fR‡J‘ôšßó@éõßÑ›_Þ¸|ao ø„àûWðßÀƒ…dØÐá?O zXЃ ‡ž:T„¸aG‰ñþÙ«@²@…ü Ž øÏÈYvAóLÿü7j¾ZøFüÙ³ ¾­(,ÝáÆ„,äÉ;B ‡Wÿ¸'ʼnyó¾‚ÕpÂlX°'¦Êûwo ‹S—,1K×ìݲèѳÂ^|€ ~èk/Ÿ½½'Z(–×Âñã½!èIÞK¯î ½ö çCÄ`%7 D˜Ð Až9!þcÀ:¦C[Äø°Cÿ‡ÖzâiCD‡ñ*<,`¯`ÿD*¿YåM5›ÜX&KœC{ ºSûÏŸ~ÜXúo|FR©Þ³*`Ö ¦~-x÷kŒóòçzÏÿÿ{ ºçˆ¸ä9a‰ÅìÂlžÌòù0GÊÇÁ(£çŸÅZ˜g²ÉBˆbBCȇ2½FÒlB~:[`Z,m§Ó*—£JÍ š­!Ùj£è"‹|\#OxR¢ä4+H‡þN"骫®9›^£ŽGï€âŽ(î´4ï   ‚J½ª²Ê*‡­Žð*¬yÒ:K…°¡­%ŽøƒødÏ y–˜ªº;¡²¿òIÿ1E}T*@2ÊîìpB}*ÕG,ÐBø2LBDn ŸÑðiñ(Ó@’Æ‚€ÓqÇŠ`eˆ)%úèVƒ\ý‡áâ1Ž!&—|r×xTšn%pRv%~`â¼¢‚Š»À¼¡ Гª­ªrÈá=#¶š ¬È ?Fþé”?XXâ=$€@ƒdHÐ@] ÑòÑL1ÕG³È&eÓDHX`~&Ü˸Ãò)ˆŸ:U!_d¤ Ê­Ö g3ä˜fËM"ßR© ãb°'†‘ ú•9ƒø1v„ëœ;öX›EâÕfšú)¨íNÓn¼¥V¤€‘¶MÓ6ÙÌ @âüÿ‡Fðûæ1.N|¹P@zÛ2›¡|í +2ÃøùWDôñk²O R8áò^¡ˆ¼EàEŸM#øŸøñMÄ]Dí žJÓø\X¬è6YŠÍ ËUsè7Î5!X^~9f†T*V$Ÿw}ˆ×‰'¶Ùf”ŒÍ²(¢¸´@©ªýG[ªä! ½÷ØäJ½»XŽÙ¯¿þ§]Aÿ;ûyÛb+À&0TLƒyXQQÕG"Ì Dð^á•WTñáüŠ(S· œžNGBdM}ü´†hdˆÅŽ­‹£iŽ!)[•®jö«—1)XŸcÌH׫ ˆ%\Îr 2Á$gwÇÉ Q|rÿ£Ù™‡<¹[ÀS¢+QûG0` 8E?2Ó òèô°ue@[ô"ÿà°1x1Ñ„ò(ôë•úÇ Tñ P"Šç;ß °>¸{É^>àRÊqYUE"†Hç!@¢Hl2×Z ð#)›#C2³‚0pk ™™ †Õ$’ÐD ŠO¸THS™'¸Ö ‘ž©´E…l ¾2;ý#{2Žf¼Æˆ.Ï];ÔÓÙzØç5aˆš‡_'3è_Exâ?(qK ÜRŠ ¨âúx±+Äh`W7X€FCšDâ‚Ä’ådÃÆ¸ñ™ ˆ'NÖªþÿõO"Ãi™ `¦ ìgz$èHW`=éÆÛ£’À£%휆hH#æîÑ; bjÿ0¼䡟y؃N.c„×þJýÄà.'0È»xh6{ ˆ]©^cVy¨É|Ob±ôW¥0µ[2ä¶ÜÀ-ѧ>+º1Ù+€|âÅᯌÑß2uÒÌhVŽ6逫|óß$Ä€Nè¶&LafÏ Âä£ËXƵNŽÄeSEÞH>¹5äágf[ÚÒi,°HFþƒP$õÉÏ6½I?ðÃZË6¹µ…Ƈr…Dƒ ¨’-ÒPeüÂQ‰YêmMüÇH 2ÒKX °%¥"TQDóÿùÁŠÂ*‚Ȩ¦2º¬­8B2ÚˆÌ%ŒM­®y$ˆìF› A§7™ä@pj2L}ªÌ’®=Žs?ùÑ$C³×B÷(I©§=Y0 øÿ}XÃJ52âˆ*+¬ˆ8°½(€  4*Y9sh Z9àP»ÕЦèx&I*“»9‹>‰È;ƒ˜¶¢“«˜¸§y±–Û †h—(몓8Qö ”†B7w‹»º½ø#º“ƒ›‡P…P…þcˆ[úÕ[ºLµ§ÀRcµRƒˆ"˜CAÞ¨ŸÙ‰UÁ=ÿÃTÁ‘ ô iÿÒÒ)ë@•áÀê80Òš‚H*ëª;3Á†¸³j9ÚACX1~€Áå¹¬È ® ¶ Þš!8i—I¿r!·ú( »“%›ÐcˆðÉ¿‚X'ê=U ^²¥ÑÀ§{ÅÃj¯KÈpË8{˜µÒ«Ÿ\C•Ô!‚è˜ßè½5z8—ȉ8ÚœŽ€³Y±‰^1Àž;Û¼ã0…R(?1‡(Š*Ä µx?El9x!©ÀÁ‚Ò¤®Éžt9¡pd‹w‘ x+ »(ˆ|€ú[€áÇ%,'ô¿þ“¢,ô·-<+S=)©)5HÀz¸R!CÜCˆÿUYi:ƒðb|ˆ‰>Ì[)¾Ýk;_Yoº0Æ+ì8Žû8|§x F0ù» à²ê ¸Ç­¿v©óËštÉš° ?¸Ø.¯0™kÊ«ù¿X2}EPÜ< ,Îs&ü‡WX(2ˆ(KÕk¯\ª2…ÜBÐ(ˆ-+zÐDpÀÛ[„Û:SÙH…Ѫ ­Ëù½Ór•ŠÌŠ0ƒR¾˰úÈ”LÀÍÃyðQÿ—5¥8\©"—R“åúÉăGcLO=Ê´ÈOôÍG]Â*}UÚQÜa†ÓÐCݨ}ÂYmdàì7*S½6eº2¬=„C•þ¢¸Rdœ`C*¾x ÎÛ8VâKVîüˆ‰ÐÂ*†À:(uDY¿e¦ô4‹g!ÔX¤B4Ä®»ãºŠ«°Yñ2!ká ûÔlÙ°°‡ ¸GYЦ%]÷%E0]¯D.ˆ ~BVÜf(\= ZH°©]܉¯Ë¬¡X(–` ŽXáŠ03ØåÀofˆQ¾¸?|¾xeÁ±¤rI»3‹ .áV€OpÝl¼³ò–ß!ȃ´MÚ€*Íÿ¯øLNc#îP,¥(Dí3‘â¢`î>éwÙ°®a¼¢Ä· Nż‰ÍüSÚàè&zßhîÒXƒøJ®äˆ(»PY=¦KÖ:qb23¦ÔPQ7\£=¥P¶ wFV”!Þ° ‘m;Ijƒ(ì)O§ æ‹ 0$D²?;¹ ‚«úЫ`“îM4òc;ùÔ‚p—÷ƒ4Âh}T1Ðä&úR±ªaQ\Úñ9Åú]Åÿà=‚)á., å›"%¶Õë™À£Ð&À~Ø ÎÌY0Ðêõ˜•ð€ža'‡°:M(ìÙÛ 6cÀ;æ»S‚H øF˜à‡¯ÙÃJk—kè±X8YíÉ›ð]´VÊ\{U˜×ô¼v_lkRb®ôÊ(bpmvÝ´Ð-+‚„™¬·LœÜ#çš®þ‰âh ec=`Ô¡g˜[9šÃ°“¢Æ-ƒà sˆ}^^À…™É¹3I5„aá-³  îý¶®8!¤ ç*r¯ˆ¼ìL’CEA¾íAV/õdŽpÂÝ^ب)ìJÑcÅ(zB-ó+ÇG%ûËJîÿT)ækÓ&–ø‘P.Æ_K°‰s0ÖÌlŠ=·8áXP¾hÍje* ã±C: °€¼LÍÀë‚L —­2LK?JLÊJ¼r»Ç?šm¸iÜd‰ˆæhB^Êò/J€"«¥¨®”_€D‰ÑÄxK[œ»tn‡ ô„ȱâaõKåH³êðÄVF×h +^˜†ÏÜâ>ÁfCýC¬qññ¨;¹3ôdˆZn¾ £ikÓeC4LH‹ßù>ÎäÉ…z|‹4çz¿ð5Ðy7ˆ«i×lÐÍ{ú¨?õ§ýÐÿW'",'˜{l ™ i"°€Ñ؉È,Ô(£™ýynvÿ¢ ­œ q‹3ª÷îs‰h+Oq™CŒ­9ù Éž“Fº{ÌÜZ¶Ú±6oý»Ý! ®¹‹ùÎ †¹ïò+ßÇбþ€urUÕRÂÚÒ¬„ø}£Ó¤Kk)ïaƒ°r ÿôý Ñ⟆ ê±bÁ† ø&N‚ï>! 3bì¨pƒG ÿAdÀ`äH(ÿ™ðÀÒ¥Âx&â±lIsäIO+w‚Ü óæÎöÚ£72½ UE¨p^Âÿæý;1OêÕYç)1Ê㨋?nP@dè_… †Æ8!UÞ=üÛ÷ÀÝ÷–È“ÇÂíU·,ªþ'ï‹ÁóBÿ|¨€Rà?D+þ‰ PY„ä+VHÞŒ3"DúDë˧ïtCªG«n­pòŠÖúrý;Ø¢…½(ùª.òÒ/¢$¾RäGž$—wPè¨J—-U®T Ta‡"¶L®ÜàÉ»÷ ÿFÄã'~eÒHéÙ:UW ñÕ[UªA鉶G­&Ü8ª–B_YðC+fšPöÄЖTKÄ5WsÍE…pɳDb'ü•Xb²°DUVAði !(gEFÁ ,Æf™hùÈBöÐøA¦¡¦ãi«©¦Ùk±‘˜=-õO E6Ú >DdÑEm$„D#U¹‘GÆEðNAÁ„’t_RÇÿRP]þãÃJß§?×]·ÒPì1¥ž{(%US)”ŸBöÍÃÕ|…%`+e•?´C,<(aÀ÷(tO_~!†X†#ýÉØ(!d"èc”]ÚiŒÑXdž ÑC#­³Ò…>.´ÓjùDqäH2îzZ W%Gõ”lrÉõ„Ò t’sñx@˜×¢DÓ› Ѷ(d¦š\®TèÉú#E!ƒ=óÀ‡TUNÙgU½UµÕHƒâSËDjˆ!úTh{ô°„ƒrÑeØ -ÈCá=cŠX_ –ñTö|ðÁnò¶¤fŸqš©xZä ™6‘ÿ©Ü¸·Œ f0Ê“Œ ”Q3¦ŠÌ?rA«m‚L!J­ê8@+V%QUçTñ@ƒ¼¬ –jßË$V| ÂQ밤όÐ#8aÀD9µÜÝN>¦E‚hQ‹\K^t¦Ì<F*É{ATäUð¯€î¬˜BâÙ'üˆ‘¡ˆrc%Br$µ;‰µ¨ÓÉm}R­_ÿúÖÖ:Ç”(I×?TEw¹’Q¯DI¬½÷Ð#,Rˆ”(Í´¬N¿ˆ*F©JYñ¦B‰i¦X )Ád£ùÌgw*È4„ *[ˆŒªÇ=ÎV9«c‘¬O§Å”ðAlBàÝf%˜ |#-àpð"’|FJ¸‘Ø)$ž¸äJú¥ ´õ&šüGsÀÅ4­;+Y¨]›Eöä)®œÊ}’ÇôÎ2OTOq0"R‚ ä`kqWJÿÁ°{PŠÀUnŠÓ´Ì-‚ëKü3Tý"U¬Qœ‰òG"}àœy³+g%£Ô>.fä<Á…$4Qb3æÓYÿks£ø¬IhòªÑü©|ÎØuÄJŠ-SÎdÇ. —IäzQ>Ô”] °”¢ ¨>LÁSP ¢^|`ïJÔ©yøqß‹þÒ k¥*v›Å Ž€IŸ[FUÐ>°2 >\þvÕÍද¢‘=x4#£`*³š³CšD‰3m¦"HfŠi”͆¨M—°í±(’´².WvÊê'HŠäî9Ó™îHz÷¬\åswÒNƒú\ÊŠ^wB(%½AŠ”ûC„ÔbPÙSld¤©åµ Ä- K1PÙÖþy(7ý“ÿæ1¿!¸93ŸÉ5M$¿ÖÊJŽwÄ­ÿ³<pŽ#ÑÇf(1è©Æ¦4(¶‰ô¡NUpé¶Œ1¥9Â,KïĹÿo¨É´ët’Ó;énx®žó$¥(}e²RÒsS¿âz–T¦ò€( ²‰D6ì2ÃàâßJ­øÎ6Òâãí›B•ÿ ºA«¸’†ÎÛ„•<#gňaÎe„­æŒ"’Pâš1´©^‹¤†4éê~4š"r\ã6«ŸÈ}ݤ!I-?G[Îédc©¨f;:gÿ–‰)ÿËñ­Ïx£0æWhuŸIHGÍ®è=èKÝ®§Dê¢DœÙ÷v)«ÕA"­“0`&0øŽ£ëIâm—´£4spê¶«ò®éqåœ ùÌ Žï±%>¦D}¬ˆ°¯Çx&cè÷ða¶"%ö2wÓqd,HäUuíÇXfI§ÑMR_¥G‹aÀbVDÿ¬œ[Pí¶½œfØÔ­€:) žÉHœÉ A”ôDíUÚq•‡smÀÖIJ¬•ÀÛ JÒ• ‘-ÜNœ×HÄ]ÅÉJz¹Ï8Yó }qÏ?ðC¢h[h@T8Hûè…y˜û ÈðÊáÈÇÿÎü©Ècð”èÊŽäŒþ½¡ßA(Р^á˜Ï¨š:ÝT)„ð¨[Ñ­žÝ£ARìÉ^G€Ä³ŒP”dŽeyHGZÅuˆsÏšx‚ n׿m‡Âí^AÑÛÍÝ%Ä+M\8™¼•>ˆ”E†!L> ÅG-ŒdaÄÌHáŠågEXOñ”hÌß¹-2%Ó«ÀÑm`!­”FP±‘© Æâ\ÆdØ–ÓÙ›Ó9Ý%%¬¡2Ú[|s‰ë„ÐòÄîa×üDMlM·`GÕ@Kš „òbS¸àx啜0"ÝÑÒôÕÒy‡•ùÝ¡”ÚƒI-S¨ÿO\„™Ì`•ßàÔh – Óƒµâ¹ñT5@äÊ,nÓÑH2ua€çŒJç à™¼žB$£º­á?\GÞ–m©ŽqÕ¡•@Ört`ŽñC×YÙ±„L„¶xÀKÂî 8Þ•ÔàJÀˬÝ®©WØPG$‘!¨ŒÁðà)D|!Ê( çÈÆýmØæ”Öfç+¼‚E6 Éf `®ÞÕ=à2¢ap\šraÕ%ËtF—Kl£ñ°DSZGîŒÀ© —t å$º DôñÌEV JÙ»Ô‘*EÉt¦!¤…ÊÄÜT€iâˆÏ]"k6m,º „Íf‰dâ¹…!ýHnÆÆd8Dk˜Ê„®ÀpZh¼B„å5Ièf<¨*ŽDB`G*„Ñ‘¡“$ךÌáq9 ­ÚuµÄš åοí -‡ b—yŽDQ¼ò$OyÍšy½ TÄ ‚ÿÍ¥¥…ZT@>8Q{@9Þã=€ÝC;½“ÝQCHfèƒlÎ&Å™’Pk@áHl¨ÓkhÆ+,À+PBÜqnÆ@FX É?Á[’Ø1²^¦è1ŽHþCêðeÒxÕ5gIªP¨½d ÅäLÐdŽ)”7.æ®I¬5ܬ±Ç#–Ý1ÊEÅÀÅý\Y”Fi'EÜPŸ ¨ÏÈõÙ?¨€®K>ZýÈ&RRdék$ ÁÆ?ЛB¨Óë‘%Ô)%Ð釶+J8ÚT½¥Ó½BŠ'·ºž=5R¤bšì8ê²üÖ@—5þÞZÔÔô }I7Fj§B"2ÿ¢QÀ ÜJ4é|š”†Ê˜‡¢Øƒ•BϬiÀƒ¸l‘⺓C ˆ.ªÌ‰ìJâ¬I„ªÊ Xúq'ªÇ>è‡ú)rªÂ+ر ’* k²¦,Ô!V#E ?!Ò„•Ü!&©+Û½¤O€#NÔŽxÎ+zîd^¥#ÝÍKD%…’ÇW\„QÖgZäƒZøà4e±¹Âú]˜âñLo“˜„l®Äƒ™è$Xª½ë y,IpÊÆJ„%½aäT¹€ üBiìHô½©‚´l€ˆ«ëD`‘«ëæ?ÜÀªAM'õB¥„ªÇM¢]Ðþèh²’¬¸GMß» ÿ­ÜÌÍç økZ Sà E'2 Áö'Ki©à´ÀôV‘Œ/•N½"Å2°J«ChF ñ­ÆÒ›Û®Džägœ&«·RUå‚® „Þ¢D±(j#!K¹’«Õ$º^ãòý!V—K$¦Õì¨Ðz*"6_^Q…œjžEû*X(VÔNm¨xLSÀ¬¬að×\üÃaŠ€¦-5ýÇ¡‹‡ƒ>hçœIc³Â­Šüj40›¢ÉÝæ‚nüŒ ðÔ/ˆ€¡i,D îùH°Ž$MÚÙAWãTÖ¦ ˆµh'ñÄëùÞÜMæR é}¼§’^„€¸Í¡4ÀJ)SÆÿKB´­JWÌ—Ò ’|¡DR¬„a›åñTi©HÆþiÆ*à±*àßšžçœ‘¨€%ðN²rìq0’ø e„°ÞŠ€ë-êIÆW‹Þ¬ ý¡îx] óÙqW åpÂETœ(™¼˜W_-ò?ÜÒ%ñ¿Ní¨ E¨ü’^ÙÂf)hi¥ˆÙ %cȈîÅ¢í®–èQknîÄdøFåB>üfÙBÂmˆrl¸@RËÏüÃÿi î$‰ÐÆ(ÙŽ ^‹˜Xê »d<°©é(!ÛdŽW_©—ÓZÜ…ÅHŒ…œ.…lS’¦´Ç<ˆÏÿp<±‡¢Í“áè.«Eýlÿqªl|ñŠ0›âínüQ„öHœŽ, ¦¬>8Á‘8˜† ì†ÞfТZÉì)ê¹”ÐIœBøñÜD䎇JtÀt"ò-æ÷æ0S¤‡ôÉ Ä™ô½62g¾ãD):…:Ñà ”æPÐê&kéùPŠ‘HË¥‘ÙRäÿci'*ôc›® ®ë©Dûò¯´@ ´BDôŠð·î¥aI•xõšœëÖ§MðläÊðv¦‰bê&tg.{ Ei&©$š¦B0ÂÅ€ÜÔž.:ÝWžA¿@>NÊ\d ‚eå?þ”-Žù˜Jï¦i©°©è}°>ìòÜFÿhhM(hËFô+9Á?$4W/ÀC'‡£Þ[Dw-Ïæð!Ôïå\OÙáè4/EP0…’ÊËH0Ù{˜—Òî_ŒÜ´þ®–¦Q ›–ê4Œ™¢-DŽŒ¨”P7P"¯ªL(ò*$j4æ˜Fpzi à-ÞVµBlÕ蘆#Õ¡uÐÖ”„BÑ•ºÖ°2ïŽZŃLV vy@8â$N|]y@›L2!“ב6ÙÝ!©öZöÀtæÈ {˜‡‚Ô´iÒôá!¶(6,›«„@.@ä°,É+ªéâRͨ©ïÎòô2jüQV§Æ˜fQoƲ¯Ä2eèr‘äÿêé/À .rÄΦšG$Ÿïaôšhô óÎÔð즺µ:G‘õ¶P(©Q`óú¦£QpóDà øu@¢E¨ 1%[é’áÁ–¸\l²Ý”¸éŒgi¥¶QöB\ST5¨´Þ8*+äkÉ‘T˜Œœü±V2!‰n“BÒCLem˜6®ˆÀ"9ÝWnGÐ!Òl Íšk´(nㆠuIÍF—™H¹¦z´˜&SÄÉÂ%Dýd ÉEôõ•eŽZÐ™Ç E>Xé/Ù4‰Ç…d(v¤Èé \Qv uâØOiÅâšpoXR]ÑŠüÁÖ„Rõ4ôº÷hgúHŒŽ>0ÿ€=•°p€5©_g%i˜ø^€o t‹ˆRyž‹¸`æžGBÑÒúvéz¨š×f®ùâjÜÄyó#Li{a‚T…ÅPHN?LŠÃPV(?v ÄÓ¸ m¼–8º×b‘¤Ø¬˜;˜~ðt hz`‘¼“„àÍ£æuG$•DÓfòÂNæ@½ ­Ÿ µˆ'c*:ÅE‘‚-óô1âш”Z0ÂÇ|ÇX_tbôÄZËà9C ^(ö?@u ÕdSdœeÛ¶sû®Ð,§V……@ ºÓ¢?E ЬDÞ†ðB6½±§“>‘ö¶ÿ¶Ql?Kƒo'Ù!” ¼¦Ê«˜Å‘|ý™/miFQÄÁ— îD@éJÀМé<„Ÿ+éÆ6…ä…ÿïHȈ6áµa»Ù*K‹ÓFA$IíÞ<>c@úㄊ-¦Ÿ­lÞNa>8‰ùûòå/@3Z@Œº~Çì_.ø&e£kù¨eùJüÎï„'ÿþóTaB… ÚSè ={cTñ/†ŠŠó40¬UÐB †&| ø¡‚½ çÑã—ïŸ Ž*ì9ÿ\Ôuâ6 =zâæácA` 6à²á¾„ŠñþW²b„ 41"žüþñ2áA¡ „¢vøÇÀVe†«Y74Yðƒ=“ ftH/c ÜqÓSá{^A|~üˆ`H‡ +_˶ÇHïËÛ'4Ô´§aIÎ{<¹ÿã@@@øïßåÍK*¡jA©L)èC”þÌ\'£týgÿë¿ÿÜ®ý—«®Üê/Š\rIo¾»øs‰´âˇóa sÌ1„"+ì°Æ Š`"h„H³ 4ЊçŸL( žxDc!L#HµÖtTèÿµ„hó£‚zÓ-†ydúí¢‹ÂG±Z¡à‚>`¥bûÇžt³'Ÿ|€ë¨¦nʉ‚¾# Ìð Ê€€{N@*©ªœBdN¥Vp¯ ù`Bë>þô¢G¬°ô*À.?¨Ï‰ˆ¼ê2—(\ø/­DºÏ‰¤âãG„|ˆ` kL± #{ÌCPZ!ÐF0Á„Ì6;± V_ íÐn,hÄw,@W… +è7ÝXÒ`Hþ–ü'‚Ž«@9“f›@6èá²&™4ˆÁ:zNÈn»Êl<¡xâÀ¨y>ˆs)÷äúç½–ZH¾r97½ÆK??ÿ»/Ÿ(üâ.{ï &¨ÿAûÍÇ^ºt¡ˆê´B!Ž%uIÄ2u¡gÔ ´O”ÑE‚xíøÆQíÕÇ“zÍÙ“ªIÝxˈ¿Šþ©…IâF’`%*©€ ˆt Ÿì±Ö·0±Ó®'ž¶ã@ÍŸþ‘ç¨.ùÑ‡ë¦Ø¥ê=ª‚©Ë«ê«—ž°þQ{¿ûÊ Á‰®؉x¡ºê²Ôá|FˆxJþ‰`0&7F¬TÄCÈ‚ÇþY!Ì<È,žG?û‡F‚Xt™ÅÌMëÀÆ\ b¹5{ ൓ ¨@é¯,H{°]¢‰*¢G¡~ž’÷šzdd.󩉞k%ªvÛ{È\ð‚âà»{䑨ÿì¥Þ›j©;ß…7¾\B8жÃj í?qoãôª;Ñö nÿQò™ááE`@ÂÀûÇ‹C|T‰Ñ˜²6 ¡anr!“Q¬H†9¹h ¹ÕIG¤µèd¬ã ¯R²:‚íd.+C mJXBÈsjr‚à`xi#Mò4å)¯';q^xÚzœë[KöD@v%d>чWÎ(yü£ X  2–õ!ä^‰šOêR¥èà Á ò78IÆTRHâÅ*E–Áœ¬bdv@E ÈADWA Qs¨ b<<¸BÖÅà 4 Eè#%-©qˆÿH#ñ½¢1âÓZÛ dÓºâI"ü1·tByÈM@SAäq·t)NxÂAàƒ‚ä‚ly _ p¢éÝ« -h¡Øcó˜Ál –ľ´(‰âG$ô85N1BhŒ6Õ¸˜S PÑgd”ÀGa!¨{¬:&ӌΠáÌ<’¹‚ s ¤=M–¹E*M2ÿxÐ29%•Óš'¹¤ÂŽh€†ÐÀ š@¦„p'•E™ÞÏE´®ñˆð!AúÅ•zñ²¾Ìɽ€)LcŽ%˜Ê\æ|rá„ù<ÊIÉéðòÁæC"Ȇ·ÆÆ P‚ÿXUÿ­XÄÎ…Ô‘! ÃQ®(È7†lšY•Vg”Õx¼±DoückN¶O,ì#?¸! aÐçH$6˜Ì™ k2<{p„:4¹Hò –©yçj>L> R„`E)&ñ^—šxÇ:V/!°Û~XZÙ„ü"Aÿø…rú¨8ÁtˆˆäÇ §C¥}Üi W+Ìdr¼`ÈædÁËyÀF¸ªj¯F`šËtà2ñ€ŠTõ™ËÉ1¬_ý#gZ3œá´¢­)L´p·INvi"À+DÃ4J_„;S“Z+ÝÂ¥sá‰{V!éæu·Å{Ý+ ÀjJSfÚ×@ùMâ~r!‚_\%§J“ÈVÿðSe11Ñ7³¹`¡P5’«ÕfLdÏÚ²ÆjÛÂÏ~TlñX«‚¬*¬—ù-l½)’¶"[X’k&µu‚ëÆpÇ7†¨FžFJ3ä[ejå››.¦ì)>úø@“ßeK&²W‰ïŠ/–ÇR·|åˊaiÿDµÁYýéÊ<•à‚p“ þÃB"ðʤae*«äh’ÑèEüŒ§-z5çØÂ4ÜÖinåÛáZE‚®þ­I‡©h5™G+©…¥âmKLUv‚,dP뤔m+¥äd œg¤´Lʪ镵L9É_\J}jÊR\ãºÖ·tgççå‰ÐÃ/7(ãc“M+[8H³' ‡hÖÊ4Âv­Ía„š 8‡6¸¹=çÖ×27òmµluKI“óÐY\ bãàÁdiiÁ²i~“2àeòÕÊW êƒÝX![ªãÃÞªle-WÊ9 ”ÙÊÞ ×6¥ Ç…âÿ€ÀùCáºùm>&µ‡jA*cšÉ™È΢QüleΚÝБWˆ¸ ByÔ¼ÓæBgÍþñâ 9ä"aJèsø3ª?*ØÖV/Q‰¹¢/ÊìûRÛRáUæRÊî½×Ø’)sѽ¼jJ7ýØúøZÜ8Ç[` 8¡:~“Ð Œ˜Âmˆ!EõˆZîUáRÏ´:Ÿm¾OPÞ Ü–<ËÔ_ùoûüCÀ§¤ 2iQwÒ–Æêï½úmñXF)öt¢LÈ!´.ßB€KØMÕ¾()Bà*Îb^p‰+E‰ªBø”,¿ÜÇn’¯™ôaù\ xZ :°dƈ lp®1ÿ06D¨V«^ !,ç©NLÛ@lÊOÜÄ-W|ÐH§ÜþçÞ/!ª–“ž£%¦eZ¦$¡,¼²%Ó~¬ê$êF ëjOöX©%Î…Êh))&PJæ@.PÉh !æ£@²ÌÖêË@âí¡ šØöbšôn¨ˆ!ãØ°ï¨âÙ@Ls˜ËÐVcVšÊüÏoDÖ/çv¤ç*ñý|‹Û6à8$€YÜ-gêï6¦¥Ònì~ôèÁVÈX —  \jpëäõæá{++ÊÆYÒb+Ìâ¼ÔC÷”Â)L")æ'¥,Нí¸foP‘5ØœÀ§ð§Àöîÿ¯oÍþÐØÑqt¤UhVˆ.ªtNW-+ýXcΊÄ(ÏI 6ä*¤å>¤%¡lì‰Z‚xdâÿ€ìÇp¹Eë !t‚¼8ê*Fj‰…+΢_‚*º†"«¬½pém(.NêB^â÷Ã× €FŽ€c02F€R24Db /«hÐôañ ‚d¾Qsl²üʱò&1ýx’ßñVxÎlA4t‡ÿYÞJ¡()¡ŠÒê‰\õ&j?hÈR‘XRÈb!NàȇáNM(pO’¨GÂ)¾ˆk$à=Ѓkî@"k@ð8ËÆÂùÚà7òžM‹M!ÿ2®O8>G Íû¯UΩžhÎDr’ýFäü$ïüºm5n„ÛLÈJb(‰?”2“0I® ²•þÁxîÊÒ\1ȨŽ:nl}©«M–GzÈK©LègÕæå*^ƒ)Ø-!è$-Mm.¹f*èE@ø\à.AHLg(ãT0°IÁªBQ2Šå*£Dˆ+VSFƳžp2u…2×u„ÛÈ Ömþeê³)3 *— 4[â7&Šê¬ò¨NL~l+¿‹ ºƒylÏá$°çGì€o{˜B]®Ç8ñ䣔“k”“³œà(ëù¸ä~`:£Ù0$!J‹ÍÿbeVFœøAEì‰c¥‘"5Ö‘o.ò*³2ÑóçÄÍÖ )_xøxÖ¦>¡C/æí‰ž¨ê8‚ \ó5u‚õ¶å‹Â@òÓNÉ•~Hì~oáäåàÔE ƒ‘8ÕE.(’.©"4  œ¯€Íô!:¥ó§4Qcgc§ÍTnpT.«^ŽFÍÓ1‚‚ÖsGpî)ñýx®4L¸:@wä±GÒ#JL\(x *o¢45 ”@ƒ,T2༲'´®;®æt£à`i)ÎË–†“ ™*ލNÈt.¾¨.¨BRŒáAKʨD7€*AYcðbâl!@ƒEbŽ¶Æ“Žÿê)©rN5Õüˆ!z”Úøg$ Y¢ 7‰\È ÓÆÒnÂ]£´#¨N^¬—‚êJ UÔLpà, ®Œ²VߣB%Ž–Þƒ ‡Sâ@0MQ‘:œ¯ÌôÍn /Q1VTµH¨˜ÕqXn4âÖ‰èâ îŒ5´µ5¸MQQþâÛL¸ˆòt˜…hÂþø“N€Ò5˜NLX@„v@õo^Yï^sB@N^¿ ‡¤MJ©•´àþâ‹,* ½ÆF^€Ì>T? äF€(A:GKˆO»q¨°iEU Ñ‚bÔDBÖDJ¶© Àd`ÅçÿÜ ž¶­GÓqQ31³Á_VÃ`öCÖêf3é3¥…gÿÌåH-•ôS^Iñÿoõ”¶ßtµ4U¥f<’®@ R– ¶ ÐC‰€³ÕäÃ,üåÉÐÇ9;¢ è¡R2e6€bJcã$Ó¨Íbð.¶ª±o iFH¶Âb„<‘ðp”tÒ1!°wòÞÑ âe¿÷ÛD÷€kR™ /7æAh§xpx,­gC5]Ô”:÷j´#;Š‚'Š"i/ ‡rȔƢ>o±A/”kÙåz@Jvã#ìäå>ü%šâã.Ç¢#LÓ×0%0H´D#àšYOBbÀi¶¨©ÿ°­ øÖñ,/pËQe±WçÄq¹—[+Q‚"`­LB®ò±>ƒã”Ô…„¸]K•õÄäh9×Ó’¶Mü­ °ö>­£²%Ê«ldwk½f)8ì äPÖ"n*¥`îðˆIP/ìW¦Dg€<ä$A€àìqZËz "æöŒ!L dG£Ð¦J^˜=!e]vqÁ·ç$ˆ(#µ|!U$ØM9Š*‚¯¦gëS*x¡X Tôˆ‘Ø ” ô—ËĉC‡¾ÔX)*¥ò{V­8Ýr.b,ͦGðw%^áM³`æ”X;DšÕx‡j;ùg€6 x«éF8#Ísz[c 4¬2ÿ³µ5"q·×{Ý[¯u|yY:SH¢´\(]ÇI1É’õos7—iQ“5'XIɤe/i»E'ú7!ôsàZKÎåà\=`ùà %-ü!pG„© ¨#"D4͆×bY˜CO ‚ú ÂyGƒæh„…íIEL5ôèýˆ2Y&|ÙSà 5R?„\Sè®â·þª,7]íï®lúÆ,W?¯FuŸ8'hKK)• P€õ“žBŸO©Ÿ"­—`âàÊî, ¢mp ·Òù qN£Sp:ú‚7˜ß˜Ž¥BHe„QƵ2zaDFø–…‚4­[q%esîmØÿ7qÛq7‘Od$”Chê3J/÷rƒ§ƒ'lLÿèu5ñíÿ°ÔTûÊ;„¢(Z©»Ð¯"*ÛB/>à¿Ç,º¤+¼wªk?nl?&ª¢ˆI@{¬K€— n ƒŽMë$/ºó„×6Z¬ÒÉbŽ4X…Z“&O¶p·y[›5ü(u!dö1‡R!ÕDF¢$BâÆ™h/—J~¸§7YTL“ÿ—¨µ£z•LÉ”K¹ tt!ªádàþ$µ»‚´IûOªXLÚæÆp‡‰êJáÖàºA ¸ , D¡†ÍŒ£ÌúŽ%7à<ópDœÂ&ÿ i…"sND»£Ù:p9L{··e.(IG=ºb »]ÓÈoÂr¥d¡ÖÆ\%›¨í×^ÛY;¾Ã;ÚD€àè›5``>t’åO\©-ôãC.N%+¶_q |Gô©3­5$!@$G„›5HVVöxEøéð'5<¡V–µ5ÜØÜ0q‘¡-»Ã³óH‚ÇÝ’{¶•zVhÍe%ÆÙþp‡±q"ÉZKŸàÞÛ[â´ñÕX¦I)+JÅDŠ–`ê>s¡ß (Ji‡©W0aeÖv5üô›ï„óV4ø¶Póz'±Y›»Ï¡»4¦{¥-C()‡R!ŒÈYÖÕrÿ]ˆg—€h¯†’‚ƒœƒƒ±é•iÛy÷YÈTzôYKuâ z¿ZÝZ;‚É•®° ¦î`½ ˜¡W@äDI¨Åüôšo×I£FÁ÷z©ê TvØ!ﮣ{5]‚†’üo$B4´È B“yü±ëIܧ¿½+r©œ\<ÛÓ]Wâ9Šö#8NÕ%*"$ ´ŒàŒ)½[†ŠóT.T6"ŠT-äj±°ézš¥‡ö’¼MbÉ?KäÝã@à…ÿÞ#°aC+Z¬Ø¤¡¼ [ŒØ¤…†‘ÿÚhø×ÂcMîe4v1¦D ÿÿ6D°¹¡æš<7XÈÙè¿› TìÐp„ÌxñL@iÈ´Ó†PLT41ÂCE[žüëÚÐW™bËÚ²õU&Z¤H·v°e®­tÛþ³ÚÁª‰¼y%J¨ðaBCFóNü3<˜^ zè1rLʼnyŒ>„x\˜…F ï-YrïÞ?Ñ O,1ý¡j>ì,™L™KZ„”(Æ!5ÐkHOC cNþóü¹ ÌÙDè)1çŸÿPoh¡¢õŠ7d÷¼EðM«>u*1ÞÓ†VµJôú•Z[ò™7Dö+~‹oï¿E:×\ÿØe×}±eUE|ðAC ÎSbÿ@6ÿDöHtÂdÚCX† t‚< qFšBŸe˜á¬±ökÐ%RdF'´pÂI'Ü#€}^<‚a, dÜ?²ÕøO<=WÑOC5ĤE8ýÃ@w ÀçA<üÄäT‚á©gUU@^–Ò‡ž¼§ßEem%VZn]$ ZxI´ßE^VdÈ88Á<ÆÈ?1T蘠‚J6cýVQA’Êóˆ¢íöI¨­Ø‹œâ†dECÏoO„Z‘#‰,±Ü y  åL•PBñ´“}â…÷T¾†ÙexcîZÀ˜eŽÀ–|ð¥ÉUžd5›VžýÍÖVìñ5`¶wId•=Øÿ á†;Y©¥¡(h1º™ˆUZQ‰ „BéÖik°J„ãIŽì“rÇÁuSNw“LNÚÔÐ ž\iÑ–KUõ%`Bñ”Ź×Pby¥æ›râ©ÖÈÿøŸ[q ¸WË|¹Ü²L,(Ø?„IDO…‡V!be8=JÄBAžÁkh -¤£¨‘öZj-$o¨"e°LMœ`L7¨ uk¨ o`Ô ÿÜÐR`‚T›—^Eñ{—Ú )KåXñASžkÞÍÜ[{ul }ƒsœå·•ý£3#Žf˜<V*Y ô„ðOc;Sú™ˆy&/¥;›&Œ¥‘½Y· zÿÖ1³’4É*åM 'Ó?xqR‰¦zêýcñz™©v^¥y²Wž¬©æ~Ç×üYõ h‘³Û†jWSõ¹ a@@Y B¢<”¦oQö`®Q¥œ·Z‰»ùæ4g£•Z§®Oô¿˜ìà$¡¢Éde+Û1Œa1YÓÖÔ»¤ôŠ9æ¹x2–ž`¥- PÞÉþ6½°¨)oïA“šð6­˜¼Ì.{:PÌx•žx‹A6 óÁˆŽRë«”ÎcF#îâ!ÿ*’#zuf‘ZŸxÊ.' ›Žur%²áw9a@Qàc¶Ù¸<æAOÜ*¢¸§-ÐKËÿ ß³¦¿>÷Y–L\¦B=]Å{RÁ?þ4Á@€ðÖ0§¾Ñ€Ê0ú¹Ú%©ÎTí0IˆhDcþ½‹!Pìä?‘5¢DÀvHÚIN ·»UD* aåEÄ$<ºIY„ÏôÀ=ˆpRžµ¸… .u +ZÑ ·.ÃH€ø€ã>`o…•ê߇$#Ùì7ªGÜUME–è3ÆXŒ8qsI£qÒ“ìD’udE»š(PžyÙŠRø *c#ñ†Ç¸é)+„ã`Év9 Âǃñ@šÆ_ÖmW{Œ‰=v4˜f6Ó iæ< #7ˆáæ<4ÿPoJDiý;ˆ"3d èïCžÙd‹þ£vþ ¨êÁ(ÿ±xFi(¸³{× Êí)(Þ‹ÕÏaYD)ZY–§P_NŸ1QãU¨ª”Ö¨)öˆA ÈfJÀˆHY‚ ‘”ÓäPd˜ ñpõ[¢qrd¥íïs¤‘GD"¢S€Il?jM¶C²Å:DÉQ¨Äœ1A¡©œ5Û|U‚v¬ƒTÒªLØ¢-ÒÚG)ªüGâPEѹ©À "Íܼ… |«!`ÁîÔ¶ŒCL XЯF̓#O³¦h@´Rkú“SClb¯+‘Ÿå¨E¹lu(ÿ<ðn7hmzŒ7¡ñ=i»[H›ÕlÙ¥˜5òj–î{>únnâÑ€\ Ûr´!(¤!'@¾ ÷A€@ƒ#×ñŒq;3Z_9ð\˜†4MK ò$Tĺ¡Êv 6Ê?v;À"P¼»»Ë&uŸ¯l*ñš ža±mcGá%WµUÚÀ‡µåXCÿ¡”xØ <¯øë6 àyÀÖªÛV˜ …Ì\/ð°à‚™!1à ȤGŠ@W¿Ð|æ0s¾äMyú\Ä$FR ð|âÙøTÅ¢¤bP‚Åé0ŽfóJc²ÙŒÙX"8f{Ù„,d)ÿ”J™¦ ’ÓVd˜7bFF•,U€<„ –)Њ´âõÖ•ÿ¡Û˜™ h†àŠy°€­[ßI=ÄÒ8Ÿf “ëQ¨ôŒ*{ì`fÎ ²;JÚÕ(-ö.OÞy6*…‘µÑlgé¶YŠ^YŸîtಢƴÑW©íDï“Ie` ¸¾H­uÝŠV¤â àu+ ^ððàh]¥pt7“Ž¥£ùL³íj{òÚ­Hq¶#0½‚UG‹FÑîr¥FÓø•Äó,SO+j‰ªpÈ*¦E+Úÿ±ÒmO>¯ Xð °š°J+ 1„ïýãà;‰*‚P ÿÿH³Ãy˜£!ÎÙÃì:¯[ 3Gïø©Ç™dò+z÷”Öa@•~,“§ø±!*ÀØÊU(óÐ(+¢õ?š@uÏÍ©½Riôä€ßK×-Ò ð†¤" yú?¤õ$a.AψH’,¡ #‡'ÉN/ˆ}ìKxLJ¢»‚½SVžØI®øƒäÄÛ1¬ÿáÇõTZ"üpÚFýéä#Ù¡ðNJ{øÁd¦@ßÔ”.žð6ÛT c GÈ·Ðs e äÚàOz*,õË›¹"i®äÖ—"¼²t¦ YÃêï/Q}ÖK’Qžcr"A(·&7°Ö€×bÿ!ÀgcPZ±+ ZqiŸæP QjÇr<êf•V<Æ3wö ŸAT¶o‹'I×kOGp”÷çw~1uQ§kõÀ~=Ó:±5™‚ñ"ÿ‚÷wmýy¯—+CE6àÕ] ƒdå…üp! ÒÐO´JO57èZHÖ0 %­•F®õP|çwF¦€04<ÅP”Æ+`ñPVe5eÝ—o‰GIG~Žƒ“÷2ˆ~ÿ`ƒfÿ!’3ñ!çdg8„I7‰7ðhadJøäEãÖVU(6s^vöP,X†¢–iúÄ| –i~ׯDL&°¾'#K1‚À1RAeGx­Fwp@…Œû’ )ˆºVuA `—t™bŸ3ÖaÖ(vË8kâGad6"yã6`84.ÄU!Œ@Mn•9ãH…÷wà‘<³¤wÇsWáZÆC™u‹W˜Ž½Â_½RV1à[÷0Ч”*ˆh“gŒ5ˆT— 0T9`u¿%ña„¥ÿH˜¢S(À‘AˆàzWt#9’ܱݱe!B\DÓžW—ŠÿDnhŠ4©6^u“˜FÄ1XeT‘ö“éx…|™j¾u‚úf™J  ƒ 9–§™ ðt u¡©yšÇiö\)/ýcq¡a—’X¥P–Cð C°C€C mÕ–g󛯉…R—´™š¡Äåyá—!нRѧü 1¢¦Fî!Vô˜dÓYЍ¶€ŒÉTOŽû´%þH™Ýw‚‰§žŠ÷ @yœ)å÷ 9Ÿ Iu¡uCPÀÆAP„Ç /|eqçälžt“Ñ( ÿúÀ›úðúˆà›%‡€–š Áxìi™ !f/@\bÖ’”a¡U™3)1aÕ|à!jÄ”˜0Tü£ð'wg*p£c€½Be‡v˜žß·oà‡ÌážGJy–çJªy7Xpšòð{¥HKdq£ç¨@-ð*³‰ùðùæóV!ÀÞ6cjS(”ùŒ9`bñGð¡šáŒƒôLŒÀ!DRžâAsí1 -:Jæ…nH£öà§U(1p!ë²6ÿ~j¤(¸žü–xïh~GzyT'ˆ¤:ªê×€šSZ¥5—ôaž´5Ò8ÿ›@öP*9ÓŒ!¡+p€¼Sá¦J,Œÿ°9°p¬ÔvCwSÁå¡,P—-9Ž|Y1P£¤na…dX‘¨[Rüà§VÈ€ÄLÿˆ® Xãz@÷£¡”Cšûv(ˆ28Ÿ§ZŸ—g8lÔ”H¢Á"JSDòDŽ0¥A«Ö(Á!NÓcZ"Ð]¦Oæ tüÖ#ÈÚ[ÔfÁo ¡oúxjˆ„b3 !©1!ÓG&[ò2ŽÕ.%p †xÊY¡ÈíRI¹oB÷œª”EZy÷ê™øŸ÷ÙR9ªPûõÀ§9¥\I²bY"-EyÿW£g ëIgÚg -ðǸk³ö‰z!†8u¬F`ÈŠ·Ë §Æº·­Ö"ug+ɲÕÚOʨ;Ê—Î$ãˆfwY(kžW(íz܇”— x8¯œjòª€(ù§jª ±Ÿõà ýY§ðŠX¢!¶ÿ b‰$ж}\ƒ¶Ad+A#ÌÑg1á,AzÅ{—#ˆp±†r1Žò‚¬F°ÒûÒ›·"ˬñÿÐjÐ*\Rªx aR(…’­Ѳ+Û8 AŹ2!9‘{”݇”Ù¹BG¯ u¢k~égƒSiŸüʯ¹Ÿ«»p[Iÿ‘ÓØª³k?ÿ „1Á ª‚I¬r¤çW[0`˜Ò#ð\àÁk`I» ñŽpÂŽ ÂŽ0 MàÂÆKzœÉ;kÌnÄÿHe;½Êª¬!û¦Ó{¬ÕÛC\ @|SqÞ A\ë"©P\³1P­‚RœAN¬Ä¾¥;ô[_Œ”BG¹”d|SHŠ~ï)ª•Àÿ+•oü´SKµþ©×¶Cá$.E»A£)!¶®±{¬‘‚L5âÔW-‘¥.¼ÈY´J4 k¿)“…"R‘·yk½ËŠ*@¼½ú¶ÄJÜÄ% œtiÅ™W'[—öŀ ¸'{Òzÿ ‘ëÊ!ƈGÆûfÆÁE¤K{I:ƒ¡ÉÆR+À¤ l®A œx¸¿ÅÇ1Ña˜"–-áµ!£çu¨› 1È ¡È.õÍõÎŽ|b5³ÖVmu!ÄU¬=r·z+ÄxkGlp ­µe—’?¸²µË"ÅÅ'Ëψ÷}c¬xoJ‰'¯Û‹ÆŸË´Q[ª¤êolªúYµÀ`%¢ Alú›Ä§ÓªS/}lñ{Á$})®‰/ ¡‘¹?Ð ñš-•Ó²q ÑŒ³7’JáLšX!˱1!Ï™¼Ôz+²-rË¡l±,\HYÕúÜX €‹ÿ§á{²x›KÆ ½x‰Gôz‚¥+y ú‡ò)š£ËÆ£û¿ú‰ƒýy— zmÿySÁ»D»áRL¶Æ+z\+„,Ȱ)ͺÓ6½Ø®ZÈét:cf–÷Sˆ`ùP3"Í·O½·ĞͱÙÛ)óš¡Æ_<Õ£Ú ÝÄ^­Êÿ¼ÃŠ—Ð#›Tö¦*HÚàžñ9ƒ•·¤IšlªRKuõºm²¼ÌËIU51lÍús°âš®ÁÍŽ¸ØºqºqÓø‚Ó ÑÇ9£p Œù‘´v—"ÅÄüÖÔp:ÄÔ2‘Ÿm¬Êø›Ö-Be“tD"%Xœ =ÿÛ›JÆ‹×Ðsû· l¯kÝÖXÑR9ˆ—§¤ü´ú9µmÉìÄÿ‰&–µ4­µ|5h[]ÇÒ÷r…¼4Ð#ÒüâŠ-Þ4î»QÂT8TǺÕV™ ÚLÉ1Äó]#I}Ï$Ëß î?#&Ê®H-­´,\¶ ŒòzSê©‚)\K,ºÀ½Æ¥ë´]ªpáüªámËf¡<§B‘,»uÎl‚Mh‹Ý¡Ø\ Û=ÞÓ QÍBM…è´ý×eÁÄ¢­ÔD>Ïñ]·v;púÉþ\™¯œ¤¡Ï±,­Ã¦¼\Ö½©ojê_.ưo€(ºœIy=ÿšNº\³ŽºÀæëAp ö 7Ò°+».ô‡Æž50ŽSöèÛMì!9¥pÍØŒôÙ kU9 ֌ǩNmß’é!‹Ôœ ÕQ[ Û%BФL\xZeKé¹# Õ$»ßÇÉÛaªÁ\y£yº²µÆ-8¸nTë`K ¼ÁuÕhçK4«Z‡=Þ¼ì$íˆ?È¡Á:’#­Ê\Ôä ê×k‚èkCPˆ æ·ÕKmDÞ±-ä$F 2ÿ¦ÎŠéþ]Õþ¬Ê³,­`ý}JÙj¥Îo­šfœxI Ü’w¯d.ÀaÑž×pܯ·ŽÜS»ºiÆÿpêÃ:Ã^Ò³‘,-Í—ä×¹Ç.]"ÿç•r#¤Ü¿îÑËí þ*š'~@·àÞ#=äη˺ÉÎÔE¬¬9ðç{k™É÷1lòÛ)–)¤dý}¦Nï¬-toªê´¿µèÀŽáTÿô8HðÿÀá¦ÿs¯Ñ¬ÝÄŽ¨2‚Ó.5NMÄß-ûã Ö$»ì/Âû.‹föëaör?µ¤Û‚ºå u¹oÛÛñLÏØkäðMýྫྷ‡äÚ›ê<ÏøUÎ̘߹Ú"êéß—Ÿ‚\ÝÇoa®ô)šSÙ´r]ÜO›yLªÈMú ÁÑ#ï ‘àß<^üÃðÿO!…ÿ8pÈáC‡ ›X¼—‘¡€†ÿîyüwQ¢D…B„(@%G–ÿT6¼'o^x@x‘óE <þÕ#ø/… Z!qE¢ä?“F:>í˜c_ކR­î32U«T…T»r€Õ)T…Ž8´aÚ%n•èH@n @¤[–@Ž#wsäØûïHB¶þ‚HE¶ab¡ €èøø©dBAÄùg½Ÿ 빪Çùg‚!>2åÀð!LŠš|ìû5TØ#]ß& q5Ë•O Ük!Ä ¥ÿåä¤`h…˜!ÿq„Áÿ4Üšý*U­d9jŸÚ5êÔ°986´ Ñ,Sÿ¶ YÜb¡0íÞtÿþã[bÚºƒ›MˆÃþâ ±çžc¬9.ƒ¬²æ*BÇ«,³Ž8c.´˜‹Ð „–2I5Õ&ʨ‰%,Rèž&fkè¶&\[È#†>’K!RZ‰%Õ<"@žj*nˆÏ 0àå jˆ Vþi²&/8@¯¨£<¯ð›Š«®öù'¼ðr»î¬Øb¡„øÀ½Ò,É,´Ì¬°ª” «ÅJ ²zº§ôŒ°±)„P ;«gÃÑ‚JÀ åÒMFµ*êè"_«-Å=²”¤†r<ï<h y‚ aUW ‡"‹ MÈ!œûÉ\‰R¡ÿëâ’Ê.·k(«¬¶ÛÊc§2öŸc¯ìµ+¹¬Ž…÷àbÊ.Àè¼04ûðû°%°;?ýìóOÍ,óUÂ@-tÑÑUh^Èà´j)ª¨ÄN<ñ¢ZPè5KCrÑ#OêÔ—8•ƒ 2z¡Šk¥IÇ„äŒHŸBÊVr[¹@¹¾ðûJ»ª¶êh,’U†Êb±<™åë$³3Ѽ«.±õVg¦fÆ\¡s(—Ê 7äXÃD'lî2mÈ1Ï:T´Ñ¨>2ÔVK¬‹.:àÞô#OÍ—ld{Ô|ï1õG†hò§‘æ˜jFj2†8r©ª†%KËÿެDÙdeÁÃOåÀÐj‹Ú6™ÂÀ°½Ô,À¼¾:gksH°¨ p ôJè ’u"—–šÐ Õ…C$0´º¹z^HHkQeƒí~-5Fì_ƒ3ŠñS¶ŸÊ¥ß"ž›É%ºŒ´Ü›S²2£¯üç+z™WÃ¥rªY¨®J÷ð+ñ;ÂfjQÿP¯ó °òüM¢ŠÀÎÂÀÌê‚¢AÅÈx r`u ¬‡8ã Ù­+P·sWg¢æ hÍy” ^ŒÑ„ãÅóÙ:•šŒ0¯…¨‰¥:âA™ÊHÕݨ;u B i…¼ädó Ëd_╱®ÿbDb5Q\'[KüâS—nANgé©‹`øÒÁü¯:βŸ] ³+…øB!Ëèuø©tÔ£®Tg€ÓQÇj¯ÒŒ¡¨F¥!/ÈÀj*’²x'üF:µ°…Qj$©µèý#õ:ÈÜêѤ¼ÂO¤‰W…D#5耯=w9œbžˆe-Ή¯DÜ}ŽpÌ€™OY>$ ,ÒL?qrÓ`4˜-Ö%Ûcã?¨%36¤HfD êAÔb¹Î(Ö¸ÍAD4zWg0ã€dàF0ùˆ¥ÔÙ hàmPÈÿa¼…H²kqd‹R# y`ÀaÈ€9ê‘ÿød ¯ÈÓß„’( é‡A ÜΪ‚%'¶¯•,³hÊb–ZÆ.õ[ýôÇË8•˜ÀìVåøÓ—„¬Ñ€É0%™:3@†þžò€Z`Ôti ÄYµÜ9¦ð  ¿fȺS!bkƒØZ°¢àEÄžËC Läqªº–ÔÚ |2=yr\HÈBCé.§yÔû~•ìÀòdKÄJ^…¥W;u%~µ¥.Õ3K]V‡*\œ%êJ §ùG=×F3͆8ÀŒÔ$‹/X÷ü4uté(0 {u„ ÍÒ28 5z¿!á?40vÎS!ôxg Õ¨ÿHyö”¤ eÔ‚y@]¨KœR/ ð`¬L]ƒ<”5‰Cp€a2ÞU1/ëEc‰¸© E~€ ¦H?ÄŸnô,¶dlœä#Ÿ`š¹¢ÎeÿáR5v¤HÌYpªL Ô¢!¤ui»0d¨FfwZ#¢l5@w¬Â¸Åm à™Û©®è)öD›oä‚äâý¬¤²Œ…Ip†¬ˆáS’:³7P }Qä"ÜJóåÕp¾:"w„<×®üÏf¶D2œæ»Ñ´ð‡¾Ll’ Ë`Vî:¡&éö Œ F­]5R€›™FêX1ðÒ6¤¨5+j«b£GâLá8?Õ ßr~gTMؾFDõ¤Ô¨ÖvªH Aà@íå² 8 '³êdb8é4¡Ä9M‚+R‡–G (XãµÊ\¥Œ¦‹/GFò,K€d²$!(U)a¢lÒô¢„Œ¢yNéþQ$eöº€»æìL/äßÕ†š±;³bžƒh̃NÀí?žM<[ÎNp‚´³}Û{xG°Ù*$­5yLlA¯åH#°(‰@*ò%­xÌßZkÁú¬e¤FŸÕ7¥îx‰W×’YV  a¦zÉ ,|ÑdRZ³š°L !ù ÿ,éÿÿ H° Áƒ*\Èp`­†#B…ObDž,jÜø/¿x5²ˆ1ò_ŒŒìÙ+ð_È—0âK5ðGL˜ â£8ê_Ï9_nÈH°ÃÍ£.AUã “'S~°W_…¥X7޲™3èÃ?¾f%ˆÏP>ÉÅu3#F<ŒÕht„Çö`ÆÐãDߦ—œXb²DŒy)¥VÈWáêÜǃL5ŠæÃ[ÁÖ„,P¾ sŽê‰ë§dŽC Êå q„ÑŽKûø”¤SÃŒŘú¡eU—¬ÇÒÔ|úôÙ³6—ZØðyùçŠ]þŒŒ [¶GÀ ~P;BÇ7ÿ8øvîÜöZ¶´ œ;Ìäî‚8Ÿ¹@ ŸZß¹vçþê>Y”gØ!4Ÿ-ñ!ä‰wÛX'œðÏ1,ÁÂH¹ùV" ÒÞcm…ÏAÁŸ@[Õr"A?ÜðÏ H 䢋/nDâà(P,ðÏ>Fpß?ftÇýS €±]uØu%„BDåA\¯Å÷VƒŒðáMšDá ,YÂ<(õ–{üXåÞW'ªøÏpˆÄHPИ!†üã Wñy"4 Thhg帋žy7Dêà +0°%1g_BK:©¤NäÙAlyåj DÔ@w¥Á?ÆDÿ(á…Æ`ØTýÆ!mŽEQZ%NW‘Mr¦•ä‹yÂacÀ]ÅAˆD‹È‹Pp`‘(ãºæ§Ÿ#8øšR°‚@ y6ß@QFö©@NB)`Aâ²®ª þÃÀ•© ”ïAäFd yñÅ—_ä F™,”ÛbUuȇásÙˆõDì!„!×Jüc.åcO>(Cìf Ukí >¾Hc¸ßTHwyd×Gm°¦›vvVžÊj’ÆéÛ•ÿÄÕï‚Y ^D«ðÕÿ¼ +y$ÑUJ{ñc¦U‹q#Ê)V¤~2[Õš½ ”WAä3òÉ'_m5wÿkW*ÙƒÕ* >° PüSÀâ1å¥Ì:ôYHJþßÔ5å?Aÿ(v§6Ío¿œP^X0ÐÀZ ÔT˜´1¬›bmNÜ+d=mSr7"©Ù?HÀؘzÿ|P¼ ôä57^©žWkº4-K#¸Ø&à‚cÝTSUãáx` –nàÙæEÃÛ$¼ÍÛ¾¿ iõ@XžZÿüGýk‘ ª'~õÀƒ›‡ü2› É*BâÍzØÓ˜›ø‡'þAZŠn$'›\K †¨@oøQ€À „&QÉ?è^ kÿ€‚òFö—¨¤üP =èB€†˜Ç< ¢‚@˜MÿD ‚ø@ß»Ðr9($iŸû\–˜û…n, ’Hÿ–7zXÍ`®sJSžòy¤g*ù¨?Z’F²ýã+ãÊî0Ö²j}¬OSœ@G2¢p›a^ú¨<‚©yë IB¦0I(4dÄçAC3VÀAù`>FàDŒ`Ž3_¢Žµ–%‚Ê SzNF†ò§ýUL»ŸPE:Lr€ÿ8àIt˜žô¬q1ê1L¦™²É]ÐùÁªeˆ<-Ëx+éàë^EÂä]m„+Tÿ¢yÂŽ¸¤/ò`Á=ްy†Œ ‡Ó „àˆXÀLÆÌóž˜Òù@sÿ4µ4Ñ}î#%çÜòJüäJ&¨¥F—5×PB:< #ØK ö'ËB¢ .³O|ú‡î¶’quäRJí¡BÄ $  à{°@ã\aÈ)yœ@’á@ZB©èÃOˆPù·D„`ç:Oì§ÐÒ(ù)¤&0Š+ÿS….„`WÜ^æ»í!æŒgäÍE_BÌ'¢å¨Ö?@:»-NuQ^àÈe ,.ñPLzªÀvð8½ÇŽpÈñ*£@èÄÀf"Õ"°(¥Ò­”ë•dœ#ÒÇ«¢¥j^9¹Ô«±‡e»—ÚÿJ¢¼DëTzéÁ±Gw6i…\1-”)ny%`ü¢5¿°\5t¡ ݎдåy aœòÇÞã±A“=Ø)RÝ@”Zªd6)±Ÿ¾C˺úÚÑ$«]…íB§æ’ ‡)ÞTèñJ¦ó¹é£L~…"Ô‚Á Æ²WlÍ5³e<WÃëØ›6– æ4#Kãø¯y}Ý^.SNÿw‡!$j)OøŒ½îr—½„LyAUªÇÍ2R„¢«YR­~b5Ù~±/¦¡ ¦IæÐ$$\ȯ~`ñ¤˜GR¦p«å">Id‡K @Wý´ÿ…1è)Að{œ d)üg cìùš#ë fóº u·œ„‰lmØ›x.`+X€ùì•DS’öSì…oh 2¥ùæËi[¥_L•¼d… Ì$ý.¯–˜ñêð€ °–X  Âi…pbˆ3w7—öˆ=N0XK ø@ Æy üƒÎ÷(Á,š(ø¹ÏªFœJ;ƒ¦ÅæT´@OßÀ¢tÒùÔ÷©õ t‰Qb˽M”,ª&Køõ@V]+ñ¯Ô“=)_ÊÈÙ¦D¶ê<à²ó!üAˆ˜Ç,Ü @@’d•Ç<ì6ј¥.š@ Äy4Ûäÿø€¦B°Äa[P!rw¸p‚ ±‘…x™ÅÓ|ñeA<dw¿ks’)UÓj$#téA>:oî nnVƒ$_yðt ZáŠf¸­Û›»ðG2­øA+^ty\\¤üAª+€£œyäa,Ÿ=„@Å;¬f£•ÊÍ‹¯‚ä°UmŸ¶8—ÄNgKqã ðx#KZ¥ï…Ú…à÷•û¦¥}µcoÕ²{*‡ÕR’¼ä1"‡ƒa…³]ýLçl –±ŸØÄ ?nàð#y„Z€!&pÆþ£äÙû@ðlH†ø€Ü_U@˜«zà0/áÿ %û*²¦»ß}¬„ OÎ25sd”ÄÎ5Š!³D2k’Õ‚xâ5«‚.¤³HHT¥tPØZM“o³”_³Tãs‹˜…B̃sQyÃxy ö† m¥Q‡kÇ9†ÀXþ%Sª£Ûu&h‚ÁA“ßÈÞÿ(/ ­°&SЈ«v07@°GIrsxÅ“F7r­p × ç–@×`8&J2Hˆ$ÏACÖ4TD ù%–ño±˜OT'‘1±…ôC±•<˜N‚#hÆXKÐXö@a}É—&ÈðF#2G?ðÎÖS…§R‰ã’'ˆÑ‡“ q€­ S”D¹·YC”­#[a˜i”p}×€ 4ÆY ‘.J”48–i øFè„ÚQd1jNGj 1‹S·9Wyñl%Å<su¼¥h"ŒæÄl÷ :Ñ’ü1ÿ€ Ö‰DÐ $ÿàöXx™81“((}…XgÑW  D…—xª67‡Ñf06šùpTGOB ¸``ç…O˜r Ì!ŠOÔe’QŠœã•DK¼ jFa ‰U«a_T%€U‹ª2È92‡\Ùïøj=ÅXùarŒÕI{™;É Ü 3Á"p9Pg)ÁAŒ Æ“8I“„(™£{wˆˆ€2}u^t&””Ø$üpTÿ@€ Í À`°÷„YœsL¾Siÿ8tS5èÒT#J?I–cÉU VPý6?©±9óac‘Xª€zª“gxV)šyqÿBŒ/ £f÷‘£GÁ—£Ñ$¥a©`61?0 ‚óð6 UbWÑìÙ'H“uú`7'E‘„ƒ\ÔÊ¥Ðp ÿ bê!¾´0Ã#ø‘zÄ9U¤„tB#‘¨r¡÷†_qÑŠª ¥*|Ê–0Áæ<Š„`%—ãµ¢ “—0Y®e'’@¡§1vJÂEòfa=Ñ£ GЋ+1G¤K@‚ȪÜXÀ0!€gmæŽM¦R`ÅE,´<¦iš"JÀ BÅu23` jìE„¸y,é£>’3’¶›P§ŠH6­Ò­U§‰.1%~ÿí¨-4.ñ%Úä­ÊÃz´EV‚Sõ¨žÅ„"÷†mÕŒnøß©$2" šö86·H¦Z!0Y¬*°Ó×]f”5yX‘UC'F VW™¥ˆPD @Ž#šk2±¢2 óÖe#˦ï3­œ«õtS¯‹DÁ§5{… ‘³äⳎ‘R\h½èu$.ê¯{×AÇeI{_¡®ß¹vQ;W%@V+ ÔH!)Ai¤ ¡¤ÿ ÷Ш‰-ç­´Z81ò"€¯Š2ü`2«#LÓÂ#:ºiŹ>Ÿx²Åjc¨(+¸ù²]åJÞÁ ²˜4;Øÿš­Á¶:ÊÙd#Ô…ed—:u¹Ò—Œ ö¾ðËegc¡ ¯#bà£ßxóp!·u‡10Så˜{÷µ“ÔggÛvM‰óCº¨8Éi‘vÓBúP|>À|¡yg&c\rcú0±¢t· ×nœÖ9ú’ÂXÒ›rÑÓ z«Q¸Š¢œ±8ÿ05\h¾¼XeÃÆ0áô¨éÚŒš fJA I¿Ê¯`70ž9`µAX&æf$d5Jñº;«ú4yôÀfZãR¡:ˆ¥[ØÕûìÀ[N oi7y'-è6 ÉŠÇ–FŠoZÞQ§bY–S å4 â³¾ÿq3 Q€³…±uBUS„ˆ"PÖÑY(9‰Û37 ô»º^D½Üv529.7vãá!vc2^¤hÞÔÛÕ²jwíI@B Ú·ŸH–ƒ­Ux_åZÕµa 1o‹m…?­8—îÈŠS7þR_âÁîXêCì8½!I%@&ÌÆXCL9~i£½LØri—#7|ægº³+%Nª»CA%šWsÛ²]70TO~âÛÆ;B*…x+YW%s\÷*òç-P{†ö]ŒÔEk¢æâf§fÿWÅY4ØQœŠ«ZÎ*ú¶úÂæî„øðÝU:;»­ò>¾;‹Û>«³;ýè4œN+– ê¢î¾‡¦kœcw’„~ Ÿû „¿V&aâE%´<Âd<¿(Æ=xÁßG”¹¤5‚¡¶r34@:ÕX÷Ð8¥SåDçK`ܪ–É Ï²b¥¨$+òø G , &@^YWöæÿDd#zzJֈǑü#…NчœÈ/ÕáyûšÞƒ “·ÐˆÊ`•‘‡:¢ ½f4wƒ\㔉gbç‹Q÷¨‚Ä5ªúŽJX°í<vI²_r@B‘Ü`Ñé O”%“f‰bá’Vʳ/ýƒòZ‘X `˜è1ª†ÁG‚4¹íC;ÄÔô<Ó0´í-¯±ƒÔÇRÅ(*™ŽÐ²84âô /ùHD"”0Â&q LnÖ¬D¤[ibÄéøæ¥ Ò,Z:ËàFh¢ÇÐÿÕdjñaÚîîdHâ­ …¯ #Ë©ÂD9%ùT>F@¶¾4Š/ ’^'ÏÖ=Á¹-S>”¦øå"æ-0ñ •Ä8ƒ$ªà<çyŠjÄ×Êà}ïkh§ã›RÐW÷äˆqFÁ2’l丅O ²¬—ÄÄ€4ë }äh9Êq#*¨c€ò˜GGU'ÿÙ¸B”ÁäãMÁ8ÉYNJ4r#EXÀ#7"v®ä›²-.M h@[¥QbZºØi4ÿ[Êä—<ös4¬`¥¡ ÒÚ½Vàƒsn$´(,ÂSù!({ â’)[<³ZÏçÜ3,zMÁ®7™ªÍ*Ú áPÃ7§Ä@ßÓõŸrUt~|ˆBô+%Ùoe­@‚åL‚¬{œÔ:F€ wû3­UÞD*i«²’–ö ZNQ]vÝ[4´d½ï2Ê`i¹M+¸9míq?ÿÿ@‹~Ç7Ï)ˆ(^ Ëé õw—P*#‹€ù˜Nb¦1õÇ7fÑâ´€|‘#éõ#7¸Á\þaˆÜqs8Fà?2 ,mÉÃL'ˆw§&žë‘'îe)KUï¶Pm%éb!GÆÿ¾‘*Õ!“úTvVrµG"~d,òñ¡;E1Šq³ö0Eç“û³Âæí`/™r„­@³ÖwX6ÈYL'÷< Éýª‹Ys(ÀF¬w&×Ä’hukQˆ>8Û R+šÉ·×Øšš4ФDúUH§·[;Ž€»þÚ/[³¸¥b'p'çÁ2ýùè:è㨑û‡ÙrŒY‰ g«•‹[Ð!Q˜ÿŠ•Ç° ¹Bð.v± òcȲºº²%y°¼y#±HC„vC„)QˆX)LÛˆ X#-i ƒ½6¦{¯=2Àºù<©—ø½ФÿÀð‹Ã2¸ã/þÚˆ l;‰‡Ѐà‡ºÈ*¾à‹c›žA3Æ <ëC9¯RÄÁ³z”%z£•`=Ʋéñ¹=2 ¢ sû€ŠÐˆ –Îû<¾Qº¯ ›1 ™ ‰¢šð™Ø»½J³½û0“MÅ2Šúr@à‹µ×0ë/¶³Ã:t» äJà²à…Š|X-Àø¸D³$A¼kÄÄè§7£°®Ò;l ÔH«Ò.rüAÒaGi#Ÿ[½"ÄÄM¼"FØEÌ˼ð¥Ï«€‚·õj: Šˆmù‡[ø™"d‰Û»=³0Ê m@qq5tCe‹Hd» >dÿJ¨@ޏ .£OXÓš~°;z iŒ¾5»'¢>ߪ¡Lé1¼ÁH {¨ ã/?;¿G !ô ®0)íÐ „`ÂÓ+¿2„±cTk ²Ç5•²¦˜¼À0C§PÈùb„t‘€à1ž³‹ŒJ!Uˆ8°ÈÈÈ×F[+§FòhY€@ŒÆ3›§c; i$¾³© D”ëcè€é€"Þ‚9 Ç@¨yP(I¬‰ò·t”<› “"ÜD…ø€ °㨈“é+ X Ñœ‡¯ð (¦™À‡¸ßÀ›²ËëÂUKBÛä­·ÐJRäD¢€’>ÿé[¤WØÐÚH]S»[“¸Z“¸¶ô€ЉX¾×Ú9F9«ª0JÁ¾~3Ú`¹È8Lã £Ö¤'G­Î惾¾õ¤M «‚éÔLŽxa;Rºq0ÆpVÜóTA[Ì uXn–ÏÍ ™¥#ŒÐ¥aXúð¹S$e+¼´-Ö ƒÏ!ô‚#ô`À ÓàÜ]^ .c L!¹í2¶LKj=F§¸‹ª×Aa§EIŽÈ^™ŒÉˆ³ÿꋌ’s0²:äI5¨Ò©x]ßoñƺ–RˆKŽ´†]'>ˆïÒWÕ9 ë å *ÛÊ݆8ÒÊ u8YNæÈݰìÅ×P¤ÏjÖ Nà» 4¾F0Œk\Y~Á2³ÎoôX9˜-\§°…Ù¾—ã­63Ï!Œ×ÀX«z®Ck ›D~‰¥•€H›Çy–{tósi,ÑZuÖ™^LVsµUFˆVÞˆžËduࢠ¡~Þf娏óÐÐh°·«@[³Ðj¤bg!Ýp:C´Ú^ Ä g¦›»á—q\޲Oã±F ô".FGÿÉÜ\s£‡ @Jq.Œðˆþ‘€Õp ›]ÿuŠ,¼ ¸‡‚ó ÙÉ9ya5aÞ³gßËŸv•ÛW€¸â¬Û¦F*][ËäTo@}iœÑãÈãíó”d ˆÈ m¬ˆnOî{D€Ù‘ˆ1¨½Zšú³ ]< ÄMq8ú)Dx’ß땾zU)üÏðŸ¹4­µ¦˜nÔqƒ¦5=“!þyTì{YÃYæçGQ$h8dËãcjmˤJ*¾£'ö•`~”½@L¹\?®­°zŒhkÄð½˜Rá‡0ŸÚ>(Š QÃ9–ßL„L{*0Ÿ ­pÌËN…ÕÿÅ”; e•ÊÂ0y£¨t ŒâÙm5´4¯|Ó}þiß}ñ2Fêò¶S ËAWª²DFº…CEß  2cžÑQ`-©×¼S”³±YQºŠ>˜÷€œÁ¨G$¬¦IŽF®UòÔ7r¦S®ølë/ÜAŠÎ Žcâ–1„ ØÃÁ‰š€ˆP.Ð,Pª¯íYG‡5 /¶ÐÝ¥?@ÇæçïŒòÆe8L¡ÏQC7§EÇeŽU…­1 w³ÑnE½Sj\íÞÿFW®ºY˜ã ÛòÈ ‹ŠN}d@sõ6_¡»¹˜uªµP=ÏÀX‚Õf}û ÿÔí.*Ö÷H´ÊÔš¡Mªü¦5dÀ5Œv=ßÝhìÆvŠqZÖDÁà:•[Jtà+ÎÀS¢~$s×Í €ÑN0‘Û¨ I”ruWÛ<ïõ¾xaÆ_6 RÜ_Ps a#†b„¯ ¶æmøü‰š³±É~ˆ‹¡²u }.ã°€ü}¥ ,fÉ׸¦˜MÖÔkgV«RÅŽS1~ª1FE*oŽÅàW°Ó¿ÓfÖ™W$§ÊœÏͰ€’t”fÔ‘Ã÷QðÛŠŒÿfÈ`¹B.¼G!(GQ%ªèTGnÏm®ÜCû€ˆ‹ªy‹JÒ‡FùŽ`’–ĮßÿðS­%€é¶)mé 0ÔøÐQÀð;Ÿvà3ùé¡qè°ò^üF¢ñ§2}ˆÝtŠ}! a«|Êgœ°L°êí ñ„¡Œ. pDgêè›ð5+´4G/›põIzm4Уâ"}(ŒÂ×°á? ­(úW¡Â?{Œbü›wâÄ¿{þ‘$92dIyÿ–ücq‚EI’ò–¡¹&ÌóÒó߈V¬@Dៈ’+~þ\JÒ)Ó>þ9]ºTÕ U"’ºˆBï_‹CäºA¾ ÿðý²6*\’nzZàéƒþÅ3Áׄ¿÷ÂG¸b <ÿýcscµŽKêAÒ^\’ô0Û‹±Ù³Šyž9jè¨ÁcÉólÓºà…ú’þLÛ "‹?`ŽQ:¦’r„”‡Se\–,T"ù³gn’DPðIRÄ Ù¥“\ðT)ÒÌ%UÅÄú¯Hx}úB„Õ%Ÿ>D"l8Ë->·lIîç¯Vü?xÓ^ñüCXL~1eØ?€ýcÙ? Àå dÅÄ@1(^ošÅ`=ÑsZh¾©FÒG'¬ö ¬µáDA!¨—Ptü5ÁB†ÂO¼et"I"•d„IGü’sp±pÓM%å$žUÓ •[QU•tCRò%má!µB—Ia‡ÿÔVÿä“ =íÑ…zd®àƒZs¹µÁ}oñUZ$ÑYR?éERQV’_~1x†?Uøc‹1Åfq1òÕ?~¦IŒ„öÛjóiZ¥©cAk§Tÿ4dÁ·éˆFUš¤HÁý³‘AÊ#ÏK¡Ø’KË% “sŒ˜ WnòMwÔ?G åìuÖåóOl%‰`ÝlL-E›SùäóUXkàSt+ÐGçžýí÷_fýÑ! „6è ?mø Iv ¡¢ú{a¼$UpoT½aFG‘T"Â_uÃGžŽ¸YAN„`±z×vÉ«ëE&ùÁíc+É!Ýó¯.yêÿiL˵„œNÔF%u }ÝP%ùôI@d3Iù„pìO.|­ONˆUÒ´.L;Û›X€Ö\wò·_Zl±Ëîc øO†|Ö½‚)¨!Ikó[¶c‘5v¡-öþS@I‘2¢¬ötÖÙ¤¡mŠâ ªFö8±¸Å2¥SQ€ˆ!ñÃ#ÐG:'OÉÀ'+ßÃ$ Á¶´RK#ÃüSÎ%õLnEmÓ<í‘ÔB ôÌC)¥fZzÿè“W`•Å?JÃ^D—¨Õum%¹‹×âñ ¡îåàÜ·ÝWƒ vàÜŠ6¦»ž\ =ñè —F$Yú¡‡ó”¨GÎm¦ÿBöxE2eÅdÿhåþ! è£GòKçlº€ Ë2è¤#'&GÞOB¤hILÿˆÐ  »ŸÈã+ I îÑ䨄ÊûŽòÒD)²Ì¦KU; ÐÒê•$]`»SÖþѧ˜Œo€1ÚÔÖ½’lhC{± ¿lÁ¯wM†u£ I6ô¾’|å+ ò#Î8š†yf¨1‘ßüW€(Ì‘‡¸Ñ>j P„rÉÛ?J’%,Á‚PÉ< ‚y´Ð…2¡Yq22¦div'!ÒJÒžþ£ -¬aLÂR»cM«KäÞ·N®¢ù„,\%€Ø5üÌeÿOò×ä.’Ph[ô@ö$Lµ!(Œ€!Iöå(¹é‰.ëã ?d•™Huæ+JOHŽH,ŽÈÇ7½%#ùŒÐ]?ðØ +À£ië7K8HК‰=»J $I’“'M«F×¹dLâó;¦Œr’?©á$õá«ü“=aiîpWÜ̓‡ÿˆ%Ön)ty-ÕK—.ÁæK ýÉ0P\[ƒ¦Ø6¾„ñ'^”ÐK2’x1&–‰Þd¬ŒPsR#cþJ£œÑ[ùÚ©žµ”‡PG¹©@ObÕ œÀGZÂ=8py>$Y$'_¸«œ0GÏHh-× ObÿÀ?T¨Â–$_YäíhÉÔgô8ATæB­nÕxÉóŽ,…èQ­­]ÑÓ~è3¶ s{ÝC2…)Ì}}±_‹jŒ„ʶ~¸@ gþ±SÑO,1(Ñ Nó!¿óTê™Q˜:ŠVé¨"q`IôÎh,d™–fàÉB'% h޵üI’VÆyqÙ!X`&NÆÄ[É“œ–x2°ËÊr7Ä®eNýZ»’( ºÀ‹@†ÚKÚà’=Œ lQ‘ S¶!’ä´$ÞÛ.3? Ò4›ñÛ7]à‚ÛÆ';+xÈZ$Rª“h˜ú‡1N°„&ˆ„¡Û.ÿ=>…€õ‘-¹‰¯|V‘jé¿Ð’uÜúAä2åƒ1"ckXm©–á)#X"ªä¼G>ðA,é”ÄÇ.ö'h±eI¼ó6½ÜW³QA) î•¡ E†1̤©cüÍË`ŒQQ?6vЧô0ê©&œ1¢8Ä£çܰÖœÌ1‚ª!fÉÊ.xÞìÎÇÄz±KŒ³:ëàŒYehtô‘¹Aí+ ’ßS³öx’“_qìþ±€S²rZ¥²«NB }AO®ÏÕ<ú<[æG.C,bõô¤˜|3¥Æf›½žx ,NEnš›úòå_6›Všöøðµ;³0Ó¬(4wƒž)ÿü¬Ô€J¤ˆ|«˜¨IÆ@tI&˜]°xu¼RI’¾‚Vê e+Ršî ÕãV¯šÉh„5Ô„g¯¼ÐƒOÊd±“âÙ#vµ8›j e=ýg—Í´“”ÛûØ,Û-A„ñ^Lr:(ËŒÙQ[œ)Mmú“6›öÃØf­ è‘s…¤RbñŸ·ÆeÛøŒi±82„*×À 7†vN¢QB’ÝQÊh1>rj×j‘äG¡À“"¥ßñø«™ëˆflæJ‹§I†·[]\Ny­³£ºÉ¿˜ŠT(¡K¿¥×Allž˜bÊÓlàóJû’Y—2ÅBcs ®7ÿSÆJmΉêÚÿHáT~3Ó¸†§žSQGaËDz²À@«h˜i7ˆcbA’­lwu5Ú a¦¢¯*g`B ³þ)ÐiñØ®p5Þ Ñ]V%Œ~ZLº„÷’ĺžžÈåKø–è |;ò;A¯;ˆià€¬ÀÚÏ™™RWÛÚÒÔ<‹*•ó†=Ø[ü€·P&±…ä¸Õo1:ÙƒÐÄÔ]Љ1ÅWÍÑØÜÄu䯵@WxˆÐOX`(Ä=±ÌV¹ âŽÅYÑD_LPÂT¬z\Kö*¼%\‚ BÙèM¯YY~H–©ZIS Þ÷¬Ô€ Þ-ñÒÜðÿK^¤\ýåßµmFj”Qjq„ÎÉÊüßèÅ`Pˆ[è>¸JÒé†:U@NyÛJI8 a\ÿL oØÕîÌ‹Üë¸N–\Ð î„…Hl•‰©ŒLäN¼Gl¬GZ˜`GVèÝ?\ÂEé%X– Ø`ºìZLLÆøK¡ÔÉ¥âO}5†'ÄMwÊ?¬™4ˆ¥hQ•¶a†6ÍÃù?èÃÿÕmEßñ‘Ž IDr‰ÌJ¼­Öî I œ¥(àÔ}ÐdN² U:íàŽJÖvýà ÄÚxµôUTèÝ)©‚­ùÀ+@%¼BIXÀ%P‚Þÿ…¡ø) õdÍ׈ =ˆa ÓÚÈIeÖaœ¢d¨ú%“@Ö¦D -bJöάÅ(àåÀÇÿ%¢–ÔBŸ!E¬^H×6]U¼W¨’<4ßóMæL€ÏDj TäF›”]. X£8’Ñq©”ü„$¶à$þD ¶…$² $òݯ!ѺÄDd=ÛO(!‚Š 2™b'NHI$ ˜ý‰‡Â@ŸæE¤X„†îÌÖí"©G\âFRÑŸ)äÃE4Í iÄÄyÉ!"GŠMWÙ)Ð e#Ü üÎ ñᱜàít×јãOÄì¤Ê“½ÂRLERîQ$ ÿÁ“EÙ”…_>î#M}ˆelA.ÁÅIÈà>a,Þ4eDDöŽß|XGPd¥„@\N|ÀÊqÖ˜ªXÀÑUÎEè¥ðÄJ4ˆ ÄÀ»¥dI܃M&r%Ä MºÅÄbn %T]Yïu[…PR¤Š­QyÇ;F¢Ч\Ô'SÆ’XàIOI(V kRѱy™AÞMféËܼ‹KeHeÄÃÀP^\À™Z> ¥`Šhdäò"nth‡n ŽàYtFTgþaUf§ÔµÇ<”]Mw¦‡ðȇxtÉ„%]!ÍaREô‰ŽÞMÞéÝ%Ô§Ø`IØÿc}”&dÅ„{µºdMPHL™À¬Áa\”Íbð‹…Øfgá‹nîæ+~¦|ïxFÿ•¤|ÜÀ `‰r²ÅÑYÄE|Àº]ôiU5Ü yR‹M{&EEp]@mIÀ•g#nÌ å‚ÂýÎìÅzú(¥þƒöI…¥^TDl*’ÖcQÞõØÒžlTùñm–D8Q0YVf(6d\<“Ep¥„n[å±ÈþÈŠ¦èÌðÐuèEQبý@bž_(à´™o\<9  "‰ÅÄWlE¦)P>¸•x’ ö Pf”ÉÆ´§¤Rgræ¶`#UHÜu@…*è”$ÖàRjÿê“iª?ò]Tâ’¢ ž è¦èæ^ŒÙDá²”ÁbÛ˜‘Î5,høê"ÂÅ |hn8ÄÜ€Ž ænðˆ¬,ëZf„Ò¥WI4Áv QDGº9×LâáÃE˜lËwøè)Iê ¼Bä,P¤JyR…­;Æ£ÞÑà+í+ØÚ»ZM~MZÌEü‡-MÖ ˆ^˜€Xå½È€ñËdø+S¤j1ê©ÁFþùMî¥)më ÜÀTl‡¾E« Ûº%kæØÞTçWŒ¬r€^i¥ £sqkÕ¤º²ÎSAVdj<’„nID.Rü‚µ ”¸fEÐjŬIX×ÙÿI GðX[ÌIàõÇF1Eé^Ë9QÖ*l¾Ä\ÙF^–FS­¬±È55lÎùÍåtè.v¨CÜÒäTNþ„fdUphUX¨RTÍÆtobºfB渒¯ZÅ ÞkúbŶü:þÞVHj<:ÅNú„Ò$Åý2®8%ÖúèRãÁÅ€ ÆŸDad½DpÁŽ%N•iµ½ž­ÆÄh¤ql¬1?ÐÈï«ÆV€[áéóþIJÕ´h€¤D`A”sŒW&mÉ GE3Çì áðW;&mÒšÇV8òVÐN.jævÝ´PÔØ˜ômª~„ùñ¯\T±Ì“e`i&ðVÿÓX&SË”Ë‰íØŽñî~ƵÙf<؆ç-ëÃñ~0Ýþ֦٠ͱ=,ÁyQ¯ÔÙWÕ0mnÙ^ËSŒ‰U”ïSàì6“„£:j›´ õ¹IÞù@RDÅ8Á{(c‡ód\ Ï9ûg¬öW¡üÄëjHl“=gLÉ”íjWªr\Päkáêky AÄ€^2PËmìr/“ðäI/Þ~Êy™˜JŠÅÑÄ¡Â13™–I« %u þ¾àVLX.bn $sËçþ©,Î?tòFÅIôÐô9©üuÀañÛMl^å…ì‹BÆ…€q+ÊJC#uÚMá Âèm9gn4ÿÄœ¬ìFМ§y[¤ÀÓI˜mzV n £3Ïäld‹ðl‹ ®»–„žNtRжâF2UϽ‡£"E0éÿîã®åøyÜd gÆIÝÍOkOË…å‚ÎÔ/i@žR6‹¼g¤§ìœÿ0Ж°Å °Žü‘ÍPSF ³ýD K¤põšluQK.H€F›– ¿¬—Ìl!Cfñ€Œ+&ûÄx„];AÔxßÃEžDñ”~ZLÖ]¥²[_àMÀ*¶Á¦Y}‘–xgÆÉψ¬‘Fèb3w "pkæ„wI`$¦Œ,Ép€­ b8öΊ™£O ”@] Y›´›ÿV¸ýN{ ·ØhÒÜ–Ò<¦&= òðB÷a”T8:çRàýo€-á ä`|Ù‡ƒÏâ9J(Ÿb„$á‰gõÂÀ2S'þœQ9"ê»7/W#²úHŠÙ¤¨)´¾ÐGèVL¨Øa ”?Õ¶Ð(m·§ÏXGŽJ‹£F(]ZT ·ìdY×Pص¨yߨ[øq9G‘] ˆa;Ö‚Ù–jˆ‚:¡c¤O«YFè.esD5ÉÞ ŽýøÔ@{pUWŽ/L9²ÈîD¤ˆ¥Ìye€‰mWEušŒ†PáŠ@/¥=\ü÷·–§C_ÍùÆòNDÁ¬ yýÄÑšw,Ñžÿa}>-øÕ4ªâ&2âmÈÚìEM¥bLÁ\}án›ï Â\S7Œ¯ƒHé¥>ôGÆNóR‹=0]¤4«-¾9ŽÏèä1Ë@ãO¸lÀ%Ë×ðlÿ7¤:òË*ÏðPš J EÍÐb‘ÚÓ¬—žÔgD˜êôœúW[ªÎ‹É±¡ðEˆ cÃK*ÌÜ8hKØ«øQ¾|öè!TQÿ{Ir@’ÀHVÊ ‘O‚¾2éC„𦈛$eŠ ùó_.™ùdFÉ÷aˆÿ:þ[ú/P„ô H a¡ ù¢0%é$ÿŸˆüÛ`áŸ|×nø‡ÏíÛ pßš‹ö_YOeÿyá!^_yI7¸€‰ÃñKýÇÀBO $K¥ 4pDÇ›9ÿ‹Øôc óHªˆR#‚Œ æºÀ„ +x¶ñßÌä™ÓyM2ÿÕäü!W¾\º’|:5ªÔæ!èÍ{Ú¢jPêÿ\üsBÏ I£úD0 T6.>|BÌ®¥ ÷?³#kOHú+0’<Ì1IRLª.cÀÀÎòËA 5”*"{M4Ò<Ša* úŸZÒZȈ&𬶊*ÒM£ˆæÑ@Äß–éÿ8 é$ŒëñGyèù 9 Hª ér’i=ÇÖ !·6Èï?yçüiþ~Š(ÊûS_}ƒð^@6´l„$œlÿàªÿ)R°ãí¹9ÜéyœÔ‚ùAÅZ1„ãXcÄ!ß÷íƒ":mžŠa‰Ÿ~ü!ÆqÙHŽÔ9©øÄ&>‘vóøfKP!IGZ;ÖYP>$áŠkôQ,à2Ä‹K´F—«ùÎk›ÙBLà‚}eèlikL¡.Ô0ÊÄÍá÷Äc!1ÅV$²g¶ô ÄÆ}¹ˆŒì1ÌVLÑÌ?N ¹{pàŠ÷¸¯~tãÈcXÍÒæ¦ce! IˆãðüDMKùåè”\8á[gb“¥p·¾/-&JïY&,CÈûW¡ÐV(µ9fz˜ÿ:Ø…ºÇC…ÙÏ{¦ Ž~LuĿܹHo¼Âû D¿1IFâ£VþÃWÿûq~“Ÿè¤sfÔ`›¢‘*‘¦` qæè˜&üã˜NAH2ÝsKõE#ˆXÁ¹9õOºf¼:ó—°Ñð;¼×bùHÚKB¯A”'lá6¿Xr3ñ¨@%5ŰŸhÆQ´€B( ‡tˆTï³ÑÈÂù™ÜtD3Ü(§EðJøÑH¦…FcÙäs²sLT€&ZJå)Çdæ2c7ºŸ¸Àhmr‚=€àÇšÖÐL¹‰Âþ„/ °—`àÁªP2dL†æÕ¨ÍxBB“„'ÿgèI’~=5m*êá†wÄ $Ñn«ÂG (4¥òÆXBÿDò2„p€r,“‡oªÕ¦Úà„>‰ÒUØä@ µ  !Ík^5ú•ˆ¥ìÉGBP~¼x»Óæbç¢M¹Ø©kd‰ÛO¨öÐP1?á Ê µ32KÝ ?â!ÎAÝŠ$i#‰B?„°&"/ÒÔ X0®„ÞˆPøM9ó«‡>t$'ŸV3Ê7¥1)Ðú‰R ¢º ôv$ÉÅ/îØ‚\´g+)€– ‚iòeijÀÖ¶&<òfSN{¹L¤zÚ½å=¨_AUÌP¿ö˜ MÆ1øLB+•6,P•½÷ÂÿYÚÒr†aø°À ØÇ·Ž°¹cÄpH³Ã@úS1T”-n±GfÍ‘¬ªS\Îèã%)žJG¢²Ô9!x´®t“¶´ø8¡ N‰ ~‘Ýà=Pû®Öää˜Å¶«]ÕÜÀÀ¼à½·’åt¤cúk=ÎH©¢­×sx¯}­0‡&ø)P~€V B6ï‹k*ÂšÕ¸Ñ Å°¦v[VǤä·Ë™•¦(WhêƒMl ¿­å*}eÛÐ9:º™ñ‰Fâ3¾|ðcˆ­fœØRdá0@’ Ù6À4ï'–ê×O!äIÌmoc'PøË_ïõ´®þSÂìÍÿ^'ïÔDý‹š3¿ÍÃcáˆEÄÒKåè7Ñ€Xÿ!¹Ÿ\!#ñ‰ ”b-0(^J R:“‹ótf)£ë±G*-dj*Ù6}¬¼T „|3À}‰Çe×–YU«¶†C£®we-K’¨ s5¯›Ç |ÑŸQÍÞþá¾} WåeÅ|ã› «@¾éð?Jò³ÎòS½D#uþÜò£…;„Ž O¤[s“6ç?© {Æøžíªj ð#¼Ç«M!ØÔ?[ûÉÔ+½CFÌbf!f¤\¨>¦Ê˜Ê:B5·­Cr0“tPOû‚–°c^3@Ýüz GaÇáq[MÿÛÎþËûÞCrÜ6qPh,w/c>èì|NÔ1i¤I’L9.-®Ílƒ=&¯¨Zw$ùôMIÒ Dàza®l`H(ƒ“‘õµ/¦ØÙzEõ·à™²5×io!a[`}þdlW”æÀ f}o5ÐÞn†rgåÑZuSqçwI€æ¥s°#«DzúlúœvtvÇÕíÜ=&eyG4°R{èÃeÑ4 k§ö¿+Éey÷ÔDvÆ_ªþWöþ˜ƒýà8ÃþÒ‚Á*î“&ÈØ$,dr$cBÂ7–àç¬ÚŽiäö.ÛH"Gˆâ¤ï¹ ÅŽB‚oúhŽ3îhtNu åi4 ÿTÀ €ÎV`èþH±Š ÔèíÌBþîm§€ªôœj‘~b2Šp©ºÎà^¯õ´Nàl!Rœ°ÿâ ð&‚U@å}ücHƒù&Hˆª ç¬#ƪ Tf¢’/Ïfi ¬¹ÄHgÇú@°+@Ph8C4BçÌMçT°—Ò„Vâà ^Ò¢ÓkÞ8ƒé C1‚Í^`3äÕ0_O2°ö,ä  ¦:ñNE⇠¬o0‚ÍRŽ–tcÙ. ($¬ìl¢¤‚Gî€Ã€4b¿…Ä„«Eû¤ä”$)hìZ "°¥ŒædÜ#"á\àÞ­è΂ì-ÿÐ"É8„¤‡{¬yš ÕÀ‰m\Mz¨'ÖD«z\‡ 0Bú-n¢c6£€ã†c­¤(8ê¬ÃêVIÛüg9£Z60ÇÄ~â,ot¨È§M¦i ý/.Æ«„°F8ß"ÔHNÂÆÔ–‡1\ÇŒþ^m'S´”p'gÍ@h’ʰ§MÀÓP…!#Ócü†$’ío€o Rñ"ä¨H¬­ NÀ3™ MÄNµ¤âžI°)¢âÐŒÍr&v7£ƒFó7Ú`¥øá•¥,äRx²@D²LÅQÌP|ê0„í%)+z"…z³2¤bÖx(Ëÿä`òò­0B7HäUöçK^Åîñ7XñÚ´è3—¢úÇ €b‘G|Ã"X3+¡B°ã±3”ÍÆÓ@ÏLâ=Ü(|òÁÕïò‚,¬f.³‘ §NR)õÿ ˜çCûï !#w’ë\/;‹J’œ'ï%ë)«Ð<·Š2ç4 ø”Ò3IÁ0Ûî¬Ë£-ø¡>Èâºt"Àštg-Šó±Ü%逧,àO¶–³LOMM aé+0ßFNµ³:­L*BËÖ²GO5–$¾³;ï%Rœ52™âaÖLD¬ÂäÇÿÿ¨¨Š"p=·U$¦²¬òÚRÛ.pe¯!B,u rõ!d"g·#¼ò(À‚#Ør‚ìÁ4múõNðBjErïÄ2¶q¼1AÐF1ÔôlC·tkœÂqàÌöàb¯¾ PO¹nöTOÌ:¶‚òµ´°7|ãogôa`Åo‰ƒþ¶ã~bp«ˆG_ñ«mä|«RM!ÖóKœOûÅÛ¯|¯ÅZ´$ ì¡Òts)ʯ:\5]ºôNdu.;íÂ??¶1àXÈ_¦Žœt«ôì©#vN! x¿¦m÷‹w’E§®ÁdëØd”¶H)7€âoÍÊxëoÁw=UÆ U&\³ ¸’OZÿ¨HDÄÈ]!×S×Ã5\ (´DK`Ìæ³î€ãÒ€‡ÃiÕ-N78…X*øÄnÀ€{*)1 ˜Moבè)R%`ü/-Äw/6xƒWz¢îAÖçþáªÊsP"G’ p¿÷o?8Q_|yôI®{eñ¡Ê €àhYÈ’!£$^ƒ++ZJ‡)éa š` Þ7îZŠ/œ?"«]°qµúƒj½”‡)ã/PO€‡J·2l;cŠÛ‰2x÷Š£3¸øm³y<Àè(<ÆdŸ·N –1PyY6>«W^v—‚|䎥Ï&G*·â"b“´s\Ã]«/ ùѾ—¬ÿVIŠ,¯,¦¦K»4¼~"ˆ!™L‡Q(c"åÔ^×€Ãv5‹þ¨LNEy”éžp 0Š÷!XeFaÅgX€4J@2Ë#[78—ã3>ðufY†R;Ìp-‚MsºÄ5¼dÐB0|?Kî!™Üè”VBÿABŸÖšT×óÆÔ-Š®k6#aH+µ Å9lj95YD-£ð µ,‹wòb±§¿XÔ;dAFÀR8FŒÑ˜$Ú8å>Ày7ØÃÂupU¦—K¢rFÎQ©R–€…"e'<"ûF¶è} ç“)VU4-Óòb,Ê/¨¶8ÑbVKz 6/¨ w¼Q»Ð&AÔ´aÿÁv¾D¦‹ÐΔÛv3:QzxÍ ÉÎøÁc. 6(¢cÙZóöþ&ÙU—¿—8:›„gÖ—;¬qÿçá þA~‚ *šZ~bæÈÑXPe’ɺA ¸à,9~[0Nvg@JRu_ƒOb&0ì©§dˆÔhˆaƒpáì ´Ð– ‹‹§»›c¦1­¡ŸÂZ3ØZ×û‚õ™o,•dµ¨¤÷3­-„Ḭ~+˜úÚRÛBú6Œ°˜XñœBLPµ9‚G ù˜Œa`à¿Ex)N&(NWåÈYœT Äýºaä@eŠÿ7´Š¯Ì0‘;ƒù«§;ö;û‹áâJ Ÿ0ƒ³µ7¢>ù&=>%G:[—oôoùp}ëäöûÚSú D ™¸™^f>ã¨)ØW¡¨7¬œ\Cú¶Ù¸³†›µ(¦ua`—€¡3D×9wCY»ç\é´ëhÒÖ06c³xÆa|§޽âa4X€}ÆxUøy­•$X`¢¢øY7<†–ÈêG‘\C¬G€YC´è´û8Ãþ¡t€GG¢ „Éäòêdhe)È£¿7¬ŒÁ D}3¬D}Æ‚Cº3¶Þ„P•Ù&m¸yÒ Ô¦MJ_Þ©mðk`ŽÕÊÿ*ä0=yÏsúm¼Ó`Ʊ#c0 @Xàè¶na%–i«Z͘oø9[ïÆowÄÒÙ¨3÷·Œ#˜û[ÔC}3ü!úá˜äáÔ€š8r¬bZ "nX$ Y5÷=ߣAÔ`®Ý©ÈÀ9.ÖÚ@Xyvˆaþ…üú^’Ývé“CÙÙÁÛ&¡3lR‹õÛ»1kMà~ WÀÄ7 MÝÍŠ¢SŽ364c—µHÓ‰´³-µûßCßEý–ÁW$’/¯,³àAË_·©¹^Ô«€x0ÏTRè­E’jî A€vÕ!às±§Xåü†°Ø@îtC²ŒÖLyxÿ3ÄCX@~YÜ)‚¨=Ód5®3$}³>X<Ìθȷ*p—“~饢鷾„e XÓ‘ 84  ÞnØ[›_žé¾€À16]§•FyÃxO9%æ?eVåUšij…–{[Á7–ZK°€çžo ºž—=öOÿ^€NFîA}éi¨ƒ3)f˜ðIÂ…£3õ³Ï0p©`Ï&™¶Á®øiC,F E,YtƒB<.„ÒB<žtRªµdÑM·Öt0QºöJ\Á ¬ÇVrO •àÔxÉ*«,YÎnu› ɼU] õæö(·÷ÄlÚBç*ôç‚Å•.¢$Ò# †‹-ÍÖpÓbÖ4ðM `L*ŒÈØL&öC·!äïA)DÛ‹5&ÄÀ uàF¨ú¦R–F q–Tl ¶zÒ\J9åšÓáÄI§1Oxœ’IP° ²Sˆ™ƒD5Á<7+B{áÍ$OYÎú·gõ¬ÿ^ošöf–Øú¹}xO5 *Ý=Ù8ÝÏ7Èû?Ö,² ðA˜Rj«%ô"Á±ÁÆbJnoðBoäQ÷$µŠw«DF¬}F/”¤EY\\¯JJÉñN !ÈÛ¤T`OÿbV ¹ƒ„ sRaæÁ–õ̉-xþ¼³< ª@òÊ·òt´¸˜+%…Ú݃ CÝõƒÔ ÞBü€ÅœÂ Ì«šjúÑ,àEµ¡!¨^Ä©†X)7ÙÂÖªýãGQH©â‹tà`‚»ÕJÒ7N(8Á’ ² Ke98Bÿ¾¸5„Œ‹ÌæT—˜ä`‘PÿJ(È­nÁNƒBÓ“¹p×ÁC}°˜a MxÂõƒ *há _m` ?˜Þ‹6µ6ÄÙKF4rªî g8{Ž«H’ŒXQc»ÕK\ÒåN}R%tè·-ÑJ~¾‰ÁžÒ?þù/YX£B&0À–@AÿÀÖ›Êò„\ÿx‹}⸠=&ŽÐ$Ñ’¶G¦€¬Úð ã C*Äyý‚ ÿAC‚-R‘:!Èmr”£ð#7¬J"Dòá ‰&HbÝ s>™dL}¥œxÒÊŸ@N–ÃwL`kbò¢ù÷  ç—T™ ¸0°y°åMn ›ÿé̹Üi&'(Íõd™{°nƒ”ÁæºCâøcxÖøæº¼a˜ˆó ä òÈ‚Ìp‘î\ÑÚü…=¹2“$)Br7â”ÊV:è@S¢œ()ñ«Äáj,­8«ß<ô#(@ zæ?”}s,£ #& ^~€ŒÃ´ SÖ"Ò÷ˆ‘'™[X ³pé.0F¸h矙…Óº9NJd]HNjŃþĬKâ{óPî¨àƪ Ë\ !0D¨Â¦yP.\Ì=H[¼Bÿcº§™RìLîaŒ79¶2Ý2o€ºEmêñ¦ŠÕªöGœ`]%Ôh‹Ú©~¹óžHBÎFDUn7˜Ø>Q«!Z5«ÏñêN,ü“Rªoª)éÀ¢‘$΄;°ÇD¿ÝËÑ»ÿ0„!Ñâ_–à,¸ÇÎÒn¥†s¶³æëEÐ\ê"Ó RÖƒôÍPÔÔhX¨RM“ÿ‹HPµÆÀ´ÙÔBN«à, ž<áGGBÛnò×tð…w»Ä7#ç s³VélÄðEî&fE/ ]0>`ºÿè%Zìb…ÐÇKâyV°¢Ý“"V¼Pc3ãÈA•ÿ7Py‰‹Jõ<Á–!@e«¶˜xÉ«ÞhÀ}-‹SÔ Ò_´V*öBà™@u”ŒluSU(çž§ÊNG–;¿9 yJ7ÿ)bZ!›+K‰®˜žË?ó\nxUÛ¡­+GøÇJÀƒBß,+ämŒx‘iÇ”lº½ázʨu Mœ>!¾L†uïR𧥤êˆÚ«?ø(YÆÑ-2HÚ¼l`tn &3ªˆ%å‰fŽ€rØC”0…ûY*+fï [¢ÉçÈR•Š"^ÎHø‘?cåYüó"Hsð€…Ü ‡Î«Tr!üƒŸãù.P‚aÙ+•¦“\E;AýÿŽøOúaê~£„ð:Á¿Ñ€ü:Š] _"[᢮ {ŽEN‹NŠÅí"?ädÇ¡`àt%8œœ%¥dgQGSõ€qÿi>+žž?Á*ŸÝ¢²]òïrq-ô?(°óìI€Ð—ÿxþyxžCpÅ0RzkP1ýI^¬þ¨¨‚tÄ©O¸˜Ac^™–iX<ŸµòåSUƒýà†AX5ÜÐÐVke×°ÅCÑw ¡°¢Vu*>dxƒPã8vÖ}Æ-—ñÀr”H}¼Q[EbU\²a"„íŠìwX—‡†v ž×ŠJ‹±xP-0ÿLíöFòtÞÒ:Øpˆ_8E‰±_bûµ.ÜeÀ˜rèB §­€vÓ“0?ÀœÂ)þ’`b&7“]Ñ/XŽw7[õOÝÇŒPŠ÷k‘sDŒ—>4DƒU´õVÆ‚KC(&”G.7 t¥øyž÷¬x©…žK(tK8‹/t‡•'CÖÔ:i`)„Ìø‹‰‡9Å_ÈSà€pXf¢€¥Hr?p‡­w4¢`$G6‚‚ÿ€¹1Ž@ŽöPb%vU$1}'Oñˆ\U7þ´Æ%‰ß§rˆÇrÄa™tU à1—Õ•,˜Óÿ~9×’N™ ù°„õWBWð/@Î43-.÷Ð Ay1 †±Yɨ#„Y‰Ae‰ù(b÷Œ*Ù/Ð ©s ‘=N7c6×åKÔxò4,çf±}+€D `VÛgxPéaK™ƒ˜¸³E[Xy±•(vm*Æ~%©hŠù·žwP¸õpØR…pŽ‘:K@;qò¥˜¾ç&ÙŒ)¹…‡Œ) ¨˜×•ù·!‚Ù“œS& AŽ|F<‰‰¦I7‰‡DtcxK¹š[õC.Wl3•1àg6„]d›íç?ÿÐ ¹ÿ œ Ñ’C‘é†-=C¡Ä”XÐS¾è‘;ø…†a(Î8NjÞ †ã|ؘ3Ñ›#w6­1PQ‘dñKÉ$F|ÆF7Êù Ž–8•#ða¦™tƒ%×~÷CŸ+X¡s!sÖÖ?]y9ÿR¤ú·©KØ tYn •d¢ÑL©£З†1†€äÜ 5|4¢¨¡Œÿ ß`WF"( C°ö§C€ø7rNˆ‚4‚™1–,p‹I7L[á9ô©cÑžòÔâ(O#0O†DþtŸ-§rÛ‘ƒšúš‰l*àçGyæ1yîG îÇ~æÑ ¯øhÙÿ Áéyk ¡C@t/ 5&¦öÁ:S‡G†ÂŒÝ„B†ú2B%j¬':‡†A0¦ÿ y%0&“j‚:Ám´åVnñŠZt@ÿ n@ëy*Q1Oñ®#`‰Kù}©™‹¸òjfžI‘•!”@‰•M*äam@(WFJö I«ù‡ !zk¹–®à <—5vig1A¼È^yq2‹!¢Äãj°yÐ"¢‰1D…˜aó¬ý@ù !ð!€³òÄ¢!8¨,Q%À\U ]ÿ]–cn,0®Ž–tžsp3öPPë™"af—tŸlÅfu#ÿ+ cfûÚ®à“>‰*íib³É\%WAˆQìWn8çª?¡ {k ‹x;mÉ<J;€Ä‘—{AuÙɬÉHeý KИ²Mcg tp§D%¢0ý Ü¤ìÜ i¢Ææ Ì[a®j̇mÞ aÀ€”Îb &F^ägñWEåØâäÞYC{Ú@˜å`”2“qÀÕÎ¥¾+½J½¥ªŽ«ÄiÏâ*ÿ®JN.GóçS­âÉÜ¢Á¸€>Õɽ ;ÜoÞ-eç%®Žq3½”Єˆ £åBŠtŒã>nÞ×î~Ò)Q´ aÒàjc1UéáÌ5Ö]D^áU(æâ% kÒ)6àÏUn‚Aå Ût«„5Ì ±xÛm9tf>…qéÀ7Và|q— 1¸Y33¸§üÛÜaý*îÜ ¦ŠÝÃNÜ:ó B×¥8¨Çɰ‚íÒÄ#Þ)!ïä!åäñíkáyÌîƒ¢ÇØr~2÷Ì&Ý•ó·_"W”7Û –k«KÈàHýKXðg.®Žæh^òASÏ)ÿ¸»®ë¢Ü:Á-ÿõ \¨-!nıWUÕ¤ˆí‰½í {òÜØè}ÀDÔèG4ãÎWN6̓ŠjÂkÛÚ*®s[s ,åEFÛÎÀù°—,½kÉ ÛnÙôðFNåÍá0…—\ÏA¦|¦c¿fYp뀤ÒXp3¯„jÙ›ô×9ua¥wÏèÖžÞÖn÷MÇ?h1ï÷àªA'¼ÈinÃÛÓR>ÀáÊÚ\É< â” ±[šÉñLÉJ¯êKíôÿpgðŽð@ç1uÝÄÁ-M P÷õZâ®ÙªßøRÞ%èáêß¿@ üGÿaÈ¿ %ŽüÀpà>‰%îËAÑâÆFþåø¨ñ£Å ` ðp ,¸LùÅLˆ/ œlÊ*?ò<´ç‘ž(}nLUñ`‚›âiÅ©N©Wâõ_ òPÞ»70m“µ÷– \â6­Å&Kš¨ýÇA‹sóæõ;P/_‰ ¨Øa‰ƒðø‡•àT…&Üb‘“@É9f)4FÒ£M1²O€çˆ9ŒóåÀÙÿJ” }óJ 9zG„½™@Ž“yò8¤LuPb©R BÅNÝ)S‹Yëq¿õW<Ì¿0‹!­Ýÿ´†+ò%\ñîݼ{ÆÜ„o`Ä®Yr l¯þôª(„y ˜·Ââè©V‚7آȴÒ*Ĩ¢ --µÐÈ04“6š­DÚ2û'(”Nê)Åž|ËáE¢B;.%Þz’í¡ç¢KªGé®ûÇ:ç¦[j£ª´Òj ¾cÒ•z†à!ô0G±Šüð>ÃKüÔj¿îó>ÁZ#ð½4’ç¼jì$Êj ƒzð^@i% 9"-$AA{­£ÒU­µ08*E‰fš)¨Íb|à¤áˆ.Ó{{¨DÞõó$¥ûÑHëšBµ:êVÅ®¢$ëD<$#ƒ’‡)ÿI‹¥ÿ3ÕúL„üb럻¬ÄO?.q³L‰8 €°/ÍÄ•%$2²ŒS zžJ •ƒ²M"Î@â°ÐD47DAE¸#n»¶‡û¨SÊ¡¤kÚéÞJiKÑ'x ¡"£BÕܪªr5ÉB‡€²,]óbibøþ•®.ñ’H?`9`Ë×P \S0×`kó ¾`«¯,Âj¡ [±sˆ Š]sÿÉ0C‹@ò°4žACБtFÈÄÛP”´·J}c±âÝ@Ú鸠ôUŽ·‡”;.©™£*ȦJ]u©"­:{£:èI„ ä³%¹1ŒL`»œkcaß3@÷LH€“ëì×ÿ €Læ´b0ˆ®’L`!휲yÎÐÝÐçB)Ê<#e­"áJ j¦˜¶”¸·~q\¢tªQnX2ŠQ傌ng…' !†ÛN`VÈ·Ýv!['žë¿_Ÿå¡cï8ãg™W4¾´Zˆ3¡‚µr%¬Çºòýo[Iꇲ¯ˆC¡/òŒ\Ý'ŠQóËGL‘…[à ˜§ëië:µšÕîU“œGE*zŸE&× V•*Ä«Ê^à€9‹Y…‘]Òúઃyñ˜¯Êt±ÁY@ö!Œ<時Ñì:\yÍTÈ7@¤"Ÿ;çÏàP"> IÑöDž$´{×ÒXÿ )¨ùÆE,iÑþǨØUŠQ;ÁIÒþ—’ <$wiŽï¦â0¦$l f3ãÎF¼Å=e[‘©GÜ2@ÿPo oQŒbšG\¡…. £›`tUB‹§1!P\¨È€!I¢ÙA\ªmg= bG^´ f}ì2bK’è̼¤RôÂI‹lw@”ì&EŒ²¡¸^" TlÛ .ÿáJñÔÐ;S9ÕÃ`$‚°-Ž(Éb31¸ìm>{4†•„µ¥ýX„™“Hò’»ÉCo:£øÄf•îS|   äÅLl!íã\jx˜9q#¡e§lô“ÍhjÆÙQ¸ÿžíC#;ùMÿ€ó» c ÝÈùrE+ÜIÛkÄЪÚÔU3—FsƒÑ4ia¾ôÁ_åjWÎÚ Hµùô…Ó…‘[‚7VPF4ý„_†3bJ‚Eý©GKíSN.Çe^ó¾ùÒ ÀÚàB-¢gNsDññ;[ØU9-nÛþì6Ppn‹¦G¢5iEÓ£ Šv‚­ÇHOš™‹~SX}!d øE·ÄÉS߉z#C¨á¿jó'õަš’[ÝÎÏa ©ªÕ¯þêû©{õš\”*N%» ÛwQǹ-p3<·ÊiNeÝø@ÀÛQ$Ðt¯UŠçŠÆ`{ÑÏ@ ¾ýíÐCÜá÷@-][3cñ˳™]D%yÉNGFH9ÍIhˆ“¾Îª½çÒPè0”Y[ "¿©¯ê r…;Ü89›T‡ò%lœÑ6­!Yãn•‰¾½PZAꎄ9÷}# €Ò@J‚FKÜN¢ðD! ‰§=Lüó^ «îAwV’°Höⴀ„\•À2Øóˆ‡Ø!¢¶ÚPù‘Ú™)³67¼Nop,rY90;—a›´R¦( !ù ÿ,éÿÿ H° Áƒ*\ȰaÂøZÀ7тË2ðÄ@ ‡2ŠLر#ˆW@¤=‚ó4Ä81ï_ŒöìÅPQ3ç~@t㢑H“2üQëßµž*Åñ)U#bµ¨´«AOCþûèAìE±¶:ØêˆqãÀ”ñþ­üg¯B{-¾¤«¢ †1lâÌI˜={*ÕÇQã”^#GŽÚTò¿«YZØÙ²× t, ò#FÒkÿ½–-ÁxþÅmW Š»ÿTÄ…2ð¥=z*fÆÐðob{ù*|8þ!±ãÅŠoxž~_ªQÿ°Ä^U©ÔZÿ¨H‘ó†\ÍGB}ájfÛ+|ÏÑä¿qíÅÓÏ_ Þ—ñ¨°×^}4Ü`ˆ%Ö\suU bˆ<ø˜|žIx}—ŠRMQ¥Až·ÙDÿœW‰*R¦•Ö ,Æ8Ö‹/ºø¶`tÞjÅÃOmígÛ]öèöo¾˜ó Ø\>ü¥`Pü¢Ï?AýÓXŠ“Aõ]AÒ…éÝUàásÞü°Ak^b‰oriÐ`‰Eic•#i&¸cX<^Ä–XøÉUPK(›€tùØ?ôüó—€>%Våƒ@‰È¦[6›œ—U¦¨=õÿÜ@HT`ˆ!®ÿÂê?t× i¥Õª-°7ˆlÁúºÀÇr5Š  |1–åÁG2Ä'‹­_Côã§9¢ãædÛ<Œ ÈÏOü0æØ¦ˆ@݃ù€Z•‡òƦ ¤@H¨Êê«U`ðÁß`ˆt DtEtUš7; #dÜAÆpq,Â+0À«E$6+XÝRKZ´,ã‰ç@>äØGåUÐw%š¨"‡LrŠ4¶¥KOs@Eùîc†¼ëØ?–~@!>ØAíïúz(UM]è­E­:TcüÔË4”bÿc?’ö@ÿÃëy¾Þ‡1ÚQ~ëc2ÿ€¦‰B˜ù¡É¼&DÖBÓÆ×Ì:„lá%×^ÿìÀ ýdž9 Žì bP%:PS T>N7Çå(øÔ‚oAúþ³!w߀êÂk‰úrË!Æ4Óagêô?ˆ¨*ÄnCŒ±–GØN9©pKÐìQr>›¬Úß dÖŠ.J‹­øÙÑíjxÒ>{áƒïZ¸½µôŸ@ò`®ùþš{qÈOŠP¼65”:F1D[NŠw™T|("*Uª@ƒÑíù8޹Æåºô®QÔÒ}8uŸûŒ(:±É@¥¼$ªH})‚°¼§¬ÆN¥‹"-Ž íkAÿÀÂ,;Kûa‰APÀ¿ôà‰4à_  %ƒPt'¬b½ä»¹Î V«šT«ØØÏ7½cA€SÛlð%¨Ó?꼜ì$0ö`DMÐEÃØ#J9ù‹ò1”£EøÀuÌ#ön~âkÑB̲Ot«Dîb æg‚õgrr‘æ€øã”§¤F0¢˜¹yöñB=4@€L#8üÇø$‘ðˆ"¿‚>k¡ï| é€XŠPÿÉ‚¸/Pÿ4‘kP$ýäšS*ŠJjØ!s^0Ú´P*"Z EÝl¹‹Cx´ ÎxT{Xç&\aE*«ˆÁd(IqóÁ‰¢~×# ¤¼É·Âyøt ,XÂ?NÐÇyxSCûÀ ÷tþ£^”`{™\lMßûø "Ƀì)>ž™&Mt¦ƒJ6såt9…2ô­Ô`% ?þõD Å!X¹¿}dÎ+THSþ•¡`R€`Å»Òrìr7VO xI_ns(äM.Pxì |züuö,h’@ CZFؼŠ?D@—l@¯ÝžTAu×ÿä«3ÚY¶uIöÅÎ"ÈG~DÇ"´0åB©Ñj04›³«]aP éj®+„Xv$†:%‡­•@ž“êÝ…%Ñ£T”ŽHóšoÿ0´L°’œ,A]Â=Žðý¦ mC”¸mª#7xm#ÿáNîEFªœiȶ¦5#{‚d ¶PA.!wî¨ %\Ð.û‰²`¨4‡…€¯È­A0fŒ<€4x"ûa‡`t…—»Ì.TÄóƒ”:ì(ñ‚R^|4GéÍD&„)€èߘÀµ© P·¼eÕ§.Áúh ü#ÄKÕ <½ˆ(òÿCó¬›gá|^øNaŽz+”µ3#ú)À'2ç\T"€ ðÇPVÒ ÑoõGøÚƒ…ÖÒÔÑ©~ð”V“ j[?Lc¿l¿÷¸‡<–°„D¶¥´9o,›ÙÉÝ$›€9Pñ'T˜ D´ÍA­¯±uΪÜÃG`2OEÂoÙf5ßWå{a´ìyY˜Üü>l”à‡Ä±GæhÀЇöà ™»1ŽiT@s•F¥rý±]jw»B~`Ä:-^³Q@€Àû8\ÕÈ‘KKrj@¡HŪ¤þ«ëÈÃË¡Ç2&léhÁZÿ œ"q±NeC;b¸Ð•›lÃŽ j‡VnÙ¶ÄÂ[ðùdì)+Bˆ[>d.Þ¨ÔœêÊ?·ºÒ¨47ÒQÙ€,DjRÓtÄìË`‡;ž¯ª !F” §ó¨—=°™œ¥n`ó`Ag 0UÓ#S¹)1Œ!ch /’Õ¸Æ}­qôW›ý¯ ¢ÎËÌ6Ù—‰yœÿ!ùDdòò„“VÜÉ®z[4Ú¡>²Ÿc»Ãª™'›/Ù#ÿ$ñGg¨æ þq!sÁ(´?´ÑÖ…B·SÀCi¢]n÷—!•/IZª`rV˜ÀKýS€oÞ`"XÀ >pþ „îÿHÿÔhq¾CÖâ+Tq¢ë v<¨¡‰Ó€æ5KŒ¾Œ¹/÷•Êë?ÿŽ×K<²-ñ0Ò'p€¡GOØ–I©?ÝV+QvQ“{ u]Öµ?9Ö4PÛà{xJØp]‚%5'¨KÆ÷&®£‚ZÁiÿÐ œÖ E!}¦å cÜäZÈRvq',À_tçpCˆÿ WÀ¡~¶‘w¢É…ÌT¾æk`&x¨•* fB +7o†y 2Oë¡ÌÂ#žgeuÖ'׿Oe¥mhDQJn ¥nL|ÐveÚ€ º'‚ÀGˆýÐ!¼”ˆ\7d°ƒ-ÿXöab5ñ!3wÁ¨†@òpG€_G0wsWàjSø~§¬¨~ÄÑ¿aT11‹ñçqþó›"ì$s`„ÿW" ÔEpaA-ñÓÒU2sIëôO47((áà¦ö ?óæ+¶?-æ° ~hìÆPƒø{S÷{ýÚ1 .8 -ˆ‚¿¤¼$A¡*SbN"Pü€&#p =õŸEŠA`„js‡1N¬¶~¹Q.5MæË)1a…»æSó õ²½ÈoFy’Ñ=Ct29dVWV#,¢€xRzÝ"D«‘Ið3€÷aâR0·ÿ×ݘJ”Vný0ˆØ`cç8‚þP‚"ЍŽYÇ:ïøEXñuRf¶Â4‘MÂîs·Š£8Š WŠ!ß÷!P+ú/¡­&)¾&G}Äÿ pL’ô0pW "݃ybøK’WÝã`Á+!vŒ1r€(”d’Ä#l–m¸U5y3säqxèb ;™J…hhš „8uþ0|‚å/îØuó¸|X÷/ò¸­0† F!T¢Ÿ–ÀpA 1H–tñªY~ñ–{äÜô˱pÀà$ ˆ°…±Nq‚z™‡)ÿ'8ÌâøÔ†¹u[b¦gCçáN«m{£,$ñ ?¤Ùn å‡S75ÐŸéæøVÍER±éuQ QdY—_ä|N±&ŒŠ3a Ò„7öj_9„ gbYò 0›!@æ2‘¢1QL"r‡ñ¢!€AùP¢% %°Ѐ €~[XÁH†ß sò¤o'#D–Ylò¥'Žù9½¥}VCÑ0³aü@òÀbúyJÛø“‘–iêØuøöˆ­y_1âKøÐ · °j§~úÙ§JwÃYœð ³y'*)K25Ñ–½ÿñT™’Høo< Ï Ú·'‡" †bs)·‡d& ¦Œù$_/"I2Âs?t"hòOÀ•¤-2õ9'Ö50ˆ Uûc¸ÚâènD¹ …Æ”¡¢”°i¬Xç” QcÊF+,tÊ}S"~}J§ÑYÀ ZÐ õrjÒ#=7RS‚Að¢B``Лâ6šqo±=â €"i˜Á'mŒI#KÊž‹CD˜´`d5ªoá#hݰ«26c `nvµ±Ú`nN¤cD ]=àc Š‚$¥²P#*ö† qFÊú€tÿ*9ÁŠþÕ§ð¡*¿ù›!Ð +@®*àjê'=‘‚q„ñ¢¿ñ´õ‚"@lô †fð2 @ ¾Â,¯ª]t&’f;sA7sÎI,Ò"{ºU#Æè,bu¤TZ™epA²Ê|K¸?2@+]C™9 ºu@Ö:j›Ú ¸5QaVqfA0„Œ ‰R Âi ´~ ~bI@l5u§"exúTþÑEG!Y›£úêŒQl2tÖK›Ú¸Ú•¶Q¤j ‹sɈŒPÚŒCD«±m›dO>2¸¥xÃ}àL§9û§0p;±üÿ³Ù[²šÃ@ºôޏ^ ìH¹0xÈ€ptw´4pÆàj™Uưkÿ@§Üzz*/ Gam Sô„Q/bC®U»QÅrú6N“GQ8 ÖNe(°“÷!A7ŒÁ ‘$\ž‡€‰Su[™Uºz(Ò9BPÅ¥¥-±¥²1JpT€(@’ pØT;àŽðŽ0 ÷°Ã@„@¾ýFQ“/‹[|ëHÊqJ9Àˆ¡ƒBµ;Áñ –~ 1œ7jW ¬Û(qÅeÀˆ@›RlFá „AÕx[˜ÀE°üÇ`ü\HÚ¶Äÿ벌Nj>>´¼„ɼ f™“Ã[šÉ´qÃ,‘AÓt—ÙÔSr7ŠKЕK|ŽÅHñ/tW1›Ái†ÀàwŒÀØ0u²ajŸÕ§j|ÃIw!y~×”n®Ë.#P"P+!ä%ž\¢ðºÈÓHT5Ȇ<[gKOZs«†Ø'5’€+ì,–¤IUÚg­Ú8öQBrø‘Ã4/qË/T¨¦_£˜j}[|¹ÂšXñ!®“ ³9è!‰ÐÅZS®FMrÑ¿÷ ­ñYÉò)ô@NËL)îe^äzÃÕƒ6!ó+>Àl(åõT¼ÿ“WB ’CÎ`xÁmÆ+\:´°Ñ’á[¨÷Ož€Ðx#£ñs!ÔËqJÈØTÊ¥<Ð\jO`]¨”ñ¸À¤ ±28O±p j\„÷R2¡®9ìË`Ù­ú¿Â‰³Õ§SÉìBˆ%ü(ØuSpÿÀZ#` àEjGeónœ* ƆñªÈa'ó+­Ô!_* ·ödG=DA꤉I?üÈŒ%Bu(9E5p=¥_]ÍÕ¿ùl¥90ðÈÇ|°ó!BF¹R9hvp9Ðpü×F¥SÝDÓ2á_Þ*ß*'ðÔÿÝ^É\\áÉR=" {£ñ ÓRhCOKp„–ÃcX1¶¾èfaU¶†ó'¡­Îˆ>©ñ=ÚP™T™7¢Os7—,X‚ @±8Ä£œj¿™Ûá¨lÄ髾[woÞE¹1ˆ+p` W§òÐ$jßpœw+±3Û¡XÑÚ}·&ÝRíEDäÈQp"€û˜ ÞÕg ÌäÀ 3^##ÈÖK˜çrT%PyæU¨*Ô¦?©Ÿ„¤âÃ{K&Û.†BZwAÐNL„]ý›—Ã?÷¦ 3þò‚Æf? •? }ÀFø§bIÿ"ßxH:Á€¡›…xW|“€ _8ì4ÓI2Nôëä”Ce~”C®¡"p,ølƒCåò´VÅß6ih¢€§ªÂÖ™Túëã€4£Œ#V0žö3Z ìæ«6ŠC+ç>¾ê+1A6s¬c5ñ ¯Pô+­Í?ñ·*Q^¯]؈aÍ„Q^{–u7as(†’3=Þ¢kt,)¬HN×Q/y¡Z$3[$ g(G’nò¬€¼`«&`ÂBmvÒåËÛ>«×Ôaó$LBŒp¨¶Ñ$Ïáºn:ÖüÇŽgz¦ñç1ˆÖgÿv 3*á>‡‹Ëä;T6Þvëõ5u#qQ²ÞñÀZ•þ#t³Þ…6Õ8ÒýÕë§–Mpm0…{Ab\l±Ýi¤<-’Û68hIÎÈ’´°¼eCL™/¼ñ÷ÑIq7‰æˆ—<ñRnîæZ½á¹­__ÝùyJ¿(ÜÂýÐ1›µ¢í©bÒ„cITŽNn‰EÕzÆ+°1J?j£F¤;OÕd3Eþ1hÙ_K@õqõÄAõÌÔ.¼ê%²j«Í&žÈ¶ð6¤ÁO} ÈÈ¡ís›#4C™poI1 óÕ6«û6~=zô,ÿàè–¯_[ÛG _©Lø å/Ûq¦S̈0(L7@ƒ­°& £GA~á¾_@hxÙôkÅôTЋaÏ`¾ ùø@4b„ˆÿxàÅï¿3Ú+`P…Áùþð€Èƒ¾ù ÒÓpbÉ¿.—¼üWsI ˜ÿ4Ð ñ¥>D+ü³ðO¾£5ñý[ÊT).£5¡.ŵ¡ê¿ 5³Öü×aW°ÿLˆí0¶fYf»þc`‹AMOZ=eÝúÏ“¸\0è02žE{ÿ T¨9¸F®ÿyÔ0o^̘,N°XÂâÞ’#K.¹×ù^æýúóWÚצ¨Žú7*õ¿Vj¶úñãßÿ C8Bà_ŽÜ“—³¦cóèÙh0½š Úûï0?ìú°cÜ(p§ÄǤ·Üžuë‹í±t)¯ÉÍšï¹ÞûGó„ø!ÁÀdž Š’Š)!˜¢**•ªé(¨Âªé-=¨‰—$L˃ MÀ°&úzÐ.®6˜Ë®¥ ´+«¼Öªi¬â‰Çžã)à1â'®¦cä±ÉXçGÌ4óŒ3Ï.›ÉÑH3)ÖZÇ5ךl ŸÚZ᪕jZÀ æ)Á²à¨É7`¢¬Ì˜{.†š ú€«7§[N¥ƒ8 L…šÄ«`‚¬¼òÖƒ.&ÍäѬ‰è{ÿéž&îÁ©…—4K­,Ø)r*µ1 ë5-ëò+ W¬TÊ"ÕÃQó‘.»ðÑÁ<ˆHÆ ZL0ÂÔÕ#Ç £,³Ï0»ì³Î2óñ$G3í4Öžu5¦ŠjÅJ®~ˆ`Ë þ)ó€ËA€ˆsÈãæÙ)¥7SìÍvÿy®¼js=žè;–èìÏ–úlÂ=E‰§™`jâ„æáJ $À¥ð%yp&\`ŽÕ*ã5‡§xR¬Õ¼õDóñ(`êOK$å„ó¤$$ù_ìÑœêû+ÜÝî(»Å$ow;~þ1”]*)’> 95Ec—ªË†r–R…E-Ìçú¡ :ȃ³’àEl‡£Š00ÁÈ_ÀR€è&w%øRŽ`Î ŠÁ!òJü'Y®&øA+†@Ùü`0#Ä®qíãFø2s„â¸ä_SŒ"W~$J¾B©1ª¤'ù@ôøšµbjÊ®R¶ÛסԪMv2ÊÔ¢2õöU+ÂÆ ­j"»ä ¾î¨Í&žA€e&ezGžÄbäÍ–MZM¤¥Ôòi70äʦ_%Š 87µ¢Þ$õFmh3l?õ¿áÉôžÕò–⩚1%PýGÿºù&”Ô8Ô¯ „ÞêU0 E86J¦š²âc+ž22ÒRÓ\hü*žœkå µ\(C‰ôA© jÅcd]¯|¤ ]†o`pt˜û.v±fæÝ~Y 6[TÛVRiP³Y'¹†–¸DmnÃçeÑ'˜äW…ËD“ãh}`‘ê¤#lE°Œ8í·œ8Û$éœ'NbEÉ;_áðP¢áZRÅWþ±\è2,øT©‰Ör®\Eã©q5„xeÐU0Cfé[‚½PôºŒ+M.»Ùp^“dwù“rÛ¨´½ô˜ýNf‰ýpù†s¥I–sZžoðû²8, €o‚ÿCLáMA5N·¸òZ3ý-ÄØ³Ú½gkEHq%o‹Ñ¦å4U8ü­\Ñ{M|àà˜BY"þ³}¨ãØE²U°¢ñan½H/è0”ÁšL9/‘Œdæk»È9®P6®À0õ˜‘nêi[¬3{!ý‚¢P"£ýXºØû‡Ìò!Íb §¢h°nI"ËÀr¾r9¥ûXIª²É96)´Éx‰hê7~1ì)°Ã‰ð!§nr—°âª„UлK‚K°"´€KÈ;RS¶øŠè²D²YC ´¢µYk P ¨•ǨE2é€ò6¹ÔY/-ce3À(Z“ÿžã Âø€ïá(Æ2:¯Áª|0„ý. ?¥©3Ù[Š;Ã¥Û»DøÇÂßÛu3¦>qò˹ô!ˆŸú©)²ÊÈç ±ùHáA>9r¢.®ú»O[·2¼$$¬‹ïóËè°}p5Ãû‡?b¿{²ø‹Cš™±?ñâDêý“$¼ð„ýûËIŸÕб«FÀÅÒ;=$Ò/ýr FøC  @}È€?ÄÖ½n›º»Û©üÁ®#ޮɓšøˆx Œ²g²"šè·š -sù›âh»†© ’Š®èò‰šH®O»£HB#LÂÿšBJ¸„™K‰¯ŠÂ!£5^ŒŠÃk Q˜Æ-´ûû ¡¼DФQ(,« Œœ[ÃãøžK´œyبð9³nü‘"ÇýG}ȆnøÃnû”pS°Sœ ˆC&¬ ¦áóš [޲iÁœ  ´ ‹ÛÊ7æË·ÊÈ›ú¡‡ì*ŸØ4‹ãË;J(Š1B£Â"ÌH®ˆ¸]D XS)”ô#¦¨’ ùÛ5 ኖü®°¸«`™ ¢ gœ™”%5éÌŸu7zˆ·Ñt¼žâøI·d› Üî"8‰¥¦ %k.Å™!ú4­1&²d®XAÿ°8K ÙDs¡­ü±¢ä¼ qRŽLc.4G³± ÜH!ÀŒ¬H"$ ¸„ìŒóÉëDŠ?Š–µIôD²`´ ‘LÈl$EzÉ“c‹—C¨:ð°Á°ž„‰fr ¤+Í3C7¢ô·¬¤4Ç×#o{ÖȬ%Ä €©|@¥«ÑšßÈÀoüÍд˴ũ´s¹­³ô¯aÈêð ÛÜàåº1†# J B°°H'« }X~(‚ô#Ì“4Löã Ëq<÷´œDº Ïa ýóü ©¹°”K»=ãøž¬ÃŸIÍyŽ<Ü3­D€*±êÑÿp+ħA„ ˜‡{[ß㊠ð Λ‚‰øGâ»b!±~S#'B;†©Ÿ£Žãâ¿K®pT£¸ïë>=O¾ÌHµq{pß*+!ON)É1Ì[c‹`™"è6µ?*Å«gÔ¼2 &c¨°ð©[½0C J¤SoüFFP X ˜Qs\›5•ÍÖ˜½ÎjxÜD<¢D1!&ËÑ¯ÊøÞ‰ŒÉ0h*Ⱦ™B×ê±ê8.Åù P[ů0¨YÜÈ"åŠK=É$ìÎIŸVU" |B<ë*Õ°ð˜Æ<•%¥+ºCVm?bû ³}*, ŸB›ÿ(rŒ/í³4ËÁpdÍ XD €d…ͤ™’æÁ=‘UœæÚáI”F|Dg1³™Êü H›È7m社Em.¿›H¿cBxµœ$ôN¢XÚŠÌ;Œ,•XŽÁt\pœI<ÄØ ‹¼RR¸zÉ•{2 ¡«ïrF°ÕaS 5·e-ÇèFdò‘;¬Ž Vc5Ö $#|ºXrÜ[°©ä‡yÀž4®O4Ž(/5;åÄ´šÉ`KåèÙê‹£‰ U ƒ¢Hî{+$´¦íK¿¼„îëNHÂx€z˜.õ#ÒR=Ï×x­ØŠCz‹¾x¼“ù§ÿE2Íq¹HºÏ`‹,';°Ðš(ý SyøÉPºÛµ±VY3MÅ@¼@ ĽX°ˆ¨€ø ý¢Gàè=å|¡Æ­ ÝùÉB 5žm½¢Š%.žxËrœQÈË¡Î`B%Ü> ò΋,]ÔÝK°ð°‡>ÑJXÏŒQ©QL³Z²³ ‰€rO bÏ©I.”%ñ¹°ŠuÖòÔü3sKë Šbáb@‹c ®ˆÙX°‹RDá+&­áÊTJ—BÎ?-Ñú=Ür˜x 1V}Ç¿³MvuÏ]¾[Qó¾YRݾÔ;§Í»ŠÜHZì‰Õ2ÿz²ÚÇŠKŠ7ÄÇQ2»8¤“+á€bÒÎ,ûaÿƒCáÌÇÕU>…¢> Óëñšpü3]ìÍÛQ°8×ð^Ù7¾ˆÀŒq%áàšgâ?ÕÕz!¡²‰r ×"©·l. -ÖO{J©‰ºüÜì›Èa´Ë»üâ2öâî+BŽäHÁ *{ 7”gŠ´Ú£ÊÑ8ŒÉeÇÜà–$'¥«“ÃÅì+Y²&“yY6Fá n&<ªü}@Ó ÍÛbÍÞcÝ[Çl™P=4‹²Ëð0®àPPM÷ýÉð)›o=d«¡©²$>£ ¥nÊ Pœ¿Ù ý´ÿ»œš`Â-ö‰öK»¬ ½»Ë1&àIñ—yx:ÏÕÄɤÐ]O(X&uUE*³è1d ÓIÑLÞ¨ö²j êõ©··ñ–ÉøÐÔ %=”aG6Vx~Ts„ÊÙ« ߇†7¢$H®Àó­¡M6l_ÔİHK‡V®`›šxšXv¾#[6¨ÖTËÙÈ·’×¶ëîD„[¼#ÄŒA •ì™ùë ~O6EFV-‡Õfz ·86‘F¤ãŠw“(Ås&Jå¨3}çwnj‘êý!Ô°gˆN‰0Ǻq‘45ÛÕõùž‚.k=UbÖ VÜ´ÿ øí 5V'cW~…ø>$Û¾·æŒÄWJXêÐ5þ"ɬ•œ$˜3$D²U0t²±eî’ …Úæ‡ÝÏH6Qáqv¯á)é=ºPâ‡ý˜á¦¾xVÐmž©Öá í&F ßìqÄ:õâ[ABæ0Y’Œ¯¾¸šÐÜrôßà¶ÍYF2,þþ4RcS`æ¢æèîW+RLá8Ã<[ ž¿ÍyÉVuÒñV¯˜ÛnZý\Œä`„ähŒw+dñiá2S4 ÙÍÞkŠ^ç‡ÜoM‰æÂ™ÂågAk¢šh¬ŽbÞf:êœ"1Ø"¾°@=\îþòÅÖhÿˆÓâ¯x‰Á;an$tý(«ÇÑnOa Œ1%ŠÌ±ZñÅî el™¬¹‘²#EO¶Ÿj[Iy7añφ{=Ä%1 c-m ¨Žv: 7ÜøïPb¬SÅ=ÑÇ­ðª£^ÞšpËœX– JyTáö_+þоËp4×J¸»Qi/Îë$¬±ž'Å<>Ì™³ãĦ™ JØÅî‹î’q„šq2¡Àè²J”%óÉÄ3ùÆ1ÕÜKóØY}ø€@é<“–š¨¥óv‰òò­Ó ¸ è=~W»4M±aaSÞìèxðº³oXγ\ïß3‹W QÓhÿJÈez-ÝÝŠ‰¹N6­B'%ËŠ>·IÁ„ t° (65oäµ\6èX¶V÷±“¢j*“£VC‚=VM§€uþ€Ç9‹:¦xžˆŠŽž­éç°(Jx ú*"€Î°ˆbU”áX~TŠ–óá QÓb‰ùh‘æŠwŒ €õ6yjö€µhËûZ°uI$›Ïú4ùJªqïI©Z“¯™Øöá ›¯ øÍÅ%#‡çÜx“ÎÞïƒ7í•R7êÅÕžÞ,HŸÄÕɸß(âíx ”µœ2·ÍueÓ{‰w87¯øŠ´ø‹çÈ>:É+¼B` ‘õL‘ù<6']R’©ÿï²ióŠñ¿"Fì@æ˜*´A>5ÑGþôù&ü¿–mñyŒbaá…²l“ÁÊ ß¸Ö°@¦Q|z¯èpv_†äŠ«Vx¶æŠŠ®b]w_Ïð`ó‡{1nÚï$ ÕJBþý‚Ï .| ŽÂw.‚'œHpÁ;Xô0Ñ„G‹AJä(Ñ“H”7üS)Q£D~öÎŒA/Æ¿šöbÌSÑsž†y'‚ZœgtÂDZ­hµ€)" æ±'ï¬6üÇõC+üc$±*F$æ ðïÈDyÿXäYvO¡óþhtÞF!,"úGaÅÄÂ)ÿü+ìX¤DUˆÿ­ð¡*‚J™)M´ðï’Îÿ<{¶¨ùÅQ Bô*d”ÄŠ[%²ôZû߆0ÿð0Â"IC ·hRäOÉ—ÿc€²Ãî$Î̉“^Nz=ÿá­;ñĉ¿>H@ÂS ˆ }€PÂê½{Gâßc¨ߨ®`%ü«Pß?ØÓ×^X ðÏZÿ¸5Ñ=r-A`w{á´W_Ç×<ØfbŒ5ö­€‰‰¨Êª¼âÃ? d&‹]™h3þ#%”ÌÈRm5´šk&Þv‘K½¤¤D$A椉-§RríàD*ìD#ö`ç“DA‰©ÿ×?†ð!J¦žíÍ#O GXeUU[ÁV ~ý`ˆXŠ‘Å×…ò,øÏ9ä]Ü1‚—]'ÐŤ‘–Ð×¢‰ Þ Š-¦éay(b¯ Ø¢¯hFÉšI”ci4Òø‹>Äê"A=T‘AvŸmé¶ÑDxTœÅ™R”¸¡¤³¸™ˆåt9‰„S–?Å@”â„”R­œG>„Á^Ü¥=J„ŸBÿx+RuÊuàZ9øÖ?tVHí¢BÍõÏù.ÁB…åFX bŠH¦‹‰øp²ªøP™¨”µë©,.`¢¬±ÂÚb"0ìZ»$ÿÑA^͆n%wÔÿH1# Y<3'«ì‘õ†e¼õ\æ?>ÅH¶dEÞy+¨‡Èm†B†!¤K=R3äUC°ýpCX†%wÍ+‘mýƒ<Ÿ vØõåhÚV‰¤6Afý£"ú4via!‚Hc%»Â+ÿ¼âbŒ‡›ºñ…Ëj8¬¥Fö*E¬ ‚>ù|ÏÆ)§lQ»¸Šäòm¿¤äo"kQÍ™ÔÁq´¡4%A.ÁÄ?ñð,#ÒÃÛwáÍ#˜ˆ´âíÒüMð´`öT=µÿäw_+}þ)O'P[ß?9$èVÚ† Þ£¾\rMDÏ`ü“pcˆ0ÌØ¥hÿñͪ®"á&ãƒÆù¯qŠKÑ+H”À‰sù€ß<•銂"Kðq¤¸Ä##(Îoöà”ä$Ñáéb—¬x©À&.T†‚AC,å<ö W>žöØãè2_W²6šV¬çO‘_™À·ì#|ÿÈ@ƒú"ñ¥*tqŸ\X¾UHQÑ›R.Å7)Mi~SÌdL„¢­À”ÙØÄ˜@Uøob’icõ…©íE ð -(\ä 7#HHˆƒ¬E®Îñ0QT¢œÚ1ÇYa@~“» Dk"?ûv¨Åìô„@ÿÁô±&¥¬'Ð¥Fð´ ÿÁ“DÀÒ§#–i&áXøîu¨¬È…}KÇ ¦ø¯¸a ÷`»ø!‰Ø—2ã§,’MÃL„D“ñ¦d,ÆÆ7Ž3D˜‹BZ`0}`ÄV‘ áé²xâÿðÍ?Z³‘òf“¤VË<- úÁ„@$—õ“6–|É?:€,Gk‘ª»'”T(;)‰„|ä aHµíàåLúàGôñµš§šöÿ“€Zóá%{Ìâê4_ÉÚŽþ ‰3É0P6#J> 2)_{–´ lNÈÄPb4µ˜›Z³ŒÜŒ"Dö7s¤Ûßß܈ u¨§ÌG>ð¶‚ d)ËU?äÚ‹„Ág“TW,à¼,³+a&m¥Þy‰ B£‡× ›¼­5)êy®>pX5Pj<´ìâðcŠÅˆßQiH‡IdšÏ"ŽJf¾€©Ò_v ®’e˜ýDfSøŽhdü“oÞ¢ÛÀýšs¿ "QWP„Îfn¶%=Ðù£ªÂV+C¡Û5[׿ &y¤p°´[wu(œR…µ%jmÉKÀ³Gÿ>FP™äMsäÁ+ד9¹”=¦û,ˆü`~ˆð€¼#õh‡ÊA|ò•(¿œ`RW„¦»z¼xšñÍæs9¤kÞ0º™‹«—½|7ýþ4D>³Ãvʧ=¬] œ›ª2 O¤žÁm>‡E‘<¬rhK4€ޤ®“"¡Ú\ob¶Ùƒ Ats˜Úä‡oÑÝÜÓ„·£÷jô–!øã]¢QkldT}äæ ì_МˆK囹ÌâOCˆß,›_³9]l>S.vhÖ0ëÍÌýG>N6·µ€µœG>|P äHLÍ S·²A §N8ÂÙíyÿû³’ÝÌ>)‚2=äj£à„5›•ÖöËïæf2ËÈ£ ÈÔκ$b°DiýÇîD‘.œ ƒB&Á">^€%ÊxÁ›Hô‘©ÌfJŒÖª°¥VW8Ái¨u=¹¯CZ4ÿM"9¤‡jy•ø´ A÷ÆYãTxZûÁ ¡p»6¦©z f £äÈ?Gé7©C¡B¯´ì€² NÚðfMp1w­²¬(œN@5 Âf+ºü’W ‹Ò™É•/÷%3ÇKÛ™Ð.Y¼QdömL¸ž»Ê>ô‰ɇÚl•‹Ä4‘y|8 ùñÚ"Ø«ƒÉÕÿZYR6·É Ÿ‡…Õ(»fdN³D»xج†öYܶż ôpBB¸ò-S3æáÔ‚K;±Ë]íO°D4Ý‹r»Ê?Øñ& âÒÌ{²-¢øæmëcf³QjyE‚4!_5oÁ ÆËo‚dˆ ɶ©E‚êì4á’çÀ=ˆZKœ§Ê!á¼BÀS”ÔÕN°L„釞åÓ=•HüFHD‹ @ÆLؾÑòí9A‚IjËLáÛ™_,ÁO¼dÍŽeÏz4– xÃÄ)H_dš-åXôMÄ£´ÁdÈLädMÆaÞ¨Õ¸„_ p‡])Þ?Èœ-ÕÿœD˜î„ ìA´M¾Ø¼@-eø@m8K¬Ælù܃YF˜NHÝ>é¹o¡P&D-]?5‹KÔÖWRuÌ„K„äCäƒQ¡\Õ*Ë8¢j¡˜LÖ`pâYÄþƒ1œ€Û½üÀÒÚà\¼ÍD|@ZõÍšˆ›æ VÖév¨-jÇUàˆ-½"ËÕ‘û©:Ò$M²¥>„Œ.î¢ÊÀËŒ!m #=¡¡o4ÒH,`¶Ä4þƒ-K5 AÝ¡BI‡LÆd7æC.ÀU¥u\—͘\ñ$PºÌ»”Q¾A¨Ïúÿ@Y‚üTa_@Ù1IA Æqcà5M<æô¨“mÖäa!០2^gí%¬€ xO>&\Š@øOE.D”0•ËDØ^T Ë2ò“‰€•#•žGpØÂnü–`šÐD0‰œµ$AÌ$OÒ&Ši߈ÌY͘ޤgö•݉\Á”E|€ …zýCY.TO¾$Ó«)m?f–‚NÄ+M„,ÕUEá¦Uˆ&@Ü‘¥@*›Þh\eèOÈ g>8¦îAfIÌÄN˜„ÅFÉTD>•s¦¦¡p‘d>ýeoÀt´JWÅ(56 (Í$zº@j¡ã7ÒßxÿâYeŸ|®‹BX@+lbgJÄò%¥EäVáº=–D\ß'†È/"­%è†&ÛiÇ›8VƒŒ¥…:¿ÕÜaaâÅÙÔdH†ß4$vŒh.x¬¤ŠÎ±Œ>„S1UmM§’TÕ>žê”^͘DtP Õh²L yÊd>©>€èc‚c Š ?Ä”¦ð¤D¬ã?œ]H?tfMðŃ8œ‚HÈÏ^È„þC ¨S¹äC™6Æ/(†‚ú]Á­¦PñÛÌñâù[ÉA@C–¢)Æ>~A°ˆßèÑ`ŒèQ%ç‰VdIb›mHSP’ÞÅC´ËÓjµkG¬+KJ‹ô [>ÀÿÛpnjîu£{•—}ÍjÅWüƒF'Re>TÀ5hJȺ܌ÁHteÖß5­@LÝM²¡%n¢ßÜ«-E@º%¦­&AÄWFÆåäQt¹€M)ç%\‹X@Fè k°Ö=•E¼bØGX'? oÔ5Gmül`B†(!?é½Òd7Vl§\NaèM¨jJ¨zÁRÀˆ…>¬]ÂòC!ê'ñ øˆæªIÄÁTÇïT!³"ÛÞ8~Q&dÐä‚=Í(náPA›iN§’ê7ct¨ªÜшÜÑŠ¬ÈªT¤äÊ‘àBR»üÜEdÄ1òS<€äŠÿDx‡ÅNJ†ç±4mK¢V¨Þ« @ÕFm"¸"l­ÖŠ™DŒ‚”‚KÁ‰ݶd¶`i}<œØÒ”QYýŒÝðGaXSÝ.¨ÅŒjj¥§îýcQ [7~@4¥û›‰t¨DXΊPä«Üjp«ˆ­ÅæMdiVÈ„ˆ™ö.*pì^ÎåüT7™™ÄpFŒ¸‘Ž„ÆhèˆÀ¥³Ž«~ÞÅ(‡G6ñíHô™2®W1W•îF¤Î@ÅkNÀò@t~ù`Åš± üÍYaާé’XT4ME/Úû§V|fH¡lž’´ÇæÅ9ÆÃJó— §bNËÚéf‰“71ÄÈJ8?îù>.‹ZÒ®¨EâìSå†=õ†º~ÛêtXèuHòo‹HRJœÿÎMu?uq¨Â›¤,AWìru~yÙTÚýR€xWÐÌDÀ°mzÝ`(ò*Ö6À£¬aŽb`œÞ4 géOg˜r¿4äÛZ g™“ã¶ùR‚©øð´fFú8ØŠbd‹T‰D@ ÑÙÌê(uI‹Tu§Sg›=K†¶qU¡!†j,Ëç— !Þ¸€}÷÷8®LXQþÇ 7ÚL¨@Z¯Ï1÷ÛU”ŸÛ"Ñd BjͰ.×pÊò#J6I†ÿtxÅÈgýüÿh_ˆ˜è7«ˆuŽuNÅÜ]f;Ël £‰x¤“˜€ŽïYÑŽPKXÁg_qWQ*KNÿ O'~‡Ùj™}7é bgxˆÁU4òF€»-xÍÕß–âZcLF¸ à=Æê1dÀß4Óá4N©(ŽÅ€Qþ\8e”H9òOý›‹³8SΠ†R„‹Ö¸kýŸ%9D‚ž 5Ény[H²Ëvîh@}§ED‡ˆ5•†Ø·g~ë7¼½§ÙÕô" €÷ÂöU?c£HÈc¿AZ^\QnèD´æöé2J·¬´nxN©ø_oÖhýå|sŒ§ÿrZD8ñ¬O cË:1nÌn$£'·¡6IèbçvÚV¹ëéhñŸ}£-gVµX¤©{jÅC˜Ù÷ô®ÿË” øÚey~ø ,=Œ…>a¬¯[³is‘GÊâz”ØúDŒ©8!w‡+'ÁNFµzV,BüOÝyfü‚Þࢠtõ?xøŽFñÜœÒm86mÄïÓ‰”0à¶O‡ÑEÕ¡ö/T&=:ÓiHÀªÇ­ö—¥gtöÏOïÆ¨Y°‘EÂötPW‚?¡4Y„†À×°&Ûæ šëº,"÷Ûõ‰4®á€Æãî­V˶Q©¨‰kü¦z³[Οcghòçå•kaÐ0réü¥Ðjû¹–$"=Ò·r,Ë ¹ÿ™êÞÛ ¸'”Ã'¼:ÂýwCðX×,YDôæ Q>øÿ„=Z…³HäØÐù'V}kjÊÐÿ*‰/pLC ‡s8Äol,N³±•½‰þ‚ DîrW‡HÈÀÊD®E £kYÀå–Ë!h7•æÕ dVöWs¨ÊòãC9Ö·K€YÔûÚyW'õ³Èh¶À1}9‚is6™¾V•Eäé1Ð7ÑôâÄ U+DÔ§ï_®„ÿ"ü'âá¿ÿ~A¨J¢‹!œDÉ—ËEH"&RÚ Ÿðý÷áÊ•-]²|)óß‚œ bþ3ñ/žŸ={þŒg"^ @=ŒúOžxÂdhu*Ï ž.UJÿlX†ùøÝXqcÁ DúøtÛ¶­¾|rã¶ÍGÔ¿†*0üðïï¿|óÙ ÜSÅ?=ÿk3Ã(‡E¬ÛQ‡ÿ6G,s¢DˆE"jtq0Jd† "œqu‘‹+\8¡wÛIB‡}0bæÍž-ñÝ´z_Þœÿ<õôðü_×Ë@M˜øÊð'ØæÍer¿Ìï?{Ó§Óû‡è†³jõ­[Á-Û¹o9×wùï‡^Cÿ$ôeXá 8Œ(óˆâ ±žîRM‚°ÖzPÚ‹P,Øì“h5Š"ˆ$ˆNC(ŠB$ê3’B¡"’" ±É<Ê¡"Ø@9䈂)8†^Úñÿ8æàéŸ:*&ž22¦£’Ä.ž Ÿb`+í¦ëÀ)¯þ±ç:òb2OŸÔC¤² ×b렸Ȍ‹3²tüÇ‚Z1d¿ÿþ!:¯Œá29ˆ©ÅbR(&l3 ¢ýì¡‚J|ˆ¶DWüǼ»`c à 9ÓÇ…]ˆ¢ÅZ §£Üêí¤5×dIGVòjÆt2ºZc’.I¤²ÃN¬í.󮃞*P*K-{ú =D”E¤­12ä­ùÊDh³QbºÿüÀÎÂ(Õ@,dHy(靿kèО,S³ 3”0¢†ª/zZ¤gD‰V˜(³Ïâ‹O#ÕþÕÿ@†Vðá$–p¹¼ ¾ê>†~Ò)¤ž«Îƒ]‹ô)ž¤<áŸ`¡ÌÊ»ãtꉫ*ÁÃòJc{2ï~È"sàøœ½yÚ [úá†â èccÒ`è|Œ¡=ºç¨ç‰i²|BèŒ(%Ìì2ˆÖ²°¡_¨½W°\îb¨EëÍ9¡|>ÒG¡Üš`ºÏ¹0é$ RŽÕ+î ¦<ÙàG†‚ý©:Ÿ$ªÉ"¯ûÉ“ma¹'5X†â᧘e>7¦|*]ø$ˆËm·å™uð…& ²ìÑýg{c(i;"@€¦ÉeÈÀ<šn­±¶OÒœ:ÈCªó‰âÿ¶ø•ö ›,µRûþ.‡æFÛ¶|DXÀ$åP«¥ãÞ‘(O 'Ys¡:Æ•Ië4/à'~"¯|*1ñQ:@¥¦te<žûè#º¹ÌÅfrqêâbyåE-üŠõzh\¾sZð8¨à6éºX /y!„5nyá…¦‚ lTô°a C Cöð‡çrÂGós1íNЇŒþ‘>‡½j&ĉ M`µ“[åcaÉN“º›¥.‚8c–Îb¢œVP€/~1ZLÔøÄœ '^O¦F©yTïlšù¡8C/j­æ‘ñÿ‹><¢Žj#-ˆŒyn£¯Cê«“œ¬^OrÓ$šoezcSŞت™XE%7úwŽt¿ìt ,ë¢PL6ÆJ *·ªRXÐØGcÙƒx²‡ÍÈGšÉLkjSÐú#§°´Ñö`¸®¤nþ#xÀžÔJЂrM- ÂŒ˜6õÍ,/,™ÞôÎ*?é°z‡äS æ!ª>…F ‰›<öE|,Œ+IUMhÂ#U­©}4‰•ábB2‰‹#Šþˆ"^dî—b#C0¶”‚Řtb¦oV—·tæyÁãþ12‚˜~ŒIbŒHqåj‚y™Ì(jLÓ1ÿÜ>bÃîé«OÄóÓF‚ˆ¶ƒá®EQ‘FàÖëòK ðÁŒò"¿ñ-&}3+ü*WÑŒ-E£ŒÛbGÅÈ[€‘9˵Ô9ò¨­NWb©ùáž2‰À\‹ Ðaˆ¿0‚}É&QŒ)–EœàD`c’<™™ˆÓû@Í#*´q’(EÅ]9‰¼Ó6ú¢ÔEÀ0Ш•S¦O\€?£X)š‹N>Ì_r§G RvŠÅÇ“ö§Wª™Û àÆiá¬-‹ýAîx d7@55Lv½•LÜõd `qÚ?20È=9-2Ôj”…£Æó.n3X' ÿt™Mz52p­B4ò'PÞF]Bßmk„™@lb`‰QHæ±Æå²'! ™OºÂ[ø`r».Q¾RÝž““ãaiwáÂ:/m&9@sìÎˈ¨íóPÛ7ÿÈì)AGfÌeq™¢‚í¨ñoXBÄØgj-$&];½~y2N5[rQf3;áŸCldot’¾)ê6­7¹ÉZWI9Ž (‰³U.‘K×’4*¾ú܇_X¢p Ñä1Ì2óÑÝÔ¼ñŽ~$pÞ˜øÇÐv2Pߦ%ˆóÉ|×H 6r- Ð$Í–‹˜Í©õ$dõ¾GÈ$‘!¹É…VÐkÿ_£97NpmCV +Jõo¹…ßû“••ô)B‰/H¼Qì(%;õ%óz™Æu!.6=´y¥ HàèFO0Ò0½cƒ²ûœ6},Þâ©Xî1.@íƒô÷ÓÆBeþÖë2‰Ì&Á25›'7=´M Úðp‹ÛSThfð®Ã×¥bûÿ d¥É«Ê·Á¤pNÙE±ÓŘð¯HDò"ÎÌ»2„ðüpÒ(ncê€9wѽk&¶è(9­@„ûF,:É]50†hàü~šÓB“Al‹‰bÛS±†—Hê¤ØçÊ(ú¢I\ÇuÂÃ܆¥vì¡I*Àsˆ¥èªP)­fVÇ."/,`/>ÀÇÞ+æäÅB’ÉõäÈDO#xd/¿Î&3,ƒ‘â !Å#ŠŠ °îú°M°iFš EœàÌÂvM!í|`FþÁú, Â\‰(–&*ŒåÞ¯(ŠK‹”Ë9þ¡¹Hˆ*¸q’¤w(  ͯ6'ÜÄ£IâÏŒþ¢ÜfS˜)øtÞ2£Ç´i…q ÿÀ%‘ˆ ,°Ž!â+³’l¨³\¨'ÌF ÿôÈÕ(¥Oj:@°á˜¯Ê,&Úî4âxRÃ| ØÒªäúæ%Pâ}¢ËÂVBV€Ä~. ;æü@æ¸~ò¼H*ôŠýP¦R,,H& ãdF e±'–ð!k§ uGw˜i¥êÞv §Ê[ ðõŒq²¤ t¦î2‚JÔ~¯³êžÎf.B5tè` L“¸¬×ÄQ!âîí’qÁ(É#œÀìne"Àúê졌b"òtÏpé(²:Ê/¹@fÏ Â ÙOf¨q2Æ–žC!¯R,>ŒXШft'I'uÞ LR2xÊMôæö4 1¼),<-&B­ö.2ÿ8kyž,«`R7¾‡O®1z-‰1Ø|­O@‚ž„r(WWæ8öN·8“GÖç8¬VpPcHÌþ’‹zðIÜO¯Äâ®¶Â5KFH~BH"'Xèç±C;Æ)M !g™¸e0Ž®02‘, (€vM›)fЬëüÈÈþ/_ÏÓøòw‚ªê~‡!ªól¦ ,ôAB§9Ï3t¤ezr!ª>Ð=ßͱ!lc™F3‹Ò*0ÑûâŒ?¯B~b€ ÏÚzÂüþá+t…¢¢‚r¦Ã W ò4‹þqÄ’b™ÎmÑ#-‹ ÞäéèÁé¤ Íƒ¦‹ öò2&–@öÿ„g;•Œ§æ0 r:WhuFäˤqsÁµF$'¯ ‰¢OBPÉ ø¡Тͮ//˜íÁBû¬bÃpn¸ŽWz0¹FLWì*‚Å;PQ;´ rÅ: r"ÇjSq’‚þ £»ÐÒèêhP½žî9C›IbàÜ>¨:O„¬S—Ñ;Ã"¿ÄB€0¬Æ<­f”¬1P8CGGD㉒ÈâQ! À T ÊBF4SIÙç‰hP鑤žC7‘Â’+ÛŽñ Ts~Âý¼C+Ô€z‚eW{µdp, Ç(m@°p06OBÇhjKbàôÀP›¦Æ¦¦øÿè$ ÄL4$µ3¢†ëø­:m­ˆZ²©fªÂ!¢1q S 4âl©áH—£‰^3+f­ Îb"J+êHÈ,ÌÐ ‡eNÑXlÁK‰sþ¡Wy5LÉÃ(ÎÈ8 cè²IñÞ$0ÆãAò-ÿ!æa Ph²>¨ÿ¡d«Seï‰8`E• ,¸¥'ô!0â%%ÀÕô!0'c쥈V²!©1} ×|2H9%ìÁ1óÁ>‹ Jå`ðT"¢Z‰3WÆ9.JÏ–_5ñ‚P€j5,Va/Ãl–9RìñÊöW{¢‡çºËÑ,cG²M2ƒÇ´)óÌ#›ÿ pÓ¶äÞRVe[öÃ[GmE»“\XvþpÖÕ¬&‘$W5TÇPbAã&ªÑ!ì tGTV$ñÅb?Iu%òÃG‚+,< ÁÍ+FŒ:®+»-a!šãlÇ´€ª#)ÎѸ%¿ì!ì$F!lªNæ²>vNbbD $pO@;#[7&³Œ(¾h¦oÍ/ÌæÕŒg´¬fáÈãlTh×¢ ”ÜWãB$QœÀnK¦ïGÖqk‚¡*ºrku-Æp¤kq¦’£°: gaèVwX}7n‘¢s¬0ÔÅ"•u/æ˜5.?ôézâbÀ`N ª–`eÿÁ嚀[¹îidïäi4øæ¢Ì7Db2Ì3µTkA"õ‡&n×z¢Á(%tVVÎâ*ª3£‹4?få- ‹–$—®£IÆñ”‹·Ò'â6xÛÔx²i´ìú‚¦<öNF=”@Š/°`[áN {ÂD-ÉädRuv0¬Q!·cy ù£8'âv4hƒÏ6êW(tVÔt8XÉä˜m?·–ðbbU•ĤBìcâÁý"¸‹S,‚¥€Èts*x00˜fb/HϦp*wpÙCc¬ ‹Ì\ZwL¸dã‹ßê÷Oùfa6,„Ÿ D{î¢|w§|ÿ{Y’µfB{&i#xøª !BB06-73-VbÃ2Ù¡"jjù“ugă¤HX5V–”#G7–lSùVû¹w¯ëw‡„™~lèÆXY™Ópçcf—Oo<ä!¾¦—¦Îz·7¾é›îa æë¾”ìê¤ø uá9]‹¨Ô¥!ø#¥/CdžÆf<4 4 Ñø!3Ï¢Í"Ñäfðt[¥} ô?KÆ~rD9X«xñvW•ÁWx2§•Äl-‹w–ߤvlwð$ßÚçß< ià Ž£¦d×…,fÐib¸UY\-DL Úˆ%¯9’‚kÊ“ÊÿÂì›Ú@t©/ðfä(a¢äؤ}ø×·?ÇGn¥¥ã¸d—ЇLu•P™‹ýÙ©%ø9$ÏmÈønâMú#0êò½adyÇìšÎ\Œ iÐZe[VeY¨¢¦ö¸³1غqÍÌÔåj"0Nm¢¯¤O0õ✭/¡»ûø¢æÑbäñ)¸h5/cWnIº&Ga÷y©}—¢È”sܦŒE‹N60* »À:yGdc¦:— øê¾R‰X¶Rƒj{c1z;¤ÇÂ`t¶l(°v.¹½.ž¦1>h¦é¡»HBkeeÛFúF•pääbô֊YUdÿ\UW ( `WÐO§b6SùlͶŸ?b'‡•§CíÖxâŒùˆM¯ÜN€ŒL¿3¶ËZe+Úqù˜W,B­;Ûº'â0¿nÔé–[hÏÃ>LžFľÂ4@(ó!ºtâ_%¦‘ƒU{XW&Ô±(Îë(öAëù)fµ¨â¼×vmø³ÉcWÅ”•£C´1ôxuÇÇù£cq'ipéJ@ȥ׈ÊÚÈPØzÍEEÓÚ¬—¹êø­1ÆE£ƒŒfìú/$(hkv?2£¥ÕI±y̾'2ŽÇZ¤õT`.<}ôú¶¢Ä[å°–(t‚Œ>™W Ô²ÿC†ÅY¼=FýtnйØ5wu¹< »¸%›Ž÷l( š& äZÁÈŠ$³«øX` à=EEÝÂ5Ú²Pò·\Ph#^ÝUº>Ú…<»\AÌwì„ûxÌ£Ì)e^1s| hJ_ÙD{IcÙ­ŒªÝ@¯-łūr(ì¤èŸÅ 4‚3ÇÕ‚%´ÅØxg™Ü+€YÇ#Ý“‰FÔȰìG4ÞÍÞó;E½7·-:f·SÊõäiôÛßáz-õa?…‘¨þÁC§Õ¹zrC)ôÅOCÈ|ÖQ¯ƒfïÂÍe"?™´%òâ ›;ª$Ÿ ”‚bϧ=Ûµdrÿº4wÝpvÕcš‚úx×ÇûÃ܃œxZ»øÀZáÒˆ*É›¢{béOröþÒ;5šÁ:0cPŽê¿öZü"‘8‚z‰GŒ¡OZÏi£vBƒâÓJå8óúšÍ·–ƒÄ§ƒ‹Žï­ØI*л8mxJV>bPð™†.Ò÷–(¦†ZßÊÈO€Þ—œ/Í¥òµ¤·óDÀY4† ê­ Ãm¥¥­~h¡™gaò0CP¶|\†ˆœ¯IrIݜΧHâŸÀ,ðôƒ#þy1â?ñš°(1âC 2ˆ0ã¿Iz²¥H‘¶:Jì¨òâ¿ÿFÄËÇÏÞ{öB4Tá߇ŒþÙ›÷ï„R,žø7R‰OOȸD ¼%òäÝ»·äžÄ¬pøG`,D±gÿM›öëÖ¤PCôÌ÷Aß? Bê“ /ß?ŸQû¤÷¯EbÅ-4´ÈÚÂØ ôìñ[Á`Àÿ4oˆðoCDÑÿ𑆸Ÿ… §=kþ‘ŸÄiÿ«%žn¹ È”™’A‡“aC$¾2¢-„ËG&ØRd”ӧˬÉ_>¼=í!þGá‚À ÿOšôD H‹:½ª¾S®YŮȖƒYiÚyO[kÝs•RQÙ%aàõÏvD± O> ¤ÿDeÕÄ Æh`”úŒ°g ÜÐÙ m`Ah¦ ´A­VÚ?«¹¨™f7xðQEÙ–A‘@:r”‘qÏI¤Bħґɹ$S6ÀSùèÄÓ„@‘gÏè€ÔS%0%Tt±ðTR[‰5—|ò%ÇÿˆuOsÞÇ~ýÝÓDW-€I=–KùHPXºØ ŠaxÂM@t=m؃Smvƒf,$ãs¦*£'?„¶€‘· D[<¾ñ8ÑmQT‘oA¦4r$5 ]FÌ9ù\u-EפLöÄÀ¦Üñô!â ETìÑE#î•&Tÿ¬™•UZq…'ÿDˆe§YÿE$à[ø­Å•<ŽF…b!| (DÞAôgb•Þ–@jP@>ˆˆàé?7¬àYh.þsª@¤†¶Œ)’–Yq7ŽàÁFU\D@ÆdDñt‘'.•RÊG’”QtÀv$S<1(u# ~°“¢ÍVðÍŒ Gæ?cfzÅp¸-‘•‹®Ó®{#Oè‘ÌTãH"òü ö<-ˆMÏS`ÿIO¾”¥M'V*"Ã\tc‰%X"(˜˜Ú§¡’Öp¨‚‹VpD ÛÉý8²n>b¤±p&{ò‘ªÿ ô+K!ñ ÑÉÉ ÓLÿŒC uÊ3ÎxáÌÓÿOô R@£I»˜!§^…N5î›MAäÕ›féG<°ÿèГûPÁgWò4ÁØóW¹[^ch Á¤ÿ4‘•d¥Àüs¢°hCŒj0þÝI 4´*«®®´›@ i‚ì_\JJZŽ$䌄sHr’ lqÀßÈŒÈØ3/%ë'CñT~–­ŒZ“{Ø5—4íiS‹Hô,G„ÏIO ºâ|¥ô ÌS8D(h€O|Â1T, ˆ†4HQhз> 1p1žv2ÞŒ,dyˆþr9Tîs' ‰’šãÄ™4 &©­Xp€€Rÿ½v‘ |`1ø™=„Æ”ªD$uŒP¶ÊĈïügz"ÜVD¼bHºÅ,rHž!ìO}œ†–â+9Èû‡5üAIôi{Ô“d8'R†CŽiCNаpÏ”Æ>Eäá3ŸaØ?ÊZ d}MHá4v›èH¤Œë¥H+ÿ2$äÆdB>B9,&Ç‹dÙ‘„e–ìoVñPsƒ5¢Žª[´& GF؃ƒ']æÁÔ1õ¿£–¶žó&àP m‘ &zÞ3ŸÛRÌ×&S'ÿt21mHŒ13J¬üÃrèJ"ú*”£¢ F/š¾ˆ”ï52‰H] Ý@¤—2“´Ô1uNe“©2'N§D OcÀ‚{5ûjæÆíæä´Ð3kE$E¹ "" ‰ð*a¡" ÉUˆÏ\vŠˆX*’ðAªz¢ôþÁ!è¶ 10FB%eÊÆØ¢µ%_ÙÇÿYf$U6êˆ.76‘Úï6¸‰D<`‚2öÏ.-Îe“ÙEJ'"Ó™HgÍ[Ð60¨AÅêìâ ±v'äùUc[žò2y':)\HùLMx¹ ‡K<°/•ÈÍHø¦û”@-ÁN|‚«8d èb/¡ÜÈ‹·›¼a§ SÄDÁ¤ …•’È„ôÇ!Ù";}cúRd>'¿JÒ¬DØz Ç:ÂhIë@y05µG…ÖP2-¢H…Âwü@˜´5áÜž€ëäVF´—¦{¬Ñ‰Ç%kÓ(ÓºEŸhËih BÖÕgŒÿc‰èøTD¤èÂŽª$ ÿ$U¹ÁûþÁ!‰tÔ [lb‘œ›÷J6Ëqi}µœXgÑIº2M 0M ¨Èêtr³@˵CqðÐò3z0µ2è¤jšˆ:•4%…`y“€ÌÜ<¥EžÿéóJN\¦¤Èk`Æ?ö±B0à ŽÈƒ†¸gŒ¬Pf É‹ÆJÔ‘< „¢Ùk%ÂãÂc5F(â#5d)…l‘bÓ•ó8/N;×Y‹p¹iürisp`LálAãöyÎf;µÂóp:Ó”7Í©„Ò€´ÿ!€³œË,Å•‡·“K!Ê$ Ì@·aе%ÐU*HAº“£™¾]”¢ÿ|=ÑFÇ»Øxº!:©«J½Øø‘,˜óÜ«™ÆY+Çskÿo–¡Z/v90P—:Õêĵq°@Ží”§~)¦mÊ­Ò±Ð,ÿËR*E–ßru?ù¹‰mL'ð’i‡È> tz@aO_I:Ë¢¿ Dõ5¢k:s8+îè´©=鸱ܤÚÖ áÄaò‰GW°N O}*]´ÕtWevr3‘ EIÓUÿž§å;7÷Ïâ³]žyD—-”çäÃJb²ÚèYD4` n”ØžÿhÀ7z°BlȨü‡½E‚oÿ#u%uV×7ƒ5dªbÿ‰C{òãX"ÃK¶±{VR¬Æj%ãD÷ÅÄÒ9AÒSšÔq£µ|@5Tô°:±Z|4E,UhÒMÝ&t[±&ç"BG!d5<·He1bö4>ô ì÷ p„Éa ‹>(p)‘xU?P0&Bu£au¡¡€Â$‚1³ñ€áfÿ@}N‡ä-0DUÖWHa‘UÙ]ˆaê".Ž4'–'IX ÉCÔð„NÂJZV:¶.Ò0þ¶W«7ÿu›fQDö$2_2°’ŠãQv3‘ö…$.¥_ñ5¸&Gàe»ÆkAu`ÂWBr®%䱈.7¾Òðþ—<=Àc€Õ”V#D¶Téi‡3:µÂP{P@ÿ>$&P{"1RÂv§EËH$ySñ5:¸†FÒˆˆÕ”÷À1€‚Ê2lrDó Eá(b)†lR4¦4ÏsÉáBa”C tÑHù0IN˜Þ<;Д°¨…|3d±x‡Ei%ð3R¬›Gæ`™5açÅ_(#qØ9°‡ObYvöZi¤k€H‚Ötvq3+x[^‚A1GÒböÑì¡læaUß"Ž”&’‘tRPC‘nߊ€¡©ØÉDÿŠ“Æ"±X€ •Ù-â žv.Áu¹†kX`IG–Rg©ÿ'S¼ù$_Ú\¶$YÈTFPMIq ÉrT·ÅZÁEss‚†UHqŽŽNÖ)&4¶Uò¡%.ÿP™H™nÑ A ¥7Oø£ÿÀ £)Q'pZ¸7P?à È0ÑŸ…ã^ÉQ Àˆ^ I$Ì(¼ @Q†‘e·‰kuRÐ@%™¡rò‚¢†²ZÓÉÿ€†ð<˜Ñˆ%„&²ƒŽÑ.c‘&ÝÇ/a'9JVÑêà öf  ™c©øtóù”Iºz°Ä"?à¤g•›¦…3†Ÿ†8!2¿È*´9{Cq–ÿi8a‘p(ÿ_ êp­¹a*µeàSšÓT&AÕkr=1/{Lj·e¼(<3EQWQ¢TÒ²é1xë“Ò42P‘(àŽÐŠJ”ÿÀ¥÷™ У— –ú/ðJñJãLÊc”¦…ž°)F"ŒYú€A°* —«¦ÆÈ°¿y–g R •KÓªÃyº¦Ãúe8‡s÷ð¦pª‚!ÏÚ $‚§0lõúGðp|Á²ã.R!ˆñ™Kð¢m£.Ž@¤FO@å)áIÐ ì—êð~ñº¨A¯@Ð £…§‹G„µOº)ùYÿq\*Td_iŠƒ1 adð£K#À›p±`›°hù6aá«Gp^V—^&wö¶-î2‰˜2/As²ÿ`x*pCðâá ÿÐ q[/ UE)èq‰¹U2$L› ®—Iƒ ºêð NT©w•$1€å3¬å>Zÿ°Ïÿáþœ—]/Ìš ƽæÊ ðÖÊž¾<­KHÔ-Ë3·.>~žvj>yЂnÀÑ☙nôŠ2‰)÷ˆ€¬Iô;>†+ɇTþüQ€×rÈÖZptGÀˆÁ®*¦5‘ä1϶Á¶GœhJñ•@„‚Zl‘ *í¥{r@MÕþA ¡WõÑ'™þ²¶†‚qI&©,àŸÿ•ìi².{ "ˆžîa®§šjŠŽÌ/âÙ¡Ìlͤœ¯Q9áÄ¡z¶%ˆ‚p/¾b’°²8¸g H…€¾NhÁ¬q TÐ)u `]Â`H‚F›rD¬úÔ:Aƒ†>ÐGSYlª´XIÒQGS`õÔ)÷|¸HÓb¡¡b$¹¥ìq)„b ­V¦ `d˜»IËœ›.K˜¡¡~<3;KIªV*ñòŽ©òꬓ zâ¯®Ã€ÜøîA+¾üÆú§,‚’pä ì%H‡5FA¾ä ‹ R½Þ'¯}`XC€$N{âŸ5êFhì&8hB¼Qµû‰'ÜW\ÿ„Bø Å"øŒ FЕÄܹÔÓêòñŸÿÉñŸ pÊ6„^ˆuc„æ‰aV”¥Í!ÚæY&æš³¹ºév 3:fÿAö§°“–èñ‚æîŸkçœr«‚Pèi‚ÀjJ묱¦—$t«-‚šH°.Î]ðÉBˆïy«'¿,ò·ç[¬wç A‚!Zi!i’ÃQ=5óÚT3S|ô¹ºÈã/#mNP‚%ð,X`OðÀ˜†­cXf’»ÚI§&cÒ²l2”Ê-GœUT@0´ï OhR1žyº“´¦ÔÃ[O+i +’ˆ©pç‹ô𢖳pO-}á‹XÊÿ’*ÂLízû«Þ¹öv5²ìmz×ËÞeâ7?’,€¡ù”=fE’ÖÐQ§2£ªt$ÀœAHÏ’iÈš.VCšã ar!ié9ɲö¤³›Hgg&4JÁ#¶p‘ÙŠ! I²´8$AøG Jð‚jÐz沞ôÄ…–&\Í,~rTÖ ·¾èeê3—ÕÐr”-bëÿ¨"nÕ@ˆU,b;ºQj~‰£ˆaŽ)Ë$lޱ ‰XLËÆb¥§cÕn„Ì™Y ƒôžÜD'¾[NSÈH¢½xr:Ï cX—¥-í0À? @$¯|e&ñá¸ú‚®ý±r^ "›¨JÿñM/•åÃÞöü„€Ê«I4õœàahбFL™Ù@ù°f>Svå‚U435n6çKZêáP0†™lðƒ°:àÆI<Öå*¥¤ ãù4L¾@‡,ÍÚ@„8.%’e B"ÚJŸ¬1qJ⢬ÚJƒîzMÇeª<ãE—‘@ŒæU#PÌ:c•Î8g#!Aá5︾2G,ÓïðÈ»c• (nä&7mÂCÕÔGÏYNN‹GÎja¥.×’$S†z€„0å aJV7º ¶(ŠK­Ëõ–ø=ÖnT•ãÞQæùÐD´h1DZ[—OÍ ÿÓ£d\ã Šù£ºtéÀc_ÒÌp>L:nü£7wr“XùðUÌqÎM˜µ¥pšŽ).$'Ink: *î\ž8ûõäaL×ÕJIíio^¦$Ik—*0‚6e«W .8«¦)¯¶EBZÿaQ¡@ŒG}«1å:¨W!$a’iêÇjºJ±Y’ž¹ä¶TH"§OÛôB¤ï¶.>Ú:·2ãw"$œ]/gâ”â‡)öåB*3¯¬–/ˆýDhSög9ù„5“õ,&ÿáÎ!Ô–)€ÑäÞ›£ŒNi¸½õe˜}ò_Þᄱ)fì^©IB/E—·¯zÕ=»$“#à±ÎÿkŠÊðÀS^¢G’ä%L=ÎcIöäœ5€%2Ⱦ¸ï>Xèö$uÕ‚Ö‡•€ª*M_©¶R ññ‚@ å¼ó\“¦¸øD&5Jã Ä,f·Nø­AŠ,SæøLÂrÐwÔå+cmò\Û¤¦8Åé¿Ë¦ïPÅÙÙºÊxšmd¨M1€;GýLå¿6VŽt~VP¾¤]c °ÐÕ“Í€„³A“$€}ëªE<´ONVIî¿“Ù)+ !m»ñÐ 6ðe!€§ñóTöÎïâS˦ƒˆªR¥Šæ€’^´ZÀÅG~ä¿ç ý ‚Vüà)$èy¾ÿcù¢Æòj \ÀÄ Œ´‚3Áîî ¢%;÷Vħa{5.¡8Ø›–¡a¡Œ»½¢Á=¼ òJ'Þó½Ú´Úhªê“‚ª I‰— ,šžäk­ÚX7¯h(ùi…òØŠª¡­°2„ˆ¨dR£Š)º€Óœù£+»úµ‡©3ãrŽ×(3o “䲉:«‘B¬s=˜€ xÂâ!; Ô¸Fq'Aû>‚¨2²ª‡ Ø“%´»Lë1¦È#»"µ%‚È€žyzx(  ŸTšo'B{6äÀ&q«€³˜¦X?¦ˆ¿¹jŠ.«³B½Wûç ¡ 1:[Žÿò‰t… p…¹S@²# *\§ Å ¬¶Þ›²òø¾ܦäÃ'ù@-üBX|9Àkª $3„Èõ¹‡ +T#²"´k›2²juú@‚à2~#Œ.ËA`ò­?ô-Î .á¦D4=üƒ3’`n:±çZ=èr£nd¢³pÂLÄñ¯Ib n1ÝK¥ :¯óò8ª°$¥J>V¬³Y‚Ê  K%òQ*ði%é8“ƒ€§1«8™²ðÆ+®eé-itF/«‹òŸÌùCSÁ'E$¬.y…‹™i.«:«·wÿ¤Šv:E,J{dŠÐ!€[į23t>’˜/zù«O:ʲÈ鈲51+²jŠy£“bl…!À$rT• .AœŽY.1Ã)‹û¿˜WÉâ:®q$6|»®ÀÊ:ž@¬&$u–®D_è¹Úh/Íê3 dŠôʺ‚õ¤3©‹¦üÊð Ê8CXÌY¬è ¤Ì¤D_<«7ÅïðÀ¤œÈœ³Šß.¹ò‰A4Ë`ºÄ" ¤æ¬Å¡»’ÄA¿=91q4¶DDGä'tÂ̱cDˆõÊ7¦ÀS/k{ÎÆ4E lŠdšL!+ühÊÀÌ˲AÙ´Xÿ”J(jšÏ©VHÊs¶ôHšÉ{ÌVä-Bü2 4аС#X‹35›Ë¸ŒË¤³qL3jºÆÈúF%t„=WXÈF±Î@†cô…¦¨døÐ@¯Q¨Gá,AãÊí¬‹x |ÎDcÈÌñTÏI»ªcJˆ¼ !ŒbÄ¥¤ÁBIò±ôÆã¢}3:@DºA¼D×{™™À™2y#‘â ³ËnÜ’ ¢.HLÄW{º&„€LdΦ(L`ð` ˆ%ŒÂ4E x€=¦èÐ 4RD‚)ã¬éŒÔ€ЀJ! õ‹H Aƒ‚%h ˆÞɀȌ̇Cÿx…§¨Ÿ[È‹<¬ òK€h¸ýäÏß:KÄœ@¬‘ Ro¤çZ³šøAÐCRˆi=!IDHÌ [}='ÓVCˆ:e/d8ÌPÓ¨S°ÉžVaôÑ%`Ö zG{”V„‹Vô !£Q h6 ‡ø‚hpµ*$‰^tžUÃÑYò/ú,/zƒM9€8]½é<Õœ5‹L:Ф—YÄ™ÑFCêKÄR,è‚‹=A.[mPÓkXäŒ2'¤Xìd çt6%‰õ2Êg½‚pV€¨Û RWNíÒ×Õà2¦…Í2j°Ùœ9‚¯³8ÜÆn\I»üZ·؇V Ÿè£×ÕZ­õF;) !ù ÿ,éÿÿ H° Áƒ*\x°Ö¦b(ð>‹ÿmÐÈ‘¢Ç;0èá_‡’'MªÉr`‡üøg¯@M„*þ©ˆ‘Sà šöò!z£èE -úh˧Pþ¨UßÄ©S >L…•+W‡Tÿ]¼(#> ø6œk!ªÛÿPÊ=Yòm‘/aœiÓ^<{ÿlÒ$˜ó #ŒìñãWÑÇEÜLùƈÇ#ìjNˆâÖ‡ÃÄÚtè¦M‡V]±sZ‹hcwÞüÖ“À—)o×­k’7m‚/GĬP ‚ßãß¼9 `ÿb$¶÷³ÑÈ“h/ê¸{æß¿¯zÿ…5Ù±ÉZDmpâ¿Tá³&xÖôÆmÓD+¤#ø–'h’ yý7'#ý3Bù•œ=*Ä£ÂL处€}@cü 娖ݰ‚d"2Ùcˆø[V£xFQi³ Ú|«™÷ÐEXtß@XУ@hu£Š%œ¹y€$’þ7y?ñÐôW•ás6MT?úX‡Hˆ$Nvƒ–!‘UÄP*-¾ÇžA7üCÁ {R`ÐŽrIk9þ£Ô¡G-ÁC´#Z©Õœ!XÐn'¸dnàÙvÐqdϨZJX¡„^h˜¢ˆˆÜÿP‰ v(­”š×Y-E$šŒQà§!ÄòOÆþC,y6ÛìBë¦&‰’)xÙµjÚ¨~båZ)BH®D’€N4‚TVp%—{miÓ_6Å4ê¨azx,d#° bˆ-ææbDŽ‚O‹CfD–h‘7!Alc·d"M¬'ŸíùOžr>TÙµ RI¥ñ”¬$•#h·Á”¨Å-¥;n0‚yuÒ¦8îf–2hÏ!}B!B6füäóÁŒ,ÝX‡dV°¯eú:&>þ¾©âlø |‘Âr¶hZQ +èfÇR÷ÏF4fHs8qŠ 4s¶ Æ£®qÆÍÿ[ô?ñP@<ž1izÿþ>1ÚæIÏÕE®Î”ûV›‘ppC?œsþ‰#“Ä\Mñ*ÜÔ… 5Ån‚˜oŠˆˆ™>b"µÖ[w+çj-Š-Ùp¿´Ò£6øÁÚJ¯}üŒ¡mµ‚LY 7OŠgzăì AòñÓm·ê[aþÁÌ1öÈÞb£ h@1²[Á„ –­ êžzÒÎÿnÃÝ,Ä@bGÈÇ*Èï=ˆ" ä'Ò Nƒ‹1D‡h×!ÁjMùcˆ—¿¤G3 U¸V‹¹§‚ó0Ø€1ø‡óøAØ ²"`lƒòóHñȵI  Ç<èQ€ïÜ€|ÿÀÅ¡‚‹ð ‰ °MnT9ʉ+!÷Abá8â)8‘sÀFüAKZR#Sä\ýî·˜ ôÏ‹CA? ¡À i2N`”)B·0‚Èl~š=c[2ƒG ÌÛ+ˆUȪÀƒNœNN°y¸“KøÇO$)z0bMƒÞòAÿ|Œ ,Â}fÓC\DE“šHBýc#¤$C<El“ÄPÔQž8‡:§€Zz´–Ô°çªqE%‚ J€ƒG>¦óàl~p‚ÿ`ø¡¡Qõ­a@P@› ,šÒüÀÖøƒ‡´"Oƒ[ÒŠG!|ó/$»¸¤%ÁîŠP˜‰=NàÎÄóòÈitì):=&+¸•?ÿA;Lj‡³ñ¤[:³‘M¶O\¥4A\,‡Š®R­üúÑÑ:–SüG9Øð ùuîaм Îý©Æ!æÕ€v ýØLïÍ] 5­–Å`"&½ÿäB7T Àþ¡¯ ¬ÿd3=uÒAžnÐÄÖOI–îI’u.ÿGrÿAzÏ„Y . `Œ´!¸Á•U5èüÄÐ$&1A¤Ã®´ÂQmQµXð‘êÄA…kã+HC=EظÄ%@š2âS’˜8pŽÿi?ºKϘˆcƒ=gk›Û©@ì€ódƒ»ks®¡IçŠe‚Öƒód,cM`%(a`æÝPóƒòpnAäAå:Æ»14p!‚Rž?Ñ4Y7=oÚsU1vp-ŽjŠ ¡`µBJƒb’ˆçŽÇ?Τ¨X±ž çl^ËÎá`¿.g,A‚ l’ÌÚHf©ù“s^ õͶ?îLô‰3ðÛb 7âHO= „øÀÓã=ÝDV Æ+»Áä]´žÀizÔI8 pÄà›açÁ9OD6M DRÔ»ŽÕ®¡Bx÷nõgG‰õÿA4Edœ#-œâ›ýÑÎÙCòãB€ƒAh£ÌÍ/ûo.RÜw ^ ™‡ ò5z$ªWz ±ZÀ‚nwë†OK3Iˆt+3}†À,oô&õoó $8"ÔÐa!:ÑMÝÔvfhð†bÑB)²+Pc9–ƒ¬6)ÅjzwzGqbA>åÕE@kÄ¥$M²uJô}@t¡°xíÇ9ü`Yjvr=°l5° ù'Œç`Ú0zeÖpsžU†\óm@‡z6Ö•nŒðeÂ"ÀT÷ß%peµ\ u!01±Ç4ýF|çÿdC¼•Gö ˆß”HÈ—vq‡°|B ®Qq«—}Ò”IàåçcQHäG Äu) q~<‚DãKåeý‹‡o–…v  ØÀkø†ù×9[8Áеô àYÎ&tH•€µ@g¿òsºãT?pnÁBq„v7P%àÊõÊE÷‚‘÷ð@ˆ`!·ÐoA|¼ÅH4ñBþèv…˜biÕžø=‰#„}—OqŠñ2–Ò'!gd)~AQ‘bq$·_óEKQ?Sæ° [h1—l¶´ŒÉ˜Z*iŒføɸŒÍXmÏ\côÿ±Tq6(qOuÑB>qa• „‚JI õ6CðpÿóØiø°H˜¦Gô`UÄŸvH÷0,Ä4wU^ 9?ˆŠ9ÆD..ræ§j«”X2À9!iK̆þ@fõ7ØÐe6'+Y˜ÿ@€œÓQö·kjXme(gI7™ ˜zxÖZ^ãT÷t|&FvD@Žæhoê(@oNù%c­cvd öÈ[.˜G6ä|Ä•.öi,à{óðóˆð=Ýu8¢XŠâ¦8ÛWýkq„ñ æŠ%¡)õIýaŠ£¶He {iK˜ÿ7¾Vm/y˜/ùds/)ROf†Šù÷EŠ©'añL÷™F¼òmyPVò4vâЛð‚èxšANYo/~BK3M Où81@pÒåvôô`ó¨40òPˆ`9œºÓC9fP:fT ¡–D@%ÿÐ^%t!k‚5k aX@”€²X8sõfˆ95ÐØPè9yöõ’ÔàyTŠl´„T „ ¦“à¶“ý9(@V'ðGg5– Áõ榆 •$TCòäú˜•Ä÷n§ˆt:ý{!p ×0}7@ ­¦jÿ)^lé¨jÙƒw1³æ.¯8 @úquYQ²ø³ eHZKù¼V=“©…˜a†Ô–Z<Ç¥±Ÿ¬et«GÈðZGÕŒN9€$i"¶”ÿÀ¨©!cò$äWY*­.T‰ú¨?D+ðpC ×€ +@7÷a<”jB zCÂ}Øç¨?ä8QõPE‘Ö¤ŽC¤…ÓJlÐ95 ŒôõªœcÂ( `’Év’Œ÷Û˜´ `×&s£‡s]SŸ1 A£0 ¹ Aµ°gðq'†p÷=|‘&˜ˆšÆªŽlʦ%0RLÆÿpd·BÏ1/ !ZBÅ$Ja⺠$A  ¨>2)"q.J y@y ZðW|OÞ¤T 2@;`Hòÿ°y0 ;`ÂÈË9Oð2`ŽlJ¦nêÀ O †œäf™C7n ÓÙ(M{f/PoeÊÇwiWæ»0û©‰®œ-À^,Pp!Îq=!¢n³l¢"@d’41Ì WGñ´qÆ·ê]0Š}¬ÛÀ áŠya»| ücÀSS¥!W\H,fH,`HðünK€ì+ùc™ÏôF¦à¦ý,ðÉ“™0ÝR'ÜgÐh¸‹‚ÊzràÄ%Àb¨H74kËéølÊA£âƒVW„Î$ÒIˆ0+>Ò "C¬ARGùÐ?yzÿµ™TÆhLwPˆQº1Á$A\¸ëÓ±¨JPˆ ­´ Ò™1%"ÎÔÑ4÷Ï$OT}hÁË9ŽÐ dŠÉN Ð^ýÉÜ'0~›±7ù[éñB%Po9@%€‰*]¢38Z‚Ñ”KóV¬ x$T!’¦W4S@‹q"PùòO#QïmCBÔÇâi¡ÆÝ²PÒD£þAÎЗµ„™zD‘¢ù©+Öh=ŠXH, ð4Õï–p÷àÁË ºÏþ ¹ÿœË”I0Bg™w¦0ŒSA­P¸øñ;pAŒŽÈbx$]ãT³x­×Qogjÿ7H14=lóבÃ+ày˜ Šý¡2ÇÓ‘ƒB¨wš >m¹»žÐÀ_[ †‚ud…¶ˆ•8ª#q.ªÞ4¡ˆQ­ÈˆVb'Æ\·­ñv»Õû\o]ýÛݺÂFÐtTó£°gR©ÐA·àáA,Û‰!J]¹ˆrÎc•VùìNòPoÉe‚sNeçU&V<»£ÂÞcò"Ðè¬U¢‹(uAÀ ´2Ü•W3*nGP/³A‘$±^ BX ` > Î’de7B0"ý5.IÊw¶¼\ò¶\\É…ŽŽè,¼Õ„â^ Ü^ÿ~§§z–Ê‚°(áoNlÉï||4‘=ž‹Å0!b°i1ðÎX•••T%&8U‚%mU×.=£òMŠÍÚ•bå¡n#}&ŠZq©æ]Ý—8ç‚ç MK8 N˜ìBjQ ^6Á®Mu'O¶lË$ÖçxžŽ÷ 9–µËë¦nê àÛ½Zªèitâa¸±( @†ð‡!˜šNœhZåY240±=ÅI> Þ >ö–„Þ‹.q‘/^ï¸N!þ$¼p.Jû¾$dãJVM ¾E¼ÕOp-@Åÿ´ñMû#1R} ^ÛUøQò @æëÓÙq"QÁq~ª„I1&aÉNGàù=÷.HàÞ“~ý‚ùcè¯ABpøÏཉöíû7êßG!Eþûñã_«Vn´¹`¡ %N!£&È#òþ-9Ñó߉=5ÌSaϨÑøUà7BÄ¿F8õðß¿x´j=j´@>~YýWàŸ=z?—Èkq¢ÉNžn—4ê3í?}ÿ‰`ðoƒ… ø„Œ‚×?Á!ñ}Ä…o1®ÀBzêû¯Èˆ#?šàõÏDÈÌš+k&ìiäˆñ®^µ÷#zóN°`A°àÿm¹®I¸°áÃ~0,ZÄX€#f/‰¯>£ðY0ùë7~, ‰¨Â¿4?æ°H@‹ž>çÅ §‚‘Šó@vý`/X~ˆV4{T…ŠöèÑà„¡Ð ¡£îCKÀ–Ø© 4&¤¹þiKzÀÒ‘ dƒ ûç°ÁHkL± ̱0í£ÐFªJ$>Ó,´?òdƒ=ÁgÇ€”‘¬²Xû€žd›m‰#Œ“H"ÝBH¡†JH@2è8ò²#0G’±JŠàº!ÊŒ`ƒF¨€‘yX¸çò†;âXê„yb£‡žÖÎ Ôžþ©¯+ûýÿj¾»þÑà£yðÂ>ÿüsÀµzP'yšpðÛ²0C~ôAÍÃ,ÀG²Â„ð¨9Æbq9É&s±¯ž¢q³f©IG¿Lc•4T+«?8cë©¶&1ÚrË(§ô!àt)·'>ò2!è–CV:|LJ ¤üjsFfo¼î‘'Ï8]¢6>?º+û>ª €ò© Ð@/mOP£Š**@×î:¡­žd{´ÓNåBr¯ôðIb"P¤u‚»8á>á_>–´DªgdKFXêOóhKåø¿|èeù‹-ˆ²Kf0ÔÌ`¬Fš±ÑÎN8£ÌàÈ9ÒLt÷«dýxöH’’fS/Ú¯iM{Ü=¸`Dl%Ä @qoú± 'þƒÁ€Î«Âõ‘Q8“:gÛâØdˆvÿ‰D9ŸÝþA·ûÄmœ!å!/7êé'îkX‚ì±Dò>€¬‹!Óò§DáQàW¸H ÙA‘Ô`–S"“‘é  UŒ'ó:ÚÅ,gÝŒ cQú¬XÄújâQ–ï8ª–·¬Í0Ä܃Iç\Â/©tÄ~xA’BAo¶Ñj€ý€â3A7¦’œËÿ¸dºÈ©ŒqŒ±Xm‚’$Éoqª@âÕ$« d^Ÿ‰PæÉÕèã*óü_kÒ2À?íó>úЇ ØÊ¿ÿ¹&ž‘üªÚ*“]4"‚ŒHX™™"«F¯c_))$M)†~QhâQÄÉ/ÿIÏbÁ¼ ÅË&5éœ?”Ç_̘f#‡8D6¤÷/ÙAáªÅ«Â:“\çCý^øæa@‹ÄíFÀÉÕé6HÅ IHšª:ï/-eu'[•O0Ô(«ˆÀ)ˆA$e©䃭Á DðDä%!8KæÎòD,à“_3Ý`S"ä0€ dú˜…°°ÈêÕ))4[øYžð„EÒºx<6úœd23ž3³9çkãÙkYé[þ‡þÑ€@3\Ìé)HJr6D@–Œ¨ì?ŽûaŒ1`¾DøüÃ= )©U?rÜ[­Â™’P,eí¢—,äÿ-kÀ¸;ÉD¹ÞAxÍR~$½BðœÊ0ùÞÏ©ì0Ì‘ ÐþQ™ÖV¢ƒµY°d&³ õ H;Q± Ì:Þp>ÿ`œN0>ÚÈã¤A$HNÊ G 3oÃßB@2EÌ^Ÿ:¦l³E `6ù0ŒäÙ‡©\H­±Ïþ Š:Ýh5äÒXÕºÁ˜…äHfwžâ5 yü‘(ORªX€*VPðB_É æ>ÀEa‰{ù ºõâ÷E©DVÎt6BÐîE’1î^h4“Å!Õ±=èLj$ï¤9™°fåá6ÓèA½í]ï~ô !ÿ@ °&âç@ÑÄÖAÿ~ßÔbäæ Æt¢¤4 FŸEoŒ0wlî–ê̺øy¤±¨t28¹JÖ~oÀðòIþ㜠|°üZüpÁU΢]¨¸ƒÔ^ÊD”P0—Ì“”ÄèZ5ƒd…ý­ œA©#nÛ™Ù0òè¿>¢½Åàìò³LX`èuË+S|¢GM?[%´ûã³ÿèô¤èLh"¦\§äl«§sÞdF¨Sª»Æ‰›{PS¥ñ¼ä/y$÷ÀXã)?ž¥>ÿàç¬ÿñU¬œå ñ*bl^ˆ LNoˆB´½;ƒ¾°rLG’ÌÈè„ÍÌ{ÕÊl;H}+ÿûŸ—Pøœ|ÚQÐèô‰=Ìžá´7¤ÚØ÷2 ±-fÒÖ1É Æ‚§‘Ì8nåóÉ2ñóRœ~]=£Æur'7žZ$¸àS3'Oy~ì#yéî?(ñÿKH• —“2ßÁD(ÉÀ$×B¨ø:Å@3« Ôˆ¨6óB%Œ’3nÓÞÔ)½¾ °v¯ ´œ"tâ ö°"·ècˆ~ p´0 8“‘Žîû´Á/ìÊÒ #Þҭ󊡈¡x”³X?½®Ù(¼9щ*D*<ÁÂÊyFꓘ<Ø.¶ª2ð´"!¸+ò¿ úÿÏ+}ˆ¤ìR/.cg30Nâ$d 5,6³ψ™TÊ‘ZñÀ2»ßy¬„¡%(>F€€y4ÚBC› 8Šç›A´K;h€êùjÀžŽ€ÀØÊ’?ó‘12:) ˜{ár5zªpBX y¹“ò™ø«Byy‹¶` /Ì“Ëíúˆïꮘ KHÃ4üœ ¸t9(‚àKâ9ÓQ™ø"“Ôc,s„¡‘ФD‰‚¥ÌȨoS=ã(XÄ=‹¸ˆÄI¤ÄJ 4LÌDâC­EÈoÉšz{€Rt-í*ì@›í˜-úq£{˜1͸áB ÿÁ㳨 XË¢±òÁÂmA.8¤>ñ§€‰¤b+¶Ë{ŠI°´¢h´€™¼3ï΀¤dÛ¹QÇo<™“‰¶—i¡Q‰ª(7³½Û)ÆÊWú•Ðùiõ€DIô"¬œâAùH|ð,‚$H죢g"›-JYº­7 Þ¢yÑ“PœùH£»ŠÚ¸Ëåry±ã ÉX J¡âÓ.1d+ftÉÐ|69U:RBÖ^ ‰%°Ý;,zœ@¨(šø¬Ã:‘‹DÂ;® ˜ü¯¢Ña¶Ñe+0·p‘¢gú31ï;K·Á*ˆòÀ€S­ÎoJ +¼ªsÒöÃŽ 5Ì!”µjU”‹²ˆýˆ—0ÿ@ÑÀUƤUÉÀÕù°Ì;;¼RSdA  ”¥Òô/@ôŒÐ`Ô¤Ógýˆè‹;-Š5ʡ׀ñ)§$¾cÛBµ²>z yr«p«š{W€×R´æ¸%¸J]Kd¡ÎR³Kð ªóèHø¿­B¼º´ ×@I•D„±è?‘à5^³Ø „¼„TO5´ 5œF™¼IÌ9³O"™Æ³b-•‘Yš‰¥ã•‹*¬ló«zJs ‰ª 'dêÙ8©DËz·5Ê.¦Ðµ-šûx xЮM×§}Zh+¨ý)Ð!‰ëÀÑï¸Èz¿ÜÒ ø{ÎÙXlÉsÿ„^ K¢5ê@Æ´å¿‘èµX_ƒÛ6´+Bû½[ ŠIÈ$ÀD ½ðÆ$ÓÌLŸa¨üZÇj믢„Gc ®•Ÿ¯uáÓ.µÕ±]ÃFUQpW6]‰€ƒ&E¯ï©*¼‰ñÈÍ¢®-^>X®Í“ॎœª´°µsÕ ‘H¹¶Å5à‹µXš”[J ÉƴƆÌ5$@¨ð“¢òÞN \Фûb¨Å¸I"• DÁ‘Ö‘à[ø‘ª@‚ð¨,W~N‡-•üÕ_.þŠýIZ}=2vWŽ;͠וY"’‘d8®±/’ª[ ≵x77ŠE·ùÐÖøa ‰Ø³ücŠOx˜‰[-ÅUš‰ÿû]ݸµ‡>á‡DÍ4Ðq¯; çÊHº–EÖÁjÜ$V›DDßc€<;¯³@/¼Jä+'>±\,žåü-T[F× =ÿîŒÎЕf…·[ ¨× *}© “‡¾ ô5Ø«§êHÄ*».þZÛlÆ5ÍP‘è5U€[°Æÿ;d†Fÿ @Hþ à‡P‘ÄÃë æ¸³Ï,::@zÓÏØ™_iÜ8Ã(¦,eÒà‡jM¬“ùUAäÓ—Á4µ] ¨2ý'íjÑïzZ]®è3.ܲQca–%~`„Í5ŸðW<™BHaå$©M·q¼“¿hùX?>ú€b+aµ¦;ìd” ›VOüêõ|äröØ\]Oc€HšD™yÞOÇ(VýÌ$“¥¤5JÓ$ ð•Qv\eͪ»Sˆÿõ03¢¤Ì Ø ˆ2J Ý8,Wš£9ôÔeš)àG+Åzõãâ~ªSË: "ëZÊN#õZ„›?=Ž'¼€±PëɆ²g‹2_Cá”Óisžoíùä‡ú8mÇp¶÷Úï×M,Y!G¿ çÃ5VON3ÃR޽ѸŠ+“¬y Ù(TÁü€âF„ã^V(áYQÕë`+'ñšq&)Bçêž-¡±z‘Î}軓‰_æõHĉî/öã®2E„q;·óf‰ææÔu7 ƒðW¤ªoÁFÒ‘ ÷r‰ã¶([÷öcÍp^ÌvÞXíN‡™$@k¼Ø¤Ÿ ¼Ò Lxdñ¤„bu¨ŠzLJÚîò°Ïü¶Ü™ÓýR ®Hƒ¦¬ÍeyøÐÈ_ïãpçpÇ‹dÏó‘ovg÷©R¼k½€ rû&–¯ˆ7Ö¸X¬à xidIiýûŽŸ¤Ê>îïÛùöæ5Îç–cCnÌ†Æ ø ºä k6…’zÐ1Y g?DôU37+ʾ`%S~öÅŠIœY”x4/§'>ÿãVïG‰÷pº e/~¼7N‘ø5‰H*$’Á€  l§1µ‡é?Ëão° ÿˆkF¯mfï˾ZË.ò]sÞ^Ã/ÿó3p]-熂@pD™rL¡Lð"&¡×1ø^ˆxÿzè0ð „þyJˆŸÀcЋqBÉ,XÈ“Çâ„ù !BDÑŠV*S.XAA"}ùô¹aó¦ˆ"Erêˆo¾ZÿF Œ`Èп +Ìûw⟼¼õ㿦óblÍêtàÓƒŒæ1 Áè_¾HM¢¤ðÏå? +Ú®8ø’ê?UyWøÈ»àÕ?J}Pê;ÐÂ%Á—ÿ¼ôÏÂ@J‚ÿá"ße\… ý‡!¾ƒ¡ñô´ሄšXíЄ‰ƒ þ³Å á¿Ó¦wSeÐÁCêì ¬˜u^F£Îûð¡¤I ­äJw97f>~ÙõñÃiS'ø„øÆúÑêhR¥OÌcpŸ€ü;rêV­Á–ëu`Yÿ|pP]Á%i ®°€* ¼åƒ H™CŠQâd 6¡cžQg  ÔA!Ræ>§åæàA® 4Bk±yU3ºæ™–Ûn*æøm t Í£rqTÂ?!IP/E™’K'IàœsùlÇOM7íÞP£ÿ”¬•Ô@ü4ÏM• TyÅÿô÷r`ýSÖ€ÿ âu ý gB¯¬Ø “ d…i8á`zxÙ(™…†Ëxÿp6Š mÀé*ºHÐ?1þ3êA&Ä#ã@Ùrn૬ ù–ãjj ÷ Í£Â<Èit‚G'Lðú ÑVuQÆôOô0B=Ô†`–úè#¶8%DÔP?˜‰TB\}Õ@ò%d_TK ûO gÅàÕSýãž{¾¤Ï@'ý#‚\ ¹Eè@z !B¼Â¨£9¼!aŠB¸€ ]öf—ŽwÙfR•"i!$ck!—ê¢A9ÎJÕB+ùÿc<D\Vô« %Ì‚Ož4åt%],{Ée4=×f«­M. ‰ \zé÷Ï}Fü“Ã@„.Vùu–ÿ´©§¾Ià'‚ˆ´m[+ˆÐ 5¨Š¡1|P_„-ú„î×M+|ŠfDÔ¦™h"§ªG6"å@ôªË<ÖZ«j¤Ñc$’J¶p¬!úDÙÊ‚¬ ýÊ-wUÅ&½´¶N'$>â’„¦š>}oÆ7U÷²‡¤´]Õ»œG,,Á^ƒÖ× L0zýýŠ„„&!`ÿ€¿°y¦ ûÙsûA†(ZâOŠsjâA ¥ÿr‚&LþkÑÆ6¬ò£d¡YBŒt4@€g$Z\gØáŒv÷  àÁŒÐ-QÈ–O|B HÍORJÕµ­u­>i ¼†§$Ü!WI²èV·º `s™iÅ%6è|éÈù $·½¨Bn6ÑG¢ÕœÜLŠDŽ÷báÅ™c@̨¹W1N*:ÈV~ÈL,Њ’‚¬ øL: hŬ‚{uÄ>" !@X»œ`t!8!Šc”µÅ*ô‘Ê@âÓÃ$ç^žìÈ@ÞJ=áp u3b[Þ—0þ ouaСô¼9Hÿn>x¥^êrÅ(Œi<£Äh8†?•H<ü#MpÈÀ Uÿ`€mV&«iòFŒ `¹ˆ,'EI.Ó¡€>$ö@¯#V¡]y‚”ÐQHa-~2žó¬\"NXX°I­! „JTäá.³I/”ùJH@©ò§¶ùÉ$vAÐ[Ž80ÍMnuYAó¦Ê)^ô_.ÈGBЂy´ ‹ú1Y šÈ9¤øßxª’%¤5³Q 'nSšP“GÉQpæÈl"ÄH{DÖêþqB NùHrn&Щvd££ÖâÈãó˜R) #ðx®\r±Ï9‚•áydzÿ9“HpDº\%‚¨J‚u‰UˆMþ¡^¶€YœÉ €)š”*˜\L‹På©U· Òcñò£S!„¨úq¸BçD‡7x]Æ,i…`gWµYrÉÈ^U…^´@+®—ϲ€Ç#<2‚¶ƒp¤ ëùJ ÿñ$Sþ)•vq‰]æ˜Ü°ÿª+‚Ñì ‹$H²…”²T¥ ! Pÿ1¤M–³-*|eóÌœâ¦sa#ÿ¡¦¡’&Õ" #$àGg¥îJYŒÖµBðÕ,Òã"$]ç:ÿ¡Ô6«+4ÏDb ؃+þaúIÃä}%!Iª×ÿôÚêQˆ_ ™«IˆÈ]½š’ºÚZ¨Ûþe×ë"Ä®;¾ÉG£åT ?r@ùÁ„`1Ʋ’*Z€'4Æ“aîdV¦i‹ªÜªù*/ ÉQzR:F^\)Ë“4å¦Å,J³G´F—‘È£ ò s ÚTX 'w<ñ…~pƒüÎ9ž%ë›Ôeô™XIþQ±X짇ÆånXŽÝ2Qpj«Ó2ÉL<­­lK°ÿø….u)Â"$‹Ð "(±Μ¦¼Mf2=Pe•ÌTËÜ2bßm-Uük³= .)I8Ó²`{üW¶vv×N`gFd¶‹CÈâÿ‚”ª)å,yÈ%âOúÜÇ#k‚kXdg¶`Zh¹^Û0 °ÀB´.nÓ‡sœ´ fQ$QøÀÁó–Nÿ°s[ur‘–vŽ´„“ ˆ2n^„,Ê,:Œ^TÎÊh |ÁÌFÏUó§[žÜ¡Û9¤!«J') ²ÒZ-6ÂÁeäYç4¡°ÜN)ný5i§WùL?¥â5v”“¥tO>ËfJoÝ-ªs›¦qŒˆ€# 9x¾ó:NRv&m¤È/ Ê/!ãÙƒÐû—ƒ>ãÅìp™m©Èu=SÎúÚ!–+ °²£¥f¿öˆ)^è’ Î%JÚÒÒW{©ÿFB89ËqW ²í!‡I(‚þ‡ aÈ>å mšÊ›2û¶ÉÑôvk‰í½ôç¢7 "$‹,’”¤ ”‡i·œݰï|;‹#ô{p úXkUZÐ'Œ«ÔD~GÈf‚TY×Ì$¼‹ ÏYÚˆV—x£C6ë2äüàŽvàdz¯¿d©i!Nµ`ÒôÜô%ß}4Á=VX@MhøŽruÕAÌ˼¹Gì…Ð?‘ò„ÒUˆ’œ|–€˜Ú¿4×u ‚h‹dÐà @u‰Eö…ºÔhåBveO]DËS„xM:ÕΜ”þ<“Žþx ÈDÎÇÜLíÿúQV|© ÊÜ@ÇÁD>\ÕhËÏèCÈD>\‹= =`Ä ¸ òÐ|ˆPítÄž9D ‰™!Oh=…1Ä%yD°´`×Ù D½áEÛ¸˜>¸Í¿ Ö ÇŸlóm"óÝY· ’ÛéCÃéÑ\ŸSÜIÉš1q†’-V }̓Ɋ” ‰z1ÓùõÏΗNñT%ÄmlVIÄ Á Œ@L„@8R$övü_µÈ±ÐaZ`íl}Û@`ê=‰!T€š˜Û ºÝ‡‚œS½ ò}ÍAùG ´˜u-8ÕM$>ÿKjí ñ \kÑaò…Tt[ҜБYWB¤]aµÝÂñ…`\ OEޓ߽Ñ,á0®† ðRŪ¨—•IçxJC¨½”¨‰8bL\ž–ЃÜ=rš–À5n{$‰9ÝT•Ñ5R,>†™ ÁV€ÂÝÓ¹•XºÝ›€ØÌµ#½ý¼D>ÔMŽ¿d%¾š‚ ’Î RƒÔ:FÅ}Ð'Äóñ "´À™½½Ó¶Æ†HÆÄâþäFh„ƧԚǠ”1áGJl¬Š2 câíÔN㋇p•ÂÅdL¤¼Ú=š`Z´¡œÑYpQKó\£U¬ÖB&ÿ—h˜"¤R ÈWñÊ Ãj"”<ŒÖ@hI´¸#q=ÕA ’RDbôÕð¹jjÉe¶¡‰¥ˆ&öý´Û&ú’ ‚øÀ_)\>8–ä#5güá%m§§pÊwžFº×ªÀ†F‰–Û/R¤Cœ¤Ap¡pÄN3:}†@L*Øa‡H\ËèÈV#ÙƒþÑd€±;abry‘︬¡8ÞЄ…ÅÙÐÇ¥£Âé ëIíQ˜ ÀÄ\PÛpÝ¡… &bb!Ÿõ%'àYq<Ÿ©Í ·Hç;5geçCЇ’åe$%¡h¨ÈvÆ3¥'^eùûÕÿF/ú0>Ó‹Ø"²ÉLÒCØç?DA~Š´E#üTK´€©€RÛ<ìdÅÑ`…EhHM=ñK„cððÊ@ â¼!'œ¢'ÞfSxDGPBô B–¡„À Ä,[ ”…ÅYß?`@rréÉUu!DܨÓð…ˆØÚvâϧ i¨Ê`öϪ ©ú¹Ô/¶ O•$—‘JDðÍXéèØ§}ÞN$®@$ŽÚ€ µ=œ¹Ó€®ÓjõÛõYh°¬Í’Z #È!b rzÐA$Wkµ@¾K‰]‹C4 ð‘ÚQr”Yr€@"™¥Y™ÛaW]PB. V†–ÿÁÑÄÇtJP²”аÔxº—iG¬Êü«*ž­hNéŠD@ Ъhi~jILäê¨I§;Gfl‚ÁOÒüçk‰æAœRËA¨gZ…5EW–é&jk) Ø©ÎVZOKƦ€ ¨¶öPòœSr& =´@S–Ľß ^„¾z„ÌÚÊ¢^6ÎÞ}çªâ…ª‰3¥Ê|ää`Ö?8Hç4éo8D GQ G€l™~zZÅ'²Q§=8Á‚uì4öÒk-–®¬^%Éé?ÃÙÜÇ)&Ä»¶,j…Ë¢&uÙ•ê@BðËŸ„Ó Ù @%óUÜõg–TÿÌ ì½æB¶ˆÀ_ͦè%^` ˆ©¦<èê%F Äáš%xÍŒs”¯C¬MÍ¢„¥íÛKÀ¾“¤œä‘Ô ¾º]svZ¨+B>Haˆ.2Þ„ÁôEïh]Â"wnʬ“„_Di-Ê%ˆ@@ªDCÄŠé@ -U²md$ïq gGwI§–°m”p>ØdœµµÅb™E==hlÆP¯¸U”Tù†×=%xEeOs‰ÿ(ürÝʦ´u%ϹšCˆÄVÒ B Q]èEú褆êæëú]ãðz e¡¥‘‘æâÈeý”î”ám¤¤pàè¯m.°!/Åæ*´© £p¶°H`K"˜;ŰŒn•™ôLR@¢QêÊèˆU$ {t›Ëjæ#üœ!s±Ínb¥=‚ J[qèž*$ŽÚÛqW^ˆO©BÄt±ÞÓ÷×iNƤãE2ÁlJ©šŸËýâÁ"¬lGvL×tžGRèðT@«!ôB=ôpÊà@p€æÆ·^)\§½]oÊÿ÷(;¢öhODUÔ¾èV^iÜè…Á@‘ùP‚c9úô.z]ÞEŽ}aÎÖ÷å¬FÊ$«†_nüȆ73 ïLD3Mÿ÷aëfrKw Â~r<Äô)‡÷87à 8è| §ó÷VR"§QBÞøTcIoæêä² l'ÑEu”lˆ]éÒŽíU #û ûàÁàÍ+°ÏÁ(–÷‰üI8FoœÈ7ŽŠoxÙ_"„ox8ˆËL¨}H§/¯nFâ$6·” ©I„‹×t7šÉŒjR¤E<Ê E ‡ ,}ÐÇ:nsdé¤A÷V±U’ZL0BÞDeçvÍÿ2F©zSOѧ'•ß’Ä*ì;ûû@'F&á•W.sÜE¶3]xB”ªá=“Hò.U¼ÔäÄ9Úr±ŸUÿw‰owI¸Àý-ûŸt—hG!;±£HßVÀdë—†!ÄeS[ ‰{gâ€ØÕ $‹€p sÝŠïžuá …º[T{·ý’CTN`Ô¢¨Â4w ¿ýCv>d|*§ÔúbÍË|—9׿ŒJüˆbzÊ“J°Ð_6·°Aæ±g³nª Ÿ‹²芮ÀôœCóó6çh<2ËÛxý}UjvÖŽ‡Å)nÛ%`è9+_?+kå65žk%^¤ZÁä…æ'ÿ8“×åÕ[x‡æË+‚äBÔßDÜ‘îcì6hx§‡øY¯§­‡ÎO­ì?S0þƔџ`Ý_u$±oIŸÿÃ4`šø³ ˜4 ëÛJu MR<èƒÖ¸€TMsŠÕ޳ó(mî@DIÙ\P¥ç³’ä6œM¸“Hm—FÚ¨·ŒrÜÙUªó÷?˜.Ü{2f–DĆÿð Hðß| \°à`D‰)ôÏÃA[!Fô4ÁÁ#þ‘äWÀÞÁüôéË÷2Š“(/iæÓÇòK~:òû§ï_iº ù/Òø~ü0„¤Â… ?T°÷áßÕ”)rýÇAÿÀ?yO´˜Ø"„>"þ‰@„UŸDúæ"úiw ÞŠmW¬±bà߈+T©ê+â—@ÿå’8wí?¿ «ú§ÊE”(!œ¼t¡¸í?J ùg:!Ã¥ *Dèºb‡½ãý3Qà F‰ :xúH‘§¼3zð‰{ Êt[æ›ùÒ¥K~ùt¶dÙèõ¤Í‡ÚL*wÒƒøHßPἄˆ°r=™RÅI‰Äš]2ÞDDnd^—¹Óë½;°µØêK2¿¡¥\BÈÅ1Æ€r@¶þ)¢2Ëþq‚™òYÌ…¡4´ˆ BhÅ¥jÈ¡ßJš­"jÈ„ˆ: ÿ$wîÙJ!£©P Ê~ l®&—¨{I§ë¬ëÉ;ñH´É¨¤^š( ‘J=ªþù«|ì/¨bø‡‰îi¿B˜«÷#@ç*0" ÿj¿ÈØZk…_$+BD#k©±9Ó(1ì´­È6ŠžBt(}>û‡4|„XèÅ…"Í´ÖZDh i¤ÈFÚ„<è#ÿù(8ÿñ€Èã²Br¹ý¢£é9šªk)ž›:Íi -ôΨè4ü§)/Ñ›J"Ÿø)ó ºj➈8hóžû$Š¢N¼$èo¢i)Âp¢É4²ÅÛìŸò:HPÉ"BlÞ(þi¡( ÿ›²€T]#Õ´‚ Ú`BšõUMÈã‰é“ä‚8D ûAÏ ñö|±Z9=Hç-zœà+m*]ÒÌ2 +ý“sôôº½tJR˺Ü@v×FzÌÉ&¸Ë‡£æ¤™lF3[šHÁÚâÒ4oTÿžDB±ˆdWµ‘!àvˆ# ±*ŽŽ„ã‰ö0{#ˆ‡•ê BI)cäÎçÙ±OY8Ñ™²‘üCa¢‘=40FÔIhY¡ÇಖÙXã…%]þº¤ò&%KŠÈGûÇ’ÉøI]|íq‚ÿbzË[c9Èe•©Ù0 À@ò„Y‘ýÌ&wpq اˆhJ_næAÆ9_lʹB?ÉE¦j›Ÿø`«(.U%'¹B‰D•˜ô¤Œ›+ndp>Ò÷Åôé«äŒzL'ÑM®xÅêìBŒS–ÊëW-eΙhHû*O$ŸÕ™bUb·M§ËìeÅ <Óèi@!Âm|Í´¶í‡™Añì›h‘³f(”‹(˜3æ«Cº!²C¯hž¦âª¨ê ªL/$Å)ë¤k?¿QDHEèMZ×ÄNÔH:I‘´•lôDì^ÇK^F­oDáQ¤z·è³Å:ÿÖ‹?Ææ•H†Õ&6 ÛÜ9IÙÌ8-0'|ôJý6nDÀâ´æ5³iQ$[õwBú¹6âEêmïïEo άFfÄÙôOŠÈ!²Á•%¥½&œ¢±öÌæ~Ð Ÿ™tLSÁ»XèÁÊŽÿ›tc W¸ZšÙ1-?-^沂!´Ù?«d´«½Íƒ”%"Ñ ¾°™)'´ &2Ëþ9§ÞËÊ‹¾|O²ºÂrÐ\€Æû`‹®œ §È"˜ä ÞèðÔêìµ²Im6ì'¬Ì )XAŠÎÐ ‚aÆ0éz‘U"ß‚å-7fCthŒ7:íÆzä{ §-à$bàÎ|”¥qÿD@¼¬CVÆšdí&N¢ì ahËø!%È(" €ŒÌE"8ÑûÄLÌ+„ÉOÈf"/:(´¢Æb,hk`2æD(‚ N8 ·ÀfZ®@ÀÀðô2F ”.!R…i¥#F"#üIÓÚѹ®G$‚¤c|d8`Ï"ÞJ|äÊHÄ%¾#íì&ÓqXB¼î„á$ª}°$"~ º¨Næab ­Œ&ÿ!u’›b€T uv,ë €MÒHæò:(bOª:r®j1"žŠÀÎòË"Ör!K§ èƒÎãœÀf¦èâ@" 7R5Vdéì F«ÿò† ~¬Ž¹tèyhçV.†ôÞV)|j”ޱ§‚&JMs¬‘9øA‰ö £ Ã&D‡d–F`ôáäÔ"$ ℌnbT£ézËyL‰ß– Gdhã' *P#h$d.)|0I[þi%jc'ÇìÒJœÈ1„§mvôT„Òî(±+„†É1%N uã5€tè9Œ¡!ã‘€ÂB’g,Û§šªÆB /ƒð¨†Š¶Žjiæ²9µðÁâój«xÒbÿ¢#ÞéÐBe 5&¸&)÷fÄÀŠ0±‡¬beçpŠ@ºÐ3ÒžK2%3|øa•âA21I@ÈŒÌ3·Q;Þ.)z‰ZœOúþaÈñÇ~ŠK™2ú'€æAT@2QŒAð"B7±,ú§ÙJË?’"LÞ(ÂêÏ,^îÂòOµh1ZÀ („Pïï ÏiºÂ.ñæÐL  ¢Ñîé"03I¹l£?$°¬.-|vÈ'p6€¼ôcí¥KX Ë’¢ÉB²¢ª6Ýtû8‘MÿÈ¥›²LÜlbÅ#Žô!ÅúæÔpÿÄ%$äÃèxFèA‰F-n@]áU«V#¸&bznÏê8I†z4T3$sDHH–1cl¡\Wc˜4IJ-[Fl'6_j¶°ì¨fm(%`B€!?>`LmMxc 5ï£ïÌ€Öô ŒaÐô – !• iÂe LN¢ÙP qËîp±ŽæÄ,&äá,„xƒB®mÂ"bZ‚u’dðéE Før;á³z>u?7(PÒ–kG€„1%Âîƒt ×M&BZq3uÆä«ÆÔÛ|˜+ljäñ~nbäòœðÈ h2Dà—ªÓõÒk6*µª$"Ñpï{À.|pDŒ­®<Çj_—ë˜"x)¢VÞ8dF"6 Jéó*jb:ºË+ÿN<:c ºä<ÞËK)˼”K™wÏ^Ë@ßïL‘µt:Q€ÊEN hKM)wÚÖ…v%¢iµr>9:¦íèrvõe1ð¹3F€ˆöE°Óa°sIêÚÊ6ÌÊ^pÆ9¦tAÍ{^E˜Ï‚udŽÑ.ŽºK3›ˆ&ËIˆlÖÔ¶½lM»4yˆ×ÊBÀ˜²ZÙZ¢†£ #i°9¬n빤N褈õT_X<Ô: ÉP9ƒ"Â(Ø&&o ¢"a¹s±XÝZïR¹Þú&¬nÆSåð†€ãjµÖ˜ißÒØàx•bµ™5ø™[FË‚¢%®¨3ÿ¬™g(À’‡×˜V˜K‰—xMŠyY6W±zkx`¬·§ÁŒ"È¥RG_J-|sMÜô]Š8p7‰×E´Ärýv®fB?õ˜BäL z 0/&Ý”nƒ26¤VwÅ+$A‰¹À™–­g£˜ÙøEÓЮ®›l·døò¡3ÃQÓbxm°eúÚùï˜R"– [’}Ú§Û™e"ƒ2èñ,9×ÔÏD±?ä½'Öæ&¦†Œ4 %øh¶©R'IÑ`Ä N(ŸveyTjCr/:És¥£‡[#~Ž+x£0¸¹Ï$ÃÍDËÎÄ–¦~ÂKÎýdŽxÿ• ï¬,yœp{§Í¥²vúŒá6Q–>Ú$³^*Ãæt,ujýœƒˆ»òZû(D{?eG}§…mìAnŸn`h_9iÅPUƒ’ âBFH‚kå0†r;c6f{ØZË7—˜áZ$6¦ké'Žbò%Î$ Îy)„ [<Ìc*¢Lt¾®ì½¸Ô@R²f3¨,"–ÀÄ»²Ôù69±*Ý€^ʲgêñj‚®êdˆ—úí(ÂØå{sJ/Z@¿s¢ %ã—Zß5¸ŽñݰG7b%†b<ÿp`WÂgÃG6ÍEf®{ìaU¹&S9hÍD`<ÜfQ´ÆÄ½ÚËÆ›ÿ ›)Çb{mZ6k“±ÃNŒ!²‡-k’ OÇåÔ•>€q(Ú4ï“+ÂOhdZ|í`Ø 0 U$ݬ¼Eh{Ö"¼s{x›$ùFotO¸s}˜ÓŠ˜où"”ƒ&´¢&…ýÃͤΑâ`DLÆÄÛª{œ»‚ïž,Ê9§í6Y§§*s܇ {Ûù³éõ!-È$a<[rjÙâӑК®5?`æÐí—Š–ѰÊ}+5Ü’x|jk§+­ß‚9áEÆÞ®…]@X„;ƒ&»þ;fb ºè‹ô ›dK@ymÍ(iz Xà¾V±†kX*Ë6ëN#yðÿ¸ï€·)ó…LhUrqÉe-Œüˆ4o&7Œ¡˜ fJ½@´:"RÄÝò=õ K ,FÇS îUã vÙŸ&âs=®ÕXuDسG¡B‚ÿý˧Ÿ>}.’Pá߇óæý‹ÁˆÞ¼ÿJ8däÐá y)ÿ-a‘rÉ¿KÿäÉlùï^N‡÷tâ¼Ç¨C Í)ïÄ zö4þ“àPT}-ýC4UUªZÿQÍ—ëC”!†ˆò/„@z'Œ9„¢OÄ ®ÖÝaƒ…øâÛàð_œƒ[®ëð†‡x826ÏÄ¿’¡@¶ÌøäÆmyâ :´­Ÿ=‡vØ¡C<~ &4‚`„ óMŽH1^ņ4~øÀ(ƼÁçÁäì‘Åqy,[ÚüDzù?¢:—Ü»é³1Ð{xèúÒyeóm|˜jT¯Qµ:Õ¡m±ùȦýGÏIÓô4üóŸ"rÍuÃ?uåe`zÆ—` &Ø N?ÿ+ü3†)eö‡DE‡j6bJ£}ÆÀi*ŽFÚ?'žxZðÚy°%ÄÐBýãDíÕFŒØ3=ÁqDRJ¡ÒH3E·D’*íÄRMÿt·ÓO§q`T—\RyB‘Œ”¥U)¹gU{ìy¥^Jb‘ECôÌ™NqаbWÝ€Ø^1ØØ_ƒ98è?:ÄÀ‹©Yd—™c‘qÖž±¨âiž˜æ"i˜RêÁü˜WÐA%t*mIäEfbô#ÃéÐHÊ¥ç?²:ÄÂKV&uÓVfŠ¥ŠdçÓ—=ÉÓÂRdýö›WV™¹¦Cè³cY!8œ-´ gÿàþ§= ÂÀ\ÿ¬Àç]íåç?? (_ öåЄz¨!?}ew¤&l–©- tðY¦œ5Ü©C›Æèâb½†AöĆ0‘>ñP$‚EL +~»~tëq'y„“r2ÑDt5 «ÝtWfçp±ùOl4¡‘)6!ÐÑšöÁn}ku ŒI®#'„¯.u¹»þD6Áøe†bà õ”¢D±Í_“±›d Õ¡¹9ämoKIÞÔ§7‰™HbHlÉßžø„ª5ó£Már± ¤G»q pPR‡ÄÀ$%˜Gز°àÜœÿKVâÎÄ#ImÆ`–i ÂnùÊJS˜’eqÒ[âU|Mm ŠÞ&¥!Дˆ{Ëi¦°ÑÀ'+Mgj9QÔh´•Í¥A˜b*{ -°‰‚ýò…Ú]€˜i‰”YåˆÉ8J™ 4SÇa%¥%Ÿ xº$AÎ U¨ž#ª< :M–€s©KÕðÌE6a‘)ù¹ö—'®…²]‚!Yß\àn@_”lI¨Ôº½ï13Ž)Q†¢ˆ“Wæ°–re¢]myK¾Jq5TìAfÃÿ¦Ì&¤#“¬5$cîÊeŽ•©®ð¤¤€Ã,¾< €“'çföÖçžcA/QPgÔÁ?úþð‹¿ÿ€A\2®§eÀŸj|æ6Ë-¡î ¾?~ñÿk%aÎa—´ûôa]£(#°ÿR2ÿ0-Á¨„P)1bhÕFtœAQÔ¥"S71°,óPñ¥òW—Ö$l1NIBÒR)Ö’(9µÒ“Z2‘HDÅpœÁ_wk›Ã‘ãçŽPH¨ƒ:×¾ƒx-aö` ö¤( „C~Aˆ‘Ózÿwm ’O\(4W"Û³z€†bró/ÆÕt°t{Fiõ>£á*À÷ô-"˜1^èD|Aƒ|M±+Ì×LAp4SUBD}HH,D! ÁÖà‰ŸŠÁ R“+¿¶qÁ6UÁ–`P`¼sFPÐ еˆÿõ‚aÒ6= ÷…cü"zÙƒ€Jt7ØŠö7u0*p“9 9¾Ž­ñ“„øáUuX3‚+S@L†|%ÀTEÙ$¼„H¥ƒY2%ô pÝ„m‡G÷èN5@Áb™ŠU…ŠS…–ˆ·HŒ³]p‡ÒåJW£´9 Ÿ9ÞhSj#á¨1OC'08€¸jо‚ÿS Ê”±&›-Amq9[9eÙ×M÷Èi@_ÜñOàûÌÀ ŽŒ¢!ª6‹ÿ ׊­Øª¡ ÀO¡ñ,4†–"Ï• (Dǘª'7%"E“*Q'´‡h¯¤0ÅWEðE°]öPð)ª™™™Þx*æá™§ |ô^­óŸQLFÐgœÃ@.Óø¡Å7ÖeÕ¤n‘Ž–¨eÂêxP3Ì ¬X8„0à¥p§gÖ, ‘Þj ãê­‡Ñru®ùR/1Úzâ0‚¹¨šqb:ç\+™"e¯KdDå¹0Kk)£Eñª¢Š™ó釕3^ôöÿøŽÓ-‚u”'ñ?ÃFGp¡ÑûæFµ›Ü7…–ئº öÀ›’À4Ë·û€Ua3˲ùr³?‹—w!¨‚z³¢·6Tk£<Ç=6'7l5D#0£”*µ—Jtâs7‡†)Á¯¼öp‹µLz,Ðf<&?¯ƒ? ‘ß…^X(a4qÿŸ¹ë0õ‚Ň$×+öÈYqdfDµ¶œqØÅ-Ù°²à·Ñ0ÖÀ Ìé‰ ð = ~ŽœÕš­ß»­ÿ…šOšG¸ÔÃO]£/7”"7ЊÁ+¶\r³¨‹ ¹h8˜8ñ\ˆ*’CÏX©î#E²{ò`º£ºÿ€aR*ø)‚¯Ë÷‘±µËŒÀPmbò€;Á»J¡o…5päš#Ç¢_3Cr×TAµ)qv›Î~ß)ÁœÙÖ°á7 mž*Ò> V¾¥'ŸDÄ1zP"àõ;7Ê€©<š!•´H©(Eœáî»ÅÁ µaŒÿµ`F3 ‘ƲS¯‹Û8Zhs|Á¹Ë,ð¨vFjÄ^#!%”mAühØA_Åâ}Ø•ˆ¬È‹Ìœœ¡äç£)®ýw›÷aæË'Hì¾8±=KÜML¿qsJጉo›zk“VúË’ÐËÇ,˧›“ЂºÜ“øãÐܦÆPQL¦f¼Û8olF05%I3i§«%Ô¿©=Ñe¦Ó(\~7à×àL‘§ Ì™ÒÆ‘6»žPgAÈ<T×T·T÷H~ß—-1Ú~áË P„7­ð…`åÓòÂ/]ã.ØÉ'«ÌG}Ôlˆö’áR=çúÿ>¥<£®àÄ(à®ý—Sd{x`Û¢ÊÕ0Ÿ¼½#ܼ¬#9’±üB7€ÜC­&þ®P+ÁÑç%]M¯ÖÝÒ;þN™âWh­ÕÛÔ0„Ô ŠØõ⺸„J!˜ý¢·Œ;ˆ@#¥T?*Ún¥æìà’á>UœÚm\ªMÕ‹ñ=³»ËÕ³|Ë9™³A4bŸªRÖ`ÝÈmC0×Îâ©- à&~A F/îF•UÂ<,÷u%ý׉ôÝÜ¡¶÷°ÍÖ?þ}WØ= Þp­Öà Ch·¡ñ!Ù|’¾âr;ÿ¾›¬mˆ *þBöc£G–[Ó¥4Å)ñ\f~¹¢àî¸)Á32),`Ûß}(í›ÀpEBqªÂ]ªâ“µ“|>(Žâ)‘ ­ )‘ƒþC†>ÝfäF›u9²ÁÒ_BeßAŽÞ÷ךœÞk€|ëÞÐÜpê¡QîzÖ êkCšJ-Qåm¨Ô)Áß¡ÁÛ­dÊ£d¹ÇUµ|€3bP¬¡¥ í}á9ÉÛªK‚¯[RýÑ~þÜ €þèêÎî-á %a×y 8c}6®žÕïs×Òã÷˜þ}Ïœ^TI ÿ²,«Ò[½ÙðñÈÝ7ð|R ›§É.ÔÀ ¥8QÓœ¿E¤×z$ßJ\µ#°ÚÉh?%ÀñíñÙæ¢º9Ø; ìí¼L5Mè­èùèé„>õ`âCÀÓ½99µÝœ±Žð¼4{QoõõMàQŸÞßÐßÎaߢÀÜ#ž¡d³-å¤QagÒçÑ87÷_ñKìÙó¾Å®üÎì®(ñEõQ_ÌïPáÑ.íE¡“PN³Ñí½œ#¤òKQù)1ùÿô8A蘟/ÐFÌ‘×`–%ÝSÛÁûàéÑOàuÔ $ÿC µ :ôç0‰@êpƒèOãÆˆ=~éñ…C ú† úw£á[6lù²!?‡ì}dô/gHzh8ÂÈuˆôgÑC‡ÆóÀo¨‰ñâˆÁ‚ÀäàšƒÀƒeËþ€A^ zì}È÷6.\{ùâÚýw÷ϼ'¯á‰%9ü»÷ðI¿‹ÔE‹fÚÃhŸèXÒ_€ý`(ì׃¡GŽ1ú…Ò¤> .)óß܉6´ùo^Îób?üP B~>«>ì@ÔhÓ¢W:´ÃÏ&ºÇkXÀÞ a€5›ÃYÿÿ´—7^¹wëÖµ›Ï­Þ›ÿZ¥Š •Rqh@¿@h(.hH1÷î‰ 2yšh 2‡"ü´¬Ñ¤Z5Ò>Òˆ¡~˜)Ž×XÛˆ›è!šãfüÚBÀq¯T‚i¥~à‘GCÚëŸxb¶ì±Ç'æÀûg~hâi;¡<Ê;-«ÂJ«÷¾Dï¼Ä*«½ ˆo>ýäbó.»êÚ/Øj¡ñB0þ‘ƒ{¼’GžÄ["²9¸ç±Ö(š?¢†"èÍŸ‚¡´x✃(’±NØö ažy ¨¥Þ€ÔM·†ˆKÒ¯ŽHU‡luh¯ÿþú¯×î@úÍ7ßLˆ‡(ðÆ»'¬õ¼ZO,²ÊtO>å{+„7ã*À®lóÃïŸþ ¤AA;ErðOÃð1@ú´Q6êL zèR:$ž(U¸NháŸl ò¡®¸’\O€¤Ó£#þyáÈNÍiÉ"ýêJ-…êÕƒb«¯K0ßcö+ jO,´ÐlA>úÞ®üܬ6q‡þG\ž ¬ž!ê ‚‘þÄÃ*ü‡Â††ˆ_Ž<âæ :¾!‘#o(úGÞ~ê`¨9û!‚itäÆþa ®…?zøTú­?røèŽ(a$ÿ=~u‚B>N©bâçª&«±ºÂ\=À5w¯!ÀÓ9.üê* ¹ŸñÓï8Ç%š\sbº!Wx©Ï>Û•Ú#ÔØní¸ÖüùÔy=R»oýèí X¢±%NÈKaÛVj‰¥h(bFrºçbÀÇÜǯÚ;bæb}Õ£>Ї¦ÈG¦b§lÅ\f°Î‹fÀ¿’VbZ`kÝÇ.pÙ–>P—ŸŒ‹@Òæ$ \B”¦´=5è!íiœç‘ÉôÃl¿C^CP¨‘õ4ýpÔï‚IýÃÜX¡Fô•†*nMp=þÑ}쨠X0"ò#ˆûýFŸ„1$*ˆAù¾Ô,™]n|^±¤5ÇÐŽ>ÓãÏä$Ȳ!üˆ‚ùz¼nO{zÁíBøEUÍ#÷`T?Ô1ÉIÒÐ4‰˜é¹ÏGêk”¥yBdšpJÿ¹µ­üGþñ0•ð苜.ÃçŒÑèL‚û‡ùþq-¦8 ¦ú¶gyê+c Ö3¦Ë‘i¥€@WÇÑéE›ôÛC ØÇÓ#† ‚Ч÷|Dj½d¼ö‰B5P¤=/ŒáRy‡ÂJRd”qÄcŠÊ„ 0mE¢ô 0‚‰c’V.­ˆK‰æ Šou«_w&÷``cå(úNPè­o}1•X¬0©‘Lý3ßIÝó¿ÄБ¦úqÓµ ›: œEëã¸fTrÖƒ0€/c(AY¨!Чñô¹TnŒM ƒ—@°TkÐá“¿³§UW˜¯5@ÿ¨!Kˆ>0 '$íÜG**W¸òäðJFïÊQZm,I,Ø«ÜøÊWt×H%(¿R®,ë{ƒãæÞ(S} vû€Ý »Ÿûðñ²:`¹&øºŸj°!A8L:´±@9DQŠ*a?p‘}6 xýpDc(Ä áI2ösHf+kåÊšËѰ³Sìöôå/i$IR×iM[µ„ÏÙÑÁ0¬æ;?ÛÚÅC͵ !àž!`4I<‚ˆ!1"I5;‹dœivczÆà‹1OÈD³™•¹Þ¥v¾A˜¹ñž”sêé\bÓ#Sy(zô¯|¡|@‡-³U¾ï¯yRNr:¤ØFjH:9ªQe?ÄÙ¾¶Є­^È!k؇¶™!€jc›åÚŽÿ[dšÇãð`ávtq‡‚Èã®íywl4íÄus®ê†hÆ<]Þ­lec\ŸæŒ¼þE=£èY2Z»Â^'ËE¾òr v.(­âÿýòa8fã÷Е2eg¢ØéˆÏ€üDO À&¦6µzä1à€Ö ƒ” d:x‚’™À^Žü**ø5TÞò•_®bRYTu0Oæ§&Àc¢?±ÝqqÐy¢K¤#ý#ÎÂèÌpÌãó`àÐäœ’ÝØ‡9=®©eº¸ . y¸fГ=6€qEh½ `˜íŽé¢LÛ÷ã#r¤»_ãD•Ÿüùÿßé´’ŸnbAáJPlW4„¸ +P¼¸sÓì!þ?w;=Œ¢ïq=,º¢óê½g*ßk)1iˆñɘÍa©¼2zx‹Zƒ,8¹ rᩆ;²³ ¿À¦©‡ú›¾†8€b°p€èò¿Óê;ð[¶†è; ¡šl§ó;Sâ€Àû; ‰´ÚÁÓZ èi"§q© !@°rðÒ±™ùž´Â·ú‡µºÂvS:p±§‹™Ý;‹8ô²=ÀY©¡Â¹ÚŠ‚¾ ¤µø¢µ°£2^KA§ ¦É ¦­ ¶°8/{0Ÿ¢1ØàGò;€DÑ>všÄuÿ:¿öh§ôó´†@• 0ŒµD¨¿úsB (—V (®ˆÀöP7Õ ‰NÛBL£"ö ‰Ûã(û,2̱+òJÀ#Û – §£9ùˆC9Ì@¯û¦†c*{q² Gs´Ø éĆàªz³A¹Ã¾ØÁD,¹Ü‰»H4”H|;30“–"T?Ð \ùpW`<¹,[É[š¨˜±æj+Ì4+ò#¨1òѱ6ò ,²‡àô=¶kÈ ä¨â9ÔH8¬ äÛ5Íòˆiü¦;±¬×'[Ùù¨l”¾D'ÛY6IÄ¢ï3ÇÈ€Ç ‘Dók'¼ ÿ8¿´úµxTAÁ¸¸À(ÂÿšÂ,ªÅ¿i®œÅLÛ´ˆ²˜›YÈ4ꊔ*Þ“2´«±àŸ•šÀ˱«‰1FÅÑH9Ì–‘A>£Ñ2AÒÃ;ŒÆ²û)–\É•4$À ŒºŠŒöè%õ+BDô’«AlIlLv"€·ÛA?´P¿ô‹ Å€ È“¨¿êsÙFkiˆ`ü ÁÿHÊ Áÿlµ±{"Ø|MÀ1˜.Õ1´d±2̪C°œ™òš=#ѱ ³Ø6UF&Ù&ãÉ9½2ãªSi”Fçƒ%§_£8G£ «Î)̸ã‰"MÌ@Çv‰vR—™)pÃ?ü{lÔN<ñ r…»ÚEÓs7¿p½t+-Ô%/Œ"»âÒ_ô=1Q®èÒ1ùE3•®a$œZ 3 3`Ó Õ¹lÆÊº² º;1I`­é, z4Ö†ÈØXõ»Ñ 1GJ˜&VluŒÏG ! <™â8ûkˆ¦tˆèkInò¾à˜ ÎO7Kÿs±(š¢P LsºSÝ_ÜM°ÆŒª«â=Œ"°HË ˜¿0›˜4]SÑ«~@„ ØÕnúˆp€IJÝE¸½†-Î"VØÐ B²ØÎª8_£8r2€>i2*¬ jïC%B¨Ä43FGÇèX÷ €f-J› 6‰Ã ŠÂ‡ˆÒ¸Â´X¼ÊP Så½|mÕ¦åÍ­ðŠ)T&©…Ð)ت€ªØïº… ¸€Ú0„H{“¨…—m[Î’ÜëÄSº=—|DQWx–©w!G”ÖÀm^ï³Aº©s;<õW(6uóSEYv øch H>Ž}LÇÀ™µ‹@)ÚO*k´¥!Wnj¸€,ÿî½Âì´ÝܪœÊ!. sóRºÑÕáŸ+Ý2mÚ0X*öß*àZ5@ ˆ˜‡([2^ã0þ6^cd@t®¡|à<[8¾]˜åeí½Qç}zhƒ>"=viÏ@ÆDߢG´BH‡P;;yd…§»}ذ2— x\”=Kd©l±ær½¨´H"þÅ2ÌW âs:âdZ}•Z}}Q”Ý  bÙmݪ嘂F`‡À冰åØe†VR öˆ‡Ö¨>Qн]‰‹ÈðS>†Þ†Ðãe¢c6¹HÜ y¯Â¢çbÖÞë jÊGÞà>œÔ ºÏ¥qÂÿd– ö}M‡p7-,Ú…„¦Ì9Ú‡X*äÍYÝa2½"ª•]W8Xª¦ê€þ.ÖÐêüe‡v€Hèxà… µudèêæà6þàU‹„¡Be‹’n!¢'(i°ÞïdG lÔ†° (ÝÅýT»ü§ý _²Mµ½Iæ¸Í@)Í܇Xçw£WÓ•.€SU$ãMÒK©Û]&V]~¶jª–â àne¿ã0㇉0F`øê†&kËÈ‹¦[ÿ2ÁŸ‚YéËæ!jºnƒºNæÀk!jƒw²QDlÔEè YYÛ‰ ±Í ”LS¤ôJƒwëÏò°ê!VCV„™#Kµ°|ºŒ²Wµ±)T)}Ý ª­ZWàç)æoÓnÝ 8`c®æåýj¶5¤´f[ÆA„íá¥X ÎGBâÄo{T–ö'p‚p‚(p'¢Ð¾‘kˆy@B[¼«!! 'l ˆF9Ò¥ü¦!(6óIKt=o]B½òV7QýÇÛR#öÅÚ!4”ÇÍge#6š_ )6íTæï)6XW¶Z !ù ÿ,éÿñHp Á‚*Dˆ¯!¾HœHñGªŠ/ZÌÈ_*7ŠÔˆãÆ!ZÀ·ßÊ—.]ÂtH³æÀ†7ÜYÓaË @70ðÔAH=UŠôèÒ¤KÚb0Õ“Õ«ž6dݪõ*ƒ¯:ŒˆÇ/^¼g ØSËv­[{*b¨°Gwm…üê2²ƒÞ¼{?T¨¯?D##®°oßBƒJ^Xëa­Š3o¼òòeË)| ‘³h‰/^Ö\ùǨÐ(]¶´ðò冕³ñ éi“aM\=wãÃ%ügP«`£BmÊ´ƒ §ÌÃ-j ëU­]±{j4숱hÕÆÿ{[`îZóuí}(`x¿ï‰ùåûðÁ£‚'FtãëÿÐXdbàN&A½†g%]6hqDš„£QDRIIxÒ-AdÁO#–HâO µÔÓM¿ çbCÀŨM(ÕUwÊåØÜsÏ1¥ÔTÕ eUv\m…Üv_àAYìÙ3^<*Œç–Zo©ÇÏ`üñwÖÿ!‚?ô}p˜– ô·g–‰È€Uö o½¸àN­½öE¯©6k9ÈáŸa¤gz’ƈAÁ šh"K3ò†Ó@¸°Hp¼aZK@!gTs :'j£B×-Et`ÝEj‡œwcÅÿs—xt•§Ö\·²w嘎P&+”Ÿaúõºå¯Ç~7`NtT ‚Iö¬Cn¦bçi‚âÉá ?pi\v "‡þ9î?, îým©î‹Æk㈮آŒ˜âûbO6j•\tÌ… pSÔ ¹*‘Fz*Ö’f=éä[PÀù{ì i¶Ÿ—Š%`» ø›;휣TféMQÈÑjÁLÑ HP€„!8W`–†x .¸\¶ÒЏ&•Ônÿø!W&Æ·©¨¢på»p”¾˜õŒ2×évÒ%°R=’]ªRaivlcVÓfUððxK¼–Z`ò£·—\¢ÿ‰¦™‰Þq—Û+›*K6Y´ 6ôQH×V$!EHÐ nˆ`NØ`… ¦sæß4Ðæn ß®z»W–ß‘5‚PT½’ZŠé¾.Þ®»ÔÇ-€$Í…%°ðÐAVU­ŠÕç,@F(dŒ¶ðe™5wzuáͱ±_¥ù•°‡˜7Œï+ùð‘\ò› E íBo†6¹k¢Í/Qå•ß`çaΧ^>ó‘Oô±?} âg\â»4öÁ`.¸jâÑ !v‹¢Zoªv5¶ˆ7ý:Rw|ä#S*xi£ÊòXµ Èýˆa «0ˆ%Vr£[­f0‰I|I»A°ÿ@ÖŒ@#ŸnÀ:#ni7`ÓM笂e¾±ÔCüÔÉ•K70İæã¿Ò¥>ô™ØZ(¶7Ä|,Iî‘[\ì×Ä.*@ ò¸|o@‚i¢ÅKÁ(w$NŠRtœß¡°„#¡t÷•n`Õ¡&5Ù 0Ì,M¢[(F¬Á-ñW+èO* ¾±KúALb³>œ”ìŠîÃ¥-›š;mq"[ÚÙ`®D13î….ô0£=òa—Šk=##ìHM¾Øgô˜fË œ ZÁ¨¦ÁÛw™’”¬â½â-Ç„¦2Ú¤Så¥`“è>i°ÿI-Äízv˘xÅ!â{íRš—ÚøDWnì‰ÚÇ.›•\Z‹5i͇P"‘-Q@˜j¤2í‘M¹ÐC'Åžyг̻‰ô0…é<þÂzÄà/Ùd„`ø£{`³J:Ì8/hHÞ ‘VÓ”OÖ‰$áðOÊTT¸¼{ÆðØ€?¶ºUjƒŸ1œGÃ* «ºM¬bPÌ—¼$2v¡²|Ó›~ŒèDÕñȈ¡å@—“¾Z‹ÌbYlBÓQ |T˜ù)\à2ô¥DéJí…=R*€^T0%Èã³òXBLçaz”4:EÄVÐÓŠ1@ù@„/8ÈsÿURèd$§üõ=± žQ•Žªê9$?ÈP\M.W©a‡z,j9D¦›‡CàL˜A!æ‰yЂ7PR@ˆ,ô*>ú Â@*è!X#XAbü0>èAuÐkœl)§‹êD!-óG[aØ0F³‚iËbOª ÐEoåIiJ¡àÒ†™µ1XÂ=<»„#,vìiÁˆy|@­ˆÀ ‘}¸'E˜­nTd[têKFˆÜWÁ<ß>¸%œdò®’É~ W¹H¦XËlR†Õ øà…'ÃP“^€À—ø"|âÉý°F0‹*ƒÙ!Iœ›¨È"ø±ÈÿMj™DüÑsJüÀK<ò1—;öÐ=öЮ*±xÈSx ´Ç îÁè#0ZᕇLgšLû¤Uœ+6àŠ‡zÁ–Ôöƒæü`MP´¿9ulbû1R-ÜábWÕjr©Ñj(71¼2˜e3ïz“TÈ öñëÊÀ×O¦hãØØ.N´&1,Î(€ˆž ¦”?XÇX ̃¥É¬[à m‚r¯ú,g9 äâ|س÷­¤OPÓz_ZÅ=g …@©5úú7#É€"ô8ÕßÑRX=•¢`%1D€r Cl$7`½j ‚Áñ`Ôà›¤>÷Ù;p\ÿ·êUÐñ*ó_%= ÀÑs¥Ê¯Ap ,@ž"ÿšh1P`ÁÐ̤p«ÄL‚¶X#¬LÛ¼w, àHÄé…{hTäsÈ(")J•ùw‚¡1«§]9ÉQA¾ÄÕ6]1įGr3†h”ÓDMóðКê æatð)Ÿ²g°÷ÀúEÀÌ8r¢ÒCÃsÑF ÜÓ¶‡ , ‚BIÁÜÌ;ͤ/=eZs|éQ7y–g”Ù‡ñ×=E€jQ1|&ÃvÊj·ÊA¸y;ì½”\³‡†6 ·6[1ÄÚ‘$WÒ$cXR{±hø0UlàaÕ¸Áݵh™^«ÜÌ ÅŽq2#ý>,s .Qªƒ¹„Ù †ÿ Ìc\ê6ZBYŽ”n:ͤ˵zôÀLä˜=f•gz†mxïÁ4`Dú "`p"¹GÚ˸Œiå¦(ûiÀ!­½Î^Sj#ÄÃ{ºjnn=èp+Ä*EâyVÁ=!Ð8eG爻涤º‹° Ý̽,¢ËÈf=ØÜ v‡‰TK{‰=S3åS8ŽhqkÁü€ÕX«K jAÙµ¢mu7—½LïáG+À yFå¼ ð½ÍN @¨m§Ò*jSi[“h}¨æ[ò´§e3áó4d™ç¼Gtq1SÞö$î‡Í\d34­¤³j»¸ËÊíÆzÿíN+ŒØ}E–1`<×s0˜ðÝ…-ŸEiÉÄ’AçYtêÖhìÆ²'Zu“¶óm7f„{س٬ÃLmP¬V  E›²ó¬RIÃÔwº™æžºº4ã/!4‚ݯ„y˜GÐÀ<™­YS$eFø-àŒàXráãµ v߯`xfß;S&  ±^Ç-àåØvbd²46HJµÎUÃÚ²c`}jNá=l¸T¡wX‘캽î11õ†”5oYbÆoæÿ¼³¼Áµj»̵ܺ7/¯¬IbQA/X¤A`”®(v{O\ØÏ|Ì'`SÙãRzCrµ+[öLâïøMõø åõ®7cÂÈän¢U¼XjZÁ—L‰EÚL ½#¡ƒ¼žñä=/ì¾­Ä~áÛ‘áølb¡7gôì-ÿnê&ˆØÑ÷ÐÉ1DóñÙó:ߺÜÞÜP\Åíã©;A¥jôƒyÈaô%Ðî@µïo,SÇ[©¬Ïúé…Ù&°mSaUDû½ßrÕä(eÌK ° &±üIŽ´¾Ù¤ie—Ú¿ÁàÄÚ ¼ó5FÑcÞëñσšx0˜¬&ÂÿmŽëöýïöYèpU#×ã÷] ù]Ûí;¿í°æ¯OA?)Õý!ÑÖ°é’.aæ!@ ‡AîÉ»·ä„¼K4Ì›§!=ö ðÛ¸‘¢#n¬`0B„¼Fxa‚_¼—ùâ Y ßF&MòÓgÓ= O´ˆ¸¤…†Kšz‚ž={ùôñD´b ðmÀ×Õëׯ¸Â~åºÁ¬Y¬EÙåÛ·&âz0ÑA®\ôv`àÉoß ž ñKØVÉx~Úc4ïÄÃ%KäI¦¼ð^ÃË÷žôëÌßg 8à À€ÔP Pmúté„k8{þ<Êöÿ(|·sï®e»«…?ZQhÕêÆ?ܨð¡„<‚s$\("ÄÇk_ Õ{>~á?Žà'Qù˜4Úƒ#ÆQÃç˜ï'=¡“F>Á´‰Q¦4xÊžôÁªÌòJ|ô ¿Š±ÄÚj«³ËY+“KÕòRCíjÕ•`Ù-—_Æë.êz+×ÃxUq°]] oŠëñY¢uÌ,íp¥%²Z…z²Ÿ´Á¦â¦o¥Å2·Þ´Æ²Ëá†øò†"X`ì²Ñ!‚z0‹ƒ  ]®dB†Î²¡W½ %´’Y^f–¾¦/¼òUÎ4DÿûÄ(@Cšžõ¬´‰iÓÍ=\“n)`H3 ¸¥<-m)‡£NÔ¦V(gl$”GA¦ƒ6±Næ‹Áv&ò&(º Nô`âS¨X¬ª}P¡IŸBè½ Å:M€”þÌ(¸À‰q?ü àǤ• ‘*s]aKʹ*V¡»Õ‡Fä¡\­Eu½êà_<À‘Í£1™ØNøÈh ‰Z0p¤f8Sƒfr7´’Öœ‡›Zx28^ûRÌrƒ ”àF 9"jº´ e§‰5Š"²ä4ë„Nàßž¢žÈñÉ&êãý1ÂÍ/!Àâ<’ò?¨äÃcœJP©ˆ²Ìÿ]Ždq YZÅ¡•´Å3«Õ]@§[hh8 LÈÓ3Ùhh½+H=!¹ÂÝé i÷`g¶1$j’ ­æIß 7À 1„ã¸KÙcHAŒ €} fY·tˆ.õ•(â²hÏŠ”;ú_Æè&ü KíÃ'¨0³~ÿ+VòaS>Ýô>ø)X Ð1NQÂqÂ(®)–8’ UòÜZ@^Ì…t„Y 7¸Î•y¢ˆdL<ë·£}ÚóžV˧¢µP#EÀz°Â-…R7ÎëÊ(ð5CPÀ”×;“uˆvÄ‹ÖË:'=éD }è¦ñ)˜wBË.Y³r&KjÉðØÔ ÅJVä„™\ÎÙuÞŒE„AbÖW#ÀòvŽL[fvɦq†è'¦Ö;(Í[­¶¼­í^z¨!ŽDL`mN`»7%ž o¢ˆEâÔÄÇ0iÆ­df&sßÈä«`|2N,›z0‹ôà¯g?»‚Ï""´£µ‡ô4•d%sRCÕZ sN0± çlaV[[™n/¹%¤Šx #{$|A»‡ ‰K’•ZÏ匂ÑêfÒºÊËÚ¹êúƒÜuz`Nö–µ½‹^4ÕÿQâzßT 0â"æsL »¬"!>ºoÿ4–¨q¬c ŽO™?ÚÏŠ`+P‚Óì˜Få¥ÒLDáÕ®Vx Ì79$[…8Ä!Â`:9¨ÛÀ¸Îg¼Tbp#Ãb,׎hA“>güܶҰn…«ÖB™5|Ô8wÍëqø:^‚ ¼«Q›z]}XXãFŽyìÑ6JßãHqSÄbÜr*ÚáÍj^Á+VଠÊþ,o ¦ŠŽ§ªÜ5©ÝÍαe|”jm©*b½¨E4±'zKåÇ” |š²Ðä,g5d2ŽÀçzpo|ß»=ÒGÖ[iK åšÿ—¾fê ”í^÷˜NF3zÞ“ª7*¸ÈœæÅŽ×28Âò‹í›ˆe³ËŒQ|0ûkÏ®ù”X9²°lˆ€úð€>L»OI›dªÍså@¥2غ¥ÃôÌL´NµsŠQÁÏ`9XáÚŽhl»/ð™IМ34 §ªPz…‡^šÞ6Þy,!«Nˆub¹K~]Ü;Rvú•‘6ueÉ÷‘Û5匧œF!§RñÎWN ÄSÂåÉ.BšYú}Ü+×lí´-OT>{⛈ ѽ]ºŸó/,÷lÑx0¾Á]%XÁº¬+W"•&+Ö?ÓmT 9þLÀkÿc®ìn×8ërú íaTÕçu[Eàtñ 0&F³Œï}«³qËœP×sX€ϧô9;´)÷â/aK\BñåG6Šð~`™ùX)Ueù ÷<ÏœKІܹ’¡ë¶¢+Aº^É£ðøê{:1¡ù²ŽsJ»:Ûëà=Ѐ!ù7iá®ÀšP";°¹´»íQP²S"â¢Øy ‹;¬íX·Áš/[㸅“7djù‘³¿Ð*¼cC˜‡ct»dl–XЍø«³F”LIº’«ޝAê¹ø˜´A}P²C ®%2Y›‘ºÊ :ÇÒ;J\ÇjŠLL T°{ÄÇò£„#E;ãÇ"4ÅõC¶"€‘|`€°3ž;ÍÑ;ZÁØ,ä6‰\Ë©*CûÂ땵 æøxñHÖ›Œ©k5~<{ȆnHI.È" n©àà1ÈI8É~ÀFæÙ.0ñ®n¤€3½³A‹:Dˆ`ÁyP‹3ð‰Ç…ã8Ü8Ì%‡a¦ôaJDP034[³!4?;ËM#ÜÍݼJL6–ò,ÿ„4 ›£…L™†Ô<§Z w":A“½p•AŠË¿É怗ŽT¥à‚î,8ñ—ªG©Ñr° ­ót>pˆ‚XOÑŠO^à™Û‡}5àÛ î¢€R+²»K¾‡+34)õ¢¢«‘{y·.Ã>-£ºüùžûòôÄ4K³e;6œ£„ó›JÝìGßT?­>Áà¹Y\ [4™×ú]§Ï#Òqtº*Dû¹T »„€Æ`½íÜ‘e|Œ9ù–*ÒñÔ‡x€3ˆ}HOóŒÏ&5OólRõ4Ïò9ÀOü@tiCÈ+nìÆ 8[Û5ÉÏ\FôÊŽÿØA4@ÙKÙ“½íÁðë˜#6Û´ÍTD²ÑNš5½¸z,RÑbÒ&MÒ&å‡)MÏ|XR)}Up,å…ÆÃÏû¢DðUBç(.q4% `²ô ©ô‚@©ÃÁÕ¼Ö¤ˆ£Ç ,<=µÍ6KŨäP#üÐÞìGôK?È"x©"à Y4£Ò¦ãì¦ k-±ñź` Ú­/Ì£’à‡°ËxQ¥ðH*Ø8ù×|¨€Ëê‰Ð²‰ñsZ…XóLR)5HÿpÕ[m<ÕR„Ò. +µ_ezšËàÌB¤ŽZVuS7Ru»yS]+Êëh Í"¹;Í<ÝS«P…àYnõÓ‚W(BA×PTd㇧@„º3£¢B±4™=ö :4­ªº°™é¤Î’¨PÍÎXžäIŠˆ&…Š©à&Ø‹MOWER'¥Ø™³OûL3\}?] »„5ÿôÏØ4¾-K5å[>…p»e=íÑÜ‘Çâ¨ÇR"¤Öy Çô©4‹ÍÂ5k³m}…NéVõÅPÅH£½OH?ø‰®\T”1*S™‘Ù?xý¦Ð¹Z^ìE©éœNÿŒ”IeŒ»Xàb½ïDXžòŒ[VµUà…èuRW…^óü¬»ÅUØØ}LáóO21„Øü2­Žä;E\}¡ˆ ›í\Çí2ÉP"|yÁjEØ 4ªP³lÍÇmíYdK<©D]4Ýq5]%ô„"Àˆ0UY×â„TH}-µ˜Ë¼§Ñ±ÔK-[ 7¥Nœé×°õÈ€Q}ˆäMØøˆµå &5&5[½[è•^ˆ^ÏŠ^ìÝÞ¼--Ýß²/_ñõך4_U3IJu‹Eb_ÅRÃ.{:–g¢ÖeZ¦33ÏÒÜý¥ÝÓž-¶ŸõSÔ*€äÐÿÔT=׊@O°FÅ3í¹×ÊÅ>ú°¢ã`ª*´ß½HaëÄxaöÈϼ¥³ýÌÍŽq)$dòä‹­UWE„éÅRèÝa,ÍÒüôO«+ÿüRC[ÅÐ5†3\Ï\Ã'–²Æp_)FåUBáí€MüWØì˜ªØ\^^³þcŸÕGU]F?c`4N¿€ô¥‡|PÔ„<©œQi I­Úyåã¶üÅ ÂHNÕ*ò°ã3±ÝÎÙ¥ Ø<µý©Ÿâ“‹UYÕžáM¶Û[_à…½¾±eñ­CàFÀ¢95ñL³U¤‹P¤E:F5´¶Aaÿ¸Óbz”€uþ,0¶Íã=ÝVÝnª$4?ôSceÆÊÕ±‡‘6)Dªâœ]SÙ€ËY*´D yõ#^ä`Ò¡Q|ýc0$$vECØí¼õš‡ð[çó¸¬åMRðXRš»ç“˜aMÎê»õdìò »"å/%Æ´[859ˆ©»¥]zåÄ:ÆðÉK¶i´É­\„=3 èâø’5ëhÖÖžíëaV£ëZ^)‰ìÄK5…ˆÊý—mä§–Šx`ÛHŽ&e Ží"m»ÕÞßÛìRF„ €æ Ó{1¢ŒÚIž„;'†â²!"3\C8Xï;³kîh0–îéæSÐñ‘În€Lc¬\D 3uuìh¦‘1Nœî³Êþ0¶¬×z½ÚùÖו aæ ^Š(èN „­›©ˆÍåœwŽä&m¬–¹Æó‡¿1çX–ìRÿ°nÅxˆ+"îY€è6Ý(ñh=g×Dçö_½kÛÜå5« @ÿèÎ-ôd#ãÏî$<àôãPÐß1NÕbTË“l vQ—ÑÝ©òéx˜QÄ­îT¹, €¨Éd\n MX§vdþ²‰áfpÅUû$s2×Õ£Ì4ïíµ!Óä;\ªUÃ*v…ƒPV~Á  G.ÆY?ö»î_§îcÓÇ«ˆ€WðNÉvd®ñÃæÐ X3„üqG#¢bQ‚­W±Ú"ß`Lm‹ F:Q·oã ®É}>\–&}ãufÞƒX¼õZÇuóíõáîÝO|Èí4—‚Æ%ÿè Ddý‘z:ëôñ–5A·ãoje„­k_Åkhïè]tn3ëVžÍölí6Ú“HÄ+¿T±0°Ë›Ö?•AK§:”ˆ‡xNø6º¼(ÀP‡Ë0Œ€m yéø8ù„•¦]ÖØð·uÕìMø÷ËÛ„ïá÷ {½­mýÌàk o{x%ºI$j.±j“%*ö¶†¥…Žin]ös½®ú?ñi˜ïE'àÔE¼TÉMÌ)wü[-k> Ïù¦¡³l#w÷A;úHKpÂ8Dîø)ïËôáb0‰Œ-žØúÏ {Æu®{±ïg-±€áøÒ 7åci4·§xÿô]eÐT$7i´¶fSFÔûؤÏëg7ù=Eym]³dky˜Ïnc&`ÞpWür_×±”ôͺ\\‰x r¢/ñ.DzÒóÚa\¤(n}GØunñ_]ç© ÍsØßþˆ"÷í…Ïà(ƒ?(jXáa…|ŒNPdq4jÄxïž¼çŘgrÞÈ(Uª4É(£2%èC„ˆÂ œ8W𤠢'OD+„ò,jTÕ I}, ä”’¨O-\rzéU¬W¯>Ý ä«|aqá+K֠زjêU»߆¸xb`w„ñðÆó`Âïß¼&þì7ÿÔõäiƒcÈ;f0‚Ÿ½y,N„”Çbó<{2+Ô$JÁgΡ"V»Áku^ED¬mû6î"ñÕ:è{¡C ?ðcZÞYŽ‘7·ŒÁò$Ë%FÎ{Sfi¡;uþjô<ú¢J_-ðñJjÔ§”ªÊçZ•>}J^Ã~%+d[ü•5V[†õ–\sÙÅ€xé•—`€V…yuàÁb¶0ÙcNV×e™ðÙt*…ðA>Ø”Óx­¤&"üÔ´m³áæƒm8æ6PA¾õ†OHàDL„’EÊ °ÏFI×YE&ÅÀIUR¤ÝˆWÎCωдâxF‰°ÿ“Pe¦Ç“*î-ðŠi¶çTTñÉgÕœóÑéÔ~d¥5à€h­Õ–že!(×tÙá^&Œ@Øa‚öW_.ÖÁ†”IÖ!euu€’œ±à™I2åcÈM;µâ¢‹CÙ¤®ÙX£Ž9ªRĬ·Ñ¶BYЊ!CB„Hö9âE9—tÉó$wS–dREÔm¶K(J€È˜6ÝÔ¶aETQ ð$î ª°¹&%MÅ gsúß»ª0Ô[âB` ø–[pÅõØvu€—ƒ=:¡„ƒEjaV:Ę lO žuRh2‘jª ¸ˆ“5ÉHãl5ÞØæ»Õh2A¹&ôÿC+ Ñp%çÛ‘²!±°ÄH1Ä ìJ$ŽèÙf,œÔ¥>ᕉ¸cufQæ.µ¦šlF°nSl>õ.Ø(·TM |µçžòYàŸþZס "fp£",)”j˜é¥VfY1,qñgóL€bM§á„j+ä®:2?¯‘\Ä 9c›¹ÝºÏAbÌ3?ÄOX‡d±Íq”,H i°%•&mv±ÏK|ÚR¨èCª>Ü4¦Ô©}kÕ+¼R.›ÆcÍÞ{ç¾Â¼ñÑ+…TÈú„p="õöiÛk·Å/\þ.  e#aaè+¬×_RJé†wø!c 8í¹«ÿfN§rc>òÁÙ„6?1Ùm0'ZÙ¦e+ËB„D*š‰¨"òPGšDhi¨g<’{|Šp-é’!šV@› fåiañ΃ž°ÇMÏ[SôhX®¤ìÐ…MËGè1‚iùÚô¤6´}Ïmsƒå ôfBA¤¿LÍS•f8#Ï@ÀK»+Uj>æ; ÈE >øÑ*1p¸©xS–Ïif×¢`I¬³„äk9@HZÂ+­„´ëÌ[“Q…Ç'–”Z Åã g†Ç;Ó W£ Ò£”\ÊÇøØÒu¯•‚’ À&·¼DŠÿQ³b<Ã08ÌR’XÞ¸,Ÿ &CÒÇÆD5"‚!0 =A{„Àö ŒXÒJsºá\®,° "˜a„u®ô0©#GxRH÷³Ùn˜>óÌ ?BmuKjþ^QÀµÉV'¬bZ@\¯&F\ü´Äî!ȉ ˜ù „—ƒ9*aÂòF)¾y‘‹õ=N`;ŸÍ£Œ4ñ]ÌV3ßâ(Ù#)Â¥¼Ñ¬j 7Uö*¡Å » ÝCìQ:Š‘„3Äà!¹A{†0iV•'í>Ó3ò³«/ÚÉOvBµòœg5uaÈr±Ð0ôzùÿ@D*'êʹ†Pä‹¢¢dK„U(—xë%ûöÅ»dfp™‡—HuTåú°©f.éè”§lPa#TÒh7üÁÑ`•ÎHÂzE–ÕC à¸XNAH¢ŸðvJ¢L«-KRà–,ŠN¨†-l°U4ráy~!¦¦Yo­CŒÂeW°¶©’®MPÀå ¾X±»|Õ¥íBÒK™ô.÷[ÂHh¢kF¦»A3?Í|ê#ÏÙ`ÏJ'Ч­yÊXãšÖäG ¹Ì(ø¦¦ó‚Ë1Â!1r(ŧI[鄉y®òsL‰ð+¦á:–¹Ì ÿŠS¼š_˜¹ÕûÀZÙzJËJ÷lÝ«®uäDOd—A Zß^–¾…¹—•âP)#0”ªÔv*ñ’PZƵ¢™@ $£³Áû‚dp ¦ 設ùï™õ+µDP´†àG…E±|PµÉ„0UyÄ%+ÙŽ# šî€‡Ÿª’Z™ÈšIçã'ºÞ¢0Ê|XÏĬÒÇ/¡Üâþ0¡l-—B}½{¢Öm› ÜV¨ìÊͯÜ}`b¾À„·1¿ôÛßîü)-&,ôŸïä;”`:’ýHÏäÑ ˜rÌùpÁ³E27m5Ïö,Z~€à†ˆN© ¦‡ÍTÿŠÁ%iž×‰U=õ©¤™„§ûì*q“yIÔøÎ±Ž¾Þ–º%…æ[¿× A.,Ýâ‘rØÃfëÁCSãðèÔM´è]!ľ y—B~ÝeldòV†R—QJ[òR™ún˜@Jphn©åQ¤²¯Äl{8! bÎÇ´}ŠÙx@;kÆhO33Ñ-•hWRírÚé'‰„#úÌ<<葦ÃÝÒ‡ /ù;æâ{¡'hÁ#•­ì¼€­m ‰[Õ´8aØ#DvgZ ¦ •ûzxªëCi—–z•¬ “K]b(olyÅAn&&*Z&"†àÌ @ ˆ\¢¦hLIÿF*òË¥´¦®yYžÒ¿>ïZb&Zá¼y8Öü E–µæké=«êº¡®{•¼$·ð¦«V£UIàzó=8Ø•ìåOÖìÃxÚͲ ‚½ ÷àöïÑé }|­Äq¿¨ûJì.ÈïƒáǬ…lqðf(~˜â8±˜Ò‘Ó&ª'§L`RMGc>ˆWêü× ³ͽQA[™ÐÏÁ  p|€Š•’ðÌsp~) VYLÒdÉ–´QiÀŒŸc…̪Xñ!ŸØ‰Ùµàö¹àNQZÓlš Ñ×md@º ¬€áŽEõ ¡ôØ,åÒ«ž„ á½ÿÆù’IiÊÀ`ÈŠÊJ@ñß‚}›­•<4âÊ-”™ÝØ% >_DAÀi“6åƒ×-Kö)ÛæÃ ø€”Zu á÷!Äaƒ¼š%ÌúáÍA!®AQÞŒ@xŸYKMüÐå5•R硲-̵@àN“eż/œ^®Ä!ëñÃÌ,ØiÝSí¡¨8šØ-ß#Íuà¥i‹bË/ê×9âNýÛõ˜Ò°Åز"Ø)ÿÔõ@¥­ØPxâ¾Ý#>¥EE©5øñ‹*!¡”_øEZQ ¡Ä9¡-æ¥x?”’N‰Æ/ÒÄ6šå çÅg ã"#2ê=„Ù³•™l”ŒšSYÄLC‡pÔ!Œ¥ÓÑ]ßžÈ/:šÛÁ<=݈¸PêV™Ø:šØ¿‰$‰$1vò}Dö%[å#¥µFQˆ€'NÓ;BZèŽÌÇ)2ÑåÝÝ©%vE\^ Ÿ <¤ú ^£„בÉOyyflžIØ•˜Ê„hØ=¨ÀæÑÙ°]‰1†„†áØ1› X– ˜m¸ÀšÁ ·õÊC4Ú`Æìƒ]ÿ„òT§=SV‰ŸMîkŽ s9“Z–£™¹ (æàõ±ÕØe¢ jSRLO…€˜]S¤¡Hk4…WaAVé"ø ʱZÁÄ¥v®†è c0^fŠÀ\Hˆd %M胑5UJh^ì½ÝduFtž~‘Ùd.PÊð‚•…Ðá¤>@Ä`2쥖}MÕ ÐŠÜ=ŒcjŽ„^Kâð©S2¥å¾œJtHöuh(*—@WµýDòLÚ½ÑXŠ(mà‰ÝÁø5ÑsŽŸ\,ˆé¬UÜIJûÙ¢wvÜ…Ä?„@"V>”gH.X&³)ÿæà` —ÝCc®$˜m¥ D/ÄË7ýCHN’FÑ&EÐX%* CíÔ$ò™šfÉV­&q WÖùVð1¢y6šHšD1&ßöq¨`_\ßG´ [ØO@Zœ5¡ˆeåm¤‰~dZ2\s®¥ÞÍE¡ôÝ¢<ˆ_A¤àÅ%u¶YIM†v Ð^ªÄ4]aræHf ¬äqYܱU–@}öBš\©x>€·‘Ó™~h.õq( òY Ñ0Îà š$ƒ&%ŒôV„ßjñ­]£AKØbŸþé=“Œñæ‰ %PÁEÁNEôµØè‡ŽIjíÿ’ °E‚<Æ‚€§§â¨ÝÄe< ^Øå"é?@Â~né0 #G~Ýà ªI@Òk)[b~5ebküBmðª*øê8É!9õçcYÓ66Yza ˜)C5,IV,E”@³B€GÖÄ `PôÎj¨ãP¼¦HÚÔÅD|Z¥ö}™§…åe]ÚO¨‚¡úP>¸k8A&–™¨Bš˜b‹æÊ•ÛÀEÜUFQç¦þ«§lެûáÚ’@z¦§)!N35Z¤ ãæéi5Á´^ÄŸzÆ$ö—ð×ZiÖöÂ%XMRÀÜ$Ρ6ÚÈi€˜¦×E”)ƾcÁ5+ž.£] „²ÿ˜µêlΊÀ"Ž’Lp ž²à¬ÒCÆ î'<2¶¨ÇØÈ¤À5j¼ž%Þ¹ø¾ækv'„Üè\"!Ú2 ü0]ød”_˜RÍÕú£ ¦åÝà 'ŒqÆsÜCK¬•æ`™y¬*ô‚ᶉgíJ°z‰zi> ,=Àz‘éT5kµ›hÀD)EbçÎiÎúÖ™«”îÚå‚¶Ô3á) ÑN‰FHcoWyDEQN«Ö Ažsª¥hϾ|ðÞõ˜ù`¤˜í¿ÆCÆDò½°0ˆÛj@ 8AÍEAæ 2—Å#G~ŠP´Ó @Àjž~]ÿS™Y©\B.ç”E,®°6néÀÙ`ª€g6™}}¨~m ¤uálQï©ÐO쬄欕˜éBpý›ÿÛNÝ[qºÑc™ØìÒ.š”‹{ Tx SøÀ«’r¢ï¦Z¾’ÁèE_pWà)ÌÙzªƒ,†x)ïÆÙEÂÒC(” O­~õ¦‘¾/göŸ(±ŸÉ£ç%±pZí•î%.®¨/É’“Œl¦6¦äª”U*+Æ6+Âé—`Ú”þ`™èl:Ðpý¢‰!NH£_=Œe5Yšìˆˆ• Öf³œ<Åó| %X€€$dÛ´è ÀÅøÐhFìÄ¡°à­p£„Ô=Œ/ÿŠ’¶dÍÙ0÷fÓðÉæp¿/O]ÓÆÑ3±*S™Õˆ*8ñV8pT± GÑ!ÃjñäVnˆDò™©@Òí£1MölΖ Öñ,q]…t(ºë'Ÿ£2›è¢jcœa"1ús‰€ÇºrCG1Ì+þA`Šðó‚‹aª@]/‹¡õªýÂQµÑ9—š`Ig2ӈΥt¤ùð¿Ù±ì2W2ýYñññd3%¼G}؉„í¼6ÑN»(B^6tÊÁfÿª«±óà©paLr-¾°’1€ Ûƒ˜E´åBè}ž ÊH6]‡^Þ¢§k4ç]Ó6êV\…g=tã¶‘9(äZÈQ®å¾]F×µ¶Ð­µ|Éð¥£2K°PJ[šÂcm¢qñÄŒ´XWVM›¤ Ö¾Ç%@¶S¼Ç»L½înÛù”°ñú+$_§ŽöÒ]*Y`͹€ôö\’b“ Å‚Ïö‰Š^¢öAô?óW´®7ÿjki= û@°$·[¯lËBiŠcV²Š 9VDèN7%_‡ŒO—6Ñ'Š€O-mµ¡Gõ 8Y•Çj EMc­{°Ió<ö+ ÿ…)·øÕ]svuöñÂbÅ 5 gç‚dÊòz'j»íÍA¿í[!xŒXšŒœ(³jGeIx.¬¡®>ñXÿêÈa< Bà €£¬0wý2ßnŠ.ñùb‰©#;š øDv£‡wYýDI‡ Z¹˜ôQ6gsz›‹¦g³¢¢Zr-×⫪ÕwC¢ßàÉb¿†v#Ó¢x‘TÇé‗Ùz¢5Á‰€l#8‚›y18gòúšãjkP¸…_8fÒ¹L@i‘g¸ ¨6ÈÁu ºg|ÚoðåŒÐ-¥}ISºnI_£/¶A A¦T ùxyÐÊýx¹Ð Ö²ÿ{R€3¤>\½$$t5Cúw1¡,æÒ §<—¶iç¢ÛRi§!tlÏ?8V6•˜»ÄŸèà ¹…{¯Ðùß9‡ª¶=ôùõq€Fo_Ïd¥Ì´cÑxTõ/òõŒKð¤ÏôL§Ç ‰÷¤£8¥»ˆe³cšq©B£ªBSpðÃä½Vj,åÍaQ¡z§¬ °pûm'^¼³ù×(…žÇ‘ÃCc‰eS®ï:¥M¼J_– üB…_<ç`&9]@—Îf~¸R)·5€ ¨Öˆß£ö5f%£_‰Gyvûu﵊9úÌ#Wz+OÐ ¦QzxÿøÕ¾Ë ¸À&þ¶Ç‚ÿµ¥ÇE8O*BÚ»…-N¤xTÔÇeÀ%›¶’ LˆÙên_“Øÿâxýàl›hÙû~ÙÏþ·{Æ_€—ȽÜËÄ4ä>;˜Jûß‹!”Þ#—ð8ŒD4#²ãuSsâÓüÀ•÷¹AišÀÍxq=Ö† ‹(P±˜½‹îîOs-}ïU~§ú©„:0èà‰'… Q ?]ä‹’Ï^>úøñÓ‡H""!GêÓÏ$J+óÐÇ’e}.ЍRué’œ—öíÃ÷£•¡ *T ú¡Òö˜V`JOS'îqàpï^‹-ä5iñÿl}"•5)!Ÿ“ˆ>²ukîXséŠø5w…ˆ¼z­ðks…ª¼yÁÍ%Wb¼{õΫ/Jˆ(NòQt—’|š7ãóŒoƒçТIƒ½õ ´1ƒ ±eÓ–}[v¼xLÄ›=ÛƒÁƒ *Ü€°ƒ~ñ$š,óe>“õ`Kv¦H¸(_Vlù2:LEØÜ¹³çO †$\ZôC|{ñ—f´§bžŠö¨à@ «­Àð«Öúè¬ßb+®¸ê²ëÁÁÓ«¿V¸«°¸Cl,Åê L•Â&£Ç '\šh¬PM³ÐF3í³;3 µjl-¹âÿ·Úpó­·Ü|‹m ‚Z#¡ãjM9”$O:¨i,DF˜ë:~J: ¼—žo#0/«é¦têɂֻ)£’¢/©ù˜ZJ{öÓ *®’¬%¾¢‡ž¯æ«-}ÔRÁ·©.ÄújL¯Æ$œKÃ"“NŸÇL¢‹1N‹Á…-ñ¢Š\È43Î^„‘FÒFs1µù–ºS~ Ð` Ы®ø_É5ÉCÝz+1ì01,9ÝëÿÑQ„L²BØ®µ8¥T1ÈZ”Äs‘ŽJ6âãÎ^­Å_M­FZð6}ìñGÙxë6#4VÉ•uÌV#Ê.ŠÒ%µä‡JD\ÐÎ莼ÛÈ¥mÄë2›^ 7½n`¯‚ Šz3¾¤ ¨©èHyüÓÓ*¬îñŠž†/2°PC×ZpßA뮂ñúp®Ë:„+²¶ môCí 6É'm¡ @K”nU…qdÏJ~õ´ °ñH[qÕõ¶]ô·Ú‚IcqÜ9:Ÿ3zšºh>š, ‰Ÿ|T’Î%ñàš‹Lœ(¾êV(8êÜ®ÓUw?êÜ*yõô¯ÿÞ‹C°G²ž®Í ¸Áßœ¸®»NÉ0¢Àøa¹:m4.é6¡¯þT\&-yF?[•r™Ó\ç‚+"½ fAÒn œa%I²:–ÎPò%{Lfc,‰–G¶¤%¡q$JÝaÚÒº$2Mí‘Ê<ìdöç"“0€±š•'nP«[ênLPº ÄfÁB¢ïü¬YàÉÇí8È‘é€PY–—¢c7ºüBjTÿ—š\˜<ø¨‹)_»¢bCyäé?i»Ç½§½í!Qf¹NxMÉEwù›Iò‘‹'þI_ O.,•K‰ª–ù Gˆ –ÆåC©a‘ŒÈ¿ÿ‰et@vô›òê6èU5kf$=«!·B [`ò³—äΆŒ\¢d*ôUfY$ÔÛX\®œà¤j7XϹ’µù0‚r²=8Éþ`EzÓkŸæ(ÉläP "‚˜hDñ…¯¢ñ ¦¨(jć!©Ãu‘úuÅ~$ÒÇ"°1¶ê™¡±@i\•²Y­ŽGqÌÌ€T:à*9!8¤×0ñK?Ó ÿ:ÓéÁÛ©Äñ°]t¼£ÈEÍžøÜGš~`¯EJñ' ¿VzÄ N÷¡Ê=ΖC‘R{QÐ^Zâ"0UÆÍ¢¯Ì«>6v‘(nq`q(Ié1?A_€jdÖW¿ú±ÍEX€\4Óɰr˜C™ÊÄ ,Ê17uœãðh³Ôy ©°ØÂ3‹øîv™Ý:‡>wrËw§rÁ/‚‡žqEàj•ì}äCÃuÝ*L[åE=é‰O‹ )†)‰l|Ý«†Ô'ÅⲇmÃØb ÛÃ6_?kl²ÒʬÀF¨™©L™iš’1VªIÈ Þh@kî4´s-i‹ÿd†|S!²:˪4Õ(Á$¶!1ä–Vr>¨:Í"Yä+EDPHú@U£ä{*0åÁ0 vZ Z“{Pæ:W^à€<æ1¨ò*jâ]ÿ¥×í1ƒYä(Ä^’†À°rïE^ÒØµYO«ñ˜EÆ*šRy³š£Ë<û_Ðâ&ª¾#ê¬:ƒðÃ: ÁƒWò¦2hh‡lJÎÂ/–DXÜX.(Â[¨pû,1#L¼Fü3ÆÝA ªz|’­ÎWsúI™wc›Â.ƒÈ V™¯| A>ö]Ž4¤øË py˜‰Ør‹Y!ÑàùÒs0­ÿPAÿœâŠ´ÀI Ø+˜8§-ªCDp%JÔK!6‚¸4'ÚêAG¢Œ9‹)‘ˆ×Sâ0‚H™€=ýÏi“óHëT°âŸ³ÍK"dœ êÝôG ¦Ý‰Å‰¤ý”L"^*2>4ï©£àê™ó+ŤG>$‘qE¬ªœhî +©ÌVÔ¤&èn3ºÑ.E0ÈÍ$è %ññV7¸Ò•\»’i7u,…¼–Àb ´(Øã°PtBã–î„ú©Ðjì™ÀÒ9-åÝ2¤Ç 4Vþ@zß Wò-=¼ mI%Y þi“ð2ÓµäeÄMÍë ÿN2,õ¥ î\ü½– Pø!Ù ´Ô™h9i.+_ߊˤ/¾LÇ™ÑñØF²…lAÔ#ݪÙÍî!Ü †D²mî–u'hÀ˜ôhÃź=ûT-ûüÕ«^ªÛc' Ç0rÖÈ[¹K¨÷¾ïï±s€ì÷8Au¾¯NW4£ÎÊ`ÃDE{ Ö “ë¨ÅßCéb‹à.‘Ó({ˆ Öñ Y®ÓXÿhª†V9ÖŽ¤ú_ž¾œŠ¤ â›n®¨ ¢ÙÁæ¢çV"v*£µ¦¥$¶<¨ƒw,P`¯£œ® ÖÏ zâ~ ÷¤ÝÒÍ) íb€ÆìÆÿºîy¾.ÒìMz$Íù O¦«®;À§ˆ‚ îˆ/Õ%ɴ¼BÊg2 ‹þм&C 'ýh±Ä¢|`sl„׳LÆäd…V^óª)6xÀz¥7¢j€ƒ Š`8ÊlÙfÎJDbÐçJHÂFb¶‚.i%þêÛ<°T&"=6Àx a÷J0]ÒMNN@ødˆ4 ? ê mùΆóMÆ0`± n$ªÓV@(;i7J¼ 0ºþ¤È"#2ÂDžÐéØïÁbýJjV`V6ÇŒèoUÌè £é¦p„eÀÿ\›¶ æJ‹•m‚:€,xÚº…¶&°WO¶X"üÿœà‚À-‹&‚Š  Ž=.€Ðæ¡÷àq4â)Ð** `*”¯*ªâ?˜ßœkßZäª{V©JÆb2$~SÈoȶB@„_çE…ý¤! „Tøð‹)Œ" r\Ê¥Jcd°ÌU2‡sº°eè7Ä0fæèò€¤´Ž‚ÀI%6:"w`âKzgâL;$BÚ):ž£À-LL¥‹ p§®Ûퟖ"iH†4 °:Ɇ֪*ÂNßðMOüíGmù‘í Žh):æNT†Ðîh/±KÉÒ²˜–Œ  ™@soE(K#­L³ )¿>6pEGˆdHb¦tÿ´i›‚""g‚X„cg˜ƒì#4âKb+`\àZBâhÒI‘\ w$³Â8¬ÃlÐHç!¬îÐjXàjè>äÍÑöƒ?àñÅ–ßÈnOpL:"ªnÜ.Ó2 Gì¥,Ór@š€ŠÉ+’“ÀâïþnDôþ|À"o#íO#MîûhÁ0ÀÄL0é8ÂÀŠEÙT’ `C7–£%ìá1kH2'±«©lÇçpk<ȃ.ÈÄЧ(Ñ­ÆÐ)êÐæANà4Íy¹–¯â?êmÒ®r”¬7•…¤Ã@2h~o¡Ô@*Ô~ˆ‰˜šE‘³ÿšSׯ"FD:àÏF(¡¥Èˆ.±ó.a%5"à÷ò cÃ;]ŽtoÆóðVt$;b?ÜåÊjƃ 3¥ÍT˜&ž¤ã2€§Ãj¢?·Š’$€êjŒåD@í!Б ‹“ÈÊyh“­êÅoߪmˆ–ú¥nD w‰øÇîøDm°Â8í'-sÁ žó¡sÔòA$ª0¾èò:wѾr15V£sÔH‰Äþof³6ðhæôèJ¹NÞ8霕6uHDëmrï‡æ°Aàf#dÖ@4">|¨¡äJ&¬ëTð7\÷—‹Öò\/N7Ø•iY #çK^a*òršú²šþHì$s£H‡ê›”±ólÁŽ…·tã9“UgòÍðJ²åp,°h¯qf¯ YözÂWÇ4@Ù ’µ×X4‡ÓÔ — ëÞÔAŸuPG”ˆ `8)w> ê+Á£‰-×rÉÔ<ªQùêrù*$Cû·Eùli2BiøuëUצö4jªFôku~ŠØd£SC«W X<ÑÐH)¸‚=ÁŽ£Ù ÿ€ÅI=Ó—&³© ç+­ñ»”ó±²øéôöxØ@‰?€Xe8øŽÕ tX”ëè¡qÍWm„Ø“…x8 •á"~M¹‘€Ð—¦K¤¦Ø¢¤£âÈu–Ï5t/#œÍüRÇva÷—ï W§Q’ [NfzC0wW›ù™‹£Žƒ7ÍöøáI#ÓͦCVs"“ï°ø›‘ÓD‰‰‘‡÷È‘@TlÄfXY@–€†žÂyN  t Pq9yˆ…8NßJ+†Of}I'1E{>€—€ð—B ‰³U#byý‚ÖËõ9áí!SÂãu¢7#4zQ€8‡€~4HxjHwc™y×<ÿGz!Jº¤“Cƒ‰/m·EÚ(l% ÷+º¢¦¿¹9Áùöö! ¡ÐÎXÍy@ËôÐ&A¯?7•e˜˜ Õ“U‡øDø´r%Ðb%ˆ¶ „ ³Zn¯´Ú‡Õ\ó׬/n}(CK`u[J¢}ÙR-Õ#¥išÕxHúï®ÉØÎp6 “äØwÂŽ¡¹¤•ãkŒ72YµUe‹J{ëŠS°lO\k™‘…âÜ®W@Sóz ¯w¨1  âd“Z´»®qª;Ù“oø8ôiV"Ðâ‡z®P×sKH-:#Ž~€6–+N&h #SFàšÖ­u±—ï50Õ5`cwÿ¥»èSÏpÌȳº‹Å¯ÁéŽw#R¶·èH{ÎRTªDþJcø,~a·v«'‚ÂÄJXc€@ ݈ÕdmXÀ‘k‡•Z©Ëˆëù¿jP‰úNeV2 ¶GqºÆO«­5[õAe[á®aö .8 ¸W· %VBܸ7àìõóˆyÿtÃlÃåúUº§[¨œÙ¯;»“£I7ø9 sØ {0âèÔñ".¨'-¢Ï&∼'öiê>öÉG½¡ÄfÝÎq8íÛdA{©´¾OÀ~NC Z¹¼ˆª•S™ÔԜԸZŠ­:.0”7›xcÎ\í.w•ªWã:œußÚÿ(eØŠÙ7ÂLÅ=šÅPó®;ÑmX6؉¡t#b:&™Âç*H2]2Gz)âÓ‰"ÉKsÔ Ô² 4´ó9œgë¶b¨Íw©ËW¿ë9‰Øà+t²:-x):ª çJ‰óª_"êÁ :.ÒiU·ÃåÒu£ý¸÷üäøh¹‹m™9ZHY\‚}%c\Æ" âI™x¤¤æYâ94x'[" T Àõ¢ÀT>Ý(’œÝÈќӹ¡2Û†_½ÔY]Öïžaý‡¥~ˆã4NuHˆay],Ä‚øx) wý•1×},WP¢ÂQW€ šöiï|Eê~î+úð¸5ÿ’ôÏ‹ Û‘™7Â%m…º;ÏÛŸùŽM@ÜUŒÜoJ¶#:.}2.È<Ð{k’<¾ 4¾É×9”wØË÷‡‡zmÖFÖ•ºžÓ7ëÑ·zp¬¶}éÌa;ƒ¾Ú¢h6Ø©Ñ$ wlRwãÝã•©îAƒ²&ZÏwÔTƒÑòîšùs×ä}#¨Xž ]^1Á}7 âµsgÌc’¥_GçYµY2B!Å‹˜n…½*àÚÛó-ø:@›þ@w˜ëª<êO_©Mµä*ô-B‚ýòZœ "ć…!ò}K_}õY¼ˆQŸ‹5æËhñcC}õ壧A½úF,xyãe„ 3ÿ7l°€ï¦Íœròôi3(MO/0¸1bD¼¥L›Æ3abiÔS™B5ᡃÖ luõ6¬Ø±cmy²eËC¼òå³÷6®½¶nëÆµk·­“|Nì9¡×¢M À8Ù·Ï„ ?Ì{<£y,X@fDÏÞ¼,–È“çùÄ ¢—,9aôÀ{¦[7Y {µÀ{ ¸wûž¼ó*Ìõ!W> ?䮯Èå;šü<_ˆ(Æ]ØÓÐB\~E^.@sM :ƒþÊs§P›Þvð ´© OëK}5ªÓ&¶rõê d XÖYgu?l`œC ºÕ`]pÙ3Wÿ>mMØ—=Q@O‡€ &=!& M Ùc˜MÆo’Ù3ÙfŸÉ£Ûi¢¡šg©ÁÖk°ÍvÛmµ $Ðl»uø\AÇsÎiôÜqD1]BQ\Y€=m¤´"+xwCL4E^yèõ4Þz6ÍTÔQIÅçÔSTág_ÆÂŒ»}vãi:öȣ围 ™Ûn¼%dÜYäëG!‚±ÍAiRtU.Keª¤¤"ÜàL1ÕTf™@¥‡&š<ýTÿ{ t§|Èi¹ùAåT~è©U€þi  ¢õîZ„*ú–=ÆÁ©=Î2Z@oEá—ˆ”Æp$V0ÁB˜Íƒ©›•Ðbd0>v‚ª¬¶Šã«4ζD¬±á6+ʸq@ËÉ£Aoþ÷ër†èCì“}d°o!xˆPf€“’=-½DÉ7|)¶jšw¦šl.`Ô ðyÀOSꪋߜwÚ™ŸTïj5îWÒ[ Yj¿·T–tMø¯\rõ…0¤[h°¤yç… ùøMbÄ(JfjÅŒˆV™e0ÆÈYªŸ-ÑY«©½š²¬'«Ldæ- I«®½5Ô«¯uD¬±ÄŠåtQ ´ÿØ-?+0fx3‘‡»Nä§m·B‰›”ST ŸnºO}m×XÁk”¼h›•6ZZaè[½:‘$£ÚCš—߸~ø.ð>/"púÁ„¯OYª,¸ãf©B>£i¨•–ãŽ'»<Ûå(·L¤ õ¯ ¼AˆCc!ëWÒÉ…o:4˜ ¦C¯ã’јö’\‹LjÊ ¸6ðA5‘\/ñÄ Žrµ¬1å\k)^}Øu'(Üç)c#›-: ´•Emºá Æ/io/p1˜°þ¾¿ñ¢K$ß‹Å" ¦sLü8æ¸÷]2ˆ“Ggêwš†F¦¹Üæh›Ù°Ìe´ÁœÿnŽT*^-J£»HƒŠ“ I0Ð2ˆ1²³~ˆÀ;J³]¶t­õlëw(Ê “¢ÂF…>34ÁÂ&¬ø‡Oó¢ôîéiE_q‰›¿(D°ºèƒ.Ї DðJó‰ ³,Â/Š  \JqÜo”8-ºˆc-£]5Æ’­F™?j™Ëи)s±iBAJ…Ð-„:Á’€H 2¥ŸIpœäÄÎþX´ÐL/J™Üé­ní.MS£Fð®H®¥…srá%e(C«Ä#+ÌóÁr6²¨-, íá ;• •Ò‘]ô‹Äc|°Á,ŸxK]ªÂSLŸc¸ÿ8Èè+Æ&¶Äuìq AŽT³L7nŽý;YhÍežÀ ¤Çœ£JÄ!G}`çÑ‚‚,A‚¦iÂi4 ‚¹x LlgG§ÍÓLÜíNxϨ…Äc¡%ÙõB°‰y^ñJB d¯{ñP”#¸Pö&J¡»¨r•®DGg)^„T—>P…*s_B†2'ˆAKYJªÈ *c+ÙM?Ë#EóVÈMOÓ¨²ÓÂFÖlÁc:ä3…Èög?£TÉIÕ×XÕª€d "ºã F`&·{Zyz‡È°ŠÇžiÅg$ÙêBü|  qª¡ ïªC†žÅ¡7ì«C ÿG `,ɨ+]éÑŽÒR±"Å%§"ö)ù½c©ŒJC@ÌÍ4™ŸÅiN9·2–ɲ¡¦ÿhj׺¶C¥R0oA XS·÷h‚hˆV!DRiÞÓr—&yª'=Ë“Qࣵ¥¸Àxöa—‹[(•åí©®Jè'µ[/½ö\ñ°*'ä(¸ìÅ-Ù(,õ!ËĆôµtì{7öŒ½oT%HÜ0ç!ÊӳɼŸŽü¤5:“Àd>Îü™¨ª¹ l–àAlÀ¬f·çTÉvD@»j-€iÄC|Èl‹MF1Ê›´Â¶E÷­` ¨|¬Ëƒz2Ç¡Ün : =¬•ÿR.•‘…>X¾ò•‰El.WàÞ}H,F‡£¬”[”¸Þl–7]·™êYè´"zŸL¿ 맨À«Þÿ5ΡŸ ÇC_ZÓÙ£¨§UYƒ\ÔM2³ͪ]‹wœ<áЗ‹3ò‘Èôw›’‰Ö6´±LfG}ðލp t#Ayð”M¨ Í5P W˜5Ö6ÑP0øŸß (5!ëzÉž …jÄZŠ÷YëxS•£_¨A¥E‰ ƒCr”ú—”J¹‰CÕ!³27ŠüØY%a×VXE¬hX˜}¶¸i‹ ù'„bÏÅ‹OPÁØ6Pðtï‚OdSuviŒ“V{¥Ðuøc¡˜‚©¬4h—>)b*¥"™“1²¯5Y7rL5ârÑd#¤Ñ‰}÷L-Ù´HI(×”¦ØwðkàûðsÌðŽ€”iÿÝprÑà ú êprV¹Él"àBBEQ#pOÀ9‘l1œMA]l¹ï’EÀFÁ‘wI{:†iÐy{ $˜+Bç!ØÄô  &AÞ¹1,õ‚1ˆž”Å)BkB‰S;ÂLqUó@4rF¸ñk›š?8š(w! šy?Ž–§}± cšr„D\HB€gOI+D‘ÃÉz2d‘Çy5Y1.-Úœ³==4. â/Ò+h’.3¥">z#>:UÖÆZK ¤5i¤7BLçY*0¥žÊdk—³R*¥¨áŽî8‰÷)šI‰rb’lšÿyû@*‘¦)@«'w›\¸ ?à :qºa÷Äc ˜§vÒhL†O7Pü0—+j6g! 7†oØ(ã¢þòÓÉT§d‡0²£’ª_ v?QsÖäWTˆïÓ1ú5#“i‡õE}Ê„¯°‘w*1¨j¥|@ÎÄFøÙŠúIÙ ¦'·Ñ0ÖÀ ™8~ ð =rަÀ ý¡+¡ýð ðĵ\$d¬eågËeV7Ðh©m³–¼H]1ähkÉÈ9­ÔštƒJ¨÷‚i£•å­ò]E!¶Å`’ U™Ù®Ò1Q…©ªÖ!žÀ"ª"«Rq¥eCES6ÈÿL±Ñ¯Sj`ÑtF|¦­šŸ'w° û 0š»(—Ò•™ø•?ð«x B#K$[nx ¬?€‹* Ÿê‰#ÑhÇã8Y«kŽ%à13’*»‚q†8÷JFíiZ;¢1+¼¦¯e[rh[°j[ 'GÔð¶IÙ' P·Vˆ… Bž · «nÙK–%¦²H€4œçbœ%:‘òOIA68›³vYuBch¡'°},`T Q½âcA31¶¥ù•™§aòàÀº%ð|Œ0ÿ2»»¡EªûUw–Ã#öG¦1`±±wÛw›‰(—È«¼Ë›”ëÐK›^yr=Ð4€ ¬„²(ÛH׋·¤‡Bj岈‹Ã8<¾v³Õ•œ€št…–C5Ö%rC0­­Àîðî0 é”N}–.ƒ£õl°²F÷à ;¦¥>äšØ-0ßêð Â{LšMŽÂOþØmÙÁZÙ;í‚&n¢V ² ÃÞßs¡Äîß ˜ –Œà„«æôìÎÈškŽ¢ñ_ºÚÕî™YÝ[-´Ÿ+âc+Éáݹ­€îì> Ð ?? N @ï/àÿv <ã!Ã֦90 r бÍìÝLž)§Jñ€-ñܢРwßô•íÞá1Ùô-În‚# ò¥ìs%ì*U'àÈŽ¬έÏ.ùøô§#`œ‘Ϭ}í€Zû/ø{á‚5)p~ºA–ˆaîIÿèLŸ ¯?õVoõ Àî@,0Ɖó1Då¤ýþ¤¾fä‹ÐêÑ` /ëEnÇBØÇý)Ýk?š¯Näs/½OŽ÷x¿ñ´sÈ#ëÂíGˆ0’Y’À>ì%¯þ*à6a>P àïÎȾæ2&ÀÁÓ~ó‘Cà>° gÿ/_¾ 6l¸p¡B{óY¤èÄ^ˆìÛ׊Â’C($hD«T?Z¦R™ ˆCj^€ð¢D‰,äýôyBè¢÷–Ükb4é=˜êè×Ïš?ªU«6ˆÊ FÔV½ZË•7¯e¹5@Ð#ZÙªQÝöcK5ZTQ­ìÚ½ÑjÁÞ{ýþð»`ÃÀúÞ¸¿ øÙ+PQòd{**À¯@<~FŒðÌ`D‡7:ˆî0:õhÖ<{6š_ŒG(P@#åÍ«ØPaD‰Å%R<¾£½(Ì7‚¤02:…•*SÁ¼®R;M™%]A(ñ¢§ÏŸ'–˜7_ôÞzÿöL 8}um\joûщKu@Ô­ýäçuÞš-ûàŠk®~^¸+:½[ ¯"¬BÀ»á°aŒŸ ¨Àž(ÃŒ2(0ÛŒŸxâÍ5ÖPK4ÒTc-5ØFˆm{æ‘Ç6ÜrȈÞÎ!ˆ’ƒì"%‘sâ"òáè"{@B$•R¡%\Â.&îjJ ž’ ¢Xèé§{~’g¨£Ú{ヲˆ üüЭÙR0ªò£†ŽÁÉïÀü¬Ë®é(È0 /$Ì/OüÊ01û D%‘2ãlE=ˆQ5Hõ¬Rk|ÍE8³§¶Û€Ô ~ã("ÿ…Œ#.Ÿ&Úu¢.j®Ø( »R%—¸¼®ÙíbêNÌ!.à!<Ù\sÍóÌ“‡=âüöžaü¼“›éøæN¼yËθz8°j µïШl‘!ô‘ º %”Ð/Ãû A¤‚ >ø€‡'p8bz öô²4S±3Ð>;íENU5F×TmÔxbíöÇTÞ­ ßèÑ•¡]…3Î8…¢h2Ê'9É.e±k6hgŸ•©;’ OÍn»]ï<õ˜ºç=¦œêo^u¯öGP=éµÏ›; M®èö•à ¡ B+ôËàJ^؇硛‘yìv˜‡–[2Mùq,ck,Õÿ wµäø9AŽÀ`Ö•kÝíž*2"â4¯y¢|šÜÈÉçö±ŽÙ MÏn»¢‹&Éœ^ƒ¨Ûcó(¦½e/¾~ÜÅ:?¬úªŸ=½B k²¸vËÞ~Â@DŸB€ „Y!`µ«ð_…/¨Àáv:“…ïK€Àáòïf¤áNGT~Þÿì³U]y4Wé÷€z„\e–spY žw$‡’´[X˜¼ÿ°õCkÓåòaJT:J•ÿA+çÁ‚Èí†V-ã-oy'Ž/Šçs˜Ü>0`þª˜ ÂQ‹<âÙ8š¸ùQL¸²—=€, ¥¤¤Ê ‚y´NP/ÈÇ ®®¨x„Ÿ` [!œ]Óˆò´õ8Â-ÞÈ$Ö¸Á®¨p('ìGzg :Ô°,”$(ûሩžf m(öS©VÆÀ6¹ÑH+dÀ–ebåáDñIñ—ŒèE “1±Èš±G ¢VËarÑœn|Ó6zîCÅ¡Ùgi¦$Ñë§B*L†JÔ>ubªµ‚ðÁ’„·Ñ{–’;·<ÿ YõÖÖº„¤,a [»S(‰O«€å-Ê{Âzš %Ѓ!™b_øâ¶…Ù ‘À¨^s°#앯+{!ØŽ²€Q¬bbkb®(c±‚å¬,KM˜fÀ7—“^µ™Óâðƒ´ŠQ‚E$Ρ©V;V­LX[´z„é¨J OìØ3ËŽp·º‹7Àa€RÅ PÞ"âNõÁ» »BnX\ÕS4t¼c Wx<æqž‰”%´”0C[^樈F–÷’x 2åñVÙ¼¹¡¥-™¸eŽži'' âÝb¿Ùp‰Kk¹æËb¦·šÇóÚ8œ_1äWÿ 1°ò«]9ç;cp9|AÏDÂ謰…™Ô ” v‘»MSäÙarÀý‰W¦ûQa¸ )뱦E/LZžKÐݦg—´¢Q•bŒw¡,€Þ÷Œåµr®AReZ­YË[ŸøX@Å8ŒÌ”©*›ƒ[2¦eL#œså+ÑjSÏA`°æ5¬á k€{ÜÕ.i¼êo¯û¤6Âó´g»KÃÿ•!1BV-›rÆ3^ÞŒ[YãRîÇg¹^þõ(|<™æÁ,ÆYáÆ6²Doçei#9!J*@DôœkÛÌs‰B§~ºÚg…›;è,ª¢Ã$HÐÖ‰ƒõ`캅ÈõìêP#!òOÝõ®åMb{S¤?ýJºÒÔ—þÔ8ЄB­û/.˜H’”Ü%BØÜÿžlFŽãš¼â½øã­Œk É2ä\y°Ã7YÞŸÙmæ/8Üù¬‡h½âœMYŸaºì´¡[¤Ë  [4Aj4Ú Ÿ>Ù1¤38ƒC>ãcyj±®#®J+죾¨QA±kAIk îó¾ì# y0²¿#¿ò F¡€™(eãÐ5Ç“¿"ì5_ƒœ{`"%ò .›Ë‚Bg½7 5%ä ’ˆÔ[.,Ž]Á&) ¢´p;´Ü+* $@·FËÀ'z´õvóÀJS¾¦1Áæó:tÁœ÷˜è{ÁA„šâ:èá’@ ”P H˜ ˜¨¨É ñBJÿ4B!¡?^s³ÈéDâ²ï‚)(|œg‹&Êú‘ÿ¢éQˆ;­ÕÃ97žâ;Š ¡3' ::4L'5¬‡6¼@¦£­#p'H›¥§C>Ál±£HŠ&h>¶‹¾dÁ@ »jDilš6é%€D´‰òkIJùAÉ¡5!,B#|¼+ZZ3qBÊZ6Ï‹ÇÈɬݸ•6YŽ#ùÙ¦{=7º³14'A3:šÀÜãEW0€¥š­Ù¢­‡ìŸ (Æä£È;l«%0âjFK ŒF©ƒAíóÈjüÈk̾õ(0C¥RD”X »0CFx% ä5t/œä¸\ã+vÜ(ýÿ¹•‰¦R=¢Ô,Fz™XÌ&9ZJm;Ž´Å=*ªƒDÃ×êEhCÚr€pÈ€ KAér¾eäºöpÆÝ DœAí³Æ·l 9¡ÆÌ>ü‰h`É’pIE‘É H6zœÄJ¬D‹;Gž´5Z±?\"Æ¡t¶È¤Çg+£[Q¸iƒˆ›* }ôGš¹#+:Ö2H]Ì=›07_<€ HÍtƒHbŒ´[Š7É·Ý:8|óœ¾?¬¾Ý„ËœKÜtŠŠЉ ¸€–,? ˜3™,ZÑIÃì8øC£¼Â(σ¥ÿÊg‹%ËZ3ÐòŸˆ3†y#†àÇÿB nª™Ù#:Õ2:CË ÑLC ³ «ÄÊ6D·àÏÕtH[2ÆŽ$ËvÓ¾Ú\ é+IßÜMíCê#Iè‹Æõ02ß{H®äËØºÏ+A‰!xN&E!¤ÎÕÉø;¯Zb¢ôz¶(´%,EÝX+d˜Éõl-ìœÎ¹#2”Êl-@ û£@ ‚üÄÊ Ò¤âÚâÀlq·<Éf„Òë˾ïI¹œ>ð‚P’¤KIÃ℮젇ÔKWp…×’ p$‰jñPñt¿JLÇñjSù‹ÓÜ ½Yº,˜²¿xì5¢‹ÐL“#}¸ÑpªÅ÷Ä /‘°\$MÖQº^¼J¬47 ÿÆ5ašï{7p©¾OKK¤Ø>‘´>ݼ>°ë÷LÁÞ\¿ãèi'pUR2“>Z‰£ ‚þ™¦ÂQÈ›NŽ£¸Œ²¬È‘¥iЦý*ÅîŒL7ÓÆ\ᦅ1 œâ}ˆV%Ú3Cù¼=CËVùDC^Tº#5€E{­A²H9±RŒÒf\ÐMuR¤Æ,=Õé‹â4’HªxU® @ª ]Αà-ì Ü5)Ó«„ÍÉ÷Ñ›œ©Ç±cu¶ÏiÏ%³8Ë]O•iÍB­™Ý#¢YÔÑTTlEHÖQ´EËOs“–!HR5×p‘ºtåÔ´tÆÿpF‘”ÁíCƸ|7--ˆ£¥Ë 08ÄÁ’èÅØÊt3¤šÕ3M…” € ¸U[ÊUóêÕœlX…E£QìDîü¿ý’GZâÓ™z€ò¸1O8: ^Ñ‘-YÒ¹ÅÕ:Ãl5Hú¤J™ À— W™ Ü4}5+FxÍMÝ:8e  A¹4Z¤Æµ“Ú ¼Ï"•ZªÍÐd± WFöûÚŠãÕ!QÀʬe V¡ü¿ËÂÓ‚5ÑaãX΄ˆõ4Ž<»Q¡ M¢9YE¥ÏF¥°—%Üt ’˜-bü©ÑYð3P(õÙv•ÜÛ\Ky=ZPZƒëÒyðÆòû#…\Í©…­Yíÿø‚­Os [„Ñ‹9]6Ì’%NÌÓ˜9f{9,ó (&†1ÏLqg%’¥V壿Qh9§nEÞ]$ÜEÛÅ×b*¿Š4Åí¾èåYžõÔ)}Ü¡¾Ê>¥µ­Ì5Nò[ 0 $¬R×>J `NÀU¼BG±ÍI÷›Ó묵Êò‘)œX(´ØúÕΈý?ܹ(ʸ`ÝÕÝ‘­™ˆÈQÛc` ÞÅþÛâ \oíâtz-}%°4¢=I"3AâòYŸýÙŽ”¾ •AÜÁ>¤UÚHã@y0ÎDüË/iá˜áV˜ íhW€H‹2]Kǃ-/XdD®2ˆe")ÿÄ Ð[/µ VcݨØe$&`ˆàOÞÇ#ñÂBýÌà@@êOèOHõÑú \ Åb@ÜD£Ywªck|Ò&`ã"¥0Ÿ½76–Òü4¨aATÚ°!<~¾\‰«¥ « $s3S K‰dø<̲N7%B÷{¿^‚UÛïb<]/>õPðTbå(f„˜PÖÝ`É&‡C•¨‡˜‰}v#…ZW hW}€îOþÄJWÒ|eYVC }å0€¯$c¨ã vF®sÆ_nŽfgôCN!ê»åÛH°t*®ôÆê`­ 6ß@fNB¾%É™DLÛ„UäƒM]‚ÿ¨¬š¤Çb¹vŒÂHŽBw~€þQ/(*Ÿ ˜gFO}\ʧÄÛ}ö… j`ð…F†­>_Øê­vT>èUN´–•`™}Ù¢r cÿ*ã!sFyÐå„ëå_%þYPMF¡æ÷x*°ô/À®%Ú‚a›H>F벦‰ò[ka¦\-L†Õa˜Î;å²3EõZQ(ŒØ,KçˆýDNþ(FhjPžQö¤ˆ;Úg¬æO`èϬîj¨E†W5èW-h¬t€Ðí°hUhW£Jëã $¶¶è‚x̓k"Óå_Ö€»nçÖenÁ¥PK@ü Ø1é™l Piiä/A0–åÐÿdÐ2bŒl"¤Î„S\Ë‚…œ$Owì¿£Ö2g[/ÀÚ²èïNfj§Ž[.ì•X\°} êpí®þçÞgdàOhÙ®°Þç@† O/ …Ùv°žm~îâÏâhq!±è½‹ë¹öeè~îèîåéÖëÄTƒ{¿k¯Œ¥ Aiï‚ÍeDAæbYŽÀ”XßB¹óšì÷Û‹»ìþ3b(Dg×­,ˆiÀ*x/ÿæd€¦® (-àóކ Ws×ö¬þçd`m¨êW5€øp p ¨>×m w`øðA/ko5^äíůLñlYcQ‚ñçÿÖzhI×Hgã´”ÆêÛ^F"¥`ªhú¸¾BiÂ& •x…BÓ¬æÅVß àD(?#&_rJäo †Lðäl_kGf“ïÚ -×òïygÒž€0¯€˜ä¸Uö…ˆ= t¬æj‡Ú—ðªæÏ^üp®¾sO¨Ådxx€ZÀðotˆq´\ ¦è{èå^>cxnztzhI·wI÷Ÿáè{×ì{Ê aÍ€i”†Uð~@žeä=ß^ß¿ Oj ’÷ƒßÉÖáq&gaO¡äl*Gr ENd"-gê`#øu¦æ 8vC¸.¾.†zhpÏj­ÿÖù˜mƒ´yþ¤óWõp¡wU …qtdÀ.Fw‡&ò ‹ø{€^¦‡Hç, hÎrzØz'p|ÏúQêT–.y@P¥íR0(ä?ÇD#H¯f®‡VxxÆÅû쎙h… ØsÝ–r3ZoÊ^X°Õ需£vÌH¦Xî#ZçLÆ¥`Í¥˜W˜€ ˜”÷ï,¿¦vN†‘€|0åPE(š7Òlv9W}Cëj`}¨Íydðjÿê=…o7÷,vz ~z0‚Þ%àz{Ÿt«ßúI÷z'åßwU¤¥nAf©ßÜnôÊ 7x¸/èÂd3<‰ ÿ: æLWÀbEÜö5LÂw<ÂG#Äç²c-jN„9ÐþI;Xˆ%€˜0ÁÕ…H”r¤C$NPECù>\üða‡ûöYï€88ààdÊ‘õ$0‰Re=êÕKÙ2'Í“08À`&Ì— Œ=úi‚!M‡ðà"½Q¨ÒËJÕI'ù¢|½JÏ ½fÏ6¹wÃ=y-æ…hñ➀º¼à1dÈ?1~ðÀH#0ä­·D«TB†$š U̘ (¸Âp˜Àƒ#¢zÙ²ö*¨uk¯ûZïqUÄÿ?ïî¼¼'Ê«·{þoŒy%Þ—Ø;1ãÅ£òëßïX Aˆ£@”F¨Q$ÙFŽVQD8‘iN„’KÀfa…,µöSC.ÙÄM¸…舸ᣇ>ý6TTÄ×”QI!—TTSÙ"ÜsXEÝ_uVYØÏwmu‡–=PÈ5^yt1i#ïíõ^“ó@IXzŒÜRå|óØ'dø@vPO åçßMý`€(i*èàœDgJ@±¶A ðÉç…@aŠ´‰Ë‡#æ¶оeåQ.*%)r”v #RKu`K8—#W;å£b iªwÙeWvGÎeO ôÐÿEÏ<9=öÔšë“QîÅȯ¿fßNhTË~‹5v¬C`¦²f‚“µ í7PP-" ‚í 7´BÁÝp'E þîܦ˷ëÞ°À{þV!P½Ñ†(‰‹.НM¿m°€p¢:uܤË(iUzÝÂY õ•u%¤Û?üT€ñüPk­ô0ÒÆ´fÇ"k\­"ÓúÁÊ0R¥—7݇왣ˆY[CEmG$=‘¸HÜ`ˆ!½êªˆ¢mµ7 ’n+Ý:ÈæÐ7T—uu\{ÀÏp½î»v蓉 6„[Nkë‹S¾» P):*œ¤ÄáýâÞxKÿªisWªcWž€EªÄ§v—ñÉ# 2BÖY#B²Ë'g±ã <^¶†œÜ¹ã’Ãì¥Î¶)–lcyöг±çE#‘­Ó*Wí/g¼êÆOok­¸qËuuglqÇf…-Ö øÐ/¡ö¦­vÚ%ÂMS¿ÿ2—ÜÀ|_:ã¦UyÚ°àÅñk—]W íã7¬»nuºßîxüê. Ôß?·ÚBÍj¦„$ YŒá™f¤5 ŠÄŽ[»û@>t¥«îÐ*·»X­4Àt½ óÁª^…ª¸ª,*(€ âÁ€ ,€h3›C>Ô6¸U/Q5éM¿†0¾ ¬o{›‘rÿº3GTÙñ޳ÇÅ.׬U@sºëŽ «'lHá)€ЀŠE6%Ú—õ‚=€ ˆ˜t‘ „Hv€ dŽàvt7óq -ûÀâ¬86è¯]]ã'‚Æí~Zóß VàJW.1|ÛNÎhÆ3Þä˜(‘Ì@(R-$,-Hu´£ ae¸t'.:ÅÂz%~¼ÜZF-º‚Ü/£Y;ìDXÛ!‚—”(é/÷L”ñ€ ,`Ï>ÍÂh»³ú§ñh`-Ü´‡~*ÔªÖ,&ÛYTx‚{Üc¶òø°lÓC*=‰!øÀ}#p}0ÎÅ”˜n´ÚÕIâ ¬8æP%Å”=å¬GÉA€øãÈG¦F0²;ÐPŒ¯+tå&FgÉ.ÊïªSžâÖúZÑÇ=¸ù@DóôË€“"Dg`#Oló6f9Dÿ"šMMI†–|˜…^󮜘Χ-d‰‡ 6i”³¼Öñ½GRc[ôœÀœPýÖV`Åîò³¡=ë™\ãRòlA±dØ0õãèbªU’WdjØa RˆÎ8p!Jðý0VZ@€´àÇ ôÀQÌ»Äßû>À‚0P! z˜¯´Q¦èAÈò 3w°`¨B­Ã°~K¥c* ™*Ëæ7{ËÀšå?>pÀÈ«¦F¨Áê` ÔçF'( ˜œùµŠbU(wçéPôΛ¾€5#Ö˜ K@ÕÓÎHCZÓ².3y0âkS=<sȃ`þ=N‚]uGíÆH¾140áð8:/¢58Ü­—*}@ˆxV°€ ÉM72Þxÿ§÷ÕiE¯Í9â¥÷¬VA±±êp¾¨A0öŒ<€­4p]ØÕv° ÀyZ°V ü×0€H4  ýÇV=@û§ =0CÂÄTñfà-W—4 0G0[!N½GwöbGppƒ ¸2A6TÊ—|Ì'Tê$}Ï— w¼Gb*F× ­/h3\p#7œ6='xs³CãcëD%7P”‡dÀV à€5Àd4P†)ç Ày=°j5À†G5ÀVv@‡H–GPqˆd5yþ ''ˆ«V,¦c@”•nlòn¿ÿC{!C+{Áoóð7çWóð{5hƒ7x•(,3p¡Ê×|¦Å|ôP„ŽÖyÁhwŒ b+` ð-R8¸à~Wcçq´=_)ê÷cÆáE¬öjýÀŽ÷€ІH6~XmÈŒhˆ¬Fõ‡IÖj…rmØf,UŽ÷Ñ_?à-3e-P³(f 0!°üð†‚¾×‰€8˜ƒ%ð† Š1SЦ8a©8µS°‚ï!Z«}Fè{Š6! L8i˜…[eCÔ3IÇõi*²…ÏUjHQ)2ÒxýàGFP€s0'ŽG6zę̀’GÖ†ÿØÉhˆ’Çjc˜’ÒØ‡aX‡“wdqŽ.e@9ñŽég 3ŒÀ>¼„زˆÀùx5xÀ×òP‘0"?xËÇ|¢¥Š&DUøVb;µŠp‡hò@‘Ù7i—‹ñxé6^¥qË•O=Ö"„v)È! ÝÈjå ÀVî C© á¸j}¨’ðj40”þðÁ°jØàx†˜]6¹ =p€øG‡+†þÀffþ%&ëF @5še4V2Z¨ô.[ɾ'ú(–  ÷ð<g1sMp·|Æà–'Ṡo·ÂT°r+;õŠ!6[%Oÿø-|~å·qÇ/uƒO2’¤¦2R)(i“u¦×ˆŸ5° šù˜HV𥠫&ÑX‡k% H&œykeÿgÚ`dê¶RšˆˆâT74TA2£Gø`à/Œ@œ^éa`–Æ)pA0Þ’–z$aK0ÌW×y ÙT¸ÒT´Š ·—؇P˜žv…VH˜ÀX/A±ß•˜˜b0‹i)iàx¬öý݈ˆ‡Ú€  ‰d›ÙŸþyd–·j:Y` ”Hv¦¨3¹3äX&d4›1W5 `›x·|A63H¢Âç‰ý(7h¨†úù¢ÿdЗ5Ê|¡…tIvÔ£„ž0ðà<õr"ÅužçIJª"ùäž>f’G8gˆ„8u¨šX ‘'¦*Ù‡jJ¦ý`¦k•«»ê}H5š¬j&ÇRLý±f*5Þ”Li¿×hÍwvðu„zƒ`œ‡ŠƒòÀ.Ú ú`;üF£qNÕ‰op¹®üfA“å:!`BÐ )¶˜øNšæ‹›v¤S’\QVŘ˜–ÂîG­‡ËØ ‰ þ¬Á  '·j˜9”p r¬Ãš™­¦ýP†ÄÒt A›ÆzÑ”,Áp†:|v­ÕaŸhœÝÿj¨ÝJɹ/à¢,Ö[Ýá–ádC;©{QbH›+S®Š¥ ¸ð ЀØ·¯°~I'Rªù’i;Äcªú¤»˜Iq TZ Ž*ù“ý`¬¼¬4‰Ÿ¶:·ð÷ŸŽš¨)¦Ì0Pz¨†É*Y 4¸üÑ 4a‹%@9ƒETd¡K@¨9›³ÞŠƒ/pLØ ˆ€A5 >eZá*ð`d§GŠ…-+Ð " ×°O/”P6ù‹\%˜‚i""jÇ80ñ Ÿ`rp+Gæ€*95Ðk·6醠I ;y3¦iÚ}²š¹šaÈzŠa›Ža›Èÿ±ŸaG‹Ãvðo4«³pœýv„º¢-*q0Gº¸BZwd|ƒ"À}Ú7\ˆpºBú.±+(pú¯y=)¢®T8™SŒ°I‹ç»&€j•¼m«_Z‡¸*¼€HPv ¤‰¦që›rÚzÁDL‹ ‡’Z TÇ3P¾Àó*ya Ž›­žx³”[³„º¸ŠŠw÷[8Õ|FTvM<ȧ«¯”À'Z¹8–ö.P!+á!^ŒbŒµ:<&rÜc’ðé~ýPìÔp‡$ü¥ `¶Ê*¹  ±:PyȺʱ¥Âu·{رYÜÿˬŒœÀ pJ䫸p Ù‘pJ5afQp6¨¢E\¹7ˆ@š‹¿¨ø¹r±Êz†*¤-Ì}·H_4A'#ÀƒÂÀ”ž)òÀÌÕQ\)úDhàŒ$¬ˆl…ÌÚÀŒÖ%€c*¬)i€œÇÆøÇ€û·¥k×e¥ðC†iØê_Ä´R£ðÈ ‘¡Ru$À9pM"}Ì·Bea :Û­¡ì­€ó࢛+aŸûS¡Ë¿®ìµ[we®Jki>°¯¢Ë³;O q"*¤ÌÑ…ÄÁª1r‘pŸý Ò(,Í?ç'@¢—yÝ F÷°.ÝyÿX& átùq(S—Ž­0ua4,`É 8§oÕɧg7$ư­¢l¨7X–N› Åq±MDo{äbüPcæ  dgÑ$AŠER_Œ\µiÓ/À˜ªÊ›¤Æ1â78€.¹V0 z€16`͵/÷«bºVÕFx Žp׊ް ØýŽv‰}såÂb´za²f4ì”vºP¾†z„Ñp‚}×*1¯…ƒû–ðÚЩµRÏÞ¡ZþÖ1\—Û_ÃEPµ´^½s„Õa=Ü/sÀg£(h-Æ×³Ùãhœx;h–’)ËA´Vkó6Æã2|ÿ Da`AB Up‡ÀÑ܇2 ÐpÒ[ÃàOðÌ€ƒ¹‰0 88 òëaÇÉàþ=,Åd:úñfo#xçÓLé-· ¸‹»—éAb{ŠkAoLý‰6¨Ï:h1TUT¨ôg¦vFoÃÕóEÅì# nQ|µÜÅWÖôâ¥Úi½h˜! Ýü¤”BÝì7 óËó1¹â2¶\A"óÑ‚ t¬h„‘ËÔa§pÁàÿv7H3!˜à Î3aT×”TGuàÀ ‹«hé+'çrQÕØ!æ‰& àÀǧhÞag­Åý ¯ãsÿ´ƒ üö`^|ª„ãZ¥‹ÆEé»Ì(.4ŒÑ]Á\ÁÕmÁ„Îáè¤ä.³äü6çö07 p'w±¥T‰Æçø½å6xëÁ–Á÷Xrz&hÔ3 ÞÓ;Ý”{B· Ú‹ | —ý†*I"$ÝÔ‚qº[1+h „iÛ­‚GÑtS@Q€SŠnît4GaíbúÚ!ÅÕ‹ÒÓit£"ÙC’Å×ܪ/RÞõ0‹S+`|º%r®l`tÝT‹&¿°Eë”ûߟÈZ|ÝÊç÷0,èìë7³T§YÄÎæBp¢9àÔÀ§Tç!2ÞQ1öÆuA¢*ŠÓ1 ÿ•$-Ï>6ßíuÆ>ßIbŠ>åæèuÖT|±K7X "ð^Oýã;rø^’–ÒéQá<’9)“+³h[Ç*À9EyÕ;PÌÀEçY.|6[ëL-ñÏ­aÉÀë©G¡ÿì nÊL©}Fs%ÏnîÔ"}ó€*ƒÛ_Ã5Ï5Å`€æ5cÁMñ°G—6ü ÜD諹†®Øîv1òº´÷/gÆÒS\ VlõÍ5Nª~ƒ–ï þ"SÁ\è$Ï)3±"+doÏ·{K(0 ËŸ%Úát¿Ž¢àÛ“Ë­7FÿÿÃK ­»É'æ5)–‹[òƒ:wp—SM5·½1óEµãdÁÝ^úÐP¸ÿ_E<ˆð _¾ôTÐÓpâD“%MNhа$"ʼnôìåã§/_>D"nP²°aƒ|)q¥d‰eK|+Un¹ŸIOìdàÁCŸAƒò2´¨‰E}v`ÚÁ“§Fð³÷Á#zó²ÎãcžW‡aY,; F?´i÷9º×–{ÞΕ+@îÛ{píK›†#¹w ØÝ·oÔaÄø+N<*åÈ­(P¸ñ£Õ?nT˜ÀèȽos€{d‰¼%açiXÝZ£=ØU ð£=ÂöÿíãíæX¡½°ƒsä'¶Úùì)GCëp²ív‰{žybŠ5ì4ãMuÐ,gfN×x|d‹3ßT®TG\µÕÈ&‚²Ê6XÀ æ)Ðx­ðס›k˰XS$U¡¥±bMZeE6[Ö’ò9niôº‰*¯ ›ll7iL“Ön—m5e‚×]ñèno€=èé_¼ù´O)¤ü„ʶx–¾Š+Q6hÅÛòßqˆA®býØÇ($€5`(ChÙÜç$F2íã )3LˆJtÁÇ (E ÓÁÿœ-aW”\~¦Ä`"ø+\†Å `å*ÉZ¶°5ä9É7¾aZÓ¬¶°*Ul-¸ÎÕœ36|I X€Iâ·ôàâmBˆ[Jì…>žèË}DYÊQ’?j`Ë1˜CÆb-J\¦¡][(2‰ ðbƒÑxÇ‚nœS™éZU |¼LV)ªÌnÀˆÙ±€v2"!„¬xÅ+ráÏÄ‚½°…ÓšÈ ª¶‘äIÊe¶Èö5ç8çj>4%ôj¤‘|€É;M\JÚ¥&òDQ^ç±×½¢2-ºï}_ô"ßÄHJF¤°p j ãPÓ-ÿ¹Ñ‘ëÇÅ22Hÿi àf‚QÁÑ’B7ð€´$p":ݪ^3™µÂ$7ø@ šó™Á`%¤Ñá2©Éaè4i$èþ\ØIle 8’(µ§œdm•Ù =BpQåøp¢ÚCÄ ÈT«':&—m£bz¬hE9ñ„)ìó/äã¾ú€±)ó ÜrB€?íQ\‰c\4 ðFZ /oI‹ wÔjš8ª? ì삎†` Øä˜‡"i§3#¿úÙ”% LÒ“‡jX4ݚƟ«w åvã‘À¦¢Ï›Gì†êC°xÝ+ó`ù}Œ©‰ãYÓyÛ’x¥©ÿ— ØÏìô>Ìš >Æœß `•‚ehõŸù  NLŽp ÐRƒ¦uigllj–Ò-S Ì(`¬ÞÀ¯c&å±+Œ&¬2J#–TÈ»¯Äx[Éß=>SÚµ¥aA«ÒÕR“Ð…¢Ë8""âWv°‰AÈ+¼&KY±DÄwn‚KÇÎˤ&µ—Þ³>Ÿ¸4>óÑì}þÅÊòç `Är–iÝ·¶5»›¦ó’f e£F0È)µ¶ÞdêÄf‹[ ®ìe €U±Š L 9À‚r)dB¡ôF;’®ÕŒÛ–ëY»Ñl˜þ¾æ¼¦iÏ bÿêÈ_¬^öŠ`S~ï]óáWØ|ä YìÛôûD/;¶—žÀâ{‚Ù¯£Ä?}ÛI’ ‡œöÂÑDc4SG‹Ù9dÛh5 T@‚â ¨9µXЂŽ$>Pd™Ý 63îÖ°új,i ‹ %Ùà¿‚%ABÃn‡ì¿í¦k7ªh¶ü‘Ž\ù¢‚¬”W Š[ãú½.Їoòº}÷$ŽEO˜K¯–Ø‹ÌY°¾à—Y™þi*ÊaÄD{F^x¨o¥pñ\͹8âQ²ƒ°b=Šœh ´+¸[V‘È·¿¥‹ä3y$÷Òú¼qYÉHâ(6 †3ÿЊ ág^WÂn [°Z ¥$WůyUÎG[Þ)¿Â”ðVPU¸—1ÒFê;l¶‰gŠ&}IœÖã:|Úi#~¢RÓd‚ew×µ^ÞzgjâÑÁhº›:hAÓ6éýX'oA"ÈÜ@fÄLŠ ,|RhŸ½‚«jvDðÂF…]q·ö™ƒs[»©ÄZ ´R•|DÁ*Q°‡Ü-ÎÞ¼‚{ß{Ç} Š¸÷½ú¨JqšžÆ>v¿ô2_{üËŸf;¦4_ ›ÝÌàl qoõyi—ôÞ±Ý@–.Nzû¶LoÙ(àÁ òñY^F³OFö,Ç©iMŽŒÿÕ`œŽÚºÎ,rÚQ­Ýê9Äí ehó &)ó}ï—à»ß‹À€"Œ€l})ñ&/‡_ñ­—½ìLÉ£ÙÀkn³ D‚+2q>ÅnOs°TQ‰ª= ýºQ?MmH‹“¥jºÖK‰Z šŒÊ¸C@$¬»Êž9EÒ¤B©¶«!µ2#|2³;¸Úk8°¹C¡¨Wk¾õ»³€K¸ ê›ÁŽSÿZ#‰¥Ã»¥üJ¹ýò²Æ#ž&ôK?˜20¦°à‡¨ø3œ2£Ä9#ê)Ô:ÛòÕƒ C;=È ’ÑÒS‹•QG“$¸zÛ*FÿL²} +ÈPyPK!‚B±ØQk«…3;T«UÒ Šz¨XZ¯ò²µï¸|DG„Aêó;Ⱦ+ãˆ&c#¿ô06óY¶žˆ¼—êúð"öS0{‹e2„aœÏè)Æ¡`y˜Ú²­~Éé°;*¤ËB‰y*¦‹*d i…©»d¤€0®†É§­# ô$ÖØ¨Æ=l¡MS$7 šc¸Óh·{8zHAXƒµZ³µ ‰H„ĤPZ3q‰Qx ™xdƒ [z9“˜“6+B#,05C0þðÑ: 9#ÚQ˜³+¨Óp-ÕËÂ~ £#=ÿÈñ?Œ<ªÐË-ÞrG›ŒàBÆú@Ú7 ø•+š¯c—l¡Ý™±ý9;Wä¶";UËÁIĬ ¯)Û8’ÐÄGtGœÄŽ+~Ø2}ÈÄMÜ/¨,?˜H©ðÄRT3öó,—Ì{’¿£Ï@»ló™ÈZŒ-´°ÓËŧ2:l˜&ÀÈA¥"‚a§Ä8ÃsÀd¬€°.`y‹}Ú9ì™ ÔŠHš¡'”B#£±´ 2È,>²Y>€20ÉLøúIt仢ÔDGŒAG‚ xAJð„JD„@„"° M|ñáÄ]òDt,’¹<)Å4³Ës¿e" ÿC»íZ”CÉpßøÖoýtuàqÈz(^(Ô"ðÅ y£DèWÀ²ïì¨T7šÜÑF#K£5}L³¬‘Ñ ¬p5¦4U!EÕÿ¸O#õ;JÄväOHtÁ£,ÍKè8€ DÈ *åÕ¶YÙ¨d‰^¢J}6šÓ#%B~¨€ÁA¤®ÚT¬!ƒúŠ,{5mõm-€tõÖxЈvEZp¬§mW^^¸Z{ÍÚBU•Q´ÇPCCè¨ “8ýÎ2¡hÌÔBAØÉÔQŸ D‘‡„øLAŠ]ŒCU\»O•¾HY hÇŽ=Ê£ÓÜXÿˆß¸'òÁ\ÚUòÙÇÆó÷ŠËêß™ÍÜ¥pÎ2ÓØAæh[…<«k%ƒ8Ùeך¾8§vu ÞævµZ äoá«ÄÜR´8Ñ ®œ]ÆâsçÕçypIJ6Kf«3Â7Ýñ$®Xн¸î8Õ!ÖÛ(è)<+bŽSeu\円hŽ£A*žDø>”ÃGðɯ-³Ú¤Êªœ#L³ÿо±÷¸œ€€óli²»À³êç|xf~0/ƒ¸c}0>æé*Ëæ®Úê gA&mr® ¯Õ Na¶‡†ÌF²’äB)ÇF„½TãÂíB‘Øÿ|@,}[RîR6ë‚6b¿óek¶žAêó„‘EøCÄËë”30ƒ¬+"3|éÀÆ\‚¼ƒL°3vI5¾m¯RÈfvfËŽµ¥Õl¦ÝwµÚÄjמ®Z«õàz aÓÖÚß]Œ×KêtÖYÿXӼȽÙV¤}ž$;¬vCŸÁ^®ædÄe ]!.nRÞpã.Ò¾}…ûLeæ&‰UÞØ'®UPM{Àhðk¬ñ ֽމv) ö “0ã`&lÃvþ˜€‚1`döY¡™êø€Ž¬íHÄi†`Ìîˆ?f¯?mÑäBý…­µ×C% @gઠPaœå-!Ü (ÿÙ©m®0ÏhÅg©îj‰õIF]§óç[¾õ8÷Xk½q(îψf}¨}¬”Etw‰—““2[)ú¸ñï&Hš%l¿Q°¤é Æò{~ØqüÊnoXÚ|pÝ¥uZwÕf ÑîæÑ.‚_à…_h¯XÏZUàÚ :ÀVXm6fà|a±ê'mdc(œ¤\aÆöŒçÚ®6Ä ÛùLÕ±k ïð¾<´VJx……Ü'^âJè×.ËåÍ\nôP6¿fÐd f;©“€é€¦®¶Ø‘ÙÁ7èŠ-£ “ƒØ ¦` Îf Æïn>x?j,o/Z¯×"è…Bí…ÿ¿³Î± D®B—€¥ŒEÉ­k^ ñËwIÒ<ö†ó¯6Þh;×p;OÕâNÕ¾-b…Öv$Ö¸—DžÿÏwL›×4wíAD©—Èý•t™ÙJ—)¯€èÊó–ÖÙö$¯†`'¹R—]>Îl¦mu°7x†d‡·òëd ø- Há0×Ù®Z}æí¹í§‚3KÆíÄäjzVì|øçQ®ó˜GGi7nä>bT^kÆ÷vž?\¸>‰û•"ÙüAÅS÷6;Vç߬ S2f³:iêyPcÑź m0$wæ¬ÿ÷X:u®/V{@á@vøý¦W,‡u{…øÿ^¹-^óÉþCqX d¤  Ÿ[[5£>ÄÀdݰð9ù™'ü;çÛ$Vn@w|Èߨÿ”ü çG]†‰ ¤ÿe¦ÇÜx°í›feðx¡¡ÖaÑž °8 MŽQˆ|úò¹ˆçBÄA¼D(dX¤ˆˆ‡ExA|HÑ¢Ä_ªzØkß¾QøF‰‚ †*H¨Páü,d àfœ5 ‘'ÅÌyób=a4æ¼™%ŽÒcdQˆù$ Ò‡h" +´®ÀÚõëÕ°_Çvõ±Â¬*U (ù Äö­[ —6PºTwƒÝ¹—öº‹Kˆ|øãŒ¯ð`Éÿ3Þ€odÈ &ð0ÂÄåÊLlæ¼¹³‰ÐŸ=tðÀ Ãd#*Ø:¯ Ÿ²åý 5_«úr#ÊÇO`|ñôñK¸°!ò‰Ê#n¬(ñb‘^Ñ9Yr$¾ qgéwL£,äÌ‘SÀN÷d=1´(ÒöâÝ eDoBˆ $XÍúµÕV"t¥ÕUdme`Wj©âÃm½Ò–[J8a]}UHÉ€6˜HŒuhb 6ö˜d©UVY<—yðg¡µè¢ ñ¬¸b¨y’?­ÉäSl=Åæ^öÜÖ"EVõÛ@tœCÌIÄœ“Íe$eõ’HØÕÒa+†¨´ÒK/Å7ÿžåétÏz²ÍtÔPD¹vÂRó!5#¶åcH"P W[–W® ÊY+¼¢Êƒ ºÕ„VÈè…f8`‰6Ò¥!2¦X`ŽE¶Á LVŠ3z&Zg m&#i¤Ù¨ZŽIí8m'8e'oXÉO’Ãé3C9),•TF)eZ½ø`v‚ý@—+ñc?èÓxåíSfM¬—f­BÅÀQ1´7PrÎÓTTýQ B‘^% Ÿ ZÖ+ $ꃃŠBøï[ü 0ƒme˜H…}Øì¦ öé©©†â‰§¾˜ª‹£¹*±jOÅ›šAÑcm>ÅK‘ð"Â+?»ÿÐCÇ;óFi¥åÂ֕d´-é’ŽâÝSf™9e ž<à.AŸ}ä%PèÂÉfàiä»(ØçXbE膞…¨¾ ¾BÉZ¦½¨.8°Zº.àX`—&V˜Ý‡9ìØc$B扨5Z¶¢g,ž ZŒ1®8B52àI#ÄôúdTSBâV¤ž‰ˆ ˆÛ¤s4›^3ugI—=ç&kò±pyû˜‡žzi51ŒKÔ²-ñqº®Eõ>ú"ºÖwÕù»€"H¨Z¯<øÊYù’M ö”ªoWa+8è ET¥Ï~ ä-DÂŒåípß‘…:êšUL8‹‹Æÿji¨up#<£Ü£'älÃ+Ñ]¥þ™—èDв`¡|4óÁé¨S% lu‚I+ Õ ðã%ŒÏðîQžò iGÑ=༟Üd³Ù]Õ¨B$”eí@+í%(ê•Elb3 ö´"JX Aæ LŠ}ûÐûc7ˆP5–á « ‡?­jFc€-×Íî€?Ù¤¯Õ ‚¤`ùÊ—–"à ƒ¬R;ò6~]‚Y$Á‡B˜D¸¤„ü^L’FžØ.'À@­ä#žŸX\ëÙ=¢Â"1Ð+‚Þ½ DÄ饒P –>¢Ez´ÿùX€8Å!½ÁoSñÛü&³¸Åîb¢q‘Œøç¿Çê‘I£{l…+«h%„+€ŒºÑ=D~”HGp–AŽð‹—à—EòJÀjÀÍKìa.¡ÙÄ<ÛÊÒ*7›Ècx–KšYP9¸Æ6;¤¦†°5 ¦²¡EP°òzвRÌÇ ø–Å^ö’‹¢b܉6£™‹n…sÕ«(£I¢‰GR” òÂÂl† ^-»£CPÇÇ> ¬#ä`C‚ <+ZŒ “<Ãs‚%a’•¬ š”F›5ÅŸÍÓ•À by ¤@°" «d¡%Ôó~¨Ö{.–ÿmE£‚õ-Æ0VÜ(ü~)?Qæ~*j‘ªŽ¹?3š†™ž¸ÑVÕžüd¶‰©Z±€VH6l(K¯FAˆä±›{,'M'Hžªnø¨vŠÊ0 Éôð]L–@»¢™‡'PeO&×$Îfx»³ °V­q…klZOɵñ_aHòòÅPŠ!ÈÜêÊцeñSsKÍàJXT½™s\o9{Ð[iræ®ÙÉ^SWïäqàõÈè±9@Ýc›ãÓ‡ppÌ2L+nÀ®¾óp #4Û#ж¶<W 4iØ|Ìr»ÓO>>÷9°jEO§ÜÚÿà%‚ä±XÐu±‹G' _ècÎ"‹C@]ê®ëº*U7-n—»ž’ŸÄ4ãd"q0ʧÞÃ2€Dc…¢Ÿý‰Oº ‘ÇŽù7Ái€LàonDf‚”³d˜uîi„nm¹ø9[<Õ[—Ó䘌òÏÆ¾ÔjXSÙ/JVè1tÅ,.YÉ>•\D¹hqò^ü Ü8º!¨¨<àj]¹RBC›r‘sdÈ3¤Çcy§8‘£²3£z9¡tYea›®Ë)™³GÉX,ãqÆLJd޳£ÚîÜùãÒ@{hgžm㎱ò RÿÂIâ ñçÆj/z­XQ±îº ÊPŽÚºQ@¦ÛªO¿µºq >&µ¼¦zÕ êââ˜,Xý=¹pgœ2bÙ[À÷®K*Ë«/e³ò (•6SeÊÈ*í‚„ÐŒXÌÑD‚Õ2Dx?¸AúÛ$Õ\³³‰(É­ÛþÙ=íYЏßHP÷@ÀÁ-’>Þ•t=1/,LOž»g9„šê÷hÁ=š@õS—Þ˜þÅ)ŸCê¾€ê¡>\Qê_žºa|ÑÃü*¾ÖÏT&àGyKšx$ÎŒƒx$®;iÚOZ‰ÀŠ$¦Y=S×—£²“­’?ée–gHB\0ùÿ|8!Ñ^çò¼TFÞ™*Pª¶°-¢áŽÑ” Ô‚÷#ú@ ]éîòŠõ–¤'ÞS7{ãÑĨnÇ¡¼tò6 öÔQ~ÒB‚àr}Ï눎Œx„¯Há‚ýþ“gTkÃöF œš*Žïå…0™šÒ“;ÙÄ5ò“?NÊGwýk~ %+@ÐÒd je‡µ„KµÌÓŽØÄMÜ„âNKõÓUO‡”úÊÉ $]U|`ÔÕ´@Ù‘àÖUÝÕaÖ¥ ×…@`Z®Ø§¡Ý=p€p@pð̓>,@lÁi”Ûy_ Î’aÞÅ29zÝÿÚðƒ ðSå¸GàUI; ÅlL\T¥ÇlP”=8‡qèÃqÿ¹€DÀ§aÖÉ™³ôLJ8é=E Å,º'Ñ ß¾üì ÅñèÊpNU¨ÌŠUXA‘¼MÝï•q ª %öØu]š€]íu% ØàðíØHÀ˜}@íi!?b2úÄ=ÈV?=Þ €!¤¹@qLBAðÊÿ9-@4AÒxP"ÉaP‹KÐ\ `›  댤é3F¸ âì¢Õäÿ åcž Aï…€¼‰à¨­ E¹F(šÝz_(ÉR‹ÁÒ®` d(q•X@éÁµâDÀßÐÝŒ$“1)aâ„Q­ÕÄMÆ#åáLTMnØ~D‘k¼¤PPÔ@¶Çðd˜„A^8A>GòP#BBÄR”´À7~ã=y J‹=Ø! zœ@TTZd Ž[P”@¡åÉ»(¢nœUD]½IÅ,Ýï$ ž ¨EA²-WWèƒLZÔŽ}ZÜ `H¥´/Å]ö!xÉ".øíÝhøÄmÀ²×ĤT4˜¤ IØG …’=ÉS†€ ÜáÔE†Ñ …ÿ¡=¸eèCiöääýFpp#hå exj¥1†‰m¤#¶©£Ú!BšuÑ= ]g†"šä š€#\у[²˜sÅ¥u]æe–¥0@]¨"ºâÛßœ§Üµ1Q->Ù-òßýÏÿ<ŽbvŒ|TámÄ‘dBEky'¿µu¡Ú&:ÁS’fO"„l^ =´A†Q×k6AR •ªDJxǘ Éki’…rÒ´ÀmŒÙoªÉŸ­‰=z%rª˜Ò±”Ì»IAJ"Õc Žâ(]—²uö OÉ ›dJ×¼  œ…^žÿš¾z¢ç+îb`^ßÍâG:Ù-ú]j”•õbº=À“‰ÂT>xçS^f ©ãöÓ´@›¥Ê¤ý¹€45î$7e ÃQFžSnh¶ïàáR _îdب­üˆ<Øcq~bY‰Ž‹!]’Ĩ¤¡å„†š$‰è(æà^mÀUvêuÚ8ÚF€ÊR>DÄZPä*.Æ“Æ+Æ`NÌŠàäa*j¤‘}ÞÈ]KȽS™–(ÍY =lf{<£›¢]›(uÁäéä¯Äs¨!çQ”1%RfÝ… QÂÌ!K8͹–Qƒ7"* †Ú¿ÅP&µÿ€ÔØcˆ]…¢qZqšÒÏ(Ù†?N 3ŽâMˆ¨<¦ ¨I^¡ê+À’tIBJÅAÜŒÀ]Šx ÜÕ*ÇBÆö&þxä{î]Hji}réb>§Pà¤)k™~Zk¨).?™ÖíX4Ò‚ Ä’´™ @´žZ¨ðeœ%wh(mîFµèý­YG -lfÝ7ÊÙ´j ¡Ï™FØ ¸«lÕ`î@$½1ë›ø\LVåÒeÍ/,â»@×ù B; ,½ÊÆ=¼€l_uÕ[½UšŠ%4‘æ¹¥,¹ 5Š€ÞV$Üùe]½ÝÆ~ H©-Yá‚‘¯†d–ÊHiLFzq)AÖ†ËúßËfæM¦©6^p‚£Öí,vÄA“-D8¤îQ²®±D;yÇ9Z‹=DíRY(ÛBŸEñÛ»}LÆPÕ$ÏU|b€-XýP‹ ¥ïM%ž Ûv'¤ ¥‘šL¥~ΠUîMž‹©ÕÛ¬ÅÁ˜'”^Ýô¥w¥FiŽáfÿLÃUi•ú],.ENŽ<îm˜™¢©Lª)3Ê_u6o†¡ÏRD/(Ë9a/ðÂЂëQ®®iá ÒfJcƒ)hb[æhM„šU&µVÏ!2žlZE€èƒ¯!ò¾ãwZĤ¨u§¤#™I‹1 E=W‚J[¤ÅÞn¬vˆõ]ŠÁýÔOá~†|îÞÝ"º¯ã0SÕ? ¹¬‹äÆ@ÀS” e§ªT¤Û‚¡,ÀȉÀ•øÀ%(‹‰ç-ð7Á °nw´mF.k´– ¤ãÔÊÛ¶”¨`î>Vó}T”‹}%C€Õ;×t9ÿ‹Á¬‰Ò½IQ¼£ âÛT„å‰%H ¿ ö¨÷´Mƒ@Æ^¦ç÷æÀ™'Àb_ ßIŽ“ÁH|V)žF_IN<ðÃK˜æð 1éSΤ<€£@j¡OðmT¦Cž[0‘±3w/¨ak%\Y‡lS²„ƒñd¦t X.Õþሢ]óV²Y ~HòPÅôr‘ÜXVÀ ¦ùŸÿ ,?Ï©æTÚ0^²Ê!ô¢XOBóËZ ™zªgà¾ÁñUESée(qarôIÍriðC<@Z¤4äYòWS°g8†R>œžÝ–@:g\I”Ïz¿ôÂ9IGÿ-7~#èR”u€^KhsJL‹#ýg³Faåx*ÐJK(òt(UKÅÑ 2W7b%—!?¤¹å=Û%I¦‰¥Š•0C¥ÅWJÛ¸Åٜ͢èåµÝ“vJàÊOÄT´,zŸ+³ïFýÀf‚ñDɤcþVîçBÞ=¿Àl¹˜Nv\é$A0‡*h¶@séz6-C„ÒC–XÀxÉLQõn$ëSÆ@Ï®8"Ž _ÕùhUïc‰ðq‹•n¬˜W„Eðæp ,ô"v¦Q*ÒÍËðÎK‚ ŠÍ ŠƒHÈscH..®ú¥§ˆ²ªyàP†E+N+_|ªÐÈSŽÀÿ•N>(¿96qàïS2«Lº£ÀêÙzÄ7eƒaä„F¨Â^8ó9 ˜g·A”gÉËqÇ–/<•Ðk@ž=Øqަ‰ÑêšE…ØU%@óÒ5âUÃÒAˆe‹YW¥ý˜~2óèWW¨ør­’Í<÷õ õÍŬºß¢§({ŠFRt-#á,Þ¢+Çghhjœ?@AkÒCPšœšut½,«¢i™)ÁÇ@Vfý ·@ˆq~ïE—ùD¸@þ·¹ëèG;˜o ÛƒxkÀƒ¯Çœ£ÉÖñ`)Uø˜õ6b¥b¸Š‰•ŒÁÒôÒó<'WóÞré^¸+w‹Ê¡ »çÿ¥©Q·ßêÃè8Gbô*ÿ¸®9Ž` ˆ¹8A°&“·˜™A²…@D¦…µkÉw(õ¬=lotøº¯_‰²{ÃP±›Ö³´Äئƒ9˜H³FŽTðSj¢zÒZÊkˆÎ¢W¸m·Ø‰c8†ïö~…»ÏŸØ!sø'Æp²rå³x‹ÛXYdˆÀÙ;‡ïu³ZvŸÆv/ÙúŠzŒÈçŠP•¡:È;vžyW~sÎz¤™¥™.y”{g çØ]‰ÆïÅ éôØ‹9HUÏu8Ê¿“¬¼ ¶Å¹¨VçAÖy!ëJtá[r†%ŒÉ³!ÿ¼ŒAÔ~ÑX)ÿT Ñ¡Ë×ü–g~h„€Lä^òåtÛ;Äì"Ý)™G&¡F›@.i¹¸V<(A” Â#ö e’0|>8öRlåÒ[ÏrGDZÔ=—syÇCïýtÇþ̽ÄÓ~á;û›Óô­t¨©®¼ „Z‰Ž˜ã(E~ržÏ×"Wº[>D°-\~»ÏWPZ„‹\ú\qPÄ/+Tmâ¾ 'J´XQHD|/Fذa‘<Œ01ÂC<L´tùÒD¼˜.Uzè°‚%={Nò¹ÈÅgz:íéãg)Ò£úò5Í÷¡)T¨öè Õ"D>{My6Õ÷«ÿˆªKcÉ^òáCÕYUªŠñeß¾?(H0¡Â yù~°ÇÈ?ª*ìÖ°„‡{Mäµwï^‹È-Z„Ðw‘Dú$<Õ÷YßæÐ›E‡­ù2BÕ«®8¸¶ª ‚Ö7ärjÍ y#\ëZ_®Y¯€˜Q£ÆŠ3NtNQâGžB22¥ –*[²¤93^™¼Vvè0B0ÏùœøteèV¤¤Ý|ÔiþQžÚ Aõ¿üÔª °Ê+­^Ì2ë¬^Ür!.|è²k¼*¸ðƒ ìùପ– @±{£l1Ç(«ê²ÌC L{ñ3ÒlûŒ5Õ\Kèÿ _`{­7Í~±m j\mG\hÍÈ(Bˆ‚¿‚ ZÈç2B#‹6JNK鼬î<”fòÎ;˜Z’)¦šVi„xìYÏ)Ÿ´ªjC~îKª>ÛòÛó)­²â“½¦\h«±dð,dK„¸,øÁCöš`/-Õ°0¿ìÑ€0{TXâ˜ì);µ²i쌳ÑF³ñÆÍ0ë‘V&tmǯ@( †3r·Ì’–¡&|¯'ˆ3Nˆf™ëRKè¢uî£6` :ìâA¦2_ÚV<™Vò€’ã/Y‚šúo+~òùŒÔøqá>–ºÐü˜Ú³ÀBMt,EÅBk­¸~h%ÿÒ .¨`¯¼6ÜðÀ>(àƒ4(ìS“§±RO¥çcMÓÇg4eÒ È ‡=ˆH¬ž´l7ЄÍQ%Cpb('ºRVªlŽK.'"ZZ/AºV¤’Äìj˜dBsjíÖdÀw Ðgë‚>‹¢° óáçÞÓFhÞ‘rŠ©Ïí,CËR­€í¾DG!½`á +ÀR¿4-ì„7í9!TcŒ±yn¡ªwWý¬da-íU`s„mG…XÛÕI™U63Í’dÙø ÷9Ÿ\|rÙ‡~îèi•£ÖZlÙ,Éj—Êô6ͦ楦¬ ï]‚–tû¿ë«/3£ŒœWÿ´<¹t_¯’Ôß±„˜Û¬µð^0o¹ 5¤Â ù²gˆ9|xS3&qÅK¼g È«zòÛ6“±F/" ¬Ô¬Ü”!ÀáQn€–‹¦Àg§YYWšå©N>ã‰>V@‰£Y:ËG”C‘/U§\ØaÉï̯;*iÚÖÄKY?ÑŠS–r'DŒà†Ó»!hò¤¯|lOX/ÄG–ïÙMQ 2”Xô–° , C›ØÃB¤ Gbì7ªJY‰Âz5#YÎr'³™È^³_`4­k]ô¹ÆE³Rh¢€ª6´À OÒ‡µ,€†P# ÿ”ÖEªµêìÎ$dz ðb"¼©k$±ÎzŒ4§@¥)îRÊeÎvz™ÆzûÚ³'¨dµEne¡ùÆ×KƒÑÅÀK¥>Ð> ½O+…™ÇÅò¡Ä‘11Áäü3³ôïdÌ&E½!å(7FÊᾜ4”ÊÐÌV5Ëã» Ä'´  MX=Ú`¡}ä‘"¡í>èî<¼[‰vz×™x2%åÁÙŽb‚Ô²m^¡Ïi¨wCe•m^ï:âõ´ÇÑ%‰@¯pâ%vi7±ˆEAcÑ$už0ÂRaÛâ¦.F¸{hŒDf¤Ì<†"³¬ôŽŒã Ac$ÑPdëÌEÿAF¬üs¨\Wèž”z0Ž2Æ =ŠàAˆlDŸI+a+)Ü`\U«&ÏÔÉm©$Æ+I<ôáËWxá²Z(IÒ¦£Ðu=`C—½R{mfˆÞ×’?3K¾‹”É[RXry¨BJ±miú(+¸œ`aó=:u¸&䔇mKÛk¶*e§¥‘'LaþðggCÕV…ÂGïT® @Ïx®N”]q£e;äŒUi ð„rWÂ\‚r’j/LÓ¸ŒG’”Ìk_;yÏyˆ{寮¡"}Q''/y ‹H57B¡ ÒÛ} QÿÀáÅR0Íl˜·B•y¨ Sb$p𠬏ÆÌ£¶m¶™‹h4TÔÖ98­ÍÅ~°ò¸S}xC@OýmEþE‡¦G>D`-á.„Ã…–¼)¹´dk®l½ñ·r¬éÚÄ:@„ €žtEïÊõêú™UÛ•®n{5š¼ÑÔPß{bY U„_ð¢P>øe+±° q蘛O‹MS2Ûô¦f¶¨äÑáÇp ÚØ|Õ6Šíϰ1¢Ç’™ž÷,3ÛZeå”9Qeüø¡ŒxEù`€¤sh•pÅ·ó§¤g\i;÷¹šÞÖ¸°Öc^ð#Õpâ ºØ=†?üFtÍ¡F_ç•Ýøÿæ"}âÆæ ^€¥P+•‡&SIŒ¿'`D6µÌd?&§Í6ð¨8Fd 2×´¸¬LƒÔ\{Ésà¶CbØBΧ·usUNߘÈUƒ¼}×àÁx3Z¬ô†ä—.ɦ€ªÄÒÀ«Ú¶ˆo5Qz:kúˆÇ×Ó­ðPá¬^òE•ïp‚È?ãµøGãVk9È-Çu})€ˆ»DÌðó #jÞr ¼?Ùˆ‹ùå™-ËÓ_˜‡vh2ÒÔÌH’JOFœ~¢œÌéÂÎÉIòARæõªjôPé\/ÁÀ#B’®Ò8‚h¾„iÊ¥$¼.ˆ‡ÀÎ%Ä#Mÿb‚ÓÌÃ\Îîkváëy.#^ì#¼>#âêΰä¯ÞeI%!R ¾rpÍã âÀ¢¾îë. ïR6¦èá gNæá4àØ‰%øì¨º~8‹ \¦‹8¨4ö¤mÿÌrz>O à ʲG!?†:õŒ.É X1>üÂâ"- (psåÂÌaØ'³ 0´Âb3þ¤)oJ 1Ïõ4€DV\ô3¨µ˜Âʉ2ò§qVS5å©OÅÐ(Ãg îqÎ[‘‘.”B×Q¬ü ñ-߸ƒi"D‹oìlñˆf²Oˆhà’^ìŠ&W)bgæR.5è!]ðÂ-°¬;%…HW0 ƒ0£0s+r™–‰(œ TB…À:Kòrª1ÆíOü'›n„m*ŽÛžÎ1n® L¤1–Ž2 /‡µã.‰2Z‘A#˜ÒSŒŸ®n?‚*ÿ% …JøJ;2íL¦†à8PÍÊœfNÔmø¤lL&^$,)Ö ÙCÔrg’ä~!×rM¾ä+-DN. ýŠTb¨âS ³pvQèÁbˆâ0“ÀFåþìO%#ÃÃP å†Ã&÷Å*äÁÐnŠU'M‹žFvdûPY×t©B¬)š5#À/ÔB¥uN½$.) ¨+MÀ„OìîQ\l¢Ì#ßQà*Έë¯\ˆ**–¸F]œÂH ʦL á Qèf-øU#/ñæ!` 3"f–€ÂL0Vþп¼pUo ´ä¡ÀÐÌò\¯*(vó@¢Ú†ÀÔTTdÿ”L[Q8êRpyæ ÂÉ@hBéT„رZB"[p6[é±[;©+­8EÂ:ÆkOÖ#–N 5®z,È“_¤DÖÒBâËj±6QâbkO ½öaè¿”‰`[î·°¦T`aáÓDàÓòÌDþP¶š¢ÿ|î3s{êèB Y…#ZàzUór45[Ñàè?2ƒöÆ·J`öÅtï|£ƒ*«Å¬æ +¹ÃC¿¥=é­ÕxlÁ¬Ê%LÎÆP+y¬gi¿‹Éà¥Õ`MYàäU—ÒbAꆱ΂vëbH‹~Awͳw“I1¯ðýÈLx—`UcU-oþÞ–§Æ³Oÿ2“ -î]ra´0 ÷çÒh{Ɇ‹òVSp¿÷ ïm|=Zé´‘,”ˆ¥Ã*'w LbO¿ãé·~5h'­sSè:ú·)žolŠÊ>61iÃëÕò+RÖ’0k/AŠäûÌ".HÎ׳pWØ,8„Í0Ë6w¯ CxTÚÖcV>)ÌrNó¡d|îç°¶@ly“'®7{QåLyò=ÞⲄ…ö"@“S ÅèNi3¹R(%Ú„;¼µ­^¨jtìg%‘sÀ&Í~úºfíªOØ®¹´‚ýà¬=zô äCÄ`Á‚äFØ`a>½|÷îí ßß x*Ì ñˆñ;nl"r<“' \à± œ;xf`‹§Ñ¤IwˆÇ¯€½¥n›æk –+¢­®×¶8Ñb^ ¶l2\˜+x®_¹\üúå"ypßmœD” a‡V÷x4Òy'Xœ¼Ç"åÊ”'–œ 9S¦Mõ4Û*4>Qø÷nÏ ‚i>¥>ä’€•RJ5–Y`‰5‚eE• he•Õl­öÿøpà váÅa^„ýåay…HØ?fØŠqöd“™àBd”QOf—AæÁfŸu šh¥•Öð?XÙÓZS\q%Â’M…`”ô„àÄ~NP¥QWœqÇ}™Ü—È—œ ¹bAØ‚cM Ö‚]¡%Zú¬ÅVˆŒ ×\7Èeb‰}y¸ª|}hjar1p,Öâd.T&ÙŒ–µ¸™žñh‹'>þ8š- 9ä­)ëÚV`A˜ÏjºöZSQ¸…e™Úò¢­ ½ðÂËÿ/¼ÑK¹E<'AkžÀÑ<,„ç=ŒÈÛ]I1¡T§y0íyONzòŸõÞ ¹AYLYEàW”FZ X’2˜O. _•=h°š> Ê•áwÝ5"««’hr«ry¢âbðSëe3ꊙ ™¹¨ã¯<‚6liÁz€‘Kñ£,SDrE[>F6µZúÄ“t>W6U¥Ôe:Ñmrà1n/E¡Ê¹û@WAØe„Ñ»,d”ÑtÜÙ[Òá‘·ï¿§× > êQD Z(ÂLåg1Uú<ØUúÒÕlŒ?ìU>QàG9~öDa=H""‚\Žº€©y©º*« vb‰¯&æÿcšÝ¨®•ÕÚë¯<ëI°Æd´M ­¤kKOK`T¿[ûšoÊ/”µ _áC/ª<÷Ašy4ïFï²Ë®=÷IøÞ¹ï½×Ôïù?õùÞß|¢t”æùI)ćõ‚™6Xù”½aΖUI+ˆË\V0*’‰¨Uª ‡ZPÁª´zÌe.8£é 4š‘¯tƳ`Ë$R–Æš"aEi,tMkNè2Í-Z²‡èqC†à°¹€Â¶Àõ­¯EäPWu.Â:ic½œ8>òÅ„=}BŸúÔ§7¡¸oNñË~ÂR¿ˆÍF³9PZüC9ÞL(€Ó\ÿ>< !¹ ð¸Ë9t:¦ÌT«cÀ€æ›ÙÌ24“] _ôAY…FX?a kT­¦T€5Ô’¡[¦^‹j6Ä!=ZÐPúÆj“ÖÄ‘"R¤:ò¢—Ú–è6î@Ñ^r£›Ñ“€YñŠ ˜ß´8(øi®QBÐã(uLˆIn*!P£Û h€-ù(B\| *RÙqt¦:‰Nw¢ªV­dcn# jƒñ`g 9óA`w¹Û]j~Ç,¡­F?ÔR µŽ'-ÕH‰-¡¼!«”‹R6ϼˆHš¦3¯yÄ $²”‡%Š‘xгŒ Ýêv<`¼d_OÚÿ0˜ê>ö ¦ÃÄâ¸2> @Q9~Ô(Mi²ÅÒÔ€øÑ¹P!P.©ëÐ[U¢<ò±­³à9!“™AF†ƒ&€Îj÷™`õ¬XÅ R쑚…ù®Z/«´ªuÖ,5³ uÂnrx%¬)4kÔ«ÈÙªÓQìhÔ#J”-§x§ÖDNãÀ/y9° ˜tN)™R”ú#±ˆA,SKÊMÙRin¬§Ó´‡>:‡Í¹„ê¨%"]Qšª»„nœ7hëž*Ȩºˆªq'V?3Ozê.H©)+ñ¤Òš³Ö†iR“–Ö¢CåE¡É)e<ÊÄ­ç¨é:I$‰ׯ&¾Öë–´,OÜL"Òÿõ¹ÇosOPH*>5_]ô¢Xùc<© ®™¼¹ A¢Ù„›èô„A•cÈÍn²ªd,Œ«ÆùG×ÝLR}Qmi×Ï01"äª#m´Ôמּäï¦Ö»ßan¹’+@N¼¥×¸`®Ú‚Qr"25Í]JìÎ JÀ.¶qÇáùk-e2E>áÉ''å€u¾,þ„È;HJÚK¹DY,?Tž\3bßä¤ ÆÐ€ :V„P- ŽvL‡îXº¿p3œˆQQk+øTÓ¨”q'Îâ)+Ñt`4[­§±8ƒÖà~ ¥QÚ€°ôÏH6åV+†.C¡Ë-pK‘nè>b¼J‰Êÿ’]á)ÁŽÙ%¯yð˜<³rÝ›d?PŠ]ßK*óL“-•£ò~úבÜd -ز¿TÒ–|Œ@C¡ÈÊŒ:ÔùŽ~ñjû˜à§Ö(¶ žªd¬ª™˳ÂÎ]î‚dÂeWZ½SM•„ëä#9"(‚Äå¼v?¯âšwœÇ5À؈l»ès\‚w¡mÓsËåIX`jó!Ù¼z;²auÙK¾•T|ëµÏnâ§Æ£€z ¸ÁM¯gâ¯%tI[ ³˜H˜l©ËFs©V‹àr:•Áµ• ]4™xv 4‹dd·IøgÔônŸÑJ ‡‰Û,}¸@`(¥åmï°IlÿT··¥)Q¾ª­;¢V¢§‚MãX‰Þ±“‚¬K¶¼=>½_6bS…Ý1v[çD%v•DÜ^ST>ç^#l§KŽð:à‚/ƒO0 ï#}é#'>!M…¢1»á=6áw‰àÌ@„^°Ý \À)€ dlvTZ%…'Òr|Dq+¬óZð7HÓö"ÖV+ñ#:B>³$äm¼E4Ká=Å-ÞÓ4›Ô\a€®—€íö Q=ȇ耈Ôec4ö.öÒoð²c0‘KåS7å!^xòC)H §ý€‰™¨‰™¸3Ø~g&‘_x·jõ±ÓÔSX¢e÷0 û°‰¯Ø¢àf£U*æ'ÿ:ztTì—°²03qFHdgVeUö—H<Çgôt†~Äphz¦×Rn1 I×-¬GiÏó +{~(³‡{(6 ‘{µi›'ò0@ˆgƒpö‚>ƇvB–7•hX”è>Ž‹ùøáåw£Xq-Ð:ˆš%MÇ•_÷€ù¸‰˜ Zv:vtT(…¸¸l+~D+6ò~ïÇA7ÓA˜÷~‘$¿Âs‰A}öy¡ñ2DÒ†g…9J1-ü n[±zì¦zâ"oà6({Ò£ ¶'D—–=3ÆiÛÃQéè.%P-¡N´/!•Kæ“RG•8‰îCO€‰à` _ ÿ–a‰‰:ðýrƒu7Šup_=5PàZÖ—Øai—€‰Ð™rPx‹H¥x0—7à2¾X#CÂ…7r„mP@Œ‘Ѿ’góÔs\õyû÷2¥GhohCmH-O£tŸåŸ%N. ¸`#²ç€S'6Ó‘uDIpèØèi|U>#˜Qy7H0Dápô˜h þ`œÇ‰œ™Ègy–½VŠN6sN [–‰È‰Ñ€‰@ð„|™x#Ãf~`ªÕf~„‘¿x˜¹`4˜‡m‰gø—Œ}††¡ÑÃÙÑRP‚9Ÿ3Y&¬§zøuTW®”2†ÿØ•]lbc4æ&ï•ðd¨pCqd¿I0ÃY—؉™øŽýØk—S›Åe6¤6q jœÚÙ@`@Ú$2Žç—¶˜‰ƒ¹Œ36¢‘^èN7ØÙO%©Ufx†@7+ÍøŒ%¿E-P3š£YšúÀ-ìö íV _“‡ó¶zCÔ¡Öu·Ù.kÚ3Зc)q/‹8XTu3Y9J—Å £Æ©œ¹äw¼†CñpMM<µY- N ~÷¢0*£@*d`…12ß©r}YGÎFž¯+„9è‰,”ïYŒîùcxŒ=âm®Ê¤$Ä[ªaÿzPÂa’$ÿdÇH[Õ°OJ$ù±ph«‡¾ƒ1ŸIVúà4N£tâMW&CB¦Mä.*/ä¡âÈ=ÝÁ›ì!R>¡óày:K66Û­þ œ9Ñâzƒ€\À ®¸‰DÈ0<…¨F;´Ì€‰ÑÀº­Ûºê€‰0Z0÷y¯ù:É~ã„‘¯…˜[ÛNÁK#G¶ñGœ1™® «#”;XËFÒR2P2¥%Pr\UÒŸÃebÿØr%Q0DÈÊWg§OV]9Q‡ÛŽr¢›yCì²ä*’x•À­Ýš³¼¶Ið «›ŽP ÓưÿÀšx ì‘YG¼'RÁ(R»…‘…70+#€é9$ļ"²¼i{ñm+?Sª9S±QbešcPÚ+5Ç“â3ˆ¡F%Ðî0·‚wÌw>&Q °ŒÖý ˜ÈÖn]¹ÇÌHÛJ»Ñ­°*·Ì{ÍÆ®BÒpÜ´âÒ¡ÚÁ/ÃÒ5bØÝ]ˆíÍŽq¼#騑 Ù<t²ò¼ÿ7zœ‰Ù±mÔtÒqŸí]™›¹f¹/7ÑYÇe¬êè˜Ö”ÞHf/)¡ÿQðŒ^|Ò7vrcýjïsÖ0š‰ÚÄ]¹‰¥0×Ç)£¢@­"Ž×µûÑn¼Ô]G*n©Ñª~dN©Ç-Mãí$¤šÁ؉Ù;.ÈÆR’ÉòO-Utk1hCÝÙ‡ÔG\/‘¹sÚˆ©íšÏÕÒA(+'LÏŠàã!Њ8R}bKîwBÐíÑÛÊИØ_)ÑÝê ˜8 £Ûù"îÜ`Á?ðloŒ×Q sÐ,Z Ì‹½°Ýí˜ßíÒ‡Ù"œA¶;SÞ<žÓöÙŒ°,=}$ï=/G®qIN'1q-kvåÛ‚GѦÀÕ“.Ðÿ” GpZNëI¬EL'P„|;2!xÆp^LÖ¢›ø Ý:¿œ‰êЭ €‰]œ´*£aâ#®ç|Ž©#Ç…ÁâÔÒ@G Š‘Ú­‘†‹Nã\‹˜›`³’g<2éí¤ñ ÕRLaÙBÓ»GÞÙršÔúBzr'‚·Áê`¯vWmëµnQD)ß³ýĶ­e:A^èaE¯¬æ¿½ºº ¢Ô‹ð§&ߪ;í’ºÑ+Ð ".â~îç|^â,îÍ×}‘¢ºÞ§Êèë¾îÀ+¶‹]NòÎÁ-ïçmé10'H±4= ½ŠŒÙm?œ}ñY¶ÿäxJ‚åÑ0FF†€bÿðÀêî‚ò€G`Qh |tÂÄÞUX‚r{â7Ä^ì¾Má°Øêà ¬k sþŠÑ°æ-/¯˜hí0âØNóâ4ÒÒ|©"?@G/Žè ìÝB¿è쾪ï~µžÑØïK#`çQ‰òú1Iô3h—=PÓ´ÙYžý¢ljz¢ÏhL†ððëÀðð/À®pjÊ/§WÄv’¾(I@Žà‰j­÷ÇŽ‰\YƘè @ò{¯‰ÊÝÖó2Ïçïÿþ9è¹[ݤÒÀ‚ý£AšîßÝÒ¡J Œ—ÿ0ž‡ =t€ØÄ‰%R´51žŠ% oÞ‡|$KÚã÷_É“öì… go=zæi8q¢EÎK–´X"/è’{÷|-Jtß> 7´¢€hˆ <.\2„‡Õ!(âQ¢ yòÈ–Í™–(Ò¢ú$J€Àf:`ôÛ×ѽ»ý¬ùXpÞ÷ºõÍ›X]´Ü?œ/äÀÑð†AD¡ÕæÍ?"xް ô¤EoX°5éÕ©0¸qƒÁÚü Ä;XÀÞ@P|CÙm¡BÅiÏîp#â‰ÌZ/Æ=EÚ#Y!_Ê|L~w ÓMš'èé̹D§Pÿö÷„²½×Äè’¥76ßø:õBÖ! ZùOà¿ÿ¦r¥„#ÈB0¨œä9A¨µ" ¨&–pdÉ.Ä‹ðú‹2ÀË1¼Ôù¦j˜Is*Ö•mL ¶]{­À¶ ´fÝX—r³-¡†f²"(t衦•ëi#rÈàº>ðNL«·çfã[ïÌrË3Û¼œÎ£I…˜òA{ÞÿüÃ×í?ÿœ{ˆz.è7,¼MÔMƒÙz¯É=¤F2:<c¼@‘p4Íëý+GÕå* Ìh†s¬*Mln@º•Ît1CDêR¢q±.X8Ó nøÁ$~ÌÎÈt7%ç0¤1`šÓœ&#@$ôÀÚñ–§¼äÝ,É;Ó à¼ñ<&Ís‰ñàE¯ÿü ^|zÜôÿ%·~o€ÞÆ’¾D‰íA÷h_?à)þ¹ÏS,ÂKPD :\”KŒåúìèCäŒT2£@˜9å£s'ꈙ¥nxö˜€K1žA¶ÎL°‹ÇRÂFä!xdq¢d`)Kû0ÂïîQ‚ëU$_2‰ÍpˆCå鿆0¹aLÐô’ˆÉfÐÇR¶>Õ+‰µTâP]fÅ€@ ÒWy¸G="@¨ú!ÆüiŠß(•7³EõCû_¸ÆÝ|ÀoÜL¼ôñ Ì1t±qÍ^¦îª#¨ÀðÉz2bõ¼'= Y€ `ƒüð@Ò¬ÿçH’6IãG XÐ;Z $œÄZDg8QRÒ†;ÔaxjØ|¸Ñ"p,Ap¯[&Ñ{¹db¿úuW˜ïLƒƒŠ‰”¾`³T¥*cÿИo˜ €!Ã Š… ¼13ˆ¼4Ç”….vtgâizΣVÅê<î9“zR•uݱM¯„F›Ù‰P’U²Ò´Rø´‚D[%E•‡°:Jûs%bÝ mNXÉDwZ…ûÐÒ=´û¹–Äf$YI’‘—í®zyú“ ò1åî£Ê¶¼2Jµ<7^rÙ®0@_Y2³˜:léH^2g¨A/KðlœmúçE0†1(lŒÃ'òØ óQDØ1euÄ-=}‹è†V7p1Tü‚àâ-¸Žt VW&~$Ïf™Vëàíî€ZÔ7Äá‘‘Kˆ‰—òÑs»&6ˆ(SŠ›Vp§_×éOw7à=uyÃøPXt>·>H°«Xö‡~šC³[&â³ÝxßZ8¸Ð‹CŒ:¡nï(•ñžX%Âmnú²/—} lÁ@“ÝoÊásø~ÐÁàxØcÿ¬Ñ50!1\ª‘—gZcÀþà†5ÀóþEÃÿÿ÷¿Æë$@þIø€&8›¸0C €§ð‘:r'äZ7-=×»® tšßù§Ù/yƒ¬’û-±(˜±P«—ò@O{P#Ë0W;²¸b;â)5RB¸"¯((€\ˆ>黲ïÙ8ðÙ"äµ]Ò>` ‚ÀcØ/,  Áè/Iñ‰n Â-äBûéB¼à·€1œ }hûˆ€4ô‘Ó[yXº‚kºëÊÀ:´® Œ=¹ :ë­Eé-8Ô³µzüÀ€Ø.ìP¸‰"µ##¥ j¥V*òÿÊ+t;»Ã2ŽÓµ"T,^Ó¾z0XB³ðƒÂ{CG˜Â-„½x‹ø›&Ð/ÔàWÄÅ/t·ðEUF Ñ íÊ ÎXC;â£Õ&†²CL2PËÀg|:;¬.x“¬Úã’’.à3Ér 0Ä ‰ð#µªñïÚŽ"›+­!¯3¹«» çÞÁB”º²ë‹ûÅ$\Â<k1÷€`Ã$p„‰™B`†5†üŸ ÉGÐJé‡}€5€0 CXƒ5x‚äÈ'x‚ŽüH’TI‘ƒl1C¤˜á ®àœ4tC{j¼¤g´iÿlFëú:ì@R40³:4 ¦aÊC8êúQS%–8µäKµTs%ä!%¬É!—À¨—À8ŽÛÄ,+B~̾]J€_#Å»©·>H2;6„Iƒ ÃT ŠY<Š i‹à”ôÈ¿ôHºüK¿̺œË_䀉Tíâ¬Ø ÿ8Æ¦à‡ Ð³È¢.P{ºgJ¡ Ê $»êR4y»Æë¦ù=p4ÍN ž‹!ä “† “u¬¡Ù<¥®¼0&;%šXŠ\ÂÄ’›ß4Ë}é5.ãµdË@Da±Ébš‰I¶€I_|ÎH ½l‚9i‹¾äËÂ4LîìËïôNîTÅÀ4 pÓ.ªÈ“Çÿ|üˆŠP¨æ´À l=ÎÜÌëªÏid«D›½ýb´`Npì´Ô\½0â#R³/Iµ†K;ïP®¬ *—ÝÌ¥{$Bà NáDB%,Eï{&œ:ê@Å1l‹ ÆH9˜‰t½äKÂO<ÄïtÑð L2 ­Ú þØ—V‰ ª`„J;ÌlÆgìÌi¼Ï¢4ÊDS±1PÚ ÐCÛ¤V›“ÀÊK3¬Ü(n‰» 3“Tzžñ Ðù B#ÌP¾Î$ERüPä<€AÈ€j!€çœË} ¸°NY”íÈíÎìÓ¥QïDвà0­hÌVè“ñ CßjNÿBRj,ÒKÍ$$]4¦ùÏ#PO3ÍÕd„R8“Ь·½ê–©‰Ä“ȇ ½ÒM[ãM1ž@ÙÇ2=Ó]RË%üÇpÁsÓ©ƒÓޤ¬˜œN¼d—µPÌ‘Ñ> Ã9­Q>ÕNT•{Ø y¸*EÕÑáŒATÕC´û¤Ã;ÄÏs Ji,ÊÐlšSôÏß+ÄDв¸Íá)ž‰²R1aÐOÂÁä9¥¸ =Xåš0Í»MüÄ@ÑÕðAÂQ\Â8€ pøÕa#Ö8ݯéÌÖµ`Ö”‡ëÌÎÌñ4Ìñ„Ö“õHi­ÖCDÉ¢hyxÈ €€­¨þø“͘ ˜ßÿ›¬øtšKEW¢Úk¡WNm&õOýlx{Dd©¹™\GT½J¹Â¡ÚÔ(„#—³¬ù:Ø[ÅP…ÍÐ^ë%Q4ΈõÕxˆµXðƒH•K`Y¤ Ö ÆÂDYî Tð¬Kpk²Hä ‚­¹<WAé (Z7Ù£Ô¢FÈÆßAÚ¥õTp¿§ìx!Fd T­Ú+=žˆ"‰¬ÅŽÚ<%/ Ëêóͽ»>²åÇáô5Q ‚45ˆUÛQ,Ácο1HèD¹î”Iß5Y¿$Ùñ$Y•ÕÛmQhu‹²Ð*€„Y€üКÝÄ ?”`ZR±Ë¤t½CÉ5ÒL}:¹¸ÜËÿMÚ¤}ÒK45`)UнÊoáAÕÊ.-ñðÚ±ôÍ}d¢\ýß³ä%$D[(`Ûõµ­V.!H’ýKç”Vçd‹º}IþËßýÓ•å€9 Ô¾5^m} ›ê%á%ô;^jÔÍH €"ù=¦«Ã¥ˆÜt-ZiôÏæ4MpôÔðÔÓdAëÜáA²0ÁÊ~=¾ÚJÔ­Íý­Ð |]²ÍU(¶/ÄÍ“PE.C`Ö¾Ý6Ùà9ã ãÍÖ‰ŒÅàhõ[‘m^AMYóä¤*Îa›Ø™5€_Cá"Æ}Óê2Ú?®aLÕN×BNßɲÆÔ ‘Ю)EÇu„dUÿ5¾åÑ+åÊ¡YEØÄz]]òß'NÙÅbF`íËŠzˆ"ESãæÎ9-c3– FÌMågeYæõÈ ( €¬Iþ˜ã‰õÕ ÀcÄݶb×Ï,Ú¥PfLÚNMæáhFMo¾ì Ïí–«Ý+US5´›Z ÓþÛ²ää(`´$`íe+¾Ù¸¶ð ã/ã_üW¾ÎëÙX¦Ž®Ví¬eçåÈj8Þþ¨ˆõåÚå.S©ìeFåpR_<$Zð…==t1ifZð{áÔô@³häá¡ÚTÝæíÈæŽâfåáRýÝMNÔd\¥éNà…euÅúÿŸ ³/–‹zNÙ˜œÈ|މ”Î0|ÉÄŒÎÁäÓ€¾e¤ÐåEñň%Å`Fá¸9™!ðiDÞÀ‹ža&ë¡_c§ Íh–,µP£ä­bä ]”^ Xs#Ð¥d1É+ÕµÇÞqÖ»±5K³`vÖ>$Tl­°XŒ¥g•eå2>ê|¦ì Þç –e”…ê Ã0ƒ¬hÌÍñ<5›å2aæA10›,J Z–mfk%õÆË]ZÔ\ÚF4¹`dF0é#ÓµZXã+¼ææQJ%0ýZÁ¾U³ìdœÖPÄNìÄΓ6Œ zã žìÊ6jXÆl»…e¨ÿæÎî¯Ï~šMOÙP‡ fñé—ïÙ Wˆç˜W"åLÉ-kB35ö‘7[~4 ø-1V2¼Npsqcøói‡yA·vñ$Þãÿx¬ó.Öúv Ȇíœ ŸêÎc\ýWp€SdߨÒw'ÚßÙwݾíO õE«r7ß{x?âµ£Ò–>>rd¥ ¬„žxˆ†p€‡Wû¶G_o{¶—{Qtü~0¹ïu¶¿õ^Ùýpá<€ȤÀñø( A§öøš¯aqȧù¥¾ö¥>^F—Ù{(ñ ðù<Ÿºmèì#üÔíu×VZ?ŽÜΤÃͬ=æ\Ú3+×íÓí?0®à¦ÚR{JNÝÛ<ó}Hhˆ_{€ø¶×û@ˆ}~^ß{û„~d¨…QÈûëÏø‰íþ¸¿u:ggÅÿFa$ði#ÐsbºÎ˜Ÿööüö§ìð$ïËY⚺8²óü —€2D+$‚pH½ & Ø*A sÀc£€9ö} r¤H’û@>8rs¬Œ¹ñH‹ ¨Äp$#Ë-U)1„F%äËg´B>¦F“~€štêT{¢Ø ‘U+½ôNðåÀØÈÌ+[6mÚdÝŽ5À²±j=ÀûC]`tÿ: \¯áàÂ…;|‘!ƒ ÷ä5i±¤ec”5ÐkÑFCz[X¦Üdt¦O›¾§uCÀ~ÑòK#9g÷"!­ ¾ÿ"xP!á„Æ#RRÑ¢MAnyò£t‘Ô7ê\™±&ìÙa‚§©‘eL›>-ÊhBÑH‘Vˆú´)ÕúR³æƒMo+½¯ûè"ƒ 0gùr€g™å‚ F—/gÉe– ¸Å×äÅ_7˜C†uˆP=C¸òÜC™Š'€–YgeæYŸiÐBdM¬fš®ÝÃj)B AAÈsb´å`„XôBo”ŠAAÄÐBÈ-TÑy8½ä‘HF˜TÒuÐá¤Fâe·“N8éÞJ:±gL*•@B D%{Q)%UTLõÙgTØ“=ûõ—h'ÕãV‚9 ¡¤ÿg!‚ºUàXuµ©]£dXW]!zb©W–ˆÁ -ÄØfšÑójgN8AO­³ªhãh¨¹Ödòè¸#Š/„ ˜ÈÜ(¹äЛoI9%U^iP+¼°×xùÔ—ÖMWîH` Ôš,½$'¸jÒÔlæTžJ¤‡gžGŧU|Ú—Ÿ¡°e…¨¢'AD×àY'…¾ L¦™:¼i€<€LÇ Öáa§'P-„€r­.²\+­¶Òz«f¢Ö£jªåÚ°#-9ÄA¼I’JîådCY[BÇ=ít=ÐÆÓMÎyi’Öcb—SOÈg”“ÕpòçNG¤”f AÑIžìé” ,U~ödU°¢ ,¢ 1Ü)Ãn]jÀ”h@=/îhƒnÕ38cD¤gùBCð›ç!¬ì2è¶æEé {•Y®5s O óÌÀö¼Ø  aÈ$Th‘ѶaQ´KAµS&t­ò Pà ÚTÃy»)iº[UïKñbÔ¦šÑ~LôE‚ùA”@ô uN`¬ûˆ¢S€èTQiu衊ÎsR@!ù ÿ,éÿñHp Á‚*Dˆ¯!¾Hœ81E‹?,F|¸¢Çµ$F¤HRb*Ž9ZÀ·rÃJ .Yn`Is%>!sêØçA‚@u6œ¹¡¨'O tXê¡©‡M¡>êTêÒ¥¶d=ÊõèO_ÃvMÚa„‡üâP[ ­Û¶öÞÚ›;—^ {ôì©°;ïļ¾' >Qb^ F%N\bß¾…!'œ¼°ÖÃ3jÖh1$Ê")^ÞˆÑóf“)Csij¨k˜/‹ÂlˆSèN†:q ­­[Qמ0ðÄtªÕ¨T;˜8~µƒR­]¹ŠK=©Ò²ñÔªµon¸à¿ÿ·EÅ\èc¨¸ãDûÁ‚÷e¬˜±cÉ‘GéßÏŸ²@ƒQH˜•d‘€aTR?0XÒƒ%ˆÚH?là …dl¯Í4Q¶•“n$:T¢n7åô›QdwœqOYµ\ŒXA7œW8ŠõWÏOTÀÝp‰'ž^æ¡§—]hƒ“‚±ƒ”,(ÆB U²p¥_YÞ'eøXö“P é÷P–ý ‚ ØYf%µrt"B!Ìyà rNä`I–´À ,°'‡ŽÔ …ZèZQ¬EbOáÂSn»áƒ"ˆ®%…T̷ܨÊIåTŒ¶ÑAt9R·ãQdÿ0BvÝÕzdxà§äyOÂX•‰pËbõY©% ÷ù„&AµðÙdÍ:f*k‚¡flþ çˆTà­!ü‚ȸyæ¹çžr¶!…7 zî7È*+"üÈ«(¢ l8[¤3‘‰é‰ Œ¢N~Õ"UÉÍXêS¤·Õª¬R'ñ«-ÎZAvCiOüà ]ºîÃÈîö}†qy°„‹ìc=Å ™³gŽ"fNÀe_ÒëgãˆgÆ0Â11“™CòónnN¶Lç-£m0ôÐÀ<I½„L/åA$]ÚHÉ@U Ì_ôGÿI{Üï} ?èq{ðƒKÛ€oRtÛ ,D8\‘Á„ó6!*T€åzÀQÀrNìŠÞ(†Ê©) ˆ!ê,ˆˆÞµÔ:½ƒ×¸nÐÒ—îi\ÎD]>×—ýÅÀK¸‰~ìÈ<†É}¼!hê­Ù9Õ…OšÇ&a×ôXÕªP(@Vßòµ¨àKX‚<ÄÊ‚%˜,/ö«¤=$À¨2ˆð@=ÉP蕨”fôÌ&Ñê¥ò¢§Ê¨€øã°‡¥F0­!É<è“UIó@!ÇÇThÕ–Üãc=Â=Ä:V¿ü³~üû" … |pi ðÍBÁ漺BT' ¥Þ|X•ö>¥GTbç‹XjØÁˆÝàÊ8pP8T˜ÇtƆëá,8 ‚(æÁŽvÉp^bÔBDAZÜ †~h± =<",Ãú![eÙØŽÏ2“ˆrò ´ÂN§³àÆ:ج q+\$^vëZ™ÀË [ìqÏ玵¬c…®YÃ?{„€Ú]ÁVP}Ðt Uè'ÁöPQŠMÿ¯&ÂÉÚXc”õZ‡²€õ@5Œ(_úú™Œõ ö K$V¡üèF¡‹Ë 0`7Ð>Qè~ÈÀÑ«Pt¥„YÐaÓýÈ@9¬f(>ùÉOæ¨,†¨IMÙ“!Ä5kpÙΊVË3Ö^»ÇIL¦š L@5¶|g׿ ̰L]yø¥’`–òÅ´lHµ) yK‰¢»ž÷¡ýŽ‹s*§À·0ì|©ÑjÐ7Fd4¨û1Ì–,`€fÿbk n@½ (ÿÔÏoD8ý°—*SBÆ”c=üt*—â'ÀÌCòùðÕ.À G ‡yòmObU zM¢Ãe§V¾Âk`UV­ws9'{ž„m¶g^¢tWz…CsV0v–ãâÐ~ôu_ý i\×u}ˆ5á7uÐgƒa§~ôåƒF$~‰U_|ƃãwDÛ0_Ú”@¯ÕM£jqù7'0ópsC£y}ñ7P°ðÏu—wyŽ ÓdèQÆ@zW¥$êD€Ñ«gVX%ªc­`:^'Xtj³W¼·{Ã|ÿc>eá^Jp„ôuDi o°Ôg=Ø}þ`ƒHˆX  ~ Ð~êÇnôe|ýð‰ó~ć}í6_Û0XóÕ¬UG¨¶@ó7‡…t¢T…Á(µ#ðzøEa†÷ÃÒ%] ·†  x0ÄhU¢§(2N²IíÔêÔ$R%ͦyÀs fR·ÇˆÒg!â‚dñCåÖ“˜Š•hDp°$F ­¨ KˆXà÷‰p_4ЊþÀuÁ0_Ø0XêçQª¸ =@vèv}€6|óE‰ã—Me’c¸¨c¸h[§-åÂ…%@¶3"H-µ†À§€÷ †Í¸†@,ÿà†CÐ]€Ns¸£W‡M²k߈Nó#UH‰lY€ó0ˆ”À'jÆPl6"_ÓfÿÒˆÀQ=OaåVªxDp^·w5ð„©‘‡ÕF¤ óu;ˆ}¯ä–ˆuYuÛÇuv  êGƒPÈp [•a‹Á ·e.\¨If5ù0>p“ (] èŒp“ð!0t"Ä3‡Æ”»f š4”߸N뤇{‘?z¸2 €AðÓ¶]3a‚¹ÇmxEtÞ†WµHç^MQ²8_9˜Gˆx÷J{‰ ™–öèœÏyXð6_£øƒiù‰ÕÙuWljˆuDï ÿdc|DsÂ;`2 š*Àžpô €2ù\kX™7y“pA0­Ð CsQ"gšàxšyhô€V¯yU€Ðh'tE•‹(X©{¾±•wæ•p㌦~ìgDRç ‘a—ë¶Šjéà*ÚÔùJŸo1jDL×~}_Ä7[þA…§M–qÚÒ'ÚиG6“ rô錘y™0<ÀŸ­`ÄX1@šMRšRå$á¨zˆNv!?tq- ð-Úµ<µI¡Œøfº‰^üâ/‰ÁçüØ!šXÓWƒý€Ø°u3Ê¢l‰~óÿ­sY}, ~5ª‰þ@ w×ÝWhPÛ$žÝÄ‘®f[ê"p%€y"‡ÇÅ¥ øq•i™kÈ@«™ ýIúzqu˜NCùkªI”¼úA±£p@!à”r)¼a@ŠX^àÖ{|Ó§Q¡Ãé} šX,ŠŠý°Î©Ši¢Øßélù ‘(zƒFÔ}Í—£vv }V(T­–@aÒá Ca†pp“K€UkΫÎh«QJTš™@´G²£¥™NO2”!K¦zˆ ¬£ˆ€²);Bð ÐÀ±ÛE S§••ÿz¡a1EZn&@hèÊ„‡µvŸ85ÐãÚ¢,zX¯¨„{WŠœ8õªiÝ Ùœ6ŠXØð£i‹úÁjÎ’-|ôŒ€ ËæÑè¡\°±J«¶*«Îø ±:‡öà¥xUêÑNFéNyqkÕF+@-‹ fŒúÒsuE6ºW¡¢Ô›¹Ô;Kåu@k~GÔœØW¯ª}ÚgDv@„ iÒI£y£¹wÙjøju4 È3"±7 †9@108¦—¶ñ l[«6‰yN «—G¥/ÀŸ°pl¤×NI²A ƒ¦p…+ fe¨6  ²-¹2 ·i§‹ÿˈ°)tV“Å­&ð§ýPš{©Ÿ ºÍÙv`¢Fø‰Û€ð¡aÇߣõZ£îJ_ßW’Z‘ˆµp¡9õ·–¢±"! p9òÀ1뫤·*`Ÿ¶ú¶p›™°±Z¤›„í„H“H2„;ƽe8fü 5¼]…Ò½sjC£TtÞ†³_ñ‚À|PÁÊyuc'„°„ÄÚ`ƒõu)*£cWuŒni‡uÉyDmÇQ9x ŽpDPwÌw„_—ƒV tT…ë9£ ±Û  CA©z»' $íV«ªÙá»—y™ ,«Qú‹ZtUΛ$Ïÿë>¼Jù ˆ &f+ÉúàE(+9 Í3&×j•Ó£­õWÜ e°Þp¤‹´…&ô@üj\ w°šTp¬Lo‡j ¼M ¼È€" ÒcÑ \ÁPö$Žš„}¼À–I¥A ?¶:vˆHÏ»+äA/<14fãÉYÔ:ßu>àÍ£{Q­7›§AŒJ1H£â8@˜xD0 ³`Lž¶hûÅ…V )ðôp DTiÝp  ®tË÷VÆ Ï…ѯ„Ëy oñ…£`),±‹Æ,t|™9pY€‚A”ÐÜ»¿KÍÁ›òÿà†úظȋ\8¤E‹„>ÆT àCmÈ6ìAtù€²bÆÉîܸ¦D(ó“»¡ ó* )°Tp`5"Sü@T) ƒƒóÀ rÀ Ýl€y {sÇŽàÃ`VPb ‰0 €= ÓÅz|2×a• °p“ úÐP Ø$xDuÙ·8§.ÎzÌJEÁ·{‰álúD”êñÒT&2m“´š“±³kĵ[L–ëƒk#Pæ#ñ‚Û>À7 ;Y;eô(›/í\³á››šÂ)9Ë^¦|O¦ £Off1B Ä4aÄ1ââEnÿ=©F$’S×a5V…mÞAšz̶ëÝÞë=]ÓÕ$N í´ZÀ,G€IGqêÂGOC€90¥¤Ð”ô{aUë±OZŸôi«ò@”Ng[r\%% ;À­’æsÔè³ öàÞ¡E›gspu )xêÎX ÄÁñ›D<ݤÝO&W”¥’õB/@=8Eó;s1o§@yÊvOzÌ€ì=ØîrÓeÞí ߃}tM’,4Ó‘?¡3WØ \Î .YÇ¡íl”” èÔ·ò´ßѯ €Øq"Ç[¸[Zd<ã±Au>O¸SY”NE Œ©á¬3½\ƒ‚t*gçÿÕ›\YÏè+ÝPÖ•ò2.6üK>îE\TůÄD.ŽYæql«ä…íq¢ßIîæ¥I¦Áj qĵ¡ªcû=´×c B(70j(9ð°úlèT?îó1pÞ1ü¤Fü„ ;n±>p½…Ô ã~ž d ;é´B°H´cf2Û/ÝʶA^ãn·„Jòè773rã#@E–²7lö³:g”By ËFä(ð©Va5êž^ØŸîæÏä¢Nš¥™Þ`µZ­ëjŸÑŸœ=ë{R,@0àõYàýäô”ì¸ÖñÁ…>p‘UZcE¼EçDÛútçÅ×#NPdú1ÿEDÎYTÜéè<ÛÖínV0A ƒ¥LÄÃæè#€²5l4086\;ÐD]ÖÌ÷ÄÕT‘~Ó¢žäýþ\ÃàŒIõYï«E®Ç«î‘ùT¶5'ò @’p PÁ~» W]ú¤AÞQÛ¼d/7àñWÆC+”)ŸòïaÍ ³‚>-¼$÷Ô'ÐNÐ-ÐNÀÚHÈzÉf¶!b^UYJß›§ëåCÕ§2R*玬_;¬ÿÂÄóÓÌl0Ðû€ƒ±õ• «LþéO0Ð00¼–rüþÞ÷`åÞ[$q}¢.†Rq%`»q¿°Vf÷H*U>™÷ÁÎK(Õ÷ ÿ.+Š/W´EZ³ñ`Ãa]:Ùu¡NÑaÕdÊzð•Ü7}Ãb_£Ü“¸6à¸ÁàO,ôà¡CCˆMt˜X‘"Ä ù>läȱÂF{1ì1 #Ƽ'XÀè×ÒeË}‰ä-Yrbɽ{äÔ‰ÓçÍ{,_º„‘ÓçÎ4—Ì”çóÞ¾}£ðIEµjÕ©RñýØðãG+ nüX@ö†¡ 1Xè£íNyLi¦Ô0¯nÝôTØãÛ÷C>~üñ1Ba^ü à˸¯=zíå+X_àù Ó;Ѥæ‰J[h𼤅±øÖ—‘ˆ”ÄWÛ¶ÿm!øpÝÞ½Ûöî‚xZÈ0¢Ä‡M˜ðÀ¼aàŽö@~ΗžÉóæÅH™§åƒá{Øiù¤éLGu®wŠ“Àwñ=h´$ÀÁ¨Ñ¤í}BÚŸª¬¶òꇰn à‡ÌB‹‘ŽhË­À€…”*ÔîºÈBz̯êøú€±|(Ël±ÅìQA/5P15zæÉО¬ãÌ&¥f¢©‰ŒY³ÓèÑ ²ËD@„"(è6|rÃM7Ú„ˆ·Ú‚3(¡âJî¸æ"¢è"FŒ#騛 Æ‘²»Î.”R’¡¥`üqÓŸZÒá>õêco'÷Ö`óMzhÉ£8°Oœ–@j'¨®ÒÿÊ*ÿD0¬Üà† aä„#ØŠ0‡{ä9!®O?K‰’2ÔÌž>¬€1ꬳîÄ !;qV9[±…gÔ ¥&λ§WšBÛqÇ #ËG„VXÀ# úíYÝ ŒÉÛޏ…¬ÄòJ‡&ò ãç£B°”Rc`ä:îNâ®BÙóÍ8ûÑáPžträ t€¡ß'¸æžnæuÓO{aXã A9´'üæï?ŠÐ@HÅÎU"àAÚºçP—ZÊÓ”ìÊ‹C~<¬`²VùZwWQ•¯[Ü´”Zàù„{vÄIž^‰¶)èšF3VŸnX` , í6%§µÿZÚܤœ²8,·•h¹.Óh$R[$uQᤠ+\‚…%Öì§Mzå¼³¾'öj(fôœ›O„_Úç ê{x½A'n4+ÿ¼j, Ë«™`ŽÈ)ä#ìåÛ¶0e¼ ÉCT[µËÇ5€UÍ(;u3tçñ™g¢ÏëuwyBÖgLÙƒRR­–„6Ij=ˆÊlp¨kˆ´m(±–?`äƒy,Õ.åÒl›Â·—àÂ`8åtÏNfövß%º~_‡†ítØþD¼ª¿Z¶ŠrÉÝ`, @#n¡yBo <¥š¼|O|m›‰è´“—u©ÀEw±KjìBÿ&Ùefv2Ò€Ïr·”^µ@…*ü™ïLó#{è+`@ÔšWßL«j9¬“z8…`+9Üjˆõ(â~èc#ëbÄ…&Ø6¥ÀÍdò×ßêf¯õê .y€6°Ñ06 5JüúÔ€p 3>V¿ú`bû“J-’w1 ",­Ø@n08p-ã\áŽÀ¸y M?zâøâòH¦ˆ®B»j^&3~„H„±ÓL‹xÖ‚ÞÆgfCºnÊ&¸¨2$’‘6µ6/‡;¼Z”‚ , JÕëÃÄH;Ä—Ml7)šì&9@_½Šò0¸D|¢ææƒ¾ÿPÓ p ëS8‡åoQý!§~` $èq,“ªæ˜·ÁoyäÛŒ™’K…oW⛉S|õ¹{¶­.èZÍ*“ÄL†(vi®Ð‚D!D0ÚÌ)aè§ijUc^´”äÆRkaq:Pêñ9 €öˆI¡OQHŠri P¶hE79S'ÓAKj Mjn~@¥&Â6(hÊqʊżB! ˆàJ8†HydŠûHª” ,|X%|ÀqŽÂFèjô±© £ýòÊ;J-Ú8û¾Ò+óqœãœ†ø—:ÔñdLWíšÌäÇ÷¹sNÇÝDói X·çtúèÇaŽ ãDL•¯dl, °Ü< ÏpƆ,®Jôé"‘ä{*9YÓ—¡ùÖ»»]øÀ«Ð¿è5¼2A”)ñ÷¿ÜEà¸xL”i±9ÒË•írå1—Äɹd§Í¥.ù·:¦f{?}|¸M?E÷ÇâŸ~ô@釆:Ný¡ —ÐÖM×L¸ÛÃ3n*æ$PQÿ¼€Je.. YÀa ˜¦L;–²Çú¶é˜)Ôe5Ü[]Ýêú¬µ’Žy÷º×¾îú€ÿû%<.xaʼPâd`#5 8^‡òWvµ¦4óšwmÚñoö ó½éÓBù6÷7×#*p=„ɰ¦ã“ðmP:9QŠs q"'­(±°Ð£h…®ûº;‘aH Ò&Bµ»Ò1Ÿã1X{A·ë±Þ¥í«•Z3¯¾z2 X(? ¸!¸„ ¼#’"@„ØÉ²WÚ²es¹ãYž$9,1ÖèýË’ãȤs‘°-:qŠ¡ó ÒCÀ~ˆÀ7Y­Ö**ô!*nê‡ÿ'À‘añŒýXªÊþÉ:ߣ€X€«z$y±ó* !È`¢P—'¢ô` Ws¸¸ šÞéÛ¡‡&k2L"¾z¾[ñB  üAó<`^Ð '[-‹?Ž‚<0»! zšâ¨Bý»°Y³q O’¢ô(ÀžÀÛ»‡1$ª~ tS:>a=d¤¦zé‡MHÔБ&Б%à­ÅÁCu v™á ä”Cª1 X‘Ð{ &K¤zZ8…2HÔ>»ƒ¨½¿Öx²MŒ J`¯ B~4¿ó+Â讽‚!`/(ü¨úƒ9Ç"©…¨BZ´¹æØ?¨ é`¢TkDÿžÈÈöø¹a*rcº3ä&tÃô¡là¸&øñ‘žéŒü¹º«Ð@uZù€^l B »ã# Ù )ï©¶².ë š0ô'ô¸‡Â¸LL2DÈDë8ÀE« ¸„¬üÇ# ¯Žk¹%I÷¢šæÑYlH+¤°yŽT1—u) C¤Cц£;:ðè6ºË¡ ðx èƒÈp‚ÁD—Qœq‡“ @☦ ¶x1áFD ´Y—‘h"•X1F¼‰‹³¡ù:ëj¼ ½C„¨ŒÊ`Ó8Uð|äG•ÂÅK¸ÍQôá‡Ø`„d6ÿá$K³„,Z|H‰ˆÈ,Y³—i"t”)¥HÊ‘±½U»)¾¼NìŠj8„(€(X ʰ'€ '@L|°£©ø C@„õ¤®ÛÆ#¤;> (®â‚›k‘“HHª)/ŒÌ¸3ÊGâ³i2'˸֜Ê(ƒMJM•{ÐO”MQ,Â"‘2•»šÄR¶©ûÉÂÂå`Ž5+Ä4ËÎŒN Po{h¾ôp¡h à‚nл!““í/H'  }X¥|pØ+ºÀq"=jL±¸œü±LéñªV³'𠂤`¬> ëOˆ»ˆ29Zâ5^+‚ÿ^û¸ªüÄ«œÍ}ÜG",‚ÖàUÌÐŽº£e#K…œª”Â’iÛ¿åLm3»òY „3ë³®ò‘¤J2L#Û™¸Ø”¹c”Ø‘¶:EȆlRóBR0Ã㇑CRküõ ǤFH N!$O+<‰‹ËdÁËÄ*£ ²Ð¬®“aDå£DÍDÕÜD^[€^[–eaÐe/8•ЂÔJóÓÊ ÈÉpš@Hä\X,’%[’9šCÎäÜ/°QŒÿãÕËœ s5_1ü¤ »ø‘œÉï¢Rj[É‘ˆ –Œ ½Z%p3¯)[؃eÒþxªA vŠÌÿ*ý7˜§ Ø ÍÙU³“)1=ôxTF¬WÐà¾HÍ4UÓݸsS­M | ¤„jõDQlÐKø8Ž“ÓÓà…खø‚91ûМƒÈBU3™IÔ{›Èü9ÐêO-ÍOXy‘ÉèÎÏñì‹ù®QšÁ„«$uƒ5<^P¿"xMµUÛ˜¬S'C¨D¨L½¹ÕÂÁ€Ï‘©ýM{»NÖa].'2Ð|d!ÆUVeYPÝô¸òÃY›ýA˵ÍkÕY«ÐðÍWZ9Æú2Æ‚Eç3®AW,Ìçà “pÚŸÛ1:û*8 «”¹ŽÇø …¡ñ>ÙéZñü]ÿ®Í ~@R0[^9õ{MR\Þ"@LWÅö¤ÛèEãB. ©.˜º«îáÌ@‚»ŽõÒzJ>2¥Ä”•Ê]›!ÇuYUX€×|7<ÚÄYùµÜÛÜJØÙ¿²DXÂXb”W¬?)¹´<)i‹H°1xˆÆ .í^D>û*bÀê>Üe¾:ÒÖp}pMÒ$6¯UBÒ‘+aÃS[ÁÛYÜ$Å $§ØÀÆ4„q‰W[µâ‹{¤`»j"è{)ªÜD2; ™s(Ž€J4MÓdÙÇý5e!EøÂhB›•_<}@—,{¹ÜHžÝð¡q– ³\ÊÔ-`ÿpA`fÝ&‚N¬Ùê+M»£‡ŠÃ$À0R}ˆ‡=.Ûï;RÊðà?Ö¤²í`Ã;d‘Cáå½OÀÍÛô&Õ J«´ ¨äŠý¬›' $åk¢³Ù޶ÏSÇ+b#Þ¹X\4²•uâfU^JØ8òóAôÁ%¿Üôy°-Û2¡•Š0F’ µ)†Ä¯*Ü¿B•È|ˆÍØž&*|`’ù*« ”Y ˜a?Žæ+>FR@ÒHR FÒ#EX8^ämÛ¶UÞûuäGÞÙ˜ü|0J«4 ¯£.ÎÁaûäáîéž‘ØÏjŽcÒPEªA$Nb¾£hÿ&ve^[ßå÷ý; àèØ´Üò»åÛlPø«¸ c0N’*æ(9Z4Ƽ&шLà—ù€ pÎ@Z1D µC;¸Þ½J">gv¢îà£VçpFjãD†ç¶Žèòÿv&¯Ö6Û?Û‘cpW[5ðåMaz6O©àê}¶ä—±.ÍÉØÓªŒÔÕBÏv¤»vâÆ5ÅUMq¯k'žîWS(ŽtP…Xö¸WˆØÄñ)ÆÍ[ÖMزªyúÆc¨7Zk©N×§ìfcsô¸†kí u•Ð’À¤zÔòÃ`š×îuÄ3Þ`ê'v©6öEþ8{Ž ŠÑmC€ ð{í‘ùMãÄAœ¯ÂöTëL…çÒ Ae'kñE_ô‰žhqï»VvôêÖMì¾ñìöD‘Ö\û\–ãS~ÿßâœÅ.™¶ex( 6VÁ@§fûDíëÐí‡ç+è`ÿÕöŒ_ÕCFd©vxöµ»WáãóÔ '¥d¿¯dzp •ü+-\qTxîoßž¿0RôœOÓ¾sÜËwbŽS_˜µt\éîžwÙxPæÚ„LH³Dã¤eruMÄóà!^<{óXÌk¸°! yò"²8Ã^¾ùøéã¸Q߯|";ê‹×Ñ…”ú<ˆhéò%/1‹Q“¦Ì_4‹¨¢é£ˆ B/ õ±oß(|IñáûAA‚!C¦ê«°ð ÷È!àkWîIœxâļ ÏbeÛ­Czö…øðAŸ>DˆVPX±b/}ûõ»·0b¿>Vÿ,Á¥È#S®LùÒ¥ —(mÞ@I>! C/e:š)jÓ¸R›Æ·Áõ† Ìî0ÂÃm·= ä=pDÁxùb`ÍÊv^‰²áÚûP¡j^’üòáåç‚£I}1ùµD)ó{Ìï.oÚÔ©sg‘^í òÑ9ˆ%YUt–Cÿ9ø€ Â5]v¢a} &Xa{ÖWb…©²{EIFÉd–E¶ÙešQh12µZj4âc#k8ÂÛž0ð£mºd‚A¾ DdpÑDEt„rp…Ïsü "^&‰`Òu.Äc]J.…WÿÓx¼àtz6ѤžO½øàæ|ðùÐÞQJ-eA+QE5Uv9ˆÕ=^ °OXc%(ÑX5¤–EiAhœ“ ÎC#H"d¸‚ˆbb>ؘ¯,€âc(žHYP(BÖ*g•m Ú¤±†Úi·Þú ÌÆ€m·ÜDöV¤p**ÏeAyD‚ U(’•zu„Gü˜ÄGú¸ÀRxáa¦Mjš‰Þyè­™O@¹é¦|AU§}£ü'TˆðÙçŸZH ÐÞs(ƒó0ˆZFZœ¢×õ†"è%Åx˜‡¡Ö؈¯,F‰*§*Yª¢ Õd›uꬴšVÿZ­5êʱýÚn¸T¤‘ÇK<0Òì=ÐB+OчNjÏt}Rw%¶Q—e—ñˆ^Kgî¤æMç‘.»ëªònQrÒgSNí§ß¾öw–Vä`„W^ªàqó¨À„Å-Á$VÌVäP]—bj±^ŸrÚ¡a .Ðc¯@ c xlê+˜¯ðÊ ªtÎc+ñ" ¼ÚŒ¸¢–T®©Æk¯>þ8‚°`,îí¦­=' <°Ñ-ÏYôh$uÏE=]HÙåJcr­&×êZ{löRâ›òÅ7o}JáƒßÚRõɯ„pµOu#¸\CôLšÜL*WVV% Eÿ©súH€¡Å§!¾ü¥q Úè<×±Mnsb‚ò¹–€ä†XêrÄ”Q´nf¨Í€t›©HGÈA ·!-iÐÂÀÀàW©ŒˆäRPÃËÔ@r\Ô»ÞրȦôôÄ=Þ‹|è5ŠQX€|QÑ—s„Ö7¤É­n…2 Z40 ÔÏ~÷SN¢BKajbšÊÔâà6A²Šíkß$™õÅ¿ým˜GKÐþ68 9瞉˔>“F¿tê€-EŒçZ²Ò5^“‚úÐf Z0)äã§ó`®d´+×ì(>šÍ!m·³Ü¡HÀAq*z„#L’,1Þñ 6˜‰Y /)×Mzr=±ú¤”dåž¼.á‰K¡ ÿÝ >, ©=UÅ9sÑÀÛ"º±0¼ñˆÇ–Ý’Ä=&ÿ™ôJÊTÅHÍk²”S/©ì ~QY胳úˆ=rÚ‚mÒ#¥k®`&ÎÖ¬œ8£] Mس!, a¿æP S¢À½*ܯjm'bëO~2VìÅ]qJ(BåãʤX@mO”Š]æÂ¨³l¥n ¢Ô‚`î‹LvÏÀ b|áPb^Ê8‰á¥³üªK8õ h¶¥œ½’6C›Ó;fS °@_¶Ú¡ÖìW ¸A#‰U,#ñFg_*€²"O(Ƀ¤–2mÆ2‰wt£cÿ@ &ˆåIQŽÈJ„Ò+m²ÔÓù²«FÅ­+t3nËâ–³è¯-1/C,iÃÆJì½Î à_Zr¥úêÊVÆ‹Kê™Ùk‚$-‡hé1%‘”N¯I0jW;šÖº‘¹¹Ý„{D~©w¸½G<‰ÇãÕË W9[b9ñÅ…Fî? JÐUbf­n}+jbyc>I´1à}'·ìПNP‚¬PDA)%!fRÁ¤TÜË5UŠ—Kiäw¼õ”ð’‹(D!‡ÅË/(ð‹½àÐË_í˜E²‚Y-¸ÙL¡Q ™³Û¤©‹dêœMлŠvJh¡ FFÿ¢—´‚Üå&]=Ç#Çv!úd‰ÆʆrPèÒxµH[,/ÄŸ7G-oÛ Øg »9‰A)2©›Up¸1:ì5ãcÿ²¡+ÙZ›xÜæä°MÙMÿÅ—é]Œ×€!%ÄÆü¥Ù‚éDžÎðFµQ˜Ï„ÒN<Ä€ð%§€ç F\J_Ü€ÑõÉL@4G×åC¸aÙKXO]XùÓN¬[(¥JDÏt5ÅîÏTTŠç¹Ò `%ùÎÀ %)œ©™…µ!WIß ÞÄèÃÔÝõµÌüèTÆmœJDßùÝ(a^ü¯âÀp Y„@éX³ÙŸýÕߚ툯p!ÍÝܵÍÙÿ鎥µÐXLªÑñ¸á è"|ÀZGÞ ÞÓðì%ÚºÄ>áP>8âÙƒ\ÐC`ÝX—H@IÙ’-Å@¦-$©ÿ <<Œ}Y E’ Â`’)™VÝàÜ1!^\ÝÑ6áZ€Ørß±ÙÉõ•uÊMá=Ø"d°â „€ùb ã̜ΠÕ¯è_pضùŒÎôN$Áñð–á—^`càØÞ Ö ”ÖÔäƒwŒ’½Ä~íWJàEà”´@a˜ÑîáC¾½£sPZ×¥E¦±À<ã<`mSÞŧ- è´ÜõQ ÜÝP(V\]¼eÅi„Cö ?"røEŽœEâFf$Y ›U!PyPýÕ³Á†éÈ\¢P¶ÙŽaBÄ€VÄP%ÍÐ4b <2ByMâVtæ¡ÈE²yÿ@P℘tG˜¸€ PG”ch5Á÷ßÀ4A¶;îUV@Ft#h@¦€=ŠNd±õ edÁPc9Ópm•%!<HÔÚMŠú€ýN÷i\8AÉÔ+\$=¨ŸÆ XzuVZÀfPz~9É ­dÍ…a¶„hK @’]˜O…ØÚ¬EY`'‚+NŠ\L áWJÄ/xK>@R.¥ú}_FÚ"vÒ&R ⬠<ò‰î¦o– g’Å~Š„ü(GVˆ”qÌÛ¥¥r6¦Ô—PGFTœ˜ÉÏ)h:†–_‚_SŽViÕ—LmŽ0$C~œ L³¡ÿh˜¤af¯@^þIÞ"Mžå 2Ö§’ø¦ FÌhÅ¥â£(ˆr`硌×6Ùƒ@ItVƒòPxàjŠ„Ðɦlb§…úè=4î¹ã¾IJÔ×€1œESf¤¡D!iiS€,ò‰Ú¤$'²—”Ñ×&N­Ù‘69„ö‘ÖɃkv&ø±âh–ùEdpÖ”($i}\>tŠøb‚É{²§“ò lD@91À´1f…õÆ@(#A KBpi³ E]0­5D  Z¨5ˆÁÍ£Vç«"·Èi˜„I<¤æƒÖ)S2%Ò¸fž†Ÿ¨æTmîÇ;òGUL…ò&[Œ*Øâ3jÿÜþƒNô Þô½§ÜДNn®Å±eÜYˆêVÀ&vJäBvgKQgÙÑ6j¯Ùĩت0¢ÎOfaÂ\b*fíÜî –"íðÃ}6Kñ–H 7ÅìÒÔ!̾*²…l“9öÚjæ—t 9Aòf ,žŽ*ž¡ha],­+T%?Ø’nžƒ÷Ñkø¡â~Ê\(J@Ê 'úë°¥ÔEÝÑúõàM".–ê>%ªv–W©*KÝÔ«¶uVçœç“æÇúí­jáÈίÂ'k¶ýß!m›`ñnâa€QŠ6 ­u]§†çx9!¦)=˜#ò|ÿÒu"G@ £€É&S’+ëlJ!TîC\ዺ>”D”ïu]xr‘=.,lÖ…yêZÄ¥Ö f†ÞNŸÙÖ¨=”¢NÊCÕâ_^äâZ}Í­_,@a€D6Y¯·ÈªX!ã±FPnÍxÂÍ„26æ|^±Nž€àgZ`n‚&â`sìhx†hÑæ”oò&oâïš>¨}…’·í-ž2lŸþe.eêºVÅ5JTs°ˆb­æÑÚ¥ÐC)ÆI=MµšàAÓ¯¢ÿ¼b³rÓ<¬-ß™Å%Þ¦~E¦Û§,†e]Ùâ  ËÐÊÇ:©ê¨g“£ƒÙÿ†…‘lÏ .Îí p؃Âõ¤]LGåêã"Þ×AÈ|ËÚ£.e äl¨©H|ƒ’‰>¬&=´AN1ðïÈæêÎ&ê†ëËÀc·kv]e *$UhGvØBNêüeBî &rÖ¿ú+«-ŽÙêƒÏÙšDáQö½@DÚkâšEgÛåÅJñpaP–ˆ˜ˆªgÇ~ÐøÞúŠúÒ'SÐúk‘@ˆÌ´ jt2¯=¨æ:¡ÿЧ=6Õª_š†›€ÒNðÂ'À6-e¹Æqë¡xÞñìÞ¦sä¦ú²²@R.¦ÆmÜÉ5G… ¤4Πeý+A²'Z Õ(7)âÿíÇÅe®ÍèõRL|¥ÑuÎå,Æã IêÊOÉß0Ê_ìÜÌ}ac ë,`‘Œ?„' h#PÉFð'òÔlÿV'[´€V" ÞåéìÏD{ìDj:A@slöi?%ii@D€žä±]@E]é/7ϯ<|s½âÝ_ž\ŽØFÌK A°²>»³ÿx²&¤üàâEá\/SbÈTchç|ŽéœYà&ªç³5X!½±0ôå‰áú¢lÎôñsH@g­¡ãQí69bSJDS³úåìv«×EOÈkæ)ëâéïtñï¾.žD\€¥ôOX±Ê…=èn…ÿ YÌ«òYÁ% —rÊm°É}e9J§]Ü‘N}Ü[úÚ•ü}±×LQ–ç\Žä¼%˜ % XßÞ*j•®&ôìP)|Zž[Dk ¡„Ôn2+òHÔLS§ú9£."J¸³¥M8r¹€3§îÑFZ(˜ål4íLÀÓÚEÛèX×ñfE±÷¨ž¡DN Åõçs¤¥WŨ ‰Ñ—;Ë¥[Ö°pΠgAÍ3†nÃÔÞ–Šo‡Lc,©89©­¦FƒAžÊZ©ûŠ!â~‰–†gWÒÓŒFgRšî^'lÞ‰E.>£ï‚YOÊwƪ ¤[ÅN¸ÀЭx~Wäÿ¢AöeO@N;‡e@¬Ðª)*Y$ª¹ê” ×ös>Mt`ªcEG”øi Z}‰D÷&^•ù ºšJ¸eµT•Hæ”JÝgü¢arxŸ‡F®6˜ìË+ICº @<ðB}~ öï˜=î.×l^ÃDHUÉ“Ç-¤L JèÊü¸rñ£3eç¸8c ÅöQ¨Í;ÆweŸêÑ7Àf{sqú%e–V4MYF¼ã›#ø ‰½—‚^Y•É­KÛ/„¢ƒku”͹ôs½BžsН¸L ý­k1x‚k-ôˆk[»5?@üž;:ž9“#/ï5êÿT³Îà HDÀrä.dû¥ ˜É›À‰›¶yÛi“Ö£n¤`@p¾îÜÀ~Ä÷ùL€¬ ­÷²=`˜¦ù¨Âf퀵Ćìò\õ”¼Ã ›jKûKp˜Œ²” °…b3AÓâ\V éÕÄ~©ªË‘ok1ÍðH nr¯u ë°&z· ÇjÚ:¤Ä Û¡£~Ù ð”­A@€@Œ ˆÙüün>Dœ®I¼›¤¦30ç"Í-vä­}@«ËR4ùÓâ&×}€Ê…­k@g uK$/©òÎè’!á Z å—‚~fY¤Ë7{,b/¬ÅÚvŽ*pV‚*~øŠ5·oÿì™7ZÿˆRÑ—»Ï@A”ñŽãõ¤¢%tN ŒÇvÚZ½Càèæ‚æHdÍ»$”aÓÄJÛ©Îâám½½ºJ|ŽÉá\0M×]DÞoe©&ªkz_‚¤>×6RÉß}>â+¨f­ÔºÚB»eþœûELÁ"j¶„QvÊ7µNýu>Y«Ž ;XR!DÑ·uД6-è9)/= 'è}@¨OÂ|öìM´Â½ù~ø0ï„Fö>PZÀÿž†%8ÜÙ¢…Ù{MZÈkB‚¾_ô!B¤Ï!D¤wïÖõ‹4i`ƒ þ%ÂEa¥ƒWüZÑx…¾Æ€÷F¤x)á"+T‰Ð%о|.`&ì ø„àsýzuk׫ñm½÷Ý<1`Ða„‡àâ÷`â8rËMÄk^ Ú‚ùr˜§!%GÀ9J´Å£G YB1ïƒÊ)W:q8z°Ì›ó}¨RU¤ˆ‹|EéEùN©ÁLkê)C. ê*©¤²§‚y¤(ì)@…%î)ë´äa+C·Úè2èBd¼ˆêâ˯¾(»K±3cì0büEEÀ†8 0.³Kÿ±¤–ZÁ…\B-Š—`òÑ6Ö^«mIÜ^» 6Ýt[`ø-8F(î¸ä˜ûr9èTР 'ŠÌ…¿ŠâgMî8*¡6ꮫ®B8iž;WªH"˜ð£‰¾™|ØI•ž~*¨?'æL̅Ê ð†¨¦úÀª=²g«ºšGÂè9á²ä9­¶Jõ0„¤ìR1 PäëUÊêÒQÇsQ1D~ì¨^“ÒqEÅL{L„|B* 'r1R2Û’T’IÚdS’¶hk“rÞ~Ž80•[ÎË0 Ð@ƒ‚ Ð/ z>|Y¤rs¢ä”3„®4Z騸DªQù滤¦^¾±ýœpâÿ¢ƒsqa†i*C¨`J+´â¹ªHNÁ²ƒ²Ø:Ô–`¨Ôy*«+®¸NŒu¯˜= ³¥›Ñ³Ã(Ë…ÞŽ̯iV%H•ΧHÒHM¶Ö¦Ih£–Û*¯d`¸âÀõöËx¼†â$—ôÓOÏ‹Œd6ÙÔ‡Mîêˆ#Š.J£‹ÀÚ¡sc*B•/¡iÐAíËO43 :Ö¥…&Ð . Øb©ê o®4°‡Ÿ°.à =Tiž·>¬¯¸bEQÖû•1ÃXD,0ÒDCúN–R-,G Ì´„Ô [Ù—VHòÙj«e¶ä¡–Ò“ ®î@8ä´æ:ÿ\Äté ˜|×襵Ù^ó{wáý<‹j7›;—à㻦ùú®/pÁóC·Ä6hñ}"60c©$`+—ê E®S€q݃œãîÑ@·¬„{àù‹Ë q¢ý%u«{aVÀ¢]ñ‹_Ô1–JR ×µnf²Òºr’"…fxB€Ô¬›ã]KJXÀÕpƒá|ËKÕ[N< ˆ½Ñd„CÉÇÚ˜Ø=¿´ !üp“C0‚xÁ41Q…Àþ•œl`÷a˜h¢p'4Ì¢€!ªR}€“Û˜=ÆÄ±„LºÇɪžzEÁt•a–AšýhIŠìDH;é”0D–ÿ¡U „4¤µ€-ÒQTª@ Õ@KyKª ””Ç<çù8ˆ^rªW=è@¡O «ßIÔô½¶±MLŸhfÇv]1i¿à[ߺÆšs`øaTÃz‹GéëŸTâX§Š|,›=@Å2p-ܤíòR£ARE3óŒeX·NÉN4ËŠÂò–*åE,ÚÎFXu5!“-¤‡>¨d›ÖX6Ëk’(s³ò0•]ò–c@>1 h±"?ny~ —a“g¼÷½>´—–d˜3‰é·÷™õÁODàLgÎT£X‚à(@Š p!‹XÈB–9p=´$'ÿ\îb:»¼,Eæ\eR˜BÊXrž')Õ[ŒÄNwy<óœg?Õµ–hà‘ú@M(oè„>‹†TÓ¶°$œâ8gk—ÙfÑÈÍ!jSÛŽHšË¿¨—(} ¼0*b á&È4¦1åwŸ™ÞGj4Dã®R•IÙcôØŠÜbp‚ËÑQ ô¦7Ø„®äM£#]T iHYYÕª¼¡?YÈž~"ÅvµÓHpõ¤(uy-劂tÓš$¥&jKšaòr“-gÒ"s’ãœn¹€ˆ€ 1'~4)ü(l€l>$^q4ñ])ûæÙÉÆ”²ƒû“}|)CHÀ³oäʦRÿ²1˜Vn@àWËÀQá iäqTŸzN ¦.·²zÉ ³ºUé —%ë Ýá']ZÆÄSh´¦ä‰çí¸[£fes¼ÖðvvEJéC <Ò&¯30Þ‹‡DÄ{ý¤t¼¹¶–_ ¿b ¦õñ¯!¦RR³+IC,ƒëL[,J 7áL·X$fÉRœ*nÂ*²F¤ÎŽ‚´¬eш&î½l§Õ¼ÀTo“Ði‚|@TB(ŒzÃØ0ÔÆö v ®5o·Ô^‹‡><^¼5Ò’ß㋎@ª^6­ÿíúÀ{|ûtZ/v¼ºæ5­¿ñ‹Ç³²áxr0#$ÑEÈU. } EŶƒœ›kD¶œ{m™ºwÅ“vùB÷‡Æz‘àj$t¦ÒÈ™2϶¬E#ú°§qãb|¼5¡_¿÷ò6м×Õ8[“(Õžö¾"¤%|ï“-í>3&C0kçŽO¤ÿŒá½¾‰ø#;¾žË_ ¤(p©TÓR˜"ÙrHèÀ Ô|áìyÿsŽD§]P„î<£/‚.ÕŽbtøÉÄXèslgžhÇwnÑúI"@ƒž6-°®“t#º¤ÆëD‰øЇ°†[îJ•”£»š¯ùÿÀ§¼øÄMl X®.\MÃHC"fÍû–()†©¾ºÈüzA&ð‹/ý ‡’pÙ¸‚N€†¢+b òð/æ¬ÍÚ° 3@2@òÄ!ð,hxu® )¾P"^O«ëw†mǸ´ªéжêò|  †ïÒ†¯†fC®ž8¶dKŒƒ£[šƒàZŠ\‚OÌ‹Óæ{ZíÉúÊÆfÅ+wDÀ>v-Ëüf'„I&F'$+² fÌØ( ëåRæhä!°)#°ÃþðT2Ï ã,rà HéF‡YX¤Â£/¸cY†NÈIÐN…Ý,ŸÌäN­åÜø£ê‹“ÿvˆÓ*ÆŒ§ël²ì+Ë„°~„Ððú†‹æCba’Ro+Zñ*‚"ÆÄ´T,NÀBÈ ˆr3€¸0OÞÏXmUjÄHF‡|Èg„î¤d\«T\¨ŸŽ¥?’sÒÝèp&éÍ(a‡¼ÑZ¶1¡âj7œçº†c¹«KΑMàɤh?椹ã{Ôñúêû(Cv.Nð‘+ãCvíð€'~·h‹Úg>(Á¿þ' r1å#F‚* Á¤pÚ*$µ8rùOÿÀÚnnNŒwDU4ŒÊ†ÎXî$tHÅCä„òQ(p'/SÐò$²)7ø¦¦(kŒßpÈßÂ1ï §‡Ç‘ˆ°rv(²Høä ¤ˆ‰˜Ì3PÍ/ ìúÜE4¼ò$1cm¢ŠS&d¢'e ÿ¿Àb Ž²!äR¶"X` ,â®#Á,Dÿ:ò#ãL$3@ç¼M/HVp;xé»ÃÖ­d¢N T¯T 1 ¶  ¬)V “"€÷>“‰Ò(ÊyÂkÆ‘K qYÓk ì.¼C_`_ÍÁ„`bK#oD£~…á‚óüæç`\€~¡aÿC-ppâ9’ÄHl޶ŽBÂA,â:4 B*R#õo¬ ⌵p=X¢]DïÂÊÐ*y†gSC¬ŽT’ÑÃöÓêØ¢ 8 KÑâ~XhÞ(Áy6à t»n4«æº¸…8¶DzÑ)›O½â1a"bÓÈxpmŒ4š ±°Oûª,áÒM‰dl‚äѪLVô¦„‰¿™šâHdB .§ŽDKþ–€(b¨®ãå(Ê6Ó+¤ΤøÎŒ'_”å\xÁ™ŠSŒ'pF±>þƘÞgv’!_¹6ÒŒwÇ$€WÚÆD,F•xWHÝ‚!äÅHZUVZ†çº£é`ÝÞúŽe{ÝMWuUdÿì^Fç ‡uÃ,à®%®œfˆ½‘Ó²ÅÓF »@ ~Gm‰›ïr½JKª¯F€m¢²ádgïfDý£ŒrÐOfªø&~|äìu¢“d ¯b(‚k#R$:ÕNêÏŽÍv!ÿ 6mI8a…Ô,ºs_ßc¶ )/d•#šnwPH¢ ¹ê¬ÔJ¹N¥"xø|8e9ùe빈‡NpÍ‘à ”~UI8^ðm\m@ ¤ pm,Q{¶5i²¨¦¨Ö‹&Z`â§¶¬&Ür6+:M´ºâk¹VþDâ!¤Ž5Òþ*Ï`‹w±Ù„E¢ ¹'Iƒbcuáœ4ÐPÂvPê3@ÃÏ6“¶4 ‚Ç+n žãAÉ”“õˆ¥‡¨ÄÓ`fû*¬ZýÙ»TI`y1­Ò{N+= 0¢ò«S £4p@ØØÚ­…¹7z<  “P™1%28$6˜+ÿN¥ÿš\N  BØšõϰ(¦¯ !âÂÉP":ÂΚµÃ=û,Y×o£Ñ%àÄn|åù|C{“C»?©ˆ©DA©š”SÓ[è×Z› I9‹Ý${†,.1ä&DwlÎ¥Oâ#×rm&.‹Þ‡˜¨öoà!÷A¬ç!4u™¡{(&`¯+Ø+êÏ` v`cn-2aöVýIÙ%±ð"Vc•gŒ…< ­„x‰%Ñ[HÖ ³wòÑü !&d‰À4žÍ×3G›“œ­Ò[¬Ä7fÖ8´f5ã´ù9xa8*sß«¤ÔË£<ÃÕž,èââ,n¾r¦èË ÿƸ}9˜ÿÏj™»bêZºíÁå {´b¦O ƒ£›däa»O†\¨Ùš9 ›w‡âm´£±ÂÎ:">­WÓ/fgtˆä~Îy{s4.ð³®|¸L¡ø„Ò©O»øòyµ‰c5̵  VsxA8h³Èüîô’,+]ís)‘2p“Ö ?r--fÄ×:¹ßš-}­)Æc‚Iì“0.Q"%è:S‹d覴42lsœdÛšM8¼± ‚+D£#fgb›Ÿæ¥^¼íÛL¤±S…Cì¾[ 4;†õ¶" €*¹¿ƒò|À»¼U[D9¢âÁMù91Íy  ¡ÕÍmÝ!àœ—ÿ€E¤€Žsusm´£ƒ—ÕÏýœã‚9~Ï÷Áý½!E Ý_ÜkâSfÜAüš·{NÀ›°VHœ²Yn=B;|©b{¦1]’›û„%#ÛXæ{“ŒkH.^f|¸¿# 6F›e™z5|}«&µO5™oÁÕŽ5´¨š£øAS ¨\Qê2‚Öî²Òª@Ê/®í#E‹s‘©Ä×úEÛ§)Ê=:íš!ãÒå¤;$²Ùþ¢;ÞÁ“šé}¥Á{Ó9}¼cúm`•èžwÞ Ïaù!œtèÆŠ¸Bƒ;¾â%*y‡â¹L³‘}›šI4¾¡vˆ®‚#5 ®Ÿ‰Èzÿ¬çkò^•ê*¾pûÂM¨ô@hïÎElf4Î(HP4ƒ ä‚ Ü}Y£Ý¯ñœ ŽÏ}™1¢ azT@U )=ê÷¨ H<9RÓ3–,Nx¸ò4…9¢%å¥|Œ|±´ƒb]&NÈè7O !4b6Ë©w¨L·¼â­EÀkhÓÆrí^äËnï±øþ)‘£ä·…£Êõ½¦Ï«ذ¢’M𜗠`XfiÙ•iÕUq’j)ßEý¿Tüñ »ÑÍ£3xØÖ,B¿\âĉ%å-¹‡p‰B…rhx@D„ <¼'o½òåê˜/d. ?|ˆÒ1J¾Žú$è{ óe>˜.ÿõyŒiseÈ™úìÑS‘¢ Ü8º`C„ ø6X`ê*T M«BÅ÷cƒÖž0ø:ÂC¼±dã™0aÖl²&Ö@‹Öƒ‡žØêà¡ÀÎz÷òÓ'B("ëC¤ÏEÌx6£8¡§¡…äÉM&KnÓ‰æ\.\ðê¥*t‘ÑETù(â#uê}û$|˜Àè½yó1¢›=FöÇ¡Áó $¨°IÃ…K”txï¡Dé,JÄH|£É(>vìb%G2m¶4ÿ²fÌ’C†·ùÁ&dz!G5Šté§MµZý•TZmTQ_1 ×l½•V[g½!Yq™0Wÿ X˜?öä³áN}ÍÄa‡&‚>™ˆbHQÐCe•5cŒ2ÂxYfNt†£"ðBÚi©©ÂÚ&év›FºÀqµíæ ò`$<ipœB=ÙPôEQW]uµ@\‰§ÏG+DÞLnÊ4“z‡©—KN"Å—O9ÍW?öÝGTYù7¡ü8`¢Jyå#„UÖ‚pÅa[c1h–\lJ—üèÅ_ù|XL ¥ã‰¹Ç¢d/Îk •Y6™6F… ùx&Âh©¡¤IYÛmH*¹[oÅ9%vÆ-Ás].wÏ´ÐAdÒAy‹ö„7^ÿH¨’Kñ÷Ò¹8á”ËM(™y‡öh Á†~ŠTVú>…¨TýY¥h Ü€  FÚ Z F8Ö„s]haŸê´SG¢Æ{±x‚dòÌJkÈ’iFrÉ!k–˜g<–Vk®½fì’Œ8Émº [\”OFIP•È] BÊA´íD×EG€E ÉÓ‚FárÔ.HçòdȺ繄µyïšÉ"=NØó5‹ЇHDáW”Vƒ èÔ¿„&ÚŸV0 ¤Wj–¥kQjiƒ^x×}ŽºWá/ ÅO‰«rتe-z]²¹LNù/¹üâæ—O.¹f·îÊk+³VÁ0Cn©#ÉBÿ͵)û[”ÑFiÜ@V2—A{ÙÒQ'œ”N³)µyêÆ”µ>ß¹Ùn>Q„Ðu×`ƒ=¶×ùˆ°E!•vTQQ5`Üýªv¢"ø¨¤RʾƒoA)…rê)á&R_cªJ,jDoÑ' öÀ•ä\À™Ìýs Ä\/~Á‹Fs8ª /z5š U`ö Mêv3Ö±n½Ù ’x椞§Y·‹ÈEvÃÞQ§"‹B°!–¬Ä<5‘SzΧ•<z+¢ "™ e_FTVø¾(*n‰š[£n`0„]j}‚_< €–†5l~v¹¥D%µ½ÎT6éÿŠ W•8ÏÀ!ˆ£ŠŽG½(B{Á‹Î˜À3ž)B¯XóœÙ†I'Î l»2‹vÏ:Èάեönw`ráu„·{€d&Ç{ "$€ÄÐÄ<âz^×$3¶6@¦ÕËG¢¬M+P|Û~I óuà`e©Þf0z.ó‹Έ?qnUæ •¨Br"}ÄÑCQ(@.êXÁpBð†ì£zqÎÑð"¼‚ X3œ}p‘±“]±hsBh-…ÈÙçB¶äirw‰Ž ¯U­ìhg'$qI*MéP’HÓLD|™Z` È£zô .¹çÄïEE|"_T–ÿr°Œ˜2f“F1fª™¶@PŸ¢ù½¤ñTAñÐ^DD¸½¨Ä މÜÃYHÒøQ"èL Ÿ Ïaiu!ÔY’rSœcÑ JúüÍ>«U-k9¤:Ö‰!EÄ䥣I‰Lù–°l’µ¶ä#áÉ[ТŽ5áô¢%-½–8ímïlI)Ÿ÷¤èK`¦ÔQvcŸKV/JH~œª©X4dM¾Œ›…ã_ÖX¸ ©l‰\œPpfn+ëã ùÔwî#ž¶ÁͲ$yUâ«uÑjÝŽ`%Û]é9XBÚYËjP¢t:I®ÐÖÚ5Š~€#P‹Kfr¦“p ¯“910Ú„ÿ%d”E¥ Vp¶zï)PÌŠÛø…¥Xñ@aa)ûøö>¸xqob< 7… xLL§:Ùl¨2û!¹©p_sBCÌ@îF tA<ìÁ§bŽŒêTñ©Õ$•à%°YV“Ä:h…U¸ IB‘¦­m:Eèr˜ÆWR—M!@ ]§ËµVul ®Âhs¢8!(+øè ¬8¨ñ)ŠŠ%ÐR‚I0Geñ¾ÆLËÞ` FþæŒ5Å‹€\¸ÍîÅ}i³¼P»!°±H–-hCiQ{#ÕŠó©d‡g ³Ú,«f"¤ÍUu3èg5«·þô§—žSÖl!7h4ÄV ÷¹WDÿ—¢œÆáF×±î†7¼ Ù(=ôR6&.àÊú:,ùšÂÞ*o +‹Õrcñ»¾.G6¦”å”]ÌTiR¬³k&œ^⼡ÓÚÃ']ÃÌU¢g >•HªT ݺÛbÛÄ#¡oƒÖ-„wA£ŽÂ¦€í!6ÆFZ€ã‹ÎæÿÓ@qfK½Â¨Zá5_—m¢&J—IiuTÔ ·¶yïÊçc,?.µE—šE™÷e …8Õš^ÈS©Íì(ñG*ÏvèØÒËi»éµ “ÌkÝÔLg.ì?;¶1¯¹ ੬k•Ä!Ì6#B s8 !ÀUHAÝ\,MGÒÌ=Z¹Í4-U+JÿZ‚÷d>Fõ‹þµEË!µ¿5‚R¥z°gÓϬuv^*ª—´6Á%–bF̼V&›i![ÔE.!¶ÈC’lÀÿ=ŽØPƒó±d¢:¦=Håð´ÙÉaÁ³¶ ööˆ»$Ê‹ø8ÑŽ?.VèH:ÆJƒºéÝý$åì¬2:kÈEùŠW° -¬¥Û†LĨíÝ'+¬Ž5Úc ë…Ó+#@ßù쾴@\ÌñÓ€íâ 3>´ú@œûÒ¡¦vTlUw: ZPt;ºàã©]ó:²†òřLj+Ÿ$'•`XÆ©üW¹4ÜŸñ.“µˆ&}z—vÊ1{ª×ÉuQTB&§¦ÿû6€ýö]õRK4pW6 »$Rh÷6(ÕpŒ){S)aöR'!`}чÁF1¢D@g£2Zp~*Ó+æ§Tê$:9HÓ†~’·µ•:ø”[ñ§3óðÅ1bJRO÷7\[iÂ-ÖAç6cfõŽð:À…]Ø…Ìð‰p¨%•A&Ý2KõbÍááå]¶—`9` wˆ‡wÚvKÁ/WÆ/(k[±=wk§ɤE“å|Çž°wWxiT}1hx,hr‰Á  #9HNJ¥ ,¡Šê„G>xaù°~‚Ö~$&tI"Gp,ðs!Äÿs93;_•Ã4-ÖL€:ÐÃHŒÅHŒû©'gHUG/cƒQ_ÓÍ1€µg{!ƨýrS>§v‰òÒ(saq|Ž¥Ž0Õ0ï3Ëtqdæ ¶@xÁɆCçF;ñ:‰;²<‚A£ªqN©N,³GxdatDG“gCˆOKh„ÀaÝ&D¸OÍ‚ކt1nÇUVN'4áÛÈ’Ž#Ls€1¶W '€ZÆ@€ÕhjË,©|xvWfO±K½]á³Réèº6q}óE×kω¸qãY+l7MA;‚ÿ=£A¥q¨èä#¥X*cs©¥ˆdÄâ~JøŠaÀs/`[ùtIãÆ‹ÍÕBýÇçöéCO0Œà` ‹É˜9Œ:ð1ËcèW|¥MQN` G6jÕÄÃØ˜£‰Ã³VX¬”ƒ¨B Ú30€EÅ”Zz“ˆ˜?¹Ù0ñèkz78ø#JËFœ0èYaç0:–¤ANe™—€–>p ¦êÄa©‘p9¾A©ó~®SLøLÈ3~énþ4’×Q…‚I…1$Œý` þ€Ÿù©ŸÄhgø•ñ]ß%¦v™G&^|@@ÿŒúÉ Ñ0ŒUfGk­iXDi>n'›Yô)—R› •h¡›Œˆ‚5õ›V9b}Ë&rß2=‚"&¢MuA:¢GŸØ# © éjYs&§Š³ÕAy‹¸¶1Ëbh¿1;O‚ qG3ç6˜ÙR˜WˆõyŸ ºŸÃ8 McÿÙ1Š“'ÐG4jâÕôK¶ `ŠŸÚ=pvB¡G¡ÞX]10Œu¢d‘ZMÉŽ ¢ˆ!ššò7$ê›{§!ÃY}+š'”œ. #1Êœ;B¢! I?bØÉNuNpy¤Jh¤¹‘¤8#žYu[¹¥S÷ÿUÐÑ3ïŸd%[Ú\á¥tšŸÄþùŸ~ØzdÆ` JÆfsJ§v bpZpŠ‚RÃ÷X„ŽËסùE‚ï•ctqVÀù›‚#/Ö'/òB@×ç™J¯:BN½RЦ;z¤¨–ë‘…Z8·[&v·»BJ"—!%²êhÅ•4 E%V*igh…¥Õ šÀŠŸÂÊu†9 E² c­`j§U0Ž[A 1»šÈ{Á¨o)šZ”Ò³˜F'Y‹Úˆø¨óÈŸ’S)jœ8ô5r´ÙD˜Êœæ'÷ Š,¤H;‚ÿG¦Z8«¶E,ºA‘ÙA„Y¥O]"¥öK`oôarIŒ¾Ú± ²1©-ÕH²˜‰“oê°™˜‡GIJÃè±Ò:³ 0¡yêšfך…•”š>Þú³_”¨„*®{#sár eT¶à)ÈVûÈf–è6Á!’!2˜J»½2–<ȃ?xañ¤8s,¸QbDHû‘K’U-‹@cIµ 'T¢SJ…E·¾ÓkŸëÄ@19±I …̰ÚØ O ŽâµQ* `Ó Ã ñ+¿ò«ÃŽ«§1{­|*_Ã×(’><Û”=››úµ¹böÿ¹ÏG¢Xº'ÊÖ7]˶O;rÁ–æ!"±;shHìÁbYAƒs±~i[séŠBwBí7¸!tì™;0tG4€%d…V£§I¿ª·Ã86ÊQ…:0¾>©0 ¥d_“Ù@ÄŨ§ŽëšPüÄ®™ž ¿ÛZ7œ °ÅìE$Ø”R_c!_QFËqÄÉ¢8$Ám,J{q1 Š"TËœ¿àµˆ~àH&xsAh[%v%¼ñ;Ð’IˆO:üîCK|5¥ž4…ÕÛ< ¬ÜÃPŸMÌ’û0[¼!LìÉý0Žú‹¿Á³!Up)E0çèŽÿÆ\•$¨›’õ¹ +ºR•Ž¢´ÃénÌÄÉ•×vTŠÑ6Ñ%â MÚ)H›„I(—Ðm:ÚL;¯3Û‘ºèbëF±1VFSÉ“†Ét ²ƒ0ÄøÑ0ÖÀ `º˜ ð =PŒÐ}ïÛó ÐõÛo@­Ol­©ÌpQ\ŽL¨\ìÐ\ËïØ7üÅ ¢)»ü^q÷(.)Ê¢ÌJlLœ"xÄvM¥º¢Mº‚x¦ú°HëB5S‹„ÌÍ;ã¤ÝB$ÃÛzêÉ q¦Ç€EV Á y›É>,ïü  ½ö¼ĸ£Ò² :Œxª¿§\Ð2KÿÅÚúÊçx¹³\¨[LË·<®da0šR|eüˆmí è¨@Þ2×küÑvÝcÄ¢¦pÜfšQG7‚#ƒä5‡H`hóKê$²xÓ‰hß\W²3”v†÷pTcGóI'i·×±Î`ʽõIÔðÔ[šÃ8 ùPÕúi§=€¿ÙšÊ­ì§3kÅF10À­—Z]üÐ_´]¼_œkcºlmÆ_1L÷¸<,ê-ÐÃl ÒÎ-@ßÝt =ÐÝ`)wZ¦ZG0—ŠO´Q±ó%±3(„¶{ù¤!y-Q¥'Ä(¹4ñÙÚ JŒy0Œ¥}ÚÚ+Ð2  Š ÿ¬¯Ý¸ú²ÕOŒRVävŒµecíÐd=á=Ücs1Ï7ºf¼Ü#œv=×Ñ#ÝÑcâb3K['KK6*!LG¦:yóŒ0ñÄØò€÷°ãÜòTÃÆÁÈ­×\ÛbtÞ…ö=‹øm·÷°ßaÚÙØ àÚĘ ­Ÿ¯Û«vÛÔÅ3ÛÕ¸ýv[æ³¾íÛ.°‡ÖÆ >ºõÓS€Gœô`}¼¡°¤zNj(EdV‡’a^ó}ÚéÝ2ÈKZã `Kªt<>‹È2¤+äŒlÙ¥W;ð©IO¢Þ ÞäNŽÔì\Œ=ðÔ°˜Ní±Þ0Œ) ÿåuzÕ«Œš´]Ðú;_W4Lƒz)P ÜMá…ZqžËxñæp~•ÄÛû`/„=zöæÑ»ŒYà z<ÏÓ˜±Å‰%¤ål2’´è&-Zxnᄞ{öí»ÑêÆ@ C>¢U‚! (´jå‹å°ø:t–]Þ¹òÞI”®·ö䉎šAÝ+S©ÎÿžM1Û'´§ºhŒ®ç¿?¦ýz@}*ª«ºÂª*¯ üá†놱Fà‡Ÿº ¨­-¸TP ¸Ö*€­´ì:+0½F ¬°Hä‹/ø±§EÇò©`1sìƒÈ> 'z:»ì @ M4ÑJ+í´ì–h‚4ÔNpMƒÊœ(@ŸÛ¸‡Zᇲ¡K(.æä‰ŽÌé #©:‘:*餔‰O¾ Ho?zj)Îù¾i€;×K ¿þ^ø¡¨¦Âê+­JÔÀªnø*,oˆP¹2lKõ8Ô.Gô@°Âôê °ø™.†|ø‘1W!³±Eí‰37cÒÇÿÑ4H#LíÈל„r±|nÌ!(0®ËRÖËà8Jhn"2Ÿ“Ž…•´S‰%7Mºg=ƒz@Ô±‰lR¿žJ¢þ´3Ðõú9C[)Òn ŠÀ‚¯ºJÁnÂÓjQC¸6¼-'ŒÇ,¼@=1E¿³g ïäaÄF+ ÆÃƒL²wœçÇÑfΨ´|=íž&°Óùž_G#¶€| pÁ…Û†0dÙ!°ìòh#ð„¨-î!$®Õv[nkÎÜêÜléž'lZ„¾h¬ñS§þÖx÷¦ý° †òzˆ÷ÏûÕOP›^Î_€þ©u4ðÿ„vXÂÈZœXS{0œøC´îz°/ÂÄ‹Ôì9gÇbü eck|L2Ê(ƒy³Ívíõ4#ÙÜùÛ&N;Á'k[Ì}<8šY „#¾KhS‰zjâˆ{h¡&ªˆÌ%XàÚ뺛ƒ¶ë>ª›È³)€ý¬ùÞ&:îÆ›è!šýôUª¿/üÎMAt”QfÐAD©@¥7@ÆQèq’P<ø‘1YŽD¡ÊK^ p‚{À‚¡{ÑÐ2#cµ,2“¡Œ ^Æzˆæ47“]šn¬$µ`GÅʇïxa´} i[:^´×%j)¯Cøáx mE/…JWKÜÿ„ü¤îÃ5‚B; n6À~¸võŠxÊ~Õ `kþô¨ `¬8Ǧ¬. ̘ ÆÁ¿0@,yAÕ=r €AÞ£aL V+uŒ¡Ž^¶£× Iv³ËN®œ4›ÞyÀüpnC¼- NsòvÈC©ù"‚DŒè3Ÿ•†4Ö±ÎMÂzõvê¢M¾¸/ ô`?Ô ƒPÀñ¾¼³¢ˆ$`ˆãÔÏ~ÛŠÀÚxƒ7°˜€=!NF”³œ”')!»lìDbé _ ƒ#`FøÉLæÈeuù˜ã$måÂÿ\w-h¡:CÅME›! ±¤ÊV4j^š3Z!6çjúU±’¦Ø‰ì¢Ã7þä  ü?=OÚÀØ1ÚDCÈ…B0M Ü BXPe¿TÀ¨à4çé;x²h‹¹ E+ XS^Tyç­G=\á¼#ÜÞ™IØ—¤d 6q)e÷ã½~´m˜GA@fѧø¥?DS?@Úû%h@‚cÀP[kTØ2zG@,†@̶©˜ˆ›ZÎ!ÒŽ•Š^øƒ®~õ«Àçæ1WάÆZ‹„Ʋ|DBlUvWGccéc¯¡ì® †64{„7°ª,ï*yx^ª×xÁ êù^ïà2\_ÛNKz">ý®‡0íl¢ÙôqQßàÞLmRÓ~È@#ÿ¢û_O” ¥Ö~`)j…Y¼eï<À;@4†µÜáÙ6Ú©R-YË©HÇãõ$¤‹÷ñ¹Àje6¾1Ó:êìÚcº¥žÌtÉ}ŒÉÕ‡ï '[4ZŨòZ™€ô¦w!Aвb¯ß/«)$÷í‡:ʼž÷‰0߀—ÎØ&ް%=> C b×DXÿMá” ž.F·‹ ð€÷bà‹ÎÖ ”b¦JõF‘©€=$Ä9{¢{ÓxÀSÕªÖ†zÉ£fòbœÖ( Õ‘ú¥xk^<4†³f]­uh¼(—w×=ô!¯­ÜÑ#` ±õ´ÎwŽd=5ãwÚ:QÿüšPžÿþi²GA3MõÖl—FŽá¶žÖÆmRØÂçdr•žî¯ Ýî6ù†›ÓáyGÕœ7bq¿3Ü|Î Ž±kYêÈ;ܬ!à1tld½Š€â. @es‚ZwÜKRž2•——WXy½ÀfÉ…=“.Ó’M<ÛN/ûá i›”¥6áÂJZÞè×tˆsNš­sg>!5ò¨Œ$€ÖµA#0lY€ô$×Kw}rÑmhv'ÚÝ¡ímŸÕpŽõƒl=!—K#âܬe¿1ïnÖ½Æ:¯xåîÐ(Ù'ÛÝãPÞu®§V‘§×®0°1ìtøÊ×±,!²ÿûñ€{á«–í‡v¶³¶=ñOhv~B¾0îü ØY‚M }ºkb­ (§K³'k½Tº}x½Ö[ºt#¿DS´Õ«-Ýc„öb:à€{˜D*¸k•F28V±+´»±½Ê#‹‡X32ˆ‡ïÚ‘\ /»;D]û¸íë>B†‚’ƒ¯ò;?q1‰±é :ðp@›ýk5` À6q)~H)k 3àk‡Çó¢hÃ1Cø{"2$Ã.r‰Ô8¦ ¥É¡;½¢úFèª~Û4°z@ØsÀ>D·CC´{À0yØ0Š( ²§~{±Û ˜±È5\µÅ¨€½ÿâ 45ä[Œæ‹’‚AYËÙ ™¾â¸¨Á¾V’š¼ã¾îó¾ðcˆx¯ (Â#ì™’@ ¸B9‘p $Y “ÀE]Fa¬¿aT‰Ñ ðk  rk1 ’@#èCäÃk¤À Ô°‹%‹5PŠ¡†‚«Ñ¸ÁëÃÁ\Ó>ôbÅzBñû¨vDô ³”‰íà€'ÈEbt„ù`€58HùÐ÷F€b”“5ðˆ`qÃ¥ñ—Ðñ&¦:7B’=l¼jl@#PIjœ½CÓ0Bì*CËE$INƒæò§+«~*> q8µÿj¸åëD#k¨(˜¾]!E\Û¡:¯¤2îkÅWdŽA$Å’/Æ*‰¬ HƒÔ'p„aHžA’’°  Ô=ÙXØ¥´\ƒ¹d K¸Üކ|‚¹äÊ5ØK&â€Úaèeñ—§ ²ÃzRÄ’l½×³F„½×³L¥cIuk7 SDšä:q¼‘s$+~*>IʵZ«ì Å"cÁP¡%Ç}°>(cJ]Ó;|ì5õrž,›­©$Dw#?¬ÌÊ N%R“o±•˼LËæÜ%¸Ü¥€D‰çtθ´NÈÂN²|ŽãÂ$é) ø&3.MãºMƒL“ÿŒÌÉü*ÙC·’Û² ½¦Kº GP;ÑL;H»8µTS«h8G¢—¡º“MS¬Ç)sÊÛäµîãx`ãMæ`p/.ë2Èâ,ÎÆÊŽù#KíH˳„Nè¼N‚FçDËëtÑè ‰‘x‡ŽfAŽÝ0„oš‡ÕóŽEŒL”¼”À"µÆœ@ï€Ï¥O;KyÌÏüDdzP´ƒDõ±…‹Úé’ê[ÊRlÐ ¹^?!Â,Ó2(¹X,?39]9åÔ™o!H¸<ËUÑ[DK=}Ñ@e‰ÛQ*à}ˆ©ùN2âDE¤ÆkDR!ÿ¥Ô$ÎÀLIú¬ÉåzVáIt4A!8ꊂ²é¢|x’É(¡¹ÒX½AìSTì!3E¯ÜŒPW\Ó,s€`34Yüœú ³be _¬ÓžQH³,QçœÎ¸TQ=5Ñê|VµN0“hXânµ’ï‚hLÇdºk$Ò“D×su@#¨Àà”ÏDÜT Ç)«O[Aµs‘û Ê2W­Œâ‚JJZÍ;EµMõÁíã¨ð;`;p uSDË€a 9ÍÈ‘Xë¹Ó…lN…Ñ€|Î?­Î]šNi­Nhlm€¥ný!åÁF ˜ssºtKOÊÿ4ÒJu@B"€-{/M=M]7¯"€G¤P µÖ¼1MtŒÈR—¨«uÎx6œÇS¬ìSX½Ó¨ô Âxس ‚³u€ÄÂY,<‘ÐXZüˆ&Ø™hmV…ÑgV‘Õ[•…NŸi°6B™MÔàÀe¹€Õ?o„@ =WuÅÌ™$Â8ÚLMĘIÏÉŸ Aæ²1Vi$VZ´ª,U«q¤ŒY Ø«ÕÚ²•Q²;ìkJ93…J "Û 4³õ]³]S"üGÄãP­Ö¹ý†tQ’˵Võ[r¹‡¹Â6%܆¸€â˜šáHÜ!˜h\ÍÕ´jLןUO|ÿ²\ÌE´™\ßD\·Í-"CKlÁúeÁQM»¯Ë‡q¤Üvc_{z/™üQïhCªe §m•dµ&.]¡1þ” €’ Ë‘+vÝÌ ÙUÐ{LØÛµÝ§Ü¨V4}tà2FS Õ2 6‰éÄžq›íÑ^Þ%Î6^Ñ Ù?u^÷zÙíVðÕ_Ø è;î+Žš­–!¸á!_òõY“ÿDRB"ÂL-9LeRx=´Ð¹OIdâæcµ*eŒéBUÈ2Ù‘êªÁIâŒYÍA{<àTŒe„ý¸ªYžÜì»2>ã^‚ï£`øjÎju‘È9®E&HæK?-Qèu^7ÑÖî´A–Ø_  ü¾UÜ^áxˆ!|ÓÇ„Üîá“t:BÃdMÅ\Í]@“k*Ô‡ eˆÛ«Q»~2µª¢ZYIe[™Iâb\ÛY¾U„UX¨dE]6ãÜ\Å^& V]rã6F^ºUV€ÖÀa]Tgæc“P, ØV ’P‰}Øk>dšu–j¹Xtäñåat¥Ô¦«dL-Ú£Õä"ÿÎèäÒ4ü­RT¥‘­bÖà—ábèXže\]EmVh²í5‘[ž ‚¶õïè•-fe¥Û°Þ™;6‰&°cë$¿zÒ\DÛÙ¤ÝÜ¢ÝÜМ4+üjO6«©m¶j]Ù]%¦ÿĨ¼“åF`ÜôÁЮjÑîeAn[¸X]ŠÎAÕ™Ô°èÖ6kë4k³–m´nf´$a&R¬öV¸îâ [ßæCFdjašäBèÖáå^Ï´ÌrÞYVßv ÎÎÜNü§KÜnÈ®1ÉoUÖbÊøgóÚµ©Ö;õvP¨4è÷N¯||ÐnŽEaí蓘[F’Ô@¨Âhh•ãÀ<òæmf“ a«4¹,sk×G .c ÒÞ ¯ ÂãžTš®Ì¥“Ì âõÕi¤¥½Lm: `ѱ‘ 3Aín>û­RYñUÞIšÇÌæm}ÔÇßEã°cmno…¶jÐ6€¶½Ø‹ÿ=á”à`"G’"/òý^Þcpêä€ (pD ˜ÐnUpâñ!lŽàÜ,Y&#xSê« µFå>Ò¥SÒÂV߯â²ÂÞTóÜ’‰s9Ç×sby&J,Ý%Ë Ê®ŒËÈŒ(Ýâ5¯‚ôß5[ Dt|mV´jE7hâpÐ\HoÑÕÎo‘ºec@¨hí6ÉèîPê$ázè{õÜví}íó>AO/íîá D‹éÈTÉÉÜCóM®ÚÛÙLu· f7öµÜo4¹жRŒUáxÑÝĵ‹gQ65Ên>¡hǨ¨¨³u}tß­f”nykÇögØœÿÇñª¦²¬^Éãb"ŸY¡›i v/ú0úKk¯–t‡mlm‰G§oOÏ÷/Á’\Uhí¥nÎjƒgÒäŽdʜ̡ø¢ÍõŠ'4xU7Cz*ù¦ÆvìI,vV#Ê|ãC;f¿Zh—Ý–÷•?_ðd0ÛÂ|dP|Åy‘; ôÝ›cÏqѶñE‚zw| «¦O÷›q vÏÐ'ýÖ¨[&—Þ9%m5í‡f@ªõ†¸€š)Ó]ÑΨjŽz¨p!î@ OWt@à|ø!Nû¤e7oüœ ƒsaO$t\;û…ÚÒ;*öß~~Y¥–†À?`ð]_ˆy`ÿXñ¯f—?ÿô÷`·ˆÅ‰í]”ŽyÞæöËê È€°ê²ÛIw€×¢…± 4Ø¢ C†B„xï‡&(>œØÂ@ rdÈ!d G^á1dˆ–.À¬W‰ÌzC`&h¢•+Lzô˜cè>¢D‹"ͱ©‘G0<ðøà#†¦:­zÄ)×C 92Ñ„f+|È—Vm>¶móñ‹«/_…¹sßâµ§Ö^”|!èÙûKï½ÂôBØ£·´Þ_hì`²ƒz _>0ù€ËÈÕª|à/Ð<¨õyòjdÈLP³žìÙ²a"‘ýâA† î ÿ”×dàðÆ4´@®AyBâM0FŒN: -^„àáçÔ9ŒéáÅ •7_ˆÐò&ûÛ7qîL`à§TU‡âGZÔHÒ¥ûÀ[uöåP}Ze•G[y…_ò”0–Yg±µVZT—]üèsW[âõVˆý%˜a€ÙØRøòšc™ùL‹’Œ/¶H™ \†OÈ<0ÊCºVäeÔFÛlKÖ“+/ü$”K´pB'$—=Z¶AO—^n‰C-D'ÑEÐe=„”Þy'@S`$2Äm“¶Åä§A§–Êi°å—[:&˜Î=gQD=GQš½ÐÂð@TCz^Iã©4hK©ì‚ Õ¾“¿CÌ×} :¨_£Œú7PTYUXU}ñS;xp„”…¡Yj}|¡[©’ü–ªm}ň%v¢Ë‰-Õ™‹¯¹Æšf5C6¨l¯Ñ¬Ù‘”ýì@-Ab`¤’I.y[l0Ýï óœØm·-|Û†ábí-r1ÝDÿ D‘cg O!¼ë&wQ…ž>°K:ñ»gµ~ÂDA/¢öaµèÂŽ*eXO!(ÔOÿäp€_õÑTGpJÖK@]i‰j*[¨®Šr[}¬±fºŠûàô˜•6¬g-æÌçc1£YŽÃÊîÎÍ]™ÒIG«ôm ÁC‰QÓÓ-˜X_}¸Þ:W-Ü3Ô-ÈÃÁØpA 湄ˆÏÛ”Q•g“¾ýúË'Þðµ’€+óFþ·wšö§_Q‘F®@‡P>R)“dJ(Ý HÀ±³LH-ÙGˆ ¢ …ýˆÚ£Ãw0“tèSI*G–²„Š."U©Lö¡U!ft4ËVf³,% !ù ÿ,éÿñHp Á‚*Dˆ¯!¾Hœ˜Š¢Åˆ!j|ÈqãD‰?jôèѾ ø,l° ’åJ”*S6â°¦M‚ 2Ô©óæÉ“6xòÄ€A‡£’zè”éÒ§J=j‹AÕ¡X‡õ$T(Ö¢FGxÁ/^³ÒªMko­½·öTh˜+WÉ»xï²8±÷n ½|Oü¼oßBƒ‡*^Xëa-‘!+âKÅ‘òȈ"3cÎlñGH‰7ü-zA„ ¦l8ô¤J”°¢ô™“¡M\7iâÃ-vP¡ xBúTjS¨LŸÚÁ¨Õ¬\µJ÷Z´ùØxØ T(`/^ÛïÜÿÿ…W½¸öb¨˜——ïßÀïYÜbƒ‹Á{ 'F<ª¿ÿÿ‹ dD£@ôØc}† g?´ÒÊ @øà 2ÚG˜möà Üàá‡7ŒpÁ¥ö[L±Ñ†Óm»µØn0ÎT“o[UGœqÅ-%•r:RõœpÐmÕUV`E–wfu—xlq§Â“åÉ•ž 'ÄP%|îÕC|÷áµW ú Ô>ä“Bý ˆSc?X H .(„B"†à©'"wÒAF`ᜠŒbˆ#$*Y‹6W¨jAÅôÓlg„KO5áfMšÆö[QD1µ\qÊ•šœSJéhK]tCÿeT‰bÇ’Þ}ž®å¡§B ¨,`{õUl±õ0_ ö± OkTˈ)6­Cc>æf›ÉéauêYAŒk®ž7ðù-„78(Ò?€¨(?ôn÷½”E?#0%AÑ”â™,ƨ©Á.Úô[³B…§.ejqWµ ¬Ò eUubÑ‹¤vlUp«xäÁ…ž=ÌcW^Æ*KŸ}Áür³aâ´µjŽRfM:y$çÚ~D¸ˆ˜[A>|ðA>KPÀ½÷Š,2"è~‡z˜hpÅÞ”_£E?þ©À²á£›Cã„›¥.Âý¢¸µö©pF¥**r9îÿíwUÙrñ±j<+­Øm—k[Rƒwë­pýú«•W‹¬ÌÍΜy˜;/´XµŠåQGþ,Ñ HRAÑ"7mòëo}»=ùÐN/Õˆˆ8BZó3®=ŒÄàõ[óÄÀÈ["¿¥B\ˆ5âi2©Èó‹lgš°¦ ÿføT}Kì7©¢NåÃUXy5Ý«xç}d<\'äo…·ø[êo¼•k_}ûÏÌW²ÎÚÇô¤•jáL!iˆe0ó¦Ó! æò]í`÷µáÁny¯S ½ø§Ï~18ðŠwF|@ˆ W\ªdDÈ$» ´t‚=ìU¯&½ŠW‚#«ãì-*ÝCÕTÿl8@焢ƌ4‚ìT IÞ O¾¸s< ŽpX ÿ´´¿ÿk>öaV˜t²3ò'g¡ˆGR Íx(‚o™`\€U<(1ƒ‘³yžÄÇ%ÕÎJK`Áî’ÅóÐ#„ÁûÀêB”`Ùƒl)TÍOhƒ)R¯E1ºäŒ¶½¼ý͇9r˜w1Œ, K½Ò’<¸pͯ„˼ƈZÆ`dÄ<˜•¿—m±Y·L•þ2ÂÔ¦6=9£d¦c6D#lŠˆ‡R§:~8Mv& V°â';z`°mQ ZÒ~h ò:ñ‚ÈÒĈ¸ÁazäCDôZ€t³ÿ¶ÞÄ’ÿ¼!„B¢ê€RˆAŒ sla‹ñ•ï|æ#Ьh•(|‰ dØ´GFçÁZjôxºÄ"{Š·KÁð/K_:Á.Ù&à [ûafÎb 6>óCZˆÆ¥¶Œì-ÞTA¾øu+<2 €vž’îœà÷XB:ï¡Ît’ÐxôÀ%,Á!DÜ+w(„MY„É–a𬛩S”ãˆò ¡œJžãªè+Ô‘UXö%2~äΚJó+Y”K¥)Í„‡ )mLúTɱ%Ø’0)WL’1'КVš6‹ÆÉ!š!F«ºÖ C% ì6¸¤µ`Ç€-RТ‚%ÿD5R•ª<¢Š,¾Å„ À Z øUž› Jú©"æ‡õÄz¨7·±8P‚4z8 =c¯2ÇÆ’BÁþU°!Ê]yû*ØÝ%MvÐh|u¹¥½Ox¹åd+ëÌ"“³Œqfô,Ð ÑŠ«uD-[èÁ—% òXíP‹ › &PjS¹C¹ÀÜ%·,H'!qi¼ bÂÝÙh’ÃåšU“g-+Û85©­L×9#@U\ŸRÀ @r5P€ƒ¡¥Ò] ª×¢(*…T»Á Ò5¢àªPQ^AÛ92Ù ³¡kŒp ®<©î%˜‡<æáW{ÌC·‚Ü-  è%Ì# ¢ŸdŒ~CmØ·\ÚCðªö—&4Š5Ü€ñS6ÎÅTõ†ê´q’(sEè«M@…Z?  §A­cdX² "ÿRoÊG ­àÊE±].Ï*“kT,µ¥v´Ì÷õ4¦·’Ùo+sE7¹#T'CL@—Í ù2{¥KÝòt ïéœXüö÷\J6ð«“à'hÁ *=b¥mÚ4í’d©…PjéÙ=­Ù#¨•u ktÈÀFüAxÂS#"rw¾»BçØ…jù³YìL¾Ps•r¤<‚—çNÊ7ç²–ó¢öËTka [³ºÞLÆIƒr:4D\€PdBp¼‘òR¸Á<Žpâ߃ÞB  x~’þ}F—‡Ž’F{¼©®4 è³C¡¦ûÿ¨Ç¿¶SSâ7TëÂØJ«¾3¥AV@áç_xjØÈÝÀÊ8ÀP8øÓ¥W7«`À7 a ó©4"+ ;ì,) —(-÷`š¯ðrÀ€BÂ,T@€ PÆ^öÀB{ü‘&ÌT&‰1g:Åtn&ÖUî6ù)éòk'oLJ|É`Î7KA5Ô×àM‡DUXOëaXaxNV5ð}7ps×"ýTCÖ£"\Jo•*³ÖòGvH ‰ç,0‡µÖÕ#ÝЇ?fk|ÀÏFTÀ‡´&óÿ óà}Xka00‰@&„lü|xYAƒÍ„&=Ó ’Sˆ0*u/ý2õ4„¨n!&GpZ§„@% ú0à|ÐÇo'@}Ô7B!TOVrHUÈ}¶[òÀ-ð°7c×3q1¦"œÔj c}ýðƒ7ÔÐÔ@Ád…ˆ‰î8ˆðXk¢Ð6ðŽ˜(’8üHkeÀûdÇDŠ3µLhrS? (ì’.!¥R*0Aɶ0³h|·Ho¹( / C@CàuÊsNÆà…6Åc)s…ëaó`*5U9c!ª!~£ÿVjmsIt#=™ä4"]ÔkL@†ô§A† ó‰x5 R 5ðµF rý`R©OI´ö 0•=ЇX™•4@Ú@•µÖk)•ÚP–AƇ4•q-ƒ¶‘—j‚Ò íò `_Æà`ËãÁñY|Ix‘ @pð‘­`b¦G$)…s,(©’!4õD†„MêF|é*¶½!~Î¥†0†~kXc[1Q|§s¸Ž…‡µÖþ0P‰G¾i‡þÐOÙóWÅIxPµfÍYxÐŽA¦œ…WçèJI‡ÛÙ”Ý d4ÿ€”„g‹ƒÉäŸSîòˆP÷P%ýaP(ö€[Ç7oJø˜ü™‹ðÔX`€o0}Å8ª2x…!$B²“Lãn-ð%ð/š&w?Acw—0ª\œ‰B”â žôwý Vy•`œ…7×ٔƉ¢[ùô£@††W@V‡.êÐ dÛ0CSé©—6¨t2€¶UK Šf NÄç˜û‰|¹˜|<0§(maž‰ )C¦*‰g‡„o…¡ €gà{Èe7uç¡;™jÝèh#$­¦qI¡9JA–øHk>Jx0þÿ€¢:Zx ð žß™ŽôÇ›ýð¨ógºéœê8Ûxó×D·èitË­ ¢aG Ÿô)Tñ@%ù™¥¸J‘™°‹œÖ núrñocZõÓ WHš¶£(Ô|™&Ï€ Í'Oó8DV/fwª¦CCaecA”‚š©„ dpµ&@ ª =º©ƒJ÷GêV ó‡ €÷"§©ÛÐ^YŽÍ‰‡@6¯ïJx5{d:éÉÔR!£c )òamñ$ØQ[Io‘™¹ÊÉBJ%tÑGP²éhµ)ç}ç᪩Aæýˆ•ýP—CZxÖù¨ø dÚ0JÙ¢ÎIkQ[xJù¨N‰‰v`•v  ßi¢óÇ—±g@ƒÈ&‘`‹9@¢Y;u¡aµ…|Ë[úgމªù'" ùP|¤²VÔØ„Z($6{5B óeòd‘"#6!qØÊ³Çj=t›P¢:+š9ŠrIk_‹ óÊ´ëÖ)®ª;“£ªû¨±{•Qɨ…däYž:ÔÈp)ý¡tÏôL€o+¾³B%aØqNv»¥·¸±üùCb…&*ëMÊ£G'ó:µÿ³4ˆðl+°©±+€B…ölB ¯A¹gCÌ•§'Ñ)k¥Wí÷jLQˆßž@Æ”þýº•T‹Žî꺄׺ڎ°Kk ŒÀ¬ dF™®vaºù_žÝ&À ¼1:8Åð¶Œ4T"HKðoÖgº*½ÈG½ô¶‘à ˆ ·Pç‘²ß ;:¾\5e’sL“/+¹.A0gCjˆ=½acÒÕVœëèÚlxÉy¢ý0¯ØP• ÁOK‡óÇ®V»œlœ¨Ô—ý0}ø5`F}¹°Ì4 ¸€ ¡tk/·po ·îö…Ã(¥ØK «¹ÿЋɷúpúP;YˆG„kTÜ1aº¾ P]Ä‘¾ù€B¦³.¦³iÊ ³Vé“JA«ŸK WlxŒ©ý`¯ª Áš´¼Ë»ëOûóº¯,Ó9œlc‰È {p†F“¶ªºª&‘†P%LGÐl‡ÿ¦†Èô&ÃŒœ‹-À‹†tñ:ä!E†fh…¦g€`¾ 0z"@/kŠMK#ʧaúbôÛ§µ n…#:@Á?Zxeù¨P=0ˬËÇ9¯Ô@©èȨM[Ì@6Á௩«Ð„‡ é¹¾ëJ*ã¨ÈÉ{"¦R*ÉGgÿQ¶ºÈŒL'°4é¡°³ï Ïú¬pEà-×y à  ÆJXL#Ê/A) ›>¡=¨Q®6ŽK¹ÐÜd©ëœ¬©Æ¤5ú£aüÅЮÆyÁòJ¤b2S¢—Û–)]Íex,oËØ–UÌ(¥z”öÐgú9΀Æ‘)ö¤ÃËÃñãÄ$¼rZü€ÔÁÏœÏø†Éù€o! ¾’«­”ˆÊu¿zõ­ú«UÜ50Öþ@ h½•©ÛvPÀ8ú¨Û0¯à¿[‰»ÕéÀüÚ¿ÀT‰Æ[xFŠD—°6Ñ 9nðò®ú˜/­R¤Iš$Ô+ËÿcØ|hT5UPU±ºr§•/…Æ>|É&ƒZ”÷Ù„ZÊú¤4(T­‘;û\óàøC}'@fQÙ•4Zk® (úqY¹ºíØ]ù”l–c)•¥dg r+z¯ýo)œ9š•+ •Á ig6ÈÓ¬Ò ‰7À.·•vU,?Þ‹/—|K÷CBô/I¢Aï¬4EuØ'ðãô…=š´óäE|\+!jÎe=:{Ñ%”¬´±e&°ýØT aNܹ܇Žpy°üØ =‰0°ðeæÜ k61n"(§q:ƒIo9«ôvv+YEàÿáZz¶AåETDNNeÕå¤Ïâ¤úŒ/&Ã`FNPO- ¬N€…P~ZHƒB+`­˜‹§×ê¡Y^$\ž**àc“¸2`~E¯dûp¨NˆÃà`Æp ŽÀëýÀ Ãp;ðæ´¿~*¼Îˆîxyð‰ɰÅû04ñ'ñ²;ØœƒîצN}¡Ý&“zÆ(Š"…By†veDéúPN“ÞrIÑrü §%BX¨NK@šÆøéõ”…m±¦ÌÊUf8~|ºêÒ£Aékm•b‘*°[™M/ú 6@a@U° ¾#2`–|(€yoÑÙp‘ÿðw_ìŽ P•[ƒ4HÇçOà¿î`BŸÃPôEo[+l±-@y€ƒ Ës Ù ‰p >JÀf´Y¥¨ªð ­/¢:Œ@Âo;îVi;/Óx&<‘ÍA;.Ô8¼°(pިÕô Fm÷˜Nší±MävÑM`ŒÆp…féF\§û]å¦ü“›Å=ŪDPe†`éG3.„%;ÇsiX• ½ÞO€ôQ¥Bض•óP ûög²:É(cŒšæÁÏr2¥!B/7 :G€[}†eª2ÔoT²cMDETú.hÿã°#B˜MéùàMw¡øi'UM ç-à`j×Êý~bª!)´P¨f¿¾ñ†R´²#Fx‘>ƒù髯‡ö"Úcdo^ŒôbÌS1¯ßG! Ü#YrÉI”KJÞS©’¤K–&—h8¡BÃMš'Œà‰²É *ìíÛ‡o”ÑQG“*5ŠïdžZQ º`AÔ&0bq„rŒ”ÇÓ¬†yí­µG¯-ÛlÙ~(ð!_|öîâ…âV= ô¾)Ø­½lçihqBË%òšœ<Ñxr“Æ… H„U ð‰ÆWZ>\¥Uã;½ºµê×doXà‰Áÿmtïæí@Dê[ˆÈ!Ĉ+Îc޶ù¼(B†dvoäJÈ'!c‰&Ë@{žH‰2P D™*MŠôèø?¨R½ñtCÖ­%äÍÑäÇ– oÀsë°¸òʇ®‰Øªh-z„²'.{œ°ç/ ÓZ̬èáÐCòšxL2šì¤ŸŒiÁ-}:c`JdµQ^3 µÒR»1ÇÕDóqO6À̓ˆìm·ˆc(‡ÒLJ\K9‹ ãÐ,è¨`†:\úÊ»”¸“;Ê,/»—äИôŠjï(ÕÞÄÇ‚Z™ ú Z‘ J8T±î‘çPNRÿ³,ž»H®¼*¨K"‰&½Ð@Á$Ì‹B¹ ±±@%ÏÐ&H"q !ËŒ¼‚[a Bcm5iµG7H­µÙhóĶÛF(òHÝø99»ìjHÊŠ*Òˆ+¯”–'yvf˜¯FÊvÌëÆ$ [q$‘”Ôüî%™ÈS©Ò–b*¾(0d¾¨6 €®ºâO¬±Ž8”' X PÚ Í(†¹8M‹°À„rKÁÍð‚Ð0´È[T2CK”'ÔDœ¬ãõBèEO#Í5UÓ‘Ö•gœ-È!‡%v¼ ’Ùd•›‡"za®§D¥l `˜®Ÿ}žø²[íVêÖ:ë1z:†yÿìÜî^*“¨¦ÖsÏ©:ç›÷†n@¤‚Xèêž°4cFíA˹h¯d”Cæb`D#Gƒ.°ÀÖº‹I„pžÆ6±…µ±Ê*“Œ¼×j‘6Bó_ÛuG=×µ´}Å-7™ä‡œm¶™¢Ž0º¨bž‚6k  ½gê£÷qd[Ú:ö9ú#º{;sOROÎöj)ÎV⯨nèóÏÇ «_µlÔ¹œêv̱CÓWsZšOK(œI½",ò²@]ØÓû[¢1z„ ž±ŠŒfD+–!PG-›U¯€,™¥N7aëèñž%æ{ë[´…ÿ;ñ ­{y@LØ;|Ä _áÀÓ¶5p OØ|$ $ÑÖ—Èd&®±‡=í‚ÏT §úܧó`<Žà•°ìƒP9È äœ¥nYɈàv¾æ0L2ÖêˆS¸‰EnE† A ×–þUæ0#+ æ4«vÝjV¡[ .xå2 ™ŽH9’@V‘ „ Y=£È¥bE°,‹ŠÌ=Žð„ÛôG×Â¥iË:3Ì( à…LrÒ=øˆ#F9C´°$#)Ϻ¼Æ:QO†0Dæ"€ˆ|åî+m#ÔÔ$°]d1Ùc˜'&JÞ `iÑK>"‚ÿtæ uI ´¼‚D!ú§ ôANÄ(à«"`×´fe§I k¥2Òf6 ÖoˆåÕ-hƒìYZ6rPó H’‘YTI0ÙMrÒ“ý€)E9G<0ÐG™Á…®!•œde?:Ê ˜ò1”%KÖDèµÇ)v2Ä ‘DD| mjû ¡Œ`± }Ó*23ò³&>æÞêbdZàT‰Q/@ˆ°Ù™¼„ÀSv9ç9­úU3/ž?^å£ÓØè4pºíY:Ù@PXFâÍê*p³žAëgÐ1_£éR–A%è&' A…’ Æ;ÞG˜!Rˆª²ÿ¤!IšE7´%Ø’]ﲓ¼è¬0±‰Öé€Z(Áõ9ÌÞ¨ÅP—,u©¦ò¢©ªx76ÚCœãTH>ÓF®¶Èª+ î ¬jt&¦š¼]@hÔ ›=ªL¶Òg\ûÙa ‹Åb–ϼ9-3‘GQÑ\Âl¹xªò°¤%d{´Â®²±Ìh!Ke"  âCzoäSÓy-´ŒÐÁâÓŸ¾MÈ|¤0ˆŽ4Ë¡VC—êEór‡‹$Z•`Ú¸\Â}œ\õLqW Šƒ5¬¾Í‹D¬¹Í¥kM™m|À^-àtDAoú T™f˜€E^•p1ÉNÿK¯D‘¨ú>´Ð6på£Ó‰¯ pe<$OX))ië¼}ÜN¹¤ÊØ~Úï',Fb1ý…Lžl¤#\ËÞ¾yñP]„æ¡0Ó(ëåÃÉ “¼ZÜW¨Â”ðÁ‰‹P,äŒ! *"šË¹¡ eŸC ŽJç‰Ú0 sí /ä§Ÿy„‰:²™úJTFÖÉ­o @¢U{9é&l($] ež×5ý&>TnÐ~€‰‡òŠXøTDýI‹ÐBXrÖBá sñÂêSjI6|å¯2; ]BâG¯à”àw¿}Pi`šVåGÿ5?£¹ãÐ-õ­Hã@! ‰7¼0@ùñ‰ÄúOŠ P­¯–µáñ$€l|›Ò¯@¶Èö6@_–Ë·‰mió`*§Ò„m>õY€!¸ÂížJQŠcù–šS*1‚™Ð¡5C Ø ZêÛØþ]¸qv!úÐw¿ù} ÿ{EXAÐ9@Ī5Ó'Ûêö37¾iõ!a½] ¶jÒÝlE.ÊW–\½ÑÍuð‘m¨’Á@@TIl˜gùØœt9Eg(rÌæw³ý ž(` ,1}¤å×÷î!00§#™Ç"•þ³Û9&wå¥-ÔÓD*ª¯haˆ)œÖ·ÿŽˆâRâþ%„@ü°Ü_Ðaµ9xÎjí¡µÂóÙ+˜å&7„ÔMÅY—q½¹¡³.ïw®sQ¨@ð»ÖEK¾P#ÄF€d‹ÝÉЀª\¶±cKéa›²ñ¹¤òŠ@Ù‡:P›¿É·ØžñA½¦=ì¸0Ý 4ýñ0#rÒ:Ïâz… x2>‚KhÁIû·ч‚éC 8)5·£¸Ò±ÛX5b1ŠP¤f2—«¬¦“lYâé†û;,G€(¬¡£±ÀÇ#©ûÛ²¨?-ì‡Ë¹’Ь¥0м©X€%ò—îñ6ÿ#h›;+ ”ÀÃ=Z ó¢òj7æÙñi´.ßAá >\AD´áû7P(}àªç5yêê›®…{™ˆS5‚à…íÚ ~¨ ûa„Ú!ìh:1œ%&¼Ž&3¬÷ú;†ÈBd+©.{9ûëWZ’ Cœ ú¸aœ€Ü´9“" "€8佉Àž¡À?i¢#KŸJRªïˆºÈà @ ꪃغ®®ì7dÁã3Ǽ„ ¸F¬4ùñ4x’1œÇê#ˆóÁßà>‚ˆ€º« |-><½J žYJEhEü{//T¥h€\¼Åû+)^C79ŠZPŠÿ\š—›ªCø'²¤A*Ìe\0É›¶h¤:HÚ³$Ú½lÄ’ ®ª®á"Áâ:AJ`Aâ+Gゞ´Á¤4F”ÁqJ»rdÏ©‘Zi;zTÜЮîã€Â+ dÉÜù¡óRÂTDȸ¡ê‡`H.„ÈøÒ˜¼M"¶$h îðÅ÷ø/ @kË Fð¢A:AaCÔ›¦ƒŽ8£FÁ²$A3” c(FÙF̺Áá"»WQ…~ƒ§x4GŸdAD;`€ó4JŒ“zŒÊ9µMîã‡xˆâè0ÅT¼5¦BȘó]Û¤’Ò¿‡T¥`%m`HÿÂÓ¬ášýêšÿšƒ0‚IÒ)z²Pqã+HJ*õÑ0=¤ÆÄÖÓ*p:'ƒ01ò<±ð>Í Êr<>$¾u4JH|1ÎI+?J™R³§{¤ÙÀGìò€íâ…ÖŒ‡‚ƒˆž)ÅDYª 9“`ªÁº¿Ûì‡àä¤Åk¼`³ÅÛä$eÓÅò(— K§h³`:˜ôžïùŠ#ÀDÁ3 ŒÆ<HÙê;ÆÄÎFY ‚L¾âB±J“´I»Ìá[OtôÉt>£\±‚1Ü‘ì#ÄÄÒ© BPlM›Á—Ÿ‰ŒD)HàYªò[‰ÙÛŽ% B˜‹¹~ ZdHÿUJK6 ¶‰êyPŸ Îü*ÃÝ9D¸~ˆ@9½¾ô6ÈÚ7"«µQŸòk‰«a·»qÌË @ˆñ¤$.ô|•;Ï~kAsüI >EDÇ @RvôüDPʵòœ#µÒA¸JM}(nb­²CÙ<¿1¬.•$sáEÓ~°‡¤Pe£El¸?ÀUBb“·`Œöé˜É°¥w±Ë¬0„³™‡v b’DÌ«@æHT©ƒIDqTF9I ‰Tñô à»ÔâZ€CÏWxA!J4>JQ;udGJ`€(°M9 yÄÏ’Êê’ Þ¨¸ÿ¸«Xc+!¿®l*Kª$”ø Ê Ù€ä-’Šó€xˆ K>‰_Þ˜´¡áƒŒ·@Œ·8ŒÃHâ¿ €yȃM·p‚(À‹r®LÈ‚KûâóÄø•_øÙQˆ yá¥ÿ³éÙ½4”%×b€ŒñܽÑRDm"M2j<§Hå­ñäQà³àÖ%®þ·| Òæ7²]¯óL°cßú€§´>‡E )ÝD+-–8*ñKŸ¥ê L*•L³Èˆ#FbßÂâ¸â7’_úe‹Œ6h ¼8'srO´*^¸4åû7I+‚€ûbpßÅÕ*lU #â%C¨€h>uƒã± W¾ªc?›?ñ \צeæÈ d‘T„¨àâÊàBÎZóÌÚW8OE.aF^äXôÜ]F@„[¸µ‚yŠar T£X¸áP¼n-DyIÅ,¿¦¥ÞÝ‘a’ÿx+rRÜ1œXÆ ' eùÕªJæ0Næ/nG`ÇSmGdVfùõÅ:æh¶ÜˆÑóž¿,Ú¢ÒÒŒµÑe×ruWEJÝpd#äB&OÝÚ®¥çG[{¦4DP$}faáuÊéc ·…ØK5U#$ Û͘0¤]µ¹3Í]<£&¶`{Ó´‹®h}èåp]ÆâÅ-Œþå`/ÒKGÀvAF¼´£ë|¸S3l˜þ™6ÑÓ³AeC“¼ÑV&ž¦FTV›pÊC ÔA&. 6ê£.O€«´wþ7~Û7EF>°›]¥4€ˆJ¾Áµ½§µs[>2ÞV5ÿ.h°n fòæžöãÞc³p‹Äh>kR2r¸Žëxèår¢*êÆè÷ ã/cc6fF¼Oì“Fi•8}ÀߦØß˜†jÎk6”“,*9<à±öiq盉×Ð&d´`u.OÛZ÷wîZø`¦6á#¥…Xéƒ á¥'ë»dÓ˜R®®UºU^Š`–FEªYbú)€…0Žë…0§é–nøÍsrñ÷åd&éí®qï>éñnÁutAònDU¸4ðÅHcþ½ÜÙ&·)Éž&룽[…½us@æ€\µ  ZÒ&dÒFçÒFêÈWÖ¦4§çÚ-J0ˆÿç£>ébʯ•· ¸Ú±î»áfF€-´Y°ãö—lt°)™Ÿq2q~0§Bçekè†ß^îe~àë`¶ñ7éÀo/o2¤˜î_ÿ}ÞÇ(­`Q݉Érµl¦#åÓË祦ÛºÑFç-÷ï.pC>mAÏ¥¦„}#säÛôl.µ…®é³‘®ðˆµ Ü`µ¹ —;çæžv"=>É@·¦æ.q}ð}0^æöw5øà‡-ã½Æ4IÿñbÆññÞñÀï¿öñ"¸Ó£Pl^’€ ‡ Åcºè À€%ü’pCZ"sÞh¤ìžAŽ'a]òÿY/êYïÑ\_ä >?R~K8Û¦.ñç…{áN®ÊÝ Û¯nͺÀ<‡€´Ùóñq1m/ñA7§nosâv'÷B'wín_¾®ñïëGétdAxÇñSMéçÑ_|f}Ç8<Îb*øl¹3dZÞÀLk ¾™ƒÀËd¼¾«øÒNêØUäxá¢ØR»uŒ±&•ðêÃD=‚«Ó©U6ƒ&°ÐxyØ©Dݸ t›_ˆ|¨èŠöàöL+w+rÏü‘¦ñu7úf¦¯ôKoúCìý•ˆ0r§%½ïÔë˜l¤…=?|Ú/*æ@ ˆðìñ¼ÿÑîýÐNçÞoÝ×õk~{û‘tŒÏYJy|.Óää¦$¤àÇŠËa{€ÑD}@ª…¿ˆ jnñ×v}ˆnÉ·ªm¿|÷-ì¯iIa6é·t¦oGÍ Q ˆé‡hRˆ'XÜ#CÀÁ pï yKžˆ1oÞ Œ) ,!ð"#F>ä3$¢T²L¹bEÊ•/gÒ|©ê¥>|PZ@‰çÏ ”†êãÐ —.ùܰAˆ|QqI…磌W¯RºõëÕ øœ:e`–‡ÖŽ0áÁD¼ŒbÈ«{¤.‹y%X°8áñ#={ ðÓWX_>ñ\ÿðó Ï…¼DðâçB„˜/Oæ\DÄç"EVˆ.mº´*Ev=ºtik¤¬wöò±oß(­øZQ`È„„3úHð #8r¯®<¾çÅÈHýâÀ}³ÏcDo¤”P"¢ beL–3Ï×ĹbUð_ù ÿ*ÂN¡DyæŸ}ôçC=%DWøP–‚åÕWd9µ€Y¨åAèƒÒIè™'ÓLt¶÷ž{;½²@j>,@~CÁGÉž=¥Ögj”ȶ@SR9ÊV_1¨`¤Nõ 'g±åV[ky][afˆ%DwêG‚åCRa‡™øªŠ…©h‚Œ—½h#Œ˜Á ¢áX„ŽÀÎdkCþHäNFjõÃ’„gHüT`OqU™Ã>V6÷Ðs!ZçݘyQ_Ñõu#écÈ›pŽÇ{2¥4ï9ý _|æ´'}+¼òŠ¿+¨"ßLò±vÓIˆÜðTQé– ÄRz)Yš•–§®¨K8Ç-twá•#ª†¢¬±¸¢Š"0vÿë‹EØz£ŸÅüËŽ:úPÛ±@úW¬·YeÕ0ùd›«VGQAØ"¤–Ï-q‘š*\§—òtIª™Ö}÷Axí–§z"Üyö¿wÛ6© ð£«#i"¬øA,éU£L:ñVn%VÅ™¢¥Öñtú?„úÖ"sXWF!°ºâÉ­¾Œ9c—ñà g0Û<™Í¾öZD/À¢N±ÄþìóQBoÑÀ99Ü´Õ•P i@ô\¤F-òÐñ•Ww–çÞØâÅËz0MSÛ7]7ië­øóL°€¥wå÷‘^ >±ƒ0¡„ž¦e‚[ñØs‚¨ùcPÿP·#~÷øIÊóœ'%Ë% ÿøR<Ñ\ä# !p1‹› ׆Þõ•òxe,£ðRy—–º¥`b x¢°gAœÆ.D!Ç„[ûkåX:­ëM ‹iã3þ‹¿¢Ñ‘ÿëšÓ xHHQ-íj%áP«„Å“G#ÂB‘q„jùËòFÖl¡$ñX­—Ö±aF‡#IñE®{ãˆz¢J_.H]}¬€º£_üRÝÀPƒLX‹¡å¼z …ìר-µ÷½'¸áªÚ„Æä¢DË5Óo—I£:ÕðºWwì)²„ZÚÓö,>ÉÚÇ )0ž£ §dŒp0 "€l=’9[™n±f¦3‘Ìr•4yHÿœÖâ¦õ“x{¨+o¬R0Þ£ êŽh,C@À!LÚn.~å p<ѽ~ Š ÀÅ+^‘%ïc@üG!ú½E±ŒåÖ=PɼðüL­ü®´ª•㺠iÀ æÕìšä½ù6]ã —™›ÄRÀÚß4éœÓ²Eàl¥lE˜…yÎv묭i¸!(}’“x+’ø Ђt×¥[ìnÁ–°þJ/‘†ë/tøÐˆÊãÑ-Æ¥-jÑ \Rã-¸',vÞ ÕCñ¨NäåèHÙŒÏC&Ôš+…<>$˜°Tgò“¿Žå.gù±|¤¬’ä„Ò9©UÿJÞãJ>H„òsåm{è¹å‹šDòww-¬­¿ÛC¥î¡¿ ¯¶×ºÖýè(HÄ+ÂôŸƒcˆW¯F$öQŒ|¤>/\P¸0¶ÉîŒl B ª3¶‹zײ® ßS’«fñ§ÓÙj†:fÇ·œ5Eå)€râ‘(™ QØóH™9£: _uLIˆÍ•‘Uˆ)Ô…ŸMÝÔ ñA ÙEÔ=T Ù}Ý\Ù¢pÀÏ ß¼Gù°5 –‘]Ì„¤EŸã,Ç4„su¨J¬™»¬DÀÄÒ ÞÇ ŒâíDŸì°_j¬F°Aži­ÿ\±©FÌ©Ù8‚´œc‰Ë=p€ÜCw|=h »=V‘‹¹ „ ‘ôˆC]ÖÒéCÆÐC‚O,Å^-Z]`Ý¢éÛ|Ý$”>\×–| |àµÉÃ<èC§õ˜ *ó=È IßÂ9\ ðÏè!¢`LÙª8×J´L`Y»¸"”FÈ!ÞløWùF— K"‹üDë¸Î±]ÅÌ“p”ŠÙºµÀ¢©‰±›î9ïAW*˜bZ^I]¼‰€ Y¨=QÛ½]aEâZ4Æ .ýT0ab·ôÝd™QxŒ‡ú?¼ÔWFZ}F÷ð”ùyY+šbiä׌ô  åµÖpdä´4•Et¤G²Ú׎áÍ"Or›GtÇ ¹}ßZ}’‰ Ši5ªIHÆMã ^›¾í[ùË+èCŠÅ[gÆ¥QÿÂÚýMÀ!Èò- æ’¦´ ÝùÒ…$Ϊ9n‘LÅ­ ª‹!Œ#„Àn †öíâŽÁÉÇñTZêNéÔÉÔK@‹½” (!QÕÌåæ8A‰`4ÕæÍ–U6šDM t Dˆ,uXNx”ظ„ŠÍ‰!Æ¡I 5ªI*‘<¸[bŸšh½„O¬ÀK©5¦X>˜ÍQ®jFJTœ&ó­#$¾ãüÌc<ÞAŒêíækuâÓB>ð™ é–|Ò•u#ެ¢qz–ÍÑK9i,½¨(‘Às*¡'ð \ÞÀoŒSuêƒ.Úe:u¤ âèÁÒ£©ÉxÂE€ÿ„2ªUKR¥) >8¹ÙfMæ[¾yF€!f¡—Úd9†fþP¿ØÍ¥U£D™fðD:ºÝò-èà¬#XÜ0Šyµà©ÑOý$N"Ѩ|I|Ùƒ>ºáª #%Í H¾Šg˜F]åfüÂe\Ær:‹.A b¦6A´@§²¨š–Æ!kñ(9A‹´TœÕ¤“‹j ægÖåÛ£ Ï’ž ÕðexÚyPZŒø –Ué`Gò@Ç–DØ6AíÙä=¤màQBq&^9Zä‚ ôO e‚bT;Ωœ¢f.=ÆLß©Mßô@õ¡Ðµ‘Ìö½†ÀÌÃjÞùÿßµ±,Ñär>gÕŒ¸~l¥Òƒ‹²ÛÂê–¸›‘r£dˆ†‘D@ká"J?ŒÄ.6Ø ¤S¦bÖÝpõÙ0Þªu$Ú”…ÛTZ ™Ø¯ªuÍð£æg²b³èÒÀ˜i4Ê[¥†O„%è¶2eÄÝjÎOžê© $ÎÝ i·„¤ª`Ü¡9 ‡d —XeÔä¡|:Á¦,ŒÌˆ­„dJÂÅ.™«b%Ž p^×8O”àšxÈ`Æ ?fvN]Œ† îØ[¹Ud¸ŒL9¥F/¦rjÂJïíQc,q­ÀÞk‘SÝf¤æÿ­=Ѓ @„Á*àbpÝÅc'¹o?&L-®‹¬D”®Õ«ø]¡N€FTíii¼MfÿƤsu®@•RÀÔÇNè„hZ°iªnêVJëZ HEŸ<*V$?„pð D ¨K€®ázÇ.~§…¤‡Ï »­=í¦©Ì[uΦ±¨ƒ§zj»…2ÛÆèðQ2çƒ,÷îƒÔNp\ØàU\#ó-‘æg^AGŠék¥Øk‰%bŠÀ” ¹g/ã0J”|úrv-WâŽÍzsö̾ ŠEÙñéJÌF5©Å?¤WÝÁ…bUˆÉ  ² ù¶ïÇþ¦o~çæµÀDDÿTŒÆhS9A0'b†fPꊶh xòSopÀ'rH)×v-À±R}ïk“a”p>,1vžÐ«ò_Õ`ˆˆ$2ÚHÐo‰YÏŒE—I›Ç*!Ʊ칡› ./7ׇ¹ÇMóÉ¿@«}4…W$å:R‘£°®SÙGaŒÂѹÂÅ„³  ÐDôݦ}§ö¹3Þ,1d曺-8jõÞî­5s® ̸sÚCЃ@óð¦rÀ¦ÖçA—òÛªrÜîÄÂà_œªJ-Ï–ß¶[}rI~zla¾‰Ôfè¬qÜeéZmq¡µ!fÙfŸN(•Y–¡´q Ô?aÿÏ¿Ô}ÔÇ ˜®·Ê)Û1i;©k/œTN¨¹zÀýà…”%_ *I”/ ÄV‡ÈDœ@§ÞX¾½Ò sm¼Ñ}Æ[¡ò¿ÒÙVo¦Þp·Û&Àò ÍLÀÌ%Æ=IÅÚCxïb:©Â†á¢ÁÔÒvXÁÉ®!c×tJ¯•r6¦Š]¶sÍf¬ÄyœÙhÛØh« O¨uiW ‘ñ±Q+VÒz0€HDFàà:û -1=ðvðp88Ê3¦÷ Çp<|\°€sÒCh€1ljwj^±£)ôŒ^ÆûíÃ’ä&^Óea~¥îöuA8„»Yn6Þ˜˜ÿͼ¸¡ÔVY»À7\IWM?ªËÄÈ[EvŒ±•ljâ¸Õ„KÐUÁ°ÍM¼BÛÌ„´ij¾·~ë¨Yk»àôM¨[`Œ=tM'™Q”İ»:2«†$ñl8%êñÈ3¾}µ?PŸ”À²¨¸¸ô²­õ©Œ.ñY·ÀYoïsÞÄV,à\¶É“ÐW6òýTf}Þ®¼ QLad>`YZ-öŒõ|žÊL9‰¾ãþ½9][Ïzhv÷ÌDB©*ˆ@±ƒÆ Ô±O‘ƒæñ‚ª¶Gs%Je9Ÿ?ðÃ<<µ|mZVV45­¢ïºÕ…»5V·À çÃq7lúÞ®¸‹6ÿúôRïF8ÆC5Deïe܆+w7î|z¨/˜·ÛC˜¯DÚ çŠÀ”®™+e;µ ºî§ZÑóÆ?˜oF”ˆKñ|S};‡ÿ«ÿE6Ú6&ÎðLiŠCÔ ujÆn8«ž|¢»Š·¥ã°>ø;pp÷šed›ÄWEÇXÓÇÚdtgc9®ˆJ„ÝÓ%¿eY}³áf½ÈÌœ¼ßÓÕ6ÿ”vÜcû‹\F¹ÿ~­ØÊ ˆ¨½)ò!¸‚Ÿ´v¹vp<†³>@Ùj„ ^¾L:2FØä ðŸ yò0Ü8^ C8±EŸ EŠôòqé’‹]pB¯E“&'‚”w†˜w¢E 8‰âbß> †*|˜ð¡BО@?ØcT ¨=zöò©8qO€Ay1ï5Øbê¼¹ô‰  ÿ"}>è3¤O"µhÅ¢uÛUDܸpåþ’{×®ˆ_úV¼åª/Ä[¶qÝ…»"n¾(‹çsÑ•/%!„ૌßÌš1_Öìsæ £lXÀ€A‡VˆçÁƒ ñdë3‘/ž>{öNœ˜Ç4_¾ Áó%u©ëA².K° ðüIz.KN'®ïE1ªRUD„>ÈéµIhë½ 8È ‘/½yKš,¬¥N<% J–¬Ýèù ¥T°§À§8ààž˜œÊÁ˜[¡°¶$ÈG´¾J+­¶¡0¼äB¬®» C‹«\$È¥,·Ä /D±£K„\¢ )ŠàfÿË>³,4Î4㬲!7r4Ó²`svĽКQd{m‰«óJ.Á"*ÖAƒ[Ê|œZå£6rjÓ6ØšÿÉlŸŒíëLc¢‡±|þDm/¿$.Ì0|·×ò-ÉÍéz%ŽNŠŠð[`æ¨Xc£°§l‰î’_~Þ)ÂÀrbž¥' PRŠ’@uLAìQ‰èª²Ã…@}É2ÌZ÷:áílDr©•[lw.®(Fa IÖ«NœsñŠx¢É„(ó£h )HPk^ÖL³OÜ 5N2ö°—©6ÌÄ&ŽùIÞÃ}81Yä NÒÕ@0a0_úŠ ò%®dù¯}ó[ßÈèð¸ NhHéD§ÆÙ%€Þ¹“rrC\ =¹Ü¤0g¾h c#ã€DA æ+>éë^3¢ v/ÿ zv»á¡0…J ¬dU³·'¼êU|BÒclo:ú(ÍÓ4c©Ý04XƒeÖp­®±fˆSŠG< P²Ý$8%I—` E)b±| \Êóµ4üÀ¯N|£_ßìg¿==&85Y£MÚ艅pwê[£î˜À~€ Äànvs@@ò(YJ(h•–0ä}ldªö)<šýÊwþ´Q€¦²ô "pqË‹#Ê ‘ $ö,^`|°WVÆjÐÃá+©5šlz#èZ.Ij%$:fxN@HÞ’Å9±˜kûáã¶é<¤|ÀY”^îD¿Kxç"ÖüŽи¿š,­&¡ÿ/~Ô‹P³Žå$ QÒIFì&Lí¤=œ‚’A–L*§{Ë2³6ò-¯{ѱƒ¢‡R¡š(Ê“H÷õJ_Æâ^Dës²é ‚0Õ¤…Wâ±Ò»Vµ5›¯Åƒ«N(ÀÃεEwåÉhÁ9ûI)ª+8mÛùrÄ/ù4¨AÍÈPÛØ›x„NýÒ3r r"cS] =®šU Ìã@¼!Ù‚À¤]7…úX–*´:rUôç's§^¤xÓ¹+Hæ“y¬´:%¹Q*(’–aY?²€,¯ö‘|âQùcËlŸ ìÚ0‡öÀö$G c;`u܉U1§ç¢0"Tló‰é!6sÝœÈs00 ª.f "•¤½Tõ÷->qVF¹¿Pjš”j‰>pcìÊ£>îº"ÐJæáÃáÓr;h&ÃCêUÿ|C”I«ôE¢Îe}ìµá‚ˆ€0rK `âL–Ìð[”7ŒgŒõ»0†¥-@§ª™~:TU{²gÞœ€)EÑ@oƽ›‘¡ä9è.îs°•¸ç=.‹ÝË`ïéþ,YÈ¢â¶(v t¬aÊ1C²Ë½/&¢Èµ‡*ÐvèÁ]îíըܵ&ålÑf[ñÐødá|—8_ËáÿÄ`/>À¹A£‘-Å~¡ùÙ~0Ì… T€QÓ§ìŒÃ|‚ pª0ÄX`’BKå@T Ü¼*öÐfOÖ¤A Ì IêZç÷ ìŠxåF BŽO1È¡´k!j:ÿl" l"ìÐneDÀ‡Fã°¦â®ïí²æ£j 5F 5¨Œ[¼þ 2> Ù8Øj¦ýܯ³2K\” b É›D ò.áò(!óæ ç0‚žjÎæÈÁBOÃ( $  PìáræA….жjõŽŽö ­-šŽë`Œ%É“Äl,…E4m!Ôªìve1^l$¤&† »«àò¡€VéYâîú$.â¢GI~Ðâ®Gï¢Ä[8kþÆ,³Ä‚Úïý ¯³rã\æò°ä#".Šà^Oú†o®Ðo茚Æ~Æ#ìÌŽ& 3' z£”bõÆ­@"öê0ÝÿŠkMÖƒMêÝT§}ÏC">ŠcƒÆtĎǾÇÈf° ß±¯4iØ™l£” Iž¬Z Y#\ƒ[Ä/\ÀÂ#›£þ ¦Heñ$â‰ÒË<.ág²² ¥êħ駼Ã"^î‡`Ô¬šê*¿«ª$%>À åAÀd7T €+&Ÿ%ª‘örÀÕÑB n\§B‚Ò-z(ÇGÓºëTzÌÒhÂß*½k:h°‡,jÕ`éá²Ï£”Ä–ZC[ž$—ø!7FÚfÌÜo! ƒð\àep-?¼ˆÌl1Œ^!ó†ÜNLthO%&0Ý0ð¸1|Ž&Uþ0ÑâÞc,å)KP»–câd® 8ÀAœ`aòÁÔ’¯+ k°ìΛäâ®GJhC`Ñãö§´¬„|þ DøaXzþÐ"7Šò‹6Ðï¬PŒœíò¦‰"ø&$ÇpÿìNô$05 ·ÒsÏ® ’õ²ªI¬&'cO'ÙcMè…ëŠCŸúÐh’mª¨A&êc)yŒ5Åμ8`@[@5 4&Ž »–‚/¬e’ì½f3û˜¾J#Öú‘fCw©7¡¨m¼H§žˆðŒ³ðŒÓD+é-Ш#ÿzs.»Â¼#±PF§3O²Ã:ÿ%ÚtÑ/ H'L²¿ |’"xƒX`@²P€«1)¨ÓÓ­A¸.oÒjÆŒ¦, øÊŽ]޼ÐÎSD$D¢d tARS5OÆ rA›X j 6Gî6ÑÉË¡ 5¸¦5F‘Êv)7 †È‡¥Š 2HtPÝÂ˰©þ(khä"#Ó,pŠÀF­ `tT¨ô$ª& ÂSS)Ð~n ä!˜¢—þè·ZïO³Ž öØCÅŽ+TF©E .ÒÞ"0ÈÇÀØ +Èk¸ )L 4&ÎÔ@Ñ4MŠ"Yæ±úà û tµ'îBƒPÿgÃ[ïavM8uª¥ ñà/<< "Ò8‡GE!FQÁ¨©bôÚza#zÁ›lÔNðä.ùòÁFR'&'ÀCDÀbÿ…g±®Ø•Æp{%Z@M[ @ÅŽ57AmÂXÊB –j)ë°˜UB£ÕÕ&î6Ð+ÁòI84°õ\Øæ=´µË[a„ØÆõ“Nq\h¢1r¡ô‚Ô´ Ú &ªVbäu~„;5/µ ¨?!Xàªj7Âs)!)—`³$=Ý ðtUé(¨aé o­8’E÷„'VòßîÅ}rë¢@q~!7d#ÄIƒ.·4ÚnZ~`ûpÐ;ª—„±À¯Zë!±•8¨ÈÀï-Ú/v#ÂDáO8¯dBiˆõ&À¥”꣛(,޲¶x‡±šz¡€~"<ðªÿ0çªxk7æa P{ƒõÞ6nuÕ{oö&¨A|c@0È…øP0ÊÊK®(hp•{èê…Üwqå·W{5AuåFÈN-,sùNûf9Ñ*Iƒý1ïÀϾøÁV1xXŠì “3ñ"ØËä/YçOŠaJÂwÛ`ƒ›Àw¥6;ªÍ©pkŒŽö·N…9Fy¿íš‘^BÕRœb N` ÐcŒa Ø“Io’öŽ‹^IoUGf>¹þÒe¬ì ŸŽ ”^q#¤Wt~WWÈÎ…ÚôrÛÎ\é2㧦Hj3í4¤.ŽJ°‡OKÑ0ì:Nn“JŽÙrñ¼ì‹E)d‚Çÿ†q L]ùj+B›-¬Œù¾ ½lÝð7.çrŒ‚…¥÷…P>d¸7€+né#aönò…óv.x,8?ÏE”·h¥ÞÇ…’e+ªqëC5CA[  rDÂ5G`n`–mPH^+cVzî®TÃãìËtM„Ÿ{6 rý Õ8Yܘ8.mŽª&pWMIÖ›Àé;äh`~Š ‰‘ÿùŽö%°ÑÙ(\øšça!{{£’/‡Uõ9¤¢M¬ã2W'ò>“>Y$GÎ}Ò臘!Þ‘•WÓF¼¢ùáV€Š­Y1zûz¹Baí]ƒ6\#—ø4ÿÈø.Úâ,јPMôýÊÕ™Éç#Bà‚]p©˜ê¨Ö]ùÆš¸0$ŸŠE2-æG}Ã_$Ù©¡ú‘ŸúÄlXt ‰žUÕ*m|Ѧ×Äç­XäŠÔç¡F ßZ”·"MA–qci˜B€#—5ã–­òáæš‡n“èk7EšJ¤n.ÄŒþžÐu׸PÛ¸9_8]8àL~ÜuÍ„Ñ"DØx½Pÿ‚*'.€Qò7üz ó%îY@ÒóS+™õÖ’[›žíÙtz8å2D¶Ç·?@‰¹Šx”zíJ÷¹V{åq¡ò¨¥@0 Ü-û6`¹=÷“D4’ÌB«'ïÿÄ,õŽJ²O¯»ÌÎ8ÀZ‚}ߪ#^š|rk¹ô¶Ã/eŽÿ¶PµTá½Ç92Õ_grfs´Ä ð7F ’I§’O»*9á(ˆµY[U_xÑüy ÓßîmÉŠÁÉbŸ?óÁ‰¡~»&R¹º'G˜"ñÀ¸kÉŠù7Z?<Äo¾¸ï¾oºÁ¯y¡ü6ó³È¯+`ªDKtÑ™Ù8¿¨ê„óÖä"Œæˆ¶D8µÔÛ§îò"À¹;/æGç›·¾M¨í{ Y¾MKœºÊïá‘’癵™”µ½ƒô¶ŸYDp—£ìÊ‹Þc˜ö™ÌÈ¢5m:*Î]0[…³¸ñw•ÿú\¹=—NyHk®EÖöt WœJzSU°Æ3Ëu!Ãä~¶ð–3Ç¡éo±§`Nk-[Ó)õ›Õ,'~â$é›·fòÛÄÄm·ädøÕù[Öåù†„ËqØ x8ƒÞ8ôVo],×…ýgö6Q3DØ™+.á*䨘¢KCχd¹åšÚ·ØZL—øZ6go(ÝJv!h‰ ]¥Ð…&‚çw\O.¬šptΠ­^f w4'ðh_Mz?ûÛŽZ H‡VÐÚv¿)è´› ªWû&k=ÀE§]rÝ…£,Xd¹|8ÔľêfÆÁ««®†ONB|°j²F –n ä­¹ÿ¯FZE|+-7ÖJwO[žJ¨»vi‰Ãã_ƒ^7-€VFÝ1ˆŠ–M~î7ræê'Gan …|ŽrÂ'Ð %y ÐL%ÓI"¬~+àgýÕ«Ë·žëé鸎 á5™^¢á{]͇o9¾ÄŸ×ž3‘-C¶úÅÉ'!®„­As#€?Üé]Úõ±ú8Ú ?¤EšÅ]`6ÿÀ®Ä"Qš-I´!gŠðP àïú…"Î p.ÌwTµ6à#¡mæˆ|b‡ öÍ‹ÁˆžAƒóÎ ao y÷äÉ[rbž†1.Yr/ä½GŠ Éá^Ê{TàÐ2¤¼ÿ?ä ‘Ï¦Mœ7w~ˆ’3Ÿ>}†*thQ}BuæËùóC®ŸLíѳ÷tÄŠ ܸ± † ð‘Ý`ö,> hÛš};öÇØº2¸;bD¼½|÷šˆg¢Àß¿öFú4qâBù¹@ÄO„¾ÈúDP~ì‚ßPÉŽ5pZ¯"¤ץ^>.¹n­ÊGl´i_j}ûõ%J¯e«RµoŸÀ 2:Þ0cBF9Ê;RQÇyO,¹xñ$I C¶üîÝ%˜2iÒ ñ'N›9õ¡’þ)ÓùGé­Ÿ/—Ð÷ñÙç³JOü ÂW_%–\c¥—[28V„tÙÕÿ#xЗ_€m`‚¶?ŒåÃØˆŠU6™dˆdö˜f" bÔeù¸ Ôg Ýxã/¦õ£ª©âšjµµ6$n®QBäm´·Ï@0ÔB'°Ñ<Ë… ]WQumwRH%uwRL*‰÷KÑ™·žTþ9õ>q"EÔQKµ”>¹(uSüñ=ÈV\-Ö ’…\>ÚÖ‚ÎÕ•]b˜¡_‚ųi‡œvXâbŠ%%Âú¬è"œYæÂd­ê“¬DáD>NåD.¹:‘kŽ=涤lÂÚfÛnµ![jÁIðÁ“ÍÓœ–U2ÇEU„‘—]T’v&´RÿxßÁDžL×SNëéç_÷½kTž8Eá'=öÚ‚Vi0h>ˆèWam ×¢‘²Õ[NºX\y…?˜ö5` Å_}•ˆÕ¨þ¦Øâ‹)žúØd÷=E+=m´àD m¬ü²/·Ák¹ðòK<þÆsÃéš’µ%œ“PZIÏ<UIÏ“I[ u¶ÖqË-™"Y-’™g¢¹õLóØkOzo2%_žwòçœ6Mè½nxo>"‘¨Àt-Ê G ×ÂÖu—òׯvèé^ó% ‰$>þ±e0¦«f®šl«‚¶À9çMtÞÄç»Ìk¯.”VÄh¤ùìsÿm¯Ø6[j>WAM›¥´%XùA´Mt RIõÖM„¦ÖãfLÒpž=~ÞÔ^{CònžÍÊ9T³ôÚ=á‡OæƒÖªÀvLp„{G˜ÃòåÉÂçE±`XÆPôÏ)Ã`€Š Õå ó"‘™ŒOÉ׿Zð¹ÐIp‚„ WÆ+è'4«k]’`—,& çY1#N -Q‰Z·Û’ð–Vël«[jBž E’’”4ok]‚^Ó‚ÒûœjˆCSÔö=ð‰/|hÁ žH}áP]˜ÁÌ‚0IÁo‘ŠPà‰À](S†Ùa4Åp€#òÏÿ‰L¶"S1lm]#è¹ÐŽe.ë\Ëöx«(¸€§#ŠÀ³úHEŽ@²œHÄZy’$%‚‰á:KÃv¸ƒ5–ë†(aIÁc.h=‰‰“Œ8DXJà)qRÛ8wÎ ŠÆP=ä°€ª}rÑÛã×E/J¨++`@ô’!ý®0&ø5 "6:îqŒPŠT¥™§ˆs3™ÉùزÒñ*ìl';K×¹òÕj¼P#)¬ß4R8ÄqBžV‘#œ 9ˆD¨dN.AxáNE¾&òŒRkjz xZ®çE©iͲžê„§ü¬-=u_.?ÿǯ]bET\A¢è°,fQ‹“BæÁØ•ŽŒÓ4c«InsT÷AÕQn²Ä\Šï^´Zg;ÁNé¨¿à‘Ž@ó Ðè*8Mï‰È°²hÈyu€—B‡0„#TÒÒï‚7Ãì`+<8´h¸·’4¹¤†÷hÂEZp®Uö'³”@.–‚V¶m‰œ3séXcœ/2[1P¢ F°¼¥-?ˆ_Zf:)û ÎB†)ã45µ±ÒŠÈD6éØS4c9#2ð?Òó“=¾g«|à*G.jV³ÚÛј&g½ÐY=oDȹ‘&5Ëí "9žuJ¿«’•’#-é|R: % E®VJÿ–¼&1Q^xFyCyø°I;ØB ?ùäOàËe.[°À~n Mè%V*CÅT¦1_ûÆ’Å´8¬R÷óáç!3.Îއ ˜×ÊÇr&ÛbŽ:+ÅpÕF½ÅÑ ‡Ë‹^¤XgÌUñqE£ºæ2R¬ûÈBB¥)Q©S²îYÛ*<ètW†Üº¡U2¹L{UÓ]¯†ð}ÍO‰ | r{Íctùåo›­ò ¨™‡úʉ™Y÷I*~2 m]6¸—öSüCmá²É¸P±öcsœíSJ´@²u,TNpA¡#Bâ,Æ>òÑêê™\œ9wÒŽtÖZYðㆨÿðº=–ŽðXpµî™”å倯‹Ñˆò®6ô«Ek|­ò^_û.›º¾nG²’K}` ®DàÌx›ÔL=Ë01ø‚f…§FÁXÓCB% kGÛÄøY(ñŠg”¦ª³t63q!;X\ÒðB !䉛î—“Z¤¦ë}iim :U#2«ËD.‹îyÌÛÚ“‘§ÞW—³s÷Í¥t§Tñ…äx`^‚c5Ð1~ Q‡’‹XlŒ¦ÉœPœó21þ!ŽÚ@•öœ9eíQù‡~6‘峠؃W÷¢Y®ØhâE¯Xuƒ,:Î\ å:בÈa«Ž§4oÚ„ÿ­Bµ#<ëx×[¥]™.Š’2½#¡HÂË)õV©;§øH>bŒð«cˆ˜b™Ô°¸ X~šU3Â~°àáåBÆf„×ø5F[¨$ú@[é1Qý™#bL­vn¯6¨Œe¼ŠÂˆ‘›h7Ñ'^÷h”KÖë¹Ç@N!#¢Kª[­oOhB±ö]ñÂDIøØÿP¿öõ»-Po ×n/'ÚÃ'8ž®á~>éã.T&f½w¿“|B€»3I[ÚÒy0› àœ³sÅÌÜcƒþ³8ÿC"Ìk®|,“gœ@bÒgÒH7¹Ù½h^µOe5T‚I%0 Ø4˜ÿÕ-Ÿ4dÙd‚Q`G§&vx|Îç|Ãw<ãQì%(¹´søu<$a ÷_†R)3l“2rÆt`Ø7€#Fø#@Œs1ãrŠÓr|ÁM‘ç/î'y•ÿ1+÷'¾¤9Wh6ba 7zîVt‰cJÈqIl5]huOÂ<{PjD¶-Ö<hvÅW!áO q(‡sèÃ&Ƨ^ë%Iv°Æ/#Øö` ü¥k‰ kàÝðbÀ\` 9˜/• z·(#—wõƒ(wa!˜‚M§•8?e~{‘†¡D„®Å©ø8öPÒ3nêdÿ+†&…¤iUèíÖ[I77YhPÔ!±×VÏ!ó]u˜t{f'Cј5e×H.8:ÐÛÈÝÈû}åy؇-€d)qk&…f}•ûàñØ¢Lo–‰r‰Ù·Ygqf¢uò`"~±8Tã`ü@sn®…#‹ð'‹Q„é~4‚‘°tƒcÇeU’R(€Yx—DŒ<Öi®÷Q׈]œDþ6Cw¨†äujäÁ<àòÈ“O|}å9ƒd:MäDìx8ˆ¡³;É“ÞøTÔ0bQ‰÷q"—‰3µ‰Uä™rØTÿMýƒ1bù?P"&à`Vì6Ë×;ËW@º¥ŠsinÃcôcë¦nü§hí6#¦Š–thBfuB<&uçb˜Æ»“¿Ø‘þVC %^G^ärO°à` Ÿ š¡¹Ì“}Õ gŽ^”rw”ý¥2ìfM ýšµ‰Û8\!0U0tQ•cñqÊÔ›uñ0ÿø#@8„ÃFŸBŠŸBaeY8""n¤‰µ"„Ecæ\3673Ö\¤qb¼x#Ùn"tŽ’”åÖÅ+ÙpVص]&™2D“hjp7›Öàj Ê%ñÿW§é9爎MäX¥š·”KÀŠ¡Ñ°¢ •ýˆ™˜TÉ0•£¥œB–S1‰—F…3& ³¸Š´ôù~ó‘!À +à\9sO‰ä3¿qH²±—ÇE…6‚ž&$Ÿb¨VV²‡éŽYÚµ%f‡-\ó/q“`Ç{¼G0°Š¡ºýXMÄŽ½”‘Õ)èD* ÆPqš¦ª¡ýrSøÈ}ís7™h•À 8vÁl8(TtöSþâÿÓ¢~ñL#0"ÖÿÑ;BHs›±nêIJ‡HD $µÁvHdt.À)6#ŸQOê9HÁQÿÇñž×¥V ‘àcUâ[Z&±hp-1¦`7 {j  Чù9âÓã•(YÚP›ü¥§{Ú§Ê}_ô\fŠ’w…*¢Cœ\ù‰'Š…!©**©ÐY8ñÐÏs7 ×i£®h:ºn>š:@Ú3>"4C3¤ªJHö °Ò—ì©i†y]¡ ±;KŒ(„BüÉZjJ#!wçãujfJ›ÌZ Ü¨^Öᇂ2”!1§Õì¸m0ˆ×­iÚ§:®$úfãZ´ö¸›ˆJ¨uQ?]y?ñ œËÉ?e™¢ô*©€q¯Ï¤ð·©5ºÿsðw"–ƒtêI¶E ª£Z$¶qª´Á:©3z ûª¬ªÝÖ*.@V¬gVÉÑ[È4Ó% õ]\BC)‘¡{—“䢲hʬ š_ÍÇ»$«YŸC§‡§ñ³ºJ¢ãª®æÊ}IÛ>꺮`q_~k¤M@E–b–}‘÷j!ò˧»»{y6ñ`ìF¶ê)i2æ3§º¶Ìe¤:ã¶ K# «{ŠúP4Ô’UŠcÓQQº±ÎÁ%ZÚÕx'`§rÇ%l(p0±¬,ë¬]Ö¦ÙàÌ ðèÌÀ O@‰0§mp§›Ë Û ,À¬Û8a!ÿ®b´I»ÀwÃ}05l$ºº#P©áŠ-J¯$©’µ Ô–ac£ñ@ñZF±ncK¼s#9V³Ñh—,¾á\îæ¼Ÿ1·3’ÂHŒf•˜9F]XÉB·|K 0VC^Yó˲þ¹ ºO@¿Oé0àŠÀ³±9 ZÜÃD®º¹‰FKºöX¨iLEœ…sf eI¯Õ$~~ñ¢yÁÓÂúr!`"óá"’ñ©¢ag+VDÊŒ´¼nKH …t;É yk˜€­‡çRôàPóPbbC9«ÆúÅ<ëû¸ÛÈ_'° \ ÿÆZ¼;гÆƳÜï (/IÛ \¨?à ‹"7g£S8ˆMÖ¯º!ŠÓ¢i!|¯ —»Ë¯‚ —¾ [úà°B¶cû©fûU¤Q\úVf€.Ћî\…°2É—|4Œ`Ÿhe-×<Ê(y-ØQN&&ÅŠ†`÷o,!Å컦M°YÜ‹ ` ܦŸÙßÐÝèxj ÿÛ ÒÜfà›ŠbÒh¼›&MºeLºCË•‹êl³k–0Çt<©†·yLÁo,N~œÍûÚ͉AÈuëâì‹ :iIÝ—“ ÎôĪ,+Ô»ŒKÕ™ 5Y½P_³ÿc˜Ï×ÂdG–K9kãÅd£ÌÊ{š ÃÅßS\Ñ‹ÀDi { ß:lÃÖÀãJÌ&ýfºy®Eˉªë}yMïšF4ÇiôœRÍ÷Š?ü»Ò£»×©/\«s$DFQ·ÂËÂæüÙ+Œ#þw\€t„dÚ¬J"E]˜6ýTÐÁo‘uíeÄ’ÉIÉSJÙwK@^bw- ÝÊýp³IÔ×,{›Û˜M`×´­ÁƒÌ÷×|ý×oæ0ã ÞWØo,T3]–4ÍØürñp)µ PÑ;>½|ð ‹ò1TBÝmt;¼¢-7òQ«îfÚîÆÃ=<Õö9ÿÐ,·CfÒÉçò,V»ý]©FÃ#Ð6Di¦ÜˆÛ˜ÜË=Å"ýu½,Û§/×­ ›Å Ø/XÆu!r$ZfUd؇­Ø4­M4mÓóJ»hy)íÊoIÙ>}nÂ`KTt’3ÕuË"%b#ŸáŽ#ñð—$b·®Œ ÄaŸ×‚i7ŒpÛ{ñÕ-&'ðÛ.Jáaޡ܍² âSÜx Ñͧª×ŠÂ×½<0lœÒ²›hü«ë`Œ#Ç8^Þ8nÞWÛŸøL`!úP4º»W=>}” ê–[Ü„aAøXþ„RˆÚðœÃ%’åÎÿåÐåÑõå!æÑ‘ŸïyÄ0ÉW=¾ÖqÞ^Vsr®¦ÜØpŸùÖ,ë ÛH|î'¾ÔMÝ¿è£(õƒÆí×t¡ºnŒœ¥ÕèrLÞ9žÞ?né•>´D£XfóÎéóîÓXæÇò^>ô@‘üÊMäåð<åüM"#àH` Ï,QÕ/ aŽ`få%Ù±¹§5)ÑP%ë{&‘{÷€ìÍÚßÀ²Ñܨ,ÛÛÈ™%Î¬ßŠí¿¬×4oèwÃâÛ­›;ß‰á µk„îAC/µ¬ÞüL×¼âßËÇénó5`ã6‹å6UŸy‚rø—ÿ kb§ˆÃ$b‘ñ°nÁa`g¿ð¯ Œp¥//À/pàØå%^¢]â+ЖÉ5fR²!1ò-ÛÑ@ÑiJ ò8ÌZøý0›ý`âŸû3x?xì¡äŠÆ£û0(8Ìæ®³*àùç®îÜl–Îp?ìGÙWËa/eÞ^Z¶KÐÚFi_q7§¾äê’|aÔê÷wê,p`ö0ëÀ/ð%ÀÈ? Bž¶Pï¹v(DpkîÄzEÊáñ÷T,= ÞÀÖíñ Ý?Ð Ô 4ÿË‚®Ý* ãż®ã ÞÁàÆˆñøÅ+ÿ0ž=( ¨`EE( ŒÏÃ<0àØa¿ùò‘4iOe{,éÙ£Gožz'hÎlqâDÍòZ,ú³ÉyAi:q’¯€Ò.š>µ˜´€>.â9Ý·ïF+ † ‘àê‚«¯ð’ ë×%ä±`ñVž‰¬;I©–ÒN»º‹ ¼Èƒ³®ž†Jï„&lÒÀžøò+€Ï=éqb)DÁ} h#«µÊújÁRIå@Á¬†¸‚Žk®·NÈi= ñ /^|‘Ãq2còÑ2u¾i€kü¬FÿEéÑÇÓNc-Ø~`À¶^[rae“­·FŠ2¡á&º²¡j!ªh¸‹âyÎËŽ¼|n)êôÁΤ3µ{)¦ïT˜'& æiW< äl¯‰¢,DO§÷4 ©M˜èi`@íiÞ|\ð€Ÿþ(Ò@ÑÍ¢@ÒT]pAJ'ý Jx¡ =eA§¾îõža\|ñuP‡1beWÆ’u³[oÎEÃ@¤×_nå†fÖ6ÜŠ„M ‚²ᶃH%ä$²–9ŒºüÒK1Eéº ¼.÷zÐ…©Ýwã¥É¦šÊ+¯=·Ñ[˜œÞ“»šúIϦDÔ*'4h!+#®ÒÿŠ-N ñ´¾‹c¸:µ«Ô’9`†±EbŒÆ[!Óñ‰Uq €1bí!æ›iD1gÐvî蟷ÚmØb‹FÚµÙ—æ§(‡ÛΪe¢+-B(#n7ŠÎ£@B¨¤ë°+àÜ|V‚)vÛ¥gÞñæó<·— (÷rZ¢»í4Ѓ=ÐÇ„ÿÚ°Sðˆ”H#=²¨¾)³OÙ[¢§0LÛjÚoA·õ°þêá mޏ·&þmb6D*«2ðÅ€k?ÀoR³2Ì̺ºó‹_ ªÐ<> } ɔ̮ —ì×° Ìd&stM€D¹·UîX[„]Ø‹¦©1p}_U;ϲhN‰f5Û;z¹&m"ONšHÄÇ$Yä~úÓì…Š(Q4¡7lèk&Äit… àh“s0r$U0Y¬ŽK×ÈÆý€A¥'Øoœò¬š¦›i›Ð„c§=C2A½ëPFÄàòð­®5¾\k<Qž2•%Ä‚¶\Ë­µ˜ÇÌq” Ϧÿ%´×\’•°„%…ó»®®í “o?Ç¢ (üZ¸yêé¶æáð‡?Üv8q!f4 FÌÛz“ßEAÁd\Lp¨a2ÃhÂŒ NÜÎdz2dŒ#ŒÅ¡Ði'Ø™+Ae£4†Rüaöø>r w¾kÜ@¯10x*ABÞ ~›k2g@!ˆ9”bÞæioÖÍø™žÍü˜¨TÚ‚ÒG¸«r•„¸+_o<ú>8¼î¥;ýŒúCB=à ¨K}S/q¤'«GLÇç†WàTº ¸´5èjÈüûìøtD©¨ÌöŒíå'h¬yãДï+ï{ø÷n½{<‚'<•ÿÍë}•“yF€<¤+súï”òm6X€£ Òøóyä¸ À¥0={'yˆªÔ34¥j½¥JœIy=E1ˆ7  ±HÓ½Qa±~x›)®8®~x‚¾Ÿ¤1 €ÛºÈx Qk.Æx‚à & D8"ᤨ€ H9eÛ¸½3¬8½C¿ó¸ß*±+¯[Ó8л{˜µº5ƒ9™3˜¥È?ÍÚ?{Ø?i3‰©7~ ÿèÿP × ´¼‡¨Â c7¥+œ3‚@ܱ=¬0€ Ä8± èÀ’ù@ òpМΰ†P&°Œ'hêë ÿ‘ o°†z n°p>BІPÅP,Á~ÅS$¸Á( ¼ ñ  ð•$#–º;6·ø-]{?òKB¾ë»#üE]< ²ŒÛ8û"€y€üÃ@Äû­¨Ê |ŒXAT{l»{8Ä|HÌÀÇ€ü‹UdEVŠPF ‚Ÿj!Pªµï#àE_¼H`4Â,?aÌ À81ë8*4‚dL“ZÚB4h«FìH Êû¶Vâª7þ8˜éqCóÈ0ãIÙªÃ;ÿì° ô0Ù±‹·@,/S@¼ ÇÉÂ7GH€„GpÅ{èÇIlG°Ä|ÔØÊ¯ È~ph‚ƒDÈ{  €†ü  `+PbŒ1ëż¿_ Æ] ³^Ë»ŠÄ¯—£¿g#“fÔ¬¤€6raÌ=Ã"tŠ|󱢌Â+G¥ã0ý‘ÀD{º§ ±?Ô@oz¨Â ßš,VÌ‹$pωJÐG ™Ä¾ :!fДé‡}€5€¿ø ‘â4Nûâû2Îå NÁ(HçtÅö8dÈF9 1! à‡Š³µ\\9*ìÅŒÜË#ÌHS9]s?ÿp«´MÒ2HälÎàlNá\ÅU Œäü ÎEÑ]ÅÚ¤ `K´øŠV ”Ÿ‘Ë L<ïÔŽKO¾ODÂ`œ2óCO–»BÄÌ,úŒ6˜|žq;Vcµ6t9­Œ³ÌDÇv3PwkÇ D@äŽÑÀ'1ÓÄÎdEf­Ø…«J¿Pf³¤Pýã:5áåí[udbv€m.[îe´¢Œ@ß ‚Þ2F½ÔYÆÝH(Çâ{\ï °,2éÜ¢ý6£Ý)4KµÂ%—hå8 ²6 xiݓ-£/VÇ‹Á] ãDC‚-íÃ4^ãݽWÐߺ¯ûòØß’Ûrj[a…Û<ÕcU^7-a»å hé€QñM#åæ²  |·ÄçJÿqd1=g½ôQ-?L–Üãµ£ÆK`ÂŒ9ì½ë`ÌQÖ礥¹(À_•bO*hì0YV@*«åͼ]vèt4PþaGa>caV4r~X†ëdöØe¶c«ÄJ†æFQe£æe}Ó –‡A†ÑFv± øfÅ‘ÀÓ·þép=_žUT)‹2Êý-À$€Pµç å˜Db£=LÐ- –P•r €èVÎbN ¹TÝÌüh²v:Ý…=ŠæÃÎ-LDB$D]õØ’mf»¶ë…c¸γ<Ëz<Ñiöë¿ S¼¸æ!ø¹”E‹`±Åé4ÒúI àsæb]cBÉÿvÜòG èµõŽ2ÀÌ8B43„9r)å'-ZSF³üƒ¼Ón oĹkãê¬,×~²Z¾Ò‹‘íÙ~èJ2Vk¶&ÊÕ¦Þ¾¯´MNeX9ÂJã6n«*g6éÅk•öëMÛzà lYF–Ñëvà›þæï%T¯‡ ¸U›åa.É[Ær b£îµßrÑe|žÏ•€Æ”j|.̰‰bUNm­ne—€ô5·åIIkÏÌå‚ð´†ðÝ•½Å!æ€ØŽV6ei6µ)ïðçe^iæX€Xè>M¾l˜Í Œ7ÚËé.ÔǾaõöÙÉvÔ)Ko¤ö-ÀÄl„—ù%¨ÿÖ³ÐsRúmhk3Cmþ]í–¸¥)‡²„¾ò×[k‹6€=dpÛ&Ê.ÇíÜæî42€‡%Dd¬^4eæ…ó †*¡bæçMK qû²pˆ ß’†ÔeA}: dö¢\œ?ßrNt¿Sçj×;'¼ìÉ=‚Øöó âöůÐÁËʇÏÍ稦_$µ¥'~³ÿ&èþ–‰ì5+ÏCïÃàÅ÷RÿÚ,Uõ.ÏmpfGË#(s»]æ¶ËuPa8{Éõ…ÃÓ†x½–sèN[ˆõíä^xöT  Œ·=änÎT!°ñÁ‹ìñê¡.^nwgÉÍì£ÆUb<FhϦ>b&Æy˜ÿƒ×•È›Õ~‰‚ž”2zÊ0¦h|ÞR·í-ÕíÇè¯-lõ΀eѪ¹`¸ò‘¹Yxó¹ëNËåVf¿åW\vB<îlï>£4 1>\dq¦»UµHòÌñ–ßv'„ç½röIZ‚¹Q®€z­traWÐÕ©›£âWí /±Þªåz8€zË^ÍÞšv}¯èÞUú_às€_ö€?ø³¯µ©[7ØŠ}*âz]oS°_nº Q ðÛ@ÛoUOˆMñAvÙŠéxƒeÇE¾Wè­rtò.ï FïOÏäqìq*Ý53k¶ù+¢Ñ>R bµ$§Oéÿª¹ÎÂ\êï)Ç=Ìüð…Ëwdð…Ãöd†øGùwÐ1€8`ÀÀ DX/Á†õ2dñáD$ 8x`ĈîÝ“×Dd‹KZ+‰²dJ•M^‚¼Ça&Í™1erÀÉ¡ä‹/0dÈ@ G#92`Àð"! Zh• ˆ„H(Btú4êW0<8’c(Q¢ûŠžM›C-†#< @à-Ñ·0ä ‹7‡GX@øð!Ÿà|„ çã‡Øp…|ú닙߇Nj/a/Š=Íôèi˜÷¹³æôæ±wdõ¾} óUÙ€ÙÆí™ƒÞ¶kûÿ>ðð냶¿ö&Ø»ö…±:TÈðEРB¶)¯Å •%5´:¼Ë0k¢§©“†!Þ¿—áA¢FƒYÚtU¨T^”Ài…PU$$…×s‘eÖZk¥ÕQ ¾•\s‰UáPt‘õ@HóVÁ`a–˜aü<†¢Š’•ˆ˜=ùØÓYgôÌ(=ïÅHϧ±°à\­Õã€l´ Éœõ@¤lÉ $2O:@mµ»Ó,oÊÎÖ›n^~餲  ¬”ËbPÏ•]bËås`RÑBÿÖÄ ó”'hãõªÁgô:AïgrºdgN9í;’L@ÀC úÓ¡‡f°Ñ|Jí—U GiBP5„¥Å‘|qƒeIØšQ ⥡‚ on¡¦sÖjc v™b-+†¢c²¶¸Ø{¦‘æë4zÆÈiªµÕZ“Ëòž,µ¾ÎÐoBfë[ïŒr5—¼u DÏÐ|ó`šì½Ê˶!´ÝöÚ÷Ê}Ov÷rБŸ÷0ªß„‚VàF …<¸âÿÕ/qÞ²_%oÊAs‹æò¹RÌP'Àš8o:ÜÉ“§À†?íÙÐæÌ™ž$íÀÔƒSœF…Jõ)U¦0°¥Ô“ׯžn V+ƒ#<ðã¯@ÛpãÊ-`JtUèÕ "††€f!¸0á'—Ø·/!AÇ #ÿlX _ɵ(žÌ‘³Æ‘ Dº4lj,´¼±àÆ ¯c/˜½aÁQ£Fñ !êSaO\=w‚©§Z›^•ÊÅcLjóØ-ždU$­"ÛšTŽ#šÀÖxáù:?,»¥^eÇŸÌfBKf™§ã­´n>f>C8ÔP;„R·-­ç¹O‹‡%–fÿ.<{ù`ÝîÖ# ¹ÓNö{¶óýÎÃ=üV |óóÄ@¥®Í¤“§<=ŒwC};ìPq_qg8Æ>¶ï±-ŒCŽv’s7âwO6I×xä,Yò̘եdÕ瀥+à˜t6ÆÅ r B‚ö:Eä‚¶£ÈÒà®æ¯_}i…W¼Ï½Wö Ç{Ì”½²Qo0ÔÞ>P(D8iô°GØFâ( |Ô"ßøÿ†X”ÛÇ,:ÂJxQ¸èX%H‹ÓÊãèw+$éè~ß Ox8×$þuîwÃê—è˜5³g‘é€:sè@¡Pæuýù™»7rË[º!:è;öø«l'ÐË]v%Ö.v˜=#%ȃKLöTH=ê1âXÁ V yØc`bCĦ:¾×1Ì|sÈÝnr”ãäˆLô@,ØÄUMg+Eº­è·ÊyÀ;ˆ‡“²H%óxÑs~T—¼4˜À1Ðt–™ÚXG7¶ hq¬ÖC.ø‰‹TW¨æ¹b}rWáÑ{ô‚—¸ÄcIàᇖpG6RøŒè,‰ÿÃK"¢ @„òÁBñÃ6>¬›§D•ÊßD 8·AJÅ÷DZ¶cXÉŠ-|¿ÈeGr%ëÎwz•9'q‘eÃc§¿²ç¥/Ac*Á˜`ª3>02Ùš#Ðnº“„y$O{º^»>)0KÐ-i©€ ãb»ÄÃЉÊHUpz.÷À§#³*É~ªøç ( }€HG¹ÉnV¾¶nb勨N6pƒP„‚ Hô@dY¸Ñ2ªLÙJG%7!Ôï•QÛ儩Ÿ¨L‹ëüW¿4=é)p/•¤LÓx À´‘ üÔÆ‡T&aµðHƒöä§ ¤k-¼‚-çü¢O ÿ`ɶDuK¡ U˜à-öøK#!YUHÞSé'=&°'˜x ¡;˜NÖ*W!–rT5ºÛ؃~x×»Õ`ö «¨ðÂ}Ëbg«Ö ‰$f¯4×GB)sìA#*Û%Äœ ³^:Ì™d::fÆ`1ûx£µrÍV‹Ži¹¥®äCÊ+m«*{x˜«”ýU¡ð¦B¡©y‰Ùev\䞆hƒ& J&º!ÎZmÂV¹Š®Õ­Q!hðÝ"¹Jð«’¨^[|Œ½d!Î{Kv±e1˜úƒË!û»Kúq¿hKŒ[úß›9{2e&5%ã›j>Ðÿ?ù„Ë% |`¿ó(€w`fϬvØÃ @VY@ªMím'Þ ÌTFk)>€‰dUiöâýÆ“ˆ€‰¢V07NÙ-7=¾®CB#? ¨&r‘'ñÄŠ¦·cõã:úÑ]ze¢ZùeزÈùÊ…âqÒ¾îüUµÆ¿ÊBÌèDGff!Ʀnr³kaœ:DÎyÒÓ&y°¹kn=çóç#ZÐò¸ä¡AÈNc¸[| Ì #éÀDu’ô'…ÐßS¡ÞÀ±?|÷Ø€?¾pjCÕýHrz×÷ê0qqe¯a¥ìÑWŠH×–Rì¯1"w­ëä†ÿ>Û½„¶[ô—Œ-#K[¸fÓQ‚4ˆD($!CH Û0„'OÐÈØ£P7¨À Žðçsa¨óçÁN¼[f´{ŽeoH·@Y„ë?-Pã$,¡£®§J”©ã» `¸ÜN ;x× PáEú‚¤ J(¬< %(8€ X =Œã+†ýÊ ô‡Ê“á ðY¡è ü˜ ¨@ˆB€H“´È†( Š@¢k6l× !6Øž ‡àDÙd*ºìí2` "sÚth¤ !oJÈA?Ÿ o ©Ëc¸ÁLZó¬áæ>÷ÿõëlç ̃/0Ó€1àݾØVK}`(Ëuø0òªPk,ÐMI,ívóâƒ]¨´^à]q7w H ªÖTP Fö]:i€hdÝud~ðPt0 ÝF³ &è]20­€ðX %p6Œ \°¸9cDM­c-A':…-Ñ F0%0ˆ07ðÁÚGW`~ß~÷pnðVC gƒ~ê·ð–†ix~8¤=ôGuôÀ†aÒaø4a¸¬!]ÒµJBJ# ÕVo× prG @ s Þ•+ÿ؈øˆEž0 ޏ‚lP‚’¸‰E& ´‰È€œÈ¢³fp’SÙ”|;—(6ö ”=Ã9Ò“i P$€OGð}áÇ… P00Ðmêq†ï¶~To'@[p8=ð‘…Y%Œ @<€|xJmEp¸Þ…s§ß… rGˆ5 ð 5ðFF¨–jý`ð¨7 Eö =öx4@Ú FÖ Ú0ß%ƒ4ðŽ qlPdvÐÚ`wßÕ 1@M±CZ:UA"9<·xëAP®ŒPò°‹†‚Ö‹^è…ÿà ˆð8¤K°ë÷jx~ÉE”ô9„%ó`O aøŠ” Vÿ€ÖE€WÙV¨ˆ ‡FÖþ0PªF`©€þÐ×rWg¹pPFfoÉpÀˆßÅ– W†èèØ Ð—ëø—ÞE樀@˜ÞU\yˆré]lPsËG8'’A rtôa BÉñÀ ÀDG‡ZÈ…¾È@ò CÐ ˆ0XÆàjoF‰›“„”ìaaT3øäg2V(þÇcBpœUi>§Dp^Ù40w)ÞEõ8hÉp—눖™‚9wÙé]zÿÙpt‡€×¹—ßµ çé ˜ëÙœý &ÚD„A˜?p™rv2¬yµoñ ¥¹…vn[hÀH †Ð "!@5WG”DùŒó÷b”Ô›¾™RœvØm U¨cÒŽmu]¸`â9wßÕ—Xd ˆué9ž ׂم)˜ˆ8wÍi£r‡—éˆr· Ó)w9ž€ +*w`mé]=3AAÁ‚—I¤AW%hõd záTpZx ¨™¦ ºš/°“J‡F”Åo¶i›TGYqÈ›•.éâ“` ð†`0i¥vÖå‡Õ7*Ú@ÿú] F¦‚ý © æÉpxi£`w40¤ô r礄(˜D¤ÛÐüHˆoÉ€Þ5¤OºpiÔù]uù—5¥ß•`9÷×´Eóq!ZÊÀ¿HK @zÑ+ô¤¦Æ ú¬\ˆðšÀIf :éÇN””CàZ5E(Vgp Ï ñ‚"2al%à3€á³¨ê]çÀ‰öèœ5 ž˜úªþ ªý  r‡ŽRJ¤E&° ‡ŽšÚŽI)˜…¹€ 0–ßõœ ‡¤é)wÔ™`!é`©h¥Áp9 ÷°”¦º¥hª Ð𠍹…«IóÿРŠÒ“Á¥¬a$Y(…5½™ñbccµÐp ð\ 5Ñ¢ÂS¼Ñ7j¤ë]U ž‘© Ø0¤ýʨAªý*w:*¶ Lj6Z¶õøŽ3Êpßu˜hYw`ûµÞª ‘ñf’ѱ ÀªÑ7ð¥^ˆ}ÅCÁhmá²­1+­ ¦–òÀÙ¸ú a¸Õ³ëaHXRBÅC5B‹c¥û·äj=OH5ño%jm•‚©˜ý ŽDzªùX°t¶s{¶fëŒH¶Ef£hË»Tð]v»Ž w^k—öÈ»u«¤TÊ`¥å:~‹-‘0÷`²¬ùüÿðôIŸ©[Æ€¦À­\ø² Š%i+À.Â’B"t%‚4<ăa"°I+0ˆ ÊcaB»I Ю%µ¯›ÀÁ‘¶Ûpk ý0¤Ø0Ä믣þ`©;¥Üap© ÷ýP—øï¸ ‚© p¤EƯ §jyëf@÷}*!{ŸÑ†ð¥Ædi‘$¦nQ1°Ž«¾š¦«Ù!@" ì¡B#”%øK<š"°+ šü¿ˆ 5Uca55á®ø´ñÚ0@µv‰ÁÐÀ ×»þŸÉ ¼þJ£Î©»v·ÿ:CZª¼ËÞU—e¹¼vÿ –‹¶ºû—6žñiJA˜ŠÔ6¸à·Ýt70ææ…,CFÄß¡/«Ä¨ù‹@¹€aÅ£%†¤!@†4þCP{j)Eà³Q¼5J0Å“ÅV5âzcg÷=°‹•ƒX»ëé—ßÕ¼DÊ»@Š–íiߪ¿‹—¤èžhÿ¹¼ºž¼ž„é@ÈGŸÖ&Gª¥à †À ªÏ‚\ôW,ËÚVhi hŽK-´êDþ³Ð¼ŸÛ?ÅEÀ ¿Œa#Ñn“Åùö¡"šV!m•=ÑŒ·í™^ÛvP°ái£Û0¤‰9—m{—ÃË»yð¶sw—·ŠžªZÓxù]s=wÔОa`S æ: •sÝDÏZz!7н9à…ò lH C1ÃÊJLý²Y…¦) ´oÃÐZ†¿ÈäÕ#0Ñ%äÕ¼Ù?ÅZPœ¶"mg>«ô7©d I‘Á Ýid¹‘ÓyYÁ=°ÿð¨µ+ÝÔÿy’Jˆ I–ây³êŽñ =qšè]éÍ- ŸÔûÓ™½Ñ𥿨ÏÈCï¡”fSuëQÄÁEtv3€A…HT‚ËñÕÈdYÍjÍ›ú°5)´Û¾”%4ÌÄÜÅ ×6ÒP5Rjœ˜“À‰ ½FÆö:(‰\À +êÑÞ,þ¢&˜ˆœHê²ØDŸYŠArv!û×£‘tŸ|²Vt1³%¿3Í9½Ù<þÅlÁ .áCP”rÛ)4OÏhˆÛ9äÞ?ÆÃ¡éò„þ'jòÊ»aeÀãý2 ‚`áý]0ð &øÁEÿF’`h}€|þ) ,`ã(ð¦;Àã2H臆n‚^ ßÁ!™èçœ@5ö„WŠMÛ¤¥­8¤Ñ@¸]˜ \õb1³2±%06Êc)$'6"ÀEºÅú€N”òk#À Í[žCUµlŽ”-Àæì¡KIá{ú¿fç=†ªÌo#w“J6šPUP€Wgai0~—™ 6~ Àà¯xD|`5ªÎ/%@À‡Ù :”e6Jp“p‡ ¶ùŒð (h; ë±‰; xá` T@)@6à[$2 'ŸD`Éÿ³5C>-p¢|!¬"Úèp ÷ðÙ·åToÚ<îÐp3"&ÂÉ®jQ)ñìþÃ+.Ö°"¢è!íÏØŽôŒôà™M íи…ËV(ssÀoÍwQV„¿db3"ÅN®ü°ïtŒ—D Æ}t6áÊlêLöëŒþ9¥b:oUe 9ä?.PõV¶+pqËkQÛ]<¥XTCß–ý ¢( Âó?pˆpŒ`Ô7)^èaW5iódž”å³X[L¯÷Íþì¶üE'r¼°%öEwM°MiÉíÏèæöáú»´4A•UÙcÆ7æÎJcÿf÷üðKÅ^Û„âZˆ ‰UPaX"¾Ú3IF)Ä’vé13íB)iÚêŸBi¡ž”Æ ä¯@¾öTØcŸ~üì勈("¿ûöáÕ‘#GŒüÂÉ ~ܸè£GäÈA ‡€{,t.YrÂg zö€Õ”áÑ#R¼¨¯ £ôT¨Jž†yVí…85ÄÕMxÊKvI‹KÄž0Vta>}ú1X@i¾»Bðíŧ—/®½~ù&|wÃáž3ð0ÂCÇüF ò€h²e~ˆôUÒÏógÏ\’2üÀÈ#z1æiðé“çë×'b°6Ööÿc>kŸèYûõ½ æƒ ¥Ã«ì(Èï8qÉóÙÓ8ê£õŽØ;þ°0²ÕÉ­Tn`9щ#fÎ$³gkŸ*€¥¿iý£Óí‡Â*ÕäÀò +¬¬*Ê'yZ¸‡,y K­&Nhá« Ðg„X` 6 À#,Dû ÌD½S‘èÀ/ÊL3Dhä§‚ ô©B кIa´¤‚BMµyZ³Mž%tÏÁÜx»ÍAÛn»ÇA ú¨€ÿúSAÖ”cN éøqŠŠ2Ú'¤@Ú«»•NB‚‚‹À n)lZ€#XÉØZ›G…yò³£å€´ÿg4{¬r”!'ì£/(©VóiB×. Kž{:å´ ÅšrBc¬¢ðá°?,ÑÄWù 0ÃkÅ ám4ÝÕŠ2j9ý j´Q«$”P “¼Ô“d°±Ò¢0¨|PݰCXõrUÖA¼Y0qÕu×Ga„äªÑhD*ÀèØ€€4ÏöIAZzæ)ÿ¾®½v‰q—æi¨ahk²·îtܸL—ËÙâ-´§BŠ8¥áÕè:¼E*é oï `*X½õ>‚d¬}º:qċԴ¨„2ðªŒ+œ̃¶9äT6™åÑšpBPÓj¡¨‰„®ËC!îÑ/cÝ+Ä [q!ƒ¬11ÅtJ®¸ˆE6©À†ºŸ}´Hm6øÆ:ûy²‡Z­Ÿ¯~Êܺ4’7'^B]."ÞzÏÄïZöòî$¿oˆ`׉…{Ô»‰½Ã–-Ùd[¼5’éRV H¡Ê ŠÓ9™26ªHKZB7ЃBÔ”Ë`†ÿˆ Eà00‘ë>;îe$ÂEŠnµ ýŒ10"Ú¯øaˆßi¦X Þ!<ó€±vð þ×<®ÕÏz÷Æ…Øx& ×[┸—©puí{ÔRŽ}>0»¥É#kúÁwú†òT`:ᔞðF>ÉcaúcËløw‚#¶ÀOœâ㟸½Ö\E+s BHý„LSY±J…|„d"{Y(’ªºP/$ÎL"âÌV‡‘!c@´ßåH•›Ù̼Âx&þ ¥?à/$‰Jäå=ž ËZú£E¬âóÚƒ­î%Ñl]KÜÆ@Víœo;?8ÉÚwDÿ0b~GÀÀzöÇüõdaïÁã´ªvµ?=SÖó£Ë05 ­@GLÀrà¢&9!z8Ғĉ‹>ˆ#I«LupA„†X+NzRvƒ¡¬^ˆ˜ŸÑ0"Ãû¢¾X,WBŽ À¬å-û‘K#éo ;pÄtèà \H~ÙYÖr˜ýHéq¶câ\€Ræ2å›ì!§Ra”æKÒ7CøM„7˜Àý”§7á9X’XȨfyZg1Õù'ïMˆd‚Ž< HÇ‘Žj$?ã‚V¸ú3’›“$q º øÅfƒñ‹u@ «2T…¶KÌÏt7ŒoxóžP†K˜Óÿ£ uX¥w¼'¼4¦´œ)h`àˆœæ)§ãò*ô ”6·P¥HÐÌ[GºcÆö¥ÄÚÔ‰Á°ƒåIŽW½bk4 š!)Ié<ÂÙŠ{¶®®Óó‰£,Ë Õu$\D ¸Š`+@« )IIN$. a_#ëÔL°ëÝkÏ`Ø"Þ•©±µgÕÈnÖ–¸$ØŽûÒãAmål€ûñ„ö´‡¢mýŽÙ`$u/n£ÖÝ@M}™Ñ_Lä˜=Lí¡ãùw⬜†EjX:ïqܽØSÈ1Y©•ºÂÅwÓ ²¬«Ýí¹Ü•.B¢ÀçÔC(ÿ‘C×ëIž½ÐSf€'Š@´ˆoQÈ2JRî;-x¿ ×üm`£kn@0j5ýkFÀ>³†<-XÏJL0Ü`-ú69š‚¦v@òZ¤RÀ}ñ[£<Šk¿™|³&rÄÚo‡ƒÓH{`õcU7cvÖxtxl$x‰óÅáõø­A^Á+|ðjU, h‹˜—ØeÉ{ýÐ_sædQ>Ô>`Q`$âå5Œ0i¢50G¶£žaX„Ï( ˜Û@Å<€mûCŸñs¹ÿÌàr×ÊÓ‚¼×íqo ¶NúÒ;’j⢀‡åX¿›HzÄøÿo÷‡@î4DòÉÂÔéîG<Ô ’#óI#Ë’ÏÅîv)áƒSâã>P…V0kZà .+`•^;9;'߬/´ëÙ†ZÜY§¡ÇŠ{.- ß1Úúõh5”)ÏÔ ÜÛÞÆgô»tazæ #1ª®çr§› ´o]3{uedŸ¢æTGÛä`4©Iþ‡•Ç‘9VCÐé×Ç>ÆØxÿ>³’cD.rñ¸È /òW¿úäfù±‚uÈå.ÿu']Õªž »Ø•qå²òù´9kC—¬gtÐifxfÁ¤F0€`zûémw-›Þ±ùùêy6÷Ÿ¹ÿ~Lï¡6m=k¥‰è“Pà}7ð¼ÛéHuÄlÍl¨–éûÒ½¿`íTq•äb>ê,kÅïÏ~¦„+8ü%,p‰K ~ä&Ÿ5™> \ïØ¿>¯Bc;RÂ]A,DY1«©]j G3¢ž³Ñ¬mhjoC€`š)¢ó  †`"7=ó=ÑÂ:»‡uë:á+³y;“ ò» »ÙÚ#Û¸¶ã-i‘Õh”û£#š#92P‹¸½•K)¿|²¤‹B?õC{?!È«K!€?J¸„Ä#9ð®‰éÂO‚9ÿ{¹Ê6øj da¶ª1 ‚q’‡ÿ”6Z*:{C¨±ÀØ“)1{3ϰ@=ì<€̺­ó3%ú3O ”´á $A’0Â}1 öY45r´´›‰èû&>aº£Šù@Ó°šÿÑŸ4™ãR®ðs7Ä1BGò±ÀK¿Ì@« ¹(¬Å'¬Å÷›?à.DB„¼âµÊë¿Ê‹Àp¯÷b^˜ŒÅæé¯9J’7Ì@ó ;†ÈÃpÃÀ tºm쇪#DÞ Aë%EÔž8›¬· Ó—äkŸ@„ ¸;N¡‰ÛÂD‚³AÈÁ´F c’Y®»›N1uJ’Kù»ã'ÍH?è’ňÃûE[¬ÅKØ€ø»ÂÿÆ»?.Ô?™C¾ ÚÛ^˜(d t †IÉFÔ¬Ò›F? ¦h€nŒ3nüCÐÒ:Cô³B|0®Èذ uzÄóaG¤Ú·–`„”=‘´›8‚>ù ù(”ž‹fc1ç[.½ë¾¯ªª;È|ú¢~º.èÂ.¸b5‘ûÅ)LË´œÈù+ô»F½ þ{2@R@‹ tF¬,ÿº‡h„É'z¢~è˜äCš„CІϨ=Zò6¬c·³Y7C´Ì„d:GäÊC£&¿Q4¾Q£{¾€£‰8š< ¡ «i±ïë4!Ü»>RœTµ†D•´*K [s¿)ŒBÿ)”Bà¬E‹¬ÂWc€ÆË‡üÆØ¡<1\¡Âx(¼²‰B¬)²9‚”L–„º\Ì œÉ` €aÒ˜ô ±éÉ%ÂÌœ´D\"y»Q°·’ðDhŸlšï˓Ӽ‰8*8ƒS †Û ¬äNãBENû£Û”¤û“ í!íšÐ óº8Kµ$ε\ËøËE’k¼ ¡„át(!H¯°Ë—s!QŒB¬é0 KAS$úñ%1Ï~@ÏZj½×Û6mOZ·ËLÒ*-cZ¢$ÊÌćô¹j:£i‰¨Ñô©Ê­âò¾9Ò¥«Ú»À4.”Çá"™ a¤Ë à.ÿV«PßüÍ÷NµÌ+:u?;?+49»Ú)d²ŒŽtbÄK<«ÄÚGר#e”…ùN õ‡~ l„É`RLJÝ6ê‡a0-Ø#-¦öhİsÒ3¢D`‰ÒH€›‰+Í“ãzJƒ[ëڣN LNñ¯1õÇÆ™‡¯ð1èbÂíZ?ß,¹’¹ ¥(LK'¼Óµ¤EÄc}ÇãH0|& ÆÁBŒ hÑŒ²ís0MIeLí;É7lÄ1£l&ð¶'ТN$-­­Ï…î0UE3ÕP£W%k·Ãa˜Åá-6Ê»‚ã¾Û­ƒ´š­ðU¡ÿaµÈ ±P£ÅâtB Qu¿*ÌÅŠÌS$D° =QëÚTT!êd‘dL¬㟔¬Q$e&šF ¢°3 ="ÐØ‡aà‰&ˆ³ðs|¯>N¡Oë‰ü4Õ ¨‘ È[Ê71O¡4ÑcF? µáÂÕFóóÕ_VaÝ.UXXs5ëX}¿8BdYø‹Säô"ØŠ|XõªÖi¨/\(¼¸›³NƢʫ×^BÇ{H½¢Ý\ÎFH‚¦= í)Šu‰ZµZØ "-šÏ¦'Õ·¾Á¤,.ú±Ò7ÊÀ€ÒÜRÇ™‡ìëÒÿOÓR«r˜YµÍžë1K’£Y‹ÛŒÝ®ŒµÀÛW‹H\<Ë’-Y<=N[| DпÁ0Q™•™%Ô]ɲ ˆ–†³*>­qIà\()é'ð‚3=p„ùýŒ“úU‹§M¶j«H—´¨Ý`ÚßP¦2cÝ4aGüÄ‘¤AÊ¡Ÿû© Ý¥]„µšû2@§òZS?«AÞáQÞ4]¿õ[Ó6µÛ ‰5cÕÛöCÖíÐëÂ*´BDè9}È â ¿úµÀŠb|Ü xŸm D¡ÜþúÒ÷U¢WÕLŒ`®AH„µªåšD €aÝ&ÑŠH¹œÿH¡JÑ€Ó±H"²)3¡äWÐL*:Á‘5ÒÊzÄÝÒ¤4‘±tjD:òº.Y4 ™.qcjµ yZþhHr+à€+^^ì’6²p–æ©×¸ÚÖýˆ;¦iù€»ãH£ªÃ)8EQ$µ.gê»MdQ^¤içízg§Žá¨[“³PêêÃã[Næá¼E„ûëýëkÃÿÖ!¬Åˆ¾˜§‚áåÊ‚³ªêë¶Ú¶ŠnAbR9ðùè€$ï*iÃæ…Y+ðo(‚¾®ì>2EŠc ¼¢R~ÁãÀ{G™È­ f¡vBö] ³Jyt>è]FHHJÓ5µØ [í§2׎5Uˆ€¼•¿®mûHDˆ€Ä5ÑÝþ‹Æå²>%‰P â.n†aëÀ HæBÿiæðæéˆל4*Òu'PfD*iÁ.lï.’K¼"PUoÈn{`lÖ¸ ÈÖŽ~•øÆ‘GmÐüa1Ÿê0@Ð&jï# sþ;¸E>pÿÔNígµºáa5ÖƒH¦ê*ö¯ÛŒu5ߤçWP…›í ×d¬¡þôzÎ$&¿ÀË]ÑÁ)õ¯ùy±,u4UlØsй(¸€”†‹íF¤®x {Gî>òÃï"¿ÂKðø uQ'9òFìÌÑ ×'ú´€÷¦iYOÕœPJÿLÔìvk0¿*¶J]ß­ž°šFXá_aµ5=ó`Ý®Þdí6§Û’c?i¯Þ©\­mc1Ä™v¨P¢Y‰]éçŠö“¶þEWTƒc${¢wŠˆ ’Ö’6é’&éL'ïò§y/i8«o~÷wø€µoÃö§‹§Ï22)x¢EÆ“mF7øŽ1¿#µVÍ1÷Ýß²©‘’Gó4‡á¹]s×~S ö9ÏÞ«Þ}ŽK›ë$öð>ÿE 1ë,ñ‚)K,á£ÖG„¸¨{ú¸i“6“Nl×Ït}ðN÷q¯¯ýð&{±·È±õÿ 7{-Ô M;Qµ¤r{â!m"¾{±š :ƒäþ–ÕÄEÔHçWêaç¸Ô¦Ð5á×~SËði—í€ça‹ä>ÍaüÈå‹?@Är—¬š†!zDÇUÞJ¸-ˆ| ðÓ—¯`>}úâés¡Ð?‡.⹨ذ¡ "DðQä#È½Š¨òaò’K—6¨l™ReJ“>>ŠÐWÀž†Kt¶Ø·o¾ ?(*ZAB… ÉcqBÞ=r˜*•VyZO87/Æ<®'N„ [‚ìX¯Œè}h«D+n¬ P·®\»+äÊ]á÷ïß+| Vµ@&%“‰}ÿPjœø1cÇž£l¼AfÌø„àÅ9èfи@‡&Mz¾ ª7xZÀ`¿xbÄ8Ë‚EÓÜG´YÒtçZ{öòÙãwP¿‚úLHlHñ¢‡Š.DT¤}c¼Br'ùQæK•BZºD‰ÒäG^Äé+Ï'ÐZø"•`é‡ ùæ9}z/UV…Õ=»mÕXiyåU{ý¥[ù!2a\p‰`W_~e` ¨2Ø`úðŠL Prd1b”làÃeš}P¦Ùxãi«-°£¯ñ#,,ÁBòq›‘÷h%ÏX1„0Üq!ÄPM&èãACEÄËtaéÁF±ÿwªxg¦™>”y+µ)Óy3Õ´{OÁ”?Üg”ù}ÀŸWòH%À>bEÀ=J.ÙžW`}WNI*Ö<ô0òA>L(„{Õuá  j*‡~¶Âaƒ½r˜I$’¸bb ¬Z"‹qîHÉf¸p&Äh¦6#޽…Új¸ÆÄfO ·XdSH.Ù=ÃU`PAñ$”-DÓé³–ÔmäBGÕuDfwÞ…df>ô^K,‘Sœç™ÏzíùÔ>´R”!ˆ$¥ÔŸí :UUT @Àú&ÏNd1ˆ£cI:äm·‘5#!¸…HÀRx×_"”zò †惈«žJÿ˜¬½’²`¦&“_œÞ°À®¢%,>½Îôi©¥fì­½Ï1@Õpà ËÃWL.Q©=m'%r6!‘ñ#nt×UÇ‘˜c¦».H%µk^›å™“LÙäDïíÓÙ(?ÜpŸ¦†TÀOŒ0ÊV„ ¢ 3™– .Ö´L ©±Zm]+ò…#S`²_z}Ž2`’ø!ê‚}xòêE¶‚ës¶…Èe¡Ôí8šF¬ŽÇŽO<ö°u¢Ž÷§1‚Pr½ó aY¹ˆ¸ ýF…y.vevÇîwîÂ;Þ¼s§ô.zÙC{z×øÃ¿H%¥¹=Tó•€gÕÔÆ æÿ)nK*ªææá±Hà-"ã‹]ôБ®fªÙêH×Á®‚s ! „¦W£ñLPEÑÔû>¿ýGqŒCÔãÆ¹œdìa•ࢼҖè#dŸ«Ð…L6ºÐ™ŒäQf²ì„J!ùú¼Ú¡†3 Aè3ÝñN5®q lâƒ/Q¸‡´0W-L)gy Qˆ"‚0•+L¦¬^˜´W„_ˆD]ExW/Äw˜È’ÿn3áR>ªÕ‚À(C)J•R{0Rþ!Àâöa•# iHîý"‚lKxÀ7ê1gw,Y¨@WGR…s#ˆ¨‰>¢@°}!0Ä,PÜÐF3ÊÑPÈßÁFxKHÔ³ž5-²D_ù@×òñÉd!©I˜H&!ŠÉ# ±(MŠX«¹Å NM H<à„ó±g_AiE} A8?1‹AFBf¡ä¸%mc”£¦‘ RM&qÌàG6µé©¸Ðñ/ $Ý8OYNü‚TaRˆABÀNv2úXA!KˆÈÏ(’_ŒV¿V³OH. 7 +^Ã0ƩŠkùÿÐOBlص„l "ËYޏ¬×‘1a‡‡Ùù++·×.ïy”£¥Wœ:R¼•ô'£ðW}’òV-óû£ßT”‰(D9,Œ ªš4 Ô•kjJ›‚‹QIuÔœm¤§„(lŸzÕSúqS ¾>€ˆhfž éªîlÔHcíY#³„ÐÆh7iñ˜A¡º-…ˆ­[Z×)ibÑ!®-°gzåGÅw’ÃŽ—Ù)îÄ>¢ÌOKaÖ$[(•å€ag’gÛc±iý7ûØã8„¡æo*TщàoD!¿m:¥8ÅvâK!X MVû³à ·X«q ÐBâ5,*`<ÿ¥²ÆÆ*‡!é"ª‹J´ý5£é©1_ùð’n³| ½Æ;“"à oó0)û 1L8‹AäNÐÅÅ-ì¬cZ,V5"á¦Ë^€æ xN 3Ž£3Y_œüñË…>ؘ‹ä"!QXð/ñ-?’òh;+|ÕËÔîF»ª‡A3ÜG¹Nƒ @£¢VE]S ѳžohЉd‰\Ùµèv0šcñ#hJ¼N· ƒ$ !©zãrŸ÷5ÙR»GUŒ0Æ)ª?ZPX$•›þv€ÛÜÔ;ç)¹pÊnÆ %¼N©ºÐÐ4‚òGzH¸4èAaÿ„™¬š0ÑÁUVÃ2Ü #˜Í¢vû”§›·mX×®Eä[AL%ŽÓ%êt±+Mï2ì,Ëd™˜W7A’)À^Z“ba‰Á?çK¨ ´?û¸¤ºŒ¿Ì+­P+”ì¸4{Ä ¥è¿{L‘æS*ï¬8/8 }Þ¥·ÙLéƒgŸÁ'>ÍÝÈc% 6PÁ?3þ³ò´c–6D\êGƒ(”®Ó±^vh¼ÝQçØàã¥å›V}ž^4ñ#À×ùöõ=Éz`kŒ_‚¤¬0]Ê…Jòxƒ2–ü•œÍA3çÎùFL룀l̡҂Dqà•¯·VpŽÁÿCõçí¤Çó1ô¢ËÈv†6÷îô‰¬PÆC”ŒÊ¼_¨(²nut H“¶â@‚àš,œ¼ûF*ÊÔuUªÌYüYÌ¿Èóoá h@N™6ñˆ€/ó ûýS¥¹Í+õmžÿÂÁdçS>AzXuµKºo¡ï¤ÛŽ ËküŽˆý“ Åž X[T˜ MH×P×C|Ë^ ðÚµËÁ¥]ÚÙRœ´ M —=ÈóŒûdQüìVàZö HUpÀö¡ÑåÄÐmœ…ÉaJiqÊç0âé™>@[ @ÐÅÜÍÝÜŸMžN˜µaÿÛ ÔVÍEÚ=4ä̓˜ˆjôŒ= ‡-²¸›üŽNÌ›¼­UOÙ^ãEÉÝ]=T_QÁ‰`ºôšœIÅ’' ÁHÕÍÙD˜àóÍš~ä|Ó hÅ<@Å¡$ŠNÑÔmØTWœÜømŠÈˆÙ(Dú™,ˆÉñÿE[HØŸýüMØ(FA\ÕßU郟Yp€È $ÊCÿE@p j†ôâÒ1]†’( }Á5 ¸U?!¦¹À˜RÀì ÉL ‘`µ I¤Zñ± «¡ùÈaG‡Ü±—!Ýi=ÄW -ÌÔ`ÐRL¤Eš$Jʃ€ÿYeâ˜5”ã¹Ï[Mß<ìNÊ"Þ[F¤M ò¤EŠYqJ³1^ã¹W²äÐá ±GÆ¢’ d;…CúÛ·<¡·MÕ)NU^aºÝ“iÜN/ÞÈ].'×0NÀg9—= íYÚ¶pÊô¼–GT£w¨Ic^ãL ™`ÑF…OKP‚ÂÅIé$_ åÞ ŸäÿÁ $”é—Þí)ÇE^EÊ <€uùͦV²Ñ±Qn „(JÑ Ú(Ò*Ö…±™ƒµÖ$ú¸“ñßU¹G–›Ñh乩Þk„¡l`\"ÎYSµ¸•aæ¦U"ÂìÀmãŽEæMšEæO"V›`¦ñña÷ Ù-éƒOø À Ÿd R¶ÇH]¢¸•â ÔTzEÖ„§™a¥>P'ne¦´·¹Ó“ØC´µÀDb¨â·UXkÍLM ]XJXU­åÌ¥î´cš=}F^¶(XÕjD@qñå˜@ð`ÜfAÍÔ¨î(›Z‹ae™É)}–žÿšëh꽆ħ–»ØÂ‰À”ÎZŸá “:&åek+´1HYŒǸŽÅR@žý†¼EIÀºr[#ÒÔ’4ÁDf€ &áÍy鲆‰Ìivø}ØGŸ ìO „ªÒƒìÏ?Í"g «=‰›[Y,t_]`,Æ’™Bl"°6ìÇërÑ©æy @¦ì9yÓ_ø+ò9™æŽº(0Fç‹öŽ0úìïH’Ô5 µ­£ÇÛ*ÿÈ %eÇD—4êkÔr‡))Çb¡˜-ë:äƒ Ì§»tTÝÌ„OüKQŵ¬”Ùƒ ¬«NäåM•…¶ÅùÀí‚<`À0h>!lXTk¥ÌC , HS ¼äµ­Ç|%~K®nHÎ0«©¼Š¨hGžÞú‹Ò4šˆkëÅÀr^Ç çêfX€éS,ÊÆ°fê^”vM–¬‡Ÿ5A¢Pa4ÁçM+F±ˆ'À’'ˆ OÔG•æR¨qd ð¢­<È AÞ„òßÝyÌ‚XÊJ6m^ÔDÅ^ÆîÙ&bÊ î‚øYæq/œ.›åC%Øø:Õ8•Έ¨ ª8ç<ÿKäB'†m†jÿ`x@šI2K¼Ý"íáïѶ·õ¦ßr–Ÿ@{L†bv BœO (0å+²ú&+zí²H»\ðPØê‡ô œmÆÁñŸñ_Ì"òz1X]~¼Ë5è®ÖDᚌš5*X~â›ê0 ûæàÚfCÆÑ§0Ê é Ì aÈ`Ð,^â%]âåj¼ou’¤¸BÆEZ%¾p,¦¼-´àf Ì^râ CQÔkq "”‹¶ON4p¤ëå)°''›@E‰Lô˜àñ¬M:"G!‡ªÚÃ_N$V8°[RZí­‘Õéh¾qJ=!_„Óç˜ÿÓ‚Ýæ³U·Á@rå‚•™†˜kçùÊʪˆeœޏh )ô¢%qÁq™€D?1t»…£†€%ƒ,/ÿí-îR0ƒ(uø›õ4XM0Äêj@ÿ3»ñ6°9û&úÄîUDÛ ‡I\0R\€ç?ppã„NÈàåÑ”å¥$[Е=ëà%6h³½Åƒ9U™Q-×µY[Àœ¢¬@ô3VFòT‹Ó«Jb¼ÂÌ4®FB®oá 1冫¸ÂÛ?UµÄ ! @“l…~±V ­&gìæCíEYO·”Ù.ÁÁôÃôÊ4úˆžìVÇyFæ#ÁLúiÎOéÿƒR€³ª¶jTTž<0°D* 䱑Ús>ÂuÊ· 91ÛUî…‚I ¿c‚m É(ž8±Y_ª*kkÑø¢pý"ï$ÒŒ¤[¿µë9ÌXÌ-XÒkBÞXXŠ4'gNð&Š%§=°"¾8„¿¹ÀuHI‘á;e)c;6HƒôLÇnìJÇd{DIô˜O\ÑLÀQœjRðƒÖ„ó2jëæÍÃA‘ŸžÝfk¿ö9홞A²9ÑÖmWµ„öpoCò/èmmÿsk·©¬,MšJŒ˜Bokê9Råú¬D“¤ ÌòỖ[áòùaèV‹Û Gr¢Ð…·x£etéQG¿ÿYrfi Ã{¿´÷&;µ.ÿ65Wǃ™šI¼Ë~KÀp³æœ*á¼U«ê$6J!~€;ïEãõ‰[@U?¾v%ÕSyËE4T‚Ál™!‚¹³´B@Ó69©‚ÊŠ@‰3%¤¸ä X!4Ϊ#}˜H£D[1?Ä8ER¨(†e8  µG (voöfëJyw‡Dœ“a£×ê¶ÁT1öOá„Å´oŽÔd“ ¹¬‹¥î7Ok6­‰¦€ǘ@Nu€N=¾ãUÝ…k6ØSËy®Î3v™´)æS]ø·p+Õ‡ Óƒ½V˜µ ª¶êÈûZnèm>F;šJoC’§)Á¼)M>„-X.H@.lâž„D"Ôw ú¢„ˆ%_.} ù° _F3nàèq#F6,XàiFxðÏD¼xø8ÁâÄ<{òñì™hO{ôèi8q‚(Ñ£-ä5•×D^‹%KZœÐ@Ïž“=)âÿl/Ex¹ÈçÄXµk×Þ»ÇÁí½D³¥×¢“(.Dx-¢ê¯*ªzíÛgHB…>TP\Ážâ‘? µW _Œ%Ü‹Úô½&LA·!AŸˆ 铵>D²i´mÛ`Bú~ì­Ú·ˆ_© ÞÖ—+Äñä·6/~;a¾Nè=Ì·P6%!ÛñaÔ8r#øŽãñ‘4_R%ƒ–-M´—É/ŸŠ¦óxú Z¨=»VéÍ3Ú4®Î<›ê)ªZÐÀ {ò)À¾êå"¬,êZ` 4yÜâ@Î<.',l"¾úú«—¿3 ±Åsìƒ!³‡‘ËìQa²T8ÿ¸ä:´ÏH3M¶Ù™-ƃŒ<²6%mh7ݤ,ŽJáv;(éBØ2„zr ‚¢\ˆ ³¨£GDˆ€ÒLJ 0ò®¼âüŽÎ8Ï;)%õXrï= °ç¨yº„OŸ €ª,¢æ¡g) @€G=²ª«BPp"^¼+BR,Â…œÐàÂÑøcê›jaщjƒ(äåDÁÄR…Ecä§ÆvŠQ¿ÊŠR{Œ¹§Ã‡¬ê. ‰l®Ð×P›¶#©u͸ÝÂÔmßé·Ô°Ë硆èÙòK'ÙöJèÎqº(²ÔG’Þ”3¤9ãôŽ$ HZ=•ZrɃ˜â) ÿ&Fs ¶|ð;4ýèQ¡¿X¨jžyäÁ@žG ˜¯âyæBÓ‰|ˆ+”#ôŠ} (ê„&Nh#Š5ôøãE+>/Kvá²6 ×Ã$˜àEÅ*Sz'ýŠÕ©ØÞâÀǧ¢Ê‰(V6™ÚלdÒHã ›mÊ„R³m¸ÛrÈܹBèË‚VèöÚƒ ½ ¯X×\ÁÍîÈãH_}Á;o”Òc饗dÊ'ýŽ:AÁ|­O¿DeJA'Èø„ïáXg“²¯^“õ¿ÊÒgÔ ‰º”ž&R CÓ>Hô¹¨û™/^‚V,ÃSúÅÅd¬L?ý®ªIƒÍ:¤:®§ÜŽ¢ÿº¢pÛi• »îl‰n}Â7û …Ì Šú»ÎE(¡0ô;¨-* D4MnóM§SÿþË»ÓpzjÉL\—Eì(”k‚R™|( s'èÒ–æñ‚G À3‚ Ùë쑉œ(e2ËBU”«$woÁà –Ó“¤d…wñ‹_â£5?‹ùUòb1zÄ Z²8ä#·@å\CÙ’tpƒ­%-©6×Òq Ò-ò‰­PkÃÝ\ˆD+ŠMK[:õJUš×UÄM}#þç?!¤<À“JV€8ðâ`—YÐPŽÒ%“A,b·»\T ›Û•@CèLÆú£¾sÑÃ'ÿDÑ%"!±ðe°¢G"²ÏH„|×™ˆ hEé•+:Œc£VƈòÅ P“8OI ƹÍÍkt7+¢éË, šUÐL—WN¡®’}Ýs<¦U&c5*,Ö«&,–CîýPz;žÄf{.µlf“¥®FA 2£i^wMœ‹~B:—^|!Ѹ þ’Slÿ6çp%Ôd‰2:“ùö6„®¡v»ˆUnÅ—ÒOÄ‚bÝ¿8÷¹| ¨Î7]ŸÉªA½1§$d ]B>/Œbù˜U†#V 40™ ‘3Q¦]¤ä”Û1²K^âØd#ÿ°qÙ6YN§ÓÌ¢–ù§,¾Ë 0¯’e¨jq›ƯÀí¶vz#:ñ<°—¡©|…²ÜÖþŒ@ëã܆Š\~„»E£/( ê‹* –JÎX!ËÔ‹Vr*R¦ÈA>èw‡¼ÑRfM»g=í1‘*O±²¦\àÛ9ÏH°KÆyb¯ë{Ù?fQ¸[úogGV='Ü.Ùg^–îBî„Ð86 ð&Ç™í:]û#$‰@×ó5Ú,ãfi‘Ð}s£»Ä>©L5ÉMÏåþ•õötšïë0HÇ5ÝZ+Éõµ-¼1š@©…êxîQé]ï4DµÅΚ֟ó˜\üXß(¥ÿZ™Èo§YM‡ž©¨ n¹Â¼Eú…måÂQ?€“´6#5?çß÷?æ)Ã~z¶(ÅM—?½èG÷­¡]â5•XÞ_t×¹þiÀ¡LeáÅìiäOSBêÁ+¸ÒAö„Wæ(Ô¬‚X ¸åQ§¤› d.²MôõôɆYãH“ïÖÄi6IÃK‡Èסß߼Дx¼A¥ ª¥6%"G›ã ççlÀд„ÏžÈþ•¸ÐûÖ·¢è¨Åd@ï‚bô0(¶ÂAƒ’„@­PG+‰PÉ/ìÊ+¢îÓîÓ¼N÷(1ÆN°.áæ<êFÒKT Éÿ†è-’î E2`â)9 0l|­HÐ8‚Ké¤Ãz’âØîâ!"äâ¿Äl:v›Z@.ˆjòA¼©ýÀI<úƲ <¶Í< ÛðSÈ„ ¤’ì÷ÌMøáJvƒf ðãNôf…®:põlÏÓ,ê/ƒ»nõ<Áö ã6J}¯iL>Š%XÕKjRÅcàŽ—osf‰°Œã %ïàǦ¤IšÂÈð–…KÏ¡¢ ïÂå:,ðJC.>ƒ,| ýÌI ñ%Ûüe¶ OÖ#€B BKˆ¥Î 0 âèàg+}Qx!ê0÷ºnùj»ÿòªSV/Ÿ ¼£÷z¯ìj¤÷pb‡&Æ?l¤yg"EÖ˜ïcZz{I°{~ëPô¡«¸Dd4Æ?Ë!¶äV‘ µ¦"ØÂ(¬Îă©F¢ 1O=ðÏÍF:ªÑÐ \` Ô0#ðlÞ5+$}ñ:äÑ.#·±SòJ,~Ìëü0=¥‹æ¡÷˜¦Fè2‡áTð°ìÁ(r)/ˆ3€0@kiƒú®Ådbã>QK”‚)´iÀä'Q\.AC›¾Rv¤MKƒaÖo"`Áà *¶`ëN '"’&0ƒl¢PÔ¤·#µE#i#ÍÂeÿr,¸ä:æmõ(a/ÞìðpO% BóJÈ«uX~/Õj­iÎ(b`í†Rq&h§4=ú¶¦‰4‘Z ò ¼dšô1ŒðH®›˜°¨ØB-8  8 ¨¦4D„‹ˆ„ÚD޾‰©&*Ï!-¶¦jz±0¯ÄôŒN64R Õð#] ÓÍe 0ÿ¨A2ÞP’’p÷|¬<µqàøJà´ñÇ Ãh.“ƒFvb3O€  2Œâ*ÖnG\0Ö$EgM‘æƒK¼d5«{ôáyäPngäÁ@¶‰~´É7©&C8Aà r! áV ý(aä,NÖ’òÿÈ ¶p±$6@F"í|„«ÄF¬×vî³#G 05 0·BHÑæ/po2'„0³ÞS2ÝSàP'£Ã&“,> +LX’þ¤(üC½RðSå-Ô‘QsQü¨¿¦InÃKZhš"BH*<ãC„d-64Có´¨@Ôgà…Ú|`в =BEÛ²œÇÂb:Gà:F€;Ï"0£ôŒ. Ñ·¸³/±Ã6âpH/òÅ^A!0,Š=Ÿt¹ 9m,Xd1nò&q?c@›b2"†ÕZ-íþ³yôQÚ.R~µW±æô×lC×äpqç)âzŽ(7Aƒ7¡•~>Dÿ;¬mÔo@Ñ’P•Âj±95%ðÏ%g7"æRâŠ1u/3Ò]DS•é:ªóSKueR¤š‹%·QBlEÒþ•ÓŠÆ_'QÍ2k 82°‚øN 4OÀÇ4a=&Ö"åCE5´AbìÆAÙ9®©6½’RÚ¬ ÷”O=ô!^G6²5PÕýhQ!µÐWlüÃ3B²æ¶a~ëÊ&¹§|*®ì†¿ä¥4Fc“7´4¬ãÆìA6À‡!w-c– Ó÷qIÂ`T%: gãÁ F;7+bªiÝ$gsÏŠIW£ppÝÉ"Ç\ Ú`-òbÇ€æwôj08e,üB•$ ws-8chd¶š%†ƒuÚ*Î6b 9@ª¾ÐT‘=vz_ãôä åÆm‰\L‘ÃïYZ§õCÉ%AÀl àÊ·_Ö·ˆÿ§#Nù_ZFG &^"5< «šäP€кG#7€—‘zH…‹˜ðÒÿHº7Gà HiŒ?%0C19°SlOÒ60lwš“Ìš/Øwa•š‚ v?üx*(f–`œ‰ÒœC»Öž×'¤Eݵ M:@ñ§²H$éY~ºÒ+‹êªÙ­¶º| #x› õq.šZ&¶E³¶êÿÌ Ý°“;ÑÜìZ¤3¦ DòÆåÜ© ¬ªTLZS>åS4Þš”iwÒÆB•&€kõ3l!prQ†O›—@'.˜øöÿØ Vœsi„ÍYU¨âJ¦Q£‘&9RÌÊœZ‘ë#¹büL–¶õâzÈsG`n@Oˆ›9iÖòR9‰(q4WJÿ\˜ô@O®Ÿ[s[Ü®Óírld,d.íC&¼ ÛÇVz%óiÈ+ –JÀk'»÷úã½ÅQj28¾.¿§Ê÷ÊE¸ËùâÎ…«z"¹·¼K¦©—~ê­± ÚÌ;¬+¹R^$(F 7fËc Ë÷ÃQ]`’¸¡gÂø¡‡)²: »ólÚºèz±F7++bÅÆh½uQ¦%Ýs1S=¹îj/©­Ò›keµwß;É©Fü‘B!g(€bÝ"¿;{mý›Ê/ÎÖÀJ×Ü'üh¾¬lð"I6M¦Müšpg ÇèôÖmDu±«!¬ÃñáÜ9•¥j=Òzgÿ›X†Ú%¸DRÄš;;ëÚŮĒÐÃÊÅý"_]ZUÝ&3U;ƒ\šsWûã&ß¾/x³ô&ã½Ï–BCx*¤Ü³‡zL«\@î!'¥>`#K Fé˜Îz Mn pzO ²Ä¨§ŒPM¨3 `ºš«Ë7Ùå\¬—]ä…óì•ãøúœÚK ÐÐ -õ#€æµFëÉÃâíß2=ÝËÝ;±£f(šÕÛUűáÅw9½áz²)è[½º™@\ÊÃùß ¹G .(®Ö´ b$Bk½Ðèë´µ'ƒ\¬iµÒFHµ$ˆ½Øu<|ûã úÃÿíþ g&Ú€D`Z¾­³¹{4Jø¼–‘ÑôÎÂåM†m¼Su&YÏ ÐÓÖ¸»ÆâõðJÈ+ÉÜûUG¿w›@pÂkMÊ©~õïyþ¿™÷œ}Å^Ëå«'ü®5VÌ=¶Ú%÷ƒÂóÔpÃo «¹Õ_\´9ç\ä•ÿΉ;:_Â=^âŠJïr?Ï]9rsÛú–[Ùæ¯ÎPº8ò—9Ò3±îHû’:ŸÝ#wß»á¾=ê&4ä–õ'ÕÙõb‰@÷ ä@à^B&¼'¯Å¼yô>„È÷áC¾|¹$`Ìw1„Æùôé+i²d> &?è“«d®‘!ÿAÚÌg={üôÝ`°`ÁA7Å·R¤I6]úô膂zb€uÄñâ™0Ñ5ž>~ˆL¦$‰vãØµ=E¬uëv¬ }.zntq÷® EDðâ[DÕ¥K‚ _òqxðaĈ¦”˜cÆE|.r9ð¾}>L°7=FŒæ81‘^hÐ'äɃ(ï´éÓå-±mðÞ@Ý >THaðß±)Ú R㇘5^Ôxò¥Y”ú\¦Ô73f‹!Blß¾1„N{ùFˆÊàÆ¦NEjAª|¨Më;5ŠžA#ºëU>&äcWZùp I. "? ê#B]uAØ“ÿY *XÀ\{aÆ`ªô2˜a>Œ¸Øˆ$ú°c—@ÆX‰>¨RŒ˜]¶ÙŒ|PZh¢Íà ¨‰†#,¸öÚ§i@ -‘[AL2ÙdAÝÓÐpwÒ™dšÄK.A·œ:µ@ÖXï¤.=ŠðSPêåžSþšý§}N¡w¨V¬pÜ]åévß½[—R:V„fE쨠†*/¿¸ðKâ¥öÒˇ''æjäŠAÙ¬ŽÛºr›]¤i¡M$O%œ@Ú¯¦-1$ °-Û³ÿÎQ´´MVÉBµcÉ‚ó(-Òr#•ä´>†Œ+uu`©u XÓIOïz !QA!{NŇ½T‚Þ·ý} œÕVa·Á'Ì‚ Ý„[q¥ F±‚ñ¸P€D±?áäâÂ!îŒ[UÊ$c¢ÈU®dŒ±•e:Ö²}ìªWaDBç#Füª4=RÎl³¬Û<É6ÏÊCfפ…Øn…ÉÒ¶2‚—Ï$ey˜ªcµ¬)i-Ð@礭O驟øÔ§9…Og»~У‰l£E°3i^:š}.X>b¤Î@H܈0JÙ’$-Ù›Ú­‘© 55¨E-9Û±Z4O`ŒôP•ãчôÄ&K³ñÉO´üW U•(J‘?½ŒG0=z>,&¬êcXO"ÿ6ŠÅå˜kɇ3QÙ„4a¦4•iLg Í4RS€ #gGôBœ,ÃLx5D²W¼:5tËR'‚ÅNyA7Jj] K8¥†T Ÿ¾Édµ€öšœF]¼û@AõÁ%­Ê‹ˆL—×%4¡ö "ŠP½±ÍÒ‰Itâ âƒËÿ%+RÔÊø Ò+Ž”¤Ã$ФÊ•¸é”7µì3Ðp¿iŒfAõ—•ÕªŽ¨² i3sZϸ5N=A „´Nv:õ6´mUsSB®@EÛª%õ » Ý¦±nj´§§ë” •©ËF‘&ažäíHj8«Ú¸‰Þ$x÷¼ç1•C ¢Pæ¹;'R'´1Œdõ¹ßéÞ²ìúŽAÝÝO¼z»\VÒîQ’ÊMíJ^r«éNö™D,eJ~Lt ýÿ °Ø¿8ùGŽÍ2›ÜT<ðÊŸÚk£fµ®a=&0É·YÙ¹‘.ŒÉ×]©žDópІ%&Á»Ð„&1•SHÃCîâ*Ð’Fu4æ5ÿu¼‡WÜves{ñÑi`7jäU^|$UE†U|QRr7È×0̧u“ù£Y:Fÿ*x‡}3òqÚWlrxß×},Ç+1À`3ãTt %gŽDBª“m"ôHFó:·C4áv%‚vŽð:€…Y¨…Ž0 Mrt‡Ö Q;Â%\tâCïb‘¦s¥@^àOÐ bÀ9` –˜€oEa/@íᇸoº—QÃQiçv‡^Å‚Í1L‚ s ˆQPk:ÑÍSk:ƒGlçÚ§}†:8#–±Ðæ9äTw6„,¦1:åç~Ö™§ÿ?SàF-¡ýà‹¿Œ¿¸Ã%GWh¥'†ÑC?t†ùc ’•ûŒÓØTKíñ=øQ6]g³DQØx(C–(Äçv^Eç˜EÁ·ˆŒØp ㈂ äAN°‚˜¸5.ˆ?BYìk¾ë»šè ¡“>Õ%ÊHŒ›~j³Å’Û!¤2`®2CN\ÿfÒÅ´ü("€œð‚¥KÆŒÇTñ”3Œ4,9‘T¨µ¬Ã$'äÁÒ¢ÇZš°ƒ€Âý°Ñ0ÖÀ HÚ— ð =ŒŽ0·ÏÛÓkÎÕÛfP“Ú; ÉÚk¦œù=7>–|^æËPpŽúÄ.¡ŒÕÅÄØš 'hÞ !ªÌ1wMBu"A…Å3¹\Œ¢´M´¬àúpŠ!À#¡ ƒà B²¡¢±,TUy²;˜§JK 0 I÷ÍHʞÀÂߺËÍ‹ð‹Ž`«u«ž½ªoìÑ·7Їû½ß«Ã,¾é‘(mÊøÌÉ-ëšs ÿ)/{¢Ü&¹Y]Qð¾y³Ðt82¸ZNÎV}û˜!|Ëž2!R8vú®'ä4=‡ç–-¤nìÒoü}¦Ì °»k¤ºû‹'P ¾HÔÔk™¾˜ë‹Ë¥/Ð úf“ëÁÈØ˜½í¬ÃÝÛ“D6¾®éš™¼Éý<§Åñ%Ê_K<‰ªbA? #¹lý!²lVƒr?bŸx?ñÀ ŒšìóPwŠ% 1%=$Ä‘ÒP‚DªìÒ÷·Ø uûy ,9ÍŸ¿ÃýpÙ™­»èüXúÙ«Ê¥¢ o­Ð ú ÿÚÈ: ཨ]?aɧ&|³=ÛNÛ苾„Êa-зù¾$a¢ õ#*¢"ÅßWT~Ñ]8¼Æ-!ŽXfº¬KPÆÀ žáÀòð[Ù‚Æ<NåÒT(´ñµôIª*¾X° €ßº¿X Fž¡-à?0ÚÞÎ{ÉSAÏì¼™a.=Œv@Lá²M”nlZª§a­4bý§ñ…Ðî5.*Ó¢%^rœ«}€œ881€ã~uí}Š8^ ß3òØ 3æÄ:H˜3q©B‹}¶ ¶²3[L¾Ç¿Ø@}ùÓë ¾8 V¾ÿ¥¾øï£Í‡ŠL¦¸î½L EÂJ{»t¿§ˆú\áøü Á”é#³ýÕÍn±Žáâj b{¡Ê¦"©*dæ­ÞêЭ[ŒÀ0È “5L¢+† î†ã°H'] ÙZŽ4—DžBpäOt>—ò¤¿ø ;àü‹êp° à‹zÙ߼ꋢ=ÚY·?€½4ùåaNv°ÄÔ :p¿—>Á'Û*ÉüLìŽ^ü ’±ÕÕò"1Ê~7Nü%¡!!ÔÅßþí&ʹ¸¼Ñì…œP']±@†€êþèß %€Qÿ/ðî%ms÷Ê:±Áÿ~¿¡O9ú‡ùÞ˜t¤.ÍÀ ÛŒ¤Ô@°ªjß’Ù ýŸ´>àuOñßÈ‹œ÷*¬DäàUív'òúl%²ˆ…ò#@w2;çZòò»mÌ'aqhÁ?Í÷¹´¼óœ[ƒ¹<ºü‚x*PöŒ´êôì~ðÝÀð%À0,P4—Ë"\s©ä;g»””ad¯ÓÔØêà Ñk ­>ÑÐäÀ(÷ý >Ú 0ñŽë£–ñÎÈŒ¬ñTíÃ?ìš……¯å¯Ïƒ/|¢ø‹ÿp_=ãÑød%ùÞAVd-Öú¢ŽÈ?áÄE.\ðâåÿƒ  ]Äs‘¯€Äˆ& ÐÓ°äÞÆ{ûöµjEaÈÈ %G†’` ­†\(ñB‹™òfž8Aó„<Ž=9.ÑxC{&"àˆÀÒ{0úõ³æOêTªOûu³šUkVo ¸Q»,ÕhOÃPh 2Bª?"¼m»`Ás7,¸›¯Ü 7øqcÄ~ñø°OEP Ø{ EÅâ•+Ç‹7ØÃˆ|ùøuþÏž=z£C”¦—ujÒ!F³FMZõlzNj×î\ðáC}!Æë-17ÄÃôŒõ”ç1$C#G¶ñD«é,YáQ‚Å š4m²h±s§ÏŸ÷‚àh 3ÿNµ>¹§ãiÔ±S­jÈódßV«ê¢ øª¾ª´П²ú-é‡VÜšK®äŠpB #”ë¿#ŒŸÃâ© ²Ñ#Q²Å(+³Í<ð0Ÿ :ël4{N›‘4FT»1ÚvlAŒ4è1ÑžJcä´æÁhZ5˜çÿéq§–h¡‰7—8¡ ]œh ‚FER¸‰¢4¨*OXBîYÊ#çVZ”ËT¾å’LqUÍJ(M6sªÖ<ò8؈:·z@ÔyÊù Ôª<²RÇ«AËP³ i:Aºá -l˜/ %^à/ G@Äà 2mu4Iœ ±SÌ,³Ï:ûìdU]¥‡ÕÒN£'WqêÕך(yp®¶ `5(Ò i;“v¢¢ÎçHˆ -@ƒbÏ mÓªÎ[0A¸z\rË… ¦™¼³i§jƒòi¨5žZÄ¿h¬tª½Ø7ϱx ÷z{Ðë+¸¾CiIQ¼¡•ÿJ+mØÑ¹<¹.G/Ƙ° `UFDœÌžÆ83ÌøÙ¬€”=måW퉕cÎ5×\XÙÍ9g7ñÑÛ„æwÝu?27 *ŠŒ!›€æÜ§êè°óÛ«ÃsÌz\á:íÀVwlŽà½öÎù là)fè  @kÌŠŽ½ä¦zˆ¦À¾Ç:À |æZÑÐáüâ0 ÝežP܆4”± TÀ¬\Ç4Õ±Ëx(3ƒ?ô¡•UÎe²Q­x5³ðÊfÔrPPxcèJ@SmèQ$ÒÔSù€V>âA¥%øŒ#ˆšr¸Ô é} \aB☆ÿP’ðA˜GºØtžÈ'@‰—P8p¶~ÔO@ÔÐ 5€º=eâ8ðe/ò­P~{ ò!ý¡dÀ#á¨8‡õEBÓÐ ÑÀ°ŠŒ@ê‰H jªHQa4Ó"¾ÈEªZYËfC+NÎÃGN3¡x~uEj‹…ºÒURS¤ÖFw¹ÉÇCvhœ`™Ç&Êc—¾Ô%/Iïˆb Wê¡•¸âÚ;‚<ŽP&[x µÆ§´ŽVéA¨A‡­€Ã~oÄ_]õýQ@!˜@ÈÙ’‰.Cb@_.¶± ò¶b>iµÈC&²c]aø1˜ÿ“ÔYUÇR#B\éJfN£NŒÕL Ë¢n Ò K£»‰ðÃ9lÃzX-šÑ#ÍóeJˆ5$Š©zär…¹’‰l!N>ÆS²‰F|ÑáóFV¤) ð§mnÌJ„‚}@ø@ 0¬s†û£„@— i¨˜€"KptµQœG>ÕÚϰ2Âô‡ê"}\’’ª*äŒVS+Œà¢4 OìJ ÂË¢-<Þ _I}8m¨ÒÎÜÄlIÍ#½4b/SÚÒ—V‰<àÁ ^p„#,…)5åÉ÷6B§£l`Üdã7µâ~,"@îÔ9£y´ÿ€ªëTœ;¸U‹Ýà«‹ÔŽ2“¹\4·SeÔšVD2ò®Škg,é™ðcU q•kèq£…ž0°¤”]aÕ«Â •FhPRRolÓ‚7áÌVÊ¢eS ®èµ4˜æõ\„ÑbÀ´†GRË'DÓµ®-_?ÜcM° `¶ïËýnû”Ü:í…8±b BD«‡sœ\Š{\FÜ‚²0pŒ €Ò’Ö¹g-«­¨Ëˆ¼†5®B]Oš•‰F¯3 !=Z`ÂðÐÌgƒ%¬•zh ï…‹5HBâ‘4 õÊ·5)mô»_–z‹³pL ÑÁÀL1-y–Ó§¤ïÁÿð+j?ðÚÂOÊR­¢Ô§È …-,–ÏÂ39êÛcWyܰ ÌQ[ž˜ÅL€̘Æç:WYÑ¥c~΃'Ív+ yFã”=NãÉÔ¤²”ÔªÝzÍã3cy¸4ÉGCâ‚ù+°ó‡LŽ æ“ú²ÌÏNbõ\êÙ%º‚$iïAÓðaëZÑȘñuÜY@–p"Ú‡asgضdápaymž%7Ú€£T 7‚Æ ÒaÖô>ÄŒiMçÀÓn&-wX€®…Ÿõ¾@õSu2 à0SEv^iX± K<={²°ŽUšÜ˜@I•¬Íl‚å*ï¤ûàÿïôÌ<½—N{LHHsLÙÙ³ƒÛ=5XeK¨F5ÛÝZ°äyÐë‡#Ô{Ÿ™rœt¤ÀÃEÜIW Å,È/³¥6vÝŸ1ÜLckÇç9'ÎÁº¦*4-²ÆgQÁÚXÄjrr§4†$"2ìÑNªÈr7? à(}v£=&›[¯×»ž €í§=Îäq„U¼Án½õ)\ØûÑ€;[ƒ– ºŸ~MøÄI…²n"°º!ÄÍ“•¾ÇÀ>|]jF({Á;}püæW`´v=ÃAéÈÈ12rj­d&G4𾞑“+“§¯¸¶Érÿ œ‚{„¥2÷ï´©×ÙË_Þ®X3åñæ |ž<\쇃­~x)k‚qSºA tª±XŸ¤‚ºÚS-ª#\  È:’4Á0.¯+·›ã{9¾‚Û4[Šåه盇BÊ ‹«»T±»ƒ ӾᾹÑ8øJ“3ˆÎ(•K?üê41s<÷›É+3i«¼ú“BÍ ‚*,X¿K-¡È¢³ :ðp`°°†P&ÈŠÜ5ªÛ—~ð)k°3àkÓc£hÀÃ<ÄÃì"=ÔÃ5* £H°P´yÈÀ–x  $Áp F ,åi?ã3ä3>ÿÔ´ -\¸ uJV«;•I•ƒ"EÑ0Å©!Õ Ö8(£Ù }ð€Æ‘‹è«jQ—™ê´Nc»Ë23$’9(¬<Ϻ<ü3€ °Û¶Û¶-ü6ðq:© € À"+@hÄFþxÆl„—nì Ÿ±"C¤£™X 0¯«´ "²Ûä+¾ŒG²;;ƒ3°ö²„‘PÅWˇ(8Eш‚qŒ3Å~ôh¬…ˆÎH §y“P¦ý[&ÃÄcÂ0‘¼¬‘64¦F¨BàîH&eÚnÛˆf¼GØFl„Gø B@˜ÌÆ~ÐhÃhäÉœÿtAäBªÃœ€€ ôq˜¤|;HÌJ´DyœÊ±»ÇLkA¸«*¤« ãʯLH'`SDŒOô¨…a‹’à`¥Ä›È{(-Òb»s3÷ƒ6hI¦a4€*-P-™ )–ë6ÕJGx‚öÐ ÐGfÒ+‘²"€5€yÙXƒ5Š¡€Í|‚ÍÍä0MÑDÍÍ€ÎdÍA¬£ä ‰¹¬kÊœX L›J|Çáóͪ,;7Ë4 h뻾ÎðG®Ä»„È¯Ô ~`HX^€ˆš(°.S¼mKFº¤K °Ë™ó/ÊËKëÿ±<ëK¿ 5ž£1ó¿,Š¢ ÏŸ·5ô!-2MÓ,ÍÖôÆÖ\ÍýO5Po$D+"«£d¢-¢ÁAG¯;L ¸¨D¾Îy¤JSAM ¢ç;£ÁéôJ®œÁ¯t’OÜ YTHúr8Ï#A7K»Œ¿` F½T‰ú+Æ 0ƘÌý{õë?¢Ä¡¬Àž7ÂÚwÙÏÒPÿ<ÐnüO%Ð+5PË ß-Ø– Žé@‹tœ€ U;¨ìMË:> ÝÐÐE¨ŒÊ9!1"Ó ¬«‚"?ýJ4QZQú¨ÆˆÔ’â‰eO‹±º„¼Žÿü/­IÏõ´¿¾4Æ(p€#0É#…±þKÒ@L°Så+¡2ùF üÏ\ÍÖ, .ÐþÜÒX¢,µR£7›˜‡€ÓÙ\ …Y ˜G|;±NtÓ5EÁ܇èQÒñÓºÒÖ~tNl¬ºˆÞ8TÞ(€Óè²Ø±Ådä4¨œ±µãÅ2ûÅ”¿¼¬¿£ÂM}O­cUR5­%õ‰)‹ŸPUlÑÕ¡0UZÕ¢ƒõÏXUÒ,…ÕX݈7i…k¨B¨M‰b¥´x S«16ÍP7•Gâ;OcS㼇L•íúÄé#QêK®„øÂ¡Š}ˆZÿL¥Àº):5¸€1lž»ôÈKE³½ °ÌR!=€|}Z÷„±ù¼ÏmÍ8éÌ-eMZDˆåZS­R‡5 +J—¿Ü× 0Ž&2U•€®y;¨œÄ EYª$Z€CA#€ °Öš%êÓÖ“9QèL•(T(!T¢É‡Ù¥&»%ÌG%€wuB—&KUZõÌÔ(Æð\¨­Âµ=FH¥HèZ¡,ŠÕDÉì ÖÄÕÎÔ¢……Ýÿ[[mX\M6ß ‚‹E[Œ­“2ì¸QҪл½[“}G{Ú9^ø®š¥»>­»-\®ìYAåJâ»T"ž`×¹,­%[ÿ±´´‹1Œ„Äò¼ääM~g b¦ÝËQå„)Q%€þû×@$Pÿè‚ÆjªÓb¯¥]*E`†ŽÕþ[F`Ón‰z]ÐÅèa¦”¢ê‚ ˆ±‚ëà:¶,ä‹Ïu}f’}>ur*B]ÑêÝ ÆæÂ½;OjÍåÜÄ9¦Îg‘<æÐêgÖÍUÙh‚FmÔnª»b„n‚A¼ÝXë[& ÿ%ë!èËCbŒ®¿” Ë.^X;:µÛ;nÞ55°9…æÞ¬ÖëÛ UÓÖU[ÜæVë;Å#/˜YÅíÓA‘}Tƒ±òäH`:jNÿ.êÝlÐöìö]j˜r€ ð×çsØSèVNíAmÚJ„~å…öâÚ^F Þ”(ÓV ¦L½¿û¦  ¼EI…rÁBN{æe6Ù 8u<9Vž\\Óôc§"ÜéãÖ¾f»3Ũ”Vìê´ïž\ïó¬gõŒgÍvßkZ)ìqÐÆ x€¾5ÍÒDVfm‚þ•úÂjÔÐ×ÖÚ®¦Ò ¸e©ÌdV1­ê8p{žàzÍf WX»$´Pá,¾5]¶eÓë¥òåh"{é@Ö ç~éÁ&qÉSÌ+Óиí^ìY£‰ÅÑ«ñÿšÂ÷õÜù5€zUÚöÿVêoï\"¹žD"÷ê%MmÕ.úRrUÕb£xí‚~Ý…]M*§ò¢°rÐrëܶ5fë%zõ·¾€#ÍE¨iw³øÔżÕãuUµ3ÄШóÀ®^À®ó=Ë»û€‚t Va•ƒÄ½˜¡ŒK š(Ú8æ´¼=ôJ}©ÎMëùmߥ wЮçÏ&fWp€IÌ€þ”bQ'Jaa±÷O÷ô8ÐxÉïWDø~w€Ÿ1Ñ2ç.·<¶óê¡€ëX»’é w^ù$Z7·xN|AçNáewédßÓìéSÄAƒtÖ(ˆªû*-¶SÁ{¬\L>³¢ÆËwr'fúSwÿW÷êA‚÷u¼wçÛS®b+ œ =ú|/úÖ†eƒ–]j­¨Žjà[ø†1à&â­Ô¦&f.ùí À¹êâ¶Çò]WSBƒKBb—;‰#äêýøB5dQ´îðòs„,ù|ÞZùƒƒT¢%OLFëz´öTšŸß_VühZùµykÛõ^ê¦È€K/òT¥Ø£–!’!Á({_ú}gåÎ\]úz@Ҩ̫?‚ €&¢ŽH¢”èqW &2% ó¨ZMŒx<–±5wÞ vNd—­>mlB­sl®Y¼“i»½2ù¼AmÇaµ‹ìÀç´ö…`ÿðdóGd8t#öÔF¿ùH§ööñÀ9v?»ª¿€h"¯…¼&-"D¨¡ÅÂ…- 6irÃD/bÌxo %^dÈC¤#9`pP‚Ç… @¤j„ËõêÙ¼9¤& †¸Â ”Êr䨗t©Ò“ˆbÈáèT¤žF=z¤„ò «/Ÿ¾²üÆ–5KvmÙ°n߆µ—Ï^{ôìÒË"„={|Cœ'ô†#† OŰoŸÍÈ|pÙ/€YFæ`³8[nŒáÁËRvþlú€Íœ7oæŒ3+!1ÜÛxÐà‰ƒÆZüÿnÓ‚^‹6ô„;LØ$£Å‰¹ïà⋽g ´d†Â/‚ðØ)s&ùšHZ×Û¹sæ BÁŠt>R¥J Ž5ꩉ¥E€°0ÏWèó•XùœUVf¥ÅVƒp½%Xö|ÐWyåå—_y$`‡V‚aB-Ve—mg*ºŒjžQö˜f |V 2È”ö€Žš9°#šðškFº‚NH¤Wn$ÔBo9D=g¥q íË]ôœDe`÷´Â<ð TvtàI0Ä Œ7SM ¨·'žC qJP=E_SMÁgÔ~ðgTýU…ÿ~Pi>JσcU@V§œ®õàZùdJa…!äóW‡õ•aóÈCâa&FÀb޵¸™f6f0¾üYeœ@œÕ‚A²¤íäÔÃäkÓR«dz<¼ÐB¶ a©%CYæå=âf™œAÌÝ#Q  Pæ=/ð‹¼0Ú#eÐnŒ¾¯3½’ y?¹”Ÿ.ùD› Bx}õ%Ôh>Z1¤Tú€<ó0òA§ †Åg‰ª¨g±•²©q}P«òEÏ\^Ùë=‰H¢bû ÌŽÍ~†LdBS¶Y‘žý|@±T†£® ìÏ"ƒlÔ‰^MCÔƒ-WÿÃq¨qá†ë„¸f›×p]¦ûenÌÍAuvb+(ip–dDwð¦‡çL1é¹uM2ñi?u”¡VÅ1£7:U’!OÇ•ÈXú üà§dq :Z+_ ÖWriˆˆþ«~Œ–óÎ $Çâz,M ¨8™‹Ç‚¶û(>[õ‘ÕZ«äÖlvµ!Ùi-nf_¶Ùf+§îAôHÿÂÜ´+u¶WïhïÅ™›³ >pá¿ÔJ{Q¡”XbŽ?L;ÃQ ¥rŽãߤ ä1M¥Îd 4è¸ÀQ.r)@\å­ªU}‘]|ô§³ÅÔ„w5ÚQ|±+ÿÖФ„ÀQÑ‚d£ ‘pH¨šfœÇ<#9ïy{Éõȶ='ä# Û¢ÇÕ''"IÓ]>°¡‰o@lÂÛ 6ƒ˜Ñˆä$x &?ü 'À“6´akJi8> a¹YÒv½½D,±Œeƒ… -!H"ô!äK_A°× @‚A5ö"MJÀÃ> L`K^2“ 8`o–kãþæƒļ81Žý©UUx„0B_©@¦6ÕË^žñ4=#ôG¸ÄòCƒôK†.Õ—š• VŒ*Ñp¢Å!ù ÿ,éÿGáHp Á‚*,ˆ¯aÃø~Hœø#ň)j„h!£Ç-‚”ádž(7,X¹€Ò—bÊÜ€¦Ã›8q l¸“aÏœ iÎôÄ h‡’&Eê)R¦JŸ-j‹§«X¯Æô´+Ö¢FGxàÇ/^³Òª][À”*ÚªP¡®†'òêÕËb¯ß¾%N.±/!Aà ïlX _ªˆµ(ŠŒì8"F­Hj.9òâG‰+oÜX úƒ#ŒašÁ-7X-[ˆP 9æÄ•SˆsV(¤«)ÓÓ£O›*_ž¼ƒ‰äMv¨Z5kW¯×¯e }u<³ñìUÿhËÖù¶ní©°Ç~=]¿çeø‹Á} +8ª¿ÿÿˆõ‡Oc8ýYdItÙF­D@Áƒ†Døàƒ¥ýpƒ…™m´ D¥•¶Ú‡xâj®¹¶Àl·Ù„O@ñæ¢C.^` ýÔX£¼QXGEµÔÍ=÷\tÓ1P]VZaçQžtP”XeP=ñ¨yægÞzí©GO *̃^øÙÇB g¦i_`ó ¦ß(6&¹$ O =¦ H"M4¡!ˆPá €V`?€"¨ht¨Ñ…§eÚjÄSÁxqÅuV<#ÄÃ3-°m8¤âŠâ²ØM¼ás 6Æÿ«¡‡sÊ=%¤sºBå¤'G&)lWÚñØXžžE%{æ5‹¥\s©gÏ]*ă|ek_›ÙÞB}…-¦6çª (Ñ(ë>ú'"†ZäCo½óòsé¥ú𣨢74zƒJ¶6Â¥1Ø“0˜ÒÀz[E‰q'ÖdñŠ,²ŠÏ‹­âò‡¬ô 2¬±ÒrÕ­N55d®Ì )]Áb•]v'7Éݱ†§³”è9Û¬´î©§Á<ØÆ××ÑgÎG_ }Ë‚~ ÙyBýÉ™Xœ{VÄ®>¨húæóØ|`Ùe§=öü¬MØ# ‚Újs·vCÖÚÈތ„ÿÀØm·§=ù¤6ZL¥–TCBh¼±A ñ&‹×ø6ø£¹æÔCr?ü´]Ê*÷ZúRÓÙŒ¤ÌI‹œwe-»,Øiù̬zÕV;O^x™ÙfšHïôÓsÚ ¹ÕÿñÇ"C¥‹ÑÖ !Øeß¾#*ÐÃlз³—Of¿Íì”âñ£° {Ç0Ï<ô0Bω¶½>#ü¬†ˆ¨ß†1Œ‘óß:6RÀæ¸9jØ¡FÝØNú‚ì }HƒRš"(Á‚IÁAO†£ÀÌX-à‡!JbÈ0Œc‡ Â Úòp"T@AŽ0‰gáN ò@ÿQ°b¨¯wóÙdÀÄôåxIš¢¸å ÈŠ‡Q 󒮌°ë27@öU¯ôÌZÔââս6:LaHÌK`Ô§·/¹OoùÛ ôÑ·¤üUL.vª:e¬U#™ ÈHjl)¨†¬lT¤^˜ä>dÕ %T…;,ä$Ùà‡ ð£“”`a‰TÖˆ ‡h "éÊJê%ÝØ¤¬ö‘ƒ<ØMÛZZñtÅŸø‡\wZÈo2‘€Ý ^ø2ÛöÂTf™/{î™Ë[Ô‚³Ä./òX‚<Â)½Ä }ís#¨jl7$"\b‹7«ê>(`ÿ¹Ì   ƒQ#¹ÒF0ÈäAeuÄÀ eƒJQY¡à¢\¨ b ƒŠ²á—R´Ï0‹ ¹â3y ¡ô$‘VLz—›ÃÞØžõ…,Ð^³ (ÄÃüŽY4 {܃K¸Ç8Ź„¬o}è,›!VàN}|@Q#XÁ¨R´?ÈùÏ!¨¨ac€ø\?Pƒ`¸55x€¬h ²‘õÃnUÀçæ«(à­=˜$]ëJh®²êÁaݪÀRÒF4h+`?çˆXÙa±Ú8 ¼Å)æÇ!Æ,©ñ”wÌŒáCqy) âŶ7ÞôaÒ2ÏM¦–·ÿüÔ@EJ íq‚%øv ônQËYN§ÎCŒ@ d}ܨ§þvƒÞl€c[¨‘@7‡Y5À@@ HFƒï2Ò ø\Xój.5•Ü»¹ÔFëÝ\ üé²öCüE«kDƒ±22®Q ¶ûÏøÖh£c:aHK q‘–\¢e^C:Ò ¯‚—âG>n:Söì®·(>ç9³$Ôïà6P0OÕ¢;sæ¸L-®S×ù> P Vþj"Ý›4îqŽJwûAj¶•kìλ¹à­çÕì]L@+×(¿œ+`Ie8¸Û(³™¨æ%÷Cÿ%S^ªxEž$DN'ÝAÓ‘ Á´lôà‡`«‚Þ’Ó¨÷ €RÊ,3ÂÆPˆ´1TÀSJÏEwZÅyy<‘}ó›€>P@BÈ>Žl1V#ÉÇ9¾L@Yà®$³æ@_hÌ›k@€@à”€KöïË`  ܆åX0´à¦ÌÞW2mLóé~˜gµ g¬Ïƒ×¥>ÀˆÝ±Í|½5ê8•jTØ[©óø@ªÇžã߯€Â¤¡ 47>(ÞËîÖ£¤¤ŽîÅ7ª®æÄ ÙÞœð Yu´Á`°6ƼìŒ;û€4ÿh¶\ƒ1@l¯5À°Rö6z ×µº×‘Ú Él¹ÆŠ¾þ­¶ *&(îŽÎÅ#©JCKÚÅp¨Q’ÀÚÍ‚rš1¾ç<ÄÃAGH´¢YP6 è[LÚx]æâž¢éåà{Ñq›JoC4È h…VÍ÷BÒÄÕ[Õ‹fÝeÛ¥+“kæÍÝØ.ï‡6XVn;;V“ß\YVWöü®Ú0ÙñB6Ú±j¼æ|.¼ˆ)ܾÉA›gƒHdB«@»!°NFÏcœ,`ĉˆª×ÛÞnöœs.ÆÀ4]*Í%jžs/Cs{ÜËÉøµÂŠÀÿßmr䯙Eˆtˆ¦=@Ÿ“ãËp¬eµf;Þä÷-|ÉHì+ߨý7WmÕk'Vef@úw6Âr›ãX‘`-êstVn(…ay65qPgíö7Sb&005q7ŒvawÈ—| † óÀv}ui8H4öð%ÙG4ôjó¡Tå”o?7õxQ~ú”~cP–`ýpVÎ6sweyTr ¨9ùlűâ…[è÷E x`¢@öW_t¥…5€šã€¯g-#eRv& 65ÒR—n°>#èü@,0 ˆð‡_§‚bgo9ÿ @vC€Cƒ—¦Kðo`ƒ™–ƒƒ3ƒDŠÙÃ6\žÖ‚ Pjâ§j§’j¯Ö1ýƒ §‚5B…œ£^NÖ͆ q%†cyº6r ˜×m¾˜ $W@Õô5Il Û`Úð¨g#ªç$cDb¢>â¶7v²5|70%àu`׈*ˆ|ô(p-d! =…f y-ˆiy¡?HÙsìQ=¤XT_W w?÷w|Ç„¯‹_…$’eVmÚV=À‘!9†šmbÆdÆÖk×’5B_Á@sö÷†-WXÉ—Ú†…þàX¶° Q ;á™{öà÷.õ€óÀw¡‰qáÜAˆÃeTS)öFöÖ<€'gÓ•`‰ƒYìC!p6e“ù 7¥8N%pU‚´UçÇwNX—°ö8T‹jÖ_6²†Î¦…Êv^gÿf\ÖrþÇ…5" Éx`:ÇdÞ¹9À¨f ¯×nŒð& <£UZФ٠'QF•Æ&>e#`óvŠF›µù €•Cqˆ MØbƒ¿‰ƒÄ94 ¦Sl3b`U@„†˜Š3q~€W‘Ö‰e`# v^Ôpfwe `–çeÀ¶ ͆`òE€ö†ZˆŒˆVpÕm6w^A+1J@3j#lpDbÒnUTaòúÙtÇDšâg 0@÷}Út*PTbç +H•öö>qb£0yi×r-lG–;˜Ú36Šâ\Võ­p Ѐ²/ÑŸƒD—IÖ¢/ÿâs5b’  e²"Y™e9uåXbØyõ9,ÐWåVòY™êsz6ò‹5^_VWŽºV‘Ú˜ŸƒJ6rYŒE©ГêsŸ´giÄv¸Ó=Ëÿé=i96Î%7°­@U²HŠâ/¤¢ýydˆ”~ùD]¼að¯U¡ÐúÀš”QBª€±Ò ³P 0a€µ6"óp´ °”qÃ’ ¶ý0Q²ò »n{#€q³ 2 K±²Ž È¥7uÄ«=Q±x‡ªÂ.ŠÓE`šÀdÁJ²*TÓŠ²Èw|óH/>kU°v5-\r;Çɧ›;»r³TÅ®mC®®+~(Âw«¶,º?­bê@¾+áP @ã Tò`IQJм8€5ÂÙ0ìp£q§ápT`"ÿpHz J° i°ösS|) «ð ° å;YEQ³@TÀ½àqƒ"0mc Dy@‚«71ð°‚»NuZ{f.£€ Û‘Á A,@9pö /ô`puñöTÒj›Óú¬kjow»õâ%¥›MÜcº„C8‚Ƴ®[®ú°œÉ©( ³1-rFüU¬¸ 0A„J½ý7À³г’Â7öÓêËê;h2^LÀd1báû`<"0¾õ¾+ð$ê H‚†Åq »>Ü}âq6ݧN|£7PƒgQCx6 ÈÐ*¡8­ÿÀà¸G>owêS%{ÕZ­-\•ÐεœØ[Ç=mñ=fô=#¦iì à+Àý§f#6ÎEU.a»HkZ]õ"K¶±ØËNÌ µ êLj°¦Ñ³öÃŨÇ70"«"EÀðʪ›U`±Å®,hâËxû!ÿÇ’2hqz6ÈÙÇë”Î|#nšÉDZ{Z\ÚE|¬ò€”~á•°)P`²ÔÚÂJʧœÓR—瑳ÐÛÜÆìê+PÇá# œ§b£œrC µ«¸lĹ‹dB!Ã[®ÌtkÈ,¬Á³Ë¬(W|ÅÓÿ¼^ì[ÌEÀ \ßã/âÌÆdÁ)Ѭ¾#0Í,Æq¼w¼¶°lÎh±|ÁœiLB¹±ÂzZFè±9à¸}±TMU4vº)ö` Iu²,+vbÚfDÕdP°œlñ0r-b®ìE°nìÊ"pÇ£|Ñ>¼oúp8ªfqE ‹s9ÛaÒI¡×Á<ZÀ±ÂUPÅ­Ì0ý!ýR?ßlÓªQªÍ!¢¾¦ŒÃl¬ÅýÒÆz­8½¬YÑW »"†6çÌné¼NëLRæRg²Ç.™ÑŸàçR`*üDØW§4[C…†hkv–L­÷pô 졳6û3öÿÐ/lÌ "@Рý¨SÊi6û–G+1}gض»"ãëʌÒb±Å|qÀ@   X<ÀxKÇd±ÙßŒÚ 2Y`¾J@~p³8ìÐtÍJƳ ÛBÍÆÑk»6j3%ì¦ÛSÍ«½ŠuÆgšáŸ©ˆÆê¸›ôð%_B4#;›"ÖˆB8NòЄƒÛ4Sj±=ÌÒ3·SãHËYãC¾ƒPNá8ì\‡#¯Ã¬–´Ž3]QÒÀ¼NÌÅEpà¶û@rƒ·úòZ"6bØ %¬në“Ýd1À"¦Ð‚ÍÎÓƒ–ÔYÅÛ<6ËÙ6ÿPâ¼½è÷ ¬ÊãÎ9aš2šF8G€Ü÷VN*F–ÕÒ%Ñâ0f1- ·bæ‘É’%"æMÜäåM×Ýs-`ÝßãÖÚãì1å„cè`åâ—þÒ5ìG6`qÒ(=x ÆuÛû@€6„3b#æ=õƒÓ8UËÎ IÎ)ž’ݦîáÎÆüÚ‚>hæS6mž‰ÞÇz£ÛTRw¢aã8馩†p Žh›‹ftÙs;lá)õcÆdàtìÓgQß±Ùî0ŸRíÛìÓìá…ÖKÐëA-Ѓ#åÌbÊ»N´0Á8ÔU]ó*/’ÄÄRìb"[¼¶ˆ0À+0˜ÿZWšo³œã‘óVíR*½V™J2Ò€ŽcÖdÞ.Íû½Å‚â!üñÑtâ쎟߸‡–Áa7Ð õn!M©‚]éJÖŒÆãÁ3eñ)<ÆÍü!ä\ca¦Žðúqßð´=î°¥D£±î[d‰‰ÿ÷êm×Η2ad8qË×µ¨9Aì&½ò!2#à\l,7 r`ø¶ú"%ìqî6ûZ€Ù€5r ÕTbf¹ /ù3ÍÆ,ïçz~ÛÊù6èe³Û{3ä‡Y$þiš’(!†0üˆ˜®hãäa² “%i1d1ÆƒÞÆJ!É¢#–ËÿùÓ‚VÆ{¾ƒØrpfÝåÄ÷?œ- ÞýbåF{ØòÝø#­&ÝÄ#bàåÚÌ—’ýbòÙû@°€=„'òXòÒ­Û“@r¢è×/˜?ŒþzTtH …½ƒöThP’?(Gˆð°ÂÃ~úN®ÁfÁ 'UÈW #{@Ü7j¾£I“âÃgáÇÓ­ZÝhµà‡Õ†>Ü:" ¹·DÞ’hOÌÓÀ–m {p",ð!?DüFìM™2^¾KÒSAX={€óý-0ž†i—L>»¤É‰M,GÖpaLD"DØPß!LU3ŵ_kÖªS¿f:»tÿiO txùÑʼˆ„ SñbÆÅœ‹0ŒŠÑ¥÷“AÑbFÓûéØ!²³øyÏÛ¼ˆxüâɬ)&¿Äxó~à÷Á燂'ØÛ‡Ô¨Òÿðê‡Z¡€‚§"Xà†*˜€ÈA¬r¸Gy0Së„ëðCÄš!ÅàK¬1{ @ˆ°ÂcKÌè‘qÆÂ4<« y4Ó ­Ñj¡-{B¸K„ d \Ãg¶Ùb[RÉÔ`Sí6ÜØ­·½FN¾á)î:䔑´3sã°ÛÈLF:ÁðÓg½—Ü[ì¤Ä+ï%~îÒë½ú ò©¹¢–Z ©¦üÿá@ üaƒn€FJ @B¯.e!CÌ:ukĺBµç>„ ²± ³Ç ºVé±yè9ÆY;µµ…Éîi¢¬ uœÌ²N“醠RI)•t’6Ùj;í4Üt³é%-µDDC¸ô2Í0ûé¦ z€²®Ÿ´Á¦t¦†éŽÃ¨‡@¢FÃ@*q¼xâO¼¹Nrï¤øÜÛ >Ÿý€‘…û3Ô¿£œŠê   •G#­€‘yJ¸Ó Ç:K~ÝpžE,`Ð 2UFZ+é ÆPlnFÈ0Ãõ\å¹ð]s4k‰„ÎñÓg„b‘ÜàIg›…:Ù×6ÿ²5Û¨”Ö¼½~®}†ã‡ n1JÎÛ :$&:°s{¢sןÜöGèLV!ÏÖ3A1¾CL=ò£¯÷L½(„ŠBÔP£ŒŠC¼áÑ ḄÁšð« 3\¢äÊ0ƒqžy8l+†”éåÂdmKæô­¹åSeŒUç‘sìõ,\#‹¬²5/HCíé§câ(Õ`cÒµd›¿ÍJ›ÌóºK~*ØRŸ@ÊöçìnrŸ‡Šj°Ûímä^ßí5ùÕ˜ðòäç ½Aj‘$ñÒÌ.ô©u)s>P¨È=nP1PÅ*g¬M c,øØ„2E” 31èT R·ÿ[±ÀV¶J]‡Ü«ÃÀjvsQL I”;ÌäH-(®èYµ ‡DÃÒèqD,ÀX°ž’ŽÒ¤%% kÍj óJ³µ,q /ÞËIN>>0™#Œð ºQ‘m`‡Á@@°·,š-uËHûúÁŒ²,$õ;XdÎÌjo|;ó’ $PÌá¢çE¨r²Ê$˜Á#€,, ÉLÇ: tq„'à”Y0„¡MqªS´šÕc’F"ñ²1€äŠn¨3¤ù!RîdųýP8BâÓšÄ$è)K‰«I7€½(vI8`ãIOòAñÍ *@Ý<Êd‘mÿ4€@#Ô͊Ѐ؉ÐТ6 $#ùNÏ9—À°Oõ~ È¥R@P¤å6L€s›ú˜WÂ"– ŽnCr mõIŸìgB‹(ƒ•BVÎ3&}d~葺y´ V´d% õ¡Çœ FI$"Ф¼Õ4zËšžl¤­c2ÀJæÑ‰pÂ&úà?Ö™ùRyä!f²ƒ°aÆŒ¬in쪈7£Z”N‡á*ŒŒÑ)“É<…)Œ¾Jj‚Ø“ S ¢&G9CÜ€4 šG;7¡}Xð$d:ض0¢-1ôÐ {XÃöî2ò cB“”ô)ÿ A’‘£`Ò“Š@³"pJ]™4üè£XGJ¥6SfµFJ¶aJi°—=ÐÄV¨€=?Í4žÍL±C0U»Iõ›â[SVËR«€¢–}1$Ê"9§ •k¤!H^ê “ ÝBÕâÁq,uõYîáÞÃFt å•a.“Ð@6/´<-?Y}lVEpXY»Ù%lƂԢ$5\˜YκžN§C` æI~ìATìèÖLVÅÎ0ܹ­)Å5çÃú+ŸýªV¦QReÛÆArOQd\tƒpŽdâ5‚>GÉ n-ÿ\Ë<A€tŸŒï{' ´Âb¹W³ŠUˆ„”oôµ Á¼Ù¤9ÍÁIóQËÚáW4DTVô–á'­vJ®Ý–À–—ÙöD­AqF/D#º=(1US,>mD‡Ac²úâ\v¾óãWÕ„„ 0±šGíîé°|Ž"»ý¼\ƒ„|„H~NFË{Ï»ÁµÄ “á Ê)Š¡÷;Ë…Írb/Y’¹¤Bh¬æ4ûÀ PŠа‚”èc•¹Ë Ž$„ÔHXjávÉ ­Óxâ0 t>ìè%(ô@_ßç‡sœWMc6¢WÆãÿYË+„›,-¥ÌcpùBS9µx\v+W!~—d!‹A‹ì r”¬ƒ2¯ƒBM)KYØÄ¦òÏ\žXñ,2]H³•=f3k6Ú¯6%(!íø€À¡9édñ»‚åýrjN¢Õì\L×z`>Bu·]¬þd @¹Ð÷ÆH?ž‘1–~â{ÞÞx)‚\íBËdL'³ÃÀ1¦Ê± ÉcÊ5JcuÅP¬½²°€nS¶"¹\~®r²å{hèâÛx áH¤>Œó²YyÒg¿Âç›ß¼T!m6ó‚£ø5jN#îÕ8½¦Êªp÷„*Ô´ë1xò5çvï~и%ÆŽ£yÿï6ÝŠ…iZV‰¯iŸ3vâÌ)™S(}.ŠQ"KÊ ´B—²¤M‡²yÈ\ìÔ¯M_ÈG¢EãY—IZRÌÇ?Í>·À%(q‰úÛßçÒ®6›ÄÛ8·›r°¨& éq½S‘.?R³&²{Þ:1°ÃàÂñ¡lÀ@£5 >´û˜¹”<8¿š•vŠŒ¡Ñ£S‰ z@µ‰CЧ0EºŠÙ”½º”¼™b( ™‹'#?)Å›/ÈÃ2‰š¡r?n»¼øŽ4Ó¼û‚KÀB,¼¿Îºh3¥ñ6!XÔ7b‚’f) ¹ ¡¢ÿéºy¬ZªÝªÃŠxx©;Ô€éØG>A4¾KD0,ƲÃ!Âx²Bz˜·²©€y6¿3² É€{H2²Õá5ð!"$4¶*“/N))3Ë›B[ð9pËBüÓÂüû9þcP0¤·Ó:Ã: Ƙ:  p²py2ð3BÌø¢=ŒFi¬Cp±>ÌFÄ9Dãr»sš1Or»¶ «rœëF©œ"A„ 8½" ¼ÀûŠ#!”Q¹@ ¬C”+™Pš2ÇÓ²a3 \*µ÷³øÃ¼Ð5Û¼, ÐB[¼ü»ÿi=³ D@14·<·Œš&) `€Àdü(ò Ú¤%`ƒjFx‚5@“èØfМ쇚|èˆJ{‚BÜFlÌFCA, æRAÉ™sâ*¶8þ ¸’¾¼¢dä[MÉ´×G̘ͣ¾ÿÊq©Ð!€ ‹z ÆóÄ\CÌ(Åûµµœ¨ôƒ(¥´³ç„6D:íô¹¾7ëÌQ­¿û“¶6ˇ ÏÔ#RÄœ°%aÆÌ yS¯#Ô  ©ŒÊ<,‚#D¥ ýÌÏíOXP05>Ôš=DœUþ‘! ïCöU• HóÛ”…BÈ2sÅÃeao}axá›-ý<Çý9ÎËaýÓáEæBÐ\ˆ•!n`¢ø}c–Ö‡ *Qå+¬eËSRæ´ÞÕbÞ#Á¥œÑ8YcÀ´ÞEåƒ[Q„3§{@cQã5¦-x´2°˜$ÀëÑ¡Z¯4Ñâ!y¨&JÑ^šýÖõ^DeÜhûÎŒ|äEvdÎË\æÜâåA½%аtÆÛ Ð&þ&SĦ\Ð0VåƒKàL«g²õ•ù‘1¥ê dC‹/~±\6ƒÓgy€>Uk…ã]cCHI ¢ ÿ‚Êf%Ž•y[æ´«>}æ˜)ª{Ñ ä’N3bÉæ¼¬añífo†Èpæáý“6y«_N^¢Ã\ç1„XRöä €Ô]ˆ¥ –â*CÛ8¢eMËe]áâ_A6¢‡6@Évr8áÉŒ_QÍãjK}>c»‹Š‡þå¤2ƒ‹`ÃèµàJÑSÔ9Yâ%KT(Ü|Ȱ°9i‡4i•Viq¥ÑW _E~iJ8_F…d œ&·ËT¼3%y+Ù æ =ø¬Áµ«Ûþ í‚kA¢a]“aåÉØ•Ôæ™ºê('`%šYÚÆ£vÂ¥¯ÞU©<¸…N ÿ§ÈЇ®`d}ã» éjBÍ®«]Ùk i7ü€Ã­æöÞìïEÔCמã¹ý[dýÛaýËÈ íÈÒr`BRÄd|]¬ÑøTêyYTGŠj;NšÅâ™ ™åµ}àÔž ÎH!Vi!(è,ÙŒÉ ’«~ \Á´óS;\”à–€ÚŠãô *æNdÈ)å¦c&»Þ¶ÎŒv2?î’4«îGTìVéj£QÏóÂþ¹Wˆ€ÇElveWC„‰$7$ºšÔbº4< ˜õÒp~ ¶4¬½â—íD…Ú$ªÞ$Wè…“ê~fíSŠm@:ðg à^HðÿÎjŒØvðÊ’X×T`‰s 5®-ÚºÄJfÐÙ+>õèG/æVYõK²j —2ûcD dD‡¶—ñD-lD.ìr}dô=íÙÀp &3¬W{Ý€¹k÷!…šVùþ×‘Ñ [Y)¤q‘q ª$%dË XꌉíËBpð0ó"à…2'03g mËV±±ä‚±¶$ÛÙtèã• ·;ç$<ϪxTÎŒæhÅkÖP’2iÖkšÑDW3“¦€Alm¦Qæ9Hÿîò]×ÅÞÜÇ5–ðŒß"e;âr›O|€ï„²«ë%¶KQÁ¥\š‘D•„' œy ÈhZOšÿØn }s(Œ/¡ËøŒ÷u_w|ˆØV)ÉÏRþ¶šCÀp ¯­h—Ï fUÕÐI2õú —åó\“‘׋h¾î?i¡7wfÜÏ£¶r-_ðçÍ=lÍõH$ÖtbD½N.¹õ Rü÷ÉÐã¤&áâT‹=¥8KŒOŒº™T‘V™x0ó3ÿuÏH¹÷<ŽvU"v‡SD‰RËMkÛòeûpùîæ Òà4Yd&?ïÃÓ䞇…I+Cú“^Ü¿&z¦aÂÞqEVúÍ›t˜¶ÈvUÚ$"O4œ "/Æ%άVú>ã¬y§´¨ ‘m™0)0[6›q‚ÿñ\è‹×Re¾ú ¨t¡3¦ ^"x)"¢hU>–ú¸äô)T¦I‹Ý™ÏÞ¼—h=!O¤H®òö"øƒ‚C*¬­PÁkHÈa—@޹îyü2Ƽ#E’ 1$ÉyŒBÿœ¬ D+(¬˜¼B²åÊ—5s®¼`…ªøPº”S”P³VíºµjO”dSÚ —!ørïî}Рîß.aQŒˆG(Áxo£¼è;‚-y2åJü\äÛnÓƒ>š.Æ“¹2¦>A‡Eê¾hj¨ >•ZD¨ˆœôÀRïz¢…WíC¢–ZlUðA !y…W]êuOEýae%’ƒ'”0=Œ|ðIÙf’Q¶‚”aÖ™f£­@ÚhK½bã­±v£k¤¥¦Új”fo¸4A'Ü’m°Á 7T`χ)÷œFXFa1˜dJÚÝÿÓLá™éÂvÞ…ÇyñðòæQ÷½‡”*ðÉG_}—¤V/;ÙCO \ù'R :à(?´r`‚ .˜UVòÐ%€9Ô•–|I7’bŠ–UDE§‹}à"‰Yª™Q&‚f«²ÈÙg¢fk¡•¶Àh7Þú™*2溕I–o· —ä²Ën°CrI”ÑGa4ÑW~‰ÓJüè£&KÛ™žä¹ šíŠÐ^œs"åC/L=%Ä%øâÙ”}4ý©_M D-…Ï7 ˆˆ!2¢‡‘ÒeW¥up…MÄ©— Ñ–JR#J€ˆ‰ª¢XÙŠÆÂúÿ*Œ>,@¯>øú ¯¢å\Ù+•ÉèY+$ÅbKèÓŠm¾1[²G6‹BÏ2d=·@´–GlÔ\t‚š„Ò<ñÓ]M≞w4©'B™ë¾+”œï;U¦ñ‹'ÞKéÉ”äãÄ~a Jè [@AÃŒºõ#Î#©¥–^º—¦ƒ•¤áÇ[n*bŠ•œ!ªFvâd/ÃÊ2¬§Ã#gªø¼:ŒE Í¢,…p;ˆXЛ‘ÒdYM")Ü“ž00?Ô^‹1ÆZn>Õ`ž'®MiŠÀ/Û½‹öº¼¬û=œDÉ[TtAïÝP 1}wK¥ÕƒõŸH”4 Âh¥…ÿˆ£(Íèîa©}ØÅRsÉHý.·¡«}DsšëÜ OzV*œ,=g/Øzžu¤W®!š`\i ŠöôÑ'¡xOÿ(M„[¼äF>÷ Ï^xËSS´hüI~«_ æ1 ™‘a‹û†D"Ö…€vyÎD¸–¾pS:ÙÜWH2"Ð¥Œ‚ˆhÑ7XHΨÎ(ï¤"i·=˜8ò‘· @$߬p7.öé_{*‚OJ¨¯tí+É,Aʈ ~ôŸòÊ&–ƒJÍÅa)©¼â@M-€$ÊDwÎÈR3ÜÌéDO‹¦®vT¥' Ù‚ÏåcF¼©¤A0M2í7 ‰!´ìq-„ÞÔqÿtI¨öPr ]Ö{?Þå¡ÔòmïÒèøæT·zýè—ZÌbj„¢@q¤#Ѐu ´T  :NãÀÒVŠ¡.ÍãËÆÀx˜-Ýð›Q9͉¢µFŠLÏc`+Û—lo{¿Á/PF“–dU«!P K(©B‚ —…4k £u Ýðbj`ç|Ü!®Ò&Í+/ΩHül—=€ ì.ë¶”^±örßÞî£'üK+?åÈ™†®Œ`(2±ÉÝDíüè@Äs§R­ÜZ±s‘/a‰Ñ\â’\<¸ÂµÓÇ/`ÒÈB=²$¿®p×§´²¶pÄÍ:kÿB6`<ƒÊ¥yÍÃ*©öC²‰K\-© Kª§¶îùÕ(Üí1Rnä¢ô¢S¬a÷¶7O(Ù¤zcòRŠ¢îg+.PþÄ? Œ³ÔÒläöa±‹m*C‰!•€È©’•Èœ—Y*:U4H–”¨d÷ôâ=é‘g<7Ò%~I>¼8ß'F[@²‚³$$´“OŠÚÃÜÞcÑ)É8óa´!ÖX&,i¥LŠXDªâG£q"J.åEE%‡Ô}ç5¯Š¿Ñ`ÇìŠÁð3¶eJS:Η)!7:w¡Ž#‰`<²P}åzœàè*x"Y)eú@ž!ÌGNSö¶V!ÿy»\ø¹Â%Ô !IBœL27Š~áqµŸ ¡lí¯¦“’±‡Ó,±+šS;ü<‘*à=øùŠÜK“j±¤ 7)JUò'1Î@cÁÇ ( °gžê8—{Фv*Pc¡-ÌHâ2Úˆ$¦d¬`d,(ºUóÚ÷ôã 5Ͷ2—â°Võü[ S˜%®g‡õ|’(Ø”H–%ÓèCíY‘ö sÚVÊɃd)©°ÇÄðŒÇˆ=;`OmpðÖiŠç;_|ÒW^Äz¢(àáI­Á°Âýà,ˆsË3ã—laSJb6à\þ`•[Ë+ó€›S«Zš·ˆÎ·›G ÂMÚÿô¼ òhÂ=@ïùGFò!øó† ÅÜѨù`À'‘%õx÷ )žá<°öÙœj=ŽŒÀNØmÜi£"ü.‹ð ÁÒ°äE¯ÃÍûðû\e? ´2 (5 ð<Ž ÖØÖ‘“ŸütÙËæ¬EGÎõsm>gYbÎØb;H÷ 3îý?òœoÁè•„žEpeL0–Ïq$žÿI€è“qM í=Ú'EÚ4-åP–chNÈßÇOü›ñ±Gœ¤Zò™*° R˜båIT8…«ÅšQÀ¹eÅÊHÂP(È©\V$ÛAMÊÈéE:`ÈHÿÇúÆ<¸œüÁÙüUʘЃ¶eaê™^·Þê}$é ÑÖ»DAÿ€. ÏÞ H%ÕìE'9‹“¨˜q` FPpÝ…ÌØy„ "ؘŸ…`¹ÓQ¤``-ÛYôV0µZÃAº ¸ÖŒEÂๅ¦ß†tĤ@×=ÎÖMQ‰Š¨XK¢VÑ\ªÄ–µ A íž™žéy¡ y…ç1×ÿ[$MWíÜ–yÞÎQë• ¬D@ÒÔÔÙž@}´ðƒVdÝ^YH˜ NðÛK Œ!¢Çxœ]¼¨`ÐÈÂÕ‰/ÉÝ$Î ÃýU@1‰2RÈ>tÿb÷ áâØÔIJO½¢éèusýç(ÛœL«Àß›%UlÙœ.ºÜoý™Ð õ"çÞ¤=Ò Ðƒ|¾íäB¸á_ЭDŽÈ^š˜@ÉÛpOAQÏá_ˆÄï âôˆ DšËK$â#ÒMÝLQe/‘—aÉ`Iñ añ ýÉ4–=ž…'^(vVìÝ5¢ŸtQ i=•TÇQ™ÈªÄ™µÓЙéqY„ý•‘DëEÒŸŠÏ)#éùÐH¦nÁŠ>Üž¡[IDAR‘¼[KÞáÓ¤5Þ€A±U6nÄ<œÄŒÉJâƒ!ýU`‰×TÄš zÿ”ù”F±ZH)% òKxBhöIPÙ6MÓ>dܤ‘}Ð h¥æ=š#E¡YH”À+RÌÁ_œ]X‰èjÈEžÎQ™FrdjJ K¼Se0Òo=gFêYz‰m4Ép XÅÛ“D½a Ïù_eW7®’¸\˜vŸ!yT¬‹RœGÑ /ÁÜ%e0ÕàIqG{]#Öìƒ5Œ>b¥—ð{RN @€¡Îm \ˆÄ‡DÐJøüèeÔÎ,¢Œ,$sšÞWâÜV šPQHÞCòEä凱Ä;õÌ `º%=DÁ9Fmè²P?¡˜4ÆÞ“Dÿ‹1ìÜŸôŒ“N®Ò6~eRÌi¥hh°€ž°Oû¸aÙGŸäC/jâ=0èd¹…ÐÔ÷YÀhâ}…Ð]¤·Ñ_ äQ]:%'Ðâµ1ç ŽHVdh†ÊèÈÝ%_¼¡ pIÕ ôÌadV™áQT†XÀ3’?AM~ă¤}VÆ€H|‚ ÙøÛ»äÕñã úçgò'–šQ:\;Þ F…“ES¬/ i/Z›6 —¹M]…ÿì] à£æ©tº(€‘„ÍY‚¨¬ìèˆêÃZ^Û©h†ä4% Ï ã¶ àf§v&RKÜÎf'hÈÌÓTíõÿ¦˜b‚*c.€ñŒ€ l%}E͘N‚‹Þ§Ûgî'S”Ï~ÖêFV®Jâ%@YzfhÅØÐÿj…€üU:Š>\Õˆ‘œ,{*`[±ž‡]¤‰È,ÕRée¤G‚E䉪èŠ>N·™"¾u[ÐQÙEÞÓ‘ä mç…=Ø;j¬dn)ÓÜ+ñ¼¤’O,Ï¡ßHädÁªj_ÊÄ‹QRÑR¼`i„Qúç°ãRZ,¬ùª€ÆZ~@¥&îƒ'VÀèãÈ^Ç ÙHÀhŒ‚›R$t&â~ŽYúÑ äÖdäVn=˜ä‚.*P¸z›ÿ½@Ò¡+WÝ(_Êÿ“kÅ“Ïüê¼J-¨)LšnÕm€3z *Öd#6Mæð÷ªjÁ:Æ*¹ÍìØ*|À– hö'ÆniÃ’fiÀ`Û¶­{äšê öµéZ¬ÅÈÚnôÔÀCìª,_”!žÝÎ`$â*†¥Ì/êÍîhüšsšž¦aaºµ€æzÛwÞ©H¬ü%r"’¤j%LêŒ i42IÕz52@¨Mr‰ªª¡=0¢Œ€! Ãï~zTGqéP wõ•ø,¯'ÔK ûkòIKØÀ°ÞNÖ©´ÅȆ"Õh@Þ5ƨÿm•»êØØCÉ„HŽ“qVPí0.Dÿ®ú¾„Ñ4ñûÚŸ\ž« AÞiÚá(:aë!Áˆë„†ŽêS?¡.¨*&bN#5zBdmM"íJ©ŸŠ¦õPªªREã.&:Ή ¾ÖMt§0Ƈ¹HljVbŒ TrEàíZXe ;Æe¡ÄŸ¨@Þµ÷zFˆÐ}Ÿé-†Ì¢ n玢‹ÔœµA˜JPd¶M1ÑÞÓtÑbUe¬¨ŽëôÌ+ôLh€²”±4z*LÆ ¥±1¤âMFáu<ðé YŽýLæoÉP\9RÅá JÒO ØðoµGÛîM/œðÙž©A Ê ¯Å\À©ŒlŠ^Õ¨€ hÿ@ÊÎë'ýJ×ûêbùòC“¨ÍŠ®U--LŒSw ÚVñ°ÑúÙrfkŠÈ²èjÎÜ2%Lô°4N>Ë?¬s±±ËàíjnjNGœ*ˆTæ¿qfM .âv!B˜ÔZPçê…&;ÁJ´|,¯ÜæÇk†#W€#??¤Dô°ðr5à]n çqí<¨„cHV¿ŸCJKªd¼rô˜ð,`‚¯Ktë,2fˆ©NÿR´ÍxÆEG‘") gL´x€ 8Ç©êîªÄ2ûl2n TGv® !U½ LÈcVõœÊ>kêOÅ›ÀG™¦xÿ°ŠÞ^À޲ũˆ4¤‰b÷BB$@;xz|µ<­Í¹ü™…EäK ¬¼HéÄò¬üÂpãʬø@§bôKº¤? ´Œ@<\ã=L¦×κ+IøÔ¤u7᣺òeE­K]©„¨€àðM‹žè‘ÿ!¸•¡ ñ´PXx&<‚‡Ì>H€hŸÊh·seÕnS³ðöÞѤEÇ#嬜ˆ>˜¶[,†'ÕY¾Ë}#l-ÑlÕÖªXø»À TQU¬¤ˆ›Ú;åHqá!Ô .ÕÆPëòkðµs,ØÍåg „DÉ‘v{€pn¢Í@÷äšÚš@~ž‘×h¸Ùp$9vÅ8~ó®ÀRï‡Á ÞŽ¶£X–õ¸<þ«Œî…Ža2}€C›hŠ.g‰F$@»ù;UÕf¾V†´Xç/é(RX¿‹ë,­•JÕxÚ«£¡øªø³Tt+¨QeÚ.æεܟ<'tjr|q$¶™xÿfªGKtQ`o Š^è•z^‚¤=8›¨‹#Ž<Š@{U¹ÞºÅhÛzørùŸ€<.×xÿq˜$eµh›a¸šã(Ê4öÚ(ÒmålYøc”²!'ÒŽ ]xTÔ Ìk¼!¦]¯®3ò+AuìÆQ `‡EZê嘌1•ú\­=¤zÌ¿MÀñàÔÚ#ƒzßtèõ;©‡=´ª÷yä’Ý”iv½æõíƒ#g9(.Èï@øª€=LÀ|„ÿýEañ»Ð^®Iz€†ˆúrW]¾êÿ«s#0x€=ô`8•4JD’1— Õ0lº7Û°©Ið„D¡àx@½ÔS}‘ó»èiUÖ—¡|{òµ ókP9—MÀâ,È÷ÉU<ÓƒlmÿâçC.à“¢áÊ[ûö4ÒeçÂnéÃÌgû¶ûr²® /x@ÖvD×ćòåû@/„= íå³gÞ¼'–œh!Ï¢Å5´ GÏIA}.DðQ¥I}ù 8iÓ±IÌ{÷šÐlÒçGz-:zlá$¤ ’(‰ªRåiR”"ò9é¸OB… * ¬ZõÃ*ÚÓ°„ÿšòp’%{gˆú~Q¡®„|à"BT÷.\½úîÞñWį¿‚í ·°¾\ùr©UeíÛ¼pE Ü.îtб‚D Ä5×PÓñÿ5Ö`›­ÇÕj2‚È<°g¢æ a¸(+h8ˆ":A94˜È,²–ب£éBʇ$^Š8 ©"î㥥6Â{³…˜ä©I<Ï êl'!êÌù’šOM} €Hƒý¨‚ÿ²§‚‡bÐÀžO¸‡±îin<湡ºJü@ íª‹¯¸ô±Ã·U¶0;± =ZëÔ#ü0¯)WÚÉ#ÏCć[ ÈÙ~\-È!k;7Ý Ð€…æéoÊáòáÇ &Òà# $:¡ yÄ7Üèx²3ÌŒ/)øîë,ÎðZørÎJ9P0''ìá Þ N:`Uz9Ê(^XÒ ÿ*©%èFþëjPàÕàž°X0ÜtÚ)‘ô’ .C2$u2EÌÅ¿!Æû¨µBS™/\KŒÕ1ÈÆSž(¢àk4!„EV6b‘í±4e¸ Iøa’,­5ˆjƒì A‰"Rîq+¾cy–0wº‚„Bi¾Kz¹Ä‡”ôq*α+êHJ׬íqâ''„ú÷L£|8Š(AÚç‚Dý›€ÑC»zHªûŠìi&§ 2ÐJ5µÔQEý|CÉJä+ÄÓc„ 4â>Ú´SW ôCÞL?êx… U³ Xbcó‘x –Ý€Ù:pº€®O`d¸ VªZÿ¡­çٔ˺ @€íï!«kç¸Ý{f´‘b{p5e„‰<{Z˜éâ‹¥U޼6:s" ¡xÙ³ÏúPr¡ÉGÂ&`0n!Ya”Wb){€¥r÷²Mæ„\Íc|¡‹è8H:ù1 TböÒº(ÀÌ'ÓÇ fW¸„Jj±B`v“Žt&+¨Ðð¼ H@ü¡²à‰#)ñàGó0¥ÐP‰j± ×ä1\OG‡÷Äu=Ÿè¤uê*‚ŸÖFŸÿ} Д•Ä– Ü#f¶ÛNÔ”üío]hœ*x±«Žê*‰²U²ÀA=ª+‹à½ô=nmLf#ÿ˨FçÁ• F{YL> ó:òTH/± cH©-ðJwôÈGŒWš¡KH°” l†Ä,%™`‰Lš=>€- `‹JYyݸž̃Y$ª8Åyèd_"qÚ.¡¶jìMé î,Ø‚°XkqÝNÀ}``ìJ_¸£žFeaaôVHÈi ^ ½À–±^©!Ã1•„2TIš¨C™ÔK.šnŽç™»³Zž¹©b”œ4ĉxz•ì°‡° Þш§¬"Q7Auš·‘ŽIoz 9!ýº Øã˜òÀ@÷¾÷¤ˆü³c"ùËQÒ¦”íð‘ú‚Èÿû¶‡“\$Ôg!øL„"Æ"ì >hB |‘îžWÉJä@{ RZ¥ÐÖJ-K»Ã ”ZTJ~“ Uh¬ˆcžŸ¦!D5õ:r¢ç"7¹ÉGôñÑÒìÈx%MV,‹¶ã-+Iü0K6‘†\kJQÜIø `¡Là"Û{cD+ú JsŒE¸f5§ûì-=ªìd<òÔ®êoÉΙG?¥ €_5„XÿCH=­ÓaÒ>Ýz±pmM†PRá Š!æ%¯zUŒbrñÝ¢’,Ï¥N @V°™êUHø'8ÎJ¨Mk*¼áñ5ÊÚFÿ°!œˆ¡EgF¤cÂÀ¸îQ„E`о@¢/N2&U+@‰Š×ŧ÷´í¸lCJ¼ê}ìGq‡ª C®÷ܳz‹+úü¦åÚ*€ïU”á˩$! ‰F¹ÀScõü¡ðA,å(Ç3®œt¬Ý o,Òˆ”²Å:Ö‘Ç€´„'4b· ²’éE‘8W»¨úcÌë­7¢rm\ÌçaÚ‚XMœÄÓy89†OÙRÒVF§‰)ŒÆ±è©({\RYAëH©JÙ­é…ˆÖ"¹AÉÔ®¡ƒ²áRÞ\t.!™²È(ª]ÿ€nês: HšR^Qú`À,ûCÔOˆ?"-k7/1LcÒ–ùqçÐRÍvSësõt2Åâg$Ù14ÛÊhFî|æ”4ÊEUÕiIk•¶2Î7¦[R€/·*”ŠB4>-?'òW*vjTy^k& IV³R}÷ ¡TÌ©óân'g‰()‰CÊL [_>M}ç}iH!%éše¹šËnÀ7ø@=Ò:r6¤ÛIƒÃ(1$!4”a>’lÝèóÛ´Ã;™( ¥7IFUHýÒ´mWVBUŸ6@XQÈbà$³n Èg]«©+‡ê‹aÿ b<-f­ü2ªˆŽE¡ MyÇkëŽM•v '¯¶^,§ŠæÕMæ‘ÃPB¿ÀsÍ,&m mžH x³wìG&¯zD pé6"‚ÞíoK)!Ã)å€B;’iÅÃBÈ÷×Çþ «ó‹_~ó›ºöuÞçÛÐS?nÛ\`û³7Œžh·g¸¥DrðÛ^Ý‹Ì=î ˜ø’ûb:‹·Jã›´³q<®¢Ä“‡sñ7ˆyJIžòDž·™“*´€D–óDjÚœÚ`¥t‚L„‚N ¨‚Žõô"è¼MÜ¢HŠö 9 Âß(#m¢®¨.í„âÄ„¯ª£OŒOߦŽkK}Èdÿ(@*æ zv,+™D˜Eá gî,æûÚêû2ÀÉTˆïLÇ.^Mã¢D1¢¤¼píñþÉ<@C 9êë'®ð~Nh<î‹ÿFC¿Ðh&KˆØŒÀ¬$ô¢›>KõD$[ïÛŒ£!dè =çlpoݾ.ìΧmDL¶î>¦)p¦£îÒü‡œo¹ Ïf!$bZ +æÁ[Ò A0g{¶§û|{¯™ dÉB'Ö"Dãhí‰>`1 ºl°â1* µP¾ä •è$o^y2o¿ÖìXPÚˆh âgBC1V­ï¢ÛZo Odz¼­Z8.´êO0ì.A;ø°$ÿøGÒ¨ñÒ(!=l«Ø)÷ ç)„æƒp|`^°'£Ïi0j I9âRû¼§Ý ï¤E-¢Všì ”j¤ä>â,– £vG,‡S87Ô,íå8" ?”ÓÿÚÚ~‡¤:O ÿ}Ñc®³ù,04Vï?d\€õlÔ05Ž;ìÌßJò$;,= Í=Ó2·jp¨ñøX’%[2MÒM§' ÎË*åbà8èáQ$q: d æN,&H}°§.(6e­Vàb-*„ð È¼JØüi£6Š&6Ô^îÔ,Ç#€"w>BHÔÿ6`:CêˆF •ˆ P¨V¥)ÎM;„*ƒúÂFqTu0£GËsz¸c(^ÁÐtw/>×-T_R½Ñÿ$}Š ?å©';s!l0’ 8ž&"4`c€+¾bîìF{îE/ÆIXq*+“¦ÌBÖozÊ‹¢,¢&äa‚îë ÿç4Åà ö´¾«Sn@9‹„Ù0: •ç²–v£BVe%˜Î8ޱ/ÃóCÂ3¡1è„14¨Êôtåö<5HUÕSkk»±šL0>S2™´m&)òs<ÓI '4¥‹*¢Œr"T`:¶äWÅâK¿æ^,çbÒ !DâKföbèh S1±h"s r<Æ2Sö´ >”·¸EDY¨ÿÚrÕP{ñæn[<à2˜ñQ s„¾³/ß‚*Õõ6Õ8z”S‡Â(V>Œb`¢1T)Aõ°ëCì(­Ië#?ap"b`VéÁ»†¦£èc›d0VŒ¡cMí{à'5Cö7öòhÿõád7ähW” }"f¨0[a6f[ñ§£ì¢ÿüo:³\}–Íj‰X&Õê8kJ2ió/š4Ru8•ãv´:Zô$øU=YR°*%»1UyIóPÆÈ¨Uí*™|’àì¡3¤kªè…¬""'kìv&,e­àqûB6èå3‰.*äQe/7ÿê¢ ,S¾Þ$8«5ÂlwürnÀHx6²Þ²Pãò¿ž3À˜ÀޱùAãUi#U¯LÏêv4#£jÑ3ê´c`²2kIëã&—/>fa¡ïlDm¤nN`í ¢I–`Än5zÿ)¥@¿Ç+7‡dõ!{…ŽŸ‚<1‚3®5&Î’8åÅŽ>‚]Á[E¯D_cPcéri)sÛLhGÀ¦‡|j/£<Á3ð”Ñ?×0DÀ(<5v9ðªÆHa¿Ž_k²%ëS‚ëÃ>-x>ö¡aÓñJû3@ŠW4Û¶+Ún"æ&r4ön1§bT8~X¸X›nC–Œ.„±EÂeÏ™fÅZN2Ì£|Ï×’qZB-ãÜ7Px µgù‹”)‹ˆls]­uÇ$Fó]MwCšO#n$"P/Úã¸_Y²cOŠ/` qH©qéC)Š‹¸4úJÀI‘ƒiP„ÿÅ„³b÷ØIt•":¶&0gZ톟†^XDF‘•7qS|SQ€® ȸjϸTóרOâã>UŽ{òyB@æ)"ê˜m(+bà[(¢Iàn­PõvA68l34–,4¸w{ÏÙðsj/+Õ"…S±2ë8)!b¼uÙŒ”OÃ9#rx8OÀjcÙö™h»moš.´°¥iø¬qôUhy–ó•ýÈÄö£¸ØIx¡îãø§øÿŽï£/Á=¿Vlãc¤¶‚M:Žvž8X¦…—’©ŠžK[º¦"¾”„·Ùey¿sx:öúƒÖ¶—YÕö0jA;橦Ò©ÐZϲZ¢uŽ#4¦ºª­Ú²~D”Ë5 µúxpc ø-îÄ!†{JÜUiU¥ù"úU0ÀcO|†;æM(öäh¶ Ú@]~aM1;jë|h2wט]²Ķ꤭ÈàÔVm=SKB4­´šeÚŦ"öøSØRÀ&©YÃŒƒ.7·w8Ê‹8<Î1X1¨ª†8ÌëMc†q‚sZ§8øáŠÀ“a®9icP=ÃéRs€hS9R«#š\9ƒÿbY•aD#k¹ìVOæËŽ ›1jö‡[`Þx°ñ=´Ñ`WUm™(ö0aÇvpöú|’3iÐ'{L@ºæ{ Y90âKé{ Œa"š`lr:sl*bd|Y¹—‘ÕY»&Ê1LQ‘«fe)™o¶u¾:†éØ•Â÷¹¶¿0úà ðæð÷ xLâ.à°¬ 30 S¹ç5FÜ[ fãOù¦‡›À~²[MÐ%¼l]RÓý§m:°ë(Î[x•\¦{:üS\þ“x%¢²;öKiú¾'è›-E\4à'AÅ8”,+J Ã̃Š{™8²s¢vÇ‚Øíx1â:³41û¦ïÁ²qœÅTáê™Æ™j($´OöR$eiÍ}=þÿƒ”<îÄ8id `D—­“u¿"kõZ·줘et£$þ´Û‘:U¥i}þt…~1[÷NŽýÑñ'²ûzaôëú|–O>ÐgÛS°=½‚ÕØ>§ÎÈ÷SmMýzü$"™îX`G˜Ê1Dz#žËU8%Èâtíæ"îÃmÇã)Ž{aø…¦$¶ùê¨O¬u ¢#ù¡ªÛ÷}•·{d:;|«k‰YF`xÛULð†1 ½iƒ><åµi÷Ñ­¯¦ ¥Ðl‚W‘^úðq áÁƒª:Dèð’ÄK”&*\裈ª"E2r<ØQ•}>0šÇˆ‘½“'æ¹Dbå yòÿîÉ;Ñ'Î%T½šO_ ¹>xÍV_V}dÅŠÍ ¶k¾®Q>„%ć¶XéÙ-ÀoÄŠ|o¬ˆ°° øoÀ·á°bÄŒ'NücÓˆð0B¯"D” ­>~£=‹ MÚôhü\èst(Nº¸-PãB‰ öÚ q¢ðн/þö¨±£rÝI22é’=–-¥«œw‚EMšKtê\"OhÑ âÇßKzþ<Óõçiâd$×*ÕùV¯Î­ïƒ¾ fÉê?ËV>óM%×[óÙEOù BÙ7PpÃD¶Áÿ<öbi¨¡b&¶@bžL¶¼x€ˆœ!BZ¡‘Eš>§Éˆˆ ¦µ†H1ÂÆchµeecgqI/—4ÔÐE%œp÷ÐA%ÇÑF)ws'¹´v,°]—ÙÑtÏáy^šá™G›J)•TSI¡'O óÐSU‚F•€õ}V–>˜5–>Q¬•O[!ài—v½E'$È74xC„€U¨Ø…>æa‡>ÆWe `æ‚uÖblø&cj¥á£ñ l¹Þ¶jg"ÉÛ’IÙ›“N"DÉBÇmÄ,•Ë ´W[¢dÏ<_¶„’['ig¦Mò°€¦ÿPåõÓOl¢wÞQL-E@RîIU [!ä—ZƒZÕb þÑ»Ö\"hW vÙƒ ôäSiƒF¸@dF6*§Ž%6ê… JÆ—ªÄª#°v–«°Æø±¬.è2Y=êÚ£"üR对äEÅû$E䃕Tú|eѦôR Û~[ÝJ!X»&Mgê^ÔiºIõSH©çTz@Ýtç[nÍ6¿eñ'hY÷º×¢ô´À¶Àkl°=ùèŰƒ{Q˜Ø…ž†Jqß~'_ž0ÀÀ ðsk<­‘æjh1ÎX£Ž:ÊøÚâ*·æÚm.ä&B÷ÒÍ 9¬Ím0\° ©Ò¬ÿ³@gÄ /CO;—'”tJ3iG&ÒßÙTºFkžœqjmNôØo¢ú…5Ù‚*ÁUòªÝ léÚqëƒH¥2)_€9ü˜Å‚ºúì‡8⥠Œ€™âñ¸‹²åS€>ý“Æ"ðìF'óÌå\#‚|à/H»ÌTa$ÒÕŒILš™±ˆ“¬ f$>ëYЊ;ç dFsÉ·®•’.a‡;G¸N°Ÿ”kMn:ÕŠr¼§,ek\˜[ð£ŸÿÅô*hüµ6¶%±mƈ” ‚ˆ D¥ªûô¶>Páo~‹LˆøB¸`q÷ãXÈöǰÅ3( ÿkNf£JÅJ€­ n6G%˜õt4ÃÙÌ0rAŠX„!"Aγ>X m„Ö™ M¾4.1bw_{&5›ï\ìÚ!òÞ”öïàiÉ£äR•³ ªlbY¥U^ )µm MÐ^ žxËå-Ha ã Þ𦾇}êC¤ÂXçW?Ž•q®úŸñÌ“ ©™Ñ—¹þiŽ¿à… ~ñM^ìq¡+Öc‘‰‡!AäyÑ’¼„1˜Ž#ﮓí;>á{`˜IRŽ]rºáñУCäiÊW¾’AE´l^QT\–½¶ÙR·¼%ó*µ—*š/}yk_IÙÿ‡Òˆ-`D„K=@FüÝJA±¡iX*E«Óx¦R(#4Å¢ 'u6.ªP‹ª9=þFuA§:ÏYHCºóJÑ^âíh[$ÜVv²cI§”'5iÓðÒÕ”« ôMOA¨yÄ Ez|€y¯ÔS]¿zÌ#£Mh-[`ŒÔ² ÆÐ€Ü*Uª¬ÀŠ¿4)ûc±aBD“‘_2•‰?¼4ަ°¢N=MZÕh5 q=ÚpÚ´Á mh­kš‹Û $ª¬«- }P‘d5•=“*"9è¸'à:S °3­/«¸-äŽOjV­/¡k“ZÙ$&ÜdRšJUÚ¢(ÿ¹L£~mA–àWcÐ2n¬¸).b‘˜ëÐY:?—’±ÊÌGþ˜¹¿ÎâH§1ªc ò!Ô¶)ؼlë«‚_…p„šùHS)¸[f-dª ¬ªG./i¹ÂÅÉvŸ»ʆT‹ÓºÖ¥5‚Åj7Ìn´§“;lQÿÒ+Ž|ó ™°+@Q·¾Hè|%uŸ…HªE IƘ„;ÕÆøa‚dY™6mÜX8#*`qTÛúÚ4§yÍhf°ƒUë„(*¯qAÐv›ÁÕmK–Ýôi»@_k„Ã]nvÊdÆp(j5œÖ%vr­žü¤›,Ù‚:¡ÿ×–{Íèql ŒGÈÕ€ ì>,ÀJ–P`& åX;öo c\:(3ü5r—½œœJ5£Ë¢ÎlÞ5';Í v‚ŸÝÖ émSERÈ É½`€Ð®j;ÜáNÄ(9 î®5&M†\–y®õ8e‡£ÄáxhLµ¨9-Ó™¶±v["°8ª A²P kX„ñ#¤")…ž<ë&KT_4Õ©F€8-k™c¾vXX4ìb£ ~¶³sÑ6¡æb忈­Ës‘à”׆W Œ™µõ,>»3#ñ¼ªr— tHî;_]÷ÖÒ$´“LSÞTïºI»ÿ§ºå‘µÓ'Ù³‡ ”ó.!°M„BVR”Xò¹:}\„õc6ªÈxq¥•½µKM°ß,÷:4õ‰ Œús‚‘¼m2ªVž‹–'þ›¿h|/~ñø¤º ¶kÙ&…‡T[Ömð7:ß9Göásâý„`Z‰¸sâOx«'j2WRàýâ¦ÐÛÞR—zYÇcÞyÛä–“T ìac‹'Æ@øaGäÄF€ÉœúA‚wN*DTnévÍ_^óú×XXÒ«|x]m§¤‡På…•k'ÌŠÐÍÇÏvJ›««´œðìˆôöñ¢‡%ð-N&€ãf-‹æÿG'5J÷ne5'íâNul‚oïVpUW'- Y“=“b0€åuPu¤DvìÅá£0j·vn÷j‘_(åXS—B?×Çq\¶}Fæq@fdæqæ*ëwàÄ~xô~"@¿á3æM—‡Û¶Aüç[<z1€ÄuncR'@47ñB^X€A­G{Cábìât³§5Žð: ‡sH‡Ž0 WTdÚóG±Q'€KöPÆf·§à^ðÝ \À–‰@€ ‰"Ë8#epƒ¤‚_ù¥ƒ<¨}>8„BØ?·Ò*²q(‡rx– •w„v¦¿À„äÿœ7%P¨†Uè[ámWòž 4¨…È\,ðÙbDW\í¦o¤änZCV8DiQ§ýÀÝèݸ; PQ“fuRiä5‚Md@Ki¶‰ßHý@Ê7e^ƒ¯&e\$ƒ”H>€Lн&Š®ÒwAÈLeŠ6u(`A´axq¦@I%…S2% …6"…W’sˆô‘ˆÄ$ GOXe-!¦Uw²-4\»ãnRCVŒ†.ÝñØÙØ.9yŽP=ùæ‚fÙÅ6}xèXuKN`‚BÑ<Ù“ß8‰_ôj•È) 82Hƒ ÂR—².e?Ûÿ–Ùw£xÁgÄ?«(Tâ(F…`<‘Ýô~5BõçM´x4Ûv%z&™€·ƒU×a-Ã…LSIM£IÕx5<K‘²§“÷ðÜÖ€™™©™ÜÈ 5æ`JiAXÚSX~¥m`‚k¶ÌÀš ›ÀóàKÁU9eB}€Á›¯v!v䓃ûeZÛ×8u•FBÈ?ø=4ESNàu‚Z¨Õ–Dh„¸!—Ü;"`ÞÔ¹Áâùœ÷A ¡H€6€€i4ô\-Ùq\̸heòžÉï¶5™‘)8yóØÖàj ÚŸéÿ˜|5oOÑQÆÀ6ªP@„H|Ýx  Ü( óE? •rG}VÉ)½ù>•U8wÇbék½ÖƒdÙœ1  !7âæ·ZSxà.P.`ë·‘CZÛž–—Õ4 ´ˆð—,&$äZ˜µÃUDGtb¨&U.H‘Þ¡tòF¸J Š Ü(5Û3” Jš€§Å—𠯀¡hZ Ú@p›¥"ú¢ ¢ü¢ã —"·SÄÙ¢º¦w1j=^&75 Ð9©‚HÌÓ(8jTi„&àá´9DºM›³‹ y%Ñ@ÙÆ$9I!hå¶zuÿ\[&_åŽtŸ3d.E‰’C×8ØÈ.`¦xj  Š^<‘K¨{¤ ¡ÑÊ`ª^çÕwЧz À œ ó¡Z•€Š•Sé¡äã‰;hdzçk=¨ 5ª }Ç} bS3Zàuixkñ£péM¸A¤¤—±Cž©ê9žÓ@Þ†!@’_5˜ ËXå¼3»ê™ ˆ ¥ò°Oo{¬Èê C0XéX„u^Æ`m`¡Å‡­hª­Tù¡Ri³ùx1½Ù­`ôèÊ1P ¯1j—:W6Z£Q 7>(ˆÍi¯•zºR‘E…RèMuIµ·¤A*°“ÿ¤Ñ9PXm¼ô°zõB`r\€Q!¥ib;÷‰CKðD¿úꢓíbð±ÈÚ0$X¿jÎútƒˆ}%­m  ^c³Ê¡ç|ê­^„¹ßJ¢#”a®/EÇYœüó6eV¡´•êeóÊ?üj‘v&03°ã¹šQAZªxdµ5GaÞyyÞKz9¡€k[¸C\ {'-©«ê]äˆÓ[sRi9¹‹§ êin“ŽÀ :°ôÈ ÌÀ…Õ¸iFˆ®ÙÑ¿ñ¿êÀq°|™«›Sæ­ùk•7kƒ¦‚k¡»®Ç &@ºO+ÿ7õq´5*7µA©3ZMú ªKZzé‘©*°wÔ¯ù³@Ý)¶»$2r°cÚ€€y;,@€·cb»SZ8\–´5ãH5-ÑPÂcêaí² ²!Ë̪=;Àãû”ôà Õ:vypÄÞØ§S¨À ¢?à …Ú¿$J³ ZY8¸1¡ÈkB[À,¯K;©‰" `A©ÀÆšñ»îd[QÅy ‘ªr)º{? 4ª] …¦êªC'|˜.A€T€þÔCz•¥Ú<·G{0vx‹uír5ÂÃÚ‹¦Êz›à”OÜ“û0 Äg ÃÊÜxË7!—ëK_œê ›ÿ¢w¨•ÀW¬}ºìk‚øJ | ¬ÆcŠ•Ò(R+P°k[q·(U¬µ ô£÷£*¿ÛÇ®á?©r%ñ@–D’ó4%ð%Nc€ëV>·/9×ÅŽ9½ñF{¥É*²;ð‹ ` Ü€¦˜ÙßÐÞèi¦î+¿ M¿ý€KFÅàZ›–"•[‰5ëE8˜_<èkLÀF¶¢Á |âw´ÃL„PKl¥Ñ#@Á6g$QRA¬s%õw??ú£þå¯Qèú¤YqÌ ´6Nz[W«04æì\¦TOÇ82L&ÕU”ݱpr]î‚õœ¦ý°ƒ`ÿÄýð ðÃÿ¼Ýè0Ë «§/àÐUÜ0 ðX¬¿qýÊ!â¹8¨_¸ldÛ7ƤËkgœº~íuOû"°Â •Ba™Q°÷Ç,Q…aRbH±£µ>JÓ‘}¶@¯q?Ý)%l€ `RÁÅ-4ÃîÑ*мD×ÔùùÔæÁàXÈoÕBÐÃg ¸ÜxÕÀt@ a ²²É鹪§¢°|­@Ŭ̹­ÌÖÿ¨›UD>^LF£›ËÍ˽ÒÛ}©J»ºP +ªÑ+`ËÌšwôÌ@Ù>zÕÜ?¤—q 4òM0Þò%„ Ò²B:)VQÃÀêHúæhè1ÿ“R-|h]öV½X¬Üˆ½ýÛÀ ² ývzÖȪ§= ÜÐ U|\üÜ#z1‚1åz) F^ÙƒB{ÝÍ® r߯7å9Õ+^+ŒQ…ÏìAAÓM·QF@zG`#6²Í4-¼P&è-òðÏ!0D­zèL-ê 5ÜñÔ£ôzâ‚’¶VˆæàÚÚþÃÐ¥PÜšÖîáÎ÷UŒ¹àÖ—{ú›¹}qL^Iœ.þâ0Î1 Í<Ì£ÆJ+±#2¢ÍÞiéߤØåYm’uYä&àM[+Áø£÷Cß?ªöªn/ß0ÿëðgŒ@€÷Àå\Ž4õä¼YªoJ¾º¬ þVHQÛkÄÝØa˜ Ö ë ÜhÊž­ÜøÊÝázî| Ó­VÌí Ñ*Ý™rËÅ å~Ýb–Œ>̹Æ_Vêe¡ä¼ Á§:—ɱ Ã—ݯ€ÓÞ„äÿ~þS‘±c¯hÎG0冠ð†P ëGcë¶NµŠ¥`·XoŽézuCÆþß²0Ðݨ ÛÜX™Ò.³jí?Ð >!ϽÞ0WLó îRe†NîöZî?oî'~^À§´TñÀb1éoôM¯9«Âa©ú2ýʵšñïݤ¼ÿ䛃ä*p^Eqfrû@ˆ`f/PåP/pö/PD=Îi ¦Ûåë “}8Jð·ýÃß þŒ¦ÔP€¬†ß=ÜhMí `íîòη|Þê ÃÅûÛÖ j®7€|úeö¢ŸË‚hîˆ^ ÜèSÑèÂ윷âîð^G¦êµo|y–ݯ\Ÿ*™äylþ£ ©âùЂµò`&p¿BëXîêY.÷/pål¯Uŵ]8vOTÃhñ–5mb]¶ýš_= Þ¿Öðìô KŽß¢ðòÊ ؾÊU|Åš?è±@ @70‘ÿ¿xÆSQ ‰PìM,‘_|òÙ³‚^ÈQ@~Ì—cJ–úZæÓS_<™¼DÜÁËEΜ. ¸jÂ/›tšàIÓçR¢T,i²äž<ªG^°x±¯Õ C††H¸paÈ ÆIPvÈ…%¨²`Aõí '¨ÞÛ7¯T¼ür @@oŽå…ѯŸ5?VÜKdÊ•){kÀíñfË›GS,ªl+Ò­@Dˆð5ê?n,Øpãì°g 4hQ 7ÚsêT…ňÃ/fDÎñH’ôB0gÞñ£½”ÔY^—©¯€KÚ]äsáAßÒŸ?‰z=¯ÿñâ9~çåÁ½Pñ¾-ñ¢Ä­f%œ´@Ð4 @0‹^xA¸äz«»äÑk/½ðËžxB‡Ä*{âˆó̱ÈNÈã‰},‹LhЬDÈ*“ÑÐú £, JkåÒRkM ˜mƒ ¼M #o`² Þr(àŒ®J(Tˆˆ"‡ ðè£çž)„喣ޤ/íq"„|¢Xóº|œX‰¥•[ (Œâ)½x¾ó‰#  Ç˜%øºç±jk³Æ2ëÀRyI!´¸‚ýŒK.ºì"´Â¾€EïÑA1eŒÌ˜<>lñ›¨©‘Ue¼Q4ÿ³ZÙÑ4#mׂüÁ“ÖPòXa‘…ø®{T¸È¢+­•6¹Ž¸ )Ì‘ÂdÜ3ŸKóLzœ@Nt P× 8ÉJ'^ö´É…=ãQ ¼ò]‚Âûä9‚…¶Jb²Ð:PÒSTÒJ%Ek-ò+¡S'ô·B¿îÁpEPusdÄZ#K‚2u2«µåÎpU,ÇÑzå‘4agKò5#v Ünᆅ*°Zè.ªvZ,ƒË¨!~X"L0»‰«›³úÛ¬·ÎZz¼VÁÝò€ ʧ™\J%íòÙó'{4Ð ÔB 8ƒ#î6˜‚LÁ´T@øÛáJ°ÔRÿ‰ÛbÁPC©UªŒïŒcÖPl£±†VÇnô"ÕÅj @1>ìaÕ–c,ñåo”™W_yÕñ†­„eÒ5œ…L7 wš2™£ö",‰³¨éxžÎù1ÍÕ:zæá:ú48A [°‰Œ¡§ z8»mŸÀk|ðÄk¨¸å80r0"ùЪï¿ïœáÀ&¼ÿ]‚‹AHƒ"†üB“ɨŠñbP#k(†Š¡êdÄ  Ѩ‘êV›‡× ÿG4±‰×;A šEB¥zmœÀG:¥Ä|?QÉ×¢è/÷ `gDã>–ŠVèa€¥(…ÿå ÒŦr~5‘/(×ʈ•¡C­ :Å  FÜÇÈ"SÈÔÝjuŠAÁ$`DÀî+Ф!( »Ö kHCªM)™4V”Œˆ#Š(KZî9¨€F’§§ùn:=ñ< ÌÉ-˜ö¢x‚~ **Q‘Gq‚î…€]*qS¢M8¥( T¢‚—2î#i$€ˆa©g´›¡d+˜¬ÊÏØò#@r\æÄUl`v©/¯ó4Ò2¸9*@¢1IáúÀ¶Š¶¶õö°§6§›f1}¦RóºÖGYXÒ&­Ò†1ØÏ»ßïc—'¿Û îöì”À™ú ÿ-(¥c¦ab»‰L|â2a{À*ò±ŠQ¬êÕVR'ލŠÈtÐPÜ3Æ»Åô^cŒFéÿÑAPùÝú}ÝçåÔmøcÔ™a,¡m¸w7SêÈV1O`¡žy‚Nt£²–}ñËEW«N_ñ>Œ0ø’? Ì(Ïl s—H% þ­Va'B…烺<Å£2( Ó#lÙP`Bbì)Ó˜ J«à͹z®B]R0n®½ûGG}»Â$`Ý6ÍuQÝÑñÃkÅ»*† L™b0jkÐÁÕŽAxÛcý„ÞûœšÎAì bÙÈîýžÅf=íôñÇïØ×½g ÿ<ó|ä:ˆîsƒÃU[œûÙÂÍ$ꔿ t¯§Ð:ñ‰( ª<À©›s¿ðS£H‹:©›:|³4°=Ü»±d³À닼¤~x–ù®¯~€»g8Bj™@¸ ÛŒ ‚5ƒz@¤í‹)*&1é• ™! é>F3¿3'ò¿ðK@c3<“‡ p3—Ø%Ñ­ë Ž9‹&ʳ}Цhº°ú˜¢ë¡­ÝB›¡ø@±žë˜BQ9#9c‹Ÿ±ú›Ø{Àþ‘'K³½  C¬«eËìº'r’Áà o‡ÌYÁP& ŒÃ'¨ðœ~ +k5àk‡â›¤hÿ°ÄK´Ä$$LÄDI€‰ÁŒ­yÈ(,k…X¬B‚%à˜cÂÕ ?À‹7º!®{˜‡‹K Œ«ÑB騎|0±šb¹<»ž%Èžœóšþƒ“ö í 1ëY&¹à73,9ùIÀÀaÃ8"œI£:K»4 Ã»›“³EíÚ.À€Sa Šã£{Т8ÒG€E4X©4Gø È$qš²&Â(âa `EE{EmÜ…\½!œEÖ£›âyì¸È^üÅ›B kjŽ#âëÉè¦íØ /D•˜F–|‹s$®"bœü¸:àŠF% ÿ€mX¼QKµÔ“£TøIK¹ÜH%L˜Õ}½Ž8!O^rDH3¶yl£F*-”,ÝÝÃ1˜DK5‚#ØûÒŠ…Ã8Ç1 žtžÄ:IS `ÓÀˆœ ‘GO“P½8Y;åS¥Ð?åÓiåÖlÔ㜊1z`:4rÿ…®ÂN^Y HIͪµT@Z´Åb<… Ï6k¼ŒÔ×óœZ‹ U“ Ëî°—˜8Iú4´b„¢»pЀ1³+¥›+=¶ÿìF›¤Ì]ÃçŠ@=€(S`ýXMÃ.€ M·R ¥Ç¾èÛmµS­´SjENÐÖ–ÍÍ©@©h­Û ¨@ Â18 MÑÑ’<‡l:xÍë2¶ïÜ Å”èÔ‹|¹|5O›ÂW~ÝE¸ÈŒä“ñÀ—ÃLFyG#³¥#®Y%3¦k´“ÌÉÜÕ/}ÛzÀÌӨɹ%GrüØ“Ê䄜6­V¥Ô˜ÂÅüÞÂQ ÑÄÑ ÿÀ Ç]QÖàÉž­£Øó•jX-uLMÚÐÅFM™s³óì%%|¹‹œÚ× Õ’üŽŒü Û‰#JØ1®ë*¹ãÏw«Q‰ÅÕ\¥´7üFçK ÓqtÞå}_̤10•k+ ©VíŒ^\•Í@ÅÞ µaêS¥YÃÝõ rÅ:èXºEá¶èìK9+—ÌÆ¤ý\øYÚѥ׸T“PeÂÙÍâ&Ò{Õ—ìp vYÉeÚ'rÊÆYÞ ^½Hc®ö`‹­Ì|óŸå¥ã69 Ý´îÛ¾}á~\Ê¿•ÐÅáÆÖ6_Þ hæ  b"ÿ®[ƒ®Ê}Qè¤_ÅœTüuºÝ_J}Ÿ{`–òìE!5`%ÔH~u‰((É¾Žª‰` 3Ë‘ËCYÅ€­ÕÈäàÁñeJyãæB‹ä[:¦cq„ä2t’…a>¶YVÊ“½á&Àá™-_ó=\¡tÜæ ±Pa"öIžTa•_°Ì½€ ØÜí\NŽŸ)ž×s€m³ ÍW˜@eTÖW{–Ú}ue6¹w9"d¤žå-{pÖýb~^àÕ _{9vÞð¼¦í1gw/¿Þ°èÇž»§{¿^qP”Gì•izü5Ÿøiw«Üçÿl£nœ§  ôvϱz¹xEÛö³v7¶ ñ,e-ÖD؀ЇHŸ>~êË—/áB…ù>ä³÷Pâ{öB\ÌHoãFŒ!<†˜'ï GNžÌAà#&]ºÜD½¾ÔôÌ—ƒÈ€!ó‰l(ÏõŒÖKzà@OG@MztêT¤R©… Õ† ¾f¸w¯‰<²-΢=«¡= m[¬=Û¤‡&îr€÷î½½} Èkñ‚¼ <Èa$GŽ ”àájÈL­*CERµÞ­—[ 1àÒ+£Î±Oå¥K«Ä ’%Zγ÷á`}½ ÿ>08ñ†À˜Ï£EˆéÙãHïãÅç"M—4Y²tÉ“,Kʬ¹³'²ž>—uÀÓû¢Ù÷Lêñ ˜¶?ð˜é¤Y¯˜Uh†XòÖÂ\hÓBƒô´ÑB„•–‚tí…W_bÀA|½!¼Ðb(fÄw/ÁÃC\–ÊL € ÿu–e Dvܹ–Új9ÀÔKGä@m*±6ÏTð? !TeAÄÔCÇ9T‘DÕÙSÀsÒéÑu¯uwÒv¤ýˆÁ>¢Ý”ÞMíÝ—0ø¹§Q$ÀÔPµ<0_-C±7È`€€X=•T“Õó ÿ÷¼Ö -\º=gmꄵ±iZMØå×Xõ•ÜÓHÀCIô¡(@G¼Àƒ‹PÅ8S+ZéøT– ÄhõÑ&“¨¹$‘IÖÛJ+É37å• W\”¾%t¥q\—јÐÑÑr!ÐsL(©Yšš­™´O…âë 2<ÙÔÓN;¡Ÿ$à@y…>0 õ•×°ÁPµ¨T®$ ™QC𠩤j±µ)…¡‚,]Nl²\¤j(–YM`ࡇ”†+%"Ö˜aFÈ¢‹;¾RÙŒ9êÕŽ \0›õ¹–j&¡Éæ´²½í%8™Oí¦¥•$¶ÿ½åcиäNÅEy‘n!o ·”€›ï±Á@ík0|ßiðRÔS§¾îõY^Ÿð¢  ¸Ä:úÔ‹<@Bǹªt$sÎ9=$o„V*×5¦-Œ”—^„8ù ÇÒj„8ckg—ŠŒ PPcÐAÿJÁ®,ŒXÔ¤¥æÒßA+’²)} èæP” '6AQrvBÚj96—yÄQFº™mHð¢·KÝÉ{Ò›{ã[y÷[yêÑ/ðÁjqûÏ¢¬R`éjDñ¨<ç'Dáì\„Nf¶,gSªÓK®B𢠔ha³Ê€hç€ÿeG>à ÐhÄ#ý$)†ÈC^lZ“$ä!éyQ«M’äQ‚'] [ ÑžA~.Þ Ñ7ãbH„h‘s¥M7!ÌH¾yÉ+;nÒŠÞü´§¡”§(5RPú6§¡¥P@) 2§·Ç]Å?ÀÆ>¹LsŸ{ óÁú1‚ž;§¨Ã¶ b /‹ð¾â1¦>/0À®*ƒ;Ì@… ¸ \1ŸÄ<­%<|@³H›×<Ëy1l#¬æ~B!½á¸ŒX‡7 ù–B ¢/U„]yâE–£›y°@OK“šÖ”}Ð(¢!Ø{ØSÍiÖ¢YŠ¢ºù7ù0“å>ìITO´Â(ÿ4jŽÁ ÁCÂ.'à1QgRÏ{æcžœ ÕYæˆDxWhg€Î !p$0 ðS¼ú<&NÑ‘ÏRñƒÊh2›3)ZbÅ&Ò¡>(‰lºó¬ò1S›€vó-m'¸ ¨AaSDpËJâû¥¼d>ŒHñ9ɤ—vØÇz`!ù ÿ,éÿÿ H° ÁƒþÀ÷ãà ÿ5lõ¯ÕV(\\Њã‚?"$ü‡¯à‚(;Ü`ÐaD‡–<Œ)bÄŠ-ŒÜɳ§ÏŸ@ƒ  ” ¢Dñ¥b¸ô_ª†µþ˜úï"J e5„ˆ+W¬X[‰uøoCU”(G¨å7‚ŸÛxüâÅû7"ÞÌFØ`Á,Ò¿€ ü“Å %N”8J˜à(©Ž’ú/ªB‹72fÝjÈPC»ê«PQiDÿ(¤¦`Q¤Y´°éÆ«`¶=*n˜[À?ž„øÝ ¤±ñãÈ“<|4±aäµJJh¹Ö¿Ç ¯zýLúC…ò…ÿ_!_¾òøå5"œh«–È #FöðßÏ½Û¸¹Å DœY:¨Ü‚ 6ˆc10f>µŒ"uNÇAtEZwß}`ˆ"þGâ⥸^z†Ü`ZjðtÑvߌÌÃ=!|À"â©à *°u×?}!i_6é$aÏ)ÆB Êác!I•ÄPI“ ”Ù‡ê•ø_ ùÑ=ÿØCšÿµÙf>#ÚS?'úf›=1Üó@0ÿ| U{ÿÄCk½Ç$–‹>éè‚Pü£BCútÂ?GQI—aG’T%EtHÆmÿô†§œÙ¦¤iÆÿšj½J«=Ìs®,,aØ<ó”¹##ÿ„ð"+¸ø=FºµÀp·Ã?åüSÄŒØF<TÏ!Çä‘ )bÐÉ@@$‡Ì£©@Ï¡@‡öØ••ÙØI…žUðœªJÏ<ä6'­ËÚ“¦=P ñnÜJÌmš'ȳ„<òÜÃñÿœp&šÿÌó#!Ì"ÞýÆOYÅI-ƒ¶øà`(”ÃO½í”‡@1²óA\L»k„õ&…L „ÏÓýpU/Ë™*\ k §[mÝö_P@q<&xàA&Œ°›=',qÏ= ÿã«Üò„ lAÞ Ô jxÿpóÄY€Ï2Ïl DËLO—ò$•7ާ$Ý+¾ŸVŘÇÕVª¡Kkô(L«\d—ýOâÿ\Œë®°ï:7¼°—L#€V¤»>ÿ<+Äà nxrJ O˜Èóö˜•ZbgÓe–ձݹÕú¬xÊ®±<»æJ=§£N¶\PÈ5±¤­=dÛoŒiÈõHH)J\Y…¯ÿþM)˜ÌLcÞc,0Ít†4À]Ò¤íyìm÷ ¸75 lVP€‚ 2ch7BªÉL²%Ô«q#ŒŸ*ÒŠ`$”( áf˜?þÙpx•ÚPØ4,Yˆ€šù‡gÿ$£]Ym'xÇþ!#„™GÀ IãŠÆPA#%$c,Á„ì#È®BvÂ1B@iá?~gâüî†pž J0¤¥$Öñ”•®Ãd$5†øŸS78Å€cò`Á<¼ó£8ñ÷€×%y€p Ô¤¢„Áï ’ãØa.E,Ý dP{cWi¸:Ò‘„=±P…–6åM#¹!$À'ìv“Ç"G°— ¢u‹$+4R“ÿÐ@&£)Iá&¹‰Á4s•É\$‘u;#, ø®Q¬L§“ˆQ2;òäyµÄÒu ò±X„e:â|øÿ¹|pf©ÀI¯Zò{°¢G&Õ$d2q 'ÜHÑyÒ²† ÅèH–w9[Îsyøˆ©HRsƒÔ] ³‡> 0¤.€8B• Åeþ#@ì „˜‘ÞXC³.ˆ emK›7™E'"!aÍIض¾%ÿd’VB#XÐÄÁÔ°ÉJ ÕPÀ©Û•12I¥RÓ¹h:W_cA‘dÄF8Ô´à Ì4w²GÊÉsÏ‹«Ntš, ½’ª1bP>xb‡,v%8à €ÿ%ÀbQÓ 4:lªÒŒæ¤œKÂvM#O>èT²”` '`„¢ ÔÆÒ†÷Ã?)e-=\¦™j|´)’¤4ª¸ÙLì±¢F²¨ÿ€b"€þþ#÷€ÀTÃ2Œ-Vïê¦íá˜çG/ T   XH7˜k‚Hò»âà‚$_ñ`R°¿)éèL• [@–^Nÿ" ‰ñ±F˜KÈâ¤hÅ t,‚üå¯A€û èøùˆƒFM*aÓ‚ÿ±àšÂó£öŒ&P ¸Æ5ŒùžÞ‰$A~-Aò‡‹’„YÌ=Âþ¬¹¬B‘C£¥‰+3èÌs  ÈÓâJƒþ—ÿ‰ÔÕ D×Aö?8y™" ÁU57 ÂܸÉa×jþ±thÐÀÅIPSWœ”Ep]þÇ©O=j“ª0qr¼àdX·fóÓðåÒ¶"Ãi ‰« qà*P¬F×8 ûá=Ö±ÃsÌã¼ ¸+P®¶I‡…Îã ˆcG”h~èãÉÿZ@ÊG$}¼l¸Î‹¨ò]„”ZÝ$žÙ1|B‡‘ø`=oŒ%ìÁ†žx¼L!vzÈÇ¥WNÿ@Æ÷4Áý`‰%À€ †.7 ©;­Ì3‚"ˆ`@ßá4ž—?«/B¨9ÿ˜ßì)G/!@8ÊnÀrÜÀŽÃÌ#Èòs>@ žPóÀ ð`Ѐz  íÁrš`¢@f)À…@'V"'ð3ÿ€’tò&ú±&W²GyD!L‡¸ uO[OŒ€IÅŽ…0’“W1UË&AÂGË$Ðc-àp¢U²’*631ãrRÈE@ >°€æaâ0”–,”ð‰—sÆq3™° °€56!0—, Ømu•wì'nxˆ@ ”à8Q7P"pEp†×sPF(¸+àˆ@'bB"±ÿb&T‚'d"bù1b’?<„.h©Àb/h¸÷kC/ÿ€`›$+ËDvvÁÿ%Lá¡P:´1³21n¡º˜#À "@‡ÿP×ò°W‰ö„[(€÷:!¡öeÒ¡xÈ‘8Ô8#{‡q0 jH1ò~Þ¨ˆ2’wmeRÈmg(ˆ2B‡zG î÷‡yW‡6Áø'ÿ@'þ¡]n2rdb(Œ`(Øv2 W,@)FK#W ANv9€X†ñ1Q4_¸A1à6¡cñ_÷0½¡U_3:SÑÇ8a×WŨëQ}”ç&'SÄ;?·FâÇ%b8¬ÿC7PA ؇,Œr ~¨Ö2&§’ˆT˜w"°ˆñH…ï'7Óü`•øW…0·ˆT'm‚zü‘'yR+‡ÇC×q‚ZRuqF7€u9 ÷%Ýãh7’ 2h‡lCqswl¸x‹sm‡ywÔÇ ‡"‡YãXN¦|±\637CÉByAø‡,§äV…߈†3‘”thŒn±ŽÖ”.7ˆŽ§w1²ˆj¸•€”§%R"'S(’‰¡C,ö`kjFø“±b? îõˆðY÷—¶ÓI–…M’i¢³Š¢Ô»B¦*…ÿY=ó*…·b,* UàG8‹óÓ'iW™fAZÃà ð‡íá"(‡ ´° z0` †ÚejáxE™)#RŒOØr óÀãРú¼£ˆP” wÄh•úP}oh”,ç@"½!";B– ´IÂéWb9÷Wµ +Æbpy7—t CØÔ&Ð×|ŸV¥Y#2'*ú5q¡s‘h×™*ºèP8ôpM`BNà0Òô=NP+‰–…é¡|€³eó!¥öeBpsc82‡¨A×x’‹¼š~“w"ZÁ‡ñyÑ | ‹ÁH”±ÿ‰”¡™©•ŽWa2Ýò/j&ýh(­V‰­7KµÔ/Ó1b±œH¢†p@hô’t¶"'ç£SÍb$Ú÷Ž#>Ê¡sÑ:oÁVÙ‹äi_d[hÒM`S*Ógr µIÒe2#7I"À ÊZÛv0¼£‹ *3²ïWŒ0€^…ù`ÜvG™™ðZÕ§£Ñ2Ž5'‰zfr;hFwù‚ý¶^ÓQN ᣧdŒÀ‡õ_Ä=Šæ*Ô-õ/##lñ¡¿šw7²š™ÿ© 3aê”—ˆH©*]êÁ=ÒÄ=-0QÈ:a&§|öc{òÿfo Z2CA# ê±fƒrʈ;3"«¢"àž Ó9jÑ#ñ5%®àj²ŠÈ 3Ayœ&ꑤ±…÷Á 4“$rÅÙo/¨$!aj'aàk=`y)c&¾I&‰‹ *¼@Œ$ë’J*'ËÜHžj¢U²cBKÐ!£-ðÇú-€&ÖuŸïñ$µF1­aLr†ž@Œª[2Á‡])0ÙŠO"R3Q¹x+Jº¨•¦ç0qQ ¨éŒä”ª´&(øX¶½:éV/•9Ô;pk°H%¤‰•cEÿ¥1õ2õKÑä*Ù–‹›’X…m²&Ëžð{wñi{ 2× Ó6%t³H?r€ƒb>!nzx~á ¢µ5ñ2¨ñ‡}¨K£ÁHËØæ#j‘ T Ý Ý€ò üà ñ2 P ®V 41jAyV§rÿ1¶cËŽ5µ‹‰2ce—М½CÎkPI%9P—FL¶ž¹a&x‰ù&nÒa3mß#‹LÖ=˜õ=¹¢=]I4¹#7­zžˆð‡ßç4¿#5Wß5sí6†—Àg˜”PÆÌw¶;Ñ µK,hÕà3>’ÿtè7f#¼.W±ƒØ5”¶ˆçaW'(ÚeWqB"lÕo™Ó;ÒÓ;eq8²[6—IU—°³¿…’+Øvm #0Kj2‹¥Ó&!©*ÿØI;Kà—K¹oc‘p#_ôUdÄ#Ÿ…,ß—n4GR¥åa…SsgÈ\ûŽkÁ|ó£QÁÑÁfÇAZ›•àê2Zú2*þ‘h+0HµQv5aëXk¦Zo™ ‘eyqö¡+vûD‚õMÉ ;ÀR–U\Ÿ+JŸ¥Ó¥—‚Ës¦OX¿k‚U–ÛU³1òÐÔÑš«Ì-ÌtAÎ|?5ts⇠â7~Nƒ †7×ÿü‡”×jXWÇ‚€ü@;¡&g¢R‡ãŒÌ &0±·è«!ÊȨ†Ûæ#Ÿõ rSíW~Ns½þLWy±;È”Êÿ¥‘uCFð"FÝ#2îbIŽÆ…ï‹&Üd2¸|Šêz¦a¾MðѽטÛ.Û6ÂÜÑ—›&ö¹:ñÒñea&­¢ÛZ¦ÖRmzÍsx,nZ‚ŠÏâQ@^€Q»r Fe£Ë¿±pò#¢y*þñ´Á0p©ßq*M‡xSQNÓS!O‡Aªœcd—b(»ÂYðc—¼2JÇ=ÔE2Þ㪱2açiÑ!à0ó Ì.+Ì_ŒY™ÿ4Ø'PAëñ¹|á43= 1#3ªÔØ3v<8f1 Ž'¢¢AnÚ¼ÍÛÙèÚ@»boʱÃ0\úv¬kNýdò*’þ!1Þ±¢µ!³|¦%—³G:¡ÛaN"10P¼EC(IEGÀ[sc¤ë“ÆLÔ6ˆ´âu;ÇýI]Ñ^[j¥±’I'àÄ#ÆâùpÝZ%Ìäd wÿ0W4'‚Õ™¬¾üÀtÒ¡ÁX7Ð0P³ª'¤_—²¿áÿ]2‰^¼A7ö@L”H€ã¿<êj=lárf‰&#ô=ùÐvúà£naú=;~w±}!áf!­#§uÍvl gŽ7ÝžQ—¦›Ž;Á>òà 21ëÉqÒ4F°Z¿+™‹ÔM'íДš‹ùÆG=º µÍá`°=¶Ä¼E/m“)mÝIfBBFÆEucg·DÛs¹Þ©ì¡¿›/䯂Y“xöþ‹ÿ’iò=× ¼³„'j#%Çù=ÐxÀO.jƒã~îÇr8m£1å!ˆ9Ì0 (0 "Ï ‡P:ÛDFm#M ã&2›…áa¥qRŸ¹ÿ#<Ä%+¦ZкU/òàíw›c‰„èilY…r0ºÒ+õHc,¬g½=Í¥×-³€Ê™;V¿ïÖr-”×vAþÆ’ÀŒ¢U½‹}±~™­%§$ágØÚ8ý#èA'2,ÀÎ?òìhl m“Ð*?¦Oš…pÂ}"·…>Â5jAåËS@[áq9‚Õó.F°Š‚;9…ÒÖù¡+ÁÄD¬X7‘ßQìþî&m2kõë1³ïåÿε+  ±ˆ\Ÿïãdãí;í=jl/­tüØê6j€ Àåíñ2Àˆº'9rz7”c4¬É<Æþ[ý³¨¸ª"™Å²…qÿâÚR™–N3{{γí¼ÕD‰Õcà.Üg]ÜGÓÖ·iGÖáDÓ1ÜIÆáÊ… ÿþ…ø`ï_>„ù>DùOŸ>+$ªRåâÅEþ‰ø÷PŸ@‡7(YØ D É“ÿÂR ®—øþá’)°æ?|t.`0‚¢Ÿˆ>6üPÐ^Áó4Ì£'CåS¨Q¥N¥JõÐ’%ÿî©”§ë 'Äj gϬ½öè­M{´`Á|üäúÄ õG„Vº±`Á F,ä9r/‡€‡ ¾Ç‚ʼn1NÄPñOEYFG#σ õž¼­O»ª -P^×&U†HxÔm„I¤TÛ6ÿ¥‹>ЬÁ¯7HD (m‰OˆL˜*“#7^ÌšÐÿéÜðÁuDÙBTA Q£I9‹uZÕüyô*u`¸uë’®Y—ˆ5&ö„г!.ÓcJ¯¡=… øÇ»ŸäZé©Q~øá þákÁ æl0ÈÁ#þAŒ€#äaa>æ‰F23ëzTàì±®¶ퟬ¸Ò꟮N£± Ohaž˜bí „êHˆh³íJ.ùÇJ–T…4A!‡¨®:ãlÂÉ$™ŽûÇ˧²Œ*§ ø+;} éHï šÀ,ù³ï„òÒ³óN•ž-F¯h„ñ«æÓ@³öãQ¬³ì)ÿÀµø‰ë'çF‘釼¼!‚¿>8A°Â8ìBÄrøL±TŠa©Ëþ)Ê FT“'ÆÏü¼g‰ÏB«Ç[kGzÒj(<V V¨Í‚K"Y%kȇŒ8:JcKjN%” :&”À„Šºn«…$ȧGÿ±‡u¡'©9UÃs^ô†¹çÞ¨²ú +@ÉZ+E þÑ1`×V=!UE T³¯óð ,ügãTÈbˆ¡GÜY<±>dÁ³÷| >u„¬?´~ ö!a6Uj»dYžwþÙš\À‡ŠøØªûK._‚Ê9lŸ6©Lq+˜ÿ (¬ú@]ÕrWàMA¤w쪞¸74´µÂw>~ÁÒ@…TÿÑU¬²…SÝ_%] Iój‚¾nˆp0­<õ0íÑ ·=Ž“ä’s|‘F|KsÑ=uí  ×ü¨æˆVn$!„P6Y”DÖPå ­¡%1gª+*ooO‰Ì¿øÁš‘¢žZ—©ßåìÕ%N&{ù¨ØŠ­8Pûì{ÛK)z:ã÷²Ô²gDv]V InØápaÁþa¡ÂÃöÉA <äLDu¹6(©!«‘ÆÉý42 ®vä£_ KXÿ°Y莴,míÌgPñÁ”jÖ¤-}é&_’J·v÷ÿ­3Uk1ÈQÜ•9çCÈc^ =p†2¤^õ5·……+ìéž÷ÞE"u™åi”r_úb‰.~²‡:>Ìo*<âs¯Â´€µ’GäÑ‚Ç 06úÈÎÍ6Ò@‰ Y(Ý?&ø”lap9"°„“.=|ZRÉM`’œŒ ", »‚ÌœP)s‚Ñià#è¹*ˆAôTÃÞÃyлòìþ >oƒ[Š˜Â”ÄÉå«IÃôp î…¡%÷ñ‰u쌨 »Œ6GŽ4,Ma.g#@FGS kdsFŽˆ tiôA’ÄFÿ¢ÄnT‰â¬ ¢#"X@¶šæ4—˜ç&W a!Q4ÅœP%Êt|išY_Г¡ôC¨ †ÿhóTÂ812ˆ 1IP¸ÇyùìX ŸY ŠKáhbà5z<-/jBÄ þ±>bþ£SÂØa:”K°(d%›æF•¶cÞG©Y&[bSFird#Y“lƒM*é)kD²6p Ö UvÄé£Ih‚¬.lwÙJÎÉÄÁe"›"SÁ¨$€ðiÏCC¸òS@è aˆIºF¥Ÿÿ`(_¥‡×HJϒΛޟ>y*ÓЊ‡ƒ¥ÀRY–²ìñÿ ‚¥!7 { ¦+ðû‡rçÁ4If¦¸)ަ“[¡åÉØÍÍ#-¬!’Í$ò4âV"‰€Q½ÉÍla uÍÚWð‘àpð8Mc K°z»›lP%:¹ ?¼³ž²TO ԇ؊ÑÅê…|¨?5ÔO¸:”¡}J_5ÔPµ†îA[õeQÈœíUcÙÕË~è.õ‘ˆ|)é€$ÄZζ”CøJ¦òæ”<“µç¢²r²ùð›;ŠCʨۧ,àuL š³”u%1 ‚Ìbê7­£­­À&æÔ›Vƒ\8Ng ÈŽK”]ûÖUöÔg…'—^ˆòu®ãÿ(’ñzPò"Ô’ƒÕdDýJÃHjR+ñùÊ NÐê-,bɰŠÖâ½…-  âËI««©Â¬4*þÌc S‚§L¨ŠZyéŽàg¶ äd»šb¯š9Æ›I„X¸ˆ*渀W4 ƒ—@Ò²TÌb-Ó© šªBÀ,×ωÎTp<Þ‰p¬%OØüèËi±4…h çJÉ®½z}(Cu}/+W8†%¯~g(2K84öQV–"µàD« #°!*°¾”ÆS»¤@:FÕöq9zÜ@¸yÝámêè6Y‹^UX¸Òº½B(Çß[×&?™¼Ó z­\Ã+ósä6µðöøºV±¤‡[ Þ5 ½QŠ|¡À"ÆZ1ûÐXhO#qÁ3À„Sé–ût2“‰e‡œmQd#oK¤XQ™cQ£’¬k²XìÛœî’TBðZ L|Ë1·jrêé„«;ëb¼L=åÏÓ{$!ªÞ ÁW¾+ì[Ó[åÂêµÂR {4nÏÊG™×cJq&ËÈ;ˆhŒy˜÷b€ÎŽ £ˆê~(×6fTR‰—l<g'ë[oTd¬Ö±î)H ØKÿì¬ßw:Iÿð„ø£x)[2YMšv-1 º@¹.YI«\^QŸ÷¨ßÓÖmô¦7®½G°µ˜ä|åäa®d¹ÑèÍ©?lŸìÎùRqö¨µ÷,Dÿm©ã‘¤hQ÷ክ€:Õ(«ªC ##¡ªÛ»=•x…%¡„9 N³€$>ß+±o¢´á[þȇ9¢ªºÐ*爎âé@5Áᇣø¥îÒ§Wq­ ³¸jN"¨YƒŠ'˸Mz9óà¬À‘õ[S¶Òž÷Cž³<©½Y³V )àñ¼%¼ ) Á(½²H:4íqºdê Ìÿ"‰·Û’±­ÓºG+*HÓ½&8IkMK§BOÀ °‡ø€°11½¡ ¯J šø–†£¾D~ 3ï"}¢µŒÓ»ª°$M Â#\‚c%¬°/ùXḆ¤Fò­P,Ó°µ |ˆ€Úï::SŒÈÑëŠÒK¤Í4ÀÄŒ Û ˆ†¨­Ù§h ÌEÛ{–¨ˆ Ô½©ØC¦B¥²ˆŽ€{XkyÜÙ çÒ”Љž¨×X¤°‰³N²0 S6;áõ#,ÅULÂ%0 Óîù2cà—&@Bù˜úÒ/ÿÑ’³0R!•P5ÿ@—¨¢Í¢¤Ð¢0ÔÓˆP{ʳL%g|CÙ+yû‡­c´©Xs4|û‡9Çnä¦~›4•'\.½™ æ‹ åP/!“pñˆ›8ŒB9{:ÒX?O,7T´©j­HH®\”µ Bñ2 hc‹`$dH©\Ã} ³|¢EF˜¶Jˆ €È &?»&­>;™3äøWЍÉCÊÈx#'jˆ¿¡Š×Á-G³Ég¹ÉnDà{ J˜ÙÙ ÜQ³HÄ nq{Gˆ“Œë ʼn‚‘?£3ѺǩlZ©B·„Ì;Û¬Mµù0Ë;ú—ÿ683{p{Îú—Ai°h‚´¼DÅZYBt£›’J¹È»lF&­˜Äù¶H:ya‘DFÖ‚;›¢ ˆŽÐŽÛ‚LŽÈ¿¬ƒÉ¨¸=ˆ¢ªˆgŽWðOnäÀ=L’KxªÐ PD”Ъ½Y8ÛI‰¨(DPº“ “©ÍMjMY\Å-k‘á›ø)$EòM­HH]Ë1Î@1‹pQµø—Ò…̨9 ¨Ü¯žÂ#j³ËŒÜ%b:b€Pù ÑÚR7y—Ôª‘ÐpŒB+‚¨2­ˊIšFȔɳ=Ë\|ûÏ%!1ä&Js£ÿáÃIcIJ Ú©‹HŒÄã .AZ³°P{2¦¸š¨ØT›ÂÀŠêÜ/ä¼ÕGTDBéJîiµ0N'ˆ‚͇pxp’E)N´¨ÐÌNC£ª’µ.Ѫ¡dPµª¥aD¸.9« KEb:ÑÒ'@SÏdš¹•È(ËþbW—™„H¬Q¡ã„Q}Èpà…Øè×xÈJÍOõ2…|¤¬œµêÜ.|¨UÕE"…0ÿ¾¯#øÓÖL9” ‰Û°)Í€ìÐR¢ÆÚ+ àˆ4²F Z’¢b£¢Yዊ=ì¦é˜Ž6: R “,Á*\°ªèˆ†£Áìâ Ép¬rû3cú³Á°§A³æ„Tš )ŽÚ°èƲ(úZæü—p‚„Ї~u^HÛà… üW´uÖp‚°$3{JŽ R!ÈË3„‹ÔÅëÆ/ü,‹!Âö­0âÇrRÅ1­xÚ¥ØBzSYa•C Ì¿ª°Ã<ü=Üè´lNk–à’”Üá éŠ雎¸®%½@É»a¯}±‘x9›«ÅJm7˲DËAQ ÿ²-³=[¶-ã-ÝP‰ã-·u¥Ôv ~áÑZ)¬ê…¹Á¹ìÄË»ôŽù÷¹ØÄ°˜ùñ¶Ó8ÜdR¦©Å3ÒR wÙ.tLš_–•*F'Ë•Š9r44»§àF•´püÀ a£¡õY¡•,¢Ì ä¨ ˜P qŒM_ð}$aŒÀµ3‘ížÇ5ˆ(ø‡EéàÙ²8QN|ÅW}¨Ô~u[8ÞÜÇÜ«ˆãå…~E8‘Þéž=¡¨{b½µ€,ˆ‰ýˆ[Ý”Hú”§pž*Š!I)IqC«TžƒàŽpÉb!V9œ·aåº;„qÄ@¦Ù&áν ÄIÿr¾äÀÖ„#ÚCÝ™à qÚ½ü Ó`˜™-„€ `IaK%d' ['ø‡C¶T³Ø´M[Ž0Þ¨ ´JN±FÞ"`[F¹ ‹( ´Ôb«Ñ˜”{Š­ù YÎz/Z£¥@SÎ8­Òz <ƒŒ÷ý"©™pÂßÈ݈§hL©ÈÆ<”1 ˆüÖùÏÿdH1ƒ;S`€jÁªúÙtÒ£§ ® hNÙË)¤°YEC©#Î{чÞxøpáå× )d`–ØÖI¶¨ºä¥´p¤fUØd·EØì!3R‰Ža×ÑœÎh˜ p 0„ÿsae‘…¤OÉÒ(WGrŸ;+ÂÔU庛€* *V-¥@ÞhÙÚSiF{ƒ›Ìx…שÌW°Ãl,ª®IÓ ¡ £iÆæsª‹RãæƒÇpŒÁ€MÂxø˜Å)‹wëœ}…gxÎT:ò}àj¸Åꇆd^X^ÐЏ€èÝ£fhæå…V‹´D¶ù ¹ñ“/’:Á‰@¼ìŽü³‡V6âŒñ¬Ä ¨rͩӀÚ0‰[¡@ #+å循ڻ=ÆV— G ÓIöiU *F˺8”ˆÝk&D`£-YǵÒíæ¿øæ¥´§VÒ¨õŠõ4‘ÿyæ‡Ðê€ç®ÖT¬ÎTãvˆð´Íçãè(‰ ~èžÑY%¹ˆ"P…Õµ³ Û.]ÁÞ‰ÔÚÉ b5!Ì"ObšŸ–²è‰Úüñ€:=;ÀöÙ°)>ˆ4éb›¹b™dLÞ¨OÛK£4mÊ4m ŒÀ‰ˆÞPí}ýȇX®ÒM¢Ì#Ò”Äêâ¼6™y)+r"˜Kuà¶g}ÈT. –ÈT³Xˆøþ‡â-kIÖˆ§€n~öç58Ü3;‹`Þ–[f#ØÊœÎ`FÈÀ 6 ÀKUpå‘#ßò ­ä阀¡ò‰[¡¨x‘+ŠÚb 2jY ä ÿ0U4 ” o´ |Š Üˆ¶Uí|ÐÝšDĦæ˜m-QGÚî‰ð˜ VRrãHÊî°„‹‡`îá¦#L5[ˆèWk¶ýWK¿ñF»éIîÝPkJ³´ÓÝ=¨rëMNáµ`¶‰Kr•°¹S*o¾Ý¼Œ,ˆV{è‘ø§A-Ç‹äHoÓÇ0R•­ÁRË•@˜,VWé5ŸŠˆˆ&9wöh’¦ëvk«˜pçè–4“í–˜ âpGÁùžÇˆ31 C§ÝtVô‡hçEwDp®VmM]n½w•àäå•dŠ˜dϽJæq ¸€ø%édµ°Žéëš³9zª?•0„ÿ—õïU¢¡£5Éa§Ôc™Õ ›œ©#"á­›iYýæÒˆ¶U‰hª——ö—_“:§k·öˆ‚ÐsQ›1¬âØ–Šè r/ÒPL­QÙ°´#}àwχÐTææ¥t߸w¶õW–wîå…nšî…×A^N‡ª_ëÿr³Ûä|Ûƒ¾ë¾ˆµ˜‡Ý(•H峞Œð}€Ä=Ñâ"¦ 2ÕpÚZ­ûQ•‰7a^!X4/ey˜ízÕŽùqŠq³­|¨à¨öø¢^ñ ˜+J˜”ä.é—grýx•jª6ñ÷­žw}à›ñÿHŸô¥qßä}×ç°{JVkO4Vû%1^K­v»NuÚ¥]þ% ÀE'g UEĺm»%ÐR©ê‰ÛõU‰þe%k6bù Ð;qB ¼%.ßž g÷Ÿ†ÿ,ü£ÑP…òÙccžÞ÷ÿPƒÉ*ÝêGÑò y奔ÌbÞ<!>B$ÂïéRŸ®ºâ"}²õ}È7zt¾\tç²%7Ïž²ƒ‹è%½ ÒCñà NÌXµá¿êÙ«Võ¸A…,P¢„üï â_γW›&M}ñôyàiÂç?£FM‹ðP´jNM5õ”SrGU/ªd•ÕV]yÒÕXÜEô XMñ¢OÈi‡-èUe‰ýÐ †Àfˆ`Tƒ^G8öܱÄ?nEhÿ°ð:F´R¡}@š>ˆD´šN¦™FÁ ü%)[>„0¥Aó´`erV¶`—]SòFQO<ýsÿ=–YFÏq6} ÏU„Ýv¸TôÏ(IH‘vñsÂH%¡DÒdé±W›lüØ„OðÑGTQBµ“£IéÄ SHQ^µ`Wÿ„µÕƒ\mQƒU¥•v½%«yØ‚\nYЊ‰ÿ˜XAUö˜©Ž £çÝQeÿ°h,±%ˆçcz%Ì3Úi¤R¦‰©S’;Ñ6å”Ê)Ǹà6áí@-„0f”悜·ÿÀôO>ÿ|…>+lÔDpÎ9gžwþ㑌0yFtDK/Å„P³Å‡¢òIì ü5J©©˜ˆÖ/Rõ2Õ‚\qå)E£Nh²§¡:åavåÅÿê[’4Ù'üpCD¸ª˜bA‡‰w¯1FÄØ°[㲂VZ¬9-lعäiEê#Á”ó”ð­JsÀAÁ’iF=ÿ„KDhGd[ršÉÓÄ?WrùÏ Þá³ÑÕqäoDyRA ~ NÂ.=;äL‡Þt“Zõõô¤¡”€Få7¹Ôþ^EV/ †%êXa‘:ò§6%BQØ£jˆt´„@ýà`UU`OD>/1¬ûä`Ä>0¼J©·£z’ù¨#Ó£I‹µ@O·µFò$Öx«Ü Éó\š)wÏrÃjfE*†9fÛ÷|ý5ä ¤Ï mZÀÑÞÖñÝÿEŸpÒâw„Äo2í©Í`lr“ðãñpÁ| è}˜ÀŽz”P ”Ac’ŠT¦òaEA É4÷ Y!«ËK[Bô&xOGº!$«ˆ0BYLD‚%Ä‹€Ã’ËJ˜™$J&4ÈÇóR#5} á4ÖÛV `¥¼àL QŽe\5¸) ‰‘×A¸óñ½OøJT2úñÅNÜÉ×þ(âç%àbîɼ$îAH|¯ˆÄÃëIP,ÈANî)Ë#UBH•MqêS#ãNƒ"4^¨…-¬s‹õÂ*åµÂVU E|ö£^Eäÿ1ÃâW•–(ïG::h¢5­èE„Z‘ Ö²X&z@ÀlAN™B“Ì(†3Ši —c6x‰éQ!J84oM)ˆhSžò§/¾ig7°ÇxÈC’ø•D 9¤¶¸À+ü‰ \` RŠƒbŠ1IU(ˆ, KUL&º±pÅ>(x*zä….5³!‡(rÚÉëh`Dʹü#X0\fÂ9,Řo ;2^”ň(ÅfI°‘Âd¤!üCR2·¦4¤s1VêMD-™ME‹TÊ#"ÆíÁ¤^”ØÀýú¥Gë`dùë›CFƒñ˜$~ÿ) zqHB Š2@óDHR?J©T@(¡_ åccQ…a±rBщ΢¨U(ÚA qiU|bU$³Z¥/}¸‹A[~4¬øÎ6KìeUX@£ä9ÕiP[ P¥(!) ©¶QŠrã²%g¦Õ„[A Š@j¹°’h’S¦l Mˆ¨›t0rÖýy¤#e}çx8#Àá&2Ax÷0n"$'’ Ê/vR©ŒI*—´Š ÁQ’‰.…fåV0z!S&'3¬Š‹\îA#y”ȤFÅ•¼>Pœq¦ò0HpòQ&½„K3JS³æ±&èÁ~ÁÖNbs½Ë‹6ñ² ÿL®¤0{àN´ÿà€/ë‚›ü”nú('• ²¥g™³”ÈÝ$4Ý;â©"îÜÓx Ⱥ„ŒRgR¤ Ç&69ï£,™GÁ6*$ôÔbA'!Èrç¢d‰ŠFWCXq&%g_j5À”wóÐúz4ÓºDøÉñå/]‚awzZ’Bü$ÂËÄÎ,ӛꡘ’‡oÔjÌ–l­à+؉s 7˜ I!+‹G¤Ë¼U…#ÕíˆG`Ý•'€b»gmÀ ^EÅF>æÍIQ,u§×x9°MñòTÜ»XOuŠTõ(Y¶Bѱ8e¿òP\ ÖæaÕŠÑiq Rÿ)Ú@¦ä¹–Ðn×ÃZ ¯I'>tjŒd$iéPZR’¦–DÝ5\ÞRœÕ|KÙÜC\º- "ÅaÛr}a+X€øBdü¹©ošÈ2¾§’)i2> ^&Š&À6 °+I  Ù\¡{ÝkBQ1»Sõ­J„Îr_²tP-«;A^8ôæÝ)Æ•À®ø¡¢#ƇÆ(:r©¹M‰XfL̺5 ›éQ¤IÚzMqbcoÚ˜í©-i J,Ë{dSl`|æp{b=ºaë¨^¸!ŒHüŽúª®ª­»ÿýé­?`® ¥×B‰—¯#À2SVbC*Q¹èE£Bÿ¦ ;d ’¯è^]!‡:ôs—BXgzÿ'wô„„ö†•ÍÆ®OÞÙ(ÝgæèDvݨ"¡HÇCÔQ«e„èž„¼“< ÏáI)â˜äs”ÉÙ…±€“ò«$5<%a€˜fnjÚMD*ìØÅ¡ÔSpÒ%(dÅÏ]ëeшÜi` ˜>m؃¡TEÙL¬TÁ™Ñ® “ ¡·ÁF˜•p(I‘¤F vâ¿Æ¥pÜ+˜,ßÀ)*ÝìÄ XPz‰€*äÝäìh-îKžˆ^vhÄ_L,\U•{J(­.Q›Ñ“ù „Œ}㘡þ=ÊÀTµšR 4ÁT®,ظOË–‹]ü†>ÍÜ‚(–ò!‚zTìhÿаfS&âçZüƒ1Ì”ù´€ÒfÓ˜“QåCÃPDOMmˆEÎÀFmÖZgÕÓöDìFMPí¨.ªø•aÞuÜIYeGGæ«y’ Îg”“MÌ®QáÚ•ÅêÒdl‰A$Dò–a~È…ÔDªh€‡`6±]Á°Û(—8AüF@ñC=kVŒ,ê ‡œ&å?\€Ó$ØÏFè<%=?éEÔuUŽÑ[ÖËs™FiHÉÕ„(ÔÕ%Âîu› Ì«ÁLj[7IG×–°pŒ0¤t‡ÞÜ F’‘½Ú P!ÕŸm”ßvMüÊàrÉAèjK^O€ÿéZ (ûfëûbÓ mýÚ…q>¸@.ÔdJ›´QÛ7r”r¬’T€Ï>Çì5‹Êr“Œ ¹ŽÍ Qo_\ÏÕ@‘¼A¦¿N­½¢hYêÄp言ªþÚ¨M7gñòcå…>Üï•=ÝüØ›¤ª¿0„‘Ñ­Gr‡¬e—üŨ‡â¶ÁÅ<ÌÅ®r0Q’ïO”¯äÕFqû¬¸/·ûj—Ä„ê8Ao”tº@Ç ´Ž…PêÃê¼ ë!¥eÌÙΜTÆ îÄ„-AÔÉÌÛ‘÷ˆšÁ5IO`°´“8'§8+ÄÜUÅ/(ħ³N¤ó*®OQAQ.Ìÿ3Û®²¶ä$—×lÈ"ÆåQܦ«M×lጼÄwapn]IA: Ÿ•JqI­Ä.Rx%¯BPŒi+Ïr ƒÊ"«·(W,«ý–W@Yn2 hSðƒäEjºDLàŠÓ´X‚}€\F…¶=ЈÔÅMì¼ p5Ó‘è„ýçóX r&§¶pÇ ›0$­ÏÜý'¼¬K.` £•½&aN¸«3tpLrÆ¥ê: éF¤ÜYD€‡\|“¾gsÊÍ$ Üê„@T¶é²™RÃG£¼²ZlT(-Û²ÊjÕ¸lOpÙoJgYÇ@…Í.ÈÚ²û® E_€¿´¦‚åî0ÿØ‹ j*³®«Ä SÙ%lèPº&á9ƒ‰ˆ“Xþañ« W˜¬‹mp‹!³â8›å½JXÙœ´sˆ%«]òœÞô¢ªG„Çdœdv r°˜%8þáT¥TE .ä ”Q¸@ JI´-“£VIñ ýCü³^ñS;…—™VH[~ÐD±ž Õ=†ÀÝÎsx #Àí¨€¨@ûà’ÑÌ,ä‚i¼+7…skG¸S[g?bbq 2¶¬¾êƒtÞop“õPK§&gx©7E;/#"|UÀ4oba:ÄòODla“WmL‰{X,lºL8z¦ÅŒi‹}w<ðÿƒQX `KX°ïxß²øî²Jµ@z«w_î3*#NŽw·E¿ LÈÞr=?yT(ä*já÷$†hSOm?j0EÔJưáG:rOüã˜@š3£t¢>ûªœK ¤JD "ø@Z7lÒíy>zßÈZ¬ ëš¸LÀËfS7jÚHf¼Å«Ä ~/ð•%yšˆw£øâº/ÛÁSñoØCç¦z'±{3TDvVtÐZ¸Ì«è…=˜ãsØC/?E?̓5GŒÅ‘fÜ…4MÖrF8dçs0ÂÏú7¼T¨ ,K.=nJ,Ç”HjÔ†õín]?oU\8qˆÉÂsoü™L1½<—Ã…l˜$•@“zÓ£¤w 7CxÄýL¡¼g¡Y‰žèY”¨€L×#®°M­¢Ø„Ý€eÓ[èò™Ê,T„ÒǤEª,.ìL¼}sÆûÄÒg<=¤ww|‚T^R[iš³"TDÈ¡ºÇor?œúQUrG¥6ÿå¼Ux=CíµH >£ü±˜ˆ)r¸hc'”$ÕmÛzLð,2DXýå©¢•„Dï¿x‚ÄéKD‹®)¤ qb Ø•‡üã*ÜGA(/ôBÔ, ñ‚F½´±ÂŽ-dÀãa[ ÉÝ£xs2*–Íöœoç/0H§û?8MD>‚µîäîÁŒùÄ?zNþ ¡ï¢útȡ "l¨Oć#æÊgÞ¿IrÔ§/Dˆy-BÐKIfÈ‚G¶Ðó_¾þ Á÷o>!ÿ~âã)ÑáOžG‘ôñA¾y'æÙÓ—/_¬?Øk9ÿÞ¼©'äÉ»G€€´DŠ”×âL'X]ˆ(RD•K—zùðÑK„‹N4ÀµIÏž=zfïÝÃp¯˰‡Û8q2Ð…‹»xývö¡ªˆ}öœ„ÈWDï^*LȈч°+|px³ ½%ÿpðCÁ{òÚþK"§í“jDÄpáséÿeŒ˜±zÓ‚¹rFù¥eä‘»\¹²ؘ![ DŽ4d>6 Z´ Óü?óä_Ð'¦½ÂJŸºvìEµKþaö.,‹‰W¯"kLÆE»*§ž3ûg3Ð@ô럧TáE0—ü‹k‚°ý 6n9õ¶ (ÿ)W…'ÿYâß~ûXT#ƒÀÓÀzY¹‰¨ËH4z9·M¨û]1<‡ÔCŽqU¿rëâŠbßc:L§(þç⦎âÑý…jøÉ§mãgA¬:¥ç„ÈN€à òù`ǰ¼‡…Ã’ +ºDÖÔfý 4^ô9Ú2^C®…\0ZAÿ„Šøç—ŒtZî=ºÈ‚B ¡|ü‡^~q¹\#›ì‚9·×>7áîÎ7‡Øbw]z™>˜ƒy!äLQv—¯ˆ|<à™L \·áÍ8-xAäDÒž¹8rþ ØB°J\¬søÚØRµ±žägA¶;—‘­u­RLXÄbêÉ,¸YK4D’ñÌ.EÚ^˜ø”ÏTKƒ!MHSôlx ÙLÕ˜•—f-ñLÌ­f±ŒÜ¥½¸ÞÙ*àFüÃ[ŒP•põDÄÙßÜ$²¿…B\—ÊÖ$VÄ÷úwø0µ‹ˆrÿ‚ ãóäL¦=âI=¼B:ÕhP ˆ¢ Ò¹"?¡ Ê£09†°«JA°b»¥Ä+-yÙB$ðˆeo¿c•i‚—™e1q/}ÚE°¯Ë „Š”Ãbö’ÈEfù¥HÙ #RÈÈ!eáe/™€=âç{¬ëùPÁºâ¶ì]HAËcÒ¢¥‘ ç:aÈ™ ‚Ò2j[ÙŽq>qJ$é—“¢ ‡`078È\¹& f'ÿ Ä(…¨"……Xw’“œ®UÁ»Ý{´ªS]Nr\”Ó©Ô8³!„“/Y»D^BãÊYfE tB.úMfeS/ Ÿn=ó®åØC# ò¤ÖÓŽ,Xדæ¸6™¨€,Àa«DÒBÞ{ÍË®û´«v:Ô!®"å#cuˆKg0õ -ðMÚ3Èü£ 5ÒÉ(ÿÑË¥QîH5”|¥”ûHzTVZ}”Ö!§S­lnGÎ')æµ> ^Nb§"3œZ#h#Ô(µ¨ÈŒ~4§:55Oê6;C"oo‰B0„mîø¤®Œów<9óÁÃêªÍ¼ñ,¯vØÉ5Y§:qH‡Úªœ°«%Å9hJ"ßÇä¿€m‹&Qt.‡&,a)[ØBýd6cˆ¹Ý #æ#fH¼òÒ s…Š.ÙYj2cp¢XhSuânYŒTº{;:nÐv<Õ^Œ/E -×t´DÌÆ!JëüæƒÚØ#˜‡º{VsùïÖtC+$_ÿzÙu„—Û‹„¼·=‘›’K¾SÐ|pDZ—‰L\í_ÛDŒ>DÙ”ÿ(X"œµó)G“]ñ+:í]Y§AÓRµ·ûr.©Ôë(ÕeDv¢S¦*4fÒ¸ÅH¥Z‡ÛmJõŸö ‰¤f4˨ÏÞÚ®üÞøÇ›‰U°²n[›ò¿äà7ð£>%’Þ1ÍK;P‹/´%X°üƒ Ž\‘†¦í&‹¸9 Ô܉=e£èÜÅœÙD=js"€Izv{ô +¬ãÇsÒîMÁ›AÁ³„g ßç…‰·•jr÷­—.Þå[Tâ2³ip‡DÚ!¡Z2££´ÿ 2¹ ˆý ru™DŽþæ¡‚îFY"|D+qØÙUÁ5D4ZÞ2»rò¥÷*Ùðù/µƒƒós'Àâ‰ùA1RÂhŽ£÷Ù¬‚ÅÍ`—{.¦Õ‡c—üÓR½´¥Kã;,Cs¤½Õ̦QwIë6k]<;³$ÝD·Ã]"FZ5Ö†Ê\«âbq[ bƒ;Ðoû°—CÞù³˜kÿûMoxX55$:‰ˆmn‡Ó\å ßA \pQñ4ÁÍ:O¼PÍŠ*°b #€9g……p(Ƥ¼â$®HöÆ6Eꞃ¬Cê.ÌÝ,lØdp «.A칌Ï)ÿ¼Hù˜Óv úžÂø”ÉGxAïŠJ¾J,^ÃÃbÀTWèáŽrEbM"8 nüˆ-þ-Z†‚Ĉí¾ÅĎߎOªü-ù>CkpŒÓ¶ )–kªîíèÎáœmb *b*Bb~þÈÈôÆRJ1È¥ vcä$§ sMo6â^à#lï#˜Czb—.‡1ÃÍD"ô‚eçÚ" k"æÒ,7B錤”‚,)ôƒ'¡þä0#Z"1ÿdÐ\`†‡:æÅ  ! +J²ÎVþ¡.xaÓR°ÀŽ|(Akn·˜ ªêÑøŠ¤/Ö(ªž"lâ8‘+ÆI&ÎIX€ À6º‹dâ‚\¦däÌÏÐX"g$Ø© ç"H0j$@_è`ÄÃÍÞ"°¸CÍ‚ÚKô«=loL ³Ð@é. éÀm ]Éiä0§<…´ ‘uÖ ÍÑˤ"8b*Š®/^Å(á l?£{À™â¦ª{ºGÇ’KÏ)hå/”Kh¸&&àÖ%¸ê«ìb T> Jfd–ÀR ¯Ò7<.I¼Œ9ؤ9âÿæï^b¶ÈìÅ`®åª­ mæ¼c’¸¬³nà"€)~â µƒ…D@+<$4ö…˜ ";öðŠøÁP³´‚gA\ÀÇQjL,5R0Ò®rD˜/ªªÒ*›eÒÄR"¨î°æÓúMDèNždJféèèwˆcÉR¥R‘ð´ãà†7˜0ž¤$Õ¾¬9Øä" ž %|\ÂÙ¼ƒ&Ú¢ $Û:OçF„"%¸lþA2GIè…?ýC¤Žn¤$bNÇ®†G¨h(ÃL«;P4"Ï4©."\Óϰñ!|æÄ M¹¸G†³)µC+¥kÂ(¹.ú®G™©\ó«ÿH¦~\ƒ-‰P"zçÚ(,¨reJTQ8Ä "³SNŒc¶G¤½hIeüªXr£UÂQ¾Æ#ÀPç|q$rÁ±Ü£Cnàî³³D'Q,à(ÄÍ WÉ(x‚¶ñiTkALËöi÷¬¨ÐÂ5‡e+躢¦õa)! úˆæ`E,‹/Cù-‘›nŒ>Má–h/Šà\c´+6Ø’œ¸Ï6¦äfªkm$pEt´”Pv.¡ðê]6’MêAÞC%Ê×ìo "Jã©ó@ë·pÉö2‚@\RèPÈbÌ&1ÁLŠudè*œg{Ï'1âA]ó;åTNéâËÿD³:ˆ‡)m ™nË)Ô/ÒHDùT±ÒiPún8£/¹ÔZ×eJ.¯*¾ÊüŠSfMJ–`J,¥ Nò$wô,þµåDåI®ð† hIlËsÿ˜-¾¶böcô.gç‚¥-æ—tŠnàz\2Á,æy‚èøƒ³J¶³€uD+æb´;p½Ì‘uúPöÆó*âA(b§†çOµU7· 0Òî6ÃèBö+Çh¹°I".Ô²&Ñ'©\ãŽæ¡~$ ëí««ñ”dŒ!¡°_þÇâ‡82û’9jqM•£’Å8(Ç;o‡_œT$Ð…ÚæD¶$F€@ÿòã£> •Ä”(0k|àBYK£Nƒ§@ô0eô$4bN -¾„Šg®(0L,[1´ F„kÒîz®sÝŽ‡ó)€FD ¢{†æzŠ Ò> vÕ%këç«~G]XàÞèE BvxSñmzׂ ‡c$ê+H0óaH{¦VIû¥ Vµ°`n`¤ôa«;hHe$*¶t2…Žd ÷”6k(‚D`öLxu÷Ý:ð‡^®hMÀ±H'ÃQU¡tÁU‰Ð{tdDBD\Ÿ2|xd=m• 5nt¥ªë­ÕÚ2ûvãûØÉ^wƒƒþÈliÕƒ-ÌBrÿ°.UéOmÍ– J"è„gÞ#,I‚R¢$ÿK>GË üjV€²´ FÉ!brõÄtt¾-& l}KG4JCÝZ¶êLk÷öp(…²"¤ÕVz&ënÄ;N3þ4~!mr!}zk2Ct•Ï/œ²*)1usK;"x™’Oxaºô68Q^ÑÉmt÷mZM1þ_߆8–Àƒ÷5Týè!!²eœ“+f*ej jìïvj˜NÞ#Ð’£†ÁÄ’Âì^ž)'v%%T!Jèoïìb.Sp#Ð!ü6°"4·Ðf–Q“!Z›ât®¢4b„ÞºŠËN$EÚ3G~Ô„–3ÀÎxNÅR7ÿÃ’Gðâh•hÓ µEyèŽîHSÍOrª¶\N Á‘ßqíü’P8ZFTTF«zÍ Ölsxòg๡2ùydB`òÆIxrSp$píî…èüV†”G–©¨l9‚O‚á/B­¨gÌqBoD<äÆrAïÚàI›™ÓG™E/Ž‹7ù4›.kèØyÄi?Ãß ±âÞÈv½J§aÔw‡C‘œ‰CÞæø)‚£‘ÅbÍy×H69¶#·Œ­°ë>ÂU+J—p¸;ž&â À%oÀ%‰˜¤VÙ ñÅ”8'k€zðpö‚GÝ8ÂÂTS"ð5!â!xÿ¤Í&Ú˜'Š Œ9>ÍQ™«Å[³ÒÁÇH5Q«yGæNšU,ª*ûm7$>‘jéh]– T>ñSQG=˜œÑyäÎo;Ï…-#9O5asÁvV 8¬òn'z¹LI««px«©è‘>">×%Êz)F LCÁF–'üvÑô$$ŒgvÊâ–1"e5wJ0V–æ<È¿`.æïr™Û‰œŠuW0|{VbZ²[kt,7ÃI^¢-áÃ5*)ZíˆÚ{T‘ûÕür.n„C {Ã! pe{;l± ,‰¦žgp4žËSëêt<½¸Çe!FÀc- X9g•Œ‰ÿ•»p "ˆ®÷ÅqI BUpòZR^ö$âN±&»¨Ä;'2¤AZ‚›¹Yœ"Ò[…¦Àh0D^Ú!Ö.,}¤±U×j›3Ùi›ÿÁTšâkµ_àæœ“°‘yCKzúå^ƶá9ªá†µ®;UNV!È6L£qŽt_ù#ì*ć8?.ó²ìåÄ¿´³ zF @Ó4ÞjH(-¬ŠeïÅ™¨VäMêÓHÓ!q]±ÉIt\ÇÈY¨fîâŽZмí„&6n7ûè•-õ…ú¿ï?˜Sqä8v¼.VÄT¦“ƒ‡Îû²HÂö‚Ã+iŸAìyv&ÿ¦D§ªÃc%Óôü)Šà‚ ò”Ym¿hÖK/©r‰¤Æn¬©vIªý%D–&Ûm°[lDÖfÂd&x@eCÙôOqòX¤CM±p\–[þÓQqÏ9GÐ=ÒeWJÙ´I"©äÒ=÷ÈsÂCô„°gREPQë¡÷A|FäÐSxöGÐSö¸wC_ݰB\€5VYü³©Zq©jƒpýÃÀ?Œ0?ñlØW‡F}ØS‰.ÈjA&†Øb*ò6kmEüòO/8Úhã%¯¹šk¤Q‚lÌ)hªLû*´Í6nEôB/&˜À ÿ•ÿXIQ ÄI„ܸÉ—çsÅ-Ñ\ž,,ÁÝô†äÒEsnwF|÷]¾nÚ‰ç<×´Ô '%Á{óùtS¡…&„ŸEKðWÕS´ñ(?+8à?†åi‚km°Zh¡åit}凵êW{ Vba‹!f׬A¦kŠñXÆË¶Eð2cª+¤=IIh¬)¤‘ÐŽ[iØújí?™Ú/Pé•Â|‚™™‹h–d¦ w&}$·¿rª§Im–Ôæ?ÿ‚”fG2Ñ3Ÿö$œÏ¹(œø•L®h MiÌ?ÆHþ !Dö±D7× jª)§žþ–D(‘ÿª²Ú*?Ü<˜^ˆñ↸ýÏcå3™‹-Oü/¼[lÓ¤¹öÕM;ÛYÔ>t}›¯šùÈ­©¦v0¶DÔP y>”%rä32ùof ïxa÷’¾ò»”/œµ4çw/ ÜèÅÈ®œ': MìcŸ‹9GM0ƨ{ 0Ù’ÈVäbº¸4(ƒeY™Ê0e’RYˆáÍjf+}Ü%1¼óP‰öÒè¨'ˆ‚nxÃàp‡ÿÈE‹ŽGšbMoZR;RՆĚÒè†I×ò‘$Òpy/fÙ)»NP0Ìl!“ݵ„x¤nÛÁ›ó77½q§~v"Sÿbr™Žp†jʑӂ‡Ìä¹ÇäZp¹jèz´¡«lÃ?\ Ë68A–²ô¡ z¡™\Ö†ˆË£³T­‘XËZ× ×Fb )RÉߣH»Œ‘´=}1™ Ã¾y¡);É=ð†¯ø¥‰$þ’ÛúÚH°-ÅO÷‰£;ýw•W6¥Mxà Œá£, ˆŸkÐ¥Ö ±„Î,YX d Y(ñ8! {R˜Ç B/9ƒ‘>†ö|ØÐ ÷éè?&'É…ô>®¼¡ ~ÿqÒY‰€°ÙL/w´š®qkz>ÉlzñµmŠèÃ"ÜÌd°HÄlÅ!_GŽp§çœÀbx’Ž9é·8Õoœë{“šàGu¶À"ò ØãH•ª„@ mB=x‚ 2#¨ÔWЕªŽdSªÓ ]Ñ2Ö1à{ÿÀ¤C]•B•È0‚(_œÀ§ŽŠtr %Hk’§È‡QhQf\º¼ÒDÍ$NºÍµ˜E)và[ÿ¸…CÒV¾ã¨6"XN Ú¥¶¤^³#ÔI#œÀy’©Êõ©&éª0²Õ&¬ä_þ›ŠS¨¢‚Ê­r¯ô](iA‘Íå£Y"ÃB]Qe— b‘ÐHPåÿ…În­šì¤'Gù˜µ*•û‘œäÌ:’Æâ‡á(GÛ'DxEãÚôþ»¼ìÌÆ˜Øz÷v •hšÉš'`Dk…J×vdLÛôâxâ·&•|À›7Ý$×7½±]mÔ7 ÂÀ´V…QPÀjc‘Vªt(+#ég]©Û–¶üSdœ èÉÚt¥ ÚZÉ‹žß D J> À'štô±#qÂ?n˜‹äbËÿøÅ/ráåÊôÐ ¹°¯~å3«þîr3l0i:[JΦkD²…º7Z˜K|Ì‘×RQ\z0"mé;—E´tŽ”ø]t»fJÜÄø T q|%òFÆvÿÄo’&ˆFÔÇ\W~]W⤠+äõÍ%¯‰äî¥Jɸ,dÜ3ÉìZ•ÀÆ“Œá‡÷Çû4%úÅò–ÁìC/+iܰzRâYv/šMgäš&eÇÙ«³©Èf‚q ‡ ¨ÓHæaA³À™ì+Ó±saq:u_ ÖN½+íé礉#™f ™êÔ„L®raåXå\üG 4ev§žµçXw©Us×+ ô1$·â‰‘|o%H\Þ\e×ù°‰W{D! 5ŒO‡‡R/#äZ1ÚÖ´––^¬t¥Lºy1±›'ÝFjIÊø·—I‘y˜+m^wk‹Ã‚PÄ]ÿóB±Õóý{IdÃPÅmHNlé};ÖßÎiB¤AÈD}´ °2FÎz‚R` ݲÃtu<ËVrÜÁ‹lSÿ|+Wtjk_;ô/Îm²¯±”Ñßi´U¹è´¥Ýå_!­6ÜêÅgt4•fËWÓ»v+ˆ$m…†TÁ”ÁÅs™L'HÊ<^‹.ŠÌë]VWy«6 œà »I†A/LN#O9qIàËÜF©€ÆéKöcð¸@/¨„¨û÷ƒ–åŸ+“ˆ=À…-·^qhìBnq'×áE,Ï”øÒÐiÁ ,x&‘GVU|ƒiWqÆ@P`9žf ^`|p) ð¬#!ß'£xŠ"„HaHáå„}5;°Óôñÿ¾fB•‹‘Ák•±V›ÄrQp8©Ô4Ñ9ä”ñC¼4½q€½cyH³sixL5%5¤·<üp8ÁA>]"n°è#uÑEq[¢%&‚/±a¥>(A"q‚Ž˜pRAæ4p}WFVä,@ˆ„F8]rá ¨ˆßÇŠ<2¥BI µIõW€5œDñP•‘OFlƨJªÔ }Á+-RÆc<È ¼"<—jæDÆ$ú@8ô@BãR‡êÒ aŒÐA.ÑT[ç{(V/AûHivB'ÚaùF>ô`v3øQ5H- dõÿe|°:«öOgé£8*¢¨A[¡¥r åñ ;U'”ô±‹¡‘T¹…"I\he‘!m/Ù-ÁŒ)•±+e<Ô¨ED{Až üPhö04„–.ë2뢥I‡åãEÑ”jb?1ðš÷B'£7UIny¤>&ÁX]ÉXU¡®TOÿvÞÕ]l]¢ˆ2à~Dh„!DcÎ…Q& ‘y‘ç*6ÁIÓi&g©te7dGò‘ ʸŒaž¼±RbÖ1iž5ÝFÔ¶< €!'èÆ™¥i&B¥@5>S‡(ó°(Qb÷8¡y’ÿ }'õƃ–æN“VÒÑu1£FƒlG÷TOöH–€WŠl¢uUŠ«ˆP/s§RIR 5}±V9ôwd‘Á!G¶IœôdÂ(ÃaaL•TÛä&S×Uu'TE‹h›ô›ÿðU¥Êú‰@Ô§žvè`„gqliŠ ™Hªè¢¸×qÕW÷‘G&£õ(ÂØ6*H ©Ð(""ëZY¼ÿЬ,x;ÐØkpy)­0Š=ì–Ä)kÌ9“2kÛ:ñ§‰TØPðö`¥–+¿ò›Q­RJŽá¥ü[m¼À¡‘#ÆdmÍèТ“14Bºs1£»bXƒêTÁ%¼kÁ0ðÑ 0‘{1P”¹‰&ª™7·%ˆÏá/^g?}T²,¨1lÃØû­PWxêÃ?P*+3³£ÒJø&0¹I\4´Vyr˜,G3»Æ"X<™ÑDDdœÑÿ#ÆTzµAÀÄcµ}•"Q¢´ÀÑ¥.. ¶r\/PÇÜ»ð ¿aÁÿ€T÷`E~Üí2uîãRµ‚Ì;9*'Šb/üÈål¢p„ÛÇrQ¢'Š¥"!…'®ž^ÎÕ¢#ñÉ1¹Dû(é¨Ü*H"µ‚ÅYvÄFfdš8¹ŽÃÏô‘ú*G^žk"‰°‘iî„uYçÁËk oâT<¸6íØ_ÓÞÛwf‰„æ WªØ½#±„#p±8; ìqš(ÊNl¥›3'÷;)"3”;Ó6ªièy±-Kb˽ñCd}©"`0ä„<1;XX¹ÑdëÑmÌp@ÿ`yÝ»óð`ܽ‹ÁP—»#›üò¼žf7úò?ŽìØŽh¬7ý’œ çlÁŒ[œ@\c©Æ³íë¾î›ÄæÊÄOÜÄ6ªQ–Û»F"¾&½™ÓHÿzÖÓ5]³¶ ªíÌÝ¢"pÀ³áRdÕÖòpd{MÇ%Ð Ê=p%~C0À<à (nCÀ°}«cM\•7czR)No2±Èã ä! ʽÓ8ÝÓØÅw£øÃg~á»YAcìKßX¢U.H¡\Ú‡óœ;Å–ëx»æ‘nÕ*eеqšjË–×"Qb"@E¢31#<Â"UQO¸×ÿ°×Æ\Á ÉÍâ'N­`èÊM â)î»Ì{«Ö$WØÑ”È?Þ=¬Aäv ÜçmèŠ.É8¾@ý䢓q!:*äWž½IP€åÉu%ŒŠÿöPêêߎ:AÁ#g«¬µ¦ÚŽ ªé©ÆqŽCçýC¼páf5ÜíìÅLÇ@(>Óž­? ÀíÜ> ð)^Ç|¾Mh¢(ç$'„¼>bËŠéÆ§ÕN†Nï’< ¡ž„:6kpå•r!bd¢œÄ¬nš¸V¤m(uôÛIü-""Ž±Ê–už”¡Œ.¼Ài¾fñc<XI/êuQgÌ/ðÐ>íá‰þ Þ/ÿË}í îAð(ß[A·Ú=é;^U Þa·Ýðî!& o"É…~†ž­pµÙZ!jɨˆ¾!ÿå!A‚dÉUåa_ðµx8eÕQÝÄ$]rï*yûEÅ4tJ4T…M½Ã‘lŒ)áú3OVÀ ú@.%ð×ÇlÌCpÞŠÎíîÙaóƒÎBéØÔ«‚ñ×kiì¾>'žŸôë±Ü;MíˆW]ÔIØC û\ÁÙ&qXÊU>^­²åQ¶OüÄh¿QÕûeeÂH´É£O¶VÊ<-"á/éÁ çB÷³Ó¯PÐ7bcrÌ^Ì;ŸòØîø±íÛþ‘Ÿ í_¡â:ßÑþ>²uÃjêØÃPú!†Ñ¿­(D$ÿA‚! ­þE¸±àÆ¿?þY\@ГÅ & Að_ ù>ˆüg/¥ÊöT惙Ï^zöèÑ !RåÍ7]†˜Y3§J‚NþµçÄ^›¤N ¸(Õ¯©.<ü»z5^}òq—¯§†÷–Ü“'íG^” Qâm ZH•*BÞ©PþMàª^=Wx@xÁ‚…<‘ŒÑ.Y"’É“ÿ^ÆœYófÎ=ùðaàÁ!x|PxÐá‚ f\°á_Æ7ažyXb…‚`#h"ÿŠZë¨5Ü|ü€HY‡%öŸ áȘš”Ó¸ l²2K æ™VL1¿üGÌ%šØ6² O0† œXó+sç$O¬£æ4<¨Ú ² á PAÿüPûÞúï"‘M/”‰àê©ô…#îÁ€‡?E %(@U‹/ÖëTXn1[˜ç}(@„‚tœÍµ%ríC* ˆÈ»O1Åô“5H”å§I~^¬ ÕÐJÔr¹<öø„¤¿ŒŒ±%Zp2pÁ¥‡)'®. ŠÈÍzMv¿ÒÇÍ550¦‰šPËaùý3P‚ŒÈƒM úo@‹ Œ ƒ%ýÇ‚&àŸÀ|Þÿ¿8cÅÿKc N€œÛ0ÿ a† `¢Œdl­sþÙÍØ K¸á†ï+ôyØÒ¯„yJ€ Õ|~f&)]Zº©0[È!ón Š\<­cŠ'”oCù¤lJ¼®¶&‹ÛöÒŠïÞ;iP  R¼@À;ƒ>˜  ^”§ð/a`¼~Å—`Û&Ì:¡¹OÌ\¯<2@ÛüJt R[ꕃø a€ [£{˜ägúàÇœ`f)%«'ÔµD9 YKB'”ÚzÖCëX§jÍy¹ºâ®@l'hږЖªmÜëP€H,`€9ŸHêÿa)Âð€ë{Ã(DOÁ Þ²A2”E92Ûª…ÌD0"-“Eþ1˜©- ”Oå(¡P‰ùGhòQ’ nPh%J®$+q…¬:'xÜä„wÂááÐZÆ0žªÖ”%Á*ÓsYΆ6¥©E>Â×öÞ¨G È”2¢Þ—7‚`Šr9Â?äÇP~¢.¹¸Kuk^a$cB DhîÉÚȈ7~ÒmòÓ?r0(ùd`>ÄÀb0ƒbÚJ”s¥jýŽxØÁßá‰GJR)äéΚ2&³‰iiÁ€3C)’˜&ôQŽb”Á")” %$àÁ?ÖÇ©†Ñ§£" ÜߺL죙ÐD´Â¯‘È1 ¨ # bùÊJ‚èC{mo÷`„hœTnîÑ$bQ‰”R²œþý.LØa{d)ËxžPž‘¬ ¹Üåóä£yë “¬ó‚Õõ0P·…©¸w™E)ÿ”¡äKâCjÁ¸ÿ˜›a B]R&‹‘IÜ\5³†‰UW$"ÍV‡àW‡Ä(,5Ö?„Ñ¿<ó¶¤Ü‡ŒPS°ÀUM¢l7ÿפjoJD‰ßŠ„ˆ‚ ãÔ=bY¸ê>q•nfF…×+b籫TAZñƒˆ¤GÆŠàþQ1rÇÒüKMa(È£Uú€I|ùÚŤU¡Ér:¦Ð~¶=IÅa{¾D&I&%R1T¶¦_*§…al±ã'ÙaÝFø/¶pCÿ‘Dó=4}ÿý‡þ¶ºNÅ’1V„ß,fb 1Åš¹+J¸Å˜Y} @Ýý_u3â¶{€2I™é·D8Bd‡Aù’ºv¶ë ”Aø8àAŽ1î,­$•çïxÀ;_É$YØcæ…¡ŽX`bG9Ó˜¦rQŽ+C3C0¿‰äA@nE¶:;dpž².5º?A×o·œ©+…ì*xÙ¶Õ4¦üéø’­™%&ÑÍþG‡ÕºŸ™t–¿†zà&–„ÃzfB²žðP|™Ê_f ’+A†®Åè`‹Ðh2Kémç;È? AxÛô“~ò“½¥ùm‚jšÇ0c¢ä€Óî?Ílƒ“ ô¤JâjŽ–*È•0‹@¼È`<6«ž2oœÏÄû}î#Íy» ¦Üë­Wÿ“ˆ>ôMÊÎ(1.´7¥çèÀÿ§uL™»zjÅ ‚P‹0£³¸ëº *ŠŸDëê˜ÃÂ+øyÀ>A½jh¼´â‡J€VHHqC€ Øš²ó ÝÒ-ó¨Àñy€˜n"5‚øº‰‰”‚øŠ $ä88â ¸>¬À é)…³–ã3Nµ±ø8/b£9"d³0¯Z¶3«âR«Ä Øö?üœÉ€‹îy7]Ò¥ŠQÃŒj‰‘Cλ ³0:”€9hÛ@tˆ‚h7 øÖû JAR‰ÛJ³Ü#€yà:$3µJÿü)uù ¢(âHŠ”È ° }0©(Å®¸…#3µP‹N)”‚ÅÞË*9’©|ÑBSB¹9#«õû ÷C‘ˆ(gÈ?˜«? øÀ6¢{02œÊ°+ÉŸºB=ÌÀ«»¼šÃ£ÀÓÆÔäj1üCH«Âû@ñ@ ¸h ›kD«Û­Û‚ š¦}È)¡A²=ú‘á&¤¯Ìøˆ”¸ ~pDàXH^›°‘‰‹ ý2³>¿x‹ YŒ£6ÛžÄ:"Q%\ÔI™3’$ŒÀ³ÄS¼Ä+Fö©¶Ny ‚@À ¡IhT´ £êºÆù?‰ÑÉ ÿ¡ ì;´+F‹¶ù{€9süÅ×  ˜›òº·òrA#ˆ¦à›A'ùG°#5LœuKv‰M¤D} E@H„ 8ɹ[ŽÏ3±š¿Â: È;9¥Ý«ÌE’ãE”“‚1<x6SÌ .st¹ ¸Õ‘%µÐɺÂLÊÀ(`âÉÔsmŒŸÐÔ1‘pÀ$J5D‹€€ÕLr€×|¶ƒ©‚± » Äè¸K«ºÝsĬ"¿ôÚ‡{à7˜h’ù2Îã8n"Î,K‘xȇ$ˆR$¶Ä¬¹„¤%¤6ñƒ ”ð5äÈĶ„ò‹¥˜[¼Œk½.ÿDIâš(‰"Œ& ð³NAÃý;CɘÁ.ÏäÌQ¡I8l@OóÆjD@44:àÓàˆÏÄÃ;ÇtKÇÚt°9øÏËPAPsAÒJ|”D®+Îü¦9¹ ¯¤¼ € 8¸Ôw‰åÁ+köØ8¢ÔyE¿Ì—²ÞÒ›9õS?‘’䑨”\Ï•Œz¸—S˜†Q.üTÃÃJÆë M‘ZFk.mÌÆÊ3Mü,œˆ¦!@Ó!ðBØ4.h9ó± ºi…!¸Él˜!2¿£:ù?9Ò­>i®#N‘ùB%ˆù:¾9ÙG³,KJ4G%Bnò Îÿ¢KìÀíœ8Ú*Ýû*\L6²Z%‘Ì ¥K$pÒ•›¨ô)˜#5€M¼Î#/o$:m».€Ê¡/ñ?á™ìú?É£U Ðå¢"÷yÝ.¤”ÆCöŒÖ[:¸x´)©ãMÄ?›¢À1²#cB%µY2 òÇÙ¹Œæ ÖBHó¸UBz2¡´ ¶:?NáÔzëžÎøÀ¼°SÊ ’ì›'=˜'5+ÃÁQ+Ž~ü·ãÿû· B\Ô%ZÌø7¯øŠƒ#3ÈI¤l™¥z¡×ñÓÈ8 ²ÝdKGS*Ì’ËEV5É\ô›%[UÚ›À@ضR.øq.aÍ¥‰Å<]0q+²®9¬+ú(VÕ#ˆ»¸‹’¬â:Y”4 Ÿˆ%ë4›âû1ªõD±0Dn:Èž5K‘PNü‹‚$H: |ZžŽI¤u"¡(,¬,”í¤EÃS?U¨¿ Ÿ”óWÌp¨®MÒ®ý $8Lá:RÐ3…¥a S,…Û\¥XÍ;›-K´šlˆÛ\šÉ¥ `†ÑÑ›¾uˆ:ûÛØ@%’P‚¨±V0ÿðM<ÝÍÄÂJÛ{@­€@-9ITu9HE5TÏø ‚Ì£Šð’iѯæøˆ£øÈ ¼SÜy#"P”ÃDÌ93Ÿ}« óE¾ŒÂT¢$E˜!ÌÈ¿ t®ZÝOXs1‚p±MÚOÛÍÛŸg<À à^.¼¢%”P·‚˜Ý×X7ýEJéÚñ÷A‰šÊ4@ù0i’Bõò“ èVË;ûŸ°D2EUN‘aT”H ­‰Kæ])Ë®1ê˜fº©úh˜&ˆ â9"U‚q?âú[‚Í`ÝíE•{?•ËE“„àÁ‚¬Êº»Ã¦Š[³ù,žÍhÄ®ŠM=˘á{ÿp+VX"VÕì% |½$˜ALc¼³¢{²öe ù¦È¾ÚÇ®Ë S³Á*öGMQ‘Š(@]Bç;;‚È`Æ’Ç‹ ‚è8ªµ!Â)6F"½ÉÝÆ<€hvL(¼ÍÈÝà IáŠ` X/›}@˘ØW“åýz‘:a+MÞ>Cë}¼_^ü5˜K«!]ó9Ò‚]¢Ož3QÖ³QîóËּè>ÁG ×ËÅÄæ¤D¯œ““8‰Ÿ œå[çȔВCÌÎñðsŸ±¼ÓHÀ(Ÿ}`UIÅ„ã÷;Ò’,˜‡zi¾Y?€•hû‡LÓ?*ÿÊ!01äÉ žv¢§1Í|ؼb@C‹GIäŠÁ¿;ê›×»‹T¸ !­³ôA‚Q·» €ÀHÜMºv êK%þPˆ 8J,Ô¯C ²TѦô ‚¥ `Ž a»ÔÎlMX| Ö•]ò¬Né¿•(i†ã²Â°Ë¨æjþ×ÀS £¢ šÍ¦'u¦vú/‘¥Î^gɨ®Ïä?TÍqtúÐÊårŸÀíjF™]:ÞêKqŸ!r @Îi$ÖËe†:Í:~û€ bQç<ׯy‘¯É#“È# ü‰çp_®nOœ‡¶¸ýˆÂlÍË[ãª4é 6Lïÿ ârl$Ýg N^|?Iy º‡¹zêÎ鈾ê@aæåÌš¤É: ÕDÐhm&¿ Ø— ð›$ I:+¯FÉXJæÑìQB©G¼OƒþÓ  ‡¸™Zÿ‹Ím<‰œðÄæ³k릵‡ìž%CÁñ Oz5fòog;=»c”0†’”‚fj.¼;¾f­VU {=Wp€ g÷1:Æ(g3“åhåQ¸àIdùaF¨Ã[Æ&ÄàK*wíù€ _ÚUKáêË K9€íLcSâŽ3h!ª>ÑÊ{µ#ûÊæˆX.TçÜ[~:)Q2ÿJ惖å  hñÕ©#ÒÑN’¨Œ´#¾Te‚ѳQÿd† G _øUG²E¹ó^iÂÅà°eÕ˜†i­>Ò>î£jtŽŽhèðr.ï‰rF^ÿ(£ #‰•ÊÖõœa¹ ‚]?òqÊÙÜÛ¡Sôý KÎÔ;ͪ¬"¨ö­—#ˆ8åFÔ -Tätn±S¾ÿ-H P¥ÕaBFP°ÒTÁ©£ì½À‰#ƒAd@u‚p_Ð3`p€8õf­° õ Wã]¹&ÇŒ–Jö)t¾Žæ˜Ž6€ŽåÝTäòÜ1ö é¹^×%…%…@ó4¦òjr M YîÿƒÒ:wpÇŒÕEF}é5vâyØ) ¸\Í Dý‹B½â†V‰©nÊÁÄ绉@‚a‡‰ ñ‹¥Þ6ã€çð‡Zø€ÃzXø0ì0jF‰V\‚@K…Qz´®Œç@÷3[h¨¾6h”¯šu9 /?üëjB¦§, ¨©ÞºzÊÉ…zØ"Æ;©‹ä2u Fñç½5%À|÷aßÞÓK‚?û Ö=Ÿ‡ 8î$³ÜïÙiîC- ‘hz½e-¶‡(Àw²ô™˜‡úzXÄóÕi{Í´× €{_Ìè°zU÷0dPã¨K&âÜý×Á@Õƒÿ¡)ããæp‚¼¾£€“7ùÅÿ¬™XìJ¼BÓE_€À ðÁ?ÿþeÀðâzCZøgáà?ˆ‡$ ð/Á? C`8˜ãÿxpDà? GþÉACŽ#MÂ,ÁèC> <óéËÇO¿Eõý—QÑ JŸ-š/ŸRªù PüâŸ={!èÑóúÁÞTªNÈ;¢vm ŠM†\ 3eM_ÈÞÍzð@Þƒ¨—Õ` P$ŒaÁsÔù_½É‚$2„Gˆ­ÿœÐíäóèÏ\§:É7:н(N\ƒm!»½Q¦v–—ƒ€ -xðÿзùq1d0R“ä àÿ‘ :ÅÈ "¬gøÜ™%[™I æcš8¦<žò}¨ é|¢Hÿ9Õ生ýôóCà?p¥•WÿÐs=cÁ÷Aó¤µÖ%PøØxŽ©ÓI9Ô´—^‚hÀÿüµ×ˆYH"2Ô2ˆ]–݇™ýÁV!”6h¦måZ>·EQ@·ýèš ÕFd}!´ÀÁA`ðÛA<üóBĵô@%ô‚ ý3Ä‹ dtP+¹‚A „RKÝÑ$y9’c2ýSÂ<ñÁWÖ?õÉwßö uP~R5ÕSQE–Wö$‚Xÿdø„.É•¡…%­äw¾è ^z!“âˆÈ㢨}ýs—ŒòXK½(c‚ c=®@€ h¡…vd‚® d‘ù¸O.EéDS͇HP:‰Ð dÄ?A„Æ”˜•õTVQD­L×tE4Džæàiœ%¡SI4Ù;kM.íéžDý™O 0EßPÒ…”SVA%T£ðX›=JÊW–²pÏLjÉ)×qމ÷¨“Õ*™Œ†m—XV"n‡˜_0nTnV–‘|PfHàYÿkE?"•‹>BÏçÂ|Ë9ä|+ ò"ˆ| ›A¼àP˜ÿ æŠ+$¼n¸S 5'˜˜EGÑd‚ ÑGeÉ]\oº=SMtÖ$uOØžë­Sú!ü<ÍÔÓFÙG_U~R¥ ¤_uf ¥íå¹’wq• mK!ÍäJ9!ù ÿ,éÿÿ H° ÁƒkLUðG«­"Þ @C Y´Há†ÇV7"¶Š ЂÀ?LôxcÄ~üâÅ,@³@<ñh2¸´AÈ?JþYÀg¡ÁQFGáû·Ô¨Ó§P£JJ•ê „,®ž(q•EÕ¯ÿ~üP(0ÕÒZ?þy¤hèŸÆŒ†*H¨€Hc… ëZTËòÆ‚*ûÞ`ðoD{Œb ŽÁX…½œö Ø+àÁ“ 6X:t(S¨JC7ˆ ¬éÓS £F}U`×YYxm½ú騴£ñ¥ýG‘B]Œˆææ«ð¡øâÅóý;ÎO¿ úòRàëq ƒ 3Úc#zŠ ðÿûgO… ôÄ‹ ¬yiЂï "Ň´þ?\øð×Þ¿ŸA‡ÿñ÷Tl'ÀCV­eUÂ^y% Sgý ›@Ýea>ÅÙó†ö§!y†ørùð3Üxü|ÀK `Æ€aÐó=ŒÌøÏ<äƒ"¸ö?¸´PB5ÔR£4}ùÉ'RFUª %B°ýÓÚk,xeRcôCGqÝ•á†öÐh£ŒuØ¡‡öÄ)§=0‰(çwÞ1òÁŒóxGãˆxtXz.ýÈPî ”èg-5J}I2UÚ—”äI‹àA¥ÿd5l ‚ê©V•BIЄc"Q&?“Öaw¨ÿ=ˆuH+yÑD^“ñS@ ž ϰö)ãwÈþȈ¨dÈŠÈušùÏ‘ŒŽ†_iKMªß©œRÊ€'ªÆi–Ÿ.aÿÄ %m`Í×hXŠ ”–GÝõO‡ý#«œ Aœâ ¤®þÖôO< Ûİ¿'ܳ„<ßC¬–7’ççrPð—@üÜðÏ l†äg‹"ô¨£ÝdE¸¦éñO p Dyà‡<=V'T °Ÿ§ëÛ)©¢†$”IÖ‚¤XÔå[Aû>ÖáyþÒK¼LPÐt“tàñà ÄÂÄêþÃó }vwëžÓQ ] DÿÐS‘$iAM)Å-Ì”zŠT90y(H<ö(!±¶s•#ȃ‘ÇñFˆ)! ñ»|ÀA¨ü*å= –iyˆ5©€<ÌÚ<¶ÿÏ}Þ(ŸWá™@ ‘Þe>) ᘟ4ð æ€Ê"¨IѪtç¢SÁG-²É̉å!AD'' ˜ä£CšÇnà7ì “ò8BÓy„@IÓÁæ8KÌsŸÓ@h¤‚yPP}©˜Ü¼‚fyŒ€K1 ’âó7„$šÍêjjöH]OpºÉZ¾~¸hÈ€§–/²à'œ©:‚yH€ƒ`ŸÌçKxé2ˆp×>Á£>ðØƒ—g4ã?˜å$ n ,UÜ¡ÕÊò‡‚ɦh0øU-¦% #èF§ÂðƒYæÁˆ·žP¦),ˆ2pÿHÀ7˜@œèa ó cuüÁÓ.zìV²Ý”õ£âý#™ %ˆO’LI%²Ÿ°¬v© £BE£õê詈"“hÐ/¬ØùëŒ`µ­…ëQ™N‚䀳=¸(ji t<-yÄß·ò; ‚2ʃüÈLOˆb¼¦ ³IMdJ˶Ëᩜ³Fi Y”¤QÝh1ÅLÉhË6ÒÉ@„°àJc¢Ð Pg]‡à» lHÀµô©–úÏõÍŠVÉɇ’3v‚»ê©Y(Ê2Ýé2³ VÎ>ŠØá©p¢ ŽJ9{=¦ìFaÙô§ÞR†ÿ0ô0á ç+Ť¾/¸-E$§ ,zùâ¬v¹KXj¨D0rÚ)hĸY‹²†§üĦ”f[MÌp—©òåi:£5² }˜â4GAiž½–%F‹#6´É채{Àu¦r«@À‚è—Ç x–=‚ k€Ç]÷4Oš–«=ñ#;ÒÇpq !ˆ, àP¤ Y!èçp‘°¤î°i©PšÝ ³¨±gE}–˜~p˜†6 % ÓHT–à¶½;©.wxï:FN˱㆔,íˆà+ØP€ˆÒ­Í%Ѱ• riãMêv(7Tl7Å<u}CÿýêW7*â' äQÙ³€£ÛŠàWK¨£ßÂâ¡‚ZÓ÷½&*ïôtf@¿†hòAÜ{¿ Wzá@Ü9"è¤ Xí?v„!F›Ù t¿-ÒXu[–˜&ÉM†@@ò;Š™\ör³²SúÈ@†0”2s óæ÷•‡ŠNŠ5(0¬ç(ìuŽÿ!~£Q×hü¿o  —‰SAt§»•"aFPqiHEÒÙ{Gv‘ „ >@¬QØàÜ QjœÐ"GÜž)ŠÝÜ£pŒ2KH(×ÛÀîѸyð#.Ô!€&è,^Võ^ÒôE]–2…6Ri `€8à,`€Yð`{-‚)ÿ¢ð`€#àY·Y Y˜p|è€ÿ ¡ÿ`ˆzzÀq€"#à‡yypJ yr‚BC{‘ðA‰Ñ!-dŠôpw%/ÙtwOR@?@‚0p_GðAÁÒtdƒþâsNôÕƒÑx'P…øn¢+JH(b"0Á "°u.…ÕÈ+O‡!ròÒFͤ$¤‘iÎT/—†<ƒƒä 7À #ð×Pˆ3F"Ó"-±7Pý8÷p;â7à à@ À+ðp#À~ÿÐ"þȇ¡×‡[wm.ñ‡15ö05®¢,´Âíа&#S+þ%%ˆA¢¦E­ðžñˆà‚rsêÿródoÀ¸6v¦}C'GéC?D8a“:¥S"¼’à”ù0"PVò”NÉðè”Æ…dOt!~S†tŽLC_xeIRÃ#ž°m™3Ñ¢'‘˜a†± VqIèp L8¹Ù"Vb¹zz|H‘7ðpgˆ&-Åq…Tã&ˆ19öÀ›©‰Á\Ê‚Š*7jL‚9µ e¨æEb¼c,·?‚>„kCÆ0gak7Ökò]³+ÎH5m2'qrRš§dñp¼B+NÙ5ðtR!°'àølhUŠ4/à’Ž‹ô\e)áVÿR‡— Ð!"C•/RArRŸˆPR ç–…é" ~·ìÇ~×HŸÉ~þ¸¤W¬²!ß75äQ#›é. Ø™°æ.Oç_£Af¡žõ2§9p¸G²!0ýä.±ro;7>çÃ3¼–BÃâ`,0?¼²/ #:è‡pá”ñJè1'0èá͹+{B"ÐH~óÕEàÆ…×!—åâ"ì÷‡`ZPZØX…Q0Qzy z¡·u×ÈŸÙWRÇg{üPy”y…'å*q º™›i#µšÊÒnN‚&!“ä5Û6‹½csp_ÿS àqO³¢nD52QC41ûS7q¾ûÂ0ù/Ä+Ä •¡ƒ~U³CçcoP€O- 0*à÷t~¨:;Ò7Às2Mj–NDe\ø…Ý9mÙŽOúoÊSÚ" çz@ J  ùTéÔ~„±œü Ò82€Q#ó`z° A TI¦/Á‡+  ýHz0Á!’"W¨yÄuŠ ¨6êVfØnºAa“ê77СÐ8­¶?ö6÷t“Ñ!‰ö#)B'Ïñy/¡0 ô—6%"ª0±5"@­ô—ª2r- .C'ÐM0D÷”OÍU¤Pv$>±z 5ŽOÿt³L¡€q)a%#ã"u€‘ÿ@Q ¥A2‡„ú`•##‘ó€¡Z‘¡Ç¦ .1™±vúA©mk!#¤i‚&!ƒÚæ7a'€;”rÃWꓜû"ˆf%,¢> ?â0¬#%µ)ŠV:ˆ+°)" ª}†OçS9äs†qúl–«9û½ú¹X]F±qn ­rÙë([û˜PAï9lÚ"¼`"OéBù°~ÕHµAdºu+µëÊ:óºp¹!†u¯’s0Šá™ˆAä˜$Zb±ä€q†0°Åx±9,qÿc͈"šò>{6rèN[OI8 ç+:»U>æ7+ô%»M,ëótú°#™!Ž …Žºú\ÖµaTe»ê <[í÷˜ª{qhÚ‡# Aì$Vs8¸ÈéBsÉN‘­ñéÚŠÂÿE 7h!Â/?b§wº{Ò #„+ßaG$62)š†º16Ù8‰51À$FE72b›ÅIÊHñ±eê+—¹[汕è'M'ça¿q78©Bêòª»äBš›u-Y’•¤é()¢‹³Ñ–˜r6Pq;â(…Âçf\ÀÁÚú#š 7*#ÿÐÂN¡ñzŽ›—›Òqj Ïñü2äQº…’·°ò¼Fx*(HÁRu7[Œ S÷僦¾¤’l;„lôt="£C*:îë!30¢ª(«^øDh铲á{BM 1MÀ6*ôªZ2Dà(Ù1¢gÿtFµ7#òP²7B%r¦í1aÉ´ÍóÒŒòqS…¶×Û­×F;‡V"¸ù°ÏÑÎ4A'4‘0àD`ÕFQ Z$\š)(\'ˆfR)‚É MãÑ‘üÂ95ÇaÒû·¶€A&€ñÀs4%p‹ ›i$x4¹=‚å{ÒW¸& K6N0O)•&22Oú«.l#Ël1M@1ž}- Óm3#éç@qHœŽž{8fgv£<À“Ê-¡)ð*±#† ¹×\ ÖÁ•½+W/²"ПVò!<± ]×É/‰–Sc×?r Åw u¼ÿ!a«ÌžÄ?øŒšÓ÷K1k÷aÞÕ{!~€…O-ýÞK–&>…²mÓÌž½Ù$Ûß1Ý;°ô0"—R…ÍV6]_˜PŠ’eà¢ÔIz{© C‰vÐòZ»ÇξR„”r‚›‘ @ÖRœÎã±'ù' –ì+y"‚û{_¥Ü#2†ÐÙ_ãBHLWµS ’Ó‹ëò.AäM„Ù)OÑÒ͈~TsRÈéS¥m>%Ûß°tå´OïÒë£"Ô¼« Y˜£³H}eÀ“*á|h{çÝÛ†Vëú.§"ÐðùàH~œ{‚GY¬<ÜÂÀ–†À'ƒh{;BzijÎr>²êgçñY¯2'0ÿ$¾-êGz?•YøB–ø—]û»òÁ$á¡,µæôît+ƒÝx± L|EhCÔOxdB!_5¿Äâê|ÅÃÒֻר&Z¾ëùÀ„úàÖhE`Òæßˆ!ÔÌÚžëú×-’Å«AÛŠi{Œ( f’"ýâ&ÉâÝÆÖþ%[L+¾ðûlì["*2xè·êÊa¾™ù‰2¥îÞí1A!Z†Íã°Œ§Núƒ>°>e\5Ò%dkY¯ïÞxàïÄÙöËñ&³^öúöË]+@üáÒfÔ©#+« •¤UgÉà´ítÕš;fB"hÿ¢ypGÓ~Ýp äŸá"Æ6N(B#²"ùi"ñ—"'…&¬bÈš¿ùVEôma~nL8Á‚…< üc˜ƒÀ‘%,þˆÁpâ¿yóTüc¤‚Þ¼'äÉûwïȽ$å¡TI2å=”›œøGÏâ?{ùòñ㧯gN†öô ÁpÅ UÿЬøÇ´è?}:ÿ}ȇh!Bð1ò¯+C\ ñáÚÊU¬Å ÿ6¬½ÁàÆpU@ô‘Ï ôò³gïƒ=F7j˜Gàæaĉ/fl1¤†¾âˆ\•çNÌ|§ø€óO~#Dmq”Å­?"´ºaÈ…nT˜wPÞÿ…9rì[HàžAšÿÅ 8/Æ<{ô,èòß’'G2Œ “úay'Zœ°ù/Äáœùô†Ð©‘¤ªTù`O‰}Ò#DðC”Þ}7|lЊß×±n ëŸÓþ K«µ"XÀ-ѹD ±« Åû §¾£§"ÂN¡1C‘!èNÐ@{(£§¯| àG§óÉé¯Î>('žD ´ÑþÙª¬Q,ø \»aa¤„ÛNÒÍ"#þy("І£È&›KŽ8‰ û‡…˜VbÈ9‹b³‰%äiáŸíè á»|¾‹Â¯©ÊÓ½| dO>-òá¨D˜/ŠòYaµøûÿÏÇôq”þ|$°¬­ÖZð-ASDø‘ ‚|òªÀ¯ ‹aC†ˆ£iDV[µ(‹–Ð`VZYŒQ'ª8+”Ô¿v¢ÇÒ*ð4|~h…È×b›­6yÀ$ r0bŸ `¤ìÒàTFúª‘#æ$rɤ1Í,S¥1ÅÜŽ¡y²ÌÇ"í4ïÐ=ºä‹êµ¨¢ÊÉ*þÄÒª«²ÄÑ‚ÉbhƒÜj Bˆ)5/5dˆžîPeÈW;fu M|ìS”1{Pönª^sm´GˆOfIÅúádoøa–œ·hˆÖÚk³ #ã”óV°Œhéž‘ cé&3ÉTÿº2ªé¾w-êëóVx… .)»+ 콄’|P…†Ä« Q‚½*ë«›2ï…aSú äg⊓SaF6d${†#ÑcÈùžO0æ±3ì cÎi”ñ/ž|§Ïâ§@I‡,òŸ#gcä #¤|öÞrò£ÙÝvC”l hb!M‰J:É˕ƕ§ çÖÅc”©êz(‹Â>jÏK„È~{í˶h–Š ?º…P4Ò‚óîo+…VË-Í« ÔÎHedñŒ«¨ñã¶üÿÄ@ : [Âå£Ì%ç#ñ–=øbPùÊEäÇ%5ŠÔ‹!Xëhóÿ4ÜØNh¶ËÔXœ$-q©ÊH¸Gµ2YjPc^J´Ó.èIï]Ô³H¦Ž=aE{BHÛMØÖ¶¶- üˆBgVm¥?›°À‚µ$ˆëÔ]* )ðÌãÑ:$¦‘€09Á,çFeÎ#˜wrBPeˆ*6úÇÞE™ÆÆXE2Ä[’ôºÛȃ³Û‡n¬u„U/qÉÑÐq’U O“^JLò,B’¶+zå õêr<é‰lÚûV,ÂJ!PbmYÄ£Pb}‘ŠÔa~„˜D]Jpè ¨ÂØ—å“G[fÓ8Œ’À¤rpD G0¦’ÿ´€0Þ’Q†VDœü¥qã,±08$†8ˆ!xJBX­›à®(TNl’ÌÈ#"ÄC^òPòÏÃ0/[¢ UÀ¡@¡O¹dÛ½‚/®dÏ^`[½lY¨'L1Z ‹£jV¶<¨Sȇøñ~\¬[‰ûHHàH“U LÎì˜o–@9i¶1d³¢‡ ‚§S7ÖDs[R™g†Šš©Yêàæq›’(„v¶³™bà;À guœÎMHrÓN–Ä“ë¥_†rJAÝ©(GaŠ*½’V>”!iãÞ%Òb”ú䇋R棽¡ŽgsÑKa÷(ÎIÖäTù j¬H"MVé€ÿ!0‘ž Y‹`6³Q…Ig)G@‘ÑcVGÓ§—2·¢%Ž([‘Q'|`HÿH–]^‡».DF°šu‘Œì'dÄ'9y›êS¬Ï©cÖ>rü˜§(èažT±€Wøˆf“kWð…•ì¥-mGL‹õ®ŒÚm`ª>øš¶ö(,©.ƒS$üDŒg¥yÃ,’²‹&LÀ˜pÁ%¹ 8pà,Ø"Ž u:ÍQSd˜LtzŠ"(KÝRΆP…F† ÒºÁ?>5)mQî¾t•âóKQ3É Ww¦dLiZÓqXÐ|È­LÿYrÛÚ3W‰Zä¨+Þb¹¶Kø`¶üÀº‚‹® l§é¨¤(…š ðŒB…]m·Je1VŸÃÓ§>;ë<XÀ.ð"Éç?øÁ´”m† º$þ§M+¼Ñ6D!ûE«‘vJ[Z`E¶j³ÖØå-sa„In#Õ…@ ScH$1’âqÒ:b…ZòÐ%ér® Ñ…zn@Ýtð×­¨,‹øPºÒµ•Ëž¥÷ ªï<±n´[l¿r°ƒ1,Iòý‹Ò¼sªþY„Îiª3uÄ`CCÑx¶Îº#¬h† ZÐ i°ž¥$%ÂDŸm| ðV%V7VÀñÿæV¨šOX[‰@Î4‚œDv"„V O»þ›!%°ÍH†g’%Ø8%.©óÑ=¿$¹×€ºIµü †Ñ^Þ+"xËv6³õ ‰ž@Dèˆó-Š£:3–æÙPŒ¾ˆËˆÆèØê爫Î`%žç˜<£›Ð†t¢MA›iÀ‹°4Ak¢ÑÞ”%nœH ý<Œ‘Ø[%LÝcû?g#h§I¢Û† šr'ÄÈDj3r‡ü9úĶbÓ¬ÉIV2-5lð½\Ø7¹9çÿ¡K³A´^åe/B0| *1§AÝbð!¼L@ö!HæGâ«6.^¦”cð½ÿ a>[ëÁ>ôØõÜu>7ØÂV7Ø cö—úûŸ()‘.ÔL›Xû•6ÁžÏÃ}°  ãŠEù%ÉÃ_ú˜‹ ¼Ÿ‚5LÚ¤IÁªI4s0{ 7à4\0c¾d0“Aä»7û*~㤔(Å̾ âø4¼+’ù¢©‰{ – 0µ‘€)ãð´­Z•–˜³1™Âc—yðÂ΀ „z &K§Äø4ü¼4Ìñ=¶Ùˆb=Ї«p¯º‚ùoÌCˆ¤ÓÀÄiš6—rŽÇŠ&Kôºà³FdD{k>Cƒ!˜>J´°zû=>ƒ·› /»4éÄÊ™v±¦ã(¼Á †Y¼“ßš(qˆ‘ŽÿÂ+ÇSŒµ/‘µ:c8ˆ¬ñŽñø 8+ à€•,ÃÄ@ asó²—|aF>ae×Yb"ȇyøJP”›À ‹‹F©·  ŒåHLj@O*0ÓÄ{C´á“Ç>?ÛJ|ëʨ·ãSŒ{@0ÿ J4)9Q®—" ãHŽºÓ–yˆ-Õpùù"{`#À£· xl ‰¤Éªpq?‘(ž•ˆ_Ô’dˆ¯¡ýÛ?Zâ?þS…þ[-“IfLŒ# ½z‘¥™œC}pÀiãÆØR­( ²©¼¸Ÿ¦”³9#7Þ³°©DŒ”?ÓÊ­ÔJßÛÇäûGÚô¯ÿ²”ÊYÈ©û*êã@䨭‰™+d1 q±xPˆŠôé8¡­R­ãè@Âë´!WÛ5}8I„ZÉ”l 2œLÅø?˜Ì®`ÓÌĸ9ÏôfD„.³€óAͼ1Êša‹Áù‹«"#rë°á²qñ,xÓ:wËMÓ3?‹°ÚôGªY4‘´éΛR;á¼³’è0t«ZÃ$Ý–­*–Õq±È‹êœÈ¿û‡ØË¨a—ãð4f*›)*Ñ7É@}0ó `k ÷lOÄH ¤`ˆì’̈€™D 6ü‡µ16|¡¨À%¬øH1+ú¨Õ„‹¼`JzÀ$;Ó·Ëÿ?stc·L>Oü‡&ÈP  ;Å)€\#õP²\¼Ãø//Ì52u¯!q u±§Âì$ãNÁ¼‰åøN÷CÇ ¼OC2"­ –«»(C(½ ˤ¥ëzìr¹WÒ)5¢ÎœF-;”¬°"Fql͸ªA ¹ÎZË4iG C7€ øó âô,ĸә˜m²œJ;4™hÝSÊAœêUÒ“ ½ABMQ9ÅVJÔuzÑJKLE€X¬1y#`¿×Ò/_Ä–3!îÜT½P¹ ²ˆ[ºPR÷\ÒýsaÃ.'«=¹ ´R¤„Ð¥ñR¾Š­ô‘K!Óÿß1PCÔ7!»ŽYkG€ÚPs»ÖÎ’´;e“YiÑB hZiË ží‰iíÐÉ-1 Nl£Ÿ‰­BQ†À © pѹ’pDr—¨û’1.™s‘#ã/̇óT–TR–DR~ Õ—$UüT…PÆ•¹Vâ®Í¼ Šê¯è¥WšØ÷¹}Í6JSßз‹dVKô¯ëÅ‘…,˜4:eíÐ&ÎÉ’‹A K ž•Õ€íØS_Í=Oò¯Àì71Å‹(–VPÔ¼`§šŽsí ¾µ0—€x×ó8Á .7©‘³C~ýZ$Ã|ýÔ—T'kX=9ØÿV•2ï‘F„E‹iƒ ’¢¢L¤;)ÀøÎ}: vë,•˜M!c‰ìÐ óÕ}£ÖÏÒS Míˆ#Œq{p‚h‘1_ö±k’\h¥\ly‰áHLjŸýV:ºéü ¨‘F=©êJÃÀ€ëh–§m?!Ó¤„ËÈ{ºW @„®å?5 §pÉÅO÷`›ƒE[ÎÓIitÃÄðF\øÒÖ+÷b‹ÖÔÕqS»­,»œ_Å;.ù Ü™uÊ›¥Ü%XÎ9_{ˆ‚ô-øˆ—[qáøÅA_½©Œµ‘˜Ù!|]­áßubʼn/éK‹P4zÃ8ÃKHXñc†X-¿è ÿº`O¦èÚ î¡@1C†À<é ÷@¢;^W5¢´ ›<\¯­8á0Í"ºÕÀçåQ^½³4µ‚ˆØYËçȽçtÌŽv) jbiíPYzp$†"~—§ð8娀ôUbhª:Ó·á ZäŽ3B5 Àå©hEM:׆ÐÄç‹ÔK`3vÚ_dˆïhœ à¡ÚÕ¿­¶–lŠ#µÞýÏÍ‹9›DCóêföø]öè (ò‘õj¼AaØcÊÅ5<= ᔸUÌ—æ‘áÀ3Ý0Lj _mÒ&œp‚(Ð !>e^‚æ…86h…>ååkš\zå'†åÿ”¸aÊQ × OÝÚX¼‰35§ÅQ›§‰˜§ÒT«í ôÄ] ¶]êz ôè×8þžëÒ²`;Õ™”Ï)ÍLùÄ`j< Y´ù0#ç+òÒ³`‹|H&s,™ 91‘WCÇûýA‹°¦KÃß½4jVzPÜò¥?â!®®"Xë}Yk·.hЇ 6_™í0'Æ)C|¬5C½¦åHÅ¢ÎÍ⌓ÝÛ±0ˆ¥b.¼à¸Lr¿öëŒ!µ }0Ò@1Ò ¾‰µRŒ?¹.õ ئ¸æÿkŠWPTý“£Ÿa; ~‰Š‚Ú¿‡å(Ja=¼‰ý¼$ààQ©¹ÿù=žÅŽˆõ«´SÁ ð9oJ™¡ò¦ÅuÜårx衵Ào@†(UXk¸N²˜“ŸâÞ⪵_âl¢ Â8’ èß/zѹ£ZEª8ÞJ?‘CljÀíÑV;!”Þ5“B«1LÉéb9ÍNI§€Ra3/ÉD ˜d²&e¹ÒÞ?~”8q“­:j! ‹^Ð…[ ýlƒh–}JK’ Gî×Ån*ª #î&Aâ²Î‡"NëêBè9þæ{ñX½nî6è¸þaÑ »ž:æªèó٦ô­jöv1µ[_æ ¥½‰‚ÛÓšæÀ–ƒ8ÃCfüèÔ_O1¤Lÿþ{ŠÉg«Ö¾](-‚ì”~‰ 7ùˆ0ê»QÞ23 ´XD阡Oœ__¿SY¹é¯I)ŸøŒÌˆ—ô…‘!b…¶„¶n÷ñ{éôw›µò¨ð‚ä·l™7ʦîÛ\›À_qï1™Ý ¡ç;‚â)nv9š÷û åNïÈ@b¬‹t*ŠWRÝe øX+9—曞®gO+hØ8½Ї˜U¥fjn|”T º]Û𬋋šÆ+ ª­×o Ò†@ëž(%pww‡ ·ˆx h¥pk¥¸‰oæt»êt+õ õô-r8âkšh5É„³ CÅßÿÃáßOY³2e¿‚PjAlس†øÃ9rAŒvåªÈåêÂl#õT&SóÉtùÃØ?A™y:ŸùZ‚ö@‰Š(kN~“k_¬˜ØÁ fÛCâ½ì±C.Åñõû¦xI©ˆ}ˆk~p”J) bGŸz¨˜z…nv·Öî9Ïî^`O¢i„¨,{"à…"NŽÉå·ñµ\†×Žb®;4j8éü¢¼¦Ü±{€–@ÅJn5ë*¯Š à˜piùÁ]»pf¢æl•LŒé”š/Š_Hèzï|ôxŠ¡ð9†ïyÊË¥÷R¯Z Õ\Ùàq¿©¤·÷#7¬~Ë\Ù ŸˆŠÿªŸî´¾úž ¬w¢Ð¸F豯î%•s÷ô„EXou[*€"¿[‘‰5A\6iº5ÉŸ¦«ˆD•Ïƹä’ |[WÐí´!QÌŒŽÇ“‡­*(wG(ÇUÇüéº T}ÿDè+hPà¿„ÿVüX0_ˆòZ´ "_AD7( ¢ð>C&$ùoÆ7ø1ŠÁ‚…¼%GäͼwD¦<˜òNÌcDÏž½|BóñÓÇx“ês¡ R.¦º1—ˆ"¼ŠpíªJÕ?°ªzùZÄÇ%´—„¬]ûïÒÛ }Ðá"½¼'N,9±óD‹ éý›GoÞ< óxÿòœƒp †$ðCT¡Â ŒüG Ç¿}þå Oá’©ÿ±ø(ïô?y÷^ÇÎYøß‡†Y]È›‚> "Vô¸‚áG 6<ÈÜaÂç :Jb‹„…&\`A>’øÀÿ%dTHãE¢L‰èCŒ,–ؼWÿõiüñ4ÏTüTõQ9u ]¼üƒUW]…%VB_ÑEWZ—h¸á†')äÃ\ ú U>„@Ï^~¥¸W^‡¦Aa‰%ö †ÅÙd†ðSÁŽÐÃb¬ð™9€F@}±%$Ÿ`ÁôÑLG(dH€"ÿ'" ­Ð¥\"d‰ÿ¥AÿBþEñAö„Å›ÜÉUT–]^ÛE·Â’x "I¤t"öÄ “}GØwjµåÄSÿñSTQJ‰pV Ùu”>ZÅ‹ E!X ‚ÕK…ÿôb†²¥a\ y¢PZÿø@j›×íõW`<ý£× ‡Ý–¢ô´B\¦¢ÿì•Ð %J6Y˜°A¶ö£J²6Ï?i^9foYþƒå—_zÊ[Aþ¡éb óTd/E×µøfr*$Љ×݆f>Úé³@G€’g’\"%´ÁI)PKŽ>z„”§éD©DàRÿHµiU#+g•X•šrB§rõÿOaÉŪˆªÅa\h%t‰'"ÂÌKQèÕ½˜´y-vŒÒ&4O7"bȺ˜afOäÊçÙ?Faä?Hêw[Ò²Àד°Á„ع郥Bî"§» !¢h¢‰¯Ñö51Û=ML„]ž7l'vÃZdOBèãCG'1,’I&y”¡ $:ßÅöá§Ÿa•^jTA&ü3B©žšr¤"U\̱£ZÌ`ɼê…hݼ­ºæºó‡EØU€^1½¶°-»´`ûÖ Õ—U€Û?ŒÇƒÙ÷äPähE0Ó’K c%ÈG­´ˆ¥ÙÜQðnp"¼ÿ6Þ¹„`˜½ŸÛÿ6ûû-O–ˆ D!ˆ£ÍDŠU/zäc(±¡>r¹’È% @#e±ïÅ&0áØ>V‘ ÄžbrÙ\àä3åf:ÿ€“DîÁ`‘€›È ½S’ F°a Y@æAŸÎÙ$'K8›c:f”LÄ„ú0¡)=À ¬œŒ•Wñ”ð"ÃØÁ¬ÿv®ÒUu–!õL- z‹ÎLÅ }ô EK@^L’¸Gã æ4,ÒûªH= üãzŒg`mŽ&Œ ”ÙXóIÛ$ä5'(A¹p“-‰É!ÂYWp Ü/;/(Ì (ò|êq™MpM “Œ°\×Q$#0Hé“0ÿ „Ã&gI…b@D dc±F͆I”ʇøAÒ ¨)3Y [¸•Þhf,¥eÌ,i!›Ñ .6ýÝGxØ3­èÃDôЊˆ–¢ÀUIÈCV4ð>C<+7¨€›€äyXkɲå9qyòI”Ç<èé¸ÝXE]wKȘ’·AB€ÿÀ_^b¬yL€§DðD0Œ D90ZB²…$Â…€nÞYÏD)8Ñ‹2B‹õ±ØLvÂÃt,„Fá«R P0¥œRdUi¥rbƲJ!Å‘‹í|ÃW¥Å‡µâ!®|7!–ˆˆL[Ñ^sš$ªf/2ª‘d¨8E+bMZMÊf`1 pŠí›–üà9瑦 ¼Í*\šÎÄ4Çäí¸ŸÞ9HíÐë4Âë=ˆ¦¸íЩ7é'±S‹èƒ”èSxë° þ£¢#`Är;—1Pú§C!ÝQÌTÄtŸ]aV^Ó­Ô2¦1m˜…€x¡]Âå—ºŠË­>2"…ˆ?Å-ÿ``›¾HK1&–Œ!rƒ~äFQñ)çÿ‘^éÞO!àÌclRóÁ´€VˆY‘œéˆ`ŽÝm”kÌ-À FŸàüÇ?Yä&Ã=e! A þÁäC  &(ý*ö$sTµàì™Ùì„•úP¢”=ŸÒ)$Ä +¹a—±Y.EèEªX•C é˜<„/[F*â)-·{Ñ@_ŽÉ¿°8t?¢õt”ë¡Çb“nžíA.qI©5©i^ È%] ¼-!_‚Û ˜sV¼,7´æÎ¼î¤GéÅ^ZdB²c˜¥½ Éux ³ê<=e”¸o›&ÑIb²v’Àÿµé†ôÀ—JH¦Ìô±”p„aYhÚQhÃjù0¾óýau…ùp‹‚µ—¾y«‰ Ô|Â8gɸqXûѶæ¼Ü.ÙæýȶÒ×Ç™u]ÅÉBÔõ¯ÆÍË^.*Ìarû(dÇ&0ɳ@†³€˜ " ¡ª«=ó X`<ÛVÈÏð-VëQsF¸;†%:ëF Ô½B˜^øÂ…–™ju÷–XÅ%WöpˆV™£0ÇŒ _—ƒ/a&ŽÕ.€BV¯š?jšlÊ©£€ÔX¨QHkЉðõ}òâáu·:Né±½†5¬üÙgHøÇåņ§ÿ—›ö8rù@Ànóòá¬,Ô¯D!ö°T 3ŽÂÀl2.z(=ÔÅI¡C +çY‰a¡gXËÚN4Å™MKWñ›¡´¯Œ'›³/7RòЀ¢~¢› \ a>qÚÚ!Æa¯¯ž°‘Ï'™4ÙP+Gä¿‘–Šƒ·ùƒþNÍãgÀÈož·å dvaÑÉB,C„Í…Wf…ñHôÜD‰Ã„Ä ]} ¸u”ÛEí-¨E©pË8ˆhU›ÅŽí° ídMm]‰Ø\¼ †qÅ]8i€nmÒô!ÑVµ]^Ja#ž ¦ È:…»ÉPX%"ZˆYüÕY’ bÎxÁÖ þRK ±ðÅôÓ[.ö%$a0œ4јª€äÀßð¥çÔ˼”Ëú¨Ú?|GšI–¸"üº€d—Ðü Dž}ÄxÙ }¦Q ¦9Ž®Ù$Zñ§M"GB¼‚*¬À+”Þ?D@!–i>LáÃÜ#èáLœMþ¡H!‚ÝÍ AÈmÊnú@ª„…ìØŽìLˆæ£…¥†ðÎ%°hׅȈø€-ðÛÏè³­e2IÄDÞÓüÙÃ\úš!舔 ‹ ØÃ5ýþ•ÿSEdçmôa´¦‘q×y*üB–ä®gZ5‡`¦+ ”\¹âG”Ýx™pÔÚGøžq(XhB Ùä0Ì6.Ö?0@ëåߣ¼FOTh9"ØÛ` â…V‡߉¾‰Enbe#æÎñµ¨ŠFj‡}ˆ® §ðôT¥ÍÀ dÿô…ÛI§BÈ]9ܨÑÑ^Ó0"¡D ‹Ñ¤ä+ROš|ÀSU———‡—i¨šBÙšÈ0J×?ÐSãt¤i^—¨­aXé¨çý”f¶-(JŒÀ ôË?䂟y,G´îW›5óð ìáL„UšP°•hób|N€)„o]ý¶×p ²ð°ƒ˜pO%ôO­3;#Tÿ¸3“æ‰_M)t€&á­Þ¦dÎÅ"ZAÙ•¨éYýµiùotÈß¿8‡C”cn\Dú:1ÍÒ¿TF8…Ç.0å$VåœnBÜ@ HÜNXÿ„¯!è-ÍkT^ì5×D,[P›áqÌìɨ£rˆPœÙ-ò]ŽÑéXâ´ˆ GÁI{µ¡¶Ö…ì”胉ýÊYQ'EÝ–)TÝšêu.Á’~DàÍÓVB¼wéƒEïÚS1¨{한‹!PÜe6ÉF¶H(BûHå¼rÜÿ… 8ÀµÐs»mcéË…ç#==+ mNrkaE¾†¦6 P0QQ(³uÛ,Œ?¨€t3Òø c“„žEÿËÙwƆÉ`g±óCHþØ¥pÀ¬Úåz ÈMùEL\)NJ†ŸÛƒµá·@êÊèZ¶³2ÂLŒoeeƉÄ:õGq\^FnY~hT„>^"Š,òÏE>'ôÚ´0Öb“{ÿµ w‘Þ‹-4Xtâ$J>"~QeRÕI½|´ôñÏCBz'4œhaóD zöBèÜ⇠þ}øWaB{öþ1µ§¡)?{'îøwõß½«Mnþ Ñ4ÿ_ˆ(DE úGÔ,"}fõam«ö_Û«"ÚêkKW]·XsåË%Æÿèy½+_¬xâjCÂÿœ„°—oņ WñmÀwusèŸ?ƒæìky÷X0úÀ/ßÅöŒÒþú'½š-äÉüÏæÍÂ5\¼¬/ž ^Uù(ÈË…‹ ‡GœÈõ_ÇÉôÄú]Øæ¢“Ñ™£déòÒ¿–¼ø`H£Mî~ÿÀ½©„ F'Ю]ᪧ4°§{b¸‡ƒ«¬úG¢ÞN(Œ'¬>¨ëªµÖŠë¸*4ë2”k.¹D«¿( a°ß¸ûJ¿ƒožÂ¶«¨°À°z/}¸Äÿ!6 È ±ú‘´‡¼áyX˜çƒ|*p±Iú®º'ÈæŒ·$[h'Žv*À/Ä ré¤"¢ûhË&–ˆ¨…%Ò¼Nßþ )ŸBh(#'F*O%–šk©^þ²ç¢ÀòaJœ+B„Cª(›b+ÿQáê‹a5ø‡€·êꪯ ËçC¢ÜbK- ÷ ÃAñŸ|úŠ¢ÔÂ~óªÔÀ†›g8Âb¤X¬¢Xèª ó!΄(ÍH Œ–´6ð±‚N`ÒIT£t²¨¥ˆÝ–Xaµ­èŸ%|sÓ¦âœÈG*‡K.YôA舫~µ•ˆƒ€öÍ¢ȩ̂ÿÚxw¤’P¢w%šc´Nãòáå•ìµ—A™š@?þì™ ©úp»2gªŠƒOa½Ê"¯˜2jÂU¯‚ËÕ—_­gXmõ+ž¢PöFX[öè«€õ-¸Zß…/YãDXà* ¢}y³ÒNëÌZ }až%'€÷[ üB50`‡çÊÞ´êMÄéK»ЏÞKzÉ×…co‚H¾XÆàžÞæ.#{œï£(öìÅ$È[RåÞ|õÑ(z7Îû%õ¤“ð¨’rêe Š»Šªª5Tß—Y1£°2Äf¸Êª‹CuçëŸ\>ÀU!‚ýg#¾ÆLÎ𞆺8zò™šÿ’®ƒ¬VwjM»Š´mòɳýâG1bÍo[Ô_¿pÞ¶ôÍb}ö„Xï–þ1S:øþЉæY­*÷ÀÀ`|õ ð0.Ê1ÈŸZr¯—ðBŠp‰ lÌLãáÅÞ\0”ýTª(Œ¡STð:MÑc úÔê>e•ß|%YW!J]Ê‚!!‚.¹£Õî|æ\™j#Xê•W¾Rį®7ÿ€_eBð˜Æ öÈÌš¥5ÑlÍZEúL´|D‰lÀ5~iQ”š‚åmËmëS_ûþ7šX& ò+KXr¯K¤: iƒ1†ó“|ðNà@£ Ç"ô8Öx\P¼‘ ‚˜ÿ« ½zÁ‹ÅA¤ €ŽŒ²ŸýÅŒ˜G t)âySZù‡¨®ò©¸yE1Ū•>ÈB·ä°,8| a•‹ÞyÅ—E$ Ô”V#'¥(!€@Ú˜—¢ë2Cƒwô±JD Yœ±€´¸†5ý(4ü8AküR}À¦I¸ A Û¶-¶½ 7„#À=C¬£‡N4IëEÇ‚ä#xW¢¤A ,G-ž@ß%òdŒ.¹ŸòGF^%PhCDÚÐå eºŠkþƒQÖ§¤Ù) Ae—]…÷xPEâöJé¬UzÉ/k…* ô%,ÇfG^I˜ã‰¥6/:ZÿŠêy\]å˜i=ô±€ÍPm{¨ תՙ-vfž`ò¡-&]6~¹ ¡fÂy0)‡ƒ§ ðÖÅ«Pt‚ATÑ ½Ùkr'qÁå4¢¸¿ H"„„@.Ó"‚ŠÑ¿@ÌU$GÇz©Ç9üXˆ=.ZIKv”£-JHB³P’r'WQAMR›.Pq T/³J3@€@€g­².)p»ê U¾ÓPme0ê u…‚a­˜›«&#_ù ²¢†TÏH[ܪDN°.`üà#Ìê$~ôT­Ñ€oìª@€*ê@áŠ]ùP$ËIÉÆüÊ’Œ™I!Q$˜˜ÿxÌ\èã+ I0–¯ƒ¨¢ê©#¬îE±…Íë~•ü…Â6ÚQp’fS²€®Ä§Ì$;*(@v–ÐRõ½Lä µ²XUe(‡ŠcÅTUÈ—Í KT“ÈÅfNc tu¶+\s0Å "ª÷lÓj°‚Vº*­0`ˆïLôšsŠO\K+³9ÿ„ôÉø1òUŒ¼B'»”¤~ݘ½®’Gq!Q°GH†+¿y•i)I‰Ä:Øô@vCÌ/Vî+úâ*‚ï/~LF†gE &$peôšÀôf•fÿ´B•4 G¨†è„Ä芎ˌd$Í&Ä#®¶å(ÿê‚Zø‚/\¤Œ^$0xâPP%:J‚r.ýÍ~®BbðçlŽÅúŒ0:2ŒÑø©ûøìe¯QhLÌ¿raÓ(åýd£dBé*Zƒ6…&æAÅJ ÕR +$Ïe¤xâBvrŠÇjÍg°×zʽ~ VŠíD W F"$ƒ±èIn’Åa@Š6`›v'k´g`*,"Žœ@>àå¼ìâÛì6Z$ø¢ I°.6c1p°¹äg$šƒìøloN=Ê$:"B"):€Ræ @L,” ñJ*ã2SÊPòÿTIä8ˆg¹h‡t)gzI¡„,Ù’%id$jøp•è)ÛqK*"±b0fnzZÏÊþ!~ Z<#k´ 5®eDElú®„^£BøA^ð2q–È­Ñ æe॑úŠ ÷ +ê.cþK²(Š¢ò(² B Îà.‹u'ü¤ƒ‚>KOL lAÏ8ˆd°‚b#”˜‚¼ˆç ÙF'6®&TIÿbÊ ÍN^à"Vtkå|Ì™Ë[úb¹€c2Œf0àd"è ‘º²"šªbh˜òÁ,n­åÚHpH¼*4ŠdƒadÂ"š$.^P-DäÏ U Ã"ýÂÿbŸVñ*§sìNbN¢$þÍ L¢üÈ.%U åÇ,©FO\ Ïô¦L ¯"ܯ”N` X€tjâ'‹CSŒ¡ÅRM+TVí*´âujåÆnhCps–*d/Šó Ã&¶BgD…©  "F/2 >æv*‘—¸Š… CÂóáJb 6ò’\ /aE™Ë.þòlââÇD‚¯ Ó5r# ó$SÑü,>MÒm3ºïîÌ.P襦3Ç6È* ·^ç3)7† ®@æ!5i"J¨ÅàDAî¡5÷壘†Œv.hEŒèÃC†çš@ÀR‰”Èÿ[ }ŽAÚQnZ ªŽ‰É~lìQÛ²è‹nZF #àe<—3êêB¿m!ã"<‘Ô<›‹7{/0/r7¦$_¢ O2>¯T³àvq#…L4'PÖî?3Ï| &)þŒBÔAX8¾Ð{jBµT XVbª¨ÌP}â¦Øòet«UtFêDÄ(@1Y‚óD³×/+މF£¦VÌbþÁkï¤sw:ÃA,äGTͧI^ÐT¿Í;×"Uï’HÇS…ì*æmcÐï«L=N²Jkr­9 Ì~ìˆ>­?7Ò~8ò~xáXþ³ ~a3A“'GÆÄRÊÜÔâÿÄÅ{ZÌ”Ô.Ô(%6gSwÐmÏ↠gÈUUŠ>~§h˜ª+ ]¶,ã±+©h6dZ«¬_=:yH3"H$ò‚¢¦â DSŽ¢Î«B6q<[$!Î&0keb/²á ó²ìŽ>7'c$¦c=WùŒK!Í%œ+ø,Praíœ öƯñp”ñd*Å{þaAq [l hB'\¦ÏJŠHiDÌ•–RDÈ&$dÇ1Bæ‰;,)+`¨2ÄA§Eö`…;c@=LÒDílÖâË‚pÈ!nã–Bì"!*!˜«ôaoS±0ÿiUJ§dyqc^¡Ï0ëVƒÐûÊocO¶£%3(OÆÄbàˆâFÔhÃ{HsgUêìhVÞ&¹À¢gh+fh\eçCƒ­ðžè˜P…«ò‰Pô Q$zÅ(x «^¯ _ñá_ÕrF€ÐÄÂb)@T~ø ÈCº“Ué6Vö¥JDTùŠì “ºÂò ÂNÖÑ*ç^âOÒ÷0ƒUd5Öd wsxAes¡eõŒR ƒRFfÉ„”dê Éì*vV ñïe|×_†OK¥BÒõ`·Ed×<=±-šdíɨ^•rAFa…+Lïç|fh˜¢Rÿo€._ok¶ilc¬2ä2FBÁÅêÄH{ nåÖ‡¹·HíV$è£7ï"%þ–0ûì$z¡¯Ô·pÓ£0oq÷0íh~1j%„P#Á ™ucD‰x‚’RHfe$Iä!(Aó\– tgNgÁhgóñ´"i.ã!gˆ\åbccNdÇW åeôpWV4`X”j_ŽWÞå*F`…a¥z°ìjØ’’7cÂdÁ3A?s¤Bi '°E ™±â»ÁûeXé™]s¼ƒ6|ê×€4JÆh‚a ·ù¨ŽKª¼2X˜¢Üš ü;_7 YÚòڬƫt‡:7 Â쩃ªÁéãWUnó e…ŸiE~HÙDPqE`3ó,•rÜ®¬Íc ËW–ïZ[ñ¢7ò|%Ì#›ï1ñ”°¢¯é,šÇ u,ŽÊŵRèBIWQù/œ[úñÞ –– }j½û9Êo·³oCgàãIFOe)Í+ @¼¦æf`:ǼÀcX@ÌèB!šˆÜÔnÛ¶ª+/Iò*âa<ÿ½#<ž*$vî*w£.3x:ò¨êš^þÄŠ5rû\–Ñ5–X?öíz•; ¦;'gGê¯ÏØ*³C[Õ%+|V™XÔäUR&v×Û(\d½Ë_Æ`Œëh†l$>¶»ðÒÂÖ>j÷ª]ÄÇ邽>®öq ø@ ‹t(âÁÃ…Ì?Ę7ÏãCFö¢/”'ï¦Ç$GÂ6)S%ð/dz¬éR&NžCäÊ'á½¾Ÿ;õA6Ùwá|½N}öTù_U&Ùób-ðZk¡µÐq}”>pm°Àÿ\uÙ5˜N|ùe"ƒ!âˆüöQa Ï`}-Ef™…àDšåã/¿ØøÏ/¿ôömµÕÖ#k='›X´õx$n³õxÛG 7nðÒAB&ŰР't´=ŒDÄÂF8…¹Pw$mÞI°¥ÙÒG4qàRLòL„ÙV;ÕGŸ}Ý©'Ró]åÓQùü·fþ£BN€1°ÀG7üÁXf©õƒÿ8¸ÐZneÁ?^x׊â÷Wˆ‹™A&X_¸š0FQ@ÿäâ/Eô²k/ª'Ük—ôB$pK~7›·å¶¤n¯ýå@W¥ª_VDCm¹ÐN_z”QÿK$m’F)¹‰lºã‰gÓœe+è¸êd_}UŸ}óéƒ+¡ÿ´‘G-УA¶ÿüÏ+4ºPX&¡…iZ&M\­pƒa+Е—¨!æ!Èüð³‡EÖ×`\åD¬ýå¢ .ˆPÄj¿{‰*Á ™ìkÿÈFqÿPrì=æ†ô?MݱÃ]bËi¼üSí aùOudštív8¹P˜"›ãѤ›÷p`Û2÷ÏœÂ?ñ¨÷é#Á|FµÓÁÿ.ÔC-œ­ÿB>ˆÁ°IHLy§S ×Z¦Å@Æ"0°±‡~ñ•ï_§&B`. ™ÿƒ]Ec^±êeŸÌ…ýb³ÄÖ–³oDÆæ¤ÐEþŒ$’ºë–lnM:Û‹'ÁñøQü“ܵÓaÉ-CYWdÒ™ò„¹¹ê!û¦Kß­ çKiÆt“܆ö4ÔQy#už°ÛÂ<…g™eá+®{äCjØÄ.õËmÊ$Ó[€ˆŒ…nE+º`3"Ï€hƒ«ó bP&»¥À…± ÍTA¬_é,8ÀÚï†$´Ä$Gê³NS„Ý|„Y8üÇÔ¢«j™$"óˆÁCâö‘"VdŒ  Ît-­G\mR KÞ„.+Öä#pÊâ=´Ó`Ænõ[ŠIîÄžÀéï:ý;ÁÿÿºÔ°DîÚÀä´Šej,n‘PŬ``ìNT¹î‚IÈLÕªØulfEÁDð+ÝáLgIÒ‘ˆ÷4•øè†ªÀ!nœUò¢ñBª¥ª˜`!%8A×äq„I!üÓåÈ„î” 'KÜþ“™ç$hSæÚÌ—6‘h :ôAãºõ¤øDuëIO 6ÅïdkD‘{T£î¨Çï8(”r‹;wƒºRviLˆùÈ ê‹„ƒñ€=iô*šUÒ’5ÛÝ“rÆBúˆh2üÙ iø£¤¤5:\/Là DUÉQ•Xº¶5‰Ü–_*™Äÿ†õlM&PÜ"zÐ÷d² 6g[2gÒ’öNpÙúIã¼ùkþƒP'(œ,_B‰¿­g§¡ “Ƭ…P‰J°üÇcg9KF($`½dA˜(Ûµ5á— öùVB˜¤™8…IMÝô6ÕÞƒµH=À ‘†ÌCqú+êB4ЄΞÉ#+™æxαܱADn\4§–u6Wx aòѪÖåDimäˆN¤Ïx@Ff"Еj¤#¡…OÖßád9¾?ìD{X_"vJÒ«Rµd‰f(¤–º4 e ,–­=‘_IGFâà5mñ’lÄv²ÿ},WxI®k‡«"¼¤6™~žs‰e´!MºŸù™¦+;¹-I ^Â6E·xnÿö€ÂGš.ÅÙãÇ#¸Áopƒ´¬ÓÒdùN¦U¢\ 9—?uc€ d]pÕ$£KˆóÊh û+ßùþ‘6^3Q(xZ³LBK¯V&6E'JØBo!É13€iž%.}' aAt¢¦­q›$(ñJÊí&¶Å”âN—Óµaœ4ïò8LöG¸¨BÁ ø.Ó‰»°|Gìb™Ô#EpØ`*­AD¨<:ÁH7‘†‘=sòÊü}!³o‚÷¿þÙÿ×Ìßk…)•G2åx•[ø@z5A,gé_ŠP${¡ÿHu¦mÞóë!N–&¢uË„ÿ,é–bE—YïÖ…ÖtÿÃbN°)æ}ƒ£‚÷uÁ(9?°yd‚èTpƒ)“ ó ÿ}ô$jƒAwv÷j,R€—[¹Õß÷ƒã'„C801B#è§xÐb<.´îwC 5•×l&àlª‚=1à&ÅFmö%qm&&ØE§çTÊTt\dZ.ÕƒvSàAEb"³WL*Ñø†{`uûÓgR0*Ð2`1\baGbiBivd‚*) )‘Ò(+àBR*u!®jQa;¸×}D A¤N „²Rx5’Ca3IØkCl¶ $­á ­ÁS2¥‹þ…5®Å ÁDFä×&ÀÔˆ§Ç&KàT[шL¤É†PiŽ ŒR‡T…¦[³g - 8M m(F¼…šW… âo²ˆëÄ0fq|g‘%hⲃ€ò*l5$“5ÖTMÖ´•È/r©ÚI‘äul¾RJ½qMF3¨‘CºQJÎr$ˆåxLò½q ‰É #Иf†’TˆXSXÂKXÒ86š§Ke˜g(QLS´ÿ£Zÿ †S»)L Y8qL}x‡w˜”³§‰‚uºÈÉ0v¤†ÈN‰h|Ç0"Î'ƒdµ#Ò·¢¦zÒ{ñ¹ð–·òL!—¼03‘C¼ò+Ë’CM¶Dú~˜®¥ÅAlñé’ИºH…•¥ •u-Ys-±fdÂ@Z‡ë2¿UWô†¥é&:¢-…8ô°6J†º8º)xÆÐ‡M ¢$xˆžÒ(²ˆž’•ùxœá rñ(ËÉv•£“º*1*bÑ¥1òqN}´¢Ú5^¼²+ãu—§š:ˆ7^.7^RJ˜¥”CÎÓZÿd÷™f³„=ñ_šDÆ0.i`¿ÔŒ!‘Yg¸.@bN%Znª€+ñr*¡B÷?® ›¼•¡º™(½×{J!€œÀ9TIi“b%X‚'zG‘c 9B”*( áp˜*? a+œ(+Çh-óc2#¤@4WNf>e©:^‹°Ÿd_õžÀ Hµ:öG…Óól–D*ñ«½* asAw©•oÿ€…Y¤€}všs3MÐg,º›½w›ÊT ä*cæZ®óˆœô¨GVuaélç•d“*0ˆH'¯ÓЉö0Âh&K³´-_ˆm:>5Úgermb6 ™8Êškøgé¶›ãr0ñfLáÁ[ÖÚ”|ª~ U ¢½éo4†¨%ˆ•ó˜œg °® kî £$ó´£/€b2#S‹-ðq¢¶ŠSc]?äÿZ#·«_>D3{°ù^{3%™ŸGÀ‰Ÿ³Ô¥ a`pLÁÄþ9€!‘KÙÑR*1$ëãvš2ñ­…+oÙ$±.YÒTúšÆP›EǾ Ú›’â óH|ÉI!:†|“C! 3´ŠA2BÒù´‚²2§ ƒØ·ÿº™A ,#¹°2°!»·[d·{»§*¶£Š<Å‘:&ÉB#ÓDÇ;±‹K.`“5ѱ%sö±"!²/•uÛ†͊>ézÛ¬3ÏZ ¡šI©8ç(¹!*‚Ty¿—«¢ÌH“ƒ T‚ÔóñÀp’*(U (f´ìµ²= ,#ºŠÚù¯7eAÆÖe‘h¬JM6¶º¢&Ù°E0¼EUŒvÃñ0±ñ d7&¸d€*šLä†Ãd67EKEK@t2u6¹Dº?Ï8ÄI Ul •ä‚Mì­“S®÷Lœ—–«²2!t7Œ}õjÅZL+×É"K‘ÿ‘A:¤MædÑ—ì Á·l¿lãy—çYüPµ!ÂyÌ?ŒÐ!eÛADqµäuH¬bán8azªg†•Œ½ù–à¼yPÉ9»­à›š[ˆ¢Œ)†Š¹¢iŽÚ9«dHK9A‰ñZ¯%òÀ43´Ü—ã ̦J^OVÁBJ#¼ DlÜC&‘V‰y0­UÅv|ÇwÜK0% °.†¶-Ùò`HhCÇ{3²%ñ¹DዚZ’ ä¬~ŠÉP©ÎàÓžò?ýÉáz¿ó¢,‚SÊQ|´y‘Êv"¯{;ú±7ÞeBSsåÙ„Jsÿ_¾’Ck»B. dþ*Ìn\dÚ5"ºR"`H%/%Q#Ó®“i7Z†öK‹£D„̙ɨLgs8l¾/;a9µ0¢Š³8š¾%¡/ðꌈÄùo—b®œ}œÀ‰NVeR,ºK±5šPÍÏû¤Bêаú~¯˜,Ǫ9T#ÿšµcQgMž¸ìC‘W>à°oRÐt]ׯ;2Ò9#` }"Ym Q²ÝsPt¾W´bu¨Ø[¸,¹'P ’Ó@H=ÔA-‚?À?`NçÙßÚ¹¤“jÚd%?¨m+£¢"®“]E°­z¹ÿ-M¢B°}Ðr‰Qc­d¶ŒªwÙd­MB#`º‘›…,0r Í]0€ &>Ͻm÷€Gð=ÌÑ¥¿7Ý1S6q†Oµ>àöE6lÞ’»Óéò­@äë³Gî­î½ï})_i®$ªä`¥Ô÷½Ç°“°l5zŰƒ©1cB¾‘•tl6S,-Dl«aªÿJ#c=BŠÕÛvÁ)âCÆÌZØñáÎ"n1 † 0`RGݹÉ/6ÙfŽ)í6àÍ6ª²iCÓ?®éß!•êÜ ©ð©°Þš¶7@‚<ËN‘â ëê)ª´³–ÿ5KA‰@‰W¬ßÑ"ÙE3»~°¿aPf>,æÙªBÚà23ÖKÊË ¤úÀËWæ@×ÄøtÜ+Î,@@†°âˆþŠŽKtÍ”eR¡EbƒDãÂ'Ó¨¢åã›nïa@ AäêˆWÅê2¿oˆëÊ¿ôÅK»2[±$@=!Bšê]uq~®ª™I¥x¨«9’µßEÖ a­ªKЭ]çNp ÎÕ^{N×óò@9 Î†@zsp;?{<°óàÒzcâȆÙá½7ea0ýgöÎ츛øÎíúú.¨Òÿ¨70¿B‚,ÏéâQQ*P O«Ô2ý=:¸n"%dB>d•žÇce«$M(Ö5çPœì‰QkÞ:a¬Õ>ñ+ÏòŽè,ð:ÿùC0ÜÞ @”Ïíù~ÿ0îß3€Oô‹cÈö¦z†ãéPÏú ±ù °ïû^N”v?«U©Ô&±´ˆ²2PÀðvC«RB'ÂA^®ëpÞë?r¹SJ©d—·í_±"`ä¹dcmе§)õ=/0ízÎø$Ó9 ùå/ùð ð? —Ÿ ™ï %0î¹Rsv½à/ý¦±äßÀD˜ÿPáB† EÂ? ­(¶ºñßÿ|\ð£c„?Ž ˆò¿öºliïƒË(ÿ¢È—g>}=õñs!§ }AƒŠ8ZD©"ªšörêTé?^.þY¥Êk /"xiõ0ÐE¼<¿<Ñäž<¶GäyÁâEìÚýw$­@üKeòàÄH†\€PâÅ?þ;ñoíB9¬¬ð A:\óYôèƒa&V”8„ÂêV n¸áFlÿDzòèšD+€iŠ=âò…˜™Ï¸“|öræäç‘Ïž.¹0êU„ˆ"Ü•~_ä믪YÃvå%âŸ×ÿõ.<Í÷ÏÄv{šÈ[ÂVž\Gäþ» ì:Õþ±È"~!•Tú럿øgˆ!H(®ÆŽ@«1y(ã Dƒà@ÒF$´W\ˆDz;h}†`µ\s Ž6X`ƒÜšm£`ô ¦–Ž”)I'’sî9žøá‰:Ÿ¢( ¶K¯»î¸ãE<¤°£Ê…ªÒÓJ=ª2Áªä *¬äib‰µX “¿Jø'ˆ< $„Ð6k!$þ©çW.àAOÿcl zŒ Ê ÂŒEÑŒFSO"B YÿU[i%‚‚ ©ÇŽlcÇ!G@„¥ÿ dú烗Šï8{B¡¸–‚uÒI}rZVJ}D𠨪¾Ô;ìâS̯¼Š–ÌíŠGÕx¼r¡€–PK?J`7.wÿ)!ˆyôÄ´€Ð\(z\Y”‡ð„ôŸÙ2x Ëþ©ŒG>…8b‡P!ŸQõADbCàAUZ«­¶Yoù  v‰âþaä øþ æaíY2&ã”Ã9Ù|vÊ'Üžâá)Üp±Ë§\ŠÎîÌôÖ ‹*°]3¨x °/εØZ—]­ï¤+OáÅÀ¯TòM%B ù ÔlÃÍ“`‚îùGÎ>”¬a†%Æ;o‚(–)§>8ažyBâŸÿé dó1È*à§‚”™‡Ë)§Çò²âÛxæb{u)>ãŽ9ŠœLOv'žwfÝ裵ýŠ«°´bÉc}°å%'487?uÛ7xÅ‚×ÓÑÀµ 0‚?ˆÂ(ü‡Q=_¸ç¸á–ŒnÎ.…a4º½5Õ@zè1ÿõhµŽn`à‡ø7ÊQÈÙPª × Z.!ðÿGå@—“–Ëô(VÌ36pX $Žhæ„0‡‚,€ë°ƒ°üã<ÿZ|ÒÔ œ` '¼Ú=0@`G8]î$< „CÊ;Û@~ð Bñe ªGáþ ܃…7”Lܰÿ‡½¨h|Od40EõP}‘YOo&âŽÜÀòëˆ'np?Cèr%¨Ó£êÄ®ðÌWÅ¢‡ç(³ıqÄãùô¸Ç)Òà ÜÙëÆäkA-XWÁÖÔÚ cÄI÷0"`„}ä FøÇ ƒ—!1G0ÚÕ ³%¤ \1h¯ EZjê„·D—@è1£¨J#ébòL2›“ýc1èÏP ɼ†’\> ¤œð€y¼æ?èq¤=žïô0Æ@ÂÙ‚&¤eŠ,@Õy;£ðh‡ì™šTÀ»[BR’9À>ô¹Ï<Ä+Á€2tÿ  >DHáåŠf!˜Rk9Q‡8"—rº‡Z– ^êcTˆ˜MGÀ8ÆÜo Œ¸Å-”I€°4ÿ°$ÐÂ^ý-Y3ù¯iyÐ#ÛÔ&dxWÂ%œà\-ˆÛ-ÅI @¡7)À²Ê¥œD5ÏigÙcàÇž“¬ä>(9Jæ.»ôDPæð3CøW£ãJÎ@t •¢h^ò0¹AR2E­i$ÌØæ#³ Rþ&ÀeZr /…)L-ùÒy| Ò\V°ˆ#“<žoÜO £šð\p:aÜÆ9Å@‚¬`>(¸³›@5åZÓû‘Kƒßøä1¬‹€HPÊå! H‹åܶ½ÀzÖ+È,íúNq—»Oà€_/3&ð|Œ@„E6b’ú™tÈll>;åÈŠ¸yù@O0ûœ–ÌÄŽ*ó,=z8Ñ–62çŠÛ]Å9T¦ê1¦™=nºtþCÿ\%g9OP‚{LVŸÀï|ëûÂW@/Ô@˜û/Ĺ®+‡X؉ú8¯k¸L¦cYäÒã¤bUº8²Çý#*µ+%KIUÓ7˜G>* ËBé—Åé°ðÈ1‹´¿-RÓL)#-'àQ!Üz´!ÎTç?ÉÕû(x,0â”ÿ,VúÖ·¾¸ŸØº<³ºq… ØPa-…ìŸ6dKëu Ø 2A¢¾^ylU {gódH½²a­òCK k'A‰%½jNqÐçë^÷ô³ÈŽL8MhBJy G-§1ZÐf?ÒL'jª°ÈÕbí¼¼WÛ«öÿ6‰3Éî ÔÅR.AžgJ†Üi +ì'M%ozGL}X½ÒñþC Ýb«X¥[¼2²Áä•!{ydyÖýýIÎrýž˜©ó(sd6N©¤¦YœÊ†pÉ™£NÜ2µœ÷QÖŽ`ÉmSYæñÅä?«è¿ä¼ÜÏ=È¿r€µ¶\…ÖÓžgéÄOAR-”¯·Š† ·¢~h¨ªô~ЊÑ[¤ŒhIÈÖ·þ؃`ÆiÖ×E‡³™ÀqŸU0Ƭ`6?©eûDÞ‚G0¶êLyî[ 8¶,æà;¯._J–>OȾÊs‚`•¬<Âðàâ–¼¨PòÀÞfÿ<õ°ŒÞ¯JH™˜aƒ^ˆ÷ÈÔqzw?vÊc}¬°š2¨,»Y›&¿Iâð,ÞA»ÒʽÎÃ%tIª"S6=š-æÀ­|`*ÞË»·‡ É@ã»K’¯} 4˜2‚û ³9¨æaˆSJ”G[·ˆ!x¡‹%ʱIû¥š(ð|‹Ò‚—çÒȉ¨Fˆ$2A#к“¯U«$€½(‰Žž`‰irŽÚ; ‹;°C0y8-ßà ü¸Š0óù'ø‡ J­Ú½Ñz$Ap©ÉÚ:L"«+;AÀS~Y´@ù!S:7ˆ 8€xiD¸p·{È€½ÿèA!6‰’“[fàÄ„€Ìc!¦Û·u‰.ûC%„X C¸€#L½JºBY<ˆ}-”fùº.–›Ù,]ó¦»ÃÝÃü¸3C¶óÁ ‚X;,-ýx¦™,èƒ,*D¸@³BùR.Rê—¢GK7Gt”8€<á?qfÚ‹½ˆ¤Hº‡¨”%ª4‡è±{õˆ5ðŒ&ú!Åè†&ÚÇ~DˆŒb¤j ®Q ñ‹Dˆ @£¼€(Ç28„ 2y@žx’) ;±› `ì&TŸaÜ8¤â(“–r™Ãè@£ê<8·(¢™j)›ôC,¤¯à:ˆ²Y´sÿ WP¼`D‚(G8ˆxàÁJœ·+:쉼ïŠ?Éh¿Xº›)‘ƒ²®L"KÉÊ­Œ?R$Åy›jÛ¥¢Nò¾D±„h AŒ… BLʺ*³$€5ãà/Ÿ˜5Žÿ’‰r³ž:Ÿd#Ik3m’ «° l)— +!Þa¬I¦j)gò?D™Û:$¾€±‡ ±U¢\¼<)Ç `Íây"€½0ˆY¯·¹ž¯Ä ³ÄM¸2M{›®¼"´”d0Nã¬Êä„›À“hÿXŒ `D †|È{±€eb=±ºK„X!¨,eéŸè¥^š¦›ÿiŽ˜¸¦n:L÷Œ£Ù² v"šk¢§«Ì+‚¡Æx€É¢Â+“¹nã6¥sJ…Aî+G£,Ç8ˆÐ XÊêJ"„éͬ|%¹ˆ*²øó+Þ|†$ù«›»AˆãDˆË0z»V¢Ðƒ8€¹0€+‰XÂTÒ Ã:VÀÇâNx™ÈEZóBUéÂè–²pçâ(–öÔ#ó–5‰1i÷H§Ý¡"k.ó¸"µ’M¤-פUv]W"cº '&â€&˜]¥×FÕWI-H’‡€ èZƒª íTu›±Ð£ñ WX «#Y\&LYµV}UØ+Ï$5O$åHdq’¿YŸx튫0ªŠC¦ÿâÝ3Å…!|ˆ}¦~’Ün£2Ç”œÍäÕß qˆoE”sKFœÁlý!iÈmT¤m½}•¨uWìaº&@ª"» Ú¥Ýë™×±K®ü¬å€"¢!BûV°M<€YÅyVHh_·…©øz¡ÿ„¾|2€ã¸,†ë‰Žš%ER-‹¿% —y¢˜Ï£^º&3¶dËCêÃÌŒFÉâ»nûÎÈz_æJ^l´„à_ "`F;%ÝDôÔyÍØäŒWŠÔ{…àu…E¥cçL¢ ²>Ô;FQKÉ€Ë7yÀ€Þm¨‚jH$¨u+J€ "çêâVH ÿ0¤l)ÖË:i´b[$@õ¼Ø)9ÏÞè íݽÕó$ŠÛ)ŠT ª’­—tN~ËÃȬe‚¡Ÿ›ß+1@t,y³Y éåD“±iÚ2¦±3nž-ã=-Óu<ÎÊ0ãÖ•`‚˜à"˳>ö+weºïª×Þ´DƒX¡æ%æßþ>q. é ïë'·­$Ç5¸¼Ä¤®Ë²-›µYë¥é˜ŽóDÏ[-eRþÞùô˜—©0WF6+?|Š)ëz&š¬ZL8ð„ÈD|ž‹f4ŒFcGƒSÐ5fç)fçAd`Ê–Ê`ãÛc„pZçÔæØÅÍÙm?µ¸vÍàËøãœŽÍcÿý“Æ#¨DœÁtsdFM%cÞ‚˜)ÖSUéå;V%€äH)¹^Œ‰Ž!ŽêíõÞ—Ib±Ø ò&âKhÑR¦™ŠÆöe)†ðCæA"øÖ·†kçÁÙj½Ö1îç"æŒÕ?É“öG†x]§u0Á®?uËÍcÚ ."W‚¨Ä½€!ÖL„M%J¼†«&ˆ¸$ys5:k†Î'½Ož(R½íèxŒ¿%ˆCò^±xíæp‚: FŒ+0æ[¡™r! ˜©÷µâ¢©¦¶ßŸól4†žŽ¾S…P·6æÉ~n$ã‚n1NWp€h[‚´+k6çä*esi;Žà¢ÿ ‘®¤éà”¥ k¥×¼ZÇv¨ ÊO%áE%lÁ b´ö$8جd—ZV+NÓ‰-@‹õ˜ò åPâ!nNˆ5Ùœ?šorº3ë4æ›âˆÆÉ†Fàf…,:nDŒ‹ö—·.Êævn‚Àk ¥î8­ëä]å~ßS%ˆH•ʦ=*ŽÒ€6¹)â*Ø;NˆÚÞÔÃ~íWK<é«•7ù~ËH ]@Ù¢z¸¡?±ˆu)˜m{άf©P^ Uypßå%õØš˜39|™mÒ#,­ƒ¸¶±–)êí).ˆ?ÙpÇzB¢´aç)é;%GæþYlñÉÞo7ælÿõ—ìNô››"û´pº‹Cfó£mrÚf¢Í4ó6¤ pï“6UÉBsë†t«ažRBʤ¶:Øô?‡¤{°)Zc–x8%%][ƒí—89ÔÕ ª0Ûî¦Ø¦Ê™ASÍ”©› Ó;ÿOYöóµîœe±çëåŽPýãÄ3ãFWwD‘A5UX‚“û @§ *Nïôfëñq’`EåJì!‘?¦Ä{€bi¨÷½¤Êõ§¹X¥O}AD%T¢‰8G„¿óÆ*S„Ç'‰…™{î/ýò7aGx²[[ó1, R 8wy :’ªö²ÞO1ý“²¡ÝÿÎöœt¨…xÁnüFõß2fq¶~ô¢‡«ì¶Ä?ùJ‰ צm’à £zmòq—f]«|ZµàÍH½ M%÷î§ 8ÕVÇ€± "èዸo$"r¦@‚ ðmÀ„CæÐ×Ã)V|˜Àa½†0PãÑ3þ™’c‚z-\àñâÅ?šóþiÀéžzôþÑseh”|CäsâÄg‹¦òšükÚ”Þ¼ò8dÀËC$ÈÄðàÁ¿rù—Ë <2¦zØÊáÆ!AÌý‡Ä!ÙŠ0ù—æø'Àˆyô}È—Oe”ù9ä§O3¿|ÿòuÖ÷ïÃh{!ì™6}Ú^”!|Â>"ŸéóX>r¤„n¾~÷ÿÖ}0Aƒbø×СËÿ$2?мâ§'OÈ<¹C$®NVT™ÉË!oÿAºó_¦?Û„ Z4—Q£G_Ÿˆêt*½!ZÜ#€ÿpðyÿ8À]Y¤•AB4½e×? Xptý“€„­€WVF„a`PY‰ &À>F8–*NF™h òOŒ1>$šCžM&Ùg‘ÙãÚ=I›i°õGOmµý#Ï §[r)˜\`†XqƒP]FÓ)W2Zv”QuZþSKsÉÕâaEÉm$žu.¹éÐõð¯ýãÄz-8ÑFž!8Ÿdô j_žAé×P‚æM¨¨yÿ<|ôÛoaÄZÿ¸õÏ](W†vIx!'D˜aL†8ØaT†H¥€,¬Ø¢f.ºø>4f¦kŸýƒh:~ð#j§}i@ÚCd²™6<ò€ØäCTþó¬O%” ¢]FY6]‡ÌeÛJŒ´×¹µ”ÑW<„à ¯)•§RBåC¨>„J¦ckQ,ÕßREMöA ˆ¢úØ5ÓGéžåP5ý¡C Ä5¡ÇdøÏ©¡:ë_Ù dXbÖªZó»¢Ì-"²«Œ¢Í(#gú¬ìC8ÒæPÿôÅFÖûm?†€Û_LöÏ_ fK˜@…xåqÎm‰à?ÿ¾€Ä.‚¾CÑr%9—&×á…\Ò¹âùç¢U_ÿâèB>zl QÔ‹k£÷\,€ÃõHèPA`Ç`ZÑdÒ\oœ8 9äʈ†•,Ð’ƒ¹┊P‚²ü¬¨͔՜s°8TêÁþ#{ÀJûü±FÇfOd¿ÛvÂp€u¶PKX`ˆåPØAêriEÑ·4_Nì\v£®I½/ÚÿL¬¯Õ;pÝÀæ‚·>.P¶wÀ‹f£®ÿˆUW§A¼à#fI˃ À7åÅ2 sÈpP²$À8d0†áN·00 DFv²sQÍr…ÌÔ.F˜©_F懣ÿŠ,ë5©QÑ~÷(©I»)ÁC¬Æ&©ìJjZÛº¼D‰héâZ—DÔÆ:§Mõ:_ò$Ÿ}ÆQ|Ÿh\¿\ÀWúÁ?D ‚ÎÌãiÁy†`€À$`à¥<ä4z s Éè#Dj "Àò”×®7ºáÑL˜^V@TÁìË–ÿ>nü·Ñ¤RFScÄ9³?ˆF0ø·à¤||µÊ¸±ãÇNUüS!rã„ :ôšÊ膆Ì6LûïÇ—,ÿñûð÷ôKDr?Ó…8ØÓ?ÿMý‡â_™öNü+ oDà‰-j¹¹óçPéÅ®zÑQF fg8ñ«÷£Àÿ]ýòƒ=óæÚ>sæz–ˆF &ùOv Fíçá/ýqµŠ|`?…&Jˆ=dÝ‚ .(Uuó@t MPÂQIôv9äP†µh¶á†`=ôGqÍ7SzŒðňtUñe~zí–ß~óœÖ"´Èù€Ür=5hä‘H5á„1°0¡QE¤ DØIYe”ÝyøX7 !ÚL1ñƒTÒc 2© ÂT’QÄWDöDø!”üAP NIOT&)é¤I-I¡’·§ ܉ا?}úvQR4ªx Q _CÄ„Ón¶ÿÉOkÚCëdÿ@ÑP<ÿ˜P”u6D'žEÍH~ĵ‚JüH0‚q $ÖbÇM‹Ô@¸Pª-ãüs`7UÐGy<… ;£iCÂ]Ú T5•pÂeˆÝ@Xi·aAÙ94‘Wõå’jÃý­ÿHÕæ?#Ø´¦®¹P@<ñ˜$D¼²;g°òÐÉÂS„_² ²@+ˆHðW´ÿ(gª¶0[•G \ùýÃ\U`Þ_=-ÿÜÓïyêu&NC´p›óF$g×–[Q„!üS2è+,zPj3EúéÜ[ÇÆ »ÝQ‡¯˜¶½&ZpÚ ¹DãG“EHì=òO@ïsÎ}²ô´9yCÿÓ€d(ó?v­‹"»ÓÜ?&ð ˜#DÁ^‘œ’­îYÐ:òˆA èF7í냟’ÒûÆÐAdø™=f5`Ù ?ó`Áäq„{ÜÏN(MCÔ¤(øïxMÓ€Tÿx”'9)")L¢²*¨lï‚PdŒ%8¾ñ$_°»bCðFOQ@6È¡ÿ1b•àMˆð„5 Hï!`„ÿŒ"DÝÐC€öα40 HgEÉ!ü¦%„‡©*Œ¢"#'ðE}‘¢’‚ôe´ŠD¤È‚ß"D!F¼¤0õ©€åjxŠ@ Y†ø@ú@FB|œÎ™æ¡Z’Q7DäÜFV ­BBj‘Àœ1ȶ9ŠÄÎoU†þñ ?ù0NC69MÙ¨d% J‰¿d@ðÈL3?6Á™œp"äG>Bd:e«%= B,ˆ@5 ÀG!=Hÿ•'óŸK‰ÁòF¡:uè' ©’úõ7`²=ÿðÀ¬,LjlàÔ„ˆý""à!Â?R‰ʤóÕÙÙòþq¬…Í“/óÄÓý‚ ÜÀ$<Ñç!›’­Dô§TñYùU´¢,ô‹&ù€„£[%‹7X&gXÃm` É@@£ùÀ<«ƒÎ„­«:~DŠLÐÃ<áé'ßDÁF…ª‚ñ)P÷*Éeæ A¨D¶÷ƒ Ð.Õ©É<ñ°à¤´¡Q‘€uš-’ €bPÀ¢hz\Ñ›J½„3ÈÇgˆbÅ %¯ 驉þ‹‡ÿ\€¯¸íb2R{5*JB> zc*c€'ø!¬ÞP²ÿ lt’{„#¶ciTÆÄÝWò‘/…¨oàȈà €*E‚”lÍÖDBp/mÿá…ÜSÅ´BŒÉ/ ÁŽ¡-«Ï…R§…I4Úì&Rnø ”@h’U΄íp2lˆÐ4ÏŠƒ¤ 4 ±AÚ";}Ù|{:_Ø6ѾŠdA-M•Ðä YŽPða p“K°Å WBœÒÿ„³0µR$ªYDxɰöæ8­ELNòK¼¾ØÅøÐ+Œ!’ÓA \ÃW$ R*!ãÿoÆÎˆ´C¡£‰‡dtUcØxxŽ.ÒÕKØv|9^D ö´†äc­2ÑÇ_V0ÙHO&ùñ’SùÅŸc> -L§—é-„x¬¾ü°PýàÈ€æ“á§Åºÿ }”Žb`°òQšÆ4ˆÚÊÒdÀ²DàhˆäƒPÿXACZûœî3¾ML¤Oà c1 e+¨™sÄÝc͈o~3Ñ)âSå­(Á ;‘É©`b}†.îÇ`ˆ "]GZÒ£MMV«Ž“AÙ Pö„͹Òê#…ѲC|*_d*r„L™"ƒØæ(„ÿˆø´ð §äIU‰sCdF2¹›@®ä©Qñ™êÊ(,p;ω»YÂyœ\çúßN§È )K Ê<Õi2Μ€âQà0`ú`•{’5MƒrŸúíkÚ”BŽŒÚµ éC vLt ìhÀ ”0Lâ ‚¹ (!‚0AQ]@a6ðŠ8h"´@ü nÀ€ˆà»Â?D¡šÏç8xÖph!@À«vÁ=¦’6  \ž=púħ¸÷íç n¨z,ï®ñfyuÊpÆ&§ëû úßý†ÈU#”Ç‚G2è:ÁfÅ|ø%p8ÿ/F f‹`0Eè¾Âgö†fÇÙ¶QÜ[AOG„'p?Ê °ö"t€Òd§@0#UŸÑy·,ÏRœ·‰²>° ñq~ Ày+P€"@~*±#Uf 1ÃÑ*Oó&ëaj{!<,u8û!’„LcÌD?E—pò$QöÀtMq?”•ƒîÙ×hÜ7‚Nã}„"·¸£ ޳v|‘,¬ñK&’HG:.[¡’=‹µ'· ƒÑ¸xFw~·Q€”fäbq!>@ ‹evÈ yÑmvˆS(¸l7À«a¶ÿÃö,¢³·‚ë‘bÒ"¼Áÿå)"ÒSâO…0sr9ë4&¶D7¡.ä;ÿæ;ÐuU'Ðaj—¼"eŦp? PæƒÓ´l§i¯Uze ÖžPQýWfweIÁÌÖä—• Á’VfʶˆfW7àžg(ˆðy”†Ž `(1±Vù‚æ±{;$G-² a‹s7X/sH%4g @ò6s¾C/ÖR¶ö`#Y7ä.÷ £Õ#lc„Ù×~f'vlæfJ)öa¤ÓŒÍȆÿÐk¨l‚ÿxr ¡5ù#ðÆAiÒÆA)iiW àÑ–Žw˜KIÈŽ7 ”ÊU#Àˆù÷¨1ÁF‰)X‰â¥‰PBI Ò`Yƒ?pE÷ZE? !'Ò!&Øh¯Rx¶„81+ãhñ€‹€AŒxs!9OJ×T ×&(lð„ ðKA{£ \ÈbœYm'AEp²ÑyŠW¸ÿ° zК™õ ó¼À.˜ig 0…Òôš|0xåÇ›;ÂHi„áÈç§Qàœ."&º7³'eÓ/ „bÁ&Á–­•Œ€YÿU,â¶¢‹í!l '˜ã᪘¹1…@Bœ³"#ÕÑ€”R4Of_—˜õai¡‚™W]öeœ¶=¶Jƒqˆˆ·”FŽóÐr6~Œx~ ~Œ¨ÏM—YiFá«àyBœ˜sØ}«ÁÝ_i<ÿhG3Á‚mÒ'É‚±ó:r6m܉b >—, „•‘·4OÏ‚PÖh 3›vèYI£VÃ…Y˜ÿ iê~µ)˜*pGìR'MP‹˜C‘FH‰6EÚúb¦buêKSbk8š·!¸, 1z"ÀˆÄqZ‰ëq¨»ÿ)i:ðm©‰vtH”õa(-ñhéA0Ð ÓÙ©lÂ5ìÁO¢| aá~ ó ž3'—”óN%élGaéè”×È0ó4¹~Ý苇IJ,KÕõÔGµ£Q=ÄD ÉmJÁ™µÅ‹ ºyø€zèñÁbt)Ð0\z£É„ëÑ„:+“°á§šSØrÈl†‚…ÎÙ1š,/Ñ‚Ex8 Ñ"çÖ#3Á !BAWƒ7Ð [ #%Œà.ÒJƺïQ0¸Ã0ĹÝH1 ýSG·¤]FHq-Pt‚Ÿ_ó%ëQ€ŠÂ^áKw%ª÷'†¡ÿ²¸ ‹7šÚŽQµ†Øh©i§ûLjÏ2šõy®Äù݇IÁ$ÌÆÈe ~W e¿&ça’7Wq7—,£¢nÛ 'ã~?°o)¢U­j|€–Ó¡û±‘‘øuâõhÍö‘m’R c¬µøß%uB,)K‘õó5%«ö¬=±cùg*'%µe³ÌQ†øpX©+±y"ñ,Êâ:Œ~z%÷\À)0ëá´„öDÐÌ&œb§­’v†ª/q÷Èj‘h‚nÂvöà7¤‚D"ahSƒ•êFóÀMn»MF'yTó‰EÁJ¬än¸Úÿ5VëBD®t.ô5trL+QmPH`Wš ó¥bÒº¸y'¨/” c©Z‹žñ2‘´ü Õ2}I!Ò~+ÀlÝ7(Œøöh;Ù­¢!h¨ÀK‚Í©#c‹PÁ%#qSÔjn4'5s3”'u‚9ëb¬o¢½‰ªS3öG,Åêùhoò›'ø KpæË;*k9išÄíQÒ 9§”+% m©ù«¬Z¼7˜‰Wí^’äd¬è½kgqn½!PBÞl3 Bd+8ñR~‘»œãœºº"#M!öi¬%q/áX2õ°FÀU½s)t8úÑa¥3nõç`cØ¡áˆÛ§\qùPìd®C׸‡Õn|š~Ñüì…§ø—ØA¡yÆAÿ80å1Ú!/RNç̦+mb& çÉÀ±•(iNc´´žÜ}Åc³Q @ö0`‘FPÝ Ó7L·¢m,å$¿>'^OõÓØâýRLFÇòÑnú¥;Âl‰Ò—ðöF±äzûè#¿eGqÚª]߸#UêJÆd3²&vÔGš"è¦óGRp(ùh!Pìö°?ƒr­R(Ò„±²‰‡ÌKt—’¤.ÝŽ?2<óq´œóâ.xB—±ÿõ-6-0%Kè vC ˆør_m—`Å ¿‡K)múpÔÚx sZ§›¹^ý[¨ü Ö¸œ! Pyÿ¤ù¡¾ÁBn¦èyRô7?åŒûœìïaÂ6áÆd4&$±<¾ó¶Ô}‘ë¼N'öþ1ŠñoÞ¿'äý[²ðŸC†÷äÝC¸pÉ¿&ò–œø×‚ã¿EŽDˆhä„BHþ»$ä’…K>þ©úÇ@„À"þ Ù0ŸJ’¸RþÃ7êŸQ|7ô\p"~ÿ V¨ïƒ={WÿŘG¯à?[çi8Qö¢£•iÕ®eËvØ’{‘ý§aV{!èÑ#{‚^{ùþñÓZ•¿"í%.P¡@ÔQI#ÿ»Ar!F'ŽŒ°O@ŽÏä±àxá^{wé1R+oôʼn)"¼øo¶ÿÃ$ ™OßH"/!l ¨–$WˆÈ""™@Š’WR¢±c· u°HÂXÚ[MoÞ ²óÔk@£l¶ñåÏçb›áEŽèUÐÃI¯ln¼¢rL«òÉÇž ³‡*Àž¢¸£¡ ›’@$y6àŸÏö‰…ƒÆŠaµ\­+Ó"…†\ch³Ùdé¢&:â诬ûí7àZ!JFRi8—ŠT‹¹ž[ §6¨N$î†Â(¡¨cržâ‘Ÿª´BèƒÏûˆ­¯æ3óL„` ¿%6Ò€ž°ø*«¬7L(Áµ#(Úÿp#røG4ÒBŒA<„ñÊ Š8jñ¢c{èÓŠj!Åy4I$}‚ûñŸd‰È•ˆ¼„IVàQŸè²©JíŽâŽ×¥š’JŸ ¤êK¬Ü˽ƤM¤9Ñ”v>¸lÛ!:÷Ãö„6âÒ< §‘H,(¬É’jåC(C3l;‚€r0B#êý‡…x Òà«?ó$i‰~E’èŸD?ÕèÓ=U¤EB$8“VXõWÿAŽºä„¦‚á7D–ªI(ñ¹î^¡Ìnƒ¦© ·$¯²gD¹*K£²¾jÑZ‹ÑÁÌ'<$‰™´ÔIé•b¼/¡Œ9HNŽ2¢ÿóÛ<É 'KoÞÊÒ‚ŠŠì‡w)¸¥ R\hÑ<$`³•þ  ƒXŒW£…Fø`iƒÈ¯yBI°SEXaâ‘Vi wJi¸Š#ä)‘iäp]kå*És¥n¸¡ØJ,}$K·8¡6Y|…‰îé!zåàQÛd§€{èå€G†á w~'‰€Ú ø]´†§yk¯MHöªqáT‹¼Iÿ!q òN›‡‘7Ã)  `PD&)a„ðݰöRï«^sïPû×Û®„$Gú8•H 7š„,c¡Ž6¦±ÇÍjVч=ôqJHÇ'øHJ”Z¦ÿ”¦På¥cVN7"®dgÉŒœf›äLwµ£Èí”Ç;ú)Ïxi¹‡ñzØ»òîit"K_º…¾ä)N|)‘ÀXS&±ÌCH¡Ì DR,$*QŽÊW¾·}ìç™ÇŠ0’"‘Ç <"’ˆp9¡ÌÈ84Ž-iÉP@–’ Š&¸Äo"”ådչι“”`9…t™N¤¸ž÷Üo,ÒˆîžWCú‰„^1RžíFbðám7ÊÛ!dx÷Y‚1¦—'n5„"n‚“iÐ35Ì<˜ªž®~°.©˜í` b$€Ïlˆ$ÓUô~ÿ¹f"9ºÙÍ•<ì/€)•IˆˆU%R PÅò@–lì%ó„I=!¤K¬ ü¹˜v¦”¤åd"Ù 13®¦ üáJ_f»†´)v±Ãwё̆~·S¥ïJ)KzÁR$¿û!ïf—6No,÷‘ÝÑC—üØE *kÆòžÒD&)0Ä (0³¥-C+1ýŽÒ•…_ qÈ=à6‘‹À¦",§àþQ:bÑñp?:Õ~´ÎW´Š-öt = OÈÉdŸ!@„“¦ó$–t"©ÒR : Œ]©” Ä4…Èh!q±ÏñjÇÊâîx#5^)K‰Q/ÿ•8,,ïâÒ-:.³Ù –y˜o `ËANPk&EPëCHe>0§Ù‹CúªÈUXÆ1QœÞlì\Ÿ‘Ó@$ËIÿñ£D΄@Bˆ;I2³‚lÍ-¤·ž¨$ T w6ÑU ¯¬¦]05#‚é²"µ©,î8*’ År¤Š©(+ßRöP6ÊÓÝ|w¹-öpKwuVêÒ•…–EÑÚŠ¯ÈÆSv!bXT‹£B;ÒŒ‘+1È Gò&›ß~ª`ò0M’ ™èô‘ZT¡¸æ6Ž$ò´@ã^²–ž!óÈGexòÉœLeÖÉ$ÉLFìÕ´ÍÿÊÞΨ»§>ê±!½a*MYå‘|T–V>Þ,GÄQ>Ä ¹·N »Û8jO›ž÷TwÉbž—(h…!x:C‚Œà&|õ¨£ª>6…Ö¾þ÷ÚŒ4"9ÈÜFÂ#PÀbÿ°¢¤×²€W¬¥5®'%9˜às1ùM0Ø“êhJp…d‹•dóˆÉnfYc' ›eÚ]ô£!U¥)IâåÞ!¯xÍí@ùCQÞÚoµ‘½"ÚÆ¨bË–2=_9²Ġzdk"Š}Ä`3.Šæ?2€°Lµg+äQOBVÄÔ}©h!}ãH> ªøG–îgZj¥ šäq$6Ž•ÿpöê³Je/mMµ"YF×!#D(M /#>dYo3rªÓ(ò¼nHˆo•]9_û8‡4äoMßµhd³ÅC)pႽØÅ+æii{5¨ƒFÅ ž"¹£rð6Šô« ª!É =šHdÞ‹†ãéxó”}›éÅcg¦Ua¹al¬ ÜcjÕDX áÚ±NÛU"|´X R¡‡/⺅É~%¥”¡ÇåXž\”hb±GÉß5lZ¢Ü¸ÁÚDXgñÇ+‘éyb06v-óB„qºDà¶¡s£›½5Åå(VÐÙo¶Ð¹ÍýG|àÜ•è1dÐÝ£­ôÿ±$Eô(™«w 3$›Çé?ÃÁ$ÒÒŽrð0LvåÛ7ÆR¿ZFH–Єټ¥ÕJ<—Ÿýq¸¤ÿ²×-ÏÉxZöàãh×—ª’ƒQÄèÚ—³*u^Ü2´x‰ÿ;ˆÓ! ©X 0œ4“¯Z€ «vÂ## ‚c BjxŠ@J5Ï©£ø§" ¡«›ó€ Ù‘9±–•@—K6µ°! ¢SR¼[30Úh‚Ú?õ#?ì³AkQˆÛˆN!0ƒ˜Ò:­Ïa’‘@¨3Û¸1š‡(ûq3uKˆCQ4kòÖø‡ˉ QÀãZ@I³"ƒ½ur•°òÿ¯›±‹§•Xಆ+>–Á˜Š«˜¯xoJA‚ÙÙ?è¢ùH,ñ[‰j!@†È°%Zê>2S f£ »+D2‹‘†ø%ò–ó€’ù«¿ € ༣Z£ÏP#ÿ«”2YÁ‡øàúBß·12ôªàh‹­ LC‰Z¡JH® ,$dÌ=&”¸Ÿ˜+Ç)2ÑÔ™\ÒDD“(— ¥PJ‹Kü8T ‰Ѐܠïacp#¤Ä¨b¯ÿÚ¥÷Ø%O™žñ—• ™…cª¿(ʼn‚‘zÉ ƒ ˃H/”„¹›x³·eâì·‰4a1ÿµP'DˆL8Ú{•܃ Aíb‹¹Š¤ »¸¿b‘D ?ר–L#KöÚ¬Eì–ÙXÇJÇ7 '8GlÃ¥Ž GÖ Çæã$kyA2c?¦”³Ö èÇègBÐh ÒØ« p²àú’‘0 IC'K£4 8Å 8‘0» ¸I”qEb¤f$¾éP ¯Q³p¦`CļÑ;û€‘Š ¬F|‹àP)ÄÇ ï« HìÉp{p‚)€ŸÜ‹½ðÁ6h“Úø02›G !˜X)ºh»Ø)v1SŒÌØD sL’(Žà$ªÃK!¯/Q1J ÿ+Z•~‚½• ‰b \ yš®Ý+»Y‘ŽT‹¸(!(V¹=¨ˆ6Ås¾ôë&§‚*¨ªD…¹M™DN1OЍ‘&p#öøIÊ´Ì|(qÁHŒ(°OÊä̺øÌnéûXDì©‹Õ ÷@ú#‰ ‰‡„/ £1½Bë¿(W¬”½pŸˆ,C®ê'ã’“ 7tË;æj‹d ;•Ð.¸Ú‰ôH2²Wˆä­fCžQ ´!D2Èôb³„˜·zc€\# E<éÏØÏp'ýŽ$ù‡Ä¨ÏÉ$6@7Úˆ3ê¤üK ¼y£ƒ(ó" ×tÍ™Øáÿ0ºÊ•Xˆ~ ­ÐâˆÓ;ÓÓH²‘Љ1C ™ÈUéÅœ0NV+„H$ W¸å » ôì‚»ò‰• Ñy"§cɽéú,„Q´}‘žúHô&ëˆ69÷¼öGþÀOÞà‘x^@ZåppÁLÍ4¢3ú”tšÀ,Pó«* ¨ µX‘À‚Pn\£ÁBûqÖPôžÓIÓâ:á ‹ÑÅã ×㬕æÂ4S <ú*Üóà{’í >¶S ˜Ù³vû,Y DnÚŸÍðJQ…ô¨‹›“œKB²p7j0&BˆŸÔ(E\"H ÿZåÕ&­L{ÖN²e#χp˜#t3¿ÊA1„ ðÇ4]H -·N}8e´…t: M CÀ‰éÓ×[@2¤Ã1§•¨•VQü·`¬:<.r]'EÝH{C„pQ\xQºªHº|è° ã¥zIÇKÅYDOÓ°‹°àLØaº8ùU€ J'È“(^‰ZX±Cˆ"(7T…¼Í ^p(}(½VD󔃹9hI)ö 8¡ƒ2Å«º¿²(£Ù°— ‰PÛ8´ÐšYÒ€Ó¦›ÖañÙ’˜ÈÄYŽ‹1N¤=®IóÖpýÅC½šÑ‹@ ë Ïé Ü™)#ÿg5ÏÚúTø¹~‰—Òˆ3ÀŒñÈ‹«2¼ ÍÔL‘¨O‡E‰¾m'E%Ñ‘(¾½X\òè‹ÿqˆ…I©”B1= BA‘€ú#‰Ó[‰F9º`Èxû¥ÁCÛÂÑ ’0}¸x á¬Øà\àøH®9\‹"ø‘Ô(Ð ¾Â.wŠÉ¾—¡ÑyàOÙŒ`å--4´õ ®À脈 9±¾“>áÏʤ (ÅU\-‰ý½% $ õð•X\_òðŤJó\ˆÜ@H2êßÔQÐùEˆSˆÊÕ „ðiBˆ#è¦6º7ËMà’º`04 }˜‹ÔÿÖ}`:J‹Š\ñ[7> Aå Î D’ê$Šq»¸[zu:OÝŒDÈD,ˆBHïqÐÄ ÁÍ~à‘ˆ‘°ÏÌIù‡ºµØZ‰v’ èb å;¾Åað€á‹h#Ûb£U¾ÿY@É]‰Ò(¬|±J飺0ÉÍgOeûˆ…4œEàH³HU!‰®"‰à¨XAmc¶¨ÝRËØ®^ÁËwÅKVA„Y¾-Ž‘C~™7ûùrɇñÝà‡uæwÖ‡xd(õèäþ^‘èêꘓËž 6ò0 Tu–¼q˜k=°±0¿ú‡:KSÂX&ÿV‘ÚÙG9 Hä•ñ”IÕV©ŽÔ‰žMfеU¢ ß€RHk±66‰}b_L‘dµ >»„וÉÃëd¦ó¨Ê,âØ‘~¡ÙМ)͇HVçyÞwΜëÅœÌÑÕ{Ö 9ÖÞ™ðd½åçK€Ë¶‰¼ Ü"~õÍ6ZâsößZ:z@¦ ¡Šb-¿¡)tëDéù-g ±~9ùÅ:ıã"T–žÒ I¶U©þ‡_¨Øßhާz㵨SÒnŒX}êvŒu–g:¢ê‘©Õàè[†ðʘPÖ´ôáÀÕxˆ‚‚ö0øÈ ¾,¿°Žpâ¶vM)~^’ÐÔÎÈâ„q²Ýô¥‚áQ …¬rfÄ¡4‹ÝÅ1ÌqLþ£¼°*¥ì´ø…ÇŽ‚Õ9ˆ‚[$ őεàfDZ»"Œà(£mú›ñõÖ‡Hö×ÖÕS¦êÿßð€\ÍÕœ¸çœ¸j­8ö^è eÇq ¥PT±»= ÎUÈ6ߎ l3 åKÍ#D!ž:(û+¯QýÃ5þ!ñ÷@PŽ€€µX@3Þ*ÄAã:Ž•Ü@X‘¨æË…ÄÖ õö'×X‡õ’ž²) &‘;÷ Í£ê8#; ߈gJN×NàNÖ‡Z­ÕÖdà†ó¬¦‰‰¥ k÷ޮˆ‰>·m^ÈÊYÆ­·Íô,ÑÝ9F€° Y‰HÐGÉèdÃtÿ5(Â&þ;=éQ ø Їà ÑKõ<ù°ð𴈂Hì´Ø‹Rõ.‚D²ìÿ^‰¸k’FnII#ãö:ÔŽ ‡å‡Yu{¦Uw~f•Öa}Fjgy¾¥ ~¶ó:É&nçaOèó¿%\ÿxIôý©¦‘èܰº¸Yö2‚| ئÚh·.´)]‘XwgN@F•!hŽÐôŒš&‘h˜Œ8 Àd’È…A÷ zxuXŸ˜Y‚êXF’ˆ’݉ž@„ÌhI:仉”¬H~PêHþ‡Õ6OvÚÕ‰N¶Õfgy×ÞúÞ ·s–ðêäög ¦Lÿ(ûs£SÑeJ{n’ ”d“ЈP‰p *R!…— >µöiÐÿ*ÄxTð{È£l… yìø ߈u}`€ ªõ‰7“س@D7yqY»‹ˆsvs’×äS®X|f|LJüÚN jï…"àçºOI Ïy’Øyàæ7âŽåƈòZ,9qBàÁôbhø÷Ï¡ ÿ>8tÈÈáÁ%ÿrü°Ï£€Šåý;Áâ É%'å±pÈ‚Å<‘‰t¨M‡ˆô q=‡%¶¨XTÉ{-îÝû×D^“-NÐ "Ÿ¾Š"Œ"mÒÂj>{ùÆ"Z±aƒ|Bþ­­é¶¢ øþ!b$é¿{ŽT”§òÄþ]rXš´K©=‘®xÉÓiEx鳂= '–<Øb*IR[&œ§a^Pº*V°WbŒ’ÿXÜ ²bH}jl9òeï– ëC,rgÏ)Bpó_÷ï‘Km•iS§RÆÏõÁ|yñá5P ó5Oú¬°@hý3×g5µåÐ7Ä@Ý=|å7’IÿÌ#VEüè#bcü¸@âVi™[[ñ⌹¥Ê?E„ÖËh¤©vÚŽ©‰ä#kªùÀ‹ a©@Ï %dÔn'ô¦ÑA Ű=†07QE10ÒÐ?¼UÄ÷` ÿ]^"WQK,M÷Þ?ËÑEpÚDfÅ—\r%wÛ< EUÑ=O_>ÿU¤ž>ôÜu„ÉäƒXÀV„Ÿ¥U!#Ôi·WM1"VùˆÈÏ?¦êSÀ‰ÿ˜èâb"½è‹•QYŸáXÄh>ôòÚiùØZ°ªÁ&›cÙƒ›n"ÑsTQa¤‘BËþcCe[ØA½§™ÂáV”™vÉBwÿ”P E7Õ´""ô¤b„@‘Cö^[nÈ!§AWf.ÑBP!ä’*b"lÂoLà(~þ·ÀAhq¦á²Ávå‡W™÷Ș=ƒ†°ˆXi…ªbüˆàÿ‚‹y¶¬šÅšë[£ÝØë?£•–Ú°ÿ°–£ižÈ&BayÛ¬t]6y¦´'`Ý•…•:uÓ}úBžùô ¨@Á¡ë›®gNI ½nby/||g=_kÔTQQB'š¯B Cj_ 2ˆÖÅ’1…7xÜ_dòu=&󣪫'—çÂ?¹ª0‹’qv«Ì4Ëk¦½¨b£h¿šÖsk>úìÏ£ÑA‘Ë"iÐ’%QËoM~híCÿLP¶a+µR}xr>!”í—H'”Ðá["Ä‹­n­Ý&aÑû„›Bå'”n-4qQU–U¼½òOVöøQA•µÿ%–ª•x„&ô TàGÈS"W&’ÙãrAÕGÄ9êÃô[Qd4:ÆÆ!4òìR£šÖÔ$6:Ê‘lfS€Ûe*NãÎnH<¿ÈCË›’C$ðçPksëRM£²}9©/NòL|â6º8„"1M$à7ŠH7SÈ<üEÝ,Ê)ÁÌaê´d%>ñyÏUãƒ,€ƒ|CPtñÓäNƒ’F"å9Õˆò¬Äƒsž«InEº·Ðèté…[†,Øýˆv–¬ˆ-j4‚°XË ÀãŽFü’ŸàÑÃŒ(åx&ò‰”l!\‰ó32¸ákÿ?Þ©ÈP–´6:éD{qª“>–˜/>ᆘÈéWÝìó4%8ñ¢ö² ú9ÄZÉñÛ4)Q±´p°&4 A¥‘`T…IýNe‡`¥½R$d”ˆâ¤ÞÕDRL<›‚t²ø…”&Á,”H T7Y0NâÍÃRòµ“."POÚjòÌî­€F”h#>ðq©zpu©c^ÂÄäðq,t•õ1ȱ<&føüÅ­î‰È r¦‘÷¤Q#{´úóG#Ú%kD›Ú#I»ÿñSx³P#ÖMS²Gt$ Š@"®LHóbI;…q;É ¤ ²ÜtYYÛÜ,責Lõò0¥PEOô+¼è‡ÌuDÓfZȸ ,€%ÈCÆÀ  ‚µ"D$ÕÎéf¸"*æé|Ò“«`MäyõϲþÓ4cÉèx‘(,‹wK –È–°¾25á|©lSާÊ}ý#:1aØ*BŸÏ̧|Ô\LbW0„1RàiÛ øìõ|Ilx¹c£à(yøË'Øí FªžCa&~‡ZÁ+rÔ¿Õ^,qŽ»‹ø#ŒìCƒAaÈ?rîe¢KäÿVVwOõaùìÝnøŽ@^’Äž,ËôÝrPDnIDÄZ5iœF8 H…¹Ü»Ä]†eŒŽaç‘ÑüÅD~UY›ŒÛ@aœØ”–ÁÛMÝ»ü c¬„`7­á¦ÅÌb€@À¹…åm ?ÔÖ©ˆ@î%Ø?,ÁÙŒŒ‹é¡!jdHŸŒÚý•ÒUð‚hðSM„ÿZô蔇\QÅ›ÕÄ«“>” )bËÉLS XÖ„ÊøM,G>S„t`¼Lžè!ÆXì\V|†4å„öèåuÏþ…[¨Åg¬¡H Ð0‚Ã@ TÅ``YñâDì×LªJ¼|cšc,@Žx:ò_صhÀTä—LÅoÐCÀ¯0b윆ëØ/ BÒ¤­u‰_HÍýÕ„^ím¡ÓåàK \áeJQ´À8Ø:ýEHNéž-~–GºE\JÀÁ¬SEÈ ~-†G®ç Ó`¢Î%]=ý•›ÝuXS=?ÄZeÑqr„€X¸±mE‹y]lPÌ,ÿo”úlW*ÙÀL;mrÍ# MŽhÆ yRFp¥‡È’ÕÄ*ý –Df5@ ɆPHÊ?´G°U„!„Y–¹_âeÂ8„!9ÆgÙ%Cîeª|À^B!Ü^MæR\¶…j}†ƒ Ý œ€^4LÜ‹ßD$aØCŸÇt„R@[åÔTV„¦‹®Ü T‘æ ¬OBžfc nP• ÀLkÊ"ÁåȧA‘—|È]U“©Ò™JÕä Â}Œ@ØGT ¿¸ NAQy˜”Nd1ºEa¾L̈€ÿ f6:„Fzd‹ædˆDF]Ý`¦xŠÄ\D£ Ý'‚Ìá:ÙÿKŸd–Ýá…ÈÌ”{ŽEŠ*Œ.Ò,ÆV˜ˆÒèFÞlW~¤¢™üIrôÍÎ1(Ž8¨C@ÒèÎ„ŽŒJhž\KPTNò¬ôT¶@Iä‡vNˆJ™CDÁGîs>ÄËýåŠ>§üQ¼ÙÄ/¼œ2þƒFú„.žÌäŠüm'xò5-ÀPÁQJšg\T@‰L{b™›Šô‘ÃÜ‘­™RLEUJ•~FV˜H„æFR~iÞè‡R$ž{9ßHç^öYÙ#„ÞõIáU)¹Åˆ¥’EhÜ?œeChG*Ä@@âyH–mEµ=‘»¹‹¹Š„ ä” ("IJç:MQìÉ~Æÿeb$GVD;æBVfÊ¿RÈöaÈ}Nà’í—ôØGp ~ š{ÌU`Å»¡i­J>8Á³H…oüÉ~K´ÁG8AßÉd hüÌŽAÜåÆnXÝðKtäÉå‹¶˜’«`KÞ% ÀE9ÇE‚üƒþ}®FhUDa––2ê¿näý!üàå?ô ¡òÜ?ˆl;JSÀUÓ50局 @–‰“Z ,[Ø ¡³ˆTì‰X´Stf†ˆŸR³…1”f™üFûÈiù„€ÈæC§Ê ë0ÀbõLIÈiÄÒò,ÏÌ®Ç?\Äô½Iœ¦ãVDq¸ÿÐ{9Q0+] «ÚÔ„½>jEÔB¡ÖWB‘ŠÆMNmºÅ‚ÅÅÍÅÒ>,@¤-I\&–Ù‹A±@QDL5DŸÐjµXEÜÚD€`¬ åÞþɆ$^âáÆà.(ÎXÚÉRÒl¸#S>[`àæå*Ĩ\€’eK¬e¡=hÜòÞu世æÅÄÜŠ„•8êa$ÔÖey¼—HDjçô ßücÙ„V¼:-çéIÖæC¶­ÅÖiÅ `ïnÀ×rLäçø a%Ç| €mGP”Œ.ê"ÔÒ~¹K¢šî#0îåòKÙÄkÉM™{(ÄíBV0%œ$¿°Å¬Å°_Èaø/ðQ¬ÙËRSî‡e醜ÿ3Vx€ ÌÊê̆ h/ƶ€1ü*Þ4å<Ó±R×&·@ôȾØåH#‰ÆZaì?p UЃÕfÒÃxâ^YDGg ŸªÀAô²˜ ÇÏ~˜]IÖË­SÂähÆÌtáÚZ~e../¿x›ÔîíÅÄ…ÿC¨Š„Ó­aQ+`4.#DäåܾôÐå)1FøU—DQt/AW2g T"irð­~ìÇŸˆSbÅÅŽËÕFƒæ“¯œÛ².ff/ÌÜcd„E|`ËsäË´bŸâ¬ ]‹?LE˜›p ÉÑÞœ”néð¢¥Ní Ò´tä\JÕÄZ&D^‹²{mÿÅ6³âˆ*Ž=HQ ¬ióÃ<ؽdJ…Xv.KŸÜ1eÄ·jB”Ui†üL/èó¨!eÞ@}t±ÿ6åXðó³1V`@ŽàÈZá«°fúB¢ @Ád)vüŽJòt¯þÆ@`q@ÿjìzÀoçQÓ_jOKÇ¥Õ¾…>*ÕÚCíFH gžÆ¶O5Q—[€zôÏõ& ÏE\0€=œÄJ›¡@›V4› Iü‰ ´€œ†@%»ÀgÚê‰ å€DûX£p@„ S&(Ÿ~õö² †âÙ‰‘'AëÑU"ioPÐoý*öYŠtNÛQ*†‰¿…¯½.­ÿ(I5ê[´·¾÷LÇMž„«¯áP HÈ ‡{+“¸WD@ •\\ !›¶Z0ÀÄRâ[0iŸÜ#¸* ˆÌ·Ž(bS•Âì6íÀö"eRLU`™È×´BÔ®È.¨¼Ý±ØŽ¨U…ˆ€”†'Ifô¶t½Ùnž†VÓA ÞDë…C”4,ÕD­Ò0™.èÅeLÛ(¥*öZzÖWR=@€ù%Þ$ƒq,Š6G€P;%„@Hï:„înj—Ó†R.ß_L Å=L4&m'/¤cÅ<ÍNil¸&û9Áèò³0‰sÀW=DÅ?‹1ÈiÒ(„ÄõèZžI™ê—¯]¹{dªDÁ”Ó"lÀ67HMˆ9Æ$ίžÐ0"(ï† a³×Ç,}€­ÓQÌÇ<›%ÿ¬{iu_šä³&[ÑÔŽÃŒx|1R—àNWo-C÷v[· íˆÀ¼ÒC(/T=×GEÜû>K@_WYŒÊ<h¤d?Å{nëý]6~;%;ùZC„€t¼¯5Ær±«dÅ8þD(/‡BQÉÐàQL  …¨Ä?-&„ 7¯E…ù¢üÓç¢H/U—.ýëõïŸUEЏ(à„='ùòýËG¯Eʹô‰X!Â… ^1eÁøOUF½*þ»äã§*DBŒh£ 'mþ5aª´Â¿ þUøÀèÃÕóìQ½‰Ñÿž½'îaäðõ&‡ ü€qžÂ¯"ô!ª«oÅ]ºhMö½™OË!ò}pâ_ ¾ÿ¢”Ì¢!â›!ÿÑCÂIË›\±!B„Åhñý+ýoÚÔ#ñãgOÞÖ|ô™,IÕÞÁ”òâêÓ¢„<ÞòFl9¤½‘%crÌÙÓNEx‘tâDy_–¹XºQ$§M´â¥_¬ô¦E~Û3Šq祋m˜2)u‚Ø›]ÿÍûÇè&þÑ`€€·¾`­µ0àÍ¡Ñ0BD„D °6Œ LŸ’$0éƒ|rù É0:¡…n*±!†J<̉ÎdÄ(%ËËçJnŠ ÿ5ŒN³à¦Ô6( Ÿ!{\€Ÿ|øA$Ÿd,ɯŽ«zB4ää‘çž¶Z`$ÿn Á†˜+â—‰zÂh"œTáEŸ‘ûg¹(|óî—8ºI•>áûé+@Óû Î뼯ô,ú…)ŒòÄ@Œ®ÂÍ¿n²ô ôã £²0j릵þÉÀ­ä)/»ì¢  [½±Ãè!´lüŠªÇZ¼É Ånjâ+`«üJÄð!4Ô,RÂÓz ò†°”lr«ù1©¶’þÉ #ƒB±¤0çQÑ2ƒ0*·1†}î«èr‰:ë)3;cªPOŽ"Ч›Öô `øôÔ'ŠÞSÿ£^riT¦ n¢ª‚®º²”«s1âôÄÑÞõS=õ #½(9äWoÒçƒßP^yDm[¬D†¨BlδÌúçž{8hážš¸§ yÀBd…Ð6X€ÇÒ˜]lHÓŒÜà†“ª|Œž­Êô J¿öûÀÄ´ý1ÉĬÌmïOM>3‚o#˜ä•¬€Æ\øgî~ùÅ9žxXQ„o*b¨|jʨ"!„ ¨úœˆé*Œb°Ê+{"Á+z¼©€¯ºDë­Îh, ëÂ÷B“5´MÛÛ´%ñV¸^v¹DˀŹÓÎfï´‰³hÌ0Z`ƒTó5ÓP+ò&J±Ez ÈMÅhËÿŸXOÇõ/ÜèQÈÆ®éì«&Ux"àèݨ#¢3ŠÛÿ'Á1B»ÍózZ“_õôtû;›x*¼"½øÅRþÁ ‡õç&Q¡œ=üS1ÉYj? Ç>E*¡A@CúøP]Nv¡ÚpW³ Ije#‰©uæ2ÕÍø¢»Üýcg·sFDs“"•æYÈÓ!j<Á”T&~?„’]0r-}\‹$}¡JB.…p«[úIʺü¦Šèü(:j›úâ/Òmq7Aš|r‰wýKB€+/ÒÇ ^ìí‡K\~Á‹›ÈVaD 4œ+®Û_à©OqŽBÍ]Hö"þ%V ÿÞ­l‚”4Å´ûÊ%›‚–Ýd|)³ða/5E2ܤFÁ$zG¬Íé#Ú¦CÿX¢.KÂÄÁäCŠ'sÞÒ°~ýÉ'áùL\P›¹Õ oýÒÈO¨)¡µí¯$ùHráF;".q2é#X¸Æ‰ýc ÛRç€æA H/:ÃÈÆ$y´ .ßú #Ñb²”i+CÖ¬ŒŠBç+OñÌW|áÙM|ÕPĈà+žjNcæm€')J3Q• ýƒ.°‹Iê—†Í1|i¦…ÀC‘vŒšübGDð<Ù_ý‚Ž@á³·Î#ùhâèöF[Èç™_ácÿVn ø‡*Ò@¦ÁÚ $“ª§@ïBÓqHk€_P´BÚEwB›“P^µ$»É nð•,í+uÚ?È'„äf$-ÑGÕNÖ†t©ª÷•$¦ÔšõŽD(B¾^3¦çñ“žôt‘wakBãK7¢¥øÊmÉÞÜ(•;J :AlòLª ÈIh9 —Ú*P)rŸ_AÄ#ù 4 Q­¨tOEæLž2ÚC¹Ô„&4ô{–Q bˆÆ€PÒpHÌ ¯Ÿu“Œæ!s Õ²R÷бzýK‚D¿ÜKVm»ª™7>~›(Zÿu\b&lCŒÚðF¡b:'ç!@Pí4ÆÅ,…±›´e eAëMrÆÕ› AUúÀÒMŽë²Ò(šÄ™ˆ9p–œÝ““ŠY(\1£±ÞäßÞM–f¤¢FÀèI·Òõòò. («{´¨’&M/Ú ç/Œ@ç~íÒHNÈÜ/+Å~|A£þüÓë|/aÄ1ZÌK"…À0”«[t †£Æ4‰L@˜¾‚ê ¼”¦”¾b÷ŠDÉF`tlÂ.\Lù&&^E¤D*CV ’´E}ĪnVú¾¬ðzÁÄï&®ï²¶/'¦I´E>ÔcÎ.âßdndÎ'¢ƒÈã?"e-f4¡Ði €k N ÆbŒ@' i$.ô çαtiîPFJÊe[˜ë1†R‚6Mß"Cø0âÖð¶.HthitO•,dIjÊ.2§$ÿŒÈ™0„âºê«n1š)tÍ™¼£O*k1zb#ðF"`JÀ®‰_&"Q01í§ø%Qê)úå€ðOŠ àb(RÚï&àï+,c¶€ #\ÑšðO oåÿe”-àíF†0>`J X\Hw#;„‹–øBÔˆ§¼p/¯`UF@}Ãÿ¡ŽHEŠâúЙäëƒú"—N&ìF(¡'‡¯üK€È¯ïàq"hð+tä+ÎhÙÔ#ØÂ*7â9X´¨{æb€¸rbX þH,b€ ÐIh_Zjän©#&ŒÌ /úpÐÍÀ%:0 L5áãû#¶âŽ&c¶V@h3ÒÔ²,5‡ÜÊT<…cbøRÆ8ÑBex‰1&)\0r“8òWÂ*¶G?ôÁ»B‰ +0¼~ $É`.„.ÌÄ1uòNìbnjj/ËÖTJ¬$«¦–iåqì&a"b&†IúŽMÈ ( /€F>†53"Q؆~Á¿Âl"6÷ƒ"Åí @¸þ¦°Ã4'ÄЉCCž@wÚBĮʱ WVG2ÂæaÿÂ…D4ò14²2BF*%æ$ ¼§l–#€L;o÷RcÂs<½¦ÏB¦íp‰.Úó+À1[hÅ6b‚nðDæžmaàjµ†‰n¢I|žc"ÚQ¦Ž-@.5½ÌOo(}ÀŽ<@6é!7ÿ9@/Ä?zÓÕR8q†ðÑc×ãX7³d{¡lˆÿ‘r¯­,Ówlä· /7~m¶‰³g}Ësã:íDPƒúO×r¥Cæò\,ãNžä ¿«ë0âö|ÄÈj×x˜en€B¾ÖB’(J#¤l«l/XE–°å•Øö]ÿ¥TO6ëð2ëLà ¹¿B5×#|W=|J'8¢|;ÀMMà?üc$çD òqU#¢þèÀÒTBlCïÏs‡ŽcØb `è$ŒDÖÿ0"€•Ž"MÂDæ!BB(#ƒbW¸x¹†®—y™—wèh_V`à.¥2±ê&±dò&ø0¤°¥<ûÒ1êfŒÀcM(‡ -td‘¯‰³ø…pñqY=!©£|ˆM Ô¹â9!‰“ÍžŠ-ºä”ïmgSÄî·“– -D´&'Ñõk²ҨĬ=Ì•®å»f÷»j•v˜§y/ƒ#n'c%C(¤ÖÞ-ÿ 6yKB¾â!V ¨ø–pPvSCå¨Io·ÁyX¿¢µ„°¨oB›UEŽàž‰Åäý,,OC§,î!~­iªƒÓŸ?,“@ô·\‘:çÒ8 ‹hõÉ€çR1P¤¬&Ãl¸jx4n÷ö¼N ¿¶¦nkæØ`e­Cê‘Î`“W“ÂBD€*ä×è³oÝE±qZ‘ 9=Ĺ]l!ñ\ „pqy!ec3e×—bàÊ¢ØÀŸçy‰Ó‰-?l yÖî×Ò°ª¶UsêV¾#„¶[fÆ“æï“B‡Srô+Öz­5zÔ SYŠÇHDƒë C^LÊ*Dí¤¬z< .ÿÒ¡;uŒÂºó„²À4= ùtš{×Ä*ýKpõœuœÇÕæF½ƒø&<©Gƒ ìù©¬JE\-cV”Q»·²uµ·õ~¹UsCEÄ„tgFy!ü£îi Z`Ì1Â|%sˆf4‚ÿ—Å ¸³x®v˜/™‘4¥Ní\=¥½ã¥¯{OôéSΑ¯È¥;ÒØ‘õí¨Pö“Ú¨1B©oâýÆåP…Šx4Ÿ=¹!G£ª?¯-ú-„&hcþ’SÄW®+ŸÍ|+#&{×ÁK£çU Jíwèj¸vrŸŽˆÊ@Ê&[%±’¢ÖŠËÿ<ÈÅc&dN|¾OúÖF§±ÍÎ#Çsœä<¶€*96‹ü+Ì´ÿˆˆéï&JO/— ž|1šsë·O\sé·v‰7ðÉßûÄP™Ì¥n,­L®E¢Ü:HÔx1ð Ã׸G"`e‰|þÞ¯,E}lüèý˜˜/ÀÒÔÉÜÚsòO -€å}ßW1ä¡OÛJ}y…3€æv8ÃyJ"ë*üw@5„G…diðjÈâ<â'Þƒ’$J<øîý0¤B°UˆÈ&?h1¶ÓRx)ÞlÚH‹’É|Æ´†møËì‘§½·dצ|ç7³5ý‘Z+AýDJ€X@h¢šþf=4èî÷óâŸ@<8PžÀ& åqxoÉ? Oh8ÑfâÀ{ÿŒYü§â_>~+ \á߆Vnø÷æ¿”ÿ_´iÁf„7DðËW Ÿ>¡?õý3úo„ D"ékê§>~.øQê„^‹ŒvýÇõŸ'Q\üâÕKU¯"Ùªò÷ß%J} h—í¿"½þù(b×nþ™èp81âóŸ¨hPá?Kœ(1ï‹%,$Ë»'oIÃr ð°ô¿‡«ÿàx÷ß=Ö±ÿÉch¢ÁKèíÖ`¯ë½&ÛØ;:BÄ‚µ[þpÙræËè- ÜrDAENšï¨ˆ£ˆò›*Âhúò³lÒâ_üùô[Ä;Ö…~QE)òÖ[][`†—_}ýµ—-V˜ †yà ÿ@%T6Pgò°ÐØdeÆÂf”å&Љ&Ql³ D›k°ÕfЋºÉ¶C'´=¦‘ñ qMpÔ„9Q?ÿ¬ðI/Ý Ð Ä”RJ1=ÓtYZ÷RNYÒ´ üÞQfޤ"U55žéñ“žPE¡Õ@ðÝIÜ}ÿàˆŸôŒ•‹>Qñ *ªøu—])Š(‚ùÐ \E öb‹UJ¡&0reø§¶…Ø I&[B‰cA§6j0D›D'F´§|'8¤ª@-h@1í…t°* ù709Ð Ì 4å@)a‡L6 „¥—-íäÉ Üå®ÿ’J dSpN…®@áåCVÅǧžw9ñO.ôÚׂí‰ÕÿèW\‡"˜^{IúƒEØB©a‰UøóÄpBc1x(Ð<¤~`©±¡Šbh³ +‹²½6ë]äŠ"oKÜ'€A=棰*|…P7Opñ–ÄÎ?7¼J.=Ó?Ì!]mMÒAÛä?u‡¹è6Už eúöóýSg ôÚ;¶ ™eö/õÚ›‹ØQÐ{ `‡ª"·9ʨ'E\X¤>زW…a:…fÌ£f—pñÄ4v¡‡—=6¢gI„²Œ+"„šk%§ Ã0)6Á£|­É&d ùv‚ÿØ¥ø") d¥´Jß®RL,ÐôÑm»;+XµîyEw”ñßýdO»óµþ'=Q¬=P.¿\?ÐYÿýâ¯Ú¿¨r½~ÉþCèú ‚½Ø—-?iÁquÀK¦•JhÄuèX‡1ˆš™@à ƒ]D8rÀ dW±!€Ž\u²ÙE¦eá“ÌŒ¡:Õ äXƨ‘D("AÜ)m'3ÖJ¬5¥j½ä„×RF°.p!¤jÈ“¡=BÐ.° dzÈ…@ôc¶»¨­¼àÞ¿ Õ(7ñÂ?{1X[æ¶,A€»[ü.በb”rÐáÈ5&Œœâ=DÅ„hF "bÿhþa"ƒ|ŽD°Zë('„Ð6¸™ˆo4' b"ªËˆ°$"¬=„&¼ãÝsÉÂiéN%4ù‡'˜s$<ã2QD².u©«Láñá&Å—³™ÍM¿Ï?¾·¨uÏ•ãñ×u E!ˆAx¹y®8ÈAƒ3Ü?.–±ÆÑŒàZädÆ?ˆŒUp¼ cÕšÒ8ð 0Pdh^FH“Éh7žjT:EBËJ»SÓ 9ÉI¾„9ÚùÇOÈdq EISÉ@Rµ2í,ÿˆÂô …TQåH¤ú†ªí•ma‹¢òb·LQ ò'.áØÃüÁÿC¡ƒD“S+­Í3O%Mõj ôPÁ<4€ÌÔDð!¬™ã¬D&/‚ $_L¤D¾b â\síDá#wÕ»­© À¤U†"Ð*‰“ùL—(ò6±€^dM¨BW¹îýÇ_ •èÛêĺÄ}yÙKÀä2¦v‘”B¬ÔþfÕÌ®yLfž¢Ìf>£7V“ K˜‡o##Ô܃#éœ:uµ„ÄÝò5H"‡ ’6g ÆXêìÚY-zî.…QRtNx“¼ÐüH’&Í#’­ú“\£ Bà†?T(üá… xA>#"וÿ0‹qJD»è-q… D2y0b$Â$LþÂ?ÿOyŠG ‰&#‘#@v  iNSYݤ¦E³“Ç ÀÙ¡&<äEï² @Ì ÇÏî1iYš#Û)¥»L’:˜š=É”Uópµ«Fñ­@ О€íOb‹?UyÜæŽÇ¸E\"ù˜;þì¹qU/Ûâ—ú`!x =HÊï‚·béZdJ4¢ã ä33½ =J—šqÊñÝÜc Óß(„5Kx™g›ÔÏRÄ¿!Œ–@¢:%ÞEõ$'ôòªjŸÄ£LUûglôáP’Ã7ËŸ¶Âa$9Áñ0›þÈ·J«¹f[®]?'úǺÉGf²Ëˆð#3Ì?(±PaÿŒDIgÇR¤öºe>†ÈfO³¹¨6ôÝ Œá›‹üceÌY4âY\‡„Øbµ’UË„w3y–v ´EÝ"d\³+SœóávÁ ¸M%†âJ“¯¹ÍE. ] ¡â&‹ˆ-ŽnÄ,ê,êƒóhAvç!é’:(6È6t9Tuz#£ÙÈk80Ù'o$V›-xdu°GÒi$—U q,A(™0̸öS‰ÂG „7 ­=½c|pl“³ J®}œœ<¬{¢·y±Ä—ÿ¹‚&´¶ ãCü´d€G“e]=úö¨@IéL$hüjCÿeW3ÿ†µ¨åÈ*s´§z/;Mð ì[×µ#’Vô:J†í%zŠ0Ù?¹K(bï0Îpf³ ªVè›-31ÌÅMrš»’ðä‹n[_žî½`Wî¾&ð£ç3Ó¤A dFÔ1ùê,*§aô¢&KÐGú&ûž„Õ EªýYØz»JYàki©mC>rPF8«”ˆ ÍPšÄۇΠ‹ÈíãJ¿ÏúpÌÇW¾˜·Õð'Ääè(3–ǼU Ò! äëûž×xD™ Fñá¬Z­j²·ÞõøìÐÎ3!%Îf+á ?p€YIÏbÿB3w~ö1$£wµ&Ð¥c(ŒçD #0w}!}1†gË…\úÐe& åð3™Çl#0$F÷À~ 11æe'2±‚¥GjwáS0‚pügƒ°G¢­jg¸Z–l”4O%4ÌñBµåOøHr_åHVÁ$ø/wõ(wã/%DBi|–|ã‚ ¥P„âs¼ÔT]‹8˜gtüPöàƒ†ðð¤1ìF¥ö)jwG—¥dR¨Nþ7;Xh,áŠa%ËaI·U¾æÿ,cØ,¡$ñpmõâO#u[¥ÃøCpÂ\LÄs¯„DrÑ %"¨ªÔ\R}v}÷CGaCQ>žÀ “÷FóPåXƒÀŒ€y¡r÷`–^_wOÇÂR x^Ô¥qŠŠ¤z¨0"qÿÐ ©PI%d€Ø’Eî„{MÕ,…1J·["q·5CêÑŒÿ)~Réy…>}A>Æ%!|Vh1‡m1Ç}â“, Àùp_Ÿw5ˆÿÀƒŒpG0G$ jOw/À!$@Ž”‘8#²+›M”5+ã„@¤…©N(Bvpy%ð¹7€ÿ€ÏÂkBó$ h×8öP#µ†Ñ–w¤d5‚âmr7{ÁDÑh(vA —  |‰>²dKüÁgfhi„ˆG1˜kfL0Y "/ð%`“8IŽG 1#0ÿp=(T~ÿ0¥’!ø†û8#¸b2µ!+OH•³¢™ŠDÿj× WX`aÖ•og 5±EaNÇñy—wbU‘eQñ)]¶äÐ(Gô/vA7zsf#!&F>üs&é©$b„âZÁ9,ðä8ƒ"9`90–(Ñ™ÿùÙ™9A„3“O©„¨ñ9/Ò±ÿa0¸¹HPò èHU•`wq7P†±aÅ)rQ€œù`VV£$jâ&Ãè&ÙÓxþòpÑÓ(’\„Fˆ°€è "`˜ÿ€aÜÇ ü C‚*ì)¤–ǃÿ𠙆Ÿw›ùµy4˜*œqzÑ›£d°© I¸Y›OÚ 7Ð KÓZ±uzˆkùP –!y—Pi5Ø–,‚â&mbhã¦èC7Ù z1Q)ˆ}%™,Aԇ؈£NÐ!jDYA°ˆQ9Ÿa*©ðž: ý)A jIè1j{ôÿ˜2zÔ¥®7œÙÿ, q*¡%T` ÉqJgñ¡JÖ\L‡yåénQÐç’*x}Q!Ü×\}sñà'Т8òÈž•j©Gô©Ÿœú Mjœ*Q*™½2X­rŽÐ¥yౚ2ÐfOJ«!qe –"t¹ˆpm¶.rúrú–»u貯AT¡Duhm1!¦‚ÇÕV)fOƵ¨4*Iò€š•9$”¡y™Ê®é:誮10®P¤µ±­ùÐ䪳²·†¯)Uƒ Y•J{^hO;ˆ0œ:zBv!pCl)|þDÿ¬ÃHŒÄx6$š,ÏÅ8bf’¬†h˲.Pׇ­3É*—‘!,p”jyàú`Øç ª0R³* ¤š®±„µ1›” E ¬ði‚E:¦e Е¸†¡bœkxZ‹ºi¨IwÇ[f2Œ()(Ù\{6€vs'¦}}†aúP?.`I%&»žÏ ±A™@®2ñ0[ ð…+Hð#°c„2QI&-äwAŸ‘.Ÿ1 1}Ÿ£DÊ7Xi¤S.¦Uv D:¤£:ÀÒ.p*@aÀ_ÜÔÄ!OÖ‘³Á³-²mTý/@>˜³ݼ¡ ¢ã0rApª&™äŒäL§Ñ!4$ÿPk‚>Nö%ì¶©…Ѿ>~ëQÙ“.âF “«íÈ£l~CÍD,V.ê>†^¹Á*@íY­#ÏyðŽa.ph™µn"¾ßû¾æGç™ ì0ëÁ‘ð³0/po¶!Aÿ„´Ïe§MÄ!êô™ÿ°¤êš†À-+“}ò“^Û²-pƒÛN¬ÞÎ1l‰C9tSîÖàýM·ÁGZgïzMtø¬£p+@È‚Ðڽﱼ—}â³ãÃ.A/ð®|ÎÞÚäÇ)3 O=$ÏìÀ'’‘³û9³Ãþì'Õóù#Nä ×+¿íù´.›~Cír6Ýñ!,À&û.Õ´­¤óå‡ïêRm p]“XGPµŽÐÝÝï’ë!ÎËȬHè˧ÿOß¿…ÿþ«ïƒD{CУ÷ož†þ“·ä߉"A¶8Ñb$ÆNæsè"ž‹NRžhrBÞ¿{vÊÃã¡Ð-Š´¨ÃA,…ºÔ•ÃÿJ)ñïÅ‹G|bpH ²Â:ZUíÃ%÷L®u˜dmZµt®1ûðÈ%$wþ âÓ!A´z(á_Œ#GýgdŸäû*W6B Ä‡ƒ6䇿¿|ö>س‡1£ÃóP>$ùºä?c*5´¡g¯t” èëíe_,xvý'VÀ¿ÍNvØ\ @¸ÕÕÖsX¯ÞT€(ÞÁ€}ö#ÿ¼÷êuÿ‘CûãPÍÒ_J_‡ýËÛ÷ˆ¿¥Z‡À‡®ú»¦¢"'°Š²Œ¹¤–“ç ò©`!~þ -4ói4ÓBHmµbKi¤×Hú'#{œÈ§¢É‰‹4@QŒ;"9æÀ G ÈÁæ,£.B¥"³îŸ›t¨»îóîŸò¸â*®’Ë ¾Çäƒ ¿šøh¯÷ÊŒêLþî[n¿¢ð!yRÂò/*¢0'[9Ì¡ è±(#/¨²ÈrëRLŸ rÈÃH%"íÔHlÑćT:a5•zq´…\pÁU Ç#ut¨G¯†ìŠG玂°²´î©ÿê¨gÁíšê£ Ê£2ˆîüêK4—b=«3Lûrs9‡Ì²Ö!ÿŠºG%-j؇zý§0Ä¢`-êŠpÈ28a¢„uR=íƒJÿ‰‚Ä@e©¨ÜœÐíRyqA<Î VKÉ8äÔ 2ÈztÎ!ꆺUãê@xҺ‚Å;ªŒ}ˆÊîþ1€‡Àþ*ÊÙ{8`ïÌÇÌRö#2ÕÚ« ÞûÙ>7¯ÍöŸ8å|‚Û2eÁœ"¦ø|ˆ„- )#Ícr¨P1Å8l(R}6|h´}-m‰_ÔþùÓ—þùÍ…íöÀ…|œÈHNujƒž t¨ÿ¬![J(#¡´®ä!êÑ3ʲªêYùŸÁ@ò)Pši~¨ÙgՋ̼ÈlâŸðÿ²Z½ôdú#bMFW×tÍ|­Àjn9 Q‚²:Û³ TµG‹‚îšiaþ!ïxò"5Ž< ¹ÂyŒY©ŽŸshë¡Jd]j?*^£ vò¨pêËœóÃOõú jÿ|v&f}$vä@hv&äÂ!…ÙÊÒ´¸bA|jE*ÊU<è#—± ðµ}  T¤8¤<Ò,$DPRÈÙHÅÔÐn3¢[ÚðO©h'÷hŒq.¶¯0'cÓ¡„”ÿ¸1¥‰ºzÒ“ ²ts¸[J¯à -9$=ÂÃF÷ ÎïiBêÈèž™½gf×2€Þ”-Ÿ|ª0¯øG+š‚Å*=0CÐvW˜Â¥ïƒж\÷ q¨QIÞgVX6¸ŒŠ. a ÿÁ  ì’ÈGÀd£ .‘­úÇ@€ôkfоtŸ9–©'‚‘@Sp¹Èýñ0 ÁÞçÁèX&H³ŠŒäã1dCR!Ú¦'*µù†!ñPˆÁ.©RÉŸ¡LGP‚’ÿ,VÀ ]BǮ˨o LúG+ÕBÅÆñj~½ÂhYr!!S)ÏPbæ¦/¥Î¤Ù™C>•Æ ñDuÏôŸ^@׺˜í,@ùȹôho:$ƒO ‘4vÇ¥M%ˆÅJ"BˆøÚø‘ÑÔS’ø¼??£·å7¯1Æ bs²,1•…;ˆ²¾BEç#($üŠ¢M'Úò~u¹šdÑŒN,9&ü+TbªÆ%,a™›âSŸ4þoMÿP —瓇L%T;E—rY]ýàI9Û\™N#!¹Ð£`’¡ Aª•¢ª¨ÖC~þ« ¡I¦:"‘ÿR¨BRá€Ç.‘iq^$çR¶i»r”¯MÒë?¢ë¤ È€µxÀ1 ˆ‡´QK{îñFEëY D¯Ñ®|«\}zJä ¹öQ­\åíC Vó @%§·!§*!†‰€ã™}Á„o©J‰ßp¤‘°À]û-Š»Ô’¤ û5‹Ò•Ÿ\³øÜ¢`ÑWTôÕC°+€.¶L;û‹1h£’¶€L4†ËN4ñrI@R®8í› š ;zšÚ?Þ÷¢‘Bu]0™{„`".DÞkÿ¡eÏÈv4×ó pÀ<½ bô8ŽÐ¬8Æ!ˆ BC·Jµ®ÃÿÊU˪%_:©Äºì+SLretA+Ë€Ræ•J¸#àU)Y×Ò‡´Ø!HnÔ‚Tœ+ÄT2bù£¬í—HK2‚ ‰§vBRZ.ð< ¢‡ô†_½¹^¢·L©YÍiîÔu9ÌóÈÙÇ i(˜6ës¾¶Ðä£Õ,Ô$ÞðDAD÷W‹RS}¤Í`yЫNž!]W¤HyÀu]õ1jZJÿس/¥V2—_ ŠDF¹F©î’´@$ôh„éá¾9áÁÿØáw{èóg^Kää vÓ¹^µ,÷¹Sl_ºÞQ&Ç+9Pë*‰[¡ƒ,•4’"³Â©Š´ý…ÿ²‘=üU—X§¥\OèºR1!µ2cëU(Eÿ“­¬<Ýùã¸Øøqñ5Öui¿T %4á-‡¼EøµxðÃ¥[áƒl^ÿäñ­Í¥G¢¶{AýŠÅÇ1%úN¡À‚Ð.B¸’…Îý%ËæyˆIƒ38†˜½ç™Ñ—Ô ¾!‘œ{±=FЉBB»Vqº"zŒ X8sЦpr±œ>³ó¸ɱi{œ=bÍJAÙ”kÁ ¸‰‚è‰'àÁ–8·Œ˜¼îâ™`'­ˆ Ôƒ x…NÛ,ÈÁ¶ü$8€÷{ˆÓ w9ª¤2žGÉØc°¢§zzÓ¨ˆ‹(C‚ ‚Y Ý+y葸!!…‹"J¥ëR ÔK>܉¶@†ä),:€Ò;>BÛ-âWè xÒ”!ܵzÿÚ›]¬‡˜Mq‡p |+¡{ˆÍÉ£mÒ•)‚ŸÃ € :¨àb%"A ™20„0C{°²‘‰Lù——ˆ›òƒz( ΰ‡yŠ#"§û®´:¾ˆJ¥‰ )Ûy†ª@†B¤Šlì°Vb»Â€kÔ"»^ pˆx×ȈÈs‰Õ ?OL›\€žyüˆBC¨h K.¢&DºÙÙ“£K+ŽÃ0!A½WL¶TK5âQŒs=²YŠƒûˆ­³”`|@¸~üÝ{ ÎxÃ!iŒàC”“<«jT¢ß! ¸‚’ò†ì3dðPü‡›Dôø|¨’ÿ“®D„ ‹JD(Ô‹èG•BÆ ¯ûªª äĵQ/Èj÷òJ.±4R, )º7ƒô¢Ñ;IàR+Xd2€#Fˆ†€ª×‚*Ѐ”<›|¨:‡˜‘,CѱÀùLTƃŠ3X©F°²äp?áC+Š›, ð…™4ɬЕ DÎk¥Q½?£¾¹úˆ `GÜ»¾)ŠèÁÇ\à*†`M‡èÁüˆŒH0~¬h ùbÉÇØ–„ ø h¢¥¸Fñ©&ƒÅ†ìUÓÙʧ¢xª㇠YˆˆPƒ }±½ìÜ ˜¨ˆ¥ðÎȇy`eQ¨Ñ{ŒÆÿPLõt—ÔS±f‹ ÉìF ‡ÄÍtÉÌ 0€¨@|Â|œÂÀÊæIÍ|ˆÑÈšڃͽù—Œ 0‹r‰A< $¹JO3%WdÌäp»<  XF©N‚CQ§’N…@ªR­¨°5P±LÜHÓP݃C ðϬ˜óT±:3¶Ç@;7kÈ,TŽ#˜‡ °~hy¢K„{ª-K@ 2ÔNçÁÄÜx¸¹Q>«° õÿô¯Ð@ÿ{–Ï\ ü”Ÿ§ð›Å’Ì ûÏ&eŠÀ3¹ÐDr‰b» —òè¶lt%]R°Ð޽#4ëp…<‘€±±½—ÀG{̽™‘…UƒÑ*†À!‡(ÀÈRt…ª¿ð ¦VÑÍ¡H7³Ô®AŠÇxEDaE‘ÖJÑRQBË-Ë:|qÔWÝÈÜ ݨˆÑ8;l³ÄüˆIKj$ !ù ÿ,éÿÿ H° Áƒ ¦ÂgðÆ? 7( úg‘! 2þ«`¨Â?D' t¸à߆FÔh¯‚½öþAùO¦Šx 6üó!PgŸ@ƒ J´¨Ñ£H“*ýYë¾ÿRAhH Š/~¨ðáßÖ|\7zÌ(âH‡0pƒÑ?·ŒÜþãWÀž 1nб‚Á? ø60\J¸°áÈ+å´qªŒ­B+–k>]cÚkiïÃf~s»‚ž,äˆ9 Â}ûöÈ®4œ˜;w¥ zVÌ»·ïßÀ>}YrAž Æ Z@`s~ü–ƒqcDƸÍ{¢ªÅóìñÿóÀ/_NŸÓ_Ͼ=ïQ áˇŒ¯A|ø¼QÕ£ÀåpÙCO ÿ ¨‚@"˜ B1òR 1œ á?Û12@pAð+Ü OW•Ç%èÄP`ƒ¹§âŠ,Ÿ@µ öâ(çÔ@†ôAÒ#=› ¤^ÿܵ\ÍýSÍ]³-ñö©OA^;c±Ìà v 7 9Í£7Øz¨TÈ÷+L¢8ÅŠpZ |$ ¼ Èi' ‡ÿ9U§ -ÀlòÒd”ë=ð‰‰Á<¤8ñõiOU¤Ñ…3’P ,®aÀ ,ÍãT:Y€˜Ò·)Ìï("$à !dˆ9Ì!tÃ!jˆ„›R &€ˆÜ`ø]ÚªÅF"ªŇA,npXY£’&€Ø£kgÜ@n7îƒ#Ààøó¸Ÿ&01 ­ Š»—l´&Cˆå0ABÄ”)ôªD`tK”×QèÈfòX¯ª ܆úÄ+=,û#Nà´iYê18Õ *Ð5ÀA•!2ðB• !x4Ü8â4üd‡yùO¡ÒGÿ8 üm®‘Õ"‹27gô) ¢p‚eÅû,*iŠމˆ!.áÏÀFÔïo4ˆàʼ` ü€ J¦µØ” éŠgºB9”©d €±^éÜä¦Áôô Îœ¤°ê3ŸZȧ’P‘W+~`œŒ»Ú?ü€ø­òoó¦@08Nñ`lC˜@Wb 8üÍÆ[ü;ÿ<{ä#„¢ç((¿¤„ =ÈOÓ–È6éÉMUêAyfE< ìE€¢nnP‚À#/ê€ì¡4œ!]Í,œÇ9‘ì’xÇëŸþ裀å#ù@ hl$”!¨_yÚ&üÿø•!4¬é,¡ÐYùi`£ÈÓ|~5 ü*øù!Žƒä,ñXiG°àBö[‚ò‡¿ÕrbëÌ?.S‹èIÙQIðú“ÒÍmn?u“:tÛ¶HLÑ ~¢fp%ɺ¦üåu?¸r08Œ.É3©TR^ù d3&±ž>BÞ|hWÿè‹:´2u†¦¹Íçú:+ÐÖÄ‹ÄÅ`Ê@_ˆ‚fó‘·ØdIѪÄý ºz‚–(É9Ý"\W·J]Ìþc•Wë„õYµ%+ç2ü@ÄDP’’è£<¥¢©CÎ3EªØ¯afAð¡âÐK…½Õ­Qµ.ÿšÖäï? d¼nO¿elrp„®X˜@«š„Çh•y†ø]Øœ gõ/!ù("öR‚`Ø?ù)joóE*±¶`^A¾,f¡B¾iUPº‘êô¦´Bv³H+JÖšOsØSދŠ` ¹,ÀÈè%$x­p,´A08e ` ÷Óx¥ªG ä2ÏÁ°@ªÌD”g9ŽÉ.ƒ–Ü F‘ŒPÈLf+ EÛ-ZïÑR…j„ÕùÄO–s›ÄoÑ®[ì¡·Í‹óÉäê‰%0J`áyœì±?Vð?8ÐÕBZ«CžRóœE±DjÍÿ‰4]†Æ DTjEh•ÊS€Hû?~î‰2IÌ÷²N(æøGó €]‚xb"øG6R`©˜ÿ ™ l†@Ï/ªÃ?D!Š@€:~ñÁF³ 5ûá# ( ô¶.BTz€»¥„ä!y¶b²ÃH løL_ ‚‹ Öo{³âûd\È+HX¥Ž0› aÍŽIÒÀÒ2ËÕ„«èl&ö, dåMºv<Á Ì|.üA¥W ñ倸#"I`K÷óWõô÷£ß@–8õ¶ª19Oþ‡Ÿ0=Ã`'´uš+Oz½»KÓ*1²j/Ržòÿ D€´”§Íúý£F¨@./ç€`ƒÇy’ôT˜zM Là×Íå)u‚?NÃC?v¡l?Ál,LÞ„-?VÊQnÅ"P#à—¡r 3>rˆ£*Ûfnž&|9¦WÅHºq%ÑI0•6ˇ´ |Ñ”ABC^ÿà ” Ð÷I‡7àám{a,+ð‚¥ñè—±/!kôN³p§7&¸HÁùE7ÿà2Æ…*;&39BdrQÆ LRòÐcøctQtñMWX>B äQ  â‘Fm–âg`oiC|Qj³â^(ÿÖi°R|ž0UÙ¢aj±Q˧EÁ #àz#Ðr¦ÅfÓ‚f3e ³j·†ÚfuÑÎqsåáßd)„×->Tct“XuW`Ø pðlõC!Òc›! 1QÍ¡:sXr%A5Ñ‘qùØö,Gòcà(C»ÔŒÞ@â²á¹§6$vd6fÃ×­R1wŠò66PR ka„“â.Lˆ„‘ˆÐS•„!Ši—aÿð‚!‚a"À ¹¨åf;æúä ƒ÷ ù#óDpdcƒ1€QA0`‚³)Ÿ‚Oó84hq†ÿÓŒ¶é7ËBPFÏqŠÑjEÐ441°vzpÕŠ±@%¦bŒÈLlB|ÕóùøbÔ!ëµQiG”Y fÿ° ö°„;’~áW†aoEE@ jÍ÷fƒàmú°ØÞ64~‘–‘‚’ødï‡~">sQU,L¥sNuN®ôlÁWJÒ4A”ÐqÞvŠËÁ„Æ–4WIçI—bæi³G÷ŠÆâŠ+pD­²vöfó0„ÿÀ kwmß„—@r oA ¹#"u8øßÿVˆÏ‘.?2…w‹!*$IˆEù÷G(ÆbŒ°Y­„<—·C›8P†axF#@ 4ñ‚ü 1ñ Ð¥$vh‡({Ÿ¸#v”GßjÕ)MpyÿOQW&’H$jb¿)`V[u‰uDiu±LøÙ’t5'˜0X‹0 ‰„§Qä·ŠsÁ~™–i™3M‰!$Ùñ1M™aøµ%ÁÀ.IRR˃5øTZG¢q6hŠI8eãÅf)ᥞ°Çß*‘ƒ)M°ôÐHƒ)A*ã6T†SKÔ›ióe÷_÷q"ÕSœI…ÿ´m5R6sõaà§1+Ð#€ay¨jCñ‡úà`ñV`Aª'W(Õ6Oð$pÓx*É9)á3\Q«4vdw$D9dš1^´1ÑW7Š ·™G¾J¸š¡¤)åòúšJiCH"ø1:%ºD>•‚)x’ „»Ñ‚ à i,§q†Ô!D9DS¦ “Riq5) PiyX¨Æzóºš|1£ãåq~`Qžá™Áìwr­Ê·Mø¡L£ô3t³?À_Zjh9À4¯™¡à4$$3)ÑŒQk¬*Û”¾ÊRY£VÛÿa "%K#sÚ)q(’v¸›&¡@}e•{µ…5²bH–vj±vê®ÞfÐQ)WpA| \ðy0©ÐacÄYv~±°~œ¸r‹8·GcöI%±%QÚѱA`L.ÊMS$~Û ‹¬Ê*Uûºj¥”I²±)%õS­òС'#%xšC1!eH„6:ŠØWñ˜";%•’vé:A#e‡[øVs鉡ªy ù®Q¤^ë·#üà ÓÍa;Šâd¿¢)A†ð3µ±é“«%%¼C?¯ù-Ü´ ËÁ‘–b¶ÎÿDòÔh8! Û!@J9232š«”'P›åÒXRZ¸e D :„ʈ Fcj©¹•r»ƒr¯B¡]!wD0ƒ^°ÓQãUAI(ƒRCCƒ’‹›"û÷‘B£ÄÀOÀ¥Õk½—w4“s(3 óD ãšX3ÈVaãµw ‚)KP­R"!µÉ¬Ä†5xê„Q”ð.»áD'‰´L´mæwH À*(«›rk¶è÷vˆõ´Á“‚~M8—~x¯;Ò°¸Á%¹2È’ÄZ‰'<oDãÒ-ÈfOQy’#!ó0E‚œ¾.5$ˆRZåYszÿǃÑòP›ô´‡!àÁã³6xK´‚š'¥;jñØ>!o yqy„¼Ã[]±0'‹*JÏáàÛ|‘0m» ù 1÷jE*ù¼Z™ˆÐ·‚Ó\–éF_cGBS,ì³ËÓ5õs29ÄM"11´µ¨$nå¦AÔÈ¥%ˆo©úð–Ú¥¯=Q‰nÑÉ&ª‚Ž(Jë…‘z„áW–‚D±R¶I"ÆÂ‹ÝÌ-Qª ‘¶úp ‘0—:)Ðt±EÂ7pÂ_ÓÙϜ¡ÞÂ=&Hæ²)&H0I?íóü4ƒ(£zekúªüÿ“Q¦"°ÓÐçkZÉkòÂzn±Ss£p¥# ©”§*¬>¦…EQV¿á·h©™§1s ¾Ë~\¦ëzŠc±£.ZYüäy†ö7°i2É6 2'¯™«D ›½är­2äi±(‚ÎÈ%8-.·‡a P"ŸæPYd¢…6?p¥rîâ.qZBI2¼¤?±þæMù‡PÓ„Nh¶Â«Ži)¯ ,W!J#À¸À»ª§},ER@”ã7 ›Ò^j†•52ÙkOöÐV;i› 4åVí’tf£ +  0(ª„"^s1Û9Ö›Bÿ0 ß-|ZÔ@i=š-¡ÙL$ @²CàTÚ ÷/ë!ÓW—A&ν#¶ƒ‡ž¡Èn³’ bõc™­48VN“3O í)_ZYUB?{Ý)óSYA6!@m¥ÈoÉ% ‘èVâ‘tü΂y¸A|$Z‚5‚ÞJ¨¶¥ÔÑšœ=¤ð4å1SÔàô’Oc¾ß”âa;ã&^\Ìű7?!#¾ˆqÙ|Û5¦”Âûù–9.•—3€DBr½G°e¾×GvátM ”-ð«lu¾2éÝ+àx¾Ä”°Äp)ª8W ÀÉè¡DêÖSßÝPàÿÝS q¥CXH§‘haž’nk…µ3ƒÃqJùÍ^áV╸ CÑ¡™y’"±s%S8­$FðûGp}4÷BÃnæ¦Ç=L£4~ã³wÌ)’CONh)ùŒ¬mf£çq !V|E°"À©ª2"LÌH3ŸõÄ&±ÔYGH^‘iaád¿*ä3#%Žƒ”ãκ¶â‚Â;)c=)x²'S±2wcÛG&. ë®ÎUežŒò$°6V.ɓ׹^ÜÈ3­"Éá‘ÎB=Àìÿp |Îì¿NoˆÀç ÔiÃ7T×¾¼¡F¨%ú`ÁÞâã2ÿ!“#ß¶8ÉÓcĞܬ?M^›®*ÐáÆ°74‰·îlæfÎå­¾Wæyœ—°&ä&9ÓX?˜âÈñ;>òÓ?!ëu BÀìeñ&¡ñx®v.@Sˆ B+Hò'©ˆ¥æ&X)F ±ÎÉßÞ‚O÷Å)–N/º¥UOí,4¦÷cÝLk½7J^QNN_RedàÄfèÛ1'^Ã)»N8J£)°é³FÉÒÜ$¦7' ¯ÓгĹq _öŠÈç;!Ff "à³­5Bò{À¼éÎXìÉ‘n¦Pº4Ðè~ó‘3V­Ow­áœ^o¬á…$*ˆ,êÿ2NžB%çd™ˆK1@²vx‚2X3­ohžëòõ¨%©•K\ö$O|d—„ü£ôïßU ~0ØpÃ?!ø"þÃg°â¿Qnü·a þâ÷Ÿ¾ ùÚû‚‘½y'þÐ ó„Ì™uîäÙÓçÏ÷6.1¨¡!=£9é5´ÇïË…%K²„j*¾Q[é¤ðaž<ƒB`„À‘›3c¨°Ç’ÑRƒ1ÿ±XÂBž]°uƒ‚í)¯‰¼'æ5ü Rß?DÑPá? — ”ÜðRdëœ80³Á‰øðá ú!È#Ræ«€Òê?·ô`⌠ÔöÿmÜ·is\²$pÒªÿ…ø—jUF@ !¢`УG ÈñoŸ€}F8žˆã½áÿbЛóÑ%òø.9"ôž<±a9¶àžJƒ‰ç7¸âà? B ˆ&ûl Ê*"1Ä8zˆ¢piè"‹6Zà† ©à†þ)Œ¡·ÞîŸÁæjÈ»Ò#ª!žÈíEÜâKñ„&ŽR៤Zàk7Ødƒ«Ãï^¢g¼ìQÂ(0„‚æ.lȽr;þ9 ,™Æƒ ¶sbÁ õä{ïžöþÌ þ ¬Áè!®!óÛ¯!^ihÀÉþ!2ˆŒÌ (B§ŠD+§²rÿèŸ(ØH–žÚˆH¸äY1§ôd”ï6Ytàè‰*7u£No«É Þzûθz‹% R¡<oÅÈPçFbô ¢3HºŒÈáX0¿”I.ƒd#‘¶¼, ªL°â³,,é[j)†6Á?öó|ðÁ Ì@ãH# н„J6(È?–£(¢‰¥°´Žþû§ƒ\‚Íž§X¯¼dR¯†.}2,tŠøaîáÀ‘Rÿáàà`:ù*Ö‰cƒ>J&£h£/½¢èQa©—IŒMÈò4¬¼/úa$C~éÄš˜JíIJ+-ñjÛH½{Ü‹¯Ìöø*°úŠÛÿ¨1nðï±"*¨ C)³Ï†(©L2°áE¬0%òIBˆÝ(þ ¼™'†yjÂéž%ÞSQÚøDžx£ÃA®Øã†Lö˜ƒ‰!7¹qƟ옧eYE³e *Q8g¿;ؼ¾1 É‘˜4(92— @)ÿ)µ½2ÍTZ.º¾–L0ßÛ”¨››g)û ÒG?Ç5(¡ÌÝè2ÅhlÉÚå³ ‰e\cCšÐ &.»¹‰w²²Ÿ%Æ|iOÉB ˆå.´9ArJDÅdmährĉ:Õ™ï—4ˆ$w"O:m†ïºD&/c™^µ!þ‘‰Z‘ˆ i ¤qˆBz$9¢PsÈd•ýÄ⺎îrr²›kɼˆQ/ör®b9 Å„ÒÅ…%p+ZÂyx©¢\ª 8éÛ«†d3›$ÿüÇΖ³œ ¬!ò8B©`—Ó†à„o#Ò‰î6›Öù¤-€€‡r˜Ä Â?‰YÁ$™ (yÎ@±Þ»ò'JtROy:W>pPˆì #Gt ÊJ.yIމ¼Và6(±.r JwÍ"v è¿4YÉ‹ H;ZFqZQcs5ìNž©ä ¨™|ƒf£4Syè.hRÊADf¢/±oo8ùÒŠî’)¾ o2H>úÙ˜Ú.õE X*èt.ƒÐÐzÁ}—Ùx2'Ѐ¬Y!ë¾6ð{Ù£•Ÿ[]fbKöNŒ¼ /þìêAŠjq®"ûØÆÝŽ]ÐÃÐÄ1ƒÆëg’’äŸIÚ&!ªx… PÝr¤ªVÛÙ3® ¸Í Y¡$TGͪE`ÖË Ïd9 ‡—#{EMÞ—LFƒrOJHÆÓî%(„=Ê[n„£˜4Ù‚ ©€=‚Ñ(M Õ1xËç|‚/é.>±FgK8¤ 0¨1²}Ѹ*ܼ¼"P>±a‚.!/ m$3~ŽÛS)¡`èpËt/ÕºH«vŒNô½Ñ»~ÑÇœôµKÊ¡.䞘L 8x› ,6‹ÕLB­ùî¤Ôv±â¬æÏ x&%À–ÿ]îAkÌÑ ­ÖFlK«™\~ T)¡ Ëy24„ÞN.RD nÐfÀ‚Ó0ÝI'Û›Â%º},䈹Òÿ¨zkR®Ña*:w.ÛûV(¡ç($ª7ouò½¹0ÌXá °MH”ï´êdaŒýèQÄ’ïl'$y[Ž0UÍk³Tñµ8C^f³G B·;I¤P$žÐFn€¡…ŒMbI7P}›™û$¾9A`Œ‘“™^è<‘qÏ_œÈM/mYô]UM˜E ’Z}ðùÒ=ªTœ5á× ð‰brÍ09t&,ÀÕÝRæG6$Í[ÊØ-¼<@u¦çdÚÿ¾Éw=(ÄBÈÈ(”[E ŸšeªOËžÂhñÑÿÉICûc¤l)s` 4` ™P­F4ZBÍw¢"–…aH™£\¸¡T@)a&6 2»ÍüRó`„ÞvbÚ„×j!æp8ÿPˆ "Ÿðµ±³“ é=Û¨ ëŒ=S—º‰ 99ìb [²¿Ü¸6EÛ‰ø8)¹¹djƒ×8Š6€ £ ïS“öê “ºAŽàYJ³ù[°à·J“{­³ïÐ;¾PÜŒÁŽúÓ¬¥‚¸lŽD3° »±3;{¡„s@Þ‚ßÒ‰xI>3¾ ±†€;s#Zš±ÿ˜ƒöœëÁé ¤Íº´†Åâ‹Î1'°'(€â€Š?üC¦øŽÎ9<ÞXxÓ ôS¦†¸7h2ÍZ'¢à‹Œñj,)‘I¼‹à¿ïè–2«-S”­)TÀŸ¸½Ý¶ô ªj—ê9›‡P›áÊ∊ø¡  6F€:Óª(2x#!j(Þ˜‘ÂZšêc cð>¸(Düȇpjlüˆ‚\©ç{¨Ÿ úŒ!Á‘„i,(ãf‰ $ACú¾´ëÛˆ&tFèã¹£ÙB³†—oéÇžÀ0 ¶ /Ô cÓ!@鈇¨D1”°rˆ‹”.‰µ5Ò”¦!¡ÿƒk«…22)°¨Š ú0ˆ(•P ø^øHIHIЇ”ü‡0Äš &õ:4Ÿ(¥Y¨ºµ4‘2Æ$³ 5Á+y=J%D@â7øFXŒ8*“h¡“ˆ‡­m~“¨]–l¡ÃhÉ—LÒU|Õ²4ˆ‡ÈÅç©\•p 5!<ðD<Žh,£HŠáICèÁ{•¬×µ’îmˆÚé·¡ Æ'!–XóRUlpéº àÜ à”_ÚˆA 4ˆp“|í‚xÔY®|I¥pФ ÞÉá2I8„ ©àÿ™ŒÉ˜l!kÄÝ}œI^HOŽ8V„UçÑ8csËâ”S-Ž•J¸ÌdBµ™ÌŒ%ÕžÉ5õáÀø0?jšø8!ž*ÜíUQ‚¯{ÐÕâ® —ÅN†Àº“¬âN݉_ÀFBµ¥89C%ÝÒå3Táê(B\°˜lôZ ~I~à®åÚu3f:Ö V܈ὰ;9”ãmØsAO}(€z㩆ˆ,íœ dY2„%ò“»`å¯ô:YéU«œ–~kÂQŸÉ•-} }pª9IŒ#þ€¢-Zø„Ïtúçdz¤ãÜÈâ˜mqü8ŒÃ°X~æ{©ÿYÕàˆ ¢–s" Ù ÝåÚÚ5æ—ôË5ævJÉÂLf ^:AÛá2Þ—fæÂŒZaF,y¦÷yŸAjˆ—&’8ÄÔ”ê( ²¨ß9§›Q¸Õ«C2P'ùÕäËůÃçÅ~…^“…¡®øÜÛˆ_H âZt˜Ý,Žèuá3h^Ÿ”ºö`Öc¡( }5’nIÄP^^@—TLÔvê àí…Û;leÛ‰ºíiذ…v2IÇœ†Š#› G–,F¸˜g 熨ÎÌ4U¦OªÏʦ‚YH ¯ åPr“­ I†´X7»ù€\8ºÿ»ùœp‚¼¾g`Ó3ÜÈ—‡ˆºŽ´÷Ðùׯ݌¾×®fËÝÝÃlˆÂ TàíÓW]O!ÞMÂ*Ë`ÕÇÖ“¶DÌ”Lãj$ ­ê刦 ùê²ð,+q“e#A¾‹” †{ÓØfIÒ‡\ `9QÚCb9Ü~kmLâúŒ°þYÚ àΈ;Žˆ~ø ±ŽÏÄ2¾h¤“àüð}pq n*’.Ì•Í_Øî?¾ X%^UhæsÙ¤2ˆ ÿ`®4Éxd• %×éš”Iü€ Y!QÁÅŽÑŽ(PÌLÝ1M%”‡k ÉÈ%bôÁµ¢­ºÿ'°ž)¾‡¿ø‹ïp“–-ì–ˆbÀhå–øW†À >¶XDÈ7™KÆ:“°W}€`™ÔÝÀtô•¤à׉‚ÅYžXÕ¸8ï8O'ÞN*þX\€¾ªIV¡M*  ·aBÑ – Ëˆ9ñ©Ç”Hô>wà„`®Õ]h÷žˆt•>UKgOâ^‡µŒÆæJ†Õ“<î€c È’âù0õx²}Ý’g)/èê+ªõ5“XpCŸÖ–¤8A𨶴"fi‚ 4 ÐU i]*•`r_Ò(8 …0¢Üx2Ü,Á¸.è€à®­|–lc©Ü¶mŒ@­\ïvU@é…„}†E^‘æÈ.Õ`°¥KœÒÙYŽ~ê ììc È ûÿy¤Š‰Dâ{×4wvÙ‹¤4«x†€j àÔå— »½Î“&˜bÐM*ØZ*ÿÈj(!Ú{~³á”ùž˜ˆA§1b“«“`ƒ`ñ6ßë$ÆÝHÞ@1ðþâ½tƒˆ^>zý+h° Kÿùø§ðRC†‹è38Þ‰ƒO,áÈñŸ<‹ôìÑ‹A¯à… ù}(ÈHÅÁ{÷þÝk"?}úìÍk¡ä’,2jü`‘ˆ")EŠHÒ‚ôIÈ÷¡¥Õ-éq=yò½yÿ4´8ѤàLŸ'óåÓùÑŠ¯üÓù!l z-|Î ¡OÄ †,ùi¸`áƒæÿùGàð‰ÿ*ø—¯.f~8-çsÁÏÅ?@O4(¢ˆAÔ†Uk$¨ª—ª">"BTÈâ?O¶z*ˆ»÷¿"ñþ,èÓ`Ѓò–,9–¸=““%h´G\¬†Ég< U_>ŒC†dÑqh ¢7™¤PP… V¬ø!ëV®CÔ0ï„Åq—=!D™RÿFS—ÈÕE7é˜ PBÉa‡ás] ÁÝ=÷#–©ÄaúÄりž¹0\Rï•c††„Zl¯EôÓŽ?áfmåã„uÿdÄsF&Ô=HŠUb‘T0ÁO/@Ô Ü=’u—µtÜæ Eÿ”‘µÄÞ{À·TAQý#ÁTT} ‰õOa]T'´ Ó?MȳWmÕ—› yWú% Q²a† ±Áÿ0V4FÓAÝYÙf¡¨Š™…ÆËAEÐÈšF°þ£Jj³¢6›o>j´[Cµ1Ô" B‘e%9¢rM¤ÂIÒU@Ý*ýó=$I–Ý’Ý#OöðwБ,ôä¡I©©fTLUôÔS—MõAžwjê•A'ôt‚<÷pÒ öjåVSI1˜ºàÝ×Ö_€©Ò…™Vš¡!18‡MÅðAeµ•SNñ  Þ?ùãiIñ‹ŒkD«a §ÿr …vGVÌ݈ÛfT’FRR)ä´Ñ÷!Ê3h_^ýwœ‘%¤uÿ K£šR‹ðèoœÔSOó–5èÑ!î[ÖEJø¤R'øÏ "ò”N ÇePÌ*´á ˆ[Pc5Fæf©ôÔ©—±(«¬¾÷K²VZËÁ-ŒÚCUZ[B ùÖ›l®ZF\FL'¹Ä8ŸÕ]AUpAA*I[¤‘â´oÅ ݺ¦õÔÒº1!ß ¿TýTA[ÓÙô@ÐB -]¶Lp À?È3ÏžŽ^ÖžÜo)Ø HÉ× ´¦¿À\zÿC©Aøl0c3pϧ!IÖÿ’(æãqòBó¥Œ,8§™Hls–Uî'8¢ÜÂÒ¹ƒ8,Cœ;H ‚! g÷Xv R’ݵ$Zÿ` ‰ªu˜ $-—F†f¯ßDMCøEùÊ'·_ á'-iÔ]Æ6-íë18š~ˆÕ¥Š°Éj:Œ `Ч@ƒ¨‚| ‘_bôVÁŠ}È1 “dNø=ˤ q'ôŒFF£‚ĆЍYkP#Çà&o»úÉËâ¹Zð2´#SPò•º´À$a4‰!>;3¡ˆZÿ°‡ $Ã4X˜æp¤Â\"1AzHç‚dOÈF)ù°=°…à @ó¼HtÒ)U€1 ” ²±î‡Ôš#hgÓ Š`ŸÿLS®†&¯æ£kyzžqÂr’F•’–€ØÔ—„¡LéÛeIª¡÷ej?™ Ä‚þeì™óYÊ| ÇÀÜŠ!—³©jàh«ÊÙqG¶Ù£Ã¢=:pG +§’J”™p #ó, I¤’’¬°V¡uTp¥˜8ôÒsa)ͤúd”=¡¬Ú{žÂ&4A³@ž0ɬ,®NŒ«w B>ñ&¦b â° PŠÑEîsŸƒÊ¥ÉãÇRÇšñò²49í/%¢M X"³Qmö(à0„"¨Ì·lÛ‚c}Ñ?¬sçï* «€ÕÒ@r(©½Ãø¤„TùÉÿZÛt8E%*)ò¹šVcÈëjå2ß{§¹î枤4Q)€ùÇ/Dð UÄ(0?¦Ä„É^ÄÔ”’Ÿupv"y5c'|Ó©ê‚"êj“´ ‘£h)÷ߟÒqŽeŽœè䨚^%Uf—`jÊŠä‘/Nl†\‰A; 2•D‹)X¡¶ÌÆ&xðºmñgELùC|‡]õ™.àÂ6ÓÌÇ*lÁS -Í–Dç‚:PEã£Q¤üå/(“æø‚ü6w±I²An@&Àah^ç†_ºTAêY@D«Y2[AÁ.ö~eäຼ”-În kÚÔÛH52g92“å0+ŒCÛó­×ÿJ-ßj$KÚÔÑ´…Ä· L*–ñ´£¼vkö IùËOž]Ÿº´…N™mJSp‰¼Rÿ3 áèÛâ’©'S° à|Ÿz!8€™fÊGe†k»tn Bö°‹@U0@QÅ.‘  ð<•+>yywèá}DNHEˆR"ûÖH.>‹ã]‚qfçSÒpÈOoA»^ˆhpb£Æ|Û’=5k$ÄÚ´tÛ£`û Ø´BÍS¦?ê¥ „þ`A/¶œfÍ@Ú‘8#wµÿ ]#ë4 ©L¥®j˜°‡J¬ãÕÕm‰ªhÔ ù37\¦øM‡R;ò÷¶Dý¤m•ŠšÖ:‰•ß0ž™ÆêÃ"Ðü;îÄüÉy¿‰ÝÚ š!‰X†¢}|])B—î1„]pd9 ˆpGA…Q 0ËO\ÉGq]´|€é9 ©€=|Ó)ÇŸ à À“NKUD Tè^›0ÑÕUà¾éÄ/x]EŒÝ÷HÈ?È*п­]AØ!}(E‡“ûdŠàÂ?lÀÌ\Òè̇J„Àh‹ctЉU„ðÕjDšA0&1Í…"¡E^ìÔ„äB>¨¢ýÉLŠUrØ ³ÌCnEÉ\ádX…AÀ FlËHÏY°ŸqAÀ·„šÀÛÒÒ¼­h \†]v¡4QWT¤¡T„Ìýag$ˆÃÀÝb±×†ðCcXÒ @À|U…rýÇĈH:ážTŸø¨ÿœ©\†’ŸẖNqðÇû­¢eŒ]RxŽ‚Ä>~QqÅÐHGQðJ‹u@™´ž0ŽaHdÿP€º0Úe8š×•aù¡]&‹X†ŽN Í÷ I‹ÄØÑ¡A´dŽà±! nÈÂ%""ŽÀ 4"ï¼Û~pÏOÐ %aYPaeˆ$ÚüQ C† 8âèÛýHn„q1‡ZàÙþ”€[ì8R ð‡Jœ=9î”]úDé”ÉeÄÈSÌ ÖE íݼG4D„*æƒÚ¤OøEïÝc¢å¡@æ¡Bâb<Üóáƒ'øÍ?4F_hÌVdÄ ¤ÿÇtŸ¦”Å• מdÿP¦ŒdÖBfG†€Ð?rÅJbà©eˆ0€ý‡±”E­¥•ÿu‡¢ÈD®”<ÇÈ#HøIHä!ÉKTLÅí‰ÀÔGubTù¡Ú×ÑGó°Ežì–_¥íSá?8Á@êà Ó’ ÓÂY¦FàƒP…¡Ä‹Ï‰EX䉣@ÕîÈKçýDM]’^C €Ðôq,¤W–†ƒR[uÀf-K'…‘uHÀÏ„=”í@ÍSø&žèÕ#ªá¢5Ú=’dI^Vó=åeHžœÔdtiU]Ç×|b­ÀTÄX@¦,™Ê,\eÊFÆ“™Äumÿ¨‡……‘”άiè&±JŒ¸À>:Av”âêŒ"zb’„BÝ(™nЊ>XÙ¶å–†žDqîY.DqÚCFXXA Óü!’&øS Î[Œ4_¥‘8ŒîÇxð•&æ!yEX"¨¦¼¸«98‚¸ü /ÒNž´Ä†j(épD0ú ”²i/>¢Ç° ¬à]UR äA]@2êI(èIh%òQƒI„m°ŠF™Ðƒ²IX=ìÙ;]E‘dè…Åe‡ d—·xf  T¬¡¼¹Ïa¨¢*:AxG„pg]åÉ ÑK£ÍЫ,a$ÿ™Pʽ²W¾ÄÅ0@ö=Ò|M™´ÍWŒÍ•ÐeÒ%qHhA,ubÆèëÑŒ)æE¡ =´^¤§Œü×BlP®Àbn9 ÌÆâ.®€õÂà’„"‘^ U‡aÜ)î€ú½—eÀ‹Wicç:&—=e†¨b,Ý!£Ž•sìë€Miއˆº-ëDø]˜”é—ÖBœÕ éûtÈ<”ȉqFfÕ‰ò¾Ô`¾8YŠ%ƒ&^Brž4AFœEvðÇŸd϶.ßÇJf« «æ$È÷Ø/ðFA˜¯ð«˜ï¥NÆ_nR’ÿ†8üfõ('±\ãM !sÕŽTþV [ä‚Ìz¢îÓ\#nDq I?Ò¼b>`-Ã1V"Òn “'¤ v©„>LäVÄ#ÌCHtÊ?`OÓWsfÌåÄá¬ov¡€``Àb†€Ÿðí7«F`^'Ú£R&/@4A´A.° –JÉ;!iIKT‹_O g@†®Õ±IÝï¸v`.°œØ}ÀêhqýÎJ¥?Z×>‰o®ÅtÈ8†e¢ „P²€Kâ ùÜp9GˆÒÔË=µhB„ ؃‚Z¥  dÀ:ÏȘ›.dÿÜA(r;'ÞàŽò0*(Û]¡´D‹îVË#yÛsxQÚ~”va'f‰O£¤aPã´€GØåÂJîÎ{ _,]SŠW Òö‡e¬’ýRìFð3ÿÄOZ­'x"Dé¥ípë0g ã?8sŠÔŽFÆÂ(•D8Ž–ö)žÇ\&Ox–qJf“ùÆ­‘˜±F)+0h0hª”¤#d lÂÝþÄØÜÏïÔG¼eÝ·êo)YÅØ ÿúcä‘É·ÿ8+ ¡¢HãÉ>Å”\ÓÕ.™Gð|îkn0"Ü€=ˆK‰ä¹4ÿ€¦¦ìÝ 4T%bQÐ-Û „"Ûÿ­¬œÇjDKî%‡@.ð‹tWŽ /Ô÷„¯¨Ân®Ê?ÜH/ôÂ/8‚ÄnÓP@瓦¨@]HXÿD+)gCÛ[b›”šFŠ[oÍ*³Èh?vôJ³ƒ°ë~„¹úi®……,@‡ìMb½Ú#6"ð?ÐÃß ž®í‡=øDs2fˆ‹õÐòLÄK†°Juo/í¦'˰Fÿ¶5gAk;XÍÝÔ¯8Dæ˜ëÎݶBþBWê áŸ”É?pÞ’(gAÐò?¸ë/—ᲺTÊÖô2bR·~èŽÆD0[†@òG0(Ó0j,$›z]PÂ$ÖOº8ùÿd¯7[0_盕=ô™´À ÈC§Ü „€>Á’a$ÅkÞ‡¢2jŽsFJf ÈÎ ­Ð ®@D7Fx„9AdÎmÒöOØÃÌ2 °ÀÅøN€€p%å©AˆÈ:O¯e¯r×%OZ÷U[!è2eÓøA´dq;¢X†@3û0ýhõڧ3Ö B;¥ÊÄhFŒ} R&OWõ Š1Bˆ—Ê,aC°LLã>ndhY=[ÞåíÞà†T[ŽmÁ%ôƒÚ3Ñ}€îöTe™¨@rÈ#öDžbO¶‹¥Ø1Aá{_ùµÂؘJÞ¨q¼×Jêa'‡ã ÿc ÌÄYõ[·Ã)#ù‘kíDÀÜXÒ4þpéQDDh fVºm2+Nh¸€ªÍÊO]‚*ð ,j„ý‘³'³ëm†kp')Ld‡Ã†ˆ›8'ÎwÎ6âMÇ¢\uÝ¿AwIÿ·>¨î·ÐwQt7¼ë‹q©ÎÞÎLEqtH”wOyÖÓ䃟¸_ÚKÙÎÁÎD'iªáÛÛa°Œ¯¼l É”†ö<ÄmÖFɆßOüú/t¶oôÂØ%áO`ZµÄßðlJFЬFäÀ?ät»5_\Z_–sAÈ´è‘UèŽè^ä õž  _éD“{-š´øwâ¿ þ5\°!†ðI¬ˆ¯aƆ„üc¯…zù\Ø;H¯Â?}üþ!Ò¨/!Lþ}ÈWóŸ½öhjôÙ°×O—|4$z‰’UE~¹Ðç"_.’Q\d,rõ_СE‹þôúÿdÃNœ¸àÅ«W¯K@3NøÉÓ«Iz1æ5ŒÑPƒWÿîýÜëUBCDú‰pÙpFšùôåRy3c”|èe¬"#æÊò òøÏ`è†÷š€öB¦O‰ÿ0þÛÐ:ãk‹®h& ÓàÈ 0ññ“±Æ›“!÷ìiò«W®‰6ô¡”©éyý*òOÕ¿µGµ'ÿ·õû¿ªÙ£´iц¬ ´yÿÇègO¼ÿòz'з!úùþ«ëµ0Äs)5Èn²(*ûé„’¿† ú³Ÿšà !'|ªŒŸj(‚†Z{M#Ù`û§# ÿqâ&n:!ùøÑg¥ªZZI%–¼¢Iÿ¾Ÿžò®¹ð´O©¥Ú»êºëTÉ.ȵºJލ¡®¡ˆç\0/£\\0!­Kxùç˸|’箆T8a þsïï2éƒÔT:ìŸß|’&}&ËE>„lÂ8ûÃJ“gÂû‹4'DÓ}D¸!£ˆ6²àR*ŠMˆ Vî)=ª,¸„DHÌ…}<0£k·4‚JÓP£Ê"uˆÒ,eD×øÍ¨µwr¬Î*£‡ÿ¦¿M¨N~IU#ÎG®so«^R£\Uqò+}’Ò§"ŠE6'ÚÓNdŸ …o&{«Ï¿b¨ö'yòËh/tÎ 3ï0µp…nèƒ(zšÐs14¨4B¡æL 8p× [ GÑš`º!}'šè"Š|Ú”µ†ŠÐ)ÏéÖœqF¥‡ÎHdž+õ+;aí.X£luî¹ ÿŠ«KšÍÈ xqà¿7LN…ºp¦>„.ôŸ¿âàÚ¾Ö<šÛŸº} ¦½ÁRZņ¦múŸ ˆ4Ð -Q + á&JÃöׂ 0ÅT¶ÑìŸ(`ò{Mz¸!ä“”ÿ·—^…µª‹oîãX_\»î» \(^}:ŠXjo»Å ¡L¯ºÖèc.ï‹QŸð;a½åÌ(0â:ÝÄz”„Ð# l]F&t®†4!j‰‚*dªü."˜B>(bi9¿¹ÊMH•™ÈMzr“bT•·½¹ê%Uñ[ȸ²Z9g;á_­Jô“–ù0+#ËÊ’-zDë'ñsæ’Ó³{ÜÇs‚¢Bz˜p™.áÕO”1%­!Ôˆ¥¦.²Ø '7¸~w)^¤xùÕ |²;Á%Gu’KüæÞ¨OUL>Âbí}å½PEPÜ',Gž‡äÿsä°ÜǶÐkV’„YC6ù%Ô¥€<ˆWðƒ¿Ñ´ 4u!Xþ‘á8iã é‚D )P#¥ÁÛ•Ì`&Z È—¾fãš7öË'¦ÚXYÈTERÒã©$…¼ÿÑHGPi•äd…•ÝÊß–r†¢«GÂ*e¹XÙZ B› ZuÉßO67š%Ü£ž;Bb4œW0\qÊ¢LôÀä%­‚ó¨Ìz”@FmB¥‰`ò4d|ÄÈ#j¬ÔDVÃA‰O5®ñAÝ æ"Bþ£9Aªè–õ È;2ÉG<þ÷7ÅI’¯hÈ÷´C Žáj(MúŽšU8åôâq¿ø…ÿZ ùhy…5ÁcC–ð³ie$Ÿ?a¢(d“†¤ä&FÓ“z¢f­ÉCÚd$”@T9 dð:ŠmlÆô ¦4uÁèl‹ Ë5ëô›ÃT“F×Ì?lD£gNGrë»NZp5«Q"‡¸"J/žTÎæH(FêÒ%·–8õYvã;ÇäI-á°=¥O®õØr­'a`CÈ+šõ&¡üÀNBÐE0æò¦ÍŠBà“ð®%aã¯ø…‘rÐ+¹+b.šÒfÞ&z„Q¡3C°è *4=¯x$EÄŒ¤è'½øM˜Œš+H K)DmYW©Ãë¬%;Eè^G‚ÿr “òeö`Ä<î2?Ö%¶¯ì„)V øóŠÅ¡ÐEÑZ¡ž`Æ‹«Ý%hÞêKáQ!~Q‚w"M!ÓWùÁ©VÔÌ,ö)+ Ó–ÔÔçUŸ ~ó›^ñWE “ÒÒ 59EYœVÔRÎø~§Š°Z„ +ðtà´Abjá£àª6D¡Ë…µšyÀ'-hÑôtán}€OY¨øZ áÎP-8Wí1ÁŒ`u‘D„§Æf#b€FÂ|¤2ؤ^‘“ójÄ)ñ€ŠóªY•öØ(AYOVÖÇ ûæ*œ÷eN÷„¥8 H¹(ªèŠÉ¢Üÿ"„™“tyƒ×3FѬÍ_bºæÙy|SIœlRP°x5ŒÃýp¹ØÆ1Šñ\æE íc:ùî!þÇ>úÁ¼fDš+âsFâ!˜&z4¾¨cò¿¨ˆÇDþG{(ë²”…Lù’ ¬ÓÈ(…ŒI‹#êP8««*•¬Y"»N˜Ä¼`º,èY2«‹fXÈçÈ,Î.îâ*Î=ú.ü~bvp‰p”4"ñ8§ªJiÍ.‡ò¢hþ*ÏÍÔlÿ ‹Oت\l¢T¨MoT‘w^Qç †kRB è!M2b»z¨!~ Å6àZÃÅ2"Ñ„Rd‹jÊ Ã UÂNH%êMêíö’Å+ÿ´$àVÄ ´Ä:tÍ'¼‘©‡‡Ægdâ«(.îpÂzá´: ëå.ÖÏ'X!ÚÄ“äQ9§þè)9"$î 3±uäc öÏkh‚ÎNê nâG…k&'èA$,ȯêjBäŒIxú%"#UcV õÈ~¯¼Ä nðFßPÇ5¢Bèåªc©–гæNVlÒÊ4Fd¶bq)X´ÂÊ4bãÄïï\æ=‚ÿ&«ðéÙÞO/¬ {†@Çå f'¦&TA˜ð.L8òL ¤.ø§Ü&¦ë'„'#‹‡D0Ž0b5VC#ðÍ+~LÇcÓfäTf¤ê\À»(H­ÿ¼( $##I)ÂÃË8æI2˲˜Ã†nÍ*ÜΜ4Îo0üLÀ' )ñ19òÌê/«Ü#Böt0d*ùâ/´tb¸b‰Ú8Oά¨Û,Ñ?Í'ò7ÁÂ7€| ¢!‚ç#…Ñ6ÆbV€Ž£ê\E9},U|C%Z G\€¦TG!õF*dè:îî(S)à.3§4Búþ¡J..XîîÇ<¯â,ÌsüLØ8©ÒM–¨)CÓZô'Š$/"ï>"Ï“.q­\1ÂÅh¼Šódç?˜æ &$/Žˆ¥‹êj_Ú£¬+mÆFŽB„an ö­`8÷Òoô-Oÿ &X„^«D“켿‚RHärW> Õ¼‹ÀÚó,ÞÓ23¢ä33áƒ3ÝCÖŸÍ>¿Â4í£4²súâ/tæÍvÇϼ*0X1h¨2æÁA'¤ZÄ'l)#ò%#1%8y1-AäéîJ\ nRÃ%èF…Ä7×m5ûjBé¨öAhp/ÌP4bÄcbðäG.fe‚rGk <܃{ÿ& X¬U25¢0Ó*µR36‰~ðª¢‚άž8ÕÙF?âogÐ]Hós&ŠÆägTÉô:O"ÇÏZÀA±ÊAŒ¡ ¶Ænõ'n Dt59äG%êJI›Z¥z~#›ò†±žâ&–Gm²gûÊ‘;Œ*(SDcÈQ1·Ó'Ýç,Ü‘RÿN>‹”—ôJà`梪g%PÜl Öu¶fË? …P _Û¥¶ž(?8ÀTݬ/:U»*3ŽcT4ñZ`s`KT2DüEWÙMDÞ-¯6`5À0Y¢NFOSÇZj/©&dh.Á$+„Їx()ÿv%6"HldÐÑ*Öñï.Ì<à´ÆÏL€q¥E]{ö\]')ÿîÁ‘²ZžMJŸ–þè¯å¦´?0t³åͶ2 ýpñOF‰ H£ –À~V®þá8ÛÈ'̶K¤ {±5‚3âÓ¤m%xÌ0ÆKnx  z^E<@àXÍ: ÓÖð®!’¢W(!bA&=…Åe3âG{Ò+ ·Rmö+J ªÒ] )VgÚäˆKõs4”iESþ@ñ+t?tæO„«N AþC*ãJ?p†ñ®ãw† #Ò\ƒMɃ%"ÑV oô&&~lüèDn±&:=˜=ÿ̳*®:ÐÂ0wÅÊ@«§gF{EÇ÷V®Â~í·HOK>1Ó+¦Eg5BS3¢\± g# jyfCñ”޶hIIgšKÅÙøQªÖ`œ /$ÊP˜H#–‰Ö ÙÍój-! ÖôWà0Hg%häTèÆŽ§·0T¥FK²MÇ_joV‚1†¥fóD/U&¤­jÂXÐÎ=¨"&M&PÕÆ¾þ‡¢Ì'׊`qÄÌ‚¸¹Õ+Ü×;Ö¤\qf/B~&Š0DJsQ’6“«å]hËuÎõœ—aUàobjlzñ!"%é\ã–÷J¡Í8p‚™ BÖŽ{ì.¡b¢Žl“ Œ!H^ÆHТy0ÉŽJÚ黹!ÿl!;·Q}À·(…˜qÍ™~zð+X€ê¢I3±”Bs 6ç4ÿ"”çωLù+&ª=iBNÓPäÁ¾B´ZF»–XÉC‚µÿáªà0¨DÖÒlƒs5BD.Cr$Yȃ%eâc=XAȈF 4²Y´†/nì”Gà°";¢p¯U|¥®dÚ[Ár¡Š“EÉ€£ªžÖ¯ª.gi9§²Ag?V.jå/Ùøq²3B þA°æ P[J£Ú`´qÆN@ª¡àÒìŠluÔô!~§W"#gbÁ=¢®:˜•X"d­‰br¹”«%;ÃÕI®óþÐ44„ÏÌ¢0ÿi;ºüœ=ËWXç:Ú±[Çyœ°}+‰ÿƒÁ[4¢]9i‰Ú‰KùotÀÇ9!äÌ"o j4òÂ`5  L¢v›ÀPûž ¾â ÀË/è#/²x‰Ñ }WýÅŒ}Â@t$˜[–dÂ\²Xµq“Ï1ÚceúK•ŠÏÎÏc”—"p¶“™2‚³ž£J´ŠÀqÅ™œ×2¶¥ýlf“Ð$Éu¶<€µ¸ZÚ”¬|´a=‰ñB$"`[żâ#¹zau³'tÄ»ÞVÍS¯¸$c8n"ù’£:¦)˜é0Uíꤞý§Ì“Û“d]þ<·“(DàÆÄ=9: ÍÊ$~  f ȱÂÝûgîéžî£/NàQæI?JÝt#k²ãeÕO# ¶4èÁùtÖ½ƒ¡Y»Ì7à!~ÀbÛ!Ævâ1ØÇ$ü»B64‚/a¨óüt0ã>yæìb²=—Äÿ™©…G…¥‘³(JB°*Íqåó[ÝWç•H•|>ªæaZbë…0€1q"•hŠ{&#Œü¨Ñ¬ <§ÉÄ`Gw3b´±\r"Äœ˜œÝ¾#÷˞ Y•âJGH‡Í“cÞ 9Cè儨½=©C:xÁNÚC„ ý.|tK.°t“N"ìäqƵôPE]s?åIùP5Uo#xÅS”QþÕ<'põ•Aô¬…—-qDEgýÇY'h Õ=üÉ¥˜V$U_·•5Ÿ-hP–]x§E/üó˜@ÿ 4Ðe‹*úh‡ m¸Àf£ýÃ?-^´©FTÀGQ$#o Ö…;¤«8ÔêrFVTĬ‰`ë?úÜæ•E#`¹“–ùu9#Xä%XòõYrÞÃAÅå,ü…Ùl¡ùeÕ›ÿä1¡ÿ#‰œÐF„Ú‚¤T¥Pjá@ìþÀC ±ÆÑ¹…êDÿø»“ è„%/5íôc««S¼8 ëÃ"xp0C>Œ`Ï -ÌöT€b<¿*v²½RÅÕ²g²pÏgñ·Ä Ë.»ŸAÿY$ ¶oúµç¹Ž€Tîï¤KÐ@7Pï….a¼mhÙ ¢E„¢G mD‘b¦æªGQx”O>¹¤’p,Õ*ä? »Ð6ÁJäÃ]Rd>×qE‹iF¬ kó7ƒD#RI|fM m[÷hÜ«¾úõ$?K>Ô…FÐÊDÒfòޏ¨g™T/D;e=¡ÿv;…]‘>œö›ÚDºDd‘F2G¤N¾›¤ ú°½ª«®ÚÄ"Ezb=dUTñ)–Z Á<‚ó'8¶SÅ ,˜fÒµFnþ´ ÑYè›Ù`>—úvçTˆ;}ÈH7tÐ7Ö…D#CXHhw«›à W2A›Ar¥ŠY Å9jCŽ\ßÄäm˹×r¬äУ[0H RŠà«„P³ª¥Â•©<òxÏ=ÜÓ¬5Q«,1+KZäb¾’$}wŠü†Ø@ÍÏ"é‚TeR)¦íït ¡¦ À|Ëu½ùÀ×\§ÙD|‹PTáUü?Q£ÿO*ò#µYiŒžEnÂ#9Vða>`/èñžï¬§…Ha  ž ðíP˜ÒôªÄ gé’X–U-¸ìÇ-*³V[¾ò² K„ä£.hæÓiTé`¦UfQoáGP&¾3Xî&ÇÅʵ`¼à‡N@ºÿ¶/ðlEÀ#Ú¢¸PþG*~Pa ó÷A(Aš¶L/jN»}a™o]¨Vu¨¢ùÁ "µÅxf3¤[DV°‹Ü™"zå›v𺢰¦8Ãsoæ¢ÆaæŠUÊ™#d)h"—.ÖF¼¸à¥› ¡!ƒ6ž%ð4](L ÿ  HuE`d9M³Ýr™JFUõ±};!€p-aå]Ø Dur[aì8»ò1ZD‚=Ö¸îÄx=–¯6F~èCypähÙÖ»íŠüBУæKÖè 'òKÓЗîF²ˆJa(W§N…A‚°þc(Á¡6Ýå”e:[ÿ¢–È\ªÃèÂéB„£•×ú:+Ò 5?TQšeÿAr~äİG˜×׉¼S°1HGas°š(PVrc9«gœ›ØK=‚B ò²,«èü³Yæi ÀY0 ÝÔD ð€!ÔcÔpE ÁãïŠÄz(ÿy‚’Dð; Cë_Ë]áŽDH !8".̘Ç;¹o¶H‰‚© Ôý깚=¨÷¯·X v°ãˆ>D  âñÚÜßrz”ÇŠÄJ‘¬ÀjîCʯçP/S«!ÐêVc )ký;oo±Zßÿ¨Ç?\a“g`ª·8u9µ\®£|!ÿÀdObQ]í’\¢!5¹—BÇâS…£>eQ"awtWQÐ}¹´"ñà72<ÑbÑ)ã#Ô”}c"a€²9øYò@_WñMWàd©foFgj t€£æp%ôH6£ 5ôòs'^ppø[!`ö½ra@—\¢c4Ï…Bü |´%Y‘öÀЂ£…±|ÿPwÍöU.*\c#XÄg#h9Á#$sÑD& ;N ƒ2óqò€òðƒN%ð‡?F§‰›WFˆ„þ§„ò%‰÷O7ã,Ÿ„…©ÀŠ'àŠË8\ Kœ±ÿt–BáS“S½˜S×C‡‡v§l¼gwuù …Ëhw!À|#zõ¦rGÈQná–cY,88(óA0Z9€G0_ñwy$pBõwVw‚oCÀÁZûä`ªWOrÂO ŠýX&9˜nÿòúàp0|l&/ñfÁ–‹ês‘x)‘GÀP¡ŒÇŒÌhg'‡A(@mP6SA:1<¡‚E“%0Pñ2ôgû°“ÿ`9pލ…y–j bEoû·£æ <„ùq_CdU.Ӥ嵧ƒrßxTe‡Fåÿ°DSÀ&5#B>õÖòÖ‚ÖbŽ0з"&AŒô …ôà:'AI#T&0T’ó‡Ñ¤T˜Â*‚$v U‘p! À“±<ùPñgBàñC˜”Iy.N©&QÉ]u•þÈIR‘ŒÇ"‹½V"ô¢: Z×Bô÷äXŽGPH+âq!HkAIs91#!^Ö€¢#¶"2©K!0Áˆas·ùû`›‘û@ÀS%ÄŽ•WDš;ŠQü§o¨OiT !D§ùuk2PZ¢J§Vtö(Â1Z¶ùz¯Œ Ô%‡Ú!Ck1I‡ƒÿ_ *â-'™|Fü2QPWAФư”3€·¹’Y”i—ù”ðÿtœ§”ügoøVž„î$8Q‰Ÿ¸¶!y!!ó óÀ$q¾6ô’ŸHð·p ý Ö)¥¡q‘o±Œ#!C«ˆî¡1xRò‘ÿ!x)#%a]ijQ1;,)@Û"üa>I§Ñ“€Ž—ç%Po㉔îh øy1£;!‰bš;*PO[ Á®ÈS\ÐE©(l†S`FPÙé© W: ÙTØ2Ã[ŽŠ~A9åb’å¢þb]~˜ÿ5öp“MÀ-JSê©&Š£PBFWaŸ©H8 P¨ŸÆZ`öO=ª¨X¡òA†°pÅÕ9¾¢‹;U›Rš"Ú“×Ù‘BŸ¢‹ÂÉ 1CUƒ¸¡Dx *.b;Àˆ·,P‚£µ œjF@ߤZ1¬÷f¬j®`4úAI®Ca•…u©È[µƒ81©a†´äÈ“JÆ©;ù“i²R:¥±#rÚ:II‘ÿ@P :êú¡<ë·dúŒ‰9“ס óнZCÑ«%K²@™™*Jtöv¹GxoƒJذPÜÉTÿ‘óÑ–?ô{D¤Å•;ŠŠ*8ó_8‹i›&䨴#û©ú±¹ØbÑ{1# :V±,Åy>ƒB—!“7Bmp„[dA_Üj½ŸZ§ÖyŽ­ IoX;ç¨åy¤[‡rAé–òéUgñ˜Ï*¶(,óxa?0T‹ùÁ¢Õ¹OûãºÔ£b;A9𥃎Zÿ&9Ì)ˆ%aªe‘80[9P²?I;i›N+·@¹¿sÁå ŠÈZžKå[¾ÈBºÿ@šr1±Ú¢ƒÇ[fZ(-pÿžü•IX`é4kÁæS²\=iwûÚ¥Ey'¼%Ñ·u!3RxUèA9¤r*åÅ5"3 újî4šÚ´tjÁTj§&ʯž9! ,±°  ºœÅZpŽmY>ú¤-·…¼ÿp€©¸9ã8ÅÐó 8 pÈvaCp¶¥ôg½pÛƒ ArŒ{rTÁ®æQ ègª%9Wþò7Â52‚UK¥kÇñ“IoAÃáyÿ°äùóˆµ@»ŒÂàÁs ð9Ck5¿ês…¡Ì`3 ¡ºᬱ· '!-€´íOO9z¡Ge;\@\ñO¼K™ÙYÆq,~cK\ Îf@'Ñ-Œó'&i¦.²xc]ùo`r¡Æ–Qiשd¶É©è<žHJ7ó˜rÍXÜmQÜó{.ŒÜ¬L×ÒúÆLö”hPÏýdI—ÝT—ÁÜš¾;w•B*9Vcwʘ‘°s0ù#Æq#\tIm^[º\&K…£f¼»sjÆZ¬²ìy;Á¤æI¨hÓ ÞÚ”þÔžÕÜÛ;áÂ;ñ˜[yUî‹“’Z | Äü/ÐŽj«Ýhÿe°/nt Àj,l›j·›©p)‹ä-mæF&è/{e5Kì°!È#Wa*À- Jyнä¤KÙØvJåÿ>„ ·à«”G'ÿ¾aî¹`>£¶°iBê¤ED)ÝqÞº¸nÞ2ÅÝŸDÒŸDÈýÂÿ ÌVE0j­Pe¢÷Æÿpe Öü%ŸÈ® ßD¼©9€§¢Þ!±Î”ýæÝr8!´#r71G2(<%AßGm¤ßk½Ö+œ&£µ ¡Õ ίΟWa<|¬¢‡¬"̳~í­Þ¥WÂŽÃì£q±Òzæ‚gtÒ2Åç±WÍ/œ[ÖbºdqâX¬˜Â ëÐÀê €È$pã ®ˆ·&øè*äÎcÔ)ì;®Ñw}'5“Òiá¯z\Ùžþl~×sòpk“_<È]Ý žž†¼ÃÖ F× 1>侨Ÿ3º©E(TÞ~g·ÉÆèŽ>FX‚A-ö’Õ¦&y8€™´yÐä,ŒÕ×éú±T^ð²Ïó(¾mÜðdæ3Úðc?ºÜ´mß÷2ç!=€wÏzÆo.Z©U'ÝÀ^kº.ípú'£Á_.U¶¶ö°YýøYß{ +’-&rˆÀù§am¦1ÙQ³Ág·a;ƒç‘úAÙ,àz½ñψ‘ÿ=À€ÿá_*ƒA4ü"Á¿‰-^¬— ÞEŒ/¸zñÀ?ÿ2ä `$‡‚M.Yò¯E c2[¶pÙÒ¢Ë&÷rúäØ òä…‚ëmäá*)ņ­"¶ºàÀàÈ9þ)|`Ðë¾’óUȧ¯¡Z~ÛZT«/í¿¸ùþÙ-è ‹|ùì5<ÑBÿƒYÈÛŠáÈ‘zm¢ä¯'&иq£ÁË-oæ :hÅ7"ù§5G†’J®äzï_N›55М9³¥lƒ,ÿñ¶Èážoß œÄÀUžƒ \9´±a=O Öbða«‡!E†íJàÊrì+øA­Ýÿ|‚6D”v®ÁõúÔšµ»¾`( žø‡ #lE:ê«ä ì;± Ê ƒÀ{ïŸ 2À€ (-(Ð4²¨"ÒšÚL# Ú,#"DI¤ßvûg‰ L0kªI¦&f¤­·Ù€ºg8Ù„SÈ»+(¤ç²á¸k E΢üÊè*ʱ# 2#JšàŸò«ðDîƒ(.ºîº /½Øc3À£g°9çùOà2‡$€BãJP ˆàóŸ#Þ‘CƒØÐѨ2íD!±4OÌhˆT,« PÄiÆŒ¹­ zTUu°Rgë¥áŽ%Þt»è$ÿ —t衇bDì B"‡\q€¼@¹‹«†ÐÓU=8Ëä§.4ïÓï.'þñ¯¿(èq"„¿$LÀè!WQ® 4¡‹}Y‹jŠ^*ÿqÔBHKÛ貌:„h#O7.Sª,òЏ25&M PUƒViÇ/šµ¸|káþ1’5É0É€ð ØÎ.bêWUˆËetQT› r¯¡j)¨Z3Ѽˆ=¹þ‰‚Û»ú !„mÅmÈÜ<›'Ý„ˆRlË£FJ.kx/4D‡Fœ²  ºðÃIýE1;Í †È•(uÇ%šgÆÛŒ°‚œØÖ‰UÿÑ»bà ܤÿ‚äùÉÈJzàˆ‚p%Xí0%‘í']Ö*, øŒ9ØöqÅ·!;Óý‡Â]lц8W(x+!ßïÕnå€jÈ6ÄÎR]±Eå2øSOºGy–§‰Àæ¤Çƽ•.ºï¿[êé"—î9‰¥ ä™')BBTECÃràh…U®d¯‘†B“œ&JPYÑ?&О´T hÿx Ëd||à.Lkȶp—'‹„`‡á̵¥ñX­kŒ:U$b/¯Yäy’Ö¿F#š³u YÈ@Ð=™¦ѹèÿôÉŽh|ó[à $ƒ¸d&ˆI‰®B’¯< ˆ^ôÊŸ0ÀœçÈ0VÁ¯&’É5¥C¸Ð²Às1°kÁ˜ø‘³ ¬….ª3]äsÁ‚0 „ |Oþñ—yø®1Š*TAÆ£(, < ͤ´²¡±YD‡õ›VŶ zH_ ÉŒ s%Q@|3K›¢`—(øMNAy˜®,„d)N @HHD†x¦))ÿqSr…(ã!JÈó  U@M=sKA®5È‚ØÃ/ˆ,¥=éÁ<ɆÇ;ˆE|·N.Y¤Pùê¤/,‚ y"ÃB¥,ØÂVCMmæCàA^бÿyœ‹|«B—ÞˆÖ\ü#´¤å-yd*t±ò£Rd’*Sý„9Äâ"1µC5&Ï^Aˆ$‰Â ƒä€xÆáHÁ3 ^°ZüÀKœ:ØÍŒî vA±‡7ùG*¦ \DŽâ®‚„…Aˆ‚ˆ<çéÑC_ø ŠVI¬jj4ØØ?‚<‘kU¶Œ]¸îòÐûð…/9½%bb@¬\<”A¢Ë¤«J—£á?Zv@«àj_¢¤)Í­u%ÈÀr¡½Äe–qjˆtéø‘dx›w ¥Ë 0H+*‚À‡03,¢ÚñlÇH’œ÷É},‹¦3õ1Õ‚+Åä—¹.2@¢mÝ"{z‘INA YLKYºÁBá¶¶ñ…U BaªþÿÿØ-U'5°ŠÈSynÑ’§‡¶8¹h«šîóâ|èåg@ k@6|r»M­pª£Oéd°ÙIPb“ir.Q™ß\Ó¢>ä²óE«×„eü–Î"píiE9HNoâÉÀ‘d %W+Èœzƒò´m)/²á ¯VzÈû—išrˆ„ ¹‚6HCSlèíi¢‹>DàmrÏCa&‘kiN™¯^ê¯Hß “h8Ãðú’(¿îÊQ¤)–hÄšñ…È™èsÓ5µú·È˜Ää¿äÃNÜu¼×Æ0FØïñS:1­ì ƒÎ ù¸n=Éé~éPX¡v!ÿÁ·Z®\Ë uØÁŠ-«ånÿÃÑã"DÀzÈ£,!qj àxšKÿ¢×_eg"LIy! ³†t÷7%øX{6È3ÌÜ>Ø\7ÁŒHqq9=bj bV¨T&·Ð¨B)S¾îY¡çákCÙWÕCTrƒ™HÚžü‡{<èÁ³I?n·¸×DGD"(Â?DðžºD¯Sêa€S>gl 2ê)ƒu¥¯1%°ayfb&43&7fˆ0„™xÆ3©Î ¶ÿc¬µ™e‹€",˜çq4'Èâ*,š× ‘€!ù ÿ,éÿGáHp Á‚*ø¯á¿ à{èðß ) ÒXQ…>üû²ÂÈü>"BdñÆ‚—7n8”¹`CCF8s2ŠÂ¿þ©°7b„‡ þM¬È´©Ó§P£JJÕ¡M›U³jÝʵ«Ôµ~¤’8öFCÿÐù¡­½·p Àµ÷!h¾ üV6¼Qa„Cž6lùQáÂóþÑ›p7Ÿá'|æm¸Á>¬^3kÞ̹³çÌ G5¬µßÒ†¢!šm¸¶‚„‘è¾ýgvÃÚµiÃm̯w{‹ÆñgSÃ^ëûMOE<? cµ°áôçë1cßι–Sƒ Nÿ\ 1UEÕ‘|l(7mzµc¨p8_…}¦PâÞ~Ã^Œ,ÄpB 7ý3Ïc|`­ ÂØ?0e™RÕiÇÝ…ZyòMi•ÛSbÕAÿˆ6‘h1ôO-‘Ö>ÞE¤züc{´1¢Â<<Ÿò(”C@ñPG"Y@ žÀÂòÈÔóÄØH‰Í3ˆ´¢ÑüÅφ6Q‡Ï„"¦™á†Fá˜ÿÄã\ˆi‘j6¥"jO™¨Ðh/ž7¨w£=réhà B!:¦=õÕVdñTj‚ ñ`§K@ÙÐ=ÿ@)åNx=Œ| A­è#’EI ÿ±¡UJåi«S—PÖa`2å—·ÅS›°Aý“nrÉ•§@ÞÞŠ ˆbSäAtÑ?,ÙX×oüÄcÒPŽÂ颕ƙ©t ®CPxÏÿ°ð, ‘!ˆøp•/V7ëe·6üO p4tμ2FCòYA;„B;trC2ŒÌT ²À¨RÎÆH•iNMûCF‚–±"õÖÐÆÐ\ý™gœ&üs© ĤÿH`¾*WT/£óhÀ=ÿ„ðAÀ^ŠðOÿÁð?–Ù4¶ÃhW´?bLUÎTtn¶Ã€2º²{‚7í‹ ‰ÿ¶÷(*ÎŒQZ,ÁÙ[<üð—o”QÞón¾‰”‘ñ@aùåP 5ßÓ4-¤¼K YEó¨JÁ ÿx뙘öëÿ°ÑvÃŽhÅh ( XQ³±lÚžÓFQ+^²fã©E› 'Ð{<Ž;NÏËãóHª`¹1Ü£‚ó5¤Á ðÚ½2dŒâ‹¯Ê+ª­¬Pã„b—M+ìøç•NXBŠ!ß"ÀÕªDKq–~॥å˜G¾þ1{Œ¯qGP äñ#4dz *ÌB Ÿùã'tŠŒq>x5%}ó’ÕF¸*³ÔÄ*¥±þvÈÆDÎT¾ÔžÿjE¢Þ9 ´ˆY$ÁyHiµqâóX0 Ĥ¥Õ=¦w„hí=é\øb<á&@â Gª)é 0êY…ˆ³:¢¬ð‹öði’W•®Ä'†$p!$Ñ‹f¶ |€`D®Æ¤y@éŒ@DM6”Œu0„8Â<^Ó–ú„ï„Hå?€”ÊyØÇô°RçÐh ¥¯zò(Aé0B±áCV{–Ø^ô>ò˜Ê€Óª4±"(:6 TàjüÁ Fp, ²€.áä øñæIïpä1D⑬O¨¢R5WúPõì>ç ÿª(µI …ˆIPÌØñE}´2ª™AZ 5½ ž‰â2#"‘šÑ#æA0QÐ1Q²Ç l’á'aE\ix šà°°¦ãÓ—,]YOTíÈI¼ðÕÎ<",˜²jÝ/ºc2ô©™qè™å»„ñLG}H+\Rªùl(ùà="ƒˆ‹0bƒ(U:ÕÚ–¢óq¬bƒBÈt®iw]%ÕJ 5§"þ‘ ôÒÅܰußÛA‹ù,§Bõ±S9hDˆ:‹)£€È½ˆd|¤ŸO€®ÊÃüG"€°TøßZÁDÃÿï®'¸kçìæŽú >t ö3T$ÆŠ”¨uÈF-;*”±Æ|.d§ëHiåÛ@\–HFD𔱡Sî ‰9U‹Îö¦³µ­E'lW‡„`úÌ+ét묹'¬aÅž#°•0 !¦ÌS&²ØÒÔª¸.u«…‡V©o0²h†1 @ï@D"?¸JIµJíÅBüˆAZÑÉÖÔºX%€"l›ÛùiŒ§°¶cÛ„uLúèM>D’b.`%.‰ØÈv™ƒ2X¡Æ„ðx&Le‡àS>ü‚Vxüv¡(5 ±ÌçAØ.A> 9q<4°µN¯ÿ½/n lá:‡äX>àÊ÷lsàÒ&Eþ‡>(¸M®ä%ü¸KY¿¶°Ó)Žî•"ÇV²2¨¿è1eàF •ý2HÐ!­e¸˜V‘tr%±]Õ;+"ÏÛì.ãªÈ)X bˆhËô‘-VÆB&¨¥z骤`‡’xL, 8-C2ňÈ@1M3Cœz^ŒpöÈÈøº¶"Žû”:0C¸J(Íu¢R›"Àkÿ8ro`Ù~œN gbª¬œjd3VÂÍnôÇÅøŒöxÌ—9ñ¾!ÈH Œ ’Ù  ¥U$'=Ré½8©À…©ÿM§«?x¬Ô¥ˆ=\9:½rŒòŽM^îÍ€;ÑEžM>òqhJPg±Îeì³ ýGOfFTÈŸ üû¡^».fÆ•‚Dˈæ%x:?ì±vªiRS«ËS»ö•Ƕì,²_ùœëš7¥C/"Dà0À `"ò¾"Ý%ÌUì/£Ù§2û€‡ hq!NevMùDÏe°!I… þ¹ÄE¸Ò8kˆ †‰Æ‚°‰„øÔ¡L=$ˆrZ·¹!°ýÇÚ›ò^×ÊŠ’ð••  *Hê͘ð-‚"üÃÿðš=ŽUä‹6Öפv¬t?:Äñ]ñ„ÿø¦À 3XÁC• ÌâupÊ'þÁ¿Â)^pŠ QÍäà±”§µ²7Y—H $ªQ+3w%A aS´”klåre¦N»ç÷E{†5CÑ@1‚cò‰–hÿÀ EP€Ê'#À #pb»1}1lš´!3L×APw 65³;dp`ÿqUÁôg¨s`~`TT ƒ¶C   q   ¿æw• €p…6À+À|ð†´PÀ&\‡71 yÀ(ðZàpqø!1â'/âa0s&­àhg†Àÿ·NNdeU“g´f ·çb+‡{kL£A‘,ñG2´VF±¼àyW#àüà#w±‘Z#hز­gG*jYÁGz”GÿÐ&Òê÷wùöw à„P ¡M÷f´0(¾1hJè à|ÓØÐ÷ÎWƒv"Ðs7 ~.(\>qƒM\þÕAcgX3zSUY€³HZ¦­ fÐ Þ–°5íK#g!X)1Ð) ârk=Z´`5uˆR%¸"¸aÅ ÝRÀ5‚ÁWŠÓWoia•¡X}"·X ¡„±òõ·IayN¡ÑGAEÿñk1¨<ÙòaÂ…çs7Ђ~á às>—-{ç=ÇâX”`}`2dQéGM€CKÒfk$Dbd“DGEM×R*Ã#_…5AóWH"' Å£Â>oñ’?8xg'¡$ 5#x|;6uS×9È7tù°prXÞ7i×¶G–vp{Ôµž`y#Ðs~§~ˆ2às=§|ËÇEÀAFÍøwJè|wŽ¡M^Cú <ÇhŽ 1däT•G2.ÓæþK*àŽÃùp9b@.ò,]Ñ Ìõ`Óˆ¨ZGÀAÓv•d”—”‚—U%G‡ÿ#,Ù-Ýâ“Å’ž©||¹ôС5uÁBÆ0˜0%8hJ”\–q™Ÿ bƒ›Ù&¨¹+pä”z€yÿÀ Ás ,ñ pEÀ#d x‡ú¨“Mªy“+°Àƒ d:â8N6BwGò*ã¢#ðá3ýaJ¶¡Û¦"_LÃ@ðÁTMŒP~®•í9ü•˜qÂGašbÒ#€$q’4.`‹&(‘ˆ÷†.øfkáÃ(¢OM°- J=Voy1&IfväŸgpÆt™•‹U¡M,QŽ ZŽ7 ”ÿÀ«| `xEà½ÿ,j,ÈGz§¨ªù( «ðã€:¦cRåIYdÇ2‹`2&t˜ªÊ4‰fª:XÃ'Ðäz3ÒÐ AÚYÖäˆLñ<’ˆ,ý¦|ýVG¡û$³paš,1¦i|o1ƒ™˜;Ö·<;u’ÅFÛf4åBú2½¡M S&Ù`M!6’Ö}XaôZ/ayz^ósy+ШI¥œ;.y¢öP‡QqÐû 0¸¨ЉVÑo¯R7Bw¸á±ÿñ*@Í×òÔ¨ÈS%ë-U—$Ö3~ö—&Á³ÔW˜…ieãÃFès-[¹¥cÿp´óâB«¥nXÀQ†ÒdÜeßwL•GX±¸# ~%,QhØ"¼öQOà(£H~‘ßóau`8çJ  [” šÁ;#£;ã“`BzùãéÉÀ!ƒû, ô±5rÔ4B^%‹¤nuOB>’åJ¸V‚@ѽ#±4>ãW!hwËCÍ1˜çcÀ'À­äsvé6OØô"4U 1K¡0S~§6‘Àš~Ç&¶‚ü¢Ü+ÝвÊÿ‚(´±\^Ð (Ð~gO‘Hz“pB¬N©Ã>983d:üÃ%ˆ6â-MjÊ?q¿zf qÆIÁÆb²'û$¸*g—/X†1"(£³·J|ÕcDbþ¥c¥­Í*AE´nÀG À ÌFÅ’•A!KÕxÛL-ç 3‚á„ÜÉ Q8xqÎ)q‚ÂOñà¢,*`2ža‚å\ ?‘}À†½DöÉyk†Ãžª¬Ýk"2²dAzë{Z¯õA׉/£C*äSùb%LRœ†q=À¬ªU³2©‚¹Aª¶KüöqìÌóÀÜSiŠ/ðyºA`Ç0Ãÿä‹wÔɆ TÎ.áw/ªI1¨6bËØp±‡R!ZBQ;ÛwTꕹ¢)Q,éìÉëÏ:ã“wû¢]í}›U# rÅÞ$¨NS4:Oã¿5ÅËrÍËšv µ”±S5±ZoHBªC÷!ÔÀ|b,Æ!|;Vè3mÁ~Ú´²{Ó’ÓO!Õ»MÁ§za}tnEì%<À/|yP¯{`‰cƒª-Ò¦\ΠŒ›ýæÕ#âG7€AGh=%ÐóqLq(‡FL‚vp /OÂ8ô²A$ÆË©D5m餪··±4Š‘S«$Æö€ØŒÙ˜‘*Æÿõ±1Ç2ö‹ÝG¸ÉÆ0?ójcåOÑ Þºk&;†(œû(>‰-:œ½B¼Ÿ,Ê3¾ŒôÊŠÛUtZk_S4Ñž×½cB%+Æ^}ŽZÈA%å#=q$·)Ã÷tµÑ)Ã2\ªÀ° ª9^ªû5CnB¾tLáTGεzÁñ=ÔÂhq2%K'Àêø$'pN!5æ(AÑ%(±x÷¥Ê³â¬KQ#H€ÐGvVRÒ¾ñ…¤ÔãÖÄÍ(ÂK¶èB‹Z$>X×¹Z"î)£cØY©AÿÖ˜¯b}úðè+pî> óªî‚¦¢t5lf§ádɦ’03+`àE™-EmÔm!`1 åV²Ì0Íù÷‰'y` ;r1rà:hгÝ1ÉÛL|cÐi3„ò7ð¾ò¾ýsNX¡2AÑ3:åJ±D>„­+?ø Ü«Øz´ûä_!€}¹!•‰-%ª >Pù”à—ÿ|Ý(²9ü@GB CÄôx¢‘l¥o”0‰ëË!•®\ép«t%¯?Ã@/ÝÜôPytÇB!ÌÂ>IÃPa€J÷/1c¤ZÉÎr¢3Üh7ÜZ) Ë_íŸ/kœÀ#ÿþ<.O؉!îÿà×7tÆBl"°˜O É•\ áþ=ç®BtL ²;¾$i‘v@ øþýÛ0ðDÿ!BįB¾íý³W‘Ñ¿óT̳—QÉÿ–ÈPXÒäI”)U®\²äÇè ÌWà_z3í…˜hâ¿|üþ :TaÑŽúñÂ@ 7"ܨÀˆ…¼#ÿäcŸ‘®÷X,Q2†='Ò›7pÉX‘òÜ*”'×î¿»KäŠlÑößL 4ë˧O"+|P²péRcJÿ.IŽìƒA‘…}J-ˆoƒø@‡þ‡KàéÒJq)ô¼aÁ † ‡>øÁžÿí¿óèÅØý7FÆdÿ9ZYÜøq“I܆s"E´lÙ† ù¡À‡ÁC‰òãÞû¨QøÂCEâôßCJ`•wOá¾®Ñr`F¼±cg43$ ¼ðºG¬Ü#Kž%Ü ð@Z8ÁAÝnò©$Ã[‘VX€±K„°` Æ>ü'²4ÄŒêòùLJÐ>#í4¥XKêŸñdtí“„‚¨§úËH7|œG…\â9$“4 †2ÆI 4≴`ÊIÅëT´.¨À à§{ ¨À&/OzêCnø*«ê:b«öù':ï©«¹¢ä"Þ.úÑ>›Ü«½öì,Ò¤C¢ÿ2ìTH~B C #³@ˆ%ôK(añU(‘|=ï!ðñ,ÆÑH›Ñ$6(hÒG»‡l{î"ÿð̯9"™#IIb‘P¤Œ!ëèQᯚëk¢|Ƭà¶ÛT S­žÔr´Æ§xj.°êŸ¬àìj ùäéI bhÖžþ™8þ ¯½ÜÐßÛ ðÿ™G7zxÊgáGJH ÏcìÒFÛt²NOH„Šr±âÐPkÕQJ+IÖ×p¬à¡ ôɵ"ìÐêožæN Oû0¶Xž‹3Y²4x6§ZX–"0±£ˆ¢˜qS¨ãŽ—jJ!Ñcÿäú´h¯æ$€…|5¬?ŒÚ¢Y߷ЖK¯€M’ËÐYèK7FæÇ°¡n= â %þ§±‘+žl Á}øô¦ÈmQ4V£‘µ’QÚàÊWŽèˆ´ü‡™wŠ!8wãuK¯–z6]¥',’¹š…©%O˜)æÞxºmés_J¡5 1è5C¬ÊêÍ*>yÄHh´6§ÇÞ!O«®·ú]…²Ø]w NاÂá!± 5\ìÒLMÓH¤„\Go­8VÔJŠQ¡ÈoL¯‚˰c}ÚM ¦—Øù¥.v"Ý0N÷À8Ä%OŠ=`2ì…JÐÒÌE>@ÿÄÍ$#ŒxTU’¨8åë){âõ` y!R[Öb°›ñ+m Bìd§ºP¯{ Ñ #…H•¯|ä;ß °¢qU%¡ØàG•¨6ú WAR%š™¦d‘K ŽþÀØŽGá_â¨ÿì_bOG<I8yjK Dr²,A&ÍÚHîrÒ<¬†¹9IypD• °`xsê |Šw„ä•eO ¹Ù¾D¢º`RuíÎÑ"ÄÌ…/1åëÛ ⃠-f“ùP‡ØW±IfD™Œʇ¹d1p®RJþJ²&DT@!F¼Hvs° ê…ÈȱîA÷ÿàJÒ¢¶¦ˆÿÎÈáf6×Òs'é Ñ([z òùÇ£‡Ûܤªø©U¥*ÄTQºIªó×ÿÚJÍ.Ãn¡"qI” fÀyÌÁ:~«I”ùF°§¡tZ0@X\ãð7‚ˆjкàl]>"PŒÍ%dgÚg⣡gÇRÍ µ6gSÎÎ’  Ž.¥*ÐìoÜ}>cîìUèÒÁnmÒÀ´c£DÆ%Qq“üíbsu޹m4V ” {”:Ô`›<”5¨h•õº3ã£B223&Ä!‰X@,ˆ¨pJ¤»KYzÉÛ¡[ÀvÐyôňûɇ±—±§”/b'0€S±ˆ1!å9ϳ1Oùà-`Ä=3#2Ž'FQÙÓ(нŒÅÐbÀ|ÿÛ“ÈçÒL±¤µV\¹ÆÇq§¯Úi‚·pm¿õuìÖf ¯¾$B~aÎÙüòƒV”¤üø€•¤.ôf°[VÍøãûöŠ43£E ô·8f^€™ãG.Ñ‹¢jK05£¥])NBJ ­”8 ÓPˆŒ£—³¾ Žè3>v«7„ÓÀª2§Ù*¤Á3 ổø—æ‹ iƒ´ëj–!Y+SßIj¹ó (vÁ€¹X‚{Á{¸›É—´IžÂº‹°™ Ìù}ÄÈ¿Í;UX, ‰¶WJ³ø zŒø‰ŸŒ¹ z=bz>ˆÿ© ŒK7‘è½ %´Óç¸<|¾ÝRˆ[ª«‚7äÀ¨Û1 :”ó¡´9;k ˜ÒÑ“³r#³h5…øeš‡Aa*°È#¹›=á¾*›Ã Ú£(‰­06ßAŒQW0-TX"—8œ7ƒ³”J©ðJÀ X€Î‘Ç9¡r[€‹[‹Ïñ5´CÚ*<ÔŠk¥èš££K‰Ü%t&X‚o4†&@–o¤¦@R»O"ÅÕA»ŸIĽ™¹ ûÐ|øßµàFÈ=²('9A—Lꞇ«!ú‘$,,÷â.?‚ü’B‡”9ÌC’g³9PéBXJœÿ“ˆŒÇجÌ2 ˜³ÆyÀ!7‘4£Û) j(¼¾&é4FkA²K¾Á&äšÉù:IA·h‚àI™ †Gt ÊÛ#C1¬I;xû´Ö©!³²³: eÒ‡Œ#£*§rR|)"*HŒÐ1 ú øZ9ƒyÂÛ‰ -2‰ò¡¹üC ýÓ ɹx…x[ ÃÁù9È)f[€‰©¤Û ³°×H&ËÜ“F$”ANs¾”È@É,‰rG¾Ð ð#ÍìÌÍ4†0?Ò±r,¥¨[¶! n”²‰[«°9R•ð hºŒ£º{ˆh, åÁµ¶ÈJÂÿ³‹ÆSœ¼—ËŒ·tËôÙ?“ÈBf›È=”À˜ZZ©2|¥Ù3¥‹2*‰½K<}iÉ­b ¸ N€¡Æ®Šº@AO”HÒ‘‡&Ͱ ¢9¤ú”‰êrš ´-ǬLd©®¸Ó1"#’¦xŠ ¨M}ø€¶x¦’#À$Qb;q°§‹ò¬·yà°–£Â„HÎýr󀊔p%„"Œž; 9°ÈˆŒ™bаî”<#za¿=‚1šü!ÁžÊ,¥®J;a• ‹qTG?¢Ozp‚p‚0‘R'p)͉û,çâ«^CÁg$²+2û ¹†dÐ ú»®@/åÃ&ÿ À¦† ˯Ž"ѽŠ:Îa¥±™kE1ãB?Õ¿â`‘ˆÑÅ@“ª%ÈÈ6”Z)댩 #&=ÓŸåº ÖÌ£Eû¡¬ ¤±„»ÒáO_à @R;ÓtO‘¸Ìɉ6xR{p‚šxÕ¨‰(ˆÕ| R{XU ÒÏ÷rÁ£L‰w\¤µ* éˆů¶p ìŠEËTQž{É!:mŽh‹‹#¢M yŠ™›¹ÄÈ?¹Š¹•€ÎÄ™ÈZ$Ԍ̢ƘQ•‘ã3!¨‘îì΂ÐÇ‹¬à¡(¸%Ë´c8¸Ø‹‹—p<ùO€ÅÌqŒ‰œÒˆ‚Wu|p‰%  Œÿ…‰U)µ™øÌÄ=cÏ–”?ê‹(yJÖ)‰ô°Ä"œ¡½(ž4µ+hLå±—ÏQžšE…°Všðš“¹·Ô¢=-»ì?fcÅù/OA‰•4דw5Ž£@F­Àê½óÜÍIÒ=°q —P̃U bŽ|quŒ–H[*qW؈•X^¸[àˆÅØöÓL$ì!$MÒ½ˆ’g‘8Å4#e:£Úœ‡Çk*…X—ì)¬ŠZ+š1E2EÀ¢¡}ŽÃ• ÑV¹ZU]ÑM‰¢%—þƒ¥BEZ•¨Œñ¬‹d¶W™‘™)˜}T(… +C CÁ$Òa¼ÿ°$´|©‡«/ƒq8˜È—ÑtèLzhƒ U‰­Û¸ý‡"(¸^íÅÞ¸Õ‡X-€Œ¥‡Gg<¹:ì!±µÀÈ“º›MÄ=#ì›jrY®@/7=_÷2 ! ÅÇ“ßmCˆ `…è/2U »œËº$Úhóf†àq¶ÿ²^Q]D8 r©Ñ¥¸QÖ }<ûx¼¡Q%Ü;(í“ÆÒ(ÁÒœ¨¡xßÍTX ¶¥‡€X¸ý^Ð^(à â!Ö^^°Û°Ø*1ÜC~=™º¡(¿ØF0Ч¨Í’à;‰ë½â™·/Æ;!,}1‹T«Y)+¬ÿðìj‡¤€ý:m… VZË“`¶›ÓBÏ›ÈôÁc-ì¿X,‘"Xì%•R 1C)&Ò(ˆ„Pܰ K.õ$‘О@™2‘C˜ŠP£MæO¦ûÄR'ˆÞ…[êÍÞ"ˆ¬!^å!ެTÆ^¼Å[0ÉÕàøÝ&&@’_’çy8…€ôÀ/ŠS4žÀ+ôb¨€‘›ñê’ž«Ð2fþ <­<˜#Ñ6·T"@-à¸l¶ÙÂôÉÂÆdfäó1Œ|H˜­ØÝÚõ ª(ãµQɳd-^"»*ñ–ŠšÈ–…èÞä…¡Òš¨Ø¹=íU!ö,Ljh‰neÿ#–å)‰¯uFᘲ·¤}n¿=Ùœ½ P¦ÚT¦h&S„“ãÉ÷^{Ù •ä+ó5m SiÙ Dè'WzËÆ]òiE…QýÛ/g#ä¡Ì äóYÂÀ‰û­ÉØe!F…¨ HÆŠi¨+:ÜWŒÖ±.Â. ‡äHak¶hZ­ }¨[¹Ee#Æ ÏúBŒºˆ¦èëÅÛ|XbuýÔÝèDïé1A»ˆ"Bl^Ø ÏÀ£“£ÿÕ_uãݺ²²“½}à‡aE§¨ãÈNŒ“P¢¡V"Õfí%jíó¨î6?6DvÔ·‘Z¡ÿéË»Š7‹=ª(l‰ÂGчxÀHià‡Š½·¾ð€»Û"øáíµ^…蔀“’Œ^b‘ÀvY&’Ñt ?zÿ$˜Ùâ$¶h‹ð«ß9\þ 989æ’À$æPá¡ZB‡¢Æÿ=# !Q >Q¡fmÄ€Ù–m‡„í¢^¥¡Îàuî¶N¤0Ì«–©ÝIŠÉ©Šà”¤Q¿~ÑžH¹aH‘ÂåVî¡xnÈà[q7 ð}˜ÛíæîgWÌÐ% 7‰ˆn]ò¾›ȉôΠh‚Ñd¯²¸§!é gÁ‘’–ûÅÚÕ3} úÛ”;_›{PÅ%#Ÿ!p%ÿ¾‰˜nV¢cksæ–qæþgË¥6 œÈ ž¼‰¸Dð‘Q:!&”¡Š0 5Þ±äÙ+ê’8¾鎇ä®î’ÀÛpK¿[¹å¼‰|¶^°ÅOYu!/œì†Ø*ñ¼ð£!"Pš)ŠŠÇƒ9`øe¿&YŽ›Ð&O¾ìPʤ³ÄµlÅ3‡c+®c#è !Œ8—B¼ö:·X$Í„Ib.\G7cœÝF~ªž²ç‡º áçÛ° ), èÎà¡æ‡Iîð€Xvm^ðáë5‰¼Œ¬È* Ù¶”øwÉbˆ‡ÁîÅ~„‰áU[¤gZìœJ¦ÿ˜¹ˆœÉŠJ2­k®""'åQc.Ãéb»æo"§]ž®ˆ°mÛö²¶(ø‡uhov½ œ b*Q†ÑŸa’]J$ˆÉ ø²¾1}1”½À(,Šxí§÷€z—Â×ní¸-Ÿ/ ‡ÎËî>‰Ñ°¢ë,²gê"˜s‚‰<Þ’ÐxJîÜ8Cøþ\ù£_­Â Ò]]KÌ„4qpÂ#"ù…€ã!pŠž†ÿ ;OÛ´Y‘…ü´MÕˆ‚èù¶vH‚™Xïïḛ̀N•`d‰•¯Ô„Æø"NÌñ’»ˆŠ}z}PpL×ôÕˆêånÿ”He¦ˆ^ph“ú”¾žÎ/ô‡æïÅ P…\Ùé•´?YjîTìSzùÿðAŒ×¥¯¨}žf_¢2ž‡Ë‰ ¹Ê¨Iq%†˜ÂxÂÈ‹üB™£{hB¡üœ\h“€ØÇˆôìø÷/Â|7(lè°!>ˆñEÜpƒÑ‰%G Þ»·ñŸ¼#K ž˜gï`>~úòû§Ÿˆ¼ôyøSDK^2ÿ‰àSD‘˜ÿ!Z´—ª"I{ùøÇôRÓ¡=¼tÉ ^.ò4¸DÞ¿‘`ÿÐ0ï_ ©ÿbÐc{¶a…ƒÅ`´–Å=ƒFþ Èapì’’dc¬ý÷¶! y,þÿ±( áÃ}ˆJ™Â? “%ä b^‹òFîxÓª›Œ5èD.l—+Ñž7𤽹ó­X°ÁBDµƒ ‰1?F!pV1ÙÝ6W"tÁÏ:ÍìôýÚS„w™@ª"ú°hÑò½ 6mzõ_TøW}\òµ¾ BУw‚ìH÷¤…Ö 'ˆÖÚPmу™A”9ÔV !€AûìEá?¦AgØ6ÆBb‹-6Ï<Œ„!“ñ„™d Q¦žA0O-”Ú Î‰–¡AMüÃÚCôœ˜O=$šhK„VRh-Ì?½Y°pjá#Ä?ø,—Fy5´Ñ=`°ÿ˜AùÄÕRC.D“K"pW“M•ùdN?IUTCè5¤J/EÅ×PTía%}ƒÆTPÿ5RZ‹ÉóßCdþÃ=ófPq5Ĉ]æ•Ã>ÿøå×?˜ Ò9&cŒ‰Å‰OF¦â ÿL¶"ˆ€Œ2ÒÚ“g5 ’£ýØ´ ybdTFYòÜè¦z™—ÿÄ£>{g÷œ?ùTçN…{”P—_Tï ßÂUšŸù8qÒ<wHÇÊ#¤›e¦Î:dO§6—†¦žêvCÆ‚äP„ðŠˆ$nk‹˜ Ñk1}´=üõ5YôŒ”,²i°ìQè“wâó€5`¶ce{bLPbAÚÜ¥}X¶AÆB̦÷JñX÷ ‰Ã$Q@éÉÿSOï.Ÿœb^`…>B¥0žä£]¡ÇC6˜ þÇG¶1ŒèCüÃt'C N@˜%ŒChðby©!©jU NÀˆH E“ÙÕ Ô¢¡I2>,rÿh@ CË?8p¬« éE2™îD°}„X¿âX“„¤¬ >˜Ò?Š>© bpkN^Z&Ú#@S>¦§’—ìÍ%{»Îu—¿"eá#žBÀ<•§‚ ||àž¡@Å>dÀLö#Ñ‘¥ˆ:Á¢PeÛ¨à!¦Kš ÜRÝã·s£HC5ļ°@±ºŠú•+‡ðÊÿ è¡A¢×Aã…à$O#Iˆ,eá.oïköÛ<é”àY"#`ð=diC›aòò‘Rq³11]Þ¦£’”Äo;.ЇšÀÓ~å)`EOžÔ‚¥)2 "bƒx¢)AáŠTþ3’¯ðs_1ˆ X)J d¡D][H"7˜Ä˜ùøŒ¢@¢˜T½0††™Ç¬$ÌXF2¼ZI³„'¤þôG *‹AZЄ¢eYÁ•»È»¼±tY'âŽ÷=*q"ÿØÒ àö6mfˆu³I8W¾”ØQ#pA<Ü4'ïŒG< d<Õ¢A!lŸUÑ' Ø3Ôä5•ÿª>—‘ÙIëssƒ`C:L$öÈ\ &¦o†•i1Vª4V’ÿÌV™‰ "r(‚!ìJ20‚ÌJø3Ä/H¶9Áj~”¾ÙËVBábâ˜6<¾ Å ðQÅg%lR¥`9BºNÓ‘åædPEælü&U—®N@‰É;Í#œòü#)IÃÖž«P÷!í!ë?: º D %aX>w%Œ× ¤TC ±WgA†³,+14f³’´ÑuY "©³Àr¤²txvxÓ}f¡±Ú$h $šŽ€ÍGbRdˆYÕj6^ôøÆƒ,îà£fQ ²CÄ …Pêÿ6/e¦Â†*‰G×”¦†üB`ÿ«’s ɧÆ9®ºi T?‰²•^"Qcƒ/’›ú¼Ì‰²dÎÊÔ\þê¹}-LÚjb~÷(o ††³)˜uÕ¯˜èce:ž–Ñ`²4ÒÒmG²Õ¤ôw¸ÒOd«5¹ñ¦á¬sEœ¶o… çúƒA²˜ÜØ#”F’±CŒ ¸ž4ä'cR˜K@¥Ü3ćlœQÒÙ‹+õ Ÿ§‚³°å&«ÀÂéÛ„Ô ÍPjÔ外~&¿ùý¬&EÃÌÄ+Ô êq[D¹T ¡QÄXÄ¥LH¼ËÎÉ ® ?P3öbs&Fž0"!¥#‡•Ýu]¡`¢C8ÿRò!|èídLZŒDj,AFÔ(þøZ{Á[8 „\L^TË_ŒÆ‚­Ñ[„Óý9‹ç Í‹¸É†¡Ü¦œ½àdp^#F"D :á™îp‡GVƱqÛ4ö‹N Åò Ú¸d‰–œ„+ö!õÙ?@• Uñ ¯àËK†Τ=æGR¬ÀRÍ#â ùäÇURd¥U6N|8ýÉLp^-JF5½ED$ÊhJ„RKt…@ZKLA[G Eð`ÜlÜb-½HƒHFÊq[Êq‡d–‘Ø¢g`äI2ÄfÆ2VVâtÇ/ÄDTnáQOlÝ$QÿGplÀ,Æi<È-FÚÕñåt `Ú TÅ 0@ù">¥l†[R€ A%Â!²–JÔ:Uø˜'<%" „ÅÌÆÐŽ@ÄÝõÕ?L@CáâIèF'ý©qSjHÍLÜ“¸Ob\^UÙK‹¬‰9JQ¥ýÄû fŒiXJºZ2ÍÆ/ÝH ï4H ÑÔŠðÏ469àC”–hÉ-”Šì1Æaä F¦aÞTBL]½9HŽor‘*¨VX‡*åØTõRO±TñèC QW¡¼‡"±ãXvEõeDk¤%)–ÏL€[þÖP6D$Dþ…C ȶ\¡/J³ÅÿÅlÔ’e!“Pˆ™›TÆûh˜•^i.(i.DdîºÜ1¹çJdæîìŽådøPDáÃtÅi°ËPà_ñƒýÐ,&ÄKpfNà?0ÀSâ rA¥ "à )k|Et ÑC'äLÔ]P°áiÌ@½ÝuEn|@÷uP¦HÝ-òÝCH^©)ÍÆ ÜÀšÜÒBz:D¼åè!”Ä9Ýßx_]ØcòÄ ø—iñ |þÃeÚKŒ©‰š„XE| ›Eà–]nRðxŸ1eFÅ ‰”„¥ô9EÑòæô¦ÿtG¶¹súÇLuDjhkÐÙO' ÊÙÿO¥`¢ˆP[âa¸Ú¬¥Ì[šÉÂáF'ÑT6’ÌC“ú"`ìCˆT›lX¿ÌÆ9µÉ˜ÕT ¡>ä‚É곸„ž=Dâp,:¹À²Æ%°éÒÙ!š:Dq0€ aÀ*õÖÇ>WˆbÜ Ï–„Ü”†©o…4Š@Ž@LŒ)^LשÚ\œYM£ Êê"VWXæG°¿n  DŽâyê-Ò©¨ÒZWÐe„ ð*·¹â홋è™K>iâ,«šìjï„.6³xì?xlµ6±F¤ÙôIÅË P ‚Ê–øà‚–ü`ÜU«œÆ…m«*1˜j´ÿË“ìF2‚ÇR~GxLYfÄŽÜóøÝ_¼k£ÒƒDí¢,À "?Š~ hX€&•E¿†€_ ^µåÕéFagÙƒÈCµ(QöTô®Ù¬ S E†ûH€ÝÚíš´¡KüÂДO¸fÇD.è†ÑîÒÄX÷Ò­øâªl4P”Éûž ³¾lql@À œæR÷FØÑøƒI›©Ä™ØF!#ÿà™,™#½ €øHL°ÕL°LÍÙñG‘I.äBý”à>U—U¼` C¨åÄu…§žŒÀÎÅÜ$” 8P}‚Ż^â„! “ެ“òÞÿ°Vø–Ö²zlÞ̯JyÿÆ—ñª&u؃¼ã>θ,èPTĪ)>T LëYÈ©’~a¥´s¤‘nñ&q Ký”`v CÌÄv$ÄI`‘¤EÛ*ÉÕÄ®ÌîoÅ9i,žP¢UŠ@AX’WÐa°E«ÁKèF èF_AóNT†Q XÙaõõÜ ŒÌƃ,ÄJ€„/ùRiâ®ÄùÎoìN¬Èr!™5D‘ „å´]Û9C\Iø@ ›âBvYÏFÀ æJè[%,i`Ï:ÏóOZÖ²æN )Z Z4ä?ƒŽÄÞ5DÉVК\&§é#ä2²|ÇXDq¢ g9K)ª¢%ÿ,Â. ¡PðDeô>ì°Q„™=l­Ò¤‘²­òªðTÑÒìªøZºÉÿA1Y6‘¬%(h„³›r±CT+JñÇ£8‰“ˆ-·HKqVâi>¸"è„N¨IÞ8AKåëÈ MpN7ID´]ý\æq¥Ç Š÷1oçÑ<$”ðš—C¤Œ© #lßv„1ä…@/’ÈÍñ Q„‰™—õ'À÷––CSlB.‘T Á«¬éÐIñÍE1 1:NË*Å®ÞË b‰EXÏXàUf½ÔØ0ñ°0™y5ÑI„SN¨&£Å¢R0È…ó¬YhüÿCÌîKÿÂíÒ“sɇãà ^{LXÑ@Ä€ðv…åº3wM@†ýG=WëB5ô¶çYV'ïðK™ãÈ‚2ÆñC Äüz†M#‘\¸IxdBOKµÀ·@.O,À% p,h&¨ˆi›ÂÍb|’ÂÆJÝN}M³‚) çXó@x†CÔ„¥QLÞü46ó4G´m£ „B¡ÅÕ€6ÊòQð5&†¥ã,«pŒ‚i@/=5§lß-2B\hJ£1ïÜÌpBdÔžé’1!B ·ŸTB·ø²xCxlg@ug Éùr¯Ø—]ã•ÎqçrSO†ÑàˆÅ•@®FCÿ®‘߀£¤¢K tO¢`ÒAYrÇpç(¾ÆK )kÐCä«ÔdˆÔ¶”BýŸåôG ´ì>ªÆ>Ä É‡!ñBK°T±”ðýÔÜ|ªéà†Ê@rù\õV—j~¹·È@×É<©Q¾ƒ¸¸•Œ£+7¿5àFGÖõñù[/³žPÏ ø8 yhŠK–,€]Œ…œæ·J(îu¤H‡XòÆh÷(Ö<í¦V¸Às'‹0ʈìšù™{v 8r*\‚ð•‡4ow>d• {0ÀVàÆA/BÆ %­+fÓÚRÈÔdËó`Y9K?OaaŠÿì1…ØrÃí’"t J 㒤ŀ'1O^Û´èÔáoèr©‹‹q<`N¢ iZKÁî„1WÔð¦'ZØ•0±ÝI\{L” "myൠå @MK=sàµB@üŠš;AÕ¶csŒ=iE>´T'}ç%$\—W§-u=жÊTÀBP¹2DR G¨{}CòZV ô‹Dºû¦ u”É_ÔsV“ eY1«ôA\ž=èCV£x&yç$›>kÃgIÌZn¤ÝšÀ75Ï‹Çkw𤇖•Öòü¯ChàñƒËC(Z‹DvöÉ;Í® èÿbRø€=éãû؃ýqfEŸð°ggCLd|jÞ5DÑ—Š ÀVà*¤œ÷P´ñCÌ{øxì*/Íu?H-Ña¼Åaù{¨õð»ˆkU£Ýãd•yþâ‚xÂ\ û kdÈÚ2-F@[Ç™há³QN€°õ‰ @ÑËñ–F`ËfKÝòk\;‚ƒÁÄ¿æñï’@O.Ú4lãâ_/N*Lø7áC…ì ü÷A` # àPòä¿ôþ…h)Ð¥Dèˆè ¢6I’Ì—ïŸÌ‚ÿråÓç¦z-ÊcJ/„K©-èÍcÉTÞHzöBˆ²TÿÃ?–ô è¤!Â?!ÿðY`Ûó߆‘øÞ®Ý d¢'V0*ðÃÏöÆÎû7¯…¼¬›$pï_‹Ä*ŸxÐÇ?½4û(ÂËE¥aÿi ÷Ó¥¼{÷8d¸w:Ê?yMž:)(â×?U»7ÿ+â‘ÏùŠø0Þë—“&Ë›<ü7ñBPíU`d‘Àޤ;Ò["ƒ€È XÝÂjÂV? zÓ&"áç*x8ÈQBð§·´¾šÇ¥(¦{)„ÿ›Í)±œÈÇ ®¢*,ËäJ+®·àÒP ¹äê¯þaÁ°|2²ì#{$¤g¯¬æ@1y0ðHžæAŒ/–Z2Šÿß~ëå‚ô 4ÑHc ({Tk-ƒ“BÐG©r"Š|\€h¤Ý4K(¡<ÈGÇß6­ Ú–k¢6*¸àÀ .ú‡‘® É#tdN*o5ÅRLÀ²iBy’O§žò‘É(ÿ©26Û®jê©–øs©;±óˆ*– è/Ÿ¯–‰ÒrË­Ü’‹®;äðO<Áü‰ŸüòQ1ÅZ€àƒNxA±{f<,ÁJÕ«r$ ‡4N•">Óg´­.2Ö2LD€0'´"ŠP…³^z 2¡ÏH’¶Ç_~É¥ š«ËŒHêH¬:Ê_îÉS<*ÿPÕc*ª ü§¦ õÉ# rI öCJ2Ùž‚ °¨‚í—*NY¢²€|2HÇ<’ËVY}•.èÂÇUn@„~”´(}rõ¨£4X½À&Èêš4äï>ˆuËì’„6ó!ÚД:¹ d[!—nñV„+yÁ—s묅„Û#'lú±—¼‘k¨‰ÚèŠ7§ûÀ‹b˜àí Ó±§Ä”Èúø@ V#—°'‡Ê•DÀ™Ì ÆÑMp¼Â2qN.ðV2ç6ÞÐÏ8\"‰*`žØ£‰\J㗨܈@ŒHP‘¢º4š«'s R´‚³«¯…«?±Q£ äåtekúëR—HJ3ì¼rzHRg:ü‡H´³¦E°‘ÿÈA3 àW$Ô‡yÒÁöDŠAɘèˆ2j6å0/ÙÕçj'æüƒ9ˉLÇ¢—ô0.1£Ùu9!,€Âô¬â&(A)W 3Q2?«§RÑ ¶¶ÎÀEHÆáZÿÚN™>žòJQm›GØõÅWÌÑCòÍ·â‘/®!GuD8˜ ,ü‰TÐÀDþc‘5c2ÀÈd ®0qÔM"1Î]î Œ(Lb“B±Pz¹ÀV¸$Ó‚&pà±ÿ8 XCÙ{Ìæ} æ?VÀCÞRfqÁ/]µ–|à¶³[+‡SL~dŒ>Dý Wtõ@d/±ÍOÒ¨›£zD|!_×2…:( ^± 9© ¾‘ì¸ìä_æxñ[.ÍS .à… >ò9¨_bÉ Úº‘Ä5‚ÉÁ#—…Ƨ[:‰ØojÂÕíç?©]T‰ÿx”5é[XÿÉx˜#X€Ë`Hˆ$­Gè²{tj¶£úG®`ûZœ tpáŠP[Òº‘¼M-ÂMêu¹ÆFüdvR¬GŠ›8 éÒ}nOb“]q¹@o]Ú›D¼;7açüTë<Éd¸tCw]$¥9cℜsž1uè]Å0+ÑÑÈÔ‚ó@íæ |¹ãH@HïSƒÿP HÿÈ\ð‚2L5…ƒ“CÊs;tÅ\دÂèhšKÁlß»f¦H†5Žm,kA†ˆtöÞ3¬\µ–Šà?§Q£0ç¡Ó » QÞ°1 ò<ûî?4uþªÊâhmúkk›´~A¿¬å˜ßQÖj×DH¦ ?~uBz1ëž`;²™¿ȰÐC­Y¤ÈJÌ2ï•Ïe8g”ŒÁVß›Pj£_lxÍ º¨GËÙ!e%ÃÑÇ èÜ¡¤Ê‡x†Õe´h“ƒŒyƒâGæl’èú` $±~zœ]—6·K_%†û¾ˆZ~XÓæ¾{ò¾"‰$ ßrGXGÿ™_1`Á É’Ä€/¦QION²„#´`Ì ãF¢ò÷Šp‡ áŶ©È법åIKÀxžožv,KA¼-:oàãþ¹øª ©Ó&%‡i/4MÊÛ˜ ÆÖ|x´Ülhë$;Ë7?ãwF•Nñ†Ô…ιa"¶¡].œðûàÂ%I/Ii#^GYß±+I˜Â$uÒ#+ç¤{ ô—áäÛtªLž ³-Öfðòª!ðµ#¶N V`è¬ÁÊíøŒÏÌõÒ+z«&ÒG ^ \÷xæ MhrïaååàBZ¨ ¬æhKHâ(AŒ¸†nègôG¸ÿZn¤K]ö'Hƒúh‡€°$kPlŸ:'X¢Úc¼Â˜,äFb FÎÀh$G˜É(„âêØo'ªFèh-Yþ©Í˜‚À ƒ˜¦ 0ëÚh£`é%`‚zþèzG RCVåf2„-< âš &4(3ÉjÒ†ƒ6‰s°…¨xÏJÞiÔ¾nìähìž‹öH°ÔLMŒšª²jLr"œ€óç·ˆæ:6±#N€£;ºo –àï4 ×HnäFä cÐX"XlBtB$`mÂ8‰'zïQPc$C2œ‚)Fʱ@j5"cÀ^é•”bjüÐô\fõb¦Uti="s FÿÎLƒ$øsb¸±ñ¶ôAÒ¢0æu,3‘‚LP3îgÔFMìL­ßD0«æ©fìrÃ#×#æá;b`:O%Äo®®c`Ê#R+=RN¢…3Ò2jË&…2JS¢"„µì…6Ü̱ÌÍh'}Ô™V è0SˆÎM0¢:‹¶ü°&64&P(;måæƒ ÈÄ^¬Ó‚{"!1³ !„DK’j*Ù.ùèfÁú,‘ÔhLz ã:@ã.Nzï,÷m`Öò!1*¼$ Ê$*ŠE¢h±b^Nc<â* Â„¤bç´m$ÿ&+²l(‡4ƤþAgÌ0 UEUxI´@Äôð£³jBe†bÃjÞ.0bàMsÚ©' ‚_L_Aºäª¨j3~£)Ÿk/¡*Ù…n”Ï«0MáFâœÅ7dŸÆ2;2n£µ@2!'2ÊÌ!×’abPìò¢h'ìÒyœ.õ •óý,clïÀRb9:æ+ÔSøa³C"@×pCèBÙH¶èc)G€ê²+QæKß"o(p5YŒÞI7Fkñ*-­µr…ë¨êQ쌃(ÈØ‰3â¤cN¼ äÊŠiø…{²‚!!¡ì8âF˜éaè.g1éE.Š@ÿ¨g:Beç¨ ²&+ÍH§_òmÈS p .pÂäb„F¾æ+ꆃÁqÃn‚39s¡Ú)hâÞ& ›N“íB­?éqÇtìç‘ ô‹nRS^€äúþáŽnd½«#NôéT`øb ˜fCÅ Sb-ç 2œb+Ë.ýbPJàR&¦c:?Ú˜)6RG ¾"0±0F{. mƒ0¨(n &³CðïŒxxT ðµ~#c&å ¤ƒ B'†R'ðD3Fö@'ö~¯³ä¨à ]úÓ*ÃΫ¶é~ Qìäè¨8ãmž’Þ.k(n:@7á;è!N´£VbN ãŸÿÂ!‘Юê1F6ú¥E›PŠ"J&Œ‰Oyñ@.j?ÒzH‚6¤*Ev#`d’‡´|ç1ifñb’gƒ2Æ6^‹ Göj'æ‹37ÄIå9ΑÆTá4CU¡GTm"?·RŽÖιÔ?ã‘?ïçÀJá…DÂÇüø%+öe’!Ãï­þaC‹‘[Ûò²jd0§ÿƒÂ0É)DfÙ¢"r)§ç¬oP‰zƒq†fè5-Ì3—îõUlrfˆHDDd0˜ÈTŸ##æñò¨ñÎÑJ„ã pã\Ž$‚õJnÓVåñ¤ô1¶W‡ä·¾hLÅD3ÿ>ÃX×bcÿ¡”u$PvÌOjàä;\„”ö‚äh‚r[·5‚æ®j„@uQjc¢°Ê>àbzJP˜¥ë¬“ü¨m¤¦f?Àd+àÂ^;ÄCÚb´Î“G_*“t¢J:b`sñ`î2à3û°Iù§j& bnó+#B"î\$â9B ]¦”µ¦?Ág3æ)3~«8Ì©ÆÞîzßé7¼âÄ0$Þ´)N;4 ×"—$ò$£‘æêr5΃¦„"ê“LÈsD¨m ɯ*Èï„ M™ú¥gJÅe¾-Gçb\eÂpF¥P F`W¨Wøg¡Pu“üÊlÅöaÈq8nèAÿ ‚Aq]â !ÆjªžÈ>Ö5½t*¹Ä‹f“{#+7úl$:€ w$:ÎüÌN¥eo¤=B‘84rÑK©~3·Fø²Êh10Âu§@Â%C]=Â@†„D/}í?†v0ª‚%„Ü8Üné0—ê8aFñâ ö„-CÒg¯2G(=Âl‡ÆUB•èAv~£ê\  ²"F¸P퀤@µ*“‘Khsù¾ˆˆá䀜Õ0øIšÖôivðœŒ/¬õf¡Ø•iä æ  L`4·#|ê#Lä—áRt“ [R¨˜ &F&ÚÖ8A¢™ìa:g:ÿ,Õ0ØÎR ´øì=U7`¼¥A©2ëM8:í¦r"—ô2ÂI±@ÂІąJ¢€cè± + Ar#|KíYœrKF­‡á)KæèXå)laªîˆr{';ÂÌ#>~'÷Ÿ2WäŽ$îÔ#äŠ12=´¸“ô£ÊLäb,£ ;™CÆ:¡ö:…jhMLŽÓkqæEëÎD‹õPD¼æî£>Þë'…wå”÷FX2Æ"žåyBºóÇÈ´ÞF5- c¥2¬d¥Ú?•j+›…pØ|}SjÆòMY +ò-U"ü4T`2O6îá;,W  沬b‰öj§hmËÿfq¯‰ÙDR'`¶ÂD¸¢hø¥­¦ÜLÏ–,@ w õðáÎø¬1/CŠN'P„Þ"ð9%3ƒtà-rÅIÉB¤¤n‚Q rúH ,I7¨Ò5¯2WùÍJ}ø+½K=¢Š ”XG@Nz ÈÞÔßzû"N7´­/ëÉTq²æªrCs•h§RÚ3-ƒ:¯Wg0b…¨I$ùë€Y¼Ö#ŒÂêØ&qFoº ½YàbV.å‚&U¡Äku¢H«Ž¥îO]w$RIG Y’)1à.6¶cpH.m Ú“nv‡áÆ~£ˆyÁ<âU‚öNš”xûØš–Uc¹ÿ»uRÅ2â*O#OW<ƒŠOÃÕ„„:¡3\ D”rè0Òí?C,t¤w4.òL›“Žõ¼™ˆ¨Q>¤/ƒ'.Ù_«Hÿ;ÄÎdžÀ[\…œªKoòæœô–kX,”õ3gй2Cª»4uìÂgXÃH8‹û÷0²ÃÍ:+€s¸wY£7ší0W`C®ò4=˜© Ù§þ”¦3°ìK]?à?¬"O,ÚªÞF`±xÁ"`UnÚ-¶™—8µUð¼e²ƒtïHçM(mo_kÕs*»Ñ‘“ ׫"lU5ï!ر|ÖñJÏ«Ú3¾H«=#›àÅâ6\8'zûÿ’¸æä´[[¹•O|ß<ô¼ Oºý²ö‚¿u#%*°ÜÃg»8ë¦&‡:ÆtÂBðÂB‹8kì°ÁÜ0.rz‚?$§#Œ‡b2W ³|×w_ýÕ©ÑHkb´{¯J®%Ñœ Žnõhǰr]óV‹£Í5c‡ßéÂ}›>^Y‹ÀFÞ”•{®C$bd$Ìwï̺[—àÚY`¹‘°®›F"=ÊZü¼ ‹— DC¯x«Ê•9}Š,5Eµi®•LÃ4´è¤F"vëø-è˜CÊmÉÓR/»È;0ËÒˆg\ ´'0„á4U§ÇÔ(s¤w7€DK¿¨Á ÔãqýÄàæ7˜ýãó¾pÿ‹X FÞãTâŸÀ þm8¡Âƒ 2¼ñO"ò ä§¡>D.þñs1ñ¢‹ú@vÔ—eÆQJŠø¡ªK>ÿþ©²éãÒÌš i6üyI ϽpÞXôŸ§"™º0ÁK ¯ÿœ°˜У -pB ˆˆÄ68A‰ÑóZ}z¡Š^ôITÊvÎ󶆴M!}‚›MB8„ ~&ðÀ¡4 ¨Q›R”ÿ€À‚–ÍaJB‹Kæ<”1 @C£Pa,±&¤J!‚l6†Ë\æV- ¯â2 z$$°›ìdW$ÝdÒ BÛd‘жÄÄ"^²arF-ã,¯K3D ­ZËXþ#–´l-a½\|MKa“NwГE=mŠ=é3“úòæª$3oU!W4DmF ûŒÜˆ mæpYB4?&!¹xL ì”[¸)tú±tÃU âbÄ„.t'¸BG³%tpG¬£¤&E¸€Œp„@²ˆ¦»„˜'i# áÕ,’~g#‰²TœŒ(ç‡ô%BtR™Ît·Œ%=¢ÿçLÑ{芎ž¡Üí*T5 ²0 b'ã ÿÔøÍÀq&STˆ]–€T¾ä±C“œ8êG„ÜQS÷h¦¼)¦ÚèÆ GÌŒáHÅmU!ö°Çr¾N„ÿ(ˆ@,Ý­“¯¹ä[=±€2%3„è·®•,LJ!°GGoÅ«ÄÚÒC·üGöD=„´@W±¤^GVZÅšE uÒ¾äãY·y‚™ø±Š3UƲ4hA’ÇDFŒ†aŒº*_Ö¢8nîEbšÊØ©~k*½ÅC…ém‘ŠØGJÕ3©sѯÚpÏ}ãV«s‚@F°‚µþã °]AXÐÿhåæ»«YMíâV´Þ`†ñ!p”Áö%Q",r«[1EÄž.sñ‹_x-À.È^d­Ë—4eÁ›U›Ûb‹;Ó>w«Ê 6°k>Q : #&FÍCQ’ŠØ4÷±à¨@#ëØ?ÈI€Ï…dR¥ñ¦DJ 0[n[ÐÕÕ)äWhƒ=œ`|4T»ÿa“#`,D H¦9Ö’ÊóJ‹ m/ó†w‘儉†´:¬Ä\ä„H/lnó/Là똫O®³€¿†¼ê¸M]øš-ÎÚ·G}>ð„Ý®²Ìfö‡`õƒ¤D¿y0¢E^éŠ@Ü(M¹ÿE‚÷Àm…¼9šÞ¾¸.1"ØjlŠˆcÜ<‡Oü6÷W“Ýên”¹>4D øInðLn¦@ñ^]ä…lO¦yw1„Há¢M]“|Ì#É™oˆ2;7‡IÚÒ””¦N†¸Ke| *˜GXñXwH~æ¬ê¢ëóêÌÑ€Û GÚLü,ϲËÁyÆ<ØaˆjLƒóR:¦!+!zç…µÂÒy‘zjD=¬÷z^ÿÕ¡RR/q{/¡%NguX×ÅD7ïQ'E`®büðuóTA(× k÷L–6ÌÇv…NÆq¡N1€Ob@zG\ÿݧ¡QOG÷P!¦ó7Ã#ưUì§q=ãxŽÀ–4ôß%e ‘]Q !Q´)(áPÿõ+‹¤HN`zNä¢%\³nH.q8L 6aGáú!3®Q#øY) ãhö#m§‚ CMŒóvr§T¤' d D¨!äÔƒ>ˆ+\•A9‚j¡ÁA8¢*À#§£x~eµ7 ;ïWô׊õgÓ¯ÓyxÿM3ÑÖÐC+ÖuRExQ@CNÄ€äö ¸'‡¡%ú1c²M!Eó‘h²Â'ŒðSv3bhÄ% (gA ›!AÅ0Re)©"wy—A^¦2‰D„Ä¥1:€‰‹3Ku§2ò1ža~@–x·‚#B¦OAÅr¢@s5-¦qIáypWÆvx…01Ôÿ×…%€a¸W4TÖ†`¨ˆ†›Bn¼’*©’l(Ïè{ø¢6u"µòLŒ€‹:+(8ˆ²F'Ód ‘gN"qSwïØ!#³[óc÷( ƒuGU¼²¡>V•(§ÿLx1/`,PöiÅW¸lNˆI2'$ù#]†‘Ls1Å‘ ö`’='%:Q0—(ÊH&l¨’a×#õá#{¶õ¡ ˆÁ0(‚#°“=98÷ÓÔS?جe)KpwtwŠƒFŒƒ!66ƒ¨æƒò„F^‘\¥“:8¿’x a„>( l¨‘Š —«8lD2‹Àdÿç@s‰z!ŒùÀsBG€9=ÏéÑ%.p1ñûAWÑ\b{¶wQažúažã)  úÐQsŽ 5ñÀ=ù“‚%pfäÇ7×™(†[·¦£)2óH2 äÿƒõ´^%(àdr‘Ó >(ÿÐ ·ó–ËVœ9…17 ‰–8(Ê©q¿—íe—þç»ä’vƒ{0¡Ïøñct{ ažÈŒtã&ð9,݈›‡¤Õ!À•1vžÉMIÙè43›rf¯u—ˆ‰ ã T–Š#–;³¡ÕÁÖ›ð'-óç–%ä 18÷Ìé@¤¢w9ŒÍSmȆëFëfu}R{Üé=©‡z¨0‘ÍH£À  ”šú‚bê0¡ Æ–"r:¬ešgÖc2xUð9&ãTZ«üˆ«´¸PÇ‚BU,À¶Ày‘¨aÈi‘QvúsO,,Á)q< Ñg6qnÛ±è–né¦/È3žýÆ­ßj>2ž5{õ/ú @(ÓA õZð,0`†p¯0©bP)ûC?£!)l¤‹܇ÿT± 2³i«I•;а›â¥èw­l‹Þ¥mJB2eSX,i5‹]ö=É^Q’,Ñs…tãÈã£7QïÒRYDg,Y& #ÛÙ<¡’/‘£LÁBŠ[Žš9¯óP¯b*†@Mûð¢Z,€ÿp¯ËFRˆó|mAc*æG€¡N¢»Љªv¶Ã+º¡¶ÓV?0eoµ]˜ô÷so5‹ý&1²°A?gÄ÷¸x%ËÈEÈC¸fÂ6m²>C±n*ù=¤>RžÍcQ;Ê.`Œ¨F/°0$pp]!@üN»º@ÿba)\ºp^q8ŒT“"1~¡°m• ¢ }t(@¼Ä+ P¼ª¡? ÂM&P ÙlµB‘· Ñ“ØË:–d-2Uî¥áÒ¾3Ë+0Eáá`àá6v=¿RAø¢{&¼p¿!ò,pŽš:b`j9P0p®ðáÑì±YQa0“‡º£c‘äiDЧÆ&$ठwÿF û ÂCp©{C0ZÜÅ®°Ë[,ªùÚS’ Ñ4cò¤taÇ ÓÁ•Áz|§›AÀ­à¶p' $««1P›Ò· Qe•ÄIJð…ã’²>!d6eã6PsÈ cd{¥^S‹JÄöðNÓúË ÷@Ë­ÀËÿÀ˽œÍœÍCpÑaüQœª™¦ȼ)ç2“¨@’sÇÒŒÒ# qÑ  ¬Í?ÐÍÝ|±ÍÛ]“‘97½QSÒ"ö–éÌ"A|PB%>"¸Íc†ÛÓqnT7óч9ṎžÌ¿=™ãYÿ“U”½ÑìŠÀÿ ÅhÖ ðÇÿ ©ðlѼ%p™¥Ü¤š‚}žò{±^šÒ…ÝÇ lÍìÒ­°ŒýV';mõ©(‹Ø‹Ù-òél—?±…6„<ÏÁ€È#˜*5­„Šu͘¨V}ÕŠŠž"P@)g¦F ã(óúü{p%ðº0ØŒÑqMÜ € ð `ܸÌŽ¢×[ ,w!9{—!€dØ)þÑÜRF2l ‘^ш|z»½%KÃÕ–ÎyÉ48 €Á&ƒËÔèB¸oHÿa7±ý¨vóìû­ÐÕ‚„ÿTœ‘¿Íz=ÅcíÇÄ­pÍÊÜu=®p×a½)ëÈ1¿Õ1ºÛ!ް1€AØ~÷°ÙÝ}D ˆ Ø€ ãC0Æ[˜ç¦ )§#€ Õ©yÚ…e0ÉŸ—54ßXfSm¸Çh¸ý¬ŒÚ<ßʨ;Š£ŠÚß³½USb­[Qœ© wM´ØáDשjŽÍÉ-õ  Æx¯[»µÐW‡N°)þ~މ¤©âT†À1.¡C°¡ý#'œN–V¯ÃÀCäD®—^m›î,ò›MCåGNtîl/Z-ùzÑ“a·˜ùÿžÐi¹éº´ª—Ö ³àC´eîkjׯýÊ-HõçCÀ˜šiäÈIi  èŠÇÝ—û0è‡eõúP)ÒN:¯ ¡o ; q”Žß¾º†"8]í5ä…µÀ2äšíÙÏé^¢žñ@êαêÖÛ<§¼£„£1¤ñ;Û6ó|.1ú ŽàøÝx×NÊ¥­ìlž ¶CámþÉÑa|יʥ ÂO:Ò˜xj>HÍÙ®qŒ@eeXަÖÅ»V#T,¨±]Wr´ßn(´;b]á“æd"—^²)RmD*"ŒÂèÞë¼mÖ Ð²×Ðáÿ­11FŠ:_öi¿*`U¦ÃT›€hŸ×Dë(_ñ®ëÖiΡ AáÆ½ÜÈܾìzMµ)fç‚1¬æƒOpâ.?¼3(¸®®"Qã8ߪx¬#`é†2bú™¯kÄbÃÀbm‘ ,*Rm…u"zIú§oX©ReÖ'Õ"‘ä2å^¹ùpðµ¨ñ€½ûhšJ%l´œðZgÜÛóJ/ðZ×Ìïñ_È-¹Œ©\*c{A„bkøÛÏr©#@IE~4ŽÖ9˜—î < ùZ)±{ÄG ´ÀÓùžó HÌJ+°RfAOà@èiÐpÿ¢…†6öþý+ð/_¼úüÕ÷ïñ¿ÿèY¦g/3AÎéÍ;‘°…ÂKZÈk²Ð`Cˆ.@¾™ïµG p‚p´Û«þíóýP¦‘^øù¿ G¨…ž6i½z®xì|!Ãó«ÝÃZu$]üxòåOºµz¯É‰ÿy!òIø Ñ¿íþûQŸgà‡…sü0Àg‚Èøy({>p¨2zì³Ïþ™‡ÂNÀ°´Lc« yØZ˜þÑ@…ìq·|R\QE Ч€ŽNÔ c6LIžrø'8Û§¸‚XîJàŽ¨¡Š+zÆJà) "»‡0H«¬Ìã²K/¿ãЧ&–8ž*û‡‚Z`üÚ‹¾þ™€°#˸}`‚I¸Ä àG‚|"˧ÐÉì á2çÑ`F1¼P¡8|è´“ämDƒ6Ó̉N?uB¶Ú"­R2Sj…‡^ÚsŸß„ƒIHŒT®„ @Xr¨ÿTp}(|eòŸz|}Èx˜ò…#ä9âžç¬ *½/§¥–¬'¾úî¡ ¡®Vð[ྻ¡‚:ýë‘'W_uuŸ æ)´}"K0(Í4£°ÑyZ¸°ß”&-í„õÚºq‰Bè …BŰnËí¡&RƒôŸŒðóŒüMÈ:Ò¨[—ëɱLþÇW’«R»;¹Ë Zh«¥¹Úkÿုԃ ÒÇZù6‚"ê†r+`$†f c>ƒtµ%äúA%zìL{e„ž,{´H’”4²'%³´õZ°!òÔ žDý'·)n¡Â{Šcu#Φ èTN¨ÿ`Å*ÊWb˪‡Ž ¢e1ÀÊ»™q¦fÍ©µ Û%ÖŠ‚Z‰ 7yª¿ÂjŒý\ƒÉh«ë)sèŸm+$qž ÿáwDá‚ .”È\OD¶ Â졈Zó¬F¸äa/¥;} ²ã=Õ¥É#'!X^Å „Å…Ë€ °ã) ®„Kf4Ï|sóšÀ6,öB`Ñ"é‚þÄ@Uai²g±ßÜ£B@GjW¨|d­kú‡ |Ç; i@d‚ ñ@T<‘ˆDq“Û?¢‘ºILû: J n]5ÜÞLje(åû!OÌÇ“'9‰X0ÖÇ^ÿð Á9”ÃÒº’•-UËM€ýÊ£31­'.¿YQ€ö­ùæÞ ÎŽ f±¨å`r‘—¼æE¨Hp2»O2Ä“â€zÿB j>Ç~(Ep˜l¢` =,‡ª¤¸¾ñäu ¤Éˆ„]=dWA ±Ìw¸¤Q,ÊR–s˜…%ÊY…ù£J´ø¥™Ù H “€–¦ ðî!?ºØ ÕØyħ" <’5Ê\&w ÑÙ‚Â@eòàe.#Aç­¨‘ý’G8ÿ!9 ä‰<úÆZ%œ=6™ÈäYʰ< e¨Žú Éq¾€KÔQ³(·•ÿ0q® ÷XÃ,ÇãB>'ÿÀe¯Z¬oýÂ9Á$ƒ²'¿Ùð7`Äô!¯«Uäju|Ì‚rW!ßYsRüúŽüx~²ÚlØCV'ŒGát X@¹ÿdG[ 9Ê·¢Œdd±§°ठ¬ÌA8ÀÚ8GŠÎÒRµŠw…Jç+[‚8“••ýc 8Jé,zÑþTÑb¬Š•0B€7J„'©>ø±L•"Ê3¾‘M1¤£LOR>Ý=< ºfEô ™"ù).‹¨ ü%9fNu G(><ËâTë+W< ‰°UVoÒe(@©œ—¤5©&<ÿAsY\è¥øÅ~ *(BXD'qrl|ÝŽjè˜÷ó!ôÒG>SAÛˆB—!db…·/†Fa(¢› ,넃܈zªªï„Îÿðì!:5“NÞªW'ûoYx`,õíäÌ‘Ü?ÊíÜ–'¾•ŽªÂ•¯¨g%²L‹æg½š%*ä –¸Ä Ñ)Sõ¯[“s@ïs¿LÌCB@ׇ\í@„’ m¶†¦ª «:+3@X^°Ï!x;Wqß^a³¤‡¯ÌYzfÆfžÀ ¡ÿâá€ò§>K¸,˜ê ðPùóàÄ¿šè.‡pH±‰ÌS¤5Vd€*ú¨£¼ŽÉó#‚´Iiî„dÁÿ8@˜ÝúVL´ÞE™íê·H§œà«H™[»°Ì‘^Ë4TªÑÄÎøŽa…‚‘ D W‹€…¹9ð€§#ÎÞé!òýxPi¨¥Ó‡X†’tPŒ2“=Ž9aÿ6¼üÇUi*¸Ç²8Žm¯¼Î[yeW„–¡W[— ÷Cô¼ôœáLÏa¹6Ñe œ¼À{VyT¢ô։ޮCà’ô-œ_¼œ¿yW|¸+Xë"âÆõJP¡TÍ DVá¸T‘ã!‚½OÜyì5!=FÄqÊ×'޾5¯aGòH'ØžctÐRlÖºµò óÇfNDëTI¾9¿GV¬ísl]Û8#º,Q2±“|[f:ƒ}wªœ§“e+)yAxÐ?dIÅݘ7ô[yÒõzƒ}*xNQû½ÿ¸D:Êî_$h㪽Ç~õHêÈÕqPór?&.^XÄȸ5!ÿŠpA¨ZÝò{–"%,ŠS¹Š½lOcÁ[}˜—7{ʧɹ¬Ð³-Ùm[ºs ŠƒR½{h\‰ÎÁq3:5K7s Üb¢‡€€þ‚lœÍsø“¾D3Ÿ!@Žøƒ1žxçàß0‚{ø@Éà´¼ã z¹.ë‹Ü)ìã4ñ¿‰ã…x5}Ȉ橑›’«`s"&ê¬$Q_»«ûj’±"z ÅA™ªª‡xÃ<"’·‡hŠ«êÀ÷ º cÀÉ™Ûs l¨˜®hÀYb¨q# ´=.≨H´(1–‹¹L®©ŸV¨‡©2䣜 Äÿ´.¶».À:¦ƒó+±ˆ zñð}#ËÁÈ ‡6hB ²(ÆÈ G³«Ž‘.6R<É£'R:‹äzˆb3¥”· C$H•Ù xŸtéÒ‹¤;Õã8~@k .êCÔ‹:¨Ó Vú—[1Ÿ|Ú¼c©czK… 'Ú‰AĹçC©íª¾ÚÄKüÄ{ z)©9ú˜ ð²³á-Áé¸+QÈ+¬¡JzûÒ2\ä2³ ¼ai+aÉHšCŸzRŠblŽÈ€+½7{º “˜ªX½n¬”°CoãC +( „ö{ˆкáSŠzxœÿ‹ŠÖ Á_ ¨¸ +ް¯ßß8‚xŒìо´Ç»DnÚÇ‚3¸yù‡xÈ.Ü/Ò=‹QÈwšB&J§vQ>§¡²8³y"JyB û+aìÅzBŸ¨òÂaq’tßÀ­<=1QžˆF¶I³ÐÃÄ슕ؒ“Ä™däFãè¡4©7‘ñê³c±©J®Š¢'ùS:΀¦,ªäŸ÷Bþ¸.·›2šS”ÔAª42Šˆ€ BË($ ªä[K}ã˜ù¸|¹$ `¸6º,%”1"{"–$¢.“*Œ ‚ÔDŒ‘¹Ñ%€¦¼E¦,‹Å1×2€@T|*"¨¶0,_|TWp(ÿ‹®t :Öžà\ˆƒ˜5R=n»6¤;:ôxgqR÷Ší$¢·€bqT“( HD@æ ¿ šª DpêÃļÍÞ ‹ßt‚TË Õ¦ƒ(ð‚±ùÓ°h¢¹ÌUAÝ*ŸüD1ý|DMTEýKCrÜËb¹Î^yD¾1—XÆà@‰ÄR†kƒˆµX«#@±D«@‰ü‰F­Ê€¬èQK³‰  ÑäÀÏüÔK4™‰B‚àû‚"¦œL¥Ûè! å´¿¬|´DìÊ;ªìćÈeÝörˆ±nâaî«» â« ˆ¦›°çšÄôªŽ›D@½/¶Q(¥ƒUêÀbýàXÞKt}TÅ9×6LÉ›¼é1°‘¹ Â|pc MEÌZ=€ ž³Š§Ì¾¹È¥Ô K$d`!Ÿ^qÛ‡ ¸-½V‹)§ås“‹ßì4L>¦2ÒD5íä ßT3‹»sˆç¢èªæLer4~ƒŸÿBT˜ ys€pÝ‚;Y½­;|©;¹ñaž¨ ï{Œ’DJ¾ád_¶”Ü@C±@ž@`x``kÝ•ƒè,æåB­Ñé`Ñb»)izpc~ˆeÓ‘®‡p7F‚,¤Ëp|<<Í Á*a"ª@Æß ä( 0”c^bù QäXt®ùB>‰Ü¬h Ùyˆv¶J«ŒÐ3åÁè+)ONµªžŒ°P8á Þ‘?°va±FŒäƒÇrr&Ik±ð…‡Hnð…ÞED³h¨}ï™i„>Úªb×_ébôÙkª ïvÝp‚¦,’ÿî}Ø)H8~Vn)Ó¸ñ44ìàd_düK["§p«¢ šžu[ TËNÍ£þ‘u6‚bêD¦†j «yðND)•b&ð½»°5‡€fÁ5ž°ì›}R+pW†kžèݰHë8nçþ‡ã.à8€Èñ0£=×Åé=Üæ‰îÄ\È®\Öa5²¼ ÁV! —hƒÍìE°:««l›ÎìÐ:Ò ¢ÅÙLˆ:@ÅÎ2çÅØ«£¢©¤š}ŒP¨~jKLÙVÙÊP8©TÝ‹X$ñð—ù8=‡Ÿ$~¢ÿ¨V'žE÷…ãnî†ä†qDœ9÷ðÔÿdÊQø=`”*±]Ñ5ÚDJño§ ’Î®óŽ €$õìSæSŸ#¿sìøîŽsZæ DÆ×¡Š(½òy¢âå…QWH<ž=ê xx¥ îkj²À.7G‹Cá®a—1'¸íðý€ ·ŠÎj.G~4Uöðùõtt‡nš;°Dß2 #¨×e²àÎAd¦rã¿íˆx7²ñ{µcŠ÷ŠˆŒ‰ûÄÇ–Oý¦ï8–ëðdÉm^UÀL9ãM¸ÍÙ«Väëí?e‡抾¨Fs²8Ö°¸íÛ~óOÖxÃb¿øº ä Ü´+(3íáYž}G_ê–HkI—t¾LøEÿU-î í{à©S¯ˆ\‹W«÷Šr$tDÐwDȇy:Œ °ã‰X_"çx€4^€—RµýB‚! P-4»ÓŽÁâXJ‘4·ê*öØÌxcÅÊ8ÉèáqÝnÖ¹¡ûþp– àÖ¹t´±æî訠¨ÇïIk`8ñ³ ù8÷Qè]rlÔŽ CÖâ` i §’Èä ¿+E# ѯR¤¯€œž7}Ú‰õx€&4|ŠeÑIǤT¾°–^¾)íᜠ¹HS¶šÚ)dbó˱ÙÙN>„ËíÄÞv[ùû?-ív¦GƆ>ÆæHw¨ ³…~Zž˜hšÓ_?vX½nÊûcSäÿÒt}`íë*ÙaEz¤·8€!ðß¿ÿVAHP„>ydx…Vþ ADÿ0< øÏÁ‹ ®ê IðO%Á @´tõÀÁGDŠ{öþÅ8Q€ßˆ  J´¨Ñ£H“*]Ê´)S|© BýWë߆­*¬ ³cÎ?Ôˆ³fF~üñë(³å† Nhчú*àT¡Á'I^:L¸°áȕ⵸±ÀQT.œŒ E™:üZ§M_GÜ:B/#¡óæšD”Q#z¶LL»¶íÛ¸/&ÈrU ƒGHÁE9íÅPC'½Tpþ§ õö D«}'‹,Jÿœwzù¦ñsd`!À7TÎM¿¾}ƒÍOü+q‚ÿ?ý9A•õ6Àý£BÝPÜ@ÚåôÜ'h€_öHg¡tÕ T€uÿh7P~,,!Ï=8Ï@!œö]†PÐJA Ä%ÐÝxߎ<¦ 'ÉB ߉GFÔ›CÍ7 oøTõd¥„ÄqS ùi€I"ziˆ!äÿ˜Ï?PXxÏ÷° ÏœI=§Á¸‚IðsÃl€1yà?‚ýß@Oö¨(B x'ƒ‘ü¥c¿íVKcK2¦dQ”F’=°‘–zøO<_f‡k ÿd‚ ¡I—~KÔYÐwͳâ?+vÔÊ ès%€É>…2yc¸,ZT ÿýÓ´LéˆPCþGä “*yà »9ôä€ãZ%QA'ÝÔ“=ñÀ*uó4ƒ;©b©Ñ ëšñ–©“AúÉC0°1@°â1î‰ À‡ã?TfA‚ØÒÆ€-×flØ ·d)cUí¥‰bŒ¨“ôQIeÞ;œ݃bs®¢¾*ô …¾ÿóŸ…) t‚ÁAþ÷ë?| ÁI+!$¡'fËÒUûø_·ˆŠë›A›zºrD „Ä?ØuVw¡ˆbA xÂiÉY'ô@w”+·òÿ´ŠMO€ÈJ/ ñ>SìlÖ…ÍÂø`Ý”°Ó¤ÍAI•‚ÇXºU&£D†H6 ó0?*x±pÄÛ‘þÏŒè EÞ|õ\Ñà$ëû•0X:$ÄÅ72{Ô 7Ÿ'Ô lAUmîé(¿uŠPËÿrÁ~ßÍc?œ°º@âý4½<üÓ¾û¤ûÝhЦAÑýƒoAX7'/hAjôqÁà‡ ÔQ¢å¼"&óи~% Èh®\Ì{ V"à ‹@X «Ý? ¶•ä4ò8Þ÷iÆEÿÈ›üxzÄ 96lŽ…"8!ä,°ËŸÿ€s<ÄeÐ ¸ÀUæÀ&6EÓóZ‚v±‘쀒)ˆ!|å“ð£5G›“jÀÂ^av9B÷þÑ"}iÀK0ÆE¦¿ ýª†š‡°æCÈcPg¨‚1A \¢™”GýÇS—Ð’ª¥Î¤J³+=øÁœnßaÁlÄ2¦ðq Ž„.Øyãôc!Þ $‚DÓc ï¥Gƒ èŒ#œGð'‹•a¡ƒüsÂ&`zh Ž1F…n)ÿòõJóè?l8o’P,OI ‡¸¤dp™ÍŒè?vƒU´s$3§0Š©kþ#Ð#vGû€'àÇnðטa%+ò‚<'B{”…$Eýéqϱ,kBÔŠ^‚£†"¢Q¤D§úTôªšÃ¨FÅö)g…ôæ±Ç+yQí)<‘ûbºÎ¶ÊÿÂ$ –ѯrøÚiùöhÏrd ù=V o46"ò(!$ñPREÐ?"KU'_zdDeÂ6 +RóY â q„¾ÅÀ=3k' À«Á µ#µ$Hî4ÿj€ QË?ôa}èˆX€n£6"R²BIâ?¾WYfþ O•3ö:¶rñÆ’?@ûVw‚êÀ Lje¡Rà*!è%uú»ŽüT@ ÑC:lLŽ@βP".¤ëJ5ö¿ðQ"T™-/4—™*`nÏåÑjvM È@Fg´ÝÍPj©c>ñ…1D>æ²G %'C_"ˆˆfW¶èã"Ê?âÂ}¤ø£Zç„0ŸQ¶ ѪÌ|0d-zEHÇU‚¤‚ 7(ApFp'C«¢œÞçÖµ¦ÓÃïkí0”bd:ÉGZP"¼8ÿbH>·Ãn><.¤cW”háÂD.ª†h*GÁ›6à£@FæBÚV–`pZÎwc°e‚´ÄA%@- ”@3&&‹ª±#”|Ìù'+IT¬™št$¸!]fe~Œ ZQ7|Mr™ù„-S[ý2–ø DäÀ@ðÝþÊ1Ø´ÍÚÇ ƒÚÃîk%‹ê©O4³Z(ÈGOüRåEȈ=Ôíê›pdΈižŸ%B4‘JqœmdL:tC(&´=ØPø•& >“®iENUFÒF´ ò(P‚öáz‰à,ãX5Ýs…ÿÿè6ˆ¹]s k=ÍþÚK—¯hiÅü艚"‚ô¼ ðA\Fàê¯|%γûG)–À _—@Êì\CJ” Ä…á‡éÆ,n ‚ŒÀÈáB9n ‰ƒTÈÕÃQ>¡|¢3’pçA‘¤½4¡G¢Ð¥è’5ø @^. má+Šã½T ¯¨ Óª\ù* Â{ˆ/½¬¶¹H¯œ¯x #à…IDp&’ܤ Aµ·W”k ZL,cBƒóÝUM’ Ä(¢øÇ<Ðsö¬`È Š0ÌÃÕüXA0ðÁ0Á„¾2ZZÈÄÿöD‹8¬ûüøHv?* ¥(@Á?P ÔÓîw:Mõ²˜%‡ö!ÑÍV?@ÀNÁäHºD[«âxp‚NAjpÓB'0oú_ÚñyeX€•3Á ˆPZ}9gn7ÑuúfLŠd]q(J伦<a#qAp@ánïö{B±&d+ ‡{ÿÀé§fÚ' p{"ãt KXc˜I(g!Ñü0>-¶öbCœáWU9È„M¼1Ó%­ÐΆc7mGJHT@•?8±&Ìñ€ÞÆr5#1àjNðN 9÷EñXZ"_ñ¸[ZbOúÿ‚NÀ^r–nÿàjq6‚@Çg@UœÈ‰žp{mæ7tAqŠK(Jàuð6_hAz Ðs0Q‰ˆPŠOx|¤÷E¼EPŠˆÐs²¦ã·tǧ7±ó¶sœ[2PË!X öA%.›‚ !?†Îæl!%jä>$[Ïawº/ñð3'°{£J«$õ"‚¨¢ñ ó!œ¡¸bˆw[{DcbUúPc³&{ DÎÒc~ÖcÓ,q|)1cm¦„í€tðć‹$áÙ"p•˜êC§³[üЋ½Øu=‡#ðb#PH¨>Èè_¡nšÿñ"Î!†7Ä3¬C²$a“†!µ?p&wÿƒd^FÇxY–¢CÞB’ñPAè!;'¨"X'ÐÐñMpút[·!53®§çcñA5â 6âu^'}µ(+`B„À!z°'ǧT p|h‘’Ä _$ojc±ø–$Ñu@Dz(k>!k@ñ—œ g€…x'˱KãÈ9¡/xRCYÇ¥†Ã1#φ6,0S('ÀRO9ñ-Öœì±"ˆp9_À`j&";—ÈW¡·&_IöT–¹r7"4Dó·¶f:Â,³{ÇÿÄ9Nç,.1ž0&48.ÉŠ&4CØ’#€~Àz@ ÿ  À 7ààsñàäEe2oêIJÀ úÉ„¤G@=·'ÐIÈg!!0qC»¤/¥©¸UP9qH‚<…cu1  ŒWSæ>÷ FâW!’+kò°qÈçÈÉerÆ„ÿ zWfOÕÒ¢-°7rÒ8'Á™s8ÆD—þöcÌ#‚±xY…Ü5©žóÉžÿ@:`û0_=‡&hq& €ta„@LJ >çs !Ù¦] 3½Y‰‚ºzeQÌÑ3øÇ"š…2ÿB1øQ7­ P6Іï7$¤"µ¡š73?¡>"ñEØqbZ¥é¦%’˜xÿ°7i©O(Ò¹âO5o˜X¥fL–”Aá©\ñOXƒA±+Š18¢Ñfó)§D` §# j¦‘'ù^¼™q:.Y|ŽI|j+1Eøû"wQsdÁ¡Zö@OôTl‰ò¨'ú9 ±¢"õj„€îó³~…/4§ñ2Ÿw:#ñ•wW?úS>õ’úa–53B~d–¹’Žªj©èò‘g•ÑoM‰ó153¬ˆ„lf°˜æ’[šD1h7we9ÿ|Ôñ^Ù“Xc~À {"‹h2~M8š)³™‘%\q*üR&¼©b!ö°Lk8ñHÅó Bî„€(2'‘ÒOËÁ^öR‚föV¨öÆ€²OcÛC£Sÿ¡Žn;K ·±:rkGlšpf(󸆤H‘UL¥¯m&}3Æ'ÁË:kåêjÿ°-BÁò–"XO¦s:Ò^9áƒ&| T¤‡‘i°Ñ‹rXÏ*¨†X*}­û"‚¥rk‘~IG¯’Y‘µ!U\Ë÷ wm)F£5$Óz¡®•ø%`ø^ÛŒ9«šFc!}+&b"‹·#ÿT0êh4{³"×Mug#û‚Gƒ²:fu*1Añž»—Ñ'Á›Ï;˜Kš«% T€O``k0Qã“þ+˜º˜üÐs’5áº'±j6»Ñ'º˜«ÂúûEñPY4y)¼%à:ÿ rgx)2¾c»"•á)v»8÷2¶²!*6oKÀÒ–L:¾òÐorÄÿÐJÚÄÕ²ÄË0fB`@û&ƒÌ“ARåÈŠ¬&´fÒ‘‘‚ªbqDà¿9wÒ‘00(ÀÀHo"èœ@q:7Áóizº+óȱò"!üPlC eÝÿS6Vq Jîc¼~Ô;­Ã±ŽTQø¢/µS/ðuwshG¸j7¡nñé¨ÄÜ«¤' @ÔIuÔ·¤0D\ãÿõXÒ‚ÈÚf#‘P$‚9ytD¹Y¸WGÑI‘9×jº©Tü•±Îy¤:_ 3.˜[)k§Q)$S6m#T"êHHá+ƒ¥CPš^vä“ÏAÊ‚*¨XB!àBU°•z¤¤5” q7`Ë@FÂñ½œpìÑdL*/dn!¤Kà·±,‚²vœ£ìsÆ(’›·êÃ*=„>ÁC¨U債1r!ÿ…ÐZ\6e†·@.øBK´D#7'oÃÓ³ÄS½R>Ž8w !8På#··õQPo¾å[ ›ªØakÖ_WzLˆ´k‰Œ1Ä*Æ[QœCz Áb/¢`FÑ e‰ìNÎY‚×ú ¡f¸¿¸Í/M€í`'ÚfmVR›±¦!¶#âO;‘¼­c"}d0}$'¢·ýDsX!I\‚uwñ¥n/&¦mÚ]yAµ›5ñ4P(š({&£UOâÔ²0ñbÇq³r9)ôd@UCX‡ÝÐ3|Áѹq[àމs¶§}Â×}RÌ”ëå)Y#eÿá?^ËÂîDe%¢Î³”C¼"c;B°£V-T³7òÐ}ÓG®âsÀ¨×B4Ð]Úœ)“2)" x‚„Œ,¥‰‡$Ö‹óÛ‘fÚÍg 7;y‚\»GónáOÌÐÃX8Q_¹¼ "2ØJ1(ÁË,•ίcÎî„Î))ëS¼Pa´5>ÉKÔÛ½òÓŒ‘ùI‹Ü™D+ “QN²ÖÙõ/–Xƒ"U£ˆ  án+àE°¢w º°tÿ—– )C(2nBeúÒ€%XSû"6ĵÏáæBÁ y° LǸ1 unçµDõ–mû£<>, „B±QVAu&ÜM.¥Fçj>£üÓŒîd7~>j©ØvK&ƵA²7&²:D"°¶‹±G<ßOŒï®fMÚêþ—pª^¡¬Asµ,¸À- ä$æ2¬3fBTºg–“…wï…É=Û<(2¾Ù{y(XÜ9š:ÇÍáÁ0#””FYA@Îó>û û€Î>=ÍAs.r”4ïý6DÝGmãÞ}¤¤(õ!Õ»úJGõp ȃ,—Põå"`cô€6rÅÿPèRÉØ¢gHWO¾²GÎA¶òU“6³·1„÷P ÄoÐ_”“¦§*¦’Ai]ÅAÓ&TFïÍB‹þÞ”ÿ|wÇ?+â?-£4Óé•îîñ¼úáùc1iO^g@ p(W/—€ÿqõÿ>þý[ˆ½úü‚߆BF ¤HQâ@|7@¼1?}üþñ«ïCE”ÿN¬T1O剿Á”‘ÒæMœ9sêxïß’Æ–œÐ@ÏÞ@z3ÿµ¨˜Ÿ½öŽæûg/ŸÔ£R«Å7‘â†(ü[8!†¼#>+1òÀ•Í‹AÑÑ»1 <Áb‰¼¿ïÉS«öŸZy€åÅ8^ˆT©VÔ—Ò% —„h¶PQsÅ…EØ{œoÅ¿ BþáS1#J¯(7’]pC_ÿ…ø!ªuàQ»¤]ò§"LÉ•/G ÔçÐ@5¨øG/&SèÖ«úÎúïC£7íz=°Õ? ˆþý¨0áDZR à;0††U÷þ›çRé@NX¬"ÃP" ( T꯺­&¨2‘DCä´0û̦Î(¢D ú2~N£hƒŒT£—ŠÂ¥¼ jë¨ÜNú ~Núç®ö²g/—–?Š–ðq(æŠ4R°ž~Š..z¨[é'ÀÌÊ®« ¥ýR*ϲn¨`XP€Ø'‡à¿ªì¢'?—úú'@y–<°#ÐBɧ;UjÁ±¬¢ª²Ô£þIÿ”,Ì2¥ Q»d U(2‰Pˆ] #ŠÈët o0¤‚ >°Ñ;ï¢bĺyH««8”DîÀûË‘#s-ò¹Ÿ(*n©¸DêF©Œ‚ ªaß|³®ü8ýa ±n `‚Kk öÁV¾Š\2ê®Ws±qºçÚ$;w Àb=áÏBø€ªE@T=V±C2chÒ›¾$³ }(h |n dS†5½)£ "· (ên UW¡?ë¢û‹ÈŸüºgä{¸Õõd›ϰŒ!ʸ”–°N…™•ÝѨê4nêæ!o”‰ÀúGè aA­#è#³ÌÔ\óMš«ŽV¿bUÿ,I5 #ì0”`N^§ôAÄÐF8­²|X@ ˆþÉp I5‹Ô_Š|HÔ$~Bc¨¢‰Fq8¥ ¤­ÕxŒ¢7e‚I˜f],Á­)2eÊ™ Œ«q d²%š_Å %Ve2.¶¸„–¿´Ò"€ÌŠ&÷µ®‡óK]¸Z§(r¸{¼N ·›$DWHTD +Z8ÃI7‚!,ˆ~àG¼¢V  !DR[­5Ø*Bqoìo@·!³n/F6þuÖ•:ŒVeWn m“{‚'Šø§\qme?Qø£Ï©E ,NRªã˜x‘&)Š;] ø‰<«"#øÀ-4÷ÿØH±ŠÉÔät´.Á'NÈü€âµƒ@fxb£È 0þ£k[Ü2Ó™è¹íqÈÛ†¸ë-ÌêI ¡„н¥ÈSœH~`> Ä(³ÏW2+!¨'‹O|‚9`ŽÿX£Éä#0v˜›#Öh˜6–l ˜cÙP`†$%1ˆ/DÝŽœ„žà5å¡X 1£a Ü*S™ì²Æ… &±ZBZ<9Ή1Þ"\>h¨¨m ÙËÛz¸èÉ"“ž…ž7·MŠž=Þ%а†"®eSR1b9šøC—'É/´êœ`œ#93ÿ¾n idc7ÝÂ5¢D±£ÉÆ926–‡Q‹6WÏ ŒF¡§v‚טaJ+,…*Z¬Î¥M# i @I(ÿQ9íîhcd—°ù'Ê+2¢D ´}UŠ,ÿP¤¤WAOˆ>Ø?z¬Ü`#Pl›NZ4ªÕ.\_ V»Ü˜‘im@Üzc9Õ¨ÎpŠÓŽi#8‡JNrÞƒ%»ãQ•š¤2&f`l‚J¨Ó¬7ÇW4¸4‚í0j"@¶ÈÂ^¡Ä%V£\'IIîN%±"eTæõSä4% …VàƒW¨mC¢ÈýõÃ\þð¯4é} üIÿ” QV†*phû†³Iµðv©Õb #¬3vó§PZ:+Nuº–œô™œRÍÈ5:Æd÷P!{5I®ÕG®@r  ï© ® DT^Û?bà4mÒG0ëRëKÂÔÉÁœk0½ŠÕ4û² !¬Pø*ž¡N³½mTk‹À?Ú;ÄÌPϤª)ic5´XÔ!ò˜""0›‡¡¨˜›…Ñ*®¨"ˆŒ¨ÝZæR梾ΧßLIP͸Ôor‹©·5#:!¬Û$‘ Iz¤fUm"“ºìE;2™É¯&‚ÙÁ î>ñ ·´•¦9.iÖîò´®²k“CvI…0}ˆíxÿËiÈ&"ŽV$°ƒe›™gDJ,–zþÊò¨ÒD¤—oÆÌìFÓ£ '1‰¥? “]¤Ö·é”®[êœÛØ’“ŽK5Ì„SbÛªôÛÓÇÄ«Í%%tIQ Q”2Š\=dcšŽ€&ؽe„¡õuC¿ˆ‰š4Ðc¸“äC•i®¢š\(‚¤d!§Yïz%–ô°º.),Ù–þ„5š*OFŠ¹Ê°þcGÙØ&CZ˜ (jòÉ DÎçq6²“=jyQÞyáÊj¥ˆ„® w¦Œ·gõÙí]€Ž>’ëû€8Йܥ9ˆ‰ZhSþ‡xphEYbÙTd mPöM‰4=L‹.û­""¢ß"€ÓÝÔŽ'YœNФ¨ÂЊ@`ªØ‘x“‰€•I‹ÎŸ4ªy&„°Ý ¯BÉK%g#ƒIna†áƒhÇx æJÊP”Êø…ÊȘøDþÝ*’xÿìêŸèÜá´ðÅ!6h§‰E'‰Xa˜m8‹®ßöU…^°å(«²÷üO€ð„K°_(€“­¦ø_dfœúø"Rê±,âôù³8“x€ (ß‘*Ì–ºq ¿L²jXs:ÑÞ"cn0í7F‡aÕVm#ÛÊœˆ‚“¥j` ¨ø€ÉúžE´‰¿¡ èê”Rá®Ä»:d0_~pñð€Bæubˆ^_V^ÐD™eâîìbŒ~_¨¯¬D"âe^ðåRäÅĸB à+ÍΔˆÁi¶fYN ™Æp6þ°š åžþC0”±0ðŠJpÿð5SÝ"7æ¥hp‚há¨N2Þß&ø“ƒÐUy°ï)’‡P.`˜[¡tƪ@îï¥qV†e°Rn‡æDhYŠ`P¸þÝŠhß)î˜Åè!oV\âTÉ%ïñNÓÜ<ˆy Ówùß7¬ À9¤‘»È’Å8+ÌVáz§PòœþH5õH;C1s@m÷a^Нó‰&ØÐ(¸ }ˆc†Ò7Ûö?™áˆ€oÞB‰NŠãïû:9 #߯…ñ·ô·fdWÐEÑtò¬ˆŠrèRo› ïîŽûåõ¥j2í1fJ6#ºP–”h½8ù°ÿ§mN®YŒ&m6F…@¬•‡F›=.}I}È Ò†^¥ÒÞ"5o{01ažv³å•ѨŽ—·-pæ5“s øöAWŽ‘[€/™rIú‘ /wNh†–ñ$_”·V—ÍàîôÃìôØnÅt¬’uŽª/Hx}°4Žx\ŠÅ8Å%QJ4vŒCú¶‘;ù؇ª›HÙ¡ÏRSE”ÏSÒà×Ö‡Aùx1²1êÃV{BÛi¿íǨöÈ€¾»¹EÈÖZªz¢gz8%Kúà‡¨Cš¶æHu Ô_wHepñðD°t”¨w¸fdýºÞúŠˆÿIx™%€÷Ålàxa(—ª`õŽ -Ú©©ÅÁ9¹Š ¶@À‚âOjšÚÃÿ€éìCj’—y1•Ä\áÃä?&h‚—?ŒøƒáäEªxÈD¬HÇn’s#‹!}ˆ+(QÚðï „ âÛ€ˆÑ’{ÿÜ;"qáAzÿ>ðË瑟¾|!õý‹§¤}ô‰8Ø’×?˜Eþ!¦B›iÒTåã  —þý$:ÔÓÏ¡Czºä£Hùìý£§á߉%OœÀÚBÞ?­—ÌÓp¢lÕƒ†*¬ðáÕƒ1X\Ü'Àˆ€cYh]ÂlÂyó&üËg‘DÿDÿPЇÈqJ ú$„È÷Áò[zôZÌkqBÞ Ïÿ¾þ»x° Öª!æú€±¾-þÉûZ{žæÜ,Wü´ ÷÷Á 7ɳ(‘ÀAÀ´^®¯#H~.ôÅûGÒ¤É.xñû§˜çÁ™5ój~<Æ">zýcÏþ§§N",?þ¿K5=ÚÓÜùàUX¦Õgbý3 ¸Å Ñ?k†#1ÌCX€åõE¥±À׆ýu #—!¢˜b+ŒˆÐˆ“aöÁ[ouv=ód$gžÉƒÚi`@Oö\F’cÿ¬°‘ló„€n<ò(’¼QòϾ‡Ñ#” Ï=ÈQd\i]bÔ>ÝñSÿu@º ‚ ‹Ådž^P‰ ^›áù4SP½ •~EÝ©TSO¡OQXuUWɳġ|¥µà<öPp 1’` …NtGÌÖ™<Ê-w_ mu`)äA˜G’u…IðÁjÿ„P$g1#g¡ÑvD÷hd®I†˜@}lUšÍ:+JD-@‰M‰´TƒieŠÜ?,øO$ÒƒaºOKçêc‚J¬"ÔRMp¾©fzÿ¨‚TëµW_Sõ)ET~òù€T¼LU•³aÕWVaÑfà?*ĨBnýÃÖ[ø[>±&TÑVÞ*aï*–˜wC0fÝ«IÐÿñ‘œÉˆk§Þƒå=˜ÖDm;Ú“O«ˆ ¹€š¬ò¸la')ô¤B(„pø0P G$„\–I$ãFݵ5.HÕµÏw¬ÂdÓ›iÓdÞLkct/M½¨RÄÜï™Bw4Ÿ}NùÐÁtö„#BK j Î ÅHÅj}0sÙC!BÇe ä .1V,pÍÈ» )ö(› EJxgœbÉpP[m¼švÛFùH¦æ¨&$¸¬À=ùÓÓ·@Ÿ%tD¦]Êãù¸…‰Ùj˜a"D]JÿxæA8Á[:½ot/œìåWÔÞ é]>Pž•>Nô·™X‡vzÐÍ-Ñ•f”«µÿ‘!’ÒC!W8g¤x hÿñP¡Nà­³ô!ª:™ª£ǨHV!€Àfl“%€u:3RÌÀÒ©pIJ#–wâÌË#’Ož%áý£!ÿ Þ•.’µ.@áG€´– !ù˜Î¹ò‹Ðµ†=™ {æƒ7.Å)P©I<Ö,a©r9ZEªT Rla èbm!,ôxËB@š2.’Q•a¢Ä¬À1„T&°šÔ,k8$0À…Ð3µZÍ"5"= Í%ÌG°ráB—Å”xV ƒ÷iý## ŽE®v)cQh ™Þ+R&±¥‰ÿM:‰×”àF·…À-)ä߈€",#³éŠVnÖ‰êÿXPB A˜HNc1`X×+7Æj3£¢ãç(AïPÒ;}ÔÇT«…¦f"TgfåÜìH3²"WKZ2º„  H@BU±€"%)MË Ä£ËD²t«-‡–éš+7ùé)Í]mÚr§ïµM|@Y 0ñóõÅÇs4¢úêË9’$9Câ{‹=áÌBi…ñir8“Ô…ì[ia %W@1uU«‚Õ:!p @€„-xÁWR'Á,.-yˈ#|â1Ü{a}|BÊß@m!7ÿ˜Gq¸µCD=ÓÝ)À[ž3ÄèEG%g:OàÔÄï}nà¹è½TÑK¾O/"]HP|À‹P%a–r˜ìÂ . ºØ4xŠÁ´PÙLˆÂ0"#1š(JÌþA_4FU§ŠÐà«eA`½Çg´jÏÅÍÊ…Yj C,­ 1MjIî¢ 'Y@”ÂÛ€Ôˆ³P-ýÃ",Ø‘óÞ"&’L”€Ñs"¶Ã¦]*Uƒý‰aí„€(÷YˆÓDy7ûâ© ˜ìÁR3?°ôT³ÓiìQ l„-úÖ *Õ¥CzI…Ñ×þ¡Óƒ@ð¹'3m!3½Ü®Hž‹û­ÿ`çÕânä$%bî‰r‚V½üΉÁ[€=,‚µÒ0“p¬tB²œ­Iøª›|«^âË^ƒNcÑW>Oô"(öÅbd¿ˆå8X)KŒâ¢¿HU !1¸ ÅèÊF0ÊJs™9HUì;WHúˆ ‰ôÑÇqŽË…!Øí‘ŽÄ##áfV „•H"…²<æºÍíÞN¦ûŠT7jTâ‡È0Eáåq 3ɇ©„HD¯å't;õ fß%7Ù°ª†Bôd>…¨oŠ )‚-Ö'~Àž C&XxS‰Uå}ö¦ƒáèÙ3³¶Â;Ép‹xd,Y.†ˆyà£Sh=º«0yÕm›1ÿˆ¤@d5¶;I†´ÇÆTò CúNK$Í›èí ÖÕK[rƒ OǽbsaðZ»>ï$Òs‰‘‹êÂÒiNO›º{âä{…Õ‘½x'­ü/¥Ü ?êy J­¢®ÈŽ,Ópgb1&$AUiXë¸uáä|+.8 #beª„°„‚æa Úó˜V ñ¡ë®QYÔb:+wD&â¤óù_äŽê¥/¥-€{Sk!¤Œ`¶EQ1è2Ù$EY®“!)œ&¼‘ïÃwédÜA|P‘øÝÕsE7½éãôéRÈÇ€]ç#F÷ÓlïaŠiš“£ÇÊè`ÉQEÐ@ãTÿÔ¤ö -ÐÜ'ðãôÏ;Î}ÔwL¯;–Ý:Bgu·êvÕ’ºm{2w¿K£àƒ[Kd%à!Äim…R¾ƒƒKeè a„,ÄýbÐ{¥‹E0!‰Ç©¬} d·«[áÃ4ò <ÐÜ„I$¹L<Â’¾lЇ e5B ûi¥™ÏdP@ B¼Êìùˆ=¨…¨@Ãh“Ì9Û·€š>Âñ\ê ÝBD'AÏ?\íXFl>|@.ÙXñÑɘUê-Æ ü‚°àXú¥‰Òñ1DpØ[ y#xÙ¿ FíО‰Ä™—,=†ö½I@}_ÛÀÂÍÿÄÂéÎb MtŽfpEÀ=8>ð“ÅÚÅSGh„¥˜Ö HÌ‚ô‚½Ñ†ƒ¹GDå9Ì?jµ‘hœÊNX ^HÏu« [«4d<”»é˜ÞС›°½¨ BÄ rò>Ô` O–p‹%Dn±ÜRS‹°ˆ^eߨĩo¨€‡K|ŸMÌÄI¤Ô ð ¯t ÏÜÈçÑ“ÔÀ”Ïž1M…ædÅ¡˜ÜûLÊ à\4£FXÞA°ŽBàB ÆM9ÕT¤tGéM‹Sõ¤éE¤ÄFlü ‰>¥ Jôï­ÊA`?­À„ñá ñ%ÿ)D•d¯X ׌^a8ÐÎVdLéÔ’ˆDzaÂÍÂ¥Ís)—u@ü‡ìä FÖb”PeèÙp!@VP ž>¼OjÐW `3*N`L[x y–CBСæ!ÄçIÀÊhÔFØž½ãbxä?`OJØÄ)Ä[„`·q˜,µKè!¤ý“» Ä @ËðaD ÖñAÍŠB-‡gq¢>DÎVÈ‘;Õ WàÆÏˆÄI  Û¹Mr•¢ëõNh j‡OÉ–ld.†@üÑ™ÜÝ¿\ hÆUôY„¥þL›ƒ‹xU, —tÞl(Ìb„O:Qš°^Ï岆¸hÿR.Æ.b%U»ýIh’¸ø“øÀA[Ÿu„ ÕÔà‚*T¦Üƒ·è–e‘s¸ˆrôÊEÞLÏÌÊZ¶¥‘™b>ÁãAÄÐh„g,j\gÝN&‹DwæC.&ÜðÉHŠ@¸¤Ù¯!ȆA¦õQS>UØEjÀÍáÍ| Ï( í5ÆíŒc7þ†y`P2âPNåhöÙ= xN`:ùœl-%µýÃhRß å Q‚è# Ñ#”\¢^˜«Æà×B’‰Žh`aG²ʼŠXGw£U8ÒðÌFâ¢UYŠTFah’>„ç›$…ÞøÀ Quj–ZþæÌÿžè­ÜpòƒƒÑC}ÞC†çÝÃW¤VGòÜËHÆÎQu*ÄÐ3K'fަ†Ä& =ÕJ Õ§ü¥IyÄyåƒûÌ覦V°뿎ÆhôkŠj-í]Ox”ÞpG¯mjø¬3-¦è•\@_FÄÅØ}"‡ëxžÙ*„h«H‰ :‰ÎTZG[ªÉYQBDÁj|ž_bDÙ(UE†ÿ@€hD¸ÈÒüÄ·Þ#BdåNŒkqÌ܃XF!Ĉ*gôˆŒJ²(K8A^áÓÚðžzm¾–,ŽìàzžU}¾æÔÑÍÜÜ‹ÛN¤ÆFŽ^¯"%+QeuP¿vÞ·ÌÃ¥ŠI âN¸£úb„åZn¨Ž†7Õ+S–N7iŽ7)„µ2AÇÖÝ VŸu!‚Ȇ¨Á ƒ¬–´uSZ×l€†g芧ŽQÈßM¬ T¸€ P_¾Îd5’íFæî§ž­ò:ó²Wªêd¡lFJGáQìÆjoÞŽ.ãÄ!¯üC^®D„pF ’´` *®±±B$«…ýÿCüVÚ†ëý«ÄžWåâ’òHü’DüƒÖmq×ð$âæà Á`0Èúš´ï¤F Î;…†#M°àˆ„I˜ÚIo8A$ ýl Íüe¨¶A ¦x´—*€BØ0ÁFA©Ã²jX²¡BÄEÄEãœÀEpPë$DmÈJ|zL ŽãùrB(Ï)ÄmüµÙñR›>…Ì,éÙZŠ­¾zVAÄ&ê¶Õ·BMµ$ŸÓ|€<`@WøÈQá´ œ€µÀw •#y^h숧Ö)>™‡Ÿž/vrÞlk~b® Ó!gaf{(V•ML\„/8Ü%Ìÿ3‘np™¹ÆØÔÝþ B¨U,–ÄœÌJ£œ«èP[úzÇ’©^àa¹­¸ôìhpF€ ˆ"Iji„ÎF7qiBDÀï¬%>VB‰( G¦iD²Q“,€àd¼âJÕŠSðÏÔ±}]ÂÜÔ„ àk¿âHáö*ëôÌl˜0дÀÀ:÷]/î ȹ²>ÄÇ<ûÍøü‰WE’ƒ…È%»ôyj( ¦D£MNôBX4¤¤/I0ôOŽËhjR´ª˜Âx å聆 oÄÎÊoFì(?Adñ{ëUjèHo>àX‡8ÔÒìCá ׬W¼“åg=¬H¸€æ<«B/8ÿ¬×f¿È<+d€ÎŒP4»O¾fáýBÝÉ]ÅÁD¬¸€T_B/¯ð/ˆO¨²…à3‹¸tL€ga—rç…\é æËB(ã*4ë¹D+&MÅðÊÈ'‹²TeW&`ø¥×þÃUdt>0À³PZl³ÿŽ´Vª®à‚C°Vˆ<ϸL†ˆ²ÓWâ]$XŒìÙòˆ|æÃ+.™|Ì ð~6M.A hïŽì=d@Îȃ<ábÚâë9Ï ÜØI}ìZÏš@}ð‚ük(5Nüà q;˜‚yÃ… „Ýê°4ºï:µ¯ãJ/*ïÄÌþ¨x[îB P`ÔHê<ð1ÿEFë]Ñ@l@ÌPê öð‘’lVùlq€ˆš#¹À'ƒ¨ÍýC€iK„hôLnÄß¾‰aùMo°=i….^§´Ži¿€G iéÀŠê VRÅdQ…µÁmë1ÀþCü‚=»>ÃaÄ…=sÄ”†uP^„ìÍ@[¬œkl%ô‹âøôŒ#™‘—ŸË ÓÆ’ÓžFÈ^ͰwRaƒ#uUäà ÜP)E )Ô{»·ÿƦAäXÌ=‡·ÉîjN·pF!iÉÖ¬–äø¥=x䛬sé41¡I¾–ÐZnàšv ¸>ØS ˜›ŸªªÑÄ|XQûdOÁHh´ÿAB´öH@ä5Øã$F¬¦Œ5P)Œ(Cp° ¨Ï¹¸Pk´F´.©ÂyÇPÓ-{·gŒÑÎzħ…ó/`óº×ýzê:'xÑäÇ€ '*UÈi\Ð<üEØÅàÔ˜WƱ¹ž…bÍÍ6_kw̦FøFަMè©%N´¹/JÖ Sz/䂼˻%^ ¸Á¡Á!ãÎ¥\ »Œlº¬aœ¶, Qüeî«ol¬´Híîçµ Ço²KIlÑ<¹Öy±m’Òl^ù ÜÀˆð\M[RâÖ;[$¡Â ×`dEÌÌHÛÏzD`®ÇzØÿ¶S(Ùdá«f¸GÌJìèP6×›p!Hò¢½ôM|Ô~\|/ØÉìC½¢åí÷¹E„h˜uE&‡õDx½cÀ®D¾OÍV :Ϲ_Jè±°ýVÜu¬ðÎ\ÀK¨zm\ø¬=èÑ<6>p¼Vþýð3°_ŒjXØ3QæT¡mÉdhäc UQg²D”óås!¢ˆ*ÿ.5ü÷¯—UEDäs⢓|Q ºÐ÷pÅ¿_EH’TuòßI /=døðR¼ò=ä•reÃK½¶iÂÉ….2ªà’ÑÃÿ4ÌÓ`ï_Œ%Dÿ @”ÃÕ W9`hñpÿ("}b~ü‡H„YDTÖ”KßЂ5ÿÙ Aッòòþ ‘ïo`À~ñRÅKïâûzçC´`A„ ’ñmpiß?Ë•ÿeÎüp"~ùø‰p9Õ^>}tÁÚ¥Go^ y-è}Ðwž¼{îÉ›Gïî¼¼wérøí!àäãHµã”sÉ!“ˆ—èjº+#0]xS„_nÚλð.1Ó;¢ZbÉô øç&ð‚­_\hã(¶>êŸ#»üç “ @ªÌ០þ 2¸ç…d ­²Ö:‹(ÕFüÈ=-ÿa­ºBx5Š¡¢°çº¿ŠñŸ&zM¯Ÿ*`,È “ìË4ë̲•íL3ù€ž‹‹yö{õ%1|5J»d,1"‡*rÖ¼€ áÏ !¹W`zI<ç(ŠN ×Nt"—0á)¢î¼Ã“½<]êÓÿùÈt š‡zi5Í&ˆ•‘ú*~h[—ì9a*¶ÈAL1ÍôŸÙÚ2UŸÈºªWã6Ö­Ë%w£`ìW}½‡ç{|}È×%ð²g¬#[ Yê‘-!6` ½h«)ŸN˜çƒÑb~y5"¡Šf'kÃkVzê{µ€wRåBzÅN3Wºw#¢p"Š»ÝËÅ9‹¨3¥; †©à;Ñ«‰—4yY¯`Dê¥&Š‘* ï¡Œdk©J:ðÒ‡rààÒKζ%üèT²N%j¨Qcfë„YÓ±¦Â*å  Òò½tž9àk¿ÔD¸á!K–YÏž…v§§mÿ¶¿^íÛøÑgû%—´° °Ê+j‡SìV‚Âxá¸2óNUDxs®‡r) _ìFJ)p¹g?:ØISÚŸÅñ„'L“…${L¬Q' Æ0†Hp@Ÿ£ ‚6% ˜‹.caÐÊLÅ2&ÁjvC+W­¢0«¯ˆt¼#] €GÏIpF7É?¶ , ˆKã ôA&ç]5ñõÔIJt v©™«b¯¥«fúx“ Ö6(æàIn— „D(2¿-:P"!IrÈdž˜}1bYð¦^t§‰ƒ‚Ä`7{Üçl.9A TÐþos`q‰>†p¼Ž*tÿ !¬:ÚHP8SLÐ?îAÃ&tÒ†-h ´+QviF¦qI4££Ê qY•qZÔZÐÕ,)6µ¹e…PõDMžLK¬ÌÎ6—0!„míË“›3‘Pšûƒÿæ5¸XI¤O¼øtbäš`q£É¨!œDýRQ!&"Åzh`)Tñ'GV—ð%U¾|[nsKnÙ&UXtIaúÒ¢Ùtrž¼¢J7™—ÔL46bÞ?~@”W:ëFüЋFnãD¿Œð,Ü{ÈZ(äчŒª\Q[$ç§„˜gpÌy CÆ(‘‰œ¤‹lSÈL›6»¹±m&NªëH•?-QJ ÿ1OÀE¦Q2¤¥*u„˜yî>ÿ@ëTI•’ÂEUDáȹeµØ”L60,Ý&³„ÈÆ¡Žùòxh#Š^FˆÏŠÈQ0è-˜GºÇ:–°,eÒ«¨¶H˜d5}SÛ¨òÅ<éäN6ÕéC6ëF7^³%òAcK 3±rÆ «u`] Âˆýl+žÿè'¯Â3Ý…ƒ°+_GÚKÊΟ'ó¤bT)ø•` úŸyÆê¡¦1+-`Ì<–àµL_o£œ7°Žaƒ¤¤´””½rì«Nh1¹„P±Šéû^Q¢$s^zº&à|ÿÐ O0Äy<”sјăQ› =2™Õ¥`PèÏn‰²|fðžŠ9Û¨ä 9Q²kb­ò#y<—tÑå€ïx†V qò”ÿ€Ñ@ÇÅÌ•‡¨¨ó†è¬Ìüp-ªyW°‚|d’[Ü‹iÐòÈ ¢Tl¬^vÌ“,¿/±fÛ0ûJpÖ9(ùì f°KØ‚!;é…iâ‚å<$€H¹Ï*ö¥8õG©n¤b°­{pØsέáC¸D_­BÒ%H±V+T“.+/l€îA¾Pï+Øt¯ú3—¬(V*äÇ èÚÃXà‡øp岜µ×"ä¼)AϬ âÏÿ´<’Ê)q‰¡8»ÕpͥɼD~ ök6çNË”È2ÇÌ–= Ž`;‰Ï?rñ‹;?Ä®-Š e¥_Ψ$ÅŠ*f)êC‚¬ˆâ ƒ‘¤éœN°\EÒî­‰ A5$ …¢H1®.%ÂôB ˆ‚ì|µî‚׿BIÔ.yòêÕ–æ!ÿbM3œÆÉÆâoúIŠòði¤¯âL,ïvÉ#ˆ;"˼~á$ÎL¿ÿ‚Æ%^¨$<¢°æ¢Mp"‚³Úˆ$g9ÏŠ þ$èbè’b-:†c–ÀN€Ýt뺮˞âé ÊêìÒŽÒ¸å-ÍUÖ¥/:d0üB *VH§ |Ead,ø¡4l$yräY*ãá¨Â2¤Å‘–$j€iIÒ‚—Ì+-žo¾.D’N¨¼’M^%Ìâ,<<ÏÛ”£À|@^ª©NÞçLD‹*¾mv&‚SB´<ï Ó)©hË µd)øb¡0äÁÃN#ä0+æ0Vb¾\æ¤ÿZ¦Ÿ(m|ÊEö ¬…ʇC¸Ž-L-F1àØ¥.ÌmáÇ yØÎYºKG*¿àôaV`îÂ÷<ŽArí¼ÌK GqŠ: ;‚A<⼈î#T‰7óŽ(P®Ëúé ââÄ-!B.:úF$“ã$fQÌdŽ%ØæLÈ#kÎaþ‹!¬O¾ðo4fè “’¢0rãð‰/ø‚cbEi“ð"ÂRL¾FÅ6TJFò‰H>J?g&A ŽlXã5Êb‡ì1y*êÕ’OÖV°*+#4އAÃzJñ‰Á,Âýñ7‚Ô¤f." <âŒâ„NælŽÜão¶H;OÀÿôk#ñd/ &"¾s´vŠ(…$þ¡ Êÿ‘þ£é&;Æ*–Žªz RK˜(-ú`gµ„‰Xh 2°K‚%Õ NKn¥‚,íÇâ(`6 ¢|h1j]ɹ²Š–k5”„B¥¯«®O¾2‹ÚEh#oò†_¶ÈPVä“FI$n‚9yBEã"­mšeš•( l ágÌþæ = ‰6bk¶~T·BŒ*vKxäÝ8‰ÑNêê0D.TL¥ÊEU‡«(7‹È6thfE.éH ‚F@b•š¥Yt¤¢~à•\­÷Ö„±ŽuÂÒïº ÒNeC ‚±`d”¼D¨ÿðF>rÕf¬ P+PÕ9P" WQC«Ùîï A;u®;o"Üx4žV²6þ§)6µ4f\ÏõìuvðŽT?¢>3“‰°è/Tª(Ù8ö“fRãUl5U@5k„‡¤’»’OAä‡0êBa})¤8ŽB)„Bß;6´û.B@ÍE¦#ø„Šz±„Š}¶)%’‰"­­À¢­æÜH&ØB\Ù‚$“]‡Â0«ˆÑŠ*3éÒé1}ëª>§õæI@>Lßì3geIçÔ\lÇU†B\ò"Â&èQR#©B¢’OÉô@•ÏY" cE`‡ÀÂ÷Äò¯tÐ4‚ -Bö!âá= âfÿz…4û‚4…*N Ôêh;Æ$çbQ\ý«pÒu/û¤ÍnΚ<áFÿR‘Bi•"”Q1s í·œ‘kw v­J‡j‚Â6˜ÀîI«/l–3mÇIPékOo¬EHnAÈ$ƒb+€õ®œå'¤«,D¡ˆu®/o;ð¯[*DzÓ£X¶–tŒ(Të ¥U¼ 9¦í kÑEyêPc¦ÊuÛBÒeD\%.ć…ðNì¨cVóâT€ ¢K#öÇÄ´Y€È@‘—3ÅÏÒâÿ·§4þoé;T£…äÃ4õónlâŽr"ª'À#ŒþçÚ•*,šØÂrÿ†&µ(@OÑIsº„Â`£©8‰¨–i­Ø_duEÕ7ÈçBêSUe¤©¨fc˜ŠK Ìl2,®ò1nY i¨ZbmG’HV0ci¤Évòi³z/Tʶ§ŸNÎ "mÚBŠ6b‹DR&¾- ã.&/ñÀ>Ò%d4rÍÃ|Àroâ yR;À"L8¡œ0(VäÁ©S·ø‚&7USÙó¹îaÑDU‚þ“\¢/v~²DRìꮎ*dßZD$åQ†æ¡BâÌ\3LÇtL5£ƒÿ[0)áÐâÇâ–y“Ëq¤ÏM#…K6O1= B>BèM"p®ÍÆ#u6fŒ°Q·É³~ñëoLÀ€¢Øª}T Ç“íj>¤•§‘*`ÙD_iyÑ<ÌZde7óU¬¥¢ä-†’ÇØ"FÞ)—‰Ï1âv¥]“¢~èƒé±áÿ,ãÌ2V‡VàTTl+uP,~MI¶Gzm†QîAwš#RΧ‘c'øDgµQeÀ&òù‘Ï#³]ØLs=ào<À¾Ðr)b/ÎPÌ0)šjŠO£•÷·1=Ì•9àtÛ-j«¢Æ\¯†¾â7Ò…‰xUÀ¥`å+@–[ ݬ¦‚R#TIžñº¤ïª•¨²SÚBÑbÒ0¤ADN4º%,y7 ²›“«_ळ§ï;aB M§ü}݆ÜBr—ÉÀð PDY”¡zÀß—´eû!š*=Z£eùž$h †´Rœ+@jH@ò•·\bƤ Ñ´ N ¬3p¥j\ʇ¢ÿw·dLM‚$È–€W `,ë x×@4VàŽ(Hª-HÎBŸOÊÒbC)4-®lCÍÂ[¾G5´Hÿæç¥‡FY±:WBž}V¦–©³3yû;ÀéGo‚-2÷>„C‚œÊ©N Ð¶ lY ÆB×ÃJ·EµéV÷¹º˜·²B@xÛ*x[ºÒÓ¬îS|¨¨ J6¾¢ ˜1ÝÚÐZÀ¶E52x„wõƒ£Y-Ñ%”eX›Hê4T±T©4DêÊJåzµAPîM*.!D MÒN•9ÂNÆÈÌ,ÎÆH/'—*l!:À éÏ I{µ¡zØÁÐ0—BsÍÕÜ0Q¼ÃŽàÿ÷ו=æª0ü?„›·l™ÂTÔóÔ¸ó“kõâÓFIÑ› ¡» éÁJà Ñ-ýyžç!ŒW3ìêTü°zGûDñù~-¦÷Öß …Ï 9šœ&"9QƒÚEéÑE« À]Âr·Ÿ‰‚RQ›ÑŠ“Òü KàªO9ªhûºý¬ê! úª|ç¹ +HÏ9)IG25èϤۭf6æA8 *ô Cº¥{?8-ÂÙÐ Ÿ¢z38bACL3½Æ»K»ÝŽ ”•Ô®åAY˜ãPE»Ç¡*îÈ B‹ÐèŒùæ`jݪ\ŒÞYË{Ö¿²©ÍƒHsÿ‹*Â0ªÎœ*®:?:t+%teyÚ$悃dþ«3|•ÎùM=w¡áê4>üљˆeâ;b%J3’ÅêÙBêã.Ó-®ØxÚ±ôÎò×lú6[NB:îÆ ànvŸ_¢€o¸.¡\ï„Ö)×™r±ÀûÎ|`0ã—”s4úõ>)žØ%ÎÜú³:süí Jåéüï•‹}‡ƒ¬=íiæï)òÑŠ/8Íd2l?Z`?Tàg<çÑ‹§[TXN2"†ÿ nøGðÇÁüçð!¥ åËWP_Á‹ü4êCôŸ~ÿFˆ)¢  ~ˆô¹ø§/_”ôÿZÔ´Ù¦EΜNÚ´qÔI.Ez-‚T•RL™ôñôi¯‡‹ø(Bõ©­"¶ òê`¢  °ÿ:üc4/F‰ÿN°(ÈBÞ¿¸% 2Êúðí¿#Kæ.éÛïC &ð°ð?Äx¾§X0Õ{ÿ(Ëk!/½N´±Åؽ&”û¶ø§âs>~+üw£à‚Lxpῃ-lˆ¸Û‚A Fä+p±`Ç.5? ò_séÒA®ÔÅIÁ§»ÿëνE“ðáé9‰âb¨ '‹,UõªäøY‹x’ÿ¯—üXÿ™ðP€˜ ^,œPWfqéõÏ#¬ÐÚC ĶÀ ­¦?Ó‘4’>)ýÓ’Fa´™‰M¼ùæ?q>Þxä·^{J)E|ÿ\R xéGß?÷øüWPdýƒƒmµÅÂ[FxÖ\uQ:ádþeYõ%jb¼(â=Œ‘ˆW©öª¨°Ê㘜“þÓ†œf ` ô™vB¹ä?GJ6o¿=¤CÂA´Á³²QIu©&F-¥$‚>"!"‚ÿsÖbÄfAM˜KÞißuTP¹h'çQäÃR¹'~ÿôU¿XõWYûXŒFZƒ ¾e©¤%DxÂ<þ£!…÷\ˆq†}@Ù=lÍWLj!™«‰M†²œ—QU”µpBœ£Pèig™Câ¥$–-YÛ²Æ>¤,CP:$Ðn ÷—[j„‘FÍy»—jÒ”•wàý£Ý»¹ü“Ë/eÿâÚiçÂvØQ¨×^ÿîÕ½þîëÃTMÕßW&:VXÞCA?äÖ\Œ|¡@’ÄÄKÑLcУMóhA¢0™Ðk=ÔyÈzÖC>¬ oOLQRD@¾“ ¯ ð‘ÏU䆷{Ñmož¸Dÿ§ ½=n˜à%@÷Š´/¼`n|ææã¼-ÀšÿD$Á²Ç^E´&ó@[')c!€´c4vÈ×!¢‚vu36Ávÿ0 ÿà’Á kðŽpÆÐ#%´I-¸QèYM%Ib%‰õqá%ÇX70Š·~„DE…UøEÒzöãúoÿtÜRtô3nÆ ù!,à @ànÊñ¶§G0ð0 t¢BiõfG·ò{ƒ1p.£j Djˆq‡ ”i˧+2²ËG§³ˆU,­PRJBï¥;Ac_ ×,¹Æ `„%Áö„%$‚ñ–()Zª¸/{²'d^„õ#†Nøÿyõ×yF7nƘ!ZE‡‡k¨†ð @Äzqa‡)lQoõÆoi ä9¥*mUPT1=3q%¢.’ÀŒH=g%’}é9D‰I"K7´$=lÿð4]0 ({£8ùðÚ¦<Éñ„QH+PÞóeÔ>pMNqF³(nþq‹Tñ7VÄgû‡TœAüÖt¡†èn \ †`€wHwØOZg8©9¿G9 D"‘c…$¥ÒŒ%XW'0ä˜=b 8hAfð­@×¶ß–•ë¡õ{ Ñb´’Âwÿ@ð<0</ðð/ÀthŸo‘oÞu@Ä1]ÖEjhµiÀ“jjN¶Qð @ zkáw4ñJ²A³ Šð÷#ä/@Ò—¥§jæÎ…í1M^´‚ØDT´ ätH‹ß†Ò tö€£’†›z±PjC°˜à ÿ0¡Ê£Ê®0FZ/0–¢©Ã™Á™{5#Òÿ9Yq|a'¦Œ¸ ¦f¦Ñ ­€¦¾ª ­ÄÀÆ,÷O)¡÷ @â#eÖ¡!Dš……jr&å6…ðÁ­qMVá³X?ù—(cxTÑoÒ©e^8V!Pªªÿ žßIž9ðöÚ †ªCªÿÀúüšž§z©‘É06æŸÄŸ˜tv”¡|¹J±óJù«H™}J³#7›~)—9'Šö ,öð/UL/•òÝREÒôg'ñ ‚Ê'î‘ò1‹QØ¢çZz´X® Ð1ÔOTQjø—€) FЫT±qJ“ p±hš±Cà $ÿ¯•‚@ø™i±Âv»|OÐx¿Š ‚¡}4„%Ý'R]†RAdY'ë#D$( Dñ¡b"q|vT¨¥¢s#h—ûSœ‡—Ñ…¼ m°p’Æ_Ë´YñPCЫÁrO‚¦C€¦{2Âp,óBÇá%ÛAþË1Lp,sÌÇã<“ÜñB~CN1¥N:i½D‚õØ”í“Mç¢X4²#q3÷šY~Ú÷ àa€óÌ£A oá¡á±Û ¤©™“Ùæ:ìq^ܤ¶—E#ýú@A K’r#PH ‹‘êÿàï÷Z¾Póa5Ò Âö03ÒãjG@måó!èóå>v˜N#4BºBs(û#áï¹Ò;¢uµZ.ð¿P¾ÔâÿëjÈðD¬ZKÛhŠÛxQJ¼ÛþÄ©º>2ñ-C»¤spƈ¹"¿†gq tõY^~Ïò.O¤•¸Ë $$]Þ?Ž8—ä?0ãvmÕ+°öøÝ1QHo›þÞ£N#nwj‡H…^ü-ú™zõª-¯ Èõ^?ÕžœÏ Ïϲmöõ`ð©î+™±°nËÅ]2•¡#=r×l+ÌJ ì¡¿å­®üöÚêò°²-îÆuŒ§¼× L”óÃ^J‚'ôô¤“Iæã@BÓA}#0£ÃüÃÍø÷F ü.øÛ$`{IÛc. /»}àñ/H‰G0äÈðÿ/!† 4„QâDŠUĘQãÆ{z¼·¤Å‰ó&|@Ô°Õ¿ÜøGaDÃs4Ü—#ç>›9ÿ øB‚¾CÿåÓÇ/_¾òý£÷Á^Cz1èÑ›‡õß ZükÒ$DyKþ-AÛbIc-ZthÏI>'öèi8±äĉyóä½`ñ/ÇÍ}; ë¼iä_Î/þAˆ˜ª¢dŒõP4Ð0ˆƒ 0ü÷ƒ¼÷êØ˜ZõjÖ;Þk¬ØyB‡PhBåÊ 1 ñæÍ†:!æüQ~úœóƒ¸ôŸ½©ôÑû§jI¼ó$æKº!é°iO;A¯MˆÿsÛÛ5¶uï¼òä•wä0bÄ<%î3â#‚ø§Étkˆ²T„(/³ ¢z&tÅ€r€³# úg´#>ƒè¢Ö2J¶OÌh ˆ<*í¬¯JâA‚!h„• ¢7š6„H1ÁzÌ'ÿ>ø€£z[²Gªê¨¢o"ðÎú§¬ԊȬˆè‘K"'îiì/HâŠûψ08âÝ(û‡AÝt³ „Ë$L žˆ ð³ÂÍ z¡ #:Ãà jEŠ´t4Ò‰XŒÊJxL‚†ø§FÿAIJ(ÊÁˆL5õCU:¢–Ó§·§–l2„†ìé ;ÿï¾k<´Æ»ò¬^!Z¯ˆ\øÇ ¼´´ÇÎXódž#Χi sóÈ@ sµ=ÿ©Ç•@ƒâÎ ,Ð18KÃ`ј‘ô.Àº§ xãuµ‰ÂjáïxpeÓhô4¦ˆs¨§ˆ|\ó¡òÑtV蜫à)‹oµ ª¬°Ûj+³Â8ê[±ÃŠcˆFÊK¬&BIƒÿ» Z¹dér¢†FnHæC €¶C§UÓ?iTLsŸY+Ü> ÔÊmè€xACƒÊ@€„P$ÀD`»·êÅZ£X^ ÷Ÿ¯ÁN`?õŽf›ˆËY° îÁ”"èRjNÖ|œZ2¨© º*«ŽyéEˆ°«ë(^e »¶ö²¯¡´1xà³ KMÕæ#2Œ":nèÛ#$ŸÂe:rÀ€G8 Å™v)D!WK Dćp€&¢ÚF ¯Œe#¹kTCÄç˜ @\œ*^ZÑŠËH€i«NÒ4œ)DDÒǬ’"‘Êê(.³‡­2Æ·ôЃ/-ÀN˜âÿÒ@'.0–ßðÒ‚üÐLQŠ‚Ó˜v3S!Æ&‚1B}þyk`qEB ðBk,Ô 8»†€Ð"ÿ°àG҈Ȧ!0ˆˆž0‘5<¡о ø5¬¡w¥¹GÈ^@šÀ8xøÚPè©•pÊ1žŽa$ ä(!pÊP} Â9;¼ØR¨ƒ2[ï*W1UìÁ”åx@ÿAËœð%“å²}Y׆µ!†(fŒýISF(SÆŠ|«O×M' 9æÿ0àé‚P(§1¤}°©=Â(vNÄD²iÂÔ– FăÀ#W4‘~A2ê̹Jè§ÿËo…6* ò€øš–# º~¨$è,§¢ûtfµ”¥0i–µÌÊžâð¢‰.ð€>VV¾+‘Šî+Í2Æwݬ8¢ô¢¸¥»¡‰kSú‡é2Î7µ!˜49«¸Ï `ꌈG8–&À,U½GÉG§â1Ÿü*¥8àÁ‡D-<8+þá˜sl3^§tÓŠ!ð€@—c^NÞt#EXCšÃJÂ:GI ±X>Py”]æM:ü8)t<+(~)"&Lÿ13ˆD-#ýc‚ìT§©Æ`+Ú„ŠVB£¶–târÅ8UÖàèqRxÄ`#ÏxÆÿfªõ, ‹œzÏŸØÓ¶}ŒÀ4©Vˆ8àB˜ôÓŒ Ê’T´¢<8‚¶*'m `¸ 4«Œ¾ª¼ ©[>*—%–£qƒ,"~É `ÆC¥TÓ•¸‚5e"Ц™œvqÒ#kG1Ôü\nR㿈„˨™ÉÌ7%2„p‘@]Égq%Â(âV¤ ò êl 9U°ˆjΈ:©Ö‚¥F}:]D^0TâÍèN5*[A&â¦Ïäf˜G`c…^Á¢·¢D1¬y;‘ºñCúà"PJ”¥ ŽƒÈ3‹Îøå€rp¢©g{r‰Ašˆžÿ%À§û“Ÿhœ€ ÔƒÿAXÔ~RV§>„¸äm¥dózÖë· ‹ò(U‰ŒU¸2–ˆn( Nç~“áÔJjt ì2„Q]dˆÍ¼»°À)ËaDR²jº5g°I&,+õ‘Ò´ì¾+ÃŽWþFÓ,j0¦|€Cc³ËsÖz@ý(r§=!ÓA+ ¨Ì`“Í–›+ä¨<$˜]†]©z‘F$WÏ•ªªÛÞš¶–Èì%†Ìƒ<[®9TrAwS—¹ D×èåÌ kêkä2Þ†¬²• Êèy—ƒŠC„ÊW²sfµR† /ØSqî™EdVk14t“Û¢-ÐÌIÁ¹qÿÐhMºl0\@ ]ÿ°}$$ ©>Žf7;Úzø-ê_½èÕ[wN-4㦔SAC5ÈpÊF  ÀeáÌø”xšþGu@Ë Mö„‘Uùá®L‰Å »QÄÖ:u—ÎvLö–¯ŒÄ/Ç¥œ³ º¼Í11Ä9ÔNÓ óÅÿlOA;£›%o4ÊOÛ|º@Rµ%t $Ä#œç¹I,‰($^÷º!ÉÇq7H”‡^q݈´ ®fîDd—Ã^5›€² W{uÇõäžC*7¤¨^NËþQ€(lçèòÈßï,†”2Z9°ª LŒ mhŠ|úÿ)@pµŸæHÈyj&´™d€8@i*EÄC’¶xE×"l@GLÇ“‘‹I xŒˆyÈ%ª(‰Ð0e*§ÐÈÁEù¯~„TžeÓ79›óƒ0ƒ<Åþ?ʃ³Ðé¹ÊSB÷»¦ÅŠ· Š¯ ŸdaÇaº%_1Š®Z …B:¢H– ª P!n©‘ôšI‰øéŒ„ÈDÏ2•ÙÑ”!›ˆ¤\¯J5ŠÀ›x ¢HD™Ô¤.‘ˆeZ¦•ûf"€Ø„ðÛ0e»C€Ó7id³}«‡ § Š(NâìŸ3"(lò9Hˆ¾¢#µÀ’ô8º©¥|ˆuL"C¬!·FsŒ #í’7q=àqÿÃÀk¿>  8NÑÍ•c9Üô ÿ€æ››ˆ£("³¸ŠÓˆ(p™(˜Á/Ù¿Á˜€ ˆˆ‡¨fâfÚˆ…´¦Þ˜2"Èàü¦ 9E?qB‰È9qÅ$˜àÄ€„8F’™ôøB¿Q™÷ŠÄdiœ0Œ'ªá—&ÉÏ·`®AÑ®RÊ#XˆKÏ•Ð(KW„N‚ à F©Ê)¥„1%ˆ 2б(V‚Ž.U2Œ@×´R»¨%Š S\!‰¿À”èñ´ù¤™ÊùD†x¼Ñ“…ÄCSB™ u.$t ¥9ÜÛ“¢ Ÿ“#7õŒÄYÉ…–Ч`GŽiÿ+ ^¹‘{€ @Ìÿ²¿lé `.QH¥}ø€Ù–˜¨«µ§÷ Ò•pѤ˰½l! îõíÉažŸpÛ …ˆ¶ÿ[D¸á¤@„¹ÁÒÁºØt\ZÚžXG]ºÆâÞàà‘ÀO›†PÖƒÈBˆàâ†@†Éµß—½_sÑ\‰àŒsÁ–³V&Œ?qT÷œÃ=áÔzE%ŲºhZ F/df &éCLjP¬DÀÊßÓQ_û[IÍ àÒR³%E΀áEÈ!¤-¯ü5yXÐ¥¤X¥¹•Uƒ,]ŠsÔU©ðçí"ª) NTŒ ;e‘,Ô–n e‹å–\@íT Ô=Q+ àÕd™c‹slˆk¦¥% ˆ;E|² N溮CèÖ1ˆ ]ˆÞMÏmÿLs¬³Ö!DÛŠø¾*ÍŠ(A|.2.= }>Gî•`­왕e&8 Ly÷åeäÚùå /þαè.~€QȈVŒ$Œ®ñað›\`"t=éD,i`ZÚ‰@A”®ctš½9Ì Ö'uaÛ¨œíŸ:ý 6§ šò5Ìt†hØ]2,Û·+¯ˆ;$¡\’ë!hZêÛ]jÄ‚€X”ϸœÐj(MüCŒðbY¦âŒˆ\_ˆe`PëZpSãö¤M \°¤ 5ŸFE2½Æë_Âëó‘ˆ_’/}˜ØÈyÕ†à¤j²K ŠÊ¸$UT0‰ˆ°Q U†šò2F~â €€ §˜›E”êmQYDDØdŒìi¬èØ©ÌÞ×#¹eýÃr"ŽðójŒˆâ(ŽK«â,®bää“',Ñm‘èÒ¤¡hcW‘ˆ .é?i“Žˆ(‚XDÈy€šÚ…€ÛÈã7r0ƒðeÎ0aõ8˜T0Åd[Þ†ReÀ„©CÐQ™Þr|ŽXˆÀa¼(]›ãëÛº i`©M]«TFÜRR¶ú‘€!ù ÿ,éÿÿ H° Áƒþ»ñ…ˆ Vø¡‚=óUøðßD„#Œ _†ªˆa,Æ?üþ-PH³¦Í›8sêÜɳ§ÏŸ"ùˆñßÅ‹‘5È/ß@lø‡oÈdD Gz1TÄû7væ ð]˶­Û·pߨ”Ñ?—ôTÐ,@QE… ¤zb8áCíÅë`Pí¿´SãJžL¹²åQ%rìJzöV†Ö+Jè¡•vÁ`ÄE'Î#hw#ó&pÉ×ÿS#ÿ³0ܲñãÈ“'Ä— ߨE´(0FŒæéýOÅh£¦ÿñÿ% ž,O®ÿ`!ðÈ?y° Úþg{¶D+ŒHI qµU9¦Ü€è–cÐ!FQAó„%P¨ ‚zñU|e‚o&ˆ÷O pÂ÷øÏK°°„<uÅÝ?)Q°Â ZE& €ÿàbàÈÁ&äz±ˆYBÀÏ’KugO>ñÄšQB1P‡þãA<BáÒzÿ¨È¢˜÷¼ÇÞ@\qÁ?†Pp"m „áCUÂäÜ‘@„T9|a ¶ôyÓÅ[‘—eöC+E4Q›Eé¡ ôhð…ziÀRJu ¢^KŒ´Ä‰b²(=ŒØÿÖÕp t%i嘙¡ouà ¼uÂ-'”PÙ(ŽAÊ"#Dô „ª‰¹ª@,Îb/YYš VBÑ)ªÕ©fŠ'°XnlÜ1ÂHÝ·pg Y°mEòO9ô$ƒN'\ç\j!+I‘þS?4¢¦Â‹Ô"4=ÿ’V…(îA)¦(‘hÚu› LÕÃñ˜ïɦ겘BÜ´"ÒóÌ“°öÄ6í=îýSBl ñ?P3Є¤ÁuF«¨ò@,Êc®¸ë±B7LUÕÈ<ùˆò×`äXnŒ›<ó(©Áˆ,–É‚] Á]&Ô,@`W-iÿ´R K§:£t¦Ôìa]˜Œ“ãaGì£?Ü ÁšóÀöé l§ÈtÜð G܃Á@¸úAhVê½éÞšnª] Jͦô Ë¹«±'µ@RQµ8>tÒ„.…­€nV²ªØ¹pEZÛ«²ó/£pÄpÊàJ‡Å•$^ýûIáXr ²cÆÝ z`YB¿TÀœ¡éòàYç–¤ƒ«[›I³´»s óèŠÿ‘|4Å`F™GµÜE£å/!^%MÉ+EØ®Œ5©…ÀþÑCTöP-ˆÈœu\Ç¥˜x"&)dB8€Ì |`u×YÚ„¬#ÿÂî<²;Á¤3õ1‚˜èCúøGõݱ8%#Nñ âF±ùÈ¡§$ˆ%‚¥©òÁª& È8ÿ á DîÅs‘Œ`34¡gBÜó Ø#SUÍ].‚©›Ä)ü`è@D€+’DÄ)®G2“öO›m 2Z«3iBËþ!°q*@ÎÙ ‚F€•>ëZ(’gMÔúÜónzÑ©ßÂ¥Œ±#ÎdÖ6àD$Ô)]q ",(´L´xEˆZ|¤ª¼bA ÊgB= ¤œ].€¡J:F 9æÁ…aKàcë?ðeà=ó¨¢=(椣ÿMé ö`דœù†ÒèMH¥Ëú’؉xTAÞbG•28¶w†ÊW°z7®âCœ{¢JWWIR\”T¤tlÈ|É‚¿À³;‹î±Áˆvµ2'êîa›Ðð)ÞÉïm%öÓ% ÿDôÑLäã(›I(añ\äÖ©&>J,'@„>åŸÂ[HG;¤‡ÞEåñq ˆÎ2¢1¸5c¤ö‰ a­@è۵ŕ4Jñ]™9ž˜ˆ` Œþ±‚¦©›yÒpo`–‰"y=鮾º«›ÀaM?’RÖp!.*@AMØp×»•™œ[åUj1G®^6ÿÏ)@+Ž0jÅñ¸úî!Sµ ¾ÿ «hÑ6% Ü•J•‡“x@#€tàt@üpBnR`L ä#@‹Zؘ(£‡>ˆ'6 ‰ƒì£'^˜€\Q d£ùàÄ– 2‹‰€7©Æ?›Db_‘Á! –þVXùRUäv4ßS‘JÊRSbáR Ø>@Ó“—!€¡ n¥Œ§#±Rù!`y€Þ½}´âqàL]äÀ™¼ÈpkD: ¡Ž©v*N6À?PpØÅ F Z€ 4QÜÀ­ñÀKY@…0¤€‘ÿFÄ’òá>ü#q`‡ #ÍšBT=|à"ò>`œ¡ˆ<„ùÜþÁ†„ÐáC­€mA/Eb78ÈtazAé!,A"ì5÷{s×¢-\b`üPWå!Gñ*êÑ QcѸƒ;,Õ[ÿð+5ÃSjba h¸”'Ì2q¶R!Ìr€ A‘ÆWPZy1Q–WxXddÑ#d&`ªÇ,d Ç›ÿQ¶Su÷laÑ{µå{vÑ‹·U6Ð1ƒ­€R¾DBÒ ])K):–þ´6œÃ("H%ðô„tå‡T‘¨1¹ÓßV~²¤EF;¹8`ƒµ…guÅs<ŠW@žˆµ²ÖxrPbèW‘w7àR¢Gs¿Qi#@‚cT€`Kòh hyßH#*çy¡€ç‰Ìäi!|]_ƒcJ‡!ÅfÈB5tÄA70VvGx„¦(|IÁ}cQb)é¥ã1ñPP0± `ñhQ‚¡S#{ÔêÑöÊöÐw„Œð7JOÿVeeAj”—Tˆ'†À†t8q™ ó ó°‡0E°ö!ŽÖÐO8Fº`ìÀ”‡ ~ sÿEsž÷h‘&zAqà™ôL-S1þ(WnfY>T7à‰† PÔჄÚ1F $He)QB#"g*çˆP‘äAP\O¸€QK‚’¯-°’¯ã’ñw/r˜±Èx ÖŒ¡T<Ù#Žƒjºâ Ä,ÎÒP sÔ8qK¢Z l†–VMíÈh¯‡’Oòta"W¼wÍ™‘Ç nØ–@åLùpI’htIvÿ‰7ÄW'jq'Ñ 3ñ0_h‚ù=ƒ.ÉÄ}_¨$"–òáöhü0àw4WHW¸x “)#2-F¸*(Ò%“ØAO ±rR#Ésþ#ªxÁü':'†ÀP*ÚP%º› œÑ º‹´ˆ0÷6v)Ì@Ž›‡¼`–"dä×±«C‹¶GÁ}†Id-CÐÑ „Œ €&PZV&«Â(•ÔM"a1Ot¨%r`¾w;#Iêq…úl±" Z"·"¢ùG…‚´5‡÷`˵“6:! doÿj0»é’ê¢Ù˜(Ž 8ü&wðT8[ôp4Aÿ0•‘w¿ÁP*÷°çWލ”’¦FЍaJj0;Ê# ¹âC `Á§4¡Eó9KãSIƒsM–‹|¡‹øåw’t:-’DŒŒb"$‚§á* ª‰1¢¦57j°)<¯iQ–'‘¥“7XgAp¢¢Q Åab–ÝpSJ‚÷–Ð2D¾ÿê0ÿYM›zž7kMáªOδ›OAW“⪟†TáaÙõ2 P6¿:²)QLDd%ŸÓüdhrUKOqfÝ‘tÿÑS¾'~®H5~ú±*ìå -+ŸÉ’-à*•DrÂ`¹ò`‰wM51X²'Ey¯Ñ›Ñ¯°°áËDDòy Ý Oò  ZOŽÖˆ4‚‡4‚¦D¦rŒVŒö³¸¤ógGFe³$Á³Ñ¥ÿàìÁ6,©4´£«Fa{ÐJ~\1ÜÁ…=…c]XEʤ*òйD-.ù™'@®Øñw{D¡ð/ð › §´¢¶ƒUÔc0™t¦±:ÿàµáîãÒÇp@\à¶‘w8ú„ù@#eyw¬¡rÜ Ÿv^çÅ\ '\׫ÿ5Ⱥ('²" z4³C—´C;ªA(„.âFre‹T(§å{´èFWˆî»>a¤z&S¨í:@Ñž‚dAt¢SkA†°™MúÈK‡^ K2F‹¯–N¡`£ù•w›õ«m¹·SM@A0† ÀsE«å¥G Kýr1:a‚¦)îK\¤Š<¦‹ö F¡’~ISØLÍdNX™ò¿–”W6yxš\‡jm5q·%Z7p¢¼ëª±:tSIûµò`ÃaFéUK7%}ÿ¤µÔhÛÃLm9«=1R"±?¬Œ`,®" )ZG´Gÿÿ’*#¢"> …ó"·ƒB”¼0QzN\_!É]!úÂÊCÌŠºšµðWp÷Të ¢S13±,A”ü€QIeI1FŸr7\lÁ ("KŠ`PòlÆû¾Q`Ír^‘¸:JÂÂnÑžˆSî‘Ö,˜5ì4›RL×ñ:w*$f„n±ºS8‡;ÿVzÛÀ.²ÑºÊ. `Á RE­7p'˸aá#ÈÒ®œTS;XýÇ&+z¢¡À«.HáËÁ iŒ"Ʊ}·#!P²•q€ûÚ‘X¡GcãˆËy$¾3l¬%v£ÈêáH”ü³ï‘?ÿÁ" ú™…ƒ !Î$iF`¹…ŠÅPôLd"PGMd$I~¥l ówBÅqpex—‘A0ÕØ,³¬¢#ù…mÙ–d|(ØË Q (R"Ì` ?œ“Ów…*Ç$±ÊO¸›kÚÒÇÈ,À"PÈ‹ÛDi|"åI€C×S.36î¡APci,ªûl Q¡ Eo42ÄžÌLú G½E`™YµE`Ͻ0…Tñç¡…Ú“«é0/íYy_ØÅ‘òWФ™¼˜„‰×NmG„Ž`·£ÁŒc4!Oâ…ììªM½>‘| a)ñB¡Ò¢•RœÁ•¤zÿ4.Μ$Ÿá²$; Aì’{n9Ôˆ°²§ C6ß¡   öÓMÁ.äjX<¢f˜AÕT³M’Ûƒ»»Û¼«hÚÌv=Ĉ:€*«²Æ±6Á|Þ›rº~¸rÝI)Ãiºyãg][%ƒÓ=òµZû`ÍAsÞ_ã{3; ÙºD-e2º:N-¡û¸› ÏÑÁí÷c+0dý‘ä,¢ýWxƒ Ц“½#P†¡¸ÕOñW Ý$ˆ›I¡ÃóÀ¼2 EÌÈ¢ÄQ˜ÉÆÂuœ±Öu—dÓ& AÕMÞ!FAæÒFS$³ƒa-Ô×¼ÿ³"ø3ºá:c9ŽnEÒÉ¥| ß>Ðÿp ¡é1d³æÃ‡Ô¡ÄCŽñÊoB“¡A«¦|w18ªÃ•,°3ÁÌ’bžüK~—Éw ADæ Ád†°tòp¬eÍ-4æR$bÆIƃÒR:cè‹mFQs§,“Ïvº–ÔÕ1’p"{>`œÞÏ™N CFdÈLš˜¤¡"E'¦~—wô&ú*±ÚêáÏö) !ëìs‘”/I@ÑA{Z¤ÓG䟋I1Ñp xOñ¬™Ñ xOíÿ°¬•ݼu‰±:±¢Œí¿#>>-çÍ"-LÿÿPEœP6ïWˆðc3ÑˈîBp Äq ˜^ªTÉìòÉ+0ô@ÎXSQyݽ{±Ýéi\q7°¢Göó¾E2ܼRl;S",¹\8F ä ¼!NÄsq”['•cq¥Ó3áK¾”Ag"BÔ…aQ> 3ÓvOØ>+®ƒ-ÙFU´Þ#‰‹8oäQ®Œz Ëøó?éDª! óó¾Œ% ôWy|OaÜROÁ¹õ)Ö£‰ƒ.("^Ï+`Ê^b/Kd_³î‹­sÚÛ^±Ûñn– 7P9Çî;îÁZF Ò¾C+Xï1îCŽLø‘K+1§‹Ï¹G`^ÿ˜óJåýs'”¯ŒœNù1d ߈p c\­9J#µ8úë’«ÓÛñ°’õ(ó4°'oÉ¿'|‚ÐáCˆ%N¤q„÷4"\rb‰ *èiPèQ¡C{ÿB¤¬øß(|ÿ`ÞøGáÍ%þ-9r¡‘9b<1%=F)ç1:ð‹§ .)øOÞ½žåqÜz¢…Ñ•ùêû§Y}"Ôþ[±âßJ/=œ{IÈC ÿ.ÅýçÃGÙùò‰@x÷¡a—‡þ¸ah#ÈŒB$@öý£'Pà¿y¡=R½gð„Á« [®f½zC}.騔žÿ ^ÿµøâ_ Ëÿ6ÿËÌøðÍ1Âü×ê!"‡G–`„(àHÂßœ/#TžpA„àú,pëÖÒå©6­2pYDˆ‹?á‚>(Qbø®Ý„¯½ô[À¡>@d îB,&‰„€ ‡  ‚$‹l²ÉPmž¦š"©$ƒJ[‚ªjmE#âÀ§Ø^¤m'„æÉ$«N°ÌzXâŒGî@ëLíþy)&|~xȦ‡ŽÀH(‚Â*!cà1©à¢šê¼ò®óéŸ/ÍÛIž¦¾â,¬äûǾ4‹hë/„â²`. ”K@²½‡€¨;„TX.É›2ä Ê!Ê À WìæNÍœ‚ Ø­vê骮»Žõj ,Ìþɧ}ä[A„¶Z@•¿øÚÀ®:ç‚9ãL÷.JÒÝï/}|³ŒAÄ"‚¡—Œ\ ! …û‚Ðæ¡¸ì@œˆ4ƒÄÌèGXTí!f"І‡(~H‡'D}ÆØ4¢­£T © ô: ·àb×_’þ!’=#aJô›hª`‚zÊ*(„¢ü2דb»„¦ºŽK1ÑKÖ<¯Œr/°³ SË­"þaÿ ˆªýŠS/ ø›ëŸ¸ôpα÷úú¾¸DèÌZ7À§^‡dVô&C*`dá‚ X!§JöDMMä衎Áªg8xHñžQœ€Ç—(qGbr õžƒh›–$Ú®ªm¤ˆ,’³Î`®‘ÈDñ½ ‡ìv(LrªY«’¶=§s-¨K0¥›YöÀ"ÎÚl¥æ–­ WÀ/\FÕÕ¡¼èª~μÂÞ€8Chá„(hP_ˆZ'ŸB„NR£œQu«zh‰®â26ŒòLjñ NÔ¡DŽ:ÿàl4¹{tLq SÇfCh€6ëHHL§#XùkZªÃ×Ìœ“ÿ&›Äà×y¯2²¬„¨î)E OÀd?>$WßÓN>`­¨9ä„AHžç°õEˆ\›žø“.ìMÏlÛ»ÄÙ@³}èm+Z”M&€7F,%"òOSªò·óäïKä!Ƙ?Å qûæ&—À:D€!OF4&ÙpnF 9ˆå¨¢SÀ±hL7‘QÀ„10Ä */%P(=ËFz‚¢Ý…‡"<áäÒpE%„¬„8×ÊYÄn¡ò[qK\"§vM‰t …ˆˆà|àu"ŸDС â‘ÃÑbxØ:À1Ë*幨ÀTDz‘`Dè#8ÿÊÑru„&á GF§Ð€&:HSfÄE)Þ±×Ìl ±‡„™ä$ÀE®P÷T–U„ç9!ô°¡µàãD¬:@<~*ô 8-À/ÜÛ~°ÇµêUlzâ“Cø’|@'@#…ȡȷ a‹>rAì§¥ôˆwmÌÜ67âÆÇ™Ðš‡ÃÜ=ÇÒ1r)ãÂ"Bž%ðEVY ±£º¹ÌiEá ­™&F䪎=럓̓É5EÉ ŠZPÕ%ÈZh”Cê–…Bdª¸O_€øèmí£{ÙO\:z¶ øÅøÞ(@ Ý _ùå[þq3„dHÿ†æ,è ò;ó@³¦@µ\5 ØÆj´mJæ6¦Ï”Fx”ãC4":úù´~ƒ£DRÕ¢8DhF‚óÈ”`¥g@1Âñ™åÀJ!¹ÊՉΓ°§/”7$Ž)W·Øä®ÞÚ®]%¿JON_«Ÿ>:‡L1"‰º×sÃÌ$Å`fmO*kNôÌîK™Ó¯lÎx¸Ö.sdÜFˆÊ‘ý£ ­1p¨Ôs¢9Ä(ÝñŒ@ôö*ÉVÂ4J) ‘ƒ´O$Bë1PP²ª ÈûÇ­Ü"‚w^w5ªÀO~î'‰ì%]M”Ë?2±”å@‰Ñsþ¾ 8òx—ÿÙ ‘•ÇPe"ûuæFü«‘ŽmLK]ŒH¦Œ,ø{MÐMH5»u®¶ßä~k›0ì å!TUÎ `’$šÐdÉþôÉ$B¦ß )ö–XqÅEOι=–ñMYõV ܵ»u­«[hì–ïÙ±’Hõ–è±D/&ˆ1òbQêÈL Z &!VòØO¢Rù˳£ã3­le£~3"3òÉ÷|í…Œ9ÁóÛ‰šõ»©nLXpB¤C:„fiÊ= Å3šZ…F¡)¤Ð.lâ­HgiÒuOY$Ÿ5EƱ “(BW„ÐX“öA^‚Ä NÏ!—€ë?üô™±þÞôÿñB㘵ºcÒQkìÚ–ps€`6ª™bæD IŒ‘Â,;*jx›="¿?ƒÌ}vJ ,ìºk…´ôä'®¦¥Ñëà¾öÒRì›À”HhB)cTÊøÝ©Œ·D~^¹Ìé~Ê˸<š¾ÀmVújïQñr\!$ÌœÇXVÃYnæISs}Ô&Ìf7´iÁ@éq÷Ùà öà‘©@’C7zT³G<8OZ¸tŸi‘𓶘¸¶²£”¹³×Hó18ÎÒÜ}ºÐÚ\t# d«&m‰4BÚú­²®ú WŽÝ5u=ÍÅÿ¦Ä¿§ÿx¯|%Ê|ø8Hýe,Nrl³Ö^3k:WG)5Ä&¹FD®"ÛücïNøG {D!%{Ç»ßbf0íÑÍ-qZß@c瘸ûV‡ö§CüÌD*;'1Фc¢y*Šá8¡“vË®ˆ´„B&q·ŠÈü˜(:/}‹ºŽ’‹ , „0ŸÖ9’‡ð“¸¡ÊŽr-Ë©)þâe®€J¹k8ÃI6ÓH°¶+‘+6§Ò;î‹Áȇp|ЇïBð#?p*ÙŠ±ÄÓåP¤‡x$Úºò‰ç*ˆ­Ø¿9[á („0=øºã[`êØk½I£ˆU‚ ÿˆÀ±}‹Ã{ë“©Ë‹·¹CC¾¸Á”¤ ¦cš'ÂY¾ëx>æ§é;'þÓ(‰“H4„ ³ŒCD¸DpÀÄK¼DÁ(¼™ÑHH”ˆ‘§`9£°€i3C`+…™2 ¸ ÈýË"Î ;³*A§a„ a *|«ë¢¢C@Ö˜·7ç(ˆ€:;›9ñ“¹0¯b,!µA‘‰‰XDȤ˜°j®žØ*šr àA;ìm“2Ú’ªÒqD« ³%Dchq$ ( ^~T‹"ðGµàOÔ»»‘Ú¢(Ô ¡ ³0ÓH„È«º9>‰ð³ÿ²6*!±©ÂŽ\,¡A z˜€ÒC€ŽHKI·HÀå)횈Wp,MS…W:­qÆj¬¨t±º·ˆ‹k¼F{ÑF}¹‹ðÀa˜á¤¬À#-ä¤9 ƒÇ³ ª„H6Ýø»á¾ÐðJ^ø¬K¬Q²ôG}øÄ| Ã3)“ 0tˆ»3Šhƒ9ˆØ L*!Øø3¢i?MŠ˜3-J ø" ¹BI ZÀ—¤XWX€ÇÌÇ дó+ó‹!2ô¹ÆC1ˆˆ GÊ"æZ®§€À9»} ¥ “\I.° @Ò@Â;ÔÁ;ÜäŒÙ (à¾|ØÇÿ}ÌIJì Á:N0K¬!H ?{ à ÄK‘r*ž»‡X¤º‘€G¢ ¹¶ÚéŸJ»–š––k ¡ù΄Љ^ÄŒ|8Id7b’myˆ5ôǤ«UªLp‰‹IÁ¢¿ÐM[Iµ@}XáK¯¼øŽOb.ŽÀ$%܉Êú?-´ŠÝa<ª¼Œ»ã;ÑÀ Q¾[‰ጽû¾ØÇ~Dˆ°LÆÌl¢¬±T à…|p¶dÇdKMKٹΈhÅ[a+@䪇À:B4¨Ð‰Ýb„\Lu¨¥P+ãS:û¤Ï5T:d|‹¶˜·¹š·ys¨Kc‹K›«¹b ÿ ‹ð &ùI#¹‹˜M× i±Ðú"¡pó áœ#p©‰.A åàÌH‰°èÁü>FUK{PËàÌÑ5ˆ"€7½Ð‹&ÚT¸ÅµÁèQìK¡d3ÏAZ›Ðœ¶£Bc–]K®Áé›:k©1‘°¥ ‡ªtC(L@…’O¶èRˆøÒë"SK›º*XDŒp6DÈ:ÅÊ tˆ  œ9;ö¸ 2Š /YJ7 -ž”pO± ƒJK³ø~(‹³8‹|à‡ + àࡱ|ˆ²¤«EˆqÁ=MNË~ü¾»«»ï)'¦9 Šˆ*!IDpÅÿWtÕ¢¨]ÙK ‚ ´–¢¯\e¤(I‰0ºÕcÉnqná¡NYŠP‹´œÖºs(ʨ–ˆ‰¸ ð ÏfÁW;¿´ýS™Ë¸W‡Ð¦mZyE~³( ³@‹x˜í!Ký‡^ˆsÙ7NýÔL¿SÙÓhØèä ¿ü Ãç¸We§LÚ‡Xý3Ò{÷kG…1 µòUGs½ìb-EÂÈR–ˆú<ÜmI\ˆ@Ð| Ù©D\˜H² ˜‡x l,{¦VãÓ®øÉêr4´@¯‡ÈWát4@~xÑ=V±¤+xÓšLÕºM-X¿(ƒ<¹ÿƒh*iÄöqšÎ"™|h Xd«urš(©ÛÔ;+ó@!:»b’€³€ÏF9:…ŠI«5LÓRBß¶b šÙ8{´!óÕºõââ$M—’9Ç{ÂÂÊâ" –ëÊ œZG‹W|M‹|] Øõ×¾0ËÙÅ„°]½0Œûš° H ì»` Ýöé )Š—{ÂaUîÄ 1\³ØꈊËâ eÊ/v@ßÈ!ÕC‹£[=ú ¦ý€\#~ˆ8Ý51ߊ˜YzxßÝ@„2ªc ÙY»y ÿ£Ÿq /ÆŠ - àH‰{ BוÚP-Üÿ²xX“}Ý×xH‰¨p¡cUèƒÃq¢L¥QO-^B'˜Í€¢Ê!‰°S ³FÚNˆÈEºˆÀ$´rA`©9<ã:dâO–€7õ  ¨;F³‡#Ž‚ÀeŠøJkñ„¨;£¸;#v4Äj‘SÃ)!ž°¤à±6û*ˆ¢@ÔŒy5 ôM‹´ÐW}•Ú´ø‡e—}³¤`lF<6Nˆ@ i¼à&ò„ÝBÕ # ½QÕ`Žƒ3Rx%ŽÄ¥'¾ ]‰;ÅÛ ÃMÃT(ú#öžhº« (ÞšýP„ˆ‰0ÌhŽß8hÿ_(Uãû·–H?ù&ÍÈòÄKÒN*fâø¾©E ¦‡ÎÄPE„)%Ü~ H½ÔdK:Öi®¢¯…YòTO=Ø@舮h„‹ˆf3Š`$¶©È ­ˆaâ"€Y¼'Ú@Ç|ŽÅ„ØŒ 3¾RÊR¦ €i¨»@<ª#’™egc‘d©;ˈ¢ÞË ú•ˆ ø·¦€Pqµ>ŧ’Ⲉ}dàlyàxZÂÕÄ5!Œá¬f­­šª‘à;¶]« ‚sOÐT½g²¥!´zì¨Ët šÅÇb²:Ë•Ì1!¡È^ó¬ä5;í…€ÿ:7„B¨R‚Ç=eµ†Ý r¼Á0¹;'vUZ‡h4p»ß) ƒVˆ^ꔢäz>¸å‚=r™C-ÑPKwCBóPð`Äd-øQ˜I±àP„ñ”Ð !²âCß}€Ð<$¶¶0qpO 9ºDbCM–Û?™!’bF¡‡QE'÷Ð(Çm°Aó@ç’K3½ôÏs6Å`ˆÿt÷AçåãÿB<ßÅCx#üà zM­·^zî=TWPÉyUbñGÐXhå?Q¨AkµÔÐ{=(×?TpADZ"FÄq!”Ðk$ž°Äc&é—fCfDdBùHð¢D ½ ÐKt˜-@AÄj€]TUf]ô[iÿDÑ )†DIÇ„H ò°ôOt-=‡el6á”>pý”j>çùyád®Sotçœ\ÑÙ¼Xí·ßqÿñÖZó¹¥=} Aþ“¨AzDYø ìµ!–Ñã+F<’¨A1RŠÁn6äE~ýZÚAT#È*À=”ÙÿcG”%ä× C¢úë‹ùp)ÚÈ -àÔ,éì-ÇlÎ%$]•-01\ w—j<•Ùí™ü°™‘Sê¥w\{uÒY_¼eåi€ÿåßXE0 B>ÐC¨]¯µ„×Ý'h0 |Ç0‘Iö„¡RÙ dôäÔÑCêÆ–%¤™SƒüQ®ÐÕTr=”§Ð - BèèC9z—ÙsEQèØ/ qVÐÿ$çìî)UÀ”ÔTíjqÙ]¸:MMP^:?.TÑOþªeÃ÷^[d}嬞yö–ªðÒ-£ŠÂæÐ݉Æ`= ®0÷Ÿþóù¡$ŽÞ‚¢±pÿÂuÙéC_>F¹ÝÔ,8/ê’@L·¹˜.týj•ÄJs›Q¯QIAUzà‚‘®a$”ø‡«àc#ˆ¶"ê!Qó8ÞûÂe$äå<æ© ›¢¢Cx¹§N]ñŠ»¢ç®­ÄË^ÜÃöäŸÿØB@EÐGRºjC-™H¿úÖ>ƒT aQAB4`EÐ {ñHD®Ò¥Í©f+øßn:G‚ÈŒ·ÊUJ‡Ì£ aÈéd&¹F¥ˆ€ÉªYR\‡™ ¤N”ZÑ>2Ââ(G%£Ö¡¬dV \è(¹”Ÿ ‚IY Šàå!ÎG·óáœl³˜dÿ’J¼â'¯@a^1‚€ñ…yŸ!²³“÷ýÍa†;ÔGòGÇ«lkd)Z~‘MDôì"ú€NnóÀ<pÂbC@™c}'3HѨ&´Á¤ˆ`õüZÿáA !9¶$!& -‚XËZ,Ùß “§P äæ'ÜSÂö.Wê >óbd|ÂǧÿÐkOgÓ¥1ò'uÇ@ò{ˆÓú¥¹@h}†H˜… qœ† :É"jʬuˆØ&m¶"xZ¥KáÄİSfŒ!IXf4C$\dªtVŠ^±€äŸa?•ó;hNÇJ«9Á–$EîùKÿ©gWèô®u (|³ô,ãz=‘r/’üÑÏÙ¢ò'¸ù’Bß‚èÆõHpÉü‹…Ä5¸f/W"(DFw!¦Dp/ÃL67£švuÜY—XÕ‘\q$!©ˆE‚@{~,H©²êÄ•”„{ÁÇFÐ,Í„ZغÇþ¶µV *”[>‘£Sž’"W h•ðÙ^¼ä½¹Î²»w_YÀ .1!`_\*¶ »¬Ï`Œ%H…b!¡bÕ1 BFŒÎu”‹êÇ®º›ÝüjdÄQ£àýrKu¶¥^œJôT… ×|Å5¢ÕúÖh ‰ `“¹¹½JÒÿZÁ%žŸ=\A[âŠWö´Ò•u‚ñºìä.Æ0n‹=] ^̧£~b›'üÓ”¸8LAÀZÁØÙö$™H?*ð¾nnýœ¥"bÎ~äü½òCÜÖÕ–›ÉÊ7…塃$˜Q-‚êÿÜhA ü*XœðI¶*BŒìî·Ekqc‚%„îÌ7!ΑŒ2ÊÕ¥‹H=¦À§i-àÆtâÊ5/Ýït .Q¸M†ãzè{`a@/Ñ(?‡(n}SÌK»Xu‰˜ÛÓt¥™©&i6G sK;±GO?‚Ù©Â…l]ÒcÏÔŽ µ«g¿ÿ¶HþÃÉÁG?'¹BûÌщ–ª£˜Jʨ†‹N:ù-‹´#ØMn°.ÿƒ@ÛÞ^}Œcw­”ù@=JWº•ŽN°‡>ˆ¼ï-щúð2dðâBƒ‘[2H®W¥0Á n}}3†çÒ‚ê$]üì¸$g™‘qkéYh¦]™$ŒÚÓëL5G ¿™ª¬ç/èùD ·ñjBЭ;åŒÀ!Áž¶þ¢“^;¯ø†Ë? ØÂvEÑ=¤Û¨§=LÃUzM¡ª›ØtJ´i\d—®Ûå²ãn)ЦD~(V¿”‘$8Å:ìp*LÐÌgClÿŒx±‹’ã&èÉ™ŸÄÁ¾ÉEäµY϶ZxfvúQ4nÞ®;¬nB&yƒ“¯™àê=ö0=ÏÌýþuŸüÐÙƒ”ˆpAf®ÉU„zÛOwJ©#n—½ßƒ~|§MOU» -d[[x›2(Èìå…¶n¯/©ùãF\ï;AbæÌœ¬¬Ñ)õ˜ 8†ÅfÝq˜‹o ËÃyS¶ŸI©Ì¯$ ¹yÖE’@‰l\KÀô ŽFe ®´@¨Lße †ÎmX„üÛëu†|‡J\k„ŸßÔ'*DŽX\FA.èC.¸Àù¹š@üÝjœœÁ`D Yª<CˆÑü¸„¥ÐJ™­€!èƒ!€ˆ„žÈ€^"9 ì9K.Fä\€ÉnˆŒgØÖÈD„DZè„N( ²”[oí»™£á?„Ø•ÈDñl nÀW¾‰F0BñÿHäcH"þ FèTc°¸˜‹Xö9 =äHŽ4B"dAxˆÜÆp„F* Yà‹°?8AÄÑÆuh3=¤ÅÂtRB؃ œ@’Õ:‹"UĉÄYŸ¥Ùq¬ÎG„æAD£x´ž >åâ7@µ™WIMaJœ>Ü@ DÅM¶=XnNމN8ÁqäÎHœj^îl?LËE¥Úe‡h|@¿àÏCðå_¢Î‚õQûÉĹŒEXÄXŽÚwØF\¹DþÝÃÌù B–¢ÅQ£ DÝV¸ËöàRۼⅾå?L^{ý(~ÀÌߥ0‚ÎØ”IÒÿÌD˜É\(fˆLbÙ(éý¹ à‘Œp|M„‰ AËpû8ND¤Ï(Ç‚r Aì.ÁÜÂ@ÍÿÐÛvT¨¦°§Ädü—„âùËD< 2ßGt¹I7š¶A ÀÜ^¡Ä¨_#µÅöX¤€@‘=FéÈùN€çI`ô 1) t•\ c¤Ñe|Çc³ Á~&e^ÅpËR„ì˜Ä²…饨ÆA¶AB éP™›¹‘ÞA‰´Ôω™ FˆRF]ð`kàÿèM¿€hNT£z´… Öe\äl°hæýfªèAž˜iN…+õÿB>WFHâ Dè´ᢤüNì—‘IBÌC´¥-ìLÖ'|Ùg€^¤Í½ M>#Îýƒ6d 5‹rOrøÕ  äsìO D\¨“GÈE ýhãÔܶzâÓ¬ÔX„„¦†OS¸@>8£öÿ5'C„™jÐAj¤¼>ua~ì˹²O ™š&*ΘȳᄸÌC @A§.-ÍÒEèGgÀ§1~"xÑ­º!: ûTì„ýÊñJ~™ÄÆVÅ lÀ­[³2h›’p­ÄLØ"‰`DO‰è‹hþô#ÃB·ââf>”If´ÒŸ H\lNcâÿß÷a(=ŒhAÀë˜Tç*™—ôRgu#/¨Mœ+ǪEšjA€ @Œ<©Ì}Äð™a}.cÛ^éULı$˜¨Ç^BJªËø€ÇþmB¬Û."¬†„†8ª‘€ch$îDð‘\ÌCå Í=.ª%.ÅWp”u£@ïú`¬ôn­Pê\j@Tj]ŠÀ&Q}¬®>LžÌRžËÁWÀ*ŒÚ!•àì…àH‡x!Y BI8˜e¨ReJ¬>KèDÐBüŠ:ù‹aÄ¥ãh,Cè„DH€P¹}DÑüðÕáƒ?m°À¡HÆÄxÿ n$IEt‹Ú½°9 6ÄjÌkP®âX„P2E‘é¨+FHø$l$æÈƒ?N‘=¸kÚ¥¼ìÒ}£{8‘’¹B@›ÄÚƒ±]°fBÈÊ×±¯Ë[Èñ ñn‡³½ìd¸Ö¦è Å2üc¡ä° ÖeÝÖm» . n´¢ñÆdæEtRµîóBDlˆØk|"kð óÁÅRdšÚl.Ïj¤B4A_ ÜŽ Œ­—TpÅ÷´EK>ñ‚Ï6ÏšÀÅýÃcÕÛ-V@L@aª/1MG/~kœÑ4ù…¨HñB#Fì*plÊB Ñ fŒi˜ÿ†¾Ïä5¤BÛÍV%hÈö%‰Ðö®cƒ<"ÒíV¨…bQ¿àcL4Ä^\1¡ŽŸÙ¥KÜXà|ðÂ.ÓÃC›ŽÌÊÈCÀMBÂkÐ(êÒ‡G φÆëöB/äc¸€G_=¼TO(d¦D€ÑM±ª³$ ¯F¦°ÐC8ì9·ˆI¨lD o9ãÊAjV‚kÏncèÌêÍǶ)'oÝ$iÝ  dÌÃ')µ% ÚñkR‘Žkèã=øããú# Ây<Å_OVt£N¨åmÈK¨Làxœð\ÄëEÔhŒÁÒZˆO\äÃ|Kdž±þ‚ Ä«=ÿ£©=ps ^JaHØ&Q[Êb4¤ÌtIñ¦sh Ëì42#k,ûR²´¡N0ÒÅ{–N‘¯~’ð­>‘Dr0k@ûEÒ|ÀaØÄÄXH>XÝV r(=œ®¬Æ  OlLFžâµ`ŒéêdÚã’ÎÁGgñÃåH,O#¥™e]*…ô”×½Œ…À4½nÍ̵±º5wv`J~¡d8û.ÓêŒTq SŸD·ˆ˜]+²S‹£Ñc´†â¢h9£ëNÛ W%hX£#p¡Û“€„'|€]4„Z‡†¸ÌÚé  ’qm°Jm­ 1‡rBŒiüºÒ_Õÿ‡ÁÇG_œ©1¯®|+¹ÑFŸÅŸôì‘Øë/ä­ô‚ @§gÓî.Œ±aD§RÉIuúþ_ÎaÆ3ú–E|À€þC~ G '„²v€ˆpÐ×qìgóäíÜ48?¤HÑœøX'%/wÁi£ËOó£ éÌoÈEéTñSAlÐJ,„æŸ:u° –ßí܇ëì/ÀÅCbJn„7îUWhT#]‚½æGÛä·dÛx›±¸ 8 Â1šHr11>š„ÓŒLȃâ>8°TXèÇ®*Viã<Ä∯ ÇÚÙò*†‘ATÆ äW‰5›ž›rl”’˜ðÿŒCÆ S–ïpᥛNeÌNkhe­Ü‘D48ˆ9x`ªŽ¢7XP”YêthF*RÚ·A…½Ú÷‘=„Z(Ù[@uâAô‚±j¬—·x6‘†hkûI™4ù®Øb€tdÀz„’p6bDleDePãIü¶†P"#ï¹hlìè0DÈ'DÞv„Úéù7Ë?ü@‚*‡šúÕ/"¤ÛåCŒ ñâp ¾q ´¥o¿¼ÖìL€æHð\‡«ì'¾9ÅVÔz£·’ïg ‡N¥’_]þ/ .V$QHõ‰+ò,›äI/üBÈãôŽTvD0š—eÈ–©äG@ô?ÈüåcëëPÿÕ&¦È­BÚNVÆË o»ÚZÑÓœˆG¸gˆ X„Àípº—ãíÕž'\}zYÄÔÚÅ ä„tŸmù¦ìâ„úÎ  è D=bQ¨/\ 0y¼Âã7|PUóÜýCB:̗yŒæã÷O_A›7‰ÚûâH¥ìýãI!=‚oêËçÂ…ˆ"ª )xéÿ’°a}¸°ÚÐI'iÓbýõ«È?®—úèH÷Ø>|ðZè·£×NÚ`-à„‚„ +ØcôAà<£‘5ü›'PEGÍÿl.ØâÅ@}<‹@dZ¢ÍI냼0_ˆØ?·81ОR!¢PlÒäžFÿ84þO#òòZpxóÆ¿ÿ"DØ`ŸÀìÿTl¹ÑÛÏõ¹à§ož¼Tê;¯/(|Vm&í™ô(A{!J5:ôªòŠøe®¼òR,±È*B³\¸ ¶°ra+UË.ÏèÂЇ¸ páŸ^4ëÅ…6Hl£C*h‚É º¬£Ê*kꟖØLþÉáÿsÈ‘ƒ îqn> Ñg…øN;Ò³ ªê©£ºì Šú'—…âè·âˆ»g³ã³è¶’!º¨Ké%–þi© !@£„àA„|èQ/7›”¶+—Éž¦úã羽ˆ*Ï篰ò ,UÄO%„K KzË3ñê°ˆ"\p¢ DôTBx9,± >`䱯ãI³N˜ñŸÊ"LÏtììWËú2ÕÂ4Œª#›6»‰7¨ˆ FÙJÈ¢`‰#R³à.¨²‰ìIM:é¬Ã΂ÍZ‚“|š“Ê!ô±7½’’öŸŸÚÔOì»)¤c*Tÿ¨EÔŠ+E•R,,µTKR¥±: õ+±(þ°ÁÚøÇzá… °ÇC^£õŸ™º,È2£¬©–VÇÍz(Ça\ˆ4&ƒ*èHeó‰Úiš¨Š‚J Ž˜³¹¸Ôšk­±Þl¿ôa…èLú;|°s³»‚²{PÍê{÷\ïµT Jµ¾ãƒP öÍÇž(òŒ¨¥±ã¯ÆkRJ´rÊ÷B°áÍëT/‰C ÕÐAþT í¡ ‚[ijÖÈ,³§€b¨Q TР̂~.–Gb¹ÆõÒê[Ù£ ’`i"tMÞ^ÜlKy€Sÿ´P-Ó£®'ò ‘èÔåî%µ½ëj{8j(+{M£ç„Y¨óôŽÏÙ‚†6à&­ª<ÆÞ|3`à%(aÏ]Œ+Ò ä×)‰h3¹ø”ˆ^¥7á9å1M1J r'Ûh`¾úÇÎ^ȧ9éäÍ$$oTK²ÖŽ“Qã#GæÜwÞ„Ô$íåήÛEÿéO$‘CªÙÙujê4^Þ3‹?2–G§ 6 žTûÍÅq@æJ‹hJüãÛJ­0‡"ÚB°T¿àÅŸÚ!x€4´šG .C#FЃ'‘6JX[&Óø˜®(ö43žeº@¹ BÝ\MåQä¥_ÉäÍ8'–¸Ùo2‚tÝ`¹Ìò{á_9!biZ±—CŽ-þ!‚ÙxŠ¡½”Y$(ñ#ñh¸%‚l Æ+ô\Ša¹\ÂÁ ê6lC4q.ÕdÑÉp AzàV–‰oW7oÚœv޼ ¦wöµ.7J°iÍ? áp’&Õ•Öý#mAÿT3pµ—¾…*JÉ\„ -°‚“„|%캲JPŽÅ:dÕ0-™)sÍJHYt…CTú Ï. OEêµxè¬Dõ\¹°ãöL©½øàSOH\èB{koìÐÿè/ ¹âË0¥v^ÇpEïjf •¹QÙ“;0¥úš±Ó[¹Ä^r!b˜áèá]i‰!üÑ `™ÜçD¡!´™ˆWg r%‚|뺜Lß MjÎ…¶\.ù½i6³øF3dH¥© øÁA°è|®qèÃDÄ-öê,RFRˆjU¦Nì¢â‚tölö YNŒ6xÂ1è­)æ" Yÿ²G3PÉÆb°Jާ# ciZ#y|Œÿ€ƒ„&!±¹<ãÒŽO­ÔêW6퇤f5h°µ$Qn, ¦Bj8*íŠMÐ'øÁý(äll õæ'P#QB~"jÔ®¨nÌŒæ )†è*¢nB"Ô"rAr!ÜB.~áTZ  ¬ d”ñ¶LFœÐp‚ÿ`ÏS2‚`k+2râB :`Ex ÅèaÞaÅnƒÉÅÅŽ«ÆBewð*—#•v°iª Yâ$²ÄLb°#,«®([BèT 7* ~¦䪣œ~ þÞ„¾”©y¾J3 ä_˜DÍÂp™ÖéhÌ">6b‰æe-Ø"†+r¡ 2JïPE݈né!F,Щ ú0íRt'ÿá^ß¶ß,c…T¬#Ðqh:BàÌN9~Æ5mƒ§áF¿Y"/¥F³+7°ÅƒP§¤c:V@±â —4#;´LÀæCülqÔD‹§ÀŒê'ó2 (ÌBçˆB$™Ñü‹Öâ!ÿráÉŒ£9PÅ/:°è¶MRÈ©Ï>0cbªüQx¡ ɸœÂBž„oE()‘ƒ)™¯¢ž2[È>Gûåýñ5,k¤d7‹¬fÃ!d <Î$n ›¨#Ø+ ]b¬†¢pŠ-P¶°<ŒÆ‹`®™®è=€7ó!–šc£¢&¢&jJr-˜±QÅêöâ·éXo19°Cè(;d÷: #R0€kvˆ2Q "Ms'“k šë8€g¢¯GŠåöÓ÷yòñr?f£®>q*vë¤2¢ÀÈŒw ’{J¢{¨£mré½Ð"["¼'ÀüëŒök>ÿîd~š…Ìš¥nâÁ#õAçèCnFÒühc;Û"˜Ö"n+©qCÊsRŽ‚X…/¦n&5ƒ2ã¢LÀ=Ip'hd(‘å«"í Äê2–€1ñ¸N3,ñ?¡¯‡:FB"x®„†"ÈŠcø(rjÈjCÈ\¬H7Cª:ä¤T¢%Іm”¨Cm®ØeÌæ‡™îEQϬ¦úåotÎ#G"¢æ/Ci-°‚ÞKS/Xs”.¶<Ì€®Q.QÐðÂ/ÜÓcVæA2€Ç2VçÞTð‡ö³Fús –òùÞñìtX8 ÑŽÈŒJ¸$œÄ>T3ðN!^+Â(èÁWNQÊÿH »8SB;NJ:’Í{¦ÅÍŽæ=äj>NãÐp 󒆎¨Õ"ý(¤?çõ>EŽêBRNÜúl3¶  EòÞxBK/cJ”r/Ó˜ë®B…F3¹B…Y÷qà.J6CeýÚgW<@Øä|3Šà+;Ðæ]¨£–Ì,÷4yÖ”o¤©òlJBàƒÀtnšx*qbç! "Ò¨b2ÆsÒéÈ“/-õðж12±#ì"UIæIcæ5\5>]õX`'†xäAÒ–Ocáqct8`nÿñ(ŽÂ†Õ*’•h¨ËxÿŒL·’}ŽÐ ï…ʰu:ªŒ—þPÃG%"`F@5 o ó~GMõæ™b± 4Ë_$KBäBX®dƒóÒ‡*Dް±Ã¶Ú4Fœˆ´#ÀÑ.(Æ=Ö4CJ5ó>SIVÅJ 26TlÕÃ…tdW5ãLÅOy”y”yĆzÙ46328¢}d¤WvЋ¾íýÒ%f«[!} O˜ëŒÒ”†ÊÿÈ,]C÷^NÃ=è·_"õhˆíN0…a´6C èïÈI Õ©X ü0­vJ¡Å´Î#ìi]5oÚÖ ÍƒÖö ‹)uGw¼ô?{„àüJ*ÿVSlŽo¥’z{ÊÆÆw8bF|‚r? ÕPEN ¸µœn€$€ØðV`oú/~5]Sã¦î·nÔÌ<§FGmÒS0Çjý¬ÂÂMûLbª-ø€yÁ4%.Š@a ¢dn…ÞŒovŠ€w'.ƒƒ7ƒúóx{æqà–Ë×–(©ò!Žõ…WY ÆB?cöj”j„#lã5à{=rõÆ–xIDgV—´£½vMÊF(\îPåjçÃYþE}@—ç†>$k@ð$Âd‹,h; €h9`ïv#';eƒ2 "Y¤Uç͘ "ŽÍÒÚöŽÕöV-¯J@ÿ”¡/yëV„/VBÑTpØ4M[p5²#6Š9þƲF$97Èf®õý ð7WÂ,W xÓYV Œj¨mâo2§\ÀãbñsãÇ<æG9Ç,˜¶S(„_'lR| € (Ü"eŽJ&™ ‹À2¤ÀÑ=Û3˜Õ¸2‚Þ.CxÏ2âØFÖ‘K˶VA¯JXõ˜cñjšù­ÊÙ[x§É:¢˜Cz˜#WÇcÆ’/!n"½:‚7«¬#D´ ÚåÒã©*ÎC«{Ö4*ï=`n º_–øÇG+¶¢PD&sàˆµ˜‹éb¢d8#3K¥ Ø=ÿ5cUƒf.£ B=Äj°i'ÒtåŽ WÛš7…ŽƒnK9°Çù~F\vÈ#ô5 *”Yzœcm—  f¬´Õ™{ZV‰rxDvwM%Ì·mÔ„Fx¤ÅÙJåÓÁ[¬FK‘ãƒ3 Ñ.àÕ{X^Ó€5\”cš)Ë%©jš€nù®\ö[œ 4à.bÆNq0ÿ|BV€÷ØK"þt˜:WØA”;¸¸µm –ø‹fçpüE‰-œ”]hóJv3~C‰pç·½çéÐ{ÛÚz›X¬ûÝ›>aŸ¾#Œ/¼±ÔêÕvHÐ2Ô±?ʃ=xì¢9à$É)µ ƒ¦Q]’x¿¹Êy æ¶´»Üî7 èËsÕŒ À ¾WÙ¤#Mw:ÊPƒ}ª‹½œÒ…º¿=„ât¥½'öC{>G³tŒQÿ±;¢…ÀN¢¸p!¢HU }¨úçãÄK!J,RÑG¯Š:˜ø×¤ LxøÇèß¼óJ¨”( yÿÿbþ£7E‰óþX2s‰Ä{K„ú”'Ï({4…Þã@€Ã¿¨«.%PµªT©Y%6ùG´…PyôäÝûÇè?Ænþ3æŠcgÿ51¦Aƒ½öòñ±‚AÅ7þýX¡â ‰%2Þr×6lX°`„>‰ü6ÿ˧è|¤C#ú×9´>Dú<ï¥çSb‹Š° :q’ w®Ýùîåû×Áƒ»s\!CŒ³Fü×\bĈE|áò#È“ÿ¸«d4ïÏð,þ•/„…=ðHUž`q") £U“Å öß³X¡B€VuÕÕÕYøMVÑ~-œÐB6±Ä\'´¡Aÿ ƨ… tA¸^ô@á„=lÆÀ ¶À?)FÙ,fd?DfAW3ªø œVhüH”Ïg­I´ZEªå=8ÕĤ’ô„PP.ÿHù‹D.HT%/¿ðÂK/Ex©J/Ëa„Ü– AÇtmôO/žX§DoJÔ¼xàQHº÷KïùÔÒ Œ|ÞLõ$ž~3•T£FuO]IÝCÕT ÀÕ“=µ§Wò4ñÓ‚ –kåeL mØÓF[_u¨Aˆ| Â&VTØ?’E"¯” ce3.v£d”y¢âŽFrVUgU¥šh¤Ùã$N³=E>|ÖÛAÿ îÿ/Eˆ+®˜ª\¢ŠâþËÿ$§uÒU„‘¼õV7/GÜôQI'1ÂÒJ( ‘K¥Dè<óÐôÏN21É£=ji]ûˆV€—VÚiÇú-¨ƒKœ%Õ=³¥ŠW…xaØ–~wi Â¶øåî &¦xÃ3Bæ¢D{d‰I&ã¯' ¦Y¤ äg¤5ÍÙfO?ýAŸ]­´ÒSz;%oÞj)‚¸ ýÃP/5v»ï*„/tfÓ çÛ>L÷QX! 阔±©D@áÊæ&“”k}.tgùJUT¦Õ-¡ ¥ØÜ1rµ˜A&hÂòÝ‹V$4ŸËx9"ü­¦¥f4Îò i~Ô<é iiù¨^önâ„Üf‰ØË‡ œ>ôÑë]ìú‡™Ôdê@¤mÏÉJìÑ“»áÉ$Ý™Àzb°‚…±' KIÿV¶•Ì'&H™µ²”ÄÀT?ÑØ}*¢© :âS4K^Bp‚¯”ì. BÙ[,„: |¥ ޏ ŠxU™Ä$fg'ªÊ‹.#]ý,EqWÇDã,¨%ïiË‚ž>@“­(@©6´,ˆö r^¸@8¿›ÀVÅ^Jq2l3[}@SºqÑÎHN²‰ð$pTEàÓðä$63iQÔRJÝfë#~,(‘ þc –¬ˆ<Œ!”Ðà ¢Ê=š`¡|¢ì.šK‡˜qAB`&“‡áÙe ŠPǸ¨2†ÁÝ?<±ÁÜÀž‘´DSѬL-zõ!i²‚›(© k¹ = ÿRƒ| !i—ÒfÊ*¾‹ÂW«Â€ŒB_ݹxVÍ0–'ŽïAJPöž?±à›*Ù `ƒŸˆ+—‹”T¢B´Ó+Õ”H…À•»´ /MÐ]þ!cxÐ’(L"à 9&“8ÂQ ?ÉP]eE0üØ–&Óæá0kWëhiž¶(¹%‰H\¢·u¥(î²*-]©ÚLIÓNÕK"öPcVìæFü4Œ(1|ÊC0¤Èƒ'¢ ONâs1ú¤, 4=N²%P¬]!·J0c<Õ'‰|Ê=¤2 }µ¬ª³K;)@JÃ`æ¡)TŒ®Ý=yâ @ÞgD3™ÿÑ$¯+ª\ÖÓ¢Ò Y­*I¼M>Ðû­oéò¥ìú¥»ÀW‘–ÚW"™%&D|àÝòüãAÝLB`ýUä.iM`‚í©5¡I{d;qâ¶œ#Cg #¸U‰ÜV¤`QʪV»XH­+óg;EqƒV´1: ]u增ùκ¤ä.w=ð#a4È)¯Öª²­©‘ff±ÔV. à„¦]©¾dÒå/å{eéé²¾TìosÌWJDΆ´Ìª xBàFþ•‡a×´0Oè§?]˜a „Šq'›©¤¥.Kù£VÛ)”–ýƒôá Rü–»¼ŒBðôæZá³$Fg”~!B£;´õÿìÛÍîp¤wÅjM#¢Òž8ùnÉŠ¼(_ù´4_ùÄ.Ȭ—[Í¥úò"] ÈGxþŽ ¤Œö<èl“@Ò¤Éx´ižøTÅ)]I‹O„rJ]5Ë#Õ?4gÉxÒc¬*1•ëb¡ZÈ+x4‹- ·¶‚W7RcFù½Y’©1¸;Á|ƯÛ‹=ö"we3WÒÇ•"»¶„”|®^Û2[ëwÅcÖµÞïI˜³e5a¤,«ö?&Ð~Ø %!UØq6¡‰ÂXÎù¸Si)ʵ ôaÆåÏD® §ó€@Oþ TäࢠvH !L@Ù,À¼Ì€8|RM@z¨ù±©õÿ»¡×m!2ÿPI¯÷Ã@:M@{›³1†{ó&i3",'BJ)ô;Ñ3E9"p@63ÈWƒKcëUQ çpˆp_;¨ acqÁ}„Þ~à§™eGxæg_\¢KDöÀz ÓÁvr@`„¢ZÀF`€ø§ÊÆ8C€¦0¿Ö7޲)ö” Âä8`1†–ÔUøAvP›ðóÖ‡†±I i•cƒA)ŸÀgo …,‘3Üuˆà] §pîÈ[Ê|QPƒW‰Yc ª´Ð#}·•ï6aJø%}Ò³/¸¦ŠW“qnÉ)÷À`Ñjc’€’ÀV®ðyÙI³ Ũ.*ô™ €1ú®ð!‹H!`>'z{HWåa´…Nó ªú ˆ€|è—)šª·çP’Á"ÙU`òGÿyäu5Rc+!uph÷°JV¯”k¦¾j¦Ðòº4§½IEåÇ.ù`*%S;¢Ñв ‚[¢1›³–³Œ: £2š@Ë…Y®,€æaa“³ X•ĹíôN›v}‹Ã÷…!*z{ou#Ø¥"…Ø,ñ·v(A[ª5ö‘˜»ÿR¼‹»‘¼ WdX£¶Ðç4¬43ÚâD°ql9§Ý!üàåU :ò€Ã(—1¸ƒ ¨æñÙP‰z³ˆê™ÿ Á­2Ú³õ0®pä:¹c˜2“óO ¯ÁN[ÕJ'ºWX¬A`!À¹ÿŸ~èIz•6ô#¶” 5¸[ÀóÇ»[[º»¸k5MTÙeVeá3#I4"Wó#ÉJxÊÊ-gN§0é[x™9%©xÿ€’‰Y®r¾é‹¾õ&Dl¾íkHð¾®à~/€Bg1Ôvz–Äûë1XÀ¡Zš”É6¯Ð‡ó–|9|ƒ‘+<"¼È˜ƒd_œ°¼Ë¸ë»tœXj·Ç¸;¶Ô’$J%Ô2R'õXQ˜Kƒ÷I83ú°-´æô:Pá[9°û`Éy™G0—î—œ9#Dœ³è[u¤œ¨2úõ £?K®8ŠRlÿù!¸9hI¶¼Å“Aó àË{Ô7óú0T«IÀ2¾Yr-a(âɃòJòw5»Û»¹û$Ô°¡$7‘$~ìá|t¦B΢¢QV#ù`7ƒ$#¢Kx)‘r9²qÏ—¬—<l%À²%P­Y1Ê©\o¨\ à³CPi˜Ø»ùabÖfI^°Ë¡ÊGÌÈ!0+ ®ÿ°‘+¤$p D¹1w˜‡y‹ÓÀMÌÆü ú ‹Æ"š–+Þ%”{â;:L /§PQ}qÁÔ‚»ót´$UAf×ö1Â!cE«"í% ·‘¼U1nh1ÏN-ΙÏQ-;\0Ó:’‚]ýÕYѸ«ì ®€˜áy“£Ö´üÖ¿-20mÔ¶€!€‹Óµ3Öcc'ò‡r”k¸Ûl;¼«ÉÁ¿Ù…£K2;½€ãÓ ÔFGG7OJbp‡ÎKÓbQÚ¬'Ø–ÝTmzyA ©Vø7©¨BŸ¬\ÖÉÊ ÿ´OŒ£Ò|Ü Î9E![DñT׵ÇÓÅÌht ¨ Õ˜œÚ%ðð,伎}sâ“-M ²‰ãÓÂ%\y‘ªrÞ…ƒ^/xjõgÑ ã[1{ÉéáâûÔ0‡t™äéûßAÊa]õи í `ѪÛØÒìé࿺:‘!!U»ð—7p##½7(ÝnEîœG ¼ÏBd_Ü|ö`Tny6 Âa"ƒmð$å„Ortÿ°*ç"¯Èfò@9`ÉDn¸”NÕ@+¢_MÄ髸ê›R¾¾µ=åt)¹s9‡@š].ºkð®%sÿ\GGÌS›{…‘+U8Xa­Þæ“þÔ0ù AâÒUñ°mÌ»{l˾$<Ýâ³aØV?1í¢²nJ²-!Ðô VEÁ¢2ŒcÏ÷]÷ ÕDž"Ùx‰KŸLžÊêûî¢Nê¾Êa$€˜GÀ8˜³鬾Ëi!ðC!|ðx}ȵÝçþÔ?éS1¸¨ 5q\‰‘8Ç–1ÀÍ7ç9yÖUñA0*'h¦Âݪ~îâ³sIA¾.¾ô­ÚyÉ™lNÎó¦|Ä뛨µ]µÍÊVþ¹=Œ…M@*)¸Üž7Ùàœ²goH>ÑQ›ÿÀ¾BÍŒp 6ÕïëF,`ñ0=¡1X]º¥MÇæñÀ,-–šÑ* ÃYN ç--Pr ³§ÿNÕ5ÉÕù-©.ñé]M¾ï.ôB/nå>,’8:Œ#yIž‡ªgQç`ÜÙZÆVI~é]!Øpƽ…Î×¥Áë$`„ )×}ÔGlfMPÞ*ŸÞNp[âÑûfyåÊ…Ïôñ…_9€'Ûèûßê­ï.£¬,ô m>|—’‹Ã8cˆyRo‡DÚå\Á·Xl(g©ý½e‘’^ßY1ÕûdÁïß@ÿò}È7ÿpà{öþÑ£7OÃC…'–Tü'o‰Æ%-–œh2ÐX‹*¶¨¡…†òþ±wäÞ˜GäPˆóŸN… (Üg$†©@ý—ªç@ þ9í™ žT¨õþ¹2€5HY¼(ñâß‘#Ë]šVíZ.kݾ…Wí½&M.žø7‚„C´êÙŠ‚Âe—ÙÇ§ÎæIÐY_A…üô L˜ðÃ?{!æ8ãGxM+lqÂØ @Dé„ejy,l»$›qZÅÿöñ6’©Â£I™®µ*u`ÕV³n}q@,ØbÇ*D+÷­€%tïi~àÿ8Üãpþ_ÿy-\BàÁ£¯ß!ÿZPxáÞ9Êûæi§‚úÇ1„ôIè²DDŸ Ò:ˆ!Κ'¢RÛ/Ã>ÚC…èqžñ 6ÊÈ+—n"à[Ì©§ßrHl Ÿ, ?µtŒj¹äªÊ€«þÙ*¬(Á¬#ˆB‹ñ–zâ"…¾{²Ê¸8øç»Z`A!ø\hˆ¦z¢à‚ ’ˆ€cs§Å0g‚ [ð(³3ƒ²çƒ8£ç!‰$:¤ÓHÚ¯PþZ1' €ˆžŒqÉ%³þAë²ÈB §àj\ŠFQÝRêׂê)…œ«Ç¬ 8àÈÎÄ€€ÿ þYÃJ…ÎK/K_‡H€ÿλ§½Œ^hA¬ þ‘o VþÂO0Cô(»näÍE0¯Ë Yj²ËîDÈ |âì3Š z(PE)J¤@C( Ÿ "± ¥ËR –øŸÂz 5±Ÿ¸í ?£J5U¼TrUÈ­‚8àYƒƒx«0À ¼°ò5Í™ÿÞ‚¡×ð8  ‰{HR¶Kg³ª§¾§îë \ÿy`->âÿæ™3-#HD,›,OÌÖݬ!Ï(z7Þ”V(_þqa_'L¯J"`Sà ëIÔ6Ì1œöQª¸¥N Ï)«êáûÕg5ÆøÙŒ¡ûÓÿžøGÒZ|¾{üd,§ü'‰µzÅò•çUc±\Ãå¥/ïX5]jVë¬ Â¬Z°#ÒpÞØÌá\EeáƒÈò©`éË©S s'KHÝuó‰BBw²'P½æçkâ(%Dù ¸¬²lË–(5ã­§à‚ƒ o¸ šx V2@ÈhÝêÈ œÉ\Bïq˜Í›ÓÔ“ºÐe !‘•²„¥*e¿ú‡A,­Ì<É’Ç ôT‡uÈ™´x cȶp‡©#ÌMòAòË0m N+ž>.£ ždÆ }òŒgž÷D¸€" ôÿñµ× ÄDóRHL^òë,©h‡î@õ·€@}àÑYΆÀ7…àOpösVxP8² ði‚–@€Ìk \ IB™Élw|#$(ÁR°XdàãÚÃÁ„@>†q@Æ\7ú4¬„$芋d„“ÅMû#¥Õ)Oxºáx¨„äãOÉ3È ¤^ˆÀ.ÐG<\z´!{­¡Üþ0•¶aZAKËD·¸Ý­aU¢JsÆØWÔVòƒU›3WqlIp¤£äèXÈ_a)$Äc ¨@¢Ç™ƒà—"Hó¨é÷xþ¦5*$’›æ_œrŸÿ$À„ÚÚVp4…BA½K¹`©¨Ùi‡;4e,ã‚'~äãkÛ@D³”%™,'ýÖu tR ð¤MŠÎŽNõÅ·¤*Uï[ 6¹i•!¸*, +éÔBOôô iB ôxÀ,}X&K‹<Rd@=pšÇ>[1­!à/VGr]˜ªTLë?ÑáxR:y|2É[ZODãY£íÉ×ô!‚êYf—yM T2îÍñ¤þ ZûãÒ¶õç7èYMU·åT<í[Õ6Át?ø-…o p l²«¥„3Žp &j•Ôõð‘|·ÝUîi×¥hevXJUôkAμþaŒ²·%9q/Û0Õ›™¯'!Tô›qUS±lO`·MÏö Ré)WÒTžC8XG½ð…&bá ‘=ÿMàÀj×cÔ¥²'"›ã=ˆâ’ħ> à™AÇ -…ÐÑÕ*« Á³mŸÌKt1³Ê‚X—ˆ8$^‚tÈãrYÔ a¬`=T(Ñ´DMîÅ #d2L@º#Ž3Ù‡ÿ.§)4]•T0•z ›bK9p4§âŠ X:Æj°ƒE%âe%8/Rél?2u=!¹cŸÓt« Zª“O}J¬*2Öƒ®jŽAU5À8lcnÔ’ƒ¶®ëAQËeDà44Hj ên‘“·]½ª R=™¶ …47&w-²8Ú¾•+dîä'NnTêóôå`¥jbR•ðL`†3ŒeÚ³ûi³s´ÇxígBð'Í?Ñ^ ™¾å^ÁˆÆÙá{OŒ–Ø´x?<ò­Þø–MZþ³ñ’[ÿÆLÜ–ØDY˜Æ÷¼KÅDâü…üÈNõ«'0“‡™yA›*Ôà èÖ3Àø>À“:ô;4Áh6r¯é3PÊ‹h¥ò!êÊ“1—:Ù® ˆ(`žp‚?)/‰ž'2‰ 1&š¾\ªìÀ½P˜‚颈ñÁ§ð/ù9’òK‹©³6åð‘"ì ßrˆ¿ÒÉœö‡-™³^BÁ{›HA{Šª{ê¿ÃÈÔËÒŠ®Ösаô-qŠúH•ûÛƒ‘ꫯ´`¸qñÀáÃ!L¸Rª“͈%Ï(/@i¾æFx‰ï9&ÙAbÿ: …è8Nr ö1/ûÁÆ?kÂÂ6“ˆÄ뛽‰&ÆC6k ™…‘¶dA  ,×°‡(HDæ ¥ ·ÿ‹­4™#*j$ŽÉ€í[ Á€[aC¦¨ÚQB0ÂØ¨¾L±Àµ Š{˜:ɦ)ãùÆUB¾Ë(¥Ìˆ‚?tÄšµpz`„.™"³(C…ø&ïI“*»»^›˜1áÇþRŽñˆH!…H¼#œ7hT¹ô#¶‡Ü꼕XG\¸uQÙÅý» n«‹qJ“€?)œ˜¼Ø\C¿0•ø;ßj¼0Qˆûp…³H©ÈzMâ à á‹‚€ÿ«(€[¨Ñ¨¥ø {p”Fê zhA®é‰@i¾¯@“¢1•Z›ÜÉ~tŠ_£)ñ«Z±•Á[´¨°ÀK?#®¯$ŠÔkîÙ¹)'HËGÁÅ×è¼s‚'ÖªÂb‘ yà ˆÂÝØ–“®T)•/ú‘­¤€'´A•ÁÊO€ ˜‡Èè :ù‡‹s±¡Y"A…p%‡p¥èŒèqD…¸š`—)³>·è®ëËòÄ_ë5/J —<±X Ëæ(ÈÀ»©y3ËÌŠ·zàà ‹ËT,0A°ù‡\ /ÁK óÁ ’˼Lë°¯ZÛÝÿò‹û8.¦¿gšùH©´!ŠÂÉÛÇRêLùÉäO«+·0GDˆ ê ¼4J…pˆ‡“!Š$™>ÛÔ±Íþê2_ëµgjö‘Šl NÀ#Ë•ë©c¶|šD¬¸Ü'Òt\85ú‡(x»:ë¼…ï,| !ˆjĵПÐô\Æ¢ø»žCšÀ±X±Ð4 6ƒ1zá!žë Á±#ĉ:ˆ†`P-¯<ÐÎè Õè>®3ŒA&ž*_³® •õ È®¨¼ñÐß<[Èe¿VDKªðQ€}RÇzež|È…¿ÿ ©/u§ì¼[쌭 ht‹ñšؽ¡À€ôì ¦hˆéÄC«¬ii¶ˆ8²ú  `q—ù7ƒ… TB8ÌØŒ…ž ,ÔÜ'>i¤y° ›š*ŠLìðåŠÒI¼®˜n] _è dð`@†¯Ú¯¨ kNs]´” 6TX>GEGGMÁ(0Á\è®#£Nƒ°Îä‘”!Í|h5¹ÌBÓå o% £1Ýé˜×ñ-Ù184N ¨‡¸»•¦ á¸b 2²;Šš+3—nœ?Q¾FRJ€5Ê‘«I‘, 4©V'¥ÇLécÿ2Œ¯ò…*¡•ΚmÂÉ+U øÓ«PÂá$È–k<ßôÑPÔFJÁÊ׉Z"Â%u™Q\DÁéÜ¡‡gËÀœù±•lR¡x€ê`4ß\ŠuÛJÐ:&îëØJ;)\€#Ét _]ì’«`¥ …ã!¤\ˆ†pšeÔ´@ˆØ m£#(Ë‹y´ÛA „ò»@†´]ׯd@`p‹X ZdàÖZXŠ3û‘#|F$œÃb´…h${íŒÌ/½ÚÚÁ¥¿rÔ(ã!Ø6KU¾˜Zô|65ûzIꋪsÏ]»V8( š±Äzµ†…ЬJšÑÄOkoÿìÆ\8¥ô“ÔDÄ|0Óu¥}é ¶!ÏK$©P¹‰žE¨€]·]…(ÝãT‹pÅ€Q0‚Z°MÌb9½9³—ŒÃ ˆ?‘ÜÎhž¬Õ5ÄËÐ+³ûš†›¨¸h3ħ0±Šg!®XdŠêp¿ø ûŽ7T¸ÉëÜ̵8kÔ;y˜ß[ àIù4­Œá»!¾Èqì¤ ø…Kæ›)ÖÀ Q؃ÁŽúÝÜ“1šN‰‹ZèŠÿÍ©p!1Wsí ]|ø‡Qv3刖Í8Í[L‹%Jµ0;K^ì2»‚#áË€ø“Ýâ×!êX’]!Éÿ¸• 0Ũ .£:ÐêŠi.ÍÝ ¢ø¦Â}šr¼Œ,5_¹Ê“óÌ‹¥‰J—…ðŒæ£_Vâšêc¡ì`›þ­Õñ µð…ðÖð^^‹ … ]žã—$ËtcbœQ̈‚]ú+êt82þcëI‹óΪ’€’Þ [±4\CÏסÃ$M€Á0¨ tÓȹé“9( p«ÈÒŸ V´®oÌR»bÔtV‡HÍfEJÅõ)B‹oÂÙ­UؼÝž`Ðu‹ÖUˆŒFæ´àVd8àŽ˪ð¯J®¬¾ ÌêÜŒ»œfšÔ ¸?äøã¥d~ ÛÑAÀ½#Œ©L"ûêŠèØ&NTIU¡<®{5) æB!d"€HüÞ@åÖ±{SúO<¥VJEü! d—xä”-F“ Á=­Êž°è'ac«‡a¢•ä÷+0 ©cU¹TÑ-&>YÊf°ÑæÄæW…(Æ^XÐ’™œ0‰$p•?¥Æl‘äé ¡öi ÀH€f›Ì}èádŽå7&ærÑÒ´ \ã“¥·°bMž`ˆ‰ò°ÐŠöìþ îþ !ù ÿ,éÿÿ H° ÁƒþkuC ¡†* üPáÁ|ìe¬8P"¢ˆ"ލ@rÄ¿ÿðmÀ'ð‚AFöì}°÷Oÿx&ù5Tȳ§ÏŸ@ƒ J´¨Ñ£o ¡ðOâ?‹2ƒæã‡±)?{š&½áôÖ?Fa‚¥8°ÀþíL¹©Û·pãÊ+÷¡@‹`ÿÑÜû/FA*þ¥3fF*4\À@"£^2šüAD&iþ£ô¯í? +éŠMº´éµRò´6={®c ¤§—0”* üƒb/p~,àêTžÀ'ü¾„ðO¢ËüLþ[ ÐK•*OŸî ½»wƒ£P²ÿL6ï¼ô^ÓÖLwñ°µA{Kä±ø'o‰@, ÷så12e¥g€†u߉æÜýcK„F¨”@ü ¤AiѤo‚ÝO|&P(Љyrß òôwÏ~Æù§ß %Ì3ŽOIÀTOm—Ð(ÿ™¡O dKG6Y”‘qÅO‰ Då@ö¼—Ö`„ÅcŠ& 4á@'àrKèŸ@ýý“¦€óðH™!ÏUð\gBXÀ>ãe‡.|:‰;”Æ?0`‹' ¥ãÉäÁ@ZÜô¥Se™åh·œðO§H"äAD Ö?ˆt(?ñ¼˜  ÿ‡œ11hC`'Æ£› ºBÑë@*ôVkržöõ57r“AðAe–y¶§@Òþt.‚ª(PÝð„Â?9ðTÀ¦= 1[ìA¢Ö"*xø9ª¼EЊ@©$ì K,qÏ?÷,пòÄMºéö1ÆfS`ÿœ`̺ó+P~§œŒÌóìf) 1^h×±+P¼ÿ`›-Opt ÇÊ9”rû°O,"ê»ñîŒÐ?Ü‹ˆ0!2?fÊêï@÷GMŸ@S`*ì?°îVSÄ»9PÍòx cŒK”\œóÈS‚Em ä@mUkò¨0× ” ?yA§é¦ÿôn»~£VdÎø¸oαJ†HÁ<,„p´ üæ·ÄÿìS ,ü;Ô,Ì“ÄAa5éX/l°€­é5Ai 4Ïòx<Ý?"ã#Dâª)D¸ÝÀÓ%Cߟ¸¼F>xJó ¹ø |ÍóL¥A~ÆÑ~#Šm°A'`îù?`°ýL64"ê6ݪÂÁr ;ÀüeN# 1Š'ÝüŸ,”P žÝB¬tùy!Rjüv"°:ùÁ $• „`¯™G~2—œ ‚:ÿˆ²"`N €s,‚º…Ym ÈÙØ?èáÀ¤oëÀœ6#öìNw%3HÿÿŠä¿Ñ(Ë2Öñ ÷¿ÞùŒgy—,0Á¢`ü‹ÍøSFÜ`¦ªH X`¨$ÀŸElb ×ÄVÿ˜ÇÆN`«ȱ&t”cüêw#xêŒÂ„ØD"ŽGeGL¤PìǾ0qgtK\-P¶ÀäY'†XÖLr´lÑJ!ä #X€9þÉÀ=˜c¬6„ޱ÷˜Äƒ¸1FzYËg„D7z[,A¤"‡ ¡lp£H !ù®“=ˆOÑ›áû6eíç  @Jð9 ܃Éþ‘ÂX„6üzáÄÒW¬Zñ¨&~Ù˜<±4ìm¯#П÷¤ÿ§úOH>#H$‰IPäaGþTf$úÈÏüc„{ÝqâøEDLà}8Á‰B`œá"ÀÚ`²°Wnmk°´•çAºX¤6œ#ØôñÜ›¦ªÎ@{'PÕ² @H$–EüDñdôeuÆ'LÆÉVk؉<%£¨äèÓÆéQô¨åjå¡Z™uD:º£ Ÿò›ðCU´hZ)Ù4„ zC¨ DeˆüiP˜iÁ&´¡MOÿw8¦:ð˜ËûÌœF+›¼QŒa„Ó8úMžh5<‚¥@`¥õ 0,ÝX°¤¤ê9ùø@>}ÿTÀ¶2щ@Lµ’!q>Åۨ¸d°ÉÌè!öðuy ,Ò$ß…Œ(Ž"%€ZØü¢›øÈ.£áÀçB4ÖnjdM]m°˜˜¬v†„á?h*,`n-MfûZ§Ÿ»ó©?yÊ<Õ`KoÈ5ÞVÆ沆Íœ.yéO\ =ÃŽ®{,D*ˆMÆ'ñ„«ä%`åð‘†ôS5HÆ]ÿ„) ÐB4a¨ªBèÀ(w.öVˆ_^“Ú0³yÑ– ×å`Cÿ³‡Ž– ±(,0÷àÀªK ÎqÊÜ )”=Òò0ƒ„(-|îÐk*‚‚ˆ  ø‡®B Ð#7ˆ>>B-„‰ÉMQ %“¬ )@ˆ f!‚wdÿHz¥~22TÃ'‡HH²q°¯Øû±;d—‚ü`^&€W:¶îÜÀÐZ%'ùXM¾{h -¯º¬äï­_¿ôळt^\E ÆPlÀbãù~0dfÉÂp…´ž ¹Ý?R‚JÑV …À *üÃ~0~Oõ,@Ž T˜Gp|¤yØ`|ð{4~ìBÿ$pü|ÐB7`Àÿô äÿ Â$ÀÀØè…ý &aw9Ã×¹×6’– ùƒZô÷R]²9ŸTé£P?7ÇjÀjMóx½A¼ÑVr…Á¢WúpzAïAc¯K|f4v[†@_!D¬'`Èf`Æm‘tÑ®…*´u' ¯…*®%WTSWÄžÇ 0}nõS1„ÓçøV+tx„O…ŒáZùV%A·BC¢÷><"zÀE8“4©€âÁ;?€I/ N~Ä'V* GÎÕ*nâFOó/ýâr!roIˆ4ëc ¡YÂgö+µ‘ˆ!z‰ÿ¡7¶[‹…l%“u=õzD&} à"5øwEvB|1óh?ø+pE@}#0Á!~}æoKˆt Ð!È ú&~@H…# Ó7}²g¹• PQm*Àp4ð†X@ˆ£†zÕ ?0Emø¨¤JÅ":44CupÞ1nÔ/Ë’%meŽðH#ˆñRãÂ%0D6!1x41-`šqc’c9åz-ˆ;ɦhˆ$7§rS¨Bvb'9ÆøVn„E׊Ep4˜Çpþfo5 p‘ù@˜v+Pt@Ø‹½ˆy©øæloµ…·¢±ñ>ˆuCµAR TDªÿ'€Ÿa*$°Q3~Ao½±)ñbs03Ñ’—Å"nú|6¬Bc¨/{Ó #G' •-`¡w¢ƒUw2*³;Ä;‰†‰+X_6e4d üÐ8¡ø„p°ucˆ0²5Ów4PnoµŠHSSá‹#ðŽü p©t#À &iS™§’Jhnæ–q³œy+°aTðÂL1x9€I'äQà ¢“!­âG¬²Žr¬r‘ñq”ë˜%YS˜ñVã‚5M×t]³5m´M°- ?´1>ˆ_ÒRh"wh8I‡†Âä=`_±÷Vù"qMÿñ,g7`©‚6ð|r`{Ö!ú‹ÉK›Â9mö r°{J ¯Áy«h’»Ø‹«ˆ_©²’øVc4¾Ö~íõ’{a—7F/? $<©'© j•a'2) 1!®x‘‚Ñgï‘z1ª"­l\Ó'М0ÔÊɇ²BO²ž1*Õ)$€ÒzIF`žpSØ„ƒ{fvòäùcÀ™oq3±s5õ˜1Ág㉹0`Õp T¹Š«Ø! „©HŸ   êV°%/Uy7ä~îwyàŒ ¤! "£4æyA×!©t+€¹ù@Sùæ¥BˆÀ9T ŸÑ†;qàúYÁ†úeô³7n" fÖ>ïCC°± †PÏékþuµÿ¡X- 67š¯›J’‰µ0![v‚M ah+ɳz‹5Ä QÊE̲ X—ë°è»g¡{$¦üÁµK 3sAi¸&¡©ƒy4³åŠ©²gVq¶ÑŠÆlÌp‰TT¦34A9%LJŠ'N9 =uç±\.hC+•>u¸q3¤)µáo£GˆÉ ªì¬.PÆ5FëA3![¨"dýd°ydüÌz‘´}G|;MQ H[ \Ï„ôÅ Á “¶LÙÐ*¾Y”¾™TI…5öžç–œ4œ@¼#¨LAÁ¤¨ô.xÌAÆ"zÆ;,°Alÿ;Ÿ*+¬ãt¾ac4F£„°"Gé±¥ì,FÍ F½¬"Ðg’¬Èë%[‘ÏÖi°¥lqSÚt·ž¡Œœ ­ACXŒ³‰Pã²s^¢ÓY’ËK˜/nŸuºE×&Á?jø?2yá4\%Nü í4p´.aƒKñ/žcaÓœí):¢XmµtÏA_ù ¢ðecììxÆ +°og4ÕÓ”<ÎÎq/Õ@EªdÅÅqCÄVByë;1±]Ú¡_òÝh¬Ó¯¤‘ô`5iCÁBzAS{‰o×J.k,§{šÐ#hOQ±ËUGà:bC“ÿ{1ÆAbá4ŽÍÍé4Xâgˆ`ÔëoëQzJ‡_)«o¡-ßaÆwñô@"slÎô‚J¶‚(1`n®¬‚Az/ÕcÕ'Œ“Ì`F÷€`£á×3"lDG øùPUVºÐ9qi-ôP'-7»-}1„=QÁ/#>²›Q¥Z¹Aéu›ª þ²S÷Ãçªà+à>ðH>¸ø®v~ ÐÉlkGæD£Bħ\c€àZá°îà"ÿÁì}ä9^kãA0Ë[-É!É ~ßë½ `ê§þ—ðþÎäQÚµU~”@\$´¾Ï£b*K­¡ÉS¢—‡%0mô ì8 G 3$Æì,‡Â,'„JJä=8º>MSìŒünê—`Q?õ”ð/K>ÚæÖñ›ŠMÿMÕØ©wƒʼ¥Ï‚¶uö·ßÌ%i3Ós8OvóµôCçƒÃ¤§,,Ìxž ‰øév^,ž¨äÓ«(vB®c+4Ï\õÄŒM;MÃØáÞÙÆÑñ´²ÏÿÀÎ8(øeê»shBõU¿—pêKÎ$úpAOçeÙ‚§{åDÔ;Ýiö·úû·ÚÆ ÌU‡³œ®:²nÙÜý0þ+èAOžÏ ææR5V˜¯lãÝ•ÿ6Á AÇ% Û9ã$ûÀUÿÂ:@±4² Þ;D?˜^?Ì5"Šï N_ÏaÔü¾Sÿ. øÏàAƒ”þ-@hï=zùnPÚ`PÈ?\ Ž:ÈñÇ ܨ0ᣠÚûÀ2¥=FôÍû7/Æÿø' Ç¿»KŒñ¯¯PF7Oüc±¤ð½Jï-vÊXžÜò?ü·5_>ƒùôñÛüO"+þù dáÒ¿‹¨Od½á% ‹¼úAâÿ?|ñ]Ì=4uï7 I`4s£•`ÁÚc–Þ¼y KÿwâÄy<%_çrÔûwðk8$=¨ôà +UÐ;Ñ¢:½_U2o)4†Ã¾ikmÌ}cá¿ húç¥ò²KãKT( ¡æ™l'žþùézl/ éªË0ÓgD~þÑÇ3 mÒ,@M Ö\Ê5Ø(B„|ì±l¢ŠÊh(Ž~ügƒHš©èB`DI™þA &èúŠ½ê¬³nCì°s<.»Ôh˹Ê3h‰¨Zï*ƒÜCs¹%ÊéM{b¸*†Qzûˆ­Øúg 3ügŸƒ~Šð/9‘»I@Îkÿ æJ»êjÚÊ6Kü‡ŸASQ´…J+¡Ô`tñ"в¬lCd²³#sëÑ  hš'¡;&åÄIB+«<¡Bí°ëÎKdÁ#€§æb *ôèQ!«aßËq¥ª*sR[kP¨µnð@ä 2O„èJÔ œ3¨ÉHuÔÂÄ|2ÏBh[€®ªFDDÓƒR,b…Ù"íÅ¡N3 „ú¶ØR¤'U~XŸC…—Üd5H8ƒ Àé!]uá/­3О²ÃŽÃdc&jq?×EOˆÉ–©Ã´8)YVërYÕ¢È ÇEi‚R¹„,¶"€Hêš©P« “i§¡ÿU¬4jNi¶¢ŽãŽh;+Äj¨LÛd,^“¾$*œKñd¢¾ÅÍì}¯`¹,UxpªnªHéß0èMÚysMfúu[šßîÝAD"K®I£,çͼ‰Cƒ@ Ű® Òº{«; Á8ò· k‚擽«¸ 'Б œ½¡‡Ø³’‚›µFqž,¡£!â……óC0;óЬQ—ꢹ FŒæ‘¯ ) R’øýúÿò¯½*¶¹Ñˆã#Š]B©‡Ñ%ƃ©õa?„¸©|`Ô¸ŽáÆ’‘輘ˆSz i®ß’‹äÀ¤Óš„ºkbá‰ô75Œºÿ¦ø™,ú‡6 '€¥ø‡ȇ ´‡ ¤=?„³Œk™{ÉŠËùìÈÓ³¥ Æå9Æ:Ž<ÿ2J,"¨)ÈP c; 0ïñºÁ¥W † „\ò,_J•Ó…L ŸòŽ @„“ð–Û:Œ;±ÝôÅš;눪 AÚŒùÜ— "ÚË©ö¸@>4ˆJÌô Ï$¿”J)UèÌäF=´j!¸³QÃbÙ·åñ å¡Žw4Yš‡p24«Éæ @¹àšrA¸r¼S‰ ³·Ñ³¢H¢„$?êdE# Âa©™‚˜…`œýi­i’¨€™Áì˜AX—ÎQúœÅ‚²v”“çˆR»²ŠÙY*mM»ÊRq¼  ÔIàLM©Kð1-ÐÏäÌŸt~Jÿì:Çàƒ«§¡çÀ ŠúˆГ€Ï¡ ,Qjž©™Ú´uy²š˜ üjDƒ ¿+¶Z &‚Îf3¿“£Î· 3 MN}X¾ñ¢ï,Šø'ºS2JÉò¸KUáéE(›,Ý æ°ÕÉU¶ ‘°Èq´Ìmô€œÔIñ1ˆ"¨T¸e-SESԇؙ8\™ëPLµ‘$£)>ÜГt;Û:ÄP/¡€/$9*-4,(+ (‹ •("³4¶¾;K‚$ UP…ÓN]"ÐÍJ©•cˆWP<¹i¶ÂóžÉÆÄÁ‚ÄÚƒà” dÎÏ,þÝŸÈNõÔÀÀˆæµ¼ò©Ë¢^ ¨%•¨+«ÛŠýKZÍ0Äu›KQÓY:YLâÌ|›œ¥¡€ÎÑè…ñQ¼¼IYÁ_™ýÉÙ™ê”,’鈎&5„ФèV„Ð ÄÈšPŠžD`ÿ+ÙPî½5ÅBˆrч½3;$³ÏpÔû ô=ßñ=_Y:6bÑ©˜#3ƒ0ØÞ‹‰\â›—2Š h…· Þæi¡¾dÈ!TrJÑ!&äîñTÏèÉ.OÅÉ/Šc-ÖÙ0Å“û”¡ð„eÏÙ|€ u¬_¡„H™ ‰ü (ªô‹n7âq§|œÄ먻ÅÚ±;*”hW< @ß0Ëæ½_}è—|øaû gñõÝð#dɇXáƒ=X Ð`ˆûÉ[4ˆ"µÿC¤.Ì­Æ@ŒœÐ¾u[¶¥öíT)ØõýIðÉ2[Y~\ˆ\ÿ5£hßÐÆ!Ó˜åÌ ÜÜ ÉχˆÒöú øTDÌÓ €‰…¡0‚= Žê(]Þ”H‰Ä „@_ôHCÞDŽ ‰A_øƒaHvÔC„žè ̃¸µ†Šƒ( Ì âÅEÌ4åKñ Ídë!VzŸù-‚à¥ß¢Ð›Kð„ˆŸ"È\‡0Ä­ñåüÙ‘ž E„ša†Í¤* :£ŠòÞS¬½àÕêí³ý ñ\^hXáÈhŸ‡Ž0¤êVêð%gDø…lŒ‚u–¡êˆÄ°à›ï€G-UÕ¡ÿvCr#ë! ·QSãv_Qa-âE^ 9ºneéV&nB»¼_*­ÓH©Ì½e¹ëSšÓË©­v™ß )¹(,€8NsÒ¿ä½( ŽûEÝæðUQ}êÎþìeòììxª m a竈£`ê\ êÈ íhlØ» Ë[€( ï°»¯:7’XóØd½ŒK<ˆ)‘‚VSQ.qñɆFgMåâ-ÖÁƒÜ¥îØˆÜØ˜Ü!y-Ð’e›º²¸ŠjypQ‹;bZ±€k’¥nåK¬‡J7æÓ ‘¯ò ë“Ú<ä‚îòå-}ó4I“ šÿÆ€/ƒ@ðQíð½åk‚y ðÑnFØž ë©ïè †°TµäüpšÁÓ¢ÉÏFùa}Xhϰ”ÐDˆ#F‘¡ ¼Ù ëÁë4Ãq¡ÐëÉÝnðqO¸›¥j—$òØ‘Žð~—ôYD ÞÈê©#ðÓQÛ'øÚ(±\jÌF È‘‰ ‘ ö‹FÒ¶²Øq@5iåUílÔˆ(À@yàÈ€ñs÷ø zØ"±€‰<ŠŠR¸àÞ êBõÈÊ–®€¥lâ)ñå‡Ì圴w$>âî‰èƒPÙºÓ+Òñƒ S21íëýÅe • ÉœuØüY%wµÿ<'9¤ h'ÁJ¾÷ô‹Z,A•hDãô—ðg¡Nùå­Æ•‡Ža"Ñn } éjTêÀEˆuVŒß zèæ´•=ËS" xdq/Õa n)Oò`>ëëöÌ Üxøa?Y´â1gTÎÉ~è· Þ è‰xOç%½.ø×ëøùL¡ ö`̘Œèv±€ÊSªíÙ'3@qiga  Oâ¡Ô–ýZmGÝïå5b›–È!yp¤FrpÖ¬ŒËàòß jg't¹÷Ї•ô]Š úïø€¢«7¼Í-Ce¾U ÎÐ Í@ˆõ-nÔ]Ñ·feVeÿ.E‹î³x5­‚x:c€¾¾ ª@œ˜ Ôvé‹yc¨„ãsE؇À $¥Ø?Cµ²ù&!”èiG½æÕFê”ÈF”½§—As$¨Zaå‚È…ÙЧC; ˆ!>ü ñï_>}ÿT-XÒ 'R¬øoÿ %îÝ;Bàß‘B¹÷¯£þõšJѪ¬—¤n=èc«§KYy鳂žz,W®lñO%ËyôþÉ¡áßVÐWá`Œ‰KްOÀDĈOÿ¾M)oIã‰*é2‚iˆ""…ÿe–‹à?}ò}ÑB^‹©U¯máöž<“oÿ¥¦b L ý[¡ï½&´[¼haûC‹ Vøx1*ô *œyðÞGÙ'KY¢’E {ùM¼ÉOMžÉóáAóA§MãG¯¨Êh¯£ª¨jý*–ëT[}õX[]â‰J Zkt‚ƒÝõ ÍcÏ­üsYFÿ0ÕGˆ±MÄQd“}ÇÂ<•…ÆP"ð¦oÜ4š‘Â<©µ0AtÑ6K* wp,ÍõOr1)oýØ’\”P 5D‰ÏM4J} |Àÿ‚v&Zw"Š'Ì3Q>繉Bñu>BÁ÷ž±'}sN´ßA÷-TUU]r(t$`¼äãE¾Ùl€ýÃ\ܰaF2]ÊÈZÞMd„H°9v’‰Œ©È‚<,°dPœýCŸå‰öÏK¹HP=®Íä¯ŽÅæv(ä–\!ØÚAœ­°‚•£då´©âà ”PâœõM´ÁtdT’H˜”êAòœàBÄ”Bäd“BïÍÙSŒF-5‘Rüæ©ç~F][D€8‘ÁøU€ ’U@Ky'*d«ÔB…ôC RÁ®ÅÀKÚ½dijMƘd,,Áÿƒ¸þ…§{•7£h¢å#Ám%œvll%–x ®YtOmËÂ2PвYÖY·‚L"@»‚–”8$‘·mp#0ƒT,ve§î…)ô¦f7ÙDï{>MÄKŒÿvhQ…ªJV!l(EJå/.0èÖc‰Oúà„iLO+²+y3«°&[ÿpðÖ\ Çcº•¶ Y«jG¹osFyoè-øü–Ð…q@@ /ñ˜’lG¢œÓAN/më-±Úx/ðŠ @Ôí?øx{Ãd’ ª ™{’«áý#/BÌT€>ùÐtS><ñQùåTo Ytß~õ¸ß]3,ÿxX{’Õ„„‹-a 'hœ¥n ¹ÉäCv ¥&R%}'gÁœÄXÅ*1b ±"j†™Ñ)H´!Öí&’{@ (MRòãÜÆS4ú‰ððä©W¹˜_óþ¡-‰@Ï[Óa¹¬“ÁÈEG)ß÷(x'ôè„‚. ›ˆ•_ÄO~^ñ*Âh­"ÜÇzã[€*‚À!ŒaRÙ?œ@¹°2²¹Gër©¹D®C"‹Á<î"©ÔÌ&mÂU¯(ò2Èœ@ls‰RÍDˆßÔ,'»z ®zÄ*Ž`;C“Ǻ%…~EXÁO½ˆMi *?f,êTÜH‘n™”›þQÔ‹à‚(Ø£Wå´Èd÷¸hhr:#*ä É`gs&QÓ’zD$·Pƒÿ !oV°—I¦ò†9ÃÕAnÛf ”è¯è2—%ä%»Aݬdä´Íl¦mqڳ¸!Öò–ÐÁHbS‘be‡h.µGLäõÄxÝ)ŠWÌb­þT?© ŒYa­µ®ÅZ†å¯k‡‚jþÁ²TU*`¥V’–y¨Söøä ñÎÌÑÀÈ(ÂsKHs¹`EˆÄ&­(¿°´dTÐò&âì¯ÜJ* é6IHêhU«’3íMH_!çq"–¥È-+ÀË\±Žº*ZwÕô‡œÈ›RŸÒO¨E™ Á²ÆkNÄ*Ú¤È/±FnbD›êpÿ‚DP€9þÖe×1``ZˆîÅ«…õÆè `sL$^鸒À2‚]}ù ­hõ¤ÞÐè¼ÙhøòJ"#¯Js\Ózoœ]Õ ZèéjÙùa kh%¢ç-Œl —ÉIʦ*u¹ä ñ›Sy-å}@½– $èûME¶ ÔU`[[¬Ìv »„QlñFGÄ·åV¼L§SìÜ´¾7ÄÜ傯%PÁUOr»ÍÁ…6Ág”qå"ûf&ïBÇè}Åw}Jͽ0¹Å¿ŒdcKø¾ßýîA¸Ø¯}Û!ÏÁÇä+Rùï­4$ÞNéà ?|y€Æ0SùüÅ»8‰y|_o´¨› MB`êÉHùTÕ 4Alp j †qЖÚß¼Q£è‹I0QÄå¬Ó^HÀ_\¶ùa]‡J½έÌ_Ä tÐʬ´ êœ\­L‘ÛíHøèNG¹Ó Ô³@ÿY³ØìÅßÊE`ðÌIÌ]´©YbáDÜ@Œ™ÌÙ\ ®^uÛDÀÄKG‘MÔ¯¬×qœ\ÀÝÁd•ž<ËA¸ ªÅipÙȃº=L>0¡ÌàAY, „€]`t;ÏeÜ÷`qÐ.iË4l”d†À “!Û'jTtt_EØìŠLüPùèC–b”-VwýÃ/àž(ÙÕ,@ÌI^ôäŸýôÌŒ šÑTÉK¸–á”f„#¨Õ2TCMÕÝľ0‡W@`°9M÷Ùƒx‡pÜÃíø! ¢Æ bú(}X‚x@>ôÖ¥i MÿKÚÝÀUøÈtt–YÒ¬ ·¡â?è”Q\f4 PØ Ê©”›¤+‡±ÑJ±ðU!ð½¢êa@YMs,€üWE˜$>`„ØœÈDü’¡§¸Å„=¬•°Ä†rDJ¨I>9‰xÄd]¿ÄæÃ¥Æ¸F:ÎÆR ¢ÇETº€ ð ¢¼‘ SKÎÑ=RH ‡dÄrÍ#hTˆh@m\ E°U Ï @ h,—>\†]¥ÎBZðE!bã¥GyŠ®Ta>Ù ùE,…BTäèýƒÜàЖx‰IFô”€<˜ˆ¹<š, ièÈÉDLÀÿšxišÊj$ËùUEà/¢OUñ¡´@¸Æl‚`jP “0ILäS â¡0ÀLýƒY¶„صDUYU- À`ެ‡L9NEL_ÁFEL»tá†|À%Ñ%á1K”ÀÞùÉ2åe!"B.V„fð ÉÍ¢ ÁajÆ/@‹O¼KàíDG6Ídu ›m¡EHe…„µ=Ȩ½äAŒÆ¯‰Çz9H'ñXv˜ËNªÆD)‹y䉾¬𽠋ŦpÊælÒÆ:j¥²4‰>ä‚OHåžø‡W¨XKÊ…üSìÍB0ZÜí¬ª*tPkâ Cm^AŠ“Väm@Dp“·Xÿ#XGK¥MG¤¡šÇÏäÒ‘lV£j\ „¸ÆºÌQ0yŽERQ£ÎèþÑ­mÎ…­JeK p—ë5ÊV(Å<¦Å‘O.àœWbíqeÛZtíJqÀðÚS@^W• ªîŠ]¥ç¿î0ôÖÇ _‰ -‰©¦BÀ„ÃYK´@l¶AÄ8=8©0€C@Ä-}©dþ*_à\c¨ÉD¾—² Ä@x¦{ Ÿšðïí „à1h9 O ŽX€î'°"™ãt! :ÁNøD;T¾îµŒq£TlúŒ'ÁLõñD”AÄà²A”¥^Çð"†YáEÉÒÀkÎÂŒ$ÿäÝlTªÂKÃæ0'¬^–_µ¸¬qP„V¶„¬šrCœï·DÅ-!q¨I MºËŽ€&}ÚïšøÈDe™”| Ñ^·Çîõ^ŠMÕ [q€!s€J˜†:¦ÄÐÃÑJ%Q¨B~t…TˆÀ²$笀ŒÌLćÀT¼èñÈÃô²2NÆñXPàE2"¸gBµE8á0©ÍÍ[D,ÊÝY˜’@ V¯*6›2slDôWô qÈB[˜ŽÌpÚ EƒðÞàDùrc ‹þ–Òþz±Ï›l‰ô}Å£ÐF¤E ¼JsžõÆtoBEÃ8 )óžXø‚`ÿvµ,0F^sOž[k¡äm"ÀLæRÍŒB82¼”†¾… õýÿhÎ|§¥)±†ãHOîÉ~ˆt>|« elÌ7—ÓbF¸:s¡ŠßˆE\¥…'ðBÈfp‘ ˆòå­A<ªñ!ÐÚ¡6Q &½0‡?ÙÌÑönZIhõ:qµãøÍÒÅϨ°YÌc¥ùvKPUB@ r;>HDs'4t#.àß ¬‰ŠÌCï’áyÄÄîè Gþâd‰ÐÅšžšsŒ3E~•XlX$vZ˜…k˜ãID!TÒjú̉v˜TO~äBÐÊy–†š;MÁÅÓÄ^Ý… ,KôÝÎðþCxËa‘F Ǿš ¯b³Ô°Dþš¯5ÿì¡[j$‹™Þmw[Ÿñ1EA™­v.",¸D[ã·à_J Áx˜¤Kç)D1‘!.§ÌXƒRL@J¼À=`@‰Èƒ-«Õßé¦Só¢dE/l˜áüíÔ‰£k@Àm¢ìa‘; lÈWl³>döžäpüÅùD´BŒÖ˜’6KØ`Žl¨”¹=t„Œ¬4‹CzKÈHüDü5lÄ$°Ç­xÊtþ7_EÁ‚À/ZD+|ùÀD§ä¦/´åÝR·4¼t䦥Ë`»xÔ;ÎÅ“;iLF}¼ªY—AÄ»#ô‚H“[èR•­†æÆ*Ó³8Ó}íGmiÿ“ˆ€Lð‚åÇ?È9cŽ~UEŽeí‚ ôAp­¤ÔJi¢¸«4­ç6Šê'b¸»K$Õ„Ã"z`ÿ¥!þQí‘—ý?ð'·8Á„8ýY‰A›/À p?ðÃ4Š ‹˜wLîÐyÄXŸÆšô…Æ{|˜ ÀP–GßF}AÊ÷Þ¡ðwaöY”2!ê¾Ä?ªTù0(ðÒ¥ ú¸TÄG‘|ÿ\$dئI›½\h´×Š‚! ÿ} )Ðä¿éÑSqò˜'Ü;1o^‹òäÑû—k¤@Dú!úGdP˜%séûÐ4Ÿ¾‰KCüÓ)¯½!ò}È—oÿëDŸU}²üç3Š='ù¢LµÚÒÞ¿ö*ˆX°!BÞ ÿ,àÛ€ïŸ_À$7,(šßWÄeo"þÇï_ÔÈ]óÙ³×’^‹œô>Hpš“§<¹[϶<+W b}"Dì…0¡Cyés‰Ö(»õ¹ ÈZÄ¿"ª^ûX¨êÒÁ“Æ‹¸˜ØKáë\$Mükc¯M„>pçnQ Fÿ \yrÉ¿{$eÒÜ)ï^÷^ø4ITR¢$÷/\RŸÌ%ª”H*˪´úêŸ(>hK®(P{ A³âr‚% |Òê{ò±ëŸ6ØÀ˜ö:I¼(@¤«ùa„¸xš'.’$ûÊ«¶²'ÿzÙ*G ¶‚ G¹~”kžC00 }zs¡ˆ^T-¶äRE©nÛ’­']pA„_Š(¡)"I!…"rŽãHòíŸ_~éè{~i¤îþùî$zb8A׿!éžö` ¦ þ@¾{tŠb$üŒ2꣜?þTh:’zôI§Ó< %¶¶ÂÜȪ…V³Òê4³Šô°®òÒ«¯¿úZjƒœêñ~\à‡Å•ä™Ç$Èâ'@Åò) 2y4 Ç®tÇñD…0µ|¾sÊ„ 9Ù"ªí¶:Cˆb-Ÿ“ KÊus!„ê5J†ÆýI êèÔΘ‰‹‘A—zIÿ ôN’ÉPöåƒc«"‰Ò‡ŠRO’JŸœ"õ$VZp"®$é¶ÌtZY &š°Êª•3«3Î<¼aB±DÂL\€ŸæÑà$~Kx%·jv鉜5)ǽš+&”+®”SÌ×`«W^+‹Á©$\ Â\|#“ ì=)¡{yñV!!.F 6rùÅ:( øƒ R ÜžNRá<’þèžõHâ D‰Qˆ[X2(ü²ü'¸¥19ª¨<þÊ) '†9«:Iê”-¹TV¯‰{bÝqÇw(TçÊglåù¯¿x½!Ÿœ²*@a™•ñ•eV@'™½Tÿ*Å–êŠG­´Š‹«‰Ž ÌÖÂÝ×J„Ì›ìÞzH^¦4Î!ÿ`RH^(š¿—_Úð­'ìx$Œø€Iì!´ÄÑC'Iˆ&š¥È$†"¢e0¡hE"JÅþ¡”È)“ !XB&šylu,iÕË8 4a>-”aã`§’ÿðÈCFÑÙïöÒ3’f\"A N•¨ð‚5uj<šGè)+S + e¢¶$ÕQMi"ôV˜†ƒ¦·5Ä"³) ЇD2 Ä8i’ßBÎ$8Á öë…×¬Ó ^´¡PˆÀ µ’ücàù‡¶H22üIaŽkÏ"2¹ `%5#ÿÙ Q4¸9L5­ƒ6’@SH"!ܽ%.`qÚV2ã²ùü£…0lA —ÂÊ"’‡ù@DïB´€Ï/'Ù€ ÍЃA.˜Ô–x­ ™F™ÿãÅt(,1PÓÀ÷¥Öxm\gJÃ8›Ù¤mi¬×¿¶8þCŽqz ?’’d-&™GâþA4•¼D ,”í( ʃH"äϤ<'‘dSÈéN˜ºÓmÅU4TÌNò2Ô5¡UfQUXúc+¼ìe0Þ?¢9¡I`â\³N ±Ç¸ˆ™ÊBİ’ç$}ôc“áŠW:™­©mKaÈP-’øµ-6äÜ—ÿù ⯵Á j»_tL*ôt`c0T Nˆ³§@—È¥$0”hŽKqŽƒ˜š©æºÆnO]uÔzZð’dÔ…- Õ'­3¸e7 é~`Ä/¼,ÒZœœÎ壘K‚ ©&9 ÂĦQ¡+ƒ<ÇL9m5߸„J¥nç}Û$'Ü sß8aû{Íkx‘–´âÜ´U#{¬FC[ÉÐòy‚DÖN&…j°ûd±s û“>ø1'Y&ŒÑÌ'“•Õ'$EQ¥QÜ(I7è]Îô‚t/ã*)=Ú¢¾L‰\™ëf³ÿK N„ú¨À¥¢gÓL]22_j¸ZK/6&„q«gËÆx¢|÷HG¼v ”'7 @„+R óÜSŒ¢­¬ëu HD©Ç„§ X.8ÚÐ5»KiUáÓ8(Н¸;áâA,%Ϻº“ ÿ$KX`Â&?´P¢ƒš˜g8[V]¡. ¤£vÂ\[rˆS„{{qÞ^L´ñ-›¥ü"íñÀòùØâñîuÏ Àƒ°•(ð10߸Ïõìs'†ü#â z1Â#yê&™N^å ­¼¡rYË,ªªÑ˜¦N]ÖK_ÇF0Ì ôÖl-Hâô\@BÚ‚AH+yøƒT”´,)ê6†'Â9œ$|âÞ„ÀÐ,B8¤n(aœDðL¢ÖÈÑ^Ã7 ƒ!ÿ|‰<O&@[h$°…(îNÆ–@ïl,ÔÒCan‡Ÿvì×þá„`Í3:(@ a ?'t@çA¦Â'NÈCp¤%.§¢†­æ•º*LÃ躌‹Ùt&ø‚$JÄ/J¤¤‚Â3J5ªbIÄ-vcfçÊÇåälZBC&Ây4o‡:/W#W‚Á$-K4èPõæJ}>+ÜÈmÄ–¥´¾+Á ì7€ãˆã/¬Š€½)ìì%ld#ø8ÌJœ 9.ÒÆ¤ìGÓˆk`ê$ánPN@R¢B(=B±Ÿ…À¯"a‚ cñlO»Ê@Ö¥/uêjÿä/ _&]*Ã)íÕ¬ï •°säÖHCwÀBGêp½TÉ*|í½N¦žZ²$ @étæÄ &|ˆµz‰(Š€EHɉª®F$ÃçÀT’èÁDsÙî4¦°)$ÌZS3CïK¤9¦ä÷ä'!Êãía⌖£lá:`8+`ÿ4QuXB<êdPr)Ê$Óƒž‚œTñÕ"ãƒæêƒ¼B AŽG­h¡&ÂA< ÙÊB'ö*ftbCÖ".èPºÌ2d‰ÙëwÒÚ mXV`(À"-jÊilDYÌsº‘’,´þŒäŒ´fZ…¿vc7rAmàdUT C"\6b›†/ì Q›èÀ !öå\:@ D"Ug «Zê&äâ%Z :¡SØäg=®³=jÇ$…3þèü±@B(¦ %äAlqbÄ*¯4`¥EkLže Iê(nà IäDð“$tÜF,AIêàÏâê)ÐG,Z qš€à¨GÿP* $O_¨¦#*£$\ä…œÒDH¢8„cãg©|@Qñ cÎ8;Ñ¥¯¥X@AbŹDãÒ#_oT¡kÇVm&Ö£.,êòá dŠÂÓA¦ƒ„ü'N"-ëkÒ¢HæITÀyækpÆ–´ô±0"À(‚£cPÃ$0zzfªéòŒñð1î'yàä+PjˆbGN§5+à(ªÎ £öçˆ#\ 9:L\UѼ&~Îä7‹€Õ:@2Æbà¸:1<Ž9c¬%T@¹DÑN‚žJ±×tl¢+e€.²+4‰ŠÀ"@dŠÌÓŠüèjŒpP´‡<„€2Dÿ4$1ÁŒ¤äKWç$î+—6v2?ËYÈtªgñ†„¦Ñ²*¥lXv¥/´¾âòšT…ZCî4V%ª|é-hS—CÁ(ÞütD¹)ë<¡: MfP:qƃEKa'Æ*Ø'l×hÕær.'*ºÒ¶*¼"§:h"@n€¨È“€t¡Îó#?M]ªTí!-Ê‚¹ì¡nUg(€¾n‰0#MïdÏlºIiO@³Q˜Vc54È΀cËF@âỾ" ®0uR¥,¾$ç$B£2nhS×HPÕié(~HT ÖUje,OˆwÇ£‰k.މâõú&:ýãR(ãÿÎö$|M @%2‰G¥"j¦¦Y¨eõÚ{û‡Nƒ3 I”æBCÈ«#¾| gpNM0‚W5Û. Cü(®~­ecÏ7ê7KΔ"2tªqZät$„TË[k˨ b›Æµµ0l6€³uÉéìžÖ~âGuFƒ§we¬d û¢³„ó®vptŸ¦  ã˜W“dø$¤)5:ÆÏHÎdlÖt¤FZ‚-£T%%PÄwæk2‘&né–BjcÇ Ïî éôR* ¨²Vf-éR”Ç7dª'¶d] @)b8N·\€Ó¨¾&²‰Þ<ìÐèè5ÌÄ?^c]ý±ƒÿ0xúZ4k5±«.N`#NY:¹ÏqàCaÌjS™q:•‰Æ‚õ¨E¤Æi<#—å HvbTï®À0.Š(Ô.ÖÀlórÆ|mÅgÃgB*±àj¤QrO¢›i* CÜòl]`PÖHÓöBg"Ö‚´¬M8dó8R‚ÍE¤²îhW&-Ñ<ái©#jM¬úvR«Ù8Ocž.îvH"Øxp§×K¢``ì3Žº*r€L„(# ?æã.Å+’PšÌ|ýã%4d¹4D|ù–tf2éK ~ —ÊŒ‰—bdOOÖŽŒA¦~íÌfŠYÆM„¥£ˆcœI™rÐ6"CÁ~ÿ€3ÑÞíh÷ 8•¶8Ê."ÈÄiÿá¥õ‰¸n"B îðVnÚZL~Ã%DJ²ÛÆb4ŒÃ‚3ÑÀ²¼mAša¢±ÉÓbŒX€ÔOà8ðèÕ›H4è5§Ã%O•N yƒZ׆ú”>•ˆÀð…)GXçtXÂ`D£ x¢ä[ =²![pÇw–~»>Ïð w»D|(2Kgzn@ƒtŽÎ(¯¢Wy*+Š<“ÛçÊšÊX†cL¢$áæ2ŒÃDðD´iêOðÒ_ÃTÁÔuvéE—b¸ÂãHý$ŠWS#y¥\‘=µaDcR;î4àoBèaPÒ’è!c‡ÿÁñ» ZˆåW»ÚÂu[ |•/p‰·ågÁ¦©W„ˆEp)…Y‚ŸD.øÔ'á?}õåËç$¢“(ÿœä’1W..z©ú÷ïÒ%}€¤ä¥ —(] Òä¿^>ÿdÖLù×?pþóÐÁD >ü‹ñoÞ‰¤ó@–8Ábé?Fóšžxº„Å¿{Käè ÖgÊ{îý#ReÑ‚DköžÙ”àú4ÛDÞ¿'š‚l¢)½ª—òy‚½[A.Yr˜ ö"Áä‚7ü‹°áÇ 6€½ŸO|¥O/Èü‘¾ Sò˧ïî” ],l¸P ?†²‡‹È$A·hóü¹“-¦·Áèâׯ^0U©*¢ÊÊãÉÃ|ùòŸÉ">Šücÿ>¨BM€¬²èT¦ÿ®žð_ ,”°ŸRZAÅÂÿÈ#OWŽ5(HsÅAÿZo]8—Yhq@V„ÉÅ <Œ‰¸×<|H"b‹ *³•YKc =ÐcOùtÃ?žõ¸Ù??€4ä¦ýs¤ÿ°’j§EÀYq³ñöÏmü€”HÀ]&‚@¹  4BCÇå‚bÔ­Éf›nNÄQv¿ð{&‰çÃHè™”^LíÝY„'EtTJò •Òô0Ò—K=å“_U-•UV÷Èsé‚z9æáVÒU¡[g‰z–†Š%—\ 1؃©¦¤Á?±¶@öÓÄ=M,ÑDd7ª£>—Á¶ )ši£ )¤²Mš¦š’¦E™Ü•8å†ÛnZŽ©å¾ T¥ÿ Åý#BJQÐ#V M4ñϺ붻—›k*ÅF"ˆðÑGêù„L~ªb‹LìáÀ)}0ÁzÚÒ¡†<Ó§¦¼k ôx¥B m­Ûo;tÙe[ës–ö(æ×¦)UG~ui¤]úé_”Ë?Ù ¦{Þy‡Sz~ãtçO…ÊGhOùQE¿$ZÑËX9…Ie) Ò XD9A°,`ñN8²¶”êTŸÂÉ\ÚÆ®µ‰è¯#À®bǘ6üC2¶j×%™ï9AGü( ˆõá¥D4PÚñ„Ä´#1yGcÀk’³#ÝD/zYÒ¶ÄE.~È!Y Á?³:Zý#©úrñ 0¦¯E £Ëø‹"¤±\"“ÿŠÀ}ÅD%)Y'Ôc[¸(õ9ÜÀx2È-)I à X‚P%bûÊÂd½T esáHBE\-eñ\NÁ­((/yáËb^Ç•j€F´kÎÚõc°ègöÈÑeV@¬Î É3Ÿâñ~™’¦)«iÄ»#ºäÄÜ`é6ÁùÍô’S% 'öHÓaRB»Ùm#IŸœþ·÷¼ç;Þ© IÜó r¥qœòÃI/<ÁàáO GŸŸ˜ M‰Áäü‰˜§<… ŠÃ ©@¯lB‘¤œO"v±½…-Ÿ*]JBÙ‰O*²R‡zµ—¥h 4âÝ*ñÿ’;ä(aÊ%HŒæ£,`ͱL£´f ‰4>™Ú¬uµmem‰ÂR¦Ö’(u©!øRïÎ8“›qZcÞ¸ÎðxŽîá…¼ ÇÏ&ù#+Hx¡ Ì‡þ Ù”¨È   WÔ¯hŒ+ jÊVõ•`*“§c aßR—½n,íÒ•\sÍŰ«B\éÙ*{fŒžýg¸¢œdvW€èÈ+À¥@€!Í'¡1Ínz4g‘H ¸ã?ªV¶…DÓ‰¹Bxƒ­§ê([ yÈ?r‘ä*W#¹ˆ‚s‘[U¤Ž4ÙêUÝ#]qrUœ a{Þ)ÿÛÄc=©çN —Ÿ¤$bUiÊ<‰.ÉÉ5®•ZWT%–ÇVUœyñB²´#àTiGÆÍ’Q•‰Tç:³Ž­"âܻѫäúG:¯ª“_ xßÁ‰{h²/›á{g#¯XiFHÛa‹¨{#ÀþLÊe,¨¤(3Äê?:Y‡B¥–S‰eÏKàËì40Q.V0¢Ñ*?û¢$bêþrØ™L[š—S+øjw ÌNÉ»A™|ÒÄS_ ÕH¥ÞS#îL,QÄŠiRSËf­ããúÆ^ýêWÝS„o•ë[IînJÜãîä)O#@—ùÁG‚Õ‡ f«JT©ÿ¤$*nõy¾">ÕÝÅdKðKð;*Ž]²ßÿ>yW¤ Æàˆ“%I¿>R\5ÁgmX%ÕSÒ YºàšaûÚ.b±ñ¶f¦n%nc»ÕZ·a5H\%ÀëælÕlNÜ®Hë¸Í°zßâõœÒyVßôÚÈŠ9eR„|8$ΞÏNöi¶Èõ')1xŠ€üXÌ]4äX67–¶@&Vj.ó%_UÈùì:0ðâc£Åꊤ I¬ÆÞqï™ê7 ¥e:[ãÝàxž‘)M…ØÓ¹¯ #h¢¶’™DœUÆÆ­ÞÝb7'pÑ!¯Hâ/L¨ê$_õªä{Í“5'/W²à¸ëg³6óXWU1ÿ@üÁ # âVLñs!‚Q£CY' ‹£ ”…!´{gç<£Yy–+òB²’Y™ÕÆ|ÅGua€p§Zlç4¢i­•S¢Ð#áq¹U=W„¢e~—ÃõÚô¹Pvs7Çk÷ —rûçU¼à%wv> &2@Í68 q€W)U"ýÁH[ñ8[„ ä©ô¤£!1£fO7:n{"È6¼;²‚x-p1|æ+êÒ†+0Rv~4x,À,Ó7S–æ Ó¢,žjØ$ qðp‚-'‚'…ù …xqŠ:QrBÆUE0àÄ…8ñÿU$wrü—³Xdöp›—€8gùTP¢Wtr9 òH.sŒY&t5!”:©¤ K±`ƒåˆµBŒ‘f&(!{av¡”Y‰¨‚~@Ÿ1p“Õ7Ŝ̒iKÃK·%& wXâDÝh~F¥m&[8'\ENDGíñWõw\È…(y`Å‹²X.Áù°6!üÀè3  H óG1ï%mVÁf">eñ)J…8*qáAEuë2n .z#ߘYYç4"+0Hu°­à­ ‰ÇvG‚p–‰>ÿ`0üZÝXK>aÿgcù÷Š×‹å4?zçÔU\x‹àä?å¢Àƒ]tÒˆ@C’0Òä—#ÀðÀi’<0˜ P23z«7‹ã8«‚Qm:1‡ÒI—ãÉè‡ì;7"+6" D9 Õ6ÆÀ+èˆ3x*ëè|>ñ”(S?€bo×Zù¸v=ò<ÿ°·‘#ýFq“%gƒÙx¹1l.'G$QzbNÑÙ²¸…;¡÷F9<¹X—#)zP¶Q}I˜&ù ˜á©pq(tU‘@P3YX㈡$2Ç!HuòÀ‚7¢fÙ kP Âÿ ÿðð#“a JuД­Ð Ÿ‘S!6<¿$•óè ¶ùFô< &«V)z-`ùPAe„X¢LÊ9y+y>aNÐyy51²H...Ð&VgE'îAsá^$iPK1P˜ÿ`’0ƒˆ@U*‰цGQHG§)Þ8!$ó)ÑŸ)Ó~È"{ášg—ö¦”ê6ƒ9D$*‰®U‰>ep!zG3}@’à‘ñ°„])ÞW=„Wœ!ÐD6&“‡]½ÿPt/qÖ%‹.`œjrïA':!=á¼´Œ$É}é‹®’`iGì9ÿ £Œ¹¥”8’â0aa:da2vuž¢Iã¨tpÚo¸ é’±Jå!3Ø”Ÿ•)±v"vñ˜¡–bž¸•&h¨“¨)aœÆåT¼uw”×k’úFäTNüâ'<ú²è£@JrmUdÕùd˜²)ó€W@¹HuA9P†@ƒŠ@«PŽ©’#_…Ä@"uÒAc!2°¡“¦§’YòÐÎú¬f'‚3xvŠ¡Ì²i@‰%Ü:w½©ÖZ]Yœ2f6ÿh7FÆ5=Ýc‹ÉF÷ªá¡£õzp„V$'¤$§gÅF  F@â#¥]{ÿ +a «N­`†À—Aðÿ€Gð/PxuzÔf·˜!0ƒ_%DQ|82Òªn;€²‚g'ƒìø­ðš4I#$¼d}ùØKȳZYé›=Ñ•†jEÔô³œ»Eù ´WS~½‘,Gä‹äD©K–?/GBº…F&Oä¢ö@ˆøm‹û·À k9‰ki:ÿ à ®pCp<À¶¹ Ó+±K û‹1’¦¡2!#Ûo :¸>ñ ~(3ØŽ‰«¸â­Gb³y$¯¡CU2~Q8x-Š¿fºÞã>¢ëjÂâ !Ø%+‹«›ÿ/ßñ'Ýx¢Ur€)Q9bE?•11FqÅéÚjÌ=W²AÆF`‹g9G.¨9Ѽ°}Ÿê÷Âun¡%ð c˜Ná¶9 @eÛŽ†p¼ÇûCÿ?,œ °Â'ì v|ÇZ1™ ĵ"2!#QŒu0ÄŸÜo€ÉQÄ혡‰»¸1õ|A2S•ÖÄ>1¿ãGÿMYâ¢V䢟KxºqeQ–á¿uÛsV¨{/ ©]ÜE»£Š‹Ãü©£*—ö°1, »s»»ÿÀûÃû*LȘŒ{È© ­pÈ @Ž<HÉ/pº*Q¡2õ±kQ!g*uláÉ  €!DPž8±Âé  •PIiÔG$ àS8ÅÞ“%*ZÅ‹š¿ûk~ö°®ÙB\áÒq€¡nÔÌôÇ‹û*¤G6q<¤^eÁ2·WqÇ1=@Iÿð‹H €È§ŒÈ?<ÝÈ Ã3ì0“©ò!²¢RÁÊÉ÷ ¬üLÕÿ ,*ìÓ)ÿ¸M$5»4P2³·Õ#ÐT%<û¢ †·\Mì·ËŸ[„H¥[ÑƽÑ%Á…#&n&ठyq»Z Aª,ÍŒaÍ øAð%PÓs»¥9ÐÍ*ÌÂ)qȳ• ±È ÀÓÇ‹D}, ’ "XÚë± ò2M]‡¡SÕ± –ù`èËÕ…¬Â]S9e$øØ=âpÒT[|6aéT´¼T?Kx.ºÜ-º¿'\º5À|7ñÑ ¨¯"`rÙ¯"p€"0®ð&oÓœ»ýØT IÝ|Ù9©Pߊ¼ÙAý P(<ÚÖ, °¡ÄIgÚÿÔL-o­ýS-Û@Œµ´žúÀŽÚŽPÈíX¶×J;[7ܘ¹Œ¿Yr%ÌÅ6×T\ VTKYì>hÈ®§#3þ3ZK¸„×YºÉL6‚º:‘Iú)˜BŒùκ Ž]ŽÍÀÍâ,$ùíRÞÙ ±Îÿ€õ ¼ÐkÇ8ì2e ukñ  J“û|vkÐàgGYüµ† ˜ëIȧ bTé#Àü0ÜÅfûMiÑÕtE?‹ÅfóYœèµÄËQÀ~m­~ì§¿Á~@ö0Cq³Š&ØB:¡’úo¦ÃÇF Á›o»Þ²ÞAÀ‘NNÿ$‡üRžßö äŒÙ‹¼ßýÝß0ÚííÎ2y)e:”¤#Ž þݸIÐ k~* WáTô#É!`áv®4ÐG4=2;ÜÑ@×–¿Sò‹Îâ(®RYLè[ÄqÕTË[GïŠaï6‚ï4S㊷Xº3®ñÞN+­IÃËoû`!œêr»—5}°CùÍ,µþ›ñ?½Â  Óû}Â/œÍ/°˜n›*à í)O6¢ŠQKÕT-`’C°a8ÁÊq÷°øK" =O @-zå‰ÑÑvÅ)‘Åibœ÷îòLo#²ãn'B7™u#‹g†@ª7þÿ¦ ˆ:a»û I Ïo9€r[°$°ä|ë@}ëçÌÙö-å@ÝÈ;=®À!ÿÁ€°ª‚Q›ò’1š7"-0’¹@óî!½ù°ÅÈYj9÷p9`9WÃ\‚‰¿m_góŒ@¹zˆ7IÁ±Xíö;Ó+va)šõ¢µ„ ACÐÒÐAüü¦Ic/ög_°›¥[:åÅ_ß™ÙbÁÓòl{Œ‰°O{Ëžæh.øƒë$Õ`+D9qÚž¿`Äú#OÜ#Ý—PA:àÇðîïþ´T.:1mý³‚qm“bqâÄ¿&ÿ–ü“×ÿBÞ’&Kž0öO…='ö D)à$Ÿ“Šù è+à±Å=þ!<™ãä?ÿö­üg$†‚°yäÊT0a‚HÂçÐ!'‡$¨WÏ•« %^¼8‚!Ã? À¼7TëJf/·ÕñUìX²> kñ Á†MN„ ïß}þÝø±`Á ˜þ1úÇâÈ¿* a°¾ úø9þ—/ò¿’?ü³b%½yô`Î;‘ö_Úkå8ØP^A´'4h §‚žϘ)þ ùJi“W(lää>Ã.]yp$„˜ö)TkO± Œ*eÊ£)Ô{îݳzµìxòåÍouÔÄXAÿ‚¿;¤B_Q ˆì.€É×ïF,À·|)Àá\ÊÊ/È|’,{>XP³Ìì9 Â8£g ÿ M ·*m Zˆè5 þiƒgóÈ£ŒNøî¤„N8‚¼"Î%•¤ê…N"áŸ0€‰º€úGÈ•@°n%ë`òŸ¤\áA;ž‚λ¬:/K-·ê»{Ø[é½èi0CNâë‡øg¿)a°gœñÆ“ŒÈ` *l%¿ø±,Ÿ|ü'„èa‘COâlžyZpT Ó:¨…IÝz¨…‚Z€­#+`BM½LhyäLÉ8#ˆÛG8äÑÇNJ¨ ~Rºÿz† ©$w]Ê Ø.ª¬®¼R.—e¶,“Nz6L·Tø . Zieîjó¤J`A ðz øÇ€ÿ.~Áþy`¥«î9‚—'o™$™iþçË%":!gCì:)Ûá °†a":u¸ÿ`Еô‘KiwáMðƒ¬—{uoTƒy`ÈßÓ\tÈ!·þñŸŠè1Û¡“Z{0S3€›b 0”û‡„5RȽ…´Nº¿lÒÉ] ?Àd*c¬ :†¡üGêÏræÌ9(¨‰™mÆÐ `­´¢€tSs`ˆUÏæšÔô!¸ëK{ ÒE™¨1ȼk”£€·5”¬ÄRKPÖI`C&Úh`_.’‡•vä¶ãMhÕ[•JZ• po%Ô1Rø†´•z¤O}ÿp…ˆÿu8*ƒ©Rwð7Åó˜äYÿk†u!…V'¡À™¾åáØÉ'/É<.Ã.Æ\PvrIîng;ÏèyóÑ@0”BÔ,$4“ò¥HôA™í$J¡ÃS•;ÙP‡«c™KˆÃCèèÍ|F2ßù”„>)E)ÄJÜâžòY!FG¸U™¥¬¤s󀻂VÅ€†¸ÀÖ`µ¯ E%-¹Ì?c  ^ð10”e`b¯ß5“kÑ£…þ…š­­Ð'DÈ X°ÍµUåFfÜJ¹Ê(I<i(¹ÚНŠ¸¤|2‰A ¥ÉJÏ'öðOXe>ÅR’c}im'Ø&0—ÿ ¡V‚˜³’Æœä:  ÈÈ¥1ˆ˜Œë’ù ªM(9Éï,”¡áð$œZ‰§f"ƒ¸è$ ³ŠöÐC 44bå%ö\B¤Å|™TÒ®–ô·N‹XA8RƒÏÅ™HÕhVVŽ¥Ï¯„¥%Ñ:Ö@ZPð`WK@-A@!\ GTNª†S®Îä$HÓFÛUA¹Ó/µ ¢2Ã(þîy$ØPJ¢a¦… )á© ó€n:ÄÞ7c²ˆ‘oæL'Lç¤`ëbó,˜êT à“KÇ*Į ´äª™ó§BJ°£ ðÀBý"¶ºÈ ÙÿÔFæbkUÀ‚ÀŽ¢4æ#ÌŒRB!`DÕèáQ„¢ù£ÙôH0‹(O…Ká©ÐÚCèìH\‘%W/ï¤Þ[ï‹ã)b“¾ú¤£¾àp>:€ÝÜç€ø¶Š2ƒþ`pÔ,!YÛSæ9²zå(¼jEá‰ÖT¥W&À€p„Öí ¹]Ec\¹¼kPc›ZHÿÑ™ yÆšµñ®OJt·(ë§Ê W2ÿžn2iUß~R–¡ž/·ÝÕ' w’¤þ#©KuŸÊóÚ#ëY#ËyÅ2౬Ë%Ɇ^ЂYÉj© j-±5Öz@À½UkÄzX˜} uÿ~B.]ÝxØ© ™•‘Š5ãÍI3‘± d*¢¯:ì¥)3† “’9˜XlÅSt–'IÖùê’R8Ã-&HuòRyð”Xb ŸØ Ì%3œ7Zp„ä|ò„ûñï$OàBKÖð|®À, ËWÀˆÕZa¥ ÌIøkßxµÁ«š‡Àƒ—\3Ý K¦‚47þ©Ä%Î3‰ÑLAAhjÚ« ã´É!J-•È—:6L}€ÍìJoáË$PÅòÕÀÍå:ž$õ’ï›j|R;' ¬j]ëY;ŽÖÇþ’´Ò„¬ø:Ì–›ê•–Í™­ÀX†ÿ ²Ò‚…F‰©ŠKµWÿv”$ cuŬJç$Gh½üý\××¹ë˜ÅÌ3‚*cbÊlP.¼à…Öå‚d„3NžÚNr㌀±’ŒÙÅSéÞH&®òéI‚˜%$üêÚOŠøQQ]8ÎÖã&sô• ,#™Ù:ÀúK9˜š`)’XµûK9³£…åÖšd*Î>Í%ÐEíH›¿µMÊQºTDØ:á¥Jàü¶ÍD†‚|úèd¯çØ­»O}š ŸÙŸ$T·až!‹VF¦¦t “Ó8Kì0bIø{¿2$h2d£æ;“Ev’Ðòf‰dt•Á«œåâie+ÿWÒeiªñþó_Êÿ]`—û¤ò,3ä1+ b« ƒ»/û–Ûz0’Ÿ‹0Ø%—H޴Љ!=ù‡¸H—{ŒÂ@Ús£c1Šâz»7Àp1Ñ8©Ì å»òB+·S¯8ƒ‰€“ñù"²¨¾%Y§¼­Û %š¯Ð[Šï{€ñÁ{-+J<˜Ø”&X¼‘›_“*ØêcS¶ÞøŸýƒ€.’V`¼¯ @3Ñ£øZº€Âè!›²´S.ts—Ø‘« ’+¹@„ثà L·Ç@ЇxX—>a)z”ú Âh‰™2¥ÓA½HÒ)W‰˜ˆÿ’½‰é8(ò@ŠM:‰êÃ;†[2Ÿ@‚¤¸ˆŠ ˜Š“?×b9Ž#ˆX\¿!ˆ°EØ"9øãŸ*,¼+ÂÂ•à€ ˜ïx.ä/袤P"‘qîû$) Tø9 ‚IK>3š” ÀåZ·›º‘ÆÑ²¡È¤É ™Ã9€=ㄉ…LÎOŒËýW8²7³V¼’g ¹[d”*‘±M‰‚ Ïõcˆ“*«“ €õ¬ ý㯮*"Zâ•ɵçd8#¢¥Ó{Ò¨`RÖz 5"·B<·•0ÍØ± u‹tñà º=å™Pª¬#““¡Š¨p*ÜD ³ëɈa¬±Û ‚ÈÉ´Ò¤PQmFÍj¸_AÈ¢èDPÿã¾¹,¢!0€ W)¿ÜäñÈÙPžÂ:)(D-~úŽ‚8LšQ–&xðUä!Ǭ-.ú¡ZšL/„FÜ2¨JT’´3;Þdļ\ É(1wÁ(lÇeå3¨<‰|0P'(”£ÖBƒ ‰8 À¸Gäs´¨˜)ð«òó Õ M4TD Ã]YÔ%¹ôÁ²ª†ô‰†ì/Jl­+™¹{”ú‡w¤‡(°‡(`©ÑДš ¬ÒQX$³€•ëlR ³W8 ¢2QQ›Ë$1( œ™º’Æ!Ö ³3­=7mGqô g}Œ6Ž|ˆ‚Û¹Š˜P õÎÚ “À°'#Toÿ…¢šÔr%‹%H#£Lft2HÑ$£ÌdNèlÑó™/¤ŠVa$A²”9•Ù(ø×wÕRm¼’äEhy–€€J L+ â/è¢$Ù›aËæ$*˜¬Ëeà8Â_úŒâ⓺BӦ̳ØC®uAÜ š=´E󉨰ÓJÛÁ` <žL¾oŠ •ÁŽ*¿‰Æ³+ùj§¤UZ»}ÆRTEæì$hDŠL-ñ ÁPF¡VØ„ÙQÇQFË!¹’ Fпà¸F©h(™ÈÆzL&©¥°€dÄÕ\mN$Ѷ ðÒ1;ÎeE5â³ÆP:ºâ‡p¬Ãÿ|>{Sw|®Cà ™Ý ͸„V±\·‚•±ôÖrõ^Í2ÀOHÿ]×ÁùÅq#¢• Ñ¶lζD ê¤H Q– mœåwtÇ{‹‚ݱ!-9ØOAZ¶Zc…ú>Æ ¸˜ÈæÅ€æè-’/2ŸOó¢òËÝÜÐ}P¨á‡1õ ˜XV–=r̽cÝàOY‰kÍ•€Ì°ÌA;Ë=Bÿê_ßj(Àù4¢â˜ÀIÆ!`õ!`ÅIQ…F­ø•×mÑÁù>'b›ß© Ž Vª‰¯ý‡\xÊ{{Jå¡ [4ÕòÜ[”‡¬h- °”mãhœ€Û #Àƪ­ÿ£Ò3ô.ŠV €zhcp ΙÐ3S}˜º¨ƒ DbÙ»Ãt£o\X˜X.{ŒÌýÙ?;?í­¡«ÄBm8#+KéSDUT>¡ÚÁ…´[Ÿè¤OSŠUcò 'ß:v‚ Ž‚=vÍ|Ê‹àˆ e¼à •fK –L¨Î«) £Gf,Ñ‚L!¢Ž/ö I­¥ÓûYšú% {5B›À£<Ê¡Ç6]‰`Ú+Ÿhh÷-”5ŠŒ`’¢«@¾Çò¯Œ’¢;WuæÜÄMŠ/f<™.²†£×øš D†€’ßk^\ˆ¾c=öfoŽŒ:f)ÆÿKA ‘ÀNx¸Ø¶ Xœ^~Gfá¨¸Š½,‚¬áó©¥m[”О¾U>µ›¬ 1e.<<‰z“=Ø{…žèùØjõ '¸ ù€yŒ¬hœRâÐ uª«8B&MaZ]œQÅícâ´RÃ1`ܪTØZvR§†téò ª¹æ(ÈŠÊœv}p©¬cˆ®`€— ‰ÄÀ€–¬ËYy3ª8Lã¡Çä9Zê‰z¶%£ˆÆ¼µ'µs+­þ%;ƒš ¦v<¦¸²C3-Êc=Ö¨·P´Xþ 9 yQ[ä›-øÇŒƒŽìv(Ÿð­‰;œZ@†¡ð…@†ðÿ–aMT0i·œ×æ<2÷fÚL2Q“€ãµÓ˜Ykö‰Ëæl7êìþ†Ùw¤lªyuiYÏؼm{ “y³šJꥧ.l ÂÞVÐä`ŰEŽÌx€…"ܯ> ¹2Mr\VÛƒåX~_è®å q_˜•б³1ñ‘²ÓpŸ@=XÙ /•6òv²ZX‰ñö Àœ›8˜¸¯ÅQÚÅ1‚š:¢º fµ„Ú„ü?Dž¸ï˜^‰\ЇË>ÜÍvMÎÞlE‹EÖÍÖ‡8ç×rQ‹È¥‚ I«Î׆Ïcl’ž¹ÁÀÁU?e©bÕÍÆiÄy¨t‰ o\ÙëFG¦cÿ¥e©An'F&ZÆ á-H‹“ s˜ŒÓq>õÐ> "‹ð^œ¯odðÕ óud0‚Zh(ìûªêCÈO«;ôṤˆ¶>ü¶ã“ðòÎγÍ6ö;ðå3@„2oìÌ–léU#C£~p©p[¦~óÑ;Cƒê¹ €DŽ( ¿ñJ+ €¥`:¿î•@M>3ß=;®IŸeª¡e÷%$ÜšÓñ ñ¸±P qΓ0oðõ­0ïªv²±pdÀX—u·DŠlìùr’\ÿ*¤€æ¶ É07®A’ïotM1Vw×:h‚ödÎË/¸¸§È×&C<ÿÌz™K®x²’Ùœ©$L÷ÊÓ jǨ+q@TDGGäZ£§‘‰eÍðÚ7â'E»Çòñrçe¾§¡r‚÷‰²w²]!õ!q€µßІÿ|x€dîDOŒN_oìH( ¸ mþ׭ý¯¬#y’k–wŸŽXŸ‹(Ñv Äqç³{ЦœIÆXeÌpßÔ8‚™ØžÖ¾’˜‡«™Ào<ñ°FqwY.s3ë˸úWŽæ¦åX– H!l|†™´ÉÓ½& ›ê±•@†ª.ûâŠ$wuWÿ &7õ‘ñhMZéb6EŠÀ`‚ þææ¨¬·_ø‡_PG‹ÿ”€‘¨5y@m-'ÃÂÙŽÅaáÏó*3|¯°Ú9ðñ«hgd™‰º €È@àÿòIȧ¯Â?}ÿ6ü'¢ˆøIÔwÑa¾†ôñãxðC¾|öL~°Å={!ìü ‘ä?üÉSbN 0äüçóPžF­…Ôh=žÈŽú‚º”§d 0À³i‚¦ÿºþãêuk‚aë¹â!!—¾\£uèðŸ‡"\ÐÅËSïRuéÉËáÅ Cxq ãy@Ôƒ êÕ+ "ˆ!›%&RÏÐB Mý3jžæMùïƒlCj̈ñŸ¡Š#>ÃÔ'×h¾”þs©òdˆŽÅÏ“Wt狜ÕoJz$Ç?îE%æø>u<ùZ§˜þŸƒËæy‚í 6sÓ±G͆þwøŸáG]Ì5Þ/<­ Bªü³‚ÿÁà úT÷ÓA¸BÁ®Pæ ®ðXv8UÆC=Cà÷Ïg ´²™°ˆÚâ•Æ"ðD@ IàQ€ àxiÄoÿ`ÔcŽ»'QFÙ3[²…pN6ITÂ7þD£NÿHÆwÑøO@!ù ÿ,éÿÿ H° Áƒñáû·P ¾ H¼A¡"D†Iø'¡Â? ?þÈè¢E n¨Tù_… †n,À·aC…ÿpÆPÁS”žöø!pCQ “*]Ê´©Ó§P£JUZâÄÔ«kýûQ "W‡[ý£`¨l…Žù>¤ý÷mD~à7w$"D7½D4¢?~7"lP¸áÆK‚ŒbììùÏXŒxüþX@¦šX3kÞ̹³A«1N°ý¯ ÏGá«õÐaÖ­T4ûñCÛ¶í1Š+О½¿?æóùÃo~ö&לhÉ­[uëV¡8^Ëä”ÿY0Z´!êïàÃ{ÿ]µ¼ÕðÞ²þ{áD²+Øö ¸=ôþ©è­_ÅïöÄpŒØS^ PT#Ï1‚Ø?:h›|¿uO ‘ý³!…™x †("S¡åtB ¦‘wj£0Tjÿ°¸P-0j5Bì©öD³"ŸqºÅ0O ôàç=ôüæÛ~B`þU€G, #¢vÂ<Œt #Ì#NsU0eoj¸Ý‡#¶é¦ˆç±P 1ÐYÕAøÀØ¢A0V¶§z ÔâŽ7 a–_J ©IÚ—ä}Ú…@Ä @  l¸"%!Ï=ÿ,ñ<ÿœ°¥˜ÿ„„fÿ—K#l¨Ý`ƒÄÝ›¼öz•h¤‰Vç?§• k-î ãjy6Ë'³ ¹ÇŽ?¨Ô—K½Q'¤ÿÄ…L î?–ÔAxàI•ÌÂãë® êUÛˆ|Â|™Œ“U¦úî;ã€*óóÏ¢ÿ(Þ Œq7ú ä4§z±¨*êÝ‹NðDC––ž]¡|Ä`hc/޽Æ!­+ÚÎÇÈ.@˜XððCw«¼äFø…ð*È=ä1û¨ÀBñÿø3·!í­qž ñ¦ª{êüPµ“Á*Zñ bºWβ:Ž)ËY QRÚ6„” -˜Ç\bà8¼Æ†7¨É&À‚{`€TÉ+ÐAu¼žÐ'¿¡[ÄÎ#Ñ,ŒãÙ w‚bîiWŒ¤³¡Ô%Ëbÿ` E#b^1Ä„@Lö Gœä¿D A¨@ îq< „ÿ8ú#cq *ÐÀ’˜üÐ-UÊSãl)èah âB )Éj‚hHcÓ7É"@Kc.’ÍÄ—äCÔGÐ !+M TvŒ'A ”À^Š#óiÿaž@q;)ÑÞ„éÏçÙÒTÏ‹#‹¢jZ󡨑pâ =A«› Ô%µ{1"Q$ Ax(D$ÈŒ`Ápù{°ôˆiþ‘nq?ùg>‡Î½ D˜è̉?wr/ƒâ-tŠ¢@––«ôp¢PýÎ׈ôÇŽ±® 4¡>iÑØk?1(?LÖÌyÄ1–$ÀŸ@00Ïy @ÄJ NLE@‚àDqÓCæD…©·Fýq‘ Üá ÁuÕäF‹ª¯¨PÅlHÓèú-¦)K;ˆÈÉ<–ðOµô^#ãuǃГž3Í©æ‘úOq>ˆ˜ì†×œÿ I¾¡=rv?yè7`Õ6°Ì9U±#B ‰Q=Ýd,u í2HØÑìg€81g•óT‘¶¥+\ÿך¯nŒ’Ý„ù¿&nHJ©=Ò’U2’°-ŠA.“Xä¶IU,¦A´Fo>õ“ÈødCæqUù2»³JXJåQZðâ’ãýò'¶þÔ1àú)NÁöÇÛ¦ò )?ê[ {´å/Àñ‹LˆË\yÒ¿!z@¿§þ)Y®û12pÑÉࢣ¸Çhxâ²t`ö•ïn) ÃÔÊL¡ÎÿF¼Ÿ@®Œ?á"ø¡2ËǤV³@ò£,`ÿHšʆcñd#ƒtzëœÅg´å©EÀHM‹Žý…õIäÎî`zK\â2ÃŒÞ0±ü?ýTzLúQ’R@*}ÈÍ ¸ËŠÛââ– H0Ü#‘£²ê:#̃õš Ù«frÀÊj2¦;Ý á–óðK¢U`¸¸ô¥ä¥'y— ^[ÆT÷`U>·æþä‡>ɇoÔò—¿Ü¥Ì+õ‰ÿ¡»¼yM¶juª™âP_)+q`,x˜ñþAȹ´‘­)£éù“!A¡ãuƒdR–RÁ!‘ÝV„`ùûèy¹liK+)•¾)?D ¾ ‚¾·‰‹m*§–6/ £éÿS5CÔ–/»O óª‰! XºgH‡Õ»õžûÔ'9Á:E+Xƒ 0"/ta¬£pR€Wg4£~Ëzj`eƘ6ë àä6@ ÖNÐeÍÛ.ÀZJÝÊ“ÿCš Y7žp\XAMñÃA`€>x•uHJæ‘&ƒÌ¢"}ŠAx¦DbçáB$R ôÎ(£’-òŸ7†$š-í³«(ªÒ¥”Æz=",!|œ}>/ÖÞ%2àÞø à,€+ø’ð_l»¸Ü•Á»ÊÜî¼'…jkÇ<¨À@Ìb"xÿÀ‡U(% ¢¨ÂDðµß@#X;ä†d ¿ËH2ñògEPp-d €ð6 fù0Àu0+v*D‡ðy>G9l0E²%\„6-‚,\ÔMÃ9ò€pð³6úQ)ñPuÇ6X·a²We1uô ‹¢)ˆ&.‘1.¸7H#àvÁE°v€•–Æ!Æ1ž†ý…'›ac P% °'#p+p` )Ð~'—|N–|C1>jñÐf-ñÃw|fèv¶³vÀ·bñG¡æisÿq…`v[>‡Õs„/Î5(äB ñM®!%D%@9€³u'ÿÃSÝbsóz1åƒQOI–dK@9û¡)Ý‚;ewrÇ0Eöàóõì77ÿôyj1B)g«ÖwKå.7«fc3 0Ý8fbvÞØw!‡jÇ~ÿÀçBéȼn7 °Á˜Yùfˆ70…úó(ö¸mèbÁÁÔñGDò*#æsCÒC2 CW>ùcÔ4HGpõ=÷òGþÁ}S8 ÷zÇSX·C÷°ŒÝrbÀ‡ñy½‘[õ-¹‡'ÿ)B˜*”ób(æiå–›S1ÓÓMá oˆa–£†J‘bfpà—†ñçÁµS8°v¸“r×çŽ~0|ð÷_à§0߈;jqŒÝ¢m¹Qbå‘üSC\B z7²"p.˜K÷2XÊGUÀÄ2"Æ€7ö#X[2_}(.rùà¹%¾Ñ‹k¦Jâ>Å(øqD_÷ ”b&”ÀÒDø€wra›ŠÈÖ’†ñž¶~¨RP’n7fˆ vvÈ ÝèvíèÚ–q…c&V¼ Œ Éj¼€Žïj}¸Âÿ‰câs“õ‘ªG4FóA™Ô:ŸT4ì1b’IÆ8£Á%¨iÁa)rC{ãs.6.rÓ’áå‚;¼q áÆ+ybKÐ-À(ŠÃY@@ºŒ2“¶Cnò—•AgH)¢^H5±ºéqy½é#B\#q;ÿ óÐUðz f¶#CÑŒfˆbôRâ7rp~P•Èg†ˆà†(RÙyÜRJÁ<¿áå*Œp…fS6ƒò²ŠaB à”Tv@ÿS mñ¡ÝÂcåBݦ‹u:Vù`)#°‡& ˜).cAºbšJ{Ó¦¢SÿÐÍÿƒD쥚 š†ÿrw%ÊwDV”Òh”E1”qÞ¦3z¶s ^å©™%ŸppPjü0|EPG(VÀ8â‡psáz ëë¥X ¥#ÁŽê3¹‹0‰]ƺñ—¤`š”IÑ4aÑQ€-¨l·dK%V scÀ8§ÁH3}ØP:¼@. ¨e—[`ÙmkÉ õ1=-p95m¦Ò 4Ìw;ˆ@‡HÑTFY}+·=¡›2¡0cæ7à”NYA•z-IÁüP†ëš[IX\ÉôÀ^áC‘~X†" ¬gécö¦#|Ãñ‹fr®ÿ¡¥m‘/)ç ;[±±ÿ€Ÿ¡VA7g÷™–i„‘!C¡–!ûØ6²²õuFò™–¾$>e7M@/'ЋjKd«|=„bº’XK#} qÄ4Ü‘·™epw‘Y?òjö2¸JBfè±]²/¤‡ u®Z¹O‡]éª#¶£_+–‘QÃaÝâOb&òa¬ŠiC6eú­°ì‘¦Rðhø/ê”S¨„Nè6¼(«PÛm–¹fG”¨÷?þú(£©JVÑ8ŽÃ;¥‚P D¬•$ùYof$Zº±j.·U·S \Þ›zÿºj!l?‚KAUÒmÊ%P &T«æ›»ª®W™–SÈXé•iÑ+À£ÆjñëÜ5¢gvF3Kkª?ÓOD‚m`¶iK»´ÿs¯v³Áœ•Sý´ÁMÐ8-uMpϳˆÚò¶GõSi;™5Ÿ›ÓwÕÇ4Ñha\1œY™¥‡ámá lõAJÑ b’šA°€\Ð Ýðk€‡ ÀuÁ\6À•CZù‡QèvA¡†1›&jvœ‹-Æú´›”>ÍbPŸª›­Ë*¸d´,0¥²3ýJ Òb&oaj¡·…S#ÿ‹ÈM´Áªr¶!¶£R‰¤ÁVq¯Žƒ¨M4“1Œn’E©nÓ¨½?ðfn&z‘Y1N¤¿I¡< e¸ŠæZà¼ÐPfR«v-‘bߨf1fìx;ÉìŒJ¡`a1ÙaF£RE{Kµ„:#Àë¯KÛ5»X9òµ©Ri쟷…$»µ[{s£²ÂŒ£ÂÊZ{£JG¤Á¬Å|u¢ýu6šjd®qXÀE”q†¬|Ìz1rÃábÆAj:[²¼óO1€Å›;‡™l©•ˆÆâêÇy§_oL£pB^Õ …RóPC^øIT7ãÿ\Y¤=×s€,»5Ê3P¦ tivÀÎ,Â…t¯è¹•$Líµÿ49ŽØf@;”NµDö¶¡ºn&Ð?{ÌA;µ¡GÄȬµ'œ*¹ a`Q鸤gl¥m,P‘!åÃ"ª!;b!ijF¦A™K9ábÔ±záÈMÔù!ÏÓ3²‰3²×†Áf—JHb7J$!@¹ù  íÙ”‹ÙˆÃØCi¢ÃwÑXÊ+œ1Ì/© ÄÁ‘!WøXKQ -| !¢bµ¾¾ñÁRÉž‘B ͯ3( ´àUl‘3Tس—*ª7%‚D>Íǧÿ²CÃØÊ3Î%ö(¡mp¡êMÁämM¹úÀqì÷´.0Úî}bJbú´³É4O³'4¼=4‘äæy;>ò† f+ö#A‘³ø!²|:ð8‹( çdšÁM«2ˆPf¢«¹‚JÒ-Ýæ#ZáÌ!C”ñ¿-EŠ‘ªµÇ9¡(ó3?vÓL*>./A¶÷ŠLñü™áƇ—k!€$bBL ßÇqE ßSîvú`;‘rq.v 9ÜßBpAª·×j91­9zÑfž6”[9–¨e¢kMá-Lo Bo¿¡*¦)w7Yਸ਼Åœ†ŽxÍn>(ÿÀ‘¦ãünâÕLøzóCIã]/½^˜þÒ>N¶IÍZ'«UyÜ]ËÙ?™œò½+P©þEPåW>¡@ë¶Ð(Û¤!?°½­¹ÆšYÅ!jËx/Š‘$=5çAx‡ä&‹¼5¨|AÌÝ®ñÛQ»"Et›äÚÐÈÀîréÕ iqþÊù„*;^ñ¢u¤=2´éª²['ßb&Àø®šåÆ~¨® É·>°ª°ª.¼âÕžEc&E½Kó—WåTÜQª(Îæz!žvÞ¤«|Èd/IâsXÒI1%ÑàñO¬çÆ4_œ–o1¾¿m9ÿ±Ü…ŽIÛ.!SI–Nظ„?tÃ<'Rb’3ƒ-UK˜.ñ/Ì„Hÿ ÁÂÔ(çíÙmæÞ¶ñ¡"Ðï>ðÅ—õ[Ÿõ©nðn‡»tÑ+”.²±iÃLÓj b9™…ä=¡ëbsç ÃDì¤8&_0¬Í©h!–e]œ6óP{9…NÒܤÝ0JêôÒ⥑ñb*Û-[$†%ñ;´ÄRFŸé¿3*AÞô äÔ.ÆÔo;¶Ãï à”ðú°/Yÿš~¨ê‡™0ôGsq¯©½” #¬=(|ç‰~ñ§­¹(æeŽ…Àa@GÓÈVÜAðh [A¨ú©ä*ÿn6›!ê+®‚RdÎL2*ë.3eFpéz®Ý‰t"$<Î3õ2e¿3ÂGGŒ òZü;ñï_ˆöþ}Pø!ßÃ|úþ!ú·à%Œ/Rºd’ñß? óæ9¼±AˆËøb”³¦ÌQBhnÐh0ßBƒôñ« QaBzç(ÈTå< =¥N¥ZÕêUªK–ü»·„©†èÙûi/é¼±Lþ{x²À¿ ¾M×äÍQÿFáûAáß ¸ÿXÈ“wïûä0xäßV£ í1dÈhAK6|DžÁÏï1ú„@ƒ'.'U¨OâÏ®!±Â£ÿT yz¹`ÅÈ%Á䨥LTóâÃ5S&O EÕj¬ïC…ê•CØ ÁÈ£Ôƒ½†½lÐVôéÕs}¼ÄðVc(ÇúLšrl“ ~p›î¿ÿhZn”Q,ì‹&8´ûG€} B¬§‚þ¡'†ï2H¡¥[¢0AÓè³Ð ­B’ê5‰$:I£BÒ¨£Ktª‘FJþ‘Ѷ\ ç2Fèɧ%ž„©9ƒ¤Iª ~¸‘ >R­É&c ¨ ça$†¤T(ïÃÔ˜2ˆ…óÖ3óÌž¸ÇDƒÆK³ìQž¦4ØŽ¿ô*ï6Ô+¦½ôúÁ¢þ1¼äqÿP€rXLªbЀK ¿û®¼1!+Œ=6E3ÈÄ%Rͱzˆ­ŸøÑ‡¶D¸Á¶-ø§Æ… Õ£(‚µèñ5„ l3R§ä–¤Iˆ¼–3‘ ,ûÑ*ÕÒóÂÕþñ²Âßcª %¸@óÛôe¯ÍøÂ‚S£‚Z`Šž<{ÒÓOxí‰Ð@cr²"¥FlB#ªKà ÑÕH³ÇíàžBKT*´¶# "}òQh£èŸ $·ä:2HVƒnügu6zBàçb#ÿQ²'|’­é/D.pÈÐês!z²kTLýPÍ>„ \¤«Z³§®ê¤G{ ˆ JMÿQ?)5kžy-œj¯Bñ€²Ç}Ð#Äý'¨T˜7È›1;n¹*,4…Ù$Ú´ý ŠHÕ¡\ÓGÂkËx,ȱ'[׈§Ü ’±}8|Á"u™*$#¸Áf5Êrí«º0)S#´£“v}ªa>倫®ÜŒjÎ ;¡¨+‹ž~_m.çñr^|jш/|×Vtª§âÚB‚”Š©>s¬S¦‰^¸ÂyB˜Î UO"<8Šø-c8Ùq©D¦dÄCZ€¥ÈÂw7cg®j¿<‹Ýé‰J(õéQ Eóž÷^÷Àž8‚÷˜Ðajg ¨w¹“XL§ÿïPEUC`Jº–¨¹ÁJÀ•„1ì¡ Rb-ð¥';‚{ØCQHahI™©4BÚn%a@Œtd‘ÅýƒX5‚àg«ž\bñ$b¡ëØf&=yYs˜ó8'U`€Aè>¶ ‡jDÃÓ†Ö¦qé`=k˜ 3¦ò„èÑ*0&h"CrE+Tû—޶.…Ìi^=;H•yÄ,fº×?F0ˆ«_ Œ` 2³¼m™! hˆÄ¥éë{=IŠC„²,Œ•dÀØ?Ta=nFR´"1)a«ÜÈê¹ÙÀ%¸eKŠ;åØ2/qÌYe„¦T›Ç"°™Ôd@Rq’!þQ‚0¢ÁÔx¶ÕÊö8P4$ÒÈ?áy˜u"Fm^M¤(ˆÁÀh®‚=ü:v+³Jø‚C¹¦'¶¹Aúb*9ÄyVGÉQ}šÌªøt‹’»„øñÆÕ":IjsPØúùEÿ˜€–”¢RÉÖÑnUyëq—ûUƒp ¹0†§=ÓjÁ·NЫñå”!Ù„O©håMà î1d1qpœóÿA T‚–Mr0ˆÁæC±Îp† Sͨ Bì)êò`Á˜»ºSnG*_´ 0{ò ÄI.lIfNÕ«ÌÈ¡vµ— ©º˜ò–Ä$9(L*MhˆL`:(B·R¯|¹Žíê„8#¡D2ŠŸ…„±§FxQƒÑÀÈœ- rʺo•ŠZg×βv:¬±§ÿÙ¤ÒÙvÜ«®½¯[¢™7¢ö‘×R²‰ÆÀÖuÒ2›¨2wt¾ðÌ`Âɵ u-¡÷vO^èÆñõD³‘6Æ(R’^âË6!ù¥¸-#õâ&dVÙbjϲ’–´LŠ3›Ù6E{m^—É í‚Ø•Ì‘iiýô¥{Âõ£­× «‘Á*•÷yw¹Ó ‘—×îúðhF®kîÐ%¦é®C˜ŒŠ&+zÑ|i—1iKØÚDÚº‘YQû5ÌÜPôMªøÅ/+ T¨©#xVÁ¹ÊÈhƒJ•:è§üÀÞ³¼àbfˆ¾šC³{hiœ¿½¾y9öA~ÌÒÔÿõQ ¤Kh‚{Þî©ãr)Z‰x˜ ò£ÊFT5S·5 )àT{l†Ôý×Q)ñh=œ¢»’Ì'ížT¾'¾iư¸ngÏ3"-39‚±¤ü[¡õ²ˆ)™€ A pÂ*²Oy%äÚ7€òô0 ;»¬P8àÛ”˜±@²âkP)¨Rl1šÐ¨+ûXŠd ZK!¾¸$ت8¬"6 ˜…Ѩ1¶@ˆé¸i›< à‘«Ð6_Ò¦‘l±›2LÃÿ„kµP‘ƒhƒ ¡‡6¯°>?ƒŒEz;0É”¬ú´@ :A‰‡êŸ¾ Ã0©Ä @©˜—ÃÄ…©ºZÌb³e61R?1²Š°8û‡Wx" Ë"ú7fÒ‘K°‡Ø?¥B–1r>áð3>ÝÛ!ìÙu:5Oé®Iä›´{P¸Vû½ü '°‡dtRñ_Ñcð3uÁ0!§½ DãD:Á¸m™D4~P‹–“¯R:9•`,•{¥\Bü£ ÊÓÄÉ£ŠËƒ‘÷SP¬8«ŠùC­‘ñ˜|˜­bŠÅc·#2 g©íyÀî¹£ía¯ãŒ½y4i%¢Q—ÿÏЊE2šƒÃ ƒpzp‚ø‰–ZF{(gtF Ѐák$¯€­Ó˜Šk4…Ã@Öp’ÔÈøÌL}I‘|F»[$£é tÉ¿‘( A e ŠÀšÖAŒ^SÂø º)H9ɤª‚9ƒ0$ B x©xT¿©èĨ̼ž°) ‹¢S$-,R¦{•ÿ «-Àš‰‚D¡(  øŽ”ÓaȶV2š¡$AVÛŠ¢I”/¿ ›š„ •á T‘(è üù^ôLOõÁI•œÆcÃN½šç+Ô‹¥”½à‹2„|Õ‘¡‘22c ¡Ÿg¡¤éø"hÃ9 @„ lõ«ÐÚŒÊOÅ­‹ˆŸ:·Èɘ0’i·ªP–©¨GJ21Ñ/Ò(®2«1#Œ¡©#„j ?³‹k´y˜Æ (_ÌS1ˆ¡BÒ"ж"hÒ"HÏÁ̇d¯ßc¾sœ,uA‹.t5Á‡ Šg¹²O™ÑÀ©ˆ!¯©Aÿƒˆ8¥g …PÎ …Í™³y\l‹‘ÍóX«| â‰fú6Ž Y)ª—‚´¦©s #¥ÂµE©ØB¨ˆ> Y27²ÌòX °ðN )‘,LS=O"¬)aÒ&uÏ÷ÉŸ)¨"Ák<7Òy£Ëˆ#™°€{Ñ5º:ǘ¡4ÔNÕ0±H™Š‚xSA”ø¸h“¼hË,M„ªàJx¿} ‰ÐâM©ÀˆóÖŸÚ"Œð˜ –3zË«• ÓSÍÉE1# I#Mâšt#{àŽQ¥ pîøW ”ì Álƒ8Oº Ó‘„]Ò'uψAI<Ô*¢‰4ÿ†áÑQŠ”/ý‹ñUßú Ä%ƒ¨¯¹ŒO唽2Õ,Í„P‹–˜ ŒV!,¿¨ ODÂ{…ÞøP|i0mýPû ¢ |ôOœ3›à°å)­‰P #‘1û“K”¹ä*Â(¹V[Í|åÁ—ý‰w,¿é IØP³5LÂDχ=O_JX‘Š¢mÒõ\Ì|ÕÜ!ͺ’èkÑ”p5Ò‰‰°É¬—K"‚yÓ\M r,ë åœ6Ú˜ÐÙÌI«à9ßè9ƒàY‹@BË…3žÕ‘ÀÇ£ý¬O, ðÊ °"\ЩË‹Ýp!r¢ µL§íG]›‡‰ÙØx×h©Àaÿ~xˆ‘ü‡xЈ$­Ö·5ÅŽ0Ú˜rÒÃ4 –,ˆ&©©©–ÉÌD‰%i…耋 ø&“c F)¤t’¬ž@”Q9ÀÐÈŒ …X•Ú̬ؔ9œ³Í^ ûù¥ŠÐ6ýÕ<_úß˳ÖPŸÞÝ}PÚš@WwFç”®¶„HÏ(,Íp<ì9 ÝÅD~¨ò PU‰’HÏkÛöÇÒº•ÜlX’ð)Å0nIóD ™—¾å»å€J¬©Ze Xj2 rª£  ©È¬g¥¼’ð }h…_0ˆyüÄ å!¤V_"Â*®Í.]DÐwt#ññÊ ³­ªHÄDI,ÿ„q Ò¸1pÂbG{ÛÀY ƒØ`U“@ÀÑ&a~à…IaÉQ…ãõñ˜ÝТYQÕ†Õã| Òå¿dÃ;üÄ •£lÍ6E ya“º1º)ˆq¢£…M2SqM\’bš­P ø…V bMœ9ÃÁ[Þe]®bœ¥)1² ‰³0uIŠˆX -åè‰ø€³Äò¨µdyí¡ªÛOKÔ9ÌÁùfŠÙ`Š1 pÏ“(çVI’è‰#Œ)üíÌSÅbáøaØVá¾ý=tù"ZÓÊCíU¯ë“_-Xzc6! ⌱žñ‘ˆ’œ“ÀÄU ára–¶ÕˆvŽgndpsÚ·å‰ÔúOБ' ^{ØÀ!%"”õ’Ê"6IÉäZÛdCðU•óµÚ²ª››º¼·íU^‡˜hg•⊶/×€|8]½þâ/.‰~©ë%Â)çˆAØJ” ˆœ¤U/ꉂôœ÷Z¥¼éŒ7F»*M.1¢Ž ŸNç ^–ÂDOƒ5áõ<ÞlÃ_©XR¦·ªOè’ˆa<Œ("bÁdÿíU ¬ë›ˆ ÌAG”¥cê!…y!µè©˜g›Ð™s ñÙAìÆn*Œ˜Ç~l½6ØŽ~)ÞÝ5>Ô8džŒ™ŸÄЏ.ÄŒ­Vðiû‚QS &#‚‡o&œe9O=ŽôÔ¶àã­©^XRxÆ< {ê¡Ó©ªnaô$æB 'ò辜¡Ëè[¨0åÌ6Eß².ö #—œ û:ßë`3é>¢››„€ ½ È0Øíe»nñá]Á9È©(Oc!"\)c˜þ‡A))ßú ›¶æVÇ©à…oFÏ a>Øªà…¡JÕl‹JÿC–¸xN^«ð # ¹x#b%ļR‹+¡ñ îlšPnzÜ a€r”~1Y®:“‚0%v ˆhÕ ÿ‡ tÆv1­èΔÙA'œç|ˆ Ò{Ðô MéD?%_°LݸAÃÙMã­"39M•Q•ÖÐãr¦ó10— kR©`RvfphóáŸÚŽ0üõ„'­œ“Þ¯ß+Öb(¥XIíŦo¼˜{5)G‰ž†Óˆ7M¼Ö¢x;¢FÙ¸H—tKMoÍä[UÞt_ù‡(pˆïÆÄ\°H>Uˆ {l Ýf^…,²ÿú"Ç ºµ8 -÷oà jñö€Ápƒ(Lõì dOpv6ˆ^(EDnä §Šhy(‚àEÉ¥øCc§qòí¨H lâ^D0g+åceñUë¼-/¶aשÀžwäL]Ӈ⦷w´xŠTßth¥a<®o¤Hoþ– 5·5ဠ8Œ&ÐwpìUY€£Rž˜3J4»[Ôˆª+MFÞˆàf<L<&ê$Bí¤Æ9vÒ×^ðÛÔ‘Gä óÈ—ê–oùšb€“ɇb®Y;vÔÞú°—V ˆ‰VNbË €´Éûj¥.ËU¼}w‘€#nƒs?ˆÏn¿ŒÿM'òÐXûÄXéØàf¶È™ÅFûæ2 ÅNõX•hûS xø«¸D1*oŒ‘*Aš ~á¡ Þà |.ÿ0Om”mBNö„ý‡•‡|ÇÔåÕˆªö./U$S—Mˆÿþ+hPÃ?„*„üh…¨àÂ1 ²(˜ãß>#Fþ0x¯à ‚!Y$hð£'õŒ(bÈ¿!fÎüÀ2ŸÌôæhAP^ yMäÝ êó½!>äËÇreÁü €Ã¼|1 ÒˇhÅ D7þEØ`á$Ú´7ìU<òñßG·î)(¯â¿yô˜:-Èï&¿ˆ\æçBŸÿÿ‹àõODÅÑùW9­*ƒ™}ôú×ËGÁK>D“þwé’§Ñ ÿ©f]¤ˆ‹|öè%å©aç¿ÿä <‰PüÛÿðEøGÁп iÿ±¸×‘꾂tÜ]p ò°k§hðCr}!ꢸ`ÍôIÀ9sžOyòç½×äßPH 6ý§ýcþ!EV]¥Û?Z}Þc !"B”ü³ÁrÆÔZuÍU]wĈ=LUÏ_ O<.ü>"ècÂc*6vÞrMvY…y欙fšj«•hª¥Æ/²é”Ð ´Ä Pr5^©€ÏöÝrÐU•Ö[òýƒÿoêÇŸ=„ˆxl"‚HšHž>6}°“Q=%Ÿ÷ø‰ßvºÑ£x8±ä’NRqpÏ¢-Ìà ¶èCX+,á?B„Ï(RȈiµbúŒ@a"èj¯½ö*Y€—e¶\/EpÆ‘—´‘‰ÆÚ³¼Ä6[oNê%”¿ÝpóXðÃXÈ8QB¡ú%u9ÇÑ[Ö1GæI‘BT–âÄ^>!Ìéž]Ž"¥|ù)& >ÑÆj‚I†H¾DµÐÏT!¥‚-@ …¦Õ)Z70r]s•Jê¼¢A$Æê—Š(²äÿ ˆ8æß®¯Ye" ûÏ ¾¢¥Je›}f³¡T4hžYN$%’”vTÒ<*è¥=ĵbˆ!i*gÏ<ängP°à(|DY¸oy}l/D", ·FpÖI§…È<Ô.\"ïÆÂ‡¤›<&-1voi5tœzˆ|ÀH 1ôü—½Â<¼½ºwze¸Z XžíµžJ¼õíœs¼•”èQ0ÿ¨V³>øÏ‘‹™Ì |I¡‡=T¢•¨‚RºZ€äþa­m†(AÛ "*ŽêsÍ+]ÿV÷”{­ˆ%)b ?ÎC£Èììv•ÁQï R }†YÊÍð†çƒã¹ IÑÍP–À=U„&¡G ’2½®%ç¬Èöªƒ=äNá;ÉvºC’‚ÈiMÑҚ¢˜§äc=!€@Þ^ð0µY…#ò IPüô§x È?·[Àcþj©=òêE°€‹YšZÛ<*ºÄåO# O·¿œDe+R®f4»‚Ø® <ÚWðš‚øŽ5;ûÌN²e-‡i9^>h㓨êÿ#BÛþš„”$Nä ¸ ¡F¨ 7Dü¸bÿè|hav°ó¡('€IŸÜÞ$7Á°G*éc™@dà*hÁF4ð©+ aXx¶€Ì°é}!`M>…YÑè1"°Æ(XÍäh§t<â–Ñ9‘)“|ÕJ$ HF¼PLdDð‹aÍw™i ±ˆ7CÐÌÐXB2Z‰Òe•ž°YÓŒ( ± ÀA" Ò®UÀA‰“r„ý¡AR‘cÄ^Û¤À ϺqñÈË|ä8Nqò' ú!oü“ÿH@1äyôÑ”¥,Åûÿ¤S?ÕÔ3JXÀ*µP*€!¸„îsêú « P¨Jfe+Šp†»‚e†™)©6³;aEöXÐ+3e!(ë™uðf›Ù õâÛo„ؤ¤K§á—D!„Q:ÉÜâÐ휀$[TIA7 è €éÛÜ´òž5¶àYÍ B”Àå­J}ÔÊÿzöÜ1S­„‹_êØQ°üóR h…45‚¼eƒ « I@Ƚª¾jýé_D³]M&†;ó¤eTÁÑnRÀE²aO“–Cª”‚­ù‘küÓ4žÐRLcÃŽÈu0ÚÄ KÔKJþ¡‚d|·=ÓÿI|b’̃[Ï6ÿÑ –ü¿¨›ž² @àŒx Š˜òÆz@`'FŽ—xÎÀí¶_om 3t’¨ö¬,…Ìa"!žz$¥[L}IÔX5•12è EùÑFÖ2«YÍkHÊ£6í³*eefoجÌÂ’6ˆÒó–pÔîÏjÅäeA²ô&ž$Á1 _-ôM<ñ„'yT‚ !\ƒ€ebÔqÙbøå$/Tênf½\·©Æ•›®ˆÛ3ýÇ&Ýe UArèMËð±€JƒëšË†LÉ&’Hu÷u ?ò«‹ÊÀæU³]¤ø±=ò‘ð„ÿwpQ -¹K•>€ß•¤î$)|ÓÌDiíÈJö£Ü6Œµ™o×ù4 ¾Ä*I3£ïͬ±ÅìbÓîëDiL'È[Ng3‘‰‡kɉuO ½¨U‡ò[Rî©€ú^O!îvåUP7Æï‹ ¿&ηKœ?!.Ty–ͳâŽg`AëcrgøÄÿƒçµkÿqƒÐÙí*™.V€ÿ$u?ÝÒ`FàOËxR+¨,²M™ÙYʤ hàœa?gég¯1éÑ&Ò$…àÏP» nƒ5{¨ ‰ö¦Ç Ž#j:Q"Aå+£ÆéÎ>Ò¦û¡ÇMK9žpg¸Æçu“þ,h+à³>|ò¢”Y­'É`Q_ÃýòÃþfQ½Ì?‰ù ² ˜@ȸœ]œLˆ8Üù…Ž`<dˆ’®ñŒéÍÞI@(ùŸéaÛíÙŒ®0SSØCSüî•ÒôŽ4=üÙnTݪ ‘Õ䅽ɨ¢UÀòq¿Íƒ1@Úm}„ ìÇQìÅVL¼ î8Uþø±‰‹Dš4ü,ÿnYÞΡÐþ“Ü´ˆ>äή0 ÃõLîPYþÃŘÅpÜZ["í•_ÅEó|Ìb¤Sÿ,ÇêÀ KüE›Àš'9 ·áh0@€y¡eˆÒ<Ä¡GnôÄþÜ=8Sè ä‘ÓèDÕ=Ï=¬VåÍ~_+Àê|@ˆŒ˜üuĉDPàVÞàÄž„<ÈnIÜì âÉ"çiE•šR(Å7Êz€Þ?=ÜÁš¬MXôŒíü‚d˃àÑ¥ä>±qHG ÊGÄ=5ň Å«ôEûô‡Wå _8"ŒÀ?£' ÑϤ#É(‰´@¼Üžÿ m䃮ÌYi°I]”بÊD m]RH^ &?0_^d˜ÚçpÀ–\QhbèÈȋM¬IÆTÉb‹¤…WÅ[í˜CmÅ¡ô à!œqœàÑŒ2Ò"°œÄƒÜÆœE4®°U€<ˆ“ç JHø VÔ\Q.‚¢JäÍþðÄÕ±šFT‹üÓëEÖ<9`:öLÎpS,‘ ù‰ô šP¶ÈkÈžhÀYìȉQÍA"iDpÍòØ!‘p,Aä GìÆ}H…»ÔQS1_O¡…›À ¹ÎS¨UÂÄaÆ„M€,~Eþ}®]Â=Ź€®¨ÈJ|]ÿŽfñ¤¦ÜÀ-€eZ\é@JUÑ â†Þ`}PI@ÙÜd@cž®x’9†7=E=F\EÛ4Nèƒ ¸€c=b Y†Ôà˜üÃÖ…€†µ–qhI5ý(~ÖôÛG$“ºÅ ¥Eü”p=D}€!´ 7Ç5i‰âd‹<Äb ¦zäˆñçm*†ú¡YݧdôL²„gþÃa¬DŽ!"¡ÅØÃÑ[jBÊ6rÞêÄÄN˜à°ËG Ì Š:E‹TàbÅ•`¨iù„ª4ÁPÈQäÇPýƒÓ@Ž‚:g‚ýN»-W¤DlŽ0D|@T«°ÿŠZ,ŠG´‹âŒÐ–,áz¼¢a^ÓTFÕx°sŽdE%àIðgá(L¾ ,*ÌHvæäB”=g.æS<ãí$ÿÄT€çDE\CÍŠ_Ì (þ PÀjÎE_^¢OP mØÚMz¡Kji„€.é†@ H*bÀí"ää‚fÀÞ³X†>øP”èÖ|È.žGiCâ?¼ ÁERd¤Ý‡}@îD„€˜È'Íì“§JØFËŒä¥!ÊÄ4ÉvÄõOœD\`ÞÈ»êRT_TNebž/0ÿŒ &Å<Žâuhª"&ä?ìÓ˜êÑH†'ˆˆ©6Áj­à[¾ `trTÓ©@Döe2µ‹Päê¿xàÝ ƒhÚ¡´«”%häUë‚äB™*Œ|f!Ü\SS=NSPë‰PiRqà)4Ša T‡‘ަÌâDã àÅýVÉ.FåƒÈk\ÅFøR%D CÀ5Y¶m´Á 0b>`kŒpfe,$‰=ÐÒ@Gó-éI^¾i‚€‡`ÖÄ€ ÙêÅb‘uTŸû)†ûø‡xxéažÈ -^fEýƒ§ªU.|À1Ewág“]¡Í*h¾8äDäÌÊ‚6ÿ…b8zýZþ.lÀ,à\᪂€O”‰É[ ÖéEB&E.ò3ÕLŒ H>@8µxÄ_Öè»jn؆íc «F+)Mðà B¹LÄÇ PR8")Ç´ ÞU ÅP H£z…²ÄzØr ‡›ÌK€¤©”­éâ"+ãrž>íï¿ÚÄ€ÂDZ&çuz|mçªlÊè£æìÉñdA|«\”Ì@ÌáðƒÈ„¿œ&jbª®Ú¿TÜÁd#´Må&]Tl8ñ> òÄ}hmn< R p4çY d™› ØCO¼ëÛ&‘ùkò-ZL|ÍÓƒ Pÿl©œ"à ïNÔf-B¥Éà¾l +M¬⒤>äxá(ášf*LDãþ‡VІükì™5ÅCT·Z >x®Ü[\( Æ‰N¤_^ЄßUŸL©Øl½+m ä2gonFd O>8 ×#*rE R= ×2b.pæF}¨ /ðƒä+Û„=Ä€JPKòu¯rHÒIǶ¨Ê–õK¦êÆ”®ÉM@Ä{ªÜøê%n&a… p¾DA=NÈ+¬5U‚ ïZqEAÈp¼èã -@’®…èÕ©ßþ¬&¬äË¥Yß¾-n5qoä.¼ªÌƒ””ÏIKÓ´=Âÿh%ÿƒ×ʰÊjYÚh';çsvðìP òÍQöWt"7Ñw² ¾Ó Œgù²0oÔhÀ,ÌöêB»¢`Ú þˆŠVÈ>lI ½‰½ÔÚI$Å Jã0b‚(—W0%˜\A›…R4â”ÀÊQ„Ÿö±!ú«;4 kªž¤E"×›‰^TœÁYd¸€$Óã[\­Õ’¥ò6çæqmR„í/8ìA,ÙÃoÐÉ/iÙƒÄ tor€óÅꋘ“rDçm™L6UJ“Ç•þê˲‰…Ìërˆó~ä†ß .åv 6Îå†A8=¬1çÕæ?IÎãÝ´*„¦ìÿä(lÀDtIìEèÑ ¦$%p"b^\£ô0"âc©ŒYòã% lÄÒ<Âè_âGˆš&wsF´€æ2çW7P 鈂À@>ðD»-iAt¢×©=L@ÎņNĉE2“™`€r®¯FÞrx©"ãä=,çMn`­MÌ’ ¯%CvÊÀtWŒ€¥È±mÊIØ©f.#„è]¨& ¶bû˜øçÍkðQ¤s$ýGcØö²ðÐTÓã?£Èpmp‡­Ó¬ñ ûsX³,­1dôˆ‚õ©Üv ˆÉ푵•DtA$y¦˜qûÅçàöÿ²>ôrŽy‘, 6°Î c*…è„¿î ׉-ÎÄP8|$2d³ô¿N«é£JN!›Îzõ_Ê­4»7øÚDêÜ n, …±XÞr¡²ZSèãS/²¨‚´ôPq“%R9$“< NâH…nÈ0óž%ñ(Ëkèƒ@]Žº@/H '=d ŽCfr0‚’"…µÌÃ1MôDŸ„N<œàL3»5{;sÆ‹yT”´å……; ×òÝ~D²R Õ9Q/ ?ä¦ãÙ´°8Û±¦¤µ3SFF6ˆáDQ9lÊÇ\d€­Un`]õÝâ´•Tðˆ†* bEÁÃh@íÆˆ“Ó=„À®ñmRD{ù>„0â½óZÈkñOÞ¿‡öFIØ#½„ö Ò£gOƒ”Døwò¾RžTéRÈ¿˜+æED'w"ÚI:/Ð\úòå˵6 B”†jõBáåÉ»wr^òÎ'=f<é$„= W,Ê¥Jð+e Ù°ÁƒN4ÿw‚Qï|†>ŠÞ‰†ÏCu¾4î™§¿¨ZA#«zûg7Š ¬KNòj¬"DÈç,ãäûí$VXA•"T!m,.ñ¡¯“—<‡ŒúÜ?*p²yÕ!¡;ɦˆ€±î* JY­"„¯àê/¶«vÐÒª19æ.§ò‹„N„ÈBúàÅðf”´_ü#iqRe*pÍЇÙCÉÕ¦¸„¼Œ§S² ´–¹”!‚³17câ±"ß°n£QP õ¶–ǰªo-h‚û&3þyÄ"†ûH€’",/*‰ "* ‘"õF‰ÿj TàšWñ$Kò¨¬×¹*D!ðº_èô‘²QÅî$—xiŒ3}Ì0NÈEv¢3¿ô¬/ÃЉVä‚R²ìÐÐËòP…“,±Y÷›Àì1µ¡ŒFÝÃÚh°•—(ȶ"R>²Í6¶1#” I¬„`'¿¹_šF“еî7xä£bþÑ„zÞC1yÄÈ BÉ‘!…@q"9æÅó.ù YîIz4Q‹º\nDøq­?€û lL)¢î²W”è‹*bõ‹Rú’w.8–_Fô=šH¼ØIJ%¡^´Á+ÆÜQZaˆub†™óæ?æAE"¹ô98‰ÿ,þã/0гz2F̦ŒV:çm.Ê6ƒœ¤n a”P؆!aŸP½ÇZ‘ôœµâ³ ÏÉÈ@¨3HDtÇ;ø\ò¸Ö-+">*y<,’´™ oÎÅÉ l29‘VssRÀî€R%ñ†r¢YˆV¿KeŠZŠÔ^…Šb0ê©$”²•v†Gô‰³×Ìn %·¥¦iÁ÷¥1a¥6SÊŠ¹.·ž ¥7yã›~²ƒœßæAõD ’ìiÏ“h IP5ãdíx7+TàI˜’’glñH>3¥‡h —4×?>Ç›tY´LÉÎ:ª¥ÆtT %Nÿ{‘ŽÁ:Ô•Ïp^íA¼ –\»ÚKìEi;º$°L)¢Ä1øˆÔŠtМ„Šß«æS¡ÚN¡HJC¸êU¡ô´fRKÎTèz4d[ÒniˆLdír ®ò°®½;Ȭà$%Ñ«y©lž„ž$f¤ ¥ø™™Wñ#JctmÀœFû¢DoêR3”sÙg6•>K+Y*–±ì‡¸Ñe®fW„³èè&ØK¨P‚0 @+jÐ:‰7u•Z'°âIÀv’#,U)§‰Bx™ÅV,mWÒÒ‚*]†¸+;“C  Ö¤&I÷à@ ´•ÇÂ9Á» ¡GÅ‹'ÿžwFpcF{4Ä(ÀÒÙ“Õ·ñäiWY<¨æ²×A"¢*çO,ÂK^^Õí]XÂlsŒŽhSŠå£’1D¢¶ÎÍ„8:Bù Q±v’¡âæ9\ÛâI"bB¡ÄflY]Ô“ŽIÐYä]sš“[Ö*‘&$å°uáäz7Õm:D²˜¡ŒÀƒ‘·%C!ì&s˜¸µG-`~•8ÉV¯/’ § d+Ö˜ÿŠ@¯@¥ƒOkª=ÿCèHïá?ü=!@м‹¢ƒ{´FkP£ú¸Ë=¦âàvBÆd6Ô¥±ìf9šãRÞê‹Üê­š£ýƒž®ã1#c’c;âä#FN¼Lî<§¯T" ncDŠ`¨áæôdÃŒ®ŠÙ„Ðå`c}ÒEõ\€¡NïTaÛb¯éNâ¸ÂV8ÀVéèBðgôâ<ÁTÊB–íÊÂâAÞ|ê°GjÂ.IJ‡™ˆ-·„d­/ûn":ú#ž†lΧbðîn<M OŸêf[ì %¢nðEftíÿÿFà Éä~Àò*O6€øAJÉŒŠ ä’C×H¥JÏÙÜ' 1wNÔÿ@Çç,k,2 ΀)WºÂD¼Qö¶­]jÁÑ+Rp ‡¢þÁˆ2.`¶Áùêc–¯3àtl°¥šøÉ(@¥2 «„ÐÆ^#M!B*F'cð¥nä-N"[;þ!oÄ0£NPbˆ¯PÂòΦ]ÚkçI­*.´¬ôn#}¦%ÍlAPÒ—CD0°Üˆh+JÅ ‘ö,yæ Ï|&0ŽÈ…:%ZáæÍÃJ(Z6Æ (/´†I£š¸‹48Í¿N16Ò…6€ ,—ƒØä«¢à!`Ѻdñºª«nf¦#Ïp €n@=¨‚Í$‡¯D ]´Ì1ÿŽ,ãI:DF`ÌÚP{©Ø‹Q²‡,0è¸ÑÁb÷t†µŒN}(ÏF‹³ü"½ÂV‹4Þ‘`шª‰*Bìº'ÃÄŠr%&mÒ@[”bí b ø‰óÂÆè#ÚFˆ6âfS8…¢#_b%šÉêIðZ%p®OZ<Ç.ír¼~ͼ,`.ʰº2hLÞ}Î(+² íç¹|IÚ€¢½ä"ßÌ25°Š I%ÀÞÌ´–®3ui/Š€Çèd¤Šà»î᥶ºåù.: ¢=&íŒ6µ2/¾[6'wÂGÒh^` ÚìK¿ê#Íÿê%p*²-im(  ±& bÄkÿ‡òÈ< ïxb,"çèJJ EåôÞ&}ªñîÔèIL©.V 1°3w%DtQ…?sxЇ³xɦZŠˆ”²Þ±þÁ¥Yœé¶þ¡{ "H¤‹ìx %@ÑíäÇ8žfDOt£í2îÃ_ò&o¤ÍÕêÆž†L1róŽh:PL¼ G ä¤Œ¼¼p$‰ñ€Êh ¤]>‡MàM¾|I.Ê«†ÂŒ^ò{ódîæ¤L è°ôÂ|îêfd0zã ({%ìOövÏ+la0Œµn€‘î'Ä.qdî1·ZóY…Dÿ2ûÒî–@++Mûšcs,çUòN>páî§ °ì\õKoj†º´«º¬Ë]¨k¬åj>€A öo¼ÈKrPâZ’7G„TοšTKÆiå Jçë:¬"l'etæV!0Z  rá²x!V‘/t(s¯g.,—|&DzFöþaAݱ§ % GN5"ìFcdžO4§6³õ$&í´uÒ2/˜d8¹ÔlP©mPy‚²H#tœ ¬ê :Ý571Ò8>eH®“ŸTÀ»òè$ÏGIR&6¡Æh€¬B< ÚŠMËkœ6/øÁæ$féã£fò6"6e(Ÿÿ(ìpäFÆÂ?¿‚Më…L¤æ,EŒXQ¢Œõ$’ÕïGÞoÑè1!psD,N3Ç9°g¡J[‰ì[­ÕÜ/ÙÄ¥Äuçæ%nÜå\[e]ÊÍt­oN"®Ò_:Ã5þfß@c ê2ÊnàkÈ_ÏË( b2J,{.]6¨=­Ñ媷6C¢lˆ-âjÏêÕ®ÃM0-, ò©ráV,÷:‹·xÈVølÎ6PzYyÁ:€~1cj¢h5£#{DCHŠÊÿ¡}öNIWgóÔ­PÃížCsZ㸨MLŒË:ç\ëE¿ B(".·T9Å*N‚SÈXxµSŒ÷€$/åÌK<jlÎLQH‰JƒcRUãðUÆln%Ê*p'ZôÖú#jHD £0p¯‡ˆ©.aDñ…Æ-/VäÿÁXç—Þ¤ÅM£(ì²Ã Íø&RÌ&tpu3h¡ª9¤"5Éz`—LK¹ÿ0ƒ€4å]ðƒ¨èpâ'”Óþ>ã:EX;}…ÿ‘Èãœ+/‘¯jxѾêÈÚ ÌlãUPo.까Ò'&ecn1i^ªã-ì…U¢Àµ,voeÅ"eñTWXyBzB:MMà$FT»%Øù°Ic Xàgóbtû1û¸Ž7§5ÆÄ°"!õ¡]@ÇPÉÄ8öX98";˜Ñ⤚©k@C(èRAó¤òÔ¹…K®}(B8°äJ69TJïIõÙlV5\Ë,ïv"8Ò"ؤˆQFDJMDWJ+óÓdeùgX¹Ü"w¥”’MåÑùÂ8¥¢5":F£˜ÃDÒÿl¢˜Q£˜·ÕC˜ ‚câ ‚˱,ªJQ‚IÑ5„"9q¿$+*$ €5 ¨´6r´xM.Oé~à_@Yµlhl]în^·ŒØ°Ië999TÀ Q±,pn‡Ð€Á„'À8 @YfL¥Üv©VSY/ʱ³láAàº(Ú§êMš> {è¯å°ó‚@úÒ¶å¯ ®g±2I¬ÏCåò)Tz„¢YL&¹ªR õ¦1˜I¶¬üœ?Ck N y©lòV‚$ÄËCR›žUqPKæÚ0¸ Ó»’iÇÄj-ëwlå?]™³TÑÚöÖZ{¥¦J+ÐP¢ÿ¨'NøMj¢h(ðºù7s:º6{Žñ´ú¼åkîóf:I!˜îªê'^Æî‡Ú ¶Å%NfÙ¿ÉXkG®[¸ÿ†"K2`ÆžüT׈Ž+‡Ãl6¦UÇ©Î7ð§1æÂW¢˜‡ÈzLm%ì•!¹‡ˆx!~;€ž;Ð|⛵[‚:Âø=XÆ«U˜YÀ¯G7¸5[¾& ‰‚ƒ­§Em„TO\¾’Ú ˜²øî-¥¨Þ„ýÎFµ–.»Ê•e( Ê%@r Q‚r(,å«ôÖ0}.ù099m&ÜçÂB¸ôÜÌzÛÈzÃOÂÁÀ#?Ù|Îo%FŒ§–Û±”Òÿž®= Ãº‹5ëq4:úÏ…¤Íø£k3"2‡C“äÑ¿³OuÃE¹^Œ«Ó¢,n¨€HLÀj zLLL¿G˜¿¨×¦ì<"‡Ê”ÑRÑÆœÚÈÉlj½“¯j̾¬½Ê KØæ†NïAbe0„=WŒŽé>Ð'šÏ\ÈÚ1EVjr'—¢‡âi8C¨P"{ú—Ðq£ÐO¤Ï˜t‘*Ç{‹[· 7Rs°?VÔ†alÈ¿Ò:VM"Œ¡–  ¬HCQŒÔ ¦¿¹Î`Âåþ•àÏæÉ:UŠüu×GËj}øyÖµ$Ô໣â3Ñ÷weàìé@PîYé@ÿóüXô\e³x剳{î1në¼Ysobg½}€{ý¶FÖ焼•9Ý/fo@Ÿˆs-$ƒŸ–îý¢žôÿAC…—Mô5Êüû~%øÊ¨‡b,õË)ç|pŽ?Gœ^;U©qJnõLU+BdK_¦6Ó3É‘‡¥¸{HBJ‹0ü‚0ž=~MüX%*àþÁåÄsmž¨J@¨J`4¾=€o^€ÙemºÆ½Õ’P@ÔÊ[}ó tâ+K‘“€bv·=uâ^ yÿ–Ü[b섆-TÐ+/"ÿ"ü»xcÅþY¸È¤È Ü@„蟈ü$ˆ¼¨¤>~ÿÿfŠˆyÑEJœ1W"rñO'КDƒª,RDU‘^H{9UÕËÇ¥©—^þóñU«V±Vý×K$Ö«ÿ:\ìÀËlL¸ý'a‡sOÌ›÷oÞ 'þõí{Qo‰|—$(Ò ×—8à@`1{‹/Þ“'Ï.=z!B|ˆòáC>Ñ£EÎ Ao½-D6aÝbÉÅ&”O4QHÏD~)Aš\ðÒBÇ‹…ãÛpÇ Dô¾QB¾¢ùf„‰HßÍŸ2³³¼˜Ÿ¾Ÿ½]äs¡Ï…‹_¼~‰ø¥~ý¯¤½¨Néõß%Jú_ò¿zI~aUHH™õOeyЖZ&¬E—\Œ0bÿ^y±ðO {±€#yæHòv‚a²UÆÁb)þÙ?”]Ô"H÷¼xf'´ gö„°£g¡ýcÏ?…R }ÉÓ’}i ÛŒ÷4qQk*™?+ù–ÑEuôÑE ˜%9SúL'?ÓYg 4]$MÞ‘y@½‰šÿ8áD..øÙçž¹øéÂRöMåƒ*Yú~ø’'>ôâ YE µ‚@x‘ pÉ%’…óð¥áEþã¡^ -Á‚AGt؉‹Q¶bd1Zv«Œ-ÞŠ™<á˜ãfœ¡¦Z±›EÉCÿÐÓ= AYÐBä†oÿÜPÑ…ÔåGÉ!çÑÿp,ÀJýsnM4á4ݺÙyWw*éc“xëÞ„î²m´öO³m´±g|îɧŸóE¥J¢‰&샔<Ìß~XIåÕXÿ¨¢¨aK zêÁ?l!x‘Ì%*^–jêE!Ä`ÿ ö*¬KÈ,™Hèê".FF+‹‹ù:ó v™Ú‰1|š_ v˜$.aWY\ÿe¸‚”yê,žrK[à‚ªi.C3c âÀQåE/™Ñ Ù$‚LÆtˆI‘ë„£{ØÊ*“4¡H^ô$Êx1wÿÀ“þ1­e²m€ªF#…LÉ [ãÇEò›qU„#F I=bKlkö2½Ö̘„O'„×tPÿ1䌀ËÅ?œ)ÃýbPdŒBŸrqž‹ Nýi\eÜX©t`SºHÈ$2º0Bs¢ò †FÇ¡ºdæC%ÂÐéff"\½nf"¼HëfÇ`rEŸD!’*…XM K€Ú5c8ËÆÈ ²§V"b^kÞ̶-âˆmÝR[H–ÿ8‚té;R¼Î›þ1ž°D4›a Ñ–å¬ìЙÓô“ŸÂr§0¥PùÇ/ŒŠ”öe%IIÃÈÒ¿ÅaÅ/)ƒ8eÀÒ%0ŒÀ(Hø2u† Dzé «fv ’F÷(ÑßIÂÕ2´I’aZc4p` ²ñÝ(ûµ§‚øl!P°‡=f²‚ 6OKËéHô@26“†äKºN¥ÊµÒ¼Õ¤:UbWöÆ·ã©FjÎúGN…˜EšF5\{²±‹íïbE/l{”ÄIµ›” ‹-%pS" Ù?Úb‚  jYŒ€=5'ÖP‘./{)‘`1¹˜›äg¬‹Œðÿ¶ð„&¤Ìéz£¬½.E·yšDÿa ãAIÄk‚…ÀJEà(Fnpmi„±IÜ@d‹(6«8›E“> p5Éä;! M L¤Œ& Þ«Ž3ÓŸÇGóyORšz Œ!e%GMP2FAnb»/6²qš“AƽÈ:íá!fó€Ù:…ü! © Ÿ¹3ˆEÒ¢…¸U¯ ÙÕßzIŤ2¯±ñçErøWßiÀ óžðbØÝ8¡8a€bÙÎò0°c¹e6%n€"¼ŒHuãà¢Ø+ÐrËtb2¨|PóO‰ñzÔ¨[ý)H%¼¸lÛ(¤ŒÿÅb2>®ÚcèX@&r©N ä°–$ëÜË]ZA´6ù ¸¨Hdf+Ê4¦»s}I&ù%PFíE¶fHÔl¨h©À«ŽXÃ?ºñ„ntc1&ÁVI6P’ÛÚ’Þ§Ç‘zmŠÞ{ɹ:ë=ð}³êŠ[¾¢2š6 ¦5­¢€Í4>šMIP‚DÀTOº[LÛ5qŠ„Ç¬uÁ:–ÙŹ} +=©ËäƒÐZ­)òêc´ë^û:1|ŒbèÚ‚øÆ7ØËšï=ßÈà,)Ñ*?sôê Y[Ê™\׊iKaò&vƒ„&ƒ¾›ÑE’.ìÐYK%º²é‚ÛÞÖÅÿÿvϤÿ=iá‡àXaÊ€.áÔØƒÈ"ƒÈÇDù‘pâ"wA>2ó"VyðCGÊŒÅ_íÎÝÍZv’ÜgˆªÜ˜½ o\ñâ'z@kEí³ßDr»¹VáZYÀØ*ïÉ#˜+µœ9EF€zÂB77"!&ÖdQ ÿSËâ¥e?èou+Áb»7u*QHuW×FG `­1U2mjž2ð©Âjß—‚!5rw‚ÓÕAqµHáq¬óo§IÖÅBÇÃ/ _ñ5P¢Px -ADK VyÜ–KvKØæfGW%¶Y8to4lfö°C÷††bt†æX¼P{¶%‡K¸ei"'!P!c7‡‚u2 „dËõ|˜!WÖô VdHºBl¡]hx?Ó}'ô„Ob~1”<%)ò$8CPJIøNØxs×B ¶`æ 76FTsŽ…mEäÿ Áã–R-%L,ñgzòRsEoªghB—æ=@1•v{¸%thÎ(u"/6ùP!¨òÈ7&`vÅUt1BŒó zÇOr…j"1}Kð*#2I‹4;²A@³ƒê¸w½Ö^~Qóp:¯‘5-ð>_võ„)q­ 6öÇ<%¡gÛöQu&gØöX•‚- Pvj"Eë"8ñ„ô6ŒVé‘êQÇçƒ[.Ðc& u·õ† RiÕHpE ÀwÁc·‘ñ0ñ`@.¡@ÿà“ó-qœ$"²qЏ9G²]¯#I’D~^ÆX&r •ÿYC'@xñ·ê%*‡xO7°Š­0.1g`Ed‘̃`ÐyÜ–^“Eù‘½¶5hh ñg6v%. Jáb¹7 °e[0¹Tqx\§{j”“7ÉocaFòÀ/¡9áhŽÊ¥”.1Ž“•'ÒŽƒäN²¢H?#P;X¸é}€ÇWg 5h]7?¥,Ä)§(rgˉm•b…áÖÉ<ØF.7E^£&Aho´5@s1aô¢Ës¯ÔTÀ%[I¡“R×{0)ñ`{pX — |ØèLÉ”lš¡yDÙ¨Y2ˆ`'3£"`P3øÿ Dq|ÁIˆ‘•÷¸k>³=C^9Wèµ,¡tÝÀ \¡ ‘f–xO(!•ùX‘Å¢;·Dä’E,Q1˜5š/çž\q&ôR‡¸— J¡žƒiU‘bdq*–TpøŒ4é3y˜>Z™ â'Hçè“rñ™Dš`æˆG€ª9%КÿÔ×N›£ oµƒ1"~gI"5x‹g¢yÊÀÁJDg÷Ç×~#þ‚îá%^ū℡ÇúˆA'4#Ž O ãVál! xM0 ζã•õ°C€C Å[äŒy×Ry–,¸ÿԡÊ(jòÞ@Â#¹¾E¸nåEÜ®™Ì#N ëQ`X¬t†Æ^kvð‰æ·çlÆ«M“ôPB^F»9sç`Û™mÜÿ€qíÜ qÌÆÜÜs  ™wÝ!ì¶AÐ× 4€ #ް½¶•³òû¾é•áB²5 .¡á§þ 7-Ù¹sY$Óqz”Ÿy&¶¾U@o幡ëNG$=bߘCx²Y#–iæe4‰Ï ¹ÝKpÒǺï;£íGç>‰Ë$ðÞ"„®Ñ‚¾îÀlÓ¿üÑõ0¼©Çv+¡>­/õ\±qùÿ< C€ÓÉÖr-ˆëƒT}Žé8 ,Øö+ž<Ë’ës,xÁéJ}a$þh,”^3”ÎÑNÏùò`A“ž -á'ìøÿþﻌ/Ðíƒ!¶G Ëf\ î„îáìÆn¼ÆJï ðk·‚»›så–>õÚKê%–Ób4J! °ð°-%Qy#P±¦i¦ê¨wqŽ, Ÿùê2塽ñ•Îd©Aý£Èe~ÑP …$Û…Cý¿dè=a0©N(^÷èøû`ê/ÛÎÐ$PÝs[ܼ\©PôVaÓoún\QÏU ÿ^°À€ÿáßB >„¢-^ĘQãÆ-Œiøw˜È%![Ðã‘kÿZý‹ÀàÇ‚‡ˆVøW‚Å? yþ{ ü†òéã§ï_¾‡>ü³ÂÞ¿èMýGo¡Öy'".ñÚÂë’KJ69áUƒ½NÚÚ‹’ωܹÿôÅË—Ïž±{åݰpßB#ƒÎá ÿ!08bªT þYNµ³f‹ þy®'ÐA^9òCß{=9¾†[öEcG–4ÛDÞ‰yÿQø5D©DÿFü«0AçÏÀ9öåXøÈ‡|†æã÷/ûB{O»‡ÐšU+#zóÊ·è½°ÅBÿ°dÍÊÓí±… *èÙ·ç$ÿT{Lí.mc=8øçyä! è{ȹ‡xàˆ [¨Œh3Î$²¬ž b!\á!J8 ÔRûI†Ù^„1Ƈ–0·&n|¨ ª¢ Ç(¸a¡~òëþ‰a§‡$‹È ‘))íÊο…>ˆêŸ¤b<®Ê /$õòª£t©#ú4 ‡Í6 ú'Šò)à'þi¢/‰r`P²Ãö)¬A ^ ‚ KÀà‡0³ì¡Ì@ÈŒ3Ï<[ˆRÿñÐ úµ‡zÒSFQGÍÈq“¨$ œ¢J›\¢éŸ"¹Eµÿy.Wÿçø,:ë”Jª¥òyŠ;©BÐRªÌcv¡yÒƒ(¬2Ï<ÆZhb¾­ *`Î:58µ‡zƒLÁÃÎý:ˆŒÈƒÅHhL'…2«ìŸG/[èÑ{=L ÑJA«Ç€\˜ 1pí§ŠHe¸áº‡ÖB-‰z)ª "¸!Ö"3z®Á禓à(œ’ºŽŸ¼´\YdÃ+/+™Ã kFjÑB‹ÌæcS…¹æ´‡žïÑq·v’çÛÕOÁpŠP -!!Ú,R¬1½ÈRÿøN_PHÑ8"T‡×5Ôˆ lb z#ê·‡"õ8œ0‚ŽéŒÊ©(Ên¸ÿ¥š‚ K§.Öêâžeäñ˜Ç¬¶Ú’BºQ-6éÑo¡7uŒ¯£XxQtÅu×Ô|à… 'ÈI3zíµÌ_|ýí÷¡z@óšà‚ r@µÔ¾šmã_$0ù·%zöƒßð~ˆ‚ãhõi£}€€:} QJ)œÊ§‚•Y†ª‹ƒ~H«¹Ùcÿ!yØ{=îîl[øþÙí D:Aˆ˜”  óœ™ˆ% ]e´6»Ëì+"–J¥Bã!À48 :µÔ$Ìa‰8^lžP ÖHŒ@÷ ZI¼ @ä%­x# %˜?5ÍA¼ú@”Z¸ïýg)ÅzJUºc±D.Z~©–<Àÿ¢£È£,dùˆVîä د$ò 0 åä 0}{Z“Â. °ÀD%€Ô†j—¡Œ$àkº[ˆï€÷Ó@$5tpØ0–°°Æ&bËë‹ 2&à%¡@ ˜ uíiIF`Á†c¸Â½ÊJ™ŠË"×8º9K~øküÀ"–k± +õ#Kµr #ÈCIÿÀé4"@¨êe|E/ÛuH"nœTDBcMá®cQA:µ)4Lm}|‘žâö¸…êCˆ`D.×|u œ G8›0å)ÔÁ$xÀ9òü$bÂß?Ús‚÷•¤,î”YßÙ¦$VïSHº4Ðÿ%¥Ž–êªa•¯56*R¶{ˆ×"J)WL4œZÈ ¼ naTOÐÑ?Í è!oCázÞ—W\Ó.täÿÒ²‡`ùˆR¡Wu¯pæÔ’9£2Tð0kZùdGäÙ‘0=äMDlb™²„å !*"À :g_ÅU è/}mm6ol©Àèø±á<Í?ŠARº.d °|ÈHåù¾hpj«Gˆ,e‘„骫ézœ$-²`-„)ĺR–¤‚>ò¤çZdRϵÄB­´ÁbN "{èù¤Õô,(A¹þ§º1®6i„íC_š–Ž¨‚)F¹V ‚ÿBF©ÖÆ$ŒTz%šRwRµð RØ ‘K º'Ã…'½’÷¶³Ó‡Lé?*;œ–ºÓòÄÌ<¹ÖQç!¿«ÜÉN ­¢™ÞÇ%õD!*:-P¹Ú\‰õiiL ‡bÌÐ\J `Sënwû‚ø6kp  ×8‚#O38"\h8–Õûç+_ÙÜÏ„­ðW‰Ž Õ‚J$ °¶‘ì¼j!ÛYˆ>.y%dE…àq>1˦Ô‰NGn“™0’O©Hµûq¿éE\im—‹‚$("Ñ@·ÍhA*X",„"¡ð„󺼌…°À¸ç»b¤ÎÿaÐqÄèi=G3ÈBÄìܘX"$(ž‹S³4ì‰3Ç>´ÈÞò²c-y'ˆϧòظÀtQSDÒÐ &'*Ò*†.‚ºÕõÒÊøâˆ+5k$ìn~ˆ—×Z LS<àÁ 4ˆ „©™›zí3ÜàF4µq  ÓHQÊíYÏ „W‘öÙ@\„€2ò±-"(>ä5yà€…Bm!‰J˜Jà}K;ÚAÊ»§oÇJ¤X‰³°t8¸ àÙ‰w’,¦÷…Št,X‘§xuí׆ˆyÎC5þ!Ù“wpÌu‚"°L¹‚ÂÆ@`I=/„ÏÆÞÿ6…Oš£ÍÙÐ~˜Ë—‡mˆ$ÏÜæ³vdú!Á =©Úý šIƒö!yHR’õ'¤yxð¾fJ¼ø‡ôñi¹,¼Mô ç=Z¹v„%䋈¢Ó´§ùí¿VÖZ£@0Ø$ ÖnÄfK‘Ç–,"j­è­‹¹•ÿ$ÂÖ¶Ï-ªl…´@7ï‹ Q8Ò OxÛù|$ṽBˆÔúÔ‘k :±KRâæCêÊÕb|õ{ww»×c {(¤ñ ŽˆªW·ý tã üP/ÛX©ÁÏškoæêÿ?ØÁúÜæ Ÿ\ˆÕ©LÌÜnþì¼æ¼ç ŒXò¹-j쉮kz R&çÊt»&D±#R @ìч"²1žª |‰8Š¥àü´ˆp¯ùЖ8„ᓸ¥ Rn2¨taw{ˆ`1 é¥5º l#~ÙÁ«‡ò+°–âõÛ—ºW nc¹Ÿ©Ïc6‰¸‘O ©‘z³ÍÓàú<¼Ê¶nS Q& €Ïa¢J9±ÙÆP—²‰ˆ©# a‰Û.ßÈ1îÒ‡–@™£à4ÇÊ·åÓ‡áÈ‹ˆ‹ðð¬ÍZ®h« (ú± #ÄÿµD¡|ÁšIɦ²”é*ÃÝùYó #´ˆQôQ¼& Š è‰ù›?—Ó+Ðyc°Bõ¸h{¶)”E‘Ò6¼úÅÈ;® [7+@”ˆÑ¸Í8$Ëh… €ŒS›8 #¨º§Ð±}³ óá@„¤h ïAˆØC~p®óüX} zXDy¨*áa‘.‚JÈ…x;ŒØ;¯™  â»YË&ˆð!9SĈT\·”•{B†HqyŸ¨ ù© ˆH®…ÀfÈ{Ì6W¼pq'p‰ga†°*d¤³i¤„ Eé>­b±wëJüGOœ ¶ KȈúš´Œ#ÈYû¥Àª‡ xt±Êû«EwÔŠ?ƒˆ½„f³¼%°¼·Ñ3)žpžxŠDÀÜÿ9¤¬( ¬@ šôuÁIyc }¤£è@Ï\o¼@?¥Œˆ|h*¥r'¯˜ÁͬÂA-º=×Ð"F²Ä…8$µ®¼F΀yˆ°Ëó+È‹HÅõ‹(ÝaÎr…œùBø@Ä­ð¬1áÈË;)i’ˆ>ƒ¼êûÇK@“®STKöÚ!xMRˬôÂlì.|ÃÃýF›(”á¡KDÙ 'ˆ‚ôÁ `P}œ¨>-âǬª¬B›²¹ÊÝ´® íšËHCŽÎ Q±üšT´”´DN8B? lK¹ã¾a”Q¾ú¤Ï '÷²ˆ¢Ëh+!-ÿt¢!µžÈ¸[çhÔ 2t)ç&ós id2î(˜º pЬ“RÆ2¾²‰à£’(庇©pT™2g™‡¹/[ñ ·û‰…ÓwÛÐeº,щ˜zÐ(p=¥­$ÕϘµ$ÄÀs… š‡|˜{’ªÉŠE-º¢KÐGU›7‹¿Ø™苨̀ym< U„µ9E¿~A±z`2x“Í›¼ž›*™£¸ÒëÌ­{•*é®ûÒ¨XTvL×m)×yø b‘[¦6EV«:Váñǂܻ‘帑 /;iQ®QÈ!ÜÓ‚ T ë3‚òt¢2Iª‡˜¢8‰Fÿ½NŽd³À Lœ;¡¾0¨ÈÆ£¸Æ{W¬úTÝÂϰŒ~¡#RE±Ðkœº^Ñ1#áF{ÓºqŽ>´ˆøÒÎ)ŸÐЬ!yÌ ò´A›Œ­©«”ˆSåªÓÁòA“ h K…Ö‡\ß±;¦ÈR-¿8‰\­ å3j!çr€ûZ(³ÉÐ $èIQÕ-ÈhŒ+‹P¸4ì¡G«À;tæntÕK ¢;–Ä¡ \ŠÇRœH›|ˆ­ÔTB†ˆ7ÿl¤‘ÓŒ@†ˆð…àùÄñs#€ØSóû;ÂÝÖ§†ˆ–’]QŽ“¼p~ÎêNKDZ^ÐÊË“ˆÜ¼Ð‡yЕ+bÑ mÒ…h=®9ÀH¡½ªë[ã( È*VùËžRæ½Ñ@à›UYÅÃÂÁ·üŒ,Áãë8ôá+Ù‹MÓœ@4©ÛÉ~7iàt!ÖˆHÙ ^ˆZX_8:Ö›7 v†ˆ”U'qϨ5ã9‹ˆ.À#1çÚˆ@–\èçAì´±›¤tœ_#É%D zHôã[–ˆ‰VNñ——Ø;£µ‚ › ¨„i롘mϤÒ<ÑDÊŒÿˆ‚bé ­@–Q~ b€¤AaO9‘Œu²4 ¨ÝÜ/³mÒÞâ„Іgõ[ˆ æ( 0pЀˆ¿;Q-³5lõÓk™è¦xßîèSîjýR+ÙC» ‡{€K…°@õÓ 2Žšµz#D1;àåF LD­r Þ„œÝíFˆøO)٩уÕàs⪠Žk–f¬È‹€Ë ù·œèbÃ$µ«i`3F¬Dû·оˆiÕ àrŒž€RjM†çOQ8ºµ —€÷ §´t;@¾°³Uÿ8å–iÈÒƒ4€Òèâîâ7ZCØ[_¾ &žDÿi—b­ÐÎ ¢k!nü›ÐôGK +r¬CŽa9ïЋÓ¥` ¬¢×ì”zŒ;Ë^aIJqDîòŸ¶m¢öï‘Ó@p¥Bk]ΗMÑ舑€8_ #[bøÍ:¥,<çjŒ¦ L#¾& b0q{€Æ qóÛ½{ Øå 6Åò6ÅXŒîޛ툒Wy•¯1»8™ÃÞFáu¬:Τ¡:ò/"FÇmƯÒd~ŒeÚl8µõÐ~/'µ4ßòŒ’xŽPð°ÜWa2ÑbŸð눋¸x&Žˆ–_°s¸óS.‚È1zxŸëkÆ‚h eÂDE¡hÿ¥NýeÓÿ‚BîGèØ_Œ±@Pwco§M×`ˆ ŽþÈ—!åÇò0ëš„¹ý‰š4Ì Å¨4÷òmö1ßõ-ÿzˆSH/˜-[ÎñÃVLádÍäø%æm¥ ñ‡0ym ˆPùhÿ‡"d¹*ÇÈ5ŽúÞLÀ HÉIatgµJ×Èo9…îÝÿZaA„YEŽÓÃììáÃâÄ©'Ÿæ©¨c š'#­Ó[·Ã¯¬Z±é¼[‡éoŒP?0‹ €©-7N›Ó×CÀ Žˆ±k‰=ˆ_ø•‡UPyç§R{d$ÃþV¦S Š^Y͈ ]Ž.I~ô{>ÌïtŠu/Š#yñ ïŒ>”ö ,ý|¥g‹ÆÖ‹ûwÛŠ„¸Òá €rÿGþLˆ!Ç¿þåxƒ`@!ù ÿ,éÿÿ H° ÁƒþןÀ*Dü÷ !D Þ PÑ?C7þm¸à£'íŨB †‚%*œI³¦Í›8sêÜɳ§ÏZ„XáŸÄ ù>Ø#h¯ÂÒ¦K4$•èˆ ?Fþ8á`Œ—.O´üç0 >Óª]˶­Û·o *ZôŸ=¥WÚZ°À¿¤9¤(ßÐ!‘tõš¬½x# T` Ÿ… ø0”Yß(™ ÂMº´i¶!© äk÷ŸŠyö–Ò;h ߥNŽ¨Ú¤BF—ú¡ÂåË–7Óćë.æ¢OKŸNÝ-¾ZžˆJWâ¿ó¾ÚÿmIo©Š–Å… ·-Ðï‡ÝnTd!Ï àŒ€ NwxñB ”™AŸ}¶Ph£<§`u 6èàA[i‡ÏVÿüÐÛ@*}GÐy`·Añüã×?ñxàÉBÜ–-„™Bž ù«sÕK­B‡0³°O?D0•µÄ=a,ÐÅñ®Æzÿ¨«®K7/ KĪ*A1Þë› x>V+Бÿ(ìÃ<÷ŒÐ(ÿ`…èæÁnÁ:o«)t–cm˜©kÿ¼$¯¸¥yæ¼.¢\Ðl'ðÃÀ‰ Õ,ÐÀ•ý¼³Ïl· !A”PkBò°pã 7T0®ÆÿÿpÏ zdLÔT·tà­/¬ôÊÊr{7ºÙÚ7't”»­yÛ@ÐB­ùäSP}L@Á?¦Ú¢@à7âÿÓ1AЧØsÛ*ãôº£âöDn¶Ù6=Ps”o®|’ˆ\`Ï!ÔºTàIpƒÄ­P #Gqpìñ¦ ÖíâÚKÏià@8ðnr€qüá1œã[¹`:§¾@ÚåIIŠ-c•GzT@…ñÈzÕÿÂÎ é#Ë4´Šg¨u»àWâaFÅg GèaûÆM…hÌ[¡ž^jÅ}ñe0I¡•óÁÑ!"ôHÕ?$–šðOc :ÒôfÀ0^A.GÉ ¸ÁJZ4Q9®Ò¢DÔ€ìè¾À…©„#>ù¡¤ü%$CÝJ*– „xÅÄ“sŠ´¿¨ã¦ÿP&ZâÌ ãWpœ_TüR"×Ô•ÝbQY7<°CôRlìR…”¤ú¸>±€ºS &ZtäUa )ÃMç$Po-ÍšTUÝüŸï´–"~¬ $gAÍòGV‚xÑ9– ÔQŒÆ 7iO°s³¶ ävü“@j.#¶™cEwÚÃ%hLG| zj[Û‚ðEtü(-"Û»ì6¸¸ºaLröU†ÁÀyÈ1ÓF-* B û˜ ˜…, ºò¬y¥Q4SJÿÈ@T*\&¶Ë²“(8}˜×ôþ•Q»íÔnÃxàEÀñ<²/ÝÞ%¤K™>‡’¼Ì K4DŠfRಥ³X"< µÄ³X?(\>xb>€ÄMá,šÄ@ ÉÁ!°¤]àìÿ àû‡ bŒ.eê‹cE PQq®wÅP—  5iáö/ˆnO»ò1‚x@ ðAóñš—l¸ ù Ê (‚,Ø `5ˆ"éþ#)¨‹‰,Äá‰R æQ¬`"0m 4§ˆ@„~¹€q¬‚z€DÀ€_6»³`A¨ 2¬€` ²3‘£¤(Ay Pð%Ôx%1bÃ?ò ,}v&Pâ w±óƒ(IJ4Lˆ»ƒ<$œÝëKÆrvµ§)ÂÛ5˜\{@¸Á®ÿQÑu´¿ˆ@ôA~&$¦ÇC2Cš£Ê Š §ÿ Ic»‚ƾ:!¢Á °k\;$Ҕɇ`.Õhœ!âÐ9l}\ä:±6Ío0¤Ès)˜ÚK, [.¦êe6· 3 €B1Ôâwí(.àÌãs糋–4À1oò•›=¬è=h«‚Ù]DÒZYøákó¢=$ÁÑré]tð¼g®çñ‘ç É 91³H™^[€ˆ¹vIlíØƒ¬×7αø‘ëä\DˆÁÌë‘’òCâ7¸1/pý#¢+ßñ¥”"œ„§Š/1ˆ!gƒ’úî‡÷ÚpÁMhmTÙ«†–$Í‹å™Ï{§<–0¸@vá9:ˆÿ_˜Ú—×󢤲QI§Õ¤| ¥ªúI0¿*$ ³ö¯Ìföiz0].þ²Ç…7°«EtÀl2·k @¤G£:‡W{»VTu)¹Æl+7 x"ðz¦·kRv)»Å#9R 8‡%™¢u*p4vÍ7Ó70+sã‚QQ!¢K`}}ó@¯²bA8½§ å&TS8ý%«‘A·/²3H±a-p‡¥xúô¢Q$$:ó+ÏQLÑ+_FqÁcˆ‘{¶cU`SÏÒ'×Ö/+зv4ÿT¨-wp¯Ç#PRähZ¹æh‰ÿ؈hZ$hx"bUY8z´/î6=…E|û8ö4ØáažQŠÅT C34kø­ ^}³1Õ$QeF*pAHˆ„áñ}&Ý"¢³'LÒYøìÒ-À%åa8é'`|Á_ÁiǓӨ†56$!%7!l»)ˆ| ó «æ¥z˜297Œ¢Ãl‡(-8 | zPˆ!x´q¹Vý²s¡ƒUB)ˆqö5@ÄXúq$£8Lb÷#s¶JvD/RX±áW Ç$—H…vç—b)¿X%wÇ!âLÒ.ÑHØR4„õó[hiÿÁÀX÷W6ÐAõgʱÊ1sýÒxSz‡xù Õ`0`KÙ/Ýv4G·c—r4:@·†yðh{Èt ‰%:¿õ)ˆ¸¢R÷±/ÀBâaFr$Ú! 4?ðKlÔ"d÷bõqˆ$-9*Éw¾Õ‡¸w–b|*dÑ"’#*ù‡GéæAƒ¤N‡b‹M#áübù0d+ÅOfsY jgCq*§ÞX{oX{¸c‰u):Ùfi ~±[9¢•#ðh¯‘ý ˆ zGS×¶”$U{¼©“’Y(8¹ì²&q¥ÿx9Âò#BÑ %q@r¦uu«¥‘ŠV™¼y4¦e³çT¨–X‰•{±-ˆzéT“[.ætM°£).M0.ôÀ/ñHqt`eh0?YdB›Cw1ÁcQG¡{é~¡# ƒ±-±¡##@iL•¢©"Ї×h@µtúx¸æñÄPR(H%IYj‰+uÑ|@q9•±Eãq1MS/ßAHLaw˜éõép•É„Ažé™ÂW W¤! J@ÿp¦Ùt ¬rù5qB -”†#A”q²ÁF€J)Ü8‘*qX!:ù@ Ánih·Ã›·ÿ“Z9-Ñ7zшCwˆ$… ($…#NÈ-8Â’[Z‰á•4cX!h!1ö£µ:~eG,°*ŠS.Ôsi’±†çzù‘dªÇx5‡B+ ºALe5W#¬f:;ñ#-àAª):S3k“9üÓ+;¦§:%¶é~¡“:iN1"ä–ˆjF]Rµ˜V2ðØõ."-åªD0´s»Q£ùz·¶_¼Ù[/z¤Š©([¢x9’ôuq=ËYBêA.hp‘‚ƒ5åQÂ娷ÃDz8º#[ǘHMpW)“&j Û×ËŠ“±wadÿS9=²”Rr‘§ÞÈ­FÑ£×›¼w<¢O€pöpA/‘0 20¯5TøzÂF%%:9f{¼91Ëùz`{”N˜+§šª’å†|)ðoÿ0˜G€„^s‹Ä>|ñ£FQ‘D°D2ç1_ ÊDz;'°…Í#Ûw¸/–¦òpŒ7Y?ô଺#…µñç4K3Aùqu¢%ñKx3†ÀšV{¡{!F»¾9Ýð¨ââG Ñ8±Qµ¸v–—²ŽXdJ%¥¥aK•7³|Æ0-‡¡*Þ3˜„é2ó&ÂêøBŒ±Qá¹>ÑGƒ$Œ7 нöÿ²… º¸áR²ÂÕcß[5’û!0°ÿ°gÑiÅ”† &”)›ˆÁæ¡;™§*:G;XŒ°>T:ÝJå¤á,ƒEz¦t')´Xš3ÄBÁHD-¢J³"R4ˆD±å!|ŒDØëµ2.e‡&HÎJ Ò¾¡Àxwi!€š¡¤\ørö—`"ñ—ÉGÁÃÁ#¨;—š¸>I$ áJ¤D‰`-º-h›º—–DAœƒqÁ\t°ã¹7è!^|CvUqÐ+.­b˜´‚Dö"K—f|ƒ…šxÁ/w\+õ…O.€.À…¬N6¹íÿOî‡Q¼³6:+QZÜÁ¿Ö‰º÷_ÂE—•f/Rœ^ ²0Ê¥ÁD±q)œ@Ô©“$Å£ÛÒ/6L‡b|Ë7 €CáŠtA.¼DßqK¡HKS˜%$²X3 j4Ì™5,Oÿà ád!§¢Ó¾:œq­ZB€3#'uJ!R‘§Á¿UR*È$,—à¡·‡3óJ¯§±¾ içÅjÉ£$Yõy¦(‘Çk›% ¬ÌKy»ðR«ó=/½#Œ»¾?¦X‡˜–ÿuiGy¼@¨ºÇð´i#1¡Ö4–u6C£³rÿOý+ЇV•á9ÀÁö"²' À¤|‹K@Ô¦!²ÅñÌ¡C‚Cê~’¡pœäé#[QÄógX# ¬8sa]¦dM/Œ+=XÁö[µò÷ì3=²-º[»õ½!ðÔ£A¦\T¶Z¤ÎÑCuôCo[ÇLq/çk«*wE|ƒ1[X²"p O¡˜7—@ —0ÒHª .Ðcû2 ü'­ÉIh8Vg#† ¢®'NŒÀñ¸Bm/ÃÌl“&"k  ÍÂõ¸Ò³«ëgx»ÿjLâÉ-À·À"KÐÁ1˜u»úb´Ãš1±:"$Ö/Æ@„™4»ôX;Rž]5ƒœFܸ@Á/å±xpº3Ö‚Á%¡£ŠI%H¡ŒÐ¾0Œ Ôš=„¨¼0iòJ¯”•±á™‡sAÒRá™è­Œq¬á|G2!­@ÝYÝävd?Dv~”‹l2H?°RéñsW/ò*3ß[87Öüˆ\¤Â½R” ]îïBðå`Ñ€E p½>]Ê1 ÔªÐ=2%0G«Þ¢C#Ãe‡Ä4ô-Í8÷ ÙB“ã}L%퇳…¨©Ò±è[c,Cÿ³[QM~éf.ÞÂÁžž~Ñ!ï0B¸Òz"Àc›þž3— [t #Qjt-³N ÎÜû4¡QR3G²Bña°ß_œ,|ÐäÓ‚{¸i¢â†+ÖbÍÏÔ2 ÷0„ãÝ%'ç%èèMæ yi-¸ N1q,ÂläNCë´9ìÓX5s|ê~ÌÙô’½ã͘ö[û%YNÿÞåÿ úŽ´åëÞgú ³(RÎ^_¢¡³†°=˜èÍY¨/PÜD³RÛ0.pß@rï$OÐ^š U`ÇÚŒÃHëp‘Dž1ŠAá¹#G°}G0äõÿmAÀá-¯uð¢8gò*#„Wg/)¼Ø¬¡õM RO Ä`³aû²?d~ 24Ñ¿óÑcÄÈÞÃy1ž ˆÐây—œ@xÏãGGEŽ$YÒäÉ’.žØ¨A=ÿX.Y‚PÃCzôþѳÇ(DŒçÙœ§!ÆÐ"EòÇÅ÷¢ ÈñÏHU‘uî$Éâ„WåIéQdF‹-†~ÈgQ"}"F D„PÄ¿)]²ðï’¾B.ý\Øo_¿ÿ(!\qw§N~ˆ˜lZrÿ7*|Êh(P‡ cRäˆ0ãXy"5z$@åkرÿµŽúfÿK˜ô(jli¦o’9éZTfRãøF)LJÏâܰ"sø·$Å1xþ“8RÞwŒÿRqmÚþmx0É¿ü¢¤¯Å<ù§ôþ±‡­6B¤Q„¨Ì9„œ»l  &àŒ!™ÔSÁ¸Òè;ÕRû(*f“Í¢'d†×ñˆƒm»M—èÑ`¦š(ÊíŸâ)ߎªH$ ‰B HJMº³FŠA……*M<„Xª¼’Z@h({Bøç}ÞsŒ¾D(â†"VÐïŸ7C¨¯Á P$¾öºLN„r²Èž"Ø3B‹”é² n ÿ ‚ƒ,ª¢ˆ¬äHŽÂK,ÛX»‡7åôêTBˆNST‰ÆÙÑ¢?é¶À‘X£:ÑFšNxI)ŒÐ¢h×”²è ߆ vž+‘Q¤¾š,‰:„¨RM<Ž„M諞4Mª#,ºçˆÔ´íp'1ái…»?‘³ˆ¯þþ±0 à¬Þýîô„ÇÔKHŸtñyТåHÚ ‚ :H¨ãJ[­o­iÔTI5ZPUÑTRiKi¼ØV[3¦­µ7µ ×`w¤É£6ÒQ¦cw²Çѯµè„”ªŒ$gIFh:¬¼1+‘XGé{–è¶£Ô&þêµJjÿ AWk\a'óÁÝv¢D0xçÍó^’|¸„ÝZ8ávO¢0ÑE RÈJ0""ðl»”<’ÇRYdE&ZKýÕVAžÆRc­uTXiÛ’KYâˆ5™ZÒ` ¹ƒõ3+e…µvæjA¨E+XŠ$#Ê`6pûîj$§{ïJ\®èù`A}þ© ¯Òm3ݼTYàkUƆ3¿9™,ÏÿÌ®wOÅ<ÑÇ/)…€AI¢„ð–Ý  ®<#¯¾ê5<§+öVe‹9޶òŽK­qs[µªFB«Íã(†¢‹5MD·™‘T(Õ£u(;YÈQ”¢$âh`9ËiŽEaÿtëiV¡JRD¸©¤oJû‡Òµ°|‡RÑaH¹>0­i-M©Û?œ§ŸWŒÄ]iã äõ:!Nƒq ÕòA2Ô¡~° !"º£K:3‘êñŸJP*h9n€£Mm¸$*³¬¬#$á\Mnc«¦mäJ!wnö%Šä,!JaNee£!µÃçæ-Â9©…´H[è" ¬@2"±JâD½9¥íˆJ ¾ôr èC)™7 °‘,}ÑÌ "ÀÙæ4YZ¶ð8ÇŠ¥ŒŒŠ;•«Ç8ü=.s3ªÍ-Ò„%4A©£ÖÌ{ÿF#³ˆRrb ÎnG@9s,BC¼Ç"# £$0|à‚B"Ùè2Û©…½;)æ2BÂq©°Šœì–xC¢ž*ÐŽû%³™û«áðÄ öpBŸ¼¬”‰Ùe DQ#F¿­‡+¬UÖœ{‹Ã üñ´yÀH–Š%]¤o†Þåì‚rCŸ?cEIá´‚ Õn*hAM—Äfº¹Äÿeê’D쩊*ØÝ€Fp ]©X÷­o‘ŒKEE³\šˆ…gŽ5Ñ/€‘M'„À ËÎG¢`(,{;;iÃV’rÙ;biRáñjÐã¥õtyÎÁêæ¹›ÂékФ[ð<Jdž¾•àJÂs Y=h‘&r%m.(m\Ýà¡I>ø±€W–äg½"g8cˆ°dÝ[ª¸­ž.ÇʼœXFh+“PÊK¹MQµœ_ÊÊ-'+ÏG\ž ÄmÉGå-ÏìG›“ —x.…`Óìq*z·­%Ùa žŒs'ðLrXz~IIâ¦7YWÐâÛ¯ˆ‡ù¶:ÙÜÿzÄz 10ßK*A ­Ú$°DÄ¢‡E¬Eç´À#r¼s›Y¹LR3f°²$ð^"ÝFävr'X^ÿ‡ x!ðÂý‘o¿>\Nšk Æ` ZÄ³š¨ø©KI™ ¬$:Y#²¨€ Ø /J« v–’€§¬"®«»=Lª HÃ|ÓºØpLÓL£N“.˿ؓ¶º¸Œ)˜  „y;„èù!2 Úr§‘øÙ#òs7  ˆÌŠ›Ò°X<Æs(„Â÷;„x“"(ø›¼”+Šh‚þ-ÓÀt"¤x‰X³k9½ ¼§Úúÿvr$“8Ã9Sˆ>ù€2ãq´ÜCˆtq±×Ø7·Ò´¶R¨ß#‰àk—‚à ´Û瀥€*„˜%Cø€âŠG™5zršIŸûé;’ * ŽÐ í8/A¤$ôdÓ€eK¿|Ðú;+T…è‰"P…+”?ËsټΜ³(©ó—⸒PÀ‘( °*°-V±ˆx x.ba4¼ÐšLº‹€BäñCNÄ´‚Lk+ÅðOò´éIŸ…Ò4Ì@; p á+“ˆC8lA¯Š`!„л&—'‰õˆo²‘(} »J¶Çø2p‚ǃ<)”Å"0Ç8¹ý¸HÿÂBù›¼|ð!-¿éœïó’/Y®èäHŠoC¬€¡À§¨¨ ªp&”8Šº¦ë#t¾ÔKž’hlôÀ“Ð4ƒò!Ì(Ç›B,8`.J˜ëbŠ‘HJÔÇô¢u‘]²` ô/“ޤ<¹!qCˆŽT"a6ßH¿ö›?©Ë+¤ÈKÈ˹¢È[¼BøãûˉÑá¥j;‘¨ ÒŽbœ0Ÿ±€X@„ðŒ«Z¤‰GI?›³Ðø‡âA Ðv©4±·ÉÈ·çÙ·‚7É7LûCnœ4ø@„C>T‰UsŽœ‡{»Hêò9‘ë›ÿ¯¬VZ{°$’@NÎ|E˳¼¨¼â‰(Œ?¿ è·1ÇëQÇüð\ôKùË<ÝèBa¼ŽË³e) zD„Ú3‰¢‰’¬”¸’?R'NÒ¡(ÂO’ˆž|ã½ âFpDÍÿD®C+çñ<ü‡¶|h’y!Œ 1˜„)}ìˆHÂP¯ì;°ˆ³‡8ÎW„}èL‹à‡µÏ41Q}ˆÎÌ.ú»Â‰ÌÈ[ô!¼ÔK MŒÿ HïôËõË‰Ò !ü›[ItSðF‘ Š4Âk:›Û*ñX¡9Ó‰ÊD:ÇÈ! Ô@ý<{ƒ åB:¼èš*žeöøDÐÿ´S>«LC˜‡r'7̸Q¦:•!°`%…øÐ29QK"ѹ@à(“BB‹»x?^€Ñ*D(\¼Îu›%ŒDLŒéÑ\üžñT©+0ÕÏØ™ei…žtOê ªªè–Ø»A"Ô°É F¸¡ ÐC€ „p–€Ê!¼ €_šÆàFnÌ:” Óâ!<ü€@Š¡¶ RªÊ Ezd­$©n!€ Ч‘R!õQý‡÷à Ô4‰‹â1TsUÔÈ®xT„˜Ñ‹,ì¬ÅëÑËÁ±¶1Ç"ÉóÈ¿9§:ÔúŒõÐŽ‘HC²°ö$ Æ Õà¢ÿïÀ¸'¡§QdлºÏĤkÜ!ø›7ãÉÇЇ¼È:+‰ÆÖ.I ‘Ð (Ÿ×¸¢Ô ‹]ÊÐ"‹vÓØ9\ˆã\?³CT»x×tMW}È.ˆ » ÈƒÔéA(˜QëLÇì8<±Î}ã…Í«ˆáH Ù‰õxÒÏH’3D &‰èUU¡PÂtÃÉB=\- Çh’m\И½ºd \”M8YøDˆ;\W­Y €Á%© WCÜ£²ÓžuUoÕX­xˆ¢UÑu…?3)Ù4IÚøKp¿F•ZZäË^ ¼ô‹:Y(î1 (OÀEû dû› âŠËŒI7ÿ5´D¢£{¨ŠÚA ;ºP-‘[:\Àr«ZYÄeË‘` k,WÀ% ú Ñr’ä]ºx XÆ• DàŒ£»:­Ó¢­9üP³{EEWúÍB•<¬A3)\úÐÆ+4Ê*\Ýë¼N8ÁÎ%²Ñ¹®¹ ŠdÀ,Õ2·yðb): !@;‰žÈª°hÆêx °¶Ir”y°Ò‘èL•åL;Ô Ð6‹}‚VÄm‹rÍ:úÐÕî5  S °åXÙ|‹îyt»[ÛGŒÛÙKYšÑ[Ê›ßõÜD5T âøK×yWø EI£Åz4{½„^°È¹:‚³ÿÑÀüÚh3ÆAŠL#[G!::Ž€º^’ é Š÷|½¤s¡(Þâ šãÁÒéŠ?Ë"¼&1‰ ,æÌ≂-p½«C8òÍ(75‰`”%S™Z£­wêV~båÌx(úXÚyÅšìúËÑÅå-~?»,‰ÿÕ`8yKÍËýHc‘]Šš]Tâ~èÈñ̈Ðð#IHIŠjI7á%[ÊŽ=€ã xB–hä? @ѽ mhp¢¢&j„XdJ‹QÔ‰rÁÞJ"3Êâ˜yÆ”(÷øšâ’À¬TšHòŒu²÷e (fÑö“çP¨¾’ÅqìÀæïËl‰¡¨›^Àu çáš^åÜ ÿ<-ëo/¤ÒŽÍþ[Ó†–{ð’΄€pÄ¥› „ŒŠø€HâµoYš%P'†â‚n?tq¬£â£•h.Vwn]žÈŠÆÈí\(ŽÖè*ô„ªmcáEâŽïM–Õ h…ªÛ™Y[o‰¥IÏó¾laº P>º€‹!h f% жø€'u’'ñ¹Ñ6M\ÍÖÕ|Šê»˜Ôˆ7ÿŽEž"¨¼È´ýàjƒÙg-ÙV–Š, œ³qÊãL…¼ùuuWÝ-¾Â¨K»vn‘Ô‹þåŠf`‹<`ÅZ·a€"¸ÝbÙaÙ#Jq"ñvfñž C¢ÀFA ø9‰¡ót^û6}·@±’ÙâiÖT —À£-²Ð2šð’퀹¶ˆ7q.ž ‹S9ðâÉ‹ÉÈš­ÙÆ-“¸lÕ»6!Oä;̇ àÜ2‘¼x¨bD5F]*$ ç®ËsG(¹®hèþeý¸½¶T<ñë®ñ– Ûj+©©+Ѷð¢€E1„i&ÅÉ%r[ûû2t·¼¥ Τïÿ@s °¤fõÞ1›µàd×H)ÏnWÄÞ½ø¤ö’}ºCäÔ4žþî´ÍC¡v-áÖ’H3èÍ%טeÑAoT~à…º`î)t[$Snµúe½|ñ»È-ÀäÅœPÂÉò¢Ù!5 ‘øÏ„Ì>9CÛXÞQ‘‡yˆá¡xœ5Ýñ […xäbÏqÎ‡Š¿CºU'3(ƒYpâ*· ¬¹ 1ñõÎ.û‘h d}EDï:‰Da’*nM™Uvb³cPNÍæù-æß&RÎsÏe[äeí$æ’Àh¾èÐ%µÜ²¦Ž0ä8/yy « +u™ ÿ© &µÒp We¡Ò°Ã‘Ø@zCa?LØxz¾XÉÞ/ßgÐæÀõ“ïζ«îÕÆéá§»@>ØØD¸…±듊,pY³.ZÍþvsaÑ¥u-ÜÀý…sÿß»†F(ˆKÿþ ü·a „>ú¸´ÐG‘"¼ò9¡G¯E yK4äøOã‰yþiˆñOÅ<„Jà÷QB„h1ÏÞ@—ùBü;‘p£¼˜9ÿ­ˆèè ýC¤O¿|ô}ø¢Ä?›øÇ!{!d¼×õã¿ô„þ¨hQ}l-ÒÃÉ3aQúò!ò±`¥ BØŒpƒÑ±iÿþ#p¤ãM{ù*äã§ï²K„ü\üÓçÒ³ ¢E´ýWd`U§M5ýOõëש‹øèõo¡mU— ŒÙ{!C‚ FtQñâ Ÿïm\òÑù "Sþ£^˜B¦ÿbÐ3iLæ=±'B|È—žO„òÖ³Hÿ¯ªQ +´#"ÝYŸÓ©ðɾˆ¡þ…O>ÌÔ=ëµPÝ{BµF”^úñ´ÖZV™‡*í%—_ 6>1mpÃ,ÜóØY…÷QHö”Çy0Ê%—e¹°ÙfmñÂKiEü²ÂlD¹fÚi©¹–¡l·ù°$A¼Åôao1é”Áh‘',¸Q‚K,!tžÄÿ=*$tÃ?TPÁKöÄàÞ?MxõOxòŒ‡Ó{ÀöP“Yû¡PQ÷'¦¹@zèÐ\—u&×ÝHÖ%„]† äfJé)f$øO¨¡—‘v¶—RUî"BRÿŒ]¡Iðé@óؤ(Zt6ü| .h>øµÚBEyÛGÔBzé³Â ±Úê 0bÿÖµ†•ØvÆP Œ9_ˆierqö/ˆðR¬‘+Àf³-íi¥>„B¼Eù¶ý¦$Bž\/úØcQ Kdô¥—ò„&ufšôN­¸k›ØÓ@ßÁ©â@6 4¡Ã± n>†0u°hM)5ŸSÚIp×<ˆÎAGùDϧd2Â<ôd>T\vB¶åÇ·j´^ù ¼ªärb+6¶¢<íÕ¥sTÀÒˆÙ?#ü³iÇFÛ²HÒF›´ÒÂVäiJK+Ðpíæ¡ÕlQû•·áBôH7®Fë!ĨtXÄÛ&Y€æ?†¸»žî‰•bÞ›ã‹æ>¹wÿù?È¥TÁ@ç–Î0å)b˜UªR¡” %óðIæÔŹËŽ)y1Ø æ3²ìegc ð¿†0ÀÇA*@³°8ff÷`QžÉünF¹?œÂ½fhIVñVC-æýp6K:bpzáé±,j·y"µœ5Pe)9á“Ù˜é¨`-kûÇ Ö¾°©:_OBäa‘Q)p.å1„>BG0¢0å-v¾VÅ$óèâýpR—º´b ïc Ýz’%/-†õSBìAže.ó.Ü[èHšgr,P¡ žt ªóXe œJS¨*šÄÕ/¹çYEwDü%0­ÿ«BNhLªˆ…¶j\¤ĹÜi†‚C©Ñh2XжòˆÀQÅFY£ŠHk‚l[ƺ!¨æ9–(¡5•f/–]frÆÅ'ñœ ‹æÿq$ôŒlÛz4PÍÅ Å:ZR—]ô»³Ö'ŽCevðÓ©6ˆ}¼Ÿ¾ I(„f`nÑGá4Îzެ4Š ªü²Ö…ˆ-¬ºA bö˜‰åK˜3'³G½Æ33§°ê“”Á2¶°†ÕžÑ€$Ç6o°¢é Ø´Ô‚ÐÅ A©(‘R\:ä!Æ*€LE1ç”i &‰!RÛ'C´¤ŒöÐ@–ÆW¯„(†Ä é\ÿLÀšÊ!¬@¸­9 (¾G©Bÿ1„¦ D>D™#>­K]a%¥Gš:UkC5×m`ó;‹¹(W Æ(F9ÓGÜØ‹)¹¥žú,m:ÊiÉf•×@u‘&„'A ðõÁ §-iÁ+Õž±â‚Ð*'LBÁI3#@ @…†ÈÌÖâň…râWÞò>¡T P\.¦æhŸxo $Ϩ„bÇ—¹¢ÓKR28_tFSÊÊÒº„¬,!#0ÑüS³È„L'=ëÅDõGûý”øqŠh2ØQfÌI "vrÙ®'<0ª<š (µÐ# Ð=‘ÿœ—F˜¦øƒ­›ê¢®V0Å}•Nˆ Êw6Ï)&KÈÝú·3°¢ ¹t9ÎŒqàQÁTSìi”·¥Ål$«ÿq•f¸Ò‡ XÒ»ÿÀGáuió(Bs×PŠåï~ZÏŸÒ’¹eÌœª,ÂF¬È©€1µˆØÄÖ6›EvÙ¶S¨¢Ðü"5¥Z¢mL‘ÏzÏŠ=É\ B€Ð¯¡!­¸‡7 {ˆÄ^²×b´íu~PPi’ "àˆ©ÄA×)‚t;5ÜV嬼ô8ò[íøSŠ  û â[|Ðv Ó]€ª°+º^O㦌³ÿís/‡y›i‡y‹Dê2ÉÖo²"*‚\&tÑ@ `¯¥=oÙÆ]¢ ô\¸ 4ËZi £Gl=© `ÒºUŒpkITvu’î³+FmLZ –7‹œõ™€JšNº´Ø‚eenoé:©äÂPäç´h8•JV\.¹ ñâõÁÎìDuº¤dëÔšPàBÿ˜H­dÅyEÊ^ñË9 èÑKŠ„GrØéeL}P×|•Fáèƒe©™ùÄžì-F „þ¬Q8îåÃýõ‚ÕYC„'L} øLN-l%DO!ÄÛèRÇLaGìÉÅd=H€[Š>|Èÿ…Üű‘Æ/$ŒúµÅ·å^^gäÅ<Õè@ÔŽATúY¡_eÌ}DÅÏpÌNèÃiP%E^«àƒà”À‰ÌLíÜÄ”!DÜ|€E<èÑ mÒG؆Jy˜^D¹ÚB¹^LìÁ^ ÝÅÐEE(-].ègü^JuË’ð?|ØF ˜ù Ä×àO3©ˆžXÇwÔBhÛ…¥ß[<øÓŒØQ4WBØê_«˜áý}PÂà¦]WTDB@ûYVL|ÿQÂX€À[à‚Ë”×GØÉÉÍÐ^ÉMþÀœÙ$„⹡¨D}[iðÈ·DAPÑ´µÿÀw ÝÐ¥E$Òƒ(• jbhìŸh¨FíÆ’×ßìqŸI<ä܈IOµ›°IàDIôDL¶eߣUÍáÇsy Ür …âýRœößÁ#B„áHÆgä‚:9£ .ÞÁQ„d Œ¼!BLžwU@WtæÑ\ÈPŒU˜ÜçýÉ5Î嘜ÉQˆ¾ð@^œ" iÜH>@Ç6Á$ÞÃ>æÍZ„ØÒ14]Ó¥J5„'@„„€ìQX]àTZ]¬ËR¼*ÊM dŽ™| öáÛu•È@Å„—AaÍÝiH#é…†|ÂÑØ&Baiže …y8ÿÁ@ˆ¦Wz%ÿ± =iX㬠aÜ€¥'ÍPȨ8L ÀY‰Ê^²š¡ÞÏ^fbV‹ˆ=TDìM¢>ÊNZ¤E:ú£ð^h„”ñ¸ànÄàð‰‹)&×»4ß?|E"ľ€˜HŒËˆ h[O¸gèOàQšÌXûì ß7ýâ![BLÜ1Æ„~f— £§åQŒ O(Ý?8cûQ#Sü¤’Íšˆå¨ßèaȼæbㄊ‹„èoÊÞä˜%ŠJ"~›ðpͰP„´ì ]›m…ZÄr ®¥,‹‘`ç‰@<|̀źՅNáÄJüÿ%øyUütÇwÜCHœ D%&béSh 凌-—ù~ ¨\(]oòĘÎJÈ(Ý…8Z$4F…\TÄýäü…ºÎ@ÜÀ Ä 8ˆ8ˆeÎå¸È™Š‹¢hŸþtçZ|RÆDRDÀ%Ðô^÷¬™>Ê tªEEƒâžhF ¦F/”J/0É ªÂDРìáKnáËòU@UTÀ*FG ˜PYBÌäôÍ…DæTÄ—ñ›Š-#ý%Ru hûíM3y[ [u5«§…ÚhÞ˜dˆ€ª\#ˆ¸¦‡È¡A †X´e¡oVÅTELù‘€¥Ç¢i»®e}Ûœ‰ÿ/pœ2gxPb ´¢¥¨~‹ræhu:ñ†Dp ÷Tˆd ÈÅ'õe_¸ ­ÊvD®J €xEWÐuX+K,agÀ‘rÌøäd~P h‚Rex¡ÄQá]¬EœâËÍâË?¢ ¾Ô…>†5VҞʈ .4Y£€#qRŒRÍPR~©õ„–…¢¤’ö tÁql>8AŒf*t¶™½ˆ¥ZdŒÀ¶ R§Óê©Þô¬*]d /Ðô´J „¨ ­ÊÛà‰™œ@‰][½¤Äà‰é8—!Â.jÌÜñ©IÆ„î…&Úl6©d#%ÈÄØ<§w:ÿ‚Bh‡¬ŠPÆáÇÝÚx…mvŠºî…WÝæ€Xp†D-b„â AWݤ@¨¾bÄ$bÄH°pdZ\Ä‚ÐÃÒQÄ?¤å¨Ú× IT„j"Ïô0/¬â@ü@+T¬W}€B™Ž®²ça^ß¡°M[$̘f"œänu„JÝY—Uh“wn_¤GZˆ3¦&it %`#@uÑžÐ`„Ȥæ1B¹î…RÔjްí‹9ZésNN¨¼“ðð®@È ÀJ"î­…Y\Ûñ~ŠÃœ-¸ˆ¦ ¼eòD/‘|íZä?Ä`ÝöÅÜ š¨Ék „yêË›(ÆL…Sæÿ‹‹hH¡ÞÚЦ …v8nBlâýM®ž4 O˜aW!÷Y«%j$rý£6™=d×ééÇI^BÁ… °€”éí ùݧü‘U]µnX¼«•Ê+ݶ ð}ðö|‹¿Š¥(•r@tDÀ=Üžt*]Á†Û%¸ÔöT„ ÁôôB/¼hl » T\¬=LÀ@¨€OÄœXmIN65hŽ]¦¡(î¿m NÐÁ%hdXWí„Ì1ÈEør;ãñÞÛVÕ£«bÜDÀ5„”.B$ð?à׎êR–°9ª™æØ.~E!šœ!®QîlC(Ñ’€T×äkì]ŠÙ|ÅWÜÿC>¸E¯ ÷Þ[ä” †¤e>Û~rYÆüvô`ßÚê BhÀ9zE€ïßÍ%ÄŽÁ/},R.óépMÈ‚h‰¨äE8Lß\DÞÌçs…pB$¨¨€=ŒÀ˜ýnÌA€ë’Ù{è¡ΘÇÜïm*È|##‡Ç ,U¥ÜïÅ-fd:«Æ/ìU`$K© ·ŒéC/[%Wò}IO Gmô‚Døë@„2[X÷ºÆÊÍ@”O™cî?ˆQMy|Ê¥ÀoL¸é¤,äî ƒZ®ÞМ1s®!EFPÈ…ø2@âI] Jž>3 ¹ŽDïhÿEu€T\ˆ6+Õ7'H㈠Ùâ ªI·£›êŸ”ª:#dmøîW®‘ >‹Êh€ðâªÁÖ/5„ ¦¥Ôá°Ä![³Å{oÿ ²k‘„OpÇ<æ®’ob·d6©–æ2w¿ïýQî]\ N”Çæê‹ºü‰˜`b1Š ˆqÆÙ4ŸÎáA,@ªðƒŸ$(‘U¼‡Ü€Š–$ˆVçC¢ÈXd`åR6ebÍ›¥Ô@´Ò½æÃWÚCðJ~BW-H•ŠE¡ê "¤’ø÷(@ 7/ˆfB´¬[w¯¡Ð*›|RU€B¨r‰±'ý@Pt(Æâ²pµ¯ÞUq§Øÿ$r=g¾ˆvô©SFÀ'*Òcd{.Bô&*òCªl¯AHsÑR è\T·<œelÈÁ·æ¤ðx€¯y4Š Ê¨ýaž(ÝkÇö²,Ø%0‹j´èm§àÅËŠ‰a醵\/C„"Wç/ÔF”,wËnïבrR5ˆ*ë‹*Ï–5¯zpnLä²ãvtƒPk¨c¸“EJàäÞ`¸bŽ S.“‹æ€!××Ü…=ðÃê4s\ åä}ùŒXF$«„cÙKÂjš£(ñ‹¢@¨@Àµc¹²í㹞«*W£å ¦ l÷6‘n ÔUω·s@ÛmB¸¸Nþ8 „H÷røêb¢ÿâHì8alR#ïo“vô2’éT˜G³š‡3:cÜÛGŸ›^Š¥´tó¢¢ñ,[PnU|M­Ï÷ü@4T\Ä8…\»ÀäƒFÌeùÏet*~Ú÷V¢Ò2 '¾´éêní„_‚LO·Ë†^|å žàÇè'ö6\>Ý‚õÒ?ØD¸€Š{rox²¨7oàÉTl)#ÉC“ Z7½ •vÂÑÝ“€. UÜ&(?ªyt¡=òf˜?îüþ¾KLù¡L£ŠˆpvB€«SlÕ†ï…øˆfÌ+[¤kôíʇÊåX „£í&ßyÍ:Ÿ£ è¦%¶³àã ÿ=0MMmÏÒ¥FA`KÚ[ÇxÅÆÍ0m TLzÄPÐOtE€‚ƒÅŸ< ÁÙDzæ~ˆ™æoÁïÀ7è-Þ¨’#Õ½ù¦ºê¬@–Ó÷­X@ž~@zxÛ^dÄÉi­ëzºyU°) ‡ ¨ÜE¹®ý±Ì|äÃ--ɰ| †åW6oÆü‚ðt;Ä¥Kÿ$胠ˆ|úЍêUPÈ@‚mþ=tBР¬`¯‚A{ÿæi hOÅ¿ïüG€ ÀláR¢úD ҇ȧN— æËõA߿һy¢E{ù2ýw4Jˆÿè¼ùõÿ^“°-nv%õÕ(ÿìiPaß?ÿD ¸Áà|BªÎ+EŸ¾|'äÍËÇ/°>Ä;“¤šê?«òQÖª•^W©!tñY„*I¿:øá?JªT‰øõ9p.‘]i(úÒh‰. ¦öÁëóç¼z/Èëß/‚N üËøã¿ ’]2¥§á„I¶*N,‘÷’7L‚9Ì$€¡Å<ê;ÿù,(‚·Á\i% æ¼–«z®!ðÓ·ê•¥&ðþPÀ ¡ƒèK„þ±+‚\¯  á®ðó©yNŸÃs ¸v⬳øìÑj$É(ƒ¬±ÀDèEÒ"ˆÿUCíŸKX³íŠø>‚Dó!G„$ˆ¯øPó¡€s¢ Ù#è!—.Êh# &‹Ñ¥•zëíºG¼ør€i&‚–"H‚„ÜCÑ CôùϪ…øÃ쟛¸"è1‚æ 4P t‰ƒ–¤LP¤ëìAd(ÈBÞøBĬ‹LkyZ ,±‚‚"H(Áþ©³2Ç>Ð*­é[¨}‚kH J H‚vc ØÞHÛMÊ òµ#üÇ,=• 'FÊèC>˜`‚B*ˆ‘ÍÒ@½”:d©Øš’‡ƒj ª§$ JŠ*¤Þ]©|¶ê *zBp‚©(>ˆ‚*AEPÁ&šXtÿÍÿ¹GÐå¸Rž|FÁ 6Àë. Ukì¢Æv¢§°©K Eøqa§¸{¬²V·"”¨y=³-ÇKtõ•W_{óÉXóY7¤ŒÒ%žRe¸\ž%9b=¥–‚:)hº¦ êPMrysô¥åº*ƒ|¢ §b‹òO©®æÉL){&ȯÿá …–èf”n„ ‚Tª‚LštYºþ±ø| ÇKˆ„Š IŸüÑÄÆN¦¸q”z—Nûè›wåǂㅵ\mÚX—v£ÄgÔ®™tM "Yœ/é¸6†¨§!V€q«Ìžö>}Ũ_^I¤Fs± ½«š¦2‚`ÙŒÎqI7ÿª)0nÑæª—4çÁ<±æ¤D•ä¢1ÁqMèjKÏŠh¸8CÒ£CÆ!{>Í”fç à>¤8_µA:\D\À ÞtdM’X_‡=ËXyØ’õ•˜{%F™!|æÅÿ„^W£7ôÀ´p˜«ñ–*ˆ0²qjšŠÂâý`nÙ™Rí¤]îò„ÍyÎ@Êy#ö*±T¡áÃÍ$¿Íó{îsÜ:³Í‰u6;‚Ø¢Ýÿh…[§cF0Â,®Oh‡^ß\Ë¡KH¥^·¤Ôiˆ­ž‘çÅ*¥€Ï^â}Ì÷Òw“»µÀ@ |ãٔѭw¹,O b¸ýQj¨—©%ãŸG$~ >ÕKTY†Ÿ@~ÆÄé~H.Ú€»Úô¢òöÙˆÿlm—踌&7$"Üz¡@¯èþ¡Š < é¤c†âkjèa%dL?„°ãêÂÇ ¬«¡¥Çxϯ ã•<¦N˜b‰"Œ°´Â^ÿ’oÀ bÕ Q¤S’¯™œBM˜â û bðÎpî"EþÁÖìe¾¢D\b1˜ÍúHµüÇ Öªà¢ 2à Æ,ŒÂV"è5`Ša.âx! %ˆ«^áÄúÏl~‹gB¬t‹7l¡n8 Bº…-ÌÄõìA?ìá~É Â;vÏ%toMNª B0ˆ˜"$ fPð]ä2˜b+Q2üåeÖâ{xO,ê&ÖØâ½L¢Þ¦‚†ŠÅ¢É9~c8.¥1TdäsÉ'Ž-Í–íSTkªÜ2¦ [@½d* ®ð sA6æúŒ)K$Ȫ4 Gf )ÉÿÆMÏ|Ãôœ$hÿ‰/bÝlaKP¥ˆ‡ amæÊ)Êlä!÷îÁQ<ЮZB<ÅQô2¬BÈTë1^EN^2ŽêU–â¹Âáˆé$> _ðE$¬¬ n@B"c‚ðÒ(=æeÈŽ–0G'èr”mµ<&œ¨gÁH,¾0ÊdÊP‚ñ`Ø+Šƒ«‚åİóxcu*‚g€‹K^ÒÎl£#õªE2š®+ìp§fÒemVBM¾[Bí*Œ¯ ‘Í«*†ÏðÂ*VFÅëÈ"îe´(?ähmŒ BjŠ Ü‚)(f6‚.Lñ!W̯o(ú££F­©Þå€í€Î/ÚhÉ>–‰,ÿÈâ"Hò½  Ÿ³r E·B§I\ÒÃzc§ñ4xÅÿàpÝÚ-õþ¡#¬Bc €\L2ôú°Ã XÀ;+Ûñ%”r¢úªáe‚Ó0gcÅ1ZP+^…7çä,J*dóÁmš¢,Ü'öÚãR.åê‚!·Ìp¦ n(L(Æ {¼Òl– *!¨çd\‘3`*0ƒ‘+lÇ d#‚š%=UR FlIà Ê%&í ÐM’¢Ñ6æÝL€*à?ºÇA†g÷$¬‹£®œ2ëŠ÷JŠ÷Zâ;ÂrF±ì~ï¼ÎàZpíeúüq@#f*b0ÑBÖ"K(f ÿš“!íº C¾/~HÑ^²"fVÄ'È)/ó²= å’BåÒ"+¬p$."£ ¨ °òâO>GÈô–¤’\‚h5¦q„IwüÏÇLàL Ý®'†‚’+&04I"Aͯ+•ôíåÇ *%j@‘ã¥2J £H…ì¬b-ð±*¤¢Ï޼(j Ø+‡Ü§\‘ Z¡B&$,³>†*Ìü¨ÌLkµz‚ˆÜƒ'@n'âÁ> Žôe-NU6ŒdHâÓX0Üv"éW t {Å2{ËsòK;LE"”V"BÀé, ö@“¢üÐAQûŠû ˆÖñ$²“2ˆlOÿò4^Ðæ6çDɤúØb¾N`¥äÈ%êK(tŠ.îcºcp­ À]ÈN‰$ÇŽUÄcPˆÙJÎ^®° fD>áiŸŽF=ÈfbU„€Äh4ižHŒ7TŒ:ŠÇ£öÄqj#5¯æ\ø-@}ïG×xÖË®/B.ågãÙCeêµ\ót¿“*W$j©b€‰D&ƒf’ž‘4bøÌÃìÓhþÁÜþÉ%Š@wP3ÿḠ‚WÃxÃXÕ£ ôÑH‚m´SÓ“Næk²‹¤ôF»”r¤À††û&Éü6OåeZ«âšþ#}€xˆ $,bvÖ byc-½ /8Žû0†rBBR‹FsL'z"š1ø·\(jAã6ÄØgZ2‹¦W² "žd kÕk{¥ÖÍ æØŽ}WbÿM@ÄTioü¸NÀ„³4Ùö,X˜€©;ªîyݱ‘e8>`"zµKo‰,7ÑeZe@ ¢|Ññ&„XÇöùoFbîtªŒžØ~ Âp8Îp0Ä.¨äBÍ ââŠb^ìüþ—ñÃ_kÎÑ-Û‚yæ>ìG„æ«^·VE Hðl!5lõ94˜W!– xC‰xÇ%J ]†‰ÒEm³¹¹¹¡Ð±êÐQëb‚f‚¤ÜÙ‘kXjÉÒ®£n“úŽW=TŠa %,qÇîj$¨‚².&ä!Uq¬ïç~"€Q„*âb€cñþAE€b©ƒQ†•ªYÉ6ÿ°Í3(Ì=½Š (Á^×Û²j ›O#pRÚ™‘ÃKÉ6õ¼ô¥ÿá˜bºg˜jÈYÀm×ö,– ]Ò \8B z+Í@Ü9oÁ#>Òq'1F¦¯)΋¢¾â°°ƒÕœ÷ŒázëÕ%$Äš7úã˜S(B‚û1ƒ=îÙð(šöGóÚ0!ƒÕS8Þ‹YÄpæv¥VwN¤ƒ$èî‰ïÜøHÂí±yƒó˜ƒ‹²éD:^nØö¦O`³)*›/V˜LX÷~éÇè–Ç즇ØyNJ‘Ń•B¶¥ŒŒ90ëÄH,*Ç\ÂÀ²¬9w .y£}Óˆ.E'jIeØ:{ÿƒ;íˆðƒÈ#ƒ‘Ú Æm§þ( nÜÆeꆥÑX5zÄÛÊÛ¼) Hæ¤}£lÛ{ƒûÓ½-»'TãƒFx†²˹y§E‰Ä=0z‘Ò׋`†,ÜËv¢@6¢Ö56=‚AïIâ©W–ÅÜPzÉ¿¦½´l b‡gÖ[Ý„·9Aa/”ÐT¹Yc‰ºêˆ<œÃ*/9˜…o\0¯IE@€¥v9¯ }À™¥þa©¾ÝÞ'>¸ b CÂ~„g=»G?ÔƒÕ»ƒÚT)¹Qó¿ÓÞÀÕžN]‚kåk²läh¤CöQÚ ´#AìJ¤åj…ÏW¾Œ"€!WLšô+.¹/æ b.FÀäüR{œ(ð(e£{Șʢ‹n<»"׿_.~õú¥ª×¿½zù‘ ‹‰.DüQ¤ˆª}øø÷ñߥ…!šéia^<üë`¢Ã?'ÿk22ãß¼'æ(cÞMz ÍÛùÁ¨OŸ,–È»÷oÉ=yòNˆzâDÓ{÷p8)àê׫'ï9­‰öŸY¨ÿZðÔÐbÉB÷šœ0vÒX ÿ ˜”kÒ‰½NòéC´‚É ",øñoC„È 7P¾lÒÂ?Í,ÿcpC_>Ãüþå[Xz¡¾«-t½:_z-j×þÂI”\¼yG„8ÐdFU"8vôø/£^ED¨Ô˜Ñ#ò‘ ?öò„ÜÓõ…žŠxéá;M“.M¸ü0a‚Ð8uº_xT(ü£Œ”2=!OjÔýW½²]‚ŸZ5yeý™ÄVY_!ØÄ? 6Q•\-œPàÿ=ÆhPS x †—ƒ' &X>#8·@M%þSâd&MÙBšidž•ÈÀ üŒÆk†všIúüXš>7æc=³…À^< DQ“¿œdÑ/eôq#©’QsOb”– äƒ*Ý1TRZÿðK/ÉdÞL ÅôÏØÃQAùT‚N9-E!=ZÉÃÂQ:ñ‰_UPÉeè?^U¥AVO)jZµYf&X[ iÐD‚m]؆&Ñã—1K4‘éBP؃ã fnÐØŠ’m`™g,¢åØž”(Úi¥õxÒBºæÚ8;Úh.ÔÛ².üÃäB"L{FÃy´‘r+9—\–UªRÿe"WÓ%žèc?.ÁDÞI4M°ÐÿÐÉ =ÍS‚VZ-”U¡òì¤ÓO>ý“‚àB²5–ZbÈÁfš´†ÁþcÌ Dí·Kt¨—x¹E^©þã…ÄÝ,$J7¤ëdžÁúÃ-b¶Š -pB«Z°üüÈÚнöø£ ú<+Z.ù¸ORC›ËÔ å²ôDÕf™—ÉMûsT‘ÜGf“M¶ÙäþcËBÌcO#°É.L0¹tAsþsÓOEíÄUö²@0UT½çÓ¾Uýs„€ýueVN(‚-<’6ŒÀO'ˆAÒG“ñÀÄøüø°›„À(ò8‚ýb8yP(ô`DÿOðwH%°Rr‘K€ÆÒ0µ@… ¤à(D2ž$*‚‹^™ôñhäê*úF&&œ$íjö:ˤDw#Lƒ–à™d…92ÞBFã„Ü̆Ë£M蜽‰ä£zÕ[Fž´ZþãYÜâöH’&vI\¬¡‡çU5¹é$z«€ëL€œáN¸{q)N9Tè’ÀæÇŽ÷0ô”{(r‘ k‚©&ºÁœ¤t›B ©ÁVœèD¶Š$¬,óÁ΄pŸ aÀ p¬™æg¦(Óò;Ó Ð ó`‰QÂü£¹(ÀDœcË“T/l¡%·Âÿ¶æ - Sí±¾Ék!éS¦L$P½Ý:€?+'¡JVvr§žDhq•¢‹,… ¯<®&êdg¦N0¡iªœ¥Ó€!C¥UvÖ¤«kdJ;Èè¬223¡ÍjÕÁNò(GCû(SóPÓ)éCÉ{aòá´‰œi9JüÅw™KxÀ–GLâÛv¦*yÄg~ÚÉ .õ¥É&HÓ?âaˆ Hàð¢æû$ðÌjÞc¨CU  ²ò ,…)Uñ¦S–*¨à©tQ ¶ÎEšÅ±ýœ++5Ïi¨t|«²ºÇ<†u–áì09P*f*œ«'axÊÿ>âÐ$ÈÑ.—ö4PÂðYÕÛÞrjI=^°WŠUì{ŦDîQ\>àEæÑAÕ©ÿA<ÔWš˜`†0ÄB @͈@ORò„®”ñµƒ JÀGIA%?'ÐTÑ•à.°.QqKŸUb †UC& $;EáªVL&;þÁbe]“äng?Ø•'^vîæ£¼uèÄN#O´$í£E¤//xaØ-µ·KÂ1"}ù1R˜À9.Ñe“så#N¶|ò(Á<‚ á.äÀŽh%0Mifð7@„3Ó32€µ€âÉ<$7Ÿ?-ƒ|Ø8£’ ~Ó€bu‹è(DOMñÿË'hPXÅŠ¢Õ‰š’”|]gxK`ÒJÓÐ'!9©ÃGÈðî—'¦ðäÃø![ØâŸ%t³œ'. T>!Ö…jSyøÇª±@T™¤ bMtÎcÿ`nj̭ËÁYçtƒq¨°ˆVŒXÏkÇ‘N°Õv=ÆÒ×ú(}#»“\¹[ê3& âÍÓÈ«¥!pèt‚.^@lL+(Z:œŒŽsÆcÉtæf ìàn°ƘdDñ8¬Í4×ð‹5K Û´Tº`w\>ÉHr‰`^/Íõ]l<軜çôš–E`/h(kSýÍÿÈy­c0¸{ ]Œ™ø (€„ È~®p…ìyð‚` ÷%xÁµK¨ûÙK+öb*¤¸NÔŽ)Š@+€N . ½&Ÿî£#Y'jÖMƤ>Q‘ObÂØ½:w#pIy7®ñôŸæã.@DÈÏ=,iD:—ˆüãò,Uz.ˆ‡²yáÍæ-#•žçgñ½÷/°ÿ M|Ãhdg7 q«3²‡0CÐHà $À<`{®½|øƒþ¢4)d°[Ò[Ó÷1Ó—R}‹Ô ¡VÜ7q?;ÒåV­ƒÅrüCr3ek:ç„§$,˜6bCsÁx×x'$‘DQ=cVy÷•%\ò^@>-0b/@u„3$s%Ø9ð90hHI¯g±·˜­ Їƒ¸@%pf838úæ)Ã0]0 V;Ð6ˆ981Dð®‘Oÿ ¦„ÔµžÀ"ÿô2·S`æñPÿ÷B¦!/D2WÇ!‡RT˜%‰gyG_ò+Ñl(‹5s)gf¥\Q, †jø`¤EG@r8G°ƒGGC°{Xˆ‚ø °Ž‚˜ƒH‚/°ˆïv8M8P‰ r |—s*f:'É5¶Haà`¢xo— ;HIÓ…"geqÿdŠñ2 BçÇ*!À#q3 ¹W DC­Œ½¦Ý2W¸6]&*wDÊä-™Ç=€†]7u¿·$à€ ƒû@‡‹Ø ¯‡H° Ð (ˆìˆ‚˜” {x< ˆ Ñ8µuM¢(çÔoÄÿ˜¸H2Piá‰iŠÿà`Œ¤A~ø§ø–¨Ö7Pd>&;-ò2'RSHJö`‚¬ò¬Â*O˜P„—4î'ˆpRÂÁ5Ã.Õ!.ÞÒ&5X*I6&EÀ7I0 šy;AÿˆÿàŠò[­°‡HI ¬›Mˆ¤ø @ŠR)•è Apmÿ@8cM3[WœÆ™GÇY–œ˜‹©ó\  :öƒ‘4‘˜Á3 `P¨±QÉ:'˜P/µÖ#À$Îñ; 5…Û£Á¦ Ú3X(-ÒâÛ’lÉ–.@M@Á·†¿¹“'q9àWq†°ÿ~è‡ëè MÙ”'!ˆ·©›H0ê¿w?€’c(–X •ó rNËi¢˜C&1ŠIùHªÃ:? cŽq+؉I Á3£Dgó2/i˜<’燞u%$íW¤Ò’l`fxÌá-iQ™!…D"ÀÍáeÕ³XóÒâ  ˆZš ¡{r8hqÒHìH]©ð–izhºJ¡õ€õp{<à›ŒsMþ£G $U#:)r¢j: ˜Ñyt¶i›—3%B‘;óc–dx5L&OöÀìA$á 4Á"$çåK³yTˆD)'-˜ÇíÅ-ÞáŒÈ ö¥ÿ8,'„Ó{yâÿ†_ªˆ9@‡ŒCŠL ©à«¾ª¦iЦK9ˆ¸‰ §rZ•Ðt¬eO!½õMÇÇ[¨×šPˆÐ–*º.:!®vùc=c®eð²6˜—JƒÉ~ ’É¢^ EW‚Á%¥ u&qÏ_œ÷ŒØÃraèùÐB0Ö0צ†GpmA`š<ÕðÐ8ãè”ÀЦû–´™¦ÄJ¡®0• {óÈ8@,‹F„@dœ{ªGÿ –ØŠ³:—hæXŽh£„f2ˆ0</q3¯êJ© í:˜~Ù#=ª³Çså%$…·Qx.!ÿ°$Õ¯›gªéóŒJ3ŸùP`·•Ø( [š%@‰ªš¶ù« ¬ ‘ ?à±¶¹”·y¬Ç:õP®€{ôا}ú²úȸæÔW‰9k¢(` ù#Üú;úÀ³+rT"H–q’öPZﺰƒ‰ƒÑ£ô@µƒ ’==Š#ôš‹=r~•^ååQþ§Æfl`S.`õý ¹Tñ[†òà{yò§É80‡œlZ±é·Ü»½G©›C€²…K§¹×n‰Ki“bpfòaÉNPá’Ëq•û ø{5DV%BwCŠ&/FáBa¨{ÿJ>J©”AO;/ñZ©§JÙ‘UNp~EQKãÏø©ÎÁ «q`¿Ûô@TÉ'F0‡rø»ç†K«@/@P—·Ú«·:›†º«· ¸¸‰¬„[tæË²Š{1}$ ³Žp³ò› 7/®K©³gÿ`Ž&Ñ¢´t´ /îo?¢k¿£ ¯:úÀ“*/G²ÀɬÄJ'AD! çP°dJSR¶T¶,'=Vý)³ºµÂû`F`9 ±Ð½µZŽ“= ¡³©Ã¸Y@ü¦ƒ[{@§½×nÿð[ê»HÐÄR\–ôàU¡cÆÿŌĭ¯C´6MÀ¹aÃŒ¢ûË8µ¬+ÇE2 !:á¹1D!€äUn!pÆð—5<»¦4¼ ,¸¦.PSDE0øû â¬È a€%0½p»†”,‡¿µ@±©Ã&›Ü+•ÿ@Ä…k¸ H‹ø¸ìT1¬|­“1%ö|ì1­ð æ¸]ü§+ÀÀÉ-û¸0hó0¿c,?:;*ÇÿÀF7±w<TD2™B2¨B!ÄÇ .ý4}—^õ4ÉösYúø–ã<ÎálåœFÎ9W ”wýÙ ÎþMu¸íäÀÚÔ­]›&á½ïHÏ&ÑÉ„KÛÀà ¾ˆOG0ábݾ¹O25Š{g”TW×ø]âÐýÓþÈõ«á¦âÉ¢®DÒ´ïJuRÒôã&‘ð´42Xe ® A⺺{D‰ BVߨÈw~çøÍÂCí†TW½¯Mà­]±màôŒàD|ÿÕAà/0ëõÏiÎÊ#ª|`W²õf¦OdUˆ¦äнäŒ,ÎP¿$·+ž«‹Ìw<„]؆í!sU7>é r‹Nà'œÓ°òý't Ú þÓ5ñ/@±®PzAÀ·.¬;Làž¼êõ IJ æ PëôÈ8b€ë¼½ åTN'[ïÃе:®QÞh]â?mìû€ùQ4”BÁ섬;'ÐF¡#(GqÇýÞQ¡o9žãvAéñt‹’Ž*7Þv «ÎíÙæ,ñŠ<ñŽÜ8Òtšjè”*¡ÁºåôÜÉÈzϲí úl ~¾G¨JðlŽ‹ <ÿ›«³–ƒÚãœóŸ>e¿¨Ûs:²B! »ƒÞFDòƒuóDbv”ã¡AËãí®ŒU²à^F«%TAßMŽóŠ|î¡ýÂû ¥íÔ5¡êô^ï@,Ä žôK¿ïêÞôGà+3õ8[1`Gðô 5(Æð‡Œô‡€g¼¸Zó5!ò`¿4d­¡B½âE¬ÛÆu2FSíýÓbNaÞwáÊô é 0 3h€RçMîäar˜G°ßê\›óþ½fbïþêTÊû^Pþ/À€ÚæS?¢ÿ¬&±tP§ÿ‡¬y¦—šM>ñçnqäƒ! þýã§ÿïŸB„ÿò}8h/Dˆô,^œ7OÃÁÿÉ;!ïà’$—ükq⟠WÔÐBCGÿN9øï9rìË‘S(Ð}ÿŒÍi$GG@¤ñ/•ЃS§þ‘€êA­\ÿ%èúµ^=Wc]päßkƒ<ØW.Õ'ÌÅ›W/Ur›ü["OÞ‹yyðp5ä«V Z òàÿˆR5r}ú$èã×P!"D !þ³g^{…Ñ›{^G•"—<‘’dÊ–ém´èä`‹$?²P©ƒ€Ê[þ„^ô§Ñ¢F¬7¯šsjÔƒÜå†åš žøfÍ@$Ûÿ%°ìÕ{ÃÁ¾ðíß·{—j‘-—‚Ъg°Zq  \y!¯êÀ`žÏ *­4ªÉ'Ÿœ>H¢Š`“6›rjaÄSúí·ŠÚ@Í ÕÚˆÉ#‘þaáˆ#îë pòi®é êG©žÊ‰H"ñ[,I$Æ"«À±Ð3`½õØÊɃÖà€€ùþ!+¿œkË{þáïÄ_@S= "ª”,GèrÊ!³0`á „ í ª ÃÓìù‡5Š>ÀèŸØhSÉ#”`º(5ó±ÇE”ˆ£é X‰§ƒŽ`¡„#z̉(!ÿ *³Ì¢ ª!‹Ü+¬®ÀÒŠIó \ëÿõ¸â+õÓ LaãÒOËr;á…;"Í‚k1Å@ˆÀ±!H8¢J¤ #`¹ô¬@Ÿpb¨Ü†ECCxÍ"EAœ'¥éáˆÞÔ¢(€ò)À¢˜8 é yvºƒœpª‘Ô¡ä r+W½“ª;$iý‰ƒÆs%² Dï<öx†Nì{"˸¶ÜK‡$êöŸ5Ú2Kyä…þiÐØÙ€±0ð VRAp¨òGØÌ³ƒÄMŸ?sÊÐ! !êµ×B —^•èªÒ|ôq!†œ°èÄäD²ñFƒs2§žR (TMµû }z bí$–ØÍ¼´ë«ÿŠ+¶•,\Ù:Èç=楨òòePÞŠùrbù jp$‰- x9§'JÿXú¶*ƒË¹ªABàæÀýYx(ÐÀ¸Kå‡Ç\y›Nƒë4"ƒy>ðÌ œ§ªO«« ¢X“ˆk®ÿQá  È4^ôõÀ¡{KI°µ}œ0Ø‘²¸òNªþªŽŒ«1ý±Âª1¡À­––ñ,ic>ÃUy'ž ð@2¸ Ó¸d2»ÀŒ9¹Ç_¶Òù4a>c’Ïæô¬×©Ž*-°™€ö1Ü9àYAðY=þa `ehŽYÐñP¤:íC ”B ±sQ-C:ÈiþÿÁ¡Ôt¨P Ÿ\À 0„_ÙH‰>ò{ØH,xAt'ÍÀ¥2¬¢JeVu*ï´1/~£Jÿ§À²4 =91ÀÅÆÂ&Wí$À].h2 rq/MР!·"ÂÔÁìur¹œ M&„@1yÒÎ^ÃÝíñ+Ó’Ê@0œìðxFÀ>Œ@=åcˆ MhdI Õ²zxaˆDÀ”_N@[LZ2“tqFG¸ §`#5ìT@B£e2ã*XÁJ<‰;€­âR¸XL†C\=–Tž‹åä›Ïê„À— $æò’iLqI¤=(Â{Ëuy‰ä?Lö‚ÿÁPä‹:?öBôh`IÐ?ª•CT=`'zK%h7¶=Á²!~ò“Ôâ…‰Ñ)/ÿAÅ^îRCQPMm"“°ÍS9éV)yÒœ¢ØíŒsq#à¼R8Öc¡ì‘¡ /FÔrš3qIÊxÆCÀ\ “ù#Ó"È ÎÓ«9I¤ñ"Íå$ '(ì0p{Èc<è¨chÔ;îNÕJ+BÙ l]p's3Š”µœ$¤9‘bbØ|ð‰cÓB@ó].Älµ,Lѓ̃DÕ]rS¡ÈÏ2t’ŽP*ó Ô©šÛüJV§Gö°'†<ˆ+Äb±èÿöguüT¥*b £¬êP–H¡œè/%úK"]ÎgKwù§P²Û-CbMp½dcheT<–2^ñV.­µ£>”G+?ËÐ "¤Sû‡ áÐèã±þeHiªè}Äà )€B®øÅH˜)ØG»#œ)°>µLª¶bQ ñO¨óŸàf;–ÚÚ¶<„ËXyÆ©b¥ÎP,R]j:ÉòÀ Ü…)d«"‡#æ6A¬Óå`"/Úf7'YbŠŽ0 Ù A’­y\1eB†¨O¾@ ŠçÚ»é"ù¢ôî—"*ø£¼ÔÇøÛ™‘¾ôC©× 2"ô„´ÿT1-Ãv(”¸µv¶ùëß視ÄlùfY·hrZ¬V…F§x†@|YÇü‚"E&zÑ¢F,«{ˆ¾à€ ¸Jx+ h €ŸKdŠäa­àìßôÅP   ?.¡ ž0-;Á€/ëŒ=9¹ŠÉR9ø»Å°1(B9´É¿œ Ci袃(Q)1lL2*:ÔŠœ˜$ñ0î˜Ù‹;Ì£¼É©¢ª飚¡ˆ‰(Mª(€È‡X͈‚sD‰èš.´‰Ü‡ÑyÚ1š}üJ¼³ÖÒš¨EÁ™#½:ˆ Бì– @¼Óº‡ `æé Aˆ( ÒÐK,´%ï){Њ ¿ÁŒÖØ@îÿ:‚¸“dd@øÑ©=£ —Ô½B;±¹ 8š×CÂ1ªÚ;Ý*'…4 <±þt’â ðÎ'JA É…|Øö³š×t—¡ ߘù`JòDh¬ÂD¼ÈÝ ¼Šþ‘½Jäd`yL5Ò( 8?ç‘,ZD©§6,é'ÚB°1O’úˆX3ä3ž;ÆÆtÏä¹#p€ ”‹Sº„#›Œ:±h¡Þ’·EëF ¬t*¸òÎt\DvœÐƒÈ†x¹xÊØ\»a|Y5Ø“ÝÔ™¯Ä*#8@äÂqŒˆ‘+[#4î`Ž»Ÿh-Ä+ ˜ à¨ÿó“b[ˆÇK¹’rˆ+¼JD C9E¤SúCtÏuÒ£°øì36|›h­o£0üˆRØš­+µµþìÏœÐ.¥·Z.vS§z8  ‡pMQeSdcJà/w¤9±jÇ ™‡@bš1ÚÍQ¯„¼ëGïÒÖ@Μ6™¡¬ €!P ·D÷zUTaŠ6}x¥YœBÇ›¬Z<"Â,MÉ ˜¢”íùNó,ÒB¹‰eâ’fÙ¸öœÕc\ÔTlÖ¢0ªÕœð…ZȉZð…ÐX[œ{ëÀ)Cª>üÒ  "Y룛‘€C¡v´þzfe?vŒíYcõ(}¨SKÿ[µ›1š<Š4áÖ~\µïº™á✡€p È\TÒ? ))q9¬Çãü‚,(úE´‡Ó¸žò4(wé [B™‡µ ödO†UI¸qNì`&ª¨…Š¥ dˆ Æ™£Îü¡OÂäò ̽®Pª]='6!Ö›)Xjˇ5]M M6™]3›MÖ±!›’h@ÊJÊSÝ$õQ¬:Z²ÚÂAÎt›uUŽÖ7ŸP½‡Ì˜Šð !š<ìL,¡,“Úµ}B¡S,Ìï\"«¹Ð;‚/j …=C—ü+Ô“ÕÆù¿Í‰(ܼÀdÀ€lâÞûÿœ·=¤R{›µÚ™:UÄÖÜ—ÕÔ‡*b¿’Ë/íNþª¢^Ò‡À€«ô. ½mU p€0.€Ü¤²lÑ"ANR”+Ø6¿jÎQ•œ X —gC¸KÅ ‘A9äýNµU[°[Ž\¢y¨‘ÉŒÛ4À‹‚ŸÊhT%@ƒá[¡@Œ !þ޵Њ– q;dp€/­Hªk‚´kÎ\ Qï‘ߊ’£¢ƒH6c£Š*Š‚Û¼VðÚMÒvâ6ëC»¼Øb A«ÉPl&ª…  Êóë(~è(¦¬ƒ3ƒà(A†¢ªQ"ð”ˆðÔ<üÛ‡8 ôÿô+4ŠÒSO0­ÈTÒ¹ÐÛñ½$Ρˆ·p## È@Å ¼'¦Ò/u½Þ¹€+ú•ÐɥМø(‚ƒÀߣÐ\Öå|hÛ«Œ<åp \x¢eàpý¤$ùăê-:¿‚U†Ô‰Œ A."¼| fûZ-&Ì@DüC"ä]"DÆO1Æ$ÆÉ€Ïãñ6÷J&Ü P>ˆ¼ÝŠðýáZÕÛ–$£&®8TÞ&¨Ú@© hÙÈÊ}™]ˆZÎeh©@66\¦,~Ê€{Ø$ € ÀmMãd6‰u×ÙëŽúgÒqë‰TKTŠ!‚EûÂ߆ÿ ¶þRƒè“‡@"ë¡”sÒˆê% hÕRªØ·É¶ynNÕÚ "þ|¾O«â%žÏ$5e&©O®h±o‚±T\ó’+¦Ü(è ™í%¦l©[¾e/>ˆ\Æh]¦,z‰dz¢œ4Æcf§(Î6Ž!®PŒšzøçcT˜Tü”_ Š ©ö¨?±øcÇBI%)𤔰 ›/³ž$ÆÒ£‘0ª°›êaÓú6J¦Šðµ’QÞ‹¶®Ô@±&&‰’JfÖ!…–¬Õ”P²Yˆ–¢hŠ6¶È UXçV…ÈåÐzéè% ‚!HW‘._Ý! €RméJlZ>!ŵxЂ ¿Ê¬ŒöN¢=¡×Äâ\‹–‹Å’‹Îx0ÓbµMÛ±-€Òž€¡œ¨á:n¯“殡kÃ#!ù ÿ,éÿÿ H° Áƒâû±p¡À[ÝH"C*HHXpâÄÿɯ‚¡7DôÑ?{ŒTüÓðŠ@c üCı§ÏŸ@ƒ J´¨Ñ£Eñ¥˜êG­ø þûñ‘‚¡~ø`(¿ˆnTàÇOä¿’alÀ·AìA 1àj8ñr ¤xóêÝË·ïQ|£ðÕŠ ñ_-† Ÿ lõÏêÀ þE®ËÑ^eÏVh/^…ÎÙRE2pÂÀŒbÐûwâ„ &~¥ä·¶íÛ¸sT<õߨ‡ >üAáñd‚ôbô|-Pf{öP3²÷uñzv…îR¤‡2ÿmÿ²jù¨ºÓ«_OpÔßC ü;ðSô–ßûÆU‚ÑÙ³š@ô„—]½öÜ?1İY[LP %”0Pw¹ÄÈV‘ÅC`|ÿXÀ{$–h"AôIe6Ð`P ×QqWmFÙ< ú¤Ó?;Öä\<ܰÊs<ÿ,q#©1ˆ£@æƒYf*I%¢Bå¨å–y æža ý6},Ø(ð½ˆz„7Òf›Ùsº„’HþÃkP2É™d$$Þ¨ÔVÛž}ª ¤ò¥ú"AüðC׉EVdñ à±{§vîJPlñ˜à@Ä3ÂŽO² d¤*Éš<’>)PÿÌÝY< _–Ö²‡A7•¦@¥úæ^ŠDXU„/uÏEw±«dkàuög›¥k»­ Ìè‘2*Ð=“ÚìM4d ]“t¤?12Ïœÿt ’ÃIÿíôß\ò†™¯X5zãZ#üðÄ '÷üÏW<ðÿܳxÿC1“.w¯\]‘ \P²”*y´x~¯X8à¸ã–qš÷íî7ªWÿÐ "@ð#úì¶¿Ê3ψ,`#É6úæJú@6µ§ 86wA,À¾hç¬-{²Œ°A–BÔžûü$Š9zö{YußE@AñO ?º"°õ• †¸A6`L`YÖˆ•§í‰®9ß­„Í%n°û™²XÇ£xâ“ýV˜/®o¿‰ÊSЄ?ßX (ÞVºËyX@ÿ²&ÈcQGÐA4g½µ-'¡ „'À&KH–ⳜP…, £îÞ3Š1¹°cï9Tp8°¬`€ÊÔ£X0C ‘(Á ¢Ä f€{ ¡PG v1‹.Oš[å&|q OÐI>2Vk:3gy‰=l¤’+éô­?qÑ ýÆ&Œ!>£(Ž„à"ì’!T<ÃÀô=u2þqWdàÂÆCŸºjöŒs‹Ü4º_q¤•K¨¦H¯*þ$ù ¬e+ÀY‹`V@‹L> Á“,PES[.ð±áŒª‹G¡E ¸DZ$Mx¥ZÇê3ïþÃB²q¾ê:‚L·å$H~9ãØïMW&ÐÑB4UÙ ÿ£¬]A˜=&#%„hÂ,l†»ÀÀ'CŠÀ¥è &0¡Œ– •Z®ÿ» Ž T€ âµ¢áT¯‡ÎU° Ý2sD4‚M#è¬rñ„0ÉäcÉÔ]òF¢×))î.H¨‹â‡Ú MdøÇ'B‡]0`a.È,ÀTá ±ˆJ€‚jô$öȆ Â…HòYfúV²Ã¤¿5Ç òKgí!RÒñr ç`hýR•5U¤‰-ƒ§;ÕÅùxN‚yñ»¤#¸4=NÀXm…3‘¡,?EÄ·ðM»þv¦OháŒã@ø âvÐB | 8GR`0Œ€+XÁJøƒlPUˆ|°‚Z zÿø²€‰*Á"úàC € =Œã¹zÈ%'”0ààT  ~2t¬³ «™Ž™8&8•÷7ùÍ0 ,D@&¥5ö¶ -CoÇ1Lø´ ž•a¥Ì?Lá}\“Ñ®w9,•ÚIÏ.íN¼]V0‚Up$¼ng<Fð\ð#ÁˆˆûÜÿoË—e´f€ÆáÝÙ|DZp§µn@–K¦+>ò‘ìð$G@ñĽ=rvÓÎ7f„ˆR:eQtª @ Ls·Ö¬Së'`Ô Ÿº9rv}‹'ÐÉ€ùô’ÌØtÆ=Ò ÿåÀöäÆCEèÀ îeÅ‚Œ3eðC-ÐOPC%~¡Þ.† _úŸð„‰Gk¨¢'- ¡–çvª7£`Ñãž zÿi•…zÈx«gyx w7À€•uiKV4{Uä22‘ñ”Dc78SEå…?Üâ"ƒÁá"?0ÿÐEt‘Râ2PNÙU׳E™óTKÐ6*0 3Ös‡– U„.”ç"°#wR—9M8x¢qa}ÓbfÒoögFx`DkÎuxÆwwñ\!¡„”gB# †éòyqo ˜."à%§q"1’6+P´ÿFfUR{d!{—ÆuáK§Q4OÈà!ˆ1åt1ÂNÊò$¹TMy/ga+K06™ãu™ã9Mh&(ñpy3/`ØhR[–WíR cŒ³$Œ—–\”Å`†)ôil2j£,wÍÕnÇtgÿ a&GwEÀn±ÇˆpWa8EP€"q¼iøøWr‰G†n˜…v³WÀVPØA`ˆ–Óç•æÇ"Y_#4'bbœ‘/eq+'3‹c£2®ÑÂ#êh~e‘õ„@F¨ôÐŒs±=‡Ö3a±"~ÿ7(jTf††ø¡4ˆg` qÏÅxH”S‘DÓ tYE‘':V°72"RA›$Ö”­É"E.9omJ7fc,-P õ¹ »º -_¡qLÃ7·#jÙ5®#¡ÍÅ)a+¡]3˜aõRÁÈÝð5AzmÛŸã÷rj:»‘XYJ¨ ×±¶YaÆKÆê†ÿ0lË+Ïkû DàŽ#qiÛ1<¢úæ} c€„Ú)2ƒ4„5ˆ+D7R:²a˜’ÒËBa¿ÔQ+ASRtÁUÅ% ü“¬hºÓ*;K-YÁ¨¬6+ŒZš‡w¡j TÁ»;a›G,† %=„wuš{N¼]Aþ{wwGTº¤=¦ü!­Ü^ËL4-¤ìƒøe‘nåšÎħü$¨FVæZÆ{ÆúIE+u71éX¤di”`¡¤­ç–Õ¹d\ŠšD-à²OÅá±ÝqD#+œÜ(Œp·lÜ|¬!]8Ó CÆ*•0* dâÍ’0Aëºÿ€0c¥mÐ6œyRiuGù“exýGÑ»Ì,/'˜v<—â‚ÎwŽÀÌ­#)°ôi…Y{vŸ±¹;ávsÿø½=PÌVÉ ä@8¢ÉKäM s¹1pC ÊŽ‚$­ã|‡T§D#nÛÑRkêͤŒ05{=Êna‡‘µËPÌi´ÆkbaZ“Ñ]MaV§\÷†ihF)„¤þ¢$'ÍÉ ¹Ñ ëø5T¢­'ªÕ‰v ‚¦‘ ™„-¢A7@0K N$ûçd99ãNC}7±ÄòCÍã3pC“lÊ•&V–xy‘0;s†ˆxÿ€Õ‘nz,ˆàwúw¡é5-×qf}†À† †“±Ç„ÊúAYt$=¡ «%ã’ð•×;ŸpéÏIA8_²OŒÉŽ¢[D¥ ÿ£Kõ\§$uw¡KºmÁÀD3]/•!,2×Á KÈu¸q ]5]ÜÌ¢K†V×ܲ=*?¥18%X0\=èG?X)Ó5)s’{)5)‹RQùE6Å‚ÜÅ£©KÐÕ>*¢’0Ph°±ª  ÿ  U¢ßœgcEHè´Í] b¡ ¨®"­ËŒ.¨²´²<*s$*ò“Ó…`ë8Ðö dÐ"%衎v¨çq±¿.‹ñ±Šr>†iFÐ9¹ÿ4] 3) ² ¹>!NÖÃÄS,-°W­< ì{ú€dpâáÿ ê´1êKÎ¥‰ 9)õ° W€ç—âÑ¡‡ÁàGVç'k7·cÜ)36kÎ%{R. /…Å ÓRÈ»#mÈÚçè•I­À7pyX-\gs2®(ãÀ–l$,pÞtÞ“ó:‘Ù:І±÷Q0Z-êÿPê´q Qê§¾"À ú “²dÑѵý{Ù…m¡®"ŠÌˬfv7t29“3¬ã/ÀuO`-§PÅv²0¦LÞ,…n—‘wR²µgÁ™]±e‡¤ï. £5!›îšÿÓÉö´¬®IW]’Òh0Ÿ|þQ,¡ÅþYL„„8£Ä f²@²"£,&Î"LÈ(D d†R3-!ÒHÛà .˜à©„tÐ(ÃÜZ«.á®Ã.$áLH8—–SrÉ„ÑÉ zz‹H$OЀA{Þ2Ê6¤ÞJª. ê*¯0“4˜i” ¸úaFâÛëÎ`Ÿ´Ä/º-ûC ÀøRK-†®»GH!jÐÂ|*Rÿ”1}™iJ$»ÄCÈþ±à-ó’|H🠼a!ð!蟅 úgµ„6h­ `C¬¶á²Ç !u,ìÄ<’§Ïë®S 0¼½Ž0Ï Mâ˜0\A„ŠÀ,¡ˆY 1ÒIêð…-¥ìpËþÎ'ê·>p4!JµEÁ ù'6Ûêò¿12n¬„CÒÞÀøJˆØˆe€kî+XÀ8pdl× à@v Tl`o½hç40>¥zSŠ2Û‘tƒ*ËÎNšI[ÿBè‡þ‘h×¾èÛç¬ŽçºøL‚ë]µã&nü˜„¤Û¿Ú$HÃùéï{`Ή’ /m8!‚D&a“œ<±€U¬y¢Ù€©fª °Ç7ÚÜ–F‚Ÿðøê+¥›Uÿ¬$­®uÈ]ðü¢®ÖùvºcaÍ\‡:×±îW³ó‹²†b< -mPΉ1Fâ™·x¤#?QLÂC|D€×â§€ïHj9ÝÙê"¯#,A-…T Y𲡆ˆa”ÄDpû%„[*nr)È$NBâ(#¸ÁuªBúšG>4¦*«È{ˆ#žÂßHÏ7fòpRœ2äw&T Q¨®š‘-…ñP¸:ÝåË%ÄaËrÒ+3-­wFCINZ“ˆ§?ðrÈHÉ„pí!†Wé\’úDøZ[ÜP’/~qPû ÔLt¨ÆÌOb{#˜f2³€ÿø ›J¸þÁ©oòïp‰Cœ‡â‰NÑO„™&@„° !™Û"Ïöæ…d|ì[ö¬™íNw ›ºX¨É˜prf4ÛÝðf'»$Õ 0+<‚Z"âôÅt'hšP:|š©)PÁ¶R&óä £@Ó?(ð÷Ä0j€ÎBŸ¾dÑ.´üJ1‘™– 9ä‹ © b $?† ‚37ÈŸCTl.à xê¦"ÎÅ.!åtHá(ã©"èƒòŒ‚ô´UiO&`Cúf$_dÙ¼ZÂ>êp¢Á“á:3šp’/µãK *“Þ…P„3Q‰½‚Õ«àlÔÿ!&q \T`µºø§[V dV\Šˆ˜G§õ@r*–0FWjªL²A|š¬6†Ø££(ÐÔ„@5C>Po©:Õov œ—"n)c02d“òÒ‚¢ò#¥ŠIÈnО lލ-ÌÆ·4†˜Ð±yákyûÚºO~Ò/å‹ìšPÚ9$¯jBqð2,»ØU²d%êÅŽRÒl™„L«ei7)`6`‹p¢ø ´¶˜¬ ™k+N…ôÚk±3#µ¡Ðb8óÒ …Ø!œ‰*C´¹©l*!ü³Tw8ÃMjRàA‚æ1Ñ0Œ!¬úÉN•Ä'ybN°Ø'âk”¹ÿˤ GùI‰&6“øh&Ç ,`Å/Kx Ô+ý''M3Ì<”"=ì˜GÀ!º†qùå:}9KNkÉ­¶taPkw 22¤B·U*C@Ì@•3nÄŒ¯:“:nµ¸‰+M«"f”¨}à‚ Y E¦·~à)+ ˘¿‚Ú_å+x&”zÍ»êÜ¡wXž$ke}Ô£X6’úRýQÔ‘Õtw¡ wÏí®FkÅ ½y Nÿ&N¬Í¸@…!%ˆÛøô‚j¢4Hu)g”úÒ—65шÖí5Wð ÀA*&ZõCx©:®ˆ Ï< ±éJÇs70„ÿ¨A¥«ÝhX¥Þ‹^bÂÂÙ•° tµAw•$õæÅ£òèhš’Ž/­£Ä©ï‘þQr|)9'ú6‚Æ’\98VRP6{•¬d¦@ò¶¹\"¾>±Å)WÜSŸF»ÁêÕ&´Ýcˆ9óa™¨ÛOO£;•bpî/&ãj¦P€¨H<^ ihêŽdP^K›v©S-_X606Q²Åi¢ë¼4aø$Ì+âq^%-ȵ—yY—È®+/³‹XD«4=?8t€$‰]ƒŒ@øÕN Óý”™IˆFÜ¶Ü Æ­Cþ¶î̬@ö yÅ£kââ†h¹˜ò>bÿÀ DL—c/²žÈØCpQ3j)‘)슖”ß+¼âEÝ®Ú&IçgùâL¹ÇË:º%ä-xe €òʺªdäŸB^?ë!Á’!Œ„ÚIì_üµ‚ÎøN÷r€ 8›k)"Z’°°°¹–‘1tû‡ÔËŒC»‰©±Ë˜ªÚ31‡ 4®p‘p ¸Rá±Ua ˆ’© :µ¥Q—{(µ{!¹c¬T#Ããµ~ú`këø¿ó’£p£·(Ÿ0?$ô!½k,Á¸¶"S<“ƒÃØ–“€šµX3ƒÀIˆh¿„h0P‹(_9¢Øú©#°À6ùÿ€ÁDC„LŽÖËŒÌp#†ø›­ú&ƒ#™ˆ4pºÁA6+ˆ ˜ÍéŒ û¢½X5PC‡ #™¨|¹AÓ9²1+’KD{ø(Ž ‘2™¤p‚±'pzBT,Â,9”°¡fZ/ßÉ‹RºpžúS]ħ¬80.ü¡#k¦5 ñê™"áè.§Ø}HÄ ¹- x'ÜŠÀÜB´ÀÃã&m .åš7ÿ!…Y® ð|´¢4!¾¤€8#‰“xÅŒB¡õ |i8Å»DbðóA~³ak¬ŽB’‹’TŒ‰‚p )€|`H†Ì‡S´‡((Bò£’•ЗÿzY/zÑ»1?ÝB]D3 0õx)Í1Šœh-ûH‹,”Ê_z­>ñFà°’A=Õ+7‡ Æwr=ýa7‚·Ë®ˆÑª‚ ÿñŸù— á#ˆS¹œ»QèÐ"…+¬8‰8ŸÚ³kÃG1ÉW"««¡›ø¨Žuj¬–ø¸¾kPIÈ|p©Ð¨Ë»Ô}ˆ‚6¿ŠD$YŸÒQ²»(ùÈ’P3¢ „XÇ„ðŠ3$ pˆi‹0 À" =ã— YD€ÆüM‡ ŸšxªÞ¢*ÕŒJ7H»”¬‹1ÈG‰ >‘ÙTIÔp83¤ï˜Þÿ­4¡¡º¾=‹»@¿™ƒ®Á°¿(¿O„Î0lK¾´Ë„àÀ(ïä…"ÐNˆ‡\€ÈV *™—÷£—AÙ!Ëû¡‘Òú;©yX©„84FxÏð©Ì:³ DB8’ÐEü¸.aˆ ˜œhL9T½Ö£FšÈ¦lÊ©JáúŸqˆÙC‡Çш…q µrˆ  ùA$ÎÓ³°È¢†k“I±ø!‹‰cj 1*B‹™’çÜQ󓉹d0Í"P¹FïôNK}`ȉ<žWô²°œÇñ <»–òˆ­n1AÊÃôù¢à)‹` Ãø£‰P2šä°Éa*ÿDèIC³Ã:œ‰ªÊŸ ÜÆË°*Né@nÂŒØô-‰Ñ‡@+ÒÍdˆD$Cé®–8Ë­—½À‰µa“BÏ`@ KmE#<Šy‹¿<Ÿ΄LHúQ…Þ21HÕT%R$ÍËxȇñã(—9%1‹$0ŠÏ§¸%úü‡ZÀ €C8IÅ 0›ðé ö‰c\­“ Ãøˆšy@ŸžÍij@ÐÌŸ8%‘§º@nŦKUnò”mõ”múIΠsÜ€I®˜˜‘v¼¶Ïû<ãŸðqÂx±’#{`|HqK ÁŠùˆ1r Õàü‡" WÓ*Uõ#-‚íLRÿX­8¥Œ-ÂfR-ÛV¢b¤¬ˆ€`Š„pÖÁ)?é³þÒü8¦°˜É£¨E4hL=¾±­Ò¬ Ùû›#±kTÍWˆÓ×Jª[X‡ΰ€Ò1×3à” y“-û¢¶ h532â0°ýZ Û‡´q°»K…mXG+£ ‘NQUV OhHý¸É” [üÈ)¤OÔƒxó óP0QâÄA)F.1Ó¹"2|’ÖwZЦR*ÓœCšÀÆl¤* l#nZ7ÍÍŒ"è›såBñËÉYA¢­@„ @!{T¹³Zñ9²—ô[ŘË=j ~pÿD¨ìÔËÝUHàíôÎk\Þ"-‰õ‡ýCèX"ÝÎ|(yN¼Ø[x‰’cü‘n1“yxL7{)GA¤V²‰,ŠQô5@T{-ßà0…C¥ Ík-´ØÃ-Ü2Íl1þߘhϸ^s¼ÍšX xÝžzÔz•Ä@ÁÊî*FèpD!Þ™@„ºäø]}ÒíLX†=ÒåeX6UO¹*£ŒÛNUŠõ€‹UÎðsŸA‰#rŠ˜X3+‰ìј2ŠØ_$3F¸Ràx­}beÍ6C] œÌŒÔ;7;L·þÍÉaªÛ/æ½ùb³·Œ‰P±› ÿK©´™pשE&á‹.Ú‹H5›hmÐè0‹Øãßå`9ä…þ‡xp@ ч&aå]^"]ä!uÞ^𔇌J[.™PUñÌ’Š¼á~¤ÑX*³Æ[- P¾ðX3«øáˆY'Vc­6»0·ƒÔ±Ø ¬…imÆwªbÙsjµGq½¬_ f_6ͨÓî$caˆ¾#‘€Ô‹p ™AˆW ¡ªG¯ð!KÜ}hšR^ðì\XPH@Æ®º6RS-‚GW¸ýŸ® W‰ «~Õ "‰­Ä´Ñ³i ñÍ»°Â±€¬š¡ˆ¶ù`åøHÀ¶IÉ»ÿ ›±­¦sÀ^Mµ P ú­_&c†8æí d™ }H \'!ùÞpCÎ@+¨%Ñ­üdŸ.жA¡ãH­£€Å°…ÜN9ÕŠ¥>fTؾ9RSÛ^X^xdGæ¦K˜¨”[ñ¾+~tI#‚ð@š‚p³6Õœìâ<_⋲ø´XŸ”¬%> !SVô4¼Á @ z¨xP 2BŒó^æÁ˜›~¬ž ™›È¤Ê4ª·ìr¿q”Ðð” ±‰òxéË©yä“¿`~€ø•lÖ®öíTm¾p¥mX†`üJžjUô@çíK¸ªq¿„5’KÑQ–Qèä©™ÐÕRîšDtiwu©n„¥d >Sp¥«_P×z°7=ÓÛu™³o‡XBÿ_êGøvˆÁ.cQ 7 ûùI1 IÝ¿Ùø˜ø °<¹›©hë.3ks±A&ê߇ ]jiÒs¥íNvæs§âöNùp›—1tÊj­ª|q—X&B"Rn™ = ”šBòH¤C†þ}øgð yGü`p_È÷ Ê["Ï`ƒ,þ Á(Ÿ!DÿDÔ‡HäÁ‚!JþË÷!½'Zü'ïÞÍ‹MþY¤y¢cÇ|5GmÁpâP‚-…’ô±Bß} Pú·!éÁ *°8ò€×…Gp.aqb#{QóñzÐÅAúâéÁK^¸D‹ˆ(ò¯_’X‡éePU/Š}ÿ¼dÐÇ%Èž†FþÇ8r^ùì…°GoÞÏæþ™ô§†ƒ¤éÅHmÐÂ(ÿÙûÇȵņ÷ èM`âïƒ5—÷“Qˤ' ¢”àòŸ¾þÑû)Of yׯ^bº³[æ& 9PƒQ®0¸½|+|,øgáêà\/ÞCÚßàÆÍ£V>èÃOtѹÏ?ñ¸À`º€W_wØ…}õ•aª(V˜AŽ16b~#^2Ù…ú=ôhpBhÿÀxLÁøi?ÅðÙ?óŒˆ TS 2%Àoו`C5]TÜEóÌÃRM"‰0„A†D'TÉIùvSÿšMÃÕ´ÄA!| Tt#ͦOx4AТAôÔT—_”, OgóQµáóÏ(5-ÀÕA }åUòÌCÏšù° ‚ &êã^D æ—_}zPªü“XRŽ ÅX‰¹-Î#Ó h£w¡É“uÎS¤øàóÿRV¹5D€£j¾™N¤ÝFF~dàAˆˆ@Á¶"!Òæ¥cš×#MÚýãEÉÓbgXµGTAÑSvÒ†é?¦.àB!ˆÀ}ZåwWMäÕW÷ŒÅ€’" ›ü”Ä`üx Ï].Ô…WR¡†Ê!V†±ªªª5•<c¶ðµY‹7fWÿÑp'TdÓ¹¢)¯ E Tk½4ÑJÐAv5ÝÃBYhV+lÿp[,"ï%ø-—[þƒô -Ly“AdÀЬçb€ÔN©™¸ï$J*QWtÑá&gá-¨Im°#!ìß¹ªÕ‚àBG\$„×ä1I ô±¨ª”º¹©>ô¢Jd•ýs2V¬>™ºP@‹Õó®º„Ó Õ½ø™ 5íÜó±JµvóWŒ©Ÿâe'%Yu²·Ü?í!Â-–úp霓4!•AÁ©ÉH ÿ©f'Û̽ýÏnCµÞ¼bïA#’E>~ŒßP|î?ŠŽuÿ„wôØ#©ÄØ¢Íæ tAɇä‹VF±TàûûÍQÊô¨ÿU@R’ ¥ØFKécB¢úË/$X„|ìBð’)!Íkãj³EF¨´^׌ŠLùžÁ¸¤©bŒ*H’D,€ŒV¸Ò¤¯Çpkr§Ä†‚ °>®ž~1U@CÅËm΢ÿJ$c*ØÒL¡¦ÑÊò!«ZUd†KHgÿF“;z¤å¢ÃjÅA$V›Ûœ)l\µ‰×zD/r©oL™jR‰2Ó¨Õ$iÚÚJ¦””€:’—ڔ¸MÍ=Î[êAØ– (N“1C„ŸTÈwÕ¤ Jj YÈ=~£05¬@í„ç¥Æ*¼ðâ/¤æ4w¹Î!uœKŠé 9:‚þàCÑ ˆ,“]Çø…«kÑ‹øº"E4;¢‡( âšò"F±²UáÕ’”+)jŒz¤aòrj&yÜH¢µxÉ-}õ"Ói pi«y‚‰Ú+lÀ¡HóÂ Øæ%ÃG«jœ7(AÿÀ⤳(¬„˜A:%’èàesùÚ¦Û‡V~†jŸ’Äî%60Кôí*ªò ˆHT“K>ôF<™Ù_ÿc àî;ŠAm†åѪ&½$^“®S·ÏæPLc¶âfŒá7qI§5!*V>#«ŽÄk:Ûz—ü® £DšÍ«I@Õ#Pb·ƒ¹#Æ‚?9Êk2ˆÄ'±™äø‡+w!mú`›ùZLuŸËÏËÍG1’„ªbdU³ZÕBl]~p& ÁÕ“oâ½Ö‰‹¯ùb%Ð;öa…¿à@ÚR»’x‘’:ºTܧVµ×EqBqK¿`¢Ò1? =ÖÖ ÞÿµÔ{Ë=ùÙÐøâ„A/ ÷ÁÊ ¶Ò8÷K˜Ç›/¶ä‘Ò4> …Yª{vºà¡fU?õé”ËÕ§ºÎ—ã€-¦Õªö ‰|°V&»ÈÉÃÙ5iæ¡ä°&h‚ŠÀ ¢¥š¨À55a'2¯~ɹnD 醥FmI³j¬Ýù…CËôLÿuË·D²!þp[Nw{¦Y“¨û.öÐGž´RâšÐï'p‘7 µèTRn'¤ÈoašçÒ8ª=­äÍÝÓ2íù°SаC†ŠÒØûh—T‡2°65cVf{ÜHfù+þlÖ£ý#w÷²±‚¤Ÿÿ”Ä …7éDø+®rÕnm™ÀA¶ó“X©jì[]25{xÍ^ÓtÚ·öäY64w\†ˆɉϛàtwǹF(Ì`6‘eÙc‹v&èjäùÂnÅxHâ'$øKeÆð+ØŽöj]‹ìᶉ â¡SuûFÄÍD¢µ¢H” "ÊÁNi@&‡Í¨\ÔmØÃhÔ„ðO½]D $ÍDxM`VLÄ–Ä•,W…YÑMa…5ýP¨‰ôDÀq ðE/ Æ/àÅ»üÂ¥àï …ÕåƒüI¡éNýTÀX¨Ø´0ÂWÑÅ–>`KÙÑG…_©1€‡ôÓ¹ÿ !Áž>NˆĤ3™$]ÌC½Èu,A ¸ÿ\8’œg¼P Bm‘ȹÈì80„<ìÄ=Ø¡:>{H€0M"ðæºI]‘`4AÇ@ÖDèƒg‰Ç…ÕKø""üÂlxV>¼ K„•^°Nü‹žTEwå>Œ€<0„ŠÉ’Ã\t°&_jÇ)‡Á8Š×¤Ÿ¤€[/úY\@ &¹HhºfJf4 ŒK8ÁJäCeöE÷Þ?L†'¤­àýÕIÙ‹gIM¥QRǕՄCüƒRDÌм'Ý Ûiâ´¹Gñ\YÆÞPÜ0B¸Œ‡  ÆE›ÌÖzpeItJK8Á:éƒÕ‡¡%.ü¢ÿE£¤â£¹…PìÔ¬°gŠ%ŒcÚGöK¤¸Çø"¦!f‹ìçb‚‰1Є™baëØ"¶„g)gø|Zbp¡ˆ˜ëh’qì¤O"‡Oɸ„Ä”œh„ˆ^d2 AbJ„–xËM1ÏŸqHŠ:N!v„r˜¢öRq…PÐüüƒäŒùÏ¿_CrH\&šÁ˜… ÅK—Èâ˼fáw´PÈÆ,WQÀJ¬„éb.f ¤Íb¢_úEü°Mu–¥ Ü“‡Àß‚ZAÔpˆœAØšFÖ½ô$GQ@ÏDGà¯<R†Í¡#‡}˵eÍ@QŠæŒÍ…½à5=ÿÇ5ÍŒåkpÞIŒDý­ü8uâ'(Ùƒ4ÑG¡ ÁÖ*Œv H¤Ä‹JM)­6`N†©œõ_OÎ\¤^?’„ßåC@´=˜l ëIQŽ)=8šJŠ Ì¬¥`_\áÄZ9TÇ]‡ Õ†È驳](°ùéA¨E8-þ0D¡ÎÐlÊ‹½H€`LO—˜ÄIbýãpÞÔ‰P›ŠlP|ÑðEMÐõ(V„*ÉþC›‚ªÒƒT˜*>àýô–A0€ªì î僔´@ò¨Ð? ^¶Í «,Þÿ(«e¦½ ɯаªìˆÄʨ™¾¬ÈVç„üLþ‚t=ÿ«ª HÐZuxG½äN…j+¼ý@GõÌÃäc R‚™½ G-åähÕ®\î±]f ›,—§Ð+W …šr‡ …ð ŧ¢TM¬Ø¢'©Š‘|"ȨQÁAܪª]F)AÀÄ£æÝ ,Ê„dÿv¤Æ±ÞЄˆšædÊãÆ„ä¢Í¶ïËh侬ÚâoþÆde„._ðìΕñC¯"oúQÕ—·öfJ¨…åY–TRrÇÐŽtHeÒ Å».™¦›ÑHß§¶pj\gAôh³ILDÔDmPÙÛê •Vá MA¼ÄÌљĶL‡å‚‡ â ?™ /„¬ª,dZa¶Ád:n½ Æ®_.¬)j‰­ÛäBíÑHeQ‡y¨-à u¨À¿LE8 ÝöÖ Wσv”@àt¨É½º¬^lÿõíO˜)jt$Û@HÄEÆ6ùëôçEûĈÛ±dýöQý½ìzðrþ³eŒñCñBH‡ˆ'`Æyù= KL_€.Éפ†h¤Æ®$…è ÿÅ µÑ ‰2V°kå›Âë¢>uMˆÖPØËOEÁÿ0“ äÄ‘»Ù (ò0WÀÃ~ÄšÀÉÙu2‹@ iÕÈËlGTÏÑá3™«¸€¼²ÅÜ„ØÔ&㬴@$vG?1HŸŠA¨Ìyyª@·A4— ´²ßµp$ã0l 7 SSEè5IgÏÄ€Ü KÇM5*tV ¾År.'átzBµ÷ÊË”FVö¸ÔoÁÀ,¤Ue&ã0>ßXŸ@ DJJ„'£!g¼ ÍêhG Åûá¬3BÄÍ,¬4`™¾¬Je9âD $g0^-ÇÊT»ÿÀsù²”*˜ LJbC· Ðò?´/ôBs…jÿÃð ôá7n‘æÐãq•èaϹÔÜ룢Q?ª¢ÖU¸„€ÙöW~ø™……§G[Ëø°ŽhØ6ù„Ó‚¸UìðAÄå\DZåt<‡'ŸÖgømŠÍ!³pæBóSÎ:WÆPw IŠMcˆ<„ÀS£R&+Íö²©ñoê¼ æCb\B/\/8ÁÊÆX/H7Ô‰)ÁtÏèæTƒõJ޼&*ˆ&Ld""UÊF¥1bœä Ë–¿êñVÂb͸à1ÌBJùOB¨ l'l@t8×ñVw ÿ"h¯¨7¸2ÓܤÃg™Äfl6KßfÞÐe­¿_§e† DÁbnmÜÄr€<èÃ#2NµAp.CÅÚcð‚>LwüxŽ_ô:-7AìD{·p–q9Ïà—N©ÒZ¨àF2Q…Íp8šš€6µ‹¶CPKÇr&ˆ&GbK¬ ·ÓÈð´DÒ×ÌÖ_ ù¼ÆÂz5>cÐðCBœ@âFGA80²XOÄ€õ Ü2áDÆÄ¬œïBo!è&Fþ¬·N¨Fa^G×$g¸AÌli®]dޱJcgFÇÓƒ øraô‚È—üATÌF¶dw”}£Þ7:Ûíà·oÿ•ŒÌœœ)G¸ôŒ%Và"«œ}udª ̶p¨öùdž;(Å@s»!ß¡_rV”Ï BT¾±Åe] gL)NèTÐÚ„Zp7ÎÛ‘x<üuš*ø ÃlªeªíIÓ=aÎaxš‡¶AÇ luÉÕ©ü‚®×„tƒª}ìΰëÒJ3(åšD$¡Ä¿þµ€ÐBÞ½ó6tˆH "}ÿ$:l˜OÆCè‹ò/×?z-†pøá߇(EZlèD`¾¶hHž½ôTðÌ7‚Á‚ 6XÀ'pÃQ—7žw"?™ÿ$¤ü°“^ §òRêû0Oÿ 2Ü›"#†híEÉ÷VŸˆ"ªz]²{ɇ^ÿTá­zNÞ¾uáBDâªqÌØ‡*ÿ|à8ùRü>ЏpòÑ1åKžöÊÕÆ!/#àûñƒ…ª*|°ÇÈÞ?{þ›§Bà— —— ®]-Nt¨ió 'Ê|Ëráðé3eÒYÓ!½0š´(ÞünzFü[ ôdžF‘U*Qß}ôžÚã÷¯ºÂ°š§…¾Óg"„î¹ç¸” '“òù®\\˜K•»2-2¿ò‰§Áœ€ #ÄḴÇ"ËëÉ,.¯"2"¬ˆ½þÙ°¡6Pûçÿ°  ϵn0ÄÙPbD»†„®8Ê€8‚ È¥*Š"Î9—>ÈHŸ\¦rˆ¼$ú ŠÊÓ¡/Û.„ÝükhÂG¾¤:ê†Úœhž%æ¡P~2ºN$´Ä¥|B8‚CC\K§Âx”‹1»„°+ÃÉ&óKŸÇ‘ÄÃþúERUtqC»`œŒ—|`Âp²†.éåÔPsA 'TÀÇ ~h¥È þöÜ´‹áŸ*Î!'úG€± dÈJêô¡:³•N£˜"M—UT°0ÑüΦCó±Çžy4 'ž‚ZàŸâûç(ùþÙ@¾æÁé-þþŒ Á¬[wÿ#•®ÂN%{V¡ïì)L&Äæ²TU¾,ÛTÊLDó9ÌÄÇ2G‹4õÁô MU!„(í—0sbG|#¸A6«Rº %zNàm$xÓY  ‹ƒ{^*çADª¡ËrLq»” ó£‡¦é¶ [»&šPH;­Z’)„ž4Pá'Ü«w>:ñ½›¬eš§‰yàšè¿Œ ¦8¥Â§Â#$|Ò‹1nQ³ÍTù+Ÿ\¢ÔÏ*.u®Ênü\ÌXyqad^~ù‡—ºî*­ 'zqAG]ñ} X ª¬Ý‰íQZjF³8È"€«$˜¨ª«!Bkídb)„©B°Iÿ {`¤í:›û8h¢éî9›ú† |K·4XŸ ÞÛ÷^»ÿ™ùìÈãï -À4SRS(‘ »Iéã0Ž[‡’™È$†d–‹B¼d!ü¢|Ñ`ÊÂAMuæ0­‚‰ zQBÐý5{iCnŽâ+žI@X¶A ²V (K 4 4íi&9^Dª6ˆˆ !C¼×¼p™DYÔCufâµ&ü㊹´(>.6Ä$‰ ø!‚y%õqÈ n(ÌûÏ?æ8‘åC»ZТ =1ty\B‰ÊP‚2|)©H†QaP3Iÿš™K*è†Gm þaÂYá vÿ(À, "†¸Ã^n²›ßi‡ Ì ж‘*=¤jý£âTx¹t`-ãŠ^µ¨/ڤ߳Èÿ±œò8•okߥ4dLÉÈÁŸLL#L EìX0¯LÈ:¶Y‰¢°·^(CÊ %R†™ËD¦1}Ñgçn”11y0Eƒ­œÐ†KîÅF¼%)_C"Y%h×t¾£>ÒpI¡¥@r gD¸ˆE¢£¥©`-#^s +5êÕR|Þˆ1gªM~g}ô(£ÜÜ“Æ:á«NHœÉtøÁŸÿ1ïJ£ÿ™×-t’ %Ø\ÅX©KelžI2$>%£Š žÐ"“+e6“¢ÊðbD­{Éé:Ù‹ ¦_XÀ)/ ²‹!ÂÒájÄTyáYΪ¥©3Š(U Yœöž÷“”ïP}DHMœI‹´`AY,IL’ž¨Oí“[œîÔ|Áˆ€ÐT:‚´ R'"\0µ¸U[vÔ£¤¼—©\0ž—¸*!)+—0F¯àª‹<ÇÁ†L²ž•¬L‹x‘‹‘Ç  3@ $Sb½Í?&zk¢¾Îpî!<‚´W£É*Ü– bØŽé’*qÖrzü <“}o3ÿÿñ4‘2„z˜)I>c¾œÑ?Ì•Á¨t÷¾2ò ÷3$! ® Ứ _5ÿÐ|ŽísÔ"ÿÉdªmrHB ($‹$ÙlesÕ7“D<ÑŒ0ïü#¯:ß _JÁÇžg’%ìç,\š#m­¸D?øiÅFf1UÐÒ©ˆW-™ÿãÉ·¥í.Íô"V;ÞP qå„\ب!&0­kxfìÀš%1° +åëïe©™YÌnˆD8îœã¡¤yýS”Hʧådm nH²Iíl0}'öø¯æ‘ Ä–§7°s|,°/!…Û2Aâ &#óè•Óˆ"(ãRiè$i„d"¨”‹5ti{µêh ¸Å5ÅÀxG¯; Ò ^(œAâY‹$v¹=7§Öp84‡dÿ´¦·µ|ÍC_åe+K·<‰EÔ’‚ˆÔ"÷ØlMXž$óÜð³9µIÛó #E{ÿàÔÚ0¿ µ"º¯ºÅµðÃDÉ•§¼ùRBÆôsÓŽÉj™OçE BxÁÑÄ+!¢6G¦‡±ìäb9ùh' ;š„³÷Ä/ç;R-iU†È¥4¼¢ô`ØBbÍZö²ºnɃoa‘DeôÒ¹½,¯¯}­@M~KXiÇÚ $1LÐý+Búé O Ü­ÅdfuìmÞèb/ä ß´NÒˆ+VÐ:ÍTGÅþ­,ÂLë5†DŒÏíá;˜¬Õ’ä”e ÐÆÌ„YöN8ÿ¨…׬D ÁËò‹:ò¨rPÂk¢zÄÏki{” ‹8 ®(6ɱdn5€#Âìaò@çèÅ!®éV€P‰èLšc"LD¨ìhôkŽÄå·Èt\äªTÅ;i‘¦nVì-Cê-t&MÒld/XäëÂt:I;0 øŽdøl#Db°g ÒL Œ¡7,"£ÂçY6J|2ŠB*@¨¯(Qðº#Ô'K{>B¥¶|FQ™‰ÔÌB€Fë(€´ÿìÃNî&"ûg$è¥h+ÿ´@ðt õ:ï#>"#Z†d~áJHH`G¨F~á‚æ­˜Ñ1û téߊë=ï &5O;ju433{åP‰ÕX (oC-rb¨(ÿÊQ8)Õ,£œïi¶D±b¢Ñi8gBO×o8„­-ÔG+Z@Ý% €òDýn€(¬©(䑘B*¨.b#kkÐ8ìÜÔ W¦*²b0ÜÂr*§Ý\à4FÑ&.HHÁtÖÔ(0 U†¬ôb3ž´Ç®¸æóëö?£P?¯Bî`møtC-’…!x§!ØQAïîð®5om(m)þÿôkBûT hB%FÎ%F¨%Á”e$U&„¦@nH ÞF'Ntn(€-1O;r)%.ÔñS¯63:NoP>$+Æ's`Âà¬+…° ré­®±“d÷f•Jqo3"W'3Æ´£l¡0©!\ÈáXíÕŒLµ‰R}‚–$NƒCP3ñØ+ãFbjôô*=‘Bû+ ¶u%¼æPJ¼.%ÊD´]y£'¨ 9½‘_\ƒN¢.å"©HœxñFoË"2uP@³xD:Q` v $p$pƒ€2͆†ZL0e5nÍ¢e©L|,¦äa-®#®²·+ý4ª²gÍj«MlÃUÚ„?xÓÔæm"lQQt-ᨰM îŒÃVྡྷ$p¬³ÐB ÿ †¶èHd¥@ dÔŒt0,äÂÓÙxï$ãy_ï !Ö"6fb_rW‹Ë¹2ƒK5³{=@Õ áo™Ì•lpÿëqYÓw P³}2—C!šï#wÁ¢æ,"ªžJOõ+ÅLbg)Ô"ÆðH%²5ÕFÕ‡]ô§vòu‡¢N¤v_¦ðˆDÌÐtKq ô8,kió`£@À¦\F$ ètÿÄóà.[¯ëìm댫=ã÷J;8hf&°4?¹T ô3€!¼>Ó6DIâ3BYÔ×éqµ¨Yµ£½öî)΂•0×"°•K°ç©þè[ª¶D é#L$zÑÖm,VöB&ý‰¸.íz%“2&pö8(ƒ2ˆ6V ö¶, (€ílƒ|8ÊÎT-Ä)Ñ"RVe5.IœO-âd67(4O %f#䢆L¢‡-Tª¢<+Yš@ µ!€ â¦Î`±} Ãö%)ÒèÿD OÖx±ŽGwÑíS‹ÐÌ ©fþÀæCËݺŠER&3ÞPSÒÓR`¤V9ãIõÐ~ÕF4„’793U£3à ÉΔL]ðL‘E‰¢î·eÑ&Š/Ž¢Uï¢u%²¦f#ôÿþA|'„‹Á…[ù*–³´æcV`jȉÏÛjí’S+[ºìoÄ0Da»S/Ø9놚žü)3ÄŠžБ“$4V[c9öÀÿÌ79Í‹ý` ‡ ÷¶‡røú³Áº[6£=¸…ûY°ÝÖ`ʘº$ÂØÛW%r#qZ€Zä!‹Šù]ñl°¨Œ×g¯ ôï=µc/O –Ó-çf ¢ß/µ^ñoã?HŒʈö«G¶FÃô¢ €ªd¥%ZýC XMe–XgõÏÿ[bMÔ‹'>ØÂ /qÙ%×?vÅE—]­"Á,ö`Ž6X‹Š}@cÿ¼è" ”u6–›d<þ¸VZg¨y4¤G®e6Q¹)Ùl'ÜÓK´Ðrmh A—ö@‘”ÿô*8ÁP{"H´‘E%]HÙ‰Hmäà í±×y¹PSMñä^x7¹Â|\ʶѣ²áö.\*Â/6èÃY}uY‚ éD¢ÕAªLôaˆ#NDŠL°Ñ<'œŒ7 ƈ=*ýcã®å6ÙF˜aù }fhDþƒ´¥bö¤ZMðhfn-œÐ– ôOÿB¼Ý×epÆ41K€ù=Ë€È pN'užà9G€Ô‘Þ÷ÒK,‰SP艠ÓC„ºÀy!pIéD-4AqÅfÖqÆöáE>O‰``§XIx!Xc=XòDNÄ–-EtÀK]uý#—Ì&еj¬)~Á_10r‚Œ%øì‹1R#a.ÊSÙ?G¨­–òDæ™hÏI-ÖÑBÚZk=¾FY•R†ùÙ@ÜvÙ†oÇ9Aæf§æ?P8ÑÜCòV4]IýÁü`¾ Nxü¼4žÀŸ·Ó?9­äR>Î&ñÅ‘jœT.šoî„Æô•O¦ è©É#oDª©¥úàÉÿË#†øÏª°oë+Æâ<1ì:‘bÍSc‹H/öØ MŸù´´Ð"»„ñ•m-Ú‘LšòÈ–¥gUùO'„)¬Ó%¥¼ã¼-î}í6$‚¼ýsƒED0l{æ+’wÓ­p¸˜ÀD<+™ÉJ±žÈÄâ’n.ׂ£xdsùE/þqÁ_<åR—r ¦Ò2‘!eZÙé<‘¡±´f±³Ëª^8»Ô.PŒ=zw˜ÞmäVÀJVaã[ÙŠiÚÛQDÓÃKFB’‘6âDì5©ˆ¡\ÐÀ7‘ñ¥i6`ÒÀÚÚ&™3Iÿ(@›‰ ¯ ðB\™GTa‹¯ð«r!«ä²ªØÉåD¶»!=ìÁ[%f#,ð¡­‚Æ´  ¦1ÊêÑñ~tšuÝèJSTË“ª÷5'q­{aLÓ•ˆ4±µ@\\2ƘèQ&ƒh`!r[Ž{DP?ŠÔ/oùóÈu¬¿a爟¹‘‚ý¤'@ ŠOòaù¯ôAÇ¢Ç]êŽÜ C5UIFô“ºJ€Š°©Lñ"-ò¤„Fx– j{—ð/ ÿ0¨*.°»Ù\b¥¢¾àRW>›G ˜Æ‚^&3SkÑ_ #§a Q+›•nô€ËÞ0:zÚn'òÛ`k¶À$âòNƒDËLäVºa ´Žµ5îN¦ŠÞ£Ô|¤ÄštQŠ|^l‚  ÷ y"'Aà:‘wÎO#{kç;×뉼®`¯ˆ“MLþ “ÃÍ(0ñX>j”„Vj"FÉE 1µIlt’|žd!ëgÍr´SeA%…Ωt ´µÇiG¤Ò„ȯ}­Š‚øÌÿšî%š´Ó1?"l6#\†GÍ»’ø IØÜªSþV¥Ä-ÞØCásMºÊ®§ ÚeF­ƒ«ô-ž¨Sä:‘þa§½nüÇG0X°¾‰;äþ”ÁÂù(““ RŒ’º€À “$'uÒÉ_x³Ù³l.|oÖ]‚´´¥GF0š©öU²’l/ý—ž}€gC»Gòˆ%ê[†QTµUŸéFÉZ´~ìɸ-\ÛBÅÍ®‰ 'Mç2p¶{l+ß óãÛàœÍFŠÜž5ŸƬæñüDŸ. ä LJÜGùÜ|:7Ÿ9»Àcÿë.°Õ‹PàCj݇²ºƒ%œ2´ NÃ-`nzuZÿc-¥´Áa»MCÀ/ gLP±t„æöT˜»Ó•f`ƒcψOÇÿÌ•ò äLÜú^o&†¥Îtu›Úæ÷¢rR ­è[+´‘Š+AC`;E‹ÿ0‡†}Ài%ðó‡G`’9ES%ð;·bÊA–<‚9z+Ž”ûNv;¹vK¹ë±À«ë«0¬gR¸Yh,ƒG-bʸfZ Ç–ùž'!„4«|ƒ±༠XxÈa>aZí"9åázC#@hú°#¢µ«›uÿ!Ђfiuô;û¨G·‹uÚÉø[/ð@$Ð3ü|¸˜à4p{C«s[·u› Âp:¹A«›z[H ¥~û»"KD·Ñ ?æ^ó½A,dDàh!CÙ¦‘ ¯àyvXèåF×!›1‘ë¢{_øt_¢Kºn‚ºŽXÀÖQ¦ä¸[o~ƵEp9U‡Yü ×3k°Ÿº@ǘÓ“˜ñy¼pÂ*¬ÂqJÈ‘ Íûºšõðõà À‡ ¸Ä¢™„)럋+Äì(°x©ymºy Oœw‡\Öšj¸Ù.läšÿÅ‘“Xßö'à £g5á›`ÙcyÆþ˜»#€u Öµ¾§.@J2Œ:廹ÇL¥ÑR’ëÂ)ìÌ«-L«ÇûHP€É®û¸HO#°±yÛ›$ž ϲ1 îR*1³p{‘n«¨mᨛ+[ PøkX(¶¿ˆ%»é8 £Ë†º¸gé‘¯É ¶µ)Q‰î‰rÌÌ»òSÈ[8ÈÁŸZ°¶Ñ’¾{Â¥òN“›È.| €|¼9Éûi‹«$±5Õâ½ñ Ϲé.G¨$|šˆŸû,Žå%´ÓÈ`T­¿ÿpÅmÐá:ÿX´Ì¡»ù'îÑUWu"ú{lu½Ç`Z:^‡‰!Ð?<„q8H°C3ŸÏ%=Õܳ¥‚ÍxK¹,|³ÿ ·‡-„õÉ®/ ˜ÆM?â#÷ÿp ‰+Ôß«Êá+!ð41„A¡¤œWWj!´1} ÷¹w™pÅök—…bãšÅµ¼=Ahæ1˜¨Sw)ñP–}»S¯g‰0»‹,S#j[°{½Î}˜A°Ç&éœ<ΫÄ̓-´ê2ÃC Øÿ¼púó.Œ±Ž¬ôßùŠôôíØáß@‚ D˜ÿPáB† ÞØä^“‡Mšœ â߇$ úwãÃÿŒüÛgò_*èûÇ/ßÌíÙ£÷ÞÎóèÍkñ/è‰'–%¸D^cÿNüÓ N{mì9¡çäêÖò´÷¯‰<±dÿÍcA`àÉ}' ¦4’CêHÐ÷’f›í1 ÜçYz[Ì;ôÄt¡KZ,jìé ©Ýwª¶©µñ®Xƒ •Göù@ÿ » žtrmŽ#%xL䟃{ƒð+°ÿþð/¿þrÌ ÇêY¬ ÈêqE²,{!3Ð.Ä0Çþá"Ó8ü"ŠšóÉ#þiŵƒöŠ/·”äbD‚¯ÒG¦™ò¹ §Âòé§–{ª(êÎ ;cZЀ¨î¢úN…ò!/,c¬£Î©³^q/ƒÜ2‚ËJ°Ë®J`ƒ’p°Á,¨°„c0±Æ 3 BËòûG ‚aO?ºG4Kô´¦¦ƒÀ£!¢€C&(áŸ#ÞÂm¯“Œ‚| ù'¸˜ò©€¦|>Ëvb„D暮հ3ê©‹N¸HHïT8ÿ­ª›;ÎúÕ¬ PÊÁ­ÜÞ2"·¹ì›à®#((ÀÈÀj×$(cLÛdz3ˆÊx!? rä\uôì’œ'$" þrRƒ´t‹ J¨i6˜ôÉ'¸¯F%õ{’C•¹y Ò9£.Zb‰‹.úG» š£g<…¡pîH§¶;!=y ø§=Ü:– ¹ŽHÀë Ód“@l“3AmƒìW ”Ð2ýŠY7é?EëÒ&:ô„Dy¸`ˆzjeˆ P~k¥d+}ƒÿá”~>E¸ÔtLÕÇyÞn®Jì*~µ¨ŠéV’©´Òª ‚¢zê¨ÈÂàžÿJÚ.S"èEKjˈ0(J¢œÙ¤0‚Ü<è°8³mpÎÇ"4@ܸb]G°SÚOÓ}õ¨·ÿ™Àþ©·•²¾€‡#Ììú &ÐGF}@ªq ? 5zŽÏ:Kƒ‡[5kð’K¶î(Œ™œjWÕD²¹£ä9áˆ{0`!Ò•ˆEÈÅ•÷zòÃ3—vÚ¬–3EWLc†æ ÔéçlHšZb÷™ø0í9MzÞ&Ðj‹ñï†À @k~ü’OæQ tÊ„ ÉóHµ¶ï|Ç'óH’Üèæ”£¥(H²Þ?üö7…íV%cÁSä1©€@¿\ÿƶä €¢BÓ¹Âìl!+¾E4ÉèçêRà=#Ñì†i!¢YXÐ>Ì‘ ‚¹Ö@0tð6IÖ?^ðÙœFÿ8¨fãä„'·ÛAÔ3ìÅ:ÖKMs ò¾……†qßß—Nj©q 9II”X ÎQË/éÖÿsº!@u˜Ÿž F ¹§]ÑÞ?~U¡ ¡Nÿ[2˜ðǃðC‰àà&âG¨ž´‘…™j*mûÉÛ¦S”‚%(dÉ!Aè¡{à¨ö SZð+]Öìˆ9PËðÂè²Çѯx áßç¬È % ŒYeÐ$c€ÿTFCà@çIË„˜ñd,â=ä<‡ªÐ„~™ß½F˜®‚âör¬Þ09Ûòiáh…5ÑÈO¾sèlÓ¦ÜÔÛ@è²NÅ£N(HS ÂNy$Œ‘È=éY)¶ø'M¦ü\ö‰€þc1Šq…¶p: í,>Ñ™5K€0€”xÇ‚–ZDX±=óOº‘ó ‚©ð„'ª!Jt„„ƒ'.€Ž¢ÂÃì±G-I­OÊ<ùAùQ*ZüËçþ XĸiªÙJ FטÓIÿè_4*þÁ„-tâ Ÿx‚2ךÖÑ€h–‰ë?A¨'pAO(ësåÊ5¬AÞ}«AÜQ§I´¢óðÈ‚ѽöò¯Ž©W`…™ >k~âeÿñÄ›‰A gª…Yv9z[ŽÂæYèC.8§jºÃM@ "Ieφ·ÚÈ©»ïAnÛ-«î–ª«ì§cüù-Þd Qq=6ÈÁ q7gM¨h@F„B$"™ÈÅä…p¢  m™½»ÛఴׂúuhõZ”`Rña& ¤y“ˆ8˜ ÍXLœÙ± ¤&6 e-›‘›ðÿ">âñxDÁ NÒÀP")²Lª‡žTRõÂá’¬ì=¼A¦€º->è½Û2ˆbþ)4 ýC·[,,M§­!¶Æe.Bú4‰ ÙÇiÓbK@¥•4JvȰ:„y´!X”Õ"ó[*û’p¼ª`@Àe \`R @ROB€“†ÀÌœ"?j”fLÀÓT°F,Iðâΰ3xôFó˜å“j 0£á᥌¤ãV–›‘Þ7ŸžûœU“í­ßþ¶ ï…±Aþ94O/HhÂtÐH×JW¼€x;öª{,"Áڛȅ¢¦ùøÈ¡)›ìäyÝ«‹ÿvAÅ%8òn0­ø‡@@‹‡qøy æØl«”FÚ~Á ›7Œ.@„D€î”BI5Íñ› BwaˆEÅ€1ŒJ=šÃylHÕtÕ«&¨ÊUfñV³%w¯zº ZlŒ·L¼à(‰Z”›ã¾›B±È%rZÊ ¤ïCÉ{Ú^Ël8Ÿ­¶äKÉð •¼K@0 ó `ì&ºøà1‰ ŠöãÅA’nš$û1‚xµW{¼„b²Ë€a!€ 96«Y8 ½Á»z¸€Xù²Æ¸7ý:#¸‡(¡fÿz&˜ÄÇæ1¡gj³NÊ#º*ð€Šàã+ˆ¢»h‹¢8¦÷¹·þ8ˆþè(ÒÃŪʴ³d +*Å9€…ô+ï{ ºK¼#±í£Ãzˆ.¡B#ª+±x¤Ð:zhIb·ˆX¼ÂIì9Ãã&S‹3d®ãÃÊe<¶Ì2 ‘8; š9=dÔ” ´3 ¤4ó#ƒ˜=£\3ƒ('Ì”ÇÙ„ŽI¼•€'0Û‹{Ó03ñJƒèyEPT ÅÅø µl:ù¢½Â€·$L¸ÑÙÌæLPL¡+²H$o‚ʬÐ)‚p¿ƒÉZs¦ÿéx{£ è’“Ä€àϳÌþ9Œ ¢CÒ™£ "äK"‚˜‡|áÀ×C„Edˆ±I)G7HÔ)œ`•óк‡#*"h›å[´"ˆ°ƒ´÷Y‰%ˆ8‰ÛêŒå„Åík;°‚NíCË»ää­Åp…0Qx" r^lާŒ§„Ê‹$"…µÃ´µºú?xaÉ€þ(#x"ð%´–5“îK@àÁ°ßL¢Ý¸‡š(˜?Â@mÄÔD© ì@B:‚ð³Њµ̇±U™‡á1*ƒ¸7xšœ´ÊI½(Qö(æÃ|9Ñ<Ç@Eé4έNñ+±zÿÀ’”‘‡_Ž‚ªŒÀ Ê8R±F$kû;Ãh8³88IÀ“Ò) & ÂzYÐSN 0 þÈɇb °6èA)¢$Ö T©6%Çd}¦øÔjr‚˜’Ð:-ˆl¢D""Ñ”I´"J´áôÍÕšAHCÑD•“€Sƒ¹ q pXBÂUÌ´[Ý»ÈX¯ðµ«§gu‚ %ˆ|À ó¸ÈÐà8õ,yxŸdÒÕÊa‘ÒÉYWUjIüäÒÑ Jå ¯Ô€€2;Ê¡Ü6„H!™€¦TM¤$ÕS’$ƒPFP F7^›·”I* ÈVkíÕ­\(«*³<Ëqÿå™O쾟qŒPWQCêôñ[ŒR㘠Å×ÕÒuÌ}Õ!.”? Ã%Te2È“¢š¾óG…•œ RÏ«—ùÒ§L+f+E;¦/ý¹‡!ÐýZžæ)ÊBdÇ?j¬¤tJ:е!ÜhµÐ”EÄ1´°I¡Y ÃVà„'o%¢­tWÎàÙãÌÈhËuE%KŒ¬’±ûà‚Ð'p‚­u­xÓÁ,OBéHTE@a2 øµRƒ¾‚–Éé.AÛe”±ÀœùY¦ xÒД{(ßHºz‰6­‘p|,p\…Ñ ÂSqJÊúF˜‡Ç}öÉŒ{ÿ»ÖšAÆØÊœÙGEK-Eˆâ<^Ÿ  ҼέùuÚi¥ p…­qS©õ3‚È«ˆu,}mŽèK4¢° # [ú¤—Š“Ù÷0Ñ'ÏÊBœÓ'ÅpɬMh³·FóÕÁy3É8r0dmžÕtÐ'Y› ÅZ©]ñ±Wí]˜y‡ÓÒ0¤R‹É±VIÁ hÛ æ 3ÇíßåYªR“†H¥zÐß(FÚ¼r%žÓ MÝ™w\à¯ÒŽ]Úfµ‡h¥OÞ)¾âÝê`†¥O¬–ÿ0È,C‘!pŸ^ÅIÆ è)ˆéÊÒÌ[ŽUˆÀ©ÿÓ×äŠh·Q ‹ÈÓ‰6ÌØà’€\‚ Yö%e-Y¨5á«‚€Ñ„Xe MT­:ŒÂâT\}HÒ¡cð ÙÈ}È…|è=;{0‚ñ³”Š ÓN ² BÜå Ò«¶dÅù;raÃáŒV ¬ÅØ‚#&ˆaù¤ã/@2MF>D$ˆ¦«‰…q]I~ÊI&$8; J„¢h“”zc_šýÐl%å{,ÔÞ´*£-dˆZð…Zø_@†VhÐHn8ƒ{‡K¸Ÿ¸RÓîuÝ|ÈçqGw|¦Þ›‰6Έ0¶=‚i;I6´²í%j¶£)UÉáämÿ^Nâµ—!Ð> ½ÇDÛÍÐØ—¾U©¢,J¢\Læá“}’r‚Ê…›7bIÁJ¼ÐS~VâB- ¯ô (J™ô‚pè8ëÎhe„€¥T[Z„NBÓ)ˆj%mÑ $f ª¦Ë3h°q$ìizÖîȳ< ˆP¦˜É Z¯üØ«”–“$—=F‘ÀaÁ(ÈÃH×¼8¦>Õ?# €Hiáý:`ÿr°E^ˆQq3Óµ‡6~Gœ ܄و€õyÜ#`'›­Ù}ÁI-ùÖ‚ ÍÏXëÏHå†KBžÝ»èWo‘€p®‰(øŠ_é0iÞ3ìÖÝׯ`lÿdìf¶àÿ£iÖ>ËÈÖ'šOúT[âÈ—‹Øt³ÍÉáçÀc ðÉ6›^@ʽA|&¤ã@Ú“=Ö7q+ŽOŸK]£1©žÔCöÕ‹ßLâý`¨‚°ã£ ZŸâ½£;`ª‡ú”€S¥i3kGÝË3ï–½Å6<Ó‡@¢ †2Çx£…NVˆœ¶šP$ÞQĹ!0 œ”¡†–ý–‡ À—(¤¾À@4Öë•Àîí'SRÁd~]yŽg…¡íyèºJŠ%Q~¶Ö°N,Q¦A†p‡¾óƒHk„håån±è¾\.NNÀ’1«ñÉ`Ft`&˜aï_"ÿ(Ý;ˆqü‡(‚÷(zõÞeôô÷†¢Íþ+ J@Ÿ¦€ñç¤*mV‹Dá£àÄ–t6%¤‚ñÎÐÂM§6ËÓx‚¢g¦Á#Ö‹{|â”1Ú=?ˆ‰6ˆ¶îŒç>CÔˆ (·-ô•íï0l‚pô;kÄ‚ˆô(< 0²Â™ãVÒ+ig“Lr1€•ìAƒÈ‹;"ÔÞ˜Fø -ÄoTç;cjZÏu\ß×}…dK¢êj’Óäš`{L«¤ÂnÕShùÐ#f_äVbžuvqÕs;ç+àÝP‹Ñi—Ô$ü«°w ˆñ`æt[ÇF§ôq|tIÖ/wqo“ùäô(BJ´ÉQ×ð«c=†»äîP`'üP³3ÇØ‹aæù/ ìÛ.ÿrçÉaKóˆ!e‚(â'€ÎP3 £ \V¾h/¸ÎxÈä­zØ*pñªù"uUWr©OÞ¡ÊÂfìÃ÷G_P…‚hü"XDxl°5œ9¦€MסO5ùeD¸ˆ£åÈŒ¶½Øï°fFÀC•â/qlíƒx¦1Ó¥ÆÞÕ^3fï¡ò:%vŸJÝSƒè °.䈀!ù ÿ,éÿÿ H° Áƒÿú!ÃøþhuC !$Tø°‘ ¿@ DtƒBE þø×á_<—!nXБ‘½ÿThPñІ ŒàwcÁ¿ nHÈ´©Ó§P£Jê”çOªóþ±8Q‚…Wª`6¬5°VÈÿ(ü3¤¶‚¾˜?Ø«`¯` üb’D„¨ÂP/ý.ýñÆ„¸ÿlư 4FP—#PÚ€òà°˜3kÞ 'X1Jœ8ñï ÎGá3ûïá¯Ñ¶þWq*ÏöøÝXÑ?~ñW`pÙÐŒ'^Έq<rÝ $©Ôسk«bÞí§¦Ã‹ÿ蹄vÙÉfˆoÁ.‚ü`P… zž.hïû¿ÿÜ„QµRr…`\ŒÐ# BÅ£A FÉDØeÛe¨á†Í“_B怓ˆã‰HšAª¹'›@ª)Ô^z-ª§Þ@ µæÞljaD_AøÑãn9ÙÅm<ñcÏ óT´Á ½}5‚Õå›=öO<'ØCÉ@Ö­Èá—`†õ¡S' dÚˆ¥™gЋ Ô"AíA$QCbÖÚ ]ÓwöÕ•“ƒ÷ñ÷ßKAñß‚FáC Ý#Ðeå=6 4#ä ‘ùÀi¡—a†*jBW9uš™ ‘¦j '¨f–{7¶ÿ¸Ú‹oÖjgA+¾&PIˆ¤«1dõß@Wð#A¼`<#,µÀæÉsÄ=K±„<òœJ¦ŒÌóA¥/Ù3BRÿXP™lŽªnTZpW* 9ÏhZa‹­É[m¥²M˜þƒ?C!²z4Ç-·Tüêü!À„Lk›¸¶ÿ«ºâÙ«nV«ªÿÈSæ?Æà¡ñE†>­‡fŽéɼÕ< [JÏc#‡b¥;÷ê¬ëgi1îPD{§H;ÁE·‚ˆ|.M}ç©}A.1ÆO|NÚ„íŸçôu] ,@>× ¤zëÜÓܯÊù<#­h¥(k*ÂÑP ÁŒ0¼8mþÏ=Gd›U18úÿ»i 6ÆíD†ÒIi Õ¼@sŽòþ —²,'¸ÁöºÇAÖa"z£‘‹Ô0;•O,øÁ äã­ß¨`dˆ<¼¥¤0BZqÔ˜ˆ…þø (ùžAÿð×(àY0üè€õ„pº:ñ‰ÿ ‹údt+7 p­0}Hã Ôe,(Á ÑŠl }7¼ß@ €û]bKhãø§ ÝÇOL¦•¸Óü‰¥“ª`áä*¶³]AÌ»Ôà{îû”€½%\‹òiŸHÀÜþ#ˆ's¹&4¡q;Hwº£²«|4ŸtÔç@¨€ ðe²‡"BúR;pPÙš öÈDÎ*o.’{, –|"Ad ²€½Š".Py0”kˆ ‡ÌÊåÖ9Ë‘æpaÁÉ0p¿“q.7J´Ìì~ÉÿOì8(1ÿŒbùÄW;ò"V€À?B ’ߤòZ ¹" ÏÐ\c’(ˆÇ+Íá&Äv¦Lmì<‘=èñ5iÝclŠËMé*T®^ö󦘉¥~(´* L,¬A&‹pF8¦J:É’„š4œi£ícA‚œM'Rg;c0ºô!ÈÊÉLF~äƒ$Y@®ÃËžâô­QáiÏ^å”cÒ†¡¦1ˆ´„—&é(p)BQ‚d`œ,€Ú ~â4™é*—kgVT—LýÙ!è&fh³­ÿˆ@´×ÒR%Xr=˜"K¸HÚý ±€|Ô8ÿAÁ‚ŒÐ QÀŒr€¿å€@8°Ñ5ž eðŠ¸ª–®“¥¬ˆ>>ò}|@¬óèÔt½úÐŽV m¤iÇ[›ˆW¨|K 0‚ &¢8ÜbšeCyQÄõíÿŠ+ÊÜF¥^5Èè²²Òût­á‡>útùÀNŸ‰ˆL§2¨#¯†¥Â¦(ÞµNslGÑ^ó`à=y ³>–ÆÂŠs¿lcFGÙ¨wÆ•QAÅÐt ´ȇ3ù‚!ÿpAhµ°R˜ˆ:|à‚0Ovò†¥†ÕÑ‹R;e„ùÒ{ÌXùŒ½ÿÆB^€ØîºÄPèÀæq_²±ÿ ÂU£@Ø(Àº4.<å)BüDÏ¢õ- æÇ  ÛÄ™ùàKQ’B™ ›™À1ä&ÿØÃ¼aœÄb«Q ÃÓQ6Äp{ÔÆHÁ?#èæqŽS”!î=è1$媭e<©Ø± NujpE–Ë@ò± WÖǨð²&þƒ‰¸8/XàÀ‡ b%ûhŠ ¼"ˆ@ bÃSðÜ ´Q*h(B˜¿â„ d´Ç @äQ âiÃ* £úbƒ°‘ú!OþY—ïôx¥ûµ@ì]ä…΃ ­ËÄ}Ù_k:¦å¶<€0‘$VÀn'èöÿÖT>!‰<€œ)Ò"ƒS,fL ±#©¢ƒü€òfÄnPdz=7‚T£þ÷á:}£Ä…ó=tL¤1¥."´9ù!‚0  oçU°N¹,(#ú @(S'kˆ¦Z Á¼Az …˜"ŠÀ! +ðÊ“@UV`o{ÿ£qÈBÀÀŽ"ÐF FDä„ã# …@äÀ‡|ü˜Z ‚¼â£zd¿Š}”¢u»È,]Na{ZñŒ~ "+}§@Ì9{ÄÙÅùîÿ„KÒªTоŸ¤©N¹K l›./FÐu¤F¢fÿsù#qDƒ$Ùkw´[ âìh³7"OÞ%°_‡r#0]ˆP=u·7ðöÖ)"p+pE 8€;âP‚FhAn9ÆUûqsuBÔ7687µ [G`QsAÉ…1°4ÖtÀåbË×tDÆ¢\Ôw}øVU‚uT"¼PÜWg¥ZS poö Kp\2h‚F]A†~žòlÿà~kò…†p²=)aHSˆ0k8MQ: `oÔ5h€Ñ$?g%_‡µ!r˜ú°†EP´Aty!há?T)bT"ÿX"èU;T'yÓ3­• hq±ñÆt,U¥’ukd|gÊ—ƒÔò£Ó24Ñ÷ŠÑzü4ÜçÔEp¿oÄU—ÕY ‰¦VG±Orâvh!m‘ÿ†qÁ†+Q ÁuÕc‹üZQ>˜×)þ÷  5]·Óµ`¨Œ*q¡“?Fl§67ÑøÑ8±·CAcP,0²ñ)Ô ‡‘ô2’$1J'KÃ%K޲?q}-cNÄ‹²kÅ}Ñw8W‡‘GÇkž•lˈ”(ªávbØvï‡+±žP!µAu§½â+ÿ`! ×øðufE}¿Á‡×¨`ÿ°q7…ÐôÐ$‡½²qxÑt!!djp8ñC-‰á •¢e/ò*êæ%‘BjÙ>jâ(ŸÃ‹©$½cÖ“…‡•™‚Ms»1¢—ÕŠö°Zx£" 1FaL¢©/È©ãJV%}ß™o ¤>–ã·Š9!˜«óOè)2ÁÞÔBKì)äy!pVÐ$ŒóÙQ¶’±KQ¦ë”"{¦N™`gez×(l Ð@ñZÓJÓYZÃ5>R%\ÿÇU–rÀ6þ~FöaV"f%]yáñ.G‹»!h!‘œŽôS¡…'ì³Bßò‚ÿc£%«Áò+=’g takNÅž¥±XÄò=ã'èY2öä?ò t2·äIžwY׈'\êlb±±¸¤5D'c: NyªfE®ô!´~2)ÀÝàš]Ã:¦‘Û ^àÝ€ó 8Ëbðl #Цf…d§;XYx=™j½Â*æªð¹œy³"ª7Ð fÀ,p¯7ªƒÂÔª¼qd½fl¼¶¯aIs›8×â+@AM×b?rԜÞr$2²êUÅÆÕÿS!lÇð'e¡†*†#1&Û­>WX%"@LÁmî¢;¹L«çÕP)‘ºö *¨ž%²KÚzÚqrPíT£Bò%‘Å©ÿsfS&Œµ£GV%((±ø =Ƽ k&Ážq4·ò€½/•Â`sžë¹ža¹¤ Ua&éO¦’ƒ¡B¯1“Ea$±®Ø‹ô1Ã9¹A¿ áó4£áۛɠ\ÇqÓUxÿ°]° «`Q–·{Wø±Œî3Ýt,9p§ñ51T—Âê Xg—ÂÒ2”å ÍetÂb…(<-Œ-h»8±¸RÿqU”…lgU€Œ`P4Ec|¡9»›ÄW‹Ýñpö@/L±Xýa Rœ!‡ðGˆ¡×È­Eû0±<Ç"ª1´AÁ!Ñ÷Ql¼G¤q]Í+ƒ·V‚…ZUR^µ=ÆJPíÔ…Œ½4<!ð4¢ J÷³Ö·è¦®õ’µÑ+†`§vZ ž¯X‚Á²X-CÊ aIöq RØ\ka®Û­Ì²L¸[W«50ØójqÐ-^Q7ÊÆn̈p]“¨2HrRAÄUêÔJ&ÅÞ‘·-ÃPWÐ¥q·$jÓåšÂÇ"mÇ!‘‘Áv£ ~Rÿ&ea: ƒœ¼…çLÒçUóPp_ó¶*ÏÁmÃcÔBl( ¨¾¶¸ÔU¨¡$û‰DW¹Û ´±†Ð-Z¡Æ9ÐF•-Ø'a83‰,@·,\ÊÂ`–¼Ul닟q&Úu¼@¼°`ÇÔF˜)D1W'=×±*TyÒ½dKlÌa‚ ;ÄtMCð_5¹!ž5qÔE]DÐn ›v»ð:7@Á¼¡ÖÌf9ˆ\,ðÂPEK‰cA,`Ò)óOƒæÏEË Ò/?´`:ˆÞ–ÜIÙuÃ&ËT‚dÄd 1™K!Z9“ »B¶#t±·ÿö¯½–´2À̰ÈåÍ!«˜'K¨ƒÖgÝ•šÒL]6`½Qm|O*:‡ƒ3Éõ;À×rÈÞ‹Éê'(Œ§™¡›¬©„w”)i…(ù·”ˆìCaü`"Ú]7Ñ#’ÇÁ3ÞÿÞ 1 ¤< _¢8-czÔw„•Å„'¢'ëPk‰$' Á»Yô^(ÃFJj¤1)߃˜#,'£ÆLWXþC·jd?Ç•·?Äu„'(! Ò N‡ÿàª`> ›Ñuú Ó5M_›E!Øèf'3åŒÀ!¼&l ‚â!‡SU¿ƒ2ÏË=ÃÏqÿ gtËË€-]TñÀŽ”BC·BÀË9ÖaýQ åÕÂⵞa/,gcÛÀóRÔž\$ ¢ V %Ë]‡æ”à}ÞWg®„ªÓOxöL7ÐV‹´&˜Z…ë”x!ˆø³äÁŠÁ’Ç•¤TÙA2Þ\TÂPF7`GZøÅªaPÐмÁ‹Á9mÕÖ 5Y“—2„é½\|9$CCžáêQv éšY!—`ÿþ[²ŒE0ˆ~¨u±XAm8Œqh±±n׫»|ÜüÑ ¡Í@aA–dA÷ðRVÎ:‰p9:†íÔ4 ÍXøôñ›§pÿ‘~#P ÿPäòå•mc­2Ã)‚\ui‘ÖÑ[sJ|$·¸-Ü ˆ Æàà^—`—°%[ðcΚš‰y!€·ÍÕ]}['ä)¥]1G¬È,¥ò"¸U£QU}åI}uÛq£‹eí^%Ãh Â>vÄ.ïòºh¼FB7/ð10-Ò’éâ”Q’E)Ñ©a_Órù¡d÷„<èN¡ph¸V/— ú¤ÿï—0æ Pð"ÀPY¾ ¨ódêc»K¡BŠ â¶#δ ¬Bþ3ß¼½üMš?3˜½Ì>B`cÙ 2¢€ßèO!;.’B#1°4-tîlÿLjKǠÇviD8M¯F/(Aÿ°oMoå˜A ¨ST:U¯õ>þ1@â߉ôì}Á`ÆBðú÷ŸÅˆ7ü¨h¨BÅ ü}øg‘=zŒè؇ðŸ†yN̬x0Ɖ{Ü«ø¤æO A…%Jô„ ô’Î<Ñâß’£ô*Jµ÷Ïà¿öÖ¬ZµdŒª1VªÀW‹âÅŠø~Dø± £òް ð/‡€ °ø7O…ßy*kfÑ·âˆÿÝ;³f] òË›çt^P}ùþå˧ˆý[’…KB.E\]Ñ‚jÕ)ùX ª¶ÿˆ|cÒˇˆÁ‚‹øp %¤"EŠÿ6ÜøgHB ÿ*T@T¡*=zHÒk™øÄ<–4å==xbIN÷|eßÞ}EGkÆ4¿dÉÓ*èé¯hÐäO…Â’jð c‰¥Qð™(ÁF±€-On¨ yäY∊ðÚ¯¹ ûG,…àJ®Ë‚o<ö&«¨…yBXÈ«Î6«i´ÑHª5ÕX«h5ÕZ£¤&V%™ìɧ‚ØÀ¸ã.bå~ Àé&¨H»* ¬¦ð*”ç¨Ã–Œ' Òi§÷ÒTó'N1Oƒ—d²ïÄû°ÓO…©PJ)¥Š; Nú`´Á‰&²­aÿ„Æ.$/ìBóÃ’²+ ®ÂJ¬ 11Çs Úî•̃,«H³ŠáGDôYµ"þa…Š|°Àµ™|-5ÔþAmƒúÇÜè™I…òáGÉŠ$Âè\Ðúç‡(øç‚ >È«¬NÚ3¼§De ±Q7ÕëÜ5Óuoùd2¶©ûï¥.Ã.¡ôê'—¾³Éßä,Jp­$\ôˆ `Ÿ»ê*¦Sòê²X¨¡?],ÔÈhš';Îþá§"Ï€Š•´hÛµ[wý'µKzýi¶aƒ-”frñD z¶ÁŸ}íÊ“N2i¥™JD¨Süž:ϱŠrâ²8xÿB÷`p„™ö°vö±¯& T@Ê~cºÌP¼hk„ XóÈòÂk¯ŸáÒy,®Å¡<íø[\¨ä‡®i…"j[`Ø(¡X–yU µÑcþüŸ"öº£DDI!œ•ÊŠ"X€‚²‚ÀÃ}™ª mûüó>Që2žƒª!›ºÜä—ßyäkš:zå¥Ö‰ƒœîIâ§{Æ.¦ƒì5Þ¤4ð^S>Qê«_—~§‰ÁŒàŸ a§¹rú¯¼¨VüýCDÿà‹…$Ã=¡Tˆ€ !ÐÎþᙑFH²¢UETQÕýG/c™kRóÿ².„>ȇ=œrydGIø`’´uƒêT$[KKÒ>ÄÐÉBbâ Ô6FDê™Ô£W¼ÇL͈@bÔÓDä5‘'Eô^œÂ÷´¸TNõ‘G îU¢oµD>QÝœ„·Vüw‹Z _—ýå€É¢–w¿Õär¹‡\(S… Y !‚œ¬+`ilÃ9HVÄs§¹%„ЫJ2©sŸ£D%+é x@*M™ Ï–”–ŸPä!Í!IP“öñEL‹éT}Hµý!OJtâô˜X5Q ñQ¬x)L½è/j>4T\ržºÌ *O±ÐAÀWCîÿÄM>-cEâ’ÕÂ"?H#îæ!`2‚ŒßäÁ——H>~ÃPb&Ó=x¾“nW2H>$ÁT )V+`Î |`ÐÍunX Êzº‡VR¡XÍ%ˆU89súH¨p€­ŠHé#Š xâyªšÁ$âÔš˜Kü¤‰3-žqIÌÅ`/yUã2yÒÇØgi9•—|Æ&&—j%T¡Øeb"·˜ ¨PÁ‰@µªS„ÑÅ.ÊKch˜ßù-1yŒËxõÉ $ñL¬F«DþÄ ´Í+|pPD@XB‰ÙÊ@è«Q´“ ÐGe¾9 ÀÎ8g© CµÕʃxÿ!²ŒË,ƒ 5Ç\o§Aœžy:Sè!Ï1èñìÆD¥SééÏ1¢ Š÷¦ˆŸ±çcúËSaÉMA hjQãHNИÆPÍxé!¿Ög1¾äñBË­ ã¶)ÈšD'U¡•µàJ« Vdv]ABíªPIBÔ5¾ª$jxô2åXT*`ÊÇ^w«ŸÐn -‰qC“û¬ô\ÁD—1èË(º´³@Ìžôxê˺ scE Oˆ×§9{Ë×O¾TaÁ|-% \‚ÝN4`Ô=ÒI5$x¬O`œ‰e‹:Ë} PKíC 4@ä¨%†ð#*ÄF½qp‹ƒg_Äò!]ì0”ñO.s’¬"ÖªQuåŠ2”©‚ÈBþnP˜L”ÖðÈ“>`ÀUúò t¤?ÍNrÜ:’§š‹ËbL3çÍE‰S¦œ—mà;ÿ£ K€0PÊÌšÕ‰˜-fy*tYâ-nšs4Z»Ù¤š¨†øÀ9g|»È}$ O ’_ÛÆ•öÒ‰Úµ~@ÑMÿå„ÒÝ ŒV›[8Â*dIz¾–4qd‘K0 #¢‡!VhÚíw6f„¾ƒ [Æèù1h†š›wòr^&Î/ÿ‰N™/j›Õ>Ó¶ö±¥=¶ÑjÛ‡÷=ÏÓD5&y¡hö ˜§eb78Ikœõ3ÄPX‘à®|—‰`V¢©öIaYl¾>CxÆÇC[{Q¹ 3¼6ŸŸ@èÛä(…¢—@9f}Õ`z5‚[ëc•¨l–¯˜#’Æ%ŒÂ™Pù¨MØJ‰IÿË[›LçRèÑ-â?0qŠ‘6y€°p‰Œá¡¸¸¬Êbm*£  ´PhF‰JS§HA“ÿ !£Â¨˜“j®wjŸX«´ ( Xæs«ìŠF² »œx…”Ù®”¯ù ã¨$Ÿ,Š XøÊ2áð¨¹v‘Éb¼”s‰” š Á<Ó Ì»‡j[ì"ÿÓ&ü'À©@™8!o2ÿûÐÂy‰[" Å¡¡òè;’øI‹Ãc´VòxÛŸ9²§ê&1Ò·³: !£-ù‡ºœô±X¾¶£¤.X5U¨;ˆãAø¬¾ !Ôá;JØzx‡`!’:ú©FøJŒhë#ŒÙ:ª?b룰eÆyšûhxi/ú¿šˆ{p‚:î@Cœúøiò”:£¿ö»¤Jªy0”¡:EÉ£HDÈó=Çë“I «ù°Š+)шÄêšD¡8êŠ 2¨…Ë ½º«ˆs2íë !ðœ ð;žY€Ø 9ˆå@+©Šî`Àú“E„).¨q®ÿ¨Qă0 àÁ9ò¨6~iÿ3Ãp‚(8•ˆ‚s34C'@‰À¤Ð€Î#,“Ñâ6zs&„àŽ—(;¹Aˆàp)A°x"+4“ ¦$6§:ð)A¾`D«€‹#I•’Dz‘z¤ÇFªÁ ÒœaY&K™R¯WkÔå „èŒøò“–¨Ÿš(¹Šy'ËÛ/@Ó§Gëžá©&ïÙ<j Å3 1i‚ñIÉÿ£“,€(ÐŒ!$Îà àŒÉt‚3” š40AºÁHž¸ºõù¦#ù8I´™Cȸ˜—K°'•Þ##9·ßé ’ú€ € ÿÛkÁ©z´‘:¿êËÛ° 첳̾.«(Ôðœ—,ÏY€ë.„4V ²ó&ó¨4ti#Áü N) §h/9 㢠ÃÜä?c I©PÆÉÌЀ^øŒþä…_•Ì̇—ìL™XšØ*—9´Èj2Í AnbMM™rª³¨œ @“ñ0>()*•àºÍ. Næ“G xt»!ëÌÁ‰K`2m($›¤¥ }`•ú ©Ûˆ‘0î% 9 ÅXÒ=Ò'M[‘öé<îøŽ"¥â?h$FÈIŠšPF–Ô‡ý¨ÁP…"@Ó"2ÿp7͇ P™ì<×Ä$“T §²´•Š§Ú­a´Ø¼Ÿ©Ì#Iƒ£921Hó2Kƒ½=­±­ˆ‘ D C²ÔækA5" †rÁÚ²æü‰Ä ÎɾZ!½Zµ·,H Ø€OL‹ä0˜³â‹—=bŒ0;)—x¥Ù 4üÕ!7Rò¢òiIÛÏàz² :SgMÓ5å7u}ˆS™„6•·ô4.ª~‰½B¡Û«º/C=‚x;:R  t=ŠÑu´Jé"å“â|+;Î #ÌÁGì¢#c5ÍñWÀ |´ |<(X5«¼ÓX ’Ñÿäºõ´wú‡%] ïˆ P ªP«È {pÿPˆpÆ_ ÎÔ dåÏŠè~|a¹+~„VYQÖÏS™¨¬YÒXNŠûÂHîØÓ’º¦qêCé ‰L£‹GÙª˜·ÆØX¾Ùo­‰JCFX«‘¨²×I¤•U£Xi;†R5ÚX€Ú8Xyµ½œfí®fe΄’G¬˜ŠìxÀŠå(·J31¦iÒÁíVyRˆìÀ Í8É¡Í¨Š—DF–Ü 7PÖþ¤GU¨Y¾ ŠœUSXÓ•…—`C©:Š­1ê‹¥ÒXšÙÛ€4¢_‹Pº€”­Ú ¹‹ù{!ÿ¡¦ÿ‹¹ ¯Ð±)8ê’DôŒ Š>¹º  R5P¥•EâJ3Åœ Ê «Ð¦’$}X‡Ð5 €€Ëð#=â ¯b ÆùŸÕ T!™I Êt•˜ߊØ82ý‡"PÖX)‚2­ˆ4=Uh Œ«Õ¹ 5%ÓjÅŽ>kst½£”¸Ù°—µhÜ9J‰¿164KTžp<¢˜;+³+ù€Uѱ³=ÛÃ[“9$ìšYQ“ý­‰Y‰ÎŒ{¡ƒÐAʇ8ÈWý‰å¸Mùª+ôª )Ô¾ð  RÍ Yq +ö Wy  íOü5Sÿm֟ȾÕB àGÈ_ÿ(€•ýÙß9‘@Ç}B©áUoqR‹rÅŠ’[ŒìŸAd1Ã9GÄ ObK«³ã5ã½W¶ "NÊ9$®¬a~5™ÆáŸÈ©è¢NÜàî„MJ·Ûi·â«Âö»<äú‰IeÙâ¯ý€•XÑb¨eàjÕP$06Sh½ (°()côã4nÓ˜|Œ¡ãŠyàÎ3̹£|2B7u#5’0©Hƒ£Á¼~6YR % ÅŠàtXVᱚhACz  œè`-&JnKÞŒ*«#ìøaC eD¸%ß‹àÛ4Ž"à:¯ªC±€eÿ’SD¸b^Èg}ØåS~82]ÓŸ¨[f­Á4Ý«Šª‰RàaaþÍ ¥ ÓôVÃh=©—x²­?M7)ivk·Â §º"9j®±Š—ö\Ô%u?ã{E3ÑÐèJ•«Xù§èȇVê§¡Àe* dÕŒ¸AÀŸbVÉÞøƒléšXŽ'„'U– Ñ#D£áŒU¹ki^8¤¦GÐÈk¨eИÔ5ãb>S4ˆÄnÖcfé•à –ü…S4„Ob3Œ/zâÙ¦iÝöWkñ_c‰îȉÝ# 7¤>+²¨ñI–\ÁVy [Ñ^ó´¸!@ƒâÿdùáö%$V!¤“ÑÆ• ötà¦(‘^}Ð~0h%)âŠ@È‚Á™Ë¸,:ªÈäò ¯} W©çX éiŽþ‰6åYÿ­ &à“–ìÄ®••V¡P‹Â_Ü@‰nŠãÎkÏË8”WÂ-Чt«½Ð`7¦A¹x”¼#óí£ Á0oü¡´[«×¡Ñ xçCj•Ü€œàs¢.ªŒÊ¸©(B™®†Ýhìŧð²r ¡‡Ї›ád!fÛU*eºl® ðªß #¡ÌðÐ@`^˜Tý­žUï†^gmï0FiÎq2ÔéAú¾ïŠð‹Ê_~jŠ R‚˜QÊÿïP¨jM‹°)™’'”'|£ Am¯2çÉ"ÁÊBêïxEBª‰Iv䀗xö¬ˆÔÆÅ““Š`ÜŸ bT9Ãö9E¤ žÑ”Hë¸<%¿ý·¾”“Œô¥—"ß'Ó‘!ïãôÏ€r ã¢@Ó ÙaAæ¶^æŸðÎñ„"à‡ªR“þîIbO4§ŸTÝm< 6JíŠd”»)›UÅ›¬ iҸѯW}H»V!x |€ã"Ï0ô`ƒ0z#ÀgÜà>••]ÇÈ€špŠ:è N>EwÕ¢¨€y¨BaBßÅûŽ­x•(ϨåÐøåû­áÿdÕáÌõbzìßšfz,æÍÅßX«î[ÿ]oìa¹+^à ”Ø¼Y´™ÐÒEôÓ'·CY‹)A„è(9¢È#”㗰ؼ,>² 38’÷ç«þP] `ÏCW ŒOzˆà ãÆɈcz¬HAÕÍ2Eîà‡ß˜n¢¸³EÜuOBN_w•¯¾â¼™K¶x/®a3ÕaKnX 2fbŽ5a¹]¯ 'ÓuÄ÷Œþu¥˜p–Å/ÑÒ¡PA)ŒZ¸àrUp¼\ ¢þ‡žg¹`#ÇÖî=}j‘GÄzÑ0$’¸ èúG{§¢fOfw?•Έw¬ ‡à‰ÿ]ĸý­F„»²gÚxê ²š?P§{e¹}-Ò_þŒd­âF(‹W$ŒŠÿMl0®(aI›ÅrÉÆ—L7~ú¦ÀÈ·|Ñ^ ° f´¼Õ7ɨ 8ˆþý#ðïAòþÉc±„àÁ,þ˜÷ý£ðã¿Bäû—/Ÿ¾!Êkñ^“… W†°÷O_É›ˆD˜ AOä‘L¤>ž>DØ£—oÄO6XX qD‚î1xd‰ÂÿbØûÀïæM}ñÔþ‹‡È…>“º8KD¼xŠQÄ/_«ÿŠh,⣗/ÿù`ü¯±FÅ{Ì+Ÿ½šô(žØüÞ‰Ð3—ˆ]i‘ †©5ÄÀçúÇ Žú*|°IðÄ’®ìhÐ A„ÿ–4dPžL‹>èCûÑjF‚*%4'xb†÷äm—3æ‰ó6ç;Êücõ›GgÞ;>ïh¾(*ó!"ìcE>zöx-`°ÀÂBX…VݳÕAÛe5OYùØå`s(ñS…üˆàOúì¥_}Ø?< Qª<¦X/A6Yd—üã¢bŒ1æÃe8A=ó¬v‚ …FK.­¤Áxÿœ–ãf®YÐ † RMôÄ@‘qo °ÐÀ!tÏD ±pÿ„D…ðANééCÁšÏéC'}Â<.µT‘K'ÈC1µÞfó͵HúÐÙÄ=B¾°Ù™!% Pâƒ>ú!âVŒøÒo‘ù -WÒYÍÙÅ–>üT·a`êEa"ZµÂ¦„ýc¢ª¤Qc+ªøØc—x"l¼à¤™u¥YÑC3 g]jI™$>°!bÈ?´ÙFqÀ Áv.½QAÁ7SCF¢iHu"²â¥4WH· ùx%Ü+ØâÑB£sUGksô@Ò{ÒJ~ù0i¥ôèÀTUõ>ÝÀçAd¶·]EúåSÁ?ªªª‘ZúTø¡…#ÆúÿWˆ!® ¢‰#⪊‰.ºhUŒ¿¾¬Åb†£‘ÑÊ#ÖC é©Ñ=<êx”ácGNBÉÈi¢$ò$<§²aðÏWDZê<äÃ.D ‚Hz7eÔ\ukT'D[mwAñé=*™¤ÑN”KHsþûÙJù¸é?“"Ò?„-ðŸ¦+ij™‚̓&½©VÇÖMªzð¸]² V­·*kͪ”싎m ô¯½Z¦O8jPš9 DðØœ˜hAÃLDÀ€H*s+¹Á´¢•/!ç *•>"y*¶”$KJˆN³Mn’V,ä eøÃ(&F8ÔˆÎx¦"Ç(¦ÅbJS†G‘å=Kÿ#ÄÑHjŠ4 |D j†ÐV Äb Ü„î øÈh?†$ÄH£3DA— çØJ=ôÅß$(];Syê$—¼g]‘\‰'ßv6s*Is`—«¡<ö¨!+(5eE0 aÐILrUÉFUjI“ 0ÔBòÄV®‹¬ìƒ;ÉìLF‚ЈtWÊb¹ >¹XЧ fZeZËZIµ"›’ѦhœÎ=¸œ–Ì'U ›™0²E.¶Ï‹ð›ŸJ6;µgl^›Ÿ‘("žÏ|/=ØU\AÊ/(Y á„¥äSˆæ`LÞh˜0ȱSM‘uD©xHÜÆýÿƒÆ5^]ᯄWÅ™ØIdƒå‘œ„>%¨W`5ÙïHžÎ!Må ŽÌƒæ²qÞ„!üRNÄ€,áÀGšY‡%J9ÍF>Üœt¤Ç¡–¢Í™‚OIÀtÝ(­x„GÄ "Ÿ †Ò}Fðƒ-¥íΘtŒD0ÈE”DÌ$™NI”зÁÖ ¯ÈúAN«Mú„&O¢´ÄŸàÈ:Lc¸HetœÇµAXʉ…Ήqôˆæ1QSDAfðà lâîàBp„ÎDØÈ¤âÁ%âœÔ†nùšOü‹Yx ¤FØÝ•©ÅαT X ŠpH rX`g8ÅE&†¯èŽ'ìÊ’ÝDSðHiDŒ4Jɱý@²) t¨DŽIi@`1Dð¹ˆÇQ°Ï¡©„„±ËÛÄMU"AJ=®S?®SJ°‘ vÄÌ¡ôÅ9±ØJÀÅF¸5Í×r±Ð€œ`LÀ§Ì¤M€@yš™›FL•„FoÁS©ÁUâ¼u¤"O1q€1ÁÄH†I4 /”JN†d@áe VR@vѰ5 ã Í}Ä~”ŒÅ?ÿÃCDSŸŒE&Å Zs,GF°Mk±"­›’•˜ õã9iX_0…aغícq•ŽXJ•Ò5…=LŒQšZZEè¤İ]|@Ž„”³´‡FøK^²¢\ÅÎy^DRyP` h€â‹vÇ?$¾èGl¡Ê<c&FEIFeÁöDK id¦ž9϶¼†²¥?4E˜Ù¡–(X¢Ä„a¶À½Í¡мPÏFD’‘Y…Òñ©Ì%bØ™ä‚J|ÛVÆÌ÷áÙMÀZ|%©ˆeRDH$!í`ÆÜ&™¤‹FØ?Ô†›¹ÑÎí\wüÈ¿P—vþ…¬È N@ Ïgÿç-¦gyæÉµ%0L$Á§ õÌbøV,!£ýÜ‹æ}Y¸Þ¥ÁTÖY`Æ<Ða´Ä”@$˜}¢É{ÄຎtP" A¡šYb»”š>¢ âDlEå%JuPÓ)]]*®Ø:¡œÄXÎPÅrúàPßÝPWö±^Ž”rX'lEè€cȤ¦… hXâD>Ü'=C êYU™DUåC. ÄãàŒ)íŒ'$/ôßñÏCü‰j|†¯Yq^/õg¶f¢œO>QP…˜f |ÇB8h4ǺÁMF,Çl¨Û·ÅÌ/ÌÙ\Øf†™FÎ÷À êÿÃð½a(N0ÕF\YN¼ê‹òÄåðàE9çp…Ûm_@‘‘ñÍÞÔŸŒ£ÔDƒ°bT­ãIä´j¤†Kd¾ µê™$fN¸@r¹@.tá• A Kbt€>téC4 `€ê,³NltÛ  OÊ’fµ\‚*H íxŒ¥DJLGlÊ‘ñ1*‰â+†©c#ž„Ð1¸Á ŽÊ4ǵg0 APt?Ü%\ަd*¿Ø%ÖÆmÜ9‰‡.’0+ÀPW÷© '©l>À*=´y6ÈIy~†Ï…’ž„Êr|ÚG*UFÐðBSLž²ŠÌÿ YÐC³(çõÒµd fÖ¯Õan+LXàPiÄ™˜Ø›¼É5² ¶ß5Q“!×?<îµ,¯n_4ª µÖ\„âPåµEãà Ä~rr¢>IŸ`ÐÑ’щž Ç·Ü ê|” ~ˆÊþ£OT`z¦ç—dGv4îgÐÃ:ŽÊz>º’`ÁÈŒtÿ£²¢kH‰EÈܵ5ëÔ˜]“ø!ëÙÃððˆh"˜¸îP UÔi5MÇÜâs Ìu(?¢L ’F ŽT¢PÌDH®VU®›XEIôH>D Vì Üú §P#ÌmŽü‰¿@€mŒãà Ôݪr¡ÿ,OèЫ†@ûÞ¢âÂÈ/¾ åJðâúÚÿ ^¤È{M<äxYR5«d‘…ÔüÃ%Q).)¨À³qÖ@f¢@bZG¸z` .¸p‹¾Õ ¯@âIì”EÎÅ£báøn†ý¾jq‘1=4_Œ¦åîàƒ`n Ó6ŠâÔIxœOiðBnZè…x¡oGÝHâN±œâ‹Rj W`yÚ/ÃX©íðŠï–±l.Hm†#”réÏJÍ0ð,—±Œ&Ap@Ãéqø\HàÈ™ –ÜH…þÃkf¥-Z‡þ˜TéêEdó"ŽÕŸFh-ÝÿKgÔ*ŽlË«‚=ä q¢ÁÚÐBtFNH'Ñl†ß&ñt–‘ž(ô°M×Iøjx‘ˆ@P´Á- Çü yò²ÙÞHÞ®ãøE‰\)É]Â%€ñ?Ôˆµ–¤r9… ’°JyYê.¢mhÀðPs5s–AæÀ9J?Š£k£8Ç Êœ3'¡Ls¸pÆF%ZäÄîÕ‰$ûœØ/AÄðÐôHŒ´í¥zUÆ€œ̨ÚIDPfÐ5–Ž„Gx¸™Ôõø\vZˆa”Ÿ+©lðt«â2n6Càµãä³6GÊþÂHÓÐ YÆà2ØVÁ *ÑHH„)ãdŒ™‚±ÿÞžÀ”<‹Us‚좽Sˆêî9Â8Š+ß&½\á£6oH „4éˆÆëní j0³rìú\\Êp¢s}ÜŒBD4 dQt¢I*Îå)£¡‘tîB{)³r¡_\éÏôu8 ¥â6®XÄaÄ.¶Xà”:c›Jú/èƒV¥F>(^_±äøJ“ At„ž=@ $ÍNC {S{Œ¤ALJ† "S¦kFT£u툴l¯þC®zFgäYYÄR [žLï‘çgh@F6ØCZ_ªZΨ¦HŸõf¶¦I”àýðÒþ°xMKàË]/-.¦|šôaüE,ÿgãöHEp î2ð¬wl¡Ê.¦ ‘\_ ³¹À`ýCŠÀåïöKÚaLµ$`BDd‘=Ð1k —ø´5o«ÞD)Àp¸Ü õ°MÜô¹„’0ZäI´g§ Wѽ€XmÆÚÄjø\fÄpbR„؃ ÷?˜Ý”µF`ÔY£@…à´&A‹˜MíáL}ë]ãˆv“’zÙŽà‚wãöÖO JôÜwkHÀê?P¹àˆa°D¶Ió?X4DÀë€Ð4šÏm8ºбv(R‚ÑyK8 ‹³lô¹Tý9l£U{FKüÜzý˜' P—Vy´Ï¥†ÇNrSüÿ‰Š÷óŒHrÿƒ'X„rXW¹Šm2UðOÀ­|¸,Mýv³•ÊçÏØŽ|ù-KL~ aÜC¸~w{Ù⯠,f|ZE_“9=(6ßõ‚ x¬F¨|¯C„¸Æt^“¨9DDs´ï4ÛE[in…¿Ôö"F¥&ܱëˆàvzÄÇÖÞ2À„»øH²‡éxh%ƒ†-oufhT:TÜðRŒWÚ¥m€M€öÈL5•zBë˨–jpðÞÜQ÷‰´|ö‚Œ8¼­7^3ÌÄÇÔ­ÿà äOD.O²äŠtÍ”ôÏ Ú:a\ÂóÂ/,oz²ü?@ÁÑx„´ÿ”r)—´¯i›j…7­KŒòÒD„µ›°+·2âŒ1[à{ØFt·“gØIéG®nK´°'¾m†ÖûG¦c*A€Ü½ûÀþÓb`¾(ÿ…¡±…¼&[Ð !ó_”6ÿih¡!¢='öè)´‡ˆÁ¿"ü‰oÿ ˆøø7Ï^>~0[þ³÷3(Ä(_8$0‘À=zèA(âm¾—"ЍòácॆU©*âBg'_"—O}"ÿ+¤ª”>.!ˆØ“Ïù&ë륺HÊ^mÚDlÃk ½ø,àûñ#C>|ÔM5Æ?³Uþ»7‘â@îÍ›÷OÞ=y-<DIeÄ‘)y†÷ž+_®ˆ8þãHog΂»3Y”ž“ú D µ…”¢°ç-›ì´Š`ƒði°ÁÌiž%Nø`­ˆòˆzNJ£P A 8È€äñizZL§—\(̇^.¹¤—Åþ¹¤ÿ±_DÈ% '¦Ê§¤\p´Dó,6ÃBCŒ´Äò$^X aÆrŒr @êÅËÜ|ë 8á"*îŸ þQª4`³¡‡ Š:2ÀnÎ òh¥ïÄûï\Ê &”+I ¤:ÜÈ( ÿÉ'úi ¢ô³ §,kʽèÑM0ÝT¸*«­øaƒÃúGÕ—èÁ(­Vˆ/?ìé Pq"yæáðEÝ=©ˆ×HSl %2É4òÑŽä 7&A‚ò4Ò´½öÄŠ`íŸ#ïŸ_ÈuB…ˆÀ² ¸áªÀFrc¨©O¯«É9꤈;9hœ¾Ci$‘ &7ÿ'`B/—ü³/ÀHb¾òO£N3vÏ úËø©ÜŽz«* ,õLi~>ÊçÕæã§$¤zÒÈEŠËg¥ZgyÙÛY¦# SåFdE{…ÇÆ˜"?œ÷‹"Ÿ#‘,—Š8ú4d>Í3Á¢p±×¼†F¬0A‚ž6~ðÍ·(€8‹íIÎ-Œq3ï–phN: °è @âîxk$þtI¦B#Ï )ö*¥êñœâsb'œ7îÔ¦K+uk@t³¬´Ú UU7놜ò£ùÂ;Ô­‚ò)ðÑGiʼnC›èaF¤6£ñF±xìvÇd™em²ýòk£ÿcÈÂ-×ñØ3­yò¸W ²:SvG¯A:² èáíŸØNÍÔt+o³ r‹¡%ž(ƒ»*<÷Xô¡+ï B IJ$7\Àä%Ù ¥~f“øXL0éˆ~> 4a l‚A¨±G90Uù?Jµ%,BÄ«43ÐLP2±™Å0hÀP $0/w ±t¯4”@Œc … © ùIÊ£¦EÄ ‹{ Qó<#‚ôÌè1_sà?rD?¸Yà­0qìa·˜e¸œ²“/rÎN8ÑvpÁIˆ¸Ÿˆü¢ZäùÅRÒ›Ýp冘•ÅäuÝ4åMöÐÀ ô—¯ÀéëøŠTÔ‘„d3yz§¹ ÊwúhÔìs´\ðQ@ÒO€šPɆ6ôƒ‘§<3ÂaÎ& 1™V  ½.Bòq+™¼êW(¡™>V:~d%ÿ¤•Å|r¦ùìIáe÷ÌÄøÀ1̲šÚ®Gf–ïkæãbÿxá"ŠF?µ‰Hµ¨„5ýØ ¼áÍäf΋ø€úNPVŒjøzçC&"€ŠôO%ðÉâ(žIC0©™#=åP¬;‰L§JQ4´ï´d<ï1B¦ØR70?· t7§üˆ~ôA"MF0%à‘U,m7©·Ì§;Ô¥Ta£^¾""Ø’Òb£ °6{ÉBê×z9 21± Pm¤j‚k’Ñ ÜlßVÕ8?6äSnI¤r"Yv:'/yŽs0°/ê ‡æ ù9¹?ÑòžäP| y6Vž‰èœ(Z)ès’¬=\À€REà½i ÿйpí®'8 _é‚@¤$ýÌ7¤C‚I\ÇRÞhºÛÅõ¨‹­¶”!”l‰.á µIU?^Bn’»›Þ ñˆ˜•š&€¿´dr”ì?ò‡¯ìÞ“0€‘€åêãÝLÁö½FxC}È"éœÄâ‹\ïˆèüj“8Z¥)ö ¬„¶’ª5蔄 WÌ’µJŸ€L`xn×»F¸w1Ò’'%ŸFÅ´U3Kƒ,+ïľULl<ÕWKå"꺸*N‹Á댈=Ôd8äÔÖõ›;ã©¢# dpÿ`ÀE°!˜$"‚$×íBð°ÿÑ]Ç, ™Sâ*Õ`g#)iA€˜‘ŒÆ‘êÓ@FªìuYTª–›ŸU,"ŽC‰(+’“ˆÖÏN˜w¦Y.F:Ñ_«-iBŒ­,naT*Í3{QÕlÒ†\KQ‹W|5J ÇaD ƒÇ@Ènº½Úéœ奎 NБúDÙ%8JAàT"Ä”6`v'"Š ÂÂÂMŸPÈKö‰Ÿ¥Ÿz¯˜¦ÐJì0tÊ™ÈC4NPG cß²aÿL1ã{ é×îânîÐ~z,7äï® Lºüæ~öf Ư9Ì/"´ÃWê ׫TbiiRÜã:\®C>Ç= âþ6¢°’킌¢“¬‚;*õ¶,Péž*KöôLÜ"l<6<ŒgZX ø­F–$im `«ëºÎìÎ{RÌ4 ‰Xú: %æîàâgï‚ûâ8˜ü”cÀo ôgNÖj’ #2xJBW¼* m¯@¢bjª {b=2…ÿ"¢°Z ¾@HŠÈ£d4B}ÔLäÀVO,PéœbãvüPt‰ñFU‘<¼ä%xï÷B°ÄÿZK4ú°ËaJlß<á5ªŠ{ÊHŒn°ÓâÇ axFM^ø"98±õÇü¦&î¡Î/å´#ÁÐB úDPTÂx@ Ë(¦Q\NÎ.ŃB±>è°hqƒ¢SÔ§^L&]ÒõVÀ… de(Âqšˆ(P<ö ÏTñÊ4¤j`"§´Îˆ^’\zA”©@PKx$GC1FÌêøÃ´¥ßj„Jld[(íKÈÈ3@¢lŒ«$@ °¯œˆ¬ ¬ƒ@l©¬B:±¬2Ù,®9¶ë!Òo/lUBÓË;*ˆ¾J&œH;Ū°âË(.%ºšÂM âSÔ¬£ 1Âuÿ‚îX*)§Hµ®Çé¨ê0¯¦¥Ñ sGãhrøDÃl¸î˜ÆSÐa0J@³rìÈG¸èQî|c(@MôÎ-ØÑáäEʉ˪³RüÌBz3 ëË&i÷⮀ÖMW ©Âúê-ÕCQ’í¡‹¢Òšôc*´¬^Ö„@XHAnà¸B‹XEèphø¡¼Ã<*KPÎ`è0"Šä$¦I™HP," ßÈè\À2_!G¶Ž(y )—HG""‰/˜NÓ³Å(ÿÁ:àmâÆ5¯/ÔBÔBínΠTغ²AbN<ž@;8Üú¤-Fëýÿæb>ÐÄ#2¥õ6òv‚Ìl1.IÈ=Šâ-6)%¬¢õá„1Àd7Xe ¦>²×pÐLò$++¿æÊ¦EÏ\²I³Kô³ÐJø[ÌÇí³È@%[TŒ¡JxÁ²É7ÒHǬæ!9ôN#´ïbà'Ú„7u;ƯWm­@”;b92%$À¼îI \jfŠ`$+ž¾;fN&¤í)$+Ú „f`¼À†¤zÃh^±ñô)Ÿ8ãÁ"L=SBk÷DÀGæ3ip¤òóº´ÃKŠ¥µø“@½¦3?,A¡¯l”ÊÑ.akh„\TÃ3ÿ:ÀZ»‰7‰8.”)Ø‘Èê´þìtô7³2É@Bî1:@¢ŽÒ¯>¨Ð< …QÁ­õZ¯'ÚòQ{ç-7âg:/t Dn%ÈÞd/±Â/½³}XÅHsHb.èÏ\Õ$oïq6ð¥4§ht I*X{Õ ‰zh2?‡µµp¤i¾®]P4»%J¸Ms$GŠÀì ÔÄ£l!"pÖAwã7Â áøŽl³N‡'\‚C71P{“ÒuÕµPåD|¥;þ‘u^+ìžL.)"ÅÂåÈ¿P*<¤ ‚ *6- 6I)`+UŒTèB‚ [UGÂÁNâöÜÓKÌc2àC0ÿ¦jôÓrÁ êó7?iðW™©F–'Y¶YÍúNÃ˦yÀŽìp¶Š€yA5¿I8fjáäÅ[5"€­ã84ãD7')p²R7'% Ã9¢–;tF&RWÀí«xÂõÖ-ˆŒ‚þ@b8bR E)þÃo¾ðMF…) OåHN+…jR‚fš‘b¿Jß2ôêc>8G‚r}!©¡ä‰zô“*SMù°µÑ{ $JÐn­î¿&X™ªÜÔ¸ ¡8ä…h£bï!Ø:."ÊÊoXÀ7]WDíQŒïðŒ¢bào^ bCÒkþhÊaîé'pÂr 0ÜÂÿfÄ/ÁêQ²z‘$ü’zSåu¼b "àæQŠÏ2pVó,êL"&X#±š j¢GHœ@=~Ʊ˜¸K‹›bÃ\DcéÜdK¶äZ$l¶'ìZ,68$:À¨onzLû*4SH·Nÿãø†\‹0+0;–`’þƳˎ’;^„ ÜkéŠr­^ ¢;x'…@✚B(–`„ì'^¢T²bzß–<âÏV5Ë6PòPD"è$xO'~ÆR$£‚öcp÷ãgÚ ô³µŠeŒav1xDc‹fs9"Ä‘<-X×NgÍ85y¶ÄézÐNÏ¢B¿ÕVÈãºîÿó"þ¦ÉE"j;Î'heCü©w­ì‡÷ÆÌÄnèÅBAB^NwŽ•£ ˜Pc› /’°üžC8lQúˆVZt´f)‚"'Eˆ)ð ü4 —W’ÏŠ@ôaØÌ;—Z3"fxTÿaU‡ ÃãªÿDn …¨†jîÐ1C­ ô~G¨¸Ç|ŽÿYvIÔ­µgyÁÅqƒˆ:÷sõšgÀL xïb\ÿ¡ÌB^¬Ã:–à°ÉU­ÌÕgºÕ¢:,…³ãnÂ^Ѥ8V¢*›'|‡b&£6¢¿C{’šÀB\8]Ø&†U{µY…à¶$v8×>RñTênEÙÿ²˜1·:–’b@¨èjæ“Ñ¢ÉëìWGmU=Y±Œ¸‡ÒbÃTÃJœ ¤a\5³;µ³{«\óJOšzŽYà“C¼]šÈ鸚WD1‰RDÉI”¦OÀ['¥8 (Qþ²LΠ ’ ùËÂ~.R-ؼ;/YÍ-$txTœª#,C¾ãn7ƒÂÿ+ËÜÌÃz…¸qUÅ ã{Èt•uø$sU®%—뚺ABXãîïÚAñºÑȹø,N€»Nz¥;”Þé8P“Pÿ´K"&v—\½ƒŸFxÕw …¦~bº‚"(À<@ð¸±Ú)! Â´ H[H©qØØaV•%T+Voi3ìV< HƒLêŽD™H 5u9Á.Ü‘H‰¼‘Ò¶Xºûy¶¦ZȘs‘Ò‰ù+,ààJúúæ!±O×Ó齬\NÇ]®¬XÀ!Úéßýؽכձ‹ëõˆ"ÞûÉ{¢¦v¨´:«ƒÓÙEJæ0¯-¯ @h Œ¡b/Sgçÿ¢wzÖµYðv,XâÂBân÷ P2ðŸÃ…0ý Ð¤Ž‰¼„Мi[R¢ÛIƒâM¶€RÞþÁ£UÃÑ£ÿÁ¸Œ>»i¼›€CœVbêÔ5ôJ  ÁµþèýoðÅ7Ó›’ÄÞ­ä‰vÉ¥½µÃ=žü&l¦b’_½ÖEă¢VKèâëþæØF0äY;7`}ÀpXÁõ¹Ö&‡fto6Ã$ìn×lšÃpukÊ›^cùö—‹’Õì”Êijeó‡ ù7Ð`‚¼þ5ìÐÁĈÿ:xˆßV$|ø÷Ñ¿çý‹Qâĉ,Rš cžI•+ÿï$¸ä¦N›nöäð@Ïž{Þ”à½{òäµ0I¯`‚S§êüGÞÊ-þ9ýwBCV›Mlþ3¦R¬½öø!bPpÁ "ÜðïA¼W Ò÷ßU‚ˆþéQøŸ‹"‹Áïð_}‹õQ^ÌëW‘^E~ýóÜKU¯—.‘&¨Šà@}˜L ¡jÓ—´¥úæÁÝ+š0áÁÄ?‰…ô`áGC29/FÁè`K°8QB&£¨ÑgnõºÄf΂D•þ;Zþ§ÑóImšµÉÁ(Ó¦%£Ö:u=“ÿæi÷ÏxK„EüSVž`Ì*¬•"#¬@—ÿ\æEÿðõ>þ£á?sX>ù¦`!†Øbÿ Yc…ñãúx@Ðb.T‹šqÖKi¯É¦Šk¤ÑVPl”´dAµT›m: äƒ-á†[o‡‘DiÔ sÿLI—’uØÀÂ<öˆÔ_w`(Ïò,Eß=F¨”{AÅ—T|ådè!u^¶ ÏJOµð]Œ6qBWmÕ‚X´QÖ=M,±D ª@„üˆ0â"¤ª^za¨>ÊŠW Ü ÏùDöωùXöâ?#ˆð"‹† Öe…•X@ÿ8‘K.äì?¹¸àÂ/½YZnEÊFIÿ·…+å¦ ôä?½xR'£åÆÐp y—À™ðƒaJ0AH%•$vó¤Ôß?ŒL@H'ÈÔßJvŠw^xC-ê{@é_Æ:µ”P j–yÑyS¥á1–¥X5X =9y ËmØÓ«[+ÀE× 7D jþð3†ÈZ"üüÒ€9Fl‹àbd“T€NÐÓF mü“uÖµáija_û£*¢ dö?EJ)Г®)¼7Ii¥ºÝÔeÞ%Gs=wÒM¯´#ó0òAH†ƒUR ßàUàyòŸA  JèO!‡\¢xBzg|”f*V*ˆª‚ÿK$j¦*8a>ÃÒ•3«>»´N.€ˆ¯%.-˜>0ÞDlŠ. ¢£>ù„àD ÒFP*ß-¶"hö™Ea6º®¥–®lC­Ón¶±[—7 ‡cq?üпÅ9SL#´øâX)°ðé*<1Ô|îD  Pÿ` çØÃ“œçN|RÔéÊbºJýC,¤B‹  cठ"ÔÀìhf"áLUtÑK]þaWmh: ‘°Nd˜_©èXÌSÌ_PÄã&ô˜žNš  ›\o0V³š´\à=³}+n力Üþá.ö©‹4Eè/,Òâ¤^ÀÑWýü%éH§`ý‘Žÿvư„AgdèÎc¡¨b,HÆx9ê…ìc7¹SYäaÁh¥ ¼GNŒ: h@TRAõ^× ¨®jkáÇ„nFTùŒ…|)å«®â£áp‡@D„+—¬™èDE4"A,•Ä«X­VãŠôZDz8AZ¿ðøV“Ò´ÍIW´¢*p£ÅðG_q‚œù1gX¸‚,ìp`a˜¿¶•;!<ìi¤#WÒ=E(˜CÊ䨤˜EAdqÊJ4ÀNC)è@‘dƒ4ãSžbÙ ð+^Ü` PÕ TµŠº0/áMlH8/0á•aHÿTV‰c¢›àÔZ¹8‘³ê-Ûí5„¶fÍ÷¼Ç‹¦1Æ Sš›AÂ.Q«ï /Õ¬,|í‹ øÀ› &ÃÑqÉG `£®G—)K¾I“!¦’{¼Õž“sD¶C1P¥ÌA-€Ì B¾’Puø ˆEnÓ9.ð^Àý¡ ±êi–Mš`”FÒ‚`viÿ:©7M+\(„͉þ•ö<óL\™QŒbˆEð¹a:!>€ñÁ=q.~ÑLÂbõU~p1ý£âÝ<LB&ÃÉ£äà ®U°p¬ò¼I|P.åžÃË%ø)fW*+\> ‚¤óM k¸úIÖã #  q|%þÑqöÐia\E²Æ#Ï2e@2¤æLore‘Ÿ"=’”í•(8·A´ÿAÓfI—GÄ"t­Ð <`¯ÒXnJW~ÆB €h47q4!H–¡Y.€YZ6”¢…Ðs"*è|hÇ=E`|Îç"‹AvƒáiWY27¦1QAq?ªvÑ}³c|Ç!p~"á10sñG4±[E'Ú%(zµ PÆl59x9™w)ÌÅ^üd=ó•D b €T,’zP¬ò*äöXÈutp¡{"(²¾B=Ãs"NöQq5£uQ`"ØRƒÆ×&¦‰=h|Í·"Çwb –væã EPŽòpX‚áßÇYÿ8ÿôS±~óàJ°Ivi¸dôÁ8Ó†v4e‚‚2ãGi(e—: R€úÁ^–ÒP¢RñEBuyDÀܶØ z`(C§´gM¿’"Î#'’„ÔSš…=Ï2‰½6Z×#ùà уÈ×4¡È|@vhÇÞCpÄuÄ%M¬ô]ÿ²w#Є‰\ð†`÷s0¾x}Ãw0Gyç1Y¥?[Uy’GT£@B¡Ø€d;¥-ð2)g9xhzz¸m­Y1äm옞`v†;5úp*²ˆ"˜lÕB=Æhacÿv£(v p‰vÀƒŠá‡Æp+¢„'Æ ÀpE`Œ2/Њ/w‹ÿÐ7ür~`ÿÐ 7€~3Ñ5Œ“ù¶0Òx^È''(iX13^D¡(sur:ì”(Ÿ ²P¨i”/Žs6ްrŽÞf爅Q4äŽ,t4vùPWaaŒ˜Cšµ4ø¨ÓÂù…{½R¾©€± F}c«Âš ½ƒ+ò¼=Ø®rgt„$ñ½kZjð~IH°ªBŒ¸? ºì ÛzÄ­«ÄJì±ÝKñ—d–Ë’þ Håq:™Åošÿ¨_† °ë—MJŽÀ±~Cfn-dt¡tÁUUº‚{ÌLª(¥m5ò"¢xÂ<¯²j›¸ YƒEà””Á ‚ñEžšW‘d,ÁF$À°EÉã+¡¶jÉCP¸š|JšìÉÛêɉ‹¸Š› ë k¥¥œÎ5ùkòdVg¨‚À±ìÐÔ#§ö°+:û+p±KŽ,¡¶g¹s'ÂåêÌ»—4‚¨ºÑi«q[Ô°ÐÙ–b[i[þJv.sp»È­HA9Ï:qÉí˺¡ÏfÔEœJŒÿ ²²Š«%ðÄ~rÐça( =­ÕV–ÿPí‹uºËí¾JY¬‚2‹:aq‡uXÒ –³È²,4bÇMsb(bŽ °n9¶Æt|Ðù¢Ä?üàüäOûcoÛÈ®È΋ùhXHФ„xûœÔ¬ë³ž ›Ý¸ÿ,Ê Ë<`KÖ‡l~2^ Ôs[½Õ^­C )ÛÕz±AÖF•1""¨Ìù Ñöðåš»øH<)È<§òÍmÉ»ñoÌmÈÍw¶ºá=+p¶ˆÀ–"¶]Alr$¡¥,pÃ=M<É‹¸dí³WÑÉ©‹­­»­›½ÙJüÏK\®À/ðG0ÉY-AW1pÅÚ®ÞÿÖ'¢³« ’µÊÀê3C‹E¯Ò¡q4¿iqSh¼×»',Q÷Ì“•3Šœûp y¶Äâ^˃hY5WWˆ·?áÄWAÐWÁÀ |úÜÞDݾ à‘H@ß[÷«íùžäA9Á9Ž`·åaXböžˆ 9±9Þ úÂ3{±Û«²CÏQ®¾I3öÜÀ ³¤áÆYºq‚Äb»µ:Ñ„ÑÙ¼(ª„e‰ÝÌûâÕS'B&Þ6승ZÊÿ@%èíÔ«ÉɦÙÔ£ãK-¸ \ä¸úÍßïGOÙVz ýràrQne I\cIjQåT‰#Kÿ˜±^ÌWÁJ×›¾¹Ök}—8Ào…z‚ùЄ÷h@#¼­‚‡A–Þ“âì*) wÎ V ”2+‰Ÿ©èÁ~‡>Éÿî œ µP˜Í­Ôú:>äJ|ßøÕû]nêjHŤ.W©NP’t 4a8ð ®±©WgkAÐõ­ž8¾m¿×Ö¾‰Ôb"ºÍ{¾‚»ÍBc¾â"9X×Í‘ °J¨"ÆØïÌÃâþAÀÎ¥ óåM=L¯wîï]Ôr5ßWѸõðEnømìÉüø®ôÙ†‡ì%_K Cšˆ[­…YQÿ•´3®ÿ’'›P¨Vnå÷3ñUaå'bTjl][cV#ì5ò –Ö#üJ8„–'L™Ç'p=œàÓìçÓÿÏ‚?;Ÿî9_Ĉ[K=ßKÊEþî<`™PºK/WÞx  òôr‰£Ë![Ûpa{Í!v”íÃè¡R§æXaåöQö0XQÁ^òW¨#L•‚MØüª™4¦ ‘Ì–"Å$ûðü±Fº`¿$À«ä=ìέíÝÏE½ÏòM ÊI ôEþ®`ˆžéP ¦ç œŸÅ¹´ÆÀ†/*Š”CðÚ‘K‚ nüCˆÿpBŒ„ s4D(!ŸˆöÚ£÷QÆyÿ2fDxBdByMNü[Òb‰±*èȇ0^̘õøw“¦¾x<õaTÙB^‹“ÿxøÏHŽ}&…0ê¿#I €h˜êŸÖ¬]ÿHD‚õbý—€lÂz\0ð/HGŠAÄ›Wï^¾}ýþ]ò¯ J„K¾×dɼþQä!^FyîC˜ôƒ>~?äsì8Dz1èÑëˆp½“-6*o l•'4Øsâ&Mœ¢ÀôóLt¶)ìº y|÷%ý—”D¼NàÕšýëY¼bË6\‹P-ÂzåßN?Pâ…Œÿ¿íÝ¿‡ñÉ¿Äõ'¼—ŸèéöFl¥!Ç zî¹è0û§Ç*¨è‹þ!íŸÔæiB G:a(Âú‡%Û4P!(­D'è9±¡|pZ1!¢„Bȵæ2+0º„(*HàK+°úQ»„ª²°JÀ¬´Â+«­· ‰¯J+¯Dh{‾.9È/1“4ðˆ‘y‚V(øçƒ¨r¨ÆÌ ê !Ðú #„N[-µ Oj­5 IƒÓè1Ô#r 9*À ˆ2¦5yŠÊ¢‡p„î HàqÇ7÷ «Tî° ë¬"Áck¼†Ìseº#þyK[oïžÿ.ÿá ×Ä–Ð Øæ@‚!¢ *#©‡Œ¸Ñ©6õù§³šHt,£ÊVãµN *FÁŠ2æŸÈ ö\2÷ ÝXügDzÊ IÂJ`i5½±ß„jÅkV„²C-°‚­¼Èbr­òþyë€^pÀ\/ÆøŸ'ÀäuK„îó×o!ÁX¤`ˆ X À¡™*Zæ©€¢œøÑ§‚˜ÌóÒ´•0膩0„Œ ¥”ÄôQ„„‹)R{ÒÕ@¤Kb¡ª\΋©„J‚„¨xÌJá­ÌîÊ;%ÓJˬòÂ# ‰‡]yK®®È8o,×hÌ]yEèž%N¨tXÿ.0v±R¾  ZÎ Ú†0Ë4Ÿ rNˆŸ|:0„þ6òvBÖD* ÜK];Á$sWÚ5C]úÇ ‹è±§ D‡Ì Sc… WJ©MŬS… bÔ³¹*›ùí~ïUµÌZ+<·Íƒrâ-òFo\9öR0Æ6|‚ †H€‚“A¢ñ#®cʈýG€#‹i²ËrìÁŸ·Í„Fw’æÔ&0Í‘Í}¬Œ¨@v²kÃì>¢»zýCo:B¦pÔ¯NymN³ ÂØ¶’æ¥J;ÞÁ “ÀðïÔƒntƒòæ1ïÙÊoôÙ’Iä1bA€®¸€Z׊“ Á%€^’ÿ‚0ˆAÁYµÚ„-ÿÐ#Bó( ‹24”¨dpƒáЇ@ò ýÃ%†" ÖfôæÔ¯=B´0 ämg/! ù7¼¸Ð< ‚@q1¾ÕðJÒú[~³yȃ%(8ô­…ˆ­¨Ç à7?µ,4Iˆ>A­:ý#yʈ=:²š„Å5ŒÌP+÷¢ªv³ÃM2².„8’*Ž”Çs0L¼p:’³ÑZv„RLH&˜Ý“$†!áU®h ”pUHð²=NáÀ¾:&8FZ𾛋xPôñ—t…®Ççx-,°™_Ô+~€#.â¢r’f®ÿ$Í6·kˆ=rYÜLjhkÌš³è̤»Ò%ä0­ôH¢%»å£Dº#Š/-˜ ‹r‹¶H¦T:aE.ˆ‡ ؂•±…c‹Ù¢&ÿd)ØqfwìˆÂ¸ö1!Ô\›Üšd³ÀåðyBað×ÝΧ=Ìð‹8c*-šúµ‘êÈ ðŠIé$;ÇCÄTD€}$j= 0GD%ÔZê?<›9þ‘ˆ4zòœjÀ¥Ž„‹©íkó![}àw‚N# Ž€{L¸/Æ|ÙFd*¿ ¥zcAÛÚÜÆ0j²-IeÁf\âòÜ+œ!/[ƒ¤©£ „º‘VñR5t¯ ƒI¬˧X÷¯ ÑÁ’œqJ7! À=I¬’]€t¡Ø $æ³P2ëûA*Z1„[<à!X‚òaˆûB”ø…ˆRû·OT‚„—ÿ«cìŒxà.¨ÉºP7V !˜˜Àv‹N()Ãáø×¼® "kQ®]ë!7kþC¹~LˆŠÉƒÜ!ðàÈ”UŒ‚À®:?£`Ó„üp`0ºêX¬çÆpöÍ)Òíõ“é#„ *”l‹Ä@+ô2—zè#yÂo_÷MÈdJÉ;åå3PýÙ<Ȉ'{Ô„"àÅ?<Û|œQÿ ‚—Yùކgã¦ö’ÑMÌŽoUÕ’^u•:›<­ϦÙ‘¼2w¥ä¡^=ŒÈƒegÊ)«ñt{ëêÚ5?nÇlÝ-¹4œ+,D¸Ëê{PX$CÿȘ0„dŸ—àê\ç?Ðw,Töd$8‚Àâ§S¨³øÝoCàì™nã)•!¨ )"jý!M;×I '߱ೱ™i4§½xÐG‘–¦ª<¼¤ñ(Ib[¾ž§“Äé¹#›ßÉË\ËBMWP<™Zõt…­HÊ;F4Œµ­ý¶¥]½´!¿>9"å‹ç'KR²ãHæK-_vçZqêlRrŸ‰ µ a“ÏÖ‰ÛúP*ÓU„θ€ê"øGºµ-[Üì)QæŒ<¶4«YÍ—Â ‘0¾Ñj£ />Þéq§·6lÙàšÞtÜÈÓiš¿ª…£–¸+‚ð>¾~3ué¼ÿÍÕ„°ßE-øxMè¥ô»‘/’¯)ˆ™cq,Ó{8uj’[¯“iÌÌÈš„κ¥z3Öû¬ Ì }p~à…Îð3~p Ì‹s1£ᣊ–Q¦èX´8Hƒ±b›Ic³A®•Z¶ê#¸·q²@)„è´’Š½k›½KñCµh™™*¬–Ùr¿i?ø»úеW[5À‘)•ã¿ ý#6:–³h…Ïk8*‹c©$¸""”š£èÈÉ 0ˆ`*¼ˆÀÀ¶œ¸¯RÊ/ª›@˜ˆ¼x·Ã{²#‰4‹ù;ßBˆyzC¸ú²ê1±ãšÁÿC›éÿk‹óBD©ô´…ƒ844’:±´ $Š ž‡˜©S¿‚·Ôb¿ö»µƒµÀÁµúi<ÀI9ÀË€.¡0ý{àJZ²DN|# "¢øz4É™SÊ ¡CÏrÏZºØ‹"œ¹À4@[:§Ñ^¢¡‡€€1D#@Çi ›û²´ð°±€Çw„…!1‡©‰ù)©>NT®N|†;¸½£+‰ ‚ %œ.ýH-Újš«SÁ`<]›5‰Èq<¼à€ ŽÄòúE‰Ke"ò¸»îƒ¶³ = P¾èh¡ˆªK:Qj* ”"ˆ°ÀÎh0œ½(Гÿa­=9 aZ¦†X#½@&ã˜6|Gyx8yd…Q’¶K6‰y)!8Ô “È&Y’ò˜#h1‚òó+)“ Úz”ÓH0‚E–à ²Bˆ82(ÓEüHuj'µû<¼;CŸ¸ ø$¦±ÚŒ;©D%DàCÄ‹l¼ýâ6¥Kˆ˜p‚„ȈÈLã"Œ3Ä6lP&¶ê4[$yJ‘:i*1|ÔG p ØJO£+°<±Ql†q›!0€@G%Ü’¡ ¨Ä؉“ÂÁظ]ˆð˜/1bó¤xÿƒÍè<¸C†AOÜN`I&»(‘ˆ|’¢¥Ó¯ ÿDOÖÓÉ?ã ÙÉ“VBÛÐÌŽ¦˜'Ñä„(«èpA¼˜'C„ÇâJ¡…áŽK¿·“Ùd.¾ ž…;F‚t„4‚Ž”²zA„'ØÐ?‰äÜš²Â[C¼¿º‡xèOyÃÈ€ ‰K€ù¸ú¿l4l³z´¤ÈzhÀi‘@É¥7ï#"¤=Sº/á@Ÿ¼ÌŸ CA ¸ÏÌP¦¸ ¨ë`Ä„ØRMé5PrJ{ÈÌ3eƒÍ‡ÃѪt¼Ë¼½3¢Š›¯æx Ù“§é(ø¤(@äl¿WƒÎX£¡DŠb35TÓÒ xC#x€²ÂÎPÿô" 7•> p…Y&š;aR›XÌ7Kº!½CÚ«ºŠˆ‚<ù™išŽè6ª0£èO ó$DB­ÑOýdDÐÌ 2ý‹µ(.#±«¶I¶ØìG3ô>E¸P,Â,#6‚ˆ ?µ?wkƒ£µ¾ÙÂ)ü’(k’(+-} …Ô¬ ‚`œQ„ˆ€€#‹0ÄQ#z²tǸ‡(Ohlˆ™´F¼H=<¤–š8¥ÞKˆËtþX”†XJ8±°+œ£6ÜUÌB>Óô”Œ1SV9±ªl’|”§çêD¼àD¿¤+Ýä͹à!ư¢T?­‰üÓH9 )lBVÃÙY«µ(ûHËÿ35þDWtÔÒ6•QT9•èAPÀÏEÌUF›®’ñ×ÈÌ6šlª+Øõlˆ„PÜ‹ÇÉ/}¶EPuÛãEÚä}[…›[ó2FFP*˜Ï(°“®:ÆáCÜšÿmâÔPÐh-)?yÆöÙ)ºEbßZh♣dz`y<êè.…Џ¯ýùWœ\Lh¼/Pºp³‡ÚMÜ=ÿ°±9"¾¥åO‡¥/ÿœã8æãLa=n¹ƒæ?>üJ¶ˆÓÏ£¹¾“€ÆˆÃSµá“-àFÄåе¬VSj°hŽòÀc#=-›Ž£teâv5’!ÒŠøq…S³18ÉÒ Ô‡”F¥UÕ³½ˆži ¼ˆ‹{x“ã3[°0ȉX8^BÌØjÞÇ@_@_¨‘®>i,ɼ9õcÒGïsä‚»¢¹ò¸€PÚ®áÿÈ…ÏâFÜqîÀCÜ?tÙk!ê8Š ‚ó)µ‰‘ º0–|ÑlbR’¯ WLº¬+¶Šcne)bþ`þ‚³kñ™ àøìÿò*l¡È¼˜/6ijR> F†¾°ãEÄ ‘ÅÄçš#¿þè´&årÓ È“=®Bæø6˜´œÐ>ì@„jgS‚Ù»½Q {È€éúŽe¶é(/–¤gQþEw}Wîb*^Z5 ±sÑÔÐ‡ÍØŸÎ˜ ˜ $ %k9ã¶v‰ ŸÔZáÚ-·‹˜‡£¤Š[ `³mˆ–¤·Žl®’¼ÆÄ†ì†H_ï µ]Öì1¹ÿ‰‚mÎ…XoœLÛ›ì ~džV:q¶oPçúÉ€ò-EZ’ 8€#ˆMü,+QV'ôþŠø½Ô~N³¹¶XÁ‚ÇÖâ/fÌô´‰m ­ZžÀ9ÓÐr+ã= °ÏxÇnnˆ=‚7ºŽžj K>#ljÍî†íNé¼ùîHµ[äêØé ÆÈ§k‘-¼°=ÜÃìÈÖ‹ ºâ{mJ¢@š‹ý‡%†Ñvõ²¯xW>ÝbÆ×*g˜ãЏœÄĽ9l]:É™0†Fü™"âv)5¥\.ºSÚ]Æ’‹7¶Õ6¤Xü|4¾Þ‹_DíÖî†ÈkAß‹ecæEÇ;¯tVãÿš«ˆ“¾yMïnon°©ûû"ØôûFO·lPr} ØH_ÜdS[¶¹•Y‰TImâzX»M€ Hß vCV.«¤ÈšÊÌaÝ ‡À(Ò‹<¼¯åöø¬ÌånF`…ˆñ£Ë²²0-½à`6Äç*t¾À€ðØkD'«¶cK«Í½èÁ<æÎR‚–á#ì†ø…Nÿ…"¨w÷,%/‚Nïô~h]œ¯Ê£$Þ4¯ÿ¦‹y.pIzEU¶núÄ/$„Й|Zºÿ@Æœ‰]ˆXvE~e¿“Ø¢6péÍúmý$ÇÌ A'÷<†ïVt“÷|fð(ÖP±-ËA4¤á;´Àɦ Ö ܃Qê|hŽL¡°_L™+ãGôpŠ åêK¯ãB*6[Í©vp7® £Cºœ`̪ãD(%„þ¬‰¸FÇöªpRS °nþŒ)âÔbŽxO™§‰M3ÐT¾²M¯÷kÃÙ§&²(¸ ¸8¯ŸðHõTÚ˜Dˆž6rË~ïMÿ‡|_„P…†P…}_S·P Æ1‹ ­l¶ì†'8`$å™ÐÇ™Ø\M;Š0~p³XÞ Õ¥$­“Õ ­¨%`.·¼/¥ h¤4;êøú ÍN…ãaòÕ€!ù ÿ,éÿGáÃ'àÀ‚*4ȰàÀ‡?ðEœø#•…#ÜØ8¢BÇ A¨`¯BüPV@IJ%¢/GÈŒÇäø6ü04#{ôTUE… *â‰Á`… ø,D}H•ªÃ†jÍZõᆯxb@¶ƒ³Òª5ËölZ´âÆe`‹§»x7xÒËïØ²fGð‹W @<{#N\X±½ÇUÄ#ƉËK.kÞÌY3‹ŸY,Lˆµ4髵&âKUñGêQSk¤€($Hȸ!“´÷áÃH~ˆFGÄŸÌÁ GÜøãOŸÐƒÆ@ª!†1 †…/Ø Uj×ïq…ÿ^+¡@ýêIìrÕ¾uÛî[¹àûÍ{·¯^¼€É4a&ÙsØaŠ5Ybö¨ðXe1Ìcg¡f!…'”¡…¦æa‡ T‹D°17â(¶B†WÁ¹Å(#oÅÕøa’ÅsTÍU€DOô#ôTf” ŒàAüDÀwO‘‡xU $Þ•Sf‰ËvÀÐÏ—_zQÆaéE|#´µÖ|l™Ð›÷åW—-ûõ·×ÿÙufš‚h`ƒ&1–`ƒ„â6„—}–Ù ™}–è…—ÅÀB je)A—Ž’é¦"V¥EýÁÕ”n?Ñ󘪹9è`¡öäÿÓ P1TÀÏF7TàÓ-ŒðzKŒ Ý<ÆÓA<1سÝTPIù–T’w `V[­ü¼WVšn­W·oÖ7W]uzrÉþ_\JÆã§Ÿ‰ˆƒ!gKHŠáf–Q:á- žöáV¨Ĕˆ!51¨êÃŒ¨ð0P¯ÎJ¨«ˆåsB #ät÷°ÀB 1ð:d°Œ„rÊ“%Ï ö|ÕÝTÞ}-VâYIÐÖ>ÐÃÏÔVKË_ñɇÖ[n¶ ׸tÙUnºxÕÅŸîVà矉Añc»š,„ýæË裎r¦¡„'Ür™V#nÕ¶Ao w§WIÄs¢ÂdH>òÿ¥=¬Ž”ÄC-æna…AÁ$o !ßsÏK8Z#ó¨¬ò>…#bÆÌSå4P³6g©zW<ù6ø#»ìÔt?šì9ŸÑßšå&œIËEW¹x—žhÎt5²n]qb¯~­‚„Õy¦ogœÝ«}ÝsÌ•÷ HÕ°eDj‹5Á8ÝØ_a–³¤-|XL ˜gG ;|©eICR@Âô¡òI‹p %¤$,G:`‹Œ/ãÐJ?¡x ÿÀøáy8Üe C¤(ÈC&‘ %F ò€"w@ŒEjl;e°ìi¯óøžU·Q¼-+[©Ê‰Bµ€Іoùà‡¬à‡Ä01~YƒâQ¿7ÁÉ„aRSnðyˆl K Üä!:j'H`ì‘2zl…ÆBÍN7A†`©*AËàWI Í"Õ°˜ªA…4àÀ ²Ü‡µº1‹±Ô±”¥ Þà ~tC–Ö¢Â)r€Ì/qá[ÛA0eYp‚#àÆ7àdšëÜç epF9T5“™ ™õ Å=+=¥~4å!£,%9©²Þ~Ð`ƒ¯µ„ë.;€úÎnîk}_ËØoÌ_:0í8ø%UzÙÿîÇ6Þ g Ò¹ÊýøL„"”Fr‚ïĹíŠZÁ“y” ‚Q$%PpÒbÀ{àøÆK\Û>¤L¦:Õù0¾ Jê$Ë­—irS„WÓIyX¬l|K íj ^v9‡EÐñç…ÔbÜm jAZq P}jzÄdÔåq9CÄûc·ø_Ûñíu€÷ $¡:öOS}f? &½ÛÝ•5¹Q'à ˜„ˆÆA”+>Ô m æœiFÀÿhW« l0{ð6/°ÞѯÁa‡ý¿v?bËëÙ‰Âõíàúe§þ~œ|v£ ¢P‘z$¦[µE0°qó0ÁÑ'öðtO'uÕ·ú0%@ø¶\ç{÷pB1||Ä>ÔS=™¤|ÉGphõO @EIØañ&3ÜA^©s% õ`Ö|Õl.ÇX‹ÇA ·þ ~¿æQíW-GH„F`ò}uyt~–XC¸qÓö%ÙDâäÔ=åVnš2 €9˜cE‰ñtÿ3††Po’“\¸uà{_' ÂopG±1fG‚Þ•| VìC$0‚9fUPö GùðuÿTƒ­¶e7ƒð%=H;ø…eýÀlØ`XKH„†—k§aÐxÜŠNØ`%Zý `²XÁ° ¦ Ðy`òyþ4ÄiE$àƒ)"&7ª'Œ£ð1ŒÀnôŒv†ÀˆPòcÈtè{uÈò€zX|fw(̈ðC,@yô"ÒˆHL#oN"qqäq%Ð}†Á‰´C„x…Ehs½feAèAøç)÷ÌÆrCÈ_"`ò%…v@Yp_rAÈ`¿†fÕð5¿x[ÂØª7†c(Ï¡B¦ƒdư]°p, ŽsØuux“8ÿÉuÛ¸‡|HžæiÒa€H,óP|SDIóGÅáT(Q}NÒ,‘XNaw4ùfÔ–m5ÐüD(;ÏÆfVVl¼Fx ùÊör燅³ƒ šÅ]™mAè£%Eöà§·F'7cˆ È0 È€2¹1C‘ñ #0oŒPirX“69‡KÐGqBNu11"1¬’GÂA½q@HþEùúÐ>ð¬&^ÚWãq{Eg &TØlC˜lõgv`f(÷~ü÷%«˜kbfV¶›qigoa’P$@á…WÁ6‚©€˜B˜¸€ â1ê(ÉRÿÙ@¤â?5i¿‡\Wò`˜¹™ž)Á*¸áŽy¤ü IÉÂ!ö°I@ÑÀqMA‘H%*%d–aùgŒu~ `‹‡f¿¶ ÌfaV¦„C¸ŠýpÍVXÜsõµ¡Õ D q†Eò‹>QzÕ9Ti˜¸ Úù%À‹ÈD4q#ºÇ{ÙØ•¹÷ÐûdNå É+cޱ’N™”í¤”«ò94¢,!ouG7£e`b§ @fÖrZ®å:Š5ZKØŽu;, Y”5XãWZmšs´@`ò _i¦X9ç:e =p;$õ%¬Zhÿêm@‘,?ÁºTl4N§G£Û9 ð7ö/áþQ'‡X‡Fºžøöu'{(Mú ïÔ™QšTZ#N ʼ #žÃšÕG Pá8â!^•ø,`:à÷Rp/åYWh-Dp„ RÍÄÇ„LÕ ð¬"õR9`7åR(à‹*1](©"6N ˆšR˜aGP}+pþL"O,‡ZÇ{h«šo Ò>у1„21 yKÑOÿô›# GY}”:³)›øà8V  Ö*Re z¡ —h-00SÄ)–ÕÒ |¤" Tpk² »ÿ°`¨³4 "TU@³Õ¢³¥D ²³M Ž MÕ²ް…ã‹ú¢º5Œh¸ ?p°£*>IŽƒÇõ¯7†ž7–ª8}ÐÕGŸ9#Žq«"àEÀ>@"PKfv+ +½A¥|Ã¥N2‰;ßaê@äPw`±î1À@…Ðì@ z ÎÊ„Æ „à@* #°#€ÙDqpg25~À|qÀdq€š» ,@|0@z@UÐ|àOL…’Q„‡ ²ê‹N% PÄ( Ò‘½{™VöPtÞs©øÿ`[P&·ÐµóÀÿ´|äè.dkª‹¶^w¶ø¶2vì¸5ŽÁêVyÄ$yÔ°#°w{·L5™±‚ˆ¸|ƒJÙ$U™¬È Á7ƒ:`Q&Úr¯M‘Á ¤z~_¦‹º+ð€¨I¥vû÷*Ä¡LáïQ<úG=[z¯µ‘Gö©GOéO²Z/M*µ’1=’Ñ¢¾˜®ãVt¶åP áÀ7v œ“I—Á>žÇ5™”y“Öˆ‡‹ˆ³¯‹áù[,ì"PþËj¶c£¼!+<ŒG@¸ÃúÄŠ¸ÛÇ:ŽSÁz!¹‹´dñˆÌ/ÿ%*ÆA<\#,ŒÂ1\,lȨ‹;TÀ €ºSƒš½A#6âÆҙCl$DI8RÛ¢¾—2£îê)!aG £ïÆgô°V£ÅÔÅ86@ŠÑ>‹1Ƹ±˜„ÓPùÀj,+¡ÉÆ(¹hªò¿IÉÃ+ÁS9A7S‰•¸‘¤’»§‹+ ðµ@ Í$ PÅA"ðΞ+<<Ï  ÆˆªÅÁS³Æ+êÉ@šÃ&A±“lÆ‘ñ¨MJ,ÓQ$D 8]¨2êz[>Enq"Þɢ!-Ê*Yܘí+‡gÒÆ5}L«ˆ£n‘QÄ| 8}kŽüÿÀ zä“|>)}€3Çzd¥Ž8w~|¸}ü¬6Îí‘΢¬ÎœTÍZ ÕÂp0u{øÉó,É!+X·k<ÉZÊ‚¡Õ1ŒŸœlÃKÉJ‰¥NÙ¿»½ª,ÄæZוËi5nŸ¡Ñ!‰cGP˜,ãG$M¶R5@S‚Òc¼¿ˆ³*C;Ÿ³ˆ²â]qd‹ÒÓ>í”MQ¸Á†Ûë‘äüI%/+=ÛŸ,Ãq+ì JÐ0œÕ† ϲ+‹8Ï‚±¿Æ¡$ú 6à¹Æ±\†¼ÈúÙK¥íTÆ2ò¤NzØ +ÿÃIÞK©ñÄÁ[ð† £.x‚Ò‹¿Œa5òD+ÔO[#(c¼8øÍ ú½ «s-ð7ƒ‹¢™Ñã¨*Õ”Ž˜±E­}T±ªÃjª £BÈ,ÑŸ@Šº®-Æ‘ÕÄ¡F r0 šS“„cÏ¡¬ßÅÑFë³ ϧ[ã.òÖ?G‹ˆ¼îq ·A±0bbµ\~0á[`c:ZÌ™ô¤%±¯ƒAûÄÆLÅ ²Oü,å-8WÎTêæÒ€#8K&MÀGQµh‹’f§à·êˆ¤ üà^ñð_TI5 Â15­M¨Yý²"¥ `n ÿÚ¢áÆ&4a´aÒÉK1ÂÅñ·¸ÊÆ(aÏçø2…(&ê'Q±½T(b0¢2*So £\WPŸAŸ'!åý|ÜPÖ5Bå²ë-#…Q#‚žÒ܇I•DdRUnÅ«9¸Z¸²¹Ç²-v'^½u‘»Á€ÎíáVšYGUÀ¦ŠõZ€ÊÆáOÞÕÕÛ·“`î‹ÕuÍ1ìŠ,èw,軈턔Le+ A žÎTïé¢^²-g~æcS]¿¬Ó—Ñþ“\2Ïì™ÑØfŒèÙû𑈠"l°°ßC|B ₈"E|4j¼ÈcÂ!;"*(¡B}òUø@ÐÞK˜/QôëÌßM hzQñ2†PàÀ YÔh?.3kâô×ãh?ÙøyÁ`?{ø1XÁk>¯aGŒ%˯ìX³dÏz½Šo”Û·£jÁkáG„V7"P Y‚…<äp„ż‰Ç 7OEŒ˜‘#Ó‹¡‚Pz–íY¶¬!q‹ - ­8´gyK–¤V½ZµéÒž?'žç˜^ÿA°ÝpXÑ÷ï‡7„y£‚!DÅTÙ|e¾–F·G²R›8uöótsbGOÅý¦Sñ(ø‰`àá+¿ñÖk¶#*œUÛßÿˆ¸âzh”Â+¡V¹`¿L2¸GžÚ[‚Óæa 2˜¨ƒ‰‘ê£Í3 l³NƒËRœG¶k±R“§ yfL E3³®:Ù›ç¥|‚ÌG~vÛ@"à¼(¸á6ø¸Fúˆ(©@‚• *ˆ ¨ºN˜G†ò˜Ú΋%€Rá„ðhz@l³`j8ʼ¦z@@N(j~ЏÊ°Ð«•ì³ÿç¤ÿm”Àá’ô¡òº!¯YøëA ›§ a£mCÉZ‚iET=[ñ„uäÌ:a¥§EÐbü¬Ä/ ÍŠÐ xIÖ ¢?}’ë 8·~Óˆ8‘è¨ÈÝ<ÁJ~>P‰º–è±ËD$s)íhbæ5 N)J¦Ò€†¢ð ](ŠŒ±òÉÊ,® ¬æB4?G°–á² ‚(p¶F4•G0€y&¸Ïž0E¥ 1ÅÜ2»í¶ÄU ØêR†ÉºŽÛ‘Ð!ã!RŸ™ùÑÇÞ•w’HcBò7Œ, îÉ(«ìè$ÝæÓÒÊ-[Ú–2¨#­M<Ï\ÿ➌i³xÓݦݮÓE/¯|ÍMúªM{%D?(à€þOÀ·’… NÈ fáN!Ä@žPrºDO¸0µ¿7Ä_Íç—¨ Áåy` fDxásÏ=øüs! ²×T˜ò1ògß~FRˆe‹îèY æÃ車N‚Ξ§a¬¶Ë[‚j3wºZ5fhÚ†)j‚A ¦ØW»`ÞÅéë~ºé5eûnþ:![ªV«´äžÛnº*úAá½aäŽpP€Ë ÆO¥ù„Œa«Qž{pBÿ# wyÜ(söØœéÖFŸ–lŽ!È\ÀB³ƒ¬@+(‹0ÿ:^ÜLHAú¬ìa¤ˆ¤Ð7uƒˆF­¤!"7)áK´ä4ma¬1¨2Íjˆ®ì]íÃ+Ï6@HLAOÕhBj0¥(/Ñ Ì¼‚3è¨-:pC„ù%)%ë` 1NÃäqÀÕ¯ScA RŽñOLŠùŸÑ(ÀÖh5L †2Ç^ÙÌ+ÙÝå&ø= nPäÊ éÈŠ€fD¢O>X¬"-àXÂ[„€:‹RòJ ‘’kaK «Ô—q¡L@ôÂ0D€aˆÇ ÀôpÒD¦Ø‰&Kü%Mäq銄.ÎÛØ7³¤…*c¡Ê4«9‚iÿ¾e.ÚL¥Ö‘ ÀïG„ö¡ ̓ÙªM˜ö—±ÕŒS€'tO01.‹Áæ9Häª+"éU¨b õÁéÈÏQ2E_R&‘ÕÍŒ ‡Œ¤,%¿ Ó´urK p”M—š'Ìò&ÛMìŒø^À,¦J›bLÏ,!WÙÚœ?›ûU¨CµÝb—KÇ/ñK£%†¸‘wµ)‘†6$¢¿Ä³žw¤§=íù?1ïe„R ‘>àOD~Α>ð%ÚúV¶²’ŽdÀAòñ»}O“¬KaÐ(²¼|s$†¨!–¾wÃm­r¤"[•âHS£{¤tÿz9ié0á5€0Ѧè™,z¨š4°: ’=Ôf¯¡ÚG+õáù FB$Î2ÄûVNœ3X[çvÈX0bMaÚcïx ØÑ¸]íjç˜9ëˆö{öʇ‡dÐ,€ÛÝÀv½ë]¶.”+¼JŠ,ãF~ìu…œl!Ѻ˜´Þ:îke Ò˜0i6”¬»zð_ÿ·=`Ê„‰'šÞDE±ÞM¤§Ç:†! ©ëÌJ ©Az[‡ÍfZBs1>*å,éÜÖA„©aäQ‚/1¢•«´o 2öⱫò›g €Æ#ü¯jÑ—{º ÝLÉÿÔ®.áä†\b»RÞ.[U±®0m³Â¡zÆ^¡-8´=Nu·¥ÄÚÕTõYÕØ«yÁ¦aóGgŸÅšâ)NÑFiR EÎK+2uý%™j¹ÄT-AL^ÛÍØÚa#˜À<þ‡Ûì£~Ó*µñc6>é€l\¯î¸ù¬ Zà²CÂlg“,“)ñäK!×OÞÀ%z}ë*7ËEЇ=ö9ŠI…±õ G¬thŸ„K¼Ó–ŒaG:’Fx÷XÜÃÖ>ã¤yÏ›·á%/¤€&1*øã¬´]ùÊ%’ÙUÎèÍͺÕÍ.!AD8 3ÎÁ¨‘0ð£ÿu"êÞu ~uDµrå)@}&ðØÊá0¨&·Õºæø®uíäî^"®X^Áªófz$[…}­ÈF~p´ÜÅwÚÛš*bþBdÉhB®!ÍúKg)Ò@¦¦M Ä~Èc4¬jâ,” ÐÛKÉÁ}Do(ù.±¾dœyü©€ÄÎIpþiKíîCxÖá‡ÀÔ·áÍ…¸­jµ£ÍU|gˆÀ8v›|‰\oÜ×Pö5à©ìÖìj¹Ø)"ÔVp$‰ðI_G„!l辦9í!õß°&¼¿Ü«ù9ÐoâÒÌŠ[^2ņMi€ ¦ @z\è9h0ãФfÝ^JÙ@,ÿÈÌðª™kå<ÐÇõ»Dé'òßžiúÆœ_{µ‹ÿJåXîÌ­§s[]Óf6KdWðVJÁÉ︮qíÖ¸.À‚²$® ’‡(é!AC˜å%ð µÊÙ8ª±  4"2Ò*¯"€ÊzÀ~x€ÿò< °¢Ø‡Dx¥4ù£Rs y Iðc F@È’4Œú'a˜¿‘‡ø!;«Ÿ{ø‘j£6÷™Ž1  y’;ˆ2Ę ˜™ž)¨ZÛ G’¿ír²Àã¸õ[¿÷ ¶†xž ²õB– è¿ ˜k‘Žª: +WB ×À±â²'ÿz"¨@9œCñ€h mà Xâ9 ÉŒ±Œi §Ó˜ŽÁ·nJ>㈱û;§‰1 ̡ĪøñA×2<:µ ûŸ%P·èJ²b)(8ˆÑQ+®h¨¶zÂö£B\<'s+·’?à‡( ‘Ì1ˆüó¡i!0´!ûˆÞI6d =rC›¢¨@p„5HFš€ÐòxFpg„ŠkÔG §× À•œºÝÃT± ë`ŒbÇI ®\JC  C# ŸM“A8Ò§Q3¬Zœ¸Ã'LdµR â;$›ÑQLÈÏq<’Ë.Yä.WL¿\k?\û5ðb+ÿ°¤Ò}°¨ýS–(¡€ø)uÂ/l{;Ó£b¼!à²{É[º%˜”I›|IG¨Fš|Iœž¤'˜ Jé¾!b¦û   w“ Ò(Ç?BB[G$1ºÚb>Sk*+ŒVƒu5úZ8†C#íBÈÒ½çB¶$#EµbÂx$‡’Eôó.«K)3<`ë5O¨2Ðzhù€ظŠÀØéË@ûê˜âëAÕ‘Ç̾»%—ŒI¡œÉ„É{øÉ̼̟ôL¢ÜÌ¢| ¦Ë)¥T Äé9Úh v;Ãu¤‡ ˜C|9 €Á{øùÙÊ §”ô#’ÄÌÊÿ¬D5VëJ?Êœé¸ „$Ÿâ @ET¤í¢Ë[³K‰´ï¢²Âc+^06‚¤ ÐàøB«,Ų¹Åè˜Ïʪ JÌäIËÜI©ÉûœIÎôÌŸ¬§—tIû*Õt,q ¦“V±sDut¢JÛ‹Ú,ô±œ˜äÚÄ‚#¬" ScÉ|:‚=2©° ÓA‰ƒ`Ë·„K‡T(Uðh«êü.J°ËW„ÂWì5½9È P·Ú@„€×Á‡…™€¾ Kø¹9ZÒaLµÉÌOà€‰¹ÌüÔÏš$J ÌOÍ žìÏS¥<Íž ž4PÇÒ½?ZÓÿÌÈé–㣔¼8 æ«Ü*»è£§V; BN’ÁV›¬Â1‚œ-±¸ýœP¤GzÎ&T¨WE'ü.\³ËV´H_»µ (‚|˜ÐØ!!ݸ·š €¹  P8±4 •ħ‡3F›¬I*UÏŒUžüÌyâ]ýO(MºÓ!l—„Ì”¸¦ƒ®ßQA7å˜y‹°  Ë‹Á™ŸzÜMr’A4DŒ¨D”‘?ýV¢ C=¬‚2(ƒZчbQ8(YŒQJˆ­ÑJ­WÀ£„^ƒÂ `+~˜‚4„(Ï…ù?÷‘1›s ´„¬{¢Êì1—Jˆ½RY•IíÉÿ0ÝÌ.íUÑ P`¢ÑtIqæó˜»> NÜÓã,×|Ztu$ÐýÜFUW¤mW¸dÚQ|2¶×_£ÚK`€|x‘ŠJ!Ö)U–©4tÏ|JŒlÉþüU}CæÚàãõXš[u+ yx^Ð`ÞÅCéeX*Sу¸ÕØ”%ÈǓś—3Ë›A ¤§ [OãA¬Z¸±í#¯ü-AQ}à‹ÎÅ®ý=Ú¹â Í®ó£ÎXü.Õ%¼V„ÂÃÛW}¨H/ek¶ HLÿú¢D²§ÆaÀWP¸íà9ž[¹]ÞfÀ<‘i&p,;žÛ¢ž‹§|ÚÞ¿UÚ¸¶Á1º ¾0„ˆŸÕ`ù¡AŹ÷Í/ K>Òru£ï Zà‹S&ZÐ5(Ð]QÑ]W¥u(T4ÝTüâVÔ5`ËÔLõËÛÒÈÛÅŒ¨–À˜ Á1Ü„8$Žc M»M9¶§@îÄñc‘•ÑB&ùÆZ™ nR‹á!´a7 _ã‹[ä¨äfÜåãlLJe>Zâ[´ÎMeVÖ_*~e*Žå`Úy½NW¼Ë¨½×Kð8$õŠ`ó4éÛ6¤Ì?eØÿ;:ÛBöªÇÔ^Õ°§fXîDj–'°‡‘iYiXùÆËHá•8„Mµ¶á‘iÒ8Bô1±hMg6Ää ¾Íø%²ÁåV”4µâSuÊ}@D €S>åü•b*nÔ£å&„Ѧ…ȨõâL²îZËAP6¾2O°m3›c¸†½¢†O¶þ*(å9bTkg>¹•Û! ä¶Ž’®¸((€¾64“ˆ ×`á{Ïí}TyQ‰#|sÁòEŽ TÀ AŸ^8&õ£ÁÅ`Nå°Š ˆHj„ìÜUæ_Ï}(ÿê&\(IË–²‚hƒ¼Y c9ãŸáJ&Àÿ=,ËʤúP²ä#•”ëŒ~ÌWÊ6¸¦‘ÕhÞ»Ó둎‚É™›q}p›)/A&u{Þ“Jä¶–á éCB¾á:òåáÚ2fÀØÍqZÜz;9Šç›ãäÚøY{ö§Ú¥öÜýâzNG½²ìR¨¤­ÎÐbîºÎÕÅKî.øЮ\l6xDOû‚%=:.Ì”'¾ÇìC WÃ"QÓ(áÚ# ¼> é¶ê^2ç…÷'Ð(S­RضîJ‚,‘þidŽ™—uo3‚¥™D#àQQ明éV‚„#÷!eƒð¾Èg¾p$0(&„å¤ÅbÿY>]-†íí¤TM•ZÀ Âp¾Ê¨ôÜ!Ý5Ûen® WÒ 2c=ñåv/=–n!éqÏÑñ"xtHô!}Ø0’­Án<ç…}·‘1§‘0Yﮓd÷žlmÅÍ ñÛdÒVBÃOÞ8²1DQVF×ü⨖j+VZuí¤Ý®^ó€ÎeÖ…¿KX€ R¨óáÀÚ5¾±ã®£ Ý9°Úl+Gâ;™7«fè’ ÛK&'ذ sÀñEztU(‚¸jw¶ú êñ|ìlãÞV}Lœ!™°ª*ã‹äàa H\¬lú™ö§îu%OnÒÐr}üÿ €/ðhp bêý]mwMðvméŒÎ×vw¸‚¿š¿¨.c±]l¡4®´Ë\>Ñ<Ùð„® ­Þ-žÏ•‰ÒŒqß°í>÷F‡tw·m‘¹ù{t—¤›1é§›a¿]n#$'>’š£Ù&ˆhÄe¯'NÙÍäjõ*o'­,GÃÌí EeÏgVNå2å"ˆeH ‰¥5ÝgZÓÝû„ üŒƒ Ê.òÔpäÙ>RÍ@§öáæ]«ïÃÉQ¦y{›Ò² r´yχÀ¸sozGW÷£7¼¤+H×ñš÷“Ë=BWkǺ6àQï~_rnBgË3zèVÿÄ0øMc_}r_ÉÜÀò|Dê¤ÑuåOmæoN+nTª^¨ókÂpÑêw$ëGp+&|!‰C2 GãV¨€°kµÿW•Œ»mœÕ4!½óüêN2½û|²î¦ç…Hô„jwÓˆK—6ôqÉBUEŠQ =z'Z,9aÑ¢¼3^œwb½y E’ÔPr¾QøVþheèeFEÊ»—C€€0Ü#pïž<,,΋Qô¨Ð¤'X”ø8o‚½ú éC„HÄU ­ °‚+_W¬KvŲgײm˶ÈÛ²Xõå£"¢]{!Bè[aÃ!+WZXðÑRòÿ­Éøç‘Æ‹wÌû!ßå|šùiÖÇÙ3h~¡õ‘ާ/ž D,líºˆBE8Ð6î‚ÒµG¯…EŠ'*×x¸ÇÊEšœg²ù¨Z„ÜxiH‚½™{æ¸Iàû½ÈCÊ4êqhÐèE~hOÚ*|D^½råúµ~Ø« ¦k®[qí7à\ùÜÕ‚-Ø•>{UÀÀ_ †üS Š1™O…çáBu’=šg Š&iü¸ šž½HûñòŽ ©BB¶d›¸DÛB¼ä…o-UÑFõÑGËÄÜI+©„Ï[QIKaðÝMÝÿ”H18e !N¶fF"…ÐUT%Ÿ[u5–_5Ÿ~{îw•Z–—"â]!L4‚ 6¤W> ,°¶A7LÀˆbGÈÙ‡ ‚èiFCEOT›&#?üÄ8ÂŒ®Êê‚iú¬ÆÚ 8ÂæZl=ÖvIAúhEˆàB])™QEA œE!MRsÍ¡t%>™Zw˜v,p—N߉åRkjÈfP,°÷AUÍ _Yvz%|1ÒÕ™Uï¹ûV‚ú'×€÷¸‚ó„àhˆ|@O>ˆ,0©®tÃaåáO¡B¶DPDÍcO‰ªªšg1ºZòÉ.²¨ZCpݨÿëBªì8mýhómĹ[ŒУÁELvÔ”"Ik4IÎQ‰t£X¨•!THA¸:p„FžËºk:5A>T‚ˆ>CÌ)o}sÉÙÞ!èuÙ½)Òx7Þ¤Lã]¿ÉÓ„<-Ì£à^ŽÆˆ*"’†`+aªé<%¤ÇᇡFvDˆÅUf#³X•ÊǺ*Âè •>à¹Â욽쌛°B{Ðn.@¤¬EÍZ^ä’[­ÒÁ_;/),ÓEÞfN„nzzJjP%ÌÃÝh»›o½ù!"Á^{M ’e˜å2ƒtåm¯ö¤ xàƒ¤ ]ú{?7ö3ºÑŃt"àË0¸º×Äf64«ÍÍ‚t³ƒ„vÆ:î8Æ‘(ehNzáL‚÷³•H (^Ô£,¥'Yó ¨ÄVª%+<“ùÈØe¶ï¡ jÛJ¾â‚ª• èšÈà²X¾Îà­}î‹‚jò‚A 3–oô1ÅE¬qøÌƒNa,clÈòQ€5°œ éÔ îGu\ˆlxô«Ü0’„CZ²R(Ž9É$Çy!QžC%”ÔЭÀa’Ü]y9øPô27¡„M]ó€€=$€6ª4±ÿ–n ‡®Œ(AÐ ì"7̨/o(ŒÈß~Â^ƯQ¼K>Ö1Æ0Ôùß xµËQ¯c›cW>*à¹Ð¤ÆUpÁrN–­†4V^¶ÁØì¨f”#iÇ€ùF"ûç 5P')í# =$–%˜´Ç(fª Öº£žq)h²èšºé&©œí]U¡å÷¦¨K´àV´âšx™1FEd/QÈŒ1ï¢Ë{p€XfŨ })"‰c£߸Œ€SêÅö±<2p4¡sÕ¡#AÚh‚'krôA‘pXø$¡'dSÛL"i¢d“ÐúB )­Z!ÿaK>Y2‚ηÂäÊŒ+yDd“º°×°&ÒRmhBÜæaRë‰ô•!)ØI׸&P„~£ÛÝDs¾»Èƒ°iMåqÙß4Š5ˆˆ?Š © ­¤q€¹#$ª­m­&KÀÜP¾É=¢H},ZQŒÖI:^¼ˆ®"¤;/¨\ ÊG»IdW£ÛÈ!9²œAÕ]u4ã ‡ À;¨Qš Ý x¥=a¦lúð&ûÀ E‡˜‹&…M'€¥Tà3§ý¢ —nzS{ÂG<Ö#‹ŠìIƒi—D‹-¢Ë¬Èœ€VRIÔK]  ð""Ñ|%,Ô7"bŽWë ÿŠ!½(Сìmo=ã¢C‰fFÂ%s­šÕÃL!䪯¢dêò¬wQÁ]_È¡”J& ‰ æ1 •XH[QÛTvrÇ'Oc”’¦¯MF]o’¥~›H#…øÌ ðc5É ô¤ä;ØÁòFš…Õij5]æ©™4’“>¼Mb!H <Öc´œJý’ÁhFú”^YÆ‘¨^ßìE‰DkІÐCDÓ¼1Ú¥ÜÀ-ÔĉuÝQØg|À‰€gô–Óñ¥†^UVÚñ lÈŒ«-RôMWuÅš>@?]DÞáÞýD÷í][ñHÄÿ¶P‡°…R hû)“ÜCê1ÚÄ ·ùRä¹ÒþÕœÿ…Åö`ž>°êµ@ÍÙM}™<ØE ¨\ÆN0ØÝüË Üfì…]´T4X>àJBˆÀ]$ÚÃÐ[`\Š!dÓ¾¥[Ë‘Èeð‘fœñ‹Ž]âBkˆ\ìŠÌôJÍôˆtõ ÛíŒ0ÀXSva÷M’q„&-G¯ÞBIÍ€ÌzÇwp@à@_\EN‘ç•™`ÿ]0†…Ú ØàDõÄ„}G °Û 4Dž¹K˜ÅÒˆõ!I½ž¡ÙÃòà ø…:NÜÂÖ-n­`§Mÿâh SU¡ÂáJ&2ùÀÌìàÛ$‘ñŒÐZp8@qLÓø=‡rüaD( ›1h™46HÐÍzØ(†b°XZVøŸž £¾ .yžfÀwÈÃäaê5[òÅšá!YØ 2]Óé YÔSÔ J ;öäÞ¤9žým]ª0àȸ çÊ ×U%Žä 'ªÎªu¥ä=™â)Ž•öÎ?Ñ+>$øµ”ñZùaÉB¡ßÔ¨—D-M…àÏYš_2Öe˜$aÚa f `½€c0ÛL`‚hã…é‡îdû0XÜ`&‰Å' ¤>8=¸ÿÞ!FÌN€ò8^‡DFPDʼnˆÓgœoÕÈéÊ?æŠê’V&Üë©WIXÂÝÎxCÜŽ 9d+PTÄÏÏ“ñ=ÔP¶h‰-ÚCÝuŸ4~ÇgéåÉT¹ ÅH^OÅaf…G휡^êÒšÈß-ÞE.Œüi¡>ä‡\œÅ~èa>䂃¹\èàXуðÃb":QáS:"ep6l~ÎÑmem¶†ŽÀóÝæ®$RÛIßoÖ‘…•@rXúFq~ŸC<4B¹e߉\âPúÝ"b}–ÒŒHAËx°Ø›ÌÉxöK¸‹œ4£ù¤Á¨¡àŒÿÄ€M‘¯ Ód"c¿ÐgJòd5[ÈŒ>´ÁÁˆÀhòÏ1§l jªXG@ç<ØÈ<Ø9]/Øf'ʆ*¬€B,À®tbnæJîÈ ¸š'tÕ͌҈KÌÐÇqŠ‘ “&5g‹žE"‚°Ý"±a„Ùè^¥ž¯±d—$]µÿ éV4„ÿ&¶%ffîå(Ò,€É'2Ž–‚…Ÿ £”îÉY̸̩hâ—JÌT@š€‡#Þƒº0¨È€Fú@è€`¨è©±Bäé?ê(R>Q«áAxh ù ‘ hþLîgÆT•,G‹zÜ`´ÂùÅèúXûmÿ¤"ˆ/Þ_ÒƒL$MGæ®öI¨iPæ%føL ù$Í^ºJi}¸žHé¼ÜÉ|x#‹téPÂ_ˆØ¹£·\NºYÚÇ\F$v%>Ê´ œ¾Þ´®ÛáiÌÀE´nX=e«"Io¾ÚAÒ†-Äš œˆ¹vßö!§ ‚Ä“QáÏ8gDÔPK\dTØCÆeê²íÑÅ8 ¿J‹µ½K–j7¦0`{ò¡“2éHÖy£` éNÖ'ÆÒ©êüª—úE¥€éàå€]ƒ2+²lC¤Ó¬À©@fì4®?ªŽ5î„ ŒDP!RXIœX"äC(ÿ q¨ÐOœ@”×HðêºèD€uL§zÑèuÒÔ¦2˜o¸‰^DÅ›„jT0À°£¥Äð (Ï…Sþ›8mÆ×¹`«ÐE«ˆ"œ¯ÜFîÍåYÈ?®ÿ²ôS `#àT–‚Ѓl•(Vßn—ÏH´œeŠ>éÂâÅæ¨îDMÔèƒúÍhûõ™OxÖÇdNDÀM3žYæjï–°•â'Kúdfþ¹¥d•¢ŸÌU²*8€òƒQ¶ã¥,€R¦Ûå8%Ü@e×¥ð™OÜ€L&ÓrâðêËFî~`i1êJM–EAA_(‹õ]דT±åA!’õ“=X u\d(10ø Gd§Ÿá‚`£vòÅž4ãµÉI-í×ï2eæñ›arÜø1òBì}Üj'[ 7ëÍ ˆ¯¢Š"ÓÞâ+±ÒVÖ­Ë¿ÁT×Ýbzõ]Õ8IÃÿëé©ÝH¡KC¸%/á¥^*¡eí¬±\×AgFÔÅ¥.vùÆ`¬®uðƒ!Üâ-2ÇöÉnvþ„sdòàåa¿,/eb.ÒA T’ï›­YU2Ò=oÀXé¡`® Ê~¸€ohLJí‘æ„àÜBº‘)×|Ì:ë°8- ò”cø’üøaúl¥mrŒähBËoL„Jaãb,Ùù‰žéÙüö+/ÄÎE5DáÒ³> i¸!Í]‰ÿe„8Nÿävðä¡lƒ~]z¡‰/‘ Š-I´”ÞôI ß§ÀàEï$Há¶EÄÆFo«²YÓL«‰•Ô®q‡s€qDÈußAt\MÔĨÐ8äg)[‡t4Gsê/Ò‡H;l[bb«¤Jï ÞHúB¬ÍÕK§w1avjð4jå4]Š;b'7aÚ¿1HëE¹0v«úah~³ ]öMkµo´ù¸%Èoض]DÁj† åg戞"BwGDDêòŽ ð.c –¥"B(…ÒÏT76~ÖMáeq´6†€ˆEHg›,Á4ÁÚñ òb—í½Œ[lGÿ¶ GPû£…_¸e3ˆfóƒT¤¨„€éİmí Ä@ÑeFŠ\4¦²ö^1 “ Ó6Fè€ ÊGAãE èeÅ9ýPx8Aë±yN§Æ†R !³|’¹u‹.÷DZ¸8MMßU÷^+ÛMÝÃd4”Æ´\ÇÌq‘öüxG37šwO3ƒÞ§«OV5],TB¥žS'=À øÀhJÌ`0@ hSPÝ%k–^ØÕó ¸ÊMá\¶šcÅŒhµVG„ƒk@17´#ˆ³·‚8ž‡ÌžÓ4"ÁZXYW]Ôp"­¯¸ÒÆí<&ÙrÞòCGÄÐC¡°aÈdYqĽ{8àpðž¼-N´˜w‚^ yô$èCTQF}†ôuDÔdHúD 92dÊŽùr}ˆò!½˜2=êòëcΕùBÌ”³a zôœ8Ég4Ÿ‹N4Ð+0‚Á‚6àÃWõªU«#J‘wÿÅ<{ìåû@ožC‡ódæ 3fÚ å)dáÄ¡ôÊFY¤ˆ" »à§´ÍÂ&‹ï-^Ø´ Q£“#.$šT`U>8w¾Ä0¯|Cž0Í7Ÿ[{{UðåkÏžV|?(P0$¡Bî±öThhšW {r¨PèÞž5+æÓh±&È GšüxR%ÈÔf£Äºüã/”Ñõ™iy(CËöB8±¥@j-4äC5 YekýÁH¯Âb„ŸÜš‰­Þú€ÁÕÒ’¨!y",m¡´† !µŽ2ë ´"xqa4 q¡ š¨‰äR‹Ï Ëœ(À… ó̇Ï|Dzš*+ÿ>~ó¤ Pp¯ÕVóï‡lí²È²ç¡ÞNH 0ÈJ'ú)Ê>ˆ#¦›NºšP"3»Ôr ¡;ïZXŽ$DtÒ'{:O-ÒÚ‹¯(Œbñ Bàg…(™j?Ù°ºj¯ŽËÀHWc¤ÎÔìd//…NH‹Ó¹$’P=¶PÓP;ÄщČYˆÕ††3H8MÛÒljˆŠÂL³?³‘}VÊ…"T)â’b‹õ„—¥^{ÍžZükÅ ˜l6{44Óà*θÆúé% ¡Û¨# æ$ÍìÆKó@Ÿ, AC}VèèÎz½ êB+2„à³¶{<(tƒ"ÈjÿQÙn8A@±*°t7-% ­ BK=‡<•Sz$&IXÎ.ñ¤Ãdk¥¯…U…šG®N­‹S;ùE‚ÌT‹qµ|(¶Æ^F®ÑC÷–=Òª,€ö¶Üž¬ÀžAƒ%¨´’¸,JN&—Ê%ì8êhììBJ7¤ÔÚL¡ó ®öœ°©ø+.6€ˆŠÅ@2Ë>Œ-rXÈ D¨HÉÍ£x©”¸"ù vfƒúÐ[-µ g"*q>v˜\å v–ä +[ù‹\ìp1;´YQ–•´ÙX`¼dÔv#µk5J$t™A ¢0ÞiŠäº"F¸g¶ï•çš]¬Ìÿ61>¸Ü c˜K‘ÛRƒ·†üæ‡qlJ>Øy¨þ®*U‚ ±ä#tR\Ðr: …€é+<ùÉd,jìHŒ6óPˆ |Q,øÌw§\D+ˆ¤GU±™ÆúÀ±°C¥ìF^´²•½èÅ/vØÙ6ð P0Rl´b!âÔ¢)o¦¶ž<®°yiHÄÉúÁÏŒü¢ŸŽÖÙN©X+y¤Ên` Õ.„Þ*7| Ö‡Œ­<`‚– ª ’¼h¬*Œu ¡}|N¬_r±» .vX†ì€iÿ4ÙÏAj´!`„f_Îêp‡* ñ‘ŠÙœ¶I ª–=„©Ä8o .‹íl&°…e§cQÃF•õ·â"žð…!–¨%…/|-lì+êK_ f$ù%ŠŸŠb³_ð‚"·G ¥Ï‹å¡Ô\wõ…†ƒSµRÍ¥J3t†iªè‡h úÖ œ[µ €G ñË þœìñ6mH…1KÞJãò©ézMe“à[0"*9&E‹'_è‡o§ˆ@pvyXP5á2öØSxѺE¿ÿØf,&°-®g;r¡¡¬Íçb/v†Eõ¸MoŒ¢¿bäúêÜhod®Í>„wv¦z§Áþ¬ œà´®Z~Àë’f—ÂNìÿ`ãIn*è!ùЮßÉe" úC$àÊf®èk@â°üÏRòîbØãÿÂONäDP!ºÅ8ºå]$ñ¨Ë>¢"É”&¬"/ð¥<¢à4ú/ô!óÌ ÷ Ä^`ÂïöJX¨Íô|nélg6 áÌuËÌf¯X6€é€F0\´zÿŒ³àMÞj¿î¢¥«…,"‡yVc߬F8žïŽàJtÐe^`<ÏK„P%®Ç0\ØFT0Ç «üª¤ 8 £[Š£1œZ£ z£)øa’,Éú§* DP®i!!Cz $ÊPû;î„=üÈÿ ±ÿ„¥XN.Ú$k?£±*)HÆq¾€Ý0Ðv…d603v&U°ÎfØm³zè‡HkÞ,@IšÆÞú¨Z®å!’ùøm B ™pPr€úêÊ9Žš´ÃÓdL¸ô„/îæ¸ì„U`q ã gÑeñö„=~ƒUÀ %©â*ˆ1".c£òa ߆×ÌШ®IâÔÊI\bô` ±TAOÏÌÜîl¾„…(ç+(}ñ”:D0Zä{O³tg³~é—b½N— ÄwãøN@ßÌŽH§BLò@QæÀfª#%| ©ŠP~Vò'ØÃ™ÜD¨(ý>r8ÿ"ËUØ£7Z@¬…Öò*€q~€þB$ÚVb.0Äcåd²×ŒpŸ .'µ /á¿‘4Ol¾j$ö0Ð'“23(0.ÁSŇâ1*§vÓQ0I'`7º’Ôˆ-fðè„ ]æB !¡Þn¤\6­!Ë?íqè›d!Œ©jk!B` Ìh8=b èc/ C1×I EŽ*6€~åm c£~-¶3On\bò¨j·4!içz(ƒÒ4™®ËñGS)=‡6]À‡F° \ Á|G)v³îq6lCw£„6Œ/ÄR[ÿ^úÜŠ:«û²Ïÿ’J|øÄ4 d“Ò9^ 'Ò§¾‚ “£V ¯VäˆíA *l*ÂJòˆbw"‰VrcR3¡cÓ^L'eÌÓtNDsioOÉ4Ç´ÎÒ¬5!Ô'Ó1v®ÍXîpuú‹Ýìk7ã! `®Ò´j7„D,T`¤ÆD¥FR[6Q[ /VÉàÊK3‚Ó>­‹ÎÈè .jkêbSJ Å=aOJm5è#Þ|pVÀ$Û 2GŽFÃ(Zh£¾âšQø¡$4S'ïJÎ!c ©2㦮¾¾Q²FóXÑôA!Tí«?Cw(T¥Bÿí4‚6€Ó¤ø6Á~„‰jLÃÑM8V´ %„-¨3š²"Þu.¯)RzôAZÆßÎÕÂ)œ¾"ý¢K…€lã†Â74 7œÂGÉä3€ÜÂ/Z(Û(ï·xíL8Ê$&–šÎ4²<.LëK®X>–ö4ˆ¾Ð!ô†&Éu§(ä4CMÀb6r  µ&€È‚Ÿ„,4ÀÃÄu‰RT9Ríîa 6%Õ\"õ9¼G;ãÂR/‡0?’.˜ ýH$ºød/Š”>ìaßïV`I»", ©n°¾¯LÁr¢$Jâm7Š·2oKW‚n]A1²‹öÿZ³dÍ-YQöÚdÈM*Uæ´<„bÖ¬b?Në6rVD¿µZdpyLcjÐîP‡6Ĉv Bs Ä6b\ËUsËÕjRô\ÏU9O's‹\Êu}«&ç5ô¨1° «EÃ1dQcÑ1þ5&$¸tWvñ)’ aÖ"`áã#àK„#N˜÷$ªc£x ¬ôy¿a/yá„%w,ðuxé.YÛ´•<¤|Û;l¡:Àq÷*7`/àr–à\GËì¤æÃ•ŠçÂѾ"írÊsÕu,pC·¸$Õÿˆí'Þj;Þã|̨/e‘ÕX…”=Îc`QÕìÿ3ÉQ† $±VàÿO:bDyÙ"Þ6%Y…“b¯2#3Bp¬0pq] ’ç‹çêXQ‡ƒæ†8ä¾,LaˆdB£úq‘8‘x•ç¡ã7jJ¹jÙ¡£Ø–—=WÙ6%Ÿ$.u‡PuM‘q|‚Œ_¢›dâ"[€™—¹/‚ÍÚãWìGwyCò¡P0˜Iç*ú8’, |úbôöÊ:n:ys‚n³H‘õP;B‹ Ë·AOÖÐìžm¸†e†:cqýìôN©:€lD¹Ø—$@rÖØXyRd=b–kùPí—Š;—¢sySü£ x øm¨ ëÄzÿÂå˜ý’¤S$™39Ð'˜çŒ/,X oÀ± &Ý)'+Á¤è S;NXyI±ƒë·àY"ù^!I»1T³8p_è±DÓ/9ƒvØTb({=$ïì“C9 :•†i š-ºÕØ¢†-¢J®…ù˜¯˜¨Ø¡Ë5®‡öP×55긚#¯;3&Äî%ç%à‚nP0?²_…T&Œæ1[ZcŽ¢ÂÉf%ì£$ÄÇ3—‘T⤧ÇåL YKû|ðÐft®_ˆB[`o’;Î0Ë{U6vôy{Á¦:†<ª¾®:”·z·; QL Z|p•Cü c\5¸ÿ­å!ì÷PW|¹ù͹Ÿ;‹O R,eY@ÅNAÊ qü™£J0³¶'0åhBŒ!P„ÇgªÙ±ßé½wÍ$ʨX"c="³õ{œ³ôJÕ†"à T/Þ žMªüŒ£ ráÛÀ ž,dŒ¾L¶3y¶üç¬:L9c·M`·ƒï%`p6rÄB¸c6eT€2÷”ÛÅËU–«Æ©„S=Fb0˜rŠ"ÅópÜ™º£Çõ„0͈Çb4¢ [š‡½)À±# U¯Â¬HNèÛ›E"WoKÉù:Øe4C2ZVèm÷Û¾-4xŽª%ëczÎc(Ùg[|ÿÃY´Ú6Ü:Ülã€;Äššø!]­?,–Y\ ÞÚj*'Ò+Zºñu1Ÿ*ÕÖªŸ>7…kœíÙ†ä×Z`=Q½Zø!*VÀ±Ý FNn {Ú¸T$,Â-›w:F½'5"Â1XªEˆ"Šœ"©Émªm¤4•RÎç<0dè¨KI 7¼·iÃÏ…s•Ë:~Á•PLsS\s•[¢‰J è×]]=fŸV€7=Þ$\òò©0_ [¥Ý‚'N  –àÔ|`{æa›œ*Hî1þÉv‚@í{b7;:Ür]TXYB Oœ`å¥s¡ªW5-Pdÿ4|çü¾$¼•&œC2ðÂ/”»:Ï;@ωØëVpÛ=çW9H\­uS4ó—`€ Ýs9èa<º)}º*RæréGì4ýnª%Çëå=”pÈèPéã¦h >™ÉZµ [NâV^Ã\„¡ƒí­<Ë՞׉to ôÛl&úK3kž7†º—oS~ýþdë 0´º«=`·=À´ Í6þüæËz~#~)óýhóƒ~Ýãº.šBìPŠ2ýôˆq:š;Â^¾ö:!ˆÐž=zMî5iqÂØ Tä·‚Á‚7:Fˆ°߆‘ø8":)â"}ùò±t©/fL3ÿõ­Œ¹’æJD.bò“ù²¥zôœ8‰‚ô¨ ¼ŠùU¤—ª^—T]òÕ‡*­>®^ú –Ø®YËúèeölY°_…\òd‹WÜt;˜°Û> ?Z’ða£ÁóÅ`TxžbŠOœ`ñØñã%ò–Ü[bÙò½Í÷äqþ :ôfyòNÌ£âƒêùXç“Ð:6ëÙúB´v=»µÀ‰† Jo!ј›,‘hŒ¢E{ü4nìxcÁ†#-ŒŒÐ‘J7[¾”ISŸNñ6iŽw±ò'P—.Zæ‹âÄ^”÷Þ]ˆpªªˆ*«U½RÅjUV—ˆÅ–WWauZY¡u‰‚ž ¥`¶ôRÿ/XØtÝåøü`_fÏ`ˆ¦XbóH6™d˜±€Ye•]FchÜCÀ¢}æY §ñ–m¸µ›¹H ÏIÖVÛ@ð&pR¥Á ×BrÊ)¤syD]Hbn`’v+ B“{,EO9ádzqÞĦ{åÞRKáÇUZRµUWJV ¦e¨Y^ùPDÒ…a†xݥׇ~]a'ÎÊŠuC ,BF*e4f¶#Žªæ¨ªh:’vjªÉl¯åB¤lGÎúd>Qw=Á«fÆdY !âå D7ÝÖ©Rµgr·¦K0åfym~kÿ›í±4Ÿš=‰€®S ~%(YW(è l!z胈2Ê‹ ¼ì{a¿ýÞ…W‡µðu©`hš˜c%¨(Y©0Â(#ª5‚v#X̪ŽÖ„i¨¥dKBÚj$l³EÁoôÌãc .³’è„å²%ØQf,J>4 ºši‰(RÓÎìx&Ÿ…É"Ì*Ò`“³¦Ð…eÍç>½”|Å(ðY®Ú°Ü(¼ÕyRK °æJˆ…YC-€(Ñÿ¾bÅÐ+ycÉÄ%ÚE°øÅj ˜¼1B˜ñk,üøÌƸ´˜‰ig]µY0Ž™ýŒÏx?ÒAÖG”Ù[ –Ñ£œö(€”Z3Š õœ)i–Îr&ªânZAòqb5qõ«ßZ¡XϪܡБŽ-hƒËnlãDwOûÑTô³Ÿ{)ª+ÒkV¸—WÌE£ ìz×kX¿¨O0ºt,c7–NÖ1Ç”CË™š xŒ«j&Ž$÷ÌÐ|“4Åô¦Q9sãrÊy"dˆêŒ…Ôå䃈ÈÈs8H¦Üµ“$í\"~rÎßõ'ÅÓ~‚®£)÷77®´¥/]iéâÿJOéò)j#Ÿí,©Dòy%µQYš€°²Ô_&p°ùé·Ê¿¬µeý>ÒpFb8•ŒüWS€Œ­Âl±SÅ™orSÀ—ð„ŸM‘ Ã!—9Íé’¬€™j ©CUŸY•L"0D¶yÏtóSi>y Q0:š=$Þ¨ƒ÷¢æá»kI²_IMj$+£â{rz ‹ZDàR±æ›ßî‹åÄÔz˦:æÆ6#ÿYLãÇתë(Í ’póöª àÇž]²è®†Ë…,nÉPñï\è8ën]ë@o?Ð¥¼Õ­þL^@¡·•°úÈe)/*Õ(À-½óè‡êfˆ (v¥²^X•³2ì#&Â\žig%'ZÑzcƒðLJlÌVÃZµg,azjˆBª7!pcà„H»§'oµVzòcO±oA–EÀIUó<øa|…HQÆ'^žp EàLX·j0Hês0P"à7ƒE›88/•E§ñ>·1¬"Z£µGx›E`Hø?WÂfÑT%+çMsñGÿ­M%['ÐYè|f-PHHŒÑ"€ÆØNŸw¦wzÚâ;ëFÄtç8ĆIJž8"ÿ™ý` þ€«¹ª«ù™Ñ‘ò7.7mw,y$ù—ºª¬Ñà—Dð¢˜ÙŸ­ðá™:pzƸ   ¸UHƒhxªbÉ5iÚEÑDÁ\k3¨éR¨!ø”ñÚK3¢Y «‚;`黾ìë—Õ†¤á‘.Dzw–GÆ0¹4s¿ú»¬Íº€h‚þ»p_|Xa €qš“ÔÁ8¹ 0âú¿¥9!åRÉã{Y[5ìÀù‡yÜ›S¯=ÑÇ‹Z¨€ÈIƒ\^ü`G™E£Z š ñ€ÂÌà¼Cú8Âè,Ôk·ž‘·@)¥_,B8¿öªvã·q[«ê›¸‹Ûÿ¸¥¸ÀÌP«€©Ìð7bÅ—g Ìà—Ñ@ÌÅ\Ìêà—r°šü¹› þÍïõ‡t׺­i\§«[M $2¿%èqÇx dû|A ÏC•ôê òj¨†º›ˆè¬°ÒÖG½ª‘ \Àö1àÂRö©Úñéã© +} ËGp·£l¤’ª”EÿÕ?4b¾Cˆ¾ˆ»¾‹›8K\°÷I™0à¥@¿Ã`Ò€™†.”³þ˦ðÌÒLÍï•; ô™ÛzhRãÆH«9 âÎÊ•÷²ÇãȨö¡h»õz»…Šñ@1¶)U0oËÿü\"ìS¤÷àÂÏû†ÐÅþ—> Ö Cp™Œ®pð/P%ðS„E”Õ×0Uf>ØÊ¬òÊI,˖Ѥ-}žû@ók ö©Øý°g°Å]ܹ "©`ÏüÌÐhÖ,šiÌwâÓî‘óÔšóÍEmÁE°æÜ]fŽ|Œµ"Ј½™Û鈈 ¼ŒH'GÊ%œÃˆkŒðRzK„ Ð C`ɆpÒºvãÖjí ÎÉÀÜÎí <`<Þ< ½/€E¾æ‰†Ö«¢1KºL€Ä½Ä÷0 %ý—‹ ` ÜP²PÚßЀù5'Ìý`ÌŽÿÌý0P5“jª³œ½p5Í£†¡Í+£æKòÓÝìÍ>QÔâìiC^á¸/½M¯Nm»ŒZ¯%!°fT÷œÕ$°Õ…±Ã9’§·­ÏÝ AÝlmØ­Ý< àÂGž @L>®/på]Þ]¤k_V1æÇ?ÏTØðÝòMßýð Äû½éÆÅºZ³yPˆÐÅÑú€Ù4Ý |1­‚€D»­jÜB§ÝÍoÌÍ~VWëÚ"Á' ÞSQ¶m¨w\â¼{›ÀË ù`£ÌXz­½9¬½Èã9@ý™­àÖHÉ Ð pÿ䱩 ëF¾ä ðäA åämÞm‰f`5Õ屼ĵJÔPæë[¦~™K°æ¹Úæ¥MÙ°ü9œë¿ °pvÆÔúÒÁ£©Æ j§«­´@ÁÎäñájÎð f¡Ô»‹Ûę́èštéN89/…×y­½$àéòû ê9pò€ØÞ Ôݳhî—ÇžìI|àÌÐÏN³~™¦&4Œê ÎÜÒªí`þgŸ'éÔá>‡6É@ Çã*d5D΀¸°}]ï¾=IÏP]¯"=‘ÛºýZ£Aÿz=å%pñY=ªÀ¡ž¤^×G0óÍÍêÙÍܲNëGîÂo/ë pëC€ëà $€×žèë2lä'`ªò%+˜~Ù%ŸÄð—‰ òþP³ÃPP€4+ê ¯ðÌÌÀÕÚ3<0ÚBÌh@ Ô‰ÆOLƒè3!ˆÀiœgQ^{<é¼ ÕOYõèrï Q|ªüž×Y]$P`eð™IäFŽäpÿö©@ëÑ/ëL^÷CPnͽð/Å‘ßqFرïMìÙePJæëë ~ Ùý°¾mŽA¾hjÚŸ®nùkªíÒ:­:¿qƒÁ 7FŒàÇÿO_>{ù>8|1ŸÃ‰æÓ—Q!¢Œú\ˆd’ETñQòdÉ""x¹„ùRfLñ\ðòà¯|ôšÜ“T‹%X¼ „¦E_äÈ!ê†\Bˆ RqM6¬×¯e»nÝš@ízõ†\pÅèÐ#÷ìµk—Ã=úþ%£_?kþ FHX¯  šŠ*¬(Øï±þ”?A$0z M.:¼0RIËpEF¬u¼‰&k¼Á4šG\±ET°ç³ÏPu(£!\ÕG‚¬øÜq¶Û€ˆ ÿ ô©8à|H¸†S2É(E£*õ‰'9øyöËœ\pAŸ˜­v&¦ƒé;^Ê Móäi¡„ˆj¯„ŠZ*ˆøìÄó/b«TüôOí-Õ:Ô@¶êá!ˆŽp´Q¾$µ+ ùëž5ÜP1f0Ÿo±âKŒ(ÚYÚ@Øá€›àYiåÈ 2¨›}edɈ’$6„&¥Jdå'… È'ž¤§Äh"  ¶;ð¸s ‘jMÓ}Tø©k¡äAjÝt_€NöîÌ€ò±ÆâȈÜh‚ˆ €a³ ¨=T‘Ç<(%­ÐIôð™í|–IN¶Ÿüä<>©´€”¦ü¤ €´fÙD& ž €†L<¹§Li ÚÒ6Eaq_ZLß¡ÔrMDµÏÚä ö‚jèO3–é3€Yƒƒ¡ƒ<5à  ¢òÇ&ðRŸK˜i ïHÎ…  ±º€øt (Ô‘G°éÓº `¤°(L’h8 Jrα' GK*‘² ¥Ô€=Téàýn•]¥,‘< q—Ó«©ŒÌœò4˜Ä<œأ”V§8‚° -FÿsnJ£ÝÂÈM©>œZщCK à«ý(ц¸Ž6*­Œ\=/s·r·­ÜÔe19œðz½A+:°€/Pù%1u*yÔh!5šH’|6BÆ:¶£§,e€OPY‘x¤¥fÌYÎÒwÖrB€XÙÓÊc>8•oksjÜjo)$‚P1P>} ÊÄh©Ý”z¨lr3“Â``©êæºÚUL’K‡Ž™Yë(”&†åe – Aç CÐÊ`h÷à»aùîã¤ÙUÓ*³$‹P£dÃì@Ž´ƒd|Rþn®…šmðZXÚž¶ÿ÷0bTª¼gN¥‰fÚ0¯}ñ‹·IUqSí&Ü1÷WÈ”¥¸ÑF:0ÆR RÌŒ7™•»jÅñ(´RsÀÔ¤¶ /3×¹ èÕ5C@ ë½ ËW*óhZr.‚BŠðý ed#+à rÀÇÆ¬åè¡ì5#Uª\%Òœ°ì‘ ñ\'hŒH̶vÏß#Û{̆0¨¸ÍÐÓ$pS¼bá¶ï}/_àLfáÏê"÷nÉRhi"J}Øljôî @z0\}úX9-G­hºê <ÓÊï­ŸSà·/5…„8ö@€8Jl(pY·ò¿Ä”xÓ£¡Iúu#‚­wÎ}<äǤLKz‚5¿ðÙ›³ÜH/Ë&Çl>µ†ïñÿwÊaË“`uBù²8ÍCÞè oK»G_\# f2©§Œªë°Â:LŒìª½~5Üûº¼˜)úœ 8»z â#ˆ¼*K›yÐ,Óˆ¹Ë/‡ú/êë»4 ©% ¬’b¶6h¡Ð€Á9£3ì {8‚˜‡Y˰†Û)BbÂ÷x÷`+:*A9´¹!ºà ®üsŸ»Y©2½~Ð4ô5P G¸©Àyk N£½Æhà€":ï3µTcÁ%`ra  ˜A» T»ˆ¢)k- ,e A娻Äj’` 6²3³— °4+9A:°5K°6[¶¼A Š@ÿ;"bºDÉ{-žÂ-yax›C7'´?Ï®‘BWPÈ·t=LË*¿Åh€§³:½ÃÀ1D ®€3üÅ`<µT£, Š˜PF·Pª­h…®X;ÈÃD[›( À+éˆ,£ê(Î!¥a«¶b;¶ËrÁ5Ûœg+{(€Ð ¥¶"—GФ@c8Á¬×ÒDL|€N<‚Í›?%Œ›Ï3Å€„Âv»÷1KPŒ¨#;j{cÀ¿à€A.K ¼ÂÆð*P[@Q+¢Žüž°‹6<5ye”C·0>!±){­ä‹»]Y>"Ñµãø•$!DÏÁ¶í+³ÿ#ÇÁ{3”ó9{ž pr£ÇL„/>ë6|œ¿ ›&€,Evk‹jª­tm2&ˆ :ðp°0´†P°T !ƒHJ«o°Ôón°p€E딼ÌK‡ô½ÔËêZ4Æ_Ô½&èœR*ÉÄ|1øq I»*JWªa’аÆä]ˈÃB¬"ÄOò¸1KÄí[9ă3áY%{ %c0­ û ©p”¦¬5ôó¶`šJ41«äM£C:Ñ3H¸‚O¸ŒQkKS œâdÎÈXÎâÆŽLÃ5œ+6  Å<€”TÉ:ôŠ*B<ÄÄ$^yŽ?\ŽŠÿƒÛÉ;P‚¬¾+­f!ZФ±•3³:«DÁGÁ-qÚ„É ¬¹PD7B!õñÍD«¦jŠÌ‚ä&âlÎã<œ =µÃ9ÃçĘ' €‹¹‰ÌfLa45¹‹Ïñ½‚yp€8€ `L¶P‹ý°€¯˜ ˆ"G!p™¹Ó5ŽPˆ]ÑÆ‰P$á/l,P*­‚³Wª%àQMÌ )º@˜F¡Š-¥ zœFM„Ižê-Źù"¦²ÊûóÍ-È÷á&4¸‚3Ø‚NèbÀ›ÒPÀ858tZÎ}`†5†Dèš$ðGxGàð‘Et’Tÿ@'JõÈ`ƈŠÏ±Ì!pQ8€PeÌî >´°ý¸ûÈ#¸‡0‹8ÏÐÌä »ÌÉ7DÆâ¸“ððŽš(Ð4³‘¢ D˜×<Ö.õR0uJÜ<4ªD±kʦlºq‚̦®l´mšVÏÓ& x€ €¨GñÓ ¸é¯¶R×]RWîâ€&x×°»4ÄÔÁôÈ4ÔT°ñ=¬08PÕ02ï„ Y‹"?…€XYŽÈÌôTO[e†X¡’âùU€–¢ Ö•ã¾+­‹©ÐÚ:Öþ\Vœr¸”ý6ß:P&˜¶Õ€mŸjEº¦ÒJà#mšY(d± ÿp€  ÝzMÑTK×5i«’+¹vM"#µ¾ Úz=Q4 éY2¶yÙm’Q}*¶ﬢ!€—›Êy°ÆY‡]Ž|ÈL-ÃÉÜ|à,)Qç‰ÞÐüÆ÷D­-}¼-ͽ©G=üÒK܇–MŸASáŠÙ˜}*EÛÊö¹YwëÊi #DAW‚ÀqõÓ{ýHyMZ‘j™*ÝÓ%2€5¨…Z©½Ô …”FÑ×ßÛVÈZââÎ¥òN ±„ý¥‰Žk|XæRÍÜ!·=–!u‰ÐØga†Áã>S¢¬H\ÈÇþ¼Þ#Â)#`¦”Ü`:S´C;ÄE±&ÿ„Ù˜XÉÅÜ0ª¦ÊµÜåYCq…è\  `Fïj«[ÚRbMÓý.ðÒ ½05×½T4WÁ 0ɳÛiõJÍ¿«H»Vp)»)`€ ˆ»6„óTÛ^[·ešÎ­±šÒ˜Rö6s tÝïQ.*²•_ò£ôýW€=€üsÐÈÎø]´E«¦!¨ßpŠ×UÑ5)¹d+9Ö,].žIɽ×LÈ¿€¨¦Äuù=‚ý"§"˜Ë½Ñ–äp…/`ЏXÕŒP[FÏ\óãÒçȈVjš¨Q ?é™Í#âRÁ…ŠÈÿkJïéÏ;߯d!vL¾J#†QxªCa»_ÉýÍlÒJR†<ï•Î_¼‹Ó59“ŠO¥à®!àÔ5à>%ZÀˆ(µi 0Éß«—ô!ºnX«‚˜G`€ ÒØL=–fåØãöc*qŽå+a†%“š^ÈZ¾¬^—-Õá“="c¢Š(Ú‡LÞdº_ÝUÐlR_€­ÜÉíÖË­Yv[`&ÕºWï’)ÁC<'Ýb™rWxU×…žÜ#Ì2Ž(ˆ×$j”PF $æÉ&ºáõf–Š(ȈnØÌ$áYék¾Æ+IO·ÞQzÏHì ùðåGndvJÁÊÇ-ÿegÝgy–çkâDsªPu€þ UÊÂøeêExÊ”Nî"—RB¥Tš¶i£6.` €Î TQG™è M"`¾hŒŽ`ôØqÉ;ÉC=ƒ8Ëìh>Ïç ÒXÅÆ\i”æ ·½¤Qzáo 3Àr(íÅ޸ƓþœÇ¦œíE"^\Þ„g"öÖá:bðå(,e|ÆÖ¼› ÚÕ*" —’¢“¢‡i‹‚p‚(p­^Ú4A5£ kÕ=5‰j’”‡‰¾)fW`†Ÿ!S&d·e jPu7¦æY'vŸŸ]-ˆŠRòîzmΊ‚|€í0Z†×ãý½‡¸Nû ×Uýí$ŠQ°àâ߀"e>"f~¡‰»ôÌëéžî›Üë”ÞÆý2A]…,+ìGQæ_oôN›©¨qõæábêQö†ŠÉ~o€œl¬Ô&úÕRv_üí1€ûÍ€{x’ ðÕ¦‡((ð?Ž\ÐîÔ^Ú\ÆxÅm¾‡õ&pÍG 7‚$*É5T€D#·ñ„dhÕ„n¶åã—æµ½ˆ*9^ÙéµÀÞ¨'ÝÕÃ,íµÇ^ÿÿt¨?"ôfôö¶ì!ÇôN†YÅ€@E&Öç|ÞYCá6霌Â$ŸÁr‹p\¥…p/oyóÛNQr‘e<˜|Lsï]sá^c âµP‹ 8êïIŸcæ}Ȁ󪸆•ö»A*aqºkˆ^3!­æ(GÜF8ó~ä·Ù¬dš¬;ò¸ôLww5m·}€Ífrl…\)~dÔÁ%›€Mº‡õŽ }È…‰€í˜BhÕ­…þ‰¢-IY‰*<W4¿)qQ7O;g<_äFöoì_*ÛVyfˆEq”Á¡ ŽB_uÍzñOÚœORG\G‘ù-u(ÁBïdÿ"Ƚ¿Lÿ—bþWð eSfò&÷ZedŠ~÷2×.p‚÷ˆ€¯–XÏòPÚðzpZæ 2~pa.õþôõ¨^Õ ˜w‹þ½­8‹­Ð õñpcâa†Û6¸² ÁYÞôTä=MÒöØY¬ùT¬4Ö£hôJfoû@:îñ\v'E',º{oùÎoàÑÍÆgý^4ßd W¸(AŸyí|È…Œ˜z@ýj!}GøZ‡WíSmΑ`$€€€«(˜£{_÷^czøYÉλÑàK;Q÷´ñ=L¾³eXó¼ûeÙfdQ!M¢~nt¬š‘6ÙÒrÖÀÒÇÀ…ä<Œ¢õÿ6g4ýyÐóÖ€¤luƒ\%ú¥uÍ÷y)¾€ `úÖ6pÒ'ø©x€p!ÂÁ(ùBDi¡p¡Bzô †h!ƒ ÉÄÁ0<i$A Ô’Ë–,¬L0äÈG5s„Ì!`ß¾{>HÈ'ჾ úéKªt)?¦úòAúª½ƒöB\ UëÕyé]µ÷A¬=z,08¢¶„Ú51¨ýwîƒ8ïâT«6̾õú†ù7Áà„#Œä/ãÅ„8pPo2åÊ” 3>lx²+B|ÀÅ ‹|õ(PÄÀ§ù¢8\èP«A¨ä¨˜cFA~ÿyáàパnóȸÄ–*´"<$»Tßg‘‘„ ôRÊiÒ¦KÏGM/5ìVöW¿Î k¯êUF,îÑÌ_âã‘ëpi¾e“]×Ù•ZzÁLPd‘ð G‘QØ`b"–Ù_®<ÆQ=Xâdš‘XXgŸ}`Pm¹˜†š .²¶AQEá=N T›RùГ›¼ AFó…Àˆ<ý¡Å_\yêe€GäTv¹•_ DèË„µø‚Ld¾Ôâh¤ÿÈDê€`‡]¨a‰”-¶˜.&¢†šbZ+® Áh¯åÃb./ªk³¶•ŠZA¥”H… n- ä¾çH!}d’Âät PàÊtu H`]:aðSPRˆì*ÂQ㢙T>ü¨IhX…æÞVô´7›e±`Ó\ΕV~&Hhyý÷@Rú(…Š:àhÂr$!G V8p…2(ª r*ꈚf6„©¤(/‹úä’TjÑ:Pj陬ϬˆäÓB?ÊóÂCvT¤±È~ôÂIÉ5+%C¼@“[æ ZÕ‘ƒ<ŒUÁwF…™T™f¢‰”y®¥;g¼ÿm‚¼óÑ7ïYø!X[æ÷_\×â…SÀ*ª°Â.ì@-ëŒß–Bæ·£ÿ°£È`€qƦ€’Æšeæf)¥”«.” «Ë«‰ðKÊ/>e2Ê)ëÂ=aðo®{  Ç3“A¸’ÒJÑE7DoÛ$ •ƒ è3õÔGù-™ãŽ‹n×mÎ9UE¯XdI5ÖÚ,¨ý‚Úk·ýg¾Âíç\yÛm¸Â{«ÏþÝçí@Ýž0ˆsF‡õ,V»ˆ“—ˆD2I‰ra90-… ²š•çh¥9Ή /‹E8ºä AZY „»%ùÌI*A_.ðÿ¹‹?B‹]2À‚y@àRÕÂC®å!ņâášš¤7/±Da,Y ‹¼ØôyÈ,HÛŠ&>¹ä‡@þº J"¸¿Ý-}ñ‹Pß—€…I Œ «þôÇ?þ¦v¡ QÓ•<‰$5G«Š€Ÿ׬V ?Jpˆ˜2`¯ÜLw‘ Âxà(Y>ãí2B! ’×!Р:™ƒê†ˆšøQÊÞPyM)WSšr®tUe*b9È×ÖôFà ŠjqbÛz‡Â)RQ/øGÖw°ämoƒqûâ™,Úqeô_eã±]&›‘{#fž”‘î°ÿtâ%ÁsÒʪXÁ/VH?Fát¸GIP•A ýƯ;qJÂ$'æÓ‰äMò$E Àð'_ SxV™Jäí0tÎã¡m*:«¸i–S¥}Òb/=­í@rñå ìRR“þ§/ ܤÔFéLŠ}2Ü3 GF „ˆš˜¡¦6ãSÆ5.¨<°§σš”ÍÊœèdÍ ŠàN§Á©îA>&2O¸a@dJr€zÄ-© ¡©àX%‘ˆ&+ô]‚ÊnË(†@Dò§&0}­%%ï[â²ÉAÁ K&UK@!ù ÿ,éÿÿ H° Áƒ¤ ш #þ»±BâAF1èýÓðOÅ?cK4ððo„Å“(Sª\Ér¥Ç–0c²LeáÆXòãwÐä¿xR2êCG{ñþí”É´©Ó§_B _- !24⃽ÁZüïD òDƒÑPPâ‘´Gµ®Ý»UÐ혯_…þQ@ô/_Y±5JýW èÀ½'„8^ Æ$9þ݌פ –R/ÿƒÌ%¾QøÖJýïǨVa·^ Т üÀÒ³G/Úˆöôê­ÔžF 8T2#ÉöH—žÞ4y‡$×¢¤Ë}tpê)Wÿ¬50UkÖ‚o ,K™ =©ï5«MÚw`„Ô†–G„ðžnßy0‚ˆgàJ&y@J G”=1ptÂf¡@¨¡6Ðkøt8Ð ƒéƒ[ÿœÀÑKÐÃÑ{¤%ERBý#A ,œÄÈ<ÿ€Á^üd‡…@ž4 T¨´—Tlà ¢Q˜ajÄÚ-ÐÊ@üäó@ö@!?AÅXcŒ ô™AùŒ°ÀˆHFЪÛÒeÒŸeÿ¹òü[$Ï…;ˆºTóu mm9aĈ”â˜Ñ•à¸DXP' H-"ÜûW³Ì×·ôNÖ 2Ô/~Äám"X§ëŸ O‰ˆŒbsÉœÄÔ¥Cànê Áÿ8`àLB zq€Møí.ÓAÍ€wèœ ,Sº|àŒ0ÚèQžh§l‹Šá ׈güÃ[oTW°Ä³( í¯€>ÄÇ$ $/½D% L ñ‚{\° ÜCˆF$42óY1B”ËÈn&žð‡„_BˆÙØÈIƒX†pÌajÄ, „ŽìºÁP T,{×b]BÀw/ðOjòÙÔ–Þó­ßäc)„á£~ìd³ˆ +€ê¤2º\f˜¦TÔ%‚ \ŒÂòPBTH „–ßüG" r¬ D¼ÑK3›ù.Eg=HYìqIíðf7ü@„z¶ÿ̦ˆBP¾¥X5´Õ8Ob ; Ap„Äá¨Pˆ¨RÔÒ{N|Ý?Ài ´}£YÌ–ˆ#«ÑäãA)ËN*@‡dÉ+ñJa’½~®‘ö`„Gö"Ç¡tbAâpñdX€È<Àb’¤ÄÃ'Å:ÈÞô¶Ä%<ë1Yçh¸žÑˆ%KJá {ö"SyþRÿ`@ö’9Ã0tr1CQT h•9F ÈÀãJ7þcûDÊNb6Ämô›ã,ˆ¦6â%V:¨#,êt´‚-9åRx$ì¥Pwl hQ—cüC CBêF.ÄaƒGb‘7ÿòԔ蹫ÂzHT<¶¢c€HMGSÆœ j¡e pTœsR ²VZF*¼±ÇžrD¬ 9…QŽz9èhÝg2{kOÐ&ISñ"ÈP†jD¤©ˆ@ì[ü„ZàÂA`À…S\”[,H†t(MºfH¡Žê!:v}"Â+¸»LRìñ/%"î‰e"@Î%t‰rØå ¨fZ¦ä¼`@àƒ´j‡w“ýŠRòQ},Àjd+U6^>UøGMiAZ…ˆ¢PñÀ C?°€T(’’RõàHYÈ n6}èaBNÈáÿ¡(åˆÛƒ@H5d½jh»÷4‰.ÃÔ£ šu!O H øF¬ŒpÑ œò6bz-·‰eÕKôÒ{ÀÓA ¨Ì¨”xäs" 1=¬LžÊ EÄc[©ñìm >µÉ¸WÉ7PkA†«lüCÇžrV°“|*娴éò˜‘-ïþ¼òÍ"°‚n'ÇŒÈÍW~Y€ ˆZ± ¡Ç<à“‘PNÓ §™k*¦$V±Fy2Ó²éËà-!SÝÞ9 " x2Õ-ÌZÊ\˜ ð#Æ$afÉ2 ð˜=´yáÚEÔÐ&äq·ÎÞ VÀ dŸÇÿÊ2gW{ÇQuLB˜|z`ä3a €ˆŠHåe™§¬ 3Y%ñ›¶–1ß·¼GF`zOg) ˆ•šäGˆUp§îàh8Q+£*œûÙ;gZ¾#­ÁúŠF SÊÙCâj¹±…Œk–°†5ðDZ¹­ð&[ŸSŽÈwE€ž¼)-ŒwÕŠê3á¯#h<–ôjn3€ÚŒÎÍzÊ]F;›ïδÕx!{™O2Â7¾áÚb_èySÉ ¡×p÷õšQWlsòp÷´e¢„“4ÔÙ"Ö<ò-'ür.å˱x‚|U)齺a¢Æ ,`äSVÏÿwƒ­ÏÌ߀Ú‘"HÂì¬ÿò—‹cø10 ÌüXи}3Dˆ óµÒeV^'ÅbÄu»@:åAb÷±ËÁ6voqhH”ÁJ3!kW&$³5?aSÑ*x‡UÁa|˜%ããbß²'ðû²e¡ÄöC>äwMs:§³5çÛ–V‰ç~X’ÿz |`Ÿ7eñx°tñKÿpyò„vì L¨)§y"p~awqtaq”ÅEGRyÁíä†E^¢´`D%.t‡VG”6'ò`*òÇ)Ü1ÃAÑžf)åfp¡ÿFpX"-"(22‰1°]G¸e§“[*‘1Š…W7Îöxa„c¨ü€V¨xå yǦ_Ýa? @…gW膸WqeQnk(¡_±C£!PRGò#v#‰v}X^kAj¦6†N…%O`rYYâbŸ6p~³-1h'Ð"ƒ#8¬Hl‘k'!§†OT¦¨ŠhUIhwû€V öF!On§·™gY¬n‰¨ŒÁhÊR¡†QL^1P—ƒG3uöQÇå=x-GYù0=q3<1¦I‘D7¼Dç&qt¡1ÿ`ŽÿѬbŽå¸2SšõëxaÁw™V§h"ò%ÑH²vF Ñ e$ƒReâ£q˜u†z ’gdâ¶qF•bK±bA5VáSA|$ÂGuÒ2 !~æœ#ù•*é$RD!d‰‘I½D-08yHÇÂ*Çÿ¢-¬‚;_n§ˆF #s¹qî©5'š8Á|ô¡_ib&Q€ qú%-·¥ …Œ¬±Xq­) ‘¡Ð%G0ò!‡ÜU‘ý‚yÁKVÔ7 ´23 ?ä)æ(£³A)s„£‰¬øWÁVìIìCµÿBv‰rûôE2"zaŒ€p'q~A6Ä‘j¦yŒf3\Ê=¤!údzL90#ˆ—1£¼@Ã8¼ÁòEƒó-¼Z‘1há{ÛҲʫúr˜p$ˆqá£C+W+¨ÈRVX©Â%ꦩlºû—#¢fšañ›1±? æ( AR’9pA{1£«‰;Õ‰U0@#´*â7ŠE^§Òüú>nhR Y’çH.&ª˜žç(DÅ^ÑÚ¡O¨Èq‘9E?¹”süÉL¥àÙñÛ¤(…RS%èÁê‘q²ô}…#Bi¾7‚,ÿsNó³Ç{^w˜¼£zY³“¾¡nèH^ø¸y«(V(ˆžØ'%Ñ[žx:z—=(‡¡G–¾w1*5 %?‹Áħ;`V_ìÑsu”05¶Ü‹)¢Ö›ø ƒ #.UË>qŒv­:Fiá|Ñ;0Ê3åx˜^¤Ú™#^¡%”Š¿d…÷ïV¡5¡wBùÅaÌ¡iÔâuÁñÒ2u2iÁ'3Š£8‰³¦oBÚeÇ^%Q  Ny QË>àß…Ë$t˜ñjÀ< å»?€ÉƒQŸ8ÁcY#¡„ŽðŠÅú6?Û²¹r Âн¤n“d}ÖW¹ ¡†ŸF(å  0fú°ê¦ŸÕ`!ÌEŠóX²—Ú¥rŽ? ¬ëÓ;!Ò¸’«¼Ô¤ü¦_¢,Güå&%7¦È8D]#²äªxÉäµÌëÀÀ³:‡43Àõo/;0'0‰ÿ°'Q]Ä[úUXý—pÕp ”ÐÕW(Çê®Å^§7ÑÊÜõEŒP ¢¡,øÔò˜Œi8±‹+Op8qêÌw¸l¸bˆ1´ð1Aª4ÁsA=ÝÓÚº]±—ºÿóÀGpAÜCÊÃGA›­Ý¾!qg,Oú0ÎÃu+1tÚ]ËáyÔ9C¹3¿\!,¤ÿ`Ã,e–ÊÝ™E+@ýÔ¢+Üc"ëV¿dT¼Ù•‰~•€ýÑ$Ãô|……-½-ãwl¨4µÃåôMì9ÎçÄ(?"úí µ,á· Á|Fñj*[£¼*'1ªN´Q˜–ñáäöwK•VK¨ÁÛ³âbS˜ãaã(B’E-õ‹P‡!XÑ +â!Å“ÿ>éÚÔè£cQP<óþ&Ú„Iã6ŒÇx¢­_ÇÙC ÿnã?B luÕĮշvl-þý;ÁQ„ þ P!!#… ç%dqb ‹%ÿä-9’ðÞ¿ (äð€€%–Ér¥É•÷F‚œ™²fʈ2=ÎÌ8p‰E‚÷8|\"/aÑŒôæÙ£ã_ #N8j > ÿ~Ü8Å¿¯ süC9õë …_1‚ÕøQÞ½Œ÷ÂR…ø!ß? ý[1k TùXðjJ>¦R¢4õÒÀÆ/En쩈ÏÿéSˆo |¨N{BžQ´7\M•*'U h9ÀÿGœ3c‹›ƒïÛ7Aæ®p QÜ3ÖÄ­±è?zèAœ§”žÂÔTGáÛnu`V †þy…kåXª'Jœ -5âEYÈhú?{ÿò9Ü‹HÄÞV@¤¯üG¾3ì„"Šl* .Éj²KD«p ø¹Î=CÀ!þñL!C>xˆ´ŠX£èúÂM8’ʲI%“J )¢‘nÓi¸–„šj&¡p£Ñ¸%zºG&¢J­µ4˜G…TˆNªyØs;|jñŸþù‹"±Î“Ñ5׌jѨž"ÊÏžô1„³DXA2Re;Wð¡/ĨAª$|,« (´P4ÎzÒÿ,‚í þ1»ŠÌ|ν·Þr¦âlÂ1¶Mꦡ8íM¦!]kn U©ÂíÈøŽRq<èÆk*¢¨\ón* ù s@Xô6 +;%+ k>Œ: >¶ªƒh³ˆLh/¾¦ÒóÀì<ÃS²„(™¬ÜýÇÜ µ,¡ìêDŠè„‡;³¸{œ55Ç#*É7àn³ TVqJhÈ{𠝉†É\µ¼:gýé§¢RáÉ*«¬sWîþä [ÖZ´í´úR,y¾ºå–#šˆž o \ᾌ3ÛËÂ3ÀÂÊ] ±]ËJ¡ +t»*ŽÈ¡i¢ÿ#гs6$Ø:Uè6•6 6° æÍÓáV]Âá"cmxâ© NÈŒèÓ4¡Õæ™Ç©ö¤Nh»„Âû§ê„öÞ½aïˆZFùÞça$¿òŠ3çþó+@…\Á;ZhÈDc÷Ÿ¥šðÐ çÑLWÑ(˜tC©N+ª¹YÄÍ_öû¥Â'.•Æ&¡æ“8ÓøèCVd•LÈc·ç:‡%ÀqZš6{…üU-Úóy“d"ÅÒˆ‚î«¿ýVt Ë0BÉL¨]’Y@…Á>’Q…+˜@~ª6ŸÇ äuãˆ[E#I­9Ió>òÿ¼®@';'@Þòþñ“&ôdmÆÃMvâ"«„8 ;陇 ³´«.=„E'ìÈXhs£„eqCÔÛ-þ±fñ0Møšˆä¿œ(R}ñW ¤­ýãJˆh"dJ„H]IÈ%èDšq}F!‘Èh‡™~í(9qœ ’8XG&ùíƒiAñ4“+Úm(Wð:a!ax”<;è£{N°%ïÊ^)KMð…,F ÅJjÉÈ—…>÷¹&gSLà?ðgÊ:å¯/†ñÓþ'(Ô­«P”Ø@Bp+J "K2äªÐ’È:*«AJ«Xuf†Lô°‡òq6 äM¢ …é· ÿâêÛ$ÈD4Ù±Gb)!­ø¶JÐcâË=!ˆSÒ¬l’É}pZÁüD'À°ÑgTI£·À<5¨P_x CIª[®Ù€gÀ؃q>aA¿ptš1wÁ4Y[‡”l.ÈQÞÚÐò:z8¡™ )@Vú¨tCm¨&™T¸C«¥©|ãéÛxØã¤,aii‘2DR°îê„–Ì6iµí¡…ó˜TàTÎ'Ö³ž Áç ‚F•¾øSOáJ̃6ËsIF^AÔðÙ™ÈË^„sÎÜ6e;uo eÍs€ùœKA/>dJó…Dí.ùÐG>\ÀÆ&„ÿrÈsõ¼V7×d‡{R Yȼ”I¹'G`ÊìÞV6¹˜o:”»ÖåpVO:a+ŠšËå?ã­=‹ã"ŒbLçJ2!ô!ØË, ¯©ØK¢NYÖ[Ô‡”Àe‚ š¬kÓ ò'aFNJÂ%ôQ3r‚~rÕ¸€.HoœðéÚ RUÅL £T§¨®Z”BÙ’“t$ƒ'p'°þûwv¥jèµVV¤-®í2!…cÛ²‚k]ãB®dÌÅ®GÑò2ú Phøé®“_…ãTGìvÂÔÏeRyÝë2cM‚´ ''Ð@TÚ‚–ž—½¼x‘®ÆÉ"ÿˆÇ]dÚ¸øôänVë(ãjÂVIœ¨Ëa^&•š#X”,S1ÙD’à#š/Ó²\¯Ø¨UÌmu*_ÍâTñ¹Ã¬2>ˆaÖJ2±ë€n̈¨Rê dZð brr‚¦ø8R{ÝÔ$³ ^§†´Ž¡“Rý` >‹ ŠS»¦.pze%e¾%IJÊU₽& d¿ã$ê?&–ž=qL-ß7õ‹À &Í< „­·v@zóTpJ܆0:LD3?)tE¸¶¤®*C‹fˆ.M¾êÛÔB6‡#:­N°¡Ã”„H‰µŸfJT¢ÂÌP'„½ÿ ²ÿ¼=hÛöà"`oÔ¦T1 r{·VilX§/WÉd(!€‹g˜Év>E!–æàþaUñì¥WT¥Î¦Ý—žå’sþWn„¡Â& Û“Ÿú‚ Έ€3!ø@hÿѨ5~`&Cª:ñ…Ñ£L†?UŠ=B {äcßZ~´^€«ã?ˆulz^ðÐÙ1#øW ðLãÜ c±*_T6MšM£e€ûG+Ø8¸ìÄØ#afKj§…"|}¥=Œ¸º³Ÿ)DP ¶¢Ól³h |îŸú\`î ®;‡¾@ŠÉ¥Ú£ö°·+u ù"j†7¼¡L9ñÔH©²ïÄ&¤ë]×}>xÿ?d#SEí€N—'ÒåƒÇL¥±å…—^%>éêÔ½›¹®ávvmzáÅ×VBKïÐc Ò§‰Dœ!jb" èœéÏ[I6 9•2[ ‘0éøÉvúÏ)"¨È-ëtܘ¯ˆƒ•03çû¯èÃ=å£ÎÐÈRˆx€@öZ2´>G¹p‹ˆ#ƒÍÐ$Øs*½±ñ¦žê,Iˆ ¸º`–Jr‹³xŠÅqJ™xA‹Ôû‡7Á|Š<—{¶øûPü‘“,B¥Ÿ1B× ·b§@¬„€(ªà’˜£ < ¢Š0ó8…¸Ž Y,*ä™;ïÒ©Iû‰$»Ó5Ϻ^ëCr–Ô詵&E«œõƒ6Dˆ<¬‚¼¾ðH|«ÿhC2ý£"ͱ÷šˆiRˆè°0„© 0“1¦ÐB‰ˆ œ|ˆÀ2Ü õ~ ¡k/]ÔÄ„à…Úª?±:ô›LÊ*ŠëE½Á4Mò’¯ï '¬b'º¿Úó©`‹™:¹:qj‰”ÿ ¶ø)'˜CÃßáEù“$ŒW¬á*7Œˆ¬°€Ö»– °{ňð\§}ƒ@‚„(¡sDx,8A÷²@‚SÂ7l¥äs5J>Û²Èÿˆ`>ŸA[Ù4B"7’/ÒðŒZðŒ/ùFˆì!–a©˜ŠJÀw’ª6éAM„“ø‘¿ÈŠ£K¬xt·Ò‡·êº è)8ÙÁï04/AF(¤ :¦¨”¦ÉQÈ2È€¬p3,Ãô"™«jCµ› ¼H2y”8ô@±#“K‹¾?Ì5›¸ñ]KˆÔ)ªüxFç3¦£`–˜‘ ꈎPy º÷I?\\?M¼'ý0ˆè£ ­3‘„G$Ó½JeÌLzh«s𠈀€Ũñ‰~9!ZË©x¬RÓD ®L¯ÿàE %‹ˆÐä–ˆà9rA¾ÿ.’Ã2RŒAÃHªX"èXœZ“û’ËïÑŠkT4nr hŒ˜‹§‹½”ÙŒ„“!P?ù‹*ÁúÂÔ ¢û¸ñ(y(J¿A:…¸DÓšôaÅY‰zø€¬K‚äϬÊØÅ„üÅQ«ˆ$Æ"ðËâ‹«„ð“ãTŒÍÆ„ØÔ˜ŠK«˜Šˆ<Üø>«Ádq™¯€Ey–y˜€àÃ|"2³±ùÂ0¤‡Æk×J£ 0ÐŒ«Ï«Ïø2}Œ ÑÈJ@ƒQÿ½ûÂüú‡QÈ kŒ¨”L©¤ˆP³‹6IyÄ…œNÿ"¡¡<¡„Qªhöù€à=ª {ÈÈe¢Šzì/— H°0« XlÍ…R)…¬½@HÊ"ÓR Æ8²àK×@µ´+#r¡ÕSo‹(JSõì&\óÈ¿ùŽ­ÒŽRªòÀKJÀ‰°ÑG<¯ðŒÄ€€¢ˆ™iÅÿê”CÝ?2 -á”FM½¸Œ1$“¬ø¸…ŠêÔ~é8@*ÛË=׈öJȽà‡Ùlµ"ãÅØìÕ\U8³XD;z€Ø®@X«Ø¯ M×€aÙ#‹ÿ‘øˆOzú´óÚŒÄ:Dð² …˜È !Duž©hÔ¼*ÖJÔË…(D„}«Pˆˆ€ ¸…9O•Á˜É5~¨EÎè:ôÊÙ®£òex¥‰êá« Õ2Äh~XÕ·"ß.•“ )K ´¸ÎáEV8MîC‘j ¨5ÿ˜¶Ž¦ “¬“¶q©Ìc<«*'h ºv,ÿMˆÔËË®XjójêtNÂÄúà^ÞË%ň&¦=:›ù g™ˆý0a«ìɈSÂúnæû‘á «j?EVØâ”̸cÄ¢ßÙÁGˆsÛ™nœ€,ÙÇflxfl|zìájzx͈n]uAÿ+L©öXlÉÄŸqBÿtÔð¿Vâ½]¾ ùToÑ&€ÃÌÈÚŒ»€@Kõè®ji>5ÏÉoÎKÐSNªhøŒˆÍ ÓU˘Rlœ°Ž’L“ÔMˆëóïÍTçŠqeŸD„_ÀE¬ªLiÒ4ß­·é ÑÈ\\ÿ,*µ¿F½˜ù<7üúÞ“S*2G/|¢ã»íZU,.\{éY‚öˆ>( n…Ø/|ð;€MÍHÏÔ£Ìô|F0ˆ_XsKÌÄRònÊ4sþƒ'ö=]l6"ñrZsz´åaÔÈ„žŠ °ó» ŒœàåÞ<>/[Ü ÿν`cþª¿Œg~:Aµv/ÍŽ)Ü : S…0>⣬ö.ãÀð?ØëÀOÖzØ£9KVâ•hù/¤îq57ªH 9¹Íw†G~.Ú¡ÌRöXkq½¸M÷sQ§.uUÿþÙ¸` ÂøV8òïÞCÿ$þ›G0ß¿ÿñËבß?ùÔçq ?D#ŠXPÕ 1aþ+òo…Í„õ…DØ¢‰< MžHøOàÀKÿ”&5:ÐæÆEÊû·džŠyô´þS10†=z1œþ34°Â‡Œc‰:%ÀÁh‹‡Uã†090mZ²ÿ‰@´ß½}õââ4ćºù>ÿ¤• ÑÑ›‚ùBFè2²^§¿\æsB/ŸË þY¸á÷$€øO‹Ìy¢4Z° Â|¸G =sMU‘‹¬hY$çÀD[TMx/hÜäO…#d*w\ —Èk¡kW®ôþÑð4BÚ¸-"¼·Z"Š›ÿz·ò@}yÓ#Ò'òf¦ßFÿ(—Ñb UðÏcý…T`,UÖ›`GÑæT"6B£‘µ# $_Q¸%ˆR>ùTP yóÌ3UBqØfù“M9J–BÚÑçÜ| ø’pJù`]B¼ècŒ1ŠEÞ@æ9Õ  ZùAAÚ­µÄ@o­æSs?JFÿÁ@]8Pe|ùÇ—€ò˜P^û1(§Y{I ~ýÑæß™þýã‚ g–I^-ÁiNá“BGÜãè?Œ ˜‹ ÕÜs¹öÏTãYK5á´‚KÈ%–v-ÄÔ5±©Qùäuz±’^'låyöðjÔBµb"†XJЋÚéõ\-pø˜dú1–dYKæM®9YdIR>~‹&· ­Ém;…Ë¢>. Dáxœ§× AQlR&$’E±a:Ñj›JUÑ w™Q;0Ptœ6<}d)çF²ú)œÿdü',Ñ–êkE©0ÞZ•w²S7P@,Z™Œÿ—e@Uw?Ò£FÙ‰n^Öö'!möE!ŸdÙ¥_n "„çc"Ê×F†¥Çc ¼ˆàD™øµA°ÿÜ2нÝÛ~”ZšW“°¶Çé?qÑs³™™‰ B ÿ õxôh@w;k=NDuzíºKÝ%G"dSAUÅ¥EXqeO ô¨P9n£µà?hùj‘všþ#ÀDÌÖ7Tw¹A†pFÔfÆ:šþ×í éiôϸAMÙ¹ïÖ^`Åî²äBXv#µzNmÀ¹Dr:OA·3xöV˜bÙ -°匴ÿ¹SOö`­,ÃS=ܶɃ#$¼…ÿÔª±R Á¾Uè å@ÐGIÿ¤™•Öw‚”øøä!É™‘(°}èCqë~.*; ÆwoÒKŠÊd¥Éiƒ©‹B@( ‰Gí:ŠgB‚Ÿdæ±q¤"%%!$ó8Ös‚&áÏsÁF–cÀåhAZ@¸RíOzñÄÆ.õšï\îI¸A™Oõ_‘…t ›Kub§q™AZ#×`ˆÖP(?ëÊE> #GµñŒµcМŠ .$'L®bÓpíÀ>\H€°ýƒ'ˆôîòñd¯9»™ð§Fp¨<1Ï‹A±¨{§+`B(6…±)HI,Ò$­D.ÿ,3:YñÈb;²SûÇ[˜Õæä/o­ËfE®ú2,Qšlr‘–(|€„$tÊÏxÙ%Ä0wˇ» R¤x(3 qB8D)9µ­(2ú¤t¶ò6‚˜L9ö`×âæÆ!¶DDÈ«òËú¤s•ЈptË(vd+ ñ$=/÷IOšri†`'{|”ćòct´w¾Ågv"KS4£}@RǸY™ jŽEi˜*ýè.½!ä ÿ D׌‚ˆüãbBHb,"•¼3ÊÁÒ$éQ”©ðÐöýDé®…ù‡ ‰KÈ8»]ˆ:SSæ'Dô½ ÿ \3cε•|ဠˆ]1l=s ÒNšEPå)‹ùpj[{R´!D¦‚Õ|hb¡dø+ k=üòSR!Ù@ˆuT‚HU{øcLôúZ³¸œ 9º‚‘aRä‚À0@6Ñç?Æ×„˜ý2.„ûG:eUTcMÊY­&%eÝÆ–Ë"CØÉçÀ-zñ*´pÇ“:M M}JÓèè¿à¦óo‘aàì•I§ Œ<ŸqÂo=z‰f4øHT¢Ð£¬($VR^{"óm¯µÙ»)Œ†ÄSaf­NÑÀMr>ËÆjqï# W÷ÑXPx‡àZ\j@*àÎÿˆ€™ê…'Ža!$¨^ 6«±ºæ-K*¥M‹‰Kgöpj¢…AØ.`À?Ê ¬„0B´Q²ÍÛLU0©ê†7ìe;RÂ"\ø(¼Àˆv$Фnð/ ÐÏûEº_˜Ø½öлd,ËÒšÅkºù3=1ÙVqþ¸Î±%·ä D1„˜¦uÌc¦H9mÛöL{Sy´–mt1 r¢èDžFò¸^åràó…Õ)>`p7£$‚77e)>pAö†}ùÐÁ&ËÌ䃅`#Ö*©¿¥Mryχ74홇ÄT¨*ººY ÿ’=â;? X%L£!làÛ»‹ͳ,¡r "Iöäv â&yº-³ø@äaÙÃßFc¤$…„§™Ì‡¬Kyà ²¶²Q,#ãemÝ]ÿ¥-rz'D;v ¬Ý"Xƒýáî³YNh‘Ga²aíi cå@ {5Ëä=ÏÌVÒêÇû¬! ¹ÿK·»_ï°Fs ݰ*ÉPo”ì±§ì QEâªÃå¯Jç¹ÿP}wÓù[ Å~c¦2Ï%zA¿°  û+7íAòüA˜;€U^“je2äÉ´í|ؾNþæ’GHé£Jq¶79âëÑx.3 ,$¨Á%&ð£Ðw.$YynJž¼Æ-×û8ÅgLÖ@¸À/hL/¤B|L ÉklŠrFå‚að/¸€@p™M(ÅBqœÉDÜ?äB4ÁP„ÕVõŠÈ Ñ‚hÇ OÌLD—€Á ;9Æß¡K6 žaÄ÷µ<¼ÛEʧ11ÑSnY–!áˆ›Ë ÿÑq¥YÚ?Há0 ¼é…UÙ[¤…ªðŸØ¼€1µ^Å€“>G‘¨Zz|H¡O\HK\FB݈ªeœRÖˆÚÄ/ÔÚú¸@üÖˆ)È~Ä„íMèˆ EŒ][½›äÉËy mHWÒüà •4Q‹a/Å”ø°XE !&ÄhLšò „ {إ܉ôR\hDðßéÅÁÄÍý‰ÙÈK … Ä™1ÐâÔÄë¹VGÆ9Å(/˜ŠÇ¢yFÞ ŸÔ@YPExT @@\¸G L@d—ÒÀÜ€8ÅF(Ó\]¬`„FÄV[IÅŒìÿÑd”´—øÄ]üŠ@(ûMáB,@½0ÈFð AO܃V´ÔlE€:Ûá „Ç¹Ï%¨¯ÕŽQL´Ò3ÙI2£u¤ 2nL/üa ¶Ä]Ì%B([7Ê LEK öÍØ& m`EÂÙƒ2•‰-fRÍÁ# áHÕäé†Qð®¤[i’!-3ÍÃ=ðÕ€]avdO÷HÝ $œVŒÇp“üBôB—)uPÈŽ2!ºOfÄüøž>Ü + º/ˆ ùÝQ œMŽéÄZrHWe“ÍQú˜¾ ‰>45i"íiGàÿb¡Á¤^lÀAL>\å €„Öt‡¤|e¸ •€aÒ!Uþ@VšàSd‘méa©¹Ë(ñ¡eLÚÅÞ(EA4šÊ%á`­!ßhHÀòå"¶ è, EÌÌ?üß#N„<@@cȘÿÐTlH³yTL^H5HÍÔ6ÒÞ6†›TêÑ…Vâ†ÑCUÐC,ˆ‰ –˜bmÚ²YU† FàRD(rñ¥(YÖ†N­å…(NB(EǬýZ¾¥u@Cðý‚rØ@„œÈEϯŒ‡WðÐ7R„{°Fô…Ä·‹w†Il]b:…'ÖEÌÊo TxÉ0ÿÔ=åzfOÝ •%Ü€rDF”V™¬ˆ>ðƒƲ™RpÑ  c¥!Ä+Ä, „JÍ)e#ìe,='T€“(=§uô¬Hç?½EZè V´Ef8DôIy¦´¨#´m“Åä@äOHt4i“&) E0ùܵÕ~æ× äÃö8A81,2dHtDÒüOHŒ”ôb²â$‡²¢p … 䂃Y˜!ÉÖEa¦Ç)…ÇÁ×ÀAé?ü€ü¶DIœ8E¡®MÀ8Å=äÀ?hëè¼F&åw9Ÿ˜ ¥ú‘ÿðÆÌXî((YÜPQ0›F|€4™\ ¼ÅÏþ,Ÿ D@Çþœ@ ÛQØkBœÆ„ÀßDA´Ë•®…—–ıäÆÑp“a¬g…Å¿õÚ@¤Û%P‚…m Æ(¬S0E¢pàÆPÇü „ þI"ì/\ €y€ìBP½1,âÆ±Å@a+ÊuÑwŠ O Ál 4¥OPn%eY•U­W{pÀ8ÿÓOÜC ˆ.*‰•&†=€Ñ!ÊÒäÍo‹)u©à„—â¨Sà…a9…‡š-YØY æõÚÄɇÚ/8A„UÝf$‡@¯†,N,Š,ÉÌÃwØ•s˜:·Ž]8^U <c¥G2Ejft>Ç?xáûzU*Éúž1X !ŒôF?ðÍo Ï<\Ez°&ö™ÑI]HlžçºŠÖ…R¤›ïòn¡aBì.ÇôrέS$ Ç©Õ’…¬Ê AËЛ=îÍúOk4ŠkÈ`óˆë^žSèC¹¢ C†ÔGy+0©^\œ¥tÌÃY6ÌÃtÊ2ŒWÄÔe¤h<ÿÚxlÄpSÜdmíòDíBq¥ºQ¥ö(V9ì@¼ÂOÅR‹[šÛ+r.Ž `MXÍʱþƒðýC<¸ û}ì? ËE-c˜ð!rÈi¯^ÀŠ Â ;!Ó@ œ¯ ãÎ@|KÉRîÙÌ<_EYØ‘…&šB¼1ä ÿúÛ ×†—ò?ì„ÖôGÖ¾‰ª2H ˆ@/pqÛŠ­^,”­Jª¯©²º‹—ónL¤2B¨ BP/A˜p:• –u£Ú¨ ;>›I!º(ÖÎÊç¾µ‡{øàî[UàèúÍۤЌÄ?µW„KD½„ìðƒS114EGÏ Bäþÿ e` dWP"äá“[GÜ /+näRÀë®ÂârBÌòæ‚ ¬q/Œ/˜À@¤BBüÀ @†°SÿÅ fƦÜ0ô¤EŒQ_üÙ¸üYZèqâS“ns)¢’&æÝ ›¸D½,€¤¡D ñ¡’xZ Ëóõ‘Eµ Äž,pÒ`„»´‘^Ô ,¿D,½YAW‡^DQ°&Ÿ*¯»XJ´gÝ.#`‰1“—|4ÌŒÀ8ZÚ^L¢v!Ä‹†½ÁcbÌS÷tsé_ÇÅùŒOª=ˆÀA"ñ@X@T@ !Ù¥OOõlÑ …8MµXߣ™‹™I ð„@@ÿ¬^À%\JpÆÀÞæ¯.…úÀÝ"Deðe¤¼ DÈ>ë@˜ÅXgD¹Y{ÀMÖQ\kkw‹‘ \çžRã*oDqE _;Ç/Õ4B$mWè 8k¢ ‚×vÓöíQDvº@Æ/J® ñj»,¿‚;…*¸eu8/iÉšnäBÍ·„fŒó2Z&Kè?ØD°H¯!Œ ‡lt!Ê’Õ$D(ÛØÅx´>”t"“”\çÍ¢ù9`)F nª‡«Xb)ZÝ‘Vf Ò cønýŽ=†ð¬IoT»\H*oÐAeÈ/Ez³¶@ Gr ó²­ÿÌw/,²¾ÿ%ÃBtBK×,ɾŒ§ðO”(˰ŠÅt´â:El¬g„3È\«2YМÀîQ Ó‡%§ÏS&Äœ“Q°PÜ× lw†¨kŽdûðæTŠ÷ú°ˆqªÂ}O!Úz\Cïw`žm|ãa3|cäšõæÖ1Eù@ÔB³™\ÀÈ®E ÛCñxJ¤xôk 5—ÈÃ0³^Èù[k¢íË8U¸• 5á @uøù`r@éÛÏáJÄZÀpé¹Y`à]:Ö†¹„Ë ‰MDõï&´­ ´£—­Äéåµ÷‚âhÜ›q À Gz{;/øwðB˜€ôZÀAj´”ÿ³¤èö@°ªoÇQu[ûÁBÓž–QŠDv Ä`êÏ’ §æˆÃE‰=š©Ê’VbÄÜ %ÄQ&ÌJYˆá ìšKGØxSÿÂÜÌk[{B_XâlLºõ%}×Y¤kŒjËrS¼¥/Ù@H¯mÌûXô”ÛPýTŽ Еßþ;© ‰…»ú·4P>ß…¬¥ÕË£66w\têä! ’˜Çe6ix²žì„#BZµTÐÒøÉøZåËŒ;‘=Ãå/DAA:qÚ„ÇÙáûøsÚ¡r©vˆªdÊg†-t@,yi¸ß“?Ù¨sRþ„"Å~‰©«ÿµÿ´:îĹVKm„U%Æ´ôb¸1í¥ŽüF…ÿË á× TÀ…(ؾtŸx×ÔýlÑTÖf©àpÓ¬ k­ “ŒRÂŽÆü=Awh£#@sÌß³âÍ;…-С-EiÝFËм öþÃX¸Èv”Úv¸ÆÑ»/g‘þ “…K=¸¼t$Èa™>bÔÿCiyEä ΄½äµø÷Þ8èðß‚ ÿ,ü÷@"ÿô…8…¡>† ‰éGQ²L9rd ƒÿœ€„é"—˜ÿ\üâõï׿"Uô1òC—–L ӓѽözºSê¿Freø£ÿC0=¤wpÞB„ó2\"oÉ=yÿîÝ£»ä_\yv±2Ük‚½ÿòé™/ŸŽ üð!ß?È’†ðB`Ù³ôNœ­ü3áù¶À;RCßVü·¡bJ%?„8›ë_®ÃªaÊΨò IÞÿ<{¦¹sæÁŸCÿ%Úœé?JW½zÐ*U¥ÿ|D…)DêПLØ2³¢¡ &Œ¤ÇH`Œ1Ø2ü`b/Oû`i0È ‹ŒÏ|ü$l²Ï( a0lË Ì8¤°ÃšIDÕRZ`$|&rH¶’ô‰, Ä<èÆƒR*É7S]8ˆ˜ëË zj*`U!}¢ÒUŠŠ²JU¢kŠÕ´“Ê“a§:¨K¬¼ãÅ+®Îã ×ú`M5Zó ùJ…üò;á„%ÔêïN†ìš+O˜2pÂA%ˆŒPAuìAÐæµ§E|ËÂì2³ò:hÒt%²`¢Š"¸áÿ%R?ÝM8Ss n£•Jú‡F“², AR$æ’Ün'+wzª)¬¬:;+¯©¯òÀåZ,Hq5Cj/[¶è»Ö3¶:¡[„æ‚‹¯ÿ-:݃Nc¨,%‹LÞL 1yK¬¬(>ë ®Ç⺠¾Z q¸*Ò4ÅIi…V`^K’ø73Ò§¥VCr!îXÏ 5·‘Šr.ÊK|õ5פŽzêº`¿„ºa¥¬Žr,*¶ˆ.:ÈY¯hfÈf<«‰Dt²ë-s“þOtÏ2p^@¥,²\$˜ðêy{ŽWgÈDŠ^‹aŠÿO‹#.GÃÖ[Hÿð% ¿þð’“yª¨zñ¤:[¨Zª;†êà|åž5<á§÷4ÓÜižyº Ú¯¼ø³Óh˜ì²‹ÃáˤîCô)µan—ÜH ‰šÖ`Ò‚y´€3# XȆ§L¤`Á©Bb’¸$%†©XHæ¦V]ÌAqÃÍNtÁq‡)×Ã!oªsñ)e)ÆÂÒæ¶TÄñ€‰!ˆV-ú¢­ù¤rB‹}Z':Á…huúîA€x±‹]„‰OWû̃–éÓ¼Ô‘6>F ’LGþ¡5ãLql™GjÜrä çƒ9ÛA–°¶­DG{:"P2½ß¨&„ÿ9H@’ZýÂ¥rN•„!¬¬“P‘ÜT¦tăˆ¶Ùwž‘´BèËšJÐÁ)„VüºôR§¥‘! @éâ?aþo—k!h,C¯Ù=íA ‰ü¸±ý#94Æ Œ¡Þ@$4s ¦Dpƒ¶µ-8£" GR(±– 2%.€ž) CIž¦' Š £#¸‘,e:ÛCY(Gb"ÂÄe­tÙH.@¡`‹N¬e·Øb-†øìŠ0AW¹ÌÅÅ1‹d<ÝO'y܇ôèЄ¬ÆRjºÇ¦Éiî1©%à wä l^33BBD HXd¤†<º Avcdÿ ×¶˜t.L’<Ù/J…Cç0”œüQŽò=)¤[ùI²œ•D…Zd$f¢ÌNîs‚Zî+t¢Ë\8º» ó‹Â&oÂHFýiÉ`!yÙdBõ)ÈNø0lþÃx‚ȉ†7‘ˆ4dO'ÄÊF œÞ˜$’#1É>â‚"rNYjwž¾0gXÞ© øœ$ËKæiC\‰°PfkX‰bÐðç&(âç/qy ÒÆx×½S¤§ã"1‹‰µg4ƒ¡ Š–™´@¦þ:]Àr(ðf„ q Í‚U<’h+ŒIKPU«àÔJ8x³ä?¨z_läH½PE”Èÿ·$ òÆIXÍŠv¾§óe+I4V’Ø&Žéj¥ þFb?²õ¬tùËâA¢;’.>7¯ÿ1ŠMŠ Ô‡kË|)`ÿ•jpi0†@à “ D€`)ðŠG#Å@m'HeÉ};˪»9õAö%áæx²ª_8xd% ÖN,ÛOîÀĸý2CºdÛt®•IQ+RR5Ù£) [Ógüán-Ýâ˹L¼E½þƒ˜Ã,ñ‹&è½Ö夨Dc}¤èݶôE mXÑŒA> h„?°,e/›0ÑFÊO^›KDâιéM8 ‰B.\› É”@ù‰•nØCëm9:9”m±¾|ÿæ<˜Â»Ž|Z&øNNóxkZØZŸŸýe/þ!i_HF¼ŽD¤b)1‰Y†€7Ø×L>ô!l*¤#Ò€NŒã»tó,1ÆÊÌ劈ÐTó´«ÂF"UÊwãGó°‚AXëHmhÚ ±ÖVIºêÈB¦¸R"kÌ×ÊB¾/‘çKc’ÖCå=çt)Ö\¼Ž Ír3·˜#ŠÒ„¿s@×´¤² Xº»«id— j¬LÃÿÞAxŠYD¼ª0/”¤H&¶7T©$%ó,ÎVa½*~d—cH±ÀæÛ6*aý‰+ÿ¡Ð4›À&ø\†©µ“·ÂÿDMóÈ›°E¢©Î$*ÚŸ©KèA¿¼ð;™”éò@»¤{ –64¶>þÛÿ(Àï6 éõ¢…žî7 é«T»‰¶ÇȘ[s¬DAÊ ³—¥2%)™YåéŠÛAN‘°æ8SW£‹Þ”ÿÝÄ"íÖ/ €a:Ÿ ‹ÌÉX4¾x1ñ0±yÏI¼z³ü| -P×àØÄ øÚ¼j60Â¥cúüx—IŽBSÒoY—d>¢ SIµÀüúbá«ÆZpðäq¸ã(ÄŒÁÀÇŠ¿8î¬:n¡ aä °â +m«m ‚FŒ†i¯š/ÐøJæü‡®üã,HÿZæØª 5˜K2O@~S6­5tpx˜Ž#ø!æ)ªì«¾^"A#¼x#Hk$r7pcÕð(hdÀ,d.g(ª#*ŽÂ~M(¸b+ا/B­„7lÉ,ÚÄÿ~.Â¥[¨KÐòJ¨ó$lÊÍwDûΛpê®üìÃnÞF(½NÄó’Ž!À…RoOP…þ@Ã/Ë `­ …E~!…I`¢T¬ÄJÄlJª¤¶('ÌŠ9Äp'ÖÇ.ìl†Zbñ=Üjøb~ä [¶ê4◨빬íâÚV.j ðü°RˆÎÚ€è¢ÕéèÄD'B{&ÿ0E8êï…„zô&è¡>Œ±,X!~“ü+(4Q'+˜pP«×þ!íÂÌ|æ±K¢ƒ`fÎÊíFBmg[ˆï⬀ðN@B Ð@¦dÊÚBúvN!íªÏþŠ7DDÇøhò0O5œ ð &p0"Úï 4mÅäýxЄvG.Ad4BC’B% >åáòááHÀžÃ(ŠàªD€ªp/â€íŸXˆÀçKP‰sxï<Äð<,@áG2átJ­( áJ@îa)Rúº˜˜A~uvé¤MæpŠèRc›ºÉP`'ºá ê³V#"$â²ÑyI€†ÿôæ…àŨ L³`dÕÇ ý«'‚‚9TAˆd (od(® µlë2ÅL“BìÁ `Á =®í<€f( Ã.ð¡¶j!˜¨hHä϶ +@¤ ’üTO-ŒQ@d`'R‚5ÈD$y£{z‚UNèEâ/ãÏ9G…&áeH,ñc (Ìl(D`;ÿ‹‡²°'¹ÃcFâ;„FàKÞ®ãþ!î|A„Ï6óƒÃR˜Dji„)"ã³æ†Æ>,­KêѶ¥R’¦`‚„SpÛïƒ>è¤eÓ"ÀÔfêù­ß “yê&(‰ÿ6f3Ö*‰b2‰nE(€²ÿL”ª¨ &Š€„‚;bTFW |ì\æ!¾$äT1î~t$¤I?FO¨ ¯²"‘TYå̱Ԓ›’ãÝâó%n DRLr0–ÎD:ïDõZ¥Ç4†# 6o,nádå,,qUL”!l˨ªVje2±5®¢âF ÔâZ… ½d' *ÃxCÙèâ`.ÑÒ‚-4°//ûDj,·ª¦øCΈÃÒñÿtÌ þÓ6õæ@ ),@AU5$¢U;O„6€&Ë/ñÓ0”7b%VÄ‹1œà„ú‹bZ4“ŒgX'³E¹“~ 3‘Àâ/-lQF=Ù³=ÿÙn'*à„”-ã¢Ìåú¢­˜m?Rg$²/ÑìÂùpîw”+/¬k&Öð¦V°-ÙRÇÒ%*àbÂ"È$qA•VGR"$"Fe)n.T?GÅ#v5z#ö¸Ó'Š`ŸxaNùKætX[T<ÄCF±¢;Ø“3Z@•=­5´^é d)øBàs$X`Ïæ¤SˆNr ÛôÊ>Il’æNì±Ôâç*i"ëÂmÓÓÀâ8_CA6`_c„"ã/%awâ:ë$`„oVEE¹“¿N1öb)X·löxa9.‡øa?èŒBÎ3þÚódQV–°°BHI ÿf*hœÙ”¦\EJ¤ˆFGêj9ˆtúG\Þí&Å &åh‡C9‚5ôµ¶ô TÕs-«Þ:÷.'4þFoêR¯OÒåSbo'–§¸vûkN§ªu3öli(¿¬èA?òCÙÚ£U")xG F tÅ$t‚ï úvNÂËŠö¨[Ÿ—þçð:ê ”O|IÎVPÊ«IRHäÝNÃ7U#Fþmbs¯4,²tL>H"4M":O¶ ±L§Ét+ð¦ÔŠÕ¾6§ª´S9.V'GâXK€ƒÕb4¢[4*Âx%˜! @o~K1#yy,çz÷ÑäD—ªæp.úª×6ÿ!þ¡¼`TÃv&@5O&A9©øÔW锎LJRu…Ð|'cAlÕ˜'‚G¢l)6äàT9^ëË!ävoiC=S[¤%y á·T!ή/zãjiBª¯Æ(?QX5]†a.çxn Ê·/Ce§5þ!F+ö¢b²@O©&’X@ŒÕk3I•T„Uc…B"÷[â¬~ªwvF5*ÀL$x†Àe¥é\á`âJ@•Ñ%hÄE®€ &NXq¯v«†!yƒ,˜j1—Âbs,R!˜M¤‡?wìF餇1 #Bèr$€˜TpoöÿÀ̶Z”T¼à< wU¦ŠF"I.« ç®å‹#ƒ-¾uÐ A1S‚ç$ÀvZr˜Q#u'Z'ù`.€æ–¯6?3U@l¸‚Ð$šê¢ž)âýƤý`UU/‹V×1tgˆ¯fO"I¾†Ã ³„| ¤¶Ä6 8lÕ”r·¤ã~0™ æaoYÀpÿv$†à¬”! þA§±Âž±"¨ä²²^ŽŒæ0]Kx ŸOª.‡!:ZÁZA˜¿b`ÛohôF`F1„É`g'Cžðx'ŠÆ,×À¬/€òM=À‘5’U”=í!h50ÿJ`ok¦1@r "À¦aétz¦z$@ A@‡Gâ^@£übiĈۮ—İwR¡ú†!ñd¬E¢¨)€5 »ìùªS²_bÎx £ß¸æ%uãË6/NwKzm嚪´9XÙób¿ä”V¥¿B€Ï HIÀ¯ÿšÀ›¤Ž@U²1ìº/„ —¼Å-dê¹ÒÕ³öÓ bóŽ¡«—¯[µû”½tF(F¢þH& jð,:ý‘ª*šE`l«rR¦9TÃX Øðæ>Q@ÎK¼‰ôUÀ3™†=>@ô6w'F ŒwAà£]@#äe’P(dÚ~’t$BË’d;2LN©ŒÊ" ^䩿Gêÿ¾Ý-|o!à`ÞÞ±õÖ‘ž!n½ˆ~»7ß6Ÿà~+¹À =+4 ê¶G<ƒDÊbªa}︎ê2"¥k0ã¥ÇâÿùÚû‡0á¿|òýÓWÀICô%ñO„¼0òsañ_<Œ.è5¹÷ïž<”ÿ`h‰áH‰%ÿ‚ü#ñ ›, Œùâ… ‹‚(Šð(ÒH–&¨·4ªÔ©Tÿ ¨Š5ëRc ¹þ3¦aØ%KÎû'BB jÿÝ@XA!£%ÎÊ›' ƒÿBØ ‘0R{G±—ϯ_¤ôTü£gÏÉAz’+*ä5ã?ü6;éÂC>{Mšü;™0ƒU#F® [Â, ‚”Àã߃# S šªhð„ †ÿ ~”h„Ë•2]¾ô…<­Ô¾®Ž}êu°\5p5V¡égÿýj+QÛ„Í‹Âçyù>îûïoQz{#=ñO ipBX !ÆPg ¹g.|FÑG µqÚÿ=÷,q\%À>å°ÿ`à@l5ÝAKFäöÒ??ø¶”s‡TÐ!ÕR;Á›VOTçavB.ÞW‘…ÔäÙ£Ï I`H+B!—{)aà>aPÞBì –_ü‰ fB]*t þ£&Y-¨ùOX•-ÅC )OHÿ`hÚJÿpðÏ>û€è?¹µtÄNĶÓ9ˆ¸Û ÃÑx\qÎÉ8Õÿhš< ÔãSé j©I.Ѫ Ýs«'ð'>|Àƒ@7P€HB'LgèU pD†ä#Az"dSHÏ«¾ íip&DdN04_Bxù`<ù@tPÿòˆ+n†äp¨ˆ¹‰ø0B)¾@º9ð†©BÅ)„œo4ÖÃ)À9"õ©©\•iá±Ê’x¬žùϵe]-åૈ0Cß‹C„Ý·Ô<¾Ê&´*¹„<'¤š2€m„E’ItØÍ5Äs¶®„Ò=WyHt "zxo8%TÂx¥ÿ(#qRÿ°BWõÂ2 ¶Ák$(Ù•-€ô6(tÁ¯¢ˆÌ—B!VæRôœu™òZ–ËeØX~ÊæçD~{m›ô˜jŸÉóšº æFèºDŠ95š›OUUTpÆqÊ)ÿŽ$ôB aÏ>ähÿ™B÷”ÍAÃE9‰PÜ ÑÝaç%ä“wÈ ¤__kŸõ÷?óüÝ,à ¸Ä Ù®6B“ONí?wdÏä-3®<ò7â¹tŠ´B9ìoÁ·©vRþæ»ÔÀgE‚üô+ vv‡ÀÞýiw¹C‰iÒd ·ýcÎqÔRV´`éÅX9ÖòB¬?ԛʲ¦$=ë+RÈ÷(´—ü@?ÞiÁJZ é`ìPò ¡ÜeÐ%(¸1ÝT¤&£¬å)Z •ŸH•Û­aJ–à„Lx­A+€‡ É/ø@¬¾Õ™:éé/ñžÿ=æ"•y´H¦9Òˤþ¨€f‘±…' ñ̃ÿ`Á pó¾DvnP9À@ HÀœR7S±ÔÔø¥ÖamSXÁIP Êì”mwuœcÛBÁ„€1P› ‘‡0·é#.!Q>ÒFd‘L!€›^Bx¥½`ŠkO É£þѸƘO!ÓIS! yVnŽ•t+ÔOJ@œ”€ª¡Šê. N„l“UqÅÖ †Pª)¾*Êî¤X a`^T‹+ð¨D²ëúø@\‹t¦Ÿ É¥~b€ Ì#,ü!öŠ¢¶>NF €¸bÃȃ·áaQ¦i¨÷¹+Q©IÓ*ÿU©ýU SšR"T4‰s®s¦ YÃU8à+×XÑŠ¥dA àÃzGñ"ðŽ–›ýã¸eò‚”Ñ Dq}k!ž•Ãi)…:¦cîàp’…lZþ•øµ’]íŠT Þj“¬PJS­§Tdúl €'MÏ&@qžuœ¤!ET0v•ºÉg»^é6YýCA팱²õûP @gy“F’½(IMj ËD§zPèMEúå švEŒF¨¦‡Ø…¡”*GA]Br¤Dæh¥®@À–¿¿þ ž7å@´Ñ’¾ ¯+.q¤$%„Ñ*ÿ¸Û¬nY”ÿxÐ!}“ BÚ5‰…bqc⼑8ÍT„ìÑd‹”G±2!œS+%åšÉ°ÉÔº¢â+úªÜ¨àW!ã‘Þ{žù€ºªLJ+®öÊ4õmA„>:“+e4b ßY¦Gžzv½Þ3&eúX€†¤ÖƒãUYGô—¼ö‚ƒb+5“ÊߥÔRÈI R@À?qfǮЫ6ô'ÿƒTÊ]°B¬ j!Ä&G  ¨k]è,6!÷DWw—jÆ…+m™ sb6!Z 5-C*²­ƒh@@- ëR[‚ã¥6M·=ä¯"«™:K^-! 8Êr4ùèÿ%¤)õ@B¥ëa×¼Îÿ :dÀu<}`+/…I˜~}…¶5¥¨`Ì+˜]¼£\8iʈ~K~¼ÍÃõ°‡¥k{©?ü£®ÚûªcB†!úÈS<'9 Ú1B™\…°F‘ÔœŠœdánGK”ô¦^Š&… KÙÂ?˜àˆd¶-õÏ68B< qÄð#¹ùîkÐAÁÇvê¢m6þÇx`N÷uãN¥‹~SÒÆ€±Rˆˆ… U„ä²(!PŒ }é½l+ñƒôÔ‚°ŒåÏN®n“ëc¤ˆÈ©»$ÕjDέQ¼(ÿ˦mÍ”˜º‚â™®°^"€átCÿ8EXÅï„´€ÏY_ÕR^ƒÓ°#„CRɶ€8¬äNýãSN³R~ðÅíPhŸ,Rrµ¼c ¤ !0H˜þÒо¬|3áBD 2±¨éªÓ¹GLiÈ¢8ñ£ùíö¡Ššç×)Œ.7FàÈ´é\;B2 €Ø.x”EišêøúÓ4Á¹ ̾åF6ÙV!(iAŠœ‚!,*<À낊Êù†®8ÂZÓ’‘ë=ä“Õ‡E>V½D!‡ù䪑$„ù¾÷ ”Ñ¥N'6G˜<Žs#['•‡bì|UŠªy˜BÅÜþCº8IOt Wc§¨v¥Á\Õ®ÿ §ñ'¨qeÔ1XKj1fE!@9’m—]_ä€1"BTÿàk ákúÀkx÷ŸYKa`"À48‡^ÚÓpX²%4÷!ó9•_HÓf„äDNtUdci“¶¢GO1Oq%odÇ]¸Ó0çs>‚QÏ•³ç€,Á~%E»÷'àx(Q¬6ž²DÐ1¸0ýÔOÄ2} ¡‚Óç×wKàåq4hˆ9bÑ,ôsôà'A–GpsòÃJF?—d„ °‰Ðщ›RT0¥NvnPAid6nâvn«ÈY“¸q.H(¦ÿ{Þ'ÂuT(†)¡@¸(UXÅÈø“mˆA!OוD©HÀë2vð6ó‡&¸¼Ö‡ ч*è ˆ€}šÕ€ ¥&ާ%í”m†r‰?X a:‡’ȉœÈhø85Ö¿Å9Bq”WÅEi—–v䆄Jæ¿Â.²å;{¦ZÕÒ EccÈ0¾h‹ì4ŒÅØNó6o-"Ÿ”ÙN9z 1®ðð'"¸a ó-¹¢‚~ˆ½öa#†jô1Ö7œ¡'ùð‚qb2l+q¹¡cE‘\™øƒÕ"¸‘Ÿhögdýø[šZsŠzÃtEAÿiOñŠð4[ÈL|¦^’C’Ó€ ¨;o™áQG¾sS7…?JùIqeqK´À3u•Á.Ðwàø-æa‘˜$“á%ˆàùÙ" eL¯²& '‰•G‰˜sO Rú¢„öÇ:á&@@‡W 'ŠSª‘ss ˜Lÿ°}N€›ô@c¯GJ(1.K1p¿$„vz˸võ@’RÁ:Íçé2vóP‚ã‡Ü¨˜VKrHaK4€Á³)gå98†%·æŽ A¼Q/a„ð¯Á>Q­‰O¨IzE"ÿ`ÄÅŸRHtôÉD½RÓáY EÈù°ÿ}6Ãd¼c{ºÓ;€rW÷rHÅYðI7’dXz±ø_CcÁ¢‡ME“3ùqÛhw6ˆkÖAØi?éÇÆPfÁ","?¹5"Í)„ï *?zžf*ü#iD@$r'98Aõ ’×Ó€‰2¹ð-XQ ZZ÷‹ðœ9ó¡ÐM§÷/ð)]$%‹ÖypXâQ2"! vÚAuW –0Ú‚×™“à2#·-@C8È9çùgfæ’¸žc(ÍižV§Tá$*öR9¢¤#r˜æ¤@ÀÕj—Ó/ ‚Ñ8È„¹°.°›‘›c¸šÿ@¼÷€qæ ‚+¢©)TêEÎ!|Èjû@€”Ãf})š‚2‰wiÔAzb} ¢Þi3K¡67œK5yXòYòžåúÛÕžE Ev¥WàæÔtªœYc]ÒAºä<¶™Xê%ú઩ re—W²voÃúfª_V´FC`ŽRDfÖKÍú¬&Ș}£9)ˆ3.¨<W^ ‘ZÒS_ºTú’Ø#Z²Bª]ÖDPÊyš„šîªnT¡³›6Ñ6ô`"°. . ´Á´. ¸œaÚÓCq-ò/ÁV/±ÿŸÂN °I¹EFÙ!"v*@ù- w.b&˜Pˆ€¡­û1ùq%Ðp?¡Ä Bø1ûƒZ#ibY¢ê?PaèMªQ6%¶}ÿ€¥ Á¹~ø Vúz½ó‹6FÓñ)°¸¤Z+˜Ð"/ÕED•Já$C§Z‚³%"^ öYAaaŽ{«ƒt¼Á¡r¼1y2 ‚Û5?òX#¢úˆ+¯õ9iç¶§“û©U!–Š+T9ò`’¹N›«N›\ê0½§bÒ,‘»%ð6{)¸D]ò”/HfqRêžB*§Eqÿ(š~Šß(U"‡z›Yìá=Ë‹/Ñ¿TÁ"¡òFºIŒ[½œD¾Yá•X3¾ÞˤüY\®@ŸXñ)ö¬šKë¯!!¡ú Ûº‚q¾€Ö/ <®ðIû{kF Ì8A œ#¹* óž<”Ö¶±¢§Ú²'‰1“‘r u‹ñ“!-²Á4»‘øQùs(º…®¬XÂL¤Ç›'¾Õ§úùÂâK¾ÃGÂhaÁ«êªþê´"àíK Q›œ¾·4_jÊ•yµe£êžª‘š<ࡌ&%h ‹E$©×–õTÕ©',(ÆRñ%(ÿks‰G%àx?á¼KÅÁ¼¡[\:Œ *Oi© 9;[c–VJ,zÄ•tØa…\Éj ʪá•ÈLÛ¾¯êBNPr {§¼,¢£¿°¸ûA€|RŒR‹†‚|žW‘'YoS1®ÜÊÓ÷ÙÊ7$x aÂ{„æË_7³›y¶ç¼|½¥Üd¹ZY‘K¹ŸšÂý PÁ–  ú¹¹ È¿ U ª¯é{x 1×Á¡q“’EKz³†ÎB¥$ <’z¬äŽÊ f„p‚"àÊÔW}SQÈB¼!ðb2¼~¡ˆÁ'³2»¡.1"›™Z[:º‘ÿ”¸qISºekMqƾªèF‡J…©¹7ü¶ ¡ÍH¡p^Ù¬ôu(!:@A W/Ó¦ãÓ…i«45Ì'HÙH‹ •¹;¨†`À汌9“&Ùöm…!¼GÍ´xkTM‰§ì£2t¢R Eá C’Åõ:¨¸8BÂÅ%K ±¾"­=ܯټ<-ÀNa,=0Aà ;ÁÁ”Ô"p|Á‡ÉïL³ãú‰Zð6ÐT´¤˜‚碼pé=ÄA¨ ÁÓ!ð±e“´Ð›IÕ· ¸EÕ„6È0`Š¶ÖŸÐlÿÂÔŒC`§¬Ê¯tMÆ­7ôðÉøzùÒ@žbAñt?!¶Ù|4ç÷²µNÙ6`^¨P“äm‰9·79Æ‘¶yÔÚŠ$Ç1*Móî7ÌÚ¥Åc¸wŒ0:+¸S¸IÎü¤ã{Ñi‡vú°´Ù!úáE "òPEO\0ÖõeÎ@­fD/ÀdFË!¢RÊ‘¸žd„Mf„< kúÙä=“pK}œ}ùÁ<aë Ü"W‚9ºÐEñÆku6û_qܰe=ªŒþD¾5Ã7OâT\zªþÀÒ›aÜÈ¿§žZ^Ã}xª E°ÿÇzlˆqÕΣڄ/Õ[–X¨dÅîGFÿ…”,Œ`Fz˜<üÀÀЪ¢ØUÙ'Ë"×Ï'+Ë'Eгë-‘% ‰BZÐQàZ „î³-/Ö‡t£n›~Öyµ¿“WŸRwqÍR±êHëÿë"°ZÞAó 4<Ø0ð:~/Ý"$@2•’zemî˜÷’">-KÆÒ±-Z}Þ¨7•õ¢.‚aÒnÆKß*Ç")®’8®Û‚+©%T­ o0¤˜¸Ÿ'N¥ f|ú™É¨©]Üó‡1ꪇ'¿°ô‡·êùþïªðù.õ+  ÿÞÓñHÄÌñE`‡®ë·6¥®`‡,/›ùË ü.ž†P·E!ÔŠ9ÔÕ×A)rÄ{Ô—ÅÄ=>yÔ4ÎÇÐ[{³Ó©ûý!ù ÿ,éÿù H°`… *\È ¢FlHQ¡>D „ÙMÈ D#!j%D˜ F•ÄeŸ…­ I˜b#Fór–˜÷Á=FörýÀïCÎy8' úXᣖ"‚šOTCˆdJ °àdž … ÛêF«?nZK¡­[ ^ ªPÁ^…öò}(°7_¿øˆ§_a%ò‹8¢"Áx‚#Î/ðà˜3kÞ¬y±g‚Š.˜o`i§ù•NØp¢k‡Y—žmZ eÕEи{H‘7„@ÃeŸ0hÂX&…r‘k?|˜`ôR¤1æ'Ï:PíG?pÿ:ݩȦÒÓ/ {A‚¡?~XpÛŠ’!mP¸v­X· l°Á tÙe _xevWd§‰ 9øPcŽ e–U&˜†—aVg b¦ÐDÅÆk'¢†âA©Uôšb&Vˆ›m§!²BF¸€H"-Í5À¤ 0Âi$J`!òœ>„pTNôÅÂ=Üu÷äQJí(#!<ÅdO[*üI€WÅÅ÷C+ú!aÈ™û©åh%ß#Ôu—==%hO‚"v?I8BH‡ ?5Ê(£ú4šáe•UÚ¡¥–‚è™HŸÉ¸P`%¶öÙ‹$ŠVZ`«©¶àŒù„tƒŽ+Dÿ°ãCˆpt0A$.™Ô"V9u”uó°^vÛQɱÄâUVM!uŸ15”!Œ²[fý0 >? ¥Ÿ[n¶…„\@K0ý€Ï1éiÏŸ|úÉ j…ý†(œ>ÖP<Zºá¤š}ÈÙ‡/ô¢‰¡UÈ¢cùBc§µê@ó#Â7.°À«³"Â.×G¯(i4Ÿs8©Ý ,TyÂÌRrw•VÆæP[²`¬Pd÷TSµâûy…¸jŠûÃé"‘n{°YŸ|.-P`]ôú‰—`廯H#ˆ’„‹>êè¢K0¥pÃ)Â"FD+C(zÚ¢¨?ÿ4è ¨n"m‘]dö«+¼úQBðú±_E0fŽŸPºvÌeHFó§¤K[n|KGàæLОX ´Âfq(8ïñ]Ó[”Äü†d6¢±ío† Æ¡`—z¨}öƒÁFqE©VA‹y{JÑÞ¦•/PHüÞ°pJR"L#ÉÊÕû‹çƒSÍÜ-›z²òø™ùÌf÷¸ˆºye;' Ê 6»¶ˆ>)aÖô³– @ wé‚ Ðb;Ȉkx9Þ]òaUå‹_dCÄÆd¡ZHz‹ Œ¤…)¹ùP`ü0Ĉÿ&Öñ™ïˆáh8£‚°¯}‹SÒŽÖ#­ ,PùÒþ´3ÔͬS: 0@˜qtdL£x3åÊ ]n€ùñgNðY>1ŠT¬ib!A HÐ;C”Å-í*žç5»Àˆa ¡¡H©m9lÀt˜¡õ0S›HT¾×½…/TH\Hjòà d}1”¤ì”D+¶¥WÔÇ>¸3.šÑ‹0KÖA÷¹¦‘9È€rpÌÐý,€¨c„> ±€¥í¨?l >F dØ.-k2„}Ç$¸éLjŠOžä5¯} Ї#I‘ÌÐ01Á£ …ÿÃÈT¼M†0ÔÃ-†•¤L¥BÁ7£²¤0#¸xE¬<§-W´ÑŽÞgˆ]ÒcK5Ûœè|)43€ [¦Všƒ5®‘™ ìCA¬È7k©€Ü#Ü‚£H§~ÒÅŸ©U“O\F•ãá¥.'ŠgTê©/ ÕBk³dÀ4é!ìýn2˜§°óÕ&pySŸŒ…>~ÜÀ{ ñØG÷>«Ø¨jnÁX(  E:4¹\̶SÀyT‰˜dÝÍÉR•2s&E9ºuObC”Q[ÓšÜ&dB‡zˆ$ÊÉ9g§±BÉKZ¡¤1­@@ãÇLœ”ºŸi‡;æef3«ÞǦ±д’=ž2—b¾—Å/W†Ÿ°œIÉ$Þ6ãS dúáÚkx¢HJ2$…9Laú¹¶GõV{ÞÐo©Ç=Ý-ÿ¡ÊÅ mæÜa‡4¦•nuß-@‰ÅíYÅõÙJsòét©2U=¶#Æf¦×¤è屎›¹*ë)7aDÿ¬³ D>`¸üCꣶbiß­•›1ŠVÌë.œ!¦IÕŮ̸ö'u¸!ORx”BL§Œ[g³î”2 Éb” ÝlImS®^ ,r 0ÊQè;,ËJÅ2&dɸ^AŒ’vì1%›9ï0Â:, ¬ÿ¤åÙ‘i]AÕÊÔvjÈm2gi¸CF3°Ìv¾3E³®uDh©H¥&×’o9ô65S!ÜBO…TÉY!m•H–½QbÚÿÈè…Àœ1ÕG~Èöp:Æ"%ÿ€3Vâx°F ƒÅô3Û1‰.Eã§~G0t’uà@óS €UOAGÀ ?À;üW21;X“&[øV&ztaDÄ5[Á{‘¡†ÿä(À7q7)p*t˜\è〠bDQ³\dw ð1‰Ó#@ Ñ8Ã1[q](á+/<ºn¨S?d‘¸@‘…„wè6~=8@T‰%E%OÁe„hó@P!ÀB7@2`ÔQHoÑ_j¢A€ Ëð…ÕBQ¡€2ÿ$ ¡Ö+óƒC+’“+'$²ÒQRB,쇄†•R t%G¡s>÷‰–XG—@G‡„ÙÁyG!õ„û¿c%sP…Paü1<`!<éÄM_xH°‹ñ$v_f\ÓØ6g§kÀ'’]µI0¾÷CeÅŒy“|çqªòvxJ|§#î³q“¹âð ?I?Hm/ñ˜Õ¡m7f‰Kx‹e~ªã2N‚9i„J‰xˆELŸsœÃE?34s_˜u4€TÀ`Oñ0ñ*MFîR ÞÂG?QUOaU†‘²‘2V"ò!j'’[•v•6pvDш‡Ó¸*zÿ‚28Ó(7²” 7IÀ+²Â+VK­ UsgA Á#À¨häÅ@Ü¡å5 ! m¿$~¡³mô0%ÃdŸÈ98A3P’ ùV!tdG;8CFÔ”4ñánÑ–o½I æœÖc1 ˜èUØa}yvy)£Ÿ„’s§P(²7 rŠYp‚ÓV6‚_”Ij##+Gm¯ 9õ1º$-ö*üi-Æ"š•ˆ3†åŽ4õï‡FîØ7%Ú±X'nÃ"×Q,wÓ¡‚jm¹Sr*Ñ9`4ð`?†Å¢Ù<ýb!8ÒY)½ÿVŒ¼f’iVa~¹v¡’aV«rl1ž`Ó©å‰wQK3E”@”€ ¸ Ÿ»A”(Ábú mÎAkW$éÑ9ht•gÔ^Õ‘å”3M??¦Í2dhê3>ƒ%ðѰ£57ˆ9oÁ VœÈ`eÈC0UtY}‡jŽ9Êv80g¦U#‰½–DÝyDº‡1±¡˜ÏØD„#l6"+£¤ˆpª©ê1)ó¯+0…w"!ù €zÁbê?Ät38#ŠÅ´šžCFôèL¢o¯‰:ª°‚ W¢,ÁDs%ðcJñNÑ:Õh4 ).¹ 2‹a!veÿÈ#ÊF—q„IH/ú‘»¶UŒ*|R\Æ÷J)B¤ r ²|ÖDK+íé1¦ê8ºqr'q`+‘y j°Óxf3RÉŽÅô‰à@°‰¡cƒG›Ù!X2ƒy]DY“¥,#û*0M!§bWbStH ™T^(³­¶sA—0¤³1ª1š£9:jƒ£á gçvŸš´ðêa‡ 6'ùq#¤ŠÑ%}¢˜•+¸B ,6°PzPÑ2»ÄEt„–vX•–£)@–¼¡ˆ3û2ºË~ÚAs˜'ŠMéY(K_|ò,Kö*‡äYl'l"pÍ€ Y¶‹Q¨Äÿq–䀀ÉC”Kó³–[q”úfíj> !>ÑB{Hžõúq+ðlóñ>µ¤‚¡b¢bôcª|v@|2dï—«1e•@–·(õ‰_ăELª‰«ÿd¯ ² ½z@tn,0ùð¼ô_ú°m4Xñ+ü§ I³Š«`ù‹«£[åO=,©<4´Áæ=I» O¯Dª˜G“±òSª"qEù;4¡W¯ÀW¹­p“0æ@Añ}7ÆŸ³@Œ»e<±“øxU‰3ì—¶•Htó G=!-—nBÁ•Œ 4$ë¡$•ïqA$T Ü4Ãj!‹É/Bÿ=“1#˜ĽefæËCHŒoþG»)šÜ£ u˵ çyJ¥ál|æïãµ” ó@Â…(! ?ÉŸW‚9gd‰çU^V™Ëcü^ò¦<˜š{„÷hô93C,L,¤ó$Œ€ŠÒq%O!J"vb‘ñQ׺ Í€1swaâpå;g7“«£éü—î;*ïËPñjDå’ßÙ¹Ä% åœN<%\Í!ÂVQƒ^Ä~+FÌKF¶ ±kˬFæÕ°¯é°åe‰j»—ͪôõ$µjc9ñ,Y!OŠëjñYîb· £&‹³ÿV‘1JK›fç‘A|ÎÄHÉ=œ¾D;)Cd7Dl>ój û´Ï˜¨bDù€\”\ûSáWÃâmÿøÌ•–«¾\öø ‹R¿¼F±T‰ÑïõE—ƒ„È4/ã”q¬Sµ»mO¤Fk¤¶YXe2‘?ÐYBÔÂñ|ϸ(ãê‘•ÜkÔ”’Œ˜’`<²Éóì·Œ‡I´am†7°(#­ .“t03<ñnSò° ÖãçËdüÚæ—·j´RÑÔ±£Ã±ßÇuL,ê%M²E¥S;UˆQ1m [ Ž]¬±’å3Vù ômßǤL´mËmäiL%‹e‰½Á÷hÆ]m,±‰]Â'b+ÜÒBÒQÍÿáÇ´&§ÆÜÏ Óþ×QÝnIz)Œ•«£$yF 7Þý“ý­©ôHñÀ 8ã๘# }AiA™$ˆƒ<~XìÿõÕiÔsê×ß‘Õƒå•Æ¡HÌ]•(‰ÅDËD¡?q ñe9ÌìàO×ü ‘Ëð cŽq©S²8M^1›ÝkSÉ{)ÔGPõk1´)O„´.®0º‘±*-t…±utÂÀ.’S}€ŽòЈ¦@7nn{íMõ(@ʶ ƒ¶]ÝÕk}ÌO93 þWEÁÌóàWŽ¡î1Í ‰AîRÈ©¾ ÈpȀȳÎ~S?,Œµ.Ômþ‘p¸Ý—ÑÝ+~gIûHJ½| ì’‚SÚ€+×µ#…ˆ 1#R‘~ßÙ~ÑÍ´ËÌ^ö(y:îFA™±¾º„ÃÊzÿ±mNÂ%ZޡӄKá/m爵ïqÙYL"[¶F‚–ô¨šTðDk¾éŒ¹< Ù—¡â­ÄÆ—1C:“9moAi¸ô:d~Å}Pyß¿|ÑN¾Á}ß­‰Ë2Ónæ~-0í¸{1ˆÖ@[ôÌžwÒŠ¡)ý±ÂîZ™ê_(—®ëŠñ7wI–d¥‘¾“ܳ€’>„´¯Áɞº÷£7¤·é)- ü}]tLdßíVÉÑ]ò"XzÌ- ô%ôö·oè-@÷½ÿ2ÁšW‚¦ÌœSEj€ül¹G'ëÞêódÜ‹f®Ô³l®[aÿÃýü¤ÃU)tþD-®ùwN#3‰‡Ñ|×ô1YJ_ÇÚÕªÖ&ÅägoÑÍ·Z̳'ZÌÓ0½ö>ä[øáCˆO AoÞE'4ž`ÁB^Fyç}Àxq^ˆ ?Ò'a¡˜0)Pˆð0`ËtêE¡B…|$TÐW‘>Dü’Šà×T_¼xü¢N•*µ€ÔxO±jš*V¯ñ¼ò+¯ìYD#Ò®¡´iÒ¦qåÎ¥[·ªÝ¹ùšêå7⃈V,ðù‘ÉyŒ8ÊcÌø†{H&PÙòåÈ÷4?Î|™2åÉ–9È\šq‹*Ô«/ßë×ç…<ˆÿj%N”ðèñcóìaL}‘‘Ø!-ŸÐüÃÌVn6ÛÉóÆÏøµÔgH)Ò¸"¾V¥Z>ëW¨O£–=/u¬X¨^ÏšÇv­[¸pñîç_@ï~œ+-n0Ð@D*0,±yb˜Ç#yŽpìˆÈ* -´Ê:# 2Ò4#ͳÊF»LÄÎ6»ç£&¢ÇžÖºO×*²µÚ4JQ#~ƒ°¸9ºh‚îz!˜à (ˆÎd€¡î™e€废€"ʣђ¦â*<0§º*>¨Ú+ª1±š-üÔÊÏ-þâ¤ëª´›s¯ól+­Sð°‹6òH3Æ(ÔCI;ÿBÑAœìÑÑJìp3Æš@m ÕB )DD8JŸ‡ì¹M£Ûæ¹qCRõ£’äÑí$•&až~Déƒ$kúa”œtzFʰòÊ¢’ÒÇ-Ä sYøÒCϼ÷Ô£Ó*úÊRËMµàÔONnåšvZoé: !éÁŒX¨u¶»‡B Å 27Q4ÌNÔ×DB[‰ÆƒXËG}<íôÓ×’ÈTRÛH#U}óÑTÞ.R±Ýè™\%0$‚šxÅi({J» XÂ’Ó¥úÚŽ®/%O/3Õ ë<4«¥-¥öÔ¶[¼¢Ú/²*¸ O¹X&©1V ƒ°]C=”·4ÕÿðÞÏÕZž¹>m¢4X‘Ø>@j DHûÓ‡n“·R )£|ó袺Q ”£tG:Îc%®Éœžùõa«tѨïÒâǘ™ S½»ØkÌ«¼Ò¼Z¹ô;hn¯:3oêhÓùJ*°¥ `ÕFžŽð]Ú!ãÐ3Î:üðê 'õšéß›X¢a±NHȳWP~O]ûÀ"SMMÕ(¶‘…º‹Ã¾„8â;¤yRœ¦,…ð~0ääŸX2J¿k_ž+f0ïš Z2ï_3ª¤ú‡ôn,ÄÓÑhÀ èAKsU ã qBQÓÌ¢*Ã!«íNRüÚZcüÕÿy,Á_KÀN`„ØC!QÁD°<剠yùØ¢—š¸Q/{ÜsÕ@zx½UÕª…@D+g|ðj'טR•€R”íôoKm™ŸäbF²À',[„OY6‡Ÿ·0Nñ0Z^šRF:¡q€zI"°Dâ)9Îr:R(ÚMp‚„ÚÐîªV/Rʃ%ÄMÃ6¢ÐCEÆ‹‚¦ôô"†ˆˆÍmfT£D"o¨ÒMp¶×‘Œ|/8Œð˜!nòodQ‡!†Åï„ÑeT¬ ýÊÃÊ• +X!Óš~&F ™.Oiü–ÑÔÈ—|¸‘03Ñ’+?@¤;>-yÔ‡¬VJÿé‹i¿yXôPeIƒÔ¦6 q¤`ZñŠsÂP£¡""pÖÆ &Áa êfOø&$>âg2›à£IKlâOZÆ):Eh¶\VS¨ò-³dñrðqADÝžm3ND+Ý´ìA:±1O\zã"`Ò Í%@(Û%A}Á+2×ä ¿~çAy3œâ§PØ Œ`Ë[À+ŠzÔÆÈ’<µMBBèqÒzw\LºŠ“2r HäÕ5t‚‹$ˆÚùœÿºt—*2=RQ|¬Bžý•¥sqùœFñ"Àÿ\ŘÄTã´Á€X ­0"3%p±ÝHSB´« ‰8dMB‘0ÿ„Ü,ŽExZ‘`6³ !Xg ÃW¬ ´G5ª–·NÊhœ-TÈó,B$¼é¦ö ö¶—šìÄ‘Z-Ÿj1 ’1q?AZYÃã%œ©Õ~äiV³6GQÎeTŒDCæ0G* ÔÔhà®=¾ÅF-¡Ôˆ…E„K…£§-öôšà¤|woŸ¤ÚéA2Ë"-ä5“¡ !)ZÒ® +PE|p`Ó2¯³ùÈÅ~æØÉH“œ[ÝÒÕ=Rêv·øM”¸ŒQ„µND™Ë¸èºP/Y‘Ya±Ùý²¸?ºÚ5.œqÿ£|”¤uú¨Ñ>ª×£¹dƒ%LW:+Zíf10ÿm¬‰@¯È¯z˜²ÍC¬LCØ„€þ­h_aTÑ X_.ª(±Jxª8­ v†dö0Qmݲ‡¢NÎv$†àó?—T ' —JtÑä¦Â3©Øx…Ól`3#8´“$˜JZȈ§Â–7Þ³­õä¾îh:­° 2xòƒØåsÇÊŠCѪܘqñ­b‚4}’&ceOü@G¹ëcsw€GCŠüMØr­Ï¼š\2ÿ×ûjßM65öE¡­YÔ]ó’lþu˜—Mñ0Gàªð²Í¼€|ÍËÓQÂØÑP¨I×ls#Uñi[IÜf0˜¸*Ù)r.¾º™åÜõ4º¢Žž ‰©+o¼ÒE@ú?šÞôŽîµõ.§9­c¥ "þ>©ãÈc BQ£3Ãì”Ö@Õ/l<+qü‚y¾þ/Q7^ì§ÍÉ~EšOû©– …˜\>7%;ì"sa»`€›–'v¨>Lpž§h%ó8këÍ<ß,Ë=Zgü&ñ]•>Ò<1]ß:]½ì]{àÛÇE»wA ®\Kå]Iîÿ8»&ÓkwY¸}é¡’…ÕíoŸ{¯—ÇæºƒV¤íxÈõþq£.»yO˜rTŽ1ÝØ““-€@j Àˆ h5:6©E“®q $hò)ö€ÌM•°Èl}–W*º¹ŠÒ¢vó«yC½ÔC=‘*&#¦iÉ1ªë®«‹ÀŽÊ“ØJ8©™¸V€£9B,ˆi {©—9úrªh$\Û/‚é} €_ø¬è[¶èSžã¸aK6¾K3b‹¡uj6䫨BŒà$ ŽyàCh H%%‚’  *"šžk+õpl.ö œ‘³(‹¡ã®xÃpîÊœ§³.P˱}Ëÿ}{ ÿ`éã´zs½ÒQ¡9ô.;„½Oó®Òi „ €£"z£@5âAƒ#AA"•ÕȬ‡89³aÁÎò”_Œ¬Áç -b¹Žã¸333Jø²0cž£€PqªyÒ¤’Ø ¹%Œ€QÛa(œeÀ±‚«™1‹œœa0½¡«0œ3ü³(ÆÙƒ½| ºfœÀ«s=NƒÀ©ë.<¼Æ©ó1ªƒ=âFoäCpä4#Œ>é@Pqˆ–bÚi ¢pB!º2{;Dø xÁ_p>Mœ¸”¸1óU8³€$¶ë»Ô>8z ’¨bÅÔ`„ïc„ XBÁ2dx’ÿkh%o‰(1\1”Ž É/Édו·{³GÊG ØGå>­3ÑÂAOľ4£„°Ëb[ž{LEˆ\EV ”‘ ‰”Ъš0ŸZ$™[«/Ü1d<ü É’LI¿„“Ì”LjÉP–´‡xP¡ÅÜÉÔIœìIÇœÌǤLÊÔÉ©S?lºÁÀ½V8ÇYá¡ÆX‚¨¹)‘ˆ€¡+*î`'ÏZ§x¤’;¬ü¯5Ã8ô8bK³a3H±Ë”òÿ!‘3$[Ë‹Pˆ¿ÑªÀ2'(Á‡Ð:ñKê¬Në„ì,ìÌÎíìNÀ„‚nÔÌð´ñOïÏà …$¸ ŒìëİäÐgË}£;¼Zˬó; #œ?}…_p'p‚nýÖk€†V0ÍÌLòœWJW}MÚyõÑzÕT¥EÚx•Z¥­Ú|íWQMU-U®íÚSÝÚ® [±[ÍÔâLÂÈîÙŒ šØâp¦:[¶‹ˆ‹JŽ•¡ƒ1S½»YÊþê.KÓ3¶ „Vý8i…°‚0hƒ€~"³JP^àY'p^‚fÚ ˆÃ¤×IÝ©Ôw5]©eÚÓM]ýX(p]=Õ6øZòU°Ý«¥OÛX­ýZß Xÿ°[áÞ°ÏdJ {`ƒ»µÔL9F•†«5º½µ/ýÕ,˜‚ Ù=Ó¹ÜMqMÏÜ4E³–¥„K@Ü;¥$gk­”@å¤! \ôí…õÙ^WJH̦=Òzý_z à¨`ý|]æ×Ù-Õ&ÕT=ÒUýTÞe`Þ^®ýÚ &^ &ÞÛO£ÐF0¸#P—¶¬Ø9§Öµ¶[¾»Ý^ÿò”3}¡¼¼ØÈ¬LqP0SsY±L_h-©£¨5[Qm0ÃÀ¾„^p6øYh~ˆyýÔzÕyEU x] Ž] Ö€6ˆ]Q…b­[ žàÞÍ`1Þb3æÚÿ…b±±-ÑZ±'ŽQ&PÉÓè…6Š‚üÊ\Ó5»åØÔ^OdŸB²KQ‘^}Í^Û;håáÄÕ’„A¾î@„°€ !°¾»$¶ß6è…üÅNË]˜ÝS¦OT^åÖeà2îâ+Û×[úDM¬µà2.ã4Þå]öÝQ-€J- Š\°€† â„8>ÖP¾„™Ç»=Š•æì%˜ÌŠˆÊæˆàÕˆ['}ôMÄKú=³>¹¡Àš|˜_ 0-ôE_Hâ6epåòãTÎOTÎO+ve+NàNààEãR5ßeÒÚ%UÜàRU±9U‡vèæeÿŠöÚ‡¾ŠðÊ@šð7`€aˆsQ‰‹Ä…¨^K@®Äu VÏJ­xñLºå,î¯å1ªp¾ àiAL3áL "" Td˜_3Oþä_åoõãUEåX6àS=`«†]ß½ê‰.^~5†RÕT&‡T%kSeã0þ]€•èŠ&[2~k-FÕ(€Ûà X!pa¸k ˜¶“Äg†fz¤Ê,Ñ̪ˆK‰iBjÄÖ/•ÆiEÄ¥\žöäž&碀t^¿Zœ_4»ÁKðOžgQ††K8ÌÒž]€æbRÅjØFà\~à,[(ëT½WOmåÿ€mà~žà¶^µ.n¯FÕ @„‹ŽZôè»&,´ é’^]-³iŽ¥f„¡aˆ ¤è±¯Í¢D¤ˆAÁu¾Ð:ßw¾ìžÆÀ” ¡ 긅cçKà8Ò.mÍmâ'RVn,®j­æêT}í0îj±mOÞÖ]ve ëÏÚ¸6îÿí·Öåßm‡`B#Ša¨Å½>'Â’¤j\ˆs;-ûã©<}HìyʤÕ8¹Sá׌М6_híi¿lÓ: ¢€®»ÞáÊU…KxO¶_üWP|ÎgUn`,æj,Nà'Ïg×^ðÛNëVåÑ„Vp~ÎÏõò‡Žë ¶h3÷êÿÚÖr/ÖL³™¹‚ßëTð7J0"—€ñ†x È…¶“J@þAçÙÕÄf¡Ø(q×À^^ƒ$pþMõöd½Û=õk|d°k90O¶oÒå^ gh`û¼âV~ò.–í(¯òàÆr·6`°6Û{åm'ýTÛ sý]-·u3nUOóUmÜ™‹8ïðÉ­…W@æ\8,,+Ñýâó¨Dt@l¡*t>ƲAOìÌ:ö\x;4¶ßìéF÷»ÝS’Á{#Lï("?ò¦öVÔ^LzEe¤õÔÝç©õ©½÷)Ær6hS5ÏÑÏMMp¬Þ[§pá–àÞí]*oàüüÿ­‹|˜ta¨…¯¾v‰Æ5ç,-ƒJñ.씕f¤áÕú>Ïö[³ölç5çEÌžy ô0n“`¨tYp^àtQ6rQîVpÝ€è4]«½ò+Ÿ×6púS†z׆ú(¯j#µêÿ¶Ì‚ßz#%c5Çõ…×b†×õ _U Xm‰Ÿ9‹ó8G§V8¬†@áý¢[©ä¬‘÷æ7k@Ÿaٸ̪i•^0‚yHúÐ˾l¿ë“HrQ`À|™xŸÿùnõÖWHâÍmâà´íDÝtEZÔ }ÐGWªÍO¾wÚmZxÇÜúX?R*/û\Îçæ÷*·÷nsÂò7ÿŒ_€†Z¬rnˆ†8t“O˜ƒìJÜÞ›Þû™=ˆDok?qíµæÈ†!™¿l!ptJPž”Ú:æ<ê“ZŸo%æYÍõVÌ‚kÎ3¬Ôjt‚©£J:ÀTWíÌÒ{P„¢BàAƒ**0¢7/lدâéuÍÂ<ú|RõY;WÄV§_[mq¢…ÙüdC|'á<\RaEת,€—_}ñ•× >&Ä(À3Š”DPD/.TY.ð¢Je½dv7 ’ŠM©¦ZS©}À"‹*¢Èj¨öh±éX[m¹FýæG,©`ܑť„¤I( ·RG ¡„såSMD “„´²BQ'œ ÿ~c’yŸ}ãØT[µçÞUQÕÕXi¡…_~ò`žQçE…È/X èƒ*w!È¢~U8˜@Œ„F𠆽ph)e! ¡. TÀ?ù€Êϧ¢~zª> ª*«¢ºÚ*¬M…š?´¾ˆâŠA&äãC»QtF¿qô±F®ääBôp¤ìpE>)ÜK8æ#"C¼RK3Íø"D+†@`¦<÷„k–¸fÑwß _ uš€UÕgTQЙ}dÑžã¶PB€úÌT®°À+ ø`h_Šþ…W¯fXNÈŒ"D…>Tº¡ jØ fÐ\Ó©!þ‚šê¨ü¤zr$ŸlrʈJÿª>.ƒêr©¥ÖJꕱòÓ+Ï 䣯m$4p·³(1»t‘L#=l”U>Q#·¢S3ÂXЊ%{Øa›ÕÄ™öÙ+”RQQE×Á¯¼û W]µ0–½Óò—Ö jÁ…œ}7XèÁyáÅ—‚~YH‰£†‚Œ0op‰* føKd.d*¢ÇR0"ütæoʆtÖ™ç!wŽHÌÇÌ2É!“JꩯǞ³ÌùYѹûFôÐE û´ïÉò¾,ÔPF­œ ô„òBh«µ!°nØ”«ß ,”™.y~²WÕ+wúÊ\ú(åUä©WÔwßEíÀ~“O øêUø‚yÖÿ¨âRÜWˆ&§±Ê¼âЀÆ(²Ã9Ñ!‚£Ã’è<‡¥™H°ü0–2ø@”ÅLŒYËReRõìv»IˆÏ€,à%/YMsá aȬ'±0JÅbÖAøA- D (‹YŽ 2ÙgˆD PÄ6J„o~ðq Ýævž¤t¥+IA„Àà4¿¦~z\‚*T¡Xˆø¨.G¸K„¨ mÈ…d4ÆácäóèÀ;N0£ëœèD§Á òtä‡ {ã³E ix+ü] #Cßá°xOš¡ £f“ '[ÓX0½³Üé;,S¾òd¯Óðƒ*EhšK'Š ÿ÷‘’ñÍoE(P]'8û)lad,ÌÃð1Љ5*a!’ÌÆzQÀ9Ž?ØHmf³›¢ÛÜLÀN?Bœ~œÉÙÀòHwAã°„&O`¯†“Œd%F¼bä!þŠÅ†yˆRLîûNó#¶rIQ=k³Ë]šØ ÷À' jZT°( j.‘ƒ(`ˆ™—¿./ ˆÀI¥Ìœ,ˆP!Š&… 5eâãØä&6mŠ›nN§75‘Mo`ˆ î›49jO³i¢žît§ºéY;sÏ©jDYÑ@%‰'Éàq•«Ê*ÖG”7-Äqí;hA x¼ƒV1åI\åÿJ—ŸDðÊX,–¢¨>†âz8Á ]YŠz¶Ò®ª¡.€¦à†8 ®1)]ÌJ…ÐÅÈI®2«Ì#ð|X“<]êg·Tœz¶¨@-­gK;ZÐÒd´E-jTc[ªÉw1°*$ïé´Ýºð%ô«?ÕŠ ´}ÓYÏò5±1‰ßc¡èJ>UTÅúˆ‚=üº.¥@EmXä5Ì/æeAùŒ`nR Ô"'Z{…(¥Š„]½˜/4.ÑŠÂP¨<-i…ÊÓ×ص7Ðég›z` ˜´ˆ-„q×zÎÓôˆF40Obµ#VA ø¹Lzä«ÑÿŠç“| ŽÄ5®}Ðe¦°Ýƒ5¶1Øä–(ö•”-X,){•©˜O¯NˆÕ£Ô}Ï*…-T¡BªX0êå¼”0Ø <«YˆEjT)}#w !@ÃøÁf­yMÒŠv¨Û,'€ÝìÙrþ·ÀlžójjÓó¹Ï±G v—‘@c˜Ð ^ÈmA¬,}&OÃ!iôÓ¾òX`ÄU+[SYãMÀÆ6ÖQÔc•ðªPv™nu£Â¦VÖ¥JU°BÙÀÊ~ä=Ô%6RÁP`0…9 ¤,Ÿ_Ì7a>HØW0„›pöX0 `i+uÎ8å\OXNѨ¦M­›Oÿûœqà!͹í‘î ¨»ÏŒ*¡} øÂò´ò0|èC8¬Vq 50¬ÎÃÂöXÁÖ>àï‰\f™§7c³tOÔîŠn]£ûÑX[—Õ‚]¬9J¨"¤‰&¢†‰Ò“¦½ÀÈ–<*æc'LÐBµ4«L  YÚж¶µi2‚œ©NjQEÛZÓº™&`7ÔŸSnv?ý9T/ÕRîqs½6ŒxH íñu±“ýëñŽ¡éave%zÑV´H~ëwØ;@ÄÀpå˜,ä:‚§'N&òìrÔPn[,é¹"!Ö®þx<\ëÆš²… ßHO^¡ÿÁq^Œü…0ÑŒgö¯s?kgļãýá€XÅ x¡Q¬¬ð|gÒàJûžcðPÆy‚+£ò Å×5|—÷â­À+9ž`¹êP^¬‰ÀÕÕ”5 ¢&Å@ 2@ é™^H›^ø™5ƒT XÀâXÓ €›åž!lÛ¶e:ßæ¨“ †­`ÑmŽò½È &_ôa]»Q]N²›ñU_»•Ûö•Ø1‚Ù1Âm5ÿ!Û=!Ü\ò8¡ „…ÄÀÀ…À |à˜•r‰ËZ(ßÉÃ( á9”ÌÓa•šÆÑÅÅšÉP{Àšâ©‚ÿÜ”å…LÙ\ã@ g¹ãÃ2”ÞæÛ]ô%™—´Â6EÀ((šEâ5!í!A fS ®S mb f¢:í ~Ó'b"ÍT€)^‰ó•¢)>Ý*šb2_óM€òY_XŸ-¡õ)¡ÚqŸ&aw(á/Îv‡0.ÎÃ1þâ…µŸp!ŒÝ_ûr5ÜÙäa‘”Æ+t]½ËV×wÉ•ŠW,Wæ!ˆÍe‹{MHN@ÊË.TÌÁÔIÉTøÿM,Àf¡Y+Ô2øB-¤B‚%¦ !u"B’BbC$BdBn¢&ºbHì°b)^ +NK+¾b+2#ßÐâ”Û-2wô¢.ã.Ú0Ò#„…÷…ELªÚ!#M~‡= ‚,@W0BĤ¹´=  šàR~…÷°GSà„O 6^ÂG¬½’ÙaÛ˜ãx9J:B¤¬cBÊè-ƒÖlÀ±Í5ŽéC^€Àø‚/C-$€%"BJ@Eöåô%_&`öå`6äB>äaº"_š"&cº"F6+–d-ÖâHVJn&wø"0zß0ÿ£h®dwÌ$baLcûÈÄD€ äsðGq!Ô< ‹Ù‘R¶É÷ä§[ì݈ÚfxÐCw‰£VÎÒSf`Á¼Ë‹§ V]qåx-L:¶c—´—0øB¶Op#” "TÝð ¸Â D)@R€+4(#p)°ë¯n©ƒú*J6¨—¢©™šiDB¤:«!èœÚçeJ€{z鯆iŸnk„v«„~«h*0PŒ(jM¬ÀOt¡w˜ ¤âÒyXœ^Tnÿc½–ãG  UT¥8ú˜x1Q­Ù¨àx¥Ž¶ã:B§ª2Fo.^DAm†Ë’–Ôƒ­Ö”Š']‚€+Ü–në¯k–~,#Ü‚h«Çö©&jâ'¦ì'"¦Ëîå´šâzâé•«Èz츪ݸ¦&Ïbè…¶ ‚uîW⼟W„EºÜ ÷ŒÇä‚€–,½BÔâk¦z#¿v”q®¨Àf^OäDކeVÇË-C3Ä£ÁPUæB>ÄÀŒ @\@=X,®†'0øÂl, ÜÂ<À<ÜÂÞ.É’lƒú*ÉúíÞþ-#”ÀâÞB ÌwBn 0.å"&³º,æfîCægEþ¥}¾ÿ'°~lƒŽkáöéìâÎãÎŽ«ß2®0>Ä#ND ץ݉hQªI’)‘V2iåÔ~uík `Ò¨r¥L©ã:ì:RÈ $àc¨=@Ü@€+¸ÂÜÅ^,]ÖÂwŽ/ùÞàŽìàrìù:.ùޝ(•Àûn'ün' 4Ð b"³^®æ¾¬³žgœz®ÿ¦çñ ké~,é2ÂÎ븦®jª&HNø¨]~’Â%Ïx\p¬%èƒÓêC ÐÅ6jãoþ”¹¡Ve 8™{4‘”%/Ùܹ×Î0ÿ4ÆÇ)Y>åÜC ´pïö&@®Š'2$ÀùÊÿo 8®ùŽìÀÈ¢¯ùÞýŠ’_1‹Bbâþ"¤þîo~bp{kéž±è*á#°ê²1#@±³qåóP0úˆÇPˆG èÖR>PžŽ×]žaÑVÆÇYÅþ¹!©!'¨.L˰aðc0J ª½õš ÜòÌmXl= 1]¦‚+ü¦rù îO€ùî- pçÏ*-/©-ßòxÓ%vâBörCþ²/;¦€FæeÊl{ÖbÇ¢1Ÿ,3‡+¹æh¶@ƒ/PpD\ðxˆÀ‰€5ú‹æ…øÔU à¥ðU^Ea0 »ðHA`N %£W`ÆÇ©ÿšy´'2ƒ2®Šç2Ô€ø"qù.±úº²úJ1ûÊ2-³À’2´¬>ôtqóc³´*[©–jfÈ.³«É6³Ï’+.dKƒ€S …Ys `³¸…€ò0mã7ƒó\P¥ã‘s¬ÉÜ©92¨ŠÑ˜ñ…ÆP/€QÛEVüIT„J>Ä$tòo/( ±®ú3Äòø2ñî¿òÈ’V—uCã²-+ï DRôafn[Ç)_þ¥+Êâ1»22'sƒ40†t3«>`:š™yy(χ@à%8…Å0^„ðé ŽÆQ×7ÊaUó ²OŸÊ1ÿÌáÆIŒQ †V¨Žù(Ü{òDõÜj/Uc¬/ ƒ@’€@s§ãB±úôACï¬24.C´DkîcîAJk\çÿf)G›q^ðGßì¶îìXéeÖ A.…WEÇ A”‡«‰\]È’Éý…Mãt {p¦°å!/dÿ4âx6QF< ÆQ?ê´ÈiÜxO{Y. ™>¨Â“²\1¿ÂšNïßÒ´:oÞ1E“ˆQÌÀ¶”SßSOÀ= 8(OuPµ”âí‚O1Aoõƒ¹ƒ¿qW‹µX34p/)†Ã¹°¯uCz¸ÿÖõˆã9‰ãuáeƒf§¶¢¸Š£ä–°ÔO€†Œ{…¡ó‚bÇxŽV.Ї¹ÀEÈ!²\»SU 9k:ðšœ9zÿºg_™“;y© |ÌJlNÀS_>ã³(¼Å‚€–ƒ]ö³—k5ƒ;±Ÿ¹ùº¯³yD³lq;æ{rÛ92ãyž+³tû*_ï¬Ðª#n·P¶¡k@ˆwÌ _‘·ÊK½´@ä‚Ó" ãgU–ûÏ«„Á$¯Ãލ£¨¶~Ìt†S¿{²+ü0ÀÏ-Õƒr®¦Á§‚#AV×úAsiA»ò®;®šÿºÅ7‡¤±Ëõ±[éÆc)Ç/»ÇG7È?·O€”%÷ww_0Vу ø@>ÐGÐÇWäßã©M¼¨íÖ9ŸsNÇZÏ/²ai6¨al#¨oÿþlþÑǬÀÒ×JLüÔG}=äs>W½_½®"ÜÂL¸×?ø–Žù-@À§yÙO<|»)aR«ÛÃ=È:·2;;P*aJÞléÒÃð¤pQºÓC¸@ËSO½|EãÇ—‡¿›d‘a0¿Ê…ÈMTÛÈ6Š:5Ì1Y“_ÙæçwüˆþLËHBuöD=õ† xP`‚µR5ôå Y‚[ÜbQ¢Ä­Œn1šðñã-"'L$‘± •,ŽÈ3ô¦!D1iœYgC$ðäÙ¨Ï †N¨`ôãÑ–‚tÚtBˆ §‚ôHõêTFY%¬ˆðÿ‘¾ôèÙ#KV½´h[4¹÷V^‹ô¢è¡/^{Eü±B`ÀóuÁ·È ªD$üjÅ+J>^EðA©2¥’7G ´@³Ï ,[^±àôа–JåÁÃUìz<D8DÃZµ &¨x#Æ‹I˜XräH&5 WyDæË›8©G¯³§¡ =‡rúá(Óð@BušõãV­U³^uÂD_U‡øp–lüjéɽ維&ä !}\(Ð@Åû+0Àsp…ùÚ«ˆ"þŠP°Wð´Ë"X ²ÌJÄ5[DÔ"‘|>Xêµ×êqe6l;èÆÈÿ·‡@@â€[~³#!!9‘”,©8”8Z‰…—n¸ŽÊëtzi;Ÿ¸ó®(òÂ[ L§ÄüèôÚcMõÔCÅVôù`¬²ðKk­þš§ ·î”‹ž¢¨+¼üâ C ì/ Mt…"‹ð•WDÓ0R?“ ´=3ÅÔnPÍÅ ˜‚g¼ !…r¬gLJ\„†\)¸[ŒC9änYîÈŽ2j®„*…¥Ò'í´<‰c‘o‚ ˜"sL¦¨ZJÍ4Ù;“‘ô¹!‚ ‰s¿µèÔ@®<ñ”k.²üÌ'P½úRP° “p¿.|Ò 1q3Ò*MÃÐLü4ÔPCÿ D¶iDˆ¶T‡H ¡Tz\"‚üí¢Ž‹$áÈ\ÒÖ^9š§9뤫r:ba:6¨î„òÉ(g—RÊfh«’öá‰Q¼ô…Qî)Ñò_™®e­y„€ HaÕ®Öõg,NÈÇëÆ²®Ã¼kEq¬Zíòâ®  2>júJjC²L§ –° ̃aÈX'2–…ùX£èBÐ.Ü!Šk\ÛKíxG ¡2üÚ†@³¡A2BúXaòÙB·9oy茞Ül´C…$ pE,† _, J€˜’ñ• 8¶RG8r CLI‰ïËIL‚’¬XFñ;V´"RŽX”*[ôH™Ü“-¬ÄEb™Ç1ẖàOùðr1AƨâQzÔc„ “M €Éæ fš¢?n3E©‰P !0r2oy¤Qÿ#¹Nç¡j Ò›˜ÅjŒT a"8BŠSÀ«+ºzœ‰p„: UbL˜9ïÌr=Ï‹pögYTs¼üÙz¶ÂEHåòY@ÑŽy–¹°î, L柛 ÅÄtƒ>P…LéÌ5*ÓŽ…â`¾RãÓojE¨1^> P‚Æ(©ŒL§ô 7HJ’Š4@›‡í(ÜÛ‘$m¨Jv/C¸@WKbPT"4•¬Tå*Õ Åî –²ŠrB×\^4ZŸó«_=Ç„@˜" &YFŠ´ÂöÉjTcÔr!5øeP†Ú`kªRfêA´jôˆÍq(x*2˜øÿqH!¯Yžò Ðà¦óTKžƒgÛà Á¯±mBXµ£íÕÓžq•=5™[´ ÂmÖ®Û8µ:îe­Œ.̆‚„ƒÞaú¨@>XƒK]nÎ*ú`=õäã8Ay H'ÔáÇ )eìŸÚÛ.Ù’^^§.–ÎΚ‡p„ºà ~CD}Á\N SØ‘§‚^k pà/°³žÌ<¸Q¬Ã¶ö°§C쨭‚!†;µÆ˜&M¬‰¦ûJ \:(V¤@ðñ¡™èCø}Ѩ—UžžeÔ£Y±‡VÌd6!\á"Ëag½Ÿ§9×·†ÚýÄÆÿNy,|: dgÍkFÈ¿<õ7A¡,ÀóÀH‚iëf ãÙÁ3r›mlç ÛÙwÂ9åöNë†Ð9LÅ;RI$¸‚0‰÷AÛ÷bÇé$É8^¨µ£!CBè"*€Ö(óE«V ÇÔ¿BÀsSÕ ±‚äc¤L>àéÖò4¦•ëã!oËäqÀ…O¢Ki~·ÍÎþî4êZ‘BPš–¶on0žy~€;²©®Àóó î;§öT¡Þ¹­·›aO{‡v'v“€G³ÌúÈú¥)Ð ü…{Xº"Œf@C”PM-ª¦@Å<; rª;Š&¦ÿo,L6,Z׺¥¼\8¹Éù„®’sñ¸‡àô§u]6³\SQd ær‹K ´A(ÁliÛù:c˜çâöyjî;Ÿžçs~*«Ý[t§›!MwúC0V‹xÏ{ÞW_Ù§¥ó àí Àðv„­@h‚Ú—°ènÖÛ>•ò’‹eõ?‚ßÇ€æmYþ ÿ´€ñ&Ë\Dׂ’—œi~ ” lªÌöNÍØûEöþ+OÕ| 8¬ó|Ž¿­çð,çZÈèŒÎ²-’Ìê,†ªœŽ}yãéðF÷hbøn æp Ç¢„„Á‚O5A5Dÿ)$˨ɦ$ ŒBsâN²/+¸¨gBàÆŠ†ÉæÂ˜ÈÅüÜâ?ïä˜æ‹DgäaýZ ™ráfgAl ¿ä0Dƒ,ÏjXDæáJ Œó@ ÉèðŒvÎôÖðè·(Ézâ0/Ðé^ïž–!÷æ­Å„…¸%ZáüïD-@€à„)€ED€G`,ìá¦îC…)ȃúlúÊ[àNS(N€þ.-æáNˆPñï-ÐeZ É« `@r¡]ÞåBø/ª ÿòO Eì– çl¶ Û|îÂ.ì ?/Üì 0àîlzÞiº‡=l’ÿ\Oå0öbÐîi ¡ë~¯MVðS"Äp¡ñü/ËX¤ÁÒÂøá¦ìšÏEzÌÔª/‹:ZâN*¬(ÉkÖ–FÊß"ñï—0.šPthñpweBèϲv‘µ0ËŠóÀPðÛêl‡ÑA —‘U&FÍ­%éÆs%'ðbðsòö^b'«£ðA€ïW€?%ÉTCà…`;R²¬ôÁi0Ë@èï0ðÂEF7'¯¸òwé¢úÏb¤–Æ,ïO`!9 Oð8`ý˜‰í♥0p¿êˆvz1Í#ìÿB$°ÎŒ s.ç,ÌMoô¤j%ƒ‹ "SG“·®1³±½1'©$÷°ÃÎOpà"„"$ÁÕŠ`X$ÇøÁ.öb¼”‰þôâ*ñBaІYă+7Ê+uF/ç†Ê«NÀ,— äÔò-Ðäïãzmþ&’‚h*Btgš¨ð)õË/‰R1^Px $+ì$ñÍrà `a bœ ªæ&Ðbò†.Sïf3{’'ës3a€?MpàŒ2œæáÈâ\“ ÃBôái /\BûÂ.ôa@íÒXƒ¢¾²§s:ÔÑq,‡SD[1-å! ]rA.ÿ¢À Ù( rþ¢ð]î^&³s;ý¯;æ#ÐÏôì<- ÎàLÂÈ ªÚ³õ*©’äÓõM'Áq'ãm¦”„†'ñÎÎ?k®PÖäa@í¡òÁAóâDà@è"èow"€†Ó.g)´R7Ã$÷îÈDÄ’ çAuiÞOý˜&×þÄZ ÊêòÊà‹¦.È:g“/7rŽþBìð‚æ!$ië0OO³ÏžJ‘¢IB†’TGÞ‰I'Ierâö†ï>«TJ…¯ãm&ûsU COÆ´L4Ü´1x˜Ô¨*%È/"@^AN/íEæEÿîO9tC;”∲EÀOïŒóãZQQ×¢À TTEˆ¡‚(ò™(ƒ&ô)_³ åB>Ñqó Ó$1ìô^`°ÂšêµÖ‰©œ*bà&UX&cÒU­§IãТtøâc[á±øÄ®O .Ñ^#ްOÊÔ ßhA¨Mmt(Á£U¢.Ѻ˜å(бµY> sì‡<$à RNÊkZ\ÑÅ\E×ZàuÈUþžÉW$k²ìµók§;YÔ  _ óCoÅMÜú¬‘ØS JUmQõ=!–IãU›Îbiuø~ï+„ÏâÂN6íßÿ1ÄŽvÄbýì!jÌôA÷bP’µ@\`Aü‚)A;¤u®˜År2çŠF-s|Os¦¯øpL¥D4T uÀµüÒ¥E¡VQ›)/àK‚àƒ¦‰d¤å¨sLa¾ðôìÂ|×Î1Cõa"F ’jõÜ6’&W5n{kbmÏb ¡J…’[UÇ(àÏ?qBã.¤OdsYÓ”qwBWÀ#`rGí–h°¢¼äg7×~&*héô~eB5øüÌB-uG1u?Žœ`\™é^“Bm‘jî‚v!˜P|µÛÑkæN _ÁPHóìΖSO6”—„ÝÖ%bÿ³Ñ†bU'«TKC3>Åø¼O., pCÍŽtðÒ"Ê0+B£ˆi.þD¥¥.A"€fá׉­(g)sÖró©8ÔB08ãN 5@i„°€DQØO‚$È­“!8w±#Y3,ÈõPï0ÏsÛ”wUJxzZbáö2/ .öö^€ÏøÂÎYq8ìdÐù^³QD€È—ØBír‚\] ¦™B@Ú÷}ïljyÂg§ˆ'¨ëôr^ù~{¢øîü†ó GŠN¼ø X]z9 ØÔ]^SF³fB¯v/âøF¿öz·Šn Á Óxÿ#l hÄ6þ¸a GØé„Wê°17buøª4ù34gXìP„ôá‹$QøÁ\sBNvé¢L—•B\à—Ÿ¦|Áë’Ï¢µì!ìÁ«ÐŠ0-s3'g]Ù¡_™Z…¶cïãhõ -z@3ÚÉK×h]ÐTM­sB†yš,8wçÕ5mókYàX èô,%öŒ¬`趪®™õrD§ÙaO8ê¾ybãðb¥tœà„awì†Àð+–f:Am”Î…,ÜKM繨@^Ð.N3'«Û”þZD®®¨r°˜=¢éô6…Ç*`ÉlùŒÊú„ŸÿM!ˆ“g÷5KÚ©ÙáF__à@`S2Üd:<7Ì6n”n2¶§yú§ß0¨%©UÙ{.Öë€à˜º©[$ªO€ 5€@ $¥)Q,ÚB|8jbÔ0 `¥ú¤½\@f±$€FÊ !ô½ÄKëúÒ.@Zậ§˜s¥U¢QÈ[PGÑ¢Í ?ˆiµû£§Æg·¤'™šÛ E§¨›±› =¯Â`H2±§m„õ8ŒbtÚ6æF’<û·â–¨Áñe5}O4Ñ9Ç¢ÚýL®,Ô·ù(±?æR`´^~¹>š’OZá4v^ÖBòA¡­s/'¹1í¨xrÿ:®ÅÒE*ú®’ï h,^GÆ·[v® °w‚h×)›ï ÁÃ]Dtzt–p™;ÜŽÜ’¼_¬œ›3››Ù‰Ê'¿U•¿ƒ:bôEûþ0oûmŽçNd{ €9¥õ¢BC @Òå‡Ñ4žvD'D 2þ-ŠÊ‹é¡L#4/&÷B•{K’Š'‡~£ø6QÈ(Z@]|@ÉH»£à¢Àpïp_·Yä¦öÇçP>»Ü¨ÿPaÂâEt,/ð1ØRÎþêH1¤Ò?òDØŽé¾ôa/ 2½j¼½P\Ð=¹â滃K]hQˆ®‡Ó8[q£»šÒ%ýpÙÅþ&q§–Ø›~ëÜnß'€,PSÚäÉ É žàû•4ÌÍFÖWeUh¾©§Ö bâ»y&å“×ÿ›'·ŽIÔ‘]¼·˜DO€ØnjEÿLþ!OQ.„0ä΢@,í$@Ló:Ê,æG¼ÛŸ‹~sžÄ+ç6ÁqJÊDÃoy€ËÂ,¤µ‘¾í¨é*ï}Á?>Ô\ê¥"¸S¿äaà—¼ þèl‹‘ÉÍ’—ì·9ÊMí]rIçV>­§×C[JÅ(¸OÀ, :#ÏROÖ, 4 $ Pî" H]N` ŠÓ,›=å D€•͘rañ?¼Û#_ç¡HÜ/Tx’à½,E”,:™ÏóïïF!˜šòýô"ÄóBÌ;xↅ:\xà<*V4à #FWõ8ÖR¯^‚!G’,ù1eH"W¦2$A‚˜2ÿk&q„ÎT<{úìiˆ‚¡!¥@¡•!z'šžPÂ^¾©úô¹Á€Ò¦-Zœh¡½¦† §áÓ¦^—¸•×ÄkX±ôœä!˜òŒ0F¯M]z!¢|€8ñ…ĉ#v¼øC…Å‘Kø`"C&0¢Çèà ­Ë’ý¢sFŒ ˆ.ÁB!†# bppÀ‰<2R4` ÆOZO9’åIí YŽüœ:Ë—÷Y+Uúõ>‡ úžhІæçVmÔÂR«®ØàÃòÜç•W„åF—X:u_KÀÕÕ\ô ÿB@c#}uÕ‚X!8Q˜c‡]à˜eˆ-&e“¡xÁd¡(Á{šUp›=g&–ü…j­åâšl°ÑV•¹à†än»äÛ<ÀA€q9DT9]sÐm™QG×YÇ]K1©„]I,u—7gÞy?¥§Oì…ÄPGÕ "ö (XtÙ¨Z>ˆ¨²‚=^õÙgW8Ò5[M5~-Ä¥A„uå³B^Ì3` €ÕB¨!˜Hjc)~Ð"ŠHàbª'"–ÙfˆH0+Y¤ÑµŸTöªŠ¸JYЉ½—YfúpfP‚¡â¶Z>e ¬>ÌvdnÑ3²•p ,`å³ =ÀôqTQ‚Èa4ÑD\BçeÖÞ~ÙK'KR×4‘çæO=Á'½H¸P`SKèë X"üUÞ–F—Zj­UpÃ}.ÑDÝkàÄ Â@s§yãê1Y¥>VAb¸¸*Ê*»úªÈ²j†ˆ­·hYGê“‹ùä<›ÿÎúðˆ[¨@@O“C-ÒÏÀtÓ ½PeÔÇYyí–[JWÝÖ`*¯JÍ—4Óº©üð&¼sÒ‹}PÜÛÁþÄçÍàW¤u–X8ÎãÕ ‚C \üã%¸à"<,hìa¨_6¹ÄTU#JQ‹&@¢ dns§ "(ðÀÙØcQ¸J Y€ô#­®5­£MuÖ3ŸÑÎv'`<–•»¤1w¾+Á¢æâPé9Vº’ñ°æ%ŽDg‡[;Sò¼Æµ¯ÕÄ<Ô3ÚxÂ6CÔ‰^­Ø÷ò—¹¯ _™›Þœ‚«PîVöY~ö¡ÂCú¸.,P‚=ÎCù€ÿ©Bf™Å\.s”á܉Jt˜ Äʈ?TÕÜ,¾òUÏÊ2³DŽP4,Ž ™õ€ <€…!Έ#œ:K5¼š¥#F‡#¤Tž)—'²¥¢]fs—ãÃ2í!B}y›[¢X >5…)·ÒbúÕ¨ZFŠpjÂáx!„í™°/ÕÌ2:ž,ÒD«x˜ÃÈh6™GXp¤#à É0†±™y4³Ø…ÝüM åñ(鎅½Î ‰Ã jHŽ•:ÉCP†2 $ùauJùÂZÇ$6)[+ãåž%âi}ôfZ¤¯¹YÑ+öÁaò‘1 $-i;C¢ ¸3pO;ƒSÇLÀ>]4]±›Ó$a£ ûLxŸª.ë¶à]x›UIê3Âa•Äš‘ŒŒu¬I®FH‰µè·gektÝ*¸²©]<öIvc¹€ø¦}ý xW›ÔÄŽ°>‹‚¼KR>lR÷ˆb1 gÅo†`°€!`´2X)æT¦&‚I{`«9Á ¾OS*µË Gõ \œ3ƒïCÛ¢Pž¼#@²ɬá·R›ÒWkÖ‹U¬ÐIñtDÙ¥JúÆÑMeCÍÃVÚÿ5–­ €AÆ;áPŸææ¥ÙmÊa9§…-R_á GÌWÛÒ@! „ð;¹ý2¦´=]³¯ÌÏ;ØÀ}ÔÈ–;³Á-M³­g Èã ¹-‡ýüg¦}øªMûm<"5àVë¸a]ôq•ëŠ.Åx‡ÜJ(¥oLÝ6­’Ç Ø4½nÀÝ ±ÖöˆÂ¿öpŸÙÌf·g’BL °/_á›Táò=+æ-¸u©ÜØVõZÀï8° Þô†7˜:CRý,o],¡WvÂeæÎÚæ0Òüœd›iW1pñYI߆ûiЩ–¹5¢´ª”;å¤ß­<†¢«ºÿæ±÷Qð~ó»fùX*j”ÜÆš!2I[¼•ß T©®¼z퇋‘çAq\´"e›Ý8‚=|ä¾á{°C>™ëyðz6á š'~ñîðt®óÝ>þÃúŒgp\¯J-¹+Æ’ñÒ­nGW͹P‡úÔoBõvÙu^A±—^IWN®&7ä\mz4pŸ…¤¤™‹„Ò¿¿JqnºüŠ>*>w™19EðÝANò`GŸ7ó Á<¨ß›ë#Ä„÷èþ´Oóî'ÞÚ‹¿v”üLäÛZ}€Žcù)GÜšÁ•ªÔù²‚¾éLq·Ü]z$aszd£V‡'Ð]§±ÿu\gâvTÁumädé£Ej(eYm± _"`¸@uT2`wWr7z·wÑçP¡q +Èw³C"ÕÆx;H~=Øx7÷g~öx½óaöƒ†IàVšç[UrbãæO£tCSØ\Ë€nU€pUo,Ãz­§€FXX3°³3¬±3ƒ„2…^¢f#c7B>ÍÖˆB0‚:UZþ…@ÆqÒ§w½ñ‡/H}$ÀÖgˆ48;$01pxå'p[ÓV~Œw~·~E¨[EhÏÇq2DhÀå4bávÀÃh/F…­6v… =Yx˜ÿ 8ZW3¯!†SA$4dá1és¯åQâWQ%‡Ðl! uH¦@g†M=`yÇw+è…83h}ŒPN³C%ç ÀˆI1<ð‹7sã—x”hm—¨[ù8„í—sžHŠÃŠR#Š^cå[©hŠž·I6eu<‹$ñV2‘c •öf'  € A^¨üð¿È‹³±:eH:âZç%*ªŠ%j*xÕhç|ˆÙ§wa}Õw}åHˆ¾q z‡@°-0‘­0®ðˆÒ¶x•؃‰×x¹Õa:7Iœ¸mYb24™×Rÿ5C·h ©I–Í‘¦=yz #ÙiöðZw3«’ˆÀ:Àh{Ã(*6B:M¥RÑF¡fA­Pq†Àq%‡w—‚³ó‚Þè“Bé“áè“阈'ÃÀˆJ)A°;¹#m3gšQyާsô”UF¨Oƒ¦„Bç[ô÷•Ãs‰AP-WÓ®˜\Ý¢<u €5a&k)¬#oÉ27€‹×g#ý±A¯—x ,Hp¡ÂZ)I{©±+¾äKµƒp¹‘)@Zìäk(ˆ¡qŽ<鞇X$0ƒÕˆ"GɈ0ñÒ¢ù|QÖfÍÒgX…•Ms@§ÿ•²)› 8<^©y+Öh½ÉVâb\rÏ•–6ñ5"A1Ò"†P9úE7ðzÚy3Ô™Y¬³:-j®Å€‡N6(¢‚X5¡b! ˆ³ãw9é£ÞƒàX™åx 1”ᘙ°Žù Ð0hñ¨[òñˆ'„šŽça<§U¯yy³) ZhN#t2tã†t5d–ý¤\°ØC[SlI‘çR‘ 0§'C¢1°Ab"°¢B"ˆ¤’*4*Œdá3ÊN*7`/)™€™#§}ìYŽNâ$åHŽáˆ¤…Ø›y2®à¤® ›žXñˆ€AO¾qÿB‰g[óx‰CØš71TI„CL¨y±)¬I<*¶Š[RVEz×ñЦ‡.d"‘©r9׸paY÷+™å…j¨UÑ¢¹pÿBNÔFM¦O53Ô]ê©òÚ“Ÿóê©$`¤áHˆÖWrÓÄ0qªðG<¯ «A0 !CV«£ImŽ÷xôd„„Jˆ„ÅJf¬^Åbû´e–ÌÊt^òh§TJ(Qϳ 4ÕZ9€4r}Ř¢*J¨×é+f±d슒ݹ®Ù;±Sët†C3¯åXKû“¡:Ÿøj}JëÖ'Ž…ˆ@C0MË$ðm¿ÿ/ [±*€[,°N‚7¤ÉBœ8„jbhª±Ã^•yÀ•¬WBV7t¡ýçÌå·¥‡.Åé-çYÆ*÷ò9"˜Bb°±‹6ã?‰ô³3£MFN;31'°´žK4¡ë¹øª´Rkºžºwh'È'c­º•_ -Pc‹[vrN2x0-D¸[¦\éUpÛ K¼áÖyýt·ÿô¦Ïê·iE²ÖaPjœ&ñ%sÔ˜«:¤ñ!Ò­à:’#Ù#ØLÆo+I3èä¨ç®ÞX;œÒH¢û¹ä¹õ{ºIª}-(l–µ¨z[kyòtA@Âñ'ÓÿŸ='¹ƒðT%ÚöxF@ynÛ±K›I%eÊ„)5Ê«hÉz¡þwC$ñŠ8ÔVÉ­ÖkÙËqzªWƒµ+´AË‹53{è´¨Š**H{Ý™HÇH´EÄEºD I<º§«“$çqÛrŠ ¡ÏÂUBÅ›I¥¹E•öiFÆ@¶ügF`ÑbhËUC‡^i¦Ç»yºùUc©¬%LPÌEÂÑ+½ÍJ½å2¨zá§:Ÿ‘¸6둲1å ";b®}é?CËÁHx¦?EŒÉ´UBò»Äîy}ÑgrŠÅ0±-­jQƒñè%ǵ¸Õs¢9* fÿŸÀ,Û¶mï§ b:¦Âz›ú•» ·F–ŒÆ¼TÈ·(œV©P*ûÊ3Èž!1ó'2Ž+{:Üoœ’êtp™ “Œ¤?álB™<δåHôË´ z8r†‹­ë„§«ðm%ð¿]ËÅð‡1*П+¤s|„——Š<©H-·I¿ ŠÂzŠ›G̺twv³•gå]ÎåÓÝÉÚÄÁÆ™J™Ô iÔGÍd «I-:yRmÀ†šýøgEˆ0qÿ±:s'Üø§h‰ÌÛ¼fmŠ#<¡Ï‹ÑU(Pnm²x¼lÙÜ^r×ÙlÙôGöàuÙ‹cxÜ RÞí!‡-Ñ$-àHäMÄ—ÜØµ•Óö;¯¡!¤ì¸]ÛÒµR²AÀKóðè,D˜sQm`»,Ôgü¨jÀã A] Þà` Ü -áj¬=ÇœÔh}ÑozÜ¥CÄÍæÆ¹Ç4&â/ ÝÂÆ˜‡1AYŒý&˜+þ¢„j[†I;±eãgãä¬?8Ýè—LÎõKº– Û 0Slä±ä¾Ê%°4,¤[9—fìßàª9wU¦ïH%r=ÿ÷‡FÇbfÃ:¼1$nr,Lj–tÏëŠÆí¼ë†CrÍÂJ'ƒ½xWâ¶"g¤Óu{b¢6‰Û½VaÝdgž»rŽ´ÉäçÓ3ºFê¹³cÛ•§è,›žŽÅq°¡ -!Vêú|¶‹°ý˜ïç  5Áˆ`æmLV·iÖcOü[fý4`mŠ7¤n[’{ۼĎ–rœ^Òn„@ƒì¨Ñž#þ6ý¦®7CjĨ>£³>\[F4Mñ÷qÎE,ÎNîšL4è º1ÔÆ”‘4R²Êº«²»O=I=÷g@Ôëïî÷­¥ßL¹ÿ„'vbñà; ±ÆÀzÖ?¡TháåŠO½u­Öõ0Mw=âwe—#3*7#J%j.Uïkaãä½É4}óåîØ¾óEì¹´K  Nõpà›þA@Ô¾õµ¾Ú;W}UPžUglA€õ™}ÁÈq›§˜ðL8»J3ö³kûàÖy Öjo<.Ö<¹Ì!Ñn9 …w>]-_ÝÑéo°Ck(g/?ý„ï(%àiÄ)D#‰oÞ´åè?Ó9½ˆAMš-%Sú[%@-®zï˜mAÀ”©Î[¼Å0JÛšÌqÀÁ@‚1Äÿð†…>d˜0á ƒxã=zäò£zK–$9²^½C¬tUÏÉ“$/Üœp!çž=M`ô¡Bˆyó襗Ô^ˆK—æ³÷aiÓ¥H“Åz´h‹-J´`V‹dÚ-ÁBmZµj´U+ï­<ºué²;n FC( áá@bC_8xqÃÄ<‚”PŒ!‡”3dpáBÅ2xþüÀÁz<†6Pñ0ã‚(R,x°µ`ÁJ¤MbŽÜ8R¸Jš)k~<Ér%L™¿PáÂz^‡ôÃF-æ8š”žŠ¦å¥†jïjøÿ¬XOÌóÿ¬Þ±^מH[–-ܶGôÆeÁ¿·Žp ÿÔZb­ L°ˆdìˆÄ$:H3‚xA!Ïrxh!n BC‡.s ÀL¬Ã~s€µu{Í Ù¢ÑÁÛf+È"Þx3£6(8‘:B ¹åŠn9•¤IÉz$Àiºë®c‚ ¶ûà»ð4§Ê[ê*¤Œ:á=3½ó¿^¨/6Kç½µäÙ¿·Ú’ ¯¹ö”çž0P­y†0ä‚ ¤0±C!z!§Š"› 4Ï00Í•ò¬CNÛt bL¶[‹‘6Ñn»­ÆA•í¢ŠRKÍÕ}Ã(HŽ("2×ÿ”ˆ<ò8”œ|®Išœ‹n:tšÒJ & ÞÓà;.ɳgª¨¼´Ç½ïÎìªLo»•§…¼îÂ/­yX8—…ê´O¼”K@ü¤б. @ÎJˆÀÄJÐÓ^•Ã0 lÄ rø¬ëLR‡08Í•ŠƒxQ1WD¬c×.2ÈAnœ1!‚\tàÕ×`Ý#A&èGŒˆ6¹_M¶W`/°N'ê¦äé'+A$Ë4é‰V©¼dš1¿å*\»¦¦Ë?y^ «„²Î]]þús7O¹Æ¦·ÞzÕ•`j“HBE#æƒ.€`Ñ(£L² €X² 5â‚z.ðôÿŒ[Õ5™k=L ƒDK<6ƒB}Ñ¢XYvõÖ/èÇ9J®¸•Ì5ç&w–Y }Zð†,¿Õ ZŒbd)§×3³L»š ëž>íò/üÂ*áÜy´îš]° ›@?(zß1Ä` l12‰B‹ˆïKïžx±Å>¬;â Œ€ˆp‹;€ã±g c9DZ5“CÈòÌg]ù¢~Ä‘xU'é X1Yi³4'VRO±D@`[Þ¢xÆ”FÅ(\ðî1ÂÀ„¸Ç Þs¼á¥¥xêúؾ–'Ée„ÒƒôJ KµÍAؤT³=‡@B q\ÿÁÉpˆaÛ”+,f)ŽEèE÷kœ@jU?àˆŒ6ùQæ.ò¹•m$sµâœ]c’ÒÎ6£ K"G%A‰'ÖéIƒ6 "ˆ Jœ¸Ò­2±§=EùJWz×»{`„(¤‹WŽÇB­q­\0üÚDŸ>ÏOF,á¨ÇƒE™,BZÈg>s„ŠØ(S ‰L”#䀺ŒgFS°Ól†EˆY£84Ž‹8Š\ \uF3ú¨}Ï<ŒÌ‚´¸™ gt¥c#“´©$TÀ«ƒ€•( |„òX Òi&¶ó‚p:Ô¨V¬o’ëJ>1 —;(.|PÙ@iDÿä`˜¢Ð“) ¥Ìe$³Ynaâ¥N³Q*".e£Ž1éG*× dUˆyͤ–µ4kÎfR¤ÐÍÑ9ËqΰNbGd©h$€€Њ@ jK˜!½ÕN4,!´ ^´ö{ªÐxë^YbèOÁņ94¢#A¹Ã dˆ_·Ñ^sP!Î$ä2ªdHaZ$ËÎàí!£¡@KfÒJÚ0æ7.Ò"KÀ å&7Iék÷Ò’ª±e®©&Hn…œá€Æ1N·“Ÿ­î9óaAtÒ©âzêYÊŸv~å\k: _0ɸàóxëºmòbØÏ;åÿ¥†Î;‚XƒK F á ¶bÂJ¸2SyC Cލ\mtX‘obÖ9Å5ö˜…EHn`ƒØ1Žt6,uie«)Àg%7Íé{“c,žø´'® ÁxCD  J<Ñ)àúàg…îÔŠÑŸïO.(^„o›µ}î@Ìs‹' $Vt¢4”·†bˆˆŸ¡&&»rH4.)اJ‚VdŽàüÎ;Ø“~l™Šýnc]¦XÊJ1ÉM{…Y›8Puù} N@H ¨ƒŒg·Š­„‡Ë$ŠlÁ-é0åz¡ ]¸U®¶YOckpÃ*Ê ·Cÿ"ö[ª @‚ÁÀõêÌÂ$*¢ˆa£ò+E¢9ß`¬}Þ©cí'Þ”ÊÌæ-lËÂ’Ê~d‹“•,Î2›œ¥h<è‰cJ V´ÂWþÎ Y‹•¢•á¼õ<¾lA2óúxÁ…0>m Cåµ @œÔp#MhÄ*Õ¹©R…€Š)Ë z{90‚r°VBc ­hÐP‚C ¥à-fºÁ‹LþÆpCNMK!ÞN'ìí§éhÌö´'tSª!P úø—g}à[‡€¯µ®kkL\×ÇÀ0À‚ ÜvÂúÙê€ÆÒ[€ÒkÙË.¨;tV Þ¦"™ÿXª‚ílk;£ü Â_êMl!Ó¢¤½Øu‡lU-ãþЈ^g®,ßO÷´§3ÙÌêÀ2N| À,ÏÞdϺ Æ9¦¸sÖI©øÃVñpêºá`¾¸™¨qa×½ØüÉ“[ô 8ËÙ„?qöEaŽPTÊíPՎ̆jžƒ}dÛÅḠp @à 8€c0Ô¾• Òì–34úYÅÛ±K‡7§9-N“ŠPïHLb²+úôXt{(¤²D<áKS¸Ûç‚ 0¥øÅ§xQã^T^[0¸kµ»Öˆr®ö³?}rÞ²my„ ð9®wŽùH hë¾æ‹×vãÿB0 Xï$ÌA àŠ Ä[¤ƒÝñ¤CßtÏÍìdl:ªs™z‰Õ«“‰¬Êblêžñ7>R± Á6†¹Wc §¸[£‡â°+1¾ˆc;‹«8]ƒy°%{Œº›>6Ë$·ˆ°2![*Ë»(ðA¨³š*7‚“Œó˶Æ3 4‰zWø‹I™ a C‹±Í{¦Ž9=ü3)‘™Åù?™é yC½ö ‰.$À|kù³·ù –kª‰(a‹R<šË6( @„|¾â›8¦ >ô¨¸ã '¶ãÃ>„8‰"·Üb‹»Ó;yá­‘û$íË# ð9å ±•K(Åÿ`˜ÅxÅk¼Æ£9ж à¿08W0h®„0 O!/犯‘•ÿÅgâB.ì¼  ŽØ‘/Ì·[„)$#‰Ù»` ˜mÓ¶c4F#˜C(ˆ£C㫸;¼Ãg '書æ3A(Œ½Á*ݪ°®¢!=©¾zñ»µ¢BkÛˆ›˜SˆOl‘…ñAÇ ‚VøV£ p…KC› `zBLôý[)+ì‘ÿÓœÇ :!ãÑÅx•ù˜1$« FpÀ à€y€xdC8ôÈ;ü€ãcŠ“ +£C>êÃk̵ ™@TÁµhA‘ßÒ°e{€m;5ÿ ?vdG Q%c܇Fdˆó Â¥ËO$¸ŠÐ§5Û¼x3Ì!àZÄ[Ê(«•KGuLGLY•¼Ã PI Ìì¬FäsšsÁc#ª¶¶P2q“ÿC˜´%à3Íd¹ðó›ËÀ¶ó‡aˆxt¼·ªG‹iW`›ÕtH‘_‚M¯|¦×¤¦ÚLÈc²Eˆ¼,â7âä‘5’2ê4âÜ‹jGš³K›Ëª¢¾œÆè$É NêXI+ÛN>„“Ä4,bLoÄ;™Ìܰ cϵš€OÍLÊ z+ôÑ(ýHy̶иŒŠ·A±÷;¸,É&Ã"¬Îû¼Ñã…4=® õ‰|Ètk¯K[½zó”h;Ò¦L¿u Ÿø@iœ]QýëL>*ªb¢m[«ßÏñüÆ€BO#®9;¹ïTî3«ÅA¿‘ Uÿ²O&4R嬹Ðx1úûOI™øÃË:UQ.GÓT’PȲü.\!‰øÒ: å \Y¬òj)áÔв€šûÈMÖMB‰’g<>KQ•¤N ÈÓ`VëD>æ“Ë<ºA]Á ûªàú¤E”39³%¼qDH¤.ø Ò‡ TÌØ¨ëÕxÔTø ¿ðщÕ °”/Rˆ‘Á “IœdźÅ]„+ ¯ á‘Ò0Ø Ý1ÿ¹±pÍÏy½ÔÈÏøÁ°Ø ´Ø؇Ø|À!À€á{8éäÀ•ÄfEÙf0Á¬’?e+Ô5ó*àŠ³°* í»¥[ú³ $ÿÐÇqm‰‚ˆsåžù# WÐÇ5µ9ˆ@M!ÅA¥"Œ?T™D}Ý1‚œ7.åBó*Õ… R»™ËJ¬Ãº!3À¶‰‘1 ÐX# Ø}ØXŒ ÂB„¡‹D¹’r{¸T(ŠHB…>H0„ÈÐ?Cü° ò…!(´ú×* © ¼ñ…6l$XagûxóêÝË·¯ß‚Nüg¾ +þ(*äš0 &#›&„p„úž 1ç‡yóèuþ'ï„@Ѧ=ßX°é‡üæü@á…–S)þøq-$kÏþc‹–àÛnª[·€½|öœÿN½ºõêùòûx{ÛÅ«-.ÿØ@iàDh×€Y XÁ’Æn¬šÁÑ<åý»7Ð~‰Ô6M„ÈA¹$?Qíä"?$ÇYY€@?´rpCÜ0[AhÖ fYÀZþÛ@¿Á‰nereáaci&Š$ÚSãŒÞ¹(è „BôOvùx÷AÙÍ—Ø? °E‘b à"$W$%Y‘YQðAà' ÿü'Ð ¤êÇ_iôØÇ¤«¯–ÿÀ‚i9}C­Qm$o¶Ý°Õ?ø@fÁ›nZu•@H€V…eI¸£±H§wÙjíµ×%: Ø–à ´B¤Ýð‘­´bd)­K„`MYÉBg¦Uy¤Ã?NÂ: òܣ߽k9ÏOܰ>‘¢µaAf!°­ÌyÁ˜\ ,š ”\T-jÐS4ʆíÊ,3T­Œ/£<ÐæµÂF7¬`Á*eÁ­DÌQ§’Jš@ú ¬AüáûOªGÜ5üÊs/NX£™Vm?à3Ê„nJxÖ†l<æ?PPá[[…½ÍOíd£=~ÚòÞ|/ÿ´ÓàjÐF4›.ˆAb‰CºZRŠÔL% =ê©TZªüD€HÍê,|,`¦_»-Є£¸Ù Ú†@P c4œX(á&ª°StÑ•¨í±}'ßòŒ‰°XDy‡È‹!ô¸¸h%ÆV+MÀHDÿƒ*ª¤UnÁü:¿RwþÏç9|Îô=,ÜZpiJ²€øh$PKV1‹Ø€ å7bšÀÆŠ3„ÞPÌMt+]ìq¢¥(ï‚}»Aà¢g¨0` +`KUܲ !Ž,$”€¼B ™0â|©ŸøHŪñÇ`ß?r ÐÅï}xÚ<ÿ F?›,%ø`ÀFŒõCpè±A¸Ç6· AV‹›Ã3“Äx ㊨ƒ®pˆˆ D¦©'žPs™TX°¸%åäGa!hŽö´S $j¡bûÀCä@ÿ0d÷SµÔ1(Ea “D C8ñ2aû2&¶Ø+ž”Àt畱lÑLl1Ñ?T"~â!bŒe_Lö2ˆ¼l>üˆMáF ©8"â!0eJCJ Ézü@f^#«£Åpˆî;!)C$tG°š~²™“|(å“Z'Â+n­ø Ø(ÊpvœªÀS ˜ÔR–ølÑôFðÿðs.9£HÛ2)Ëpkœ Jg”òÎJÿ¢ç ¯DZó˜(ÒVu‚¤$˜ÇJš¤+\esÓJŒõIR¾Ž“£( .~RîØ6Ò‡!ʘϞNG©žwVÂØ&+B|š’H'.á ÁHÓšdÎs…üãûªIÍD$FCZM ú$«Õ„TŒXÔXT²¦ËÄ’c!LŒQÜ@ŒNcKŸú•:…#ÈÄ"¢¬à2‚ŒJ QTĈé™ö€Àøô£¥©V4‡Ô¼‡ÔÉYCz–‡1XXûõyàòÀîu¯L`)Ù@ºÌ$«ÿ´Äc†È$>j!!7×ÀEŒ…7½¥å¯ÈíËvÒØ–æNJS^! ÿâ)/4O`r¾>šæXæe£YDD´H›•KFS‚¥Éƒ&{dRà’’X`l+QÛ˜&`ˆûâ‚M$K-þ |@n ?ѩʒË`†LC€Ž„ÎE ù”Å2CìZ‚Ÿ÷"eV©RB:ôõК9ôêû²9ýÔU¤ *·^-¥•-cë°~`ûL‹EdÞ6„ÄÀƒJÞvºà;!#HÌ b)DX€$ÐEWÄBZÁ­@Dh¬ŸÊá„ 5Ñ2šÃøñpÿµ'¸G<ÛÃ93Íj-VïÑèÑ]´ŽÉU0Äpq æ®qÊTŽ36¹ Șé€H}õÉN6™ô3h„”È™@ !ó^3i%¸‡yçÌ/ÐæP´îÍýìÁð–ê^öù” i3¡k°ë¤b’€²È²•` qÅ2ì•!¨É˜np2½r߀D…Ô¨Ûƒ.8 Ä­$yw:õôq“IWuñÒøµ>yDmi ¹‡¯ß÷Ãóf3¬Ú”šMJ—ÞDSòü]À(®1 tŒIã¬À¢Ë’I)Vˆ7À˜©@ZÙ×p78"¹ÿüÉ?>øp!Â;ÑG  4¥8!)‰e~v”ÑX­ªK;ÚT¿*Ö‚L~ a_ÐI:y{›+APºmÉ ð÷2Àx¢@F)uQ¬ã»AÆ2€ÁcyÊ‹&÷+ó€:‘}‰ÙÑaÿ \  kו KÇ¢@ãã /g4~ߣqRg:WQû!A/¢–Ê×B :e#ùUÖoñáÅ@ËÑB?¸Œ[)éMj}>i—%ól 1唨‘aS™¬Z©]—•JØŸ!î3w|ñ=TÛ/‡ö½ßHe–~…uˆïÛ×¾Þ¥ÝʸéUž2¶¨BƒÆÿZèù Õ“¼ã dbʦåÅ•©%ŒK‰ˆK ”ˆÔ ΕËØ){^qX_va €ˆ Y°ÿQ:u$uUürÙ§PøA5û1Zд>Ó·*¥’ ‘%Ê7IS×ý£,¼ 7 ÉFJ¦ôU!6ÛÆcjsRñ‡AÛ¡-÷=’ù)t'"¡Xk•N^XÜ£!᢮_–õàuZSƒ4¡1/¤qC9k10Dzv%ôrGN2ROòÐ0ø0;‚Æ?7IG¶a{ ¥TµÀ~¤¢Z©µQÅ' x|4^xpKc:Ñ*Š70¡8©b[ÈXmØഠÑ[á5‚Å!aãÏP`+Q^„s¾È2Õ’(Õ«Qa<)Vfw‘²”°w„q@å!>R19æH0è³t¤^ŽÓçU—elF#5[Ø*3a4³ÖG©…¨U}÷òþ‰2ÙZGlaƒµÿø[ÿ° £NÆRÿø‹Çc"@ìBˆ°Q‡ueBpŒ©öe­á¥¥%ä£/™gç…fùY[^MÇGOóbO‚’âx9øVüá|àïh§˜p4Ò Ÿ„–‹ SúB±tATCäZA¢Ý¹ZA'?Õ…y©-ö$´">ôò%×—N2Æ„÷‘WL:]±£ÕSî± ÈÀcÈC„Ú7¢ ÃJ-B‰ÂˆEõ„asÇ£Ñ, SHž¦I7QЀ¤Š•:¢™¥Q…­C2d…1y¡!Lè†Bá®V9Ò¶ädaQ6½ééñ&&2À¬ ñ'$R#?1#["*²¤ù°ÊØ.!GXú BèˆZœ˜­$)M)6ž*ƱѧZÜ9ˆ$:Ñgp-fdy…cVÏT•­êM°²]x4NaÆÿ’—ÅÑ {¹“ùÈc6(ö'°w¡-7â' k(€B# #p_Ìze qea&›ùB0©Q0]ª­m¶C‹´±)F|Åx ƒúbxœª²«’¶U>);Žа'3!/h½˜›Xá6nóî1Ëð&ËQpd+´Ü‘K2-$Ò¸ÃúY+€èRÁÀ!Ÿfa¶êC^;Ô­ £Q`k »)lfާi9™ƒC¤’3pT*Þd5Úv;$d\æ&ø°«ÿð Ë€–¤q —f¸ (š–´Þ‘( Êü@èÂ`mb€›KxþºµÿæµÁ/#›Zàûk%{tûMI®A>^RZu³…¡2Q‘mAÅñD 2ddzÏPq»Ø:U¸Ì;ݱ° [F°¡°O±\ã¹¼'.–„¡eÈ-€>g;lƵ ¶µ6žës¢ÂÑ]šã>&‰‰G#öAJ1¥=&©»Ò¦S:ZNb¡~½¹“Ã; ¼a2¯dƒ<°*’¬ƒ½æ1önwúŒ››ÍÄ ckD'M˜9¾U|^ë>‰®Ñô‚x±ñeª,`µø±t›0f˜l4k€–´Dz´ gúU£+É\¼•,‹ª¢A!`Sj-°têJcjŒ®uÊS:Í5³m¡,ad1Õ |ù …fÇÇ@kÀÁJi<‚SFÌóx'¬‘l©ØHUc0úÑ5ñɰ±F@ ‰Sú0­-`*$ÕgVt¨’Áž!¨›ËB Ôw‚ Ëp Ë@¼u…sãæ®±ÁËEl° «¤ÂŒ´iDeþC4£*Ût4\šHHÇ4u¾üÆÑÑ—µwöd}ô`OiÝ‹ÿ¥E- Æ|&bŒ®¥ñ(û43&u;¡âg‰¶V÷Õ·;Y¼+2CüKiÔWü ñÀËÝÜÌýÜMœÇ³(ÌÜ1-Í%›øa4£•MÃÿ÷Ìã«>òÖÚZQ€HæåÑ9d=Ú³J3«.·AÎ(-Æ“%@Æ©1+Is/pªF—!ðcp’“tØ<‰hO¡S=i„ÝDýEG ÅÊza¢ÒQZª*•,MHŸË4_½Ñ¡]ª*;Ö¡Ñ¥=¥Õw7ó(ôwZdŒ‰§µ¶VÛ•3d\9)M>¸M p´Ã9í£ÃÛ«ÀáÊsÔüàˆMœ5"e„Äœ¸'#ñ¹ÆbPÕÝíHZ-™c^Ó×€W%K M0Ö¡ãÒ¥õþ(¿”+ 04x5Áß9ž–U‚9¢M¨5Uÿ>±ˆX1E`ÃKv·`W!=ßQႳ¤žÀKš¸™(%d¤‚0®òxžH’A45kù¥û¢>ŒD^ Ûòðæ¢-KëÑç ÊAçA[N>âã$ãBqZ³b>•ƒÁÉŽZ‡>C®‚õÌ¿µ«=½ä$=œÛ1Q”ƒ#wá?m2^ÔT®F1±”¤G-Æb5Ÿ(}Å‘ Ѿ–ãç\)çm½Jt®7¯@ã"PrÛøÚÛÈÖïÍÒ'ùÖ /ÊFC٪܋¶q'15v; °Ù1nBÍ\þ,´?ÑJØÀ+½98n’B"ÔêJ}(ÊG:Œw¾kÿîÞ¢Íçì$8_†»Êö$Ô†eX‡õ .úÊ¢ë8_ð§-*íU9ŽÁiÌÍh²á6P ¸ ;M`v%_ƒ©Úné:(#P¤Ü±(Lò4ò(tô¤¯¼^ý]Ù•™Ÿ[ž`Ùb k5dCܘʞö Ú‚.­ô+ð àæK­Zó* ÊöyâCR}ŽKc4A¡¿uü&:ùG,õá4³A¼zC™¸1O‡jú3pqc!ÑJ/(ùxÔ'ÍXÚÿPëalóøŸìɳ™Æ_”øÊ¿Š¯øŒÚ ñžò"÷ñÖ;>CüÖ5+ÿáˆU Èp Ä;S#àm¾FÑCá©çí9½7ÌÑ#A&¢"¬¤Ã*¼ôöÆat óþøÇâß¿{GÞûwä„þa`xðŸ–*ÿ™$92d‰òN°h!) y,æM¨ðÏ" †(üûo°×Fý@ô_H–üôñÑÒí[¸qåÎ¥ëV¨ÙwžUY!ßY³ñ¬ú¯€=~ö àǸñAD6ÿEø×ŠBY &€œ÷téÅ{¶|hQ^Å%Ox0DÈ(Bc«äù¯­ÿůbæþ73·NJ¯|DðqóŸÜ-JÉhÞkóZÌÛxÐ`Aé, B¨Pö ÖV?,|m&6ÂÂ!ùyW×ý{øðù¶\`¯E½{ TXlŸ1â>°¯°µ¹ Z`+}˜û€‘ƒZûÌ¡ÓD³¨¢ :H£::žè1*Ÿ’òùÀD–ÐjI7gò!·™B²©8ä()îJx!¦¶$Pé{B`$„Ö:c!©ƒžêl5ˆ2ä ­ÂÙ–Áå‡ SÏ6Àþi/>0à “Ÿ¿î,¯Àº´h?Âì)l±ôÚ«J­¢Ì2«zPµy2¨º†F#à¡ÒFôŸBÿH“ˆú E‹Xº-¹·^ I·à,¢l8mâ-§•þñ±Ñžû'ºŽ´Q‚" :²£J`UᡘƒRJd€Y˜.³¨=]½ÔÇ5…5®üŽÍë,2—%óå¡°åïe•¢åÚ5 ðŸ™Wªó ([aVD2ƒB¨¡ŠJ#t¡ƒZ=(ȃ¢Hÿ8.}vk)&}ãú-8‰£ñ¦›^´ÔÞõ1Éž¡ó(¤‹»„æX)hEÊQ2 Ÿ´üX­öFþõðxXòuq–ó‰'ñÁò2¡âÉÇÄ¥¹e•`n9Ml›9±·þB¬%ÄR?è0þÌb쯊‹€ß(o@¤í® ÉéA3dH©Ö\s7 ¢¬Ž4¤RœôŸ³å²ÔlUŒ«9‹Œõà|î"ò£·rÑ $@„²™ež¹æ‡Uúr¯÷] ­=Ë㩼æxLpÿ ̽ ©=8…)?kú\^^gûäCZ‡ILb„3ÅäC1LÌa,ˆ‘N@©%Dÿ˜, ,šI•i¢A¥ÐwÈ?@²6’¤„6ùXÂ+JY .+PMTáš'vþ:?Õ–¥¤]Üs‹Ô¦³°WQÀÜÂÇ?2–¾eTqNÀúŸã„ò>÷ öcÿ1"pŒj”V]*` &&ŽTŒ€à”:Òñì8 J£³ÌíQZ|„‹="* |«h¯qÎgþ¡‘ræiQJKJR¢G1ç'-Ñ"tb/—¼¥k9Q"œ úˆ›‘À,B²äD¢ä"y É9¢2Ä, ž¯€E}€ƒKÅØF5®îKi$c3 ó¾“Y„Z„œÚê0øGÅÿ`ó‚D£«‰FAzÓÙ4‹>nÀ/JD h{ ž[z§¡ß!J$Š É»ò‚ÕÄòž„½øUJ lªÄ‘¥„s›¼B‡·™%#@E¸0Җ⛠Ш¤±g<ã†(Œãr͹ Ó=Èi!ßh ¦ô}ÐÄ ÎJJû´T.üãA €Ò|x’_ @å™.y(„’:ˆúH’Y¾j“B‹ ‡ö‹ÁG_¥ìnzèAêyð8¯ W©GœÄd©ô R»à¡FY…”Á.À²Œ¿é1š`‚BHêº:ÿ¸Å*È™bT€¾ÊÔ¥|ÕYKoZX0±œË_ ÛGÜÿlY%, B£ÍCw ¹ÇŽ ‘¨ÅMžô@ =©FHé·ÙQ[@‰¼–ðk/RÅj{!J8ZmÉMºD$ñAô€h\&ðpM‹X8:Wè®®„åk`—¿†ä±îq,`÷ê]‹8.þAD.c’à=D¨”܈ÔDCª¡I(ÀçAXû–,/_ü:Î)«:“„ØFÌ£KpÝ5¤¸,Œ9Wáe„ð`4cb©5£{aÔ‰w¯þ¦Eè¡£ºe»áÕi“ð·ú˜uœ¶õJma¤EÉ,íA<«e€¡ÊIÖX’_ /¯È{‘dêõ9’ÿ‘ %´ Ü© )µl‰-?ð$D´b`%–fà¢È„‚}FÌá¹@¯w5Yvç bíj Äÿ˜³H4â좄1QçJà‡0­’".H Ô€x)Ù$\æ©ü‚ ”örN^»‚šD/$6¢Ì[\LóØ"àÌ©BФ}&²ª"pA.þñ‹ƒ@ãÂX@êJHÁ¢.kþÇ™Ãg]{X.w¦G‰QªS ”êP÷؈ª\ƒƒ,ì5l‹Mñê²ÚäEºµ¶ 2trƒåL”À©^“ÜÍrl35#Ž{•NgR¹øE/ q h´¥ÿ¸5›«{Óëúºm(*ÿtïì0¤*Á  *¢ê8t1˜¶ˆN¢(‘D%ÇÚÖ@uHƒü#ˆIY¼S²ûŠœ¿u +ÏTB¤&,ø€ø™ Kø¹ ø?r Ê,öÌjf³°  £«  |EºQ“Þôº]Xw¦:žé|†8ë7™ì  ¢!8B¹  É(Cú:J„"Q¿¥,ÀýÅjí ªzrµÞ‘¥°ßbèêG=HÎËD˜¨ÆÑ6‰!lN™)ZÀðÿèE.\Pï@ã*É5Ö‹~WÂJ»VïµQá 绵Î.ìuçå‚çªWáo)±œÿJ•—§2Ä .ÿ{»u…´ yͻ왰Í¥-ˆ¨{T-âÞEDrƒXM—$çÜz2Z S" $ò@Û¾á]àŸCCgq=†›^ðíƒéRW_¡={ü‹ät1¹LÑÖú`\°D ˜¶µq”pµ¹°;å°²X–ˆp/y ¾Œ‹² ™Ø¾<ŸKÄ ¿°˜,K‚ɜ˹^À̃ø0¹è9º º¥Ó€¥Ã.‹8¸^ÛÁû:hÛ+z¸¿ü{3ó:ÆøšhÊX.`‚V(=¹$áQ´‘¡¸®Õê¤å;†ù‡¦€1‘YÒ‡v©¯œ<‹¸„ÿ  „K<É{C±z”ªÐ‡«¨Œ¶Âòã¯íë…h@„†" -¬»ºðª?¨ƒ‹¦«¿CŒ&ëÚ02½"Œ¦ƒ+18C©N²!hÂò†[.Ë` C°±I¾·Cߨ¯G7$Rw¡2”‡¦ ´R¸8(·€C9D2àRðh|\2ŽWXÁWÛ¹ô»„};ˆž[½^ƒ³F¬F¤ã7¶–P½ÇÚ.®Û£Ç’ÆJ –Óó:{Ї à³Ê°P„aè´äb‰×8‘ã“€\Èž¼Ø±•à;ï0 ³ºˆé‹¡˜ ô86<¼Â³JxÃ}Ú‰<—¨¢Qš"òÿU¥W#¸KP?â«#8mä7¥±£;Ékd:“„:ªëÁð²+ùs,½äÁbÇ÷€½= Cˆ€;Ah¨…t2¨),¸—¸ã$q•˜ˆ!«w1 3™ X«‹8¼Ê7\P XÁŠòa@ÁÁ»„WP…K@ŽKhÁ6À82ž 5t-ýº‘…ì­K°è$ X«*Á‘KK³ì…ÉÄÌC”Ø+ÿ»:ꊬjDI¾D:«»ÄÓ‹³ºè®êj¿C¼³oœ:•¤³ë6B‰ð[G‹˜LaHVYj”Ê…QÙ9A“º˜¥Yz¡È©Œ¼P4û”Oô¬ ¹ÐHËúÀ«ä-µ Š…Nì4È9‚²ˆ^ø…,‚x,z€‚Œ¬žS³¥“P~ /¢+8:#ºELNSùc̸ø.è”D]kIÀÔÉ÷îXÇñ̨…å²€WhY⸷ó‰ 5¼;¹ØÌD¿)#‰˜GÓ¤‹ÙKœÛí[€JÓ ùŠQÁ(‚JSPŸãŸAÄ•=r5³ˆ6H=’¼P¥ƒK U:ÑÓÿºt å´ÐÕ«Îð2Š—¬.ì4=<¥IºÐÉå,G<»AF¶ñʨ…ƒ0Ôxò, ö|;æ¸GÚ0‰Fs´º Y²š¯s!y ÓÄ¡’pµú0 É99|Mêñ`¨ÒÞH^ ¼þáMYD!XÆ@ '$'x,”¸)¢³¢Sô[3aÝ£0íµ»ª«5kÖ<¥Ó–TŬV«ËÁØûK¬«³«³ÇŠ8Šʰ,CÅ(¬ŒuR‰yôÌ| ͓ʿSŽƒù  2L˜ì! ÀÛ Ô ¥× n1²˜pB q«*õÉp‚ós6è‹`P{»!°n*€ÿ2› A*³2C£Åº+aM,`,ÉY0ù+€{ ;‰Õ£Ë¹Ðº¼ Ñ;-=m¤Ö‘t»‡<ói†ð¬ µA@ü¨O•0žÌt À¡šEûGa›À <[ •žøWs*ת­„<„¢ž˜°€a>¬(‹`Ø_ Á´¤ÞÆ”®©á< ¤šZ ÷8Ö_EÙâ¼ÜADÔFëÝÖš¬I¦«&<¬Œ€Â}…²°%‚HŠøDY—yª±|P@ ¥”¾s¡€l•Y„€²òGJm çû¡þ‘É[Hã X®Ì*ú‡ŒäAlXºì…³•XÛI.™ß=™q–“ ~K)‹¸µ 1ptI1½NkÅΠD•4 @án ÄêÓÆT ïeÜ𤠘‡V9r©ŽZdZáy ÚÀ }Y¨¡Šés‹ÝyèWû²—¨¬•³È…4¼¡„¼*a¨Hm‰^hØèZ½|°Í X 3V‹2.'ÿµÐ•¿(ã Ðt\¿xã¡8 ¿™ô@~Ã:a¬è=ªë1Â’A¹|IDa¬SasI•ôV@)i‘€V €!8.r fS¦e½Ò •Ñ—M «1Šé8¾Uy°_Û˜·àß–¸Y†b‹`H@ÁåÂ…%UÊKà„}X!€hÀ…•+‹õX ·@„õx‹7Žc~xt\f‹ã¾à‡9Á‹ªp^.ºcå7Ár3¸ ­CÑo1 BaEÞ^fLDW}hahÉl °¥ê ˆ¦<ˆJb õ][ËâÀÛøÑî³$¦úW°±‘×´Hl‰0Ž*Áÿɼ‰Qı]F/>[hÀ‡ ,˱CC8‹X! cæc.éîhéî-ã’.i·xæ.VdÕÛnþ.ÖÛ®‹‘ÉoêD Pg™ÜÆ„¹gMD˜€ëÀ˜êòM³'Ì™”âè{)Ry:E¢xŽG×~¹SB'¬…ÆÆÙ8$Ê0Žñ¨H|ø²þ…5‚C¿S æ°´€Ÿ¹¶·ÈÑ ‰<ìe&é‘niú° àœš=æfÑ;Yø8a¢îµÉIÖÃ^uæ:-' ‚®a@´é´·ˆ°“RRÈиW¤šG Ð/Ûî_Ã{èó¤èDÌÿÜý'¨ÊvÇQÀ‡Žñù‡¾†’XIî­@îæ>¸È ‘¾ ë.‹Ï“&oÖî¹@ÑÖs³›69-a=¥ì‰¢&6™=Ä|¸ N¤çx¨˜ìÖpíƒh‚ƒè8Òh Q¶Ú²¸ 'x!xÙ‰¹Ã»+…]¸€C„ZÁ^œ &;ŠDAYžåW»<µ‚â–•»Ëñ²Ù4¹ƒ0ñ¹0Ç ·ŠÕàÆd³eµ©Æ4Qï.ʶSG4ŠÉ‹߯E†3<‘²à©v‘B“Àjr·¨”˜—"XÒƒx Œ [½¼æ8ýu‹-¢MÛR¶Þ´˜ñh ÿ†ü_5<{“ÂñhÁ‰­q?ˆ:ñçVn °¢qÈØs¬øŠ­ó·½4“‹–Ú0€6pÉ”N>d¡ÞqìTY"Š#À§ 阣²aÓxr‚OHy%É'Ðr‹¸¾Há•¶˜òøPÝÁ{‘(à¬Õ—^%ÃKFÍ ®ýVtW®“Ù|î:?q<ß§:7—ó²ø™'iñåÁÊñFQŠúk©Å,êúãv¢îÓ³lñ.½¯ –°H)_騥a¡BÑ14•YGŒ"­E˜|XuRfO|’uî­Þ²·šZž’DÍ‘þVÿÜõ¹´|aº­naŸ¾¾æöxWñ=’Yùx²¶ˆ¾žW.Bêò.`„àlta“Ö -píÁpôv¨y:û°þô!ü‡'ƒ\\rJZ uIZ! !«{:HV¥*¥Qj‹·SÚ|‚õ–`Míó9Ý.7ä/  QɤŒˆ×¡œÓ—ކ¡‰€¨Òàx=GYÉ :× ô0÷xqµ²–nYA‹`q꾌 b”©y#ÁÖ] Îjòãð²qßù ú‘´:ËçvL´8˜[ôjêÀïꨢ¢w[|iâ*?%Ô­4þ‰üpX·"/¼›P]'‹Ãÿ0'üÏ‹wÜßÿ½„`~°!°H|¨¢Ž™Måþ$öHßs÷xÇ ÃtYù:‰vg_¤t‹©“x£0±‘)˜oõoŽhúí,Ì™ävGßü½ úƒ¨ùy{ (!ú0ïB„òþÝ“wâÄ‘î ø/"ƒ!þåÓ÷KDB ÿùx•pÂ"ÿDèù¯¥Ë¿P†Lx‰’Mœ8ÿYøwéÎÿ"å‰O²fÿ”þ3yé’Ÿ>…@»&$ÄpBøÃ$a) ¤`èß „†Òþ#ûoX°mÝX‹ˆÝ„xç¶=›Ñ¿ >$,ðïC{þÿÙ‹éø1BÂö>Øc4²2cFcư¡æ*艃´zÿPÏ;ý!½ƒ*þͼ dÚ#12\¢0r.Ü"@¢T¥J¤HUÿŽ/éâ?Ñÿ{ž’&B“;}nyÉxžâ C¨´™žM/™ôùJȵfB%´Â÷׿­n Q‹0­[eùX\ÔÉÕBwýs—!#ൖ!y„b5öA‹åYb”1BB$¤Yh•m›f#öh*ª0Ï‹¦Ñã<ôVc>P¢¡C ÉsO óltÐHò°ÓF WS{•ôJ"¡„ÝK,UGÝJTú ÒH8I•Bˆ ÿ¦˜tU 0 5#Œ7EÅåMB¬iÒ­ôÄ•K?ücˆ_{ºuYþ•àžˆD((Xˆ0ˆV\f™…`„}ÀO¤.ˆn"&bdÿX†ØdŒT0=¤’ú©e.1òÚkô¬šjkªåÖš§}0"eÔB,,„Ð -œð¯'4ìjDñÒL4­€Ü+8q9’rEPi¥cÆ•DÉ´>u)%B  ˜lþSž0iþc•”P¢P?]"„0P°ÂZBÙ÷O*!ób%dˆ†ixÂ{.¨°K‹¸ÁD’rØE‹õ+O&ïRKÄ… å†1y)îR#Õ²o3¾4sÞ(í’t‰*7ý$Ä lÄH ¹2ÄH¾ô{øb£^úÁ£VpÿBüïÿÿF%N9¦`Ž‹˜ÅøA0DH€ ´ާ0ÇÆ/—âïìÀ |àCòT3ã˜TÁŒg¬cYìRÚ|`BX)˜©+!ÃÊHBNä5æT[gkžIV°5ìxMlÅéRNs“ž¬­pC_]ä®Xàþ1Ű„èì”ÁҘʭ‘w à$ ©‘ h|XŸ˜=-Žÿèäøw˜¾}à"ê Èª÷×yŠv´Q!m PðäêŒÑ<’æ’ÚCW™žr”ƒíœÍ‡ËY¨ôI° 1!ª–K¾ä-Jœ¯ÿ<ШÅÚŒtMñÏßNºå}I9B xpÀ/!¾˜ ¨ÈÔIó0f4ã QÍ…ÅKb\KxLj Œ1aýˆMlnsuÍAb×HŽd· S+þØ’V¬ úAˆuCdÁæ˪NBÚcµWúÀj@¢V<•xm$¨THŽƒ/ÅlHü4Ôµ6qµÍ{Jy†¹¦Å%4¦h÷@&Fb8ÁCO‚$ µé’ èô„ӌɡ€:±<* SçãúÈ8ÆÁq1ái"cB$ȳª9ƒ$B 0 DØãIzZ!íôh¬\‚â„&>ÿ`h“jbÊ„Œm•+Q…[šZ"¤'À Br) r¥éÍæ´”ã}ä#“Áˆ+¾è_ $¸E n‘:FPõÚü,oA‚ƒ”€·˜ÇiG¢Ù•ÙŒP ’ØOc»Æüå‚f¤ÉBÀàý#x"¢Ù5³ºBªRU7!BI.gô®F²Ò±b¢7„Xg9VshržÄ‘XKj.¼°#-©ÈÒ[æí aµw®4‰ôüüÚ×D`€.a!ɼÀûêÑLý 0À†Lë)ÏzŠÉ‘Ü«°€íûǃ õ(†Q¸›bXâöÈ Aš£jçHt¢âZfh›åmÿêB\CtEÞk›½ÆêIÇÐ#z0©hS€âÃQ’djAåµ~|Wë2T'Õs½bÂDÇ,0ÏY¬æë#ð@õHÈ•ã#NpfIðßbd60BJðàËPÜÜårƒ±¾Ñ60‚ü‡ÿdk䔸½åìž÷ì©âJÀ>Qô…@°}$’'²Ñ%pq ½Á$J.±š0%*Ñ{í#ωJ4ã¸Æ!v;Hû*ìY@+YÀ¼¦ÅZÇô€HðŒ!d9€KH-êq»dµ¬ý‡f'`lb·ÙQ}ç"&íhS{Ú;XÃ𬡖Q¶ºí¶"eÿ÷õdMd‘Œ…¨B‰L­¤¯ uG/y £+øˆEÃF%x‰¤¼‰kr‡bä” 0€iI>8¼zð Ë»þõà(ûÅa©ÁÆìN5»ìÇáHGxéO‘º kW»OÒÞ#ä G@ý9u  OS7MËpö0P—R„‘Š_0n#ŽFÝjB@°µ%–&ÛcÞÚœ‘°ä uŽ ò¥]äæÉ(u4XÇ!úÀÒabÓÛ‘ðú p8Bz ñk–Í0/°i•fdFÄã ¾Pë²¹ oì +g“ò‘Ü4H•OukiÆü§±› ñ „ø‚MCè­Éÿ'86Ó?!ÓK[Ô%N÷ZEÁ»hM½;W§„Ž´.”, !±¶˜°”Ô|$WN€+z=ÙZ€@²,¸…ƒo¡ÙËŠHãÊ63#.;·ç†:ü‰­/,9:.0\c4!óÙñ”ª¿åé˳Ê}¬-ç¯B.6BV„tr$¸™4¦>é’ãÀÛÇuýäsœ^³dÇ+]Í‘9ìÁ5Å8 uðÃñTSLýüèW=üÚüÄÄ`ÜN!ú-›Ü%o°À1•ü”ßíÝß1̆ÙÙþxߨˆJp9Æn¡ßø×·9†ùíDHY@>IYu’œˆ>lÀ´à† P‰¦)rÿ*XËL$H|šL¬DFÉ[óHÝcì„zÀ^"%,íýXí ÊÇ Ø?4:ÜÙA†àÜÂlœó`ˆlSûDᏄ¡°ÅOÅYl)UÿlÛ ’Î ©Š bO½ŠÑ P@Û¤‰†'m„l†ø€TÔA™GüC$!¼„Ø´ÛHtMutšDD“8TnôDžH Ä?ÈbÖÞ ÄZ º®!BÎï¡]!D*¸‚˜©Ê5éT™é–hE߯Aº–·ÅDæ ŒRõáÁ O}XÁœ_ˆ€Ö ÈŒ…؄̃`OzP£Ý?8ALØè­†K<JD áÝ&JÿáÖ€ E1‹|}’Óý¼¼‚*,Ïè‘ÛNBŠá,Æ"• æXÓ ¡b™Ù _Bd # "›KÜ™ˆ@€FŠ  •ZXÈ9UGncþp›ˆ¨S≣ˆmd!†€P”Gøa„@]þ]B>œ•'rD.¬ÄsH±l¢uàX)®„ÓÉHxÍ”ˆN”aLh]Lˆ¡D@VBI-2`ðˆ0BÄ”déÙÅÄD/5#BxÖ6=Ÿh)fqà?`‚Ac.Fcœ̆’¡¤÷[·5žZ±S"Ž_Bð™6!B˜ôD+8$cÐÃŒÉ ¬„jðJBx’GüC.´ÄP†@gÎÿÚ†,‰S"ÄLTÔ ¤P¸KMtÔA¾šPØÞ«‘¡PŠn¡¡K”Ýcd L!õ­Œ†H²ùfÛI4zR êZ5¹ÑÌyãøé”®ÄÜùÑ\H[Ü$Ñé¤ê$ÄYm„a´À±”AÁDKåR:Fw5¥x-¡[9ÉHè,ùÀ@Pe~ Å-Þb‚€å†Ä0úðæàèID¨™Û¹eÆ•Ñò§Kð§4žE_.ä$Dþ4Îßm!E fS7nHœ…cv¢­%Dj¬è?´ÁFàBÜCynD×TWâÛcˆwšµÄgv”„V* ¾B¼B~Úž´Äæÿi"?8Îàæ?˜¥"N-ÌÏ3ݰuQL$£-›f¥Šô-XõõaõDLßT£Ä®íKž‘%¥_tÊ)úñTÕ^þÓdþtA—j@W Èh0 l,‹Þ å’(¥¼FÁW饒êÍ}‚aG5a^j~ÂâPÔ"4ЧHVð hn^`õd Å%Ä\†©±=ŸK”ÖeA(àÉV^Jã†üÏH@þ\ÝˆÖ úy "ë ÏPíHж(<þé?Ë þñ<+ZqfGT‡>L µüؼ Q•J¼Â „¡‘é¥ej¦ÆfžÄ ˆÀ¶¥á”zQ=HBÈë® ÿ(¿ÎEºÂoº“z`™yÖe•€±Î‘Ì*…NècÜéÏÒÈÐéNyc°kª¸Ê ¬1W8®t™gt j¶ÀüåŸF!õä¨K´ÒþÔY~â§VÆl¦þvaðn؆ίÙ+åé‰K€ÙclܘšVi±lMSI•ÈýÑáèÚé·¡Ñcü6‘Œ°";!D|€!Ü""ìË´hZAfzgFÓjh-ÎÔ R¯BU!Ê–ü–(ߥŠÂ£þ¦±ÈŠjÐãH ¥>ˆ€Éz—Ô4jÛ xÁmSÜb{¬@80ž)~îgVú§:-Bè켺ô¢]–=/Z^dõàÃõ¦Y— 0ß¿Šhú>Q%›ÒÑ ÆlÐJNÿ”îOÅÜgam>Ü¢>Ôßc°(ÇÂFZåÿÃ=2KîÇî¦RêÓý›ò4à¸.é’/Æ¢“ô'sáàÚ®¼®l%€áôK-üx/ƒÄ ´Ï‚"›ù¢*Z¼p䜠ZXÎRuŸ R”‚¸õª·•\l“m¬þŽDÇbfB,ñA°L4*…î§æ,J0¹ªB†!'wKZT“+LàcølB40Ro~ÌÏÛèH¼@BA1Š «`úªÓâX¨cl(:ÑÙép5g:žÈD¤§„`¬ÀOºDÇ.ò´&Äì6†=@ íz]S®v,@( ÙH œ§l6çØ·Ê•IPå†@ïcx°ô.;+Rð}"ƒ/ôÿ„˜ Û°EÖà ô‡¼^–˜âñQ¥‘_HmõцŽDßÐÝVKNí‡Ê\lfo‘ ´Ä ˆ-døé"«Ž³g¶Dn³¼i3ôäŸmZIcrÜž„¸Î"'¿Ú ¤EK@@®é,)‹±ÎX=Ä«ôΫ?ï•ÀòÇD¿\o N-4u¥Âœði¤Þé·%ù!ãœÅ†´ÁÐV!Å‘!âÔš‘ȼdúª5•=´Ð„ÞØ2stA³®DÁAåCgR!q,]GÔ#'Ho\õ'“6àP<‹,Î"Wδ¡áQ»Äó®P›1BäÚ?`6:“²KPÿè‰àüËâNLü€[Üð˜ÅÙ3"§9eµ ÷}õÿT@È0?,ˆ3ëX'pè!‰%Ta,s•­K\æclÉbJg"”Û~’Øê nDM6K”6£„ÃÚ`3`'D p°:;O»‡wBÀ €$Dïå&€gSÀ~lAL´©Ÿ3BpçÁ¯ w.ä‚]×µAu^ÿ“d&µâoxera—sBD¼Pe µ:KÖ–n)¨ª2Bl)B¬÷?€eO/Bœ°"cR+ÿL ÊIzŽanþðe.#4m?ùÄ<)nË}ßͩĦŽmkˆäÊ"û/B43±øi·##±3·€›ó yŽ;îÞPf S žbG,^1vô­qAÆ\ö†È+ÿøcö.ÏÊVö*u¿È3‘…²m#L~óI]úâþì!,À 0t0N!¸‚Ë$å†Â­õ§¯5#óé´N«hÀ3Ç9B4Þ9òšÿˆKÀ(×>r¦X‡Ê–Þs*žêašf'—Yv¡ÿ8x£³c¬·ÎêxB$nöºa0޶3%Ì£¬¶œ9ÆYd.ŸHß\ú¥’I€±n@PGK0ÿV¦ÀQé¸üþVMÀîØ ÁÌt>FΤU37syB« Þ0ÄB¬ù\'„ÈÚ5`×9»íusïïN YL#Uö²»Ä²?»cÀ–:œd1SB\¯§B¶g€P(º£ûš.NþPÀ D@ZH ŸìM± 0¤Ç ¦0VX“nõ¸N…¥Õ³Y#ÂÏ{,­÷Hð ¯3Ä=p@Â;üA|q'D.$¥æt¢{ònb›óHœ”::d¹c`À#ÄynÈüd +•’+’¼|~\ÌC^OØ ‚(Š¢èƒD@UxU’&G0D*œ®µËy¾øFˆÈjŸÿÕsq,PÞº¯‹¯Ã†ÏA@‡sÍEá"^ö4™½þ,Dz :Çù³ƒ|¿+΀@´üþïÏ}*¹cd/Sg`/]®ßß…¢ÜÀƒð X>D"`PYÅ×QÂ`‰ FåÞta aº‚O€muÊä#’§Š 1½Å¼:PÊŠo¼KpÀ?ÈÓ´¡Ä?]ˆ!p…Àƒõ Œò¯á?´xÑâ Dÿþƒ€ñß b#JŒ%A&"ðåK—€°hä¿TµRé¼èëŸ! B‰h(hΣ†˜2¥Ðê… þ!B¤®kÂ"´¢0dÿ#"b5®XaЬˆ†ú"êË—ï߇$Ì•;á^Œ&Äí›wî?Fr/–°Qà‡éÍkqâq‹Mîý#ðƒ0 lq¯2ã‹¿(ªdE¥)TM(AÂÇ‹#/šTJ;g½—ÿ†è®÷ï÷ÀÝ ˜ òÕ— *°5H¤‘6¥@!‚…×ݨz‘…k[-DxÕJ…±­Ï6œ®@¨!J€û¡‚^ºvçöø÷/¾äb£¿ ‰ª¡èùg þyl²*ã€3¼¤r±H„_V ¢*šh †Äq¹‹:BJ¶L2é€h)ÅU΋P nÿµzŒK1§Zþ2§çþ1jºê¨‚) ð± •#­BèJ„‚,-xE=E¸A­íÉg-}&šh#·>ø@‚¼ËÏMÿüH¿¸è$,. (ð.ÅþY±þ‘çÐ.+£(6Œ"'þÙÐ̆<ôÐ"Ò:"Ñ¢¨Kˆ<(ˆ JõŸpèÆ‹êq%8xÜ4§a%r5¢ŽT²º$™D¤•Q„82ÊnX`©ù@D(±@£±Âú§졇'ÈŒ”-µØ’‹Müâ‚Ó.¼äl rÿ ,0D¨ÚÈžÐä‘l^6´h±‡$²tÒ^9+¡Ž<åÕ.XÿE‹Z$I KuÔXx z `$êááŽWK 8dI¹åŒL*(¦R ICô´®Z™¹*ðá}Þû Ÿ‚ÇÒg„l ʇÚ| Èg>}D(èç†Ø¼¿ý*XNqÉ¥Ó/ÂúªK ¼ót±‹æ¡GPÊ~Ð GÊʼn°/Ò‡_ƒChé\ØÈ,ŒäÖH «$˜''Q_(ÕjsQ ‹w£-.ñeÅ Ö!‹Ê)¢ŠjŠ)=GiFa²\½©Šaž±íù‡ÖÙjè "&ª–Ìù\˜Ï ¬¾âºÛ®ÿ“Ûsÿ‹ó? ĵs ðòYpÆ4ûz$ûGÿÐjkûŸF[Ðþ!¸æûe!ƒî»îƒ*!à³è.¤Á)¿ÑŽSE)ÇÜ$Nqd {²ˆV™ÎRX&”=µs†è4bVžVë PÅD@yPËGã?ôÁ‚„D+@.^Wð¡ï”8ˆ¦FÂÀ©ÃëËñüC½øŽk†`Ÿ>äBi5æ*[d,"™jm¯mÛs›BÀ>… #šú”"·ìäT¡¢Ñjòœàp¬¯ª\qÄØ¿œPn9üŠP"V†ˆ€0€QG!D@#ìQ´äÕjýÃh¤ZªH‰H$w"ˆ€(pº´©kÜÿÊÔØ4—ºXM/¸€¸Œ7º|-‹Y 46¥h‰Ò×@~¡Ï‰ š8tôŒ%!ˆÛ?J0¸ î“ü —?ŒxlŒ)Bã?ŒcÆËñ&)C¸Ž@³NJ­Bè€!¯èrE0Kš ­­3“Ad×6k}¯Cj Oþn.0¼@~ÚdC6ájÕ$ڤÄÄ1cÈØÈ¦Éjz¡G"º˜ùp„-tãˆj¢4¥q„}tkÏÀ÷ÄH~'U)© ’alÉ”iM,BS‹ü/'ѱÈu†¥D@O+¶9ŠÐ‰î,º‘ÿ*DðÉØÃ Gƒ‰D­|¤ iLãˆ^‘% Ø$r©@@% ÐR҆ƃÚ?ŒG¹tÇ" ˆèqÊ?AH §t”@‚Å4äL.x¥R:J0Ž¥f aÁ@‚9#X­ê7ÁÁ˜n 'SÊžñ"ÆYæ?’s$8ç+×Á28e–ëTe‘¸(=¡t•ðá_’i‚áRˆ˜ |ÑrA£HhB³ìJ_ÅËšˆ»&äM †Æƒ û9P¹\R¹Èã“Bt¶?@Ù " 2Q4ê"Q¦T¤Ä,d#?³\â3 ¤p-}ŸŒB‚‹a$G½ÁHL|Ô£—\¶² ±É2Íÿ¸YС§¸>¼B:ôJe塯ø–¬ˆˆsùpê?¬õÛÑMW­T±‚ù¼BB ?`¿…L<ûlöéHäþjÈMë¸ðµ#U…0Ï£«E8î~w¯þ Û+˃1£‚²@š×M q@¦1yÓŠ}Y) û/4kZfœŽQ§ÓŒ0F!á¼õí*;›Ö‚ˆ»¤ÄúøÌlÑ 3ýã„E ZngóR"fØ_=üÁ†ŒU.kÕ$žÚ5º@­.xH(÷¼4¨¡¢¹TÁ›Ê{MnQJ²çMo:„™h {„Øú"¶¦ÇFÒEÿ‹è&Ù M02AØá‘M²Lœnö³­‘&~ `Ñù”`úðëC˜µDDg¡h–lÈÛ ¤Ex=‚­a+­#T—UŒÆ‡…4žt`„‡ãI_àžUi B”ÝèEz«a”¾NeOÉn ‘øG×R¢©õé.vÛ{ã _“bÀãµáJ.`0ÿ&ÙÐã¯/û_c+åÌÇ1°g$ZaàãÚÑ£UA6y-Á‡ñi-ÏBÑ{4Aöˆ‚÷AKZŒ"¡• Á•” »QÝW Ò^Wàë6öwÇÚ¦}æI‡Îõæqp»*…ÑQKERªÿºé†öè³~×'Œ·kÛfÜ@x 8ä  ìç1V¡<Àdf94›YSß$®7/ÇÈÌ›]2#…§°@›¨vžö€Ì=浺Ú]e£!þ ¡œ°tÛú,. –ôü®Ò“+À.=Tð–­ÒÇìOÃç#ɾ±ÖØwU©@*äG»®n¢JäÒWépÜQ¤"JVßbžá)Öôà6^`kÄáð‡ÿ‡üeûjùb^Ôï° ¹ßôo嘉²ˆƒÿ€„'6EÚjîð¡+ðhÂxŽ.N œ– ã¦J£Ô"lüÈZ¢ [NH-¢ÀQ¢îÐg,€+æ²îÿ’†‡ØJ ÆÊ“n­ºæì|ì É"æ-áz°Ü¼ >0¢ÊÂR"ÜÆ/SôÁü,‚@æ¡ éæ!ñàñ‚þN²pä\ábRElÌÈ(ò ÐG‚ƒÐØP¦ Në:~Àž"" ά–ÂdAî¡Z`LP㣊®šàAàiÖÉ,Ta·ïàƒ-DOá1² ª iäÙ àÊ 6*÷ÉžÆ ì)ßÈO—J‰ld ®,â^0 ;b!0"–píAç! çþ^ ñ,¢¥´Œcx™T"G‚C&|ãØTnÿ$O wcŽÿ4Ë™6)>Ë€ÿºÂ*ÌÂe2Ê*,Œh&2˜ìu }éèþ¤öÈÄCªJ´¯²Ç¯ô! Ax@ CT`¯¢@Q"/ñ?l0¹Ê*†Üj9 PÚ¥]ºÊ6$Zñm B©PÃÇ‚@šp K O¾:rñîï¥:æä0¯²ÂØ"kòö/²–ÑŒ˜-æHØHÞ& ;Ü"ZGÕÜb£‡¯Eir‡¢ä¡ ¨¥öÖÉÐàB2öp¢Èä Á^` NÀ4  À+{e  àv0àðj ŸΞ¾ŠàÊ #B`u4í"†0±,¢â–È]l1â2z±#‚ I²~:\eUÿ"¯%./Ø 00ó˜é%Z¡&¦#v¢'ˆÄøo€„b ¡1æaƒÖÄ-¸Ñ-àb1ŒÆ^GiFŠ(ý¨Zr¡vôQöЈª¥·)N€6¡èÊz4Ä0|¬+=I“d¬’ /$ò@ðŇ²§O–T“>VC ‰-/" yI)` €èk F.õò¾Ô°bvÍ&‘7úë×D° Û“V§  ‚I^â:Z¡T6WgLÈäZ´Å-Ã'ß‚„‚²=¤g^˜²Q–NA" 5áãÝpaX€PZÀŒrAb>*í"ÉÇÊΑð©’Ä $t’A2{ÿV‡9»îQHê4îiÛbí#&À ë’#ñò°sþB"T'úU*FcŠq9PUžIãØŒÍ#~æ,GH> š@Ï).p–Àœ|ˆg€’4Eà ã(õŽ¢äe¶l5§GêOè!V@p »n“Zè.ð|³7Ë%?0Ñ •‹+5‘+söFÍ!>@î OÜr‡Ð]Bà#šgå".ƒG+/Â~RG~ÃËVÃ//åXÌ~$Þ#dRHÎŒIÈŒ)Za@N€P|ò?_-|`B€PšRL…òAñ!d)¢n3 V Á;N` ÿöÿQ¦ó"ºR“êâ츦ì¶U 1ÂeìÁÈÚ’½BÉø I)ì#Olt N€êUp :µG¦ ð†éqrâñŒ ¿§G„åVîÿ,âb.2wB'x¢^Â>'ó(¼†Û®lª5è”LÐç„ äaW7$`[n^š` šÀºþ¡e'£ l3VpvÕ†/1n5òmßòilì,‹$í6B1¤y.0Öº‡gàCÆNjÃÆR«V6ÞK ÜgGä@Žðd¤ð0ä°Ð6rcG\Å /"’ òö'QrØ¢”d¨Qf2kõø!u®œp³mÿ‘-6@D€d##z&Jîࢮ éuP…2µ X–)„€Ž¢ª‡E×Î"*)'4qh-m8kp¹ð)(t‰0 _òaéU9Iˆ]©,lü${& -âå^Cc x; ï ä°L NBFRÅq'`+‡`S„Ë aèðºØ4f}h÷ÞBŠÀȉdç2ǯ<£¡ „Z‰²2àwr'×\àJ¢D¦Rx V)Ò†„shÿÑ’¸F;‰:æ*uàEý‚ð»bM9· ^1bi¢èU,ä2à ƒ1â_1Àð ]‹^Ä"ÿ¸ÌE" mÂËŠÑ׎”`J“II(ߥAÌ4ƒ(»ŒR|óAWÙ2æE¡ÚnANfófCCY–ÏþA.ávÕ3æ[mH Ø’¶ÒM˜\zgÊ,ây.B-=—ú¾«»ªó#Nà½Üþ6;=8ׂi_f$.†J‚Fʶ²²°6GcÖpSÊð1$êó°Ô9n€! ‰=c øBèŠ!©ç1зŒl÷àe ¦RS E‰rr[ |Àw‰òAìj}kÅwºò‘ÆE ú)ùÚÊ?¨.3ä“xDA -§'”-‚S9x 8äúÕ‡i$OÅGSXGÿ"käšWÙ’I e…ÙjX)t9((€Kóª,°‡YVf]sœió1>-‰©…“çõнtrIy2ƒ €ó·^ÂC wÐeŽÇ–kÒÄ¥1)^0tysåT0èá]Þ$Xw^uUW-ôŽà0€Ssà8™9€é#yGÎa¶H%~cï‡GÓ… Y™dEJ;Ë9Y€°ão2f·œ&÷è@ƒ(59zªÝy1ÆÆ1þÆ™õž˜•§ç1X–P~2v/$€o>#U¹†6Ò"mN0B¡B68òl”º1¸ pÚÚl£Cî×<˜r€38C °óðÿ°v ÇTˆ4FD‚°‘GîK/Q… ½L< ™Uqb™8O€þáV!`yxg«e[ö§×ùp±ú¡LAco—xžúŠÏÑKMûBis¢æÉUƒbÅþ÷\nhN´H Ôlh3áhSP0ZB‚|÷Pöú8ã<Ú ã« M*;ñ˜ t°oÄbr¤ CËGšeúcŠCdƨ:°Ü…1v‡— Z«•6Ç&ʯ&J»‹AŽ6½”MY9fQ¶žxrb“?€žéC%@Iô U¦ém îÑ"赚Z^ ƒKES}wþ6º¸1;‘{Gåðp-£ çÜÇFB"Fÿò8UŠ4²¸Ðbª™q“»-™n¼1¨ƒjÛ…ZªZ5ƒàÑ&xíáR“Y¹¿gK ,Ü"ò26Y®ˆs5î.¦“ Ës5²ÜWƒP*Ü @æ:Ã[  ¹wô"D¼¹ûk³6yé+Õö7®»…ðycÜ`/B²Y€èêb÷Ú¥mÜù²÷½Õ2ÈcmMf´]–L©é›‡ŸüAŽn~½õ{½£\ÅüƒÊ#©­ÐŬ½¼/ø"'gË[„#CYB#~{t®An£kð•2à®s}¯sÀ"`ÄKú_CÎG«`÷òº­qø\`›É1A":ÿ’¤"`?ćÔÒÚ;5³òу¸]AD  %ÃA±2d+Ã<26Y°)þQ»æ«µf.ø‚¶Ü¬#E–6Ëå5'.4f½Ög} Š›ŽñZŽžþzT¾€IT˜FB$w/SäÎÃ(¦˜½8Έ8¾;ˆI3:Òq¢ }1"ݸŒïÑC©½;PÊæ”vMQP,ðAÒ÷1BD§“µ–S„½\0>‚æá–ö˜ `?`ò-b®—|®_à…{ƒÑürÀ®“;“ûð>üãpÍ}Rʹ[~¦Î#çx7%ÿ8^Ùs›É/)„ÂV !æÿá;ãÞBѯ‚ÜïîcîSÞÊd>^Ä}{p“C€°Dx`Ô󢓸µ†.â8³\éÿa; $链¸Üó!ÀFWšZa.@Â1âêu”£ï2|Ý2ºþ"‚× =î#_ ¥äo$>’T–}HÙ^%NEqäÞò´¹Ø6 ju$`­ÿD-»ç-”®ÅbM]ÃTÆâÃ#Aœ`Aìa)/$2Rg“S§fŸ„Êmk4qC¶séëŸË¡~ àÂÕ¿!Päß= òþ{ñ¡<ˆ÷þa ðïAÄ2DÔøâ…Å )ùÂAÊ‘ƒùð@Â3ÿÿ¹2±æCœÿÕ³Ù3¨Ð¡A Iðð'Ñžˆ1ô¯U…óèYµ÷á_¾ùºæ ±lW®Zê{ÂÞ?«ÿÒ† b­U¸!ÒFÉ÷¯E ˆô²·6Ä !þA˜°ôbŒ¨Bˆøø!‰yŒJTž¡À$ #¾0‡ÓVCNdèðÞ‹…÷Nc¸w„5Æ‹`Ì#"†#y“ô­ò¡Ê’wY’fò2ބȳ¥P®”&¾Þ‰O¤ÿ%¨—`÷‡†$T5"Ôú Ћ6.Þùú¼v-±þC¼ñ‡ÖµûÏ]~±ÕW\ó¼U× àÁ@ðÁY=$!ÿ…1ÂeA•@Õd·V#óÜÑcÚ ÑAAˆDaã>ô€o.’“°‰ ÙäK2ñ„s³Ðõ´×¹â¥Oصí¶í­á~ â[ö`E_búA„W\ù¢…µX`q• WVgµçž$º"L1`%þsYO¡þã°eœþs uGv@¥ýs+bð/@ð« ÞÐ'üÛ%¿¦£®áöòËŒCä@°C¹¸ÜIù$ŠRö ÑÕcê>…åÿxÚ½”Gj"«§ZüµùOSM¹›O»vþƒ¯žwî©Ö~~ÀUX#ÿI BV{iº8U!:\Ù…= ¾¦#>ÌÈd$`8ÁC<Äí}“„˃—xȆ± Á¸ŒWdÒŽ–÷¤¹¡4©'0IÌ>G’›EÄtOzVtPÁ¤¬®'[_D®„8¥4¨€íÃ'|ݧw»Ì<þ„-"Ék˽øs/| ll×¥ò!»”€B‰[øãCˆ}"çcÌùH€$\ }îã –”²#ÀÈ€ÒÇ‚WýC$àáå4s€#ù‡G~‘àl"/8ÿ²†„Àd•. ät"ˆœ`i‚à©–ëaA¡Ì."YQq1‚.º{ˆ ò;Þá"÷ŠÂÕ Õ–j“Ë«ó6«Í_ó`÷i,~šƒQ À›–ñ@ª‚ €À°€Y¡_PŒ œÿ™$€0ƒ‰<6šk‹xIKn^0uzôÉN&X-eY’! Âr)ÏMíÚO=ñ{Š’ÙÊð@¹'‚ CT¹”Ú"¢C/fID˜!(A%J€[ês…+ç²½~GhYDIExD̃À¬ÿs0–Q#‘æµÅ”˜.K0iŽè,¢S)y¼ÖNS—%vúd×b'˜ˆ"¡ |€ÕJVvד{~Å’QPK>f.¬á , Ô„&dµµ\jq^œˆ´â–°¦*F1é{ŠS†à 5 pÂwó‚ î")3ãcB™\@SÑHZVÌ‘ ¥fØ)‰çr³ܬŽV"§9y:ìtI(Œ–ƒ:x»Z^¥ªýÜ]=ó±O=å“xwêI@¿B«I¯RÊ”‡)M)³>Ä”GØ!DXÀ¡ydnk c¤ Ä)}+Äø‚ ÄOp}‹ßC@æ` 뻀 õÿ^ 8tÌÜÏ‹9&i€ÏJ8)”Ÿ: ¨üéO0”t•Kô,…³T¾XE“Oí§Pô©É®BÄx—T‹¾úÊL2Um‹Ó-v°GM9´Dˆ™@œþq÷AÀºº&áFâŠ, F·9£HÖǃ`B¤G9xA\;fA—„%llŽP¤lnñ:+ÝMTW_,õÔ¾¤g=Ò‰j}§³>ËJ"ÕÖ¸ïy“¤š¬ÊàÜõ©'Å !ŸÂJÛŵ`™QènÙ»LWf˜RÈ–«Ë±pˆh¨˜×ÃÈŒ¶ÉŒP`‹T –X’ ¬ï9rŒÉ•c^õÿk92q/MˆœSg™uLŽ ©¤UKfh‡(O®RÍ,A±¤¿Æ\/a”¡ÇcÜÃTWšòn6+ Žàæž3šÔaÔGš¼%ät-1pÑ`]ä<òˆÝ‚!3#="÷pB‚Ì]€4tJMnÚFâiÞJ2{§¤¹É=Y5}bY Œ‡Z×á– á ÖbÙ-¸^Ê>!ò¬µ…Pï×ÄÝó¯ · òØËouë8Û%ÙlS[cŒ«>3Á5$DÜTõ€+0eÜŽH>ªÉå7/BÕ5y ž @Ë% ±wLÞ³—µ1$6U¬LÀyG êt'ÿB½¯OïX-s¶³ƒT Â)Úª4fÀú„ðPZ‘qTBK¥Vwò’ºCÆ3DpÇTß³‚A¡6ÆCÜGl5ˆlÒÂwÛçwp†Ð PB–1€é·$ƒ#W|eç÷~ÁmøÇÀ<1~~“^CV:«Ø3€,3>f,kDGü–ÿ h-§sN(R<  ¡È{ŒÀ<—T(û¡'[q‡»“<(ØUñ{T!wuÏ÷|Glk†JK0$w%ðásKá+Aà\!Ñ"£2×¥XàuFÀáQŠ—&3–¶9HWX?&NØdHÇŠ=Ã{${²§uTÕñ‹6!uqbHéÓ€p§TcwPj·`\e.WÇÓÈóÐ$é‚j–%àqÄÆqWˆAÁ^»ÕfaVº\'¥!c~ÙÄrñ<@8+¶‰aGÀˆE ˆy¢ÁJá7‡“—ƉQ€C,™S-_’X•º8ÿ†×¡f8ÖQåÔdÖ†vf‘ö%y}¸¹sUO“v"ÉTy)\ÖÑ7#Äf[^\r¶u·[áh}Ör¶µ/¹LˆA>è"®8/Ã$8A W+’#9rFfÄz6w~Ohë3m0³äcË!oW¹ÒÄJg:yÔ@Íqš_iæô@;p i%;£øå]A‘Äè ‡ñJu)y™v,Äp°(¨ÃE)<ÔòPa3Â!¬DrS ˜¼ž¿Å?ј,0b’“i…N˜–#8® Põ—;§%nCáúÆ-®iA²E¥tÄÒŠ/cáX˜Ãÿ áy¡×M@%F·8•¨;Å‹ý¶?‘É)X²{ÄY;p'0'þB—r!’$™Ù¸’»µq/)}®¤)DÁ^$ƒºÕ* aa°±[@ñ›˜w9G°bñ2ùó?.†"0Qõ,"¡mŠ¥9[‰¸Â1˜Š/â³Ùnʠɢ3œ6Sè€ñÅ¡šÕ‰K)¸VP;·S’Uá/å’'³Å6ô@jÖqÙãqk&!rTažæ 7CÁ£·©<Š˜ Ñ8KpKPÊõr|f  /ÃxÜ&8¨²¤ ã~-ÃFBÁxÜR…¥a4 +âM+!ÿYËsRø"¬ÉF3ñ 3Ed“5¡nÔ’õ =¥¡ºÉ‹{„1øõ%¼FŒ¶¤ˆpù€)a¢lN3’s¸5™˜4ÙßÊ’Â6‡Vxw<Ä­bVBZìÊ÷À(t—#Jº$GQLj~f¶ñ#»á"‘£ÿ€9WÎMÇR6ó•YÂ9.òX]8tO÷•3á… T%ýu‹U‡u¬¶V"ˆÀ{áqÔYK"r|'Az#ªq›!D‹C˜0É£‰˜Ä6@C©l ðš'±g)CEù×n,8Jª¤ŠÁÂ#idAD@È9¼áMÃrÂz@Æÿi:a±AV•F"™Å3ªƒ‹§ošNA¡ÉÙ†sj!Ñ ?Ñ.h­ÌÙ1z¨ãÙ™™[·JŒºˆ‰1ƒ<¤®º÷0ž3†ðrý „Ä2™=Ò1"Áb;ש—Ö;‹‹6i©RµÂ‘9œƒzUI›«–CGÍ!‹Éâ«Kç°Fç°óõ›ˆd¨ƒ"¸›=!; ñ¬Äù DZ6¡ÕK@³B):Dƒ ¡¯Ñ3²0”¢¨/ª%yg˜&qá*p6]¡  (8OÔ¯ÜvX°{~”ø#°>ÜWI—D»@mÔcBáFý‹ eKÐ2SBbMBái ÿlº œOÉo¹G‘‚d°­ MÕ˜x;{á¢Ú‹=,p-;#ÀuJpã}}7À•¶eVŽc2ï*¾MÒ[²“Xº1WMÊm@16ïw—æŸ-Š/"{Ó,ŒzÉá1\ À¢‡+%‘±.ÑM tS73X¬‹ ,–ö¦¦"¼!K“°A«ÿŽàh}'Ðq¹5ˆu&¼ÁyÂlVJ/¯Bd­…Ø-+ƒAá³ßû½âË@aÄ2XùŠ×åŠB;åæ#¾riþ¸ò þIy—£¿¼Ä È¿®û¿J,‹bغ¬K‹[ËkjiM†këÿÀ§Å7¢{v&2LÐ X'À¼ ÇpSÇ+ÉÁ±qy«Cדa%°晣À…J*Œ¸Ä†®¶—CBê*<4,P9›š˜·Q3š©Úh±ù#8W‡wMÒqM*Ñ¿o\ËÄŒ«Ì¶Ñâ«sDd9¬ )®ÀË¡a0²€u²Ø™·Ø›VùÓ@”‘q)‡2Ïü¢ÀÈBa+ËDr«#½5ÎU æ×¤½aW/”Œç2Ðô¾°¸ŸÁJ¼c‘52XìMEí…ÂÊi¹YNøteZ¶[•^ØFj‹Ãj^¿³Éÿ‘T÷z)ŒÿÖ‰]Qa·’=ÔùcçÑjåk€q½™á*ÿ£L›%Ǧ¸¼¸—“#÷à ŒÜÃtÕ“+ƒ;ÌÎ1FÉØ¡‹cëc$S”^ùL«7%¬— Åü2’åy3ñ8^G煼ʉ‘ÔÀÙ¦iH{I²“ËÈe!B™/PÑúÀjÃUÊÇÛ˜XXwû=ô#`ÍÁÕ¨<„×:‹®{=ŽÃ³#Ñ$â;‹ d-÷"$€2üû •»ŸâÔuU,Ç¡cX*¬ !S"ÙŽÕ•ÆZdªù,Êj\­‹¤ãµ®Li †_œd§C¼˜ÿ#ÆÈÅM#;qɈ=ÁÊɧ6‚ׂ—E½"¥PËM“‡(Ãáù¿Q1=h“Ø“?$®˜žÿz¤¾ÖåÈýJØœˆ$űºEãáµÿ0yHxóÙwÕõÛcù|ÅÂÁé¡.Y1!2Ÿ½3™N•¬˜Úâ¤ä”ndüFOf¶¨–|s»b4þm%.ù°|¸îkh/sZæíц±'–‚¼1°½ØâÈNܼ+‡=Xtõƒ­´¸²çÁÈЄèÐ$ÙŽh„Çn‰N8Ö‰TM¾Z…üˆMîÍÅ*•Kí@ 6:Ñ¡ 4{ à´ Å-6X+N°“',p§mÍZmÑa¸žð¸îÿð[½ú3nˆ&ìç¾…Vˆ}g¯˜uγqç°Êâ•ˉ0bØa‚C°ß †Îêà PCp,;|€îsxº•d¹–-Úú+Ryx½šÅV<ÕÊ"Å«CdÓ†SKз'ÃÙ7ª2èò§+û+È`ŠëZ_Ä“?¹NKg6¿¶ÿᄎË=©Èî‘ìÛ¼öá5¾$Ф–SXÆÿƒ,Ãm+ÿ2º‚è×n"a @pm~SOÉ™+Õ ÔÞE¾¦Z=»Z¬ÔUI:NI{S^iîN:®ÌSzD:F~ÜM°á=ãfô UC1á߇'„˜ ÿោ<þýƒ€ðáÃþUœWB^†}928xQ"ÈÃYü;irâÊ#òZY9‘ÀÊ™9Ž\xáŸÎ‰:yÆ\™á_#s`€Yt¥¥3¸²ðƒ‚«vŽt°Ó«A²þû TlÌ`Ë’}aàEÙÿ R6ì¿aÏ>4°²Þ¿½õòî5°weÞ²yÝ®<`€ëÊÅ@% Buçƒ1‰ÝG@^‰yôB0¢øðà‡ / üðGêˆÿBxýo^ΡF089’ä¿)'º<ÉâÈ=˜ï=,þoøÄrX呜ù?«V>¬þOhQ¢^d:±ã?#•wiÕ*Aÿ >¾ AÛßÇÞëÕ,Ⱥƒãžè®³æ2Ì/ü{(ÂÜŠËÂò2ìÀ‰ Áé¡ö(›H)î2hkC ÄÓúç4†VØþ rÀ«n+i¢ÞjœH:âþ!î8˜ŽSn& ¨ Hø (ŸfÌÀ'ê†ÊÀˆ&y¨0<¦’’:#^  ©xàۂЯ+µîsà¶±l‹¿¬²Zk¤³îjSB°ô+ÏÀ"̳+¼âÊJAÝìäk% †©½öb*¯¼ŽØŒžy>s­ ‰RH xPè4Š>ˆFæaA§ò0Ð)7 |ûGá\â1ÈXDî!"'²‰ÿöÆZ”9 ÂsÏ)ÛBôI˘ã²b-|‡]_¨§L4“|ˆ­º®¥+«9ÿI‹Î·îœKÂzx0 öT®·¾zëÛA«Ö°20—Ú§©¢òÍW»èy(¢.2(†TÃt¢ÓNƒTç9‚Žš(ÐÝÄr©G‡‹9`š ~z®ª¨ »öšÄ®eÛ+˺•¬Ê É!âá' ^Øu>Ò´3Mmt ¿‡Š®6@¼£Ë+£ÕJÛÂ&Ê“ÜB¬¬¸â p$9ér ©ñRxP,Åkê¡6ø!+¨` Rè…p¶Eˆ& õ×çzª7Þbʘ¦ÿˆAܹ¡F>¢„ .z,ë~31'²ü¼ 3¼ µ#Ï; ¦ÒÍò;ðhļܬ >`-û¾ÚöÍkÛj÷€ÄäŠé6ß#Ÿè/<ÃÌ-¾… .ÛÌÝrÈ:¥öïŸVú!_–m½4q$¼­‹š‚DÖ.ÕŠý¼‘Õ—|ü8¹™š“ùŸ"_˜`$ˆþ=(Œ °Šÿ„Y¸Bà‡ !&0 !pÞ‡óÙ›÷ï„Ëùæ hè… M¨€è" >¼¬@ោ þE°°a ! CR Ðª•O†þ!j¶•Àÿ*Ø{˜¯€½|ÿ^ äW@c]~Žø··¡ß¿€#Ü(¸ðA¸úðÜ`¡"¢ƒl`e•GþkÕ¢° A“Þötz"tgÞ8"TF ñƒHy9×@”üƒÖ@#ìØ^3ÓÞ?BXAf}’iÿ°Pà@ôd)Ð=^ÂL¢õÏó”@“jÊ4Á„à²ÁVêYôt9Gs\0ÁýДøXp?0b÷OŒ‹ T@ ЍB"xWg˜‚GWC@þ—¤É¥Ý@"9БˆéÑ?š±jV+Aÿ@ ¨¥fÓ@¨)M1Øs’=LZ ZºÖ&MÂùÏœ$J…«ÐáigSÛÛUøQ ­¡;úú[`'nvxù_ÿˆðØcßeênab:é@@æCØ 5".Ðhèª@ÐùÒ<]ÄB–4ýS+ÿ€yk£ g)Ï=GH#'œð…sft•©÷Q˪APŠü€ÏTݰc£Š#¢ä”Ñ^•¦ûîÎ ‘7//»;ïô¦¥Q©ÿ¬€Ö JctC”yâ×Êœ 4®¼“–òTL :Iܵ®@˜`ÛC­,0’Q¨èÓ¥ù{g³g’@™ 5ÿÕJÊSá"Ê\×]¼Í]Ay™,Á ¨gˆ~¬ t0A¨ÐuÃg+Ì›ýOÿ ©vZKHp>BÌÉA¦Ž‚LAM ÿlµ¼ÈR¹lvWCº猧;B¥Å+9Ï@>´9¼CBŠÓh%–׎>Ò=~c”t‚£ÅÕhÖ©U&à}Ia÷0 r@€W1™˜<À&‘ÄMtaÁMžþ1ŠŠÔB8? ¬¨â A*ÐÉÂ2ÃÙRèÈêâ¸J¹à;Ÿ‰¶3IÁå1áCÒÿ碾ˆ^ÿ©3‹2!ðKT:ˆHMë¶ ÷¥¹ÈÚvUûí]§Û@uç·ab„•Ã$—Ú@ågþÁ5¨FiÄàÏqn®¥ûrâÅ—Š9é™bB.»!#•ÎF²žâÕdœî¨M>JÆk>¶`s.‚ýü…è6ã‘V‰…È“( :Pã×ÊSC‰‰+„µ¶±4®ÀT‚œ‹µ¬Í‚N’§ŠàbG–Š7×8Žy óF‡[³¶ê¯hÃFöœ)Þ]Ç6;†}ÈbÃ+Yao² Â.À§ìYƒäåø¢yChšÞ~ÒÔ×iI4at"ÿ»{WôÜ ]’]Y›é†ýKP–0ÀV˜T4Ñ õ)ÀkFh4øÁ!wf• s´ID4ê±.>w3e/Œgq†N<ÅvHv4ègâ%l)/ƒll!T¸Çø²$qG#!šÅ^šñO„kZB²#Q-¡~°1]B¨AE¡ÆU,j vEµ6;¤/!*q U¡_†=T²Øwa¸€Mü€ÕÓ…öä]8$ŒDHÅF¨vyfH+O+6Oè3sÁvta/]WŸb‡š$}g3qTJ‰%0‡ö7±°Bdÿ`jbEH×kÿÅ0¾CL+1!`òЃÿ@61~òö“7A'p1cocò Lˆ‚#t"Eá €'"c*ãhΣkÒ•fb3FqB¢.‚†Nô޵ve8†ÊhNÃ9‚õqôd,e/qöfñ)¬tªbÌSØ”4TbˆàjÙcóà4H+0y:E 6,‘0â¶iüQŸw6@`rsŽ­s+­C&N÷0(é5Px&ë5ü³!´øp‹?€Qñ Ѓ{13eŒúX„lÅøX¥÷‹+fÍgw/-ù-t)Ìv|˜Y‘^©ÿB­b†s­`B0\ÁqA‘_`"F`“;÷À0õ¦ìX0»rE™j61q1YÂU®j°Øt(s1[q''b*FBM?àhÿP £Ð Y!]›³€ESÃ×Hï”Nr˜iH|cxNDC|òŒ8*Ì')u‚1IïtmøQÁoì”]ÁOÙâj"Vd1$cKÆPF—ï˜0²ãŽÿÀšE[òyH·‰c24Hy‰[ÒUÒ Œ`Y7iØW=h!"Ðñ<Ë€"²#u"2êÁ‘ÐÖlŠIŒ!˜ÙÙS/RN€¹Hèvoÿxrqh/2é>" O@†¸¼¡*O²¦C$Ñ -H¸‘Ÿ^6`³[ãxºbƒòØ0À½“e;¡áw‰1çHe—¦5£+lÃUŒM1!†f1%Çy!ù³a˰ Àøžcc5EHyÁ|0¹HagvÆ]ÖéNÄ|Ïè(=[­CB4ÔX>%”šeŸA=”€bŸ­Ä ˆX »4oecE¹²yDX¡±JM™”—Ø¥¨¬‚P‹¢¸µA2GÁ\©²Ÿñ˱#[a*,ã<Àp )J_§?†pYå³hbqhŒ:õ‘mÇSæ„v*I©7‚š‡îS9wQ/{D}ȹ?šVJ"ˆ@¥ÕS@‹¨`î˜ó¦+±ÙšÄE¶;UT@™˜; Û`ó ¿µ+-± iRL #ž³´/A Uaîiˆé!K ®,A8 +n’×”^[6 5o±ù%ae ;»U; u[*as¶Š_;èüE+!;CañÒt!´!˜q¢ºF")À6£dè˜æÔl7Zk>7Kqè.–c©Üš-)¤‰êN ˆÐ¾1%&j0!*ùfVJü@”ù˜Kºbi ÔiïV@úx@—ˆ„øµÅ"—vº4xüÁ:1!IÆÙE"}úQ×ÐaH€2´8œc©ehŒ6%‡ë„v~Ù]Ƙg~¦g;+€¤q†¾]ÿX-¹ÈÞ䊚!"íÑw1[’+Ûsîæ;í'«X4¦I)»ÁÔɸu5n§E&¡®ahlÆÍ† Æh¡2pt¢T_çfy1S8‹¨ÜUwçTŒÇøvÎ6*Ù)¾1¹)Ö©­ô’”ñ‡ø • ÆU± Eõ`°Ýü; AÀ+þktÿ©sû%õ~o»Kh±!¿½÷s?Ú’W± }5ÇiAËêsÇR>ÿá6z½‡qvGÞ:ÕÐ+ÑàÊvô#ÙmAÑÂ<qú$aœT¢/Ñ׫ªÉäV]úd ÓPäl[µÃiJ\÷Å«°³Å¬)@1±&pÁÜ! ,á?«§{J"\È*ø@—•ÑØÏ0{F³ÝÞ€+[بyñ‘8å]ØYȈÉN"YÈFó#%ax]ÁQA¥kÒ ÃßýÝÍ3Ý~[o Q+÷µÅª¼æWtKP¹ Ò&Pö +E)Ôœ:3T=¡[=(32#ûáz{Z¸ÝÛM"klI=òH€<†#(N(élåñ{wl/xîC5y:øñ,!*[“+ ä³Ë0Wtè ÿÕKFŽK¡y C0Þ" Þ4‘Ó[³5R&eA=þ#kK!”'º $K²E}€«'hŠá³ŠëÊX’ˆ…Xà#çt^]—„çÇV4Þ?§""a1á,±ƒÄˆ±èÿ°n@:àÌnÎ U!é‰S4ÑäÛôxœÞ诓›úæÔL¥Áò&±Æ…È Ôÿ¼u¨4 Ñݵ¾ü`¸˜lîHkLãçCv¦Ìznl÷4±¥š+¿Íýž^j3ÍÛ·ý;óã¿óUËÛ€Î;–Ž%“‘/Ñ%Š£á-–U+0ò6qöQo¸"åYòÊã›qþý“`h`|È|¶l ùýã§Ï>~ˆ2Žà×qáGÿòMŒ§o ¾xEªüÈ/^‘CΤYÓfK0òËW@æD™>óí”yc¦Àyü;Bà†š÷œ.•*õ#§ Þû'O^×{_†mò¯Åæ 1”ŠBƒ^H¯EÚ†ûâ~â è’§éº,º¾Np ®øZùá|ºæ2`~ @2~ ñÌÑ8úǃÕv’mD L[ˆÄÔŒ3q ×*7sÓéÅ*ø©)‚É7‘òñ¬‚nÐg‚ÂZè¿®–«©ðŽÀ$&ÃûÎ*®¶úH¬¾ÊëŸ%²\B­ò é2õ¾…V@ó#ÂS-µæI ºJÀ«µJ+:µX°“AΊp!`þÉìƒ~üÿŒ®FÈ­$ÙZ±Å”†«Ô§—2- Å;‰'–øñÉ6 :[}Ô‘V0‚y éK°œÜSJ ¸ÓU*%i"ï£ )Lzèy3­ö>jå•"XˆQÐÐúGZÊE :¾æAŒ@Xh@äp ˆâ ’2|F)t e€ÁC bô&#]ˆ¾ÕJJ'~CüÇ…M=¸¥á@}ë# EU˜8ŸxÒǨaÔ ¸ð ÷JñzƒîÂËj¦=ƒÍͰŠý ŠL²ëŸfÿyeWXž—ä4À‹d¶èIêHž¿eL¬mÉ,²VœM™u1Ãç†xåÅH4~8µzcKÿ)Ói[ȶ†‰8–p{ ˜*ø­¶•:ɨh壸ø¼RÉ[ÿÙ•)+Ç«Û,ÿ¦-9)š?R/„(^4 ‘3YfÖÙTY€e»P^è>>H+çÉí¬ÓÛÿ¼• ‘Ìù,° ¡BŸqwOBŽ»ü=Ñ%ÚëEÉßázs­5Úhìú÷bò=$³;UaáþYÀYg’OYý^ÈÉ{œ¤Êú˜¯ú+iÕ«-´’’öŸÔ[è-ÐVF3æ^~Å}|XÀñ“â*pÍH¿+ð/oK:á舡¥îK3Dˆ*ò‘•…¤v‹&¸)Kå x·yÍJxòÿA¡äT:2›¨â…#•ø$[Á"`”·-$nWbŠ<°Ã½Ii;`áÒ_Ìc–›Øc(’‰šþ¡Š…¸>+pßò| ¼<ñ"ˆ IèõD2 *Açè-‹ ät¡€|þÃÓ)¤]£X"$ð@•âI k„6²@(:I‰øqƵâqCƒKôæ®á)ZéØÞvFõ¼Å|ìK>f85¹Œ‰Pü%˜3˜Á“HÌX6Å”ÁÍ|ô`„øê@èà‰9ÿ˜€AÌ(ÆÕiÿpHYšŒ@Ó$¤`5ëE; ÿÆd±áÑG¸Ö5@ºˆ7},ž¨ŒgBаH@Ú‘Ø^„Æý#žû IRŽð•ëqåIvûUÝÆ{„€LliÏr’ÎDM1ƒÙ ø8Jø ¢”ˆ¨ò":IøÌ…Abü@ àÑ„É[}R ¶BP‰™q Ⱥ®‹)$ùiÇš;öm)êcŒ¾i“AæëEÈP ‰B±Uà`(ÛKâŪX`ž™/"LÀ,I;àÑÊB¼×ôDÌGY!˜¸#‰AÓÛö Äs–ßËÖ:¯¢Ä–”[tò‚'Ä$t‘¡À bÕ4ãׯTÊ ÊæÿŠíT;SXAÅÆ/©ÉkŒÐjóT¾ jiùaÓ&ÒÁ)ÞÖ<’‘ÇIµhäjÚGv6½dGWã™ É +T.,ûEC’Ê(&1¢Î’â@(¡<[Þ†9’t¼µ³¤Là(ìÛfËR†4V¥A E e’ ¤¼À5ÖÜk¢ØÐ(6›˜¦øˆ“}á7´Âûà¾Z —Bþ…d{Ë:ÿZÔžJÛ€òÞfÉÜVzá±aM¸³7òÅÍ~§\Èj‚Df%‘&pˆDŸ» fª@SB_ÔÑ E/ zt3­y@€ ]|ˆP×hÈèâó¦w ›5 –‡÷‘Ö|5œÕ2"½gš¯L5›ÙVËk6›“l‚¬Í‹ƒ½Z˜Ìp×;Z LÜ —²y3ÌCñž{P—Kg›ÞVyKž³ìÏåp£ýØÄ ¹ Q…*˜¿(Jt'¶%%”xË“d!ŒÐÿ¾—-°RÕ ¯ÿBþ¡À%L6˜2oÀl]å,§d³Z¶2g±ü/ýËD¶áìKX{¶q£-8¸f³D¼ì7·Ù6ë,ùÖV ¶8;8*o³¨òq¶bòic\>ÐK$}åWWùˆÍÈw0ò™4W4 ô±**4$,Nëã ?¼,ŠŒ›tºYFº¼hº›¦I_dõX…Ýjü‘ã©Z§½[3 LRâpºo°'ê|óùZ~`6;[¯ÃVjmhî÷'þï0ò1Ùg­àé1¢ºÕ ×Õѹ"ÞÿGÇ(²*ܘ‚@„Æ–¥1•åÛ ›ø©h¾8˜îS·°Àî(X­îÛ@è@ð@(€,A¨ÀóÉÀd ¬ !Â6Ö볺±!yX q™ÁòYÏS¨•I(šX+ÇQù)B‹‚™¸ª·×›‰‹Ò¨¡F€Bš€z’ˆ (¸ƒ;8Ì…9½*<CÇӫ3<ðÀSAÿ¶È>ì[ÃÌ@6„à‰‡y.g‘(,í¸‡¡[‚¯Ø4²·À´”)—ÜX_€:4)ÿ[)š$\ˆøa®I‹«äj®…¸¶u ¸™€¸ g¹6\h`H/Ä‘+((¹7œ‰X¬EX¼E[,A\ì4ìE¤ÃFÑ ¨b¬™¶è><,F`ÄC›8A½z˜X7’r  Šåø2œ‰3Â5‘Äù1"ªƒ‹’¢¹J=ÖûO<$¸ ‡ BêZ ¸Bçb @Àðbš˜ A½‚‚œ‰Èü DA94”C„¼ Œ‘c\ˆcÔ`ÆbDÆÿ„¤ Ðȶ HÀ · «ÓF¨AîÑ'yø’ýÀ½û¼÷³‰T:H IÄ·üˆ!„7L¬¨%üÖ{œP ¤ªˆ@„÷@1¨Ã²^è!0ÆúB ´‡æ#A©Ì@8 A¬ôÅ^\ˆæ“À™ÅYÄ‹TÁ‹¼‰ ¼È²´‰´¤ Š”!ºˆkl’ð(ôë>~ó´Oó7Ü "´B–(»@ŽÐШ„J¥©ZˆK‰æ’ù¹xdȈ›¢9E49(,»Å‚ùXH€\ÃdA¬Ü@€üÌ ,ÍÑÄÊ5ôÊÆÛ°H`É›`Æn”È5¢‰@}8ë )~£‰ÿ((·›§S™Ð‰àKºÐ÷+«0«”IŸš(XÇÀ+¶ˆBÜAƒˆ!–Z+È…6ø…^0h`¼Ê l>AÖŒÀ`Ü Ü+Fý$ƈ”ö˜µžîÓ€Ð{ ‡éÌ´q‰•w¼KÜ0÷£‰U1“3™?È ãŒÎŽÊOÒËôa¥XÌKÐNí<%Ÿû€ ·OŠZˆ_p6ø‡_XÌk¸~`Cü„‚6(H˜Ñ„Ü e,Ò’!È5´ÈÚtÀŠ-¥Ðm)C@?ŒB±zÃö((S®½´P3¡ãÔMöÈA¼è‹-!œÿé„NãòÉOˆKh°h0ÖŠ"“È0JHZˆS\ˆõLÏõ¼!˜ˆ·ÒPP Èà K'ÅȶlÒ%Ý ¶ÌTzÈG“à®@@!hRô¹òÙÁé«¢ú÷ƒ?C›‹ ÕÍO) “éaaßñËä ‰Å|ÑØƒSZÒ¡€ÃDFû‡Å\µ½h(0Ðû A‹ìÊÿ ´Ô@ ¨ÏÁà dÁšqƈ…ˆF½ÔܰÔIÝH „ D€çz›|la „版`‹¸Nê 0¥‰„Ò(ú@¼ÈËË Û+¥®4I¢Ä¤ ¸„ˆˆ x®ÿIâ‡é4YˆÓiJÙs79ˆâªQC¡=­„„‚=AŠüÑÝÖm5H˜¥ÈG…_ä¾ œ‡ŠÜYýTWt…ÚTÒdŒ‰°!ˆ€¢ñXÄ?}L›ÎTý4‘ˆZšÀ+Ѐ±ZeŽ-YSõà0õÁ¥Û(Q‰[–¢Iôya)|0JŒUÖ^Ñ6T=°ÿDÔ`ŒY¯”Ïý‡—µT•UY2L vÔ0ן­‰&]\%]ÜúàQ{`Õª!€U´[Ò¹ñ+´úÉ…ö‹‘¸)–`ÁÕ¹¢ú@œ[í”Óˆ¯eÍ7°€…¦|®Ôs™è…_È…ÿ^¸„k a XÔ¼ \˜õJjUÔ¾eÞ!eÒ6,KŸeFråÈĽ Ÿ-º©E ð®¦a°€TÐ\–Z?¤‰\pÌ\èÁº0© ’aÃqÓg9‰¨Ã7&ÒºìŒ*Pˆ@ù‡ÊÀ6Å|…àT¿UVh€^H¼ûtYd¤ÙšQÞÀMDETçÃ… ÆH]ËØ„Æì}Mu¥`5ä®Zª…-ÔÇ¨Š§Kº\‰ˆV‘ÐFÜNq4½Š±Êáš@4 d±˜y"ŠŠÝ±¥Óp`aƼ„ˆ^p‚fmÏâ-HjÈ6PÞŠTÙ-¦Í$ýâííµCù%Fð³ËÿŠ| VˆVPZþ‡¦| È…¸0%³jSázɎЩΓ«édSZÅŸòYßM™Ã\“KXż6 L#\¯tsb[š]à5!üÑøÑüÑÀÍbîcMfTM¥Öèõ œÍŸeܾuRžå—ýâú°~›8^â%N…<ó°T … Лöû<ãªÁ+–´H‹áLƒr?" árUŽud–j0@Fùaah·XÏð]eÕäPªîs‚ T'˜VOÎÀƒÔ@EÅbEÙÿ¬YÁ@p­ ØDY€¾VµäY[ã–åÿlR·£3šÜ@@_†Wpaÿ;NÄRLÕ¸¨h MDãìèäLæ…8Uc i9[´“ȇõ5é•!Âksd²-Q£ü\8ˆ¸8ß%çèúõühÖ9° ´v&j®ˆwngƒ¬ÊÄsçլʽ•gtA‡lå6ì`Œ¼TÇEFKmKORêÈ5Ê3Šª8†}Ü32iÇ4¨\šN÷ÝN»¿´áHÊ!éáü-ºˆD†½^5bÿ}Sþ‡šn¥ȇwþ‡wæi@ÍihÞVà‰·¼X\-'<©”J6«Åª|>€¼Å¥&Í©6ËÁûÇìÃêÒîgÛÄTFÍT`ôäiÍÈÈu²þ}t#:Õ„‹¥Îÿáô\ø®uÊiAXcÙ¯8‹5ÕSý±Ð¶ZÂÙXJv@@ðÒ‡ƒrÐnœ^Lõ„†g€†@¥ê‰õh³|@¶žØ»ô6<™{Cè£ n=Ÿæ«J©4Ã`dÁ Dí´<è¿ýïpÎ[FåÞ²ìOÛŒÜäl…Vˆcñ}ñ‹ 4°Ç ¥|øm„*"МãöÊÓaòI‹Å·(ZçzÑKhʱ5lŽM—%^[WYè…ôLäïo ’Üi¶­É+¶0o6Koó6!‚@¸1òÒžÀúÜÀAÔbœÑ'GF(_`‰ ãè½H°Î@gdÆËñ £|}†<‹ˆ³ÀÕpÉÿa ·¶ZŠ‹[7»ˆóÙ¿zd+õqÖÖ•rds¥u.f)õtâZOуbÌ%Tñ• $  Œàcà1%/žûÞôÏ„9¡¦jî%á€î>Ø®iMÔ–è;<Ã|} €V/`8ÚÝ¦Ž ë8yCÏí,ášµ¥¬å.ʨC.$ ç^ Ù‰]4!ÏÊÀ}œ¥ÑÍ…Eïh0ah#ä¨P„™©Š€#ŠèˆH'÷™ð‘9“Ú±Êú®o@ÒF=WÙ„à¡W>uÜ#hî3ŒqK)Yÿ^@c°øŠ&ÀÕé éž²´èJþif@þ‡hÿ;×=™¬í$BJ Âþ›ØOäÃW0|ÀaÕ™ø…ôLOœþ…¦DëP©S#o˜ÏŒˆ&Ñ ˆ˜΄!oT!*tGŠˆôT©ÒütÏØ‰·è`Ѭ‰´hT–´÷!]ܦÇçØ„Ü¡ †fˆª!P%©Í’¬JI8)ó¹8KkÇ'TnÝ{â¾F9,œœ78-Ñk¦dJÀGA… ÏŠÔ6QDÙlÿi 0£‰yy1ÑшàÜ””2ˆÃÑ”òψÌÏüÌnwÓŽú­|wÑZÅÍwQ\uJå>´ìÛ¶ÄC4¬B‰y…Uü^ ø“`aBì¡ÿ0Ù™· äZø”!¢ûø-ªâøÐ9š0q׋S–ziðâÃ…¨…™ä$ZLsö[Ñë…W´|paÜà º`|0ˆ˜˜ Á‰Žá¯äôƒñüûŽ>üFº|'™ª¯zšz*þiø÷žÁ* &¨a!DƒíåC„¨•AŒX$dÑbÞ‰yÿZü[Ròß½„òHþ‹’0!%¯|øø§ê•AD üÂ¥A}út¾|YóMƒ””^ú×ÔÂ%¨”šŒ° B„„ø yIÕ`¹öê*d> Qø×¶hN¶ÿ ½%JÁÐ?¶†ôÅ›pïKD{ÿ³%¡½—PÿÃm¬ð¥=‰%,ºÐqCÇ• 2Tˆðòç‚—"¬ ¯• C Ìc!ogˆ„'^·x-/eÊ×< I8Ó÷Š„ú|ÚsÂÉ¿|!òýŽHß D+Dÿ·BUuƒ>–ÂÝ@UêíXÿeM(ÌBѯ.~ý2øë4!”, -Ÿ÷F[ 7âg»ß`ÿåtQ­EàZúˆ\‹!öƒ2he…©°›Aól††6öYhQhÏ,@ž>¬Í#R†ðÏŠ™ôÏm(•4=ÌùæÛ8”]ÇGO¼4œ>"UDvJmw”SÿpçT/­p¢}ø #LW”PòJ/E…iÿÐ%\¶’>?ü·ŸNÿéׂø%”~û!øuúçœþ9fØ„ÂU¡g©0@^8!¢ˆrFC Ñ#‰'®0‹/Ò¦4¾XTJ‘d¤Q É$Ót årÉ5÷’’ ]w NQÞ%Þ½´À ýcA-\Eð¥*ªôrì?½\ÒK±B@C ¨bÁ­Èé¦÷é7àÕéÖœýõ&"nÖzÃ?10Æ iŒ´h]oOô„p´!Ä’‹,½fP¨pÝ#=D×Nªô¨Š’±…=XP ‰Ð›v^ÁÕTLÕñ?'ÞÁÿœõÏyÿ(ùÿ ǾýR¦0­Dk>[¥ü× tÍõVN@S°í¶A%à~oâi ž ¢‹nd…)™=Q#¦îKô²ûáC›i`O×ÂxáC8ÚÃ=ˆX°ÀdØÂ µ}ŠajÝ ¹í” [óK«þÃÏ?.¸+oMú(e”S^2_®Eù°½¢ì¯"õ‹*/ùгBè3„´i¥¼×òì³[#Ð5Bë¯(WQDù5ˆ}@‰Œ`OÀWüÓ¾›ÙKÙ=1,šóÍo¨‹Þ{o†ó ·€r<ÍFðŒ¯ÝíØ ±9¦ÊQ5unS¬.•±«…«oIIÙÔ”^â ÿUx Ùgz„ñfX ¿Ø˜ýr gY@†Zþ¡¦¥¨gI³`^„V.½ôì@„“!npÁ¶ÜÎ Áû@*P˜ ‰xUÛÝ?Œt¼@1‚1ŒhWQ¶Öv%†yR#H ‚Äh¨ e[Hõ¨÷,@7ÉHŠ2×옠:¥šÐªˆ{‰ øÆ/Šbé\L¥„èŠ;è V€% `üãŒÀL|p (YÀYÍx…$@- OH À!Sw—Eºe- Qa^à’ ±åhwÙÏ<˜Épò*ÞXÈÂþPj»#Õ? Êžð†*¬! RÞ­ÿ]³l^bá.²K"až/ÕÎh`RëúÇ }Â/D˜o6µAɧ¦x„”`À ûˆOgœ,ÎJL2ˆæ4ç$-ŒAªàþŠâ¥_qgJ Á™éhG¦èñ(—(Ó5 ‘A¢iúAÊ~Ð$¼Ä‘ º‹`Ú˜L⥃~¹‹ C™ÂP¢0!)LŒ ´;H²•¨$%$…÷ZÎòlg‹A ‘ÙµÄF¨)™G„Ã7˜ }%ëà ÂnªpY_‡¿¯4¦©ùG΄! d£Ï€ãb²ÇwB£Âÿˆ@+èòƒQàb+`­>@@ÐÛùE'NKˆBûb¼ø¬-z¡ì38Q2G”¤|É*[¨Ñ¢ˆ’¢‰å&@"T2B†´ÄáñtšS]²4ó`Þ M‹L‘ìmhƒ‘>¬òظEò(Iè7ƒ¼¨3šP±nB²ÎÍ;.Küв±úuóqêlJS ©2þÊÈ00–ñŒf=1y…s½ aDG0úÙ‚å dÔ‘õ¤_$0Ǩ°„/ñ‹!TÈÑùÆ„pYeD÷[Ëر¡Ül&ðÍN`¤pÉ¥“Ùv¹!8â©i›7FˆGÉÔÞ° ¡ÑIµà+Iÿ€·’¬D7q’¬cW`G&R¢É—jâ7/ªœ«NMÜ阧ôñh}gj‚5Öj·¿R N¼ä¬KH€“Œ` nA‚z€àêEF—=i*Ë7!eó?ÎŒ— H€ÍD³é@ê#¿gV!©FÉÑ2K’~¬G'€gÍ.Ø FæK’©C"ÞP§,ÝðA6,éž@FK´€NHõê¥Ø˜¿ý­Aì‚á¸À&6YÖ÷Š/eõŒÿà¸n2 4jaBöQ¬ÀÈn3–AG‘!åà¯Ê±©°€G( ™Š`-Ã?Â.°`6—èषUÿx_ å.wƒý’s—è²µ«oQy‹Y¿mÆK›Ûlæ1³yÞå™5ÚàÎ28†Eæ _‚Òƒpص g‘k+Ía†‡€B8QlJ¤*ÏÖ˜EùmAräŸJÿ˜É ª3D•ILª±MZ=d)¡§+ІjÁ¥$³ì×ÁÞîVÞh+ðZ@SÄâ?‚`t¹¾XoÆ —äÐêvwcæ <”‡Î¯'u"Áà{Ì:ákÙë›f1çÛÏif!Ǽ»;¸(‰éHnÌI¡mÃJ4Œ `ˆîJÀmc¯ÜZB€¸í6!Ã,Jph<“U/%ÈHyI¢ yÿ&¥/Êz\Tn­2aè:5…ôÅ2 òŒQ¨ÑØTYA>NÀ‘‘`®Ó§md´BÛ¹¡„ë_ù÷ˆ6~Õ Íˆ $S±s9;QT(ïüêC…üXóÚ÷{f3òÌ4øâ`æ*ïèzâ?X#_!`D'ó±@D‚Úã%ÃìPv¾tr{)ÈØ1®Ë`ÆË]ž: JY-t°t2Ü\3< >ôRÐXçÈßIAú¹+,]˜ù0¤‚+ 0‚Û@ „ NÝKL€ÛŸ à…bÅ` áW`ô×|ÁEÙ1øeVf]Öò¹ \  VZ†4\þ|À®½‘ˆÿ•D€(^Oœ@1ÍA¸D9•ÑÉ­ÚªM Lè_SSo4‰Œ©Âž\å­W½„—àÄ9ajô‘ÎÅÓ¯Ò¨û„ÚÑÝÖhÛÔCäžzÕB=À?”@ â<@Û<ÜÜÂ2ó9â-ÜB Xâ!^b"&â Ü pâ?|Š æ V$=M™U€!”YÛµø©ÖUÝ‚eJ !¢_ñÆ´.äœ0¸y(IŠ…b¾@^û@7Mà”¼ÂoKÉ$ÎÉšŒIŽ”´“c,ÅWŒWééšÊtÅÎuz¤¬¹O>Ø‹$Õ?ÔÃ:è0 CÀ8Æ%Þÿ$æ##@âñ¢1¾D"&Õ'6\üfØ×} ›]Bœ›¹%Ø(é „™à¡Í_2í b¤,É’à‰ž“ÕBPÀG%„ùœ‘|$D{¤L¤QªuÎu¬O!WcÄÌ9ÙØ}LcpIu¡G~S½Š>”Ú«|=¼F"^Àí½ÓyÙ?€Ù?Ô£?&bB$â-LÀVå‚ÝBGœ b`c dí Åp0'ÑÃÞðRþC,~ê^µ¥Â<"" x¢%ÚfÕ`?„m:Û?8è¹€å#éDoVè_§éÛ?ø^Q¨å„,_Bxh­tz8g3ø‚0¼ÂŒ…DGI~.äŨ—RxyrGçü_u¤d’epˆÀ4žf`#umæ°dŰÔèMÿŽpðÃpÌ–¡UÝÔÃÅRþÃÓ±l`"(ƒÒ¦AðãTåfm2Ûƒb „Þfnææ â œÊ—›eDŠh_¢Ù©clQµ0˜¨—µ‚>ø%=0FIþ/É?¤¤avÓÈhGª±ý‚É|Œ6±ÙGú0‘;­€>8©EIŸiViB¤fBøB-€À-À&zâkÒ¦‚bBT¥ÛȦAxeQð*œRКH_мÁYÛU¸Õi HbˆFâ Ib2Ùé[R€0*y•™¨%LÌÐãêû¨Üú8Õ”L&8•ëá裖ë’þ†…Ð-Å‘RBVœyøÿ¯¸§RÑg?^¬#ªî§i‚€ªV[«¾ê—n$-få#b"‚Ì®b†B¢‹€V¿­[Q [‚©`[…³_,E’dú-籌Zä‚r0r„@dH>È+‹"ÉuZI®OB¬Ït@LJ–ZÚìâÐZ6 fÅ”ðÊ( ?äƒF‘J,ò•ÂÅ~bzýÁ(&¢ óɦV¤Ap„¯Þ¦ '÷å[CB’‚×ái³bˆÚâ,ŸÖÕeÙy¬@_bFA¬@ÿ0H©IaÊZ“ Îá%¬TÇM¤ʰPÂUEÔ„ÑþÈ ‚ÒbØ^iþÃøëi¶£;NÿmµýÐã%†é˜î£,6äŒiÖb¢kNˆ„Ïíè—õ›÷™Û†šÕu(.–êĈþ^©ºå,Þ *§¸Õy ‚PÌA ÉK8ÁÞöDx*I.D¨,Ç„ ŽæcºÌujáŽÀ…;ÙãÖDg^Þã–Ì•Tcˆ†€‚ñÀÐïÓ®ã~zn*€@¤–V[—1¬,ae‡®`™Vâ™ ¤c$ØÚ®›6F™a¬‚Á¢Øêiú-سN]/X©~@VpIØ­ ùD¡¶ BäJ¥Fs$É?°¨ÈÌÈÚ˰pá´Ç÷¶ÇÏ:‰QØNX…ÿHÉœ/ûžHÜìøÙÞÿDæ&„i2ñ?tY*ì¯ÿRm- Ál˜‚iÂŽié"bš¾®AÄ.Øj(f¤¢¶ùžÔ9Æ\Šè •ä³ßòoú…FLKH&Gl”°ÝDIþÝá4‡ »p¬°VáÆ u|‘üBØGV¼Ék41R ½®/€¬ Âü¤¸M¿nà?ôkBlîKâ~‹"Àl2(l®î ÂE™†©Tdc0pñÌ)œ5†Cb¬˜]]ˆb012‘_\nä¡ ^Vˆ ¨Ê†´la胎¼FDÑrnu¦ë»Úu¸Üßúh"먫™ g>î¼2nùñãºç•\I¬”™‡.ÿ1ƒ¢AÔÂW1TþƒWJ%$ÚjQÌæ˜â y±ƒm­ø…í.$¿9P =Ò·­®‘XðÛÂ/q‚(*A«,ÿ`"BÀ¨*GI¶,B´,c\scħûÐÏ÷ê¨ÍàßZÉÆ‡qA²¥o÷HN«sN3%SÂ;Ó«‘²çuQç/÷ïK´*=>Ûƒ¤­j嘾-?" \""¿)Bû×*ªâ±–›|!Áœ~ß÷©Ð÷ÉöýW[vìÆ6Æò•j©JÀ `Å Jb˜p1iЍÜÃ3E‘AT'x®ÀcÞ,¸¾Ür5LwÌãæy¬ZOÑãºó‰( $}rB”¦+4ñ(wÿîææ¯â;®j«2¨W$UBë6F–a™–]õ~mW%|9†¶É×WŸÛ†~”¿qºµFGbU_ÐuɈ@Ç…í41÷O´ps)dÒ4ÍBæ« øÞ,ãB2#3r#Û+O«sBè´•”ÝÞˆ2\²ð§{¯ãh'Ä2èó!:5@jëJuUîw®¢.˜6ìl|]^ø^›Et‚E4Óg‡Ž¤DÊÒ<„ÀìÇèDl*I“ô‹4ö¶J„¿DÁÂnvt§uähLkÌ7«\Ø«vâQÉ0nU°3äÒk5j ¸B¿röK´w{³#Ûó¯*ÕúB*´ÿ2mÁ³ñª&jq@¯™jY€Oo »ÙCÊ×¥YºÝéÁQ4ƒ\ÙHÇ{ú¥c Ä^c†q P +uШ©ÑÊq)¬2pÐÚwÄNï´ž'i4þm‘„r{köK8m{jþCcÎÿZ[ ¤_5×Â2´íc 4¢eú+O9•Óvî¾ }›ÙF4)yèD;8fÄå°KIÀ 4‘™…4D1U!õê¡BGº’‘œc†Í–Š•àëÉí2Î+Ñ«E|À':)ë8¢G»~&„ÿbŽ/`©ÿ¦ÂÔ¢}O%m.,UÿCí…é#z:nÎW+.ôX:Xïÿ6ºMÀ÷U]~Tf(˜¯`[Ôè¯(­ÓC‘n-wB(‡6àÊöÊÍ,a§xxº2rpèôwó w´³ŒG#<Ö „löȳã&ú„0À2z-´<>‡Y—!2ü ¯&"t–ÙªUî£k«;}Á—¾µ{¼?´¶™[¸5˜Üqh¹Ï2ƒðvg%! †^Àƒ ÄnÐðo„!Sn̈rÂÆÿ6ü€ó„ÿæ}±@Äf tþÓ@oµÀ„ æò8Q$A–,}ôƸ¤N8G^LùïÕŠÊQ.?é:%åÀWܨþÑ?ÿ‚Ì}ú´®ÕT•øþ½{T‚D\M€ ÖZµùªå ?~dµ´–m5ä‚¶. ¡®?ºë.‚ì+¡¿þ¹àA¿J BÁøªp² ƒPÄ+è1Ê@›3‚)‘DÈ8{ŒBðh}FC(6‚V£ç ZøÇÿ‰œ°‡6†òÉ¥£_Fšk&Uf IŸ|Bx( <Ê#æ¬üÇ9è^ši9,ÿ¹!$D+‚îâ®§Ècª ¦8 8pà€‚xhj¼öþyþÁ._¡Ï>)ÀÌ ¤+AF$H¯Á l°+…°°Jû ±Å<åëÓ‚:ÃNÑË&#ñ3ÏP%1F$XaDìq­®×\km4'hk(—!çÊ-!àÒGŸ‡ Ò‰X,:Ò9,™ &‚RLnHÌN©‚š«ÎñþÁ3©„^ (øçÜo½]oÏä«%Pxõt„V€pÑ|ÿIÁ„tP°I Ã[ÁKlÿ³?¤L2ÈkXEÐb³ËDä 2>øÔ> §'‚jMƒ¢Ç ” Zˆ £0ÖØh.çòUŠ Šv“„•ö¤ßŽ ÌÍÊ4(Ÿ¸…j¼©Ü$èÍ8ÿ©sÛ‚ „¯Ýøš¯.°òš ùjùA_-ˆA¿{[ + nµû‹SN#›¸Ó‡G˜ETMLqâÊFû'„ÆVn®Õl-hq›?j¢ Ú±@yvh´'óÑGÙ"~ör…šhŠöH— •\̬+]ª¿Š(sÑ=à:ƒØ–¨£®Ú]ëB ²¯ ûøÓ*±ï[в͞ËC ûëy¸Æ–ÿÒé%Ч‚|6Þ¸²¼þž®ÏR„˜pì m2ŽW¨`p¢ÇfØjáZÿi‚rï¿ç#yîùŸ ÷€\ ך˜uÄ"¡Ž—ˆ‚ç8 ,Tô‚í8ÅLp2@· v.©9E( 9à´®„¼ç(i ¼Šg=êeʇ†™€rˆDTÀ#ÙÛÞÆ$C 4,3ÉÎÞ‡‡aFc(¢Èd£8ÙèVòHþÁ¿ˆQGbœÇŽø§£Ì½,¶!ˆö Ä¹(ëE(é¦3DP }éVê´º„¼ ƒ"$HºŽ²ž ¡]*ÿLH*þAbÉ™½QqoŠú‡=¢(±Ti'8\ i42‚4A£Ë=ü÷¿3¶`G; AráLIXxœK‡F—ψ‚äJˆºóAîljèBWwæ”N @(CxÏ#Å"ÉAõ‰P÷œ %ùSIxñç…3ìä„Ê— f”wY@n°€äаü„ „Pàzùà±Ð¦½Ç<1}ÓåG&#ªÊ`lb£Q?:›-î˜mäÀ=ÈXFýÑrÒ¤¦môñ IAై’Ö…s¡ ÿ$?ò”Ûepj 'w¨Z”tÐAy$Ÿä >yuO|"TZìY ~fR %((›7©¶1À‡Z¦p¾RÂ5„! °²ü‡N6³1U~oˆž©KI–“:Ì7økAæì¨Fü«éGZpœRn𽲦‘Š£ U䌴ñÕ\¾©<¼Mã¼Ô┞Ùn4–°=ê'9ü’1dÌ_ù2š‡ôÈGÅIÎrfº€)_ÂD„°[qNí#åò޶¨b•òL…ÎÊÏ\Hl äÂK (¥( ½¨+èòÖt¯ñ `X`C0⤅«œŒD½f¥ÄZNF•QlbIÓ÷˜6ŒÔ{˜G‚í5¦²!ƒfA̘¿—ø¹ fþäHÿ‰ ˜Ì¹f]ZëG6;ùãò œ ÙÎVÕi xÂu”Øâ©@¹;aBòÉmßaò…¢ ¿TîæÝ€¡ý(°a<ãаq_KXî ›ì°Œªí!S¸|Eªä&®ásé |…ùW—¯²¹¬<,÷úÕfeºrc tk ût"ÿ0’OÅlæ‚(Ø@±Š•Ã%Ä<†Ümz*Ì[ÜåçÞÂö\Àº'°¤Û‘d KÙ(A;œ„î^b`LÞ+4„´âµ7ðš lƒØ°ÃÎÍ_%=s/!5ùæRsFí³Î+cYÊÿä²q–‹D!ÒÄ8±~Jàœu›&ÿUBDBÜ| %Pöêê4B‚Œk\¹­šxða§x^Û‹ÒÓ¶ùŒÏãúΟG/ÍtrŸmrÂؽæ5Ÿ$—Ø%b²D¼6Ó™Öc>ÒÎYSÁ7b+VW·§BgWÌ©I}ðͨ}àÑ'¢ïÄEÒ $dóÈûAà'-ÿ½GDú8"|J”;ü¯ïÿ¦©“C‘÷åÊNöå÷_B¦K)ìçDìžò -TÈÄöåèŠnЊn_Z¬­ÖÍ€¸Ë”„)tÊßB A²~3mŠ@ÿà' €s<šøÍ,ÀùT¥° ãùЬÔz2ðûã°æN{ì‹4⨌~8‹rüß ¢¨‹ý ÂÀ,ÌDX€#زÎ#^Éå^ ‚àhçMÆpN8¨.˜ )Öð(Ôp.Üp ÷$…‚®çºÍ’…¹&°õé­­œ§€AÞ$@Òþè4`|@àÇ>ÀÇ^ ø‚qdVòù@BjÐù.1TI•,„0î£@míÎ_àn3 ¡Á^ qÊOd4 ï$îdZÀG©}~ÌHN¯ ïHR ‚£äå¸c\ÊEvÒ ÎÐp*ÂåÓ°“F/¬¼ +€®ôÿÄ]¬è ÿ€" ÑL V0â$p„ìA–6*ˆ…2D eÂc07ÖL" ¯#C$ã°Lñ‰òJC«AŠ, £HBl/fE æ!dnÅâêâ}(§Gr­×€Ìä,ùâ÷ÆþÈ«#ðÊ#J@À Âòè„\Ê‰Ú ð#˜ ’êa’ ~‹©¸Œ ltRèå.ŽN¾ìªÅØm…®˜¯ÁF¢–£ìÁrÒqsôÍŽ2m°è6®‰ðÆòq…Dª'¯ë‰ÖæCzÈ 3ã.bÅ߼LJ¦~`Špz¤}ÌzJYO sHñjéòÿòÏòÔÉÆPÿÚ¤Mêძ)‰©°2©dò&k’.ÀÊûdÐXo‚J ’J©®ä«öÁd „áZAÍVVXB‰H°d©“OŠ€\ÀGzes¬)g6òºöqcr°FÉj¤çí@$Ôˆìí@m3 £öê®'4à!i% °GXÆeÊGý”eØR«ÒlS¼&ËÇ:­Ikc^íÄèÆe0Q2] "„Â\að¬Ã µ >Bï·®Â[ÔP k0i¬Œk¹ð‚‚€ `Ž®~@5MЈˆ„áB…€ùþ<ÇtijìAe‰£è6«ò*ÅSÿ†àjL a{FW|“XhéyÎnDzȌóAHUQÒKLÀo ¨ó:å§Fv)6ï!4ÎVÕïŽd°§‚¥ É$¢Œ°¸´¾aJ]Ê]Þ© ŽÀƒ‚ 0(”"&ÿ”]`2wl’?ó„Øƒ=,³—‹¹Ð¢P˜kÝ8Sÿá€a݈¨áµ#(Àé"Àéb„Ìèï"B  `4¦ó’¦2ç¢`}‹S'ŠjF¥d²È“*…1‡¢ ¥²#wçáD& 'äÁ0 € B€=è'êóNÔ´i.³ ‚«iÃã·M&)SžH¯O t’eiÿA)H€Tsj7‡¨#5(Ž~ÿ’Wßz·`]€€š@tlM4x„šz“ìr†,`mלcP¢83å!– 0Å`"ÑL)1Z#ïwIeHãW8†-#×8×’X!* bm=œõ˜õªnO”Â;Åóô ßiw€Aõ©“’n©þ­BÒñJøµòG’‰pHÔ:VRâŒðÇfsÓ~JE e¸WlcºV X6 ²‹0,™ø#C †BØàxè@¸'Ö䇋º´ûŽ%׊“ñø —‡#–T©1Bà1fD6zÂŒ)i>ÝØ)€â—"¸ô³Æ2õÅ ÿW·ÏÌukÞ î"›²4- vñµ:w÷5ßÀ6ø,-ð<« ŒÏ}Wf i!ž¤#V€„@äá²ÞòG^æzŰº÷”çO91¤ÇÉVõÉrè3Þ§'ª!Hð#<‚7éâÇ@rÉ·e6ÃX/h'äÊtfE(Ãv¶(’&Û@,š+³i){n,Z¬Èªw‚çš7©èÔ3ÕuöˆhÒ€¯* Èr²ôš°ÐÒ¢à…éa6mJ o°fMdHP„À€—~Z@~ø! ¾F #$b£o0N¹«‰zÊ­Å* ëdÞ§¾HppWµôò/C j§X J€ÿä¡f™%™­;ø(δlª5v'¸‚Û£?E7ux±û,)É\){“>Â+b7!~ ®L –ÆËˆ€Úÿ+yîlƒ(ßxŠX&‚$j括–ª!Ÿ¡Œ!cóI>@TÓË0„‰ŸÇ ¼—/uŽûˆŠ[a{"6ÓqK»ïpmYyFpɶ£¡-ŽX`˜éÂ\ ÎÆÃ¤"ÄÊÆŽ‡v¥ñ8‚¥ñ(¶ª+îÉšÿ©x¬Y³Qi ¡"@5}l—y·#ƒº–À*¥Ò6aÅèœydH8ç@ð¯f¤ P&J€ÇŽõªßr è²#¼¬I™É:o¹7  ãF_”Å"*¢ÿ$*rš85C_ £ã¸ÌDôúbà€ t¼0é\x+!Ü,„ôì=lôB¯t½EÛâ Aýd\kÚ²…ƒ¸”F%€ÄD£6§/E¢fH;J+ùp#u7 ϧ.¢Àu$I£„jìXåÁô~ÞZnáÎ8ƒ?QàNyÇÚ{ó¡8eÝrÈ”T d"g—Ø×ŸåÚ@ ƒ°F;ÂïJàÀ”nüÆsüþÚ •vÞ‰ ÛN†ŽÉû¼“&u'¥…K¥?¢ŸX ð"›?sÝÚMÒøA{H4ìD€×áçª}½µ/'H;e†$<§Ž}~n$ÿ|(ÂÙ~z„}i‰.¼{»·=Ü·K•C0¥È‹»P*dÞ§}ß+×x[±„pHú™|ßzÒ9úÒ)n\nüt|Ó1àœ5 eV€ÏI) ©œ˜(”Bá¿Ã—Y³éÂGï™»PV·²„© ¡¾!I¾ aX {}Ë“£œdZ`zõµ}ªÁ¯úÁ!ÕƒO7›` ” šB€ÀëXO`ÎoešÏGyn­f”RÄÇzCRµAê–”þ¨§Iã Ò ˆ“}[Æ}$z£ èaŒr'ÖLÇ3°w<>8]^à)Ð —ÏL}œ¨Ä\’ÕM¨Cl2ÿ_½.ΊÖ8²Ä‘NŸ;KŰŽ= Ã\åÿÊÀrGšpQìÏëjþ˜¤é`€ðO` D&I0èîz/d3Ú&ûº—G*U…[‡â點mS¼p2gVæ]wçp¶^;@Æ!Ç¥“åáå0@ß @Ç äŒÓ…‰b\¤ª©žÏ`)ä>›bÃ~QÚuGL¾“ /ê»iÑíÁ_ŒtûðÅ\>t衟|À'+ówäÁ_PØÈæ] ¢>€âΗr‚^ˆQ>ü“ðA¿… *•%Vcœ‰ =¡ž@+eK܃+k°åØD ñ¸`Ïaò´&˜º 4+P°%pýÃ$D!yÁM`pØ2÷spë-ÿN=»æ à‹.ºkŠw‚<î‰Pé©×žEýƒgT%8ž~ ÚÐ øM•V=î÷ÕX+iÃÿ8H) HLá¥x!¡F›’f -hæÆ$æÄK®êS.>¨¶’É'çóÈ´V˜­áªã?-¤Ö„®D.D«&…@­HàlCLf|PB]{¸rË’HB𴙘_6J(é\ì»ÃæxÄ=iËyRÿdPç9<ÐPP/¼@ßBGè‰7¡Tñ§Õ‚6ÊC]¹VXšåpã ÓÅ¥ éµW\­, X­†õÜĺ¹´˜c"!‚Îc3z¢Í¼Dÿ»¥}ói·ê¸D\£DÏ”qÃDÓ.´%ÓUû­BÞrÛsU32AÕÒ1¢uØÎ“œ-¸Û&œæ™göl×''`@TÿÌmþI½mTx7µPTÿìíÀô§•Ÿÿ(¼= j”8«Œ- s¤Ú! MnA’õÄæ1•&fÇ c<‚b%â9–i'ÙLW«ñÙ®jG¤Ö-dˆ°€(`-¤5d†hÒA* œIÐsÞ? 'œ@`ó(Á›(Ó=wQf‰@‘CØ&>òý£|p3 QèÖ¾ù½*é Ø?úæù!*ÿùÇŸö·W îQýûJÿáÄP.”’ƒЩÁËc‡)ÍÇ,C'4f³ÏhŽå)ÈŒF"ìÜkL“#^ý¬vÚÑt!| ¡"¿cA°…¤,-¤y yNþqÊèð•ƒi®"©ž.òél ‰ezˆ‚¯…uz¾â•>ÉOOýbÈT²²•­€e?ì ãU@9òåAI@]®¹@†P€i­ À°ÃPÑ£ ¤!g¯Ž%¶ï|®$Ô xX×HÓôê4’dˆL£DT"BB@d8<¾(ä[¢eóV‰Ê&”ó ôæÑÃ.i <æéb,Õ£¼¦–ßsâ§h>¸åmp«å5ÿ‽T#;À þsL3îoÚM•ŸÿI3.þ« \’À‡)m!øÇåè©Üˆ&T›3ÌŒ™&Õ©N »9×Ih%,Õ ©uª!aφÔ9/)7Èäþ5äi¤xjE’óvÄR.¯¡ÿ(AÕB×.I€xÁž˜£>Å— ‘/‰’òÉíx:žòôèM~’ý“ýò§¿A±”/c9ÜOw긠jC†¸A q®•(dakm"=(ÕÝPu%lšYJÈùG”°¦W·eÈhþ‚A{eª%%~Äj +^o1è.Ä¡vÅÉ-¦k’4J`C À&ý/ÿ§°O­¥FxÙôÑ­NOãSè#Ù0â­oO¹ÏãׂjAãi4AÛ—1¬šBÕæ?ŠjÔèÃLªm'9èÁ—´dÂ3AåwL¦/F UXÿa  ¥ä$šÀ FaŠX [I¥ñ¼¶²’‡ ý þq݆î$:¨œ ôS¸îvó+ý+Gç‡Ñ×”7—ë£ÛBæ–ž-¢G~ AÏJ‹ÙûµT¦$Ø üc¸¯üÀ{œFðbGD»¦EÄÒ4˜´“ƒ'Xç‘‚g<»3;èY¨8<•¨&;^C õÄÃ’à"Å<`Žt²´­+Å%»<ĉtÊPéÞÿº…ÀoŒ‘ãþC$­õ ê+/½y4=N$ßSË‘â+Ê’­åÞTª‘< 3¥\$ã¡h̆*§Î$ç HeŒ 0DI²ã’ضósöøIFÂ’X[uÞ±°§r&0MGNX=þ|;“àd µÀºƒh­Ò=ÔÈNÀÃPczÇeŽHÞ8„nžÕx€¼Æç×ay/^Jib {¾|Õò)V^È|õDå<Å/¾{#ÁE°þ¢Ñps‘K£ôóYHa3qdKÊよV ⡉´G>œ`Á ïÏù°vÏ{nm’¨ó:ÓÆÎKV¢:ÅéóHp híjÿC„·Ô£QFPÚ$% «Ž9o“ܘ*ÀÈÁD2œ:Ê[ÌÀkæqR#¶ÕWŸ“çf·yÍoSîµRè3LóÞ÷ãÀæJ°‡¨­%å"‘f²ß’€Æç† bN~¨Z˜$-ùçîùžd $ÏçXâ’i¿ç,ªàç2_5§÷sê¦,%*ë o ÞµÆ]®ÁS]JÇPI{¿îÖ” `@k%ð^Úæw^º<â³Þ¿Â•¾÷­ÖŤ²Å]ªL4úG³"¹N£‰8¯˜¼šmyÐOýÇ—‰”‚ÉnC`ò5ÆódŒçÿ_Suy|&,Q€Q¨ø×ÿ €^Wcöv{eÒµBF´&ùÖu¥Ò! 3õÐW&ÕW`// 5çAj#$áC>FÑrS_}rkØ·Rr‘7Ü×/†·0ø£?åwSâ—šå0=ÅH`G’¢SrkFÞq,G²ޱúÐŒQ¢t2ÑmØNö°Š¡œ‡6wõËBD%`Dp(‡uec %vwˆW]÷E¤cvEµÎ2jT8k}ÅXñ1/p/ Dï‚‘X_Œõ6v÷M±k_x‘"?[„7ýåÿñkù…„$§ òrQ@:å„£D-ò‡ uÿÿ/!aù3YXùÇþ×s6U¦€WØš‘×V†1±FóÀE4ÿu|:¶]—E4vÒˆ]·@oC´]Ð(ÜU8óaR¢‚p/XX3ó#%ÀäswMö^ñCLÁá‰GYý SáWŠ˜ÅS‚²( ãx "y 2%.6‹ì´ŒdøZ(úÀ‹g¨‘œiHtªóAºX’Œ‘†1a‡9amŒ`/IÔèzx¸zÈF—QH-9ˆ<{2/èNñðO§–X0Ðxê†ë…EÅ/ÙÇEÓ‰ö“ûˆ_ ÿY±Ey(®rq„ƒ‚ aÁ ¥(‘'`|%Ox†Põ'&)©‹Zȋʕ¦:ß4Œøg‘ŸgAšáy÷g϶uåQÔè˜ Á%P“Õh:Ù{ UJ%ÌÁ-Ã3ÀñX’…A‚xïÖ'P$!%P]e¹¤qÇç}QAeb´‰U–RÄDYù/›fl‰Skq ÒŠ&M@‹Ieù‹rŒ€*¡ŒÙÖ*9Œ»˜†‹Y5à4åa“’9™6iD`B™zȇuè\•ÖcCt¡‰vgQ~ð%A€‰©™‚âÓ”!``D ”x>P¶7õ¡ÿ'SÑ7Ч‰Z!0Ø· —Å'…A`GEf85r8â¶B&•6Ð]Þµˆm[7< ‚LOqê#F €OAƒbŠ'%¨'6›ˆ³ECé7h„› xûˆ›w³÷“_Èä'ýѲ‰Cr@ÓYÏ„Fçq q–«ÐÓ’p¦® ³‹Ø£ØÖØ!Ur–¹¡ÿ:*‘ÀhbU=™ѯ‘¹ ãù\;é<ºÛ]C@ÚËñá m·|Sæó6æÓ'Ãk”¸¦l‘ÁúáRaT?+¾?'e„¸_t(Êd¾"—(UAœ†2œ0ûL©ØrŽòrÕ2—9´\9Q5šK†dŒÆÁ® ®™·L»&ô€\ü^²DÕcF&VkÆqá&5‰žèy‡ê&diç»q‘'Z3¼AÀ|Âês>íC`DëCÂPqjg³†s7ØÃúeªõµ7ÐçXˆu‹// plÄÁÑ7xƒÒ'xÒȳF‰xÂÎÊDÉÎCÃjSfñl©¾$×§j±Š ²bÕ²Va¤‹z¡as‡iÿQl€+güÛ%Ïf;'1™¹œ“ }ä»®Ë ºË5I°bÛ_W™kv|c[D¶z—ÍîQWÛ·t3Ó3(C™7ÅD0¸ ùLŒåØÚÜEaÙ‚ò‰Œ1ʪÔý“Ù Q‚$Ǹ cm[3 ÅV˜t$Û1iöF[¨$*b³B>1Ñ6©ÖùúWlÑpÂDZ›Ñ¨»ÞÅÞÒÙWÒZd‹‰Å}°Ú;ÍFðpV6{VÒ P:xÛ« (•kN‘È0\FŠ8–¥؇ ÊÎärÄÉÉ ²xqTõÛ0Ì3¥§&ú4êNü‹W }ËÔ˜¸\jüÿ½Ñzƒ¯º=m-»¼Mž$ BdÈ Ù‘øE|â% ”Ö—ÍN¶¶ÀAíÑ>°"1FשªÈ:}Øõ%?7ÃLÑEc„û' atÞ’ÂÞïÇÙš|Äñ»xQ=5ra%àÁaüÛG¢ŒØ\j’&æ%TÛÜcÍwžé²«àF¶dzS;(Ä`¡Y~„Å7W6¥Hé6(ÝbN†'oäF`Ô'W†_eT7>]ãɸy[QgY(“3Ï ÊÞŠ„Ÿ…r,ڰع˜ƒA+ª…‹)™zï¤ZWm ^sSË5øŠËªë˜j­àV«ÛlMÿµ'i3,A:™Û5ÐØJáXú ?¿Tše§½¸$7Je}³1}_xü¤Œ8;®wïµØPY²T?²¬:~¦áÇÉõÃã¼Ô Ó~D¼ 5[8OBTb-qAßPl"4*–Ààô˜a£3ŽËíòEprRDZÌ\enRÆqB´®6 ¡6äa憠ë5þw£‰È[Kx°Ò#|>dq'"½L“E¸óS÷5ŠŠ›Œmí3v‡®¡ÌˆLÏÎôãn¡–|Ñ(êTͳ aü°5æ2Í®dBZçÐù^6Cr=’éÛ9Y™Ðغ QkýjOB!0¸ÿðOÔð,0GÉÌvü¦>ü¢|Ѫ'ÝiÄ*ˆ/ðá%ØÍ~›•SF?æ?‡R¬ùS›º&ÎýqÞÉt袘?[–&?¿6ÏršýÉGkQ@Oò-RW÷ÐQµ"4Bc¹AåW…Ddà BrËÙe&ÈêGᎉõh3? ÿ´> SöܦÿÒÖlö‰ˆà ЩӌúÁ]8<¸¤é{¿½ÀðÏÁ‘‡3>ÈðàF$,b ! ,ºš„ãH‘-þ’à‚‡8xñÂÇ¡/8thLJ:Îìèà@ §‚8•ê0ÈC‹,ýwÔ¡W§ 8}ȳžÃz<Ýþ{›Ö!µm™:”ððÿ î:„0ÁÐDóNœøw¢ b‡óèÍûù!„%ZÌkqðÞ½Ž÷0Ü#€ð È’ÿ•81Ïå‰]þ}Èâµì×°.dqAÂV 0±¸ôáÇ+_¹Ùû_Ž9^pÅeÍšõr²ÝÚ|ãé‚}’»gG ʹŠ6lXÿ´Roþî4xSõÅÛeÊÓ¡~¶ýyìgêñ˜"a "@$„bê„"CŒ±Ã›G5˨¹<;¨„总ÑNS­—jsèˆ×Jè¡„‚*´ Xè$’ó0òH#¦> é à-Ãâ<²È•G"/»!þ©'»Ž„ n&¯Šê)¼õÂ’J¸¥@ë*1½ó¾2Ï\-ýÖ:K½ú `S.8_ZëŸÿþ«Jºx𠝽ú‚-DC"h%ÃäYQyD ²Ô&¼Ì%ÃÌ 6y|´¹clDO™RÑ XU¶{âì¡…d$ 7 Zc²&  jÎHŒ‚àá¤ÿÞ@"ïJ@ÉÆ#¡¤à¥­Žóª) þ1ꨛÄpÀ¶š®²JËŽÊk=ûò³ZýÀ|è?žðôÊ50Ú B"‚>ÀÌÂDZ"1ÿ©ì4ÖXãjÑ}/xÔM[+XÄhO<ñE¨hÝð0 !Gó.Rn¸»0zÁ¤Z3ÖÓŒ†)‡š¶¢ ¼ÚŠ„kÁbö¨dÁª©4¹”y¨‘»½ªÛk}¾K=™ƒp‹hþ::‹KkÜR](å„S-sÜË/@™òëm%ÇÌì]T´Ñ*«í2‡*;¬Z#íA‡äaiíÆBØÄOSLÑ%ƒDÈņ6“Xb¬µÿ 1ªi8^Af)ˆ¤šó­¦#„ã±ÇˆM€Ì¯œÝˆód§T/ÚòÊ«V+›˜f¯[0¹ÝêÍoQ¯Ó̱޽W¶¶-ÝÙÅ러_š`É­#øçƒ ˜0ߎlAÔ:²Ó,ƒÀù‡ù5¶GC Å¿|MÅ!b(4º±„à/öq¼3ºœ¥!uÕðt•þ1B¤Œ3záIfM7K@w--u)tÉVýR'¥ÿ puä2ÝUxr@ØP=lš`î:Â&ÝIÍ!{qH»’µÛ9N­ˆ€ŽgƤSŒèQ=zü£†¦Ñšó–¬”ÈÃ"ùÛL+ñä ³Uh@ÿó€VÆ—±‚P»ÉEôçæ<„9|ì4” ”€d)Ý|r˜‰‡%?)WÆ:mч?I‹–Fv¶´ÛÝ¥¨ÃÓœB8Bßñe< Á„DVèãx5d”ƒ&Ãjí†!pH £ä€/ "d¼ç½‚J6 ÕÀ"–ªŽäàÁ;B†w¸Ä‘Ç:RÈr?üí#F0“úG!|åZÁÀ9­¥< )íQÖÆC®¬Ì1hëÉâµâhi¥)Cá‰+<¹¢ƒø±Cè˜(©/À@Œ€!Â/ÖÃŒC3Ã0¢ŸÇó§C0Ɉÿy`²z†öLv)…q@²)åhB%ÛŽ•MTŸË”ã)BŽ<#¹b,•ó#)&-©ÉbêWð¼–+Ú£dë(u”fO°r‹¤',=£¦¶– Òç.oá‘p·´»àgN‚ìK»¬æ—Ä$FØ‘ÂGFæ1ŽÁáŽW½ÆL‡…À’FO|Ò¡£±›xB5Ru„T0ªQªBãÉÁS$¡™bGyå£7>Lñ%VRÒŒ´¢ð|H@Æ! !J=ÙʲfÆ”ð€1uì¹Idå-®(mKÔúYjó˜4-m©p©ÓîF˜—Bà]I3 € HÿA5=èa(ÎÃx~!#È:PÈ@àx6$ë 0 €yfÓ5C$åÛTÔºÖU Á_ ¨$®–±ªÜ¬² O]þcø3érÞkÒ' !€+j–þ\©iQ‰JFv¦ž, .ÜLÖOЈ¥Ù…Žü‹YðÈÀü˜ó/QÃKTéÖæ Ô!ûÈ( š& ÿ€añ#ÖáP 9ԚܩsG§² bK3 65[Ôº ™`ŠL¼‹X€À‡‚Œ ‡>3½à‹lkA?á<rÂãi ð: ª Šú®.DØOš•Ö(¦1ĈË8ºœŽ\Æ—8€—ë$Æ àV8Æ«ê‘[Ò¯:22dEÕ1>nĵ3ƒ>oL>ó£a¹º€“¶ÿp wä,AG¢Q“¡²ˆø’Çørˆx¯È8ŸJûóF„¸J­)üû"JüŸ›""º4zë¨û‹®Ã€¸!`Ãá‘x‚* ø¶$¶’1©§ X ð æHð@¬Óóâ2]c&o|ÄŠcA-;¾žPªèÓ¨± 1™¬X¾p™ £$ª²8 0‚{üJ„Ñl+dº ,ìy\°1yH ý0ôx(Rqº{[×»ˆ.jŽ# 5t…ˆ›¾‡Ø¢Ú ’ ˲xÊ7? x’ 4µk ?ê`’_û’œa;Ç34j–³@º•Ñz×ê£ÿ`Û Êd;°£±€¿2¦M|‚¿V:çk|ˆyx”ø:mN×h‘Z´OZÀúB縅µ4 ÁÄ)ä‰âÜ% ÀÀ ¸ìà:âd¬'ÍglŽ Ã)3£IØ»“Òy³^$Ïñ¼f#J›á>m” —bLmš­Í°€Ñœ/yü§4‚ÈËîÀ×䦽ÈñÀ Á=¤ÊwRM#Â4ôqÐÜLª!@(¨2ñ¸:Ž*ŽÈqŠ!°Šò ¾ñ{ÄÀzàºtÓŠ!¨2 Ü=Š‹ݲ°-ÅCÍÆþp»6â ‹à‰¥ÿ(ª² Áªè–óbJ¦d yP ¸1ŸŽÀ… Ù—1ÄÇÓ(P 8ÜRPMÙX=ÁSUœ@ ‚µ´/˜'«€ØH¥BNWÔ„©`¢‰à'™<Ã$` Ì&ñ;ÎjÔÆ nQí°wdšÉl‹£ ­4ã’å Ôú ÃV2L÷2Vûwm%‚‰{tMPÑé| ¸ÙDÔJä°t „ØòÀʼnŽ@ ©VŠy"LS{ËËÁ݉,âÒ MCëx¦|aÝAQC#fê¬ílL› Ô¡ÌÖ3‘;×±GÜ.ƒ£g¡–Jż,QpÁ•\V@D³¨@ 7(ü B„ZýCò‚!¥C(ÜøÑ*iF¥ˆ”RXðcÃD ¤ýP ¡Û·pãÊK·îÀ|ÿ6âå§QÅ Ïþëë±™0$?"ð©@CD¶$8¯à‰yöžhhà„—1 º\ᆡ•W#üÀ×JªÔC ¡@Ûk窪K—µp£B^ö Þö_~Åí*_μ¹ÛwçÛÈú BV,0›2cõ„Aÿ;hå` ðþcBåÊò4Ï«|yà‡hÿM€©S&û–+…T•!·!6дYÛlV] ÁೂOá#Øk”tê9çᇠ΅W¥¥uÓµ%ܰB D¶.ׄØaBØ@úèÚ?<´Ù@ññ·ž@¾}ðã<¡1MT°€@¯ „>JõWÿ\0•@@øƒ@Œ)¡i½Dtüd–\ˆpÆ)ç@Ç&’yA'Ð ù$"-ÖŠ>¥Ô?!Tä@•t=ŒØ£{AÍÂ<,Ü„™fI0%>¦‰õÏ`9–øX`ÈzfSdJÿå‘Y†@çæ?ÁE7箼‚˜ž@Óí%Puˆ¸8¥±½ˆ‹OIA­8FT€TÂÝC@Aó]ËB —AÀ=GÄde%0’Og×ýãÕ?W‘%k­ŒYêCt]NÐÔ˜JyDª…‘ù†«p} g¯ 7ŒÐtÿ\œF tgFºx™SF…ˆ³­L‰ˆ!útö#AñÝdÓ?òKÐfñ‘KÀÌ3ÄH|ñét(¡ð:5fH£àcªX+•@‚~†tZZ0áÆ/Ùãql9lõÕ A´ÑÃÔ£AņÕW´g¢Ý”ÿ¬´Rj"tÓM.ÿ3.Ë-Ï-wÛ„Á=ÍÿÄ÷R¾MäØQ=o5 2À #°R­ qÁ@pSI0ÄUõ:]Û™ÔV>ú,Œõè¼ò“V^#¬0BèÃúÆõ?"€=à?+´²BJJñ)#‰õÏ <Ýô²@ãÚ]·@ä òÊ ¤íïÕÊãRd-ΙR«á‚Ì(µŒ:ê¦ ¤”+“;î”÷RÀvRÛ#µZÓ Eúüó#‘iôç»+‚ÆâÈÆ(P;Ú¦mJÈ¥ˆ“I[Ú:Â=•<@y9›£ “¡”FØÏgþ$ÀÕd„JJgÀ÷¸¤Q`U*UªÔg°à°ï!¹ ývXè|íûM^ÿT—~à/cq—vÕ£<‹JI¤ÀèÑiØÞ °% èm üGò²<…ÐC'†èßzb t%e*Õ( 2&©P…,V©Ê÷ä‘QŒ"hi[çðÂ:R.â^ †?èDf àŸ"€’½ÆÐJâRø¥®ÛôŽ6Á"Y–7⤌@ô·¿ $4`ĵ5=ñE‹ ¯I£™¶šÕ`©©ø0p1ŠVL­süP_txÈf6¤GA!=+¸yþA Á â);ºÝ”Ù»‚@ S›Ò\É ‚1[Bê{nö#` HL2G’Rÿ/|Œ)_ðêŒ!4¡ý£©ÊÞ?š | CKyHלIÑæl„(\ãZg²‰6Œ4æŒñH¾"À,D°±sjÚ"ÎȲ„Œ±ž iž) " 0$6~²HòâKù0¶ô¥ù[Ì‚yЋ\ˆ·6ãC, U­(“О²F@r@ –Æ„ 2ÀÀûhDªRtZµCøÑp Åꘄ`ÛÏFy Ú®5J"ÿqQxÁÛ¶p›[‚`Q-å+ðr-¾g=÷™–ÊD <Ž nüPh1€ h>çÔH X?ôìè²Ú–ÏEWíC¸º±®Ë1:‚VX"€¥§`R@ øð€Ë×"]†tPÉ_‚d@•äëïø[`‚LÀ²@V&¤Cƒ5%ŽåÊuuÙQôÏ7¦ãÉÄ;:iªç8Uïh3âĨXYAEp±, ¤ä–©ÅŽþH÷äÕ‚ñP) ò·ÍSåÅH¤jf¯Ù²'£`Ÿ ó°òL§þÑ3 L* øÁeqñCLà8ê‰ ‰ë——7Çÿ(ÔYHV@®…Ø4˜uãg *´²<äo«$ˆ+±È“m-/ŒËK´Û`j. $>¡yIPü5£kàbU^Ò´…§šT ¤Žb¦‡+ÀjV‡wÍ ÛËCŽ“žã Ù8yQ1B‰ÚøÀ'. Á}l ;Þf=ù&=%µŒ Â@1àß ç-¶4A$˜ÎyQË[þ`\ãÏëq#Q0wjïU·Ÿˆ#3«ù¢OX7 9Xmsž„•ïƒ Bòc@6ûÄÍŒxDØÍý%‡˜T)zÇ5ô²µ-dœ–oÆ@€'~éqö|‹¸š´mà£ÿ0„’Bø¦‰êT­¶;Lh(õ¶·œð¿ã°%-@NŠuõ'~(…´Ë%6¨Õ‚L#™@h.PZ}-R’G¹ ]­¹mêìBŠ8ñ´E€Ñ›k>_“ú±àÙ#4~@ýØ>)j$È¡¶„P?úó4è!<¯öòæ« $9&º‹žâGço€øA:.ºYó¸€O'ÿ—  {ð«ôÐ9ÈËuFFÌd3ÃØgÿÇ“òíù86„qÇenÔ s´ó¡t´K\ò=øP ~ÄH°6Ê''oQÅbÉ£k%yN”MÁŽñ·tVÇö|¢;1Ñ6pãE´åbz8QhÇ-…¦~ÿ€[óP†æ~6Å%{PÏrƱTÑ'NS%U¡²²%‡“8NP9WD]£u1Í÷'B'BÚÄc@Iö†Hw_“‡ID J± È-—±(÷àE{eOE2Á¥duéT$£W1)€X0Ñ(Âÿ£2Æ_YA!`u d¨qU ž’I߯dt%ƒªhziô–2$•)µ&|õ‰Ò‘GáF%³nZQ&ú€³y µ)—ÝQDù‰H#‚V5Q^Xmf:{ñ‘±p 'H—_ˆ‚!И: vZs33|“¡c7 ”7ަhÛb7D27]Ùƒé3AžA¢¤Çüç;§qš–î©€fÒ–%rRq+ñoCZ;ªm!“¶Ö&,Y'³öŽÕÿ°‰€€-[$•1„ì´¥]$7º©ÏC•ê—7ð‡·qýómùËð Ï@¬T1$S+ñ5…ê ëf2ù¬ÃŸÕá||ñ'ØyÂQ1üòˆ›±@Ÿú¡ïä[—A™e´uÁÅ7q“®êç¶ø®MyO¯Ô9@ƒ8QE«n«V¡\²]5² ÿð  ˆ$=B2‹‰¸öNˬtYµq:qF­j1x·†7 ¦â¹¡¶K¡h»¦¾U,;v¥DWæ:A1ƒÄ)oÓ_)‘RæÂüÂL!P¸Ió’jÀ`¸Ï° e1Çš$=‚¨^ü`½Øë’Ê'¤½Y¨tƒÿú|ATµ7PT&ÈebsNvË[æÊdáJyc !¦ðŒ¬» Ñ`7$ÀõW‚@óà`É4Q2¨Pµ!¸Õ…%QÏÐTïÉ#ñjÂùÖ;¨Ùk½£¨ñ€xüi"¨X¨“"¤µ1˜ät™˜6h)ñ1$¨j™ï˃!›¡ó—-Ås•ñôdáW?Xq´ºú»ó–åä·:´šU±!!›%¡¼V´ûoú³¬ñÁ×›Å,¹öæ´¢5gšӡ¬±k(+´C_3E1a÷ô7#›ºDfJ1ü”rcA¾õ7§kÑØ›E3áÃðÔ2áW ¡è$«ªÿgq•¡y´Ãk’X ôù³É»¼câj˜HÅW;,¬ÅYŒÁ ‹k‹Ô—p©¥lJÑ#1a17Œ7Ç !ŒàI¶x OŠFÃü-Ð(3!)’A”Š+å¤@[4Ëë”7E¢ö1bŸ¡ž X/À:A›Y”SÊà<‘^Ì…‹GtÒG,0¶•øTw©hW'kË›²rǪKdæv„\’RŠˆNJ‰XN JÌÜR¦Ùƒ9õÇuQJÂ$¡á/˜C_<×° £ Ìú5Ò Î¢ŒÁñ0½#Á\ìY$Ü!€¤Å’MR ô~Å[-ÿõm#;Ããr²™™m•ñ7~¼€HH|qµxQÐý\hŒ¶ÌC²@9E—ò-3ûPmÃ$1nê˜9ÈÐ ÑPu¨¼bN›´ålÎÓ·Ò¡ÃUð9%&C1!<Öø<–m¨d7r½© ±<7|Ï÷l<@ý;*°‹Òh™Á|¿ÌÃD$ûõ»/!©•¡)O 9]â3KµPA»¼^­O·A?´ÒsØ kw‚Åo±¿fÓG"¯ã‘D‘(gº2E"zÎcJ3,.L©m‚ˆÇ{í<æÚÊ8$!PÖy›‰bÌÁ¼Ã ¶@9$%P„ç÷Œ=(Ѱ¢ÃçÀ¤¼ËàTÿÑ#?ôCˆà׫ =Ú_SÒ1ÒLxý,ÁsûJÁŲVÞÒƒµšÐËF¶` AÏAv¬ºQ9.|¸Ø ñW}ƒÎ;ƒ¡'ÐϨÙn„Üš̳$X6Ú:G4^^B¾æÅ!Ð#+P zÐ|iäªÇÜà{37d7CŽ2„ÜÀ,ú›ê’(§ D–T±Ó#ÉüWÐAV-›y¯ÿ€6WŽ€ˆêáòÑiÈ Ô(Ë=‘ŽÐEhÀ¶nÍÛ%LÁŠrJA"[¨¯c1¼&;†8®'ãçK‘Z„1ú1J4M7”é®®÷©ËÆ¿«NÉög¨";ÈàO>ýÜ;°<ç7\„üà*³@  — b&4W@; P+0ˆ÷MJ»Øûˆâ~¯7æôÁê+Cü`Ù:¤X¥2›ËûGù‘'=¢ nÞPOìÖõÀãΔ^µÿvx‘¹Þkù ã‘güš°B÷ 3âéèyLÃñqéç~à<`Íà1%÷X·/êXQòý !0_¾þýû@Á…ÿÉ;ÁBâ?%2†¨ð……~XøWk°eÏ®úH""~ÿø¹äç!¢¾x õ]äÉ/žO ñæäWàgžI•.Ms S~ù¢Æ,0pa¾Žÿ T(P”뿎[«•9V*¢ÿ"¬ ÐÊ£Ë"VdaQž¼÷òÙû€_½å-¡È4Az ÿÙ³zQÄÂW¼Š¸–Ò‚Ë>jŽ,b…Ð é¨Þ?Fóªþ7¯‹x_Ÿ(Ñ‚âÿ< ˆ\zâvd-`(›!‹€(ë¿.õ)—)1èóŸÑ¡}*´9SìÙÿ5vzé R§JýñkÖ®»’EYm«ú'!ÄÃÕ´í¹‡ï=¾òp@íÛîƒ("jL©WÜûç•$‚ðA.£$¢5kp…ÏF“@¡î;ì°ÖNèµZP­„ P,­²`d–ùçd60n¡˜ã§¦~Ú馕j¨"“ìi»‹ØãI*“ÚJ+®²ê(¦¨:B$’h…C ‘`‚û.šÇ®‰úƒ{þZèž%2Q){˜THŸr2"ùl²É"zŇA}ˆ BÍ.¤ÿ¤Â _³±ñk…L„Í¢yNPm¹è“È7àþyf`,¸a7ä®ÃiO%—²î(ªZ•uª«xänAõÂ’ÈžŽê,@¡x¶Âr¦þ± ‚ø\úP±Öò[¯ˆü«Í‹äi;ZˆD"[A•Üû3)JV°ðŸ 5´Â| ²›$°óFNkv¡ä,¶ ˜ç¡Ü(ˆàËF§FQ¯ÁÕ&¥ Ò'œ¦“nbêÊéÈŸ‚TO+&•‚J*«¢²U&\±| ä˜âç~¸šr!{’™Y° øn¹68öŸVæÓG^šÿ©h"þð 0/lNÔxâ–ȆøåŸÐ$Ìÿ.BÊ ]žås¹Tåµ'ÄX+QèyäÉT"Õ.à£x^(dPua—Fx8HbŠ8¢/ŠgÈÁ—*O(ÄrÁ(ű{ª«žB–|<~ì)ªr‘»bùW±*/f—¹ Ö+°ô¹Á!"@¤ùPóWÒ|å¹Ú…0,鈮Ýö´:#úÀ*VwúE ¦~ŒÏáMj5ÓúB‰Ü…\DD@D„:NjÅj[‚Ö `D^ýç`»ŸÁǽ/<‚ÜspŠ[-Ïâ-¾Ÿäæ¤b,ÿˆ”§*WÁ\ibÂZ})¼ŠYï²R¹íðê;cA(q,h ô:ŒjNÿ§4 iJ£ÝBìµ( èw¿#š>%O‘W /¢ æ9O"B×+.ä¼Ï¤êQ ±GÙNÈ´yì«5øŸD"·Qü£n Ã[”G”œÐ/YÜâ?,¥À¯H.ÈGy°2ÀZ®wb±Ü¯´BÆÄì¨zÜH¥B°Œ ”鸛ÁL,3¡Ä.„ˆ¨$ô*Q]ÞôHjEKhº£‰zǬü톬’¸þáIO~’†Â!e .èýQ”ÈÚgV <)d ‡Ù˜æ,…¤¦>7ø>¸4 ý¢RŸ!®+Æ'CŠ À,hz.€úc “¤«ûÿõêóUzÈor¥w1ÓJ·yr~“ž“ã (Q,´b†Qkäa‘4-Z'ÜÖBBTí‰æxú¢R@IC„¾B>XA¢Téƒ ÁsP>L ^Iš9äifºˆ$# ÄMu[FJÔwƒ \ÎbIy¦Vr¤ýEä™1•U¿rîj‚Ê©9» 3tr,)95P9qÚÝüÃK”¸¼ä²6‰ÐNis‰=Џ˜¥0¤QŠKŠW<츧†} D/„5.ä‡èR²Â…ˆì9D®K9Íä"¯Y`F ΨFÒ½‘¦}|é`µcXà µKñfPo*Ȫÿ¨ºŸ7õ!Ìëzq9Ó#ãd´|ÎiNE´ÇióO„ì$.YÁrŽ—A26Tª*•5w9oQj•%|®ÀõcQ*` ä5ŠR$é5pXœ¾T²E‚O PÝV©ÀÚån´û„W¼àUb¦ïz¼7ld·ûMîHôïvÝ»„ ˆ\€^¯ÇÁØä30¹eD¸UÉ„hk!òºˆ>.û‚¾v!–m"ÃPÍ0o!ƒâ £¸¶”³{AÛÞ>$-DF3®Œ¤T¦Ó¥q±Ëî¾w½;þnd×ëcü‚·HóÅïvw\' /EÿˆÙAD`ÈüxÑ Žv¡ñĪ! í?dT­ö²¥Zg\ »'2 åO.”µb¥5•½åÌhˆH¶çFÏ壄„ a^ãÀøAËþˆ§ ×eô?ýhFCÚ¼“No-} üC™Ž¦Á›é…h`ÉDÎ4}3 êPÿƒŸ™ž¯¨Â´, 8P ò2Õ{9­ˆ*Ô¯‚ªë‰ žAÕ:¹f©Ù“YSå¢R©ÃˆìV© x%CB@/{‰þzX®'ãQû¯‚0ÝŒAo@›Ž–Hu Tœ.¤ºØ½ñ¥ äÓ”ÚÓÙô¾—¬ ƒúÔ©Þôÿ¨µkU©Dfú˜r_øÂÚ°^þn>ôkq‰0"ÖkíÆ?ó‹ȶÌU‹m¸fˆÃ†F(•s¾ˆ¢”jçá*æ!eƒÀñC òŒ€']¿KüùFÀˆ€Bì1é=¼utyîB="íµ·’òíiQg}ß™ABü‡^¸„k¸†K®©‹(hƒþ»ˆêµ%‹Dt=0LG 0µOÛÄìH²Ôc2ËчÀBµXhhaxù‚ŸIˆ±¾¸>¥@䈫‰° 6l ÝÑ sŒ]$4Á€2݈ýB®…€AóiÿUÈšéë'hƒg¼!0ÍÓ?n$BüFG# Ó:ÀFJ¬:{IB‰ˆ[:Q“ÉQÛ:täºKÜ@Æ8ci…† G VHJ˜Ëž«PŒØ¨¾kŒÓ‚œ‡ dˆá¤bƒŒW°H¹C±F`¤6¸òOy¢S+SR(‰è…\p‚\èh¸aØ {è´ýÓ4\ºðrÉ“d·“$Ân|ÉKû7NÃ?Q‹œ,¸OËÉT T+µƒÈ‡ ‰¶†½R €ª}èG1Ô;ª9Ãj–J©”‹xšÆp¾=™š ëÅhK±ÌC;c<‘Ð+| JÞ"”ŒÄÿ…¨Aºt.—°¯v[= ó±‚kÄÒÂÃÜKÉ Ç¥3›PK=ìD=í|BîÄÎq´ÄüKŠ›Ô®"2xj¢„a¨…WHc)Ž{’\À&Cæås ÕP>‚¸©ƒø½=’4.žFóFCò´Ø¹‰½ŠU ÁPÚÈò{ÆCTj¬Æø›?è´Flt4lüP—„Éň/K5UÃ/LÔÎ#lÑë<Ìð<<}h ·†f( J è™c<Á&éÇàÊ» ¦”…ȇ‚À7üù|R½“›ŒÉ0ÁTºÍEq?lÇ« ÍðU˜ÁW ¿$Nh¼†õÓɾlIÿüjÉÂÌÔûºìÄŽQÃFc8½ì8LìDu,BÈêº8ÕÄîÜNð¬SðòÄà .]a ÊZÀÂVÀÇVTŒ\øÀ|˜Ï­’HíÐTçÛnIå³—Uå«Ô¼ˆ¬¹ ±4–\€ÇØ_B†µÄ­KÐŒ\ˆ[ý…\¸„f€!¸$c7yÃF¨»Æšl:¦kºb5IòÒI¾d·ð¬)‰(ÂíNVóÓúËF€Ë¯x .©…‹¨…ý/‘—µÔí ,ÕRŠÃØÊ3Ĩ\ ˆyM•×j(é‚:¬C¥Š ùÊ\À‡w.U%tÆ_ø…éóÕ§ùÖˆ€ÄÎÂÿ夨OCÉ>•ºêJ2uʱïÒ@ýÐAeIl½4PËD«B@žá’ˆÐL!x…/ »¶ëÓ‡yˆÑÔ–!j° ¤ÀWõ'~ÓÉó²× "a³8u% ñ$$ Û4˵€º™Us©‘Íñ£PÊ+Jaˆ2kò#(p S:'À.³=(˜4øÃ®ø‹¿“ÜPé„?«F»Õ¿ÈdŠ€s/^q‰ö´€Z°QhWÝ–ÒbˆÍ¸ZAa+Òp’HÓ0›Ó8 QåëÔZ¼ o±-tYU\•6¥* À`À‡c¡}H'p×]ˆÎKH?\(ŽŽhŒÞY´£;ºýA/ÿ¤“·:1¯Å˜´Ñ/·UÖ Ú¿Þu4 Ùɲ“EÇh8VcLƘQž!‰à0ŸVÀ“Ãà§Q ˆ°Š$]’5+¼Z ßÖÐ׈ h±–y¨ßJº¶\¸8È!wá±dÕ.á¡<Ÿ…Àt‰ÈËؼ…uÆé£¼ËûÕÜEõ°Šªx,n:4_¤ ŽÞâ…·>º®I$+áúÚ¿“ˆFœ^'ÌÉk=G&ı'dÂúR ˆ ôl±Rñ Ð%9b‰ÈÊð‡%Õ‰ì ±ƒÔÙ1 ¡M•ˆ°°vAÕWÁ“'·°|@]m^ÀÚ…-Äó‹¤Ëg€ÿ\ˆ2“Á’Ç’™«` :Ú##)Í|'>Öùáá'÷ Ù>uSQsIA.dB–ÄF”^e5=uÎD¦áC] ~X޶(Êa‚V §L± ¼èdk™¤MÙ@/4M ƒœÝÑÚd|bµùÀT"} 0í߈8At±EáÓ˜ÅÂbQÙú,ÄŸ“y´Ë¸,Ù‰Iæ‘”z ÑÊA”a(á –™£2  êâãnÆã3/è­[Ya½F†áÕãštÎV½øÒ< Ð‡Þ Êá° ø€|¹½Ð Ù˜1-Iß¹Rš<äè=zP5´6zxÝqèyPâáÿbëJú­>›¾.}§D" !àå?·tÆf¨×¡ËPãàzéѨiži™v}éšþ‘ð,™lœ]a7>j |¯q.ªÞá'¥8!"#2˜IÙtÖÓNQ½ˆ¥ƒ™IFO¯€!¸7ÁÙ‡&°Ê9ñIÉà‰ œW÷Uú(›ú%åC•ú–ÍX+Þà;4–wºÞŒ¢QÀBßò¤ñ›X3~…ôÄÂòyi™0Æö”› ž‹Å®iɵçxŠí˜éfç2oúctzg@NGnS&‹,=µPcêÎÃDO\É:‘ç?¦V@¼N~–h‚ 0h-ÿ¨”‹ Ü…h;þôµxä *u3\•A²¡[oÃá^~Œky»¼›(¬ÑpÒˆ{p‚ ù(Ø(—Àpx‘­ƒ­åÞºöDP[ޏӭæL¶TŠ_x…Kà̶àâE÷ˆt§ÈzÏ÷Q÷ºK ¤w ÉwCH÷G‹xaíè(ÇïRÿXï4§²¤p!óÄ8å7 `LƬÌ0€bUoCÝ)!7ÉøJ*R·%ÎЉƒ y'0âÞYN¹ÍØóÞ’AjW+jÓ‰"/Êhy éys³ÇVè¥Eÿ‹ÜtˆúyßñìØ|¯;v¿÷{OŠe ¬Ÿ,¦6êöÒV%cLÕ4úBx’”jO»¯ˆÆ ¸0Èÿ¨ª\ûð‹ÜiÜãY(kstM¥E‰¨h ¹ká”ö§•Á â±yc! dàL¶Kx†UOݨ|E¿ü…Øt¨Ï Ð_zž°w—Ž‘zú¼ÅŽ÷J»$ézÿ¶ð¥zþ©((àÀUÐ#8^ zˆ(ÝÁHá‰'þÉSÈQ!{þ…ô(¯Å¿ú<*\¡JÕ¿W>þÍ|©PÄJ…ù<æËÉïŸ "`þƒéc¦ÂK”XnXJiÃ% RZð…ÿ"Xø' ˜0 "€þBúïÒ¥˜B ¥ÒʨQ~üøGAá $7(â{ã*D} !b©°/¢7°ÿ* ü×®¡‘±2öøÁ²½ 2gþ×¹@Jâ «]z´éöb0dMðŸk FŒ¡PÃl… ÿÍ+¼ârÃyÿPþ»÷ï‹âGJŽ4>¼a” ‹5ÿüHÜu^}ýÓ×b¿¸ôy4Ñ„'ž4­PylŠÀœk©Ð/©"R…¦UŸQõiS†â# 2Íü£¨ ÿAsMX­bÈ£à2ŠBµŒRK]†L8¡Ê†!&ÿ‰ aÕ2K˜Ì3jö+hýZ¢=¾¶x™¯¸ÚZ«Šÿ0’âeHãØã?ôàÈH¶ÝÖö,K*¹õ@óÄ@5#¶Ùö-" üæm ó´Ð‘<ó¸TïMÿjç¿ Uè{£ýùˆw¥BLq¢a¹GIÂiYM€+´zCœ‚P 2¾SKƒ Ö¼²G4×,Ø„¬§~Uëÿ|H˜ŠEÇø3Ò:ט´î¿"ÝYfDgöâ?/2òÁñ†…¶G<./µ×T+œØJ‹6ôóèÁ|`Ñp/|TBÚjwÜù… TÁä)“yöþ³À˜ûÖ)” lÿ¦™”Àß§á·‹u%q ‚0j!Œ$ÊbéÙÓy. !èÃW˜ .€$´t¾ðE-@ð$(¤H«€$0š–ÅŒw§# ÍZø.ž mw%œ‘®Pã»]E/Bžglذ!P UeÎE-‚Q# ±fÔþ…5åOpF_ÄX¢Šz­1;eÜ›)7šëP¥Ok‹GH¶¸BÃÏðãVü??¥ÅP—GŽPW !©H…/øX‹”ð–íá>p¤] ½hŒ%QcM £½ )_‡ˆT®rBúP¥*C‰ÒTªn4¾ ¥kuK˯ǻ)K|I.¥yé!YdÔ°¸Ó$!@„"RÀ`E!KPr‚n©±<>À›˜X‚7UN7) ¿lr…¡fO€jÜâGÆ%È+}ÿüc3ç§òPn)úNGR‚4“¬$2Zá ì²xF3–L{Ô«ŽN °5*ië>–4ÉêÐ0!-a(C ÓPyÞ»)sª<Ñ*¯‰£å  HDAú À+ D¬OJ, cv¯±å`òS˜:g"Ÿ"xu%Äåu®jF¬R¥pN‰Ê+ˆ¸ZX ­ÓÆWš±ŒüA×y‰D‚y$GÌàê‘¿®p#&_%¶Gƺˆ|âK¥åòt†q u¥JD\v4*¬ ku਱¬ÑM÷;Óît˜æ)¨0©ôA 0’êÔ†´@` £ÿú’“òÄÏK¹Î‹_a•û©i4\%Q^œ–˜õ,T1 âôÈ•Z€Ø+À‹º2&¤d'öÀ+#y0Qø•’LÅDIPá@€À^j'_¦ö·€bdx±0gvƒZfJÆfôÁü­åh¡S%bQ¿~Æb—9l°™qZ)3K¢â6…^óºªÿN–ìkcñêšèU­ÀÏÅ<.œG õ'h0Î#Kv±kÀðï]ùø€”R{÷ÖãUÖã膽2’‘{Õó-.r‹üNàÌŒ8sƽî5v¢¡ëZúæ ©Pe fÉD/@ç1Ë·Ûó•oj»ÿ<ÐC¾ñÎEÍ03Â"hvÒŒ°Dà.Ñ´­a98o¢FãU•[”Mßoö£Lò5ô¤=E^\“,ñ¼‚PõéÌ©{У#A¨ïÔkÐZÔÂ’"Ä’aJpæ[t9Ø,I-²="7™fæÓ¾9ÔR©¢8ÏÙ¢½y|‡Xfü¾Ü—ûM·—ï‚>b·+@4xM èÂ`SN˜ëo«¾dÆÃíQÆí·‚«þ¬<Î7ªi@ùiP 1[>â>°S¾z¼VÈ`Rk¿þ£ä¾H…+Žp€Á‘gn¶™1¨¸üØl¤a°„rœCMÚ”3FµQÿÊç´Ë¢ sº|F á+òNà+Z±¾õ‰¦[cBx~QƳ˯(D§*fÿÕnÌ%/Q®:ES¸õ$9q‚‚X¤-îvúi%ÛüÇOf4Mð€ïÕ{Ô ‚Ïñîe䎎f¯6çüÍÕÜ#Õ!M…!•©G;JyòsÞËú‚,Ö Ñ c¶ßcýúØëу' Ž>äÂ) Eüð˜‹Ê’mšìyÄ/äDÁ¬IØÑ Þ̨…Zs1NTø ¡lE¨ ýЄÙp‡h8Ó?@À¬ Á?Ôƒ Ö Bu_*$ Ê!žÒÛÊ! [Ì•@áúM›åéÍÀ”BÿVGMÙúYýqÙXÀå4ÔÂ+ A.D]·ØV¬Gwxs±ÄzÔ^h…¿Dà?T ¥á^V Ÿ%Å\)„òÍUø@}èU˜Bðƒ>üDÝQõ]öíÝ_ñ‘%Õ Þ$Ç-¨Üâí Ö°A¯5ÛäE!'Þ\Eubñå̓±L´ÂΛ´BÝ=<KØÃRhÅúÄ‹¦­ÔÔOxÌX¸ÀеaKÀaLÄQ;‰†¨… y¼Øä!½˜MaìDÜyì’+TŸÞÐ Ú ’Ü?,áààñ K 9‹ËE¢ø%Çù"ìpÞ'uÒ AüÕŸ·}ñÿ×ø™ Ã3ä‡W¬tá‰pœÑl› `¦íÍíŠF.šLàWµD¢ÆÚ¡12£Îû¬À ÂJÄÈú (Dȹ`È1”6®W"~Ð($À-€ø™™°[}5!#T"²±€²ãë Ï%Ø”Xž…â}y›¸Å—ºá£Ñ4ë…—W‰@þP‡aÀ„ÆùK£‰‡¼Øå  Š\Š`í­ÀdG *DIŽ›±¸à5Öšz¦BTYBy#àýÃð NZ™FcUbc¡#ý$P¡‚¥)}âhÔWÐõHgvža½ÿœB¼4àGX´Öói%ÇyFCèƒÌØ+" yD.´€m†@¼ WîÝÄ/Ô˜vL¤aÈ‹íM[²„U`}T…öá 0Hæ¥aPß”¥ä›TaúܲíUÌ1æ?@añ ›™er¢úM›¨ÎDýa½Yg~Û{â™ç1æ|òþ-Xx^ÒCAn%=dÇŒ)DtœÁD“»ÜC àfœ4ZÆaP„×lÊÞXhEußh„`}ˆà2£ø!ˆ"ðC,yõUãð@ ކöÔö•\72âФ^­œBtçw6&í:ž:vbNÛ;ªHEù\EMx’–wª·áÿã·ñ×gZO·ˆäP@+Ú UqKø€x=‡¹ ¨Š!àêµ@.DA.¬ïqõbç9½…Î…Z€†“½¸aćÙÜÀDKœä?øe­ùeäÝ jß?¤Â¡–Ü2 ƒL†_³qç±åäbÛhª\%ŠceV–*휜éeyÔì’=Ö£c2©aéÙ.yP>t«éƒ“=UC´ÁmПr„mFMìÄXD¤/ž®ÄP|þ¢PÆ+hÅLßR,€yP\æáTÅü,÷èØÜåbä„ Ô÷Â` ÖšaÈ ß%êÁ(M!w6¦}™Y 0‚Ê•@³­ÿc¦>[êpÖf²„ü!–h%%|Þ”âщbópX}X«!Â÷äJAÒCtˉleq4Ásìê } N„î῎GuPÚÛ c´VÊN«ÊJG§ zy\ÆÝ±„++¹²„_êÝŠ’œß%€"Ûªœz&O²„½¾ëœç›½Òø%.õÐh@™ GÍ×ÍaíWM"$'•Æ*·ÈFÔ Í?Xlq<Çó±DDŽEùæÀ±QîMèXŒ)'U,EÅm…îíÉN+÷,'KüE Ú`ªŠ”GÀŠ*Dº6"M†Ÿ#éÕ^1¥6á$[¶ë½¢Fºßÿ‚fZFD1VDá}a­hÔc“ž‹aqØqŠÀÿe­ÒjBD è=4A^áÛM¬@Áˆ,C¶DW±‘KšX¤³RN}G ¢Æ2"«Ùøá(y«B|k¹ž¤Ÿ¢d6Ê ÷1îß!ÐÒkrЫÊÁ9zÄù6æŽb*åýè&ÆDiVnÞ?eNòkòܯ{~@—…)ù_Ô=UÄFMÄ*Z è®Ù¦akÔËÈ ENuÈDU<ë²:ëÊN«žlœö!ìðïâY_Ÿ^c6nï 2 w/y£%¦BÁäÑë-¡â9&T¢°™'PÆ/ -á xâ’Ñ\Äe¬/iN‘ÿâüÅÀ.,Þ ÄfÓ?˜JÈCè®úäÖ/ZÌ¢‰›î¦hðËx\KÐÅÁ,Å©lL¨ì´Â‡7†¹”Y5ò•õՃᲄx„¸ÚšBPÒZùÂ2,*lä r§¥î¤"Wb¡™9òæºÌ„têPª†Ò'²çŒh[Œ8áÕÞÒqž}"Ø¥³žhàF6)šG8Áú¸2K«£¦=0Ip«‰ WÜ °ÚVÐO†òmŸ8ëÛi"ŒÛ þ œ¤+ä1­±D=(nëñ #j¢ò6_Ò€]PÀÁ^í :’@±‘s9*³Af$ßP­¤T§bTziDIÿ€ƒÅ¯FiÔ¿ ñ^„3ùï 4qìJ]CàFí²DA†@4,# pJ ¥‰lDŠ“!ʽ\U€:ëLH«´Âi|P@¨[öÒZÞ f4ÿÃ4ç ¶Âö7rc*l_ßÕ‚`±Ä£Òëh›9ãd°Aò:sR¨PEÂû¥Äè>'‡fö„¡Ÿ|ÕP)*gS„”à hLõJÈË¥ÑËx¨%j̲´ÄŒ™ /ï²Fgk™´ìFï TP2ÿƒ5À`Ù5`æñ4Ë ^_ãzùÕ$mßö­×¡2î2ŒB#b Hž^i#12ãñôNþô먔¾²DHÁóгG•ÿnñ鲩®gÊW!O NµÝtKB„€8ß$t-òæ¼…îâhÌí°V‡]Ú¥Œ7³õÞ'ÒË1¯ ¢Ùuß,J߬Ÿ*®Ë  C¦ö}Nè£Ab:À?8€y“@Øõâ‘€zW" m$ŸPf)Ä`r*¹ŸP×oýÖó&ãs{êB˜31ÂJ,€SI±@G*=ØÃ69ßómÓD¦É ” ™¼­ŠA kšŒMx3Ú¥Ve¨G,¯G:š¸Í®5óI2wÍ:³—°âÖÚ4_¯ ò• ÖlAýU!Á{½×zQ€`o³`gÒ¬Qv ˜}ÿÒPW”D“KHÍT¯”êüñ—Eà’™rÔÆ@$EV;Ÿ6í„ì%ÜÀMøÁ “݈,¥3§wô–‰EÃìˆ3ôËÝe/_A³hÌxâ¢ôsOó3ªÈùU+¤Â :è â‡è  ¢ƒ€!è¸2i$·’ áwf5µM™ÏITC¨Rw¢Ö^-T¯ÀN\õh4DÀ6ƒÿƒóA£B²-N8R¨ÂØ2¬ïzx ë+Œb0§™`‡Vpô+ÃöšG43³ãq4já’ð?ìÚ´xŸ7]ëqö™ë¹bsB±DBé‘9 ÁXú{SµÉ~_€%#ùF)ÿØ É¿âÙøÅ×Ó~vJǬ ²mÉ–s X¤t($œÅïâž™ëY 4ëAc£»Y§›÷²p—‰ôâ…—P{z K{ˆ÷y×lö:7CM%¡Æ·ÿµöù8 Qv;³ %ÿ)µÌ|ã÷fçN¿‚j[.¿¦ÄèM­ÒX-2ÏÔ B>xK¢F—/8lGÁ6Y=ÖçC.øâ¯þêW±I> `Ôëhlüo{u\Ço;Z²Ïî ºŠ³„#¢´t×ì`Ýì®y7µžŸÿé`š|KÏ4j€ {%Ys¦©G¤'èÊYüÖ/§7>&ûJ¶5”cÚûf"OÕjÿTj™v‘ò ܬA U±2U·U¡~¸òAëå˜ZýSmÑ~ (YS1[…EË®Ÿ1{T‡´Ü¤VŒ£µãõ^‡·B8Àˆüžë¹BLRCÍAM- êvßk|F+¡æÉ{Ë´T‘úÜfã÷æAmž9V(õˆ¢FÝÀ ðÃx†UO±ØNq‰‰Æ[,qtùhD‹Cü‹2p >„ª.XñïÕŠ)¾Z`ñ¡D„ÿV*80ˆ A@<`àß&ºh%*WþCù¯ÎC6&¢VЩþÕ*j´¨/_Aúú‡ìŸÓe©VµZµ‚„ +úçÕÿV$.d%+áß…[ªPჄn+Løðïn]¼ö¼»‘¯_FC0úÇ÷ÄÁ? Z€ÈBzÿ4P¥§¡ÅåM6lÒäÞ½÷ræ\Zt ôB„ˆ’/Jˆ|ÿòå¢*bàCй¾âˆpU Jð/$B7Oùüs„Ò:˜YuˆÏ>A\J4Ux¤–oê=zCYzmÿõŸV¯f˦åZ¿Ö·wé¾=üŸªÄ,1¾ C(1Ãl‚Þz,Ÿþ™ ¡Êè™ì„H»§  3åÙðþq"Š(rÑÇ6ªíŸ\òQH!ŽŠø'8ï‚›ˆÿ* Ò‚ŽI$ê^"©ºšP2ò 0¨—ÈŽ§Zù§»@ *=ðJ¥¢r*½27êê½÷ÐZ«,úÌZK« âüଷìœÏºôÚë/«³‹‘T̯Ã<Œ‘Ùáç®yšŒ5 *ÿဴ8ˆ´*hE…pÛhÔfCÈE3Ë‘TDù GI"iI$MJŽ$é°õɬ; §ìJ ²#Yb±¡;f³DH<0¥-o 2UEÍ®¶ÚJ‚õàÓJ‚pÍ2¤¬ ª‰8åÒ*.;ëºO¿CÐ*ñ2 ± t ¾ìr ‘'|tÒLüðÿ´K/å€ayþ­SPj‘#Ty¨ÔmC¨FïjÈ; € ¢„’DB I$a‚©º”¨‹Ž¹zê™ò*kÎ)§ª”¥ªYh‡òy ó®Uo-÷B+ÜsÃRZÜn·-«é¸æú ±ë²SÞ¾ì÷.ÿ tk‚ìBë}>á{(5x ‡7àÃNK”¡áèãÜšØT}NE¨Ô¡b8㪢Õe›Hø‡„›^rÙW¢ÄYr™e®jæÌsÞÙY,»<*ªÿ¡`ôk»ZÓ°º5·Û¥%`=Ütà ·i¸à¢³ß­&ë‚¹ŽÆ øz7@wGd…€?Èg¶H 6XžÓà¶Tÿµê­²Í}îÞ;7DøxÔ¿ (aÍ’@b’ª›V¶Ir¢„òñ2s¾|;žËär<«Hú?$À<Üá%\ñQË æµÃhkò`\npDè1ÿÈ ä!·QÅ 'JÑ ©¢_à‡Bˆb&ä•A"7œ\5±&F‚Éü‡ù¹DŠóËY™°9ìÌs ϲ¾¦ªŒ‘tH&ò¿«¨q4X”YMC âÝBD+„äq-á\Ël¨¶® î.>ÿ¹‹írȨ‡”òi¶œ°D3Q õ‚|$“N˜á b›_hOŸÄMGéC ’r”<òè¸ á/he®fbéP%~÷“ß-q†zð€~Wéå.·ÓÅe=ËKÐâ2½‚Ldš š9%`+x ü xÌÃE£›BÿõD}ÔH!Œ‹ )À¨ÅL»Cgïzg—kòÐo¡Ô?5d¨D%j$”‹Da…¹¸Û/ñIò†T.@Dö€hQòæ{MÕGAJð‚\¥L%Ïñ™ã —”'#­Jp9´Í±t‹UéKd"!™¥S4ÙHÀ!´ÂøÀ‡F .`Ê|¤V ŒktÓ{"pê#Ÿê7ªý…m±ªUU…'âvU.cCÄ d~N(C(ôY=%ÐÕ” l•kBR>ˆª7£ Á'QpúåÅ1,“¤³÷:Q'<ÙˆÌä—ÒšYE¾˜ÓÉ@Š¥³Ÿs˜.¥éM›ÿYSøl$§­KÝ#0 `<°€G¸‚;Š,׸†0"r>Ý>ˆ¼­@>$È»´ ÷0õˊ«ÆbCGÓÇ ’gÏGý#C'«UÂV¸†àS1ÈÝžú‹»ù°FåSåCnཇš·|®zªGˆ£Qä0ÑWÿÐèu˜C’JÑ~Þ –Uz9,`þò—\Ô,‚Œg°™iÔéSÇM`4ÏÀ°@d;ºS"ÂЀ†0(±},tT½õm\FË iSEOŒÓ’´Ø%„õÛ?"C]_¨2“²J¤2äØd64¢Ø(«²Pñ.TÉTék|ô1ã¤7Wé(r‚àDÿ[=¶²WÉ/KyR¥ž˜Ô¾ùû¯²ƒù¥fxË|sÛ“Ó7ŽîšF3žñŒf#­pE-,JéNžBQ)Á⥜´d¸(½•©í.rŽVÄzvúBgt+ƒÖ •:ô`ëdbHÃxòáîök_uûᇑGXlF©B•Ý„–CÈ™|ë‘_œøD¾Y„R/I®ìÌû'ÅÚb¹”¦8;SΩ#ÇxMeÚ‘ °À»ÝŒ ßqÜÑHA,qïÙÉ‹¦]Š‘–NáÊ »ëZ-­õwÂ|ºMøL÷äí€ÐB-Ö¤,Ðijÿê‚ëÈÂwíøèÈU â„ÌŠ`4£*2i ¢àíØª5`„FJ pFEâòNüú$ì¡ ˜!ïjÂzå wÅPÊ&PJr"¯°j¿æ‹òtbÿ¸0ÿ2«Ì†%Íþ+<\êÿ°t’©š” • ÐZpa¼ÉG€¨^„AÂÈKd*.#.F.„ö&*¢Èk¶-ŽÄÅ Ë".R°wÄ.¸êu*È> yî(’>íšOÔ6"á–P6¢ > 6˜ç²'ûr«U¼¯¯Ä‡ÄΆ ?`2 `Hþá@ãd‚ ¢‰ à&P ¥&Çþâ Jò¯ØpÆ'²h‹2+XöoòÿÔÌÙš-=(€™@‹™®íBï´ðpaÂÉ‘Za^á ­©œL·ÈK"T¡€ìT´çÐÂñ(Žè#P0+‚!è-°¹j.1ihPBŸpìÆ¢oBNÍ^ã þ¦“èjÈîŽFÂ/@¦oü&¤0È*Ó¯* + /g\!òì¯þÍþ 1¥DŽ&©æ®"PP]äÄ*ä¤\zo Pù¥ŸtŒ2%“d# îâ bäQ%p2Ó'†6ÂQŽãŽÀ$"–¤È%ï Çýå°h¿®qØz³tbJ|‚3³Ä qÊÍäÛ~‡îÛ,›Æ y.b|@2£*™'½ 7‹@|°fí o–&,J,MÞƒ[Äé*â-ÿ…O›‰Ä.ä-d#˜06^ÃTBF6FT8†#º‹ïÂÏæƒ ã© 4Ž*z%$óxà Á,'x€–Í?‡% Ëòü«&)`­B'7¢èÏ+ €0ÚÂñ'®šP "Ì¢M\Oé|`±’ä’yô q7óEjƒEjS"ì(Ž~+ÕÌfø¼*˜ó,ÐC9ãÃç\åk6‚:ëå"m£c0rÅsÖâ#ÎæŸ‚È®Kf T×lB>¥H>ë [îfnÆØöï¾ÌðýfFX¬ä‹´‘W‹âgÂ(8'þ Ш"`„~R)qA-à¢-Ê”N|À ÿ†ä²&ªclÓBÀ f¤Èv(¡YTmO°f¨êw ²\U¸òm éÈÎf0'ÃQ®5T³s;B|¬¢c:fò.¤ xÑÓpìîáI†q±f啃Uç/=¬ån¦Ì.6ò4vJº#³¨‚'-LŠ‚'Ét'¸qFïöL™ÊM¶"@„ X/y¾'#\Óò!zZ "ó¡†ÐEr“í¢ E¶/¡ ölvÄrÁh%Nx"}õ8ããÑÂw°¶*º¥ˆðˆ6࢕ Ö¤A&£ÐJã`#À*Nb œ ›´Š®‘*ÿÆl?eu'2‡J^n2ók')Äd¦Œ†™DSôð„ÀŽèhX³©|êÅÍmö5E`42Ã~vC_±6q#EÀõ{øtR‹ìb2òÔVà ž !°ê€Ž7¢9o·Ñ†/€éš iH:m ³ól? SUå/Ðæ`Éê¹þäá.i Àn›d:¢°Is%’1>£HUÊ gZÒ¤V*¥¬±J¬dÙ edÉ;¾±X•élÂÊ#FÈlhKé>Ì{ä‘ZCÀaNà[gƒb C1ÔOkÃh%‚ŽX  €ì®žöÒGœzw΢>À’wÓi!4ï$dB(%;kC6ÿ1R8ëoîÜö¹2D¨ †1 {d%HÂ$+ ¥lÉ&(çZÆì1ÿc—±ähUÙ´æ€>Lô¾ ZAžÜ\ÏGnà7tÞÀõÿW#"´’TÀ ~–èÎ6½G7]#û—›„n° þágVVähªîøPÐê|·9™óu†/iœIîi2r1I,;Õ6H§Îf°>¢=¦wz"{é!LÕ£ qLfŠÜ¯*(k#pé~`•ˆaòU™æ²;ÖÕ+† ~›!5›ÊG^yôA…øiB8shB  ä¡2\qOíªrá[57ͧ¶pá^@Çÿ4 2X¤·ôívç‚,Òâ,òm›µ™9©ê€ ÜcÜ²ì… `ydcyzÐ>5þ)Ô!Þ–ì¨ë’¥w#4Ùn W˜èöH$Ö–v)rf JêK”˜b«±åRN‰÷‡*LÁÞh†øl©œ™ÆF y"%z4@6åÐl6"ò¡š 3–Ùvâ6ë5òaûîXM¸*ƒŽ ThÏ8;¸ƒÇòÄþø Ç„ò+èÈlðy# åŸpq[£5„Ôy…ô8r  J¦’«‚22!¨IŸÄs:>ù%& Ìpb²®1ñžè*RYÿ¬´}ÁÔ*LöqÿG'£#ÌŽ¢—u«F`B–@4z¹¡4Â7èA–À ¸hÊf3TáfzFD Ð,`¦2ÚEb£.9U+bRpwÔ‚ƒÆ ±–k— U(zß.T—!ÈÏͳŸä!ngøäan3€¸Ÿ„¬Ok­×3%–ão“‘~P­Ûs*‹rü¶1Ï—3"@«Â=Œ@\K¶£L·¼‹€,zŽCÉf?F€9Ã\ú7?‰#ôBxSV@€aåNc]¨yw›Ñ2>V»NØâ‚R°j×Å/¶ÒŸèÀ Nm(ïâó¹«[€Z`†?¤†›n3àÿÈZ&|¥&´÷%âeÖz¡C9²æKJߤJ¹%êšñ´ƒ;tòK©-,ú¾èW~ÀÂ$ÄÌ[I­ zùi+{7IC$›E>Iéº53Öª*_A ˆ¢§DŒAÚ€Þùv'«6‘«‚§ÒT¬j,È\! Ç‚§Î0 e NRÞ¶ &£ ÆT©·néöÄÉš¬³W=QU&4*$°°×\¦×¢#ˆ¿¬~r||.½¥¢K¾´‹øzóŽ&Ú‚ªr×¥·¼Ë{üf—׊Bmw‡$ÂYú²íhy®$tËqÁË3d pl§ŽöHxøÌƒÉ²ëZì?0­!ÉJ¢ìòuÃËŠ¬ÿ(œÂÓŠ÷9¸}цáæzûTÙÓauåI àP¢‰f%Ç#Ç1›T²0}hίÛÓÓIÈkcKùšŠÄ˜GàÑ{8ÍyZ`Õµy$ÂTz½årîŒLé~!R&ƒÌ£`ítýŒay3Ö$ã©b]ÉRk­ªëâIkI_üEÎC|ÎM$å©] (‰’¨âäö Äs!L<{µÌSÕ°šÈ9RâÑ™Ãqú¡å'Ýu\‹Ö¬g:!RgÓø!ß½ØÔ >áJ-TzKáeÔXã[Cå{ÄU <… ×á± ®2Ø*mGTQÑCÍïmäQxÀæ…ÿ_ØPÎÆ¬BÜa–Ç:ÛÃ]^ð­W{ŸÄ†Yèç à ç3ÀÈzËt U€Ñ‰‘94ÊqLJr¦('¨ˆ³{éÇ7 ¯‚£>ÚcTOÀ–G6Cðti£á_CÑÈËÝ€Œ2Ú` izû€Ù"…CX:.„ ³ql×ѪÌs!„/E•óÒÚ‚^æe#†ÄmD1pp vý?üÇ#¶æ5H£†â¸½ñçyþO’o­¥q&+”ëKºâŸÿÕûçê Á… :|ÈP!Ã)BlhHˆ&œ`q"„½|ù>è;)‘ˆ•ªD™×"„¾\'ÿOþZ±2_‹&èµqR Ÿ‹•EDèÓÐâÞ¿&-ô "ℼ%'N´ø×“^É“.H¸èðÿ¯Mh„ŒþÍkÛ6Ä„yó*eˆ †»÷öæíÛ—Á sÈñ°b# ó<òÏÁ È <ðÂò?ËAL(p`èzEƒ=ºâA‰AP´x1cŽó¤R‚d¾šúRŠðèjˆ(3y¯Xq’^‹åôè9Ù=T„ 5ÙàÞ¼©òZ,¹ú/Dn}_?t=}áÃYÔiÓTëvíBµŒÞB˜Ç‚…Þ{Gîö¿W_ÿìÕ`˜˜b =e‘ä€C/0ÔÙÿAXháfÿa€+ðPPˆ‰fiõ€–ZбVÑ?ÁF! ÁÔfÕwôØ“Ûn5¥Ï ª„Ð=ãÑdNúD¡\ Y•tùÐÓÄR÷4A/Eèt<ÿLeÕ ;†`ž>c­–yÑ'ßBí1BÂHþ¢NS.÷“ôh”OÞÝÅô,Ѳ^.ñOsd"òž_y啊oºç óÅé^ÿœÿðÀƒCœ+üy(„ ºP‡!ú£ 6!„N(Y¥`á¦`¶é† i¡.¼D0&P*DüCAÍ!õ°ÏÍJë ”|pUÿÌ$>7­¤ÅV1ÕD˜-¼Úl•23{å—M0k=óˆ—Òr-”žWëM Ö!°5›ó´ù· 1R‚œöÉIð0ÄB­PÀç€^.”d{AÊû¢Œ&öÀ’Mˆeùþã CCz¡†"Ô¡Š«1Ì0Âý#ã7üS]ôXµ\Ë-ð8R>Ä¡,%+ÀôIQèÚN"äƒñ—KŒ>º1ÿãß•W6ñ*ÿ³ÝQÓ[Câdýc;Ab1”4Cí-=Ï-uÅI<[NßBЮœ…5A­$ÐJÖÿÆŸ_bà'`‚åõ€6ð ›Zf@ßåÍP¦€CTO÷ÿ7=DF†0 VM`ŠÂ#¹Èe>¸DäA‚l%žËG°¬òÛ¨.f a]w3œµàÐGÆu4ánw AÓ¶ÞBùÔÇ[È“Ú{H  ¸DÿZA.Da`B^’G5¨B„òʽ¿=f2ý„þ‘™#ä«R˜aȧ¢¿ˆì,§"ÈÿßV#‘Œäv_i"j³ÂåxçU+ürU aÀrÂ6Ø£ˆ,„U¹ëJÈ2HƬuWzUwN0X€ jÓˆöžö@Ä[q*ÁBJ°Ãº0äÿ¸+8„VäÿZ¢Ÿ2€yÀÍOòpW¡0p¯{IHns‹ÌúŽÙÌ //™áŒg:c€‚iH3f¼È‰"½„d!§’ˆD*pÝÎ7¨Ø<G« EXöp‚=2·›|ðB”Xas2ˆH}x0ƒUYá,éHfíÄt ,(@/M~wšÀÜóÐÚ‰N —*‘÷žÜÇ[ò!â6® äkB‘¡"îÿCR‚xÉzf[HÀ‡‡3¥2[¾Ê8"ûy ÿR#QõT!¨€!*À¯ !¼X ŒÁNwJn7¶Ó9ï Á(X¬6t9ÁwªG–­î‘/cÝËV‚èÔwr|ê¦ûćœš·TYMVfs!< i^Ö5˜ 1”½tPöòâÂ|1b|߄ĸ|½O‹‘iÞ:tƆ¤1"‹ú·$®à,mQ¿""5ƒu¹'R',iiEüÁ9s#E‹ :«KU¾Ú@Æi`1[Îw¾ºÂîìl€F¡6S:Í-\2ÝèVº$hË*‡@DÿOñ@šÑexú¤Ò°õ…A _dêV>ô±"ƒÔ|%“¡ U¨¢15R"=ħ@-DŠ´ \`àDÄ AU^uXHaÊSïéN‹ÝSÃÑjN´"ì–áæ1LYÁ—ø~– &KÔÝÏi®Þ’®v‚ʦÍ5ycACÔ%R‡`À8Â^@€M?NT h‰ ÄØí!ó½H1"F’ B°L†¨¹mÊD)ш|ŒšÌ2dA=M&çÜ@ªìIVšƒbÇ1eX;2’ÅÄ“A©µ:[œˆÕyÏ&¡xјkÁÒdrƒ£éÇ”%( ¢µ¨•ÿ2Æ™¾1A:]<;­§+¯lå,ëÖ ¡È@Jðè'‡`5CÄ7 C­/}t»2~izKEÆRZȧÄL"…E¤DfÞijç¿6Cd=b¹Rwœh /GHS‘ŒÄ# †§µnÑu»º8>'Ú ‹­rÞm¤ÙÖtNç)aLéüãÅû–1§?]ݶB„XŸCøD˜“Ú)^÷ J H@$À€Ûû^†¤2Wö"Xhš/ýz†D û ³Mdff£æ ŸRsòÆ"—?äˆ@D: íá{º,+à ™Â³Û¶@>:“ÎîÌ£|´ÞÒ’7=‘›¹ägßÿãcA >rõJë›!™fˆ}àã$\ä_õ#Ø æ Z"êÕˆõÂ'`>ñe mº[¯¢0ã+Ë–q€MéMÍj–E*7È@H³Ùgûo¯*ú€!q4UfÛµ‰x³; ~ç;{ú='œh‘±ûWÆênC¨gë ¹ô?f½d]»rbËZ¼‹»†Ü®ÔjÚdèV.SÆ‹!vw–CÝ `$6DÖg™ÌT9Rýâù"»™½¬SžRÈÉO®ìƒ¥ùšl6H´·il„wFÝ-VxÛmX<öø@>ÞùÕç_ÿåv‹†+¿a~‡tH q4Ñ"ðgÿ5©1kS×i¦DhQC¼f@vîUê7kÑ5ÀDE‰!P@ÎLîeEA0]à Ap!êÃ8…!øBv”ñ>˜AMø#Á!g¤0‚rAØl+'~æÒ“Yáu ×6*@* a"!-¸‘y adRh¶[ñtGc(2$tGƒz:c1iQ„õ%¡¨{úÁz&¼Ç‚•Åâ ]“‚åWƒADöˆ01Z´(sGCà ùÒ æ‚³!3H^‘‚X“F8fùÃ}%'„ƒWxntF.×?Òc` ‚'½##m!a*-<á–û·4ôÿï„shñ†ùçA%‘ba†´Uç4¯GL6>_Cu¯w•pmR'ã’-³'dVÓsiG7iÓ=‰!€GKà“ŒA"m6?2‰”…•27™qa6ša?âM‡×lAèõ€0'‡f-Â"q“,pôÙz°—uÏȦÄJ @2ç djwRa(ƒÁ ®–/p]3‰áF<à³9e[ù “â_WöˆÕkÿ‚Zt(\¶•¢:r1„g‰œœUΉ~PÚh"õ˜nAžJg‘’£;Šú±‹å–AfˆyꙘ¶e[0qqØD„ul°§V§¤ A0=ÒRBÖpス>Š¥›ÒÿjeGdÎñø ¸‰?•> b> R/Ë7 œQ?A60cÂ9œ?åFdYÎÖ–“.÷faA‹ç‘!Àn‘+%±¨t÷yqa£>gyãfyôô`Jòðú6kQ¤Cz :u!BLXˆß)ñCDK/À'bƒ¥ÁDã¥v­©Ž™Ùœã"6EÒ X)dZÄ^ì6n3lÐT?v3ƒôctfœ8`›UŠýXýI ¶`l1˜sW~„‡š9›c˜³ˆž‚Yn­…WG#AFb$PgŒì,I{òùz°Ÿ±ÌªMë*bzk2%?ù$ ÿRbƒqfǰïc”}*p<ïr1EƒWKXIAò‚_ĬšU²‚Ge™x}Ú0ÛTœ&»„ùçGuÁ…䉗„‰… £†Úú®çd©Æ¸…uqWÑ˜Ž “AXŸë˜Q;T{iæ‚À&L1pƒ‹¡¸ä^!{x)áÔÓ² pù°v30:ø¦zq>ZfýµŽ›a•ÚYd¦ÖSCèFiô)Çù).K‡j¢8ÚhÃȨð$®Z’é~!‰†•ë®G‹9+¶oîÙ˜õÚ†Ÿ+ŸNÄ©t-Aú´¯·Ÿâkê¿íÅEޱDÐ¥p3=¿ºÿp°)›ˆè‡}õ%dùâ_ÅË=Àt( !Æ«}ÉËÆz~çeþEr6–‚§F+òœÏ:¶˜9‹4®¾ø¸Ø…?›s¶½—Ú[t!|_Ó›û%žÊEÚ©NÔdýqKP¤üÁu¯„µ'¨kBÌ Kä ]j¥mãj„±)bº¦0¥€*S•xíC‰c4¼ñ6¬_“R0²‘uSÍ+~ÊÖ·Ó‹ÂbéÀ q;e¡Û‹á1¾ã)AÔ……Ö‘ˆ ´ì©¾Ž–¹+&ÄŽyÄò {ô‹:OÔK—ìF<$ ¬Õ¼þ›2^Áš V ›¥›R}×xÿ)]FR¿9·÷X¼ðµ}t:•'+f’Á8µ‰$¼‰!"½Æ¦DtxJ˜¶#CÉÓv.L1hˆy³9JŒ£‹Ía¹¹4Ž˜ªoã,{ùuÍØ¹ ñ¹n¨Ät£”¡ÄNÌk¡ÀaJÛ± y$7‹â“°Ë{s>,—5"U)öZ>‹_רÌo»DMûd‰|‰`6Ryû™¢œiô¼qm Öo§z7‚È…öN¸nêÚg‰f¹½Õ[à Î+VúÑ¢zuAìNû´hÄ™üDPÏ ‡LYÁ4 ä2­–¥kÚJ ;¬ˆøQ~gT>j>?›aÿ¼VÖ»hôª÷˜7­!f[f•úhÌкM)÷ѵǦÆ`¸Ã¸Ã`„Ww¶#ã9žëšmf¹,ù£øq—N5ÄHŠÎÊÎ;¿÷ÏOä ‘É†0r‚`c‰ˆˆKB«‹…KA`5ê‚Ê_*@¨/êÓ r"…ƒÉêÕ ýEÎ6Ñû5!™QËz·öø¡ÍªÂ{z"Á>HD.û0+Òg¶£áŒIçäŠöÐg>'.ÍÍ–ÛO0I7}Ó}ò2„%|[7ªÂç´SW¿–ŒeN¼îòz^Q0N )gw/s'?µ{‚s7«<´Ž÷¯Âûiñß÷¨Û—ÿÛ«­EGÀc½_Þwjf}!;Á¾0ÊFDýè¥ÆJÏü4c‘m"—ÍAÍ9G—‡s8WÛ½âÄ…}Ó'ŸÜ{uAiXö†FŠÄ:yÀ‚$`€°kê¨ö(ßS¥~õ==À ÷±"¼öÈЖ‚_=M îEìÓÆj»« !2x!ѧ¬!âe'›² 2* iÑÙcº£`áŽw#+>,W%Ý=—çÚB &-NÓ+FX7µ)Ui5û¾½IÄÈÈ´ƒBG` ÎÚÇí-À$L–È=l ´Ê6ˆÈ|iw( :"µ )Ǥ>P7iÝËk¡¼ÿ‰h½ÕÀ¢9Uôc¦&ܲ½M RTqçeaµwtØvvUP7&Ù˜TxÔO[wùñ2_"ºÛ1kã¼o‘‡:¹¯îÌ(nJûì7Âzkµ» ˆ™kš“ÂÄ "K¤‘<8ËÂV!·­T>M¸ü¶œ7SàÇ›"g®·#Âr™Ðû²çqÜrCˆ°üÚâbbtçô‘êÎݱðµÖµØ#¯ãlJÏÈÓ2 °­w¯N„:~ÄGPª9é™gWvz!?HY…KÁjE AÍYpm«w }¿ùE‡Æ‡RðZYXþÐÀ¦?„;Ç _ÿ„(ÛÖ Y-ç1ìÓ†´AÓÑŽI[xÒ Dò]’:þ±ÿò7†s/|‰Þ©U7¿DŠeIŒ:}?EúÑ5—ºç®í®¸Ä K6F e'(LÑ#=ÿ¦ª›¬h-}\ ð²óˆ!/?ÎôÐhí“r¥qg­F™ÒŸ(÷! -¦Ö1”{VkRQíüê|nnnáȃÞK½äã3Oóòšû¼BY‘F “ʆDê..ýS„%0$0ä·æoº|0^Xª”‘Ž>iEÁº¦r. Ê™ø ¸Ýþ­nàÁgÝÆëÈ»¾f¤O!©á¦ñOà?Wÿ0hÿ¡Àzÿê!\8A¿ .$ü7â)ü›wBž¼%òZlqb½yÿXÎk©²ÅÈ‘÷äÝÃyƒÎ‘%Nü;ñd Dþ#šPÞ?G˜.ý·T yGîýsj5!„bøö†±þ kp,„ dÍb˜Ãˆ‘fÉ l%ì¿ éÛ÷€ƒƒÿ&| ¡á{á |ä€Ð}ÿ 6¬˜ï@Í—.¾lÐÀÑ '|øÐ‡' ¼˜Q Ç µ9‰°âü™%›DM©R%LÞ![ølA•fÍåò^°` “E‰–-K\‡ ½éTèNYl?RõžUNÈÁâ‰ÿ#`3è}€öîÛc_¼plÐƹFÞ;¸ •†0‚‡´àáW,#-´Ð2s€1½HM³<¡ ƒøŒ2ÅJSì³Ó2 Ã4ËOD…JÍ€†ZH£ .øÀ"Ùls¥6&0äŸVBh馑Jé„ã‚S‰…|b²…fzÒ¹‘€¢ê )K  JÊ § òn ï¬rê*°Š‹€& ê̳Ä"+Îøè›ð«Ãôh¿rØçŸ¹ÞB¯ÑØúÇM(ÂF+-ÂÏH³{ÁÉ>³¬3G+SŒÁG#=¨PÒ+è´zJuH  ’ "ƒ4²Í6 (a¢&š‰9ÿ"åiªä€ªn¸Œ|aØb‘š§y0 @¨–†BÊ'¤0ÒÎ¼î ¢j {ÊKƒ5ñ»ë.ÊJ+´ôzÁ¼t1ÚG.?÷hˆ22Pì²#ä÷´*4HQI3,Œ3¡úíL¡ U$è1Å€¸ÓG :u!-®H+Š5ÁŠ h/ "xmØ!Gʦ%‰‰¸T^¹:˜J8‚ä!êYi§+*¡l™Â :1£Âj¼ÌËáW°œP>ùÔj ¡Ì=­Ý}ÐÓ¬¼(³ ,ÊxЬ°`ƒ0pmPªRÊ6;1ÒÒ ø4Öà²TÕOC=(5†VcÛ*ú8ˆÿÈÀ ‰èù'%’L &z°œ‚êÇs—4o™ 2ps d§#ªK ™²2*+Ã#:¼ðŒF³¾5ÛB+÷ç  ü ‹Îw1z!¯†èèWPíwnÑFÔ,Ê„Jø J;“Ð/ƒªñxÎ@å°{\¹®‹&‚µ¶ € ]f3È`°ZA$ÍVɗ籟‘쇜@ž =$š+zÊC¢$kZÎT$X%¡-EhX©Š@®ò3)0í œ‚÷¦²Œe>È€\2¶< ¤O|H†ðƒ ¨AJˆóœ—0²UæN¢ÊW¤ ð¶Ç0Ê0‘Šxÿà"ø pz; ÷@…*ïyU„³ÈŒhå;øù)qàÁñǽlXFÎ?5º$þà@ ÀÆ °fF(F’¢ d*áiŠÑh—šqð9 Dø–²ÀÉ\oqOr¸´ç=q×? —!äÅy áA©Ó­½aOT…¢^BJd¢ïadnŸüÇaô˜¼JR*_ùb ôrF+YrÀ.¼€Áå\â\îrldš–ìG@ÍÝoYX;v°E­FÐK‚$Ói¹ ½ÐG,Pkä¸ütÈ÷8f˜z yЊVPf/õ•¢Îv ´ÀF–¸„,ì'‚ ¶¥ì3Èï7 ]?ÜæÅtÁ™ò<,䙆—”€£)§ZÜ‚B¢¾…r1Ë"#.<ý~£AÔ%uѬ¢m,i-F2e6WJÿªD¿…ËSÓ’U¸Ô#¢pé X.„7T昆–šx  ]Y]cKü§Xû±q°*/–¸[Íæ ¦G(ƒ„&Y?’iƒ¬™e2Ó;çP$q»5º&u³ÿ"â0²Yÿô¥T—D¢@³ÏÔÊ.hËÃä¶¶°&øm¦° ”{ÕÐ0Œab1ßF$¾!ä­0DR([?ÁÓ…ïqJvÿ7cÿö!a9²Ò}òH\]Ô·õbKv´;SÍÊ“GŸ2k˜8†bý¦¶,Я¹Ì…WŒÆ,Ãü¯kÀƒyíSjt£¹Ò "ê!ñˆÛÍÛ2\J¹ÿ¥Y>aT>‰2†ÁÐfX)VÅóLåO"` àÃ%ÉÔñÿ+›\ <¨4gUÇkNtÀ^@žù #ãarƒáÅ¥Ø\ -,> i "[÷$ÕpÅÈŸx6Uq±%ž+>û˜4'84«WÅö™è·ÊÍOgDd±†,D2ú\ëö zOE,TÂ~`a.ÈνŸü€e¯P9LìiUŒH4CÏ>.y„¿xê;“ÅHfá•<=v!€ÔH W„?þ’Ó¬Õ‰B\@®­l„ uÉ$®¥›ZÖæð”’ñê)Uâ7 QŠqÿŒb¬x܆!Bñ…_ÞJ¾/.ÜOÌýs @6>Ö›žf¥ó '4ÊO-…LnR &Ír®“ º–^,óqeÕ,ïYa=†Ðº.b†Tx0¡h|?ÿÒÈ¡…[Äï!”ïpN[ílgÐÖù”w+ëgVE¾ín¬\e·íB?Ñp 7€g&ïè„7ë÷ÀX–²—eDôêqS IâR¦¦55ÈT>󠇳ˆä:_,.Ú:€]†Kšcׯú‡Â¯‚Õ9Éâ?à 9$¼pÍýîT˜ñ;¨6…ý2hÎC}%‡Eì·B6ÐÙWˆˆÿƒr'¤OFø¹AÔM—„càô§‡·½6HÇ„ãÆa,ôx»™¥¾(5li ­À¤àÁT鋱(¡"¶8á0[ž¾X-ª‰§[‹¥ß¹«p À8¸¸; r¼dÛ>½q›—ínÁ³Ó­?ûAû”êéD:b‹B"®¥Ð‰†ü3\ˆ¥½jŸ{H!D‚0´q "b¯@ò©š&›)Â(ɨ9 Åi8ôû”±@>}’²HUj… p1«¹Ñ¸ái–{*0‘ƒ‰<ó h{<뛿Ѫ!z³‚+¸à6.Ô°°<ùc,c 0BÎÃ\(ÿÃyâ Ä=ÂÒ “$H"ä7âô ÖWä×5hÿ„ÿ?ª ZC>L@:o&iТ;ãä<¯„@Fó5ˆ4„æš1­gÈV9¥UÿضÑ?¸q¥IpÁ?Ü`[+e%¸k{=çᇠ†h×vü@Ð]yQ°Â”,pÊ7ð£"@Œ­Xà`}¥i3é”iô½‡“g:1’ÙKÿ¬Wg•ÙC#ö¼d>ø7ü`A‚}õƒo2áP…^šDrH%”W^ü RÝ?#ˆ¨çž&÷O‡~êG­0GQ$ÌpØAUÿ|Ü?l6š@,ØG ò <'¸§YeŸ!Ï?%ìB í1UÁ€BŒÿ‰ˆR,Ðf?|e>?(5!…h¦É­Øöú”PäS ?J$‚Ñòiíµ ­õ^xA„ˆCiô"Gˆ¬PÕ—ÄZ ©¤†è£š@ó\š”îIÀK¼ê§§tê öà§Ó”!Ò(J%Eì@äÊ n­$<\ ›ÿ ¡k»nø=€,%AÈu+Pžÿˆp§Ê(cëòžÝ®%ó&4#¹›‚ ÈW h§OF+M0P¼éÄ©@÷áÙ§ñõ{÷€:Ï' ySზJ²ð@È”©!CPp UœpWëeÃ7÷‰!‡œ=xQÿ¦í@"àéžC¿løµ&"Â@à6ÿÝ"8ÿ³d"¨)M/5ÐO˜ú´ÓTc ß@ž 9.: 3õ S d‰h„a·òCyÀŒòeƒ „N¨›š ÂÆL„lO>äó^…ô-Êñl?ÕcøöÌÑ 2‘ ’U"qÿ¬¤”j6Aù9¼êéA¦—žÜßÙÓ@ñ g*pš`„?ø@"s;\ ²Ê˜ a´¤LM@Bš$Õ¦º=dÛâ[ØGêŒ@©Þà¶Ã½2@TòT§0@;åzQRÊÕŠV`D(‘Mÿ ‚ß| RõâÌ 83š{øÏ3G0Hú'Ô ä^§:•©®–”¡P°IMúT”²ÛácÜ]¤h+3• 2cãØ?F±È¬dpÂKµÎ7ë™{ú¸ž ‰½|TÏz.LdAê¢Æ ±†1”) ßäèKy”¤â'FôÀS9‘Ò@÷ª…Ή¥DÝé¦8Eÿa j,ðÌ=tb4‚ý£íÉee^uƒa™‘A_ Û~ äƒü7¸Z(3æÉèY ñ€PA {ÃÞõLDBE¶0"CË“ªS'.%‰Œ@¾´ P"³»"†vÄ,.Ñ'%8ÕÓ Bÿµ*"„WüŒ@åQ*%&œÊ¼¡Àa!ÈKIXdÄf^%(Wø@0’¹eñíyÎÚB4ò£j¤š× òâÈ£_ûªL{ô;\X mgÜ€R*ؤ©4JA jEÚZQ \4c¸I*fœ‰‡!óz×lj˜Ã-dÒ|·4³tÿÍpÆp‡¥Ã­9÷–‚ÂÓìȵHáBº©åQxN’è´ý ¦ã—R QŒe×û“N PË´¤\КÜ$?°~p¯P€™L¶äÜLrÌŒyi¹kEÖƒ&ŒrÝ–!»i1Û…ÍkÞ–‰|=çl±Å¸¹AÊÇ•ü%$ÐðZÜ Œ ÄI öQ w ’§ÍXtP2o{ €JuH›ƒô‹Ï‹‚†‘~÷]€wpÑŠ i[=šŠÜ¤F­üàÀè•¶ì,^/’-b>$…õºá6<ÎÅŽkoÿÔ/‡ÿ0¬3 ´S;V OHz£hv—ÿ¡l* òÊÍ´gt0]¥gNã‚d^öˆ¥§ÄM›¸mÀ¸>¢FFL€™b#VŽÌ5ÝLøqë´¬pké†Ë,¾èh¹--QÂïld›ìßóÓBütƒæi(ÑÎÈÌÓÁ1Ôv—Êé“~ù½½§bÁ¥%x*išA<ÅF0¢S¨ ž¥@fB€«_Â…:"F‰ˆméÁM®@Ñf £Wv‹CîRȆ$á)L¡Ãó g‚|¯Øw‹ˆ3Í>"“Iø¹§Y@Ð$g Ê6!Á%|©/üQΕ‰{€âã‚\Jæ/§ÉÑä±Ï§)þÒ›½‡ÿø‡Dðü(Jq‰Ðç»4y§ANâ*—R+©isðµ€5ÝÓ’m>Z‚R8 ‡°{ áR»V€o&g0U"\ÖL,ä{,T±” Z!ÐNrä|9Õ#Sh±+Qø1?SæG:¢dUô€®“iWä)TÃs˜ò9—¨F@(¡6ZkÅîà Tm¶Sgô1,!N(Da=Ñ£Õ³MzÕGb§Mxf»f\/¥HÚâu7l}•å”q’ÓB ÁÐN­ð ›W`è¢0AÀLyñ4÷ð‚6Ç4FšÒ}Žö1@©ÿ2/jaèA€ šFÀAQA Q‡ø§„¼¢¿áeE8?²bvf¹·u¯—…`çR.õ'Õ³k"ep.ƒ7]vKb(Rf·9d@VA æ’] CkÔ#ºÂN„ˆPK#3›õ9~øcóð‚­Ã4èex/ZöE¯´n÷AxB6*õåx—G s‰_‚# “Ò#¯Á>z 2 ©0Qü'=ˆ°Gt‚RØÄWÁVk–\y5fÄv‹nÆf†Ó[Þs<Â-3jÇBC±"aîÔŽ‡*²NvŒN¸%øÑ:¡ó‡Rµ—%5¶9Ù¨Pˆ„¸/ùÿAˆü¤á‘jÈÒVF×PÄA7!‘a;ÿP ¸¡Qkõ³Šª8CS"…ÔzfÈMÑp®÷Ša&>-ôy1l^7{Q3~2>ÔgƘy‰#V!¡Œ!ñë'•$R$PÔâöJâ6-0x5K?6`ƒgŽ¡R$(xsñQ! @A¦Q7üAu?Óg3;E(&ÿÆË 0† J>S)>uHy%Wx\QÃU€†gbg8V)É-§-Óa–¡‘:O#·qX-Ò•qÖV´£)y+f*UãwÜ—nÖ(€x2¸bIó™Q/ö9ÿq)U#RÅ9“Y`µÔP(²@H`Gx[¡‰_Qšª¨N{”py! Ú³aÆ{'¢=¯wkV›‡c"0‘¾‘uñ›(W+b@’$9™(9ÿ¨­ ñ%rÄ™1A*ñ±OÔ)žQuƒuÈ‘0’R]ezcâyñYNæW饿–BcvW¶¨= y‹Ûa\º"x"·Ä-ü ¡\ÊMʃ×A‚*’¡BÀ«Q^59Â/‚82Eß÷0 i*PäÕ£KõK°˜Í­/ñrøÁ%P¤A0ði ¡U7ÑB+‡µNµ Q¡ùÃ"=á“ggæª ×ŠâvXYGqÄ¥a‡qzò!·5™}÷D/!aT6F·Öy´3eF´Åÿp £Ð G•¹KWx©ª"e  :v±Ç ˆ‹áM»‰ÀÑA†"um¹šãÀ™·NJ?)$Aö¨MÓOwûýc:‹˜4Ör™P1ÖO-ù)-°DP¢OÐ*5ÚYL?K¡ƒëçŸéj Å‚ P× ì‹ _A^ÿV8Q8¬ËaÖÃu¶¨Ä¯8v*u"`ˆlwÑ[WÛ²›Ÿœg¡Åh‘Žzƒ‹vO”ˆWn—–¼âw?…ÊÆ—Ö/T£¼âç/òaÇõ*:Q“2‹ŠôcT“˜©¨ù¤l’!ÀÃ˰ Ïpz]Ñ¿‘ü¯|¿éÄÂ†ÄÆµWÛ` 3d‘»gv–4¥±3r!ñ|ÿرØÊË6)K£ª³Ou¸¥TSU¸Ë™æw£1„øC£õ’“Òyò 6½Ñ%ÃͰ ÿ`´ ¢¯B¾4e–Tø=ZZº{Rµy•VYvÞ$«Â¶½É|s{ßSš)— ÿR‘ñ£ƒ1Ysü4s)‹<÷Ó†*PND‰ú¼ JŠkŽâ{®ùpk ƒAQ¼½sk27„ü;øPŸ-Ñ.†P'à>'åReöRø°_ É×Wß4aºIqÏÃ-Z œ’a0!'’yg %~*n?²V”²p¼Ó ±Ï,Çc:zûDk$.YšzZóP)—‡P•™JQjÂ+°š½ øPÕiñ,ó;á“›[—R­‡Hg©º¯X›¯ÙBñЛnmÀf‰Û3R'Á4Àûiœ¢’W$ÔˆM-·c;-ÔmQ“-0?K„Ùè9›â˜\t4m“’ÿ¥m%(L¸ò%hš[bг²Îg Hl'µ ªa«iR®g…q6δªÉ#’Û[ºš†0 `|ÆZ‡0 ˆ&¨AEѲG¥²fL~K:y«à›2ÇÔÝ„èØÿО£ßeŽóƒFÇ![Ò&¸#ÐpcUI¨ÝÈ nÆÁ€Ø}á˜SÄ{®QœÑ/¨.*£µè&5¡´•BÌïqyÓ„f„ ´nÈ;u“¨¥Œü&É¿þ¿yEHG¬¿[WÊ…7ròЬŠÉ¦ì1‹¶TνxW„TO>5Þ÷äR‰ô %ˆ.öPŽ]ê‚éÍ—ÿÂáÎ:Æ /@1*0¡1¶cúÌý”vÉQ9O$Có>®ãaÖz€4µŠôR–ì^›‹«3dÑN`”Êul˜/»OÐݲNÓñÉ-á;Ý/νO_~òõ+-l¾ATs óŸ#žfÞႇ*yOT µ4WsâIñc6<̾î‹PP' [8ƒ="ðëHüÈxY…òG WÛÅÖ!zA‘ÁµÚÂ(ÏY.d<é4ÓþTÞ^£TD5ÕY5€ ­á^!P%Í¢ç$H‚ŽdUÜ éa ”ÅD¹ÜE¬Ó9—g4¿¡NO§QZÝÈ<ªXÍÑù Rx•ƒ”ô ÿÙ€½–{åþ¼ÏRW£"xбâ‰â(ß²w{?@Ë£Ã}YT5ù2M`'ôBØû÷!ß¿þ­XñOÄ¿|!è!œ7ñ½yÿNP蓺B¡¾Ô[L =[¤ÿƹ籔7Oà)Y|nyÂ% ó&ü;ú¯…8uþ¶ìß²e£Z’°´‚!¨ˆ Šàçá_¼¥]Õse¯ž­T¨hÆ7[ß~Y~åæ{ Ö?Úüšï ôÉïD¸AvƒàŸÁ¢òÈ/âÂ`)É;¡{à«ÆZGÄ–h!·©6²¨4ƒ¡!çZá¡|š#zN˜Gâ0ŠJ¤ŒBBI³–€ ¥yj©›þÁgdª˜k€ùÁ*¨ ˤÀR꟮ºï<±Ü*«µŠ§5Çts*¹Âªë-{â* ®Þzk¾§ Ê ! ôáîBMB®°Ë.;ÿBÃ{;B²G ³¨DCÕ³‚o 7?;éZK)[Y¡D¸›`ÂZBhÑ6¼gÑÅ2ìpÞ¥2k£Bº×W,M ¥êò•bø•…V@DúÌS„ìù  ‰q5£’TÒˆy &^ iМ¦+öšì(Ê@iúòóÆ|+­òdë=¶:ª}Öª-Ô3aˆF÷Ÿ"Xà9D$XÿN$•x[T3{ݲŢòW*„̨"§5 ‚˜ŽŠ¡RO¥¡†g¤˜ÕOÿUãLc„ÕYO,%[{`˜&0D!&¥ƒ²ºŸpùa¯ôüû’G—§¨eK¡—¸F'¹0.Aâ#æ*ðÊ”¼ê5ÿ¯Æ\¨QûºÇþÑ;ÐŒpùhÑRUüC¥jØRöWPz” „ *½°jù#.ò·Aà3â;IG>B2Iàÿ˜ââþaX`Xשߗø!¦¬¥@VÙœæú·9=©©+l:޵ȖnaåE›JXFw§¶ÕÉgûâ Xµ)¨ Ë)‰ŽlU!zÑë"Àî*ô#ÑCc,ÚX²”j”hª¢èM/<ìa(±R3BéÍcba6²xA ;¤sr¿ž,£À°À næ%ÿ˜çgí!fÿÆÒ39qå k š€G±Èigüh›]"–:ÿ… tT¼bÔžƒØ…àAi3É64•!Æ‘CˆÁôV„`"!Øž m#ÊH“ yØÜâöPy>Ñ YS3{L€àÛ ð¦#”@AXjÒR,P È=#(¾ìSz@WÆb†´+<[¦|âѦ5•‘€Ü¢#Vêb.>m©4Yj[~ ð^óKˆÀsÕ ñGˆ¢PT&#€ÍJoé›ÛÚ(‚¹©TË!(AùOFE/Y"Ró½y|fH?Ê–#ÅVôô&Y„’užqcýr*^é¨YÎh'ªl*”Ê5 H®º4M@P ,K?×´ƒè'iÞa¬=øÔ}qÿB`ÝÔUµw.^¼¡†È†˜‹!doªÕÆÄ¢PàcqVàöOS-%åÊëu6,,ÈßȺâD…WËVN"|DÉ'ËÀ‡/Å–õTEºdœ.k´§Òšt+gÚ ›ØHÂâu.Òlaï(®:™ÖubïL‹GÍ› šýIloB½| ¨  o>È!É U©iË2#|.$†f‰Û ÿA‰ bµnÍ+>|µ±Ø0BIš…×!K²aÅIç¸B©E”ÜÚÜ_Â¥=þyJHÏs•®°†=cÜŠ ²eãàø+AcK¯ßîI¼c9ïKçÆÁÚ#öÿ/!ÂäÓ-|LÐ,Ð0D(„]EUCÃ!4RRb§T6*3M¥!ZÁjßöæNÞóªP…ƒ ZÊéåpz÷3èW6f°´•ä6úð²|Ü+êDÈp+\™’öÈXñhæA‚¶Ýó˜=&¥4±Âc¿b\àroAÐ"S²0™É[j/Nóe·¸ºxò]rÆš|§!‚ˆ~×eÕÒ‰¿ÁÊ:“V¥&5ǫ٣ñ‹g3.*Ë‹!ŒVÃζKžmXÊWø@z yÈ?@±jК-ÉÆ&²VX€u@”®ƒgLî±úË\bÉ”ÒÿÏ8ÎÿBB]‚P*ylr#eU7ÊÖ´”qJ-™6cõ©æ¬ó±€ºÙ¤j2a‘~#ÂÝYæD7’ j6F±z RC˜Q}¬-ÃN·>w·Ÿ×C=û“‡P“ÑÄ â=wNe‘ S ”+ KyF\ÅÁ”æiÓßz×Ñ’õ€k ¾Q‘¸|_mëY—¦ìŸ¸X®yðT«@íACFyØ]M*&tÓ@ ’XOEvK°T^(–.!=œ^ÃÄíOªÞvñÏ£J¨b‚¡NE¨úý–.ˆE/e?ÁÇvlýë+%‹Ù7NöŽÙ>±“ܧ¢¹Ó#+€Oaÿ£751˜!’f“:¦’VÍŽJÍ^äfëj,Ô{< —’ÕJ~*>lkúö·UbdÝñUÔœ„ b™ø¸¸Á] wÖ ð»=T`{@ÁþfÑÿíbû¥¸?´?(;$ÛÛ¿vªÉJ@–˳Di§Y±{(09 €9­ZˆÖ8<)‚±·ˆ!qã9ìó3 ,-F˜¤Ìû‡a„娥ˆ †À„`X€-I׋¿û˜?¬¸?#|ü+ l zPBš€ߨ—}Ùà˜W‘ŠÒ Þšæc ¥xˆš“‘‚*<ÿU8A§†é6€·úÐ!› #:·ÌK’ðCŠ!¨»yc¤Žkx«”²¥€‚%lD¬ Ú# Ñ0@ Ѐ°DK„ÈD È£¤H¨߸s¢—X tk' c›|'…Éæs¡Â[C5|›#A±Ð¾¹™€z0¬hÆkïc#BŠ˜ • D%Û(!øh†fШÐ’E@FtDmÜÆ¨°D$ LÔ€û‹Òȇ‡` ð Í@ ¾Ó,‚ÀÀp9Ô(y*‹hÁ‰*ù‡"X~tˆ5\Ššë¤8Û3Ò>„¸„¨ (‰©‘3K¥…z§ èÀ@¤óÿ¨ú'…„ŸBVËÆÌ¿o,5nìqX-yFÓ¼†õ‹ðؘÒñ+·˜¿üC·õ«}f2Ûë? Æà1‰ÂG$ÐkÝÝå]jq͇­j!ÐÒPþ‡.½´Á˜+°2$Ãz4i€Tˆ‚Ô¸L‰Ž®¥€Ñ›xLOá9€õŬb<ÃÕ"PN´Ðû¤O„h&„ðZÓDfPm¿h®&%ƒÄ%ãþP;’ü ‰;;7r²¹5K&œŠƒ~^ÎY_f¦@јDY¾!x…†ÆZÕÌ ÍÃÕÎ!l²0!1$阈ÿ˃WZå½›<½¾ º gü‡gÔ¡†Ô¥hƒšÆb Rh_ ¼#£lȾþP²ì– ïvµÒÙîÄR²•²Ö¨ˆD“ÜÄ¥–Û¶ŒÔ¸}Ô .Çö¤ €†fðax…E¬ѨˆçD<¬ðmvˆ°" y¸”ˆF|jUðáž¼¹YÑ+’…Ðà P¼Õú›þѨçfX¿„àš‰Š»¨A¬–š ™úɵ€©ŸÞî1é?ÜñÑvY¼ÔHˆÜcï4Ö[!wcÝÜ?IZ!ødÖn Ø0 ÄŠWºˆj2éâ¹NR ÓÁ˜°Šf¥"ºÈeÿž ·¨ çä^¼³a¬}\œgz&ñ¥8MhÄïÕª}³‹¯¼ü¸ ¯µ ,÷#tCÏ’!D5Î~½£.ž…Vo¡¹ÛÁµ[ í‹Ðt¨ë]r}ˆ€OµDø€àº©.Hªx½ë{ˆf³‚è@S’Ðh©PžÍs‰åu‡ñ'8‡Ð†žÍ_8Öè¦g…„PʺiC Gg GŸ˜-/ áh'» ÈÊ.µ¯à(¤t¡QËNÔMÛ˽u—Û–ÜMö^Y‚8N†¨‰˜á«aÓh¿ˆç”–k+%;´}À$™h>ˆ1— uiAÿ‡±d$îõDKH&:|9¿";œX¯ÍèöZ¯EˆQÀïͲ­z´dÄ©ˆv°HFeü"¶pù,! Öpq¼–»ž¯à¡fìÓrT@KßNNdwaÖÛMG%;N!‚›ø€@kø Κ€?!àÈ@{ªpç‘z²ˆdSò] ê™â5º9XãfAéŠQ ¬Å[°ÕÍd¯ç+bX¨ëd›_ ,‘+¥|–üE~4?—Ê×w, F,ÛξãÜô¨°½éÛ»uúÐvŠÉû¶…€•ørá +‡®¯Œ&ØNJAµOZà^¶PAS\Ÿžk«Cÿ€eQ}Q]v©!:…ºåà¥8öd/`¨ù“o©|›Q—wù,S›?S…Pyd¹Å9SÃ78ñ÷g Ç kÅ?§6 ¤§ÛídúöžŠ‰ðà7žRÐGÃ’q:)«ˆòîýXð_ˆ‚úЬøGɇÃ>^-8ø/_Âôœ„È÷áŸ>…EŒü§j…ª‚>(Yüw‰%%–ÿ,\šÙòß‚3kýf3â¿^.†þ:øê´‚ðá³`ÑÁI-x£ …«Q©fÍJõ߈¬oªêuªV{7×¶TkQ…Z¸l-Ò‹¡‚^Ay÷þÓ;—n_¾îê|PÃ?Äó>ÿ¬Ø°@Bÿæi,8oÞ ÌåÉûw`Á&' F)Hòß«‰@ü×Ð…EŽsµ¡ï´ë B\)³àË—1k:­)±àŠ?fZõOˆÓ‚¯R¶ìõ«—a¯(´ú1 ßVþÇz°¼VòR«þCDa„U¨ã¡bMOÿ/þµróŒ«Âï]n±EÏáu“_H`bÿ f˜ ŒDH" ,ð‘E—µ gžyHÀ?€Ze ¤Jo½‚Zn¶…=¥åSÚGù°…ÀQr MkQ°‚NÿàS0ÈT„D­¹¤Ê/+ ñË­47äW‘¥yqõ—Y_%Õ–Q•Çÿ–€9šyP ÿÄà–=z%Xªgš‰%Æ qæe˜…µD'=óä%@Ð -løÏ œubg÷€xSF5DÝŠ)A„¤‰ÅhcK÷YDÝMÆÉôÒA<ôÐ+¬0ÞrÏ„Ï++ˆÀK/7½òŠÐP"w±R‰¥!”UV¨YûÏ•WŽ)–UDz'êEz&¶ÅÕ_áUà?nÕ‰X_w4Oa* kg uÈÈ<öX¨†-ÌÓÙA„ÁM$ÒÓÑ?°x\Š–ä?7…tpK µôK5Õñ—WP«ä5t2ͳ±¤ZÄ+4¯ð€ˆ”¸8‡S–”7ÿž±Z¡Åì{Ⱥç^X7ÜpózÑ’•ÞZØSÁÐýO -~ujkW]*¬ùÖ%F=™^y(õœ¢‹… ’Ñh-uÆÙgIêád1LÒ¥)­˜Š+¤°-üO<úð£Ïm€TÔAšFlÑŽ.]A”TtNøøô0­ â§7.Ä?дò°øà‚ŒSü€Äx†`eˆ{íMõrëï•wóÌ-yÅVýîöô¾;ðCûî{¸BO<[ŒØ£¼òË;ÏÈšiÚÓîôôTß®ºˆ1¨æ]ˆImç<ƒ…Ÿ¦_ó$¼ÂGó,jТ÷þƒÁ=ð[”è?Qè“ÏÞÔõ–ÿiá+ü/×W±å7Š[œæ$‹H®cÿh†ST¡ŠKø@8,é•ÇZ1„Ð<ËùÁébf• ëXï¹YAXç:ª@…vô1a±*`¬ ­w¿ÃÐÐ ‚¡‚äiºZþ¡ Bl‰—·©¥jy±‹]¾æ ¼h`1 “FêT'AYè aÁ?Ö÷F„ %Ø ¾Õyàå´1Í¥TÔ¸µ&%œò›Àôá€ä›ˆEŒ3±SÑ:3¡„‘,"„Zi†!·9h@’€!~ÀŽ! @EŒ%CÕ!ª;O ïãC„¥X¬d)]y å®ÿ‡(@§4òP@= b¸vçFyýaÞòb=…Ë"1 Œ°×®LlQ&eú2z0"PŒÙ"¼¨¾l†±”¡Ç XМ`4‹ÂKBÞ ,I*A‘DP’›§äí¸!ÕŠR“‰]Ì"““UA,€ž4²äÜMbB a4#)C].`ˆ!$àµ@†/ñƒ! á”k!%[LÊ:Õ©„)$a U— ÎTÀœåM{ÈÃ¥Õ’–Á¡}W ü”DÚÕR¦–à%M𲠚毩ÖňV TA± ‚¨^„ÀhX NõM¦e;›¶j“’†¤F&sÿ{ˆDNâ°‘¬%˜RÍ+NU*‡')Õ‰²óG:´'NaÉJLÕ«,†,(A Hð¤‚'ÿðE-@@RC¨®Ò@ÄÑòižíìIµäÒ›Üt‡É¥}¨Ó ÕÒ" *#>BÔᑈc<7ë²ôŠÿ…È@Œ™ÄƜIJ±iJ@}™2*\‚Ä¡S$ãQB@ÄÂàÏE€Š=@!˜âA\Tƒ xÛÖAÖU"%z#%âǰÀÓAgÔ© ’äÚýèæáMŠœòÑMðßZl€Eü¥Þ„²:‹®€aòCbº Ðhw’)M¶Ä¡"X*\Ö2 Ã8Þ„$Bª7z¦EˆU~2M¾Ý(â£Ý!)Zºa)½Æÿ«×¡"Þ— ãÔ \T؃õàŬÎEi, IèCFÈC Ä“äÞ˜FÌ™l<¬‡ŽÌJô~ÀÄýeã,ÀoôéU‹A\@¹DÕ]àA ¢ÕýCŽ.Ø`™ç?@%†à¥]¥$Zâ¹V*Tb K=©" „A¨rØÒؤb×–Þ*V= D€Oø„ÚˆR1SAðÂÄýKiŒm´À=¼“ýøêÃDÄœÿäáÚZÄ/ĥР`|u¬ŠFL€,k°(Œ"€Š¡Úÿ?(©j)¼aiV *¡EÄd{З%ÑKÀ&Y ÈS„º H …>äBTJ.äƒ p¡k´íkXì‡"ÇÃ<ÎAø@5Z„ò*o¦h5./Ƭ@)U€4íAxgM*dbkË‚€euëþ€ÍÚlApÛ$r%寧¨].¥f.~¬æ’Ji»á™"‘¨àÒkß­Enß-tÈšÂÚƒZì¢,UØ =Œmzùê°òC ?áÆÜæ†ÿÐmKèDжßr¬ã¤(uº4DÂÕcJwF]Ⲃ)ØÕ…ã%¦ ÖÍæê§‘Â/&:Ñ톪»¹[½Žj©r×ÙëéÿÖÖvx„ÀjDØÉ†è^€Æ=,° LÅ’Äï"ÇZÑ©œÆÆøJ\$j /â,oô6o&ôfrðߟ9mKxïìYD¡ÖžÕ!ÁÁ<zr%J¦U.|º§|–#\®iªÐ’¶„€Â A)FUØmQ.Ú|ÓÂy²ê®.u…€|Ð1^AÔêAD±E4Á‡F…@.\aÜÖÓ¨T¤°¡*gn¬uË`Lƒ¬Jü¥ãˆW#h}@ «ì3Ä¢²¬ÊÒ^¢î¬åž/ñf¤_…ýžÖ©ç ëp¶H„­„ÝVF]2)³Å?ñéqêfÿDB|°Ä ,LÀB1=´A’q[Dt­eEž„\ÙÜêÆÝø@©B5RÄ+DÀSD1·1Ç:ï[fŒE òÀ¢Z„üÃH_`[eYVãúðä8—cñ}fKt_7g.¦"Zhí…í¬k ÜN•ؼ(—òvryä3p¬×ªÑkW,3Ó@«F†è> ]*ôË0NHtH/13`JEo h±H§p ®ÅHcÓ^·ÖÞ·& PbOž/·íž|Ž&ñÉç#Zé™<òZ‘!H_Tz.ŠM€ 6b“²nµ³º˜ÀÝÖmZ‰ñé¡ ÃøõÁ$#H@rˆ€åGŽ·€KBØH3«—´–÷»’ô †4€Ô×(d*e¥Â€rü˜×Ø×—g½!Ê ¥Å“3`sgN¥3¨*6ŸÇë,[Ž‘(³Xd0Â</p鉞ƵD5Ûn¯ÄZ•„µÝÀ Õ<ü¡Z7¸„ÿ´4'½æcùÃÀ‚ÏžŽÖÂ(€”/ÆÂyAd=ý»Æv£u*¦%¶ŠÅæ1)V{‡%Çy㇣GÀÈ—F-»€¹û’` °%ãKf„<åÚIÔ Ÿ®GG¤xÉ{S¾eøúAþæwA”´¶¶Ä¾¿Àð:°»B ßqd¢J¯E‚½0ЈCþ4xaB… -üwá` +\¨ð?pÜèä?Fùaä¿  @ø€È¢|!j ÷ÞÍ!ì9‰R0׿|]èûçBDÁ¤+þ©ZÁ”©‹¹hÒ£9ôŸˆ§U\±@ÿ!Ø>.øºâZD òPèªàƒp ºªw0ȼå´K7AÁ»¦úW+!bƒwë%ñC`HÉ+4¼èP#ʼn9^øÑ`… Ù²5Øq2BÓ…(Ùp?šuÖnqg'CøŒ’+W¾àõI=ªÏhÕ›9ÿýü÷« Óf§¯x¥lôÓ ‚+aÞ‹–A‚¸2`þ ¸~ëÕ³Ë÷Ÿ^½/úþ£k—àBÓAôïødRР†º¬ ‹&Ê ‰‡(²¢F›@‚Õ.ºh¥Õ JIC…F©´’8BdDìIHƒRtè¶Z¼­ÅåZ ç¶B°ŠFƒZ !ÿ {ŒA„®Ê:ˬW¨óÁÈ‚Î2ò¬*!‚P¨¾¸¦ü缂 Pï(ÈP¯½33Æ Ú¯ T|ð Z“sNdÞ\†À/CðŸ‰ÚL"C4º@£>£ˆÂÑ:2m¥…RBM¥’HÚ¦Õ&€@¥HDähKÑÓ‚4haÔ‚š0¨‰Z<èž‚ZMÈ*šœ«£²ÒJÉ\ ºÎ«îteŠSL1Õ’<¦46®â’kK¸äúòKƒ®D¨15×D(6S¬ _ó¶Û<'3ð C*3WA‰0’ÀˆØý§ÝŠ*øl4CUMBCm4Óƒ>\mÑ M;‰- КéÿS„èIqUSjâžî™ØEUo£ 8ä‚ÊÇ9ƒŠ+KWƒÌbêŸ$I‹’ÃËõ®¬Ò háC…†ìŸVþ‰l?ÃØü‡ÍŸ¯eóMq ªŒOÐmÐÍà5ÈÝyAËì´£B­#”òe¤£I²”#®IäçƒÙN uÅN=µÕ‰9Ðñí‰[GÕ©r)ª8 õÆ[¸Z Òª…˜ë« ïUÓ ÖXd:ÀX½âóŸ½dÓ  LsûçwŽì?lkIåôÄŒVˆ\«/T¡åÕ ‰$˜Z‚Žð]‰3¶<Ëð  šÀž Œ·ySRé¥d²ÇFè]Ì1ÿT„Þ.ˆƒW Ú1ࠃH–ʨ©ŽK*$êB¤ (Á õ®ä2¯ €œËh¹ÄÀK¹ ý ùI€æ‚Ð h‘™ ·V÷4>5„\° ežöCj3…ÒH…ú„ ÒxRú²¤•/“”æxan Ø#;Á¨NТ{@ì×3ˆÜt´óå$³Ž®D`œ¡)"YBV€ˆ!„@ Â(¹É<꣜¤³ÙM ¢ÐK‚/+˜UÊ]€ã¤©!A_ §)£ä³rÓ’KU ¢¬ÿÙg«®  -©V‡àÌZ ‹ ÎbV¡¡5$ŒèÏõÆÚa”"µËà]o'׊<$4 úÌË ¡4SX3úìá©yœ ¦ /Nnòš8Ǽ³ÑG. £`Ö —a)pTÔ ÖJÿPV| €¦<(¨™fÿ»˜Z° &ÌAÌ ÜI¾1ZÑÊKAÍuWÖ +!½~&š1vc<=:ï g›GNËX„8¡0Þ dgó P.²”YAHg‘Z£2E+Z©¯¦DàÂñ*k/úõoÃ4¥ f‹[|OHò“9Á$gœ+ëBzI {äËkuk„É av™‹] Š¡ $×WHj·û@Fô(b…€XxÈ[A‘;•ÐãÏ7½)%{JÙU6(ëÕqVôac… ÑÇGÝìQK‰Xƒ¼Éú¥æü·ž,ýS!`4Èžüä_Ë Æ™ÐRÑ`´¶‚e–µD%€a>h™œ®FõÑÿŒ€ºêhgD,öÝ  ÒS g´º… a+ˆ£‹ú7£EžAÖTC+OÄê£Púe₰ߘ]iJS’\Ÿ —*äÝù!µ‚MMÇ(xg¿õ²ÂüˈÎ:ÂH8³­%ŠQ§ƒíâ Ôúš„Ø¯$ñïôJ!£Ù;¡Ç‰lª…%d76jÑ%C hâ Ç7&ޤÙiö¡¼ òü@>ƒ&sƒ‰rò±ßy3åþœ õx7¼3ï1McåÜ©?ç6‚P—zÔ)0„¨ÿãê`FH˜‹ pYŸ9ÂìªÁ1¯Û…ûOlÍG’ÙÇDí•â‘@Z^ 4ÿRE9± Npâ„›ÌÊ ?ÉEù\ ÛXÒ)2BkixžÓ ³yÁ Jà¥Ëm:!éùbò#jZréf"u•žÛ„xŽŒ =H˜ãMu‡d=ÂC0„ìi?k‚—¹ìg>3F/ ðƒhºÏ 7ˆ9ˆö‘¶#SûÝQóqÆ.¬¦7-Èß#¿O •8E‘ŠqÒIÃóÚ–>g ÕCäúµêåÂÊn•茕ѫIèÕzwAñ @¡e ¾ŒÄž jÔà ëdoê¼N!ìöN¢PPlM¥}€¯ƒ ¦^<Ã>CºrÇPŒíåpb¾ëîön9>®ú"ïÿvü ‚¨`ŽñVî ÊçÈÏ^hBqêŽÀªÂŽ‹`ë„îŸòïÊFoôFmÀ6ÇÔÆJõ,"ë°Ìp ømö¢Îê LöPêº0꼎 g íÎŽ™ÂM4BŠBr'wn ÛGù‚)PTþ,EìVB È©9B*ÞKjP)äi!Êf'ÎÂ#ýh†ýÈÃ-°Ä-èb î él)èªŒÔæ­þ õBBß ¢­ ¨!¾¬ ±nö N »0%ªËPkÍ/ð÷x C*.Ü4"„ìcŽ#nD¼–Í ¤‡Gfã'f+®í9ô4ËûÊÇÒ4"‘ʉ'ÿlćÆ-fâKŠ… à#‘¶@â.:‘‹lI0’nÀ¨Þ†&ß\më°ß/(®cQö$à€iƒÐŽP&¢`ή3~oB>,¤‚-Üô¡$jjE¤/òvÐ’1 j…cñ’â }œ±|$ÀoøŽ>`Åøé|°f"ªÀñ>¾ñý†Nþ¢Âô‚€Äªb‰) êì‰ ­ ÁÖð í±ð}rWqÞE‚®}úd‚ÍD®. ÍŽ/šàå¥zj B[° ”±,-)$ïÆœQÚ@R\#jjűäáø‡þj¦]!ýR ÿìý"ôŽn&¢AïÔ¢ÕÐ öþ òƒ •R¢¨n ë‘]ŒÒ'™ ¡3Ž]ΰánÇŽìÈášk* åP,BzqùÂ5¦¯ þŒ #8f(‚ã’ü&ñ>IÒ†Üq6Êè¡81¼0àîòKRRKÄKÌ#»*ÑQþpkSÕ’Îènæè B—àÑ!°™2©A"ê°öÄPêÞ3)}²Zá|:ó3…éÝŠЮ?Y3¤®²i0,ƒâñ"â’VŒ6ïL!Ò”Ω#"‘ίR\#Aã² òi/óºD. Œ.&Ôh’ ©Å&˱èj²Êÿ4§ÿv©ËV‚ SFMÑ)#°)‘ (mêæóæ3æ³¥) ~à, `œ‡^ª3õ¡uBJJ¥4ØÒÎOúsO’‰5CÈ?Q‡4Ùø®G*2×+LîÑÚÒ‡°KXJ° Xà±NÒŠüË%Í=$±ÞžÌþÊñ–hÒþRÍ;s†tê·êtÃ0ˆ²ê ®Ós Æðëñ‚"Ó)àðÁŽÔ:5~´I©®,`„a’-šÈyZ$ÿqJ§t4Yó ¥"<!Ú¬J äžæåzõFïÓOôvØŒ™ž«?/ø"ŽíÅá⟔ܒ‘pB9Æ5ÏR2$€*Îo'ÞT.ÿá^@äÁ9ÿ¬µã"ŸS="‘«Üc2ŒŒãf:QôPÿrk€ Bg C?µ@^^‚­)WÑR¯¶öˆRˆ´Tl‘AðAS-@I[!T-š!a–´ZN#¡t(¤B4Œ4euVßpƒ!ÿ”¯!¼Í…f£6,©X¥-$bH¨BÀ4Æ+Cág/ `Zÿáj†/§ä¼ä¶:aéóäL‚îÔÆhèS;] uPÇfF­ëˆR)3söjïàÚEJ)À„šmAI?uZ¡žVÀr„méIy™ê>¡4š.ŒVYS],P虪Ò4³Ò?+C2®ÑPj%nóOrAe…5B 8át6Y@úR²r­:«~П¸$=` ! ,O诀DÍ:¯…ËR× 0 á%§¶RkáB3@/(¤ ¡„l›ÁvW~ ê³I›È:Ö, ôFÇDiÀmJRAÿ8#B"n5£©c7¢ÍØ ¡Ëáœ4ÌÀtú¬â4ªQ("|kÀ²Õ÷fÖ.åá¨Õ n¶ràÊ-ý”³eÄ1ݶ•ç¼Êsk©.g6á ÁóiIqöxrke—Öì$@) „wuWw…Iëó)èé)^Aà˜ê«©žb)‚è°¤”Bd8zO3#2ÂiHÓŽÐî"^ø÷N‘#гÆë ) Ì·d‡“&ÊF¨3CÿAE‰ov‰ BŠ%¥åÓ ÓÞ"Œî"ÊÌ„LîcDÇÑD Š‹ÁóÁ ¢­ì5‰ÒFkíì2S>}rFµS…¡žáš¡"€ÿ–ô>Ÿbp(¶¾ôdÏœ7CúÊx&Öi¤R*£·#äŒj\x†Î»RSA!2ÅÖô” ,wp6hZ ŸK dVäT/ "~;´CÓOYö²K`¿èGZhiÉ~£¬çŒÀny2Vt· [Ú„Œ‡Ë—…Ùéèàž22yI”>UÖö>m7xϬù)<9ŠlÏpe~L¸¯¥ã4´Ôj ΆÇá’‘¡RB $@&@¨è9‡qŸ±ïÒ—‘Ú«]D-—2 ZÉ•÷‹¡34•°¤~$g·D£Q–|'Z‹%¡xYi|¹\ÿÎÖnàˆYH[öw#à„wT×¶ „ë©©RÆš} „ IªÝ+Èñ“%QTÓ³'ö#ŠÚ…äár5S*$…ô!?úfF‡‡e“9r".¡ÍE^`nzÜŽà&· ¬u¬­Uqîý\™¦KèõêÃ=ì—–:k ¸¬%—ÞñV‚ˬ=ëqTq·mW±)à„am‘÷°œ‘ƒŸbdÁ*γõ&Èš(wzu%žÄÒù! ùV{5âfU>0C¤)ܾë6mde{då2Açrˆ»Z”‹XÉf6ýÆ:r ¬µC÷2sÀ9s¶r [YîG¿¸0ÿÂ-6ÏÁ2w+<Ÿ¯ç(öÞ³ÙØK•méx“9™Õ„ žOy'ÛD AƒÃÓ ³Ó©„CJÄFŒJO6!@ê!&ÎÊ rÄ‚¥PCÂ+Iú^6! |·xf1 mŽ`Z'—¬À¬ÏºÓ•Ì­+§>î®6~hiÀèzÅ¡€BñÓ¬ µ¤³6 ›™ÁVa“Tx%;‚-à«ñ¸ù)T,r" ãL‹È›oÚ…î{ÀAÐVQc)»~G„†›Éx0¥l×›N@ú­†Ø·Š8§Ì|bÌœZ͸«5¸ÿ!Œ 0@Y.çK\+å"© ºgI®ÿáb–•{ÅOÔ&s.%|N¢áͼ û Þ!rÀ*·K :í"Zäs%çµ  =*zõ÷äMÔÞ@ßÿJÑ€IZ˜‰4TSæ»s„6-¬c"€çéáˆÒý°V V@èE è¡"‹ž›YéOêâPý4¢Púêé/…ê[B%æáêq‡PY§ô²áìBr "‚ÍÚâzã1gòZ• "[¯dîâÙï>—lé$ƒÌ|ÒH?ՎѶpW„ €³¾RÆ,@Œ<²bˆŸ"òg ô!Š‚Óƒè›C¬WÛ¿¾}玾øO$ãê¯~!ÂK.1}[â…< ÷0ü;hðƒÿ 2|¨ð<Èñ#Å^0LøðˆƒøWòŸÇƒ‚œ<è ¢Ì™4ÿkÚ|˜à_½œ5sò¤i(¨!$~ü°ð#B„V¬òJ˜0 ­† H„SU |¬Ñ‚ž=}ùDŒ0«µHZ}!œäÓ§Ï…ˆ¹sêû0áÃ{zßVЛWÂÁÿ.È”`#Åÿ?œ÷oñ?‹çÝ:A V%@xq¤ hƒGþ•&HÀƒþ ȱð¢Å­ÿa(}ä"®|˜0È’ƒùÏ€+ä7›;¯éj'MŸÎ Qb½Õ|ø,XPº`Å ÿ(X˜JnÖ¦N}øX¯EØùøÑÕšv…ˆ(!òåŠK×/ªhõ„À_!À%Á]L`˜`\ðÿDzÍ4Á<‹1Ò˜d ]vP ÎC…]ÀC­Pà™AòwOh¨9Ä]„‘EÕ6Ò õvPJ9àÀ ôpFºôÏr1=wP=PB‰DÒý3„M?É„–æ!#•PAxˆ€XdŠ0\ú âT{>ˆ@OXö¼ÅÏ›"èC—Zù8…›{Šð‹~{ê5X!| ž>~â?LPX…ÿàui^”>Äá<&FöŠ(j‰&Nº™ŠC´bØ=¶ÅÈC§F@Be@ÛŽÝ\I½@R°»ô[‘ s1Ó“S6·“³IéAYõÃ(Í4#Œ´çÿ ˆ°%¸ÿŧSZ©âÞWòÌ—Ï[úäɧE¡OQ¼åŸrý2"!@p=b9ѨÀ)N8b˜njé†Ê “‘¨áA$@F™Æé? dy®`0n‰&Ïh®Zt‘BqTh»•väHERID®Äl“Ê2$œF2TOtÏ:—@•H뤓•PÛ„!CXL3Àˆ nS7¨û=ŒêCŸžZÅé•>ò4!V>È  ZjEáD.üÒe¨ÀóœÐ‚ö¸uî¹!„€a¨œ*ÆX©•ðO [l™‰§¦ˆâR&`ÕAøèâ «Éóâ?¡Ïx²Aµý“AqÔãÿ¿¢T,B¶ý3\J8'ytLCCtr1IÛÉ7Q+ü?Í<ÓŒ]ÇžüÌV¼êÕeïªèGÏ»!¼-¯ YÍåg[.¬ÿË¿¼B-œp‚ô¸Å§£„C`"‡m:ÿý2¢* §gýãŸbÈ“x’‘LH*)Ù‹Xp{Ät¢QHhÚÛpî&>›Ï(ø3fyä$'a“ˆÖ;“L x5ADžä´‡ !yP³á?*‘kaíÀ°Àu²rƒ³é{»S¼ÎWu…@Kø‡=ȹÈM.ø“ÝêU—oM± |Ó€ò±¯·ìCŒ˜ÿÿÜèF6f€þS ã:f±AT’zˆ³²”¥•üÈ xÿr„–…FFµb®2Ò‘€äÀ¢ Jf¤Vð É!LZReù‡5)Ó®„JÀ«\%+±`ChSVà'|tvŠV¢¸¯ü£ïú[>ú%¹Øk.ŠBÖ­(eŠKXBß4à„þ,jsd d6„8:Šj€ÛØÅÌY±=dSC™NÜÉ<²4ŒûŒ"AG#X$6á&/ÉÞøæHRI(I´ä0ä/LÖ´f€zDtiAÞO,w“ \@£5 + a!ŒÂ[ º "Îÿ²‚"¬€lTÌ^̦ÄWècMhÁ?ÜrÌh }úT\ )‚V¼b©¢1¦‚Ámsœ‹cˆ‰æá)f,Dópœ97Æ@Ç9æ C¸€a`’¢ß8ÿà < ¾hƒ¥™Mê>"» !4H—¬ Xm'Ö£=DIM’Bur‰J°4|Ž´Š'µŒ2dBE %ºcD 4è–†Z?†¹6züã¥ÑTbx¢Ð‚%´-§ý¢Ë€š/ÄCq2Ä<¨X;L©n„j㪊1­Ê"¸u\ 6f±þuì †ža6·,™ì-"À >0 Šn€Œ;ÈDNWº !É4Û(³˜5,ÿÚ4%ŽGZ’ Éð%¨ ØQÎÄ¢H3%D ÄXâÑ@†XÀ·Z1.F!â|pbfäa¿;©'+ášiMÛ°/7ýk§.`ˆœðÒ³©mmkã[X°78ÛÊÄ·¸¥*‰7ƸÞ>®Ÿ‚žôUš«6AðÌA€EUUG˜‡gpö€ÖÁ6@RI@}†³•Í ½]q^N"‡… ¬`#:QøÊ÷9«FgòU ~B“BÄx 1`½˜ÁøAD>N0Ì(8ú‰[B;Z)ÓPQ0XØö&¶´l M°æüä38QU7ºa£SœbšTµ1¦òParW0ÿK7$®^p xW‡! ë¸ GˆÙ­b"a»–ìt­MO’-%-ô]E“S+ ;°,ÙòMr"%TŽ& ÀNf²|@^÷™ [èÁ7zhOPáʇlzSÿÀåú~òQ'Íbx_ö æ=š°6Cc¯!Vg ý J—º3!àA4I 1ñˆ@mCãß@(œ&5N½Ç׆#À ’qüzP»úõP–ÉíFÒqñF”Ã+6–‡ X)–&$Û‰—M N 7@Ħ½—iS›.Yч=êA±6—d“#œÅ¹Êu’1Äòí%pøÿR_ß^@U7ß2Ùw N°õPù/œ±ïÌ2`¨7`uBld›°2ÆÁˆ0À¤w1ÑÙJ€u†2ÔÈÝi`^â‡ä2‰É`Sî^`ŸœØL‹šËo˜´¤ˆ2™Ðj¾)±ÙcQpcó-ÿ–ÊM³sê„M{ì«_+ÔJåÓ„ÜëžÐT7l= LJpÖØAÈ¡M=¤K6ÁÀ^ iÖüæ4µ€s .“ < íÜÍÈóäÍ~í!‡«NF“Ž ¾%ìýëÉI Q˜ß$K—O,Cx I} Íÿ ê¸s÷‘Rùðz„³s¹”qfLþQÿZêB'Mðn˜{ÕoðFuïgó00ÅwA#ö[§N±[ ‘%&¢I¨ƒðUwp2a#`@8_¥}©“HeuðwÈ¢^3a†P5Æ‘.áḆW¶;óy¿†eÆ#…Q‚y÷E! 1)}4`šEL¢5zhTz¿$"Y·mˆP(Ög~¦=µ7 ú>º§Aøn´T'uïôŒS,ð"<Æ,P]_‚p)"A~åd³ó|eU2xW%d¬!C–ÌvÚ‡® 9À Ð ËÁ-äW<86q~äUq¸SƒxAã$í%X2ÿ…&A-Ê‘,Â&%f×$:QXœ‡…”‚§F?¨Yá¦=ã0N!|f7Üã!ðmõsaÈEô{T‡ÜH‡ð–‡PÅþˆùÆøoä[Œà) ÁF-¸)àw ‘ÛÇj¬ñ NBu÷Àw`ߗѧKb$‚WBzE$ñTA?Hx,!xÅ:alu‹Oó„É9a_Ñ‘"¹øC}Äy”BŒ„mÄTSp8•a=§l‘(H×Yjømvrëcm-P‡ßØo' P¡ƒA¥:±hŽs|üˆ8ƒH‘2‘^­‘¾23vgÀ%€+µqÿw<0/ @9Áôw啊§W6!#4z5•íwJCìåCµ„ÅfCÒ<12}‰i2qA¡Y7iMÖ”Œ8ùósñaÑòò †w6?ãoh$‡÷À°õ"-àh{ƒHç(€¸oga#1†Ñ X"V2Aq<ð€vj‡q¸‚+*È,PƒpwC`p€”$µf$HÒœ³FA°Ö+C¸W4V)’RæI¹(%Ì¡—4!_*WVÔ¢Q?dÂx)üG?-PSôc0bq.nm"“Y§ÿMúAÃômœù'ùð7ô@hÈÿ=y-:y:“f”­ivÚT·EÒ U¡wøx:»ŸÎÈù<À·#dx§9Cp<<0k¼³3 µk3Ó’œAhq4Ì’½sq€õ,É‘Õ,~é,†ÑžQ!h6@òÁ7ï"[£uø ϸ u& ( Rš`N’wøÛ ˆRw“†3€ˆŽ°)]_Ç8`‡[™á@ýÔ‰7;ÚçHs„¨C/žŒ2Zkw•%k<êˆ ÔΧ]Éqr/$J2ñ–ç©2lŃ<õ€Øj€’ó`?¡euÓ6Ìåÿ&\úô(¹ òŸ{ÒgócMdDöCFºç“è ú"m:]¶4šbº*M"V!ºWG% a•´Að$)ƒ!%¡h9<`4Ó·PYPuUW­¢'SBé¥,êU£¥(y¡D…Ðb<9-Jó$¨Š…±ɨ|S?½Ä ¢FaÓA€ØØ“°'`uÆÀ7h¬˜{jš‡R±n:]8úVE2q„Ȉq¹îZIºñ:q³‚Z2¨cpÄœ@J^|ÊI$è׸F;¹Ó~ ¹®ãy¤Ô’lMXQ/±e‘)’µQ%€ü@ÿ0ý—’ [?bq'ô!ÿq ¸:[at‘€ô#¶‡Fh&ŸÆ*ŸÄ¤¦jÚê”Hå:­ ¸®Éu¯É8% j…Á×Y¼"$s[yù·¯Hú4>$^¥|‹1`Œ`Sm:? ‹gšeNt¯U~öìM×¶7ô«Æph ‹¦6eMò€±Õ;?Pµu, o€{pª½ ÃH¸«D)â|<ú"apNÖ® •8óH÷×$<©¶)Y)ax¯´œä3ðú¬³Žº¹8sHhÿŠF3´Õ9½ãIQ²‘O3µ÷Wåú†À\ƒAÅH”pÛ»à8¶À{)¨g0‰’Œ¨÷iD€ ±¼bKFF¡%¥RÊ»mJ”Œˆ¢sŽ‚‹H ÊKp@ ¾,@œ!•Á9$¨×§w)º+!úôg9GcÀG–ìŠ;oùðt•I–d, d4Ì4/ñ–7ÁS6ªæi‹!†µ÷Ï·ñYMkS¥Éøz$¬Y„sƒ“u€ÌØ&”¾ÂcSõy@- *YG”\gåø#°b®ÚË”Òv)Á£¿²­EÛCBdñËŸRƒAB<Éapç—ÿ3jy­LF£è(„Hè°h4ÈÒ ™Æó¥¯~ôx\ˆÑX £|—òUôSS Žò ¶˜(Œ YY—u6¨',9¶fTŸÙ”n³U‰"*§oú–o}›H¡ÑH™A‹#G`¸C j41‰@ˆv<`§a€Ê•IRðúi€T¿R¿¶PÇq(Q~îZ´—k´sƒ'^)æ5µÖ—Cµûºr‡QÈÜG˜q)®ÚÌKE oFWÂõ„|¼Gj6ôi0,YŸJ¦õ™u{X¼ÂwˆÍºÃˆ„ŽN–H-{£Ld‹p!ÔA¢¾Éì¾ ôÿkfIPœÌ´³3›”~íjx#— µ$ZìoéÖé—í×GŠ}È<†¡|¢€«ËkSrû.Ö”m‰bØ È¸Úª¸:Øægj+ÔXŸ‚̇#ûÌ\ך€Èc—\®rÉùÖ0ê­s¥›¬vAÀ›ùXÕ\‰"¨ÏGDJ,a×ÐåwkzÕqò:;‡;âuIGóЭÆCëÆ¡l‰4!»ˆj?´Ì|-ö°7L„±ó3ØÄ$†­Ø¨—Ø›Œ«ÓÜ-Ô³õzQp ‚LÔØ£·•Üh<§‚èÙYÕŒóÔ=Ê:EÛŽÔˆ„Iª³©;¨¶1ª2Úÿi¾ ;ÑIÖ l;G3,>c±˜ÖÚ´cÍ©.‘lžOÎòxWK\Î=ÂܬfÏŒ=±˜×Í7!Þ‰ÂÍ7mSÜ’ac‘m0£w ¨TÄ U-P¨ÙhçxؽC¾H +ú#£§2AH´q•ñÝjª½¢NüHß:Û<˜$±Ì8âç–¿¡~±dPráõÛiŽGÛÀu…,;ÓP¥èÀ  Qð%‘yy=)àÉrT ÐÕÁÃ4LÆ7äØÌJ¥Èý׆íèÅ‹«’mÞJÅŽÑ•”Ó%]‚‹”¬™Õ`Àž^$?h­31©/À›”W³c"§S¹®Ðÿ 9ŠÅx`$Ñ–`,rLûÕ°èƒÓIB Éq—úkÔr4aÝ¥ Á\2")Ø·XòÌ +è3 ¶ÙlØ„óz~öaP¥ÅK”ŒÞí’-ȃSé…ûÒUä’làûÙŸ}7kÏr!ÄÐÜ:3V-º˜”+AñtÑY^ rd‰$¥«d¾3„¯˜ßE;/‘ÛIKA6Úœ¿¶®¯Hç,Q×É‚‘Dê܈A)–â¤zQé{sh‚΋6}|ãÝþaî®*îä]ÂF-|;½[·uEþ"N¦½„H ®O0ïG`œ²ìOÖšñ›v œÕ áO{Ú‰·™¸HBÿG[^ER$+ñõ¯háf^W±V$‚7—ÃAìIË;Û™ñCó$îuñoìG÷W‹!’ym&ÏGŸ‚(¸JŸpٖͨ—(·zî‰òíÕmÃŽ®¶ØÍ„ÇšUUÅ—½ôÍîG):¸+ó†ëvSÍ¥¯õ)'غòO™ƒA wè'ªûw°£~ çõ@¸Ší¾ÌO—É1•6 a4+—Ü¥heµxjÏ펡f•^ƒ_Î4ýòØí3ݦ؆==~Ã:Mù‘ŽÎ±ÉagŽFäHyÉ®µb¸A I'ˆß»bà¦WCÆ7ˆIA“¸ñÂÀ? 088ÿäßÂ…pxàÅ?ˆ -0‰!A;~ ù_Ž} äx`Ð+ õ8RÓqjW$¾€ûáKØK.Ìxš¢l†AH8²¡ÈÞW¶$n1dH‹Ž tuÜ¢Ìé©÷\x¡¡Ú‰ZLúÚ…Q¿ZmÛ•kWÿ¯Sÿ•…íÒ°-.}ÿ~lb–v²ÀK¯…#ìŸÀ[h° H8¢ ‚ rÐ /Zl"ÌþÉ`3†røŒ!#2xaˆ! ÀàH˜è€ †ˆn7‡&:-6„:B袃("N¡‘‚"!|I¶’r¤HºþN2é¶#ÿ©ç&›NÊi!žþ‘`!î~ê¢,‘ ¾¨ª’j-«B`„­¾ê²…Èúç7Ÿ¢o)9ŸúÇ>7å)Á͹.ª+1í«/Àþ!àŸ#Ž(4-a‚0ÀL3 ÌP31(°Ä#÷1¢³Œà¡ âËþáaTuÜ ¸‹*©¤ËþA(Ça{N¸ÿh„(¹“–{ÈÈ™~cIØ…nÊiJê,º Jí–œ Ú™¬¯Ä¼j½óÖ¼ï„:½­ó=°à|¯ì“ÇÜä921¼þü^†,‡Ž ‚Ž ÂÌ1È ’´¹Žþ˜%>ýgŸ(âT\yÁ1Ò¦¼È‚iíϱZRWå|kI¡^mÃxÈ踗eh¥x믞&¡lÙ" .Àg-£ý'Z.ᄪZ«æ!“®Ú›Ê¾ä9¡¦ë,Ai9[ˆúܺN`ëvŒ÷¿¾XàÏ@“28 ]l -Ò ·ˆ3pàˆ¶=ôŒ!Ì.pn³_RÈ%jã‡f³{Hÿ‹f|Õ€Žž# ã^)¶7“Z”R¹‘Œ[òIž”MÙf†´*tŸ}N NóÒB­ö°òjž¶ì,‹é5g*ê:­–ç½ö4i¯®ÙíÓ?†îÁ`° h4â´)œõ_ÊðB†öÉ¡ƒѲ y¼‘‡ x€5óÀ z ò‰^°-ü“@b<ðäÊçØW†–òcŽ~¥Í/ºy‚›Ýè Àˆhåõa‹TRz”)=¯ëÊXÆbªÙ'j'8×ô .I,NB6BœˆÀFGŠœ’b%>&ñ e{Uær%,•lG;g¬RGw @ 8H<€w~ŠðÅ®…üÅ"ôZT¢008d1zd؆C M¦@tÛ̇àö†]Æ5Ñá@‚ ‡ô ‰b$GbIÝ̲%‰¹H¿žôÒ" KÎJäwK&aÇ"†°R•ú§FŸÆJ9—›Úä 4°-ÿhœ€6A¬aÍj‚$ä Y00CòÎPK« _ĵA5/(Ôg0ÀƒS±Ínýádôi‘vz;$%Š™ÿøÍ1&2À+My#õçd»\ãZ9ŠJ”‹-«ÇNŒéP íH$¬’ÒFûƒUU‰J7û@ßI€mbZSþ1G:6ЦtSÓºÎ.§º“‹!ãuȽÈë/Žl¤øP\ì’¡Éd¢j¨fHŸÕ#ß’ÚÖ0Nþ£T/ñâ+‚ÄWÊÊ$T\åûz³–Áè¢ÄÌè²zɲarŒ¢ƒÎ‘X†CèC,3yðH ú€@7sê&§T¥KgYSÓyAÞòò že „½0²p1'#‡‡—Á”–…Æ#­¢v8¼é°†™Œbªê˜ªÂöè“Þk?UP>ÿˆY ÄL©˜"ök¬7¯ÇVÀÅr9°renkéøò!¾B¢f‚$c g+ Àö/(Xi%°D(%]KÐ)YÂ$0…ðƒ‚´ì=`Y (³ýÅ@bJ0à…Ì%xŒŒ0Æ”jT¡q u8ÝàÀx¬C& q¦ø\!5äBeÍí’~,\¬ÔPÖFD#@CÖòÀÅ¡^©Q@äT . É<;Ø÷xvîqýê“/Ï.gyºrDeO 1ÿçÒòÒŸH* ž iP“òÊx¯žü„íBøðÐìÄ&H|@FüŽdÈ¿uwq™n’ÅÔ8öÞnÉh¹Öç2ç­·21G=EOÓò"^GR°N²†G\Ö‡¦€k vjxAGð! {ß@È÷Ž¿ïø9O)ûA°½ä9ÈÌåÂ'_DµŒÁÌ\T¥Ýp»?Ñ£ªkk¨· ¸Â O÷-@3* ‚†`@iñŠ‘\šýHd¯H]%¾Œpº?Ö9Îþ¨Û#MGºHYgUp€E0\ QÖ5.nýôXä­ØÇ 1¿—YøÀ³…!tŸðç'Àøÿϵr`]áoò’ÒI²ÄÁ^µ ÃÉàÓªæà3y`¨ ‡ø D£•I: 2ˆì‰·þ8©´Ì)‰ Œ )‚“±Ã ¸+¦Í1–•è‘óQ»É·´C5´«µtYK: 膈ú#À…ÀÀ€ø>ó€y €Q8Â#ü;ÀšzC’Ý9‚ €¿XŠ92‰B9˜ ‰‹(RrKz€ CÌXºæX›¹y€’ 'øa7 y™@`‘xÛ°º  œMƒ¥ºš4i%± ÄNÛ–Á¨µ‹¥Z‰„Bˆß@»ŽB¯ƒHAHÿ§óŒø­Oê 0‚(?ñë¾gC¼B¿J¿ˆ,Ù‰šÏ ¡#¸­=Q³‹P§I×r² cyЀ!± @Ü` Y%YRºæÌ"$h±©ƒ7=´²z«‹T«Œ)«˜1€îÒ´ò9 ‘9¾"Aµ²(=WÀ€Jt€°Pj…ßâŒX‚Zc¾;¼Áó;¾# à»òCB¸ šÏBHªA#€ÁðB»žDš6ׂŒºX3ò©‰VXù³ ¨$yc‰ØÊ §[Ãrk*Œh"ÅÅ•º$X7ϨF˜¨·ÛÀ >\‘xøÁIlŒ"¡;»š±«Û J¯z.–æèˆÒ»€8ø­M씩ü¡ë)Òê¯gó;Ê3•“9DÁ€¥ø¬ -o!€:°µ¤ ! › ‚ ø€ÈEu3à ~i¦3\ !ˆzÊ!…àÌ:tÇÔƒ/ G×€]ÂɳЍÅñùñCàp …»â Lc-jDØ‘´£±„!ù ÿ,éÿÿ H° Áƒ*\Èp`>~õýƒ(®WàƒV˜A nü3dÑÀyŒæÉû·ržÀÿ`þû0ðÄ‚Þü·à†¡.øÐ$nÜ  P¢‘†µ°A$?šöjý7b«×¯`Ê ñ¡Ù‰ÿV¼±áŸÈ‘+.ôÈÑà‚‘gN éÒ%BFôJœÈèƒÈŸ7MŽÌGøCáð¤ÙQ‚† 14„)¢ âûñC$>|ž~(PÁ^×°ò+@±aWcsëÞÍál„ˆDReJI¤¾§… l”þEhEáƒcšé¹\YÑà7ŸþÿK‰2ëøÿèý›€Hò?¦k/»ýÑê_«úõÿ]@2sý DQ`tn!òAkð‚ &„ÈâýãAW½Uhá… ÑfDÄ"9  . ôd25/  .ÁØM‰é5O 2úåvðÝÕa[–Õ÷€ÿàÓ  d­ˆÔŠ{,`Hm1X‚Œ!…0n†)f˜Y ôP‡©•V[(Ý{ªýãWAó°ðÝ .qÏ?{þÃxö˜4Ï ,ôùŒöÔùO–OásI$Õç^A£ÚM;eÈTýCÔ dE°ñcArU?r9æ«°’ÿ%cú@¸À 7Dxà P"|M÷"† Úœ±p¨@ßô"³‡Ê£§žüCÀ³‚² Ïœ7ÿnÒ¬æ*Ñß@0 6µýãv±{bì h­•pGÛbýÖc½ðd L!ŠeÞSVè :¢±Ï@„á(‚5('ù¨ÀqÔ4DL®…/ÌãBd¸(ˆñ#iyÐ@î¾°)-nzÏ ,@‰® ,4%hL•?ƒäî‰þ«@H#pçC¢b& ’Ù¤`¤#ÝÊ`V¬3’K\á”@€ 鹿£Š#DPXí)Í`²éW<ô!LìéÑ…ey\ªTU:µøÊMÑ9ÑH ³µ°ˆ&ÈIŒ\'§ði€ÙS&ÿ7΂pçV$Ì2C”ç-oˆL°˜ØŒbD?vóÔ@B¬©™ D¶‹PÌ dr’+@<ÄY€Õæ X‹V¤ªlÃÔKYNÚ ‹¸Ýdÿê«ÄÖÉc†š/Jh"ÃXjƒ\ì)ßKP§\È@†ÄG`*4†U’\™º«ÙS6â•jy-”¥œŒ€+`ÀЃ¡jbðB”•§úåm)"n•uØò¯Z,à'[G±"Ƕ&™H2.hÜÀ #1Ðd³MåÊ2ò‰ 3N,k²É Eªja‚y"ã•ZˆäÝÃ*ÿU¹ê Ø‘\€Öa¤û‡0ÜD„ †ºÑžÜö 쉿k}íHg,²“ÈéHa0õE ]É™[€%¿"£ÈøÁOø¸ë.ÍÚ%/A¤¶ÐU«ÚͯzÊ>'ë ø@yÿæÀ¸ºD„€E/õmLt÷׿Ö/êYIkulØäè,A¢â­›T;/ó)M&e%½ç]<¹éŒ÷Z—|)ØoªªYkÄãšxa&Š<…-¾Šœ$¹ÈËB1#Ì䣰¤ZPk’Cà’ï@Qm·Mˆ)‹l²ý…€ 41„ÕÆv`¬l°Çu‹[ŒûmèÔ"2ÿáËìÆK N$ªá‡äˆ)fª SCýRP¼ÛMo IäT•Ö÷Jàã°¼Š±¢C üÐ$~äÑwS¨Ý£!PÏ“ÁPck“ÝdTš|f«´Ï(8R0kÓoQ$óƒZŒk—©@ËÒ/£9j‹/mÿáyW5çhyuÏ·ò9Ü´‘¹øsVÆH&­,ÏEÿ'À˜×%y0™ÐÓ¬>qçO›]îdw¨Á(†ÈÝI!"ÐÜ@2IuL¤²ã)„@nÙW²DL™ž²ÜMˆç­áxØ\Cï^uiÑ À` z çVÀ`Œ3_šÄZ!¦Ä” ½ß“¸ªf˜ÕY¼Aæ£F &*õÓI£Ü†22àt;ïI•»ò¬` ¦I¼Íô¿Yÿ‡,ʈþ)W,ðÅrb3úQª ¶ ÍÀå&A7à;uÃÌQ+“É»Pm&ÅÑÊY^s꡹š œ!7pˆ9vuÕòpg<¾çË™gE ·±çKlò Ï~aYâÐ3M3='7­;eŒ6d<¿ÜÙ‹Ê¢6q›Ë!ÄËð Ë€Ì? O ­7BTC‰P½—Mí‰ b›Ýwúh&ŽC%íx^€ß*Ãú3;@&¾+|º‘ÌÖ‘l£5Gû7[7òÜ=X®øÌ#Ü:% 0±@ó›è²@ú¥sq¥XŠ >1ôêÌÃr]Á& ¡RS«@ÿÛn.°Y¨GÆÛŠ‹R/fr§œ³OÁ";M±a…_0|­ß«à”ÒñRÞô×!DJc“Å×'ñ¾è+„»Lpõs#õ##פØú×0È1Ò¼ÝSPÜB˜5ÎW|kÖÝ õWRÁ׋ýhò",ªõi,­G 6ÕJ ‡‡•D¾8øRE$*ôECˆHN?Xdü=©ãMÿµ-Ìòöl'-KàÌÍ3 ÃX³$6;\ëªw#f\AŒ“îX|‘lUÞe±«à3˜µá³bh¨Ä2ž4(ƒU¶>z-ˆÎÁÆ4ºMðK M0×tÿcèÑδ‚Hy1êáÛIƬ‚8ËÆÍMe¬Ïc5g$F X·-ÀnÄ¢z#fúÂj eUéØaž-¸@K´<°æef¡!p®!¬¨É'U½/Ðsâ1³#-GV}";¢ãõm€ÊcèµÎ‘`™"àH+4YÒò«{}òKéF$Ï8"I³¬,eõ_°÷Í-ïJKå–³n74„5 ·ƒ‰ÙhÎÈÝÍê"n…+½­É踜˜ßGèåg‚:êq2/Ÿ‘J-¹×NihNL>òÌ,3}äíèwñ ¯@:64Ër¢>ØòfÓƒÊÍëÿ^?›{2UÖªLK©úØç”ˆ<29«îê™}|Gb:뾊¸ Û¡\0Ò™YgA|ŠÉ\C,J¿ˆŠNy­"å£ô}|ÈÛâî mf!jÑ ¯o¯4Ü®²’Žöæ!»?(I~áÛ0²-ì>u0²-ã.žr¾[ÔËÐeÄ"æWã ºï êÄ[Èœ–…L°ri&ÑIÅõ¸¸nE3H,£,þ%-ÔöI°`iüì’î"O! è@nkðö¹o\©²s2ûB3û.!låI‰¶È" £€ B<á¥â,@‹œÙ•u¹jxÿú.@É•cða¼´YmZBȾâ`¦“:ï§Üžižß'Ô’_Á1¹EéÞîƒöBÐËWPßÁƒˆV¬ø÷ªá¿+^ùxEéÕ‚EDèË70Ä¿í} òÃGz@¶˜×’Å ÿ^ʃ ³d…ˆ(ü3Dá> µJ.{lÃ’9ù!ÉÔƒˆ¤ÿâñ›Z•*Õü¢–Ô'õ_¾©Rµ‚ŒW lÙ­iÕ®e[Rk>­²–,P¡î]~rùå“ 7"¦,Ühõo'" Œ>‚„së½# 1Ü»GàÈ{òÔžhu^Iöþ}È%)T ÿ©Zà#Âņ°úøGéßÿUÿ6"ìÚõ-É)ÿ}VɹDç%Oœ(!Oó¿ L‘öü÷á׀áË ’_W·Þ«úf‹u«Ü]§š›O*ûx`ÛÎïþíÞ¸~ñ“ä÷_^»ìJ«€¼Æú‡@}˜©0Œ’š ¤Ï˜SëˆËþ! ©çÖú¬¤ÅFÉ=„Jb¤WT‘ˆ!‰X†hÛŠ’Ü@*} ù*$’BPl¸yJ°é%ZðÑǘ ¨`'$ÿ)¬$dšYæŸíRð;D–êN«ÿâ™/¬´ÀŠïÀ«´Ìë,³Ð£-÷¼»ñù¼óÏ-¼„Ξ ìáÇN¸@"À4WlA IǤæ±)) %«ÿ0ª%’K+Ñ>ˆt«4¡RkWÂS†(Á”"‹J¢Ä‡Q%’Q¦$Hs4ÅæQé!û'¹ iœn ©¤Rù™šyæî¶²2+-ÏÒ°\/>´ØûÇ…•-oͤ \s/6Á$ÐNô, ’²â¤7H ‘!À+$F†;Až#4“ç2 Kj‰´èùG ’Ò4¨$KW+É!ÿÑÔÜ(±­¢Ú "ÕŨ˜â¨¤“vü縚4KÎÇÏ>³ñÂv*©Ø–¹f”K²¸¤xÀ³6Ì«ÀϽ°ô‰ÖZeñ³ïFmÕ4§›ì1Ó-£ƒ†HhEA Hz5^bzÿN³EÓbi«ÅHJS‚ô¢bÈR†bP²­éÛFi#Cd.©Õ_‚©l½ÕÃ]ˆÀä„j¦¤Qnà5*,y†™æ/«ZU.ȱ½V¿4¹ÍʾU/w+ó€”K4=¡Ët¢ÑÏ"hªFxÿ¡‡jGÿq²´*Ì0­Lck~Q$ED¸-‹T_ ÔQ'Z0}ÀŽŠÐ´|œ5)F9쪳`””ÿy—µLH*fòu6ŸünÑ|ZÎé³ONÄ+—Ÿ[nïÒÓ?ü ¼‹Î 0šè;ñ¥Mßù‡, . *úøÀ<¨VÇdævÿ¨Ì½Jâ/zt(`åâÜ/(àÿ;ÌTl‰ÑDHU‘‰Ø#ãTTš•VAÀ_I©•„ ô* `¯$µà^Rz8ÄÉm>–#χLjÅÃÐZ¢ËB­£eëgp±‡{øT µÀ…\u‰]´X -ÚÅhc<Œö¯Ðݨ Y)HÖ¦°ìDj³rLLU’ %¥±Ó`À¶¢ D *5ÊÊMðLô ‰ø@žúm†·À%t®ÓР¨öCÜÀ€L0@òŒÂ!NLÊ’‹ø¼2-²DŽ-rIµÖâ¿;U $vòZ@g&’pñ_89cÇø9\ši, ÓJ¤@ 0ä$,Ifô%;Xme$!xWZ6"‚!ÿüb!KÊ bÔÍà5dùm,r<ŠÕ†"Û C #z|Æ_RK&0DDÅ…0†\ÜÀD#K^Ì­’,1)`‰b²¦…‡ª…•…Ñã?ÿ´óée/çÌY^T¢“<_¤¤Äñ°'£rËXCIH¢»qDn¨úÔ’·•ÄDfsˆ‰F5*Œ8…£‰9kƒ†¸ti pF³ÔEÀxÒ¯ $‹LïQE÷!ÿI£güeHÙºV¸’´-¢‘kT¢•*ÚCHY€V`£¨Ä12ÑLd «Ä34£fzT%D}ˆ€ÿ¨ êV*û»ßÑSª g [3Û8,)®¡ RºòNFÌ%õÄÉð 8Ôy²“D è?€({D”¬dM–YÎj-FÑ£I9Feù[ä&V4 i¢6z”$wTË<âé:{ä#Ô¼iû\¦…éc ì¦ÚøÓqæ†T­qM#‘G"µ05'] ο>ò@ê­ ­@]VqáI(E]8¹S,ñý]WF¢FÌðy<ÿY2³*!ÀÜ5~0·hL°âŒ×w™gôÀp„Å\¥ô6L@d,tÚ%åu- è*̨Œm&ãfRڨܠHaé€Ú«ÎB¿q+.òq𦠕@ÀUŒÀ$`lt¼ÚPÂB€4 | ôh¿dp©,fT³ÃaN® 4 2kà®>k˜óQ±4ˆ¢<ø• RY£MçÓ‰W7•…JŒÎTKÉæ69“m\´¤ŒERø€Æx±N'·ù*.áÏ–q+*(€ V]æó¤zÖ fµ¼­fZ»ºÞÊò— æAW}0`ˆPIÿ½Ü|Ç$™¢é@:’ÒTs-2mŒc‚m5IùæhÝëz$‘à\D-ôâLûÇ5 22.ÛCç>5†¡ ‚›ßœË]¦7Í k}¿Zè–µ½çl ôÛ_oú ~™ QJþI¢àÓèÏ9éó²O£DȬ ÅîÍá±’\‚—HûÚXUºúØV`ÕÝæ¼NÈ… ^ÁòklÀFöhì£âîUë|Ý9Çyãs~¦¢>ÁùúЮ¬`Ã" "òͼ@Ø` Á<€CWH™æêònZ ž@ª%ìl: C‚Ì•ãIù¸ÿ†ˆ @|R lIò<áÔrÂ?T~kà⤆O‹â·b}» Øþ¬Û@ôíoßÝÔ?kу~þ½$6ÿåAÂþyø÷ ‘€«>3Á< l'È»¼ö«“8×Kv‚¬ù*—yê –èŒø¿ŒË3ù ¶c»µÙJ°@?ÚŠ ¨»­°CK‹_`»g€^‚ï;¼¤0Áuó9µp°WK?¢#:(¼}k Ê«A÷+? ˆ2›'÷Àˆ@D°)+ AÉíºZ:Ôˆ¬ñ »°ë³=ê yhšHŠÈ…|À±ÖX›ÐB; lª;ΑC0X’jªÿ1ü‡æs>¸†ÈÑ µÃ+<ó£A”5hƒîÃÃõ+ S¿óCC¤8¿DÌÁZƒÁJºÿ€ˆ6 Oò´V €v‘€¨™?,¶¶˜½‘›ÕªBhÚ 2»Ê‚˜¨˜ÀS—à‡àà 9©ãk$Y›KP¹(<–­ ³÷û°|£Á÷CÄBœ5î{Á´P?äLñ;Dt·ïûôdFöKŠ>ì2<F:×\¿ÒìOϬMFœFi ªa`šZ°€%ùð;ˆ³Ì¼´–“±‡›ºº¸Pù‡\\Ëä ðꦒ`š¡¤@ŠaŠV8>Ôy…¼»„oòÎ’p‚l9éã¥ñ3¼ðËÑž;Ë­œ5}›Á³4ø R䲇kl¿!UÆIµAÙœ<ª»³`)‰Âp÷8S% Ë NµPdz®°”4Y 7ÎÝG ^i|ŸˆÙ±"(‚ÉT¹É QOÃÕ± ÿ±'9(p‚‹V'`ÈJDø”¼ëL ýQBİÂãÖ313µµk¬HN½J¶XK1[5®œÞ‰¬"aÐ|°L¯1ˆ5º˜·QGð꺨ÀI“ˆ‚wj,ÝCN³‘{Ã’SÙ3ŒÈÊ*4pÿÊÕ’¸hø (( +€fýXã:µ›‹C ;ÙÄ[?zëQbŒÒuÕ­8Ͷ8A‡3Mý %y…+_1‰ }' åP÷Sª˜ßñ×’X@X™‡)Ü›wr1ÝŠŽKÌÅ´@À6Ä`¼36'pæ³XçãSð´k° ¨€àã‹*‚Ã2Š«q™¤[ÒÍ0kYý—ã S w»ÙßÒÊŒAÛdM˜-º‘芨O[—x§m‰©» ÑРzåA3 ª›•ÎØ  ÐÍ)UTLê\ a@¦ñ軨p%b=[€ŠàS4“Ú5’Ú¯ £ÿjy+º^áµ3 Sœ}ƒ°u+\æÕ·æ½M'}HÃóËQ{€@⯸ô…+eŒy¹š•ˆ : L™äœ§¥§’ëR‰ráBªÅEÅá`ñ=^O‹­ØÅØfÐì°œ±¹À9I¾H+ÿq[¾;ù4ë4{à»1ÀýÏW{^ø¬`çÍ`ù,RþÍ?M0û!`ˆKüÐ瀳ôEŽÒ] K §´HSL@Ñ»—hˆ¦ˆ½…)‰!SÌULÔ¡„pD}ú\…×] aE%§D¥¤è´f€ìèaèøœÀ5èàƒ ‚"¨ILœ¶H¥á¨ž3³ÿ¿]7ÙЫ´Ùœ¡I-Æ×\ bT2J``9zº|Ñ£*äŒ.)‰óŠNŸ‚Îø UùÎx–øÉ *IÃ’ÊÅ,‰–A+u˜Žû…^hƒŠM ^ô'|P©’H,®Ø# 6É Yô  ›µØbÑy04Wú€µYë7><ËNEW]6<ü„M¤¤Wû\¢íðÍÒk&Ð +”¦©­@˜t›jj©+YŒ Á^㋠΂_Þâ ÜG0dˆ¼Ûž~b9D¢Lh§$¯^p(#–0eÀ@™Äé \¾*A—ô Å± àÓ }Àµ É.Wå…YåU5ÿ™ÍÑfÏÜ&UH% ¶‚h\8ÐôM_{‘æJbµBö=®•äx§ˆ3X°É³ˆˆŠwn˜‘NsN ÕÉ;<]¹ÚP…oúä\¼’ð§?Á‡¿1ŒçDÚ¦àC~ŽŽ¬àçœ (~~êªhª¾7™E#3D¥Ûe åÊA´c`öÃ~;MË#3n • ¼ÑsÚµ]H9µ ±%[: ‚½¶0§![;MS‹ˆXgëè'xe»áq%QF˜WȪÁhŠ?R ŒŠ`ŠZ‰ÍÞŠ‘ñ_ ž9ѳ;¤°ˆWgü\dµancg|mê»Ã…Í I‹ øäéh‚Ëxÿ ͜ᙶخå¬;™qS#ȶS;!f; L˜[…Q€Ìœ¦i烆W €VÀ¤n…Ã1 ^@2PC €9¶(òîŽ@¹ÔÑ\ãõ#)2û0zÐÔ²fÍf´ãÖLkòŽ¢CŠ›–` ôEß´h‚­pK9!ͬ 'H½Ü©¦ØëWoºðµX;QS8‘*%"¼çƒñSçãÅ^øoÔnîöØ"Dïˆq ¢ö¦ìq]щ× ‡ñùË|ïY³zøÛˆ.v­µ ëÃÓÏ8v5z6{@Û(¾È¥!Y™æfÊïr‘„Õ"èŠÒ€ÿÿÝI“‚5/oJ‹Q¡@µ›À D»–YQ¨|˜ß¦RîïÔ!Ðn|˜îðn]%ðÖÕHœ ïqŸñGtG'³I:í÷3³ÏEAú¾hU;<¥Óå`–3 û }P—ŒAN߬y”´h˜E焲Ã(p‚‡ ÀÝɈ O;´snï¤ XÕÙ4½X:Wé\؉ìäìH È¤žL œòŠùñÃhqð~öŸñ’‘²[r$—0¾…o¼JòX›o;NºôK÷èUM‡Ä Œø€Ö€Üg¾{˜Œ­˜ Ž“õ§oÇ–œ¹PZŸt#ï”s"^ ÀÀsÿaˆƒ‡ŠÉL ç®; @J ê8ïöF¶nß•DO éòqsöµ(—·7q%w›%˜÷$åJa´h±vYãÁ¢ë·²ÌÉxZuÌÈ|y©K˜FÊ¢rC‚Ákz.$HñNÂÎéŤnaÃO£Dt ­+ tíÜ%I JûL"o²´·‘ÛúñžÔ•œØ‰´×‰@‘“‰¯1úûŒ"¾·ÁYJ ;3ÏyX %ƒ°*¯y×™÷¤È<¿ ©Ü*¯r ø Úh !‰æBù‡zy3Ý6¶E34ÎJ}à9 jiPh}ƒÏ8oZ$RaøÚ ÀÅŽÓ¤H*ÿf¶„(ÑCðúñ/²ž­þ!¡`èßU«ÿ(Œ8zµë?D)<4tƒ¢[ÿ©½aVl…âVˆËO`{tçêûá_Ü‚r+ü³÷ À¿„óÿþµ÷QcFŽ2|\0Fez1þi¨bžç*j®,4æ}H8mÂc…òî=”'ï„À(ùJ¬øÏ‡*Š%þ¸¢£>"D€ô8ÜhÁ—ÿ¤çŒ]'ÄZÂ6‹>ÝâÄ2¯A³p¼Â„ H µšêëýTÉbEdè*~Dô¡?ûmAW‰ea»ñóÁwfÔ^ Î%ÐdªåŘ^†ÙãX VdI&Ðfÿ`6"h¥}¦Â‰ó”öh©èZ7àäbm-‚v›<µ O -îösItÑŒ3ú¶€*%‚>¼ðWœwÁTa7]ÿÏ?ÈŒ@ÛÍ8ÿK, | A ,Q Õò0µL…^I@XXÚgß“ù`}ùö Ÿ-–炉f¢H8zr©öÏ~àX‡ ÄP Œ¤6*=ó4O ¨¶Hb A€È7ü¥Zó¼PB ¸‚Ö -!Ð •…°›sÇ­PQo3btÑqÿlÔ¬QA¤ÊE*My“KÿlÇß•ÿ,ÓÝCC½‚“tB|p[ G¨Äÿ€ðÏœ]RuUA{B´h¢Š¶Æ`A„ øIÿ´–裊κ _táÅ`s©©Ú›JúØaˆv#ôÄ©ˆ/Df*žš*#«~|š>D Ï!H ÿAļQ9þ,„ÿ$'PoÄývQE8 õÊqÄ'-DHO§’²Ù*ûÝvЈ7õ?Yj+o3ßòG$%ú€Æ‚Í$ðPP*ùRö´›Þ´=W»CWAk{,7Ý€í+0?¨O~+ÊŸbý^ ÝÞ­ýEi¦Kú—Å–*C‹ú©©¦>æ1=0ôA–¸+P »â=!èöªøV‘3ªd%Ír$‚F-÷Ò7-eA¾YPKÂ`WeNs~ÙL3Ï„W‘+ˆnòq«+¸2D ”-М\ð8¦Q*ÐÄ1þAÄíæ;˜_öŸôâwÿß}XÑ+7ñb·½Ð-oy“ #Ð3È0bc‰PÉ SUÆF‘ÈC ‚,µbCXA„ „+Ñ#X¼RHgŒ’¨Âg³ûNx‚b,@Ë(ÆJIEÆ5¢`ÚE.q»ˆ¬ÀgÐyVzóÈ‚ð%QzE· X€y_Æ‹ðè#“‘G½ç½Pñÿ]ñÅ»r O1b Übéˆ-Ê?þáVê³ýÕ«Qz¢ÛžöE·¶±oq™•éˆA£xh # @Q(ï”1‰ç¢…˜F+ЇI‚ô³Ú¥DYIL"’ž%Ï‚d2“•´ˆo8I®-þ0ˆ8¡J‰R&'²óGvcAÀ®ÛCÞ¯PQ %¸E  Èˆ]²:·¸#B:[xs—+E•JYJRþ0S›‹bc¾ Ò®El}‰ñbIؘìIšË tò¥@cN­hCh‘(ˆð$•TÖìÆµIžÕÐYѪ¡%£S¦¢…UaM¾s<ªe ' ÿpN’~°‚” ¤H=†ÐQˆÔ#¤ÐaDœ,óŒt¥!i›ÚT0¶?õñŠXå•-^e_†°W]¸§ äôIí+Õ¿Âæ¡Í`8¿àLÿðŶþ‘‹†@‡"€.Pâ‚ß•†àq–Ñ’¤"ðî!©ä ^è<:!B¿3PéÂð{È  Ý `¯ò ß-‘À£Ð‰vIXÓÞb½Fñ+Džø¤ÿ*™65J4 ¨·‰©Í§é%€³øËÒ>fb¡--b>»Íô #z¯M ­"”44íS‡^V sø„µ E3Ê#É´’§…&8Ñ ÿ%"bš„GÅVûÇn’ý%©ÛCê‘ùÀëµµ.£`—·˜À‘+“B",p¢µ÷ÚE+Ú¼2£D—=©­ËèAO | à›6œ‘ƒ‚rZÓª¥ àªcZ÷3äÉõíÒ0‰$Éh(©órŽÖÕºs65Úx·&ÓxÍñ?v ÞŸ¡ÀKÝk/¤·hõª!RÓdJ0„¹ Þmëþ°€ùÍrP1…ñ^[lÌŽá9Ni·®5v.$…8;!ÊÎM檳Í{µh/ä³õêüç¼¼#È}Î$é¸è‚¸Ø¥/ý¹5‹ðÃŒ5D»ñÌ[ÉQÝCÈÇÖ-ÃíÒ€©M€’Dz°ªÁ—@ØÌQ|`}… `8ܽ” á” –a ¦‡|Vöâ}“À0x¼Â ÛBЃ=8="\ÂÈŒ@Ä“³,‡ èÃø…@.pÿXDD&A„GìÖn½œu[tÔMÅþUÍŠ¹%üŸÿÝ Ôh=Ý\Ú¼QÑD=€†Ïœ¼G-ÈHq ÄÍÄüRª9Ù¹…°õ‰°ýO4AgÉúè]I‰#^ߨe_™±Ee‰ÔX@+èC.ÈL8c˜FEð\A¸@.(Ä=Ð=ä‚>4Ç’›áÄr=D³qátàoD@@e 2" ÂÄØü"Õ•œ^¹aAˆ@d·,ƒSL ¿-V\ÁY î’ª _ bÙM ómã!vŽ­¤ð âñ#2j\“ú Æi57ÓC¬ÀÞÐLðÓˆC8ÿ„ëÀN+éÈ?(DÌVHI&‰À͇rá†áé=„Ð=Ä[É ÌèÀ[0îìÙR*ØÒƒ¨áá4©)Ö?ñ_þýÖ¸,ÀéÞÓ<‰´äÃ_t_ĦÁÞSôX¼¼ËzT5¢T± î‘äbÉ× ^cKŠ Q¬ ¯aJ¾HÊÄtÜ6^O˜`y¦P@BMYäƒ2D TF>èCÌ?¾c*ÿ¡ÎŒ&J W )ÉŸý™õ,Ñ?=Ä+,@PÐS@ÁfŠ`Y‚aÿÙbº›X¬ üD+PÝÔÕFòÕ^Ý[*tTy=]œÇ¡”‘5™ò&ðɯá×C b¾&HJTIöù’iíäÞ´ÂqDURþÃ<2DüƒÖ‘ $áü}„AÒКæ ÄŸ‡ ÙYŸURBÎbЍ-öß¹…aîÝ9Á ¸Û?Ü•Q'Éñ•øÛ-ý€+€Ú%Ö’Ù-üî¥Ùª€¤ R§5æŠê×eýƒßI!¦‹ÂObôZÕÆ%O*ØN&YXÀ+èÃÁ([ õc?æHéBô¢@\ÿaÑ W?9‹´ÈGh W’ÜÎCNO¸€aЕ%D©‹^MQx$øÄÞëñ.ʼnAs6ÙHÝCÌÔ-ÀFt’¨°™áÜ Å±hÞ\€½lÖâJ86åäõ…ј-j˜!‚еB­ù "=„S6‘:en´'D\¡•âç*Þ±üçkž[©žÞkâ‚þßB–©D¶F»ñÀ»=hG±e=)¢éÕUQ-à‰iè±|îVbÌTò]Ù_âÅKFÓŠ²h½ Ú$aÔjüÝÁÈhô½à¢–cPĤ x©zöãþC(ÄŽ´ëêЖ Ùçÿ׆A‡FH‹Ñ¼‚*Øâkþ+lžù‚耪ØÑVÔ¨»ÁFEV¤ëmFã½ Ä2¤ \ ø|}¹¢a•Ý¿DzÙ—‰RÖrYŠRÅñqÖËPŠÛ¼ž Ï@,NN†«ÎŠçOÚØjQ%\â§ -=¬'g¬S¯´ëSn"=”߆AK±HÄ?õ'D(ID|eé¥êkÝ¿B‰€b„Õ4Kº!‚ˆéÃbDü¢ÔÃÚòÇøŒÏ-Û€À¤B+\@¬Ú›†IIžl{‘ä¿\™ž*ES~ÁìeñZ¹(z¸¨ã~‘·þæ3 [õ5„hAê+ Âh¡Üzÿm -n¤P²åF@âœWa¡^R• õ¤l]X¾‚nÒ®YÂf$l³8[^T®BÇÚ²-1ÄTp¤ÖÕB*l¤ø@2`hªùU`nœœB¦`¦¬ >SŸbݪڼÅíËÌÎá¬bR_ùŽÙ<qn  RgЃ» Dù@8­C$Ç ¼œvU‡5Ú“<½*lY’eÑM.*hX„€˜J]®¢­Ô=ÄÚzdÆ^´Æ¡ì=E- ƒ/4COäm›AÞÁ ›š ·×ÈV/b¯­]§!HkX\\„oO)ÎO#bšèa8ð˜çÐòGe´@ü:å°DÿÁºŽIÔßr(G£•æ• I³Ä.ÀªÄÿE@]ºQ@v•)Õ­-™ú¢@XpA¸Â®îØ¢m-u 0Ø^ @y¡ð€Ä /l¸ cÄ¡hþE ÃOŒ²¨·Z®¸úäâ`®W¹ï“ÄoßcA8Êåƒ* q¥´ìïh2‘@Þ_´A$—*Ðè&‚*ì[Wa”+@,§)\j“xdp>(Õé˜øh]+$À A= Aøl°òn01s—©µ×.=+uæÔâ¦èµâW—=ȌʕéìaüTÇ…ÓÁ¨t;AHz.RèJüÂÕ+%ÝŸhBû™2»ÿænök¿v¥@¨…èüCÞ²åƒzä-C„Ÿ1ÛRQÿÃ-{dyá2¾ÞÀaÝfÝGWt-àòþ@+P@0g»4k +ÊâΤ4wY!vÙDn"fÎ:2¦l3û(›LBDf|æh9Æë˜„VGo 2‘’¾ãÿ†¥žMD©V ´”!?ÀÆŸ1BãUÛ¦ñSô`•—ðs.çò[nß’Ù<˜»@4p´Æ†´QÐ׭ɰžèÔLºÍ÷^Š¥Ï¬ôpAFúZ€Vv•+?DgTªÉµÎn 6@ÂÎpä'í¨l‡IäcA(iWÍ“`qºå Ü´ˆN ô³.çÿòCÜžgwÔ@ƒ¨@€\õS7´¾%ź-šÒxÁábH¦u>D<Ê¤ß LÂÌì¢ÈèÅN‚í, FŒÉž£¼Fd (Û§”_zÊVÊg|F%ðø“ä‚C8wGø "Ý<“x¬bv@À ÀFÄz?„´BŸñÀ ,SÝTŽ¡)GÂK-øBź¥@XÝ^t³:³ Q €(Þ`VÛ†ÌÆ5Ä[˜ –˜a®¤¨wÄ_SÆ&n¢Œx 8í²U¥ÏX*ÂSCü ü^òë\[Ÿ]±Ïîo$W‡KÊ ó@@{dÞ‚Úí±gDj§ÿöi_õ´mÄRݦa]\òÇœ$/•#o€¿‡Yf½pV€´ žx/Ì2Ž[7aLÌ"+6ý$ä<#îÍêfš†·€Sj*‘¾8)ãùÐŽV>XåV­‡…÷靈G+èb<š6?~?„’³÷,£6¤;u=9¯ò˜Fݛ֑Ϝ8ùx5– Ydòa/ÄÑWñÉÌê×LâI„»Íž¤‡¤è°`جúXü0Ð:fc¾¯­ë ´+±O™±ßC ÜÑ*»±#qC0!æC.üùøqªúÅì Òi{){ìŠè”À<9{?:D y¨µ÷C\F³ÿ£Û– •÷X¨Û{€(¸°-S¿L«ðqtÙ3ùö—¥´MÂO™Ëè"Ïè‰'crœ‚%ÊÝ,ĺö#¦6A)NY)r€@pÇ{üC$Ð^¾‹ôZÐ;1°É½H lq¯EÊ&ÿ…‘ëß/}+~½ú·BÕ?U9 Šø§ï§@ ‰ˆÈ§%‚lú¯i mjà€­®\ý«'ÐÿU½ª_¿JLP–`‚ƒ R LU˨@¸qéúW ]‰ IÀ«wà…¾ìú½ a „Šÿ]XØ/EÇW6úÐhÅŠÿðû ‘=“'Zœyä=Õ*†øò§‹_7g üEóŸˆ]ì›nQ¤ˆ(HàQ*„WÿM%H¢*ôU¹v­ööé«ýzölÚàÿ@¥`è|zÀãÇ÷í+obJ8üñÞ‘+Ð_¸`4ã+(ÀB“A¢â¤lAå>0d…A(×J˰yÍðzBpâЖ¢hÁ‰¢pMŸ\dJPÜ®‹^4 =-òô¢ JØÑ©îšÛñšÊWZ-«*ÐÒ,öÔª‡I$ËËu-‰¢¤ØÐÃ’½þöCbËüC¬¯1û‹Ï1úÐdìÌ3ñk[Š ²,¡„æüàÁÝòù „yú裕Z0— ' A]C‚éDLdßÜ*=hS¢tH|aÔJÿ Sõ)Zëá,Y‚Ø+S·;è;³$z²×~vØ.Ï[Xý„=ˆ°úú:Œ>2ó›À®þþks‚ ° Š´ýGÁ›çü‡‹ò™°ÐBç¡gž¤W:#•XSwQm S|‡‚ðÅ«&j…}!¬‚ƒ •  zä‘Ç›ª‡¾‚t{¬‰ƒ»5I8F’ 'S‰’ã+·6ä’ôR¯ø¸L ¯ * “gÅk¬ZVˆ¡À¬•hL+:ú¦ÍíèvZÉO×Z"(ÒžBñ JÙ xF‹@“ äÄ~áRUu`*çXåê«!$ºŽ¬¸„÷ ãê&O-˜T+J·J%ÿdô¬Wd'ö½Â Q?CŒ­oLͯÀ š«Ù(Šr“MÉ+¿H4ÌõhBŽ4(š zÜýD-qéôQ@¡§("pÑ×ð…”® „OB¡]Á㥠G«:XwÊ‚‰tåÂó AŽg–²úø@ز£³ÄGÛÙ ‰2Ç"ÏzD ÝpõÇ&%s4kÐA&ƒ2íé ŸŒ¢ÿÌ¥zìh… AþL'Å Aê•C¹3\e¡ é À‚X´(Ah ‚Ð*Ž^G„FbIñ†1;<2ÌžJ§CôÕoçA5½4¸ 00 ÉÆ'¢Bn¨è еh ɸs 7xÍ@˜Ê´ ª †^3À›Ù† ³©šW·øWòŒ\ªœæÁ‰JT ø‡n ²Aüƒø-ÛÐÒÁ$<¥ãAJÈÌ\%ànY¡D¬´Í—Šl¦y©’ƒŽ‹¥îvW›iÙO÷³¾ø,æè+ˆdÕ·CÍœ0ùÇþP)y9j€öpI£ò{D!$Èo^ÿä¢Ôµ®«lía.ÚÖ/P•nÑúÜ—˜\ñŠKÈÑ<)ŽwÌëI7LR>:Ï(-¤Ëƒ¦ÔÑŽêå<Õœé_ œ‚×($KçÇdI–é‡çÜáµÖƒ4xö©Qu‰éò(3À? sÖ)PAùÀ¸6ëšSÎóGˆpn1àÞB¥­®àA†b<‚¸›x|srsõa:âÕÅÐŒ¡^¦yà «»Ô4‹á¨]nöÐ!Ž‹N³ôFki/“åY´äÔÓ*(ªó%Z?ý›¸Ò•05¿P›e \ 1h(¹ìûy*§¬ZË\fîpeÍÁýí«¼rÿ¾9ÎÍE&“äìGã†$F)]¢'išÐIðŽ{Ø“Ú.Ùå¦_óbn–(ö™%룸ûÀç I™Ú–-ÙÌÈG“ï„D#šX1Á0J.®V›a™ |RµbBÛ%3¢\årõ?X  ``¢»M˜Ö,×îÈjÍ' ’šéÁ³ÜõãÀv›¢ëZWcºX1,zf*hævt¯Ü®&²¼¤Ø“ù•pˆ½6`„Üîšó0çrAì’¦H§·’Ĺ‘V4%kßÿз¿ŠD D0B<+¸é ‘ ÄÓÕæj8ok06âšÁŽuêáA9Ömãwı’ìã*ÿ»Ùì±’vërB#=ÚB )ó§”p‰'ܵÁ„²qKòÜ<ìñšîâ—r²{èá‡ÖíA®¨Ö¿ž¿÷K„f1¦ ÁB”+i /<Äf`:@¸ÿŠÚo-÷_‡tIÅæ°ò2Æñ·ã­xfyTxZ4{.AV ³Çâi'vJ5ýk¶g*¼&¾‘‰,LøÀ4˜Æ=)cOäyÈCs©eßKÜâI‹(†OãR¸kDóiäƒß\IÊô$Bx<Í¡xæõ&öV9ŽÈì¬ÚJ­2 Ã~ ¸¼‚VòlxBÎø”ÉΆ/Ï( º|… žO.Þ¢-ÿ¢ïð«›®MÛ: ¼/„¾æþêûÊÏ‘zˆeÊé}H*óä„e|èïq(ÃeØOeŽ4ò‹¦ÊQx&¶L— ŽÀŠv îõ’ ÿ¡lKh` €Â¢"w¦Bí.®+4p<ŽG¹ê ÏKÎÂã¹ò&Jš-ï)ûöªJ`°æº/ðf*ü‰ðTf|¨/iÙ þÊä+±œc¼ð£e‚Ê’€ŠNâCÜ8±1§A LqOAÕ#èÁ2bß>#NÍñȉËt†¶À]N Z á$.0 ѰÌÔª9z¤­„©HL¥¤†'®D¬ƒîÌÄê(8î&úÿTг«„hN°įtî0àƒe/üȱ‘*±?Ú©ÒD["G1$ç0¬eÏþˆŠòæãYäc/ϱ(Àþˆb´E­P3•TÍ¡¶ŒÕ¼lrQ }QNàŽ `wëÔ wt++‚Ëb¢;:У¬mäâ.¹äxXhz|%úÏÛ´1Û ¡¦Ã>Æñ>ÆYÆñ{¾'urËi¦eÒA, Ä1´ÄÜöcÜ01 "'¢±Èmq.B`xfáDg³xæµFoËB@rÕÈå+PÅðʰ ÍJ·Î0ÔPâà$l¢0à`ºÂž"*(ŠÅÂHÿb¥VJ†Ú)Äòªä˜(òŽz^¬¯K&g°ðèCƒ’ez’¿Çܾ‡fÌG[,«(‹NŠr!,kÜ#èÊ-ÕÄ ÈÌm1ƫǘ2Éé ²%îç úoÉ\‚\zóQxs7[b¶Ì¥O€ Íê$03’`*Ììáè²U‚Ë9°Âb\Å÷†ÇxŠÄÜNî4†*>ˇfFÓ(ó?D!*ézh|6Ã/êÃZ0Oˆ(ë2%B@ãZ`¯žê«%ôëtFk¬\ãõ`íÁ^À8Y áhÌ‚1þ¡9ŸóáxÄGZE+ÿ^àâ0f¸ó $F; ‚£ˆÅ)8´/=û ±ph§eÍ-(ű*3Hƒô3‹4CS[HSI!D²Ú/’†Nf¢%ƒ?ÈI’Js1†@ !”c]Nà#®H Á±è ÀLi^ ¶$’öîAÖ0€ .ÿ!Ft·è2Ìx‹aÒ¬9  “ÎÆB+ÚNF ÓHFè:^î;áìäšä¹‰.´‡&íBqÞóYØ“=©SCUqÞÑ3EÓI“t!ärâÇ£’œ"-)·…Ò†LSu[CëæÁL×Åž‚"ÂPìÜ4ö>gØ29ÅL$ð”DbnÌj/a‚@:ÿ¨s/}'+b°“HÐBVº",2ìQ¦FÇc™¤ Òõ™ÂKú¨‹‘N¦HåïýæµH‹Ô܈THÏÄ(Ñ„Iù•¤ImU’Îé«Ea‹j‡ÚiÒ 1b-GcžÂÐu±L{‘-7V·æ”NGdñtOÕ.ÀÌÐEÕÊbX”UJE,FQõeÿÎ)\#ÕVÊÅ”6µILjJ§¤Å=q’hoò&…”eø54qÒ›ViCSÒ ‚_Õ‰½–ò)‚Ù ½Ô‰g$£?dt*€(ttÕLÍ6t:gcï¡ 1€Nßömí”Ydõt·ê2·Îê~DEf:ÿX…ƒ„)p7ÐT´£\³I Ë™˜ïnÒÓ]iRX(s§4sá/iV4ÿMž–IMµsû5ÝàDš’.§ZØ1rvèÜG9Z¢¬þa"KìŒÓL×r-7¶ Unwëî”NïtOI4#ÿÁâ’.@Z{os$÷X¥e©#;ˆÇU¾"V^Vƒ„;³É˜–Dºíg3u=3ß“hƒÎÇÑdj9·i—–IÑçM,§½°t†¼¨ÜgtuFé¢( náØr pW€åmíÔmyk¢~×NÿYs G4ÔpGî2a"NU$L+öòT\a¶H*†z+F®FqÕn¸—gÿ¿7Žìw'i’†4SHÔS/¯‡ÎäiÑI‹vj‹ò)ùu²lx3üÓ±®4~³Eg´R" €wé”Ã\*äBX Žà¨ømÿmy—ì2’Yõ4ÎDó4ÂL6oM¶.шrd; •ƒ\…H.Êm°ƒ$³i›<èI¸·]ÝUXÀídp§p²rƒ2Íï5Ó„i ¹?ï>Ó$~|Jjí³(¾Ä ±…=&€] ¢é 2·z—ŠÝ–~7n%âN"ds`é6r .ËŒT(¬Â,Ì` wp'G~DÃ.cd%n渄Q¨~Ùд«z„½D;'{H…Ô‡O)Ÿ¶åZª¥ÿNÑK–AÐ$Ý ¢¨6†–R@(ù Pœ•X‰›Ø~š˜ÐÁÆt)*‹=9â(ä€bA”YùtO#X•së$ yOyÉ­XÔlÔHßøƒéBŽK¹Æ#:.¢Mñ¶Ï…]ØHÝCñÒƒZ¡8ìÃè. £[á" Zá’pÆqÒC›ßäÑ"OÈ,-gÀy È™/ƒ¶vZ›yÀ‡ÂÆáŽméÔö>Ù“"•` "8Œw+ZmMy—ÖHÂr‡y¹c×Ö˜¡‰%¢Kxd&ZñøÂ^93Ñ£ÒZšÓzà<t°ZÁRÁêÚ¤Ûún šã±!ÿÞ[¤e¨Ô}™œ¢u d æÆ™H[4pÊ'ê¾iy:~K­lÝ(Š„°íG..x%“'1ÒOqÀ¤—…3“¶žeÁÿJx8Ü„@|¡¤ý¹# ¯ÿAƲåA¼\ĨktI‰-Ÿ¶J@þ‘£@rºœ“8i:Ÿô›¸èâß¿yŒ Ì(pˆ+W]ñø÷aÄb€B`ÿäÉ;rïß‘ˆüËðN”ˆ濊ÿbºtä@ÍAxØ3fPõøg h½£ Ö«×Ô¦T„ þ !ZujL .Tðz¡ëׯb»rEb(,’®º¢ÐªDC­ˆ`!‚0`Íšù–w…¹"ìþ“ o… +é+¼b…É+ô}˜gÐ F%JÜ*ñ¯ ·þ‘˜7š‘MF¨[ ,áéÑ£JpuážZ3Ì 2†‹—#v”×ùHË|ÿ«IÓAÄR#þœiÓÁ?¥ÿ<ðÝΣBÉÿ[ZÔ¦«¥çÿ14¯Õ)Õ¬JãKÝýì…ûûW8|Á  W†ÒÊDW+‚µòO+ðÕ ÿ0€ÉEAcþ£O‡ˆ R˜‰H""„[kÍÓh6¦Úi/"lµ&ã-˜MÀÑUø-‘H1ñ‘IðÁ ¾aÂe,ÈóB LðÂ%e€ÒÚ!$Ýs"ÕÔ%D0—^ÆôBM=í”ÓAÇЛò±'PRäeg{öI•@z¹¥§ž@»I`“L à¡&z¨¢Pðƒµ‘Š”8ØÊ+ú´B‰0ÏTxáFFªÿ|bú|8Ù?$ŠhÙŠ5¶Ø.†Æ‹7ÖÈb¯¡Å6 é&AnVñ@ ÛÅAøö×\ H²È†Ì„JFª”æÿJ8I·Ü5¥ù™×Í´Ó²½ OÔPSÝ)ŸTG¡·ïž|¶÷Ô€úû~!Úèÿ(¬(¢fQ`>ÂLlA^˜ê3Ä+ÂôÕŒ0 jh©+ü“Oötø˜ˆ –h‹´Òz %œÚ ¡¹¨ë¯¼ÒxÐi¤š@ˆÐC6©DP¼ÀGd@€E!’‘¶PôI3½.NA KÝDcZ‡n|Óy›rÆtÔIÕÓÀHE0QCôyUQUÊÐzî jÓ»%Ü0£J€ µL,L-y½Ùú@ MÇŒ}8ªÈ‘éBùä“2¬ JfÈŒÐÜê-Þ,³ÿ‹3ë|¯›q„YA ¬[B¥]Ö¸ÛXÿµ/| ¢-—CA\à¬{‘Ùešð¾“OÆe“x.ñž®OR­÷ÐÀüNÅïSuÿ“U¾5etÁR)Oxý‡s©{ùÒñb FFAhEaìrƒÉ¬`+ðè1Ï…ND¿ QËXÀ‚y`pƒ2‹‰Í"3|pWó8ÈAn1¬ Ù‡!áBL„‡T1JÂD„pÖ|c aá–òµìA$'IãNÙ,Âè¬d9àQ[Û¥'£ )r[ŸRöÖ§>Yå}çñ[z>pÂ-Ì~@ÿâ⢿¾XÈL‡þa‰ÕÑ1£Á а@!ôpè\ð*ADü53JÅEd@P׫Òüì)Hü(°'çðˆ9Î3 v¬D¼ à" <‚Öœc€!¤Í 4@O~Ò“¤%ÍM×ÙIK~ùšp'iÔAÊPR¿ÅG)ý²{¢“¦¤§}éIæyÊg´ÝLhcc£ÂR,DP ã‹…'˜ÉÀ…S”h̪BD@6ТÉ\ð‘"¨ .³pƒòHA B„XÒWS±ÝÁÊðà!Å$ÞÑœ–ï‡ZzÈQAˆ®ÀÞZÿ‘[ªt(¸$“tÂ’)F‘:j[SºÞ´.¦Hï)yªfžà7¾¥)ÎcÒhFy¶éf €¨ búP„ôbNÀD C‚!Õ?Ã!ùQ+PÅbOCº€Ÿü,ÌEHÐ þãI1ñÈkⲜ1‹¶É wyÀ J: 9ª4‚u‘(:-ؾrAñg «\"  Q 0è”å꘡¹Ü 2 $$èÞ9:Í­ù¬n[‰ˆ|”f"¨@"'¡ ý &]_ø? TÖ{1:Ã&úî$Ì!åG)òÔð@–¶ÊÓ$ïIÇ;¨s,2E ¸KÏÏS1™¸;{g)vFȺ˜™>§Ð ¨q‹›mmK>Ûìæ?òÜ7erâÿÃ1̇>Њâ^h"˜qȸ‚(´Àsùà‡F0²ú 2ô GŒŒÝ)¹¼3MBB*Or„ZŽ ‹82«@(zYk¶ 欥Ik&Á’oŽ0ÑííN`kΛ+x&–Ê |‘lƒñÓáÌ;NWKßWh «O€"½m(¡Ö©¶-ñX”Ÿ¥.øE-6½ }(Cè”Ǭ"ÎÌ-À pA­ :WgŽTª! Ù¡®•Dù€@ N°ä0‚%¶Tˆ-3šÅ,v½âÈ`$•dà…1y¶eè€d•;jξˆðR’þqÍ PÈ·½ÇÙ¡ŒÉÝÿËéÝ/+"Y“˜L*=JwèUèz}nÛˆe+°h&³š€ZÔ‰Â0ý•øÆ鸂X&‚Z!¹”‰,º+ G ÙꕚãEÈ=Èn×av°ÕƒÓwvdD0'† ÓøÀ1²‚jÁ†ôc‚—Œ   ƒ$-@2 ®ö‚Wú`kŸ3rñ BòР…tÔøyG@Wsõ¡B!ñÞøQiÑ/´$ÛÊu憻‘QÌñ;`óD–€ÿ.Êá^Ʊ=AáK-áZ&˜ø%2xS¶ž˜K÷u†¶'ç³o@x/Yä7>òw¯8!}á1 '2 àq'Iö A+3x#Ó÷ Œ©’ŽñO$²HQËÕ!kõŽñM€“:iH÷W(Ò]QÆ€,p!FÙË©ÇI¾TŽæ¨Q’µn‚bV¢u‡ÅU’fždD6zgéRn¢&¥%çVQ’Lc²6ß—bÇK,5£(w’6>ö10À ³M½¸ Ð0 š“- Ôj¡C*çóp-À˜Ó¸2“±HùàQ€O#W“U8M°ÿ\xqù ’ù` ”ÙHW e÷°Š¡È “\Ó`bùlYcZYPc• -òÈQ;7DYSP$‰ai/4eUä–Û!LIcKßán¼Ánm‚Ü©/Pn³EÆDhåÙhT‘ê˜zä$ø@ ˜õž"ó@ò‰’ç!”Hw9I™(ÓVŠÄ9°\ž‰”Â( ªmPHŒùÊ€sÕ]1á.j¡GÀiÊ•ÒI_æ&QÑ#YKò<êX'ZX/Ð>OgS ÖKðr&ZÑÁä%Ð÷R·hÐ÷?Q&v>;xoõ}â¤JeZ“ÿp1ᡇ‚ €„$ñGV’ñ' šÿ*r™8Ù…ˆg]¯²H"  ox†Ÿ± KÐ;¹˜›Ç–$lõÜØ³iõ,å¨n´÷Bé*UGù%Q@t?„õQÿ/+=·â%Û“œžj›fÂLÄKÞ|áqg7>@Š 97ùYÔEkW0ä™oW‘&–z ppÚ•€ÍÅ¥ÁxûùxñÐ’"Âc’!Ÿÿ°“`ŠkþT¹ðxˆrœóšeº ÂxµAÄ&”ßXPK ® ”£,W§mA_Aâ‚A8±‘šu@RVÑ{;!ae3ÿg×£ÛIaÐQÛ@ÑnÝÓgqÆ×A&rRg>x[ñæI?õƒRÑ€c0ƒs;¹jð!Hò9AF*œs(˘Õå˜ÐåqŠ’ w]ÿdOÒ‡-`´'[¦'๘WBá]ÞEe!¡¡ÿp²ÊptZ3ËÒQÔ2d•efX‡Á’êþ5 Ð{Ó¹YÁ©ø¨¶ªÊq¶ô¢D€gÅTQñ}VgJ%v?øZøF±C"QEñåù„ÂT #¸7€$Àü€€­2¥âx¯yx2ëO"ãx J2¹€2ý¤@.ðÃè‹ùô°›{<§ž[kÿ”–ôx€¡¿ÓK9ÜÒsN»5Ž(@Ä.1-Ï¢¨A@`“Dg¢`P—6œ /¡ehS×KÙÑ&AqJä©ébÃ$væ«zŠûÂÐT[Fo€ÃŠ3%R²¦ƒ§÷…‰¤û[¦óà…½¸¿P*ô šÀj¸ÖO•›ÑØ¿ôpF+Æœ»ó‰rñyteÁ¹ ÑÀoÌ‚5²ÛsìŠèju"Á£^æI'D(˜DvVE6jæDôÒ°S7&ËnöaMk—ϧZu‚Ãcbç‰Ü>Õ4$MÚ½„‚RÊói*WkMÒ‹Š—d‘ÙMð2+x•ÿŸMPk†d¿úàOT¼qz’ÙŠ­MÀ¹Áì'‰röDWªÙ]nÜÀFéÀp•eÍÖzØÑÜRBWX‰%¢ZRWÂU`jò.u9u«çœUQ`²ÁàÑDؤ/…‘¼ª ·Õ÷7š¬|?X£¨L“l}EQ‘”ÖF6q(†€§c3'`2Y†’¡ö™ûI]EƲ•Ë9Âø¿oXdˆdÑ^ª ÀÌ!]Æ-A¡š õ§§{CÄs‡Q)Í^‚u6q·0!YÍcÁ;gDC0/M”©gR¤‹Œaª^r–ôR¤C!a×Á©îö|sùªIjoŸ7éqhî‘<`ývÿMMÕŠœTlÿ`Ð๮ü&£Ñ¡"UÑ]84)ª -Œö0 ·XÓp·?µ·És0rw;ÿ`Ul¹ØjOgjŒ…—×Ë :”‹]qŠÑ†D ü„Œqʹ`ÝÖÒÃ|/ð€…­¡QCt<ÞÒ#Ó)Á” HÁ[²°”F‚äKþ ”‰Žˆ$`‚?šÿ6·”嫚ϾäÙ¸Äå܉iþ-huæÚ5ˆ½k—«'oCbK Û$«ËÆ8‰­?ûÃýNÔ™''ÌøÈ“-“‹)¹ø‹O‘)ã' é‘^ØQ”4eÛ5GÐÀ9@9ðŽT‚™>X÷ÅØdIH(!ûð-KWÒ‚5´dLéâßÔÑ æKþ }ÞÖAsB]Úy[b{ÉuÖÔRa¤kÎæAáñ ]å%§Ãúáv’-éHòy’YÜ!„~Ñû›V!À¦(Ã9}Ýè3Þšóé lA‰º;žÛ1,¡Z»3=Áž'Ïrêÿ`KŽÿõ±©NDªköm 6ƒ4å¶Ï¶b§ßøÃH1à)Üð@šSy[·P'lìòbûòSZ!¥_­ÛˆÐÛž»¿Ón3‹ù91¯dòÉ…g­·ü*.@H]È¿‰_…ó[¦1ô"-^T¶ÀáúÆõ59°ôBD®;ÍG“uéJαõöõ`ï‘–ï˜6<@=Í›£X.ÓÎçn½îßœÚñR^W—Àÿˆ¿a%vñ0—÷ìññÑʺvn¤ísª¹'ðò–ß!%Có]˜Å¹ð¦²\k(0¿yô ͹ ½³­9ôuÌ^÷ÐÍñà_Ž/&¼ÀðÿO¡B >ü÷ÀaÄŒ<8ò/ÿ} xÔøbÈ¿`òÏ x8pp`åÊ…5ÔT¸òÀN•‚Ĥyà…Bÿ Ü$©’æL• ‘9` ÞÂz<ˆN­WtêBP£-º'ΩaÖ”ðOÂ… k/à\øÁP…óZœXÒB^“½'4г—ïC>~úò)ÔÛb^Á¹>èÓ'B²¾-þ-9ñ¯E‹¿ô<ŸhѤɽ{Môò=-OÞ¿Õ,\+\]óNt54¡B‡'{c0yrc†q~,nä#oCx`î %Í < ÀlZs7\›C¡bÇ®ðÒ£ÿn"¥‰3ýXÿ©ÿêmuŸÕú?«®Ä^™Ò&RœRÛ×Ü*- ÒR럷jbäŸ ùÀ.ÐäYb/y,ûÇžò L~þ¡çÕN샋L2B G¡ðÄ»î2MžÒTKŒFÖä9á…ØTËèž#|ô‘·âþ1"ƒ H€N …”Œ8&52)ƒ&âÊ0é‰0x sÀªØ Ì„ÈL§ójŠiL¤„rª(¤Æ ¯J§ŒÒÊ*¬üË*«…ôÛ)M–øs¯Ðšü« ‘ Yè-‚àäjpEùš3Àì ÁžÁ³lÂÅì‰BDÈ$!ŸW¼ 4¿Z}q Ók5yXøÇ5ÿŽXm¶…Ž Øl#."xb·jZ6àxÃÀ6%?”Y%Ez®"”rÃ@:Æì6¡p¯ ·Ì?o¢Ó<²#ï³Êkj;¸ø ¾Bµj拓8ŠL¢RË(WÀ24¾š(øGQ…>PK‚¬²j‚I+h°Ck½g¯»â”±>HQTz:ý4 £ŒUKW^Q³í² ‚J°,Ç\ã5X…~äY!ŠË€€„.¸ Ùí†ÓèÉœ”¨¦#ä­I gy¸@Ë? €®:£¯\h·øê@s/»¥d"¿t»æºí;ó4Ôº>=à¡X‚7N÷ÌR¨¬³ZDÑg!ÿ«$áQµò€žydm´Œ-óÌÂC¨K¯óŒ±PÎ'ó'tõÅ•SlÕY¸ùV[ÿÉÈÎ~¾ò¢‡¨z¡eár–7ã4bÛ¸!Ú \y΢`ÚV¥ÝÈ<ÉÜ&×½é'´›‚3¨A‡‚½*ѼÏ`=¯’*«†òɼœÌóI¿¿w"ô¾ @…ÿ)¼á!„`‚?°‡ã<$«Ý3›ëœˆ@v³»ÌÃ3#û@©S™ÇYªU8BÝŠT§:ÅP5®ƒÝ?|å3œ4äxËpg5%IdJ¾Þ•šE¤¦ ä89hÚ róå0©:/E|×µ¯e)ìZPœÿ"›˜EPàcÊ}à3«ð‰(êK"»‚À½êÉé)»ÓV0ÄN<€À †»#<5ZÂ?05ÒmŽC˜sÜÌZðÀ‘aΙsPé`¶AÔ9®.ª+ z…2Äm 9‚AFÂWàÎ_¾sáv‚(‰F™Ö”„«4¤8q€+ =&µÐw3Ù—tÖsDìõ¤MüJ›ºJȶnè*÷š›xÂr“õ ­+ažxr”£Ü% ÁER¢ ;\TB «&´„ÒdÌ€"[Ìæ`ÖA:Ðqž$Ìä1Îr¦nƒt tF<ÌΞÁÂÀHp‘lÑ@¹áÝ“ÿ¯)$+yKz†#5R "Y^=vØî|M,=Y߼ؤ.þDÅ'ñs[›X(¿ñÉ?ËÜ"1—¸0‹gÑ×YÖÄši…)†Ž€‹|ÞòˆVÐDØ„aýCòL´"d@¸ÌNð¸w>uê :ÙyÕxŠjÚÉH J@‚!bF£š+¥$gùÆ­ºÃ‰s¬vf!7È×*„“؉kØA›lªQí©T}î{išÎ4®^þ²?}ºÞÎÒ&cÊÉw{Q¢‚Ø_%än/(pqÑ>ͪɀð¡Z¬†Bø‡-ØÂBˆ¦’•­ÿLu8ºU§:ÜÇý£ Q¤jBH®åóA8ÂM\A!ì%p…£ÖÉ&u7jôXMDi’R.çJ-qDÊuõänÕROvÔ÷Ù@e‹ðõ𯕂qEMBÙIWÐ¥þâò‹ìc¦G×÷ÕT³[<Ý©5£… ¡Šp °žÏn[ã#›*úoC¼Î›YŠÂ]Íj¢HÖx•¹Wj£qI’Ê‘ !q€Kà«%ádYö©/×$2$#ä˜<üÈ^€’¸;ÝŠÉ|s²ã‹ÎmF01eòÈj餥}{,eò^„¿õ}Ó—¡SþWz3t‘ÏÑbÿdÂ@ €Š>‹¯ÍQmSÔà£Ð>‹æj.&+а ¬+1¤C\‚–é6,öU=6è”üD§)¡@Ñb’ã!éw<îdB¨d¸%…»:ëG’ì $$kZ¼¹`•èW¿¦i°˜pzôû×^ö=p)_K‰ ئðËËæ—ñ4Ì?ArÍÅÀ( ÃS;aËLm€  ÀÐ5Á¦P_»áa1ðÒ¬qt¼qt+½ 0¹ ÁU¯Bª¡ÎMZqÖ•ôÐ$ø‰vW¥'M¹!L:I–“ƒ !½LZ˜Ú´à+E‘×/å(‡¹ë,F~PXÅ>î*&Ô^ÿ3üþí»1™É×>@¶G1 žòœ§£À·í¬ZC[!BP-lŒô…؆ž·¬ê£ä~ÐêV‡žyÄÈ+55Ïà,R@PëÝïßM†{ÜW'ú-?ˆ“欑8 ãoÑ’y»•®LG§Ž¤²_уe …äÛQ©Ì;m L,Bùrü̬ì _ôŠXDŠ+°{Þ ´1ŸØtJg øOqú= ZîlDõÃzê=<¡«/Z‘U¿ºj†‚«]ÍÆ§B;&àȄص‰@zø åI¯æÍª?¢¾qRÉÎÁÀG0ÀO[w½.A8i͘WiðIÉ¡&ŠbÓ-;~'}Ïø*å+>ËxÆÆ/±è¿¾ü’ó˜¢!ù ÿ,éÿÿ H° Áƒ*\Èp ¿|ùñCD —!ÿ6 ú·q°k„†kä?a,ü‹°€‚!Dˆ UÈ(DÍyÿæÉ»÷ïļŒN°˜7ч }øAàÆKN€(Â? S%ºÁ ÿÀqyáßV°f+’IáÇø8þ›Ù°®Ý»xóêÝË— ć€ån²`áa…@;‰OØÉ‘%U®¤PêÜŒád”óŸ¼òzj>áSàѤ&hþ÷AijF&ŇïX­mñymu£ C¿Í*ýwáƒÕ7Z½ý·€ ½}£KŸN½zÁ|ü"êÁ܆7(-ÿ؈h®kÀRŽtìXåVˆR‡ø7hSô:‡¾º4Qά½$P8™†Ù@K-€Ï(¼ DWq½ÕŠr­€eü†ÕÄõ&„UðA>öXgâ‰(¦(?Ð]‡RÌqÔ\oá >V"„JBàXa|œP ¡á$ä@DþsCÑcÏRöp¶#%°ÀB 4uf”ƒqÝ“Y+YWÊ%·Ü†\0A±I5Xoyõ|3µ˜]N€ˆžzz°'?p§â „J÷Ð?Ù‰PÞ?7¬àá‡4fA+ÿ¸Wi…¦Õ'  ÅBiD††@¤eöO”DýS‚Bßœ-dOªÿ!ŒLª\@É?j1Õ&w€†ãHåÅ: ð¶k½•°«ä±VŒ7wÅäT…9•$Ÿ8íÿi µe Qó@+p¤&‚LÅFÓ@(…͸”°39YÊ—Ä’#ê;#2Ï d¾ÿ€tu9„|«q7`@ÿ64í.Æý3Z¥vÄZ)âbœÊ‰ðBëy‘y ^N£@BÃRЗ_Þ(“äƧ%x™ó|4ƒ“o×À‡4­{ Ó9åQ†.d+RáM`ü€VOÊNyó¹""9!—*äZTiKGä³ð~Èàî’ìÜ@[7AÿŽH«Ø($t”w$1­êdSó? ¯¡)­Æ¯Ff3 ‚g•8±Ÿ&»œÈj<9C1“±ŒIà£ÿ@O. &ÅæuÛˆªE–å #nx¾#( BZò :@Ýñ¹G–ÎºÛ u:´0·óÐEZ2ƒ £"ÉÁñ,@%¸†:Øï”œ#+¡ÔN0ª"åCYþ*)Ê,Á·ó?Šû`àDTüÁ‰¿*ü5!HXS¹Áyð•,Í%o`9—ÈmH¸Â*Ká‡#g¼"ÃñôñÐ1&y¢Žì¨G7tR&‘yÏZâ%rÓ Ò(û-`”èÍEN‚ !PJÕÂ0!­ø.^Ëúà¶Ô‰Ö ¸aåB`®0BÈ*{Ý«(' «´Ð™,E-³4K®‹ø]*wÔÜÿTû¨†ÕâaÈxKTf¢S´ôs™ŽÜàÔt¡nòçœ-:g÷¯ÙLΟ³˜gtÝ>ó-¡iM'uÃãÌA‘4V§’11U!7`GE¯”1ª‚…@ò0*¶cAðÂsådV\k¤a, Fm‡\ž1±ÂVS Œ p©qžÃ0Z‘r„Ç~'€)ò7 MpQ ^ABxÆsq_”•iÁ"E'3š9R€ò×^ófS8ãyì-RØHà3tõ…œVn0+I¬u?AP3:+ApÇ0!@ ñ‚l§`a„‡s%(;ÿÂ$¬S%ZƒZÃl„/©ÿâ4E‘óÁ~—bg€øpg#ðr°GfhÓ„=P ÜôqAŠ`båÇSê“Ig82˜—ëV‹ö‡(-BTø”š%€…2_ð€›†(•s(/â%jH +€Uµ­Æ.Js2{V!Eð?ñäÌgK'À@aT0àxŸÁ\/XÐwUSAUÃ|qµ¤//ŒâZibf3 @"¸Á(!h1h 3e1 oqG Áˆ Dü°3‡²yóv…ÐY“Fc€·ÈÈ-õÆ"L(^Øa‹—dŸö"Ñ?*ÁA6BA&A³ZqB ÿÃ3KK}d¦a㇟Qr5Rº–f©B*ŒX5ƒ`$$ó²¬c%Vb Uy6'ø°(%yÅ(„–6ÔƒɱJ©`hpÓÁh±i²˜^êµn«gn›‡‹º…CG(³¸"Ä-—…—8“ŒN!.£6U @ Ðp61…Ps‚BÛ¸Á9?c<4±Pý¢ˆ®¢$£ÂFî˜$dÅ^“*¤¡*KòQ›‘9q5µ&šµV0Ô'd" …!"¬}ÉB×T„&Ȱ ËðßeNè2óš”IÑ"û§^ ‘8<ö‹!9(Ev9ƒszó†Oe¸CÍa.)quŠÿåZQõ?” abˆà9x:˜Q &/Å;C*df±Ã)-л¦a¥%"Å:RÓC¢/ò¹k‰§)ÅÁ!Kñý¶É!:ÅŠÓ” ßu s£B‘ùn\2óFµœVØ^—³™”Y*êñ¤—æf‹Å¢Ðrn]ˆ—å¶…Ñ(ß)µ·8Ú9©äS5“yH`bE*Ÿç‚ÁgW·A`A§f¦9ºŽ›Â¥ëȇ°0 =[4rvÆB~¼Á9`23„©œuaY#9‘=F’|‘^Xt±…*r(Ù9†¥çYòÖáö–ú:‰ÿQ{Vä”2žÔˆñÁ0Zº\bÓpùò¤óâºc;çxe‡¥C*·oEPs%­c/Šˆ/Œ`¼W ß8>ã ­& oqsË7hBœ”w¨ê…1oGÕn×ñOŸ†y…â§k9z—qz‘3øôz‡1+À£ "g7‡rC,ŽQA‚²Â¥L‚ nv F·ö@º¤ˆUÓFò":!/ 4*ëŠL$˜šœ¢fö1±A2c}æCH)µÐMÁIH7 Å ¨¶(Ø1›T—!卵‘“n ’ÊJ9ï{†ûYüðzÌQ-mx6ñ;S;ÿiEë yø±Âq¼ÃˆYã`µ&°¶ä‡4¢ª$Õ*j/»4_RP1Ö)C1rïB`5Ñ„;‰xoRH1 É=7@Š.CŸ…!‹™­ácŠ‹ÙÑ^¸yñôÆz")SnK—‘§zcȲ¨Tü€U[ÇB ø@ ù @W‘E! úgäö`$“‚Ôv£¢´ aW´a÷AºÆ˜FHkºI[¯Æ&W=Ykq5W3%ÄŸ˜a:0±é3Ö °Ü±oâ! ó%_ò¢ˆiƒZI[(i86WرË9Õ™"¦72KgS¨Wo-R†(ùúÿÐ@“U"RaEõ¹ú@@ޏkúZA𘴌x\ŸË´Ÿ1V]š¶CA{ºL›k|W|²û—«:1•_µ³\TFáHWá¹ÊzCHûÀ©¡½Q¼ÅK‘@†§êSot[¢o+—ÐÊ…×^™5·ýÇܲ‡ª±ny(Tx’MH `'ç†`Ñ%0ðfÁ½T5GV—5˜)|ÆÅ½åV»rŸQ$Q“`—úžÛüYez$[’EP±,yËqsì›Ä«4NáÆ;_â–y+\‹ëu§CU‹ñç&J’ü7—(â§k‹z-òtÓD7ÿ€ÃRV.à8,»ö¬³ÆJÌmç/üºìXA¤;¢ ÊñØ‚pV >±q­:š­Óª:¥Zº%wÄ!´âÆgŒ«ABÁù ×€ åg’åiëy=Vô×cB5Ì çÂô´>x¢iº˜±urÌÁjQ&7v˜šB¡:\¤¹|‘ :w#§ëVn4|»ÕF»¤ÄÄ&Ÿê\L­Ú¶Žªr$”H:Eyœó67Í0ßESQx€{ t 7k!™œù'…Ñb¢4ó=3zCs18È(^ÌUApQf[—gY{aKðE·ö³…¸5µQ½% é|ÞF˜™Vÿ%/ÿ²ÉUÄN»Å&ݪ•ÀBígj-:~"œËÐ ëM`2cëËÇ*\I^è¼CF²ÍY(ÑÕ§É—{9<è)^×ÞhL¢`gqŸìF;¡|š©ÄÖÉ&Ø‚²ÓÎçxwËk`“8A³Tu$¬qGÇC*)UBp³ ÏH‡¶}Чv¼c ÛÂ(œÂÈê^3Ô‹´Êb;7!hRµ“½çEý™kÑÖg×l·°]{ç5äÓ× ±Ž­s@@ýž®+"D¡Eñ}wDys¼7ùÛ q3ÙªøhH„¨é%…Q¢wɼxÿ<·•S²%«"Ũ‹R¸tÝ›—I”ÈqÑd®5'ˆñ.ªsʹÄKtÛþkbtqጴ¬»wõZa±Kq£‰´«ƒ@@-WÁùð‚ÍUL!ZË@È›1õ]M= YÔˆr_²(˜×€"êé#To«±CF3šÄ§Ù;8ÇHÃϪ3U’A)ãqGùÀ!DW¢LmK²ÉIÛ¹me\¤ÜK¼ƒ$ðœÀûyw_õù1 Ñ:Ç—*ù(%‰­4ÈSÔlH ¿*ÙËCci8ç%Õ+ÑÐJ>Ï+ã)¼I{ çÛMDÊJ’‡r’ŽÔäëØ1%ÂE±$w߄·@+ÿñÒáœÛHŒºýñU­*R³eö ˆÀg¹sEq*5ùûEWcÊZ«Ïr]WsŽMh7Ùq³ ×°´Â–Õ2n–^;·˜'ëH5O}ÙQXdúÀ’­ óœÁEjèý»Ü<Έ>èq§Ó3íÛ1W¨9"ÊôÐ' íô ˆ™.ÏCº /‹:‹Ø"²Uæ^˦ˆ LœqƒŒâ’«4±®Þž†yF5Çʸâ·²o›âÝÒÕ„ê—‡ó-øô—¡?¾Û9…™> å˜´hôã:MÎ2}äý­Ó½Ôv¡±Ÿ©â$#¢2D––Þ¨iKO^ ±»—kõYƒ¦ÿóÈ‘1.MAhÍ× ÙÁÙԴ‘ˆI€|ëžå¼ñSÍk·'ÜI•&Çʈ±9b.wNkJ¼[HËvÒwÓ¤[Vm5UºÎ»Ú~5ùñ$žµ2ˆÑàP>í,n$ØEË…%Æ4$÷€îgüocq3Âe^yðt›¥Ðv µ>·ç¶w«Ìís8]nÊh-å‚Ö©Á:©ÙñÛ5´ñJ«´UÃO¬ì?Ü_Eíj¿30I2níQžM~«ì³ÇfV²\U»)G2‰– ^ ß6ü/¡3†Ã81£ø¦3!ëæoT™gâRÝ>í£ Çÿ¹¶Q?‘’Põ¡šqU/XJ¯;YOèet´‚^ú:-÷­£à³•iùëŠ"²K-þýk1OÞÀyÿþ“wBžÁ'X8,1ðß‹,æ•`‘ñ_ÅyM!Áâ¿Vøý[ùïÙÉ>XÔ÷O"~8=Àäi1ß@~ãñûô_Рñ~*íÙÔéS¨Oƒ¨PàßÏŸT­Z½:0ŸQ¯"L8ÅÁGþÝÃp@Ï{÷þ‘Û“Ã?ÞžŒ‹mÓÿiHhÞ¿™n®@´â"Ÿ!ž×âÄB˜#²hÑq Ø'ž(!QâCF&ü3Dáßõ4d&ÿÎÇ5{òÚ;iW '¹ZLš/ÞѨɕ7{òë¿üøEŽüèׯ5kB¾jaGFf¶å門ܷuaÖ•ëöž¼ƒhåÉ]2°î z„5ü£wxà‡|»­¦ŸZè yèm?„"²ˆ4y£¬…:‹Ï¢ŠB˜@ÈZ±§<CtƒlœF8ê7ž†Š7~ô9¬šÎ:ãŒ+@©xvn9 {*»©ª*8®Šzޏ ¹!: I!ÏN¢K-¶îQË" xJï¼õ’¯‰“–§>šLÁ¦òYLD‹DÐç'z HœL¡ËBHž 9Ó#1'h5Ûþqÿm š-ªD:®9â|㉷š˜êÊ8Þ®ê‘ǃ4õ$£À *®¦;R:èVu΢V¨ Õ>ï;æƒOKõþië¼/×Â+X‹¶dH :#h4˜üãÏž~ÒGÇxÅÃVs NJˆž-’! I£°Ùš¨£Š&ø 5î<ÅÑ Q´Ô¨aò­ßãaŠGo :ŸNU8V¢€CN«é\½Š(¤lâ§‚ŸV¸&Cfú3µŽøKda"€®¹ÜBù¤ -H4ÑžˆÍ¤=Ìž®jÁ±ûgÛV˜3Šh÷‹™žp–vÌÔ%M¢:2 ‚yaúÿŸZ Ò§épBÄëI+½*Lr¨Þ~Š•Ôx\øqa e]5¨ `ª»bàž+ûŸà|°"‹Å’<·xÚò¯E+ˆY¨ ³'Ÿj¯Edçb{Å矪rž˜MÚ"FèaÄO²ÖµHêŒbf„Ã"m”%ž6àî1Èrzê_{ãI7«Œóê8Ýtêm¸•›JíX£ãǤ˜Çy+Š‘ç{JPZ€ "mwž˜’ËW-×:¹ðïŤ¯Ý%8C—\þx¢–{ˆ¾­Òz~E[‹^©Þþ¡Ÿèp…ë?ü‡%ƒ¡tF3„:ɼáۤ䩑Õ(p1 xÍ(*Š›¦Pµÿ6àD§G!Xñ”ƒ¼†U¥n@auª’éD';ô‹MÐlrŒî#Ђ –°„—#¼-õI_»žU.sg ȵ,â3UhK[ÝúæV ­úsô³I-B­Ð1"\ O ¢‘°{­“JÒŒeüc7¨ÀìN‚ˆãü+*z„ oÔÆ£Ç£"žÂŠÒ•èM,:+TÛpT…³…:›Ln "íñ#U²Ï»äž±ÔÇPŒKHˆ3éñs—ƒÉ+ìçý-àgý%Ð?UØÐˆÐ‡I‚Ò4~ˆ˜”:FTmciE~ð•<ªr ÎntC£½ÿõуh[ÊoIH™Ð:ˆ$¼™ ó*.äJu´•TÏ"$: hâõÈK{ùž\NPÒ• g°ÇL~â1/>…÷«âås¿W¨Â–µ< %úÇÊÇ8%‡ŒšCÚU‘ -ä³[Ô3ÿadÌ&ŽÔ¼£ ù(É´ÑèÈÛŠ8½2N‹9KªŠ«ÞÖ»~¥:v䛢EêjVŸEö‰†\þæ ê°\\“~˜ Úå¼ “¼¢°ä‰,ÊÐy^@õlZ»&rî-d¶¡À LzÒ¬ä%Ïh>–YÎí¤x¹“¤Lf)ÜԦΡ9Qˆ•sâÔÿH°‡ ‰3}€%6p/%Šæ/ó bážz%H5AáèãN¢Ïz«ŠQW›QJ¬`¡´¬ž+ÍŠËIà  Ýg>ª@ua†j¬¹dZq×Qc¥óäànpwÝÜe×7\锨¦Îá¤rVÑ3Ê’ž³¤È6 ,D¢U„t¤u~…y–Êè?„ÀDø¢; Ô8)0Á¤!}*à? ê]&”«T.úÄž¼"sa­%õÌ:YJøµ6ñl›²Ñ`æPitÍ3iTŒËx 42£xtJF3ŽqÕ¦àÝ!ÌwVé”Ú¦Óà•'æ-ocå;„ú¤*ÿ(À;yòªÇ ‰&0©ác’щ.4ò1±Üó©‚ë0[«µL¤9o­à®í?r©a°2ôÍýÛí?l)aZj.£ÂuXH#b?¡qW"‘›«â^ÿhF‹AI‹x@:&‘v³K#x½©qïþ‘جjx0yÎV˜|7Þ¨)CZžt>1Q'&³e«R„R¶ËŒ ýZQ“|@<ʾTø„x 8[âML“Ja [M±­›WPÛ\ºY[½åD«'Ïh¸R³#¨ÛÊ“d [5 @l~` d¥×À"F°B-EmÖj[Â@ šÀ8%ü4ÿT\•§¨Ð*Ífò¬›‚ІSŵˆÑJ³‡ó<{èz‰_b’3Q ¢ù•—¾§t€Q°–M ÈM—®b¶ÛŒíŸ…Uü·,É gÈR–šƒ ä„Í>ö=ü3!0Ä6€W•´Ä%¹×Ê9£ a¥Êéqëc€¹'Ç)e2ßëúGfWÎÂuÝGŒ7%ã6gO\û5‹ŒÜªÿËY¢Æö¬å=h鵨…˜ÿäC1ⵉ†à¿ž¨‚‹´­¹c|ÅŸ‰Õ•v¶ó…-*OÐ÷¬¾I{¢ÃÔµQï¾×£N2 ¬p:Véw×é‹0²Óà¸ß½Â–ÿ·vŽ›]ãµæ8t‚|±/»ÖB¢{óÒlêÉNžíÞ™®4øƒ„ø0çú%€´ƒã˜‹à2WεÝìfXò\–5+õð¼ÐžPb¢E¯YÃØ“`À$…º‹a÷•º—{«µ¡=\>˜H>b;ç#>»;‰â›»SQÀä ¨²Äˆ`A™÷è(…8 è ȱ“ˆ˜¨ ÆØ™ÙŠ<ʳ-‚¨P…ª%:“0ùkŠ c¢_rŠd’Ûh¨¡E†–¸ ÉÙk²º[,&„@°‡'|B(€B§ÂŒSÀB˜A‹Â-l¶¦àÂ/ºŠ|X¿ã»„@‹ö C9—ÿc­«P /z9šš4; Ùš¹žX䟀³¸0¨°%Ù:¨›!‹-¹˜Á`ˆDˆ ¨›àk²­€‚&T˜'ÜÄäPÄ™(C É×Z¦0 ƒ ‹.I™†øÀЙÃH2 ıŒ¢€_hŒ5›¼ )‚´¢6sÁΣ3A´%p‹?Z²£`Û(ÒËC€ŒB[§“'!†˜ #†§³‡xÐB((€p GO,Gl@å`“ÐP AzPu\w¬¢€Œ@„™e‰…˜‡¸™q¡ –c9ÁE=ãŽJÙD³@„ `J¢* :±²(ÿŠÊ3˜ ¥È%Ș 0úÔCªy™¾F¬ÇÈ¥ûúhˆ£G©€\¸N$Es¬Ét„GœÜxüx„›ýxÇÿhŒH2‹‡‰0½C ¶/’äAHÈÈhHÿÁ`ÌCF¼ Ûª@Ì"ΈKðÊd”%úk6 9”å¢ ЭÙÊ…X³Gˆ—X€HÒD˜BM´IsdG½ÌÉžCžàB¿'<áIÌȇºÙ±ˆ£ ‰`b6Ä3¨ˆ‚ Æ;‰oѳ“Xú‘H˜ žÈŒLàÐÉKFŠª¨:ÆÐ‡™ ZpÑ¿Š JˆUP…5s‚Oû…K†k¸†føºQÿÀDG¼\,v ¾Ô˧8δ©x<‹6x€B#¹Ò!¥¼©áò §äÇpŒ›ðÅÜ Ã:i™ ã¢þóJ§èŸȬÄ8 ™€ A„¸/ «èÈ…6È…^øÊ¨ á,Îâä½LPž„ AÐÝÄæ<Še ¢ !ˆ€šHŒ¤¡Eäa¹œy Ѫ»–ÉìÊ` —|p“.ÂÇü¶Zºp³€K°‹rŒ½‘„j7!ÀQmГp^€†À‹èImBæTÒ% ˆ½Ü{ˆ¹¾i…fhh† \Ì–»*ÄK¨ž@„_ÐL9á¥o™Ìÿˆ–ùÀ`ƒ'ò}˜Èpƒ !ýÊ¥Q ³„ʬ¯°€½JÐ^ˆÿü‡¯|#åŠ6Î'åÄ•ÔIí‰<Îw¤‡t- ­ŸA†iÊP”ÏÿX«12¨à¢Çˆ\—6¿ˆÕjÑkÑ+ÊŸõì‰Ý­^ú€ ÐÛ°²f²ˆü„3Dý‡6pKhh±™Ô» (ˆÐ¨¨ÖµT…Ñ€¸T QÒLPÜTÍiçºÐi °€òÄLäù€\hQ9t ¼ãNjÓbZ„&¬pÑÉ™9Ÿyý9‰=‰F9X¾áŽºŒºòuµ3Ñ«MFˆÿDeV¶4Rû ΓˆÔ6°ˆi5•µV¸NvŒœloå‰ýW¿üÉ‚©×yÄtM [בó z%@×U­SÕ¦~Ì>?Y­³U…чÒ-ø«(J°Ñ‚CÝ- ºz.FY×ÞŠ(@·ÔÍÞD É$Õ€j­Vx<[vŒT³mÛd[líÉãtÎ;áI)%Ù&ìË–Ý[žÄ[¡}ÀÒV HluÍšZ‚é  È*ˆ‹N§L¨Í×þ ÌœqQž Ÿñƒ‰õÃÓ“ÚS¨½GbuØV˜Yv€ý¹‚ ГX3°ˆ`„nµˆ6P[´mÛÜE[fU}Ðÿ»Lq5N¿ ÁÀÌžÊ&ENæ]^çMNèUN½mGþP™‰lœZ¸/l è¥1E(}`K7¬œ¼É”Ïæ3:‡ù\;SñÌ9„EÖ=ÅÌhD ||XWÕÕ°W¸è…¶øX–¤ÄáÞ³ˆ³­K³•àÞC øØ·ÍÔé}P0Mœ[ŸôpÝKæµ.á;)ÞJ]aIeÇC¤‡™€ ¨l|Ka¨mÕj± Åð%k©WÆ»Lµ‰S[½Ü2 ÉZùŒß¬òZ§·K‚KØ€ƒ­ÚÔÛ P4v­Ÿþ¹UøÊ½Ø¶lË"eI!ؘ%ÒÄÿÛmÙ5> (ÌeVqÛæàl}àÅÅ$=—&íã”]^äÄ[S1 i «a|A €’ø‡øÁ}ä9ñ¾žP°9Á1Åãè, ÉŒ‚kq“W= _²ÃD¨µQ*¦8‰ ü-¶3±ªÍ0þ™eeÖ26Ò¿ÒD'°K(ˆT(øåý‡^ÎàÔº„`¡cdÆÖ¶-Y—­Û–^ANa^æäNˆµ_0\þ5M<>ó Ÿí¢K¶Ì:•“q#µòì/p‰LÍ•HòM“HÂ<ö„ ª­E)Õ,V×P]Ùc‹¸„Dý…5ƒßü‡0S$Å]WÜ„‚‡¶ÿM|caþ劆ຬË7Îè¸}àVŽN ÃÕÉ>î[¨ÐÛÅÚ>ac¥a#†ûj…V-3A_Õô òÕœ:§q"y 5ÿˆ¡¶Ú ³­\ŠZ‚Zû’?`m… |7dðçÜ\˜c…m…LÒDql§pÄ8rd6»¤h¶^k›Âc®KŠV`admå ºþV žæoåÖ  ·FiÃMQÍÃcÍõÍóU,JöúiŒ†$Uˆ—!=¨¢Õ‹C¶ì"­ ºl³³(¶öë–lþ\P×úypÜdÖþü…‹í-…`‘µr­!Y"'h¤Œ3Eÿå3'{À8[¸) nã¶' Û¨ðB»SÎâÙ¶^¾í˼fÙ`F †fum ø€ `šv‰%Fš м ÑC:ÝA‚° Ì‹fÉ0oîÔ3Ì¡3§Å+Γ¥V:•…µ¡Ärdf5è×½efWc•uZ¾áð8¬p-VÉí!a ¿Š¹C87Vš¤BÅÉèq/ñãŒî“ØàSAÏvUõ€Vàù>ø^p¹Šj‰œžþ`¼£ò-OD4¢)ÊyÀ•ìÍïtA>ÄS…êúYfza¨ò×Q…"@ð^hÖ6(p‹ø#ÕXTÑÆª%i,ÿ¢ÀpVY+¤€•ŠùŠSƒ_ Ùs,[ß5ñ<_[=WÐj¶`bi1„ÂsyQåîT@„ðVCû(ʰqÓ{7q‰¼6-Ꟛ`d„hSʶ:ñ»‹h’¨S  È‹AZ2+ “§S–§¾™Aÿpu³"è…_p¯Åõ“ð^hÀ…xË ®á‡é2ŽŠ©˜­yÑ­A ®ivq AQŒöÖà@NN”ö]žÄ` l%}ÞåÛúWNU¼V¨a!ˆq8ˆ¸Xà “¨z™›IjÈ(>¼(Çø¢‘Ë z…€ÀˆRúSç‰(B«‡mFÅQ!åwPûÊŸWÔÿÛtËDýÊ,…™míÈ ÛiX›àŽšVÈÈ,X!Ý sH{ Š~kºÛ¸‘N ÊHí]q÷›¯UÒmÌwa¿J‚í¶ _é’ƒØ×X}tÆ10œÑ‡Ä²ôÏó`;ê—QÊ å;¤QŒÆÛ2¿\’QF½ÁC-MP=©ØÀlüQÍ6Ø>ð“x…ûz…ˆýY”ÛÀ¯œ¨›b­£ H˜«#Ö@„:‚ Cö­Ivnüºn¾hC–¿ë.TÙ宿â5ápwRçFŸPØW—± 1111ýís“‰Ü¹ßЍö†6±8ùZéÚ‡Ä3ÿö¬ý6ù7S¶ü<«‹½Í6p1ŽbÝÏÌ“ØßñéÙáê§Ö¨¯¯ùÀ¯/ŠüûmåNñ.Ìü™§ü§A™[é¦ö”U…€ûŒq¤ßž˜q¦éž¢tw?iÑ‚ˆÿ(½úgPà ÿôý£×â½! ~˜˜áAƒ ¾Z°`¥>B4x)äIJ*7.ÐhៅQ„¼ŒôÏ >ü£[>N„ "=QØSFÿì¶QBw çÔMÿ\’ÒIÿ´´ÂGh$L-ÄitÉh.ôBG¯@sÉ/ClÁéu·žR7µ¥xÚ95BwÝ!²ÿåVwU…¥YðÉ·æFhéçš~öP— ˆ=ý!x…FO qÅOK@0dóÐ#Ùea†™fufPõ&%¦™øO¹O¼V@ù”úÁB)”‘}>¤¤cq<—Q+$'„0Â$÷Êh½lªã‘ÐD ­ …SÜi´å™2z‡U˜JYå–Y•åÙÞÕV`n¶)–\1ü#î\vjk˜aq%hŸyÊ¥®m P‚!ÌY ÿä‹áf‘nÄY ó”jЇN½‚š@éS[¥ T[hǘÐsÿT|ä]—¼DI>´t­ÿÔò“$Âh9rôË+¹Š ÿÁ¶ŽòÏPîd†`Y•v„§Ô˜H±wÔw6{g•Шڃ*ªçjĦ~ñÍÉ\RÏåô¶u˜Ÿ qXž6H öê;O òh¸lÿëuÄ öë].ÄXÛFúèãBR«’XDŸ–ã%éhÁ«t/õ®ÿ.üÓËŽ44 ñ!­à3 2à­UUT]‹•y¥;+fw[ÝPæÑGÓ§ôKkÔ4îXãå¹ÝÒ§`ZnônC~"Öµ»“©@.?-…ÀȽiÄ™F¶]½†Ñv¢Å"©B·*¼®Ðé?’ÄCüÄù«á·A$q|烈ÿ ßoÿ0È4ó¸BPF·DЂ$Ð9|DÁ`³ NågB+T0hªh)*:[]Sr÷ P„iK³ÝjW;Ý ¨waP äÔ­@Ù#P^ ®uÁp2âRÁñæñä‘QÛf.ô mæ!À=0$°Ù0D!ª(Q÷LÔ‘ƒùFa^ÔGP‚Ü‚®ÿø!ÿ±ŒÐý †Ø Ë$£2é­Š¼ë^ :œ%’ I1DVPE p´i¶ÙhF ’ɉ¢Å¢ö˜ìî&ÐJ§ -¬tå)¤Ã”ê1WûÌ*5®óE`¦ú NõUa^¨,°íCÂ!‚ýâR"Âß(D 2H§ô—TxÂJ@ˆ»Ur^‚È®¤Íø0¬ûÛW¨ŒcùÀ Xð”À  Àx R‹H–„¨ÀØË^¼xy#0Äb¿l/ŸùÌkÖ õÁQ§9Ö)%áeÍü~ •µÓ¬GA+‹K\ ¦°+_*¡C¯ÁŒ:ÌDB@ , "êÕG+bÜþc  ª\Bð¢T,aÅ! H–0òl#€CÙsPS8ì.w#xÉK"²ê8Î ÏFHDÄ1‚Üdˆ ‡”À*»âRÚÈ2j‚ \`Ï ½ö:<Tmû©>ÿî/«·ÃxAšÒæ÷žkÌ#lÚ'Ím0«ùÞ.a€Qň>ë®Á‹úðF&lá» J2ú°î`F[…$ô Ç ‚ºÄÜBÄ¥ºÈ‹ ÍM1~9*qUãê¿è¨ÄVü7JXW¼ö8㜠ø1Ø{T….å°€¸@=êÁåTÉ ÓžÏ?@úX¥›ÀI·³A˜¾ík3­Úë$C«-­oÒÌj6·˜Õ 裸ߛÕHL%¤h ÉÅÑø˜ÓŠVX W>ÒÇ)!¢k@QI1Cgº g©\Às^}À­˜4‚ѰobU—T‡&ç¼Ëaò“ÿ^CWÁ~q¦¶i{¤<¸€+êñlƒ7HéH'0RE#˜ö†=ÓÂØ£ý¥ŒìWœR_áŸ9ì•·š%KîPÞûËÿÏžk á¡Kízø]ÒþM 9ÕFç…@è"zøßðÐX‘ÅüUq’ÔÞèØ)ä»âQMs‰WÜ(V–S %XÇ­™Ó¬X@W M!É ,ÌeA üœAÝ? FÔÂÀ?”À?ÜÜÂ<ÜÂKÉ^ÒÅÔîÙ^¶<^ ÖðÝÉ—•Éœyœ)нýƒ· ØØå—îhÀá£0¡L@DÀOÔ0üÏý ÂD°ªøÿ@Î]Ós Ljü‘Lý‘ˆ*ž‹‡pH^ÜšZjUI„„u%,ÀoŒÝHͲýüC=ijeÙ–ÁZ‰`éµ#ðaÚMÀ-0‚: 0B b ¬U œÀZÍÃZ±àaeEÑÀYÑä|i›‰ÙѪ„™€iDî9dDˆ¶@Ï]PÀOauE@ZÝÐ]äƒ5 ä|ˆŒÿ…H.*•S|üèàŒI0ÙüÄʬÙÏb^IÀØþhÕ$E§¼ÏÂÔ†=DLÀ¾Õr™ÈhÄ@!ÞÅZb!¢ j„”­ã ~G ²›¶Ì—zIм9Å€åÿÞÔíž>’ œ €ô£}!O%’°¢FÀQ. Š¹„€@.lP3n„áQý9•5)ùäRšI HšÄ®Ü@\Þ+ÉV‰†2Äö ŠDÄ[¥^®žx]à?¼Õ„”‘" âã: pàÎm„²9b•Ò¹èU(áÕuX ÞÎFŒ¢îi@¾TVš"ÞE?ÎÃÁ:ÙOÌ‹¦“SøÀéC.DoñßFÜHøh„*\Ñ×âÏ :Ù‡ÆÌJIîæµ–Ç胜ˆEˆZ@œž+d£FÜá?øQ$ nà¦#9ÆT[mDQ ÿˆ݃ÝÅ;2¥|m –’ì‘ SX£>ö£)ÖJß<\€Œådþv´¥\&=À†Ž\Ã%¼á/¬Ê0ãR™Hþ̇ôVD^SqܨLŽÜÄü8…qÉJ¬aq|ÄÇä\DÀßYÜ€ÔÒ¡7vãnúÂpÙ-8f²Õ]€Ô-¢}$ (›ffjf‹—…˜M%œ #Ð âcu|ÀÿX@+èùý]|TF|%„7¡Aàâ†ÄåÄ 0ɉ(“Ô¢ZÇ“Œzœpp§øþ¤¤ÇˆÞí8–þÔCªgþ“FÐLv fvÿ }nD8Š#¦cþCiÚÇi¢&šÁ !€]U%œ5(Úñž˜¢æó°Ç̹D+äÂD4„œ°e\ÂCND „á…Sq„FP0ÄE§I~$°XÕp\ÞVå(ŽjQK0€ðm ¦AÌ&¤<ÛêiDˆeú`f}Š`OJÝÓ9Å-¤#hi’æ#½Î ¨™¥›]éV%€-è¨nÄ)‘ ?îàÐÔæ=WÂýŽÅYƤ‘>LD[RGÖiÇ€\Šju8FÎ4ÉháP^üªV­!Žz„A0@æClüHÉá é?\ªFÐc\2€À-”êUæg~þÿÓÞ¨žË У«b’"Õ S€"}éyJŸk¶f˜Vå î*ÚMD÷Ù̽BÙH1QH>ˆˆ¦ÝÆŠæ)PÀãI“ާ>°(÷(k‹½ßDf‹÷)ã9µl¢~ Á B>¤PôªA¤'J :Ejh„?Y¦fšjÒÕk=z)Hew%›A(åaõkjFíš…˜É› rÔì­Â^V HWd„´ømÞ$$}ÈVP ¼Ö?´¥FžO„À†DùD4F$«©Êq®(Î]Š0Ö)^\žǶ"*þÄG(ÄÌÖìöEÈéÝ…”´§ÑÁ•A¤e.C*hã’ÚkfÞ‰Êÿ^”òf”¦`Uâ€ÎGÕ†™€L%LeËÂ6MmnŸFH€ËýD+¬€¼d›ºš(áßEAmÔØ?DAÚhF „Qõ)ŽqŠóW-FdŠ>“plJᜆ¡²„V“¼à¼´x ÄÌ6.ÎÒaϪ‘f eÖða©Šà!­(>Ò)Ývn2í ÔÂã¡Ùòýï~™Ó °}X%eèãDìÛbåYXã¡sÉÈøÞ^ˆÀ%(¡^´Hª@d.$ïg(¯äxuÜŸžòVɲ¨@<àj„¼@ÓýxŒVÄ9 F€+"„e¤'êÙ`Ð鬔¨ë]Ä•/ÔB=ää|Ê«½jÿKýFªd ±R&«^©îpÔ•zÛ‚â½9ô)lk ä(Îf@:Æö%Å®`Ú†¢mäCäméE¥pÝØM[RQ«=BÏát„,§õþÊH¬!áwæ¨`z'Ì’"`ªð6Þ$ºF¦zö,¦^ Ñùkf%ð(’#þJ™éî/|)Ÿÿn„zimÔ!(^Œâš:…c¹&íN†¤d+¼â|8Á†èËEÈ­Oi„ðÐa„ùüB4žF¼‹¾-]R¯0šHJ²3’Ä÷R3 ¯aA‰@ˆcN*nÄÔ!%³§S´§/Pf]Qiw­ÞkÔeß n¦fvÿE|‘2 ¥²™%ÝÀŽÓñà+ç*®Ò@#Øó0æh‡Úb¨Sø‡^8\ DJèKCDú@«3þ\Šþ"à Åøâ".6Anᚡ倧ŒHÀÌò@cjDêiDùJ²S—“v ’šj:lÒ¢Ò(/âF4ÅUH±~ðÿnéÕª{…™·Ù[ôÙÆ¶µrÔéãÖ.0V#lÍËE°­F´AµDOÏ…DtC@LùœÈ³~ýÕeF_SŽ=¯\S“°ðÁ d¢šÓËž^°á¤Uµ5f6i$k„Üd ]9´)Rm"LÑ«ìià>þ"ÿ5 …Ò×Qíò±®SK€Óué}.mì#Vãª,w±ÃB@-k•4 ‘u-)SZ·@Dç‹…XD1£¨ÅhôÈù^&—ÅØå+t6ËKGà(sßEJ¶DŽvSì.6–ïΦï.öF8vdê%ã…+´ÕZ•®væë"í¦z2 RêFeoé–^ñ'±nµe[Òq[ÓðÊ"kðáÐiR ­FlnKÜ£4A¾ _/FÌtÊ B\ÓpåípsH Æt„þ„ø÷þuË"òG(òbÎáK'é7ßì?€wßE=ˆW»jÄ2øBèü´Bhc D™A”j;óT~Zÿ6çvîAÙs¶XmS½°ToDôMuÒx˲ôôähš€Ô §ExÛ­È„³åȺ5«Ü%^îqŽ1ÞšS!o‰wDJR¤sŒˆ/2Îδ6j„8׃z9×äÏât-$:ˆW- ’fBà’€fC€Ï•àOÚëeŸc_y¶ÓL¥˜E9 ŽY˜)wÛ¼U5‚õYýî#SÊ6B(äôˆ]Ô‰´@PF¥8Añ†† àQ [Jtzl2÷]xŒ*D€@¸}¬aËÞ¹@ÂbÂø[!vÐQêÍ:ärãÏVî¢w;\Õ‚/Ì\+¸3g&1¦ÛkPþ!~R“kD *õÍ´ÿ—êvØ™ö”óÙ•¯v–8¿·fU;ÆADmX†Y³‹eô…\躩TFP¸DkBD|ɺ¥}H<©Dˆ o|JÇ0²GK(ac¶8^¤§ Ÿïb³ù¦kx‡7‘2øB3`®+8À”€äü?ää?Aø¼½µ~f)·»{½£·m)ˆú—A5•ß[ñ™O³–÷*C.@X¿2^̺^غö¯®·ÈÞ<çTá¥/R‡ùûq_ÑRYwjIãH°áá–Dˆ[Š¡ÌÐßä Çx=Ä4¶+6¡ŸïÊÝvW —¸#C|¢ž¤§ AxK~H>Ĥ¤Ä¥ÿ=œuç۽ݟ˜…b€Eµî¨ú¾-lGèêÓ”ÀÃ"Ÿl,Òy¶e„†ŠöÖ]>Çh¬FĈ¥àªïR­Éh|üÝÓ=«,2c¶øbó@Ê€+x÷ ÿùÉo„w_?öSòŒ‹7!-z*”¢':2ÔBú×B*üÁxÛ綪=ÿ•ò‰6h0˜yX Ä ÿü0á_Â*œÀèaDF ÿEl1aˆùüÓ§±aÈ„ôþih"J¾((£x!B•ˆªVü[áæ*›ÿ^ê)“gίþ]ðjÁФEú8ºÀ)Òš6o¬ b^<òpeàÿë¿z ¿Ös%Vä?jÙþ;à !± üKP÷_­ZÈ|õíûÏ༩~€(ܪ†Ò6v²Â¿È I¨À¸‚å ™9k®°9¡„&\HH±âÀ†BtmQ!CF?`üÇèß¼õ¡NkÒäÈNþøÂI¾úr‰ø%“¦B§ªT- )BßÇ\¾y®Ð™Ð¨R¥RNí~%›çoü»!¿ølϦ]›Ð¬Â³õÖPxà-‚K¬zæ2­„@HE¯ÆjI„»‚{ à !cL5Ë<äl³-›à³…&€ÄÓb«ˆ¢‰n“ˆ;„¸Ã(„ B!)å#‰ÿÇáìÑȉ”Ê%ŸœãI•"j¢n§júH£HJȧ_–œi¦¤ˆJ訆Šê"øg©ªùà…¸Zë¾¶Ür¬>µü3 ˆÝ2¬zLK¨®»ìR(…j éÁñtЄn`lQ 1dŒ1‘&kÌÍ6Ch Ud´Yc­±×p;!Pq3$©Þ¦l(¸„€KÈ äòù§¥„ZÊÅ'*ÿq!¡—z‚’ž`«Uçœü®¨¤:*©šº$o*'Û£¾ ‚+²ÜÐ͹2@¸¸u`NW\™k¼M(Ð@ ,¯Á@˜B÷ò™HjÏÑÆ"›4Ãÿ1MÄÌPœŒÿDNš€»\CͶ„ •µ|Ú;sU‘4 ©…xüxJâ¢9„’W:¹äTnaJ”Š *:2׋V©dÇë訚Vh…L}&¸öZ‚HË¿Ç ¨ç­†Ò<Ïý ¯ ÿq7Þ„½zê¼ôô¯~½~lRC– ‚Ä&øƒÍúŒ¢É:]ˆÅÆj“ˆ5ŒF]ˆBdŒk(㦠®ã†š©ãÂ?Žž’£Œ5 †^.¯!œ£Yg…j.‚ °öŸ¡ºh á ‰i¹ü'Ý?ÿ™·êD­´jBbŒ‚ É]߯Cûv "U2….¨Ì³ÐH‹,m†÷\˜!P7½íÿ ‰\Ó(b„4m…ôù1{ò±G¡:Aå%o¢ð&îq¿ yÏ(„\ìÏ×\gÍgÿDÈÜYæq™Ä£¹diÝ€ê”Ô‰Nöq`Ò‚„A¬K@ëê»×µ+AC%»¬…0k ¡@Ù|÷˜Þ%`©Ôg8s¶„\`4)JØhà&·…ýðE´YM¡÷¾)EÊÕÆHÒ*õÉ£ îKîÁüãXTYýìç}<çHSiˆ>¢à/ºàK:H.’Ž  Â<¾%'Ñ)dþ!—€Ürº¢9À¸Ë\Ç'žñ¬!°ƒ„BBµ†4^ÿúÕBI5Ä3•Qgh¢ Œæ¢ØA"ƒ± qEyHm~87‘LäˆãC„ø‚޵Š-_cî‘E p`‹\ôÈ/‚²$ïÅ‹¡’‘þQ„ ]NŒV‘ |Bw­Ð]ó¥cÓÈ•`@\ä:ÚÿDÈt¥«êjÌ”G6&w–t ¤’‚xÒCH˜Ìð,%QJÆ!¥d؉œÇèEo í¡kÂ0½I@Þ3¢Á±\j '8ÜÒ‚,þ£p*ûG.ê—bR@g4¡‰3u5+ðJ&+ Ę!8ò$w¸V xŸˆ-mr „'µ Ë@CH§ÿ·ÆÒT Õë‘L”/L¨;Þɳ!û, ëi™ÐTJ!*ÈÀüi¢RFfOaH¦ZÉ"éáf•YQ,á¨) !ºœâG±R‘”ì~¿øby~¡ %!¼òˆB€"Æ56(AîÎÜÑ?L+][HpMže-æÂÏYε: yK$#$acÜ/¬jh /Tb+<‚„uR^Mdê©)áaC<èjî&’à"âp¬+IN€¾,£Yépó7êæb˜ØÕÇ+tV؆%;‹ÝUc5ÇÉú*Ž<Ú‡šÍ¤©!¡‹¹P«§ý£´G{L–Ú©a¨ƒ±ÚîÿLÉx¾–2Ò¤¾rk¶´Oy( ¨š6‘6*ªˆ†ƒ 7”zDµ)=Ð',fq—­¢+–ÕOW^$¦Bˆ‰X]…$ŽÄÐym‚ÉV ¾ž}Ó²):ÑzK¿õ1K}O«Nº2$줃²;«^Á[ cž§»PV†¡ôêB@Cæ´E!ÉÔAeÔá¸Ud‰#J}‚ œ€¹ºL^W8'´àÏ‹R­;ã<ç`ôŸ_rÀÇÈ”¢’%Jð^ѨtݬE{.ÐÖ1ƒ¥-­†ÒéäF¹‘"±òª')Û,ÂÕŽùL‡r0¸á‡(J³ñ8<Üÿ†ôÍzcŒUz#¥ó .7É\Hsѱ–ÀW½ÂÎsdš–\!³t4dg™»É.äsAÀì¸Ç¡Í×,õÁÓÑØ’¹¨N!õÅ “_7!';FvnµB ÌÂ,ëî1žaW'ƒÛ2Ÿ9”$J›®%üO÷†q;ßd*¬¤Ï!eYC\L[®WÑþb±ŠEÌ+„ä¾ JZ[ŸÄ>A®Ó ŠFÁÑá÷,„D-H›z»ûÞ!é ² ÕæÅÊ*\5%ÿíµá¹´Õ]òÂê4‡á÷$AʆW˜ úhÅ ñ=zÌcUæÃë<ø 8ŵÀ–%£1• Sÿ Û ™¥[“Ö½ì –6ä=&ÍÌ“búEȆèÜñ^¡ºØIµvº‹é­^¡ ë¦ÏSR—L™•\Ó õ¸æá¯ƒ{晹ÃÄþÀ”Ю´'äÍåHèáñ‡8´ÊvQ>ã#¡œ'ÅêÕògÙ|™ÜTe÷çJðžÒ§K|.;4Ñ’z]"ÑycÒ‰ê?áåèŽ °ª?ßôIr –"È'q80¶eŠyþ,ÈWÿ´˜†o°X,pù0¢²Ã'z#> D#¸ï?Ž 1¸…> Dë!òM+ÞüKÞ1èük)!2†€éü …1ºlËþOë¶. ‚þâõÔŒ  B a*4‚ŽÌçÎHÌöÇ£$#Hâò'ÑÆðø(Ç%Æh±À ¢ägäᎠûc@èd-¸‚›ª´$òXç1‰œþ0òþµøÄP&Dýn§ÿUȪpàÑ1„§R¼Lw„P;Ä4ž'þf­"èÏ1"$P ‰7†‰²V@¢d %ÂkåxâäÀ ‚No+ªÿ!ÿœˆl@xÀ¼â\Š‘uæ"瘌¡Fñ#èt®.ÊÏD¢]np„r ¬w:/ò ¡"SÒ…F“&q`È*âÿFáL#&®SDƒ`<‚’köð ùŒŽèáGÇ ÄG#øG%\J Ë%-ÑtÅõ?@îxäG‚ä’!-è?„†±T‡©qm3ó’O–êÞFè$ËG7õò1$1$öÂÊŠyB ×F”–S tÇÇÁήKÂUèÁ$Â'ø\*%ˆ/!”hW:sŒâ¨ Ûð4àPy„°btJ5ÓÄ]Ó›˜çÀ¢M d,ÔògÐÝ´!8#,ýRí„np¶F2žl߆ÀóŒ“R†“%o«¬Œ§05±9sH4ˆGxâ 5HL8Z&|"§%\J¼@Œ±ÿÔåoëp± ƒ4qƒŽjTóVÓ>ÿƒ@Rð[ÄReP]2r7uÓ,ûSè\Ç[ŽÎQ˜ôI’éŠSBO$Ì‚gË ¬ŸÄlëf­ž’mv0Žæö¼ó8T±ËGꃞƒähe4Pè!>ª°TÓ‚r´!à"¾OM”Ì+2H,†”¿’1Qç¢iÐ7hUAÔw¬ló¦4C\íJ±ÿþò/ÎžÊ ×f­™31õެsVÀ$èÇV"37"Wp…<‘/ŽR44HÓâH3ΰg~5Ù\Ó‚\.šFM|Ô+î#NIŸŒ.úëOê‹ÿÿj"„Iô75D.gë1Uü,ñw`HÕÆjËĬêŒÇ«:i“B©aR•C> 3Aâ4_õU[‘MgE»£M•‰H(B `' >E°cJ 51€ÀO½‰\έ>¢+ñC.žÕÝ"¿ø+Z…ôiê‚#‘Ø)8ßãå7!ÅA‚!”uðÒeOÒJ!”"ôkdëËV²_œ2Äuôì0IÏ/="Žn5X€2‰Æs<µ«VƒôAI³N–~µ O@Ja_€¯B‚D‡+¸R-²…?´%üþ“í¢u–ÊñõPÓé"Ï6èP葨ìA¦fPRaw ”ñRYM8ÿ‡ðv(Ô’ª®[ò/‘óB EB5pM3pËàÈlE¬ñVÁM!çG\JŠd9ö•_W„!jä6 ÷Jà^Àİ’ŠõÀ‚øû€*¾ÔähŽ1C$’7ÏIc,©tƒlð~£ŠÊh'ÃÑÊæ²l‘B#¥#Ef_Vž@cT ÓgFëH5þd²àB‡x+×¾4]íO†åHsUÂ'‰R â ·Ö J9~u>BÒ$5sÔ‚àV×uÁIt)t>Í>XC0v›ª8­u#wýJQ¨Œj(i.‡0žï‚uÓJ/@ ÷ Ê‘fƒ 6LœsOÿöäDö„·ÒU&qk ÅÌ{aØS=u|©3UATJª0!ȇ4 ²ßH$0‰d9¢„4%; –RÓÄ^àà¤X!\÷Ž€t¾IœÂ„ ÉüÊv@=6I¡ÌII¨ª pYv…(ÃJ]ȃikOÄ‘¶ÊÆÓÂÂ0ìô¦TP¤á$7¬TÞjíyüëbxË ­êI9q§®6cìá ç%Îô‡ë4r¢‰åãâD°›X!PwG uâÄ_7P¹¨hNðK¨ös-è-HÿsèøÄSkµÒ¢ngGwfö,yAGóHRÁ,„çÌVƒ ¹TZR…ÿ—°*6 “Ö*4 †0bh +°³e- “X“¡ò~óôW[ Z ‰UsïÁ5ý7NÙíÐ*h67Ë‹g3?|ô>~n@Imwý+/ϘRúP_X–2’1ô¾±RBø3޹êB/ôºt`ÃyRcÂLÄ4âLÂØñ Òªþž§D7T¹#&ûR]óB}Ã/®xØc~­1Hb°â¦[ààùŠyñ£öžÿ×MY@ø×*áâôó½ÀÅ‚L,>­Ý 7Q«çîKCÆQwYAÝRÞ˜Aƒ$îGþ"nô 7âÐ*6& ¡Øú/âôṲ́A%m€¶¬ÿ@ÃCÍ ¯ Y5Xc: :fgi4JhO8î”§"¨÷7u±’žIùž1©±RábG!\†‚"(.ÌGÓBÉpsÔ UeQüDA†×x—÷ñ$‰¬­t Òš†Âlô*€†ôÉR†­ºŒ5 n@åCc…ÕÑ%I¯q®4,¬{ Â\Q#:Á턚ÄÎí¾›jµGèÈáY—ä½+ˆOW÷žÿ!\³½­r!‡ÕaI›v™†æ¦zN†&? :ÇvÉl¿| [(cçxÙeý¶J_ô%·<ê:É¢‡»ÑJÂËl âLq?ÅHzFÉŸœsRR˜x&£zÿ{èRRƒp{EÐ,6ê×jÛ.!xX±çXàÐ;½²¨—¤Xa ¾3À]÷ ø›<ûhN?B¿ÁåN„ ´šª  š´~Π1$jpyôybCB¬nh†.ÉS—™4$Œ®%î7,$J¤ ‚a41DîéŽ1 TN;ÔÅÓ 9“M~p¯½íLÌÄÎ;!îÈïA5}œX¥˜È©8©±2MÉXÅ…É»’Nj.t˜Õ\äB–gs–ñ+AZûµ<¶œ„@p#Epym£Gx>ø·Sø_Úú†0ÅÍS•þüS€-λ‡1Q&»¸ÔêÃ‚í¢ ž ½ÿSÓ‰s¼!z©XåžOÌ>©xŠÛûî9\w}Q!ìphhŽæ¸RñO?®ú>F?f³µÅrJ\µRÁ4Z=CˆÐ¶:š…Yúpj aFzatÝ!jXzòœqSäΓ³™O¸¾1ôˆ Ý1ž}ÜÄèÛ£¸!Ú;î™È"ÜWÓ*éÛ*ßk!YÓ?êäÒÊa™´Ê¢Mؤ6Å2˱‡ù1¬´ƒ!gÖÄ'ƒà'\Â4<£¢þ&,š?ˆt]­¾YCÓÂv-¹³Þ¸ ÎldTø Û{Ü7ž²Ÿ7¾!¸]!2@íâ½IŸWž5ƒì©é½„L.¸øiÿewÞ’Ø2¶ÿ /· gÉÕÖ¦Ë.:Í›§„QÄéKZÃá|º+ ìØÑQ2ú4ÚÌkVbä£ áY”ÍÞ³±(ìùJa={G@$ˆ<Ÿ‘|Gé“5OP¿‡L-"È@Œª1p>›õßÊFZ÷ 'Éñô]5fÈz/Úƒ-Üg‡{ò‰ç »>é»>ØÛLÎ×<àbÒÍcÙg<>p#oèˆëÝÜš¨³M¹übu¥˜Ûs Š3 ÜGނ曾÷¹e\à²BbaÙ‹âŸÀÿê4H0¡Â… ÔK€¡Ä‰ÿ( IhhÈ?C†þ]0tAÂÀ *$iò”!%” ùÏ¥Ë ÿh†¤‰3§@š;ÖüÇ“âÍ@ÿ¥H#ÿ˜„0á£CôIàÁByGîuÅplW÷` H þxðïÁƒ#/þÁàCÝ{ž "ÐA`‚è*áa‰õ Ôsõ©d‚\Xád†‘’ð9¦„‹"=~ ‰ÄåçÕ [Jx2¶Lد~¸0°ô¢ŽNü°;ªBá • 8¯£yŒ¤.l5$È ­\ÃÚhû¿³ÿr¬U+w ^ñ×qð½Áÿ "=AÃÿL1rÁÍ’ë]„H™AšmFAEuFj"Rk ’Úµ”ZÿKÒ&Û œmQixÁ½íæ’dJ5%RN!GsÇ‘°ÔHÎý3DÿôõX: $_ ©Õ]xÙ•W{|µ—^zÜÝw{óýs˜<ð·büi4 ”Ø–[H¥gMS… 58Úk–¦kÊDÓm5upP-Ô[ž»%DÜ@ó¨Ø\sÁøO‹·@0 ÿ$Úç~C€àQ]ü#Ït[QÊãv÷„Á[o Ô–\G°°ÝYçØ ç¥·Ývê™GÜwXbø-X”@†`.ô–Œ…ÉŸHªy´Ñimª¶IÊt’Ky§!µ) ´TŒMAMÀÿq+Zè<·Ì3йMµH¸4 „å”`€_¥õxé@eu —@ýÒÕêNª—äÀñ ¹ä^ŽAY_BøÙ§Yb’ ;QD—ôë@I1E¥}üÙJ™©`…¯™|¡lÎ⤧†L)ÕRBå-Ÿÿ4¨R¢ ㋉7®¢ÈjüO­ÐøB_ǵÕ©×áÛ£_f=Vq™ÊÝy¡Z°xý24+}SÞÊ}\ô¯u\ñÆü!(‘±¡ÁSjª…Ô`…*¿6›³*PNP5óŸŒ(*3SÚr»ÐΈ¾¼¨¡É%z³Ð)º‚æ Õ3e«LÁ…»GÈ#Ï=^ýsO¿|ýÀÿ’¥0{¬Š·^BwÝØ×®‡`¶•„]åBj£üæED£ÛbNÔQG£­’IЦ™šÈ±å}ÒI"jÈ}÷ÞsËxSɵè. áÜT¶ˆ²[¨@?+J9º×ÒxAçÙ¨7:….é¨n‡¯O tEzzþ§½œe`›•ðãŠÂü㻚HcðámŽ lSˆÄ6ØΰÉywHþq”„%{{‰ID"’ˆ¨Ý ÷lȈj(\;D¢JP‚D9n~(J߉˜³(Aç8å"ŸrÐÅ”v d`"Û{Ž4¤%„:¤âÓþ‘¼ 0Itq_^0« UDRÿf%A#Ù‡V ¯4S+å%ÄKïÒã M"½—¸!J‰ˆ€RH%%£Ñ^ ½÷ÈíEÒ†Ü#†n1Lj)HüG#7¹ãœë‚òÓr–îø)ЉØ2¢E’½‹ m œlj!%@T\üõ#` 7ˆ`¸&Y`v×1f˜º¼1™µHï0¸]=æ0¤’C„åǘÜd…51IQl²'¢|‘3 Aô½íÝð{”ì#0 Mž Fˆc¥ûüY(€ ñ“ IeÉ'( I`Ã``•?0ê…)<8KzTš°€&p][³@õ,D0uáí¶ÿÖLV&lÓ4[¦nbf1Žáæ¢*F$3õè BŽ‚ ¬ó'; ‘O2Fžñlj7‚£tÏÆ˜ÿ…ͱ¦áTò¶T¼˜¥Që<_OÅÙÏzÏ’ô­}ëkÉC‰öpBngMN‚aË€&„'`-CRÛø=\ïH.à é,äÂÉÀ \a?³|Ø“ˆ ¾F[9€ˆ4­‰eJÇŒx9Ë’¸ó@îBiŽ:Ž`ÆŒ,Þdžÿ³T¬’~Ôz¶Cnk!¥$H¸Nýdî¡:Êhõ¡”’_Xg2ŸK0ù&0\Ñ8.AV"æx ¦­kÏç” ð ¨ð2&ZìÂƒŠ¶*‹l‹µ_š Ä÷¸S…áj™ô H­Æb ‡1L­v%1òÚ§¦ ãñ?d9!¼Ò Rc’Y…¼,F*Ì Rp„»L}‡c8ŒT´Ï(‡ë!ØòáN@`Œ‘Je&vWƒ-³5käÍå\úRbyùËSÿ€?ÐÑÕQ˜©Ë Ã BÓ>+E#¹rî„ìEº>N—lZLo›0 ^”~L#‡Ù ÿ¾õÈ ûÄä¢8Y‡‡W×!ðpn-åPí_ªo‹P…rä3X—“Cà×G¤"æB²Zl®>…p¿ÀÍ)P?f’øs®ûea2åÖã `èzHÅÉÜ 'ˆFù4ÉÙê.w Ð#Ý$Qð:Nº¥56^ÔopxOïU³ÁDõ*áo{º!u¡4Zª]‡Ñ~a͈pàz\¶Dd (ˆøp–s./#Ø×a¹Bwº·Ñ×[Eó±ÿ P:H¹säM dÏ`Dî Ò"sš»â=Må,+’v‚dæ’jÜ$]ìÁ;acRüÖ0zÄcA¦ÿ;1 ;…€<Àc‰! 8qBK¶!pupÅ·_c§>¨pܳv€†ðà|»8É× ­Ð ÌW“kÇófÃ6Ù7:gv²UjË‘DÜ‚­@$Àb Ñ:°VÕ*Üñ57Â5 Lç¡ßF]åFtÉ”Rç1LǤ+5M´r+‰Qt‹ÑXŠME÷A¿rAÈ/5IuN6óTªæ=]GZ —|7@%X‚lç|€#ú |ð1+pˆ†@CËák°Å}žff&lžH †ó“(½4Ñ óç#6S‚*µ_$­ÖQpÿWàTÄXò’¦RîAGræ5œ·@ê§¼C6C÷nT‚MácáSicdqYðåT[gOùÄO$@ã‰/ˆCÀ|8'hˆ@7`ø€`2X‰@qó[8D½ÖkÙ‡)WEFl%ÿH"Qh \raŒn„À®£?ù^Ô:3ö‡g+†+ùgcÚå CSè#xG0–LM÷;HьӸß•®Wo‰1%2¹ˆ;´pf×p˜„{"Ò ?ÐŽ€„@‰Ì÷úÀ|‡0 BP ñ8ƒF™`¦†•¨Ò#Xõ‰ 1}' ÿŠeÖK†€„®R+6$NqŸ‚a«sÊöyÀt#!yÁ°8c%G¸øK){É;<·y'™’ ,H׌(id1uGFט2" Ñ=×pbWeûÅ“–ôLiOI ­°¢•úŽÌ÷­ ÂÀšñ¸|¦™ù0`‰`d†•ÆY‘W5]ù‰_ÙK¸Qh€“Ò/°b†¯“—ÿC5qÑ¡ã $«óœ¼ÅPøaƒ*È3‘ê‘æ6AïQAõ!XåVoô¦z3å€8uSÂ9”©HFq;ÑT¨V|­Æu:4­€£ðމ1ˆ„+À|úðÿˆ $h¬)ñ¸"À|ˆ üÝ—ƒ¶y›Y•}¤Bw±»Ùq¯Ef¾¶QÉwÒ1b¿0ù®àOr±:z!“ ׊K8]ZzotnìRi+&Õcó6±b˜èÉžé…’'ù’T<±'pS1´BÂO˜$3¾|OÆCMù”O1¸”( @ «) Jú€”:•Œf`v›\!l=Bw¿æ4[ н& Å£ØÅŠIv‹aô˶¢®“‹Ob$Ü!xg¡L݉‹›šn¦+yìvEùc8iôá$p$ä5S­ ¥ Ñ9ù–4dÿÈr߀ød–éd€ ú™B0 ð ­ "   J! ¡¢i¡ Š”À‘òʬ5üè¡"ÊKÀZeÆLa2Z*|¡5¿4/gmÑ*f‹ƒV?ù5 £¡‘>² f˜Ýé_cFFxÁ–cßu+dÃy†d?¶0ÎØž á[ %—õBFeVñeOb*v¡%"5!@ °”ðè”­)”Eùj!+¬€ š¬úü“³¡}:* Øƒ]ÁâJG@´¬5Ÿá.G²p1NA5xµN¡mÀdbú¶Vk°°"MRÿR—°«˜…å*uQDA£§†1€ áÏøAË˜Ž¥U'AõÕˆŸÛˆ™›Ä{HP‚|“Ž7°1ø Â€ È0§/H¡¨©³Íú+` @6«  úvЉ(Š›Xé­=‚*,p:^±Kâ:ºa–´ªh;3@ y9@ÏõsKö®0y÷]$EXí1MêQ˜¬Ë¤íž:g¼Š•LkØR Û¤½%‘ùŒÕDû+%B‰×h“Ü38©.ü9ʇ„¯‘”¨Ù  À€ ®Y¡ ÊöЬù Ê Héüp³öP›š¡»›¾‰R§³5$ðÇaÿ*<:/W˜„¿”W)·5·Cp‘ †FfX™¼±yéf˜Ö6o„F,V˜ÊÔ”¤sdoꉈò¹97å·qH¸¡N{ÛTPñpƒ/8”k¡`é ÂP “8­ÌÇú›!@OÌÓj³¡¬Í·ƒþë4¡ëƒ Aº]±FòÀuU$¦"¶`”†ø1)VsË6 Ix`4Þ¶b ô‡‘ëf@ñÁiè¤Fò]Ý%Ș7A²Rnyœ¤oäÂ01û±0U×9œd‡u<Ü=k1ãÀ#‘­3…IR3—Ü–xÁúP#õ€Ag(†%¼ÃôÆTïmë*oMmM+6Ùì'YÍêEMæ0ÒuåˆÑð~Î#!ñE%v˜|®½ú‚¨Ì! Û¥|ʾm³Ô*wþÄí;¿ó»ªPR\Ü%ÞáÊš¬¶|›Vwv1Ñ«ùÞ—$€@ ©a2Ç´{…±ÿpôÆThñâß ÿŽ`2ÿ„B=Aü;ñŸƒ+^¬Hñ†4bt Ñá†1f|ø0ÈE @|yÒ@½“h”h fÍ4yþ›¹óß…$\$zrÂR¦C"à«…ÏB«+V Bb"!À„M²‚‚D"®®Ð—ž½|úô•AÁêŠVÕÒkëV„>{ɪw‚ʼn%þ±8üO^Å#òŽü»w„À¿É“ÿåÀPb‚@ .>àX‘ã#ܘádŽŠ9öUÌàŠŽ<.á˜pHʆ¤xÓ¤Eч‡<ðbeò–; ´xӿŠ-Îü9ý¥t¡>cºªçª&ÓG“&­É”)ÿ|„Iµ¡ÕØ |ˆ Lˆ úÈŠ0k®½èÁK~°Bd…­*âŸðj«/¿úJ+„Z(á„þ)Ã*’‡…Å.² #0cÄ•ƒ< -4Ø~ÒH ÒN*mÕ6bˆjseG †øÇ¡ (úh¸‡B‚n#"O¢ºÒÉ¡^zA:›BâI¨š‚ºÈ•˜†[©ºì*¢IË“h’`‚1+Rs).ˆ¯„©ÅJZ¹ ‘æ™ „ d¬þKÐ*þ¡Gƒòi«¬ µJ„Š¢pËDüóÀ|B`¡ ù•OÔsìž{*:ѲŽ ‚Ð<ƒ­3+‚ 2í±ÿ1*ÍÖ2àa-ˆa+JÈ• ^p J3*N#,'Z "ˆœu(x:Ò¦•Ììé$/O2)¢oÿ÷L2µe)\Œ$¸à¨¡Ò+j‚7-h&߯â›ëRQ#°-·†øo…P¥{Z ç~ôñÒ¹V(Bz­T/ õ !° 繘žì™`CÇF4HUUàáÃÏ6‚U´7ú'ƒ0#¶¢kd­f €|áÐ|Ëí²ò§¤CË%{{Òº)Zº&á`bˆ¦zx7Ýrø²Z˜„o]-i:¯"xk‚@½!ðÉ·÷â«ê´ö¤‘‘à· °.‹[Xôáÿ PŽ ”/ÿ$D+Š O äò¹¼ã‹"‹Œ€Ó0Êá‚ƨ³‹LïèôÔi¾ŒWŒpMèØb! !/?: Ü‹»(%ˆš-w k"‰xâÖl—¥z¼#OÛ˜ª3I'#+ŠÉ'ŸØmwCÖFŠÞ¦Fæ¹÷{¥ßOáÒrqë-³D@ØDZ`¸€F_°7Í+ T߆N Ù£q˜ sεFU9P š™½êUªñ ®ht‘ž]Ä(HÝ„#X‰DS;*-$ËB ³Žç’lÙ$9È3ÉJhžŠDyØ ÒN‚ó’l Ç^jžÙjÿ¤‹ÈËÓÊ™õL5¸n2»cdH¹«É¬¦Ó,œt´wÖ RñHYºNjt8^*Û?¸Æ¼éä%˜à“"’$m%qL­ø0sªµUäÄüQ&ð) r‹Ï  •4jà‹i¡#Åȸ€´à]ÌG8Ý—)uæ# rl‹õñ‹KMóÆhéÙ~pŠ4ÍdV¤!h2‘´bÑ9 þ£4Í® i„ð€6¤éHí^ ,P†’u!Ö"A"S^wH¢Þs¨÷‘VZÖ¤/)®W=m!-¤Äyˆ“¨·¥5ééú0" Qx-冨(ÜC‰þ¼ÿebp¤&Õ‰ùÀ"8cÖ2G®ªŽ_õŸÿüâ–\X5hƒ<³š{”À1)M H0Ð ¸¢®àëgHøÐWÕD¯CŠYën䀣p’4;$¨ÑÕÑÌ#6lÖG'«2¤_IÛ»•¤T¥±ÄÈv.‚4œT)•`›Nœ—IQG8B\ÑA²àøSR ñ·YL÷àc:˲Í, /Ö[´Ú>®ºàbrdßÿÚ™Ç{è1žòdKJpÉ0&“ý^2ܸWhžÉà'Z³ (ëE»êÌo2`#p"!­d•;[Qd9V"•vÚmáÎEÿ%%I´D díK&ñÍG)"ἤ͎bxrÙ‹% ÊúÆ)(M¸‡píç¾ù-Ö]n^*åÜ|0.Bj_¬ÚV§•€¢G "ó˜#”  @]‡tâñ×g¼¬föAP™#„½¯h 2B_%ÖPá]K×Ê«ÁÔ…?©ÒÔ¨GaÏ–®¸sðõü,¼’$ǣœ)ul˜ðôÀÑF|⚘¸0/01XÐÈã/ø€æA€ àT¸Ç<ä‰-@—–Ù"j®VŒ@¢žî<0 ™%4áB £#–Ì¡(¡Ëmþ Íg/Ïÿ`òl‹–°æAƬfûFñÅÈ v¦úéœäl[Ø~ñž#£·248ñ|Ÿ_R½™Ô(bÒ6ºcâfB‹é$ŸCÞG€!½2ÿ¿û𠸟J9;ÞqñM  K«v¡JǽlêArlŸYÿ!s%$-Õ ˜Œñ¢|4¹|vfV3Év¤’>\6Õ€ ,s=¸€ À¤Ô‹Ž«£{–» š29kI0Vr¬¦S—Ü{½àÀ% ƒ‰7« ±I%á¹dø‡Qà‰A:&C\\ÀyȲ“‡‡›¾¼Ë€ !ø¼ƒyÐU{§ˇ ñ)¼MùzØÅ3L“‡Æ‹<[Á€Èa$1þê«á~Rº»»à*"Ô‡yhD1 ôkvÚ U#°{ ú1¸X¬Â+¤&Ñ81hW8Ï ¬Ü¨Ã6Ü<&y6Nr‘_Q)*›™W0‡Š$Ý‘F;4 œ°‰ß0èà¬ks:òàòÈ «‰¬Ë£¬ @‚Š@AääÛˆ8 |ðAÈÁ»ƒ\€ËG\(8ìÓÄæŠUC#z#RlK£Êa˜ 9€HX”Å{¸Bù+¡!h…e4›*!ýëŒøBˆºH9$ "©ê¨@k;Ö±Cª›À;´–#9Ž »ÃlÙ½±!ª§y=§S:Œ0>×C ;±ŒB Ÿª€Ÿ*‘+Äú¹Â+ ð·S!˜ jš‡ö!§|¨ªhƒE¡öÉ´ÐjbµŽkÈ€ÈW$Y¼BÅÀéÈ58äE *ã‰þc‘ÏЈ‚–Õ!! Á€ÒÈ€ ØD:ó*¯¾L´Ï©C«Á>l’ ³ŽÂÔI8@)$*´r¤žªÆ¨9ʉ04#òë!ù ÿ,éÿù H°`… *\È ¢FlH1A‹ˆmÀEÉ® ݰpíš0!€ K l”…—( 2”±Â‡›ó1¢Çhž|LeR¸aׂÙVb[ÝÐaÂ… äM àXbQðXs÷Wöìåà^ü؃™@†%ÆØ…ŽñãÁ4„™f—m"gžuÚ‰•4‘A´ñS›‹«Õ–Ðk°Adc‹‘í¦[e·Á+Ü@É7däQK­X°Rr£D×JS u ,H‰=H±ðSPUòdSÔ1R•'œ§ÓuS…‡ >7 u}¼‡ßœøýðƒ!ú—çl‰eH+øüÂÙÔà_ >8˜mñ#ÂaeôØcMf©dúX*"‰šuJ"§ ž8ZF¤åØPŠ8F&›D¬"D›E<êÿ&P¬¶ñ³ )ÒÃ!â‘0õR’ÃÊ$ÁuóhùS•'T‰ÔO@q©#öL ^N=És—UêÔ,T6Q€OVmuuÃaѵŸvÒŸUŒäiȹH a'YþpÃö4èï`zµ†[ú„éÁzÏ“χ$†âg&‚Ö™‰ ­Ú¢i¦RFcC«j|Ñ@ªå¦£EA¹")IÉseµâ¤ÌfÍ$A×5Ë]²ÎB+AeTQÊjKÈà:%+Ï<è3ï{2¡%AWlð^ ìÚy@PÂ-0rÖC‚Ä|ü0×#0Ø/ƒÚ£Wd°ÁŽ5ÿ¶!dJ&¸d“‰˜¨ž"þéÅ‹"V*‹G~c©Faj:ÖzÉüÜ B‘Äõ:èp¬YòIÈÈjI¦OKoyÏ=(­ì=G­ûîA̓åv%ä¥ÑGm¦}õYøá3Ê(-Ýk–YHL@Â<þ¹{Áõ a  nëÛoÝÐýAkCº÷"4–¡ Tøe…?¼e‹ÆxýœÍöxd®Á¨yª’cÈÇ À˜…°F$“|p:Dx%+XAS$€ °.JE9Ò„¶4Ìi´Û’î@æ€'<î²4;yœà |ŒU®œÅ@£À0ñ}Õ©MZÿ p= \`møi[œ`¨9hAùÀ›Þö&©Fm¨a–Ââà*£)Â)ÎS`•@ ¡ÇEoáØ‹¨Ëq.ùáFÚd$HŒW`–”…~\€V> ÞX"𖄦ÁŸ©w€$%™’PwÛZíŽð´ñÑg85LÓÙ°&³ä‡]‹ Ø"žè]àyÂ×{,° ðƒ_º¥m f¾ˆ}èÜ¥7«‡yQ2" QˆT@1¦¢ÑÇ ÇF…°æn#Xd܈\)H|¤`t¢c–Óñ‘‡,dSB€A2-­(Úùà#i7ÉzVò„)äfWÿ¥›ˆd_bDÙ`Xù<ï@£à]VÉEÀ]±ì~–‡ ûä¥n‚#ÁžIEƒuè£ü`_a´ø¾ø]F™ó3Ü2STD$šœf5ù·šlJ2ˆáÕçxµ2q¤tÑáã Bfd¨YÒ yŽ¢%yí©G›d0Uî.i²SÚ<¾$KZ˜!‚X«‹Ò[j‚¸ÖYŒˆ-mKH[IN5–$ 1é3N¾ÓYú™‡—¯‚.@PÈ3å†pµþñlXžB»†`\0„¿ì:>‹Œ&E„yÑ›ÞarQ2™Ÿ2W ±ÅéOE9Â/CÖÃô¯ŒJ_bÀÙ‘a™Î¢¥Àæ g7j Zû´l9’ÿ¶®]îªzaªN•¶Ðêmwœ&ÙÖ®ƒÖáHðíÅ­H[ž CÄ8¡éK „d\c7˜€^ìªQ—Ž·£¥2楲xRù(bœ9œe8“8ù’šŽµïærc²üî÷B‘ÒÇ|L‡!‚^Ås‚E0ã§õv"L%>˶º;¡†qçHªZ»Î)¬ÝO¶¥U¤hPƒ³ã$qËô” ÈÐ>¯ÄnVÈ£«LàOq TÛV\/¶jµ¼ _v©:ò&SÆ,²0GLc²úàLãåDfë(Ïšs™0’Ù׿.'°ÀÜŠôÚˆh§VÑà@ëY»ÿË@TSHÜŸYøåqÖÒ¶ãìFåܦ’wÄ””Wtq T€4•«Á©­^Ó°«C Â&~‰b^ d^òÃø`Ù›ÌĪ:Õ+EH…®ÞðÝÄêìT†¸ä3Gf„W.*“´»Ð|ô%h• ¬+šk¢r¤Eûhœü -g|ª°Ù˺w€’x35í<æÆ4€aã¥%O0„áŸJ9c³Ø):Ä ešg’qoû[µÖ‘ü°.rŒË ;ÙkYGÜ6óƒÕnh™l2à›‚t`tä ø1Iƒ:ÉÝ[!§ii›´XÀ棞¶AkêÿË PIòï.ñEÛR›²Ï ” ^¬3ON$\ܸo¹@¼â¥iîG‰]3i‚ Ë€ w¢ÐiAv–cƒudÃô0™aRãu¨8PÖ{¶Æ´2|)"e ñOÂ+sôeB°yæDZJ2lK±:/°}PSÚá,Da$ô3ûÄIÞær–BŽ4½å3ìç,GÃ~òð~`²ï6†'ü€5^Á=tq/ø‘ Û ª'vEtd|ãXƒ•dGjgXˆF‡Ó)ž2V{3¥H+•F#|2U!Œ¡eÀr^ñÍ ª4(`& `á$«S>3Úÿ-Le[$„U;3y¦;ß§;í'„³sŒ-ÊÂàbHDTï†×€ ðD7Kë’V÷Ñ5¦¤]M"QÄbjœc)ª1jXj\4Œ—ñu¦†‡ñRu´åw8?‘ÕFq+°Yo',f¾æ€dˆÒ%RÒ-3ø4>q*wƒÞH;QoB@“;µÅ[ÛIGø;÷`\à oñŠMq@ö·úPþ¤\±ˆ5HÔC©Pi̓NÒK! 8•bgXdÈ^LfŒw9e§vW‡³"|³Yá_œ%+cwB Hƒ(ac±|ÃŽ­ÿ°:U‘Ï2sæXmµsX’H;m‘G%~¦Bí×Bï¤3]Òi–&€ÑQA¯¤yøÀnyiu. ‹Ú3‹l…PÈ€ b±S¨‹IEdwu2!)rd¨F‡‘vù!o"±Œ{M#S2”7•± ©€ù?:°”T¾–+`0áGÑ™†Xw vÉÆˆA莻#PÁXÒH@Q„O“H'`[ÐFmݦHÖ±sPùކhF”5¸0 ˆ°75ç274V]c©]£P ?p=³‹2a0 Q‚Œ[7ŒÃx{xنȴdÓp2E‡cv&C‡ ‘MEÿBf@²r'žõ”¹7Nm5NÀ–™ñwŽXU%¤B§IrÏÆ~ä×;<ÁB¸S[;¨¹g“÷`9ÁhñPWók’›=¡ifA ò´+ày’›q7¨‚9ÁY72àˆ ÍwqÁò|•iˆÁÂ2­ HƒxÙ¡%ñÈìGmßOIÉAÑQ[¼¥mïä;9óN_ê3çQ&àèP(DÇQôÑ6_i]§³WÀ° ËÀ…gAÊ {î³XDp‹r{öƒ—éeXï•?n¤’>9ÿŠ*ŒªKQT£Äq,£2æé Õ0ZF*™B`,w$RùF¨m²Ó[ÞnQe~;ÓC£-zæ¥ÿI4FÑ”|擉'1TK Öðw5Ä@K!iU.¤„CÚe§Àà'º‹¤2)¿˜dù“¢ñ—ª"Ǩ—m™#|ÙW–)eÝ)’W÷v¼B àY™úKlq‡¢õ«cA]±:DÙgA±«”7bÏÖª$„P-?a\ÿiËâ“BˆU$g kˆÐ¯ïGroQCê›§Vs¡ÕU§ÛÅ¡zú¡óoi­´GLh¨ƒz¢¾˜­ÅÿØ0p(‡s8Y–‘7×jp^1à’§R~A>€˜WV+ª!è)Õ(w”pü@AB’‚½rZi–HKÀmô°êçB,0B—øTûô3½ÕA> ¼µAÇåð”Aæa¼CÊ–!dgѼqz½ZJ¸¬Ë0 wò¬»H¬Á½ÏYR¶G8fø²‰õ€ÇØXUv¨á¨;ÒA«9%£B"à˜ A»™MÁ2:‰ÙÑHõn³c]+[P:aà×B¬É»O5ÁζUü;C³ªKsÕ‘,Êvc5[a±m!Ìõµ]uzi+<…%†Ú+Ü‹†H¨áKÃy³É£<Ììÿë³wóÆYvgžÅGw¿èÁ¤­+Žm¦HQºO@AÊÛö[5¨Å*Ô¶Uʳ3[ÔÀ‹äZ[uµÜôð`'P›Y&Øq5úàºWó¼$œVJTiÚõ ÏЬEòt×›Rc9Vv^%¥V³¶ÇE+j¨S_‘«³‘ÃR—ÀW˜‡y˜ÿåàY• r¸ÜŽÞÁ¤ÚáB›g_ìÉõ˜ƒÔöARZš´¥r©¼”„°¶ ÏÝ’HʲgÜÁi¼TûØË¬¸\Ñ"›<µ€ÂǬzH0…Llº‰QGX¢µw¶w)\T¢–­‰U_7SlT¹3Š€%Y+¨#ÿw ŠžÎgAìLsZ4ÁЦŪéÉU¼”£l°Ó&[_LõxrDùΕèmÍRÆð¤¼ÊæZhœf®PC5ôË41V¹]Ëð Ë€²iùtc×–}’5 ³…Z{&ÝEÖœX9ªÒ+"¹®¢¾'i£󨫖‡á©¾òkq÷ƒ”¥É¢Tý:ÊS¬Ô¦œ»µµOIC;”­x¸KaA¡‰©„KcñŒ¶ðüZBƒ¸¬™gL%ÆÕÔAA)[.jzµ@Öeý × íR†P0Ϥ£6?&ºuŽÛ†Ç)A{Û¬×é;+Žªyã1!£y%.¿¦$ÎñZ‘Qâ:‹ÿä@Ø~D­Å—TxßÊÛ2ò„[‰—”D-ÊÑ"Ê`¼ŸÕÔ’f§e\gŒ-¬èЦÇy*½tQcdmÌ)|ùt½ ø!ÔZ)Ðì¢['k³_T‘R@nFè‹® +zñŒ@ #§{“ßh䎑×,ò„Ï–m¶[ò ~~vI.äÀÊñÝÙ ûÓNÙ8ƒ3yEeÒZ ŠZ¡C]-¬"kzvbuê·Æü ȰJq;…k92üÛ/;¾ŒKá9 vˆƒk¸ÖKx@ñPi—›a’Šœ³‡ñ/¡wm¥¤úÀ3¤,òhÊp6‰Þw[»ûŽšøÉ¦ÙÉò-ÚÛÿ–gØ,dÏþêQÄN;%å–&_ ÖN ÂɺŒ`Þ­äû€K¦8r0ÑÊܦκôŒ}K€½£”ÐkBàã´œ-ït¶|góx4pƒúlƒµõHÐ2OµûÙ‹T¼aŒÁä,ÞC ›=% ÍiÁ"<‹`‘]wZÛ·­à67yÅ€áj­è•‘¾­x)ÜoøEU4*­¯fk7z®Q|ä#ñ½v:ìÙËú@HÞÁò(Ù6a²e[âÔUU|4 ܵK0Ú Ïè;f«â¥}ɦls;PK^AiöË6„PÇ÷ÿf§f­zz¼îͼ"#ïZǸ„¬^>ß)ÆF^æ"ëÍ­7ʾ> ÉY’,‡NiÖ4þìñ ÜÙém°Í¾ÊA]ÅÜá°C3”ô€šÐÒ¾S |иêc²ŽívW3Œ¦ä‰5vÂé&k§—æ]ÕÆ•3#u—‚5r½¢žø¤öEd)”SvkÞ×>ܳ7^pGN2QhÆ“Zõ5^ìWUÅõlñ–Ôì@˜ñ@¸,jïgÏ/ù€„D'«B v£ÝAé'ÞQ\_%•V‹-eCD =Ó ~ÛéuŠ O2…U‹å»Mê#Š)ò^ø#…¸î^Žÿ *Ëm#HÏFA,´{}¹’¤9YAåQ«Bq; Œú[ÐñïâÎ>ökϤpôop!æh1ÞAzå dq¢! ò$NœWQ"Äy% |à8ᄊó 0‚0a‚C­(üÀ¬Y³eËž-l’ 9+è3¤"Ÿˆøñ‹GԨѢI‘æ‹—”i<}M‰6eʯ@Ñ«Yã]E4â§×Ÿü„ ;ÔìY´iÕP›o¨[·f㎽qcÁ‚†$„`D£%.–¸wäÄ/f¼¸ð=È7& @±bÊkžxâÄA{öòåóYZ_¾!®6Hà‰Šž:¼ØYpÿDy çy$Y#£ J^ÒªÕ Èj“¹ì°ˆ$HÈ'a§ B}ò‹ŠÔ»Ó¦R›FU¾ûÖ©V·®/ÐÕ½×eå«¥_m lãÞç·ßìÏ € >,¤y&Rp²ÊsL2Ä6ƒ1DŒƒÌ äìžj-5Ò²ûIêRS͵ƒ Z¨ ØÊMž.r7ˆJ¨¤y rèFওà†ZIn¹˜fº .Èéƒ $( ¨øDÁîÊCj<ð–2Oª«ÔcJ«¬Þs¯,²È²ïLúØz«?6ý‹KŸ¡~‘ó,GyŽXðˆÅ0c ƒ%àB ³ìAÍ$Óÿ잉Xô‹žP#MDV@D}2íÄ×:,(¶bd¡…†`|OK8AUU!ba’N2dˆ•"` 嘻&&d(h2'žxú J~¤ôÀJd¡ ï),§ª*žgÕs,±ÀŠs>4í+ê,5Õl‹Í³àDäD IÔñ\pPÊÔ0>$ÔBÉä¹gP{]TOa;H5{>¨Î§ ¦SMU#ÈÓØ`“-ÆW•G0‡@z•ÔZŒTQGòÈ‹À‚QrÉ9è 1$''{Q~<æï´œŠ¼¤ÈSoYªØó¾¯¨Å6[¢Ñ‚Ë*«âR3®7‡Íae„¶ó„ÿŒÝ #[ô°B ¥2í [¢ÏæiAHí5‚+]K3M­ z ê0!UôlT³u3»„Œut¢… a)hÅV–F!’9`T9§|*‘Ÿ™17 Nd£b ËóÒSöYh‰3ž÷ª%óÚ¢[w‹-o‡òvéþvŠS¨'Æ1÷‰ {ì± 73LP µÞlß±[€± y–à÷3´ R›ž€C\¡•‚ Ó|NLÑ y4øÌá‡~¡ †^Uùg+‘P¢àãXª¥dÈu…œ˜ÜÉ2 e݉ٶÊS*Å(WyJ—ºÔ²ç,f‚Së\®ûäÇ,`Z›¸Ãÿ¬@°Qo"¢'ÜèÉjT 73¨ãiHQœIŒúõšè!$¡ Àô‘½d¯`šBÈAІ¢Öà-$éÊX«ÐW*t-dñ+×€V‚,âŠ&[LÙÊ*ÇžˆÅ=TŠ™YÄs”3æì€Ïú\ÝXj Í‚D‹ÝëvGüÈnM•; iì"uÄ7¸‘Ha쥧ßi(^šñÝÖ £ ¾F6wûL2šI,ªXÁ+^‘=L…àD-XÍA*yð!(0 ÇrãU‰;P™âX’Eæœ,r7ÐÉvÆD…ŒÈ"J½³@ð<…>s‹ÐÌ4Ç nPƒVù€Uh‡AÔÿðc!¤Êõ fFUcÔ!c€OÛØž×©€ïˆET›=v©I¹íA|E+>©½Ó‘”I¤Þ?0=¼A@c;ú"2#XVqˆÈ~À’TàC9ÎyÆ5p±€•‰e'–+KæÌX35~§<Ÿ£Šéˆò¥x¸ Ke‚æ•ÖØñÃHÃON÷·(C]@+ÊU XÍ(…†ÔW#g¸5}…m ² ‰%Q©C{DA4˜ôÉöVD~Fà x%@yÕˆRêaÀìÙ—¾ìnU®ÜÛlb£ŒKe)±>ƒ+˜8Ñ©À¸4ž”˜ÃJc™¥LŸ¡§ÿ,¾¬i¶ôÃ- öÔš:EZ>.;šb-€C5N+D`Žhœ½³¼X(¼¨:oª1ºS)Á—V{æv4™Ò¦¼ |r¬Â«(áä®`{¼e.oQÃÕ0B5")H;dª†Ðfе­.ŠǹÄ9£ˆ@X »:2¢¥5J–°âÒõ|©Kçý`e‰Æ´nÁ.?´#Ok—`Ï8´çH–H›E±Sk(dó–݇%1­ÔÀ¶JšL‰@ˆ+PY=ÜÉá—¬Æ=®Y9,ÄíQJ@=ù‘ D}¯„l""ÑŸÌϊDZ€j‘Ë—àâ^Á–™RšÆõ&…K<ÿ» x à‚øÂѾgù)¸8h{°§=ÍOì±eœúNB%­7‡]X©R"Gðk‡·™æåf¶ä“Þ=y()í6Ã~…8üϱ¬¬#Þ'% mhã"לT®ŠõÁHó%!ðÌÄìz§Wí¦7ÐqÈ.šÅÀ>'7ˆÏàD³ 9ÉÇTc2{æ3oUšþÁ¦ÑøQM*ç´šõò­»…4q- Ç¦e 7’M„Q ÖP;ç\ʃ”#’âêi2¬ágÛ“4Y_¡ JôùЈFô&³w) h4©éMHôƱPU„ØÙâT‚œ”L&Ïx†MF`ˆú(ù(«NÖÿÎ`‡,­|©¾C;“¬1ø-Z+m¿[Þ5[vZ€øTŒÂ¶ÀP+Z  DºâÌ“‚Ð)¡Idª¬QÛA»GíGW»·¿í¤ …èìõYçá÷q#\?g/(rKmZÔªRÅ2$‘`«úýµüîhtº’&6<guéЭ(ƒ]+áZ‹Ït´5…Ùìv¬¸—÷»SÑèúÊ™ZÁ°‰Í“† á$CE©| eÀ¦IÒ`˜î¿e4£…»aAw£-kY} Ö“Uˆ#2ÄsMt ÝÅFUð¾8!²ã G£Ìá÷5†ü̳ˆç<©æºRš Ù¢@öÉëA‹íÀÿu´¦=âVÎO5áÂâ‰sÙ˽þòë2»¸Ü@'¶7é”šÝØCœÁ ðŠÇ¨Ú´‡=Qž›Ë[¯bÛñ‡üp¿Mîr—8¹ÚKwÌ!M(Q•~ II a— é«ZX½}†0„R»(›=%‹ ;ey5Ľõ€2­ îð½,éiò–*ó ×É|€;_ˬçË/û²ž‚;ŒÛ5ä  Ú€Ž³¢·¡“¿€±Ùh0y!²9%³§ÃS¼æB„_ €_P®›+Fc?O± ·Ë³¼pû¹pà åª?êˆ.ýS¥x:Þ‰ø? ø‘…’Ù¨Öûœˆ½©XÿQ•RЧ8e±@(ƒ©ÝK¸­À5ј]KÁlAl»@D·ûÃå ELD@TÄÐð²F4ÄÑX€  „ƒ¡(ãˆØ $FQ”§¿J%Q„®ÝÒ³Ò@ÂKa?U<1Uà¤à$Uè³à:.ä¢Bã7?û§‚ Ô%` .Œ'øá‹“ €À‡1$a0™4Â’=iÜŠ¶Û5j¤ÆjÌFml;ÏJÄj´‡.ËÆB¬8,DpŒÄEtDu|DvLGHÜ©qÙ¦±”½¨ÞY³ïk§… <БÝr’æò­ú¡UÌž%<ȱê0qSä¢Å²â¹C3®Ÿº^œ.`DÿL눀§ë±¾ÂŸš(’gØ€5´&k<ɬHIöPɶÃFl¬8(ÈÆ˜GDAHdÄuôFwtÄ›äÉuüI TG(°¨0‚Yœ˜pòÚøG’Gù¥ˆ‚°6Sì-‚!È#d?PõSB{E›EÑš<ÑJ´ë9CËtã¶’.UJH‹§C޾a\a½#á%Ù¹ÆmLÂl»˜œÉÃ,€™TLÆœÉE,JG,Ê¢|G/“L°ÌË,Ê¡ìÉG„ÌÐðÌÐÊÏ\ÇË´((MÈTzø€J¡Äò ¤ŒrÊ—Ùä¿„Ø¡©œ¶«…ÉÆ4ÌeÌÆ4ÍÆDÏÓTL"MÏúLÍ$µÌ%•Oû¼O(RüTM*U ØÏü´RÕÔ-ÍÏüD*m1}¸‹» žóÁÿÕ? Œb.îèÍL?$´ÓlãPX,¼+ù‹€ TÀ‹P·ÔÐ>ý‰9*}Àεh€†š˜:\à%/KLļÌÓTó,MÒ¡,OÓ U¢f7žã]…G6 h¸a0áØL<díÝ^Þ!b®\¥Eæ—sdQÊJšå³¾dõÕdM®Ä æ#”hÔÓ[œaû§¦5å&v(¾„khåXÎÌ.èûLÛÛ[Æå –Ø1ÖûTØãÕRÿº•Ø- Ö‰FfþÝZõR´ 1¾¡Âãf†+-o2j[é8m.Å;dÞÚHqfäóá—E68U<;ÎNÔætç%j÷­€ÅD{öi%lÅV\â&Nå_è…kˆjJ¨€'Í]XU` ~ÕZµj0¦à†&^ 0+Ï,P´ÕUºX¸=c6fãâÞ„Îà]ÝÕEJ0áV¨…—!Hê‹!?mF\8ÝÜÞK!:Q¤éE6gQ”¹®J1>›¼ÝY!ÈäLæä±Oª¿+¥î&>å^Håþme ¨€ˆÏ68ÍÖf4îâ,ÞâÖÎêÛ]k NRû4ë³=[ÿ‡uÛcnkŽ¾í¶¥°@~ p `¨…W¨$ ¼JAnéi•áLÅ„pä"߬4_ #Èšó$Ì;4 ¾kÌÞ€Kp_ž¼ÄK±*Ëom¦þ'xêKhe!@„Xí®åÒ~XÞíâ6h¯Æm¹^RÝ6[_6[Œ5[0]c2ná&n¸nµ ˜ãÐËf!€naðk °æ·\@< Hñ¬d. @}H+ÀaHfáMù€Â®ä3²7ÌÖäôöÙriÔè+dükDkZѦï&Få\ˆækpeªîÚ׎Ò×.`ƒæâFè4¶ê0Í„UR&O`^¶nÿÞ ¿m[.Û²Žãxf`†ZÐËi6á@¤GñÃ_ %:©nÔ˜P8 gQ”é\XñDÏ…!øš³9½„ËFb$NNJɱãÀ‡Qè8‚ÂW`ê|®oUfehØDÀ×Ù…‚+žåÞ6Uæ46sÐMÑ ó&EX3ær _à†¾eÛ^[æ]Hù€¯ò1;_˜fÀVJŽx´>B<”µ¶óƒqM1ßH¦áCÏöE7tQJtÞrtžŽtMfgD»J ™cTö¡R´%gâ&fê^àßKH]aÀ‡{U'Pu¯E`~½òUõw‚½òvuWóÑlðÇL…µò ÇpŽþb õÿWMꑽô…’žæT×Í窎DÇ0ÈÎ0Bç?Õ ¥8g cÜìpÖ‡" ÷'¼dMFâJr¸±|¨wê{ø…"hò&^ò&âh†$é²Q Õ|§ZRý×§Øó|Ý‚MÕÖÕ]ÑìúŸ´õVvËŒø3ïõ‰§à6õ ¿Êë™Qax e§%;<Âñ— Övæ¢YßlÜîA%Rж(8ôÂî{ÃÎqÉË;4IÇù º·Yœc‘6+ЇÒ]Ú§Fú_ˆâÔm†J­€Œó¬ªõF-Ç?ÍGÜÌÕM{pÓ$J'HØ€ýƒoO¯7x…Uÿß]‰gk-õ?ð?è‚" {þ±—€n•(8í!Æñ« äž9æ{Ã|S:ÞSjì‚Ài™_ñÇ{ëÏ {H ÏùäŒ|Ï TŠ'ÝÌßü¤wÚ§…  œˆ|°WÀIÁ„*,ÅÄ NT¢ˆö2ª€ø°ãCˆí})²£Š”öè¥l©AÅË—m`ª˜“¦Í–9_ºlésfÍ”<}¶¤÷á¢V­„4kLX„Vˆ>„`DoÞÕy!BDÙêõC¾(rå˧﬈´+Ö²=«*½óZœ w¢E yòî½À+¯!Ì¢]+BÕ>ÿPj|É¥ǗûXÛ* £„ ±`’.FÿjSÚů^ª{ýºÔ 4`øn ⧯lÙºs ì=Ð`>{½Kä=1xÅ ר1$IÏŸ£¬NT&͛ڃÞÜÙ“çvðBÇe)\‚> µ 5V« ŒæÍ;qBÝ»X¯Ò£·5ßQa¹¥Vl­u–WqÍE]zåuD°Âežm6JgŸ©"Â/£ÖF/.¨v‰j¯ÀÆÞ( r?¶ñ“Ï9¤>?‰ÛeYAGòS@ùT0’¿E§ÑHÎA’J]EPa¦”ÿ“wÛõô%v/±$ÞP8Ä/ã”­HÁ<,è¥×=:È`þ…àXh¥UàZ ¬ Âmù„Ðß‚tÊB /ì…_`ú`H‹¨Ê Š%æC‡’E6%#.‰( ã%¯±ši¥9‘Új6 # 0£ü€°š[AmEë#M*»ì±MÉ“FB$?Ω°¥tÎaiJÜzkÝ—*°TM,Íd®¸)«.yA¹.Oæ 6„œíY0„óðÙ'¿z5~rõgÏ`Q˜•V§>¨¢ð¢>×]uõÁ\sõ•)jŒØ†¤’êdr¸@+”X> Y¬EàZÿZ‹¨å —àƒÏ7Pl°µ‚Èψ[¤ÐÆ2Y[ú$ÍÐL'ýtÑH-$?ô˜HÓikR·ßrÛm—ãŠíÓº@ý.¹é²KÓxâ•'n>DÀT†@ ×üúé sÇÿE›ñŒgž‰A Òƒ—Æ+(@VX³„:£€Î±³tžg´S§:ßùNÚ¬“#@'"ÒYÏ|fkkýô'–†¸¯­m‰_JâØ²WÐê±Imôˆ >° Dà(Á æ¬d…> Rß-G0ù)æ ) ¨%‚|ddPLnƒ !LˆBLæÂȹgzˆe  õ˜2iÆŠª“Ù+zñ !c§!z&’ªè¼ê Î)NÚœ³«ìL¤:©šÏ«ª fÕVA²4°m’]àÿ#¢ö>™Dµu¯¡ôø^aLh–ô1cÅòs½Ý²oô0˜>:5¿ÃýTEHKY6â'üG—Jl§»‚"Ssuä©d:D‰µd¬D à«¤ L`ªŽFJåÌ/žÚЍ"«[­§UÃO|b5¬´K$YÏéÛ³W[kõ–B7 Q!^/mu.šJ)JFð#  Ø,%G˾¥_ À-›ÊÂ|ñ€%eØfES–(P¶+b!‹[ôႚÚô0_4œhA²¢ª2+h£PwEQ•.ìT— à… §Žp¬üAmo \­ÆS«Z½ª8}ÛÕ ×“vâûðŠ+âæ=/11ÿDÚ\¹²ël¢\SºîúÖyäƒ1®¬Ï\¶§>÷»>ió1ßìּ‡Ã\âp–õF¾ˆ2‹ªÂ}Ì üìç8´˜ÿf,‚»zÕ+äû Uø¯   A |À#Ä…¯~q‚u'íò Oyî9·¼e'žÇJà(§Ð1¢Câ—ÄÝ2(ÅÑ·>·”¦¼É]ÅõP`å„ì+ƒ°¸ ðøÇbmº…wµŽM‹ ΢Ë&£E¾ûÅfiäü6´ T”e"¸`Ôé,œ%ó©Š* hD`Á†XÀ(zuHƒÏŠTd†³Ïmg[Û¶¶=óÿ¼³£T@|䶇Ԏò ¨›ÝŠN4¢‰Ëˆ;'|à³Ç½M¬‚·¾õÅE‰—üÍ’yÄ@ @ÄFs¼c½Ôò¤þnaåbLµPÙp\fzÓ_Y»À¶Æ¬ªqÝYÊð´st­ˆ‚í™]5*D6-°l\DÀ ¾Á|•ŠT µÀ3è¬3CÐSžz–§XÃ}OuÖÙ…êt÷º“³n)¡;9SZ7º×âr¿ûÝ ñ¼¹®‘yÛƒìdÏ÷CŠï•@ô¡ßwJæ‘ð-¢rïÝ5@Ÿ¯À¢Ýñ=êRŸ½€÷àÝS]¸r0ŲšÊ +œcU_ð#ÖóM”yI@ÿÆžü™ jÌ:ôÀËDPsz0Bt¸g>3Í× Q \ è³­2–ŒTP è†h:ðë ,F¾3†’d:¶iCôåOeZëf’ÖÙ-ýè«[ëÔŸ~¹³ÿa®—ûÞ7øé1ïðYe ýßÛ%M“yÄ‹?ý‰»>pƒèƒ>»T`졯½ä ñwIc¡$ÖjÎ/Y«¥ÂÄÚYPÞ|\ŒYg‘ ªL ]褊ɬË=C3 ëqNšACßI@ °À”€$Ô‚/´à(€Àüž Π ÙÐÐÎïMÓÁÐðŸæ`º ‰ôMMáÔ\Ÿõq_ÖeÝ”ÿÛÅ÷y_ø™XùÑÛܤíöð§Ñ]Ú\V B £hT^0œVà‰ú°€}ô V|@Ê}±h «)0¬ÙZMÛ-ŒIÍÑN}ˆX6b-l`JÓÇ(PšQBÍÃLb\@D@-°à2Ô A ÊžìI@8 æà‚b)V*–¢ìI ¾",ÆâóEö5áºÙâì±›=LÀ‡ñ"#„ßZø0§ãÀIûyá0^…0>V %Ü€xž°_@ T‘ƒì‡.‰Æ™æü }]È¡:NY**ÐV<bÊÜ® CS,ÿbZ™hñÞÈ  X"¤ ¶`*$ÈÞTÀ¬ÛB.Ø(F¤*ÊÞÔÈ >È ÐàD*(ÊžÒ<ÍEþÞÔˆ¢DF$IÂ"IÒ⺉â°YCÞâ>áLÀ/Ö¤UÔ¤ø‰ßM΃UðäVÌÇ|Ä@viÔ˜ ",z,àI`µaÄÔ…ã,žb=^IT>VFJ±}=–ª[•I¡\©€g"E±JgìʜРQÅŠ™Æ ÔÞü# ¸‚'ª`*´ /ÔB\@CN@LÆdK¶¤ÔH@F¤aK®d.Š"dFdòx¤ÔP$(ª"f†âHšdIFfg*æ(>ÿa0Â0M–fiÖdÙéä/êdNîdk ePòälþì• >´ÂMÅ_؃0ˆTBD7VånŽ–P ax%Ž\Š%rŠÖ}F­ŸòdS·Ðãœø‚ù”Ño ׊€P‚¡(–rú’X2–y‘£JÕ”§º© iîT~•Îc0,ÝrHÆŠu¥ícÉZYTESò€+h¬zª'•¶§/`©€ÍÚ쯖ìʶìã’ë-˜ìâ– d®ænn´ºP›öÿ¬Ï²"fj+·2d.Š©~r©²Ò¤²JÎÓVÅ-žLè.¶G-¼ÎkøŠ=è.@ƒ È/„e† PJ!J§2g‘I`¨Â-–}Þ©b¯ö.Feè1åÆ×…/\Ü*ùÞjáÿ$_"ÃAZî 2.°Nnä®ì-H±Íê¯ÿšàÿNâ0›pè^+f"¨Ðæbž¢.Ò¦±êšæê:0ÔÒ.íÚdS"‚·œØI ת¨ À†äBaHoc2Ž:zJ9Š}}cŽŽ*u:réðLre B¼TYPÅ„Àð@{2ùnlÔCÇäáä4îåúêÜB+¿²+Sîåê¯<äÍ$Ö2‹îeÆâ.[&g’¤J}*°£)ëÎç7mÒRh2><ÃûÂOã£lÅFä1=¬ÍÈ”Z²h¢r®Ö¢¸Ì­Ñ×ZhžrN†ÛŠ*u5ÐY—¢$ÿÆ¢8Jp‡øLÈ{òÆâ¥”޲^¤&úB* Á<ñ¯új¯Æòü²²+·²¯6®ÿf±-߃]tÓÜh´"p.mJd0í§±—"«Êk×nM*ëX@3l0Tøf? Á8Aø4\‹v /uŠQÐW¬±ˆ93òÁB2$_`ª cPÂ$O5£Z> fx²Æjì­J)S)•*ñ•¦‚+ÐìÈVnËöê+3lær1\‡±›rô pœ¢bGš.d’®}š´;ð±öK£¬KÛ¤EáîL·Ü+ AÍ«d Ó ÁüGbá ¥I¹#eœYf%ÿ`Øþá”×á€g¯qN¢*jKuˆÈ$Ð<"ˆïnòßq=±Wã*®&qA¾ç-¤2°V®p¯5J &ËB4Íúï=L¢EÿÞµ-ŸFærÓiD–´! 11—)`+….s…ú-7ÅSØ ›é±Š*X€x…VNÐ7Ë劤-£€v9¾ÜØ®sŠVjc`j3Æ$¯À$W5ø6h5WnW‹² †5_C- Á-AãR.,_À-tk|j¸`újþbñH·ˆW+dR÷H‹â0£®±²õÓŽi«ô`[°0w C+èƒtEø,N¬%¬7e?'-àv0=ÿVÆ6”Ùw‘ëÚh?ò~›Ìõ¦öj¯6=+J‹ºÝîó3n—/˜‡5Œù^º§/ü ¤rB÷C7ÎïôjrÇ5ó‰8èúì(jfd^ÀH-J3°éJ6Ô"ë/ú-D00j-Xާ‘HÖÀHµÖöOñ2J.à^D”ÙÔŠØ”}×”}º§$/|{3%„^”¿³Aˆ°¶€m'w¹VA‚wõ‚ÿ3™¹)“5B‹,›ó'‡÷²zøæ†ø¸µbä/“ô(sгv :Œ‹k¡«lS€éqF8i-ÁïŠ^Âu Fª¥E.Ä~ÜC D w::¦ÿ#¬•³Z¤…:"Ð~“ ¹újû·ˆHµTWÆ<‹Kv2( îà‚¹ÂôÎä@*S8㢵›£´ä®¬°k.Ïv.³k$d^¦‰'¨éžîÑ20[©¸VK“iŒ7eÕ Ø^ Á¡õGˆpeָа™Án­‚ù®çv˜¯ )Ÿ9Ú?ñâöªZ»}œ»°6îÜw<çùD>{Gö9Š+°ž¢t‹O?a[»¡Ãñ Ýxdíq”^ðKä<§‹ÆhýQÏW®­¿ª­”Ù—È•—yMç¿C5ÀS}ý¿³Ã~Rć xäQGÂz 6LÐ!ˆT¾(úZæ Ä­%6–ðøñVÈHL¸5£ A¸Å¨Ä-†¢yÓfN;yò¬`³‚„ B%ZáÂÑ $$ùê•*CLµª’žU©Z§BøÐÊÿ‚J+ô}‚žzZÐkc/ ½&÷îÍmq×I>}{]ˆø%0`U+«\d…ˆÄU!^A²a“_QzÁ¥š)EXpÙfÑI‹þ¼bÁ Dò€ÐBˆ0°pH½‡ %ÖªhWY9ÂâcÌ”)§J5i’ÑrF/Kؼѻ͚Ù{J0|R¡†„&5”é„K'T(0êÓ©ð›7w>5Ä„üˆÂFaÖzlc@OhAž»äiBž%Ú !½ö ,±Ç+ìB¬Ċ ²WVxå3ÍH¬ì³9ÛŒEJB#­ÄR£ ¬• €Àb‹ ÿ¢zn»­Ç„L ·ß–Y¦!… "ˆãC.¦˜BŠŽ‘éªTÉ¥éL‰»ì¶Ëî'¡À3Š( (=¤Ü“@½÷F‚O½ùîÛjN®ì[ ‘:CĬ³Pƒ?ÙBÁ&îj‹ž¢ØKÀVø%1UDÀð°Åõ²#{E•c$‘³H T=õÜ ³ÓTûÀµVu<è ØhãÁ6{ÔM¢Ttõí·ZRá‡(pÅ#'eú¨%+_‚.¤—–ÓN§/»ìò' ¼#sÌŸ"ï£ØsO 6áœÓ9rë+—« A‚V(iå?{Ð*Э?¼‹AD”wÑ û×B-´ÃÄ£ôÿ1+3q,OGÍTC 5Ô(@äÆaËñÖ…~¬¢Zùµ7ßjñõ×]‘i…„˜ŒƒR¦’d~.º¨¼œ¤–çïÈ«`ÌòƼàçïØj6Ùk“iਾs¥¦sF>ÈÓ?³þü“ÀµÖÒàzZ{kµ¢°¯ +X±¿ü¢SÇ [!´WêNÑSÍJ}QÔSI| ‘\{ ¶Y‚Õc\HHˆÔ„È<•Zñ¥™Z† áˆä‚(IDBtÑ£›yËž£U]'lÉüŽè¦Àû¼6+X鑬– jtë¼¯Ê èaéFDVˆ`…|æ¥WP@¿¦G^'üTTÿÂÕøQK7Ä~nGŒøDÔ^ U½/3yäW c €í}†xìÑ6uË­ž!†d|¡Þ.oÆøÜFp0) Kײґ$:\bÏ´E&oeKhK1OÒÚ3 ´Éin’Ï練®}àxÿYÞÖœ'¶µè .ò:K^õ¶ì)&{7L )¤ÄL*D>øÛøDµ™¬hEžyLj !!ðsÅ¿*R±c ¡ C†T¹“µ"H¨Gl†$93R Œ®PcI0A7¶Îh¬Ô””Û¥IƒYÓ›lö•ø‘„$ÔŠTBð ø€Êcá"¨*Qÿ’õxX!€áð1os¿.Õ½oâKMÞŽ¸!zÆS€S—ÆÜ§£÷QH·Ùb­>f+ÅÕVSd‘(÷ƒTàÃr–CÆ0‡9 _ Â\Qº7NK[­y°•-Cœ‡vK×ÒB›Í V;—Ó¬ÆD¤F‘‹TçÖBåål}ù…*æi„ f‡Œâ¤£&Õ©Š¥ óŒ*RdÊ"´b+¸>x0(F1Gõ«Ÿ­ti«‰Öï¶ Âà€Œ`~ºÑMãü÷“úÂW’ûAä†Wää:1}&v¢é9f0[Úü ¸ÔóÁqKwu '®ÔGèCFúXáÿ:ù'êå# ŠZ” *TOÂtÊž >ò‘ 1J0‘¥ÝŽ·D |)Jkjº ¬Rcï›â%:Ñ1‚tq¶áhF9ê¿&0¤\Üe®NvR”þj7 Ð_äkˆëÌTuãùYQžkº§v´óàzº T•|³„~çîxLjy|À”eYêÖ Y¶Àªg“Ð/þ"){^u`dQêY ÄU‰D£®(ÓZ*¶Þà1ì{ÁkjZa”£µÚ‘èj€èîÕ¯µMlð÷!‘4r…åJ}¡«ïz7ÆüM!M Ød¬_¸À¿p0?%õ/}DN•í^j;·„²U¸ª@«(ÿÆV·†` #Ü+øÑ½NtG;²®G°ÑŽ:À¹cÄH½kÆ’ñÊd(Ë•®*WdÀÔ:ÅŽMáG¢ˆgŽôÍ fï 'žòñ³R‹šY§u“,«e­:ó’à\DÍ^ÍÅš½Ê`¯9¹8Ë¡Z0´DH/ŽŠÌƒÐŽïŸZÀ[Ÿ„V&Ð-nñ^£»ÝØØ&»~íèFAªã-Ž”¤D&rÉ{2/šÌ¤Ëx¬’s"ÙœTk[ÚM¯5Ç¢hðŽ>È}ï+Â?~³ó©RUÌe5ÿ  †Oêlm Ù©¯»(ªh A²é¼lÞ.Q“<‡1)hP ¡~έj 0å2I£¥ô^ÀèV÷Æ‘Æq­.i^þXÓ•ûôÉè]ïñ.ƒÔ:±¬{Ö癩B3Šš8ˆÙ‘TY¿ ®g@ xˆÈG¢>¡1{MltÖøÆ5Î[6»™ÁÊ‹BÅ#Ä=CFÛ&έˆz±|ÎÐ D`9ºèŽš£êÆ€v¹¨?ýéÝCŽ÷н(ïMÖ"ȉÒ;­Ú;= ŠÏ€;5ak)”Í&gÙ$;**½³®yÇä61ˆð€>¤Î±µÀPqŸ ]Z@ÿê,lÎ…<7´É GÈ«ÕcTžÛlo›"¸X^P‚BËœæ6N4voÌ×ìvtçÍŸb9?$0‚`“ó±äRo_¡ìôH÷E{wR­R“g²cŠš®yÙnÍ·àø¿.Bú2œöiIœ®q‰`ú`!$[à Ñå~ô¥w½Ó6‡W £Jîæ¾¬mÛá¿>VóÄB'Úº6ftúûJãK:º˜þ¹Ï;ÿsL^"B7ú®ê]¥3éXǽ*¨ZˆÂÉêHh~æ<ŠÂ[ôÈv6+w’様&]² ]®æD@òA@ùQE ¯ú8€îäØâlÍ8,{ÿæICc“ð ¬NŽÄOüŒ•ëñÀMýjýM»Ödr#7ëV¼ë¼|¬ôˆîè.ßN'®…šZͯÅ;º…³³xŠàBˆ5r‡>œÃ€ï\ÜÄj*@¡öâŠàÄæ@Þ°P¨ÏëŽãZ€Í"Œ¶^áDd0 Å0`зL®“lp`Œ'ñoB ¾mæ&Ϻj¬® ¯*-°ä'‹¼‹Ç¾K ™pÓø/€l“ìÿH-ê¤0êÈ `¯<ИBhðk§8>Ø$ìz/wH לõA5&Î@d.¦oñ®Ùò®Á RŶ£¶OŸ~‹ÙÆ’‘Oÿ²±æÈí£¨®ÔHÇÔè6xdº²È!ø§Œ€ŽôâMè<íd°#M‘;PÑ&n¯(®Ië> =0 )Ô#\¾¨ž&×¼©á.D@‘àðùè"AŽÍ ÐìÙ’-Írá,R[°m6„/ô‰B¬MüO1ñb\ã²qòl¬Ühì£ð uŒ–èêÍQÝ èÞ)gèj¡KÑzò á+Lè¨ö¶…[ðñZÎC<<¨=–âÝCƒp1xR }O ñæG0_èL-¤Ç r¡¢à.eÁLÂþâ/th{D%!oUC5O5ÊïsNræ6ªÜÈ%ÿ e¬®t Í1Hl’)gÈt2ÞD2R2—.2•ì§îßÄöº)d§[’*Y#d-wØdwªò"? ¹Rk†-îåP¸R@Ú/Êò6Û) l“ãRÜæ-…üÒ†.ïËïN’/i»<Ê£Ê ¤dL6¾Ñ 1Ej“PבdL/€òÿÊ3ƒ2'b‡U‘²ºE<Äc=. Š‚³>ȹIáºÉ#P(`Za/d4Pæ+¹²[À ˜mAóN6©/ 8}³ïvh{lp$#!—“O<‚Iø²ÜlLÝ< °´&±ÈDce;ÿÑ‘o¼4 ×£ëü ùwÜä*Sc5èa@e@ÁÆ m,™íØÊ2"ÑÆÁ&Œ‡8r«Âôäp9•.ãr5$ šsæ¦S:+Ïý¦Ë¥0‘ŽP°Êˆ±SèÀsFGÑ<+=_ï {TvX±“‚)nçh8èH›‚³z¯™òH™Z!1” Jô4 Jk3ãβ-ÌRAÓb’T0'Œ-ƒ8-t.­g.740âR莠ñÊ­9ÓÆà/ÁmŒæçNíôV†5dvé;GOrˆÌ') '•nrt2ÿõ™¤°Éjïm¯3у5R†ë˜"Rõ³§œ†=,Õ­”*J=•l 4P„-þD-ÒÂ^ÑBzdðA%lÂ*TLßòUe5UoX€M_`DoÌÆÀ-;M”!ðbóça%OÏ '§EÁ3e$‚F•éYãñY)säöjï߯£)Z‘>ƒBQ».eÍC(ÈUÛäQi‘5®r]$JÛb é]Û¢kìU@ê-¢ª«RUÂü¢UyèU7õI¸jY^À8VrDßý¤+„5‹Ä¨!Œ•EêNw£;ÁKYƒŽÈò/fôO¡ÕcÝVG±cdm¢n»$W±ÔÎd‰†[ÿÂ$ _í[a±[ŠÔiDó+Õõ¡@…¢´gæS‰mhÃ2Qdz ¤ä6)ißòm´Qh•Vk•«"DíA! pÕW³öòÍÑ(VvwlvÍvb5±yŒE“0ÿ0–—`ôWàö'á–lZ«•<'ïvn³ãnmBoKÖLêq ³Ð=¿qÕ<"µf‰ôf Q©Â¦g{^1Ž^/×O¤ .(©#{³sC—8SU/*Ž~ä,Zâ^6Ò2/»(V8l˜vi7wͶ» ˜v‘PO7VY™5ÿÌÓx‡×F§UnëvdG¶x‘w5x‚îÖ;ôÖoS1pK °3ÿçó)U=ˆôjü3ØÆ×S=ã¥íÚ _yË >`äºsE8݆_·J~y¸Oü„PläWY×vÎ%-žËk‡ÕX%6bõ!r—$V±Ü±S 3™Ž—xÏn§uZ“W Á‚E¶gîöy±#vJXp±÷„ƒ¢ƒ„‚…+õf-Z5u+g˜|!I^Òâµ¢*† Š‡»oBºôs)à7· MõÉt¸*äeº­äö÷‰ýê“/OA q"w¯øŠÏq•¹³vÏÖŒ€—1›7ãÖŒ3ø'1xF=ØZí˜Ý˜uôÖŽOø„ÛÓHé3ëFs\YWe@e¸ÿ¡'QÎ"B¢À®Ï¹U߈‰8U7P éµÐ"šM ˜ø“qŠC™DåÊ%·(‹mwbÇöŠÍÖv¸lùT<‡.‚‹÷ŒmÔ–wYZK‘—…ùnmÔôö ç8˜: «7e‹9 õx£“Æe½#Ÿt|;6÷嵜@^ò¡‘¬«¾ŠÚÈÏ7ãt£¶(ÈÙ,ú¤Û”Ø@;Žà“Ûyç2Jø•G°¸óNï™q¸Ø•wL±ôGwy—Y™c)º—¥U'˜7¢¯úVñLì{w¢ÝsMdçÕ•añ'ñv¢ùO>õÙl›K—›A÷7ã—Q¢–]dÚ‰ÿ†'š Ô@õw¡ØÍ•h…cfelPvSy3‘lÏË©õσ·– ×xxkT™Z˜ú³:´§«_o„w ™¬av{_p»n(Ð W£ QŒ…ä%†FN¶Ž–«L¥É¸+™tMzœÍB?ì °oº“€vú‰°~zŠ€ZE![©)¶&ñ´Nd\4Y5¶²9[ ‰w‚3»F…yƒA[˜‘@—š„ßÈ ‘µw™;Ó3‘…Q ™‚&.ƈ›¸—§œ!$›¡J/R:SUÁ7¯U³Û”›+qz§uz”ý*ÑÔ(G"ŠVd£Ý¬w)¶•™Ú»~Zÿÿfùweè0[x1»‚ׂ떡כÆÕ[Æ •š–LÇQÑéû¬±ð=ï8Qí»[ï±£ãÒ¸-d(‘ |®}[ÁÙ«Æù,ŽûÁ½íä¡ñ˜8š{§G¹Æ6 °`%¨ã'6. ‹ôÙ‹…„©í™;GœÍÓ±‰îôTœÈÎ[o©º';½Ï›«ù<ƒOÑ _Í={QsüöÔ¬­÷eǺ3“æzíf+š£/†üâR.ÙÀsäxj÷¦Ëb¦«üF6ù¦O Y€<2`§`”è¯Ê<~dÉa·sÄ7×x‹w·qÞm¥èÜÎã­³ÿOƒÇ[¡ß˜ùœ½¡Wzÿµµo)€¼Ñ¯W>_6…íX¾ýŽ'=…Yû¾Ã%ê:!UkkdÏ4÷/ÁI¦ó!ÓŸíÔ“;Ë_@Zý“ àød}çh½Ö««0«»Ó|¨wƒ±¸ó‚î©e4M£ WQ«Z—Ex¡¯P>‰æøöšÎ$äµ}³Vû¾=¨Žª½)®·ÝÛUÖÛ'Ò]£×†ç®íuu»<ݤ•§,zX¦ßɉœ(¹çÕåé‹cßeÖþ€˜$Ò*±~(M¢"°§c²xEØ&c¹²÷/êVZg\—ÕÛd¯éã?žä‘äM¶í³ý3—ƒâƒòþãÿ›"÷D3eUÞåï;¬;Èå•r³ðb 5.m;J™ÜšÏÂ,äìÞ©Ô!ÿèûJ :yé­ö^ýßàr@ÖàsD9à# Ñ­”qýÑ,J6º¾€!¢¨»Ÿ—¼‰½ÙsbŽ7zÍøù¶)ÎDkOøùvpÇHGâ>ûøäí3\kþ¾é^e“9Û ß=­Ý¬†Í"Ã>5QŸ·0ùÙÎb]¾ß¯¹ß‹CË™îáº<þE_ÖýÊ€*¼Æ-^ÀºÂ€@®ê¨‡Ð Âƒ :|1b‚C&N1U*7vìXKãC†F–$IÒ$”&/DâòB˜ÿ.Ø„)¦M›5kJ¸ðá„ †Š4©P¡I'½ ¡(O¨QƒJðùág¢@‰þ”4¬Í¯T£J0„ˆ" !è͛疞\z!êÚ½ûáîÝy! ¼-Ñ‚…`yòŽÜ;"0dxðø†#%8P|ÙA< ø<0´‚£\ذ`A‡«#:Ñ"ˆ9j´ý1d*”)IRིd𜆦¼æÔžÇ?LpîthQ¤L™NîÔyX©OµšýUføñB¿Zåê³,X³ú$ø×þ\ºrCðå«Bß÷oß¶xqa…%†Á=‹eЂ‘aàÀ ¡ƒšmæŠÿg/pá…ÄC=¤ „škªyˆPk¯¹†PõXtQmeô‘F+ ÜK(Õhcq3mµ\r>2ÇQHA'ÝCu…QIiTd%žU[mUTVØ=åÜ“P9TT†äå× '´@Ï rõçÖ[i¢ |/´@Ø vObòðžŒEö€dG8xY„†Äg pá›)di 1Qk&šˆbC­È¢‹/¨o½yšãpÅw\©;é´uª6URÓM—%TåAù]­àU@VXÙ!éUˆ•Õz`ÙX cÎcæ ýµß± XgòHm‹9† d=&á  úBÿâ–ö‚¢…b(ÐÕÓ¡£¨IJb¥(R [Š,ÒF›‹ÙŽ æI?í¤q@F×dS®©¤Âª:)”>™¥^UBqùS8‡UQUVõ+8¦˜ÆŠ)& pª¬òœÔN‹ÌÕÀcyn›Ãd/8!ƒ;Zhg~V®g¡)ô!ˆíž¯¼™¨¢ŠõT”i¾š¾xV¿ÿ²dÄåtTÊ§ÜØHLpöÙ[±z¤ÂL)¬+”¿ŠµqŶB5•[âm%XÏAG$t` a(³ Oá…ÏY µu(3Í’gÞ}>ƒdå~‹Yš}„A‰½áh®$ÚA#>D©ÿÓ(F}ïl²ë B×Àm}#I.]¶¦ö¤vÂEb'Âo7¥ÝÅJ¬zCØêq’b%Y¥ôÈOæœÚω÷8ní´uҼ͕çžeŽÁΖExă ZÖ`º†š[º‡¥‰æ.¥­»^)ØÝK6šª‘¿|Ó­ ¬kCŽÁ(åPçU›NªˆD.e‰x\±Êw q7* é:ÖsXS 0yøqÚ;Œ ½G€&1ß›Yùs>ÊõiAŠŸ ,ã #À2ê B¹Ê´t¨BüãëJÀ(p€³Ë¨x’EG²êÁ£ŸìJHGA˜á¦<&-%+{žÿY<˜$ì`°)Œ˜#<¢°/Œè˜äñ‚ÃX«Zß³`æ½MÎ|”Óaæü(AÅïžTý>4Eá¯t›i¢A:³ºÿEQ"öš¢lhc;Ü!ÐS&¡×FÅ@² mSÂ0¦Áò$L—ÑÖÂìv–ïðêŒC©#ï˜Çdö1™ÌT¡Èüò‚Ð0|ƒ$äbîCš¥ï|zڡμ%Éù9QôÛŒƒ¥Éq ]Mô$¤V#ÊQ&D€˜ª§Q©JÞü&ŸÁÄc2ñÇ•[–r…·Ÿ$OŽ sŠB¡•º1‰IHÑã1ù–<SdΙSx ðAH bŽÿ`=N‘×2ž*‡¹˜> ~•?žÓ•lþ:)´t²¦Y¯ÉÉ+¿jߨRTéÜÉY÷ʼÜ¡ZÔ^×îä\¥ªòáé½Uå… 4•MŒGL…¹®®° #ÌL¨'×ÿÊå0šßÒf ?“¾Åùʃ@‰ëÑx«YHÈOŽÙ¡Ÿý§C«|ÛÜ>y¹4“Y—¿<4ª´¥Rdé+>ÿNÐeõ@ã l«ûnüq¢“ªT9 ¸ÊœG .oùä÷¸&ÔûH×þ¨y×Îú]ÛÌuW ¡CgW‰ÃõÈ`(Á ú2emÏVc&«˜œ*Zå€òÜd‡StŠk3žÓ;¡D“º„4BFȺÿT§©Úc¬ÉQ¼y9elF/ÿRvBÌãPÂ}<.æ/åwþNŸ°û+¬\\³¹Â"“pÄçl°AbÕ•/ÀuÖ0]‹¡ÿ##, qµ‡mÚ"ràem9†NˆF?sWN….Ÿwê¥YÑ)¦§ñ^7'5òk#mÓ65t$‡tl“®`BtdG·À>¨QN§\ïE˜\–÷s¥\H8„ WzÈ„=6±z—WFT]<à"%‚!ðºÆóð¼Übcí£mŠfYŸÓ†)w^ŠbËá"?v‚Œ)*r}2yª‚KnSF7¸ƒ«¢0:ȃ·0m惑ˆa?h\MX„,P'š™÷~Hè~KHù÷LÎt$|åusv€á¥yõz<0/€ 1d†0ÿ]hÕåvš³hæ(nÈh…ò>rÈmÅ'Œ:&nH·âx óG„™x‰êXîèŽ6i‰¢—Q†[CŠì²ÓÖíók%¶' gAZØv}‚^w{Egî#N;c.¹mäÿ!8U‡CT‡›ÑhVLD‚Ñ’åVSó4îÕ!a †’‰hLÞXGõÞŽ>XGàèyöØfž“âxa—E¨\˜˜“èØŽ'ÐŽ‚‘“, ‰Ži™ŸxfU§GØã™§HqK9r±¨¥é-dç{j¡‹ng«§úÈSG¤|…¢I&‡²›eÉhâæcßF}™²zˆTôµ‚É9—&9Fwé0]†=Àå™ÊäyytÕ „×ùyƒYz›wy· \’™“’y™íX™“©ž•ɉšØ7k^v$ÎÕW|å $6š×2RvvA!éŒ!/€0•â|eÿDrÆSã4vØ|dÉ›‚òCèUNâV:ª±.9n‰œ)—"ˆA!ƒ‡Èex4z¹¢yùˆ*Úõˆf“8˜M×yâ)É…Ž•ù˜–©ž?ú£ìI„ WÉ4°HŸ~¥Š<Ã9}Ra'\G€}Ò”XøFð{å9<­ÐÌ× â¢I)¡½YmÜvYDÄ|˜U!#â(}Ø¡Ìø¡Ïh‚°ñ–O$—1y|™yÙf6ÞY˜l†ÆÅpvk•訌yyÊ⣙ ¤ˆ8‚q“ù˜îÙ„Lg¤ŸÙW0gFÄ99{Zm® ‹ ò0†Š±-Ù6ÿgXŸõ°|¹ŠIt8Nd‡Õæ>hIãÒ•êõ¦ §0÷.vê.H2—sY½ƒ&ôožiñiQ× ˜ÞÉf“hÇd¨ÅEŽò7„˜7陘ʮ˜©ˆžœø‰K¸LÊä™\'bà 5¥=Ó>ªÚ>3Åu Ù' ¶|e”ãµè•˜ÑÄïCÈuWNö¦F–{‡ÒNÎhœt)ÉÙõ&A<2Gbf¸…ÿC1˜õ³-гàºf·æ½‹©“J¾—:™HÌ?J,™”iž{ÃÅѾØFrÒ6m®l¸ ÿØŸƒ /Ðz°× »[É ‚›ø‹‹V¡ikÅÆS†â±DTÊtмÌê4ÒzÁõ°oÅS­“­%L½…úˆ$ŒB‡Éfˆ[£î7Š–7ŠJžáÌÃŒ8ïz©Ä|Ì|ÌÇ2L{ÏÃ¥ŠR¶gµ.6{Ó…qØ"AàuUëѱ{SA4Œk:š ¿Hrá¬wš…›áòh^Ù«£¼Å!Y‚=—(‡Ahµyù·´¼QÿìˆÜé0¹fšgkD(žH¾à ¹‡©ÅÿÑʶ=ÂŒž@|Â3!®`‰Ìº\Èuðš}ÂÍ!v€ó–¶wh—‘›Ã˜m\w˜ìCuø|t?Cu±|((’Ð}ÿÓŒ…ý$+“ˆ»—ImG„ùÏp\¨wlj›³slŽð÷6ÙЗªÇÜ©ˆñ=†vDk©a B%ö'æõ- Â-6N³JÄ÷Ù¾Tl^å D% ‘ŒvØÙ†±gª›Vl$€?Yü±ÔÎs¸Sg‰¬ ·%+sqÁ]„7eŒKG¸cf³|Þ¶e0г‰Êp=[Žã)ìH¹©ý®xG°)åBû}Ç|Ñ:ì3=4YTÙÿbÑ6º~†ì9ST8ܳ–ócÜç„cj‹»½ÙmÔí±Ò}?‡R.X¼Ó_LœrëŒä~C±6ë·Þ]¨Ø‹GŽ8ËMMpilŠš˜‰Ú³ù¸âÛŽEËÇDK´âÓÚßãß®R, ÖpÝXù‰¥`¨q—3P6!°S)®@›Ò&·3à5DwÅÖ]»Ç×-.×ÎešN†âDc±µk±ÂkÊ쌔2—ÐÈZ!+y“Ï|¹Ï€«—ϤÙhL¨0®Ù„‰ašmfUk¡x®é Ö“ Ñ—ºß(Åß(¥bú©0]aYbL°…Ħ-a«Ÿëb+]_«Sˇÿhñƒ(wwáNÎ ‚I¸i!~?ãDæ!ŽØY|.l¼$[ÏõŒõ<~Þ¼÷¢Ï›ÙãmL¨L ‰‰.2qìtò¹¿œ‰õ=ä'5 ³bG®é†QEêÀWÀ.–m$eº ®×X*¯ÛåaD—.¥ë†îçQ\»|cy.™´ÓNp^? ,iîâD{èÝÈzâ_16¾ƒ*ê¶œÙǶÜÔ„J˜œÇypüŽæ+é•Ñíè®.¤b1O™Jó ͽåk|GÜ$ÑýÞ •û>!⢕;c /ç䌑dÊæfN¶p¾ë.§ŒZÜÓ˨ÿÝñ|ì|:0Ñs¢ÿ¼P—LÓûìé½ñ}³¼\¸6ô`WèxÕ+_ß`ÍÚ+¶b3Mšžîõ>Àß"ÄT¬q;Ÿ-1?ŸÛvÐWÃæ V‘ÃMNÿkÝq>Da)!m¾ÎL<ðd[»oÞ¶êå(gÉÓ¨ìÈ~Òjäaƒ()Ÿÿ·xdWËÙªÙLŸˆ«¢¿Òék¹éh¾.oÌ`ßü=óÅC3o†‰¥þÊ'¡‹ôº†Ü>Ðß'»zF”«3Fhšá>ž¡Dþ”^Ü–Içr(e¾Ó!âìT ±S_T~·N AÏ‘M 8xù¢09èA‚£ A˜ ÿ0¡A‚B88oÞAF>H0$!ßFKÌ+q"dH%Mš”w’EJyGZÞ;ræ=4!p³` ôŠ¡g† ?1¼€ÀS¨Ñ£ˆ úÓU«!A¼’ÕÁÖ­Vø V싯d¿n{Ö†µhy7«¸n¹Š=7¯¾}ûÖ3Øà´_ à øðâzë n°ãÉ‘%\ a‚æ  ~ž€tA‚£GC¸Q´A…?¸†0/¶Dˆ>2t£"C†œ'’ÅÈ(Q²\YR^Ê™1kæ$‹ Ž8ýÉ”mO¦Ax(…úâˆO#9Œú|dÿWé®e{u,جæU›¶0×­lóÂð­ÞÊ .üôú1Äó«Á÷ÛëÇä‹ÈãA1ÇËP²Ë.±3ÛL3h5Ò B± Ñí–kËL‚fœÀC°í6D(ˆ ‚A¤‚× A"D*TJN9—b’ :š¤;¢„ JàÎ'|‚ªËžzÁK¡2ÈÁ3sè’ ê±Ê;žØj@¸<ëÀÉ:Oþ¸*¬9õÊŠ@T¯ÅtðA¾ðƒÓÐÀüBŒ² #«ŒR0Ãl3A+S„H(1ÔR­ P?“€ ƒ¬@È_­Àoè1‚TEDÆÿŠ<áH’TJéˆ&Wji‰˜nr§è–=‚WXÈ.Ë ¶ã«0»$ªÌ3@O½!Ús€‡öØÊÍ<Á¢S¬:Õå/¾>Ã’K.éŠ+,xáb0QMË¿¾\yô° »PÃróSÏ Z84I«-E^ˆ ¸øCx¤€Cô RŸ‹f”ä{´ ÇVVðXÆ|:b¤á˜¤9¹c£\6g4Hè:ôŠŠ–Ë¥„zA¼¢*SÛ}´å ª:ÊÖ2`ˆ!̽SÝsË:Ë,jÝÊKÎxé5@ìsÃFp`EýR ÑÃÀŠ1€kPRÕo>¼ì2†M;èDY+Q!ÿ…I-µÐ à‡q]õã LFä†Z± óDD>î×åŒCÎæåŽ=vÙX+ßä2»Ø(ªË#Š“L3·5s#0Xr] Óõª20kýÖU«?à¼W/B¦ð0BñŠËí|õU{Qþò¢;Ñ‚ñžì¯½ö¬á‡?ƒˆ „Ü~:åÑÇwSòWr „‚V¦*}pFFJ’°”ã$ä,Í‘NtV—ƒT>ËRí²C” „çv¹Û]à;3ÁjkyÁÆe¼¸¢@öb»ö´xáåzStíE_û¡Á’¨ðA¦Cåc›0ÿó¡¨o}€óTÅ(¢ P™kÅnv„«Š" €>B€JX €XÁnÄH*Q Í„u³Nu´z|ÒA=þÌKây€—æ;Œ0®`P‚p¥ï[uÉÓžê„–‚m,_ ÐÀª§'JâÅ@Ú#¢ö Âü燉)”ifaN„bCXc±ÚTq˜!,pÅ”µ¢c+&LæE „@þ;ã :·L}äCô˜‡IŠÇç%7Që(˜ƒLv} š—ò€ë``w$<§™^0„ <ï(<(ž\Q<™E’w±g|¢g–³á 1j#%íâ–ÿî%Q•¢ìË‚æe>ºLoáÓ`XÉ7X> " zßEGU›÷¥j—š‹@E*/z±€b >" ! Q™ +`ç@—$šµÄ¦ÂºfµIÁà}”–ì€6”:E„å!aQxð­¡8dyçw®rÏïQ5Aé* ¡ÔF!üPõ{ˆÊDÚ¶9€/¥Í—·DÅ(F˜2‰"æ ¤†TëÔgr^òUe+Kcç`*ÆyäÃ`™º¨X¹Q8,xÒM¯Ù˜,ëÛ,S‚05p>€²Úe‹jÔ£–'/pÅ~ÚÁÀ³-®—We /:凶ÿDÌ Ó<«ÿj0šÌÚ´,*¡ ßp4C Á­™ª(§PôƒÜÂ} YbåhÕŠ€ sšKì`;z¤Ôˆ]fçøaR~pDI7 ÖÍb’SeQP$§+ •Øõ7¨ž-j KK;Í2µ(ö!œ‚@¼¶ð©-ú¼ç'÷ßëjQ]mX" \ÅÜn9L õI ž²/«r«fT̃¿‘¨4¸¼®u'€›ŒÈŠ,CD3W ,*V˜l=ÊËe V.ø"I 8^•DX0™,êfìô'°Ú7»¡8;µëÉQ÷A¦.uµh­ð0à&øÀ‡†îºç¸6a±ÌK“ÿe“¡WÜIéímÿ4WÚÃ;(¹è®2s‘iŠDµ¼(^SƒuÌÆÂìæþ'Œ^bHüÈG‘èñ#/ÓÇjJæØùæʪriµª€6v@ãc®ÑÝmkò^ 3®0µÖ*ÔBö×ÞÃIv’+ZÐb켃m¬”J壴[AŸmzÝÞÚ LÈ¥83ŽþLiTƒ¸)ÄY¤€/w¤Æ’I ÂF-xÜ 5®Q˜ä-¯=J&LÅ’TÉ"[É“`’:lâ'4 Š&@ë!¸œEác–6àídà¨O<‹Â-}B ÐbbJ´Þ¥µ=͇‡q!ÿÛÛx g¿E”©G¹Ž8¡sYn´ý3¤ª·¯Œû‹@Ú_FR\QŠØÒb‹k…ãBš?f~ ±H@S7š£ÎÕˆdƒð7 ¤e@í¯.Á¥¬Û«ýTã{ìòg÷H;8q§<»ãÒwHkžA §vâ¶µIÒ¹NrZŒn1üæ“ä£LÀ覠ÚÚ· J(”—"w®ÞJ¯±s3à $£N?Õ(ðÝÀ{úø˜ç> MׂZ$ø2‚|äÃd.ð"ò—ù ŽíÌÊtn÷ Xí;:¼g·ŒìlÙ㬠“gwgrý”vä_3#ÿûkk 48lw‘d kèÏ wÞy”/îÍsÞgº™õÏ??ݘÿã!Ò a‚y(}xyxµ °Ž0Ù¯r ø‡‘€ø¨^’7a*& X)| UI#“R,€+>}08’J2Åʇy8Êj»ÕÁ‰W«’˜ ëk“Š{žŸÁ8Ï’ó8û?nÉ¡ò¤)“Ÿ¨¥X?pê–˰=ÉšAÛ¡i{3¨ +—J‘¹·©­®=™S+C ½’ 8\ÀëÀ…8t€6Ä` Ã8tÃÐh7†á^Òœ,#“ cú,™SK²fRÁ#sA,)Dµ—ˆµcÖÿ©² ,L ‚¢™§ª@!Wp…»§(Ô>nI!á9n ¼ 0ÚY³ŠE)t¶ «*–Ó@)ÚÂj3 IñÅEñ¶­º.¼0S’ž8Ä…ëpõxÆft\ ‹ëÈDÛ ,i­!°€Šç*š§‚€P Ì à#¸²[DFDÁ·™XJ¤ ¢)ܱ¼¥ª¸ŸJØŠE¼BÐzŠ¥r…çABôh-ð¸ÌrY [ë#ø»¤*¬*L´d¤*𻋹‘ Jq¨·Ùª³q‹„êBã*@Á7Äh\‹ë`ÕLÉë¸HI<Ä€(6„`(!0€fÿx†gøh€†Ày˜‡" ¾¢Á5:ÄÛ2âC¾,»fj¶Û©Õq¬ëÀŠêóÄ¢X°`ë¬(ì>ŸxÇ ž0SE4 E3 8€³Døã­*”!´ ÆìÙKj0çA%º9(1ÄH*®DFS:FüHI¡pÃȆ8d 7¼C\¸‡È„ ø£|L†€†K¹€k€``¢yЇqã"Êù" )!s‚|pô€’:8}˜™zÀ¯„г>ó3‚#àˆE½ó2 Å»y“·|qiÅô€E=9.q B±'ЬÅu1Ý¢ÅÁ̽ÿH%$" ™“È@3Œ³B »C,Ñ|€€)Ù&4ãú°õŸt€Ý6Ÿº; áN ÿÀ»yb°¦øõ¹|,«Î@:β@LñÔt™žt±*r3® ¨®H«ì!1ãÒÒ [èÏWëÏQ7üÕQhC1 šh¸GÕ4J›Ä€kÊê°Chjì{ /â«S62µE´J%S¬à” €#0¹kŠ˜Š§á‰Ý9Š©É ó¸ÑÒ58I­cc‹0QÅyzwÎ*R ¥Š{þ¸^LRÏ›ÒÆã-¼ @©ÕS ãj¶,MC‹Íž¼šd €¬›¨@dÁ’yp Í¥úÌ"i@›RÀÌ  “œ“²‡ò*€â3¾£#D¦wh¤‡Ü\,«ìz‡q%qáࣂVH€“¼H0¼ä²>â$HÚ¡Y‹Ú9¡¹tÈö;€ §°°<ËkS­!‘ ¨)]žù$P$QEp½D©3ù”0º¥Y(-m¨ !ù ÿ,éÿù H°`… *\È ¢FlH1ŸBD „l °!"D7nX€vM˜!À„l” Z!’ð¡‚¡éœÇˆ£y,äÝ“'ży'ŽýòæÏ ~°—¯ß}û(ÀÏ¢>~G|\ŒHñˆÇ#(ÆãG¸r¼|ñ,Þ̹sgÄ  LHº E§ LMq¢k‡ª¶H[5aÔªù-X°aÁÝ‹3^Ã…Ÿ°»+ñŠ¥ùS©Ñæ<é!JtɼôìMÅYáC‰, ÿÝÉHû„ø„ÜЪ•‚w”½ñƒÂû7.¬Õ¿6n{$öáÁQ°—_ùØã×` nV›DŒ5¦˜ˆx Od ]–eÐafƒèÙˆ·Á¶Pi²ñ“P>²­H‘‰¡Å˜â‹”Õ8¿íFÁ ¿muJB”õ^/E0ÖMó@€ AuÂsK 5 'è¤ÝO;uDQF97OM ²>ë!bÈ™7D0¦÷ÕÊ}õñÇU±eH}â÷ÃW t÷` 2Ø`ªábŽAÆüLæ¨>Žj–Ù¤VZ)¥"~öÐG1ÒèéŒ EôZ§¤YTÙj6žfÑ9‚Ò ìÿø•cyUVh…Hð4O 'e•GKÔ=È“TRG5)Ï÷`-•Y&zê¥eˆgÖ}øÜÁzHè÷TpÖH 1ÖâuCöÔ» ½ƒUPÀ…U !Œ)†¨#0ÊjX)‡šq–©Ã!n¶Ð¨±©h±§€Ñxب›¦ª¹ñ3‚ -†Ö\m`L]µbäXfΔS±Mžð$•AI9”²9ßã3@MÀPã={ Uñ³.džÉí™\y5 .À æ|ímKB $Lpæ`ƒí.œõéW½ ÚkOù–СUؘÁŽ6*P<“Y†Ù¥|óÿM©¥ †¶)C zj8Œ&â¨âæ1ª82¶Õ [µ¢#"./ ·œÏÜlQÌRy,Ð’¾„PBg@@B}„“>­˜l`æ¶p›ÖYøŒ .£„[–¸\׆öC¸ /|©}¶_°h½>úÀÁÛchð@ys˜7Þ§F ¸ù ¦oâDž¦æ¾B…NÐûÝ0ÂaŒ¯ÊãG70fùXš£\Wb…ˆ„à41`slºbnhCC]@APp‚«šÏDÁÔ¸Ú•[à"3¹ >¸@†ÕäÓ¦´ Áh1€(à®7½ >á* ¾ÄÃÜ1"ÙÈÿ³¨Ã8j2vC"a"Õ(Lù퉔È "ª­¨4‹Ÿü¸ù‰ a ÑGŽptƒý!b¸Z€GpµÊ"Çû€>º3§%…YÓAVР% ]P¬ ö8%ŸméKœ×ñ°äŸ³ìîMÁ»Ï›\È-ú$Oöa¡$[aQx2W{¡×ÚÖV¶ù ˆ‡âdU·# ÄCG\¢eæÄ¿}F"ÜáXÓ8øm±"Á„¡¸V•1Vÿr^"`9fnåI Ó®Bàeës}„ ²~6Á@vó‚BÛ ŽÐÁhç_Є Ttò³ ¥=e^+’w6å…œdÓ·„ÿ ªáƒ¢ŒGÚcÊì¡ò#$‹£Xy7»%±Fãã-ËÇ¡½9±b¸”H§>æÅ_Ê/!¢„ Ä€¬#j\€>ºr¼te\,A °Ò™8çIHIÊ[§Ç?~sBóQ¨SªìDXÀZgBò¿±dO`;Ó™^x'°|N÷ñÝï,PQÖ‹^Ý)Ì¿´G00®’&h¨£0Óļyˆ2o}¢ø6£>²"/âeÈ0ÊWrtdYb²WÆcª‰2ñŠ\J—,@JšÇJ–Έç(% JëxººoæÀ³B+ Qø˜é<©(JR¿$ è5Kñ$¶ ÿTà·¥@ï"y5dÀøgWIé—~${p{L…’hćâM¢“‚k¤ư‰Z*‹ ÑåõJ#-.„~‰ÌNʱÆj0ÁË ”¹ØV A'yl’  QÓ²-O°ô(´@œì&h5x-«(Î J´ ù¤¤TE]k2Dó¾EÏþìG·‘Äj»Þ„ŒkãÝe)ùÁ¯ìŒ¬#`k+ ÑF±–´¬¥‡ö8Ùøq{Íq_½F†œF¹ÊbÑ(„ÅÆJ±/K„€JH@)IªÊœZž*Íc§A¤ë„"`@~œA+J‰Â¬-µò¯aÛ€¥ÿ0D‚7¯ •͵*œÜ‹„À¸ø0¾ìÁ¾tS,"â)H9·‰ÐbÄ*Ú¡¹¦P‚Ë´_QU›Nëø»4¯À+ö.–rK^l’OB&h.‰YÐÌÙ Ž’MÕ­›[îã—?ë_ æZ¨N"ó•¡%N<ާµø`Zñ8²;[8.gÙS¸Ú”€wá£-¨mdÊòjo1j}ôŠW ËñÁŠçŽnyctW¿–(¯³é%À“Žz€'Áq”<¤ÅºY” 5BD^y¨߬Æ¥{òá¬ûl#x:ŸÁW*‚çôž4-QËYx¥“·¼“·ÿ‚V)àÛø?XKÙ¶®"nëVÍ£VÜD/lCÚ¥å›å|Ó^$LmN¥W^r· …UŒo>¢F à¸`£W^b’–.ÀG0˜r&Þ9¦z_Ô?±'µ/!W$;¢XÇQ$ñð,‡ÆG,twD,‘ÕGÄ|AeH§#|Dk 7T ''CÀp 7°paƒZÑ?'DdU? އ õ14ç/¹”Jœ2%¢bµDÓ%K w)•n%bP…tòvz¯¤"%ònqŠq µ”¨Vd xj,u¹ÇLe]ò{—p”,™e>!W6q¤Ó‡4†$TCaeÔqMˆÔqÛò€~ÿ‡Àfuò9ø.š3’'µ.¤BÿdkÃ"qbˆn¹¡!—!nQ²4t–Ft»"]„t ã…As¥Ô6’cq>`€T'¾Ad H{cQ†-”c}!Æ‚q¨svG£‡Íè@Ù”,e'wüU`CcH7÷R8a¼A´eV‡ 5XroC®NåT>˜ £€ žô7ÑUþBŠ©Dñ'Kd7qõsP$t—¢n³ˆ…ªW¦²…29v¸µƒ2+Pd‘D’dë…dCâL+ˆd`ʲ‡aö%öàQ‚:47Nœµ3xt3ãÿeTqr7Ðé¸4£pS±ê‚xP0CïbCàâI.Q<ÜñCþÈrtJ—Šô‡)Ò5>ô×b¨h_È¡t!£/”q#¶…ezeÄ*jbˆ°Ž”€^´§9Ì„F±×^P†”S@%93¨#,ÓfFaÕx,>£:÷0kzˆÛˆ¯“1à+ e8Å$<Áfr¶„d²:agñ–h Ýâ&7*T5qˆö[‘PÄt7ަb¨(Q­ø!eQ cn“‚DT„…:ö#v•Á/5^!ÃÈ‘ÐpKf±Ò 9$EÂsáFãØò -–q ÿVv”¹SƒDô $I1NÅ7%6Ó?a36ã+J!,ø+ó g7 €¼‰Õ—Kî1 ?И˜t1<øàx˰ B¸-6ÁS¹‰Q!Fäh.ÆyÑåy¸I>œ)Lô!ï¶± œÿ7ÈÙlCs©"o†Á*&…” ŒB@ B[‡” 3QBgQ@,˜$'ˆGc,ÉB4Ä_uHTÖË‚:L*ÎØ`Nò’Ce`[îaŒP¶eg†&ï±s‰RÕ'Ä ËÐ Ÿ0Gè'Å)Ú(„i¹ùV/F>Ð¥7Â8$*?,’tJ¨–6²„Šÿ ¯×Fx‘щ+”pR…†D"+@'öF%éà9w¶%Ì¢Y~T¢%/ ,R"l=Q,ϘªÎ7fÄæ:óP”𙚢ùs1ë!UðB2Yu~Ësu&G7$ƒ]y›EÓŠŠÑy’U(œ¡‹¨’‹ú®.2ô“=»áçúÖ¿1K† E–€ðF$G4YW†3¼gÎ×@gAABÕˆ)l¡ó|',§¥`в,°‚gÒqQQŽ®âHÁº¦lÚƒ Ú Í „iÑU1³š8å5§q•­"ŧ®K›·y’Òc…úK¼‘¯ÿô„æ8¼tF¹#”ãðªR&¦lH{oi i’@¡`²J,ç|ó©K@µãÙG K%;¤Ã{‡ÂBlWËN51¤ÚÂRµ;d¡ núaÚ²Si§X‰§­$­®¤¡:@÷J"š]……-r‹h¹¨8ÖKˆÀa©¿auB0! sÙó–R+M‘«@àHÒµŒðŒdǯ=U‡Ô±³3²;U«qÄ‚ÐQ,Q‚u‚ŸH1±¤è4Psšg1~? BÈÐ V ‚fͺ$ƒ?ÐêhK´yÆyo…­ãó§…ÜJiy½ýBâšœ¨úBÿ@"à³K³Ф5Ñ—5õ†%p@Þy, {wدD@ÃjTÒ²`¨;C#-ÿKf¶ùº,9É$¥Õ+KkYQ! ¡¹0RŵrCtËð ×PÌj13²È‹¡XɼxÃ¼Ï i|k›¶I…v…Wa¢Ö«„ѨA–(Šcßkd,¾ˆÐŒR¾‘KLJRvtò´ßyw¤ƒ¤|Ä{ÑBf×4ªƒv>³¿ò»MTŒ§#:IQŒ`“ùjuÒ²Ëü˜@¹ó4 0cq7T ÷ø»Ï° £0O‚VÇ@„\È €u+­¹VÏ5c%l­‚Ày…Õ‹¢²QÛÿ[#Æ €§:꣕ëÅÔŸJ@JùŪ:À?Ó ËGò‹`¦š:À¥;ŧKNd–3´Æ3'ðÅç´M‚H®†YIÁù`r8qÆÀ¬Æïò«  sÛKüȵnÍÅhÑŠŠx»Šwë\58ظ~eᚨ$6béEÙsȸX”—e9õ%y”ºN AƧG {Åî9Ť°N;Kœ’Ðá|Nûj•Ù`U13PA%ëĂࡸó4óIÈú ÏðaÄëÁ¹4V!l·LØ·ì¼M8Èøw€ëÂÚUz aœfùŒœCsÄ?’©]‡Î ¼,Äÿ2ÄóËÊ §pü[ÅØX:S[A0©Mÿ5ˆZk3 Ö¹CÕ`™õJMÍ$mrïHcµ-kËÆu¬ü ÈÌvls48‡‘y…Ü„IdÖÍë„znÁYE.lE|å…§‘³·È…Ü+bJÓ¹d³W$4áÔ¢C,, ÄÛôÎý…ÊÈ"%U ˆ0IAƒ´3€ø3§‹˜CqÙ±CTÊ,óyô0ŽÐdY8™™9ñ”x;¬-»[½» ƼÕƬ?d&E²]Ôhã–­Œ½xÓ›Sø›OômŒ¸#M³¯d–fi1¹hë‡Óy¸—dfò¹9ƒÀ ψ w¬“v¤‹ÔAÿmµüEA‹‰Z ¿¦KÙ‚¸Ï69ØURçTYL%Õ÷ s¹s;óˆpâ;®½ÕÏ Ã Önt—G?­´y@§Â%œD˜ñ²27ŠŽ×Üú>LÃd)ˆÑRE& /Q§!@vF- Ï9½Ý­£e¨«ÓÙTrؘ]Ù³Êį¬Å§åÙÍQù ëe¾Œ@4Æ&tBWƒ ý ÑÏ0 I¡ð/Ùó6ÍÍûPÈ$L]Ÿç7"áqsP!=³ðv–àZœf™áñ#wÝi´Hßà˜Ý9N Gµ£çù|VëÝÎW‚ž¬ÙegZwd,7™.¹<Íñ}öÿ]ßõý4 ÝðáÆÆlÌ ëÑU2׃?ž–Šš¨ÜÛ”ö•CçD›2áà–„Õû­³Át’ç8 Áá+ƒ+è8öÐ,ëi4 gkh'4û»ºÞA4H=Ùô»Ù'_9«)y9%: #Ÿ2Ÿ |è’ÅöälÕ'´[‘ÛúXÆúàÀµÍE •Ñií·/&>W>½2š]£–ÍÚl8'Ë6ŠŠœé=’fA¤®kGû•e9½ëDÅÒ÷΃T0nâ¨Ë@Ç>ŸÒA! RJ°ÊBzèðe·¯EÝ%¢­%W¦8ag@ž;°íÈ \Ëp ˰H`éü ¹Ëÿ|t#,nÕs½í„J…¤>á.áó¾iĹ½„ñHd–Ù#Fj„+ba&9±b<âÅGºq.ìwGl”-ðTجAF,Ì‚ñæT=ùΜ]Z-™SofÀ fˆR@eÇs<ºc`äýÝ g[ùÖ˜NL³iyH4n›¢Ð¼s\iÖmM)>ßåóK…S³ ±­gdRjÄæé\Þ'àÓT_õUü3X‡øŒÝð¬qR:/ñdŸúÐ6 ñùµú­?®¯ýŠMˆËÐŒ‘¥$s˜”IüÝ ÈßóÒÝÁ~Nw*åw;nj7Žöé_)Ùü`ÿ^z)êiÜl&Ã#•+3Tá#îìÀNð›…Ä¥/4 ¯Ó\+ã¥%ñ|ûø3Ö!0ñž ôæ lqb^‹yO”8ÁBÞCˆ >d8ïÃF敘ÇbÞ¼Œ&H¸@¡U«£€­\¶ìÙ2`¸~ªP!_~7íD¤Ñ~"âñJÔèÐxúâ-UŠti¾¥D‘BGµ@¼«YãýÜ9‚'?D`ù‰[ÖìY´isšÍ§¶mÙ°ˆ(¬X@ÑÅóbtœ(Ïá‘{  ØðaÁGß L ±áÂ…fì˜ñÂéÙûOßgŸ"ôå#m/„@z'RC>}’%ª´-Ò£U±k—šôévìZ³rõZžlXµéÕŸ};¶í{¶k}"ºq‘!Œžý°ò`$3¬±{c ƒÉ p²À*cì2y2ˆžHó VÀð3 ôé,ÖZ0¡ýü2Ñ!Ú`KQ¢Žæñ‹!@šàC ¥~@fG`ZZæškð¡ ¦ >° ¬žv‹€âǃ£¢\J;¦ªtê;¨ «­ÊãJ,ôÐ[oLöÜ[«¬Öj¯- ÀZÁ¾>’ȵŽ€ˆ…A ü/A¼Gž…‚PÛÿ,„‹>‘VA´ÑHK ¡D”SNþ:íTž†8j(¶ŽZ{¡!y@‚€FC(0)ÇâŒëÑÇQn H~pŠÎô)J”RJJ¨ºkJ*¢®vJ£¶, .°¼ “:2ÉlϬ4¯-ë­÷*Àð.øõ#F\„h B L îi·2u3Œƒ{BetPP šÂìÉç}2”t®G?û ‚èA¨æÑ ÄO]„í£TU„M·WÉÕW-À§¸•J†‰¹šÞãé«G¡+*𼓙Ÿ«’5Á©,±¢™K­¼ürÚjƒ6³­4ÇÊ–f£Ï„OIDB˜¤ú’°<ÛEÿ¬PǨnp1y彌ßþd["QÕ&4-F}Z¡•HÛ¦à3´é‘{ „"æ4!ýZkAT‡JõćXü@‚àL¢V|Têqq`„¼Õ&›xÏ+(ExRJ©–ÍNX˜¹ƒ9Mž¹$/Z0ÇShõ´E:iÖ>Ó§î*¡4êhê© Ì—1ª¹6PÝ-³ìÁ|ûk¡ßÖNXBo¹åFÛ4Ò Ž4‚WÚþ…ÒÓä†xnî]û!9Ul¶†ÆçÏ!?‚@‚û@Fi”ZFAnÖejE¢‚ǥ󖺢¶3êÿ%gC¹Ê È3³ˆI¨ Úµˆ–«¢ ®+ÚšòA ]Dƒ1ÑCìÿ˜ÜF„Y`ú$(â T™Ò[òZ¨‰5ï4!˜>æòм¢ÕkE†àÖ<‡io §™#ìö½ Š!0ê”Æx3ÔÈU?Àå7«kœŒ&5Îþ”4Xn,.²ü-eÇ;¬´ ÅÀjUi¤Ód¤¥éhBÄpƒØÅÈOBú2(æÉ][SŒŸBÿD„… ™ 妚zžÑGÛ"0½WT¯m"ÈÀø¯Óp&`ô0b^HÄñT´iH^>æªV®Š©P‰~$¤šä*IÑúÉË.3óŒ; v¬º¶¼ñtpÄ€Ùà ‰^Á2ôÉWPo€"%š| M¡ ½HÀ0rF€È•Q‘‹šx>ÞÐH.@‚.sT ä$§VÁÔN¼1šEsHY)æ¸D•î$‹K.h£é¨‰:nåD‚zÜf}šlAj”N+ì‚BbD"±“îù «PwèZÂÆ’wºÉ͈r³‡&-šIl¨+ Ä@«G‰³¾Âk=(hÜ ~m­ÜT,2*Ø$‘´c_.[…#*†ô—7 I®Æ²À/JNqic¹C•4²‘ÿK:Ët¦yÓ´Dð,zœ`vºS›È1š ç\Z1}H`FÈKk™HÀ¼kxû’Ç–粡æ4shø VIµ.+PÅV J¾¢¬”*%(±VUw”JØÀ.B¡Vjd!äãÞRe$WÝÀ}9úÓŒe4£Vè©b ”¤t™ó%Öw¦‚6Ö .eY fדÓì”f;µÇg ðÀ BJœ¥¥À 1VºÒ!ФZïs®ÛºÐl»¥Çœc!N†F¸Å®pÛ–V(×¹+~.sE)©„º†hÄ2å7×&ä6anÐ ñ®¼ ¥ß5FQjM“¾KÿŽÒUpF%-¹à¥C¹,N•64£ÁÇLI°€ ÜÙЮŽ>”°€8W0„û„` *W¹b'ˆP8Oë-ù,9FtUÏñh¤3)隸z%qYÕª\å¦8h}®p¿×Î0B®nÖqùµ©L:>þQ[aÀã%Ïx.b‡“ýå°ŽeõÓÈ,ûЇ¿ÔÔr{pR4³|`,8y g €GÐþ:o Œ=»$•`%+!.Ü¥KxâW¦`¸a Ò45kX#]U¨âÅ&ŽT(qˆV°8ÝC­Þ‹cì¡,¢êØÅ>Þ̃p†hE:#óöˆÔÏÆÿx•–2™É5# v®•4ý]Å·Œe5]Á`öl=Î`¸h;Y€ŒKBΕ3Š<¼­9æ!Ë“ØZ†ûZ¬Ó Š|‚öà¸À<îYb÷QeŽ€«…t^Äéì ¡¬¶µjçv3ru?9Ù!·þ¼màî/È-îãæp­k¥Dq[ŒÃQö¤C°n³]ùú„ì-ßµc¯ü-N‘⊆}Pÿ(Ó±TiJ±»g…®R. äæžåŒ?>jÞA[à|,ûÖÿ¬È»Z€ÿ½«@=0?F@‰ X .ˆ8É]œžTùò– œf€(Wÿö­2УÛrS«¡K4":´b7áJ…‘+"¢ïi­˜4‘h•µÀ’dè:‚»`R&™áôަpÏ É*Aô¬¬PÁèS ª£[ <ª¾ëÛ©ê+°k~°Ë¾_û5û>!ô»ûµìË DH¿º¹@ª‹(ך¨š­ˆ0›EY¹ß 1é®N ® ûBâ=Ò;:¤ªES+´2±žˆ7¨ƒ=ÿWº‹X³¸ºò*¯X‘•®ë=Dø½‡£VSA@ Ĭ`¾@4A@„‚@ôA㻎û¾Î*Â,BìkDñB=»DLÌD!´ÄHì*µ™ WiC P§Ú²0Ëh—Àˆ³a¨ ÉB-è¤. :”®è4â*¨Cª :4|®ts.ø$ ±.´É*Øs I‹CD¨@ Ô½ã` ¯ã@l!AA,ÄDCÜFpDDä;„DFÇÏjŽŽ‹Dv¬DM¼D ´DxG{€‚®²Çy|Ž«§ÔR­¨¹ÞÀ8ûÓ$‡ŠÅèÁ<Ð@„_ð9 ø…‡$· ÉEáJ±@ÿ$½bD·Ec1抔ž+­r=7d”¤²:36aظkø@5oäÆTÁoGœDDÜÉG=kGK¿ Ê ´Çzü¾yLÊ®šÇ{\J§dJ{PJ˜J¥ì°‚¡2s•¦ƒ€8󋀬?×pÞB›xÛ¹·úŒž¨E@@Š41(®Cæz.åòÅ+:4: I›+7|F¤ ~KI|Ã\I—怠œlLÇìÉž„ÉœLÊŒLÊ4Ê |Ê LÊHJ©ôÌ£œÊ¨¤JÒLÊ6€Ê6Mz˜ÊÕ´‡6XÍÏTÍ ‡öÒ‡P¿·!$ Hâ©?+ìªEAÿmK-? Ô* ш„±ܼÍóŠ”=cl1FËK󣽤1–‹“׃“4'Ÿø4c#3a€†’i†g02DHäIžô,q„LúGûœLËT(ÐOþ”ÌþÔDФÊÑŒJ-M=PЀ©TPL’MuP¥‡5ÐÕ„M{Ø >ë#褀˜€¿H™[!<3<Ë‹ð-³<Ë‚ é™Èàê?B1]4®Ñ›ËbL4ìt®Ž„N a½îì0‰Ê‹ecŸÀœ ÐQó„ôµ ‰Iñ³ÏzœÊýÔOÉìIªü5DT,=J{ôÏýüR)•R/Í-ÓMÒ,PÏTÿ6Ð7}S8S7MP}Ó•S9uP=›?’ty$tñîÁÂÞ²¼ËÛ?bµ|Ѷ<¨ÏƒÎT±¥„KÈKèÔN¾¼® °tÒˆÚé°àè x ¸„øq»„ó„ô šØIɬǜÇýŒR4ÝOË”UýŒR0Ó…RªTÐ4EÓÒDSbEÐdePSÑ$EuÑ\œÈ°ò6,1œT\+ã›àŒ•c Œ¹ ¤ÓÈø…^8ÏfÈ"|(’¦ŒÕ5õU_åϨìRþ$Í)ÖÿýYîÓÀ=a7f$ö; 8Oa°  R¨É­\ÿ=Ë´ ù¥¾ ‘㉱9 ñ­³$]º°Î“ZJ-Õ#5¨ä3BŸ}3R!(+ÿâ’` ¦Ý6hƒ^Ð]´Ec5Pb ^:%aÎØ½^‹ÍÞæ5†çYeEYb½^ÞÞ®aFvVë•MLj 06•†fha`ÔJ*¬¥\Wu†d:Ѐ\Ð_*†ðéßÌÓâ¶áâ©åžeæÚ Ϩ€]Ù WŽ $*]|…6î8†ãÝ}hcíU=fSffæîcÅXnSgÍÛÇ ¥^ëEä&YÞÞì…ÖGFdnÐyÍ ¼ †Kâ“0ªDH%åûͼ¡M­\XÆãUnÃ×~ò9æ<±æb10žåR-à cè˜ù1Ü(ÿâ ·8ž]7&f †XJªá½Ûenf=&Þ_%ç’UPèµS¾aˆÀ…do–ép¦áFVÙfÐÖ$I¶€O³dLNckJ(§ö­Sf½Ê e´$e}X(DiÝ"Ë%nÑ ñ¼r#«¨ýb…žå 0®žh¯¿§~+3¢2·pS6î ¦`Ý5æØÔœV—i»Öf¹ Þgöæ’¥Sk6SÖ$Í9…i–nPgïµiq&çmFY–•ÍEɇúiwb ¨…c‚öµ¼\¨g¦¦_¸É׃x€é_ø]l·ã’T¯þê#-«žà¹h|5ô¥º,½W¸hÿÚ¥`ÚÝ]h°€ ¨k)}áä5P=ÞÏd%ì»5ä7m^ 0SÝ[]dÖ4áîudî†îíUì eJÏba¸ìZ†Z`gÔ x#CµÜâdb·b@"Z(F!  %˜ ©\PÈψÈÌ¡€êâ…Nc!¸±^ ¨ÀQ8¶EC:ÙÝKæ ~c³½hHÛâvîŒí[ýìðé%M¾NÞCþk7ÕL¥4Ök~Ð%dðvìíg÷n”M¬e¿ >ÌâH­‹ølÉ…Jy_?‹_·RFzÞ6q-%ú^¨þÎ…þþŒ_ð'AS.ØöâX:2 hp3{ðK`kŒnk·Î… ¿ÿSû]*íÏ?^6usà-ÞþU½vÙÎD¦4ÊÕÛÒ\áo®^“qA‡ñ–P«âó>Lôöé"ÆZý†·¯òЫö ûvòÏxr'Ǽ†ÔêãâjJ=p0ÞÔÝ( Ö=q ¨Øeë8~õ¶n%UÒ ØC…¶­XªtÛ^¥ØvæS’Õ³×s©ôXµnŸi@gv`wÙCNîahß X›÷L†gÇ×÷öŒÎô,&×#7î¹âY´_(!‚‚.·ƒ¦R—`£ËÚö7aðòR(‚"pkÚ¥]Œvë_`ÕkX[_X'èR.mxDlJv¤Uÿ^õuaýR0mÊ£$ö§Üó5õpÏ„ñïi=ŽvD\jfÓ¨ÖÊìòÞvd˶ûæ§È…ŸH«u” ¹_ümKû+¡y€”¹ÎœÚ¯6õH Åá°\¸mêÉò\ˆµà_ X`¦]3V…†‘¢™¿cG²¯Ä-µÇÎ4J†gxÈõ‰ŸL¨lʸ§î¿nÂöþnA‡ö½'Ön6 ª@!hy_(3£fÀÇ¿šÿöøNT ÐyJ)¹ÙžO…ºgv—rÒ-®aLèÖKÓJIa`g´\pÕOý%Ø€ÏzáFóØC Ñ>ÛϾÒÈý ÊÿMŒGŒÿÉ{lM¹¿D|ÔsÁ®{é¿-aÇÎ{’ç{`/yÒœ<}bwx.â8a¥¸9mÑ-¥Oî6m+sO ‡)í)†ÌhÑ«£'®%ðK8p©”“¨ÀÂ¼íØæw ¹~9ùõ«B„¿.AƒÖ ؆ˆòñÓW€_>Š7~(¯c¾ @Úã2£½*Uæc™òåJ{NìѤ ÅfÍš7í© Ù“'O=…JOh”2Mº4)T¢N….-ÊôªŠ¤Y­rýO_«Vš5f¡¢óæ˜×‚퉷-è g7„½¿êá·ÈŠÀéËh×m‹Äkÿ·xqïÞÛBP¡ï²¾"Vµ€’J¢)]ºdôiJ Z­ˆÁ>!µ„X8­ªÈ/½Úüjã¢`B„  †OâåŠúøU¨ÀÜ9óåú*dägÝùæ×™kä籥׌#=x‰3§ŠêÏmÏõéU­Zá/­ªÁþÕúù©­º¿>=öä#b=dÖj ƒ ÞÃ` ò06]R–Ñe~‰ ˜`—…ð]q‰HO‹Iˆ„-@ð"ˆøÅa`>¬à¡fZiB¦Z`¯Õ&Ll´YðŠ*ªdomôrPB # .£ü€ˆ!-"Â"L—å•W²\–ÚMgÿv‘9&tÚ5WuQôP;å´ž=7 Pîi…|ê§ßTþqUÔT¾w§=^ !Y´" >6écJ…Ú_/éƒ*]–OvÉYFÌSBb/¨ø>Ƈ¡Ò¸@h6âhŽ£Q²B+>Ö†0BKÉ+Á™ ³Á1D løX ‘•„µX•-R—X2gå¶Z6×¥™ÒUä\›©{žœræôîPyÞé^QG©`ï½Fé»o¾ýâ'UŸý1UŸv}€ˆÍ@ƒjÉóa𠥉]Z¡^® J &‚>”"ª—‰<ª”Á c­3.ðÿJ®¾–†ã%¾FðŠk®Á&„Y¼RR¤B.´‘dB Aƒs´P€ÈÒUfë4ÔVbë4¶]RM¶Ygë\–ÎIÝ»a×/Ùyš=ÔQise/ÛDáÛ¶¿üùwÔ¿û•—>3 Z°ðpƒK˜¢IhªÝK.m ”ϯ´òÃÒÞ@î-.­¶ÕúŽÈ #üÞe‹X¶(|¶fj™%OvÚ ¼a“ÝO’­6Ünk¿÷òñ‰ÕÀXùW°=, DˆHPƒGÈÃäñÎ`ôËSW€_ùÿ*h ùñ¨è‘˜»ˆŒrº "8¤¹ÎhîV6ÚÑDã3Ñøàe­ÑY´h£# *Ä7Y’Ax¦ ´"Z?h$BáQkxº{!Ó`èÂ> \-ÛØrh69]O?é Üð5¨¢ØC+AÔ¿èFžOçkE‰þ¿µL†-l܃(f8 (C‹þç—|`ìBÃ>\ô"Á„j|Eÿd¶«Ò@Y‚Á F!­ÚìèAs‚n–Ô‹Ka† !>¤ÛÝàd$#c¨ÂI2ív#ÀÝ $¢IK®pi*ÞÒ(À.ŸHO‡Ð;›õª”~ Qˆ¬¬×÷¼¾?ñ)ÿ)ôX =*@‰ %8 Ö²zr÷“ÔÃ4—Œõ…caäç>2¼Ðc&*ãfú¢¡5vÆV4MÍDGšÒLpGë‘éˆÅÇÑ$ 7ÁYÒ+ q‰!0mv£°À”ÆÈ>2x)å퀷O€VxÕäîøéI‰àÐ< }()㟼–ƒ²×|ú4>æG‰GÉÇ" UµE˜pyK["T?J=¨.]ìKŒàÈ9\­0 ˇð‚—(èE/˜! È4ó"À fŸ‹ 8E'Î_­ %¬F:dIuÁQE²ž%!Pà?À‡´~ÉÛa²‘)4D$1ùOµb”•ÿL¡Z W܉2Q5ù€C!ªÃÖd¢c»Û½‚¢¶|±'U)¬öð žÄ 7 D/×RR¹ümAz 1eÎDå˜Q‰$£šN$ ›rO£¾dHC •38:úl¢­SM··Ú|lc3+MQ…_ð€i_Õ£W0W´Î5“p%«ZÝJVJþ3 Ö ¥D>" ¼æC¯4)DýJñò5•ó²è¾\i•·ýç^½? [¢ÅÌ~›TÄ4›ÙÍʃDë 4ª"ˆ qáT>œMi蛩ªQA£«:Ò œ¢ñ˜(¬Q<)+èË/|ðÛK¼¢ÄO¢ÿ$ÐU\ ãžb½0‰„G:²ÆdšCùÖ}Ò•Çkm˜=*€W!Ù®4Á«‘Œd$ßu¼ö`DCádÅ€ÊÙ{å`ÛvÄ[æ+ó¨Ànð’ºå¾’º‡f5;) ù7CŸ­Ì4×F¿èÃÀhÄŒ ѸmÂöS1ƒ 8ÙÔÑȨEÁz Ï€a–ëƒc#F–p 9 b,–ÒRñеӸË1\Ç\æ¾0¡ºC+©÷Id!à2›^-’Wã•»µ¶k«oíÝ)óš&ô˜h€~í^acÏ(Å.ö}Œƒh`ö¸Á$@Ì+^ö~ Êb~)& yÅÍ3Š3œÿÛšú¥q®sÍ]`>o ÜiêHA³ÆGÂÆ5š!Za•Ž¿mˆ(Мo@J¨2±éO{ò–¤ÃÍŠcS<”g½Ý!«”V›Ä$èrµCdW·:ä$ϵ¬‹\F°IlP~rMñk{Tʽ¹•­ìêå‹B*¨r•ÝëlD,%²l *UF,hb÷˜Xƒð—1OÅΟªªPA†î˸€.(·†T!‚ªÖH©Vj9/Ì# &úúŽýmž5„7¨À&pƒ µ†/|ñƒSÀ¿qÆ_¥Â7Òi¾;$•YÂ3ž¹ÔiÈ™rÿYc^Ö$gõÉE.k(yÈö˜€]_ó)ËÜæ4§”m—{²Ç^•ç1Ñf3‰iQ•1çì=Ìé ‚_[ô+mVµê RÖ5Äu¯s}Ýé3çâØÇ³§ÆWŸq %t ·›åìã|Å%„q !âŒ( ŽPWPÀïGF-@€$DÞðþŸ|•^äÅÿ=Íî ZáQÉ á…\s„Äæœ«™n^ç}ž«1Âè™\«®1‚û=” ìñZ•½ž 0ÂÏÍžì [ ´žì-1}´éÃ|Y–„˜Ò±À‚œ€ŒÆø4I4͈g´QÖ ?lÓþ`ÿ_„ ñŠÜ¥FmX€l< YNØ8‹ ÜOüÁ€+€ÔBàùB-P Áÿž4‡!TÀÆ! ÿÅaòás4‡ "!bç "6Çp Þ±ê}À#BÙÀ^ë‰ ÌUÙ¯abÚLÙ°©À<Ü‹îÍ#xÙ ÎC Bú´e@@„¼@[L–Šä NkµÛó¥ÕÈÆ‰4m“>ðÂflF„ÑVÉRሱ ÎêLl< 04Êi|“ª‚>°<¸ü¹Â Aß©á2ø$€V@^€9¦#:¦ãbÞ¡äa<šcÚ!Þÿc;¢> b¦#!nÞ""¢É±š¡ÞàÕŒ ÂìÕìe ÐÅ …`")R#PˆI!Ìèp¤€}AN\S[H¹–~SÿX‡liXŸ9²À èÈ–Ëi¬“°d!Y”}“8©‚ÑEˆû”ÀüM@=$ªaà¥Â\À´ZÞAâTNZ@.â"¢£«-bˆc:~åX¶ã¶Ô#Z6Yö#[Žå=J`ÈÕá|ä\–œVB"$2BB2‚^ò¥_R"%ú¥`>$_Š¢(^¤(zÙZ|Àk >p•ì ÅÜ`üÈ"‰0Ó×]óÁÑlq/n ¹mÿÈ6ÕTMÕçØÈŸYØèèäN†´@4* .¬“ÀÌm„Ì<0È @ÀðÀÔÃ0¥ý±a\€VêeU&çAÞ¥VæÝrâ¥r:gWb^òÃfI6`Þ#>r§YŽ%È‘espe\¥&¤A‚à &_fëY¤a^¤|&} Ó< ½Â“ì›P¦,JO]X¡²DS¨ˆf0þiòâ-r&2ÎÖh`áT…ñ ‡íg9‰ØÏh-È  Œ+¸B=,¥p:eºÂ^ö¥_:gsB¢‹¢gŒæ]_ÊèrN@úáöáâãŽÖ£[¶eyú£V$Œ:§z²'{ÿæ|Ê'af}¢ ˜E A£Y|äa܇Ìe.Ÿ6Ù"4ÁgŽéÿˆÝK2áÆÆó !2 š¼)cmÀk¾æb!¥F®€ÊM“<”€oò€+ðÀ,eSÞ¸ ÜB ÜÂ-0Â-0)_¢gúe£*i¥*©_ æ(§fçvgZŠçZºe‘æÞÑ(’bja^d`Æg|6i|ª "‹Þ<„¢=Ê´Ì p)‰lfP]öÉÔÚd‰ÁÖ†8 ã.ã7Á‘›Jh¼ !¥†œB‹µòÜEM‰[‘h]w… ”\ ò@‰šh:å¡À¢"¥»–ÀûA@‹²(#Èÿ룖 à+R¾Ÿ»ž@ °Å¿–À¬Á~jZÚ¡X¢#Öç‹&$Œ‚`BÊk_R,“ºj“R¬|®jŠ=ÉX”…Y4ÌÈdÊ-Ù…> ƒéÃ/´›˜úLkœu«`$+hU˜jŸùÁjðJ÷Íé„Z(ÀäMu×É@øf=ü&pêpÖBÀ»Â_Ôâ+_jl£B@£N-R²×v­×æhÿÞÁŽ­ÁÖ!¨¥:6":6çŒVì¤R¬ÆÊëajlÕú%ÜN€C46ƒ/C*¬@ªE… ®@.hƒ­@‰±²Ô$VÉgnL²2è› ¡³J¨¼AK¼‰F¶rîœÂÿ®xLa`©ä…Z@€Ñ^@ žëR.e*¤Bà-Cþ!Á@¸†kÔÞÖ2 L€î:*ï*ª»z-ñÆ×žYu*Ù.¯vÂãx:à6¢©Î¨Œºm_ÒÜÖ­`Ò-ÇN@8„ÛõíY|ä”í\°Q4A6ÆåΑ¼ï¸‰ÝäjFiî"VéìR%#jXëhÈ©ÿú€¶Ò©§äE^HƸ j=è¹&€p®!0ÔÂà /×¾k¾êî- g3êï–êô"§‹FjÝJªöÊ+oÊ0{òf+ŒŸÛ%äå[5‘ˆ\Ã%èC.€ÿgŽÎ˜rä˜_ +²R.hUãΖÙù ÏÚLÿ†ø-WÐ 0^0Œ-7šëÒ§£Sú2¤‚+À-ð"%£b­ï’€^öîG­ñïÜà “aâ‰-óŽ-¨Ú#!öc@®í©žêô¢*‹Nl½^rö®¨%ç°Xô04Ô‚Òô'5ñZ©Dp½Â¯²o˺¯ÿTÕ6!kfŽ&gX1æêìlU+Üyqh|†ÑTa(_¢|Hô&¹š+—è 2eßù2ê-°ëÖ*j¢2êø±ï^s£2*£n-w3²ÿ‰-"+2 bZ–s9¶eöðʵ3õ"©Ö+zÊÿëÐ3_^ªÝÎÃàÂ3„¯0¼B‚T5Í=äψ€ehS‰µì*ûŠgîƒ}Ýž5ýã«fÿìèÈiH0ƒqèÁDèML¬ÑêªJ›¨Ÿè*\¢Ê_»*ªïnð5»¨6+ê-Ä_ x3!2 #o"ïáòöhÊ¥ÃJ¯‹âRrÓ늪ªTÏÃ'×£|^USù¶€AS‚ &ô†(îB/nèPP‚f¦ ˜›ÊÎoQ54´Öòç‚Æg„n-hF3# °oê žëJ'K§aì'ãî¢&j¢ÞôÜ‚q:çk3üqm7ƒså5Q'²‚ÿªó¦ó"õÚB²sVÀSï%jW² §6û¥(¢nì-f5åLÙÈÐÃXŽ®¬læ,tãŠháFo3XDOnŸÅ™h,±\÷/ç°j„ŸGGÀ]¯^…€^¢îI+ðÒ&s·ñûB8Öô´Nã«Mg°s>vdc³ð‚pü-gß÷ÀÆã¨6lòm#ÞÂÊ!Až6rÒ+TKu½N©­Ž¯*0=´å͇‰LdÈ/hÎ/\F7áÕ%h÷v_hS7è.¶lþJhÏú¯kÖµjT·Ç`·Èpww׃¹v70*ó#CÔñkó5»7dë‘WsM3ÿêa ÿá2 ò’í=²å¨.lsF2{Ç3ªö¤jyTÛ0ÞqX@ A.Œ 5UHXBWÆW¸ý"´Å$FíOL2áKqØmVÖE7w¶z±kR7èV/aĘÕóI诱—¨p¦Â7’·à‘ã1SóyÞ]ùdoíû_ã9ùØuQOù^ÀÂFò$Ã3%S²Æ²vܺv=‹Å“ˆyZPF€8©Ðƒˆ…ueTxf"qb@F „@¯5EI÷‹¬¬§ÀoŸo4ΰ8‹ :hú]{Ìu‡ŒÈôæÑ¢´1?:ëB:SÖÂëÂn8&@íÚ±b/*5¿ÿ³‹ö.Sv×vª©ã÷Á®%ª“öÚÊ»¤¼–8½Ú°ªÏÔÂi´BÈœ9áú€ ºÅ]pʰ—9³„@DAϹfÆKN±‚jÆÊþBóhgj+Ìä2¶ƒ®tk;{FSqä˜u·¸7:2/p¹;ðëÖÏÞÔƒÛ±L#eïRoÑwz=g­÷a¾ëûÿ}e=ö{ô2l•·ú;Oªû©' ¯(Ý¢nè$%0|–oÉæÃ |@œÏ… ;[ç†dæmë™ã 8X·¶QQ©‚ÿ0qËO÷t»&tS÷Ëx̋˼¢íê–{¹¯t‰€ë¾ñS>³üÝ.3ö•¿3ïn»"ÿeŽz“;}¾ãò{¦ºôJrŒÂp_óã0k_²v£.Ô©ØsÊmß’Ø`„¡»‘õÆG‚;âó¹20‰Ö¸â*ä/2€À3ßñ»Ç;ÒÓ»‘ó.ðn³Àì¨ÿhÓÿh<†><Ž*ˆåÄ… &T˜Pð „-lø£C;yª*²BРªDå¹âg‘"ª†]ñʇJ>^QZ0õÕ‚¬Z­úˆpõÿj¯^­f]q‘„ @àñöm=õèÖ5 —îº ê&HUËWàÀËj% qà@‰#GJ4v|‹䃷&3$a9â-F% !2Ôù3èУI‹.º‚¡ V¯fýz5’ÕixÐàBÝNdXñ"ˆ#^ qðC+D,y² J•ôf¶hÒD^õšùnê±b'R§LÝùK„Rñ@2 ú ªØW+¬®ˆ@?«X±V)éç¿À‡Xa´ØâÁ-Wxp¥®ºæªç®»ì+@á/Á|Y†0$@•Æ+Ç›€²†RnqQ¸[>»á´m¼1µÖ`ˆÿ5C$xí‚Xè‚Ö2h-‡’lh#‹xk²Éâ&8. @Z‘’Ba:z¢£ç„™²“§‰N8)„(¸ÓÇ…ð¾Ko¼³‚:‹§ð–j/Îùª²O+ûT¹O>¿š*þôÓj@,ChË­¸æzpB ˜´Áº.LÓ —¬–T@ø! \¹…Ä#X(Ñ1"ƒà2]eD³[X-ͳm%-5WÓ6 ]h "…=H‚ ’L2¡†Ž#î"(™î ¡ÄEIRéK•4¨ŽL3§K³»:‘ún¼ï~¯Îï~ŠSNU Ê >á4¿±ÀêÏÞùL«-¸Œ4Ò#¬‡Á¼.¼ôÿ¯ZîôÒZRO=ÕDæiÊHÎÅXñ¬Ö[? Yä\uxµêO©Àë>ÑZ4 x‹Á¸ xÒ·óJ`¼/=ØB¿þBÆ—fj¹@1 ¢„ H(²U%»Ì²Ñh™òÑzm­å”Sn™GÛ&(¶X™EGN¢'™=ÝYF ˜ç ¬Ê²ièº4%šÐt‚KÜóá.Ý7¯þ]¬ƒÏºj¢Þ3‹’¨BT^Dì ¬WÄpÿßú…˻麫ҹ®T¯z*Ì›B ™!; ˆ^`?H˜ÔUígµÅËdœ¼òÐH>-G¼:çR3¤ i5Y èF‡,†¬uÌ= 0}ø¬9&éÒIRÒA0¥ÄO á–B Þ]àQ!¹xâ:m­k]›×S¨gDIOy÷ùOÚÎ"¶%èmâÞöðB0I±`•"…ü¦0  @‚‡@O]± xâ.  û©ªa´\Q¦#CÐ&iüœE·¤cÝ Ž9Kôñ•æÄnƒT‰íBP5ÑCwl y®³ çúHdNÄõ“¢0El5ÿ¤^óô¼Cˆ@U£€õÚ†½ÕÜã^Áê&)J Ì8eöÊw©( çŒ/ËNý­H€!\Q?àb¬Q®Tó™ËÁf .3`°f#¤5")!KªYo&Çã|̹VõˆÚ=-Q ¡M¹òp­jßé›Âž¦è©yò¢á ·€?(Q7XV1”¦¤_„„ʺM 1 5ƒ ºñYèS°Ô†bé© eñ‰ à¢0…Ù#s'C çdºÑÔf¾‘³&¢3eMk,ᦶ6è„ÝÉTM.h“PЍÌéúÈE ¡æð %(>ÈdÿŸ&™•J^%+õIZØò….-å]z¹P4¡ª<€Èʾ^±A|©…0˜Yrª ¨P=°—+º"44Ò«È‚Y“©&eedl^S"ÝÆ Ð,–ws3Fé!,‚6p}li¦zLIœ`›FAM¹ðÎ/Œ×S÷U—%!8OX¼§dR_6”WòÒ¶³Pà,àç ÜâÏPfï b媇‹Ð°’Õªôj_ö²Vˆšï­ne˜s+‡uŠ£ÍÕkvÒÖ ÐXA"Èb£ÙØ8>0g© z/èØ¡Iƒ4¥ÝÒÔôÙ›æ¿9AOQ‚צ_H  I ¶ÿ´»›˜3N_ËdÕ„I¦.Õj 0xÑñ‹_XÊÐí5¹ˆ)«* –Dñ=¢žjkt}¡0gja‚A†!ø‡¾Rn»9ºœÊÈXÖ)±GÂnÖâd=‚³¦4YD H¦NËã|o§&Ð^9 ¹Ð²–…*Ô-u¨Ô™‰JÒÄ6‘ ¨“œêTåÉæà6hh›…ý?„!¬ nö@ŒÜ²ÆïQim.[3µâ…I·S‡~ë`$7£ìÞ(eŸÉÜlBÚÝ5 ytÐ,/“N‡dO“.¸àôÁ´F¦šéL0Ûj³šÕ$l€WëÙ‡§jJ•çY5Éÿ³Y·NÜ…ílaö‰5¹!VnÝüìçVʹKX¡aü—„-ìÚ Ì2jüèa~¦²QËVö£pûȘÁ‚B’›ÆJ“7*U©ôdKú>fw{ ¸:øÀ£Ð‚/wY¨á,s}oý4óÚj—8x(¥ÄɹØΰXñœgÄ×Ïx€–[¼U7Y”6†0…!–S{Ú‚±¶7ämÝ“,m›Ìgþœ ¹)2‘bxcd¥Èù±žŒ–èc (uªÿ¦2Y§L0q‰KîQ/ÿ"û­Z"orS}¬‰‘äúI¯'Þv´ð«ÂvÞø RÉ>ãöÿ™ä©DnŸ°—“[èärüÁ¿·—W;Ñ×Ö>ÃxC8Þæ¸Ò¸Á-dH¶ˆ±Bw@#•¥JÇY³œ4z‚I{ùêma';1‰ dÏ€—Ë蹚ñ蔓²ØÌGYÛ%Žtéý¤s*SÙqo|¬ÇûÇJ¼/ozÉ>u«Kx‹R[æÖVt`"o£ 6gÜÕ@Ô yÎsŠe#²è¯ô¨´"Lª™±‘}M’'8¨ƒÌ;`‚öfoënËéÎņ¢êä÷D«áˆ¯øÞvÂG†MÎ2ìîðLî˜/úêŽúŒo*|Í¡ÿ¢í¹öæ íÐÃñj°üBã5znHz 4'™$@çÖ!n#t†îskè’½"Þ Ktb@š&L„LjhoàXm˺ Ÿ‚(~w‚MŠÊ…¨†øÈÅøD€vB$„Mãœ?N«ð씼ê¬èÂÄ*ÚÔ ÅºÏûbüÚÊnÒ>ÊsðGÔ„ÈÚ­ ä¼”®Èl ¤7Œå>à,‹€†Kª#L–ïÁöª£%÷rÁP‘º¦§ÎeyÂ÷Öɨ0°j6ðͰd ù q–Ïãà}&e~ª—Îê¬ìP—QÐøÐ¥ÚÆÚ®­ñªññÿªò*çüŒ Ý4‡#ÍÝÏÜÌískÈ‚Df0ÍþÒÑþVбâMa qK¸$iHQL1&n¯„úqK,˶0ì k¤F mùn±„âÁ!CàJà–Ïù„1ú–-{Ž‹•–ˆ—‘/º ±Ð¤Q¯q4lÐÛ¼ñ4R¦ÑerŽmC-„%™‚dXÈ«þÞh‰îXä‘!ƒæh¶¥ ±ãö††³Z fb)qO¨px²wRËDB'tq]ô)âŒÏ!E`RòáéÌãÞ1Ìr¡<ì«´Š`”ñ#™Q­¸O®þТ¯ÐBƒñ O/opçÒí$͘ÿþ2ÄýЈ ‚Å+fÆkÂtêKô©âšã$¦0Ln®)_­š2÷n‚ìök*Å0µ¼×ÜÌ+Wè+îg"­ã’í”ÍK j¸ðð-YÐQ.ÚHòû¨ím0/QR%-ÒÈHýñŒñ&ݳ1‰0IÓþÞhèx’þâq@TïZæLZ@<Å3 9ó3[@œ²¬;ôë<ÞóMZè+qM“Ðâ;¾K\“Ÿ$ÒÂ&r"múÀÎЊ`Š~¾J-ñÂ#?2.×j.Ô$ÿ»( /“BQ’G#ܳyeÝï&hóeæ0OŠ'•®ÿ£‰ÆZ<>€Ä3F© àn/=_­)A áºã4ÓÅ;®ò(t1 Qs2-B@"ù³}„1Ù@l¬ÐÒÃ’ÈÄòð#W°[°ûFÒ$[®ÐŒ³8ôF o8Jsz0ÒÓýtðW0oÕMóësÐq)±8:?Ç;±„$dTN@FÁDÌî$:³)`=MˆGub¿H3í„4€Dbó}jsïD,¡ììõÐJK±ô-ãòBú&8#ôå(tòòU‹s/3Ôr:T01OýÐónóæ´1‹¤X3Ht9hÖ(eV D@¦Ê%æF©ƒÌ8 ÿªw@+¸L‘D3H[ˆ'æóMDÂHS«;*`w2Â}$ÒI›íÏà‡~<ìòBÃGûê¢TM®õKBÏå0¥BÏBÅ”`‘3»X&½‘G†„aÖ Ô‚6¦óak22‰¥N!ö…„+/+POàLft¦Ã †F%pw¶CQ×éGMÓ[¿Õ!rn*êt^àÜïü 14ì]yÓ^IµAêêgå•^OÌhCò7Ÿk_KRÅ, ö8S²`#aR0Ö0 ³ç´X~%N l‹ 'töt$bô25Z»$[¸$)«MHÈÀØ©áJóHa¶;>`fwg?Àÿ6±fÃ}ØUgG°`èuTñhå•ëõhEòSÕ™V‹/VŸV1jñÒK£L?ãsm nä/ÿò£ÐH´–6¸¨I-ŽðqR¼ŽP-$`n@(eT<ÕV<¨dMwìdq§$¬¬=i{G$–÷&¬òì6qfCK*bXÀf9ÕŽØÕî2Ò«LµhW/BÒhOŒ/Æ7_vi벺(W‹(~ã~1´B“Órï·sÃ(tKCFÓMÅñC»Ö&a×u/m¼4öÍ8vF×vm§ƒiN–„œ&MÄ í¬nQ“\¿rôvGhiNbFXäa1Øu{ÿGLî |zsq}ñ5$×|û†. ïå.EsŸöU)ài}øB¶8ŸÖ>÷‰ot÷×V>W‰ŸÓ‰ÿ÷£ÎHk1óXÁöRÃëW!›à¬O{ZØßH¶¶¤³ÒijÀiÚÄ…"Õ+‘´;ÂRogvK à$T§z1à 6·RøÏt³—Äh¸A¤^$™khŇ|Ö·$¥qoä×’á7V_õr‹˜ñ.·L³ÑæF·F3ÅÑ”§Øa‡µ „t„ÄsZYcåq$æÁcÏäLhg„B(<ë¢À³¬lnyT }T\ñVôáRûÖ9ðçauæáä!ÿû`{U©½÷Q‘OU†·…!9_WÕ.3%‡1„BXs1ùB{ø~3t¯ñ““ØF˜8ž‹øžkD”óGÐô”?ô• X1‘u:½˜–iùY!8xw9œdvw'4˜ 7ØR‘9zC„TmGx„Y`šù8­¹¬Òò“‚¨ˆx |Ï—hï_Ç|UP¦¯¯†ý°œcð`.ˆø‡å9jïs‰øž‰Øžñù`‰QwMx­xi—‹1©S¦âÔ"FÅócÉl„ÒdŽCëìÌÎOS'ðv$ôÖ‡6ñ8œùª=š„1àø˜¤GšäŽQAÞ&{%Keú‘É7¦ÿçõ¡NîïÈùÅÑK+T-Y`?Ÿ_•žºLí¹‰Gc#{”;”?j©U·k¹X1ÈQóXùGäQõ$@gÜV%Lͦ졾€/em‘ìrVO£CmJš™­?ú0€B:·7~Žñ_&%.L |[˜Mµ‘ÕêïÔ¦…“°[.ã÷iyÚU6ˆ ¡±;¨C㱺#íq0Šñ²©bD7ÏÜ ³½›:åÑ3ÂR-èØß¸„µYQ¹#[Ò¿×iµ¨Dgæ!æ¡N  œ¤¹·[®Aµï: æB‘TÐБ•;¹«ÈBT®ðTìå/üî~«›ºÿƒøˆ»û»¿ Ê”ž›X>W¼Éûj7§jM÷9ÍÛÑ»0åCw•Ýû²+Îô¡È_F&—ú¦Lˆ¿ÿÛ¿% œ£Éœ<ú^ ˳œ·|¤íNã B% ¹e8’O ÃÍ}åòÃoº­q§KˆãW±574û3¸;žEy¼ùue>³wܼÑý ÝÔMQ€AôÐ#B²âÎ.vBHw€¹ÉÉ!9,k ü™G¸\œÁü·´?T7±ŠR(œ@]ء䕦aÚÖMnÛû`@ædnÄeîñªMœ¨CWÏG·{ÐtƒZ¼ýCÿݰJwÑi£ÚؼÿÙ½Oy LÙ0Pȸ3H»âÒÂ$dÔ„׳:>`¿Ï.Ži›%|ÔÙº„ü¤™·@äúȲ¬N”@©.JìJv†_xqý¡ñ`N»kpž-4V;4¸ˆÙ¥8ŠúWÒ6ç9¸Û¥t“‹¸¨ÛWX “WÃ}Š×›•·­ý”ÝoäûÍÒ"ɵZwž¦—gÖ„œ<ÔL¨¶¥7ÔsÛÀOéµ7€˜žß“ ÏvÛ…¨nx¶”¬tˆ´7Wp‘öhyÝá1S2Ù‡A·ì]|Ïzt¥HÐ¥¨ä?~ÙÝží#–Œõ s1Å‹³ÿÙ›0Kþ½…|Ñ<ѶÇQ9ã÷ììx„ý‚ —·¤—ѺÀ ?À·$#œ9LXàPÕµ··3 DŽß1 qÈ*…ƒ ®‹M¸­N Bþ‘YPök:r;=âó9¨žÏôãÏhÙû—í×>0¥ØïKêWï^2ñž:Ç«k‘ÕÚýRÅQHzÜúG~£6jȱĬÇYS{„¤×9¦¼ò©dQÜ£IDò}ýKø· šþ濳—šÉ õùLÃì®ÃÂ@=õê h° Â…õ†0|±!Ä! €¸"•F7j¬¥Ñ¡!†ˆ$)’BI’$M–”€äB… 1ÿ/Ø´9ÓÐ:c"‘pè‡ &H˜0´è„¥E•2%ºÔ¨ÑA«V*èÍ™Y%p½@U+Õ FqýÚÕ" >„˜7Þ zt놸‹7oÞ¡oC@xû¢E‰òXÈ“wäÞyÈáä¼rƒf‚pÅÃÀ  x6ÚÕÀ‚ ¸Fˆ0¢ìÙ ´]±"ÆT=z™ åICPº,)2yÉ™2›W˜ ýæVé\¥&E uéP¢C·SÝ~´-T³Y?tíZÕ<ØõBÓÛÔi}WDm!À×℆ºtïÎÓK^Ñc\´W ò¼pXbGÐØH™ÿdG\V™f•áYhÄ/”öšk©fâA 1¤šjõ´ø¢lI$[n¹a„cG¾ §*Ô#O?Á7]sÍs6i÷TTQÕvØ95ÔQE…‡UVU…w•yFµ÷]PaÆPS%!Cáw ùÉE×}ôÀ5'sâ7Ï`ƒÆàaˆ)vfA†A…RVÙ fÈ¡g®˜&⇢‘öZŒ­¥ÈZD.²H[D¸Ù‚E»e¤£F.™$rȧœ‘̽j–«5Í$•“N:e+UL^XYq·žyèq5S˜UJuT’|¹T[]}`ß ,äçæ x"h-‚-ÜÙBŸ‡aà'ÿc&†A Ž=6(d\x„‹^بk<|XÚh’ž¶Zk+ƶЦ›vÊ©B¸Õc£E¢æØ[F"±ª\ëò„U‘EÂ*Ó­Gµ®¶:y¬—ÆZ…æy_éJ2wDKVxS™·æ<'ÈCm›mÊÓ&‚ÓF˜<÷ˆûm >—{î‘ -´¡/p¶(g”¢£"Žho‰(&T©ŠüÎXпOtÁ‡ 6¼©êpçÂÄ“NÊ)]¬M5kñXÏÍäQß!e7QY^uVÅæ ÆJ®2vÍBëòËKä·Da0³ðr¸;—[®Ï:“{.º +™º:ÙfGqtiôž–¢ÿ+-¦(oBÿ:¤õÖ&@QÁ_ç˜&eó8dš; +ůN°ìzÛúöÛ«ÜRëU¬eß瑵l{¿ÚM¸áRB»#p…K>ù>߃>úå’{OæCF–킞4gœí€k#’^G}F5©+‘A¬–µ€ÙnkºÛÝnȤ†'9-IN™ô­°­9ÈÃÉS®(';¹B–ušŸ/eeŠX˜N˜7ïÑ-*Œ(´Ê·3@UŽrçãacЕøQH~9°ÐÑ’v´ADú;½B"y}†5%º”@´V»Ö¨ ¹k Á0ò»ßQà8ÂIÓOšƒ„µ/;KêØÿ·±¤DOJ! Kš²ÂBxz!\ž“±²†„,Ðø £3pñ– T"Û×>÷e ˆ“”ŒüÖõ%ntœ)þöç™EªQ§yÔ£ªh@×À¨_Z¤ÍŒrC0¯ya,‰J~„’\6LxòÙÒô˜£2+éJ˜K*fó¢T”î.*MÉÒOú–ž(al˜!QHñ R„4Ð<ª õI‘€2W9è˜!>¦ˆ*"e2:ûYæ~L¬ÌéBô¿E5üD¥?M#e±•]sHEºËO首?JI{gˆÞ…ì,[BYõˆ"¦”5'beÁʱøh1­ô-¢^©“lÿ•MnH¥54Ð6!0È´[ß×ú~Ö> en’íeØå.{îožHã ‡`™QðŸ¬óçŠHЈô µI¨,P¶†g«ZMUD¶_FtKhëWBFÒøì$K͹ΧÄL½©µoˆÞ4™ÍnÚ§¥ó ¾ NH€‚e!J0Nq%F‡9}Ÿ„„VDw~.tí*ÿ¶!Ñè¯iñêç?«š€jkÊ],Oû)¯Õr«)a˜r¼Ñ3B,¬<žªÌZÛªÀ‡VÌñÜèxL¦Dl™sK)6[jŸ¿þõóø«}¶IÂò`h[ €ëAˆa䃡ÿ÷]R²ðÔe΋TO**C ú$Aôš~¶ŠPhT½F‘-¬–©Ò*WK[š”é'þjV†„&_FL¤dñãÜ€‹9"¦áÛ&6I€Üy0—%¨ar› XFv°!u[1dò bÌŸþ”ï†W2ð‹Œ<ãi™£!•H *˜øÉýÁ75®iêkŒŒB•k Äm<Õµ†!‚8(ñor¬¬œ®ø‚Öã–žIV鉄'ÅëK«IÍQ‰†,•é7A¼Üo:·†Ì-AˆÑ$Ý!X7ÅŠ’G ÂÉ)&1ŠmL„+™›7“œäÿÌ«¿v µ3ŽÈ|Mc@-ÿ´\ƒ%mpц ¶»4pl<à‡5b^f+[Af%ÃR¦2õ0­Á H[¡9ÍÙì뇙çæ*Ä/­ aM  ð ö#Ý‚{„Å ærê›ñd0¹(%*1ÈEõñý¸}OÔ¸®©§Då§UN?$¿ê~ˆmîhê׊Č_7nQ½å-×¶$A9£RšÀQ)à´06kmaA¦Íh>x!Ÿ[ çûÃ$€ÀŸ› cVÏ&&0”ÈÔ0àr±"íÓŸút޾ße‹:iN&•CŸ Í/Mµ%+°•Ølls•«¶ðæå‚}ù•~«Z­Ui›ó‚«±…SÓâÿy*•+H ƒsêÖ¦¯áâ\ ƒØpƸLo2]«]4‡€f2P°@ r‡ÙÙb³¹¡ÙSC:Ú·ÁÔH’‰ð}>QɺGQ_1r%Ÿ 0‘eeÞ”5P¢ƒù›0XÁMwz11úƹݚ›yú«­Îá“Ø)}®øÆNö‰CÜâ´–ŽÚÕÎw]†Ù!§ L!ÀÃæóPTçÔe¿E7ZæúËäbΙvHi¤ QgT‰iúªHvÛÏÚÕfPƒn :—ß(È0ÑÏSÇóì¿ÉxàHæâ¾ÔÃyªúé­ŽÿÕ7wÃ{=8ˆ;|zX÷fsFk<`C··lºÿnrAÁ ¿W|~F,!ÈwD¢órŸ¤c¦xÑn£qOÖG"GZ˜’s™¢/<Kíö6¡+o³,ËB7Ä•ÉóîwL¸28<(eM«7†ahø‡Uw„bg¦ÇaõggÄ&€Û”fb®€{¡±^A b†à€PWsW!@p“h˜•cEõwF…Oî‚•‘mØ4#XxŸñO*85²“‚Œ·s¯Ô)›’%4Xƒd†ƒ3Ĉ3HÖ4·‰Œ€a·ÀÌÅ\Jhuy99%pVŠIh„FhzJøMWwfgg…¡v°l+ö*¦A0ÿX…! ðge|“ñqr¸{€·Y1}rx¥Ã!pxsóu@Ϙs݈ Á/¶!~[7Q׈Ú8CÜØˆK!‰·âh‰å¨a§…÷|,PëØŽ ØŽ£€¨wzO˜„÷MSÇL&†…ühG$r´è÷’ †ˆÀÅlLJ ¡ŸA:ç…Œ–E¢¤?¢ÃI£ÓcíeT¥Qx§Tnt.B’™Zs±Jÿƒºâˆ4ô39“åH‰—ˆ“·PŽ%Pg§×‰ïèŽë|@ÉŽò¨‰ewŠ ×pÕt€ €‡?³N³¸l‚ð°n'4 Óeÿ&f¦“D÷"i¹›‘!iT›ÕY¨TnÑø‡*8Z´Ñ’1BߘkÔTC>@øˆƒiMƒ4Ž5„aAHgãøU—zð8”ñ(”í(”E9”£8Ц™}ÕWÎ¥·b…NÉ è.¡®DÔ´^¸h(!Ð ð)÷`bA]®àò?”EdæÅ–›tŒ”f‚¯¡x˜¢Ju¹xO•’sZœâ"±)ÞQˆøG€‰M2©”€„k$à—Þ NàIŽ)õWÖREx óXu,0Á'-”Y™ñY™ïXW§a{õRQN+dbVˆ›ëTG@XöîOƒ"ÿà€Bc0]¤S(Vd¹IJjé›—!*TM£(¼id'r’Òh—*R;°á"ù%¡,*ƒM‚R¸&u†iMÕd˜Ù™u7z“;Šatb·à„˜ž§'-ìÈžò¹Â'Ÿ—…÷ŸÙ”fLa…ÅÁ·(bI‹/à \9(ƒ‚!pG0?F0–0Õ5˜–›eÙ(HårØ–Ìw^GÅ?¹™‡zø"ÇùŒWT5T„‚ ‘Jり#,ZÀòƒ×I˜ƒ©pˆ™u u2Uq€•Ø™¬W¦GHMJŸEzñªJ”Á…o–p…”f¬'vÀÖ\öÉ“H˜ ðØžKê8Á·£êž¢Ø¤_çz2HÍÂq)f¥W:‹¤ã Ð^9I“”•6ÁÇ[‘áV"@¦4Á›J-‹‚Ù¸š2½4[2Q~àŠ¨tC®€$‰çÂ.쳓Êk•¨˜ÞI„7™©IËa«Ç©¡h¤M+”I µÁ÷¾ñ+Ÿ {ùh(¦b>Åw~·ÿ»š½j4®C»jø üÄxTºI›”‘ xMcJaÜ‘¢ä¼$²ÿœELËÁ/,j¨k«A“L|é&lÂC¨Âˆ Ž, ž&la|¾ÌÈî[ÍëÄLê2WwY‹ ùS·Éš*:;‹€›œŒ ±v+¶|Hs=Ö–^‰Œ¯kOßVÉ›Á°¬¼úÃÁ•²§€ ¨ô%³j|ЀZ[̱ƒs#‰ã„æÌ~\£C8®Y¹7™ªËU„†‰H(Ÿ;\Í…ªï{Â.!=ÄFabnwÉšt(Fs®€Xé”H<A°»Ë?.ÇhœdOG¥?³9›^¼wÌW‡7·¦ž1J§’ì¼´ŒnÌ©œ¬ô»ÜÆÃ%ÿG¿\ÂN¢ÂÔ$žm¾½˜ä8Ž›Z‰Í“öÍ𹹕™¤%Íž‹H~‚ÒŸËŽó0<[šð”l(%0€oW?‘½JjGõÏ›¡^A½YÂ;›îrÙ)T’fT&Ø›ôB"v*¼ ¨–ÂxÈ9Õº±jFÇÞHÑ—¾ÕŽbíÂæ ©¥+Ž9v«'Èõª¾Œ`ÈIÍB9mÓvKÜ ¢Üïëžìé”@,«µk(†"05ýº;Ó[{m¸»vy»?K5Ù&ûÅÜ&OÈè¼PD)’²·®Úƒw:¤¡²½}|Ey52{ ÖtÃÞkÿÇæšfvÌEk¹v|˜ìª“›ª¾I˜¯:™üj×#½X€¢3, ÜɤC9UÀ,&ÔŒ ±e‹šo/@´˜rp{D7†ŒÎŠTnJŒ sé$@Ñ Ú«CäéÀs«‡S#U3Q¸õ1Åâܸk‘„E+‰âëylÑs\£„ä§“˜´é9áìHÜÖlÜuí8Ñ(‚>¢¤%0âfº‘‹By.4yؾVH»…ò p»[d +}¤cÄ(¼B¥·„¬‘B¢ôÙÙ‘C^x/ë§/ÛßYÍÆ!7:Ñ}ÛH„³ÌÅŒf þÿ¨ïºõÊ©<)øGÍmþ´„öæqç®Üóà”|!IÓÝÛvëõÄ´jÆiK]¼»À»7‘BÕèùÊr‹·”––•®é¾™ãrkäÌÁ¬£‚, ˆZËQ~´“áê$'¬åâ›u5JÑâÑ.\qâHý® Ü…üŽÒ,סâˆ!|pÞë²Ü¡ :±m½¿Dã$°‰f€0>…žl{D¼y?í)ãdá®íp ‡Ý­c\Œ¸¼¯ŒJÒŠœ,›Úí’•³tc£¶B„ ·êâ{“ä ¤CHÑ~üÇ´>áH8Їì´Îý´ˆ¡Ü¾þæpîæ,[«ºÝ­ÿw\ø‹žc€ë5´‰bi 5I¤›Aí|Inyòx»·“¾ÅkO/öB/~Û¼NEó«±5+ª‘ÑBÞhÑ-\®?ŸÇaÛÊïý.ÑÏ ð׈œë¤Ê拵áoî]G ìfjìxŒ k|Ç›³˜Dc=-\)Œîˆ¥4:ÖèJSŒYÏhEkŠíGÎD•®:}ZnòM"%(ËMNÐ|¯÷PžBdñîRRåV~ÛuœàÛŽ®`Žå³>IŸæž8ùŒœÜ¾.cÒ>ÑF,`ÞµÝh†Ò~¼ö³^ëU!2þØ*ÖËæŒÆDÓ—¬qÀ 48ÿÃ@‚Apèð€‡Z<ð"ãCŠ<òð豞%Z i`äD‘õ\¾¬Çc$L™/U’ á‚Î .LøÐ³'¡E‹2"1BÒ[DI0Z •éRHAÅ:Ѽ§$nÍ»U"l ²eÉž(Á‚EZµmÛÊcnÜ#òäÁ{ïÞ÷àËw/‹œA0`xø0â ‰~áÅb GgXü Gb (qð"ÈèKoÔzch„ ºVÈðaDˆƒP,XQ·Ä‰,U¦ 9ÒcŸ[vüè ¦K’Ì]ÊT)3çÎ =%5š‘VîÙµvÝnõ)£[X­–ÿz‹×ÿŒJ¬';vl ´lݲ8r®Ü¸wõê °¿Ä«„Ÿ,{³Å,Ë 1Èx ÁÅ&àÁŒ à°Ä¸€‚! ‚‡cÈ¡Ô@+è Œ: 6 Bˆ6kã ¡‡h¤è6àvô"×|cn8•\RÎ9#‡„ 'vòÉ(¢²Kj»[&xj‚){bê;¨Ê{ .¯‚Š+°Æ¼%=±â3+­yîcS­ýÞê¯#ìë/¿dä‚ ŽPL1ÊCìW  Là @”² <í {ìh;-µ ªÔµ…6µñF#¢H#OG½¹ãÈ# Qé·”Š|n¦!¡‹é·%?øI¨ÿ ¼Û®'¤¸ëµ§)±ÊòË*Éã Ù®ÀZ²Ü;ͲÚd“¿¸èòN¿øÛ#zBð1q{±B 0 ƒø´Ðˆ /´Ãz$äáÑ… "&ˆ@QE[dˆDm­6ˆr<øÆNi<øT' I 'É•ˆƒƒu&Z¬gº ~úX¨'‚J¨a©´Ë”ÉsJ<«ªªj¼’mO,hç3‹´¨½ëÚjãÌk¯¿¸ u ³q }¬„u'KÐ]D§F4‡† `²\áa² u™‰f@2žî[$8ŒÒà§ÄdÀ€R×ì¨6µàQWãà(,†CpEìRä"æ%/66J ‹f3‘ÛôÆGÆËMÙ¶>Jj/b©²ž”óþpÓ™@u®SD^¥Œq&KYãšžd!eîi–{`i&ýÅ>?Ã%]ö"4¢.¿|Àx ºö©9peÖåF ÎѸÀ æ€®‘H„H! é"!DTaž 6HÙ¼¦ :¢›«lX±‹¹PG›dI:ÿ6·OŠï'å#ܯԓÄ-u%fð“%ã̳¬ÿ¯ÈòL–›YY´HŸ´ÜNm©Kèì¢ËÀ˜Î—¿Dæ{ fÌ¥51êBŒ3pÁ}dàj l¿&èM6j›/ '8“W6@lxÄ) ¿×I¿G"ÃÓÂn˜’tþ0'†ÀÕrRD¢ô*<æVTØ·2/‘ ‰.“ŸWÆä•Y‚süãâæîѼ„q—a4)€_bÀª|*fëè˜ ³B¤21ðÇ $hZU½´¹*˜þh5äTáÁt΋¼“ët|úÈ5’#<ô¤Ã ±Ùœ,u”EiêP~Ež«€GXZ²YVžWJÑ•íYÏWòwPi5TgŸËÀ8Ö³žÿuhjý%¢2„ @Ê£tkíJ»Û]è‚áP„ º€í&ŒæXKýH6¹CpƒÓnºÈ…FŠ•d]Õ0Ðz—šOÆôŸ6œ™A+’'$'¥mŠSB¿X…šäzÇ*Ö*Ó™dÛ°$‹À¾C@„¨%0Î^G#sjR ³©b¥*HâÁYIPö¨çŠìÉ™®yK  Q¼h•‰#±=$Âz,0®r”G”×7îµwQÔŸ)ôQc²Ü°3ÝÿæErCÜ$’Ð:ÆH–3« ÉS ÑHM±éH"ËmTœþ4¨%jQãÛCèìgõ¾. |KZ‚i»ôJð¼gLÈ*“ݳP-j㭜*^À¿üÚ2dÍY¯®ÍµiDvÒ³Qª%fÅ j Jl\Öå®'lRÃܘm?X¹Wu ½¤&Þ[IöVcBÞôÝŽrÒCý¦çüîwNv¥ª—ìXJqœ­Þ¸~=±µâÌX°P³Ѭ¿-`°Ýw§UAxALôXLe3{®n4©„óLÅ8ê .u‡ÐÇÇÕ»-¬¿6"ÞÍG¾Å…B’ÿ“KŠS ÒÞ9ÛOª‡(Ýi%€a¼æ´#\{2dð€™8÷Ñ Wà ǀZƒ5¯K3ñŠ„¢"*J(ÿÁ^k»2"# ršØ ?º€»¡&@6i“6¹ê“2)HAº y¦7ºWoC4ðû>׸1úK¡òÚ±xJ·!ñˆ ‹˜ÉžˆI¿á=OÑœP\8 À…*ì¿*Ä…#¨B`¨B ðUSÀ¬Ø2VsœXr-܃€ö`­€5W›@†z‹´S3µR«Ç8‚´ ~Ù @c)ã*&–“+Öq£¨®˜Ç ¦¢# ˆ&8+¦7Z²ÑABj¬Hÿª IARA“îé)R˜IQ›™Z,"K¢•üÓB)¤ÂÊp)|E8`°ŒaÊøˆ ÊÐʼn Z|¥̪d“™YªøCȇ|ø€­(»Ï‘°¡¹(Œ2£‚x~‰&àñ {±AbŒ¤¡&j£6¢&lA¾2¼Ä€D´º ?ï2§ÂD›‹¼˜£Ž)²Þ¨1ìÑ<&txcBQiˆVD†Ê@†_<-”,<Œh*Ä!Ây°ŒQÀ…QÀ¸QàÈÃ|À<‚\@)¢À­H¨™!ŠH:Dø€—¼Š5¹–¼ jd«Óá—kÌFãÛ¾åsÿðCäB¶ºÄ0€ °ÃÛš=«$X¾GÜy,§xD¬ù9x<¤v’£º)ž)!Þ@¸‘ƒlE ÐȌˀE,Ä…{hÅŠ“ )ÌQ Ü˾dKÀ$ɉÉ.£" @ ¸¸P«€—´‡­¸ ã–Ó¹I »Ã=¡ jJ€Vè8¢44úÆ¡t #pêštŒßa.#ðB k ’[ŒÇðƒÇÝЊ$zê$yÇ‚H‰ŸâáGOaK·ÔÈ·ôH„KŒHŠÄxyÌ ˆ ¾d¶ Ìä$)ŠP{L¥È ¥B„¸@OOÿÓ‡Çü*¢ ª¸›¼É#0lä¶k…à¾DA—D.iS.ÇÀ—°QºBJæ2)@Ä’ëCv ¿òr¬BËl2ˆþãJ#›¯šk*‹é ËZBúë Õ© Ôέ V” Ñ©8VÌÃØKåKî…€QKLÇ|ÉeÉÄ\Æì´Nû4~XÆÈ\Ñ¡É «£Ø+X9éŒ Ò£©q+G,GÅhŒ9{Œßa18s àHW!2>$p(•É«Mó*$…A,ʃKÂÐv/sÒ$€Ä$2‰H í¼ÅŒ´BCÕÂ#ˆÌ BŠ‚_SQ|ÈÈ_ÿûH­ÑÄ–Œ€V &Ó}µPU `ÌOk… 7pÌeüz "ødÒ€ëÒÌÒ>ϸ2}#ˆ€«¤A®>A¶ê´H\MÞ¡“ $ÅÚ¸J»9µMÅë®òÈJkåSjÂùÃÄáù¦=…¡EŸ*ÎØ €d^ZW¼8ü`Ϩ8 °‹Ê­ ¾8 ¼¨ ÀÀ€h…ˆ€ø´OP5UUXP[€ „M=~Ð{y_û‹Ël3ì"¹«‡ÑÕ=‚Òî+<¥)eU0”^ö —‚–‰¦f†!†˜QÈØ@ñä3™dF¶á_a&â_ qFh ±VZŠ †D0ªHÑh4:Vá ¶!â+p”ÒFDðí7ÄGkiGS15S=…çÜ <õDx÷ %ÐÑSPD².P€•!¸]£¨7 Y‚„!ÜRÂS†œyp9× RAQ{}ðW‚åc‘>Taa„‰˜üŒÀc˜êƒ©dœBæi§ ‚"fšAXꌨž˜ê©ªªb9ÿæâk4Žpƒ!Â#nÀ gf+µµ¢+Vú ¹uãQÉ“OÌŠg¥–Ðæ­–>•Ã<̲@Ô +mÔ^VX‰õ>ȃ _§›!Àˆ{g] ïžc‘eA™Eš =ü U€¡°V a„AšØ t¡Ânèpd–zYˆ£.Ô*kž­ØŒ¶zqh0+D¸Fxƒ°<©+FIð{.Ã$²Ó-K-ßÉ£¥d@€<ó,-áÅ•æi¶A™ÄürVï‹ .ȼIßnU0Áf^Á† Áu½Ä»QQ2È k =z˜ˆx`)¥—*l7§”Qö©¨œöÿ"«®´êà ©–0?‡Ó(P#Pˆ¸@ ta¹®Ö —ß¶€™.‡ðr>@à%NÏa7Ó³Wæü3ЬCÐÔ6Å‚OG˜çhGƒ&¥ÜÓºŠÕÊ£àbµWaÍÙÖæibpÄÿ®Þzƒ2ˆàP —VìfJ·¥Úý˜†—vø)Å~‡Z¾d«Žªi²©JxCì äÁ ÌÀ> ’Û fr4\› °ô:| OAL¸ÓéTGKG –O~öº×e uЊ ì®$žy åXYàS¢RÛÄI+B" ÖÌ"¯¶¸DHø Ëò»àµéˆÞ¾”€!Îm³ÔÜÿ.E©x`ªn“1â¥l4>¾5ñS1D‰$2£†{_CG}ܪTIØ (á‘ÚlNAJ‰ˆD "g9!’8¥yÜÉf7ËR–^ç:TPh7ƒí€r”¨ä§)%¸“N¦²›çwÅ›—VÞ’•¹ˆ.d!0€‹ Êö0(9ìF{’*¢¦ìvDô±CKtÌùF*‰8J}3r‘âê§Å…èn•úˆ`p„ŒPÂLÄ‚,¬â˜)w¡GB‡“(òI¨›Ö´üØG>-vÕùv”TœÉ£9O)¡nܨ•qý@l@BödˆxÆ¥+3ćH€ÿAHzüÊ£Üö‘ÆñƒRr‹Ç*ØÊK)DßÛPl84K ŠŠ&YûzÙKÒ&ˆâHn’cR€*a&"‚£‘ÐÍÀyÒÇ¢““åÉ4ñ1£¢Œ2ŠKÄE)Âb/vÑp¯dˆ˜ŽV@R!l +H¦3‡p•,À¥ ” =J %ó`Š6w&­{|‡ü©ë õ“ž@)(4©I”L;Ô§ÿL 7Ø@UÌB¬þ žiA B­ŠxC€ ð€Ñ |"”*e({˜X‚"ÌRGD¢vçZ·PÍÕS°Ä¨ú&؃l¦¯ëÓb`9ÌÃTWlTæƒ$_fR@%øXÁf63™Aif8Ւϸ A+ýô§¬­]Oj×À¦<ç; vÊ̈ ïBzÊ„áB ?ÁgY0|£ € `±‡%(?D×?Æ¡Ýý.^Ø!¿¥¯ |ÝåÈx‰ÂÅÏ!#€[Á>ÂXŒXËä_–)œ)“3-S¡Y ˆÖgÛ,-SxªÚסœ9“S°s3åÿšÌ!®8°]û±jà#¤ùO\ËÅÅÊ™ÕÅ#hgc¸º²®thdvL>Eä¼è5ri6ýZÅF4ºœ‘Ž–ü‘­´‚ø€.(5Z@)YIô›2uPP²És~¶¥Ñ:Xg~ô©´üÈëçz¨?9#–2H Ef2€òpq \Pà¶xVÎÎ3I¢‹« ø]¹ø©âŸµ”ŠžˆB½¸V~׉³4"¨ çª ¿ÏF¹Ü´¬ê‚àj”ë‘®ˆƒ U'²)•-pÌpö¿ŽbÄ[0»žñ,K¬eJ9u*­aŸiP ¹O ³kÓ&;*ÿXŽÊÙ²`\cUÕRšæ]áèO*ŒáÆ=ŠV¬8/iUk„·iLY¤ÑÒ±,—(iIßµ3#:{ÿúi}Ǧ5f¥úªçä¨H½IIþ÷jW ëÕY #zhk£Ýã‚[ÂRíø ìŽ\›®•ǘbò;錶¦Ç¶¿™`µÚZÛ6R¢âž<‰E@- A Idüf†îÌ{ 3­R–Jttû&ª'Vôq&²÷ª@ ²ƒì;0´òtÛ›+ÄIÉÔH’F•ÀZ8gÎ jr‚ý†\&@k4ÐÊ$K<#Úh3È,Ÿ¼ÍB­É¶­µbEØZÿHÄŠµHÀ-6ÐqàR/?¢\£¸A£ c~ä‰`Â,H†Š¾]‡nŠéÿGQ">󶪧E6âi Øø68ˆÀ p  º’RÊ´La(õ{Å@ˆ~à|2‘v¦ƒSç43 t:Y’#WHÅZY’3­ÅfÕa-‹4(kñ2Ä„&ý×€ZskÁ;r2+DbÇáN?P äR5ƒVü€hŠ!‰>HgtEW¥×)(o“QJ12u»D 8QV+›dš1FÐu°F>²LVY½·pû•C …¹ÖO’qó°_ÎG%L‘TÙGwÓ7rÌÿ§eA!Bkr ”È10&¸€0±¤9Bâ“t2”Iµð~¿AJ0V÷WP•Ó= stÚ…DI”7^bÈ7¶$\Ä^¬{£qVÂØ>¡–+¨^§Ld4e8`pvHöÁ‰DMB[WqÔR!`+xSv/0ô°Üq2q-TbT3Ó@ú±ƒ¹6c²º³mm±O5bZÁ~ò~Pøs=k5­Ñ0ý§c˜¢WöD¸hWè#ufx†±oW׆Ó†»¤?  #((½ÑI”°QV$<±D²üÉqTx¡%TkZÿç$Œ0:‰x%=óäHwô‚‘¸“31"To63—H0„$¤N±B“$'Ç„'¶ (U.“VÒ?ñ ³²Ü%o7ižWlÙ0P4†g†¤‘u±7Œ.6iX”†ºô€Q÷²B à(ib9ÃkÆ10fÂ9žC#¸`÷àq“,¨%wò ˆÊ‚ˆD£qäA10:Α3¡”FTò ~Œà(@„Ms<€Òë’'ä;ÌS.ËÐ ('¬ˆ¥†"PPá¢)Zè–iIWITW¯¦7 óc¾Èoa#ŽábýruºäQM¶+ÿð#G%e&$åj*q¤+"ðÕ¸“ áqlÖq}˜é‚HÌš;¹<±¥ƒQ2f?aNÒæp'…ôl¢9 ·5r‚•õò~À° Ëð&h–†!–Äù8à>8fWiùnácDšâ–jY€TÄ1¨Â4rçöiÙ€lØE´Q¶·”°{ftr¤Bð{Ë„qGÅâRûE:!W;à¨`Ð1ˆf|ry—,KrŸ­Uƒ‚dr¤%çt@ògG#$yÒH»a¡':§¡\ e!ÑŠÙ£n£Á|ê…Jç)ÌénM‡>‡s€«·^¬ÇY7Q=ÿÔ†GÆŒY0‰šè¼¢ú`Sk¿‘@i" …öé`ȧ¥Uú,À'˜%Iõ¥­%]:[á±|Ì™PòáMÆrMŒ`ܧ#b¡y‚&ª`á<¼¹ ‚vBŽ‚§œG!š²J‹“c±´D*úœ±øœ£½8u ¸£Ú™—)’† 9ÇÈ?n1žP–X†À(†°¨:3)ǧ3Zê ¡%rêh‚}áÁAz´f@¦y”k…h3[àh:Û¶_Šä a2,PÓxÄzâÈбËVXSOšá¬œ‡8oµœÿ·– õ§—ôf¨%ŒhŨÝÿù¨¢>àXº"žA&2•.ãED$ü³_…™¥Z;ƒ”w^6T!çŸÐÂ3`&AͲ||>I4×[3ѰºVˆGE:‹t@XÁŠÅ 5§•_U.ϰ øÀ¬R”U8–d9­Ýµ¢i­}â“tIG–F©*Z£‘‘ø–†:Êð*ü“V¶@RñMÊ®û… ¤,‚ßA;Më¯È6µÐRµW2«W‹qÌRŸLA2ѹˆˆOÁTRH#hóS).³¶ŽÇ<}V  Ïð =Wn¬8–íZD·n¥Á§›z›DG”t«4‘0{¸ ±¸zÿkuwyñãQ”<2e öj Å!P šØ4[z„%&÷ú»`@ITèXly¤GÖ¢›¥7õAá%_BªOÂTùe3M9DÛ–&³i§¬í§¡ú tš¶õÔ4Cçy©0G7¸ €9†Âi­°d¸1ºE„X3Œj¸²Ázˆp¾ ×(µ®IN*Èà(r´ºèˆ¿Ö祿†q>óÄ·µ÷ëˆêذ!7§ ÉÂYʦ´vtúL.ƒÁp³)¬ÌÃÁêÁ›Å¢X$ >ð nÙP¡·th™Ç°ä¢”æ†Þ;…ձ‹z† ÿ–‰TV_ò"x”äaªù;}¬-³*ºX%Ëk@ßӂ¿ËG%tg¹[¡EÊHù˜ ÆãaHE˜CZOi‚›»s›Ä\É» ¿e§¬Ø¼Ä2–$ê=f™Ç+ŠD(WÑi–R¸çõÌÙ€9:­²ò¸ ¯Åq¤¿glGÊb:ýJºÍbɧˆ>1«t¿|·:p— 28”X«¥ç¼¿¿&»*˜/ #Í¡H(G„ü-Ãú'3ÈÐ \¹ É{ ÇÍ«X`i7ÉÙ·(н)œ­³­P„>˜£ÍQ‰;¾6ÜCçæizñ8̨Ð _­ à׎±‹ˆ®‹%ä À©ÿËAY‹ÉG¼:Àw[Éê Ïóü¥¯Å  çZͶ1!Æ;XÆ-ŠKXC›ÔÆÉ;·òôËÍšhãybÑ{z(ŒWzvÜ0xc€1œiîó½Tg†¢†áºhUaT& g&†ð%Ä%¡ü¿S T}æ$ZÚ$ÓÑ'/ G¬Ûº®õŸô|Ŭq:»25‚ÈÏä‘Mý2j«Æ—IÚÁÉ‹ 7 Oõô}ˆc^ C5–…I$>Å…5>Ÿ’nРͪ·^Z7i!—„¼‘•µLòE›óM2%Õ¡µ3™C£ˆ?ã3­uZ£¥G±c%³Úئlª¦ÛŽì±ÿË_ÍW‘¬»:A‰9TÆvZ¬bÑg¸¼IÉëÁ¿UOíÚ®ð Rä‘ uÌ5ÛÊ·Ùª7NTµ„Ai}¸n]YWÍ‘uŽ’[+¡pÿÓ? Ä@FCؘŒºÓòMèÝL‹Ž‚­ØŽ(ƒÚ}°TÒˆ(HßÒ¡”5s´@Ó1aÃ%ÆYñ2/ÓxµÜÎsйŒÐqû["ßR,1¼P #zZèJI·n{ìt¢Rà®V0,³ Agņ۹‘A£hvÀ’Xƒríø%Ë-ØÓa>9ºÓÂÚÔÉ9m“!ׯeÙ3C)þÒ ,UrÊ5³»hªÃ¥wñl0S¾ÿ3.r:ÕÏ„pÜ4ü`§ö8û§ß´èÂ|WB¸î^”ƒ\Âü¢†h¥‘ˆ‡Ò(ªJ[¨ƒæä¬ÉÖ§ÜÅ;>™ I<Ô'NŽôðëݘ!0:ìAx.@1 LAqùZ¥¡UšO‘Y8žeá§g“4¼¹¡º¡ñwÕ4w=šqK!½¢Ç·‚ËßÐɽ bœ`DjU~›Vê+®¦ñà/Y1( t,ƒ;³Ü$Îø‹º²~¿>éær.ˆ ìz¡(Š2ì,îµöÀâ „ˆý µUZ%N!Æ+B/¥mÐAò"qÐú±oÒ4MÃ(s,E¡~)x,­ÿm½uî ™î³4àR®–b儃or½¸6‚V9ËX‘ú}2ó L|7âË¿§EÝ™xwÄÿùÒäØx8¥ 3ìA¡ð¿ñÜ­”¦jGK±Ü‘´Ê13ü<è/“è£À\Ú~ÐÈð ­òÂ94Vt3_½ÖkDNþ].JÛR¾ó£^~Õoœæ‹EL‚²_KMÄ$è¿ÿ.ëÓ-Ý~½M–<ðÍ‚â(žõz©¤©Š¢ôó Aé%(>%°[W»²…Hä™Ä7\/uU<ãÖÁËO!œCѬž—Xuc¢ûÝ¢ä.K 5øMÞén¸ªáóšVu¦u£#AüÿÕç"§áÓ32}3£¥S…-A %(žÀôÐð˜ú^¦/ìÞ˜úЙ¨ìÒÇF @ÑSòXÌ›ÇâD‰ç1bრ†ZEøa2`À–m\vm$>ðûPA_D)Sòc)"¿xú^΄æÌ|6qÎŒi“_Ÿñ %ŠhDÊ£+ñ[Ê”åS¨Q¥F­ôi¾§V¡be™¯?}LoÜ@ôá#„ OÈcËöȽ·˜+Wî½»ðÞÃkׯ\ºvùbà»·ð=¶-N´˜G^ˆöòIЧOÄ DTΗï½y‹E3>q‚`i¶ [Èbàêƒòš˜p ÿ£  Q ÐêÇ|3r\†ì‡H³”ëCdhéR0¥×”>Sf¼œ:e^· ÔfÎìA‡Ž7Zþè§é§®g•+¿÷ù¬rÕŠÕ$¢$C×&ȈEÛÿøÒë/¿#à-¸$ƒ¿“ÇÁ#äKÅḵÇìù æVÀ 3D8ûŒ1 D3mÒB[kEÙR#Hž´Z@¨6×ú` áÍ·ŠFÁh™Œ4ºæC”ã§cN%FˆN¦êª ϧž¨ä;Ä#мóÊsª©¦ÚÓ½«ÊìêLøÎä*¥B˜‡­èa¤ ¶àBÌ@ýJÐÎ<Œð϶µ°Ð á±6;ôÿpÑõÉÇ1BQ,1Ð$Uñ ÒjS­dûoE…r‹ˆ7 (Â'¸ 7Òh”"KRÎ$ç˜Zi^òÊ›xÂ’:¡ª»¦ðÆÛò9¦’b‰Ø1“%M¨êcÉÙ°Øü¯„y è?·øzëA<Ä+®½òÒ˰´By– ð µ²>Pt…W<a³| sŒ]‚ó74ÆJ‘±Õ<] ¶Ö"Ȭwë ¸Z|ÔH£F¹!¤¯Ž\R%Dx9Š—¢´Î¦+³ã.Ø]sv¨xÊ[êã0••ù½#ÂÊf3çK>”V¸AŸj ÁZlÛÚÖN>õ2P[¤Ç—0Ä LM1+ÿm4 .<4² +»¬ÞV< {3}>s¬1J ­ôß~:¨j·]u­ÒÑÝL=Ub U%R$$Q2DV•øñ€¥›ªÛuä›®›’e˜V~驘¿”yæÊJó¬ g$óA„(@" >¸Ö5£%|ë-¨õ:ÂÛÃjg ÂI¯mžyg·ÝwCè¬2üV»ÞzåìPzÍù íaDÎBO+­„`›û¿y¨}ˆ‚݆ à7|~ˆ˜â<ºáÕ| aNÖF˜üpÄE¶ò°ì)'-Uî•Xd]seúÜOªrÀT+ôèðÀ¬Àt©›ÀœlÓº#<A8·^‡ÿ4sjE¦‰ÔÙÚå®D¡k–YòŒ÷Š$3•ц¶Fw}Àö ^¿ºw©°Æ6 ‘M ‘#Þ8 8¿áÛ2ž±ŒQ, psÇ ÷”ÄeÑW¹’Ëô'“¡ø/=!bIXžbF6Kshú\U8÷Æp¢#]ìX:C¤î,¡©Ñí\W¨ë0DŒºR#›€ùË„Žy—d:3<zÈ1\A _¼¼bª°—£ò‘‹6uÆ,’iÓbà˜9 ŒZpâ@ò‚j}À9IÂo~S‹qÇQŽèPb9úÑO‹Ã¬ßçvå,I+ï;VÁ²­,++nŒc55w³4ÿuÈŽ0^sôhAƒü'ƒòøà¿¥-?¦K6ª)Íiù˜ÈD’–¹Ì¢è•ÉLÞ†ô¢„|ÐOØó^ô ‘gJ)§CùjÚ ç~æ!K%‘7¶DÕFžˆ‹ Ç$e‹—¢Ò“û‰ W‹Ó_v’ eŒÎLc|àSÀtî'qT`4±‚Ÿر­@ÄR'´Tš†uvB‚ø4!¶,a ¹šiN˜!nè‘Ä«§‡TANzH†”àç þI °þÓŸ\µ×½R⨨FFh>dAZfC­ÝUk7ˆ¸©ÆW‘Šn¤»!Ð󜂔˜ÄVwJúcú/šÍ“±‰35IeÿiúJ عªt®s]&N-`Ç A?eH*OCH Þƒ0‚Ô‹:×y¢ÒL¯‘ù€ 94Ï{ÙS«ôZAV[ø J¼ÂÀ+XaÐE™õ$e3hñ™¶eo-o \2Ëü Ξñ]`D€,g$Ö“Ò‘Õ„<ÉŽb‰"4*k²Ì2S};ÓÌVÀT æ’ |v»§ûœ»é퇜*Œ‚“TÝ™k\ÓgUzæ–“¶§ ;¬Š¬”X@?¹P!B! ц̢Ö¿ˆN‹AA¬ˆHD¼;ýM*FŒï‚w#¨z bÆó&¹‹]ÿ$iv à¢Ü”£eš¯4¸ÉÖ÷²ùÕlç$SlFK pvêS³LÀ¹ÎÝ#¶°.<f WÓõ2¤¡ ?RxVqn­úgëV¸—ü'q;âáÚSÅ!¢ŒYò!4ç® Ei1Hmœ›ÝØÒ7øœøÝ!!e=·Ú"zÑ›Lõöʰ[z‰}we*§©15 ¬m-Ÿ4=2×ÕÄlöëk.Ë̲Z€>kæ”@ä,žœ:% pkYM<ÍââGZ˜Ï¿P±n{ëmp7“Åä?K¬Iß’m´¢tn‚}¨ÐìQËZš(SíBÌÓŸ^ƈlä¨Óiœÿv¾£“ùD¥ ïIçP¤\C|²g‰=Öȹ›õײ¿®JL¹\{x™!'¹¯q¦l Ì4!ÌòÜçÚ£ E{·Æå ÒÐ㔈žð<£m c8·U]TVñ!o×K†î§&‰«Š~~H3Bk›ªí/ØžE qp„Šo>ÂH‡ôK‚»D&SLFzîÈÄíòxŒép¼ÛÇ+# y—}­Y.ó$˜µø¬(R~Cg¼—}]rÈ÷=ä ¼„P:Þ,€ÀNeѵøȆ8Œj¶/Ìg}¬ õUõ-¸uËáA‹u¬c51º“Û(&ôÝqmÛ<âÿÕYnš‰Éåw—!ÅŒ)<«Ý‹ñ¨Ìî~§¾ßò˜e¿}ÿ»ã½ï}’ïPüùÃ/þšüüš• ?ÈŒyDðT¹9 ë°å4Õª¶-ìŠAdp/á1 Oâ¡K½9:{j½×û6Þº*®+±r#.Ù£K±²ÀêÙ½‚è6É D ³Š‰ñ®g8;€ãœ-©>lA» Ô,(`¿’Ó/ȶ’û»Œ<ò#?ô[¿ ÂüAÑÁ0ž0„x™€k1—p =¶ÐšŠ—<ÊØ¶Ynó\”£ëBoË*N®±´q3±B±~Š ‚j“ÿ“´Ý{®4Ó±°Äø® XŸÊ’©üÄAœÁ,€@ Ç.+DC”AC$DCüAGlDvdDFTPdGyœÇutGJ´ÇN´Gz˜D hƒôÇEŒÄE$½” 3 ­ ?’š)”x ž ëšÉ Eæø…ÿ «']´ד$T…,´r#±ÚKF5ôZ1ψȆؽxʈ?J°jÄFaŽgÀ>Gq,Dt„‚Ÿ$D¡J¢üÄzHwlĤ|GzlÊ¥ÈFlƒ~lƒ}¬J{JÌÊ«„ÊydDzx$D+ž2‹7)ªÃXªvb$ÊÚ²­y²HæX1¹üìÈl¡ Éâ .“ìK”Ô¼²ÑQб~•”È#™´€³Fh’kxdàCì¾Î)J ,Çq,Gt„D_³Ì¢„GQJxtʦ,MydJzH”J ÐpÍ~tMzpMÖôÇÖlÍ×ìÇ×ÌJ×”Môˇx ÿÓšÙÙY§ ™¡y¶”*$À  ¹¼]¬Î^l=^TN É@ưêËd| e%zpC9™7ßÁ<ÂÅCCžWhˆO`h†œ\ŸÊûlD~ÅslÇýtÇP¤ÄÑMQ”Ç MýìD¤4ͦ„ÍÜ´Í×¼MÜìÍÝÍÛœÍټ͕PmMÔ€Š “(ÅS,ËAJ å”°J«Râ À+D=¹ì¶ËÀ?ó6êÌQp«ÏK0IbCƒ*OÁL°y“¥ÑÊàz…_Èø…^¸aˆÏްFÐ/ ¼Ç,=ÐÓÔOx¤ÄPÜÒyäÒ¥PvÔP¨DMÍÍÿܤÐÞ|ÓS9S9}PÝ¡ž)‹7# ˆÂ…йHû? —Úš*è„ËÍX±_ NºìÅÅ0yñˈ¤zòÎûQJÀT°F6 ÌRÊ=ÜX3ˆ  ¢P…&Í'ý…KˆÏk¸`8íR/%Ð%P}Ç}M(hÍ¥M^Õ€^ V®lD4MܬP7mS7}Se¥ShÓÙTyèGÁdŽ qrçÊ¡ò”'l‹çœÅèœÔE3«­Îx—CõšE±ÔLíËîÔ¼Á³kû@Ã42³«ÒÎ^pUÍ…^€Ïf€Õ Я¦DP[EP‡õÒ_ÝÐíÕÿaVŒ…cèÕd=Vv„P…Í:ÛM’•Ð Ö …S”íÐ×ä¸Ó¯0ky€€Ù¼´"ÒP*Ô(0½xe¡›NËHW+›f|JŒžµHFF“ÔÔ“\FæÚ×k Ã0Jˆ!¨»„KØ6xÒ^ˆÏʆJ´…G³]Û¬X J‹MYŽ=Y0†ºMÍFÙ¼Ð6í[Ù|Ö•åГ \j½Í—­VRD}h !ˆœmÆ ÀŸ3=¸¤*˰¸¬ «“”Åhyغw…K{*±düQLÅÔ ±³r±kKÔ‘ˆ™$+UàÚ®í…_hƒ6`Uh8A\@ÿF„M¸E[¶MÛâí͹Ü8•J»µ[4Å!®Ìʼõ[ÙäÛ UÞÀÍ^–Ðõ֔¨$;j\`€aà)ÑÒ#ríYç̶Ÿ º£'Z¥C]Ð ”Æ€WèdTÝÏzÍT ¸„ÿíÔ AÊÀ›”è j¤]áâÚ^è…6Àݰ}Lh¸5mÛéµ`Ö<ÓéuSŽ½Ø¸Ó×lÞbåJõ[f-ÙeÕ^®S4uMÉ@šl\ah†f x…Þ0 Ķ\`ß©º\‚R·£mú¥ !bßë9è¤Q0¼¤§½Ôÿbe<$Q‰!Б‰ˆ€¬U:eàÖݰ=A`XF`J³Å`y\Ûÿ‹ Ö¸%ÖíuÖæÕЧ4V ŽÜ´ãyLV:^á9}V?fÙÝ?}ˆccÜ®a H…¬5³~¤õ}ËË¥:G">b"˜wºŒ\F¼Ôbþ`PÞ€KèÔöaŽÙ©mÊZzÑNUˆRWÎ…ÝÒW…† ˜5йMÖâ•J^n[¶5Ó7ŽPcÑv,æ Îcj•Ç‘mÖ?VYhmf?¾^ßÔ°ü¬Æ¥ákŒaÈEß΀öa †ßI> ßx ¥ÛBTB@÷<´dü_®â èT}˜¥mšˆc[ÒáZ:/vàݽ„Y&[-Sý¤Ð]Væ vP½mV8E^ʧï¨Sï‘î4•îÎWØVnà¾Ý^0X«†U|@[Ä-ÕR'¸ÕÿfG‡…í×N[½…òÞÌíODð9æÊ[FÛ/n_¦ò…Þ`â6VÙÿ}ÎÆù†Z ùñxlæ%ö°·¨Í8«÷Ín}ACÉ— ÙéÕkoìÕû°L*oͶÎ&3k\¦Ž!®rJÿKr/¶ôK¸ïfÀ‡(Éû;'ÐA_ÓÄ ÐμG(§G2Í]ÍUQ”D%ÏG|,fÒÔàÚ¦Mã6ááÎà¾ÍwÁEƵF_¨áÇËO%WQ2q^vH¶ÎÌ@æ”Ñ«”€—¥!÷½Œ«"Cÿ­qQFÉEÉb …ˆ'p‚]U(rK‡†û¾†]¢€ú2õ3R·Dǃ¼O S0U&×Rõ ÌrÝ>ëw¤h6m[`}ø/_VÿgSœð†M*Ï便®…íÊÀí~×(hË éÙŸ Ú¡«'>O(J!˜J>b3°wõfÔ­ uÚK qPŽ:ãÉ©¦1Õ‹Uew‚}÷ÓÞtùÜÌ錗z$Gš<0ÂðÛ÷û ¿JÌR'Å&Ïz|ôú|Lë…a x^?^ ¾ø´n‹Æ!S_DÞ. 0- Ѳ-ŸÃ-^”Ú•Ü$vyyxÄùk‡W÷í°q£W®]]” }–á+T¥ô'ýÚ\¸t ?Xù†Qà©Z ‘à™Îž5ùØÓŸú¿‹)’¹|À÷G”D,ý´fkéÅJ¶x^wÐÿ´gh .M{¸Sψ¿C¶áVðn9˜Äø{­‰—|¤Ü*âÜ(ðû ñ=]Õ"b™¿B_À~rêþIL J 0|0÷jTÌ/KoÒÜ}ÿÌoÕkôÍÛ¨¥‹åÚ¨g}üøUà—¯ÂÁ|ü> \¸°@ˆ JŒX _öòA±g¯£ÇA†,©ÂÞÉ”U¤d©e˜2UÐSóeÍš1kªxé³'P 1{þ|ɲ¦ÑZ iLXDJÈ«*ïÞU«-äµè:½bóåÓ§O„ˆªÔ.X!B_¾!èµÐ0Ïkˆ|!î¾Ø*ïÅ< ˆÒ®(lØ0¥”|ÿøxåƒäK.Q¾9ŠV,pRK˜ΔTõ*ÝëWÔ.~™îu Zh\£6P@d›ŸmCˆ*ì¶]A_o XaxñäÃTHöyI”ÑMJWÙåuöxÖÜ~ò&Íðày²,oÞ%z£çq=ùA_ShµZ}xQõþüZ¹¶8Ñ,=EQZj1æCaoé#€þÍ“—>ˆ5Ï]ˆ¥Oa­öJa¯8öÊ9Yd’™™mm¶™ø„šeª°ö ©¥ÆZi¯Yð >=.P›m½!¢[n¸ý†ˆ>¼á¶änü$¹dqÌE‰\BteH'­´å–,a÷¥K(qgÿÏP9‘9“gÚM(¥ÞP1 ¥›>(À@cÁœpøaUWüqåß `Ù¡E¬p k­`V>‹Òs×!¼—XF!txØ r¸À+‹=Fbd“YÆj±ÆÊ™‹„6i¦¡–‹8ºÍ+­üð>Ü`A榬²F*Ë"ÎòöA½MûµIê3]uÑi)—[¨¥Jä鄞yä±)žPì•Pì©—¦”à"D+ÌcÕ~…nåW‡Ȩª0¶Xk¡Eé\ý¥©\rij–[†a6jb”ŒÈ*%¯R‰¨ÊÊb‹AöJ®¿ôzãi¿¼öÿ ­´ˆOÜ$D2»3³:[Û›ÎÇ ­n¸aI¸Ô…›Ò¸bvûnxMC=õLkV§Là­‰NüD€ï!PÅBURxÂ]\Ý'OÀÓCÖY…=ÆØ‡ ¾•]‡Å|PV&)ˆ ÎÍ1â“胆+Äú­¡‰™®¿ä²Úi½!Ì CP@ì(?´b³!7 R›Í§Û†óê# n›éªïlú<+ËmÒ].­{wPK5T“çÝÔ?•÷f¼0åD?”X Õ<,°`vX_¥mVúýVYú8z`Ý’¢…wXb-šW÷g¡…$©k­µêª–y ò«‹q˜Ù¬3ãÃÿÙ‰¯œæÂjpÄa\âC@D+zdüèf7xà±L'ADH0u6{àéÁ ÂŽDJél†»rë[KkÉyÖžë\çzI™¬¶“5±§'5‰A>@ @€B-0›Ù~èÃ?]%?÷XB 8G¬pŒŸÈ{8A,V„pD€ˆ_¼%-’R‹*T±±ÄÕOq—Y"V@üÕJ4 ckJó ÖÀFˆ±ö÷R Ä`)h3ÔÝL°£ ìÈBRwÑ ©C®Þ]‡…,\ay†bµMÆpyàG4ðD@=âûs"bïÐÞÛäÅi ÿAk)’¢‚„À öàÛ€Òwõý¢ba #ü2V•Ej Õ¬@w«¶¸Ï—pM/HóŠ—…Às?ØÀ(ð1,ú±t¤ Âtú1ƒè´`:ù˜Áx„žö°g$ó¹.Åà$Ëûgx°ƒÉå©0LXC A5pCÄ€7ˆÊ^æ¶þȃ•Et¥+9ðJ¬üg@êsŸcT¡*µ¸%ŠùЀö!a¢¥@ªæÁVeÆ™*®~…Lþ, ŒQ3hù…**C™9¾BÐX:=þÀN½Ù ×ÙG NªêD¤KOÔm¤«Ð>õ9Âo‘µ[Ñi(CÅеžG­ÿ]{¾b†Ž *€À¥üC6¿\e£®$`ñÃô™Å‹aüPclY„…•å¤Ï1 döÓ‚ ™‡ãXýš©ª¶ØF3›Á‡0ÑS©E¨—ðÐk„°‚ L?À0B7, € ¥CV=ÈÈÓõñt®S]«JÈA uørÿ†Ü ؃¹ù*tëÙU±Æ w[ªnuQš4´ºQ‹ÚvÀÂ&€ÖÉLýŒA >°‚H€hA øŠì °ÜÐò=ºH ßb]@)aFÖ.uŸ;¿ù1S™‹A•¨4ÃaÃ) Z fÚŽ 6Ç­€!6€dŒÂ©Eÿ-šZUdyt.>–q]üºáê¶Å„NsƒŒ\Ó3¹:ž+’íÁH–„!¡GC·SÝÅÀÉQF+wròV-3Ê9‰ÁW±D0âl­DÛ¾Šèתü°:¬ÁDdËc–T†¬>\€¶¥ª`bœIÄàe&Ž›hñŒ=yèQûe: ›!U`†ÖNì `Ô¢¶H€qµ*ê›ÝötÈB–êZ|ÛÜžÚ¶>NH Âã@„!>FîB|¬cæÙ¹Í-À’õéd)ÊÉ®±»3®b‡7<óà.X¦\e}´e/òH›`‹ý'Š_™òhÜ ÿ4·'3Ra´›Y|ç³0ÆMlP—)?y'NV´†¢› tÌšó¾„Q¡aº0â%`Ä(ŠZÃÈøàÁÕ¢ÕG‹5$ŒÏØâ­Ö xìcçÇ#ÿñqn}k“›<ÈJö5¯<{Ì|ØŒ¸¹’«Ëzì\Émê®—.t(¥ÊÆ.ónÀÞˆ¦ùÚ<·6¿Ø\QîuïݦÛ †ÌŠI–.ðº'{Ldޱ¦šu¬ í<[}ÍÐwì1£R"Œ( Žp„Ô# ÷àkAÏU¼ð†?|ŇTø¡ÉðŠO¼n Oòƒ¬¼ä,¿<ËW>òÿæY×ôäµ’ïÉ‚{ç;wòΚú ó|;;÷òêyîåy4tXÁó$ö^6£Y¢eÁ*ÿäzô­Ï`äïÁšø¨Ú­¥’ÕïKËReΛ~“™Ì­Ðn’¹ßo¿U™TQB—ø€<Ȧ÷#`š©E-|±ŒN#¡ð –€!ð_ýÄ Žüÿ9^äAâUœå &àqHÀjÞ1B@`s-WrMrNꙞé)ÑÁ”õÜéÅÍ•˜•™Ù„"XÀ˜Ir…ÌC ÜÅÙ ^©Xx”ŸÅY )S¤4IFZ,Zðôý™ô5FÙaÖõ ÿò›hlßfx…¹¾ñ[ÄÏ£½B|ÀV<츂+$üàý@àß0àìßþ½!ÎáqôæŸý áÑ!êa–\ÿõŸ2`VÞ:`rE`ÍÁi ’1ÂÈžéñܾ#œà¥œÞ<”Y™…äg É胆„Í)I¢¨ÒöŒ…ú€Q‚¥Êáð×¹¹OIa£¬€£-}ˆƒ‘‡e®]hP˜S4ƒäØOÇÀ¢*èƒV…ºÂÔC=€Àž/¤B Á²–²Ö"~À6.b¥õ˜Âážc„ãÀ!ÿñCŹ£Ú!; !"fÿžÉ%â:~€B $Μb @R¢$V¢ìÑÞWp" n"MÀ×´Âü‚ÌpÆqETW¬’*–O÷¸€[$X’,¡Z¤…Ké.ºbœˆÆMu†¬Ú‘Ìæà0ÜKø‰_H½…µ‰!\€+ÔØ!ÖÂ\ký#7r#?ò£7vcR²S>¥TZà>^æ¡ÿ¢ Zž=ÒáÈõa:Îã:v#?f @– Zž^ 2¤&râ&º%AÀ €_+€€N=…¸à¥ØEôåäa4,’ßc¼ Êœ.6Šó1.Z,¢dÒ” ]_0ªÝÚµˆ>áMŽFNÂ…=ìË @ÿ€Oþdß eüùB-$€+@Z¶fSBâ?Âf@jàQÒ&ZÚ&â=^"ÞÿñŸÿÙãÈ£=–£Y`¥E%7Âfk¢å¥H"… àZº%'Þ€†NU^òÏ}…¬€`žÙŒJjŒÆ Œ:_KåbðàÕ±ÊÜT‰4!‰Ädp~æ'|ò /ÀÞì ô$Ôƒ+ Ai‚ü9 ”€Á9¨ƒÞÜB ÎæÍä-ÌÜÜårFgt²å¥l¨º¥̤RX+„@$~Å (Ôw:¡Yp‘!ÿ–‡$“¾‘*Lb:ßI’Tœ%õõâȉ@á|"¾B´Ea„Q¸YDAx(ðiJc˜a‚^c=@ Ü)Þáé6(kR(k\ÁQèžê)¡æ) à䨢’¨Šbe ^åýÉc9¾áqL€:&§mf*#èè†ê¨†*$Zꨄnê<\À]¾/Ð¥„쀴ªÀ†‚ù™gchŒ‰‘‡Ð"Iª'{Ê\– ÕÔ–^_}^Æ—Æ]rˆú¼…šÖ“{è (i¨i2DÜÜé¡JÁ=¨ƒnè-L@¸Nè¦*ÞIº¦+ x^ežÿ!Wÿ:ŽåTÚæ†ä†Jâ†~ê§nj Šj™ÝUXá÷YDjJs¶*=tØ%@–xÎêÉ Ê&QVXc6Q­Ff¡y ±Vf±"«¡-@[,HäÂI-Хܕ›¨Âiœ"(à-2¤Øé¹J¡Þ°&ˆ+#ôéÝi«º®_Þ-mäM\űëá馻N-¥.`X^­:V¾Öfl*g§ŽªÀJ¨m¦å&B@+àB3<Ã÷¥Â+¸à\´êväƒ\Ã+DV©kªßÅŠ‘•nìb2&‚ÉT°f¡]ÚÙ§É¢,c¬ùLÑy„­›J#åR«ß¡¡ÃÍ è¶êé-ôÿ)ÑNkŽ®žJÏ,í܃ީî(žëN-ìNí‰Ö£ÕŽc¥jmæ+mjàÐÊ&§Žj@*çÀBbu>ƒÚ^!}X ¢ˆ¼ 4U.ô™šÅÞê-))•æâ1yˆyRlƒ±Êf&ŽÅª lʪ©TJ‘M@¨+ è€R.œž!üÁΦæÜÂÞêç-‹+†BèžnÞîúé]ä(ìJ­ìjå£våÞë8r£Ö&¥l lïv*oêØ.'‚0o3ÔÂ…­ê…… »lèCôžÅ/x¯÷š'HŽÆ©'å™zJi™ŽÑ«îÙ®Ú•¯Œ©â..ÝÿSHÈkA«´¨FqÍÚ/2Xk- ÿÞ¡âéçvhmŠ®ª·¢nÞ©®êžÓÆ.ìþ߉>ª9ÞcXÞëÖ–%×j꾂mð oZ&US¯0PBØHÌ\ìS ˆÀKJˆñ•ЇÌðL…”Âd/»…¯º"/Â'õ¦]ÚéP?†â®¼Å¢|ñMÀ]M@›ò€¾ißeœÆ)æÒ郪ÁÍ m- °‡+lÞB·¢+¯_Uª±£à£òfÅéß‹–ã:VpSâ+Rf°¦~pJè<ð€¤­SÃÂJÌvø]ÀÇ+ä„ÄÜÏ"ÏêÇØjK)©€uÑ÷°ˆÔð–Rÿ¯ùZæda¶Êâ’A”^Ã/B±4Fñ*·²ýÞìÑÀlñòòÐê²Te¸òr,#ðAáËm s‰ ŠÚaþÍc2§ã:^êîF34_h…¦tkB@u¾|´B„8®¥|gb¸ Ëê‘TKÙ-†Öi¯‰@öªgG’T“‚ï%‡Ÿ}Æ$%hr>§ˆ'»E\ðãûÂl´Ö*W.PÒoÍ ¥5¢&ÿêi-C" à²Q®5‹+„š. °nÅiô Ð+G{tGï¡ÿ•㋾èÖVpîînJçqðvk¾¯T… Ã+„M.ˆr/…=(†\‘ñ-c.tE „@.ÿL{ÞÒ®j¯$·Ô ˆ§ZŒˆRnÉ:u?µk‡ˆ>Á0#ÍÝUж)ÎìÌv5åš!5Rc*ܬ/üÀµçm¸²–QZ*7&·¸Öò[£®à]Ç®H›ãHg­îbjJ‹ª¨Zè…–-D4àe+ˆÀªXh@<Æ‚ˆEèàb-H ÜC}·€“Ø‘¤P+éNSeÝj--†fÅJªè‚Ǥ˜>õ&£¯'ÛFrÁlÌ(oS8ýô¦‚†ÇÎ&À-dkÿr1/§uR^À-,wRN¨ƒnkÞ-ž‹¿øëV·VÎ!Úë37îÒè³ô`ïñÀ’ruRg´‚8¿-€àÿw,€^¬b|« ä‚8w|¿0iGi‚h/€“¤[ˆçO nÈh >¿¶SãócD5™"‚ ’2›´@¿én÷¶Pjxp÷‡¯¸ç²‰;wr§5/*ž³£ ót[7íÒ8v‡åÖ6³Ž÷xðÜJƒ­†&ÛíH+ ‚\H6€ EøË·µ¢€ý“Çw~ acîªó­PQÖZ Ìh £%or˜×sܵv‚K5gE?òüN¸…«r…¨iž&jzxÿnëƒ~îD³Vr›8³3{Á° ot¡Ëx£óu÷µ¢övǦ )#ØJªŽæq ­ÌHŽLkJ7·jYtúU4ÿAWЃD“§žµ-F.®'«3Q€»zy*Ó˜j ‡HLÚºk¯ÃIš²)ǯ4ºù…nשôÍZãü!Áþ·ç~ë²?{sn´ãé‹·«µàFðþÑ!½ŽtIãë 67 éØ~»¦*')ßœÝÝÕ| ¿Ét\x³B)T^tz}ßCÈûä¾çY»e˜Zpïaø«WIEÊ 7†=5ˆ€½˜—/ÂZŠd!ã7?J¸›Àü^¸üô…÷Ý+/Ãp»Â€0¡Ž./ãò²jŸ>èjôhôÊXb{ãŸļ n£0ºTÊfΧ¥¸óüßÿ•LaͼwxµÁö´Aô€¼sÔ¬ï“çY1Õbß Îª“6 Yé¹qˆˆèPáÎù>5™'<™#ª 9)·éáO¾½…ÏoÆ÷ö*Ó=± 7¸Âç–€*ÈCèCç2ë2…m Ìuâ¯1þÙ_ã§cH£cä×|·»ïQªôÎö†¾ï¦.EhÔ­\¨÷z·ê¿°ÓD z!òåÒ§ODB+Y¡êኈ&\Q¢*ˆU½ê¸àÕ++@‚Œ’ÒVúHI)BÊW'%" '®\ñ¨÷(PC}ºªg´^‚ @¤JUËWÔ¨ËFX:„Ä%ް(áµÿÄ-ŒHL¸5aìYFÈ2r[ÂP\¹séÖµ[·BÜ öò•à·oÞ ø^øpað‡ &(®ÐxBdÉÖ®¥ÌöråÌlÝrža" Z ÉÂ=ÕªÛ¬ÖÐâD‹&òZT"J¾|ú\ˆøÅáB‰Ã‡ÿNXD„*‡Ê9F|åR¤ÈHF_°à%ö™-¯“„ˆHâuöüé¨Ï¡õ ÔCtˆ©šB•ê«–Óµðý¸Àõ«®¶ÚŠ„[ (ë,Û‚à–¶1äÁ¸"„ð® -Ü« ý ‰¿Óð1Ń 2ÅØ’,²ÊNT‘Åךà&‰À‚Wôù zR£§ÿµÕT;AƒØlóq (BÈ¢…„Ûh¸„~QÈ!‡.bR¢W(YÁºW°” ;UXÂN¥˜°‹‰¤šn B'|z/¨öØco=¤’Z „Vœº“>¦êC™T È 5y2ÊM¡Þ„sÜz†Hà\:•Zw©§ì£ ­¶ô@µ ‚Ð Ü´²ÌŠë†G¦+/½ ÿ0¾0űøzŒ±ÃLQ2S4ãSS…à (iEUs‚H]qUM {œ°'„‹4Ù˜›LId/’²#,KÒZ-¯ür¦¼ô»•J*S‚‚ o'WÚ ÷§öØÊ9ƒJêêz¨ªej‰÷–Ä>€ž´>‰ \!”íD! P®F¾ÐÒ‚ëöðR$N 1N%ðOÍxÅÊH… C"ˆ d—KöñÖrÍmÖsãMæ$Ò§X}~©Y¸å2ŠN¡¦ng•@Z©ô“ˆÎ&œÈ«ZͧÛLÜöŒB ܡ̶ºÝ§Z‰(ïÎZ”×/•ã‘à©í æžÞÿ.I‹´°óZì± îôïˆQ4qUÂm›®ñÇ]3y5{t dÜ0?8âšüüHJr8Ì*tŽ–º’xIh,!I+†Cð”MÞÚ‰íÖ£;¨UjGÊØhǨ)…)û©Ÿ|Œ¨ C*ÈÈ|@@!¨ zÔ£ž`¦°Ie(aˆi؇8e˜NÎD˜ \‹6S‘Š-!øûD澓íJ5¹ÉǬèq9äXÅBôaÝðæÉIŽF˜UléÌŒ¥£Äµ E ØdiãI“Ó¨†Aöì®jìáÁ©&6ˆ­jf;ÊO0§v)Ï>÷‰Ê ×¥' $@mÿ’$Üdø(nˆC Úaß¼Ç)P1ˆ/2‹2ƒ¾ÎÌã3ZŽçÄ\9~º™bn Ò›_¨â7 ‰þÒ²Yé&ŒKÂ’DJW&阑h"1à nP“ð¼,íúø¦ßÙŽ=xÁØÐÍ!ƒ J!É5ûœ³V)äO\Ñ”€`•˜ÝârI !ìC™J Ä&àÉ…ªDSÑeJ©*ϤÊ-ˆ€Ö\F+ÈL5,“Ÿ,¥èÞËÇÊH±:—£!ä‹ ÉD|0Ìêl$Ð"Z2Û- @šhJSíúHßýÎlÛ7àMpZmœådÊS‰ŸtZEV!jÿŸ °¦Lžv¹††·½|ú?ùI¢ÀU¬pK߉ØôMG[9jÙã ¨#'HQ7Q«sQׂ¸¯ÉEAB0ÚÔf Å\‡ÓÒÂvgejã (°­ <MÊcuºÓ8íÎiÝü#7G6‘“z¢S”‡Ó./yˆ¼2¢*C{& CzÓgÃú¾¯N1§ÊL)9#ÊT¥ZùhYËvtøµ–N€¥Zg%W¹â†-ˆB B@ݵ¶`YÍå’E‰œq±ßն޹‚VèŒ&À9Ù r§6íN5[ßö•sj~R‹Hÿþ·´RYÆ2îÿBÏÖlRzɤ>aËðýÐ1“h(W”Û‘r¬ú€–!ˆ{|¸eÑý눣 Ë×&Ò‚^»øÜÀIÄŒÈÑÄ+Þð6pÚZ/e ÀcžV¶§b{¯ïè[_o®ç=ä¡hŸ‚''» ‘MÎO€}Aà§^ùÀw¹T\ŒÃ«fˆ“œ ÑCJbŒ2½LÅR媤ÕUEЇjæq«[ÙãB:±löŒâºþùUÿôA9Yò¦7Ñߢ½h80šKk/d)ûãøþ±õÅþv-yxLnŠh›âdÔöWÀvqj–¦½ Ì}ñ"©†ùåÁd&s%\±ÿÜæ–EåëLc‘㤉` øpÉ^³„Èc6M¸‡´ïQíjÿ5öÜ/Œƒ%ˆ Z˜â¡{“,Å6ÚÑ5¶bJÙöŽí½Cææf‹üGoÀèÒ·ñÐ ¥¤«œtõPK¼&“VµQaõ£hXkÄ$XoÙ«ª·zZü1ÿçm}=lT²1é3ÄBSy¥eãJu~ö mmÜ£¨ Ìýœ ¼r{XIN±üç?Y~±ÜèzŽ×cð‚“Öi¼-Ûãʹ§ônÏ¿×pB*%)_ŠÀG=Ú'K9áV¦@\ƾp‚%¸ª›-Ãør˜½€Ï0ŠaŒƒIÄk3cÿÆ-¥e…;flöÙ#»A‚ͳ§]í—˼ÏÒ­« rñ9ß39©ˆEóaÑ` gè°{´Ñ­y¼@Ò=†¯;[ÇÎÚT§q¤Q†µ¬ëê äº×¿Þ_û‚´6»\òr©ç%S ÃTU÷i˜}þ°{u℃={µÌ¡y#çrìÑ<·` Köáí¿žæÏmØ›ôÇZöômooú­o±Óõ²f@‹]ŠÔœ¬à¦Ì]|a.ÊnÕXÍz㈯ֲ‡0£í 22ŽbLTHäùR„|ÈjïDÅUÞˆ$ô!Gb#6ÿfÃð®íûp#Ûj–V¬®Žç,£ÂòÒ/Æ2"‚ Zô k(¶Il¶Iê¨ð(Nò¿kðÓ–ìÉ ÎÔjìv¯.|ï/îfø.…0ã/þÂa,b2®{$Æâ$ q«ã(&ú:…n€ÌKéŸÍOLM¬ºª«` Ð<§»o!ŽÅÀŒ\0ïýŠ.!ôᙂ ,Èœp›î §à¤ƒÂ© ­ð I¨†Ê)ô„ ñ¤ìè¢ìÆ.ç¦÷æÂ÷*°žvqRÐÐ÷Ãa’ù C!̇¼Š2ìPù¼JT ±ëF~äúhƒÄ‚ºÿ¨ë­þÊ jÃkI}c,jþ&QFàýë<` é(Í‚ìÞ0 Ÿ†Ž PwNÑõZ/¿²°™,OjO.h÷¾ðÀrQËvqs1S¬ê{ÜîäŽÌ>iÓÇ2z ”$ ¡ñè!»Œ+6æ!ÏD,ñ®q•K®"ñ 1fhæ+B"@&1Çb‹<>à’. ¿)ìÍ›î 5ÈiH\  pë2 _± kQ*woË.e0†¯RS°G‡,°Ÿ0Γj+2,Îâ  Ä‡SDª•`ÃG°«$iÐ$qã!Ñ7Že7§çhvjÒçoÝÿÊq[ ( ·‰ £N³ ³Ä ¢ ߃­p)ÕåÓÒI+0*q/g ¡Ch(â°§C¸ù¦S ãâP"û‰ã–où(’›)Ç:2»ü0WR.ºH°†K.kP® =Ž…‹zIÂ'kÒ'ñHÔ¦J '{ê‚Þ¾)Óõôñj"S2) /O ’h‘ Ï“3ÁÁ0ÐÖvÑ ³Ç÷¢oúfîÈŒ,]s|0ÒŸÇ$k“ÎR6²ë#Q°Vc¹`‰–‹–ºÈñ’‹¸¨"–s/tÝÖí æOnX`'ßë:í-ê‚L;ûOœ. (ÿÀó'ø12_4) IOü‘ï¤FÓ ² -$ã©’ÄPraþ"âtè4 £1c5ùé [Óo€±1|H5ÆsL¸æá#u¢vÓG†«AÔA}è¾ñI(´B‘åBõ¡Óo7> ¶D_@NÌÈ|Òw²æ[OOóË\à#¿X´e”)þ±FG«ÔÔQ9= ’='0Rh!uQÖ0°+3E5™t0ƒ0$rD¢ô{¾gî¦ØV in7ĉH†A]¦~|Å Ò¯L‹sj†‹ SCÙTÕïM?€WÓ«^Ž1ëôöÏ(TTE­F0Y#s°†•l+“ »÷ÿ†=­5Gq/[¿p*wôGkÍPíjí45…aˆQS¹§Ÿ4å0îÓ]åN"ÿ¸fõ°”Îüp5Lõ6–+°t¸`‰Ü¾‘s’“!ÌtCÄx•WóeX©^?ïF”NSlœÆ<úÔ1•µEûÔES±:c• à.©@ÈF»îZÓs35SGÍnËÊp+ âü¢!/ÐC.õ ÿÂHýæ?“ÔgCõ/ö–í6ëÌ#¡ˆd‚eèG»dðM÷*ýzŽ`3TM•ÓeI‰¼5°”äá0@b9Óó§ªf'¾“c7ÖO¯¦YAk06dUÑ2 öI[5e£²e=Ó.|Ôÿü6ªò\-Eg 7gsvîÜ‹T#R6ïFϸRŠRC­ì! –6s3wÜŽ9aRI4tM«¶CÖK³Ë-æN@ê%l`l…’vüPÑ–vÇ (cÁ³õ Õ îw[ÑëΓxñ6Q=“xµZ—WyF÷W.W {0% Ñq7Å\§]Wå°§¯¯DR76¢PÃW‚ ¤HŠ"4970}0WvWµË@ûªäŽ`a·›b·ô:hMÔ–€á¶€÷”O5–z—P_qàN¶…¬5÷\Èx­•[ònÿ–ì|4÷4x`|pu.€t ã³p¯—Rÿƒ{×ð{š”t9L$Ë|{eiå‡ >ÀÐ ÆxÃVCý† W;T‰Xi¸ À#±”‰õwÓFTl,îQN’µYonAK7vO{Wn µö²yŠ—Œ'˜‚«•xãÉ‚-Ø…âzW† •„WSêØ\ïØ“$†]!æ{×µÅ#Oà@oS¢P# t˜¢tu7¾—SˆÓOrAaqG`Du—˜‰ówÓô—7íÈüXm°v;d¯8w³ŽêäVà„7Œóä<°_À‰1`°KÏ ‚µ³€œÿ„Lõ¬jØdm‡ú±¯ëü¹F/ûë8¾=Ø¡%=¾§WÈÍS,Ýz‡ÜÉß.?ýÓÇÓɶ“œÀ׎ß“YÀÛBZ!Ã@ yi‡«×wÝà3\ñô^`Ø»VÎ!^Ä €2 Î-žÓJà{šŽÞÍéðQœ*(FÝÖÅpdÉSŒmÜ)Ä} ÇΡÚGƒ\¶T˜æUÓ1Ó;½¶òs,Q¤,ó³,×u1®ÜÒ 7¿YI3ºR?šŽ/åV‰í•HÐ×૾×ëýN k»6°½vâã-ÞÄÀÇÖ§ùèÇ2HjÞ„‚Ê¥äã>¹½ëºÎÔV>[EzÿK;¾ÆÒkÉ;½Ó)îç!#è5N?•‘ÔwýÓÔ-õf¦+‡þ Uxßa;'Ñy†¡¨e¦Ùê×¼œí5nºá[Îùw⑽âÉ~™ý<¹ÁÉ=RõTÏ=H›ä>)±©W‘àjïÇÚƒçûQevIí=ÉA1ÒÆòÍR2_2Dý>#C|:]…Ûß^5û;5+5+Z£©ÔC±tð¯h©ùüÛ\ë‘Ø¿þD<õ3 ìÜâ1žÙÿד€²œ†§â… 4àÊ@½z 6\1¢Ä‰#™˜ ^‚Axüè1•È‘© bò¤I$ !I ÓÐCÿ*\¸‰3ç›`•@5«W°^ƒR{–jЫl?@˜Çâ„Ü-äλ;¯^zw[¼h!/°`y÷^ÜÃpÃáÃdpœ!r†ˆ_8À€±ƒ A,H°`‚xÔKÈðáB…]~]16ÅŒk' ’¤Ë˜0_®üMÓåÍž>}"¹yüBò¢H*m.titçYƒ>5úìÕ¨5©úJÖjÔñd¯ZÕkS¸'äÕ•«÷}Þ%ê–§8ÿ½#‹ï-n,YdH†–aF™rÆYB¼@Pg£´Zÿj©›k²m‘†õ\dÛF݆ÛG©€à›o¼õöФ]q6 ÷SÕvI9Ç£tây5ÞYkiWzà=5žXäq÷XOI%%ÈØ\ÁÕ ÷á×ß=a 0&€>àØ€ñ ‰a曜AX¡…æj®9ÄPŸ¦It‘kzÈá†!Ö‰¸½¸b£(¹$‹Çɤ“Œ8ÍHŽKåØsF-SB©7ªYkÙÄVÛY•TH9y]uR %#wµ'Ïòàº%aŠùçŸ~þ5F¬cŽå0Ùd,{„‚Íb eG`YA®DHmž¡æ†}.tÁÿD„jè¡¶á6“I6š’Š»ÉäRO3Ò˜iqHåh”«ÏÍêÔ¬eQ«²EäUª]©×ÅJ«R!ðøÖ ZöÊ%°‹)FØÅŒ•I@g€,²kºyYfÍNk ‚HHmh£¡fZiÝÎ ¹Ž QF ™Û‘¢ìÂÔ*‘b¤”*'q5òt#s7}êéTŸn*°ŽY]*ðY0ÆØªuPIÕÔ×L…êŒL0­ƒyIX`·¬ÆÅ>ö²“å°,em¾Y ‚–Y¦àfœ­¼òà!tZ·Ѹ‚Ú\¨kµí¬QˆýŒyLFÿ´Üw•â$õTPI}ïR£‡0’7eUpÿpX\jêü:ªÙØÎˆÙ¹Ï#±Ø<5ÙÑ„˜i“^=< zÀí[4 â —úÕ3ƒDnÍpFS‹$€‘8](•Ît½¨¨ìœ ûÝÿ$n2‰Ü¨ ÈK^RÐv=¢j¿8[Hé.·<(.¥$%[îÒ,¬}(ê;–Àw¹ E‰2 È£qí-ɦ á’9kÂ~c©Ì Ð\lòÐ]accSÊ`c‹æÞUÔ¢­;¢|‰rþGwƘ¼óš×tòu^²Ùr«dœ`ÙbyUøê·´X•R.Zà(øåZëÐ’b¤À/ƒ V âgŽ[VðØ¦½RظjV­GÒ $äš0Ŧ†Òa™RäÃ''bâT]×$œT•çÈËDÿ¹h”˜üèœ65ˆÝîŸf#AMËãE¿’—A#}ú­bÿš— ý"QnÒP‡Šš° pæa´æ,é“¥7¾h®žæ—!<×4‹ÃBîAš»'oEwÎI¤aeS¤ž€Å&Á©ÑÕfmK5'ó2tRC‡/P­m Íå‘oYƒÊ÷–òr|ñntgú‹øåe’!Àœ„ZÔe-µðª¨., èç­}ù„a6³˜w×¾¬Ö†“¦…‹šo!NO}b‡Çg¾Bå$<@¹‘ÇrÊÒ™òÓ:I ¢¡VÞòö(TŽž l©Ë˜{;æñE-¹­zn$[µÿh¦­š^õÞ$¹® ·+H] Î ††€X‚ÌCÿ^1õ€ª|R>âƒ;©I÷š»–”AÙò5!U˧ý† jd¡ÂæqN ¥ã§LtÓìnÞÌæ½½¤ -wW_™{›¸<ÁÌq™K[uõ –N7¸×½Ë*%Þe¥wYy excCp:™ €\~ éGPeìØ· ´éÖ®Öœ‚+f…«,¥×ûë… yûŠ ‡ùøH·0½¥ãÙ¾ñ‡âÀ%óX¾· Á-žÿòƒÊñqaA X`ý)ÍÜðÞã‘c¾sškõå’¿+žÌƒ¢;´É¯ÒóMjÈÈãˆ@£L^·e½@ÊîÐ]¾xRgp° w5!Û³-4sÿ{j·{kW÷!Çvqrö8âÅw|S£Âw6KQKt 0‚ÌWK/ÇUx1}ׇ}†×‚Ö'1ÚÇ}ˆ‡K;wPt>¦YäP2G§z¾` ñÆ @ ‰‘AÐd òd°)M£ñG¨Be6a`f)å7ñpŒÃ=|‚8v»X³Á{.:òq „|‹æ‚SÕw!ø@ÿô@äÇ|öw<n߇Kا},h}ØgˆÜgˆ‡Hˆ¨…Uäc›E6Ofy® zÎbGPR%À‰‰Qe!@`ù‡OR<ð_ €$E8€a''¬ÿ!¦€€¥{ ¸‹ßg½w3 ñ'§‡x7‡s8itŒ©Õ‡Ê÷w·PPÍHUÒHd·ÀsˆÇˆS’ˆŠØÞHx-x}pAsº4P¶"K:¸YOv£–‰a‡PØ&MRHøAÀ„Geå<pM w=m’=°‡WxÕ7$v¹ØRõpMgkç€|"X¸†ò':Òy˜‡dc;!)‚€ˆÿ}/׌vn[n\5ˆäÈ‚¹T}àH“Þˆˆ¼cŽöÅE©E‡DÁbE¢vtÌôe/€‰›Á‰™ŽQjòF€e 5QM†…wM™1pÓôÿGÿ'†mC½x†fX!ÂÖ‹”Cg®ñ'à#7r 4i x6¯´d·ãhÇcŽVZ[uŽ6ÇâÖUJVƒÝwxS}üެ&ZR“ÞˆK“ZfyÎ8Àd‰BI’ü8ûwNwu@ g„ùgWõQ¶=×SM*³…^Ga#‹ ›c¸')‘«A†¸œhh!²C±ñf¾YL4:|‡—x(_©%$ÉEŽf6ÑI~'؇1×m3—K†GƒÖǘý¦ˆé˜‘©}”™6=–ƒtHC”C@^™GðKjæ õ8&‘,œ÷s”7ðƒFùP €yX!ÿ*M)3Wc·R ‰-fgq¸SÂI!'‘ŒSg A(ñ¶H)rØwšE~„’”&A~HiÙKäÇcC˜£•KØxã“‘ù˜ŠÈjÞÈ}àiŽdU¤YñvAÉ~^™A0 ú-u/à”•°šAÐPÓu•Ô\Ø2º9¦ jp\¨›ÀM„C„Ô=q¡d˜†Á=AXÜ$Œºœ—²JÑq&Ї'ú|y—w©Ygc‚™Pƒyƒ=ø&uÿ‹›aZ˜uÐÂ…·V‹Í‹„s«rúW¹8ª8m35³l>qwƸŒÛv¢’K‡Š—Íh+Ê—€ørI¶‚Œ™ä‰žqÁéYŽxa¤OÖ À‰ú™n²lB„Ÿ¹,ÈÂ¥ЪYZt®òyt`©2búG{$4pXêe'ôB Š'Q…ÔfB3oZ¡1Œ—œË‰Ps|µ3¨›E‚J±d;v6/÷O$xŽ”f’Ó}\å}Þy}/û­ßª˜†'1äƒæ¨K’ŸAÉ '¾•t6¥óú/0˜çÉ’p‰¡¦a8«´Y (¯”±Ít\¿am §Ûÿ-¤A¬j‘â–‘46:Α—#ø±ãöŒÕh}7‚‡|؃9˜7‡Î‡‚ƒ;êçY©åY“3 ƒ5ˆ¼4隟ŸYf$ƒAЙŸ  V¶¤$䃕™ˆ+…«¶Ö•WÛ7Æe«.õ¹º9!ªº:§e:ŒTÌ¡)8#²$;·mË»ˆê@عU*›·67™Þ ©ßH“=Z“Ê ¤– žˆ zéš”§gG fG$pª2¥øvCp°šBùzÎ$¡Z¨u¤;´¤ËuÚ$CwBtµ–ê†k(gù»ÞÑ[|yI²¹£|.§¢t‹.çÿ^º#AÒȨÎ_b„첈¸¼ä©¼=ú˜ÁKP¸éI_@då |sl¢½›šõ•F+Ÿ§8 ê¥ù ºÏÄu+\› ¹JÃyu=$àt"Ÿ«mÚ¦ÅiÄÆù¦Ñ¥!óTq·#kK.§­ü±ÚŠ·(x‚:'n ePÝém.HÁ1;¸Øw™Ê+¤c$JRyt ¡¨«Ýk¯2öÙÂjdõ &„B§‹lêuÔË«°÷,ÇåÃ/t« ›ÈÓ¤ÈÊ¡½IœÚ'„â!¬ñ'ÚDãmÎÅ›²½«»"ø@wƒ¥lŽ:ˆ7êȸabÆ”:1ü!ÿ£Áƒƒó0îƒÙ&Ðã„U†ðò¥tŒñ…ß+ ±Ú³µ =û§Gkj¾°‡¾=÷«B¼=cYkD ±‘\¿ß£ å•$¤ÿ&P(´Êâ~eåÂËÃdUa8f¦ȧÒ^Çz,ŦØr'Ùðû¯´ ¶ˆs!}­–q±±)¨âÄçLÀœ|R ÏT<‚¶Ã|}KØY£\sH½ÊüL¸ìÏÄ#Õû1Ð-ЖšË†@jÐC‹V ÑV¯ßë‰õÑËŠ0]H†Ôò&ÿªGQûÖ£+vH zÒñ¾-3Üÿê¾ ;¶g7±ú»!ÛAØ*·l²¬¢}·d:=·ð¬Œ?·ç|ÎÁÓÂÿoYÛ:%ªwl‹âŒ¨Ö½ër>˜ÁË’¤%ìƒØ²©Í|”=Î2ZèÖÃ-ï„Ô¾:_æ/mjŽÄrɳ>T©£0ÆÅvx»ÔíÎw ì*[£â=s¯}~nÿã™ËýìÏŽQELŒà”­J‹Ò®¤¦oŸ9K>cGÛ&e€N¦ ^ê'.óà hå'6¬3ãédêÈøN±º»–Ìõ|=Y‡üôé<çs¼Ú}Á{nôlsz>ョõåɼi&9~<Å"öüQDQº*ȺòÛ[ØžF`À -ÃL2Œ´9œ….ßBðNóç>ÃŽ-}áÇHc8Cˆ\á »ÚÄáÆyô#Ä÷øz×É_ÅQ<¸;ÏEzñÕð¸„Ôãí‚‘ù£ÌK¸öaöųú¯«U&ÈÚ;„½Åö cû‘#‚÷)3¦ÍÑgF‡îJhQîG½ûlÊôÃÓ§Wͳ¥V,‰ÿ©ì¿†%k¶íÙ[cÙÚ›5ï<»ûñêí ¯Àþ2Œ@Âü’g±{l,²È0ì‚,³ìX ‰ ÖŽ­¡JK 5ÕT{„º€"\1Q¦â&º(!Š2º¸ª#Æ“$â&˜Xbî8‰ž#²Hàx§ë‚Ò®¨£xð®§£˜ªà) &*«Øbo«ÔÓJ+²ÐZÏ˲Ös ‚ú Pë¶èÊê.ôš³?þø:aÀ DаÁ[¬±{|,ÈŽ€à‚†:»¬ÂÌ0Øì…BË@µsØÇˆL¸`ˆ <»À•†"Oãh¤>êhUá†òE˜œ»éÇT{sɤÿ"¥Äî'U•T’&¢‚JÊI^e’€)¦ 2¯ªf»bO½­´š>°¸tk­5¡ë–¹ð+®¼øÚë„ô ±ÿTP±A!34^ =ÂK YËìÃÒ 4 FXDÕZCè.àÁ!(p%" 1‚8FW«‰¢9ÒU%çVJõW §#²×èp“'ž¤‹òº&¿ Ù€ðššàÊòš¥ö*·¸*+Z°v¶ÏMùnÖV®¶ò’³¾þî*÷\tãÓ¯P êÈäèÂ&ø_Ì´~  ?;¢ÒÔ05B€L÷É€O ZèS‘l3@#\•ÕD¢¸b’jÜÑGZéþµF’|„.Êÿ^ ÿ1X’ 7JcYŽNCÄ‹êÙfãóÊ+´ÂÄ,ùÜ´o¾²à·?ú#×Ü¥üA [ðˆÇdŸw^nÇàêѶfTëÒX+!ˆ°xà!†x!ƒ›‡ âî¸né'’#Fê19ZSZ¸#‰+\J(q;|ðä¢ ò]§LVÙ¨f~Ö*jÝäùL3ŸËÛõÔÊ*®»þ¿‹Ñþ7®;áÅ\J[×a“˜Äf1Q£]íâ% Á$p”£ðU¡}½`Q!X¦2„!$ìCÍh0Ð8MÏ…Ý3έ6âZ%go/´Û§”ëÌ„d³ˆs†ä"ó®HØ™\²>ÿ Ëue*d Юe¿0‘@MjÝ\Ø¢¦üÉ.§3Z\ÆE®Õ-Ð0Q‹]»4ÁÛå %pÅ„¶¶A ÍñÑiö‘šÎ8ïZ^C<ã ¼oÒ;äqjT7ähO%ÃaEœÃ¡e‡>Ž‹l˜•,Ž&Ñ)" ‘Ä%.ë<^r¢ÍÐô•þí¬>õAS}Þ¢¸ÜNqÑ €ÊåPP{ ÔÐA@ÈvÈ2—§(jB—é ¿ŽÐ5âAyK˜ò0 A6N#ÂQ!ÅÉȽq2b¸\­V¸qÂrÃzœOÌ—딬%Gñdm" ŸI”@–àG3ÿöPë,¨äŠÝcÌéMjšÇ}Üä­/šudÜÓëL`¶k˜ð²Ýi¼v0CÌfŽ'lÔÖ(´ T*`nܦ¢ é…< 8ò*޳U½ùH ƒxþ$Ô£X¿ã¤îÌjp*Â@L8™’õ‰$Àª(ѾdÅŒYæ1h¶ pÅ-uéLiZœ ªnéENäÒJ :§ˆ]•cd'5µñB€Àñ(À®qí™ÑÉ4]šÇËÔÆ„¥QHCj“Ó éD'ÉNINUacBrê‘À™‡°jIÄÊRmeTVçG?AÜsn²€ôÓŸ\Ub².0P±”ÿi‹l ÓZÒä–t—u)\Ç%×¾è‰]ƒ¤F€w]ÈP"yTŽ7Ø@³QÚliK£ùµ–¾”5Aéï<㙚öTC²ŒewÕØÍדø4iΉµ#“|ÒPzb”×rÒ"°Jg°^bՖж¶þD„> ¡ÉáÖ”ÔZËz¸ä¥‚nQ,lÉ¢'ZK¢í§Nw*à\Y€@ &jÒmƒŒi!ÍHJ6Ç«ÇóžyÒÞ¡ÔB»3 ÀvRSñ‚wEP!¾tRX ýw‘@…rÄ^4$Zõ—´ÕÔÉR»–%޵2ê7Oœ”™%†°>†¬ A†Ÿ˜2ü[­`«,ÿtÎ œxº²ìÇ­c$#‹ »½*‚±P1¼Ï°„²ÉÚÃë] iÓa{€¥¬ù€ ˆêC›f5xÒF%²³@í«þ[LÒÈFy §i Ð$KZ²d^þ^ohò1›¹%+Hs²(,97ÁÆNâUÐÃ¥-žµÙÂ=Ëèâ’ç0Öå‹ÖåŠé*èîÕ˜é+„ %©ˆÜWm8õæŽyBøB³ƒ—1B×´¹•&ÞÛ\›JI͈µÊ…߃˜õNâºéôU¥=ív·àã.Ž|ãcà!`ôŸ bôÈg¬7‹kþÜJQ”+—/üÙvŸ%ód–™wœThÿ°k›zdm!K5…0¿yN7Ì»ñ~A!ûaßñÖ¬ÕS½TC53ß°2«³®Ã£¸‰ü²ž“³†CŽ›p q€æËÀ@‚À‘À…ÑØŒ<)¦b’¶`)H™€„Í€”ãz«Àà ¹B®^4!4ÚdÚAÈF ‰¨‡Éû#N³<Þ9) ½sµNû—Õ ¡Bâx»7Œ('Dz!Àé·„à Ф{°”Öଇؤâ{Ê•âÃdØŒQÈ7D>‚‡8âÃ!øÀy‡â8|Ã?$ˆ?$@Ô"\Ê‹9—p4–»AÅ+ÁB9¦Û!€àÿ™–Rˆíúå X2}{& s”…hÓÛ¦¥S΂ 0=,­UÁ¯T5TœÏR5Ñ Àû$Ûƒ­—@=ë¢\aµZ10‰8@„C …cÄd„æëC\¸q;Ae,ÁQ(DqÃF8Äk<®9 :¡ÁFÌ“=Q¼o»²Ù)–bÚp )Œ·…(Â}Ë Ì $Š Ì p©¤[Ì3‡˜8C’EÖˆÓBÁ#a°{òž“ù›ó5¯# eüCALÆcÄ9Ä€{x=$€jÄ`–ÂFFPFkäF ±DD.¤áÂà þ B[£tÜ#@Oÿ ‰ ! ¨‡»YðDRë±&,!ÚЉyä®L½U¬{;WÀJWXHŠ=¨Ë¯û•'s'ÙR'L*° ´§ ’!ªr23—ø‘ÍxCüÈâk å+¾#ȇçëÃ$€áƒdÔF‚(ÄlìÆn<.úÜ‹ãJšœ$´i| d¢Ì=Â+¤F¡©RYºŒˆiš£Þ¯{Y¡Ù°¬Í`! ‚Jyç鹨Â!@‚†ù l'ÿúÂj½¨{ªA™}"Fß3*ï!"VY×’ˆzš8—h –T¾Ã`¾å;>åÛK{À=$I»TF\À8,Äî$|(L8„¸@9šñ,.ŒB Â€tD¦=Ú‚ 0÷b¯ã鮉ˆQÓ7ÖPž¡kÌj”ãyÕ G Ñ!×H€çi!¹ëJܔŽ‘¡ß¨˜NÜ5 ÎV³ÀÎzb˶\N3+±°²‡x {(Ňy8‚yà‡ø(A ‡>4ŒbÒ ”KH”;Ó»¶1äây8Ò¹ºÁ×y±xáAËDÉG«‡?‘ËLJR Ê-• Ò Ê0PÖp… ø Û‚VÛ€ˆè-X@·d‰åðž’ ˆ˜µ¬œ5ÙÚµØB™–xމ íÀ‰SNòM ‚€!ù ÿ,éÿÿ H° Áƒ*\ÈPሠþÝ@´à†D „àúG!>RI°„@yçDyÅ?zŒìýc4¯æ<òŽÜCI…J†6à‹€È„†(´òòÇVÿ þûaH #«þ]Pj …©­ Z¸Qá߇ìÈ—6í¿õñÓ‡ˆ_ûxóêÝË·oB~",ÞXAÑ¿ 0ZÀGxiÈ@ÿ!úpõŸJy. ÄYð„g8åå¼§“G ²¸úᆉÿ•`Ñø,ü¸û’ H”˜Ñ O‘R¸ñê¡>Ø«°V`[™óU°kׯ÷ïàÃßÿ¡Py’'®¸Âö¿…—FHÜÊPÕª!Î;ñÏç¿ò˜ôÏ=÷üsf¢hš D@KŒÐ3ÿp'ÞDÉyñS?@„È“!2RD¬WÐ H ¥ld5!A7ñg étÏi9 ¨9Ði>xà?ù ²Á?wÊf–rEQð2ÀŒòÑn~rdHV.â¢@®L0DŒ¼Ù˜=“^7PwFfªé¦‰€ä¥0‚•qDÑzJ&Plÿ„pÖ@äÿ…ÁNª)À­9üæ›X`ÿT`Ü`H¬Y}p”H~n0 .ÈŒ"sHU@›±@°âHVs -PAhôvü°Èéºì‚‡†F>ƒ1ÞzR.0ß|­wƒ>]B >Võ$¦AgXàiåºf® ?øf,¸Z'R3 üÏÊ dlRÏ}dÐ+¾WÕV}5UT»á).voéˆVúäC°¼íæ¬sCüAÁIòóî+ TbYÁzóµ¢r«†›_ üùw’ýú™of ĺ:8 h©ý#Ï Œ¤Ý1hÿ 7#†å‹#!Ýá‹—l,m‘ÿØ >£ ƒËXhh]hÅÊÏv;7îøAB‹*y’QTÓ”HõÏk…$P>ó” á ÿz™¢e'àtæ›c>ȰÃåЦ:õ7Z*½ý˜0Ü_aiQR_ý@•@H¼hP»éöÏGŽ 0¸ü@î?Óé(Pát=î=x>.ÄdAüŒ€³d˜ %J¯ Ö{E`AD‚òÚôûU.ÝÃõArì&„ñ„4g«‰íRsš#¤Î'…ûÊšC!ø ?Â*°A’)Ê+AZ‚<ëÀÀ‡a* –Xà,L¢Ù÷fè²í/@ÊwÊ'Dè£,E³’ÿ6 #È ¤0¢¼BÀ±ÂÅ 3*I[¢ ÌNWiÊ¢›vž Îl¨™¼¨6ŒüÃ%Bõ•eU†d¥Ê o¼ò§f#²Zb¨u!$ÿˆ?IÈAvG4LdšD¡yž¢œÇ„H‰HE‹GΨ¬Ô¯&ô¨_ê ØÿDvb °Ú‹ e+HfÒfˆˆäFQáXt"9¸HÄ­‚èø0D X(rÙ0}1_]rCƒR‘Ø"DµMɬê0FÄd+V`a€2 $ ±ÔY&VÀPAÐÄÅ«ý#M¹bBÄÿ‚ªiM?òœÇ(p§ê]@Í;”q6–- t2"s,øƒZ#Pd‘ ©ã#¡1„‘—*d<€„Èl®+ Ò¨B…D¬'"ÿÀ…0*yFÞC#°¢åhN øGŠ"\à±™=ÒÁPúÇ|ÄC"5ä5MÊ׌€VJŒ”Þc\@“Q1N½©~©ÓÌìê9 ³©äW§A¯ È60Ê£@©¹ìÖX‚… Ì$_.®‹CI83ÇJÖ‘•ÿñ† èˆRøfÆŒ®Ô$4­©×¾z‡I‹£Sw@Š<>i"°YÚ@’8=ÎÁOæTß ØùÊÄ*V©¡P Prš  5³J n‚56­rb•ÍZ,繓íõ’&è®xzi{[ÎŒ,9§sªÏt70†Œ/HwMÈ’Œë&-‰: º‹mÐSD´‚}‚0pñ”xºYR`NÀ±yˆBÿ1×Ì&RV†u™à€Ê¶0ž°`ufcA àikeK[2+`ÿÆ*jÆÒrFXÑ‹ƒDYé\¼)¾‘ŽÂz…&!·LáF‚”;:\¤’ÔÌ\„”oÿ€û„ø!ˆØî>N ?C„€8õ³L™ª*FÖÙ$¶AHƒ@/Z‘²˜aA Ìv„~Ön›!Hw” TàÐÀÅ NÄš¬lú+*³Hò^•ZŒ(púJ²ø1\„4ÉKÊ+"×lÈ2¹9ì\tˆá½l€ba¦qÖöÄ™|6|yB^Ä,ˆ„˜Š¡;Á|O³:”ô³'o» ܲr•¯Þ`>®½Áj7 !}`Êï™I’w7 ¤â®Ž–õ<WàÖÕËa³@™k2ûúÌÖ –ƒÛ\Š(ûŒv^-¹Øq.¥¦ƒO+Áˆë?ÿy1JØ+¶íIÈž\D‰ºK@ ¸ %'ˆâ=ißÙDÝqÃÓW.pƒìò¿QŠJžð–<³Ä„ÿœªB.Z¢šnNCrý–”ô{9œøƒ¹G¼¼K2ÁózH¼Ï&,oáRÆÉ‘,ë?òà¡GëÀ·Ñc?äý'Jþ¬ŸÒwÒÏ4ƒw²ù„8ŒÈå´\ÐÛ2ŒÈЦK%UÅ+á Àÿ­ú|€…«µA–4á¿r×ñàÑ^gòŒõi~‹’ þ9»Ihƒç Д‰Æ!cD<Á¥J1Œ8ÖªÊh',ãßÁ¸:.² ­ÿJx—ÀyÄ@BýâOÆÆþ'Œx÷W °iDtZO±$çR•ºM€‚`øÐ ."Ú‘=ôsW'H\ÇzHÂv=’$m–=BkZF¾GkÊuÃ64„ÑvìcXDdÃ÷$Žávÿ0ÐG€{²1i#&>&_‚7æÅ+߇—1 Âr5¡hî×O.A^tŸE&%P7pB–ìV8Âòn#¤2žWwz€v„%b-Õ/ø†Dk…D9J‸f³÷8Å&>¡8–{ºG'f–$ò PI¥4>@µ‘Dv¶9‡!÷ó$Ë’;à ÿÿÓ.1_Á&0+' Ø·b–±£D /FcâÆ}L¸5cÂ_%("h±uIA:±´±j0â9À€B£PR,²l‘€sáe@Æl¨$Özelx¸H´Œ”fÇÈF%wb¶Aù + 2F0sùa¡Tx:_2‰3„L_{U¿Â5´B5Hˆ9ñY #ÅA(×6—¶1±BI1ü·!AÆ$"Ëp ÈàRq¡MvWÝ¡$†)±çuÄh^çu&µ\ RAÂŒIâpy˜tDDUòàCòRK{&gD¡1ÃD?³âE–ñrÿq0a^“5StT¢ ó ¼“hpsU.HT˜–7V¼xHqw"Á­ °öF"HÑ~%7$ hWƒfVŒ_‡MÌl¾'q¹fØ‘ aCT9ö ð÷C'€”@4!5OŒP?-À„,1_ 4UenSä5 Ó ³cŸx@ cEZsnúá;›¨?„fü“"áQ’Q¬Èe)-B(´ [i,E!,Ã…uƒD–!µzlèk¿¦kö{2\Õápã#4”€I¨rÈöð*çB3W'z èW5òE™BY_=õ+5Ö5õÔ 8¨ L¥Aÿ–s–1^©sž›É™ßh%PÁb-²A•Ú$¶2³ ÏÀ[ÍÔ—@qCuWxea¿He©zÆ•f’13>Ù[–f~™™ƒnWrØSr”q(‡àw<ñ?¦TÿÔSÔ&`^YC”eâ –Hcõ%&ŠvŽ%ëµö•h<…hQ€Á"O±ÏájZùÏ -OC3*©€sñA2H3 '’p‘–ßÃ{—‚‘@©Cø ’t±˜„Së£4“Ax™6öPØBé:b ò?öÄ5g“wBT‘i @†5Œ66R„ìenäc'¡™ŠÆnm³¨.ÿÁGÑ%D–!w÷Q©ð»E¤ ÙLRyuI' 8Ro)±§W^–oØ.s±@²­>bŒcG9ô›ƒXŸ4B˜r‹Ör9æ ™EY<”Ÿe ¶¢& Cn=‰n:F£‹'Kùüs !Oã%äryD•_™ŠŸÀ°t]YH!èúˆWIRHFH$e_öeØ>_Z9l³jrA‘Ng”% 0Ÿ‘hó@:áJ ¡&\T‰r¬ ò‰6—Yy'¢V_5¶>d8çNO±âTc¿CÅ¡'ö!,y䣢ÀàšÏ° Tqm?ô$Üÿwå¤cŒï:„„‡ñªß3a& Í„)u¸ŒÄ¦!¶X‡%D1Gx6Ÿq&˜)¬”Õ0LU^ä– ;Z¦”psS$±@¦0 “ƒñÕ-ðb2ß+ ô~)’67’º²_A©,S‹± Dz ǃuAutÁ¤½7>MB¯^F S*‘v•HÛ‘8vˆ\’§G/bŠq W('KPUÙ)F}:¹6ÿ ¶^Ã[c“oB&˜…¢/ ¦A»´û«ÛEå¸wšs0¡b@:¹#ho³1Ûi%"@Š 6¤D: ÷!,}ÔG‹3MBB–ryM×ÿD–€4¹¨‘â3:c é³GKÂÙ¾í+—úS( ?T"˜À‚ž!Ê ¡Oº?YTݨZ#±ØæYÆT;·sC!4¡Ö†¼±E…yc±,,â¼¼"­)EJHPãR ½\ªL¾zeW<Û–^ao(’34œÕ¤xaÈH±gÙõF´'8á©“#6óT-w ³Y®Ssq:ÿ#^Ä:i6ŸX„Œi6T¼x¯c?Q˜*q"Ëb-tuš*³Ò‹BÜUÕ2.Á²8cª7\ô:ªAK–ZÚ³¹3—¥ºø{­§C¿)4i'G­Sÿ"·›á«¬#6¼ÂE³â?DIéXT|z-jO£áw5K ÐXšIcUuhA5¡bLD¦‹Gô­£ ¤ü ‚ÛL'WµÁ¤)ì©ê¸§ú{Ÿ^æuä›HÝqzÚ¿1£MBlQ²yªÂ¼/ñksý @f"”éÈ&FŒ5³Â0°_žAÅžqÍôö—ÎB(:™Ínz6çvB¦Š3Q8GQ3©ñÓ2¬•®‰¿,Ú!pÜ—ò"ö¥¨ú® G'€ôÂcYBë8\:pqÃBB9MBÌSAðrç) tÊŒ–°Ãú& ›Ž Ó§1ÿס'ðwì,@"ÛGÅô`2ºÀnË›h©,ýä6]²'Wa…)U"-á·ÿ€L°âLùpu}™G††Ä…p·I\ÍL Ù„ff¡\*Âx4†SÓv,@m¤ü«:ÈÒDŒ5Áº+þËE¬5ž1ô°Îöp.A¢“î¬bÒÓ†ºbîäE²”«ÁÔ§EÙ_¡ñ²£@ÔªÙë©Ûäй§käûÌH‚ÌѨ–ü°#hMkŠ›$ÝãRK Ý–„Ž9±›¥ÜÂÍ0ümûÙ¡€A3ÖÖÎÛg* ÜaÙüJ+&O§l*¡Ê'ÿ 1cja€¢Æ1{Õ ¹jx8°Ü=¾ü¤"HʸW@Œäs‡MšŒZÚHBƒÛ)±‰A”EÎ:Æ DœµaSÎÇ=Î_Bàs˜Œ†‰­—ô n;Ê-c†zÝ>Fî·~,÷xW±œ9ÕUŸyeÍäDºl³†áúàHªµY–½GH? ß“´j©ŒÀ–ÑŒ4còr2J55±wQ6§±Y2ÎG@nI\T~m‰N<¢®b°"–Ô"€Ø5£—ûÜ~ë屉† ŠFãeix×ÃAý÷3"-ÈPÞ‹L½ÅB‹#W#/‚4ãJ0 ÈÜmÿ ¯åû³px¥*~ü¥´¶´ò’õbÂüÁcµ3™ÝùOS¾¶ á?Û áÿѶÉýr®O8ÓCbÞÎàg-Øë¶ö|žw'8÷}#›‰oƒt_1#.{ÕZ‰ E.ðD3ü900Tú¤ 4e HÁÈpµ™M¿—CdVã½wk:Dk†0WT°¦LŽ›¼hÞ¹cÍÊ:¿R_ |5¢Ñò0ë×\Ò!à*Ì}ˆ+€19Ø-@'€æ‚¦0J¢g,à'Žb£Û³‹R8ØÙÇÃQ‹“Gv14Nã W -¯¼æ³ûj‘{&ï8m MÒ˜"WB£cÿšÅäµ#Ú¢ ’0e[YžhO^„êÿÐfð"!2áÎÿ%,¯0"@á@"ð7Yežžÿ1^€wnø@Z,OI—X»8U-)d²´Ë$ˆà#àòýGÝ`>Rv¨HÂÜfZl­­CK{5¢«L”’=ŸU;±´ÒˆÿîTF²;ðžsönÔÁÎt$2¸4¯0NíØŠýDOƒ}õ¨³ë;¸T“‰HøÃ"C?QW Y©ÆË†ûùçUÑèa2žÑʈèVß GRÍÂ&/Ãì‚´Ü®uy¼¹ä£C"PE¡% JéÛ¨ˆÿ_å:_‰Ö¶üðªXôƒ-/w.@ó4±+Ðï5“÷r‚}“ÝFÿúAõ9òJ´ø÷ÿ±(8ïŸDþ ‘øCá?dÀ–ûw ØBæãW?…þñºØ² ¿xÿâé‹ó_¾˜/ÿÁDgO—A…%*4ŸB” TXÚ”)Ê î$ùï?Dÿ,XA‘„ ̛Dž<…Gî¡ýGà{îýS{$í?´òزMØ,½yô ¦§0ćù>üÓ÷OÄŠ‚#¼ZAéUdúò…øW¸3=Îôìqþ`#ÏÿÈlQ¢ ‹ &,áƒÿ!‰†þUÄ— ²‹ñé)’ø¿“#^ª$ªgMš< ÜŒ7ýhÍ>«kÏ^Ôû÷‹R’žŸT§Ó­£D©o„ä ZQ6#‡,XÉ‹÷žÝ¹æR«­þcK(Zèë„Ô:+(?ÈgÂ|ôi챂"øGÃW^iå•@üg…DÈ, Iû±ÅV´çŸûVb­'|À'öab‹À;2ÑMŸÿ¹ÔÖ Zˆ ü²íݼK!(²’ô \ü`lš VR‡:n© Ü9ORd²´êÌNƒã9Ó›Òõÿ¥6MÇvãRŽø¶6Ÿ!€%,Œp~`#Ù(¤P†*ÐE4 ÑÄmEB˜fÂ1UHŒp-шÔWŒ¥ªo#‚Lfè¥Ìc^©T®`3£yŒe1¨È„õƒZdD!DŸK¦Â˜™¼é¸ÍMÕ<Š=*RÈŠ ÿxö˜©ýZª£ZÖ~q:¬„`‹e…rôûG-!¥6”­_C%ê¤FCV«\² ™<\fJDÕyowóÔ'}¼i¨”žRbˆ8v¸ÅÔ 5y¥A€eÈ‚HàøÁñð1 ͉ñ€Át’«´c6(J‹Ê˜Ä;Ò\1Åc5)›YÌRÍ~_:*|ÿ…ù&ö"õµ‡>nÐ. tåAp\ `xéµåœ*#KfK“„-†´ã+Ü 6õ1ñýBž.!_Ãî"ýc} È*¨*f1ŒQ"+8œJ3•1·¨ËshÚZ\d$#Û­ëEd7Róz¿áÒ¯=(ë­ÌZó²êÿmÉ‹œÐ’'»$Éá1²„"b*ú€Å´1ôO#ûóSÌZJÌ‹ñ^·Üi¡Ì<Ûü[‚7‡]æ2xÓ[>Q…b½ ‰§b1ýF£\Ð¥–ÊãâEj! d#›ëˆ' ±À˜Ä½ÞO† ž£ª@=*X …£ª7±ÕœÎ“3{Y؃Ӝ¾R j^å7PqXUX³)D/z¹"ÇÊÃ\²BGqÙ™#£ÛÊ2b*ÿDñ#þ-ª4–g½¹Ä7ÈŒËLÓÓ‹¤L†¨ODÈè‚hDIø¸A”¦r^:â÷Ó ™÷}íM&N«:Õö»tPX]¤zßÿþGÿâ„}w†ÓôPhì'ðìÛ4ýÅÊ,°aM×ÿ©áUì™F4m“Pb¼DZ¦éC"Q9³u™yònÓF1Šû©g—¤ŠU·;$þ.2|B~ÀÍ)Ý*„Í!«#ì>c3¡0§dÞ«vuÄ­nõ€'á®¶G¿›ß‹|¾XGxà ¢z´A g;$r#¿hE+XÀгB`Žó+×nwÈ<12ÆAH^ê ²7u[5ç¶aÏ&J'§=±”Ò2Þ)åDP?ÁT!(YA =_B€Fº—~’9½ëö½¯¥±niØGCxíkñUOz(7d¸ÁUÿ µæ÷ ¿agxÏv´cÝ3¼¿aðWÍp<Ú [AD΢ Ô†ÿˆAØsTÄL1Qðac˜¦IaQõ"jn6†[ÅD&rŒžHTÈ%Zò)Oq*à¿ÔßrËbƒS©*PAº€ޏ|@‚Å}ˬ¬ã4X£7U5 ½°¸«Sˆ[;à»Ùq>ƒ¤ßs Þs»âã´ä+ à[»|Ë!“¸{‘»(Ç™‡˜{X®Â°”Úùµ ©bs§Ù:Å «õSˆºa ©4»0 !ü+Š (Ÿòñ¡‚¢$[ù;\¢€Æ½×Éø…W°?`¸†#ŽKy¸ÿ°=V“@ t5PïÕÛÀ°k>·ƒ$(ð@Hjƒ lšæcµѽ¦a8zà½”Ê Ã*¹8‚4£:ŒÃhC¨0Žò¦«6C6äX35SBMa‘É…È–ÓNÉ6…œÃ­`1ÅhC«X/¼Å Yw™3(2TT’›é:‚Û7:ÄÃ&KÆûÁ¼/ À¯Ú‹ÆˆÓcp4D§i¾ˆ¤ˆ;œ1ëÓàˆP¡±ŠÂXƉ­2» j‰M±–c %ôm,ŠDœ˜‡z‘&Y ÐÛ&0´Äȼw4©æp*L2œ°b¹ÍŒ~l]«øÁ( †!Š+Ü€Œ +¨8¿[sÁÁ*…à0¸_°¿Œ´ˆ®k(08©Dº,808»t@ÌÃß³ËâÓ€”LI¾–—á{»–( œœg„IœÄIz¨°Vh…`ha°€VЇ! Ÿt\*¨— 8œ;©ÇUÜ ~Ü5×$ˆ@c§õkB©‚h«K0H ¸°THKªb3„ÿÐÜSzN*ûë s‚^èˆgP@”ÈK””ÎÄ4Iß“Éh,Á»DI ¼7±[;c€cÈFÈ$¾³‹8áËÉÝSˆPö¤’°8nRˆf€ϼL ÈŒ¤,Må™­M”ÇÉ$}$˜°J­‘¥ÄL¹Ÿ‹pÅWt«–¸8Z¬€¡DŽ=)H,d<—0¸ƒ¼!x,…0¸¹¸»ìKºDàëÃáÃÉÇlL„¤ñ¼F­ó@÷>› àÅÌ9T\‰xW«@Å|@Û8áO q 3ÍŠ 5 ‚¡ÊWz\M"‘Ã!-óý‡©â›PŠPƒÜޜŖˆ|€« QùÕ–V9mËÒk†Ú &;C8lµÕ«CŽ»«[I2¦FiTFÂz8ÿl=Ï8´Q7NL¸|s^_(ˆÎÜSÜ¡%Ýܸyá”Û¤%æáŸÎ¸a˜DA_…A_ôU¥ {X‚•0µ¿Óe±Ö-¤;ôч( C(C ˶}õ_Ø€‡‚¯ÌcP+'P Mkå®K,XãÈ(ãÛ°ƒ¯ ;Žìå|Ë=5¶¯Æ|c7FIbfÔ}ÌdÎÓ]8ß àÅL=ÀŸ½‰€€ÀóÜ@‘ØÒ<ÇÀ03Å“Æ Öè»-P½°‘Ò:ÅTLE N¥!=YDN°Ä?‰x—†!9žPùųUn‰Ú­Ïei…J©%‹“”¢²õj/ûz2'X=ˆhÿ‰ö´€Ûe¡Àà‡c=1^IŽŽÛ7&A6^‘¶¡™Å=‰«]=Àðü² ™îGI K©$þ ïäJÂá•R½@°È<)´„ E±SÊMKÎÍ‚(#ȰˆQØd&üÅPvfûÅýõßšI ÐIŠÛ™¯£ÊR©8ùR³¤÷‚º÷º¯úRŠ7de~K2®“FŽN8e”IºíÓe®`‘æÑºK8Æ¡|c—¶!ˆqt„HgÇ.P!Œ(€­¢Pr>þ¡éZ⟵¨¥ZÚ׸…aP#‚P§F±!|Íá›"ø…_Ø×_h@Û‹8H\¸†:Jœ‰ÿÛ¹£ ˆþ˨ð#„žã^2uQ5€Ûå£Â舫/‚ÌeNfº­Æ>}Ô $iá ÌÅl;3JH×!øê >§/#IŒ­Š.E*Öø©~<Œ( ‹}ÄêðŽQ¿Á!±R²M$ºBü ·¼¸½±Øâ`À| C¨“„u!Š|ðíÀ™8aåi“ÿ|£9éåKCñŒ¶à ¾ˆ¾Dɹk-ÄÝkQ¼$i€CÄèN©V€†ÿˆ@‰‹©!MÌŽ”¶aPO‰9Èh 칞ÐÖÉ¢e^¬§Èë'P¡XYŒÅ½ášTà¦ZXí±Å SÎÿ6ø…(Sˆæ,½!Á‡$ Dn3"±òO–s–Ðém*Ùððý*Š,n²Ë4ûÑqò<éWL¿Î=LA °?LÄKY\@ìµY‹‚À€tÎìõþŒvüÕ*Ä?ñáæaKJljZ€… ôÁZ{<Á¹‹I±§¦„w!…Ø& ¶Ø_…°íËþv³p9 âÀ Ý:â‡f‡vÏ«“˜ó’øðÙs—æø¸ý*ô‹@D³#×”Tµ6x‘¾WEÃîÖn|qäMò™´‡‚ÄÎ †pÍ*ˆƒ°Ê&ø‡&@ ëÁC 'Àùæ'$˜”‰À³ŠÆ([ÿZ±; ÔVˆ¹‹x«uÅæt‚»ì_a‚•6v/Ú Š¡ á‹h*ä:“0‰ —šW¥¦:#Vt€Ë4Ö“TÓàåTöÃÅ\¸îì=¶CQîÜCäK̼Œ»HWXm2Jü‡ÈJ²Àì*E +á¨LR¢ˆ¥ °ŠÇØdø-ÂPÒö$3º ÈMXô ‘— j{ŸµŒm6ÿa¸„Ê<¥­ÉÊÑ;;Uù–0üÂi|ð O‰KtÏàÛÔÀÉ—ñ·ëËnÍS·óÓIGÏÁµ‡ÏZWzˆio  "»‡&HˆvŸ~¿OéÊJQž`«{¬ÿÅQ±'ú«¿Ûv ®’+DNWtÛnË-ß !Á‹¨3ý/ ‰07sÛâ s‰‡ ìo åpÙ[æc¡O é9£ßÀË¿ü¾Ef<¼[‘¥IûùFZ£óˆy'þœGïßÀóZ ”GÐá=y-þÙ#øOÄ?Uÿ^ùxµàÕ £„°ç„^ˆQæ#¨ï"Œ"0ZTõÊ¢JÿQºÄÓgO)ù ¸¢Õ¿ÿ,ì´pI§*U½~õúW•à¯KÐþI@A)¾­nP ;‚ÂÎ7þP S-"´×DôÖâÚ²hóÞ@ÔWnÚÀ‚«°h¯p`{1þÿi8ˆxçã´ Öð¯2dÇôThàŒùßæŠ!ÚRH©àÄOÈk ñåÑû@pæ¿ÿ|ðÖYô_‹ùB¤¨ò߇–/õÉü÷K·Ñ¿ûü´zZ+(èþa1¬Å›Eóà HGáýgè†!‹vãúõ 8-Ù¸dñ¢¥pöŸûÑ7VD ö¸X Š%¸SqE˜–c ]f™…aˆà…YvÐ<”ÅÀZ!@€A'´ÀB ­ýsŒ÷Ä/dÚKãÝÄGé–O>QycK,¹$ÂK4a¤[QE µv=YT]+º!ÒÊ“Âà#„R¹a䘯¨òÿ‹N—èÃC\?„ÖÈU–]÷ég×`dõEÐ}vf×ZtøgŒvàƒ*ÐÃàa¡V܇—mÚ£“JzAöÃ+,`©MäA÷üƒA²¥úr;éÒ+DWTpH¶”O.@ÞjM¼Ö4ž¬=eÝOõ+wHY4Š–LéóRpiÝä“@ ]£€§Ö^rѧ€¢E'qÆÙŸ\†¸I–^qúnŠýÓàb >HPq1Ð#o†Æ1ŠXq›Y*i¥•êË =ŒÐƒÈ/ÍcÑ ÿÈcªÄ¤f±iEûÛP+ø°Â E¬0“ úä³\‘¹°MÐ8ÿ¬uefË c\4‰÷ŠO¯# %|€í(¸ žwx¾Ÿ›ú [þ'î|o‘_`tÁ+˜m€.FÐ׈Ýk\‚J¯a‡*ðŸ!”°¦ U`±Vê?-̳ÅM|šmEbt“*EÝôñnÝ&BÉ9é".0~ÑEªèFÞ“€VG % lç2{Uy¹ááA|ܰ¶©XP 2i•å^¹w™ë4íó•»»»ê¾§–ºqÕ¾5ñ1b\¦‰ÄÈ‚ö(|Å«ÀÜÃÌͰ¡ qÃÌÍ6ЃžEBðµŠÄ€y_ Ú6¯yñëPô8h —0z̈ "Ò÷ˆIdÌ{Ø*Æ‚ èa)ÓAv”–ÂE#ø»ˆäV¦?øý"#—›ßo¤´”´Àl'ⱈy–•@¡èñ\mæÁ‚#Lá 04øA„ñ©ä+IJä¤'ÝÓI÷l2-š,Axh› ¨9¬|¥En8 ÿ9ÌKË-—è¼0o{Î;È€øC'2¢˜?4HAH &šÈ ºø0Õ¨†ª‘GBìѵ^ 0ñ`9¼Q‚%ë•È“8òeJÖI S¸GÁãÿ†ð?é€ÓIUjM^‘ù(7EˆÊPÄš¢Èª:>&¤EžKyRwÆòÁ°Š2²áôàE†€ÔBƒT‚|yI`‚L`¾%°FÜå PpÌfsd¹œfÃ.60&ˆz˾.6²°Œle)ËåkyŠ SˆŸ—g˜Â˃€m„ЊWX@ÀÀ§\èa[&·ia’Xƒåâ?PIÄUœw3Õ E¹™Ó‰<…bÓÀã­–p£¥©ÈãD€r[“€O¸˜Ë óò@ªeoyØÆÔ²‚ý[XŠ~t®ýý+Wh(ÇÂW¤È)°žShbË´´3%4²‘ÿÓè× £Р®!ꦃÐãC(%”$\R¤#b­wnxU„¦7Z; ’¬\Ž1º'NŠRØ 0<º8‘Ÿ¿SÒ‚ðàÍCoZbG[”àÿàø-<þ0Å$óƒw¢MØä$ù°•½Éަ¿aêRiàbë\Á…L1ezZC ºÐó˜@£ÍÓŒÄîCØÛ<,s‚'²D¸É/×…s„Ç)œpgÁ|‡$qÒ Ö>•ëÎ s5)9æÜ‹#ÀÃEeßÇ!ÅwRzL9-tÅ8Ž÷1Æ@­ÿG ~HÝ‚ 'C®VÄ—`•Ÿ¼Ì#ŠÂÿ øUÚsÆ+{g8KÁ z¼þËÃnBCå­_<º´t‚h°™)iÌ„T±Œ< VüýÖ¿Žc1½*dÅe™Æê­‘a×7= PâÙ΄‡u)]jàNje˜ád t¨§•¯ÌDÖéMú Ý‘±P8FÉ¢å¼äÐŽ)Ždã0Gdê[ÍF"†ªÉ E, ;†óè œÕC=:¥î=’ÓÉæ-0’àM±%[[ò&oº_mâMqÖÜ`¤Ž`™ˆR”d‰™éý ÓéžÅ””Ûw¦Ò3¢„¦¼ÍRè†äŠs“Fd>HNHôGÐÊmèO|æHyà×uxPÿUŽx>É9efú€ç|L[¤=@˹”%¨+pb=òÝ‚âaU’Ñ’É­éÆ]ÀÜBU†®qnèCýZÊr `ˆ*X ã‰j'.céQ§`¸ÛÏX€nÄVE8†$Ž Ž8Ua:S ´@øèe„ÝÕQMi`¸ŒFÅbòdŽaõAâfvÎMèÆ,€Fšá”i`8å?€"¸•E á? !†²ß-œ"ô¼©‚!ëû}”*Úé»ì•rˆÂ\F§/c^Rçé饷ÆÊµ‚£Uˆ9¢F…>à¡fa¤’e ä‚>Èÿ'nD :Y¨ÎÄ8¥ÑQ…#xþÑf¶j:&EQ|D€Î?äÃx‘<šæÞÕƒzub'ÆÕÚ£È$@ÞÇâ€UeZìæWîÄUBëY µ®%‚^ñä¥ë*/iÔ]ž˜2¾š˜§m'hЃ.^  „0AäÑÒ,ŠåCɸ@MÎX¨æ¨—¨gn\Ž˜ÌÜáO¼õ¬96P«ÆªÙÝÀ¼„Fzâž&`¦EU&ÍNp¶-†^BÚ&z!ëʺ_Ü–¬É†`I@s —Y+Ïí™¶R§n¤¡¦žéUщ)E ½‚\DccHN´H¦jªDÁKŽÿŒØùÊs8G¾AÐeú'ê F€>IŠ*< FÅÆÞM™UAð£È=h Ì ÃÝLhA@ꆜL©DDÞm’¸Ä/4Î9M¦R•®QhÈì½áÛ:ÆÊGÜ[ëâDõíkãNð[í 'HxõÝkŠ"( +ý%ððž"ÌBîȱßñjáE9µr!œÁ%˜¨-ÅeOJd$ž˜ÊI@—˜"™Æ„ÐCÊ4Á=4D´€ íæ2Ç»ò+S)NÈ܆nˆŒn<üîØùÆö ;*öíÿgR©Xh3ýoø‰ŸjÄÿîÄ”)è?0(A ÜÂÀ,âây\VŠœz‰Bnå°NðæårÒŸjp²Í1 NÀ%úÜQI€‡ AÅqüƒü,hrÞô¦žgæ’MˆŒå|Ý ¢S®å„‡Ë *Èc Tùç¦Åªn¼Ä׃ì`«¦„×Å9e†/,C-˜"â9€E'Çe¥…B@A®1´VpT%»’¶¥Eôêe²!ó¯QFjXQHHÈDH 7ÁNíâ(‰Ž–]ÙUòLÅ#¿ŠHpDxÄ3ìÀ²ã¥f*…çlÇ”æÃzÿb`°•üCiÒs[™ZY\%€A@ #ñ®û9k™.w,ÿŸ´žrf°]Õ~¥Z´¡ÞÈFÆ,G«a]š"0EàúF4§ÅÃLDåî,ADÁJ¸«¨Îr±ï †Ìz’H4IfbíF|Ä2‘óÀrænpfçØ"èÃGŠ_>[D*+uxu"(¦™Ä2lq-¤Â`µ,ôUv\V’WЬïÈoç%rzá}@{ež}™ñtÍæ%—éYeqk]§è% ÅIZDDH»1D¦N]÷>ÑK—¯`ìè7SÎRóní4ÂÞDýúQ;oæP¬é.”ÝÿóŸ„×=§r>O?ËU•U™T—6ÓÕ@Þ…eÇŠÜšãV"dR³q)1V`!A^M´]±Wdá[™œV² *]C//Y'r( dLqD³»I†¤DÆ X}6F)VÜFŽÈôq‡:Å/OxŠG`í Р&ïôO{;Z Yûï)35)F*Ó#`&Àð3³æ”¥B•!ýà}œÒé? _Yu±våñr$¯´…^r®×Tô[Ç¥‚ÝõÏ *éië‰|@""t`JDs4Óh¤îDœØ£¢Xaò°QàSÎ/Ànìp¾‰Âfòy÷ôüj¦Gl¦9ׯ§ìÿYÄÄ#Aì >[D{v*{vÄðcñ3AÀ•À´í@ƒµgï‚oYðš,ñß´îm æ™×Ðà|±õµ%X³që¶ÞyFo™›ðöJÀDÈI7†…´À‡¬D˜ÆÉÔ'ͤçv¯@Ž,Ç¥ÝÏnô¬˜Ô/Âî4•ŽnD9g¦§¸LÄPqSãšgÈRC1ø•º+¸k¾U-°G¯@'ð·­³fyÍwY›5‡RTœ`´9§.v¶nYšá9²Ûù‰†À€!Ú«„ϧEcà^÷æV Œw÷ Œ.È8‡ËÜxŒósä8 ö4;¾êF˜·:Ÿ·ÚϹ[Z°ÿœ<»B”×·Ãn”C½{ö„¶iªf«cP½º€#ƒÁû‚Á¿z-ü€wP¤&Y›,Í™´ýURô}˜œ»u[ÛHQ–cËÅ–ˆçÆŠ † ßÈKÇÝ1rdoòû G®<ºÐ¦Óý—º{ħ§Ñgz¦«Ò´mÁ‰d%SÿC© FS½Ü3†ú¿?}•“6\Õ½fû3¯¶y©—®§æ¡ì„ïÏP{ ;q¯˜¼¶‘‡jr3B\Ñ ¬e`¼ †˜D£IÊÔјŒŒ*ˆ€˜ÜÄ/hn.8“3éJŒsã%«nÏ2É D€HÀê\À#ýÑO±Ñ{bSÿýin>A áwѲ”zjbœ˜.¨i‡"•Ä·i÷*óJ¼ž–RsÖ•ÖÕÐdð\ÍWœ»Æ?o ãE³}*É,f…OÀa´[FÊÇK[Úûô(dJNÖíèL`qdêí³T Žy{ºx(æN›Ýöª#Ý ´Ð3õRD”{¢Ù®zæÓ2AЂ—ò¿C|ß‘¶+Ä¿¾j L•@`„ kÕB`D‰)Vœh¨¢„ %L¼Àñ_… /|(9ä¿>LdÉòßF2i œÉHà‰Œ>àT¹b‹éi ÷OÃ?zôœDŒ’/Ê¿(¹ôQ͕Ϫ ­Uså A¯ÿ…¼óZÐ ñ/_>}¿V\¡jÅ«¸+èFlKwAÛ¯òúhû¯Õ‚–A‚@0@˜GÃAþˆxÀ±®Ö3pÀÁc ÔsUo¨@ˆ#üg:•ÁT«W×B6ðuhÙ³ÿah¨F+hÄ=²¤Æ’ÿ>FlQ§À•*•Ӝɼ¹OŸÿxN˜7Q^}Çÿýwég!SäŽ;ef«-Ê„]íxÌeNsPH“š>$0”…)„Ì?êU/Eýƒ28Å!¦*sÎ Y䑲[õ4™"yʦ#ÈL_ÿo qP .V ‰á7œ ­Ê}¶ZΑ²Ú«@à†  Ú¸°”N óP }""©´ *küÅZ  »_ÄnŽx]ãk—Ç‰Ü [ D„>†À ˜’0…öf“ÓDYf›þòLecCV2"nÓäQ÷†±Á´”IÄØ:‚¸‘èd•µÈVW’+(é}½’nP‘£8K'Pk™(& ©)sš]ý*‘ØÉNvX*.¡˜Ë\u …e!(ÁtƒSymèk›a er:ÎÊDÈ‘A•ÙÒ¦N¥"›ålE&6¸Œ´WpX½û$`¸\çª8eLгœ­Îï%ljêû<ÿ˜‰P?å©È|€‹F´¬©vþ‰ˆ2Kz§6þ%[ÿøàC5Ü;+¥ïATCa…¬R2÷®šT X„@v3_†œé£"òÇšS¼-–ˆ )’çõ4žºqÃ0r>Á1Upü$D"ßœ@lVA: û@ÌœZ½/c*¹@}uRæîD¢à`Áâ%š¥MjôÎU€6%¡Üuvy¬f5)BM V©bA ©FÓÿl†¦”J!OCT>;Ï’Á,&3+7ì¥wЄæH{#V›MO¬”»ñHG>2ÐMb(É·‘”_"é䉀–`@£äG­ .S”‚eã˜TŽ®®“P¢É²åòu°øþ€t_pÚ‹RŠN½[8\z ±!ó$NÞYz“”ȉÔ{=wFUð1|› $ rÀávr. $ý6ZHÊ)²aK>–¬j«:Šx@ï)ÿöŒL©2G¹-/ËN¤æZfÀ×ðް;-(S‰tp„ÙXÈR“½³ô&òÈŠWã7tB(NÉf¯äÑemD‰‘‘´Ñ©oiO "-ÿ:¿ÌQ_úZ‚_‰X‰ñÖ@²ÄÓ¹×§;öùt’Ì×ãâuÐTî­•šXeh NäÂ_G$yƳХÒVú¨Š—Ï·xBHTÞÒÓ°ìâ•&Õ›v‡ù6òõ'SÉ×hF'º©"9qJÛû"§›´êË/ânÃÁ|x'Y —`öžîW¸i—šéXÅNòy¬ØÝaš¥'j•‡D¬zÍÀR)Æ!Å‹s쯛¨2%º8þo˜ÎL‘hzâæDЋmÆöÖË©î©po|ò)pØŽ|„܈¯pDNcÆ´Z"¿„¯%¬$ò>€çxf¬¬)Ž" ìá=ìAK´äòÿÚÌ vf KfK"B-¤î,Ä#æÁçâòÅÜÏ1 ‘®é‘†`œÌFD$Îõ¸î_òï ÓéØ2«õ†½Ú‰`>î9«© íÇ–è{È b$|FâïNHæŽc2†e(`°v0"Ä£(–…^&ìá£BC -ÐÂvþ!é–)Í k¯È§%îÓ”bóe `äáBÏêþAER®IώͲœG K/‡–Pÿ.©¼ÒiÙ Æ`P¤Sjo ¹ø:bíȧ©Ê° ¹­”bÅcNÓLbý‰J¥%ÀC­Œ¢£ÈòVðŒj­)b­¤#2fMì%ðñXÿä"‘¦Bo¦tj"ËWoõüoDÌŽ²M 3«’j/T´p£-ÆlQ7&†Ûd‘øüi$š÷Îæ€DH4Ѓ %ðæ€†‘"¯Á…i:ª™ÒÌvX*P†Ýð'­ ð¦Ì×ïÚïkfJœîE§$ ÙV¯ëü/MÒ ÿ/!ΆzžÙhÃS2"e &5¬&ͽÖK|M¾æ±80ª¸Mä€8šq‰B"È’2}ràæA˜Îoëð/*®¢Õb¸’«Æó,"vp{°¬Ñ_€l”uJBx $ÉDò,õZOB1†’íØF4@m$¥bL&ÿ)ÀjòÉd’³pŸ0ÑæKѬ­'AI‚Uæh‰Ÿ0b&æò6ÿ£2T-ôAû”±"Æ/"Ïâ8B 9Q­Ä¥Nàî`_Üþ k.…Ú’œÈqϾÙš°ëJ„%¦äÚìf6b Rj"“ÏlÒ6¦óÆlÃï-ù©0#â#Þ®÷¾´–h#4 ‡ƒX Kpíù”ÂfæùÊïÁH3×,B¨bàˆŽ =§N€°1&"-ƒ )kÞò3@c-%‚.=ÑÿBQ¹Nÿ&S‚S’óxHEZ{†Â½n²ÐJoŸNt0 a|ÿrò6rr'+¢³ÛÓPí‘òG6m)W¥É`Q䦃XÊ;– ðð8eúp6rü"Ç?!Ày0"Ö¯J ój“"¾I1PŒ2$£7ïÅÎhã‘0+ËŽ ó’y(€z "9SáL±FžsEÿ0#b|¨Ó†ª“0M4E$È1÷I| µPíÛ¸-ÍU®ÛVE‡L9 5=Ã'%­¤%ððð[ºÂ1†;ñ§%„ B\3çZ€ —(B…hJ"ÂT ܲVYìA¹îÍ!xu"ДœD¤%9.nêF{>…E( &)à9Ùn˜Õ6˜ÕE×tŸÿTôÉÓNã È€,ícxt|¾mÓô µÄmGR‰¯Ò'|° ¿> „0GàPíÁ >À*?ÝÖä)ø05UÓ; dJÕŠe@ÿ¡ó&Ñý(QQèl(:ƒ§ºk(€óDè’âZŒ _/¨Zòmâ4DQ$oRÁ&mè9mR"ž“0™‡ˆb [jÓ°5}ŠÒîâUŽÒWÔç‰\Ž\ §'ýn «†/ÈÂ'%Ö5X S)Âú„é=­rN>À+žoT;SÁþÁAÒ„bê4’þ2RàóƒØxá<×rA5’ÀnÏâv즧­¨*âYS”ESr0ÿkcOa¶Pc”[›Š[/ †²Èl¶WZŽqmWZN}Ž#Ü$U\W…G 1"’²Ñ€Ã"¤¦BÊ#>B˜±3WSʤ”JK ^@UåAv«ÁV 2à ôk…a¯+CÞ¥Îju2$Ó6â<UfèDøÒÙPq¨,"'é:çkòtOï?yÌ©¶³´ôKÒp1'$÷H¤h~ZîîºÍ{1Wøð4P '=×—q»sÚ¢#"G·l"ä„",RJ•‚]·,O@#!qýjwÿáà€l‚ ý‚03@^ ¶ërÊ2 «Øô,4J1D,nÕËþpS”YÓ#j’Çÿª×ц‚[/fÑcÜô«"bŽ;hX†‹drj}7 ¿†ÏÒf…¯A¬‡õÁj'Þš¥<Ž‚úöw[÷uesýPÈU1€6x_p—l÷¥à%‚1XìC¼¦§\Á-¹+BʉxA.—·y˜ÚŒõnVV šu 'bC#OC"q‡˜8ŒÒ˜ÈWþ8&,Mï\Žf—Üà÷Fá•´€C‹xx‡c1ÿ‡,’%af·”Â"yÐ`!àJÇ…”ai“6o7l¿¶@[È^ö囆Wm!V2Òv¡÷T€SÙ6n"–ó"êT„[ôEeãf_X<¥Ì…u¥8yqbbH|¥pbNÕ—Ÿÿ’#9Db8<7š7ÈVE'hýDí"MYL§“Ź @´ód}°a¿VØ©Fe…0…ÈøVÑXbýÌa¦pœ‹’‚Šm–S4)ƾ‡ˆ¼ÕF &\k±Q¢pyµ&b«À³HºmÒîRý©»Í$ðñ‘mŽ(g˜"\·­œ… Ÿ…,\—,^wv#Bt®q_Ž€&Ñv3 lmº*b»|úC^à0ôùRIbsÕã¶FôŽ«G/•óz&®Žÿ†yxŒ¡-â# :$RÉ«]—«(b‘Õ•Ÿvq‘1W,°}¹í—L‹ŽÃu5Òsv¢Ø™g¶J–®ÿ÷…¾¿v‹˜l©x"´ ë\¡‡D¸K$G¤3â–$Oű|ªœ(bX£:n‚ì„SÅNUôE‹î“«zv¬+"¬•l%:Âå‡]shcšY™Õg™‘e×ÂHa=¯eÚŠ `¦7òª°[§3 ¶@q7-eÕ¿é~m»´¦×*˜ô(¢_&6D$KƒçÎQ—=Pi{ñxž6×sÑ͵ ù—¡âr1p(µ}I&î;‹påÈ.º! dâmýèZ LÙ”w{_¼ak3¹ pw¹1`kð60ò^†0xIÏ2ÀÑRî…ÅøÌ‚9‹ìüY s¼ÿ+–"¶µKi‰ÂSRj†[Ž}³|3BÓæ #ÙÆƒ8Òœ‘cb¿©ùÓtÂ;(' ržcZ"Lùožµôv“["ا›ûàpZ"†P›ÃR.店’‚ª²QŧŠS²1»BeÃ&±ºªE‰8‚ï|`<«Ä GøK«]ø{•À,f…™'¾~ü$Z Id~"‚`qB|¬ v¯ \Àõe·oúlôtZ Èv•¢‹7¤a©lKÌQ i‘2„Ãss©=ƒÄÿ‡–0XK\$bz‘—íú8}p¯øºÒ¸sqÅ×bH»½Óg\—ÃÉbâÐï+‰ˆ6À^•’£!€ÿ¤Ú§Ñ=Úy¶VÉ)ñ”÷¥—~ûÓxÊŸûknóÊ©ÆBö¥K=D›E"Ðx6`ˆ²”Úa$n z ghÍÙ+e/‚}a‘[G‰íѪ‡yãÛ­o±½aBŠþ˜h‡ÏïîNæv"Ú©ƒÚ1ã£Ú¯‘u}ZtØŠkºÀ°3r€Á)§ðó&‘C° Øæ,7»”©Cã©õö²ª°Õõÿ†B0¢èE0wl‡!õ6”¾sáåÎsuxæfeÜ y‰#;•Œ«½">~Ú]“p‚xptý»#Öóôy@’ü©kizý´<"¬Î6˜åYžà§%Bº;D¯/$¦LŒÞ²tÕGÒFІBU,¨üy'ƒ94û±uÇTôPEîàg”¿êŽ­cn§ãáË÷æjÅŠ ýô§”ý}ÆÞA2ùA.`>‚$àYC7‚Å‹#òŽÜ“WðÞ¿÷0,Ä@àAÄqpdá¿#/þ½ppÀG‘5v\(òÀI<\i|©ÑÌ™4ÿkÚÔ8ä_½9ëå´Y¦!›nÖ”€DBͤI/H¸ðÏT˜Nÿ)]8A„ &`Õè#±&”…9áׯÿ&Œ% aYóHü“k·uK0*QwÞ¿³Jy\B¡!ÌȰàF ,ÌAÑòÂ|ܸùŸH˜ž1ŽÍRcšbþsô¥Ë™A{þ¼Ésa£ÿĦY”÷B$Q¡^0„TªòãÌ•kdº°ªò«ÿ *ͪ‘zXFÿ¸“õ¡ûK¯ÇŽ]8o¬àvÞ ,·D ô€ù²‡þé?Æ Z òzAБ<ÿHöÒ=GHtYE•”F¢]ÔÙÿƒitak Éô†ÿ0Û†0ÉTˆÂ ÇÓn¾íÔL¼HÝP¼)ÕÜTÃ!…TLå(UuSéç#Xm Iyá…7#$ÜÂwæáÇFG&)åzìÉu¥]á•ÐÞ|áñE~V¹ÄØŠ a/tÄ,üƒ %´Ddà L'­„ÚC¢½Ä§GÁƒŒ ª‘‰²éd‡/ýFÛ‰:ý3ÄN7)úR !÷T†÷©UÄ-ô”Œ›NåÜ©RwÁT®Ù[_‘S`\ÎÃ% JžwžXtÝ¥{Àê%e\áÉ|ÿx‰WðP&<ñà€C–pAxj„ Dxvv¡ÿ„¦eD៞6Ú A8°Ú‡®È„‡5¹ROˆFú’m¸õv/L!*ªiT/Q'T8eãSš9SSúw•vDÆ:¤Mf‰×|€mŒ«`ï骫¯w‰Å×ÇË&ì^ŵ~z…‰ä³6RêÊGêª)% oj¤¬F`¶Ñh¥ tšM"]ØÑh­„«‰´š£Ž~¸Ÿk.½KµLŽÞÆ[=>±Øo¢¯idÝŸm­YÑzp[6¶°U_Åú¸âÕZn{ÕÕQ Ë“_vÏó-»ñ_µ—“ñå×|ö¡Ç²¯0Ã<æ&áJ8ÀCFŒ-T·|oBpÕ·/F´ÿGš»’Cã‚öÒ ÈÄçlín›±Õ£5ðÂã{SN¾u5L4~+Tyk:UHOwÀÑÙ+W[±U$‘ÞÿÃä-»êÚ±Æÿóæ ÀììMH,e‘øõíŒgVzÉ%é0!³j«q…œ¯…ì.%Zé= ¿vèQ>õàBîå9ª„×…MÕbÓ·ÿb2²‘ÝŽY.¦Yð™'dÜñÊ-À$,„2‰\Ì{ï2ZÄUõˆVå–MVùÏ¥þ-=H2O˶b¥ŶG«àXa’Ì…´Q¹>sT‚@ŒQ».m)…g‚® ÕN5ð)քǘŠsCSSÔÔ¹HÞì´^êtKYΑ-´;aRèL|ß&ñå}'[R_E~Ò„”þ]ß|äSÐøY©Àd¹ØXõ;s¯À¡H`˜³ÚI3/ÈÖ“é’¦åd1ØÓ‡]bÙYÄOVÍ^—¶iÆd6$šÔÔT ãzx‚éñZNá÷¼=œÉ<Å„2»„IIu‰gàæÙjÿš=ÿ,~‘LZ©J• ´³&úæ±³‚Þ娖’l…‰ºw„Ó öb˜ÕTd×V [)ì´œ€Mª#Ie“ PH¥ÚÄ3J¦Û×뺆j5A¤"{GcAo·›´‰KêÖ¶¶ñ+QÊ$eq¼I{~'<8n’{DzÌv‡Ò%{å;¡Ü³þfÄ@o2ÒŠää?»qÅ2;Ã'k0Ï/©ˆGAÌ{¡„¹Ý·iÂß^±“zÍïÈVÇžÈç‘fhYn±•òZñ>™ýaàäBé÷ˆ_Êei1´Î/9•ÿ¦ji׃|ÚUQÌnkr„³†$ÿ°LEJÀv± ñÜ&]éBAg.%ñÿz%q­" /JCm6m/w]Fx§£Ã!^%)$Ø&?ä O(ctâÓŽ3C8K²8ëcu¨dD¡ÇoPÇ-«Äyé“>ò1VBp‡q&HrwrçU'k¤bQib!~1ˆ)`öyY ±- Ây“áˆ,PP‘e çk’ÐFö˜L¹ö\A ´öP™<©7!’zz/ò²3!1±Mµy;òŸ‚²ÿ{$õl¢(X³›Œ¢†„NÔ6:ÏQxnóS/!ish—Ü!8îÆœyˆ‚³^€8\ò7HW˜¢ÖTˆøte ¡K  q£É_ð–iââ'Y”XcšŸ8"01RAw/ÈfV˜r-ur‚tmfvT!zÖw|æ|Ö6NÚNŒ%‘÷ò"ÙÁBHŠãA^tÙC›DK{™I‹YëZß÷^‘O†jÛÿăÜè˜þæ ¢a£ù·èã/rò t7axò¨wLw¥Éd&2W|T.¨!ÁðqìG¶3ba)¡*u”Ô(ZãR-Öÿ/`ŠúXf££=F’F¢ŒžoÍÉŒ$xU{ÑC\Z{êüåt& ;™ܨƒ aM™ÓZYFxçQw’„2©òr|Ð$ª¢Jah•PóvOúlÏÆl]ªÓuŠ:᥻C–d([šNáB3sIŽc—|¨œy˜ŒvÑœ½õC%˜1ƒÙ¬€šZÙØuB­‘y£q£÷`¨ q¨HtF@E#GwR”#õ-ÂäöøAÑ ¨Q4t”§êZZ(Y; ¡R:›¥‚$"þš]^ÈIê‹×°9o¨’Ò)H+ñ6œ%oï5_zYËŠOÍšÿyÛÙyDD­;©3» G€¶!ž§¶Q¥ÿ˜„£3a¡Ñy²ÃV;+±.%'¥Hv$/Ç\¨m8Ûp|´Hm'46¢A:K¦þj¹hZxÅ8œhqœí”‡õ$‚›–PKò1ƒi‡ÓµG“8ˆƒ:(¨òp¨h« hKl»±,4ÖŸFèQ˜ØV·bð~A>;’M:{rIGªÊ 7]±ÚM r¡oÇ\òqW¹„þÊm«.t½Å”¥?çCEâ8!ÂÏÙjwz%ࣺ¦£þÕé÷˜Öj¶«¶ ¡ ADR±+ÕÿF錴K© °PãaIgÅæV j4‘º½}…ªÊ ·™g¶¦bÓ(º³¸Á÷•Õf|i¨9Ü$öƒ’~¬§4HžÙXRD蓃 ÁÑ04ªHÀÙ² .{ÊŸãu¬p…TAïò¤6»¼l|ÇGŸ mX ¸Ñ†|-¶¼’k‹·‚tqH-"â*usLíZ0‘Y~ù8xxYÉ)>íôå8¡íSÙ‰ÚÑõrT4'·z_¹€D笀G;m)‘6›Ò5¹˜‹µ,h¤‚0Ø‚<µ+BYKrnÈèI×ÝÃüÐH5ócuîgP7‘G ‘ÈìÝÑÚ¾•—ì\í©À‘ÐÍ¿¶˜1×Þvá±Ròì›Üš!ÑG²¹§ù:&;]lé5aÚA&Ì{€\”KÝ/¥ /²Ë:§ŸÿOß½i;lê~ZÕ8?ЊçâH'´S»´³iõ9pèG°T¼„ üpÝÄ~F^a:›h'â®ñ¢¼cˆr€$åÂá•çÄLç¤HÚ%ÏA-|´ScC±êj [EÌyÓÊ8‡Â|æ|˜V-~Q2X­OK¤D½¦u†*žŸÛÇè¯ñ?gÉ÷24äNí~¢„úì'<»¼®#ª•žÓ™î(ð©õ™ª®!¾Ä é…$Ø#•´m|/ ‡í®ªï•ŒRí$lÞTt}2£Pþ¾8È<È.Ê¿Ž ‡j7zÄ@Cì àF€GNÿ Ô{–LGìéçs}ìÆm:aw¦,G¿çÉ¡jl¶x$/Æ'ò¿7H´\HšgÞk‹ôÌ¿ñg/±EqóîÎêÄÔ2ÜóHÂæxy—QÝÝ?$ã÷D÷uyREðÁ"ŽR»4®¶­ýÖ,ý±p§±F¡ÀmèaÒÀU<“ì£c¸tW¯g¥Á¼AË Nþl¿g…|5<±áØÍ—ÊÒ[éÆÖÊÍo+°…ÿ0ýhꨋï’å+7F26ÖI …â+ d"Yœ.“9Éù—¶–1»l4® äF® pô)ö¯Ç‰Á4ñÿÿý3rÿðß ÿ <Øð¡ƒƒ@<øÀâAŒ/:tp€âÇ8IräÊM¦4P/¥B”ÿBhøò_I–4 ógɃ þ­ ðϾ!†Jx*áÂP‡$þM˜pk F ü³úo^ذ`λUâ–Ãcÿ•pxâÉ#ëÞ;rï¼$ ä%±`Â_á±p 3ø‚ „õJ`D­6oé̵~:AÀÄë þ2è!PDÂÁ Ä€Â^8 Cê ¢ÃÓZ|è1Ã(¢ÐQ… ò)ƒÏ ú-#(3ŠM¤‘htH$—^¸N!“n$É7›’)1#û©&Üzbµ"ÿœ~:à:DâRŸòú.¼¦†8h >@Ò{¬÷H(“½[¬]«kñk“„ýþcäK…ìË@‡ü¯¿ØóÁ> Ú‹°ÿz¡„ ‚€íBWxà!Bñ´H:ƒàJ¨ çó,ɦêÊQ{2u¨‘LÅ8ÊE}©5ëêTÕ!kEÒ¸v£J¨štšR¡!„¥RY¨ÀãòŸ ˜u¨«µÈÌ>¯à0>´ÐbÓ¾þ<®9çLúŸ¹:BžƒàóRwáíLBë‚«à\a(4ÖPä,ƒ»È`ˆ„äì ùJL(1?]é5‰ºØµ"¶É¦—€ô˜TW*ò¤ÿ˜gÎoTqÓ˜9Óü9˜$ Â%\s4P AB„”pÀ“P J2¼C Œ&cCJ@YÊ2@ÌtxY!DH%ÞJu(ÎqF~Ke©HÆÿˆLÉd-ãeú¶ØšLN7Enþ7σࢌSÈ6Ä»9Ž"0Z~B‚i®e?Lc Iäa uÕ¥ØGÖ¾YC‘Ó`ÿHGÜH2/j›ev(+ê@d†<øä !WšWbÄ})«ÎPP…9‘”9äChâbéO,ôdsˆ3;÷±ŠÕ.hYr|ë©CñèêÔ"™´i×$‰ýˆ'!Äw}ÚG‹ôÔE1†p Œ2=ýHó2`¶ç=%¦dlEÀ„l¯p(rJ 2©"Ì¢H¼ú·­Zçª-ó%D_I•^Þ˵·åH‚Ä ÝÿL!ù˜@ ø‘⣣(àЮ5ÒµÌ5ƒIkÓ¸ê$ læeBYŒŒ`Ïd ý˜Ú.´YŠ|汑ÔCPÓ6ôk5ùGbjÂ!›àrŸìÉD÷¡ù“Uɘ]"Rë(By(å^c·NdOj(J$"¦ÜJüø³’™ÌX´€ìÂG0ÛgÜ©h䲦¸b®²AxrH`þ*Øíb€_°yñÀ¶˜Æ8¶Q­J %ŸÉ¡$ ’ñȆB;„D4S´ ?}ÓÉÞp•|zë*äJB —ä^ËQŽlgr’Š¹Òˆ:I%åb·ÜãpÈN §ýƒqpæ|‚‚mÔ@% W’‚¥M{Äà[ ÄqŠsÅèÒ“!¿¹ó.Çj ]ÁØŒ’8$IÀΦވI©Ìˆ|‘Õ œþs"üÔç‡æˆÄõ¨bttˆrÌÂÔˆ¶V׺ò*we@ž˜¦4!ù ÿ,éÿù H°`… *\È ¢FlH1ŸB Ü@„h…Áe¡ øPZˆ@¡e óæ•8QB‹y,nÆ<ÁBÞ½{òNÌ£7£˜óh²¸w¨Î£7?|€¾V† ½4„¨U ~ü¸a’‚ر&0R a-£ -% i…ïG+°Uš¯€={~.PÀ¢>~úr\<шÇE0ŒÇ¯@åx– `¾L¸³çÏŸù)6È/¡é‚¦æ·z5ʼn° LȺvëÊS[¼‘Ñ ¾5.@I‰‚×ÈY.áÃQœ'ä•H*/fOŸLYœàyý'¦ÂgÿqTžtF*,À'd"C¶":iµîÙL¦eTb:#òH—ßVݰ—=&˜_å#áA‡‰ÆXc=$ÙüP&P<ùl¦Yˆ™‰Hf ¥H˜B‘VÚ‹©F[B®½ѳQćµáÖã"ˆ°GÝÒçÕe½÷Þ^ÏñuRz÷SO?ÝÞ–\†gT?€"¤DVÍI AVfY0Ê(À sVKY]À þ˜•HAø­DA þ„}åS¢.ÆQc"ŒàAd~¨e˜eªÙ¦š¢Øé¦)Šf¡¨:–Jm:F©9–fQfŽÿdÑjŽùæhH­{­dôÛTk6çÜN6 •TM>%vá @›C—@%¥¥MèC’7ì)Õšó-‡ œ¸Œ"–I­ŒŸZ¬{Á»\0„X€þ°‚ù4ø ¡ö¸Z>\YØØ£éãÁ@˜vx‰œq抠yÚÙB«æxªVêa«VŒš@@rX£>@2à(GáÚ+7°„ˆ!Lž°Ï%•RXnùSSÐ à³9Dí´âå„]ué©ç‘°m…°ær-¥‹Ï(Ș;–X¿¡.€C‚D×éz…R^‹~ ¿öFa£Œ‰àØÁ*´Y<™’ø©ÄŸ‚Š"©£-ÿ„±©€[…ˆ},Pˆ˜À9í°`:7‰N²Äƒe5ËgÓZÐt¦,óøvBQ˘“›åv7țζâU O,ËŠ¸ÎR“Œ«\ØK T½´å#>ˆHL£ÿܤñÃSXøÆ>òQ†SP¼bIDG4:Í‹æG?‚.~ÁÛ$â›"Ü@HÃñˆ…¼P@œ›UºëDÐfì’²*¸º ©Îu:ƒÝĤ&ß±ÉSæø›ßønNïêS²‚„¬ü%—̤YF `”Kz¨@óѯEqŒ{ˆp›â1‚ð)ñp*_‡JÄ)BÌ3ÙžûJe¿ɯT‹ªÈBBæ˜Æˆf)„\(A‰¬,l4‰)ÎÉŒ#8¤Pžƒ¥ êQ<ð#ÅI´D.¥)6AJ zÂ3Ø•°(Ûã](0³Ôeíza¼^ÿ—ŒÂ>Ã01|–™›f¤xˆyêF-ÂQCìW#TqQG„«Q>2”¡ÅÉr éJ, a¬Ä+ì±"GFÄ,)/($NîáÍ.=Ë{—šRHŸü,ÎÑ çnâÔjÍ#YZ:Š™¬ÅÀÅZO¼Ÿ[Xu„kŠšX-–ß™%Å…‰E)J~¤'tÕ.b<íÊÀ 9S±4Ÿ¦JÝ)pL±ªˆGuk1¹!©òåZ1ŸrÐø,Xºìkg‚©íIí*0AZGvkÿf­;IçìiÍ–hŠ ¬›,e¬%äZBw\zxטîq²–—l¥%-cáYèJƒbÐA-"WTV¨B䳿AäʘoŠølŽÒ„ÇïÕµÉÌ’û%+Àͺ#Í ¢9‹ ’¬Ñ³*a ÌP» ÐÃ:9–’J ‹ÏAv´¿)¦È|g:‘Ìm‚žJå%È…€(0ŠkàCD_‹Š·—•ùä§,7°Ë¹Ò éQD 9 e>0í¨Âiº¢[_ùþÚį“׉Q4ø.kRXCÙ6`„u{S9ßP‚r]¡é­ÿ«ß[ãw€­ÐrM«NÀ¸µ÷ÐÿQˆ"Á-±¹'=I³–~òÁ)%Åþ©ü×2½¨ø·n…sŒbùå8’,ŽD Às©€ óvPWù†JÒc âc˜bQê3dµÔ)„%Ägv>Òjª‘;´C¦bLˆààÏÔˆÐq·&(_1 `­Ð +`1“/$A±s`[;;ÅDG\qtsô:d,FCäqBj໢<#ÖIPd°=HÇ$ROb™dµ@5Èu:ÄvÛƒJÆ„u¬Áoº÷iãUK S"ã3Eç1XR«J‡Óp=²È40™"°¹¦_Òw9É1ƒ·ÿ69úˆ@† 8U&fâQFQGÔáTÀ…ˆ·ZzäÆÂÛ¡ZF@V+Hc*vœDcGañÁ27PbÒõÄ2érnò&æÒ;di´÷P°XZ÷J Ó{ç{¿væRQv 7Rñ£Rɧv`äK9Á±Š˜kË„'Hƒ^Aƒsçˆ30“ smVצ%ç¡#A¦ã:ö¨;'@sË’NC%IaHxä}11VS¸&€ P·’tðbËQIHgÁhÈð‘È$—w=ü€iÀa+‹0=ÖD?æcœbdtc‡™Rp…“pfãKíÿU¯‚"x=ER`9–³äH ¸ B@ …q€_ô¤- AqÊ#ÿATØ!sHQ~[òZòÐIa,ÉbþxôcI:º[˜ø@9Á† !q §“È‘+tr&^ã;Á(cÀÐ r¢9ö/Ü#_@¢u{õ†¸“%^±+‰)·^dR F"Èj~({°Ô±”ˆq ”+ñЀ$ùõÑ ÏM 9j‚ ±R¡uTA[2x$4”•ôÈ~öˆ–Ä¢H:¨>‘H¶5UóÐ4{ñ„3? )t&¿#C¾Óþ„ Ëÿ° ždb÷D–Å=–">tÃu‚5KCf™ºW™upV832íåQ 臸á›i¶™±Ï $‘2¡-ÖˆÀSÐP  8q‰t†•&ѱ%DEl&sühx¤S`y-×UŽ~%—† Eq‹23I)4£º(C”TIažEžP‹²†'£˜—²W=V™…QG*j䟼gŸWY¥²™ÈglÇv;é‡Êk¢±'X9½2BPeÀA›Ûr}'3j¢RQM'Wg-ÀaŸxBœ„w:ù,Ú!ÌYmßáxæ!`væT䃂|†òÇYÓïÿ±'Žú—T À0žÍ`.ðñCN² H8@ÖD¡&^’97ÉŒO´0›A8¨™ßØv•qŒiç#Z:ES•ó"Ajª9{a›B°»’}ó0?:ÿ!6ÁZr ö`36%(—­Êö}jœ'ʧë—HJÃrl%Dœ•ÇÓ‘'R1À6ú4˱3hOT3žË og2IÚ³=Tq2û–Éuì³"Ñøžƒõ˜w8“ ‡&E’´á™ÿÙª¡šÈW‡!aqO‰ ”ÀS åPFòFaùRŠm†¢Yé~yš•R¢¸x¡x:97yÖxgÛÑ9Ù4:ºÿs`„@αN:ñ¢éÁ2¤®6 Æ¡zR ¶ × 'g"%i •onC8KjQ¢:EÿZX¦*KU)—ªª&¥Tçpü «hçKúpÒÇ”O)“«=Ú3A;yæxè ;.Û ¸”%Ma%Ô§…gxÓAÈ"³=;UÅ9Ü¡þ‘h,6êH˜eiÏÀ£g0„µ˜–oùZQÏh™í¹º ™z57ŸJ°W´^#­Ê°‡s¢ˆ¬*!ú025S9e•@èp§c™•9÷§Ó§è¤¼jG¨²”%ë—%E••Kø§wk²3+rvÿë¢ë„õ/¹‰¹ÁRzó1ƒ4ô‘“ú¹=ªÿ²=ÙµAT“ ƒ{ÏpŸf™þFYG7õÉ>µ¥´ÁŸ¡v!¸™Rº=>p}1økó8u„†¨Êk:ëG[×â²Ú;Ì«lÒʲ0›sIX3qZ,;q¢”+A4{B1äZ2³…ñ÷Ç&ꆸ Ïð È`„B(Sº)©†¥*ÀòjJÀ±tµ¤¦^Ç{|µÑ™–A’µ°TúY§Y+ 9qÔ•Cq‚Ta?Á%iÞäx|kÂÄ¡Ð-@¡3ÌkœA1¢,³Éˬ1|2“Mij!ÄS‡ÿ6zjò°ëZ´˜´>ü 8„B‘‰áP›¼où»¤«»Ä«+°t3Jü{bWŬpºË“u=ܘ|…“‚t×k­Ðu„[yz§S¸<¸zоܯ1wÏÒ¡lÆÁmÌǼi}ª½43 Tpk‰Æ•Kt1jt7¬¹'õ¾–\PC\EZ¡=z!DwÅj¢ £ì©“éDðy‡ CÅ£A»]L áQ>Ù#ýù¢ù/j‹_u}±9è'ÍBe½Ô%0§²“ÌÄÜ¡u̲{lÂÖË~%*¢AѳC!3ùb<»g–,7L‘Ê2ß,]ðúÃË€ò[ur«KÂÿçW”YÊ »ãcµòܯ¢fë¥*»8g›#Ó°}Øv°Ö4ÕYùµ ¡::ÕÖÐßsá‘TÑòÁÀ̼_y-ðø(Çy¼,Ç›.ka- %b≳]I¹ˆ …*,“¤ÃæjR3©âü¹?0(ZqΤ‹ÎUÔ!—2+–ÏKÜ¿Mü¿1ÉÄD–dB­Êa«p¹Û°¯ŠÀñ”\ÆF`áï [yÌ\²xiö,2GsßÄZÕ+½g½G3²#;y¸µŠÌ¹M;p}H/jHVUÈÆ(´‘,†²£ãùÃÏУC|P{-r{žü]l7 Óž/Y"¨]øzÏCÿ8©Ù:yÙ°,‚ÇD ìawÈq®fƒyz¬=TŒg§æÇ·ÁL½ëWÚ<²·}ÂæT6ÍÛAÚîg,–§¹•G(S!èÊ&w‘ Εü £0¯ÍÝPUDÓ·§iýÙñLʤJ˜Q+$ˆ!“½ÊYÚ —mÙ®A&÷•Îô Äk³ì4ßÁ¼lMQAYâÕj¦Ì§}:´½.äGà€L~ï„6×ÑìÛ(3ñ1ß´P#5TCᕌ€Há/…-|ÜèiË’MtÓ?}7(ŽâlCÅßÍ^Ë(°œvÆÇÀš,a4ã‰?¦C½Œç¼¨s„?mÙºÁ+ÿkÛ~ôÐè GÞÇ1°¬ž§Íz[j391äÀÂÁíÈé†åI‹Ü–ü]®CñÑPk¸#W§W#®¿ÀGp¥(ž’±Ê±&Þ]ŒÙæ]‰q9Ít’ÍaZQA9#œ8>;=Žèjè˼²ÃÙÇCÑèôÀ ù"!¤täÛ‘íªXä%+AÑqvrM³…|@ÓÁ9/PógÑ…Ü“ª´0ÝÜȈÎñÅ#OœºKj滇{“ˆS+ê50»Þ7` _Y šáˆÿâRÿãŸÓ‰|ÖçQeÇÍ.ÇùMÑ’²§ˆ½ùí@èC†‘=ùò®;1Ðè£³Š£s­ÆÿÆÆé…üpÚr›gNžðº£P·…:$W:¶ë÷“ôæWÀçD×½Óÿzëknð±²ð 'šj‡ÙýL+§ ÇÎ9å~FCÌ€ÄxrüÆòmö<òNpë»Hœ=H :uDFžÆ‹>³ÎÂÖœnœ¹®øï¾yì Îõþ¹ãÉV©þ£ŽÝsDÓmÓ‰ýº–y)8ÝMÊ)SO‚” 8ÃX)«Dâ•%å1²;žãàT½à¸À¼xýx½×[ak=³nÏ r¯©Hœ/ö€í' v_äâ~éŽKóï¨ïtÂ'ê†á\ïAê„rPéAØá1Kÿ¯ºÜ¿îLÊQ¯)ÞVo*ˈ“z@JÁXéAØûM^ÝN¦ä:³,, ÷Êk!ïÄ zéÑË÷!Ÿ>D"D¬HßÅ|ùèÍ;x°Å<'8d!ÏdIy,XœX©2e –óXÌ3Ør„ $¢@¡Õ È„¶Ìèµeø(T`Tá¿ôBTÕ"?~"°ÆãÇÕk<}\óÅ#˯ٰbÑ–k6ÞY¸ñ¨J·*?Dx±æÅÚ×ï_À~+ø›ß྄ ÷]|¢C!@¦œÇèƒL“&ÜÛLÀógÐ÷< $@4У9ßÃp/³<×°å5ñxBÃÿ¼…ôB|øq¢-êk¸!Ç9†æÃ﫯î\‹Í²Î°À·ò2×® ÿ t] ý:BÃ}¾™r· ÐpÔJj€Iã´3OW”ÍÅæŽ$2¹ärcÕ¡‡ô™HÖVt”È"fŒ×u)$ŽJHÉÑêšLi¥yJȉª!ŽÅ§–-—5o™Q–ÓžÃø1¢ª*bpÛ®Ò0­m\ë,6É-àÀ¼èb]¨µŸxͲÿÚê©©n ª’@H!¸¥Í*…ÍÄ#<ëŒ`O*›E…? 2×\nµÆ"NÇY)¦Hâ|Ì ·fddð@ú(ää˜l‰%ìTâ°kC$|FÙÒ/Ó[oLiá듟DˆG+ÓÛ,Z¿þ+«N®Ä%‹\¿Ô=j@³. Äv7«÷«+̈ŸŠ_¡kD$Èéã’ÈvíyÖJ3±íùE2U‘f\7‡kl5£ˆõѱ•¾e ü.ŠBðíòž7{ì9<ñ]aÊ.ºê$2Ë i™‚ðàã0›™QÀô¹1á¥~QÐê£:âç?FkKì¼";Ù™+]¸ã`¡rFÿÞ…ðj8ÃZ„D°€¤°øš¦í´h3œZÒ"µ;CÒ^÷Y­à|” •úðV£(ðÆ!R¬#$ó±%à$ÉMVRì¤'†à‰x³ó<ãÎJ Tn·&¿MŽúá æ:<Þñ-{H_ôá—?v01Á£V<ÂàÌ Þðx¶JD`…ˆ  o&ÃèhÆl«™ÞŠ,uª%ðJ$Üã=>𾆄O" N_aÄàœï|¯¤„léŠH,ˆ‹ÂÈìñzÈøGjb2ެäó %)à?ð„'åI#0ð@¬ÿìLt¤ãÊçøÍ­PÐhtËX0Û r!Ôï Bw–ÐjA %¹‚!$oJ*f Xà)Nµ†`ÿ:uˆ’ö鯗»I¥*YÙJZ%1‰¯`"-)qQT—;ªÈp›Ýl$Lò'Q†²PåJe O²–…kÞ` 4Ä_æ°€s[aÙ ¸ôÓ<áIêlL¡Þ¹»hí.„U3ÌHJ2y.œá!}ÈR8 ˜ÁäJå|L7­"+oBœ]®2¢:RÅZ'jÄŒ^´–Ȩð·ˆXÄ©ô¥³:’&Yg” ±ªåVM Œ§€×ÅÖcSÒõEÿ§ÌÏ@èÁÎBõV™»B¶ÓƒEm!sT¥¦L%Ì#-`IvÍ… ÁáaÌLê54üÔ@ˆtVÅÏ—‰BCÓ*¾‡®µ­}Å+TAÑŒúàÒ•«žK«ª\D )0?Ç5n°Ýqæ Zq,ý A™™G!Ómâô“ýf/Ø×UPi~\ EXHÀÖ0O aU[h@‘„"TUðÚR`³…”ùy2—ÀS£1I(ç\{˜Ò” b>r‘Vµ® ­+v+[W ÝWRô¢t­%%Ð÷mWЦükÈòǤbVF'Oý$[š9d,ãKÿ~.~pÕçu”ç€ú•±˜O‰2Œ´¸lZ0Ÿ6BjW»x·© .0ÕZK—­A ;ħà¶$$9Š|›½,d¸7*qFˆ# Fd"Ém1s_I]èʘ–° w λANYr–s“›PÉ7ÈR+~rÆ$3ùÀX|GÏRYÖSžeñ»e¡zPZ&¤…XûÅÛ´©T°;q¦`³™‹\pc ²9G˜r§Ì‰S.ƒ2̘¦SH*¥)[eVãî’ž¿Ptp–»Ü¹µ­Íntk ׋¾’VC4w[Åé ³È„²åJÀZ(VÉKfµÿL+ÛÓÍÒwhüùÒŒöŸþ¼e³pñu‚ÍBæ|`µîD —mœÅ+©_¶—‹½ÚE*8Ì^¹ÊSžÕêcÑîÉ V8[Þ\u$(éíô¸Í*…Nbúè /#ò˜_¬ubMîFe5]èΕºµDßňsÊÃ!ôcƒÝ:p œŒ:…ÔÜP¾êõ4°hö ‹ar´µÄ]Ëiv‹R•ú–Ù=ÙÅ^0³•ºH“<‘ñû8ïnt£Œ¯\Z Nyüïx¿+r‘ËáS(!„T…Çs!¤FòØT™)¥pwóˆ†ï"‘Ø/,=oåF”ÅÒ]Á»ÛMã¸f4ê6¦4Ñïÿ–uy”!¨ªeÒ»²o‰šLÆç*  ¸ì'¨ÑÇ \ì~ýÝ5ûÙW-ä·Ïý¿‡ŸÙã‡|üÌ_þñ?þüè??ãóQÏãU¥ú¼dn5Ó[¯J'˜®²Ñ)Ágè㲈ô‘Š˜·¤[:)Za1U.Hª+JP…ê’+ Œ€Zù¨Á|û+:%Ë’°€²†å[2õ¨µÛ¼Ã»ïkA|ÁÝ‚A6#¿Èƒ–ÈSí»Áõ3¿ìA t‚øÑA ̾ókˆ*Q¢`!°!&‘y±êXÓ®(ú?}@´ ‚_ß`¥EK7tÓ‘P…¤½ç’.wÓ½¸’1ÿ ¼¨»Â¬«-é±b—œ@„VADaŠ¢ 80aA¤Al¿THB{ÐAJœDƃ{ÀDLT?FLÇrŒAELÇs4ÇLÌD{lÊS4G§ÔG©ÜÇx„G„ÄÇy|G¬„ÇU H‚´Gz€‚H H ˜D²Ö TmEÑìôÍy1ÔC„ ˜‡`èŽ|Ú§î<%WI¥¼É ÕE9:ÀY%E»4OÕ ¹)¼ù€óHaFÇDUU­Š‚K">âC´d"3t®_p\pèÿÏôÕgx/ËÍÜ<Å6(ÖŽ…Ç}M9õPÝ,Ë“UÖ’õMhýP|ÈÞÄMÛäPã$ËšýÍmEQlÍÙ?U‹ 4hYú,‘³Vøþéμá+„WC“W]À‹ÀK•TÉ›Ìhx"OVZL¹º ØZÊ%ð±0 3ZÎtX¸¸íhp]%Ð&»IôX¬ÔM¿…Ä¿åØ9\ãLÙálƒÃõMÄNh-Kc¸M™Ä8¥YœYâ¬VœåYÕ\?µYzˆ€äôZS³ah`°€Wh…|ÊB)"±|(®x·´ºTqÃÚ(ˆQáWQU½ô,Õÿ¤ÀmL²%[JX€ìj¨ÙÚ £U¢ãU1][¹mƒ6è…»U£2½Ê¿ÕMŽåJÀ¥YµSkÓ>MÜd}Üß„Y …ÙâÔSTâÌVÎ_m]Üü¥†ÔÉll†f  ÕŠÑ‡WiËâúN¤ÝD#· Â]®-®%ˆ†€º%%LàeÌâ…Û²e"Œ‘Н¡ª¨˜†573„ÛKèhƒ_è…^èUì­€aåÞïåXî­aÌMÖ’%_å$ß…Vô…Ö!|Ç ¥Ö²´ßßäÊÊ¥_%Î\ Úôµ}ˆ¤5]þ†Zx­hïü?.>`Þ¥õñ‘nàTi ÖH/®ÿô¤ÿÞ &Þ ÞF«Ñ¼+ÙC¨²@èµ^>î…_PáV£5ÚX|¤^ñMN®VÃÅVÂUd&öЪœÍ"®Öö5K ]b?ÅVMÎ5Q¡ý x­œ†*~­ZÌs]JÍ…íââ/Ò‘Æ1þ˜ .àðL´Õ+@6^"åL vÌ8ŒOˆà Së‰J¡Yq.3Œ^¦ÞêíÕ_E0„„î•Ó¿EYžáÞæ9ÝÞ&îÙw”J”d$æÐq¾ÖGÖÜM~ßòeßݰ¹œ<Ýþ­n%¢»º\m¦îçÛmˆÓö¯«Ó‡P­ýöB66¢7,Ûö,¢ŠaSÜ"“%5nßnë^xëæÕkiinS eSxt{œD'ÐÄLH¾Ù½6Nó³îlÄ–n¬„lUì“ýnEþÐ/é³d=|…Ë&eÿ]ÂÍîÎ÷&ðyW~¦§KœKuꌨ‘í‰SzWÕF®E‘€P ¢­Nf–„ÛS•ã»Ò‡®ñ‰Vȳ¦«(Uè…2gaÿfa[máážð8ÐQÌ>LtÆS!´s(Íôpa]S?gÓ¥ôðø)E~,ôÚ¤iŽ%bçëèž\ï~ñ ×Á÷ An,å%<êWá÷~o©^ê®×‹Éo®uŒäZbâï]‚VF±%H’«²‚âÉþ |ˆ6[ˆ‚\¨[ø^Hs?Î…ç_`Ø€šJ¹ì³;íÛDhôò›sÜp>t{„Íë&Åó+E?t—ÝJEßî>­VÇæ’6ìµì SRöÿ?°Õ'ÂH¼‘],¬à¿É¥#e¹™‡1¾‡ˆ9ãyo$¾!" <Õuè³ýÿоí²6ëW m' XŠ öFsáæÕ˜Ú+ª¹Õj¹•;y”C9’'y–K¿ø¡ó\Ǩ”vBßpiçh½J ½æDïytçn÷môï¥Öp¿ÜTeÔ¿ ÅiúÂaòv…Z}(LSr€¿z­mÖàÚ1ã'B1Z¹%“õâ}7›³¹ð†²–«W‰u¯ÛŽWóçFm G£ÿ[­’‡9’Oy¾ÿû•ÿ»¿¯ÁÔÔDA—vn?qÌ'qbÇô><Ü(RdD &SR_ó¥W3in¯)sÁŠâ}2ÔÂJ¨½2uòK=4h”ZÅgBVDù éçŸ5,"üèV€\¨?ü ¨! ~ÅÕWråÃÏ„€ýå—…‡ñeXav8Ùd˜)fOˆ—™H™b)ª˜XhŒA–¢f™¶"BLÁk Ñ&H-øÒGM„tÂD§åãÂAª‡Ý é³ÑqÑBAùl4ôxà¤Ê+-‰ ÿSw6Ñ„L¬Ð“x?ütž”¨¢Ê{ì5õ‹ êÙø O?Øwøùן~…úÇ`¡‰ H¨€ æ7`Vm}W^n˜!b—&–馥‰ˆÙcŸ†Yh£zbh-ÂÈ⊊i€B³,Ä&E•pÑGòÙÄi@A%„]p¯œä¤qÍ3¥FÑjd%""P€x )Û’œdnW¦w”´Á+ã¹YÞOd§Þzm´áTæµ"ü` ø jh¢ýúûï ]Ú•£o•Ä…•jØ`š^šéd™â`¯BbÅŠ•ØÇ‘y¬©£mê„Æö¬°ˆð0<,°PÿÂ<1ËÜ«¯;ö8Ñ]¾)y]˜`6éP>ô m´Z2V“()t’Ka~kfMáÎÜšlú”ÊyBÌôÊ+O-ÅÔ{ëõ2Õ  AÁ½DЊ¾ˆ´ß¿pcå¶~sÓhÛþÚ¦}ûÝ0à„VÆ"n\Úá#.²ˆ/2–ªÇ†›¬¶!¼Ð‘Ìô<;OE!ÅVÛ=MY>E+nv¡¤qDk…–=tíÕY·‚KOKÍ]N”¨y›éÚGM>¨—‹ ¹<õž0Bè#†øiÁ€b¥ïõX]O÷ Ù#è÷øu/>݇ŸïâH†–úÝ·á vú!ã­Úï銤}ÊÿxŒ’Ù"(±‚@@f”ç’syØt! @Œœì4!+(‚“BàBKKU’ªu/%D[1áÎL¢†Âíøà$×ÏOð1†â¥y^¢ Ÿ¤Ó+l$L ^øÅ(ŠøU®2–P„b¾8K·Y/–áS_ ´„+å5ö¨€I?pҔ挽t)_\¸˜’h˜„Û_âG±Ãf"*øõQÀŠpîV:ºJlSíôM ]"—,À¦cëîBuÎNH¢¢$?zK’û\á|ú< ŒBöÿ‰€T´ \ÓTÁÐ Ü ÈÀG*~Šr4PÕ—*éö6Âæë†¨¨F‘¨R+ Ĥ(EÍe-«Kš¾ÔoÃäËàNƒˆ™‘Œ‹ßN50ÚÕ>« @DbÖ[}Ä6Ÿ“Ç6›z›ÞÌ®„ Žœ€sA Ƶ8‹\$X)Ö9—®fM!Z¯³ X²\À‡0²+„VÈnNuµkBó =CD¢£¨2Q Š"–Šu›i R÷b†pìbÓù£í÷¤*½l>€R”ªT¥*p†qàcJÁŒ ‡‚éaÓž‚Q~;-c‰$L"1"5ÕÔU¯v³Ò&©³¹™ÿ!·ôá4×%bmátÜ®"É7"P.ss‡B}> …:àµzaÛ¥î±èµ‚Ƈ\©À¤÷ô"ÃÈHE ‹Ø-—OËø},˜ó¦¯0C¾!µ?Œ–fÿx¥0j Œàþ¹ŒðJç¬à(ØBŒøl ~9Z7 3´†­ æQèÑ>XÁ1ÈÈ÷„z´  | =Xv 0ж!™‡@HV0-©iÇbÉœ–å$¥xõ!.@„Rhgß'\K~îÓÀcÝŸd·×zìùݨ ãBàÊæQ‚†‚ Uö0°Œû‚ÙÖæÆ<æüØWPÝó—¿ÿÝm·| Íkp*Pt§›ÝpðºL`ßù¤õ¦óRÚg{8¸Ñü´‰YS ZÂa´ÁGFÌC X@l•ÝÛtä4,‹­X‘Ñ12ÉR]˜˜;ÖƒÖ®6È/Fˆc©jGŸ8áqt}ç;òt5¬Qw蚨 +€ ŽP‚ $ ©¨…/’^‹ÁNûÚN:Ô³òôý`›Ú×–ºµåî|´[ëòF7Ø¿`“]Þ@éÙ÷[ ì7ßùþÀòÝá~C˜ßuïs òŽpF«àÁŒfàýà˜}`xRD ð‚ìŠáœ«H1b$¨Š|IrZæU÷3ÿ°Æõ«Lõ<_ROçòŽw5ÄIœjHCòȪDf"`OàÚºô¸Ç^æ $$ Ùµ@ú2–Ž$¢N—€ñ‹ük/?ë͇úµ“õ¥»úÖ¿¾õÝ-ö²—ÝìÛW{‡íÁö¹žßN¸Á aƒÏcïëgx£c6X l•‹:‚Œ°ò ‘¼!1ÇùËEÈ‘ÐUmí`P,לØ™ìŽË]‚yhLyX€¬Y‘O©q‡*À–­¸Ñ ï%/üÀß@ ¾à BO òÍ` Ö  ê`^@ôäà"_ºEõaŸ !Š]º]ºÙÿ €±ÝÂÝÚñŸ‘_¿ñ›Ý=ZúÙßuá<^ÌÀ_Ì@"¨ "˜ÍšœáH<ÞEà ®(Çè¨XTYÞÔ°œXUɉ‘Ð<íLÓÜ“$}ËMÁM\àL¤‹f4°ùÄuÀDME³Èà ” +¸Âô ]Ò¥B ¾`Ü(®ˆ"ܱ]Ü"ÜIÀ\À)‚âÚA™€Ù`ñÕ¢ñUŸòÝbó ¡õñbõ¹b !0 ١"ÜÁ]ùž2Þû1\ AØà1cà}!5ÊŒ!üD+üh †ÀPUÄEèFDˆš<\Yy ']PC$àA˜NÎLH•LhGYåS qÿ£ìÉD>"bvi—êñLpëh@Àd=ÔC$@*Ò%€+„"àMÀD†¢E^äE2BFbäEÖb‚4ô=.aæ`öñ¢/îà(¢b*^*#4J#4>ÚŸ= Š¡ã1ÂHp#}ÙTPÀÂiÎþcF,’КŽ !""^`æÍ‰ ´Î<$ð@Bfbï9¤/Ô Ü\2Â-”À2*#EÞ%EN¤Ffd]Þ%#``†dÖE_ñaIî I²""_Ú™"GÖå2æ¥NLæMÂÃD°Y@¯µPÆÿ̰œ€É<äÃP8Dí€ ×$ ™ì\<ÎÓ²8eí¸ã±¬ÄkB×9Þ#ÆI>Ê mep޲‡@–TlAH@=¸BB*dZ¢×Z‚€@ Ìå-Ä `'à‘ÀXVæ^j¤xZfeÞ#€\ÞÂ<ÜBžµa]VÜ¢-Ö"ôÉç-Vßòá§Iö`€Áb*Zdxú%EVf܉§€Öee~ád$"ô#0°° hŽÌÃÐL„L…“ n¾Ä¶æo×pµ#癎QŒU²ZáSm¥wüæ>f¥x(Ë—ÌÉqGL@¸‚YÁYBç&&]ð%€[ºL ¼L $i’*ÿ›w¾%xž§\žg’Îå”*©•*)`R`Šä–FŸ ’d Æb(ž¢Z樚.(CUæ“NcfJÀ6C3ø‚0PÂh„ÐÉnÁ5P‚ì(—v *9EȪB¸#m¶ã} ERéA*oÞ„êÉž¥'¹D@ -  ŽzcYúès&¤&:ä2L§+\§Ëä’^i ¼åyR$z¢'#¸ê‘º ®â*¶QÝ~h)`&Ÿ}ΧÓÉç Â`ºÁ"(^@Ü­€¨xè³.ã›Nk–Áƒ>C3d—´ÂFf‰>ć*ÈN“ÐãvhGvÌÓJˆÕUq^m–sî¦MüÿÄ‹>M>Ê^Ui*"l!m=¤©r^@Öƒ&@&¦  ^@ äžÐ±ª•žç-¸e¬šç[Zi®B쪺̵QÖM]} ¦ô•la&áõ­$GJäè™ú%eB&H€4Ã3`+0Ô‚ˆ€xkOI„*\4¬¹âNË=Mº®ëœ Ä¢‚U£šNB´æÔ´(Z¡ Õæ«ï<\pè=Àa‘D„Ž–e=˜å¨BçÑý'"äêv ]’¶ê«²ç¬NzæåuZ)«²À@¬<A`JÕ‰l—né}kId,‚¢(²$Ë¾ì™Æ¬^J¦2ºiÍÞl Ã+ A·Q‚±ÿ‡~‹¹Î# Íš»r^Tö¡ bÕÄ?^*ÖF€Ö>"ðéDlYòÀí¢%4›ZZY*ÜÂÁ-¯Û*é[ºeÅNÀ-8¯óÂ%\¾mÇîíí~ØWÈ æöviòí ! ë(ÞY™n¤ãÂlúö%´‚ÍÒivµBžÚƒDðÅqì‰äBoq ¡ö ­À/’ °»6jTjë²î·ÀhšÈ\U=Ü`PÐð©7,Ù:gÙìB6¤ ZÀ¥ñÚêò^lÜ=/Eš§ô¾-ÇZ¯ßîêà¾ð°Òçõí  †i±*ë²6n³:®^¨äJë@ƒå6Ã}䂎ÖoOÑÿ%Á DDoE-× ð+¨ºÅ•ÓF•ŽíÕVêLäkpÈn˜,„*0@:me$^¢¨:§¨’j(d³up-©ÐÁí«Z§\–0ôBïó¢°’V/ö:]V. ‡$°¦ó‘$ž®$³®oËF&dꤶÞÜTŽJGЃXD„€èCÊÉSJ<à=áS$*`ÅÕéþkfGÌ)ðwè£.뫸<ðB4IšIDAdÆñs.$(3'žj*ÔÃ\êñuÂ% _ärôF3®²ð{&2a.ö1rɾ ðç˜..:¨€Vrÿ0‚2BÔl3@ÿ°µB"}À”lXF´D|€þÄ9ý‚>äA´’¸˜UW*§œÕŽ‘OÒ·ø¦Ì]ªN\´˜<:•Ô+'\"&f°Ážåïþ.C632€ÀïÛ*©ôJ¯ó*+Üûñôòµ9Ö}y3}Âpb:2B2™’éFÆÝÂQdæh䎧4†D0,b=³"ý‚V׿ƒï ž!=ñ@ûÅ!O£.íé¦ÜB/`ê6MDS-=.€¸ìrE÷rUýòh51ôØósú(Ù@Z¦ð.ì»­Ã%zR³ ++b›ðKߪÞî´ñÝ@9ó´"CŸ Ò0†i:3ëc²³dvÿ¶Ì’!‘ik+ˆ”|ëD Â% PDhD. G„W·ÀVkñWÓ¢îS²&Z¯n[—ïü춵ᕱ—xÅ)zôGcp#ó¨npC/Àï•R)vÆL@vÛô5g3õ²@N ®dì}Z6ž÷Pcd€Æ]–8+̾÷‚ÒÄ3=wmŸêƒˆl+GDè¯CüB. R.lP WÉ•:R*7RÝ'MŽ¥N‹ò²Ìý[󲦢N—ð,+3 صsò®H—-C¯/|pñRi#)vvLc䬦g4¦gi7·µYö¢7Û)«f§³:¯3<§ú2ÿuàd+ô#6–2‰L„DÁ äƒTùnDT%WµvA¸@›èÓ¢®#ÓYËãnf¹øŽÓÀîKhª›û€Fm唥G_"ï2÷àu=s"`»Ât‡0«Þ’2/5ûq5“€ózgç8 wïÈŠ$_6 ..Q¯l(5´RäÂAîx&hAÊJýéCUïéi€€!~Ä)á7¯¢÷qø/:\â8|6¾ó}³e—3ôÜà Zþ«"ãžï#uè÷°xvzA’—鄾!BУ׆ž†„ôZœhÑ¢ÉCƒ„ˆ¢OŸ 7Y!bEH‘9v\áq…ª*S®xõjÌW\Fx¥ÊfÌ”tRŠàÃ'O˜ V 1/¥®xÔkZj=P§°úê­€Hõ5ÿU-°©¼¦B†¬%Øaû¶ ¹$&Ð¥{«î-$‘0dèÆ_Áƒ 6<¸Âß 3–àxñb$‹/,žy‚„ &dî̹sè ŒD“îlšÑÒ«WO€À‚„,¬žA…»žÐàðʼnô¢äË—±äÆ ­hNR_É“ÓYª|µÂÇu™1WØì>S¦O?iÒ\@‘A ,e~Uªò]Õb¿^­ ôï„Zô`@X«„#Ž`AAKâÁ¹ø²‹´ 9 à 5”ÀÈ3ä1A¬àÆ*ó¬‚.àL³Í>3-„ÓBCm´Qc„‘?€ ÿ„, „‚Bh¸"‡³‡ ‚è!(Œ8"éI‘@á¢+ %XÒN'™Æ»Î»žzªÉVhEŸÖSÊ€¦ššJª¨àœÏ€úàsÅN;£ê!0•z\‘ë¹ Ï:]9T¹fô ‘¿"TÃJÑÃÆ*hÌÊ84QÓ .p±E3µ´m\uµ×\û‘(Y!ÉÜèqÂHÝZ0·|’´è¸+“«’تÄHXå¦KIU¸¼nÖœÀœ '˜‚êÎLô$à=¥x`Ê*§ä„ïÍ8ë[4ÑE­šªÿ¼ªå)0ÞzAˆ H‰A%/I-X°Äÿ2È*û«2OITñƒ‡GUÑEÐDSMU[c­Æc‹€& Êu!…Ž,.Ÿ(– ¡I„mnÊ(àÙšõAD9\rÉ—P%&œBêrV¡Oh¢B2DMÚc ݪ¤Î6¥^wÑ 8 Eñ„ÏÝ{k¥–³ÎòåO´¬wˆ~´.C(%˜îÄ S,aM9|³R5ã¬T‹?\FY]´y$X’V"y¸]'rÂ8_—¤<£F’Ró_Á(—‚EV9•š}6[ð° ¼€^Aé‚\¯=oy°zݪ£ªïêÖåÚ´®N;ØÀ°jñ…yæ—_­Tð·ÿí Þ¦{Â̱Iü¾áRI”àÄ¿'FUpÃßGÎB€•&ˇSr`«(Š&©tN•æ¶4–¿HÓ¯ŒC:µä&)! Qh24ŸmÇhJ[ôA»¤° \¹óTÎ5•úÜîàZ‚¼®}KPðÉO~ü“€¯†¾x^-øÓÂý€ _~‘Ûç–½Â$&2#êd2Õ¡ÊDŒ1—ñ ‹Pu*Τo4cŽB£ èƒ&„ÜBxå{T.etFªD%4ËXÎA2^‰ñŒ¦ƒÝuºïD KçÙÎÐZÐÎ[]³J×´¶5¬á ‘‹ áÖ¶<ß½GO÷ÿY¡ø“¼ÊP@_é ]ˆ²¸¢‡>$Øb æ°ð™2EG\щ˜øÄÐXÌb4Z gV#*æÈ°»’è—+{¨ eú(N.š„—ÓeÄ¢F¢0‡HdIp ÉuT‘\v;Ëæ‰BìèìI !ÉiFÒk¼+¡ÙùȪpO]<•‡Iú‚,òJY„6ˆ²Rã^¦B”7PEÌS«„ØŠDE1'žªFÍÆl›Ü`·Y’­†£ÞLî‹ÅiþˆYR“Ó"QˆBAZ hä"ÑyŽu|& .Ð Äæ n@ ˆsœ„4ÀðÎ)BAFmŽ4¤ÿž¢"ÉIve,/¼ç ÅÃ~úbX­`þ®”0@< 3S~ ‰‘QhC/F8W®ÊFbáFD,BBRA‚3ä W¼Ú•Tš?•¶À Ï|H’rñ«ùKY,Ù™µ™MnŽj Â8ÛDÎBr‘K5g1Tß­ ž-¤gX¢*–¶±mÞ2–Vì}·‘ÉÔd“"ÊH@E~ëL©š±T‘c.ªeNCš»®@dïÃH‘LV2Å^W"‰bC@Ø’º e´’0 RÊÇ› Õ{YõŠŒ=ëäf yZF¶S!,!J{¬Ø§?ZéŠ<÷ÿ –Gõ…¬mm?i{Úv¬BX¦P *P™ªT£Râ†+–*ÄQ¹©‘ÀnpD؆ÁqcBþ œ,á!Á®bPÒ_¸ 9U2–•\–_V#el‰eÛ[ä "³ÚìP×¥5'û®ël¤J»Î èËûB ·2`}~YŸdKU|I¬vÍ> ‡:µ©‚ªU· KepE¥Dâ¾òÎ…KîáöEžæ5!Éu â7AM¸Ç¢}(ú!'ýŤý×,•,#`DotŒÜi‘œé@8åKμ`k]óÝ”EØÈþ¶:?Z°¬±\k[WÌbó®Í\ÛÿÂxUÍûž„ÉJ¢¿pè”h%ŸeȇÖÌ\€•mu¥i’kKæÎr3w¥@>F¼€ÐcÅóðè‹ÝèEßÒ×%ixscc©BK)ÙˆFƨ:逞 H¼‰3 † œôêªS}Úß-r´Œ¬~ô³BIoOíb¡jÁ|`³ö’¾Vs†€¸½ÊðvˆßÛ›…ª™À1”¸o%œr_Ä\Z2w3‹+ñâV0è†4äK£ÍtËøº& »ý÷•(S.ˈó­ï¢|ZtÚ ÖS_F†3չ˺ r®Ý± ž?žj½æ²\üµõô5þÂöc¨ãp¾€áŒÖ™ÿ\3&_k‹žÈ÷‹™F}p…Õ ‘™};Å7_‚¢9àsŸßã™!hä¹›?}4I€ÎIã/аa¹ŒJw™²œþ‘Ï ÉGy’—¼5T‡Ö*êJW %(†÷+Ô=Ù)©ë¯$o×aaž!ôõöK±ùØwÛ)Çç˜!Ñäž•øbN1¿wø4³"DYÔSPÄ™'@ôÎnu¶»’ï.I•.@!3§$J·Ù•Jÿ¤Ï!bà¤/}¹¶Èf=Rk8¨ër/ìÆ®]ÈîË~ï÷€Á|a0ÜØ6Î{¼gî¾ | ¸<b”¨|œí‰ }Rƒû2&æ ZVÿÂ!mñÌO±ˆcW¶KòKýlL¦6B¼’#é’Îf4ÇÈt$p&Ô>J`õ®ÿI¿BHk‰xlk<ˆ© 0+Àfâ0ÌðìZ«íŒ¯0>…Í8D4ð1î®1ƒ Åg•Ä­G‰Þ 4hI¢ êbá&(¯”ÄÅnΙ$±"±ë!K¥ŠIÜO¦ÔÈ?g¼6âÄ0ëÓ df(ÿôá”0à°NxØÉ‘ŒJQ°öÂeá  qo“üã©Ü%ª0ªÜ. ‰/ eq”@D{CˆpñØÚŒ 1DJDbƧD”(ï¤ûêð•DCÃ:ƒøöPg"N€#gÆÿ"oò*˜lÆŒ8B#’#:n&gŽŒ'hJpF Õ^ Õ@q‘‚ >¬‡ö ð¿&ÃN’öe yañ÷jqmQ”>…ƒC2?eî$ ‘mÙJD"¡Í¡m¡ØŠ•ûî¬E$@û(MÂmWþÊdv»Ô±¸ F'™v}09žîÄÒÑô$ñþnæ1FõHÈŸ¿FQP®ðNò ÷(© ½ð…d gÑ)!lä@ÂC!ò Ï =%3LdÙ2ƒ3Þ°GEÃ4’pþæ3äFvÒÜ ­¯RÌ Lò™âVkWRФlF€ºÑó¾1:ŒP9>ÿ5çÄn†0õA=J€Â)œÕà±ÿ–ì\"©©ô1 áÃ©Š²Ç®…þ‘ŸÄ‚í>“?SÝŽ }häÚÌS:e!ç®!’|ÒpW$"묗qp>b\ ¸2cb·šZ`¥Ì+ýð'Ž£˜hy0¿QŸ“&ÑÑ/k&=Df^;K€1M˨¸&öð±.`2³ð>`<ïã2J=Áæ('®’^1ÁBS4‰o>Ű`?Ù@ä!Gäî–­¿2¸èì5=Ã,?Ã|Täîˆ/£¾mÅ4@ÜÖ²-‹„—p%ý,Xjfôò&û2g>çf@YŽ#pó”PAÜ1©ÿ¤L€’‰ÒÒÿñµ@ó3‘€G¥ò0dq ’? 25«Y“+ñ?ÁçDž´;C¡ô|"fóÁ B!ÇB‰³ Òo¥€LCõÁ“…#ŒÐf$ÀÞŒÃDßæA^àTtEÛ‰x¼N’òÔá$=%ÎOm43“‡Ë6s,¾Dsx4iÑ>y± 2R?¥ù„‘ AÚ^³Ù M"…«•¨TE€KöP-ÔbByee–är"L‹Y”“C9fÒq¼jFJ´D…7 â:åaNƒ§´ªìÿŽŠëÐsO±ð2uO³,ž¶pói3Ïî ÿ‰oQé34}”0µ)‰tîzÑ0€ô[¹g51õ5;µ jJcNúp“7‹B&ÂT‹ì¡"ŠIØttHGX4'ÃÑóDÔØÔ±B GNSt¿VÔài<ñ£Fÿ´Fit’,À²lZqíPç Ëb>)`HU>’[)\cH†{¤’ u1 ñ\eS]!æo4£aâ°7/BôH”$ ~‰|¥r`•öL%qþ2`Gf-çÁiK䎀ʄµÊ|‡ˆç[ð”('³FÙS+Z!_äiZé©c£•SA4•m}Td•[Ió0RÖèVC€Ô0Øl\É0I;åeÿ%RSUi¡tS·7=2Ô|eNÀi£Hrƒ BªDQFW÷µC­d¼DTMk xÕ`Áí(ÞT¤ÖùkX[MQî”öþ?,Óu[WFUˆÖ ¸¢âÐ,\ëÏ.QÝV[ÙdumŸd­U0JÓRè6eñV0ÔeÉÇ\Ï•—Eâp•òNTõ+à(ÜTl"d¯|Œr5mtò2Yp¦0 #> tx5G²ôM¶L÷†µ¿)‘Ö…š‚O!öa¿PŸŠÖæåËÄv¿íõ+€×éó3¯µG³•íR¶x‰O*íVC4R A!+U"G¸Sê2d³fÿoVTã­Ó VŒB#÷8EçÞî:='i‘%Wqó}~%~ˆ¯@à~ù+xÒIö¦ð¿nTìd·Oc÷um’h÷+âÅÀÊŒ¸muQõ…miqQ%xHËØíR–ƒ ƒƒ™wyù³ƒU3ù\3zÿóî 2”­1ì®{”MnfFdp3 Dñ6 I9s¡€Ä4‡“v‡{XH&@Mèa~ç1¥vj«¬¿”8]®ÂMRËka÷aqï21Öbé¥,r=ֻ؋ƒWdƒeÿbBVyÃé–Í48R?XoaÖ—_6Éç ÛÐS4• õø>Ç>€0­DkEhÁhMÿyþÔ´‡¯ yæ÷JÀ™^À’ Àt‘Ø;I (ÕEk§â)–viôxœ8÷ n25³ŠÍí\KwÇ¢w[ÙwÖ¯µnÚnñHÛ&– £ Õx?ôyýö]˜#r|š/Ec¡*úRðÈäÇöª8Ü·ršd_Ùš‚Wµ9ˆŸVØBj @œMׄ6KÓùvÞI()“áX á™pËä©O´˜Ìr,¬ŒayŸ•Z–C*‘`H3X Ãn‘¯0ðV?•´!•´ù~9 ëø\›M¢ƒQ¬ZO¯(Ô’U{å8¥9±šAGBçWxÀ ˆ©ñZ 1ÿ-yœù‹ ½°)˜*§#ê1S 3•yͨÁƒEÓwéÓŒ›ºŒ1Û!U3³{±!ÅU„Yó Æ*Ù°3˜4¬ÿ3¢Aå?CµI}Y†É¢^¥±^#×Ó‘I‘í-M ó}=7tC÷i[êú:œÇy¦Uô´µ¾¥° ð°µ”+Óº:+ÊΞ¸Ì&û‹ÕG3¸wÅØ©ÿâ©=ø*[S´ëø·×oKX,Ÿ"§T¢-u"ÿÖ˜I»1Hµ9äûÍ…WŒ­'÷8C§± 9Ò¤sÙcæ7ˆ]jAÀXùKœ,ÜJ@¿J«kœ›Éº¦ó„]þ«ºóñáÿ¨Û±•2øô™–=4•·‚§H3PI‘€SݸDh÷’5ã¿,l,î+º©;½£5+ÀÆKÞíOéRžS'æ|˜ñTZ¾6ÿ[^JÑfC5+k]í¸„™ü«qGöÝ™š¶i¥tWzØéÃÁZ9´Ç\[Ê÷e Üê@^cމ—˜þÆŸÁVàŒ!h ›nƹfrÒù™yDÁixÁC‚ÒHS itÛÿG¼Z(JÃ-º"p0>ésÊÝØœ–¦4A(AÀé<Ö}Z$xáqªyçð€YU®—ƒZhÉe[G8`«}/Üú_c’ Xaƒ ;ldnN¦¬pj6‹5ˆ²ƒ›M›Zµ«ÔÚC]ÄC†8‘F"rô’ˆ9ï,¢G¶ñHе¡ŒC³tcH:úHQã5§ŒXmvò8 Ö£ŽuÏ©æ1%ë­µV«îÙJëÃçJ×­/Œ9^}Q&Çza\òf!KÖ Ê °ì2j§Y¨§žƒ²V£‡’Sôq+úŒ9G"¶$ÑKDï#P3MJ¯L:ÕW«Nõÿ«{ª•¨+ö¿l0•«>pÄÃð‰…ë—o·•+Ý·â}Ÿ¯{ë­1² Rxgo:{òÊ,Rmâ×·&ÓC²kÜk¯=þè4Y*ôÓ»-WcLF¥[ºë¬¯ŽÔü@æ›oR,”°U¨NÖN¶² Š`sU{ÞÃ¥[¹Mn·¢• ·»á­L“O-\ar†Í¡ètòC]o4%¿#Öo’’,â83ÿ KªÔ’Iœ;ÓéG ´Â%¨©;›„¤° •ìÉðøž¸1pK[z@ð|Ëäù§‚a"#Aù£YYƒYBa5pY1+´8eÆìŽ|"«Y½w‘Ê„5é™6Q©]ä”ÔBRµp櫤HQ)85YN”À’ƒÕ ’(“t>F¦­hç àD¯mÍk¡*X«ZE—†y‰Ÿõ'Á8±¼àRLqjÇ2f,„&èªÁ¬jjëÁ!ÑèB ©ÐYÅz‘>᤬ Á#4 4Þ5‰V#A9Áy Ö…Tußì«aÿ N¤œtœ5Å×a¤‘!\ C(0„ÿ·„;_Ái\Ì’6¶< ¨_úl?¼‰Õeb½ÒK}t9,4E•1TŒ¡·ZθöX©¥‘Mt²¡«Ð@H¶(ª-™ Ò¬iÍA„áŒd¤xµ«tK¶’$î&RòN}9Há4§`;ØÃ» é ð– Œ“ü“ $ Oö$laþl¥PØÏ¶8Lü„ òò—rLcýLû«ÚÇpÆA B`ff%†+ù‰ølR‘BV8ÃjÖpnt†¢©us qˆE|É<Óuˆ•ÌsM£ûM•Ž4‰)m©D\¡Îî à}_P‡@ *Øyï©6%ÿ³ýQqåÞZJðn€ÉTù†eTû·—&YƒBvPÆÌ„[>¡ˆsMîfz¦›7÷³ ¸BsÁE @rlÜÂj…qMýì;3Ätñ´3ym¿¦´¹"åÔu+ìŠ (úª¨Ž_`—ÌÒ>.É ¬dÔ+b $xËßû4ÉGã'ØÔ½ù7ªÒà;Ø,7®ñµñOP®}+:ºÖè†Åár¥(ÙÆ –çh—`"öŸCž”¤\Ę1‹‰ÛRBOdÿQ´¢ëS¼®BGIŠ'p„µœçKóF4iùYú}Éq‹Ë,çöÅ\ÙwyÿDzbtV_†A á¥ʑ\‡$Ç!Ù5ÕpÐiœÃŽä(êŒ[Éä.{å5ݟݯs‚‘ç½yÊÉk:mÀã™°)gi]Ý’DK Ü6çA} !ð J/I7ô‚{>àŽo‹+†NÃRb|‰%ñŽÌϨãEWÁ:Œš®<ðæírªÓ{Vc$ƒ¬b!7Mcû›OäûàkŠÄÇ>lr±ìeÞÙ~9ɯ£÷º›|ïv¶6tYªÜD‰[»é.?7Ç_²g!!C@ •p€¸¯ÈšãxôóÙÕ>«ÌÆ xp;žRYߊQ Ç_’AV÷u”ñj´çÿ1Å[%|o:Øvqu \tEWËf]œ¢|Óv %0m÷|϶?yww—‚{m"Hmó0‚rDuWê´6×]édõX Nò†òàÀq6<@õa9Hôenö<ø×E Ô6÷ÁOb€Ââzüµ°wu˜u4`‘ဋÑ<ÃaqDø|jDqU\ÄׯG|}v ÇõwÎvwÎ})è‡|Èw'rŒNCDh4¸Ûgs®0AoA®®PWthQÕR—µyP·2­pÈ37XhvK¸Ò0ùWKª÷dùå_`Ø…®wehªvÿU'C{â€|óÙ4|?45pø†rE5ÖD…¦lˆ|%¶Œåt\–‚×r&§‚~hר‚'—bøƒøb5ˆ8<Ž7hsÛ•cxó(oQ’ð!`Ð]õ„­àxe¢XÈø' ä6[´zo“<­8 Å¢j‹Øz|ƒ,H8 R Èâ<6"vi8ŒjȆlt¥lGt‰Iwˆmx‡ÔUxÖfr϶w~‡>v^“׈gúÒÜ$?ˆ§<Sà¥]8æ;‰ og‘%^fÃ*A@sœç]7†cü¸+VH1ÁszHöx÷¡ou1ùz]Èÿ_y€V–²8 ¸Ø&Y`>cvpeM'WløHX‡ÛæŒuH—Ðxƒµ’+É‚u‡~èc[ƒÖØw)bݨWÙ⨈ݵ]l76xñ¡PylAs¹ò‰Ý•¥øJwt}PY„TÉYSÙü‘\hA Y‹f)®…"‚âV¿X52Dh]HD|á”\(åʆœØg„%x!xg5…‚Õè‡2™‚0™‚Љ6IˆÜøH4()Ý%GÚõ%Ž8Ú*趈zŸP|‘dV¹™¤Š®R'eR˜+­©¥õº_z–mB‘ûUwD(7Äa×dWª‘%æ¦J¡{Ʀ ÛŒ¨R"ˆ‡z˜¬Ö¸§×±¬~Hix§±+ú’˜H‘~2e£W­xc„›ùázòˆñgsö%zn…]„ŠLÚWIK…&{aŸ¤¤ –³›`xp¯µjI`ýê ñ-—'Œ‡U|ˆnZIXK—wxœ˜”ÿ— (+¹‡Õ9'j+$xˆy'­tŒu­ëho 4ž\B0©!¤kA®ÝňŒ_BZÈSTSÈŸ $TYDjc´´öF“&FkU ò_e(kl¡nÆvǦ†ÇvY{¥{µuˆÌ8wÊȵ% |.‚.H¢ “„©¬Z3˜×èwl £@ÒUrĈqp‘žRò¦J nµÊ YMyŽw½hn‡*yôj D_ª®7KKK·%Ig_¬9•4Ãå P­¹Aaxue©È“‘¹±[IÓ¹Åz°iJ—W’VÛÎ{vIˆm#éºN\À+jÀ¬À±\;þ"O÷˰ “ Æ8Jû‡6lÁ*ìI”™5oá¨íñ¼‚ãhíEt´27¦i½¦ÇÄ3APv1¬™Œ(7-ÄjxƘRéüØø«ÄøqƱ!:Å5EÅÔØ§&j¢¶ËÀ[SJ¡]; bB±nÅû¤šèÂ<¤›' ˜å]à…cÒûE¹¼ÿÌóÁÛyíÛè:• .¯`D¾åkš€ízJ…_ ‹ÜÌ€ü*Ï1ÄQ{µ¨¿£›°V+Ä! ¬rWm±;Ê&¨ÔÖÉÞ(º5îMO7^J½s'0­±ŽOªyóæ¨êÉßÌÛ*lñ¼Œ&&û¡% ᥧàOÞÛû–®!ýÓY­åÊ&ÿ%,æ `˜ ºèB9âpõC7MÄì¼ØxÉâÊw w8ç^æç€YÊúL¶gûÏ@€~ã^ãr) äg J–)ªsãßÿ]Ö0à*½+¢Y7?[•SåûÖ€ÜàãûÌU*Ü4,´Å©3¼Ó±¸¯“ÑÃ7ÿ.¾'ºX«Ó¤Ë†&~°ÉÙã¤|ÐÈry.¶,㩜ÀRýÏ¡McS;WÍÂ6ûª9öãu±0±ý<`­§ÒKÎ@[7 >Kø7ܨH+£VÍr-êx}7­yF[æ&ý×âk î›´ŒAæ<0e4 •Ók.’ׯHb©‹¦sç:ƒ.XN£üâ{ž¬Ãž»ƒ d”ìèÉ6)  qÚCÊË·]Ñšeß ý‰ó™ßç_¡§®¥Xšßþàèºîþ@P&á'mFøµ×âë©„Œá²&š ‹’AïÒoÅv(î†kŠ—¨«ŒÄÀvNÞ o‚lÅY¬5®ìÏ/ÿ0d£ã×á°ŽE•³/{Ú9©rž+7¦xׯ­®GÇiåþd1Ÿ<­I×5Ÿ÷ ¦¶óöa&_ž¯ü¥jÄ…‡Ñ-±žC!ŽÝÖ=É@t¡_ûH›Œm#†Ôx.õÂÞçË/èɾÅ%ð†ðÕ Ó0lჷm™`±Á쉷¢Òò–ß-lštÓ¤çdyìåëàe‚ÍëÞš\N€C›7pfYZ:‹»UâkèõWAŒÄMùÄ*§„åýHMÀ}ØX±æ¿ÔMBOS"ú\ß;µ,¶rYªÏ*/Э ÃègûF0®AaÈ AxðpàÿÀÀ!®  âàÀÄ HÄX1aB -Nœä€H‘ ùäÅ#€ùæL˜õbÒœ¸Q¢z6iάçªgOž<}ڬǣ¨ &T¸ðá„&@°š5+#«·¬’àʵ믌Àž5›–„µónÍkÖm F%n•À›Wo^,JôX0 y,–‘wäȽ#îhL@òäÅGX@0áEÇ=rÆP"Èæ2äÈa$Ç>#F2hå*!WA08pÅDŠ,/n¼¨#G·%öîòe”¼Yo¹ü'MŸþü½ræËê3…öä´¨Ò¢6/H8?uªVÿöZIL ÿ+ ¬\½–E áÖÚ··ô3šË,ºH°‹®õ:/¿ëË2 +ìˆÃsl2 %ÃÀ1Å‘‚ŽLó¬#¢„ÍLK­5÷Á€!Û^¸! `¤À&’†ËGn3¤ˆ¢›è&™ÐÈ·•Hšî§ê®‹)HŽ»i:¤Ä(ëxB/³¨¢š`=«ês,²Ædë=üøƒ­¸ØbD®·â ,»æ)NK8ÁÁÓ³0Æ(Œl²Cƺ,ƒÎ< QÄ‚8"[[ME(p¥£ .°í¶z†ØÈœ~Ó ¸R{t‰%•^zá$™J*õ9á\J&òªën;ÿ'k-/¼*§sˆ)¨º´ÊËö®²*,°²òê=³Æäаô›-ÿÞt .»ê2p¯:ýÊSOqûŠP±ÄîyLPB -².IS”³Òèè1Pq5}Øç †èô…ÝŒãaTÒ¨T…7òÈ"’H•¨$”fbŽHŸóM¤$µÉ!›†Ô&W‚Ì5W%gJO‚ª2;¶å±–…€¾1Ï<Ë¿5çisÚ:÷Ó–‘»ö«“¯ÿ—0À„PBÅ tP§Q#àÉ^¸ê 2P”^­ç%1Ò'm-ƒ†¸àz!ªè6.8â…߆.ÕŠ|[5JåÜ~›d\Ë»²cì‚Ô¸I™LN’Iÿ˜ÊRª-]Ë¿´ª}üq5ÝÊ9-pÞÛ»|¾ÜÛ¼æYP\ÄC¬2ÄÎýS]ÔVwš€Ð&°mëxµÎAìŽ( l~]+˜‡xè6ƒ"zÛ8¸Ci8Œ4~ub‘†:+§ä§'úéy' §®VC˜’ª)©×*¾f×zÏYõÝÊﭜ᪠­ü¹.;ñü‹Î>Kg¡t¦ÿ¯ d•uR ‚f@SšÙ•&G8Q¾T6 ¬Í¦)6“Áë1ŒGʼnž¨$"Œ GTC‚Uô€38£%)H!ÏHšd‘“ÜÍI{+J­@Côq™©Š±’5–gEËrW±\´Êÿ¤ý° .ÙêœÏæâ¹…‹A¥³Ì¹–¶E¦MP[jV‡@ 8‹ZT¼®ö@H=@waæ%0 ÎH)iá‰Ó0à¬jU™t*æ<”@O üH¨d”ððMpÛsš£^éР"aD îBdXŒØ&h¥Éˆûi(w¹þÀ¯@$èÏ ‹Lãbe%@É Fªa j0ÀWL kZËš¼ðfR¬Áš+dÔðÀCÕ„¤ˆŠ#"ÎlU"LÈÜþ8¶µd’91ÞÉ¡øê(>9N«&bœ»µ ;«Év&6‘¬“›ì$øÎC,ÿ‚nE>W¡O«…¬i%fÿñÙ ä&ºÜå~z×ù—ËÇè²1ŠëVóKÕ` œMÕ•Ò'‚”*i$`ÓdÀi£Í=²µ8 §=5 c‘–Ð$B*äŽò¸T(µÐù„grœçáSp2±jL*„¬`þÌä÷¾÷C-rkJK}Î9µÊ%.ÙÒ\€ê´¼$hZlŒbx)ÀÈDÆ—a, HôÉN¥™É<鉾֚äÔXÓ§¶¹5ŸúÔ°‰$êM‡úUQŸ%!Õg<•e(.Ì¡r 9UV9iH”ŒÒKVr¯úS“úB@ÇúC/™ÿï*la [×2ܳÔé,O|Kâ´Îykh‚±Ì-—–¡¾î•—MQnó5„4žQéì®v„µÑTR“ª ˜FƒL™hôŒN¦*_ú’ÊHûlô˜Ê#ãÉð´Cq¤l¥š°œèsTX=jÅ|ÔÏL†Uë&Åú½OjÅ?ðnã“ÖáÆ gósS,ë²9¼d £yªe`ü—× ](CR{Z€µG137eãi逫ÜΓê©%UÓÅH™ð…ïm‚3UU#$óžcœtò—ž5ù/jUkUh'£Ò•T}DdúØíƒ1Üöpc­0|öÜá"±‰ÿö¨~pÆJú±Ï@°ì–çä? ¤K2RCtÔµ.‘ ö¢yCpŒFnªk%ؽðåšÔ< J‘JÇ6i•"ÙԪŚl_S Òb£ò6eMÃ…W¥H6òå4)ÌGÚ¡&wË”!0Ź}ó›!œduØÙæ°*u&źhÄË]Äý æ£ì¢ý4rÆÜÝL5"FÍ+XKàíÌ&)7Â;?nMvLøžš^¦*AfóÖj9´£Ú£h‰ƒ½ø(ÛAØJHˆÕ»iLbË™-HŽíÉðGÅþ¸›7Î¥6Ñ™ÎÂe“š¤x99Ä· ÿ´ý— Y‘t] Ô¸WW@Öñ\»Lw? *ËV™G€@À¾ø€NWÓkpD‚ï’‰dÒÞo!$xŽˆ„’¢aᣕ¯­»ç“çÈ—ë ùòÁieøõ ‰*ÁÕш("V£{VL¾h“e‰‡ß›\.bVº®4Lbtéº^þ•ç>_ÝIt»â¼ Ê“rŒµ­ Ìj€à¢D]6I±ÿ2›èố"1 ‘«n5Ý(¢<ׯó¨åÙÙ•«JÒ†Ù¡øïA‚N¡ÁÀ(p1ŠŽàÂùÆwþóCðÐc-ªlSƒ;­“ØM%ÐD t?;=7t7_ ãÿ{Ž]‘ªfF£ù¼ÁAE›Ø%™^á}ÔÕŒ 0~¯í‹a[ˆÂ¢·4 '–8¯«=ÊÞ›=ÚK§¸‘’ÔÊ'üš/ù2]s­ŠK•‘(>d8¾äëˆ#`>Ä€Äy°Æ;Áy€yFÀ;G AÁB.¸xl³¨¼à¡9?rQ¼½2  ”±û9{™,Ebƒ0~½dÊ?• ‚!8#z12Kiˆ¬Q‘›½«{½&«¯C.”žJêÓ•ÌÂŽ¸Ù³œÁ´šQˆÁD9>ãSŒÐx{ˆ>\ €pA!P>ÁJ¾åëˆQ`¾Gãmq9º2™›¥+’b4žÿÛ}¹Ä_ú¹Ô¦‚ˆ¨#ã©íJ=à‰ˆÎx‚Ë‚Ô[‰p… ¨‰@@ôBŒžqŠ•Ù"C^aÃ5¤¡03¸s3æ-LDæ[¾e´š=¼‡,4ב‡ €DÄäc<æÃìFjÛ–ù‰¥ä’¥ÃK±Q¼h\4K$ K܇ºÄeâÄßùßQˆSD£R‹ƒ¡ÑЬθ$8/YÂ4:€QÅ‘ ¸D¤Ä:Œ)!¡Â™Š´6„²•Æ«Ú@-µK>C4D8,9$A\°šÑ¹F!àÃð!À€y°šldmäÃCd¾©(ñƒ9ò뜙ÿ£Ð -²"\wäÔ8h£}ŒBƒQ›úK2 ‚ ìþê7ª ßÑÂO¡€@‚ÚPª†ìB‡$¸+;I“`KÕ F4‰„ù›èPöôp»ÆÆ8>ÈàCãcŒãã‡ø€<Ì €I×áCnÁläF„Wò™¼ 1¼ Ç;±«ÄÓ¢ B_zÇÔÓ# Fq€ Hà ‚`BÙᮂEé)WH92‚jJ·Mp…Zœ§²t=³ÌÅ ê=ÞXK!‘*¤ª' TÖʼGŠ›Y±ž˜ ã#€€¾ç‹>;ä‡ øècIÄÌåÇCÄ€ñd>DDÏCúì>ƒÄœ‹‹ê ¢!yHŒI¬BÇ}qÇÚ˜àQ#X7Eq˜BJ»¿©ˆÐœ,Õ z9ˆîJ€VX·‡Ø¯S¸… ΂ Ã00ˆˆN³!ü¢@å´c̸]¹ ‡8€°{蟨€ø“#8Ň~àQPÇ”¸n²ŒÂ¼Ã”,îc“%2÷¤+»²«S¼™\x$©J1‚ ËÉRq£=$£Р<¥˜,zYˆÝ?†h…6‚ÌKž…ÃÅ.ÌE„3’" ¦´‡¸¸æð=»!Ñ້Uy‰ÝdÑ–ˆ's¢‘‰€!ù ÿ,éÿù H°`… *\ÈŸ¾|ü ”(bC†Æ˜ñ¥ nDX€Ñ¸  ‰AØ(a¸ðYhµ€‚¡Í ¡óƒNFèÍcqBžÑó€~ÈÇHé‡óJe1/iÕy&| °ß ›ˆ ¢`Aæ ­ZQX›6… HT˜p!ë nŒåŠoƒ…ˆò+Ï^È &,PŸÃˆ%KŽ@4¢re 7f,osçÁ‹MztÄÓ&\]¢@×ü`þظ¢í‰µ+@Ü=p3ÇØÀW,X°âdñâ”páŠÐª¬|B,¬¥€(ëU¢U‘f?ÁBÞ=£UCÄÿ §ój‰î÷0È+au(V nÈÔkH‚„± Êþˆð#mÚ¾u LÀÈN—!H…K~ÝpP>ØSØb‰F…êSAd”MV™D˜ÀÏFåóg*z¶™b¡•&cFYd@ª¥öš` Ͷl6¢æPŽ ¹F# øP"yÝpÒÑ}TÎdHI7AUwò …ÝPFÝóRÜu'Ïbz‡ˆ‰”NGeȸX |xR>øègZkÁuK %0 Å`^­ôWV}PÁaöTŠ¡†öÄV` R†ˆ#xpŠé³Qg¨r¦jª¡±ªªŒ§•ÿ$$m´âXëc¶YäkU6o•ädI+èY\¸µK#µVX7M0Ï \n¦˜÷!z÷°émÞz{ Byw OÝPÖ6U€§Xcý€Ï(ȃŒŸ „0r^ ÞÇà4xƒŸ8[ÁR(–!¥,U>‚hÙúx0Щ'‚Ö"h.Ž#i­Š¶®:I+c´Q´ë®¿´‚‰­Õ6‚.ÐÊ +°DAÏ#Q } ýTyÜ‘9-z ùUEÔ H{ÇæÓÝR]u¿SM¸mžÛ]›ëIjÒÑ^Læ >Èà2Šgõ÷CX^ù6H€ÄCP ¼`²ðß—VšO×SÜ)¨7Ó¼qÇ©Š'ª òª0  ä`ĹYÑJ61»Qæâ#Ç0 §qÌD@žýlu,ÑÙë %œŒ ú8š{N°¥ì莚|W5¯jÂóÖwŽ7¦§|@,!`ÏU ©¼Ø/Z[ÿõ¸\Àn£ ZÔÒ¨³˜OøXÀ P!öUJbúðá(ƒ³›ñCcÓÇNÅ1ΜH {]%C(Äe´ékø¡2ÌùˆV¨Qmø!‚áÜ :ëY•˜5 à!¸":h;¢|éx»S ÙäÂJ¶0†Þ2J˜Æõ& L@*ÛZOR$`’¯ˆ…-þéO¾ºçCû˜ÏOyÂÙF1 v}À û›a¦}(²b]ä#ãN4Æ3’dýKãHš‰|È€´¹#pr¹†TS!³ ‘§teD,€:›•XB%ØA`ÈÇÏnrN' W›Ö4¼æàž.Þî ÿI4§=ó€šz¶UFT I_±ÉZð¾ðÁK`ͱút–V Mm?ØT…(¸|tÈò‹L!ªx`,Ž)&ãöWFͤj00õMŒ^JGgæê"³‘æyµ ¾T HéŽã‰’3:j¡•ªC t–*Q!a#ã)Ï6ÁwÀ{á ±¦-ïh‹*:a Ž@Ïlm `= s*/é„_hè}äEÑ?hi†W$å0Žz´k¿¦@\8•²”˜­ÇÔ¹ÏÜôÑĦm%Ùk ¦Á·¨YoŠS©‚œEÑ‘OqW†"U¡˜©ªÀCÔ\ˆÏÚÿæswÝñç#_˦®4)@_Zaˆ!ЕöAr»gZJ´‰j1-¯ŒŒòpZJÑ>T±’`¦c…Åbù§ÿ¡Š¥.ê3kzÊÁì€;½œk,ËS^y T‘™ÌÏ" Ú* AÏåotA ¦„@+p’Êuzç-«±I/¸Ç,‰OLZ5LÛºXsÛ´®ŠU‡è4Äødâ’åzo›óä >iï,ú "0®1 T(—…ÉñÄžÕ݈ìïD¦ï©2²Rd>ŽUŽ © ÉäúúHš—‹ò|{JˆäèS“‰ Ïx–ŸþRIÿ•¨À¼ œó*XÉa ºC&yÐ3ÿj¾Ca(ëYá¬Þv†g:Š™y&³RÍì¹À è„‹ÔG>ì2PT|D ð{ûùA.€'Ö 7.#vEú2¤ ¢˜©F­R!“×È‹õÌâ89ʹz§5㬧É+ßÐúGaÀ ¼Ë3ÏòÑ™ÒsÀZ!Ø®=ÁV”î°‡ ¦¤ðÔÃ%ªÙ9¶Ä{°™ðì.] M㺊¿ª2â¸hEø¨#FäD+Z¹£°ÇŸµ ¡|?HÅ(€“·Ù£ŠT´2¨+†«yŒú[©bú÷Ò5:îqµA¬ B£ÈR1#Àªo²¤Ž8‘¤ Q'râƒØÁÿFÄj£B”TÇLÚ™mª:&¤ÌV«ú¼-?5J¨«*+LϹÐÍiÆ£x› ””eE`Kü¤‡ˆ„ÈX¯6Þè-žv„a©k {X—™áþ[&qTº‚O¼Ê0å­“)ÌÞº5ÜÝuÏH‚ˆVˆS9&'±OÜsÊ£òÀJª-tž wSKa Ïz•ÙþÎÁò4—?5¯µg«M9Т›j|@ã7@PSÞ-)EOoÿÐdùƒKßK}›ÖîN8 ú46¥fiKÿ·"d²h˜Œóßc‚ô^;j8Á8­GW3[™g&ùH±VÚ1»Jc†ŽÿQ…vfûD“`=ÕfŽþ¤gZ³•! i^¼Môº%¨Rd§>E'êÜøð=>átŠtJ7(Óa>jòriø`c·Ô0]óQ_7¦?fXеjãpç¥v÷XoGq¼GSÓD} á7à $!@ Ô~¡lGƒ$4pƒlh¦I•.‰‡f¹Ã`g%VP#V•&m¿ÕO¡z¤ôKwD6™Ö‡¤´Lâ61{q0~û¦6­0¸”]X8²B(%dˆ?å•L+r^³FŽå7‚Ï—‚±чk·ÁPbˆ°¡Evƒ3ÑÿV%i±†6TSÑ%îv„M“x«ÅBWõ`A'û„5Û¢uŠzž„,qK'bʱK§9…yN2cÑ æ3uÔƒ ·÷ÿf!ãuZæ)¢“(d.…vf×pÉÇX4ñ{µ¢SÔ‡@©1wrW#Ø%°­ Z5Z!NÕ388%­Ó úÀC %-E¡I% é±sIÁK£IlÂÐîWTU<_Kó%¬ÅçAòƒVbwq³håq W²: cH0ås0M$uµ@/1ñ›–)’"?Ôa1²‚"(|äÕRDæw˜j¸GñÿÅ2W3›ñ“Ò5˜uGN²k !É!”À_ÉÒ @Ã~G%~ÇjQ!PY’Š>PõGŸ¨I –ßfÙ;JXPŸH-Ô‚ffÒ~P È¥ ]!E:¡øðô1§´Ph1=´„ kcÿ18ò¥"؇xF0Å8h„*ƒa^3ILäEdjTظS9F"'M®qˆ\F B%*,HY?(SB ð8äX,‹tïóõ8c nÚA-b.SÓ%'°fh 5]å~öà‰ýèHÚJfÕU_%!aç4ˆ -Ïs%øŠk/ð2bÿØ€—Vc 3)ºáQQ1“^/y*‘9“fT™‹“pü3Ÿè^5²Sö£)’Sч@'Ȧ3=ã)ƒ Ak‘1øCÐA‡è,dCPÅsÄi.¼  &Õ|·Rq‚,×5¾qq&¨™ü ÃÁ”P¢”`A%AJÈR%eF‰DÃHç´–%Ð#š4 '3'tüôØBœsºmК-Oc; ´y>7.%pCíF(â&£Å‹ßYVYðÒ gsi?ú€’’Zñ!%+¤6vÆôŒø9@tˆ™Ìxªȇñ>B#›1!¢Ù}è Q®X…B ‰¾$ù€ü5 ;ZB°ZT‘[ç’4;a¬§·s„Ws5Ý"I+{¢a"I~ºyHqK$º–Fÿ˜œ<¤%b¹‘žVù.}™J#é£ï*!OAG¾ÄW2p"GZdµ —¯19ÇG«ª:qG2)aku7M§#€šò3¹j»^WH Ê–›Su<úgÔ²%\b„ v53Ç&Š-*­eµ;Sñ&>JdògC!VM—¸ Ù¦Šç=õq£>¹ 9=ÂØ ?:  >ºw ¥´!…+DdD™Ç„|’9ª)vuøî%°©ae8B# }<ÅÀ€”Å‚æh¡Oá!’ÒÒ%cïÓ";óÝã<ÿÎUÙ2O¨è·Õ+Ûš´]"Ú!‰\Âóp–I³–¡„f$T&¡®Cî&£oàW§ÔD#yiê|ÄÈÐÎÿf©c•µNÝŽaÝrÈÝoκCÖ8j”âÛ$+mÈâa¬¥ƒÁµ€Øç+лÏÅ”Õá¸ä1ÀÕÖãÙâ4ÊÜ¡˜gÇ+KÕ+Òh™–ôPî!†!€é㾜ô0àh)VºmœëQ&S¸ç¤µønË%oŽ6/®þ£€ýÜž¬QC#ºð\¢Ò×?eç8SìRq®v’á^YFì¯&»£ùŒáó5²É$·I³Œ ¾ÓBß×nßÚ~½yë`‘Íß.[Ĺé›ÿ~îK‘ѱêÎÛåN¢]r²pÊsk³‹ê8!„9>{Ñ(y5©¿†VæLl©ÑAnÌý½Ön‚䛎K6ÿ÷YäQ¸´÷' å®Û%D=ïé—h„ŒßìÿáȤ¾h‰ò—øÎÎæIë6$pn„1|Ôþp¨ºŽ ÿ+Eúù웃2xž9*¸“e üø!BtcÁ D>0š7á y%Þ»G€€‹5¸‡bÅ1†¬ø‘#E‰-Nœh1^ˆ|1õ$¨ÏfL{ô\î\Ùs^Oy%Jd!ʼn¢FOÌcÁâÑA˜ðA‚¡V­"àCÖØ2°aý¸P¡‚½³ò©5[Sà[~âÅãGw®¾¹ùîÎåWÀ®^¾€ëêõ[8^D#*&8Ðñc¸‘%OŽœO eË—ùe~s ¢7Bhè^Ò‰G(ZÒ#GØ!EZüرvÿí%òT®tùÒÞ›úDˆX1Å ÓWß5»°ì¾ÎŽÔ²‚D`R ¡„/§;Bž»c¤ÚNz­E‡# "– wîðÞèéXHälÊõ’wµ‰Ö&´|§—Kk)Ù,±sj;¯óVC¤¥Ö|FéŠh6ÙÄÇ³Ò Ø>Dø¿·°þï@vDw®”.GûÑÌ(M{éíYÞl+aõ‘`´ÏQ[XoŠd|mµŠÏ1Æê/f˜dRƒg‰¾™HŽ`È#?9É{cRÉŽWÖIXÎAÉX`2VT&€'C AZÖÂǵÚ–kŒâHð–œö˜ñÉA=hÿ º 0ð:L¡ £|áëxú‡žÇ<u¨CÉÓÔB„|`!(ÑuX‘RÏ#AT Ž~Ÿô&q£Õ¢€™ ‡dõ#%Hv2}DAI¾z‰â<ªä0¢S‚ݲÓ,)eg¥cc+~f-l=i±û€êHFwéªÚGˆ5®­‹0%ÈLÞ"5 r…’J†ò!C¹°2ÜÐ =„Ø0­@Ä®÷2E{Û#GdT’Û”/:O’¬”C+½/8ÃÉ%l¹È½"—xÅA†S;-Â9à"fÇÄȈÿ ‹%GAV‘’¥¸ÝJãq£™R!´ÿ>c,ˆ0˘vGCÞÇq¡Z üSN>Æ?24”:#S¼|).h‹†(É<~8Ïy”¼ AV€rO ™–¼Ä¢ÔàÈ#%‘Q#‚ÜD§%;iŸo„d™8®HºRÅ l¹ù銗½|…(áìêd+ ’†)$Z‰±!ÈJÖv¦³”dÉ#*¤£@é@3™IuÙ>(`–·\Ð1ÚÓ :È»ÿ Ê/‚)a é—Efµ2pÙg%ñ)C̤ DXÀ&[CO¦h*ŠˆÞZôVT e ÑÙ_ùŒ‚ ~DŠÜ TqŽRQ—ƒ]ImyR”4¥»ÂUíRöß“ÿkeINŸdí Ó*]5ÏT‹5©§EÓ˜F™§¢óœOݼ 5—–°Q‰´Ô”gIÍ`ÊC»•T c¨Ï¯^(~ Ä&qøÉ2¤4E!_ކˆ*ŽHÄ'ÿãXÇ>FÌŒ:NŠ}í+.#w’¾Â–&%nqOº+#ÕÎzÈÁë|³ÎmIf¥‰AL7-3¡©uËÐ&œF`È€¶©}ªS©H»t¨@]3Ô!O{¼°B¯žÉ‹$$'éÛ O’R™W,`³¦u#cU~2J‰}Ï"FLâÆ ûâ÷Á$8ÚÍUä:ÚQîêJ—ôÃ¥aKzRJP!¼2D> SF(:Ìÿdç&º³«dåeBêÂòŒgDðP«PÕ|àr*xytAÔU]p˜©%\» k¿ÌFO iÈRjc^ó–fæ)m¡Ä‡7¹‚ëÁ´* bÊCé†7“@¬J±RŽíWPêu`ðÃ-¥xãswÇ?îåI‰›Øƒ\Q½1‘#~3Æ—ÑM¾ômÈ®r3ÝÀ³\ù –±<Šx2rÑ—}½»©jm]sq¢°ª™q¦lm–Ô IçÍ”m†˜)€³ùáì ·xž$pÙ&‚ÁÏ­¸Þt($nÚ£ÐË•Œ\Å›]»²Î,i™i•n”£ôÓqMjÒ’—ß%CÿʈIP*ùe…Jæ¢I­Mþ Zgm‹81uO Ví_„½à¹k/»{í$VgŸER™™Ô>-ãrFN*Ÿ.¬$‡À…–jwû·Ûæy>OŸ — ·Œ› éÜ$˜ÖÖ‡½;qÈ„iŠ¢¢½§v•.qr¥Š\ÕØÆ¸ì¨a}‹×ŠW,¸KA5Ùd¾ §>)Ünµ€håL@³²­Ÿq]“™äè² ïþ3ÿ«…a¼†M>ÉÆCÏxÎg_rÎôm?|srªï¿)±€ñþxà%ã•ÜZw2"kJ" $pƒ‰Wkã…/Ôck Ž@ãÆ6a×Úo·òó§éé/y•Û_õ’Ç<Ïç?ùÔë<4=œ<À<À˜X ±Í™„Ø¡B 8©s‰œð˜ÅÑ«¬sœÆ"ⳟ;’¹1ïZ>´2Ã:, 2’AÈ dÊœ'Á˜YŠðkÀ½?¯ð»Q8*¦Q°Ç‹¼û;B$LÂ$„þ;=ÔÓ9ÿ{4(=DÀ¼B,@'Â,D=à€>“Ù,ÚK:hˆ¡Žðé’•œÈ ÿ¹yŸÆ™±Ú)>:ô:¯#âûº(‚=,Áå+, ë´ó·´¥8ˆÚ%l¥Ìކø¸1„j±‰KÕA°@¿ÿb*%ìDOüÄ`B& ÅP@pB)T)ì¼)lÅm[E{€‚X„X”EDÅGÛB{p'\EX´‡VÆXTq8«O‚Òø’Ý[˜‰‰FëJpAë™±_Ú®âàÆK)ø«p$)P+Gµ+DôÈä’—©FlP:Ô;4að `¸¸8‘PüÇ#EQ$E„ƒ<È FUFUlH`lÈV„È`ƇdHalÿaÔEŒ¤ (àHåЀŽtÈU„ Ð . ¸…0Ã3Œ‘ˆ²/:µß€¢ŒêÀ!pKëÆn¼7|K)æ+»ðê1 ;¬sDÇ;›ˆÁäXˆdªÁ1…¸­ø0|ÀGd°ÊZ˲ˆ%Åœ?¯¤¿,ȃTZ+Gt,Í 5|1{P8ƒA8Ú¼Dh…> ²phÐÍ}̲ 0‹mSNU”Å´¤EèüPµ$ѹtÎè„H(àN‘äˆLQˆ¬NêLÝNeQîÜÎñÜQÕQýÑåHŒÂ¨‚8FD˜€›¹SjÌyèÈF»«S¥$¢Ë¬Rá°CK»RôÚIãàIM[Á5MçSǨ—z1zð‡PÆÿ1± а€Wh…Á|Ô–kÐʳHÎX|ȵDK?mHEQ¸ÌÑêÔ€½Q¾5Ñ@EÑlÑýPCQÕcxQmÈó$Ôn}T=W­TwýQÁü½Â`òqdÍä Ç)˜ ýœ1.½ÒW5·ƒ¥ %Z%ŽA,D]=¬H)3MH¥ÿ1«½‘¡ŸcÕ‡\øØ_¸!xÖk(Y|¨SkÈë$Ñ@mƒ–ÝVo=Ôs=Ô6`WëTc× Ož-Ï‘äVô\×ò|WJ]W¢ÒíäHSó&¦£›( €¨ŒªZRe)•´½Ú+ás{3Øv£h ݘGZɇ\È:ž¼U\}Ø[Bˆv£‘@!‘€è3È!;eÍ'HÖK€hP:*•H¾<\UD\ì\QÆåN¾4Ôš­Ù•\É…ÔñÌÙ¸ÜÙBµÜõYíd×£íÑÐ¥TåˆùHˆy?Ó‡!hSE¬•÷ù€´Ø“9d),R/E[ݨ˜Þ}¥ÿ&RÛþä7¶½ ÈU䯂£I¹½Ø»ë3¿R…\½„^øèÛ^Ù’}d¸ÈbT ÝÙëÏÆUTÝÎmךÅY(×óRrÌïœÑBµQñÝÑÍßIÌhRdz4<™– !ÈŠñ@ˆ¤Ã:R{"8̺à‹U,r)üá]ÝH‰0[S¥áœòjAÓ4ÞKá x>¸…"«@•´]j).å aê½^ø…^€†khmʵº4Ë•½NÅåátÌòÝô¥Ôq5†Š„NÏýaó¤ÎνQý}b -O¥µ}?܆f-?û0ÈQDšŒ]Ú•Õ‹à˜Ø¢±­.éÝÿ탩8œ )òÆ óàÒa 0^‰u)Û½C˜‰(8^Upá^èhÈÞ’­áißÄíÖ•åÎ Nßum\CÉÊm_QFÉ ÑN®Îù5×ì„b¤µYS>WþU&E8DÀÍÜÌba¨ ‚¢£€Pˆ÷É…”ÉÏ­­RõÒÊi’ˆ[(iXbœÙµ‰Ì;]‚>tDM:6Íu¬kÄ1Ü,€²%ŽRnäBVÖK(Ù,Æ pQñmdKÆÎñM×HNgÉÔómQ…Æ»|Nð4WÁD×S†ç¢ÝçvÝÎy`{€Æ|h…-ÎbŽe|´ ÈÙM™]ž]8´Òÿ*Å8ãÞ8fÆk¬Ò_ €ä·\*ÊÓ¬c>^D k6`ò˜€Z>ædêä6hƒ…†,‹ Cx4˜…Ë•UÙvnÜF^_ÇÏw6™m˶Q‰ÌŸåÙvåÜRÞ_ÖçxîH*>ƨ…ÀÅÇZÀG!ˆmT`0&5úØ–º „Õ ÎÊtk8 +=™i~ã¥86Ðh¶"^±ÝÍÒŠØì‘,nfÖ™þ…6p‚¦ah¼”eN(øéçŒì]YʆÈÇ­ÑxÖ€šUj¶ôlº|H§fâu-íÞl%Vâóß6Ž¢ÓfÐM°¶€Úƒ l`8LІAa¢ÿe·öW¾å\°žâŽŸ¾)’6é:~ÛÚA 7â*/Ѽ„WéÃVì‘}V`ˆ”•ÈžÆìðfÎuÔEjî¤È‰´Å‰ôE{æVS6Z}NíùFåù^EMñ0|ô…ý†TxmüW܆Ãj c+Í®›˜ÒáÖhàXðàøÌ%Ù¶”*¸=‚ñ@Mêðñ áWdfä^È›þÛf\81µkÕÖ•H'0Ë=•EÅìF®QOo.¤ÈTmèddQ®ê«Îìúvd%r½Ô­ S|-a±Ú“ ðc+ýå2N»Þ½â`¦•µ]¾š¢»ðtœæÿ=¦¦Ÿ1^B;f-)ëÆnÏ…^gHE=•E^”Â-TW½Ç3@F}q?­Ö)¤ñ=åqž^jre•¥o­ÑÖ\L/rU%·€¯†å'o…!x©/†"T­òËü¥üðr ¦œÞ š´·–J: (î;ä7\špF^‰Cò@£ËfÈ)U qáAöÛÀ}V\ø<ï6ÿÛ?ž“ÅR¬vÜBFßóAQ?môG·E[ToV<Ñ¥KM¿ê¥_ÍþáÌîVUœ*–Ð܆—åVX¯ª“k˜¸ºÐ"Ü–uÿ¼$¹º•!æ.ºèPXY=nã iÈG[2éÿKaÎ-Qð³W˜uacdeÝnîÞ€8Y Çè˜h9Ÿ{$Ÿ›”–ôž“ùüöï¼pgEœ÷NŒÌl /m$·ïLŸÑ —Qs%RƒÆâØ®…8UˆE\ð»²m¸¶·"¶»*æ–8ã”0Û5sÙuÙ‹œ sæ á\ µ‹?F`v+Ê'ˆ‚ýøC&qpîja ­=öIÁ‰•wùÀç6˜wùÂç¶Gê¶Ä‡yÈ[ôAtp7EHËsNç"÷a¯_ÃU÷&†HàVØûØv@‚Ñ(a‰åИ.òîr,>—R(!f•ð]#ZcÒ8æ1éÿÀŠØsL{ˆÕjÑ |ÀÍÃRÏ…B†a7v;¡… =§‘úËÁ ÌH¶è‰0ä¸Í0-¯yo¿BF×yÊFòLí Ïç#ïÌÇÎçRŒR]zu #y-ZÌ;Aï`{Q>DѧOÄ':dxðD ŒéÍØBè…Ð÷Á¡D%¾’èã¥J1/QºdÓM[Eè‰ÏP ”"Htáâ—Ñ6¿œüúÕëR¯§Ð YÀ7j> †qݪ¯‚>CaòÓWö¬Ù´`+ åÇö«[·زÍÇ/Ÿ½ù @±×מßÀ‚¬ÂÞáĈÿ'n£â±{ŽUL¦GY…Ì—-[ÎìYógÍ“5|ÎüX…eÀ†X€ÖLX XÈ“wï¶íÛMj4H2Dˆ|ù ŠX¡êø‰úò}q0cF’>ÌkQb Ày%UNìÎÒÇ«2#ĤTÓ¼M™”$öüôgPJ¯TqÚÔEL£F½45‚{XµBW]!²U¨Ï‚ò³?ˆ”eȃF¸"_!²?æS]…ýU‰‡-¦Š'fYöX†ÚaŽq㌎™vާ™ZŽ¥dÏ­5#D+BEÉqNõ’Ô/Jñ÷‹ÂP0D+?(z"¨à£&XÁ† néV”R¨ ¦nÁÕa}8¢‰‹™z¢ŠŒ=ö"=öd&côL6ëc´Âxë‹7Ò:ޤiÂ@#Œ„PH¸1‰ÝµµÐÄ  ÔDE¨¢¦LW.÷ÁAô`%sÎìCu¢¹Bxá©¢^yo^‚SzæMA+õežæÇ_Tmä²ÐÈ$ŠOŒH`‚ 6ü0Ä Gøè¥‚U)?"Vja&r¬˜‹+¢º"‰ÝzÚ‹±Öºòe-ßZÿh(Û“OBG ëì“ Ïn»ÝÂA¡´L/µ´–Ë… Ñ´!D1n> ésîDà‰§fozMMèù@T½¯ðä¾@Ñ4Ÿ*Q!¥” ½ Í%úð ?üÔ £ˆ4ê7à ?Ìð x‚„#þp„ˆ6*‰‘w\bЉ½ˆëÉ«¢œùŒ;Âèùe¡9##4 / {Â<­·þÑG¹ÙV[”G#-x>¨Â4–ùtûpSÒCÅyGå+تç.œç™ÓDõöto¾òí+w Gñç_¹Hp!­üôß^¸ù~÷M`ßí#Òþùæß?ýŸÿ¾ã’ë¯ÿ¿å¨…̪É4³Ëå(G„Lu„@ÒˆùX€긮u©ÎÏb—›%5hÁч $¢Š6¥k"ч¸¨œ/9¤xÄ)Î¦v}­ya{ZQ§XÀ=ð îÚö'¥8Ám¿‚0~ñ­Lo‹ºÁ¿(â/}V”¢úÒw8üM‘QÔ"þö'F1‚Ìc1°Ç]ÅUÍèdàMCÀÌtæeóx`3X° ¬ b·$% „$R2Þ _rœ+õÎ!p‚#“\䣅Ä+Nµbˆ®—x­“ç›×t(‚3ñä=ñIZÛšÒ·=Eú`„!¥7|àCÿQò“_ßǾ]¢Oлĥ±Ø¨û­oŒÆ4Ì©sÆ42f™hÜbRS2.P€Ì•æPC3Þ€¬ ë|ÖÚ ë6àÀ …JºÀx#|…|Àcˆ ¢j`’Zp2<µ"¿`šqŽ3ÂåÉ䆠dÞzV€…NÏ”s¨ù%·WC¹€€ Q(j@ó3„/u‰¾F ³¤Y¼âEªKó-ŒÀËK_ ${T`¦ ©MÉLg"Óc…‰Á6ŸY²^Ž3ª£ÿ\‚,@d ÇYsà @ÐI»FD†ºÃqx·œ((„9 ¡$;±„¥_@dwÖÿ:ÎW/ñ¹6ï“l WØÃC|ý„(ű–\mQÿXgÈÛ(1ŠZ¤â (é0ãÇÒ•ޤ[©ÂÌËaúm—7eÎÌfZS V´Ç Oõ×*g¶*šBæ4ݨ¹ÎÑÈE@­@S©Ó:ŒÈãgåLÒU¯Êª 8-„áµb¢&u­ Lk¡pìYÉJº8Í@a²¼°ò†¤Wx²W¬X (Á®MlÒ‹ù”øÀðfÄ"£ŠýIµrƒÍ¶´³€[ß´"àËz‘¤ûÝ¥.ë9æL‡¦7m>PÓšÞô¦…©0a, FHŽÃ$â0=±Í µ!ûßÿ4¯ Ô3†8óÓ™¬ã[ÜÒªÁ¥1=ÖY<—¼3wHs«s±äKZrÈ)^}ÂzÜÕd&5ì.%r¦ÎWÀ ’CÚÙ¶ôÚä—4Z1 \àNµ¨0|ŒT€ ùýœõ«¾XúW+Z˜ß6kˆXxÀŠ)?ý` ?§¦p…1Œá 0bÂV48|SSšÄö`D –™ Â–3%æ[uN#¢©ÈàT—ä:Û` ªÄÝêË×Ü)rw:q+q²LävöSÎarlPï:ïMccÉðeåaY k>Hw… 4‡%à@`__øbµhÅc‘ÿË=“ÏÒó~Ç}çuÓ™Îf¢ºÙò@»EÂs)€½ç’o ;x„–p£ -ZHO:Ò—¾4‡W좄ÕÓ¡fñ6Q‰˜#(Ü @Ÿ-É7!hA’é,’èø!¶ž!<7™]òN.@Ä›ö^·®Ëm²ó ìÉ¡¼¢'”Š•›ŒòŠm®}o ’„ $ ©¨·}Œ6{ÏZ!7Ö³~)u“R[/÷× qè¹|èÐû»½§cöÿûÐ`4Ûá[ L‡°»Ý/}w„s˜ q¦E ~ð!nÕ<ì1 r˜Kú0õëT'’ûvg¼ÑŽÑÚiÿ˜ \w#„Éî$R„ „Äùç/€ýùgɻ葓'»¶W TTB¯^î¼f¥|ÐæàÁ<½Û¾HŲ>¬K Zß³óo <_ëÒÇúWæ¢ýís¿ûÚ'ôÚ%üv´ë[üƒ†¯=èŽ÷¾÷=ÄÏ\ñˆY,â†Ç`ñ‡_|Z—Ñ4g°“ÇeÄ ôLmøÆ!Áš¬^ÒÌÐç…é= ¯© TëÕÄ»ì\'u P .ÕñL ëé ÕÆµñ€+ñA·ÕB T€|ÏÈ`Ô`óå  êà ÎEòà ÚàŠ]óÍEöeŸ÷qŸ~ùéÿÛ\¼HØLGÜÜÝÝÝá]ˆù¦y¡û^ýy¡Þ<|! LuD ø ÏC rõ˜rµ‰ÒèDw`és½Uv% š¬ ± Nà‹×…n 0X.T»´ÉèqË<øž+\@=¨àÓ±  ÔàˆâÛ•¢¼Ý^á(Š_|Ñ]^À´¢(Þ „å ØÝbôù`ô5BŸÚàö}@ã¡éàÛÁ2ÒÝøû5#áaáÞ<0Â4r„ˆM£j"4ÛèƒÁ(TƽΓ’Ïp‰Ô q,'=xÑ"íé1ͯ©Þ|ä…TÖí¢n1®dâ`1Î*Þú1c2ãn¡ßmá2£ß•aë@#l#%LÍT”±äßneDoa°PWm­a <…ÞèµÜ_ÔÊqÒ@A G|tÍ?ú@è!¤=@Œ"CAC_ñI¸ ÜÂ-0 0B^ú¤ß-#3R¤`.c[v$`úäEÂÒ„Ýó].&¡.c-®d J¡LãH¦_zä_úP åO†ÿfA€!à lHÀõ̓đW:bK;>‚GèÁãèýas ¢:ʦ|௽•ÒVMàcNÛq^ qç›È^,Í$ }€ =¨çïÁ%\nb\¦Bñy[*ØeÒ%ÿ ”@w.iÒÍ Hé-¬§{òeÒY”Bé 4iÒmÝbÒ'¹Ùç×9fJÞ'B_€ášÖ €*£`.(`~fbž§2ã4æ)™H@<¢/T¨/ uÔŸ†J GP‚À¼æ&•è=Òš=êNXaåÒÇæ ÝWÖyXçPy0@¹œï@§tJ'‘Æåð™ñ!C*$€ÜB“²­‚ç–.é-ÜåÜÂìå^2­‚'­ë°V ˜«˜æ'..«™:ßK²©öÕàeÎÝF¦G¢çµèa®§g’ ´BÐU¨0|[ˆ˜ d(Pi‡\ƒ´Ðwx ü=¬ít6¯òÂe¨êªJì K/ÆÞªÇö% wo÷òª#“,áî|vÝñã^òš¡´ (µÖìµÖïývæfN¼B3€®0¼ÂL‡¨9ÒA¬€oI<Ä?¡KòÜòoZ ë5[¹œ/÷Z/‹[ñ&ïÜAqjçlðØ®À øNuˆ°tº‚+ôq ›ðó¢pÔ-ÃÔÝ¥ÝÖjÇr¯#ßÂó(Ò0^âp$'n˜Vroß²Žé}ÿa›áäZ$£Ýl¶¶%g6±fr®Ïž²¸‚ÀäÂ(•#qÉ xSHlFê üSW¢% ó ýÂÌYô?aî*±½1q*<*•D•Á3+¥4£`ÃióZçó‚€ð¥‚Ä.C*܈תּ§{Æ¢9›ó®–s:îÉ’[º¥Û›é™^Ÿ úgGîÌ–bͨaªß2–+#`µfþ3Îèƒí ]*S@:aÄBëQ.ÌòJ`´>¤u.hDÇ 3Övieó+H{xØ(¨RÂ2ì ÐI¸é©Rçò^36éóÒô2pÛM@õêtx:©öro,Vîh¶E¦ÿswnÖÝ@ V²õ)kÖ #fòûº©E’âå~d¶Úow&F A3 K- m&„é:`ëCÑÎò޹@ñÞÃ@t1v¥è¶[õrs‹P@Õã^ßhÏÉG׌ ðÊ^Á†‡DdHÆi5Wó5¿ôbé\úÂ@NOïÝB©xZvP·6:—3àº0­.&RO2i7îJºdôÁ¤TSõ`†ä2Ò¤(g.g %Îð@+@0 %Œ.sˆGèÃzÜ“$!7–¤õ@ „Ô 7sÛëèÑ5—ñA¦ÞƒÇG¿I¼V·ïZ÷x`÷ØŒmS™DÑŽ°x3¤5#öÖ0ñw!«wõZ¯¬ê-|/ÿ29/²O÷-°>éž!u²¶3c’6/þ Tq'ã³Í^¤3±(ó¬g"‚<8±4›u·äÓäß@L‹éµu.Ä9>­Ói^’ÊõîHt:¶ãlê^Žþuu ¬x6`s·’ò£ b—0 _³¶r!ã´õÁWöe5PÏðEjï’î·~»sjS&©“bÍ"ñH–먺ªgõ?(5òé#>b³™„stK`I‡{BèC-·ÐUM[ÇŠdÕúrX9—’áu;–(¼’Gu÷5v+çœz3‹5Î,útn{Ûr{û8 nóñ¹N[º­^ïÁÞæªÇ’@,Ò7¯úÿªÈ¾7²‚:“=—ú´Ž"¿£ú–ó3¶Êé(Ÿa+¤ž°îMý=,=ÌN‡·€Ô@D™‘u•[5—èÅc );°%Oy|¼u'ÏŽæ(ÏzØzº,wž*5Wç5b·t Ë%_]’Àôr{o) ¦O}#ßð—>Ÿ×Ù{ji¾¿¯=ß`€£º¿Óolßo‚ÚiÒ^EE€HÀ:ÉJ·8s|DÜÃnx8‘UWDüZ¤:à b²ßfŸ/WʧËz:¨bwÏa·KY¶·<·Ã¼Ã€à¾Ã66ÜÖôñ=/¸w^l{;¾­j¯»÷*l}ßv祤›úÚÿ;/î¢S áôÂè)áÆâü*ãüV¤ª¯zzö³_²¥>Оʹ ¡9=jØD·QR–EÄ”¨½¨þÕ Ç‹Þ"ÅnKì(º K zÉ÷µyÌý ˆõÂ’€  +”p÷O§Ì ~=t¿Û‚[c9céÔ~i)eg¬—Š,ßz¤¯zoß’@õí׿'5õ„!$4XIÁ .|`Xáć$PœqBÆŒ52šàñ#F!D~, ‘="f‚¾öèÑkCOCÍš-ZÈk³EÍCsés¡ODÒ¤+D¨bêTÄ ¦L•F]á´ÈU­ª^­xõjÿÁWJa#t ûj,Ø´”"ŒõÁ낈B@‡õöî­÷×@½À‚û­7$AâV @¤JÕ˜ñcǵUFäV‰[GJpæÌ‚E Ñ$&0½2# $n‘`d‘ÀØi×¶}·¡  JèÝ›`oC +P”°°â‡†3&g®1£ÇŽ£S7™BˆVB„XXâÃP7sj T'='!¢ä3ZuiS©¿VÐÿ?iÖ¬Z·ª¢¬W(k)Q+ÂZp@©$° ½òr…¯¿,4`°¼³ÃÄ@H ÄÈj¡Ì—e|ùÁÑ:ëìˆW,!ˆL#Æ[Jóèº!ÿ·}ì± ƒ‚#È䎢âŠS#Ž" ¡º(©óˆÊ*'˜D,â? B ‡¦›ÒKÔi(÷ªê¾¨Ü¤J„6ácJ?©ºêÊ´,+À#Xðüoˆº‚àQW\Ñ0/Ä0ÃzuÅ€E+´ÐÃÉ|¦–þš4$êÕB*Ñ´ÒH»ñÛb›íÇXNHàˆ$ ƒjH!&/`®¸ç4ÂHº)­’$t¤Dˆèo´@µÜ"P*•=4ѽlC¾öÅ0H) â€J)¤PÿÒz<¡–T~xìá–8•Z~`Œ$4vÕK›àUYE¦m7ÝtN8…Š n¡ˆky¡‹–s."b«“ŽÊc©ÃR‚, ÄË¡hSÚôì !Ÿk³Eº[¤~ñ‘û¤·[ªõA$>©œº3¬…«+AÓZ`-©àš+„ îâaQ½6Ü·QÀþ5à€ 0¬Û‚ƒ˜ôà`Lâ}©ÌÊj)|DÇ~XlŽQÍhäÈon·Ý‚ŽÖ] ’¨¡˜ûµÉa¥Ô9ç“ ø`…ŸõÁ–è1ƒªÉ‰¤¯*in]€ON¥šÞ½Ü¥®Z·«” .xÇ:^®z[¡àAµñÊ`HKÿ`Áò:Àºñλ`JûþËSðÿn¬âÍ?¿aÆ@¸˜‚&%áWØ$¼ráx3H7Ía†h¡â*â¿fÍÙtnFº)y¤.ˆˆ€³X×:œŒ)±S¶Š‚»7éc*ÜÊ{Ø£¦ªYek^ÑŠ\%Â}ÍO+h…TV÷»à«RzÝà¦(ƒ ÆÙ#öò¶7¶%¬C Q¦Êw¸":&1BôP+ÜÇ1WÐ&dó‹UAh%*¢¬rÈáß;¬ ,ç9™#Br¬’| ;†‹Âã@¼Ž”]ØÓž|ÜÎ>Q¡O}æ§Õ‰'M²+Wä5°Ä@Ä[Áñê% ¤Mm‡ÿ2€ÝfH· C|£sxI a¦†¢É$®aŽùÐÁ׋Iʰ’eE$ÚG‘HAv©%u#Á #ËH¥ˆS:!À€ÑÆ3µnZN8še—´¢”ëixÔcœV°:zÌ=qdÚš©Š®ÕËlõ:ä:¼¹Ü‹ФÝÔfÉKb2†wËa'¹W©K…Òo[Ø)ϧJõ´b•ižHËZš ‹ÀqˆNöÞ$鋾ªè º‹+:6C#uHò ,@&Ï ™èQ&zDÁZlO.òqM}å(G)ÊNWy´à<‰£ìn§Î«t¥‘ ’Šÿ\’7<©PÍ“ä<'Y0ìyò’™Ôç>³‡I€:J|™Bh—J‚Îi-‘/@PCðè­;r(ÉjS2ŠVÔ7Y´¨’.ÇËŠôŠ£¢–=¦ó‘cZ'g |V¶Æ4j¥Gší‰Âdë8Ù\\6 ¹˜,e‡Ò‚x–'àêK±)£ž-©©õ:Wð Üe’“¤ê%_€U‚aˆ`9ÄÀ>ñùÕQ"faäsÌp‰{Vô™O­i]F§æ*9*)¢zå%CŽãK‰X$# æ X,„ô#ʔ˵Fr´yí±ôxƒâõp°Nˆ¯¢Ð‚Ë^V5åà3™VT­±Àv'æÿ2eÉS¶õ¼í=¯ÚÕÜê(ا“ÄW1ŒdŠK\T·a‚S®‰@›’5·®Ã!.¢ÅèZd"¿ºnv¹+%(‘ÑX†ýˆnÐÚ4y3(ŽuiNÊt#¹¾–½¯ \05«åƒŽâÜVï\e+C¯¥çÝ.¹ÃºY’·žÜ-ova +Í¥LÀbªaƒ¸ÃÈ-Ñ2–‘ ¹ÆŶ±«tk¥×ƒpκ ¹®vklCK§˜Çü€IQ ž«©¨Ô*O‚ú“#Ÿç¾—ý…}þ[Ê챇šükeSO…"hž L°ÚàÕöäáö:y€2Ÿ×ÀÕuXÕìfÿáÂù¬j¥³o×<×õ±(EÂl#Ä—Êñ ¯.°Ñí2ÇIAà¡Ãˆˆ4utÓ 4 Ÿü´'MhÂ=ؽî{p(™]²}œB¨øÔP®]RöxjÖ"â©"€j]`¤6«Þs‡·Åí=¹œIIyê‡ëÄ•Xʱv¸b“)ßœŸQ‹cǪdн•rEZI›eÖeHDÝQ VÇÅbù b²LDÔ伓>Aäávs€Ý÷à‰¥²ä&sz+Mi¹yG«ø»^Oø\$ e3ØÁ•”ž÷†°¯R\aaO¢šÛ¼aáþ:Ä›³/B¶ÜÄ&«@®2'$-Vÿ{‹ñ%0‡é²a-‡#8.u¼ˆ«‰àK-gP}t è@©£¦¹ÕoO/å>·×QŒÒ-¬=ýÔÀˆGBÀêvÃj˜MuCJQORù‡¾Î¡Q‘×ã#î†5>Ü´>c†ÈÜézW+šÜ¢ÃÉÞã—­¼Å×m™˜”Ñab{:e´ŽCæbˆG«wÒKàù»ƒŽdø&¿¹xšÔ¨’G¥Ü.¿Üò ï ž”ÒëcúàAê½Ü`†ƒÒŸ*iöB‰_À|$ÎSÈN}Té1~­¸~¯6ÜÏ>î¹(ª‚VšmH\,¯vź~eI¢ú*‚9H0ÛÄ(ûnª¾oñÿÒ-è„î<>K¾Öck¿º…ýؤ*ŒÂƒ¸k°&À¬ÂMÜ$&JDãµ´lõ²§“@‰Rò©’¦§ö( ˆD ¬Pì‚k¸p÷4%ø„ønIÅ|ãøte8(ªÚªÍ7Öp ]¦úZÌ ß°ïH¤@j#L¯ôÄ œÀé§ÐÍÈÔK½"Hòâ+vê>Ê%\âD)r)8O)X‹À¢nS-‡ Ë”«f {(IQ>¥oö…BàÆG1ˆÂ'µ°álka$ðíÀ ]qdN¬6ÈÙ¬3‡ ÙPW¨ë‹V.f”Ð@Ð"B¹KøZ¡ôÚç&MñvâÒ‘'ä‹=l*\ÿ1wðƒ\®f*梱&ÕìÏþ ïAD#’` ý¯{〨oÞÑë,$”j/jo”LÑQP‘ÃgÙ._Qié¯"ÙT¬Úò ÓpÚ~å8~ñ€)"¿(#~Å!çP€4B¼m.Vç¼ÎkÈŠ ü¢q[À²2«iž¦wQçD) à^Òð /ÿ*â´¬¶ '»ªË2iI‘§pÃ' ЕÒ'2ò—2Ïî !20!†c! ÏÓ Ž$f€‘+)RƘ£‹†Eø¨îKΫ¥Î’hŒì³±½ê¨¦R¿%)ä)J/)(q*~\ [d^€ÿ‚@'wòªÎnøÆBnOâÓQS12ìP2‡ÈO)Ý3ÿ‘\Q;s®œO¦H¬r G³HŽCWv…ú¢Ú~")û@ðf†zL&¾©&ÊD7qs½VŠ=k=^*³Þ.ñi6ï=Ä1>ôòó<ïj¨ï/à&¹Š«ê†’n–l¬nï·"2½ “èO±2Íg¸b3ÓSø’ø˜í8Æ2Ù²ù´28þ§sZÓs&ò¯JÐ+/6.7©Åˆ&‚Ö’ƒèh¦l§òàã(ªâóš“/ù²[’FdâJ€nò¨3Ì´ª‡ µ“;½³Â$ÓD‰2 ÿÉn2‰ÄÌ323‘@F‘ VØ3ræSÅÎut>ñN w‘º°5ës—ZÓWÀ’">€ôòÁ,¿ItSž²âȽ†b=°ÅŽp°ó‘.çR¯¦iÜ#ií¢ ”ºŽ Û‘1·AÃJ©âP}@$2ÇíÌs3×sd43a1 M“Ù¢R 3g yqÚ"µ>c?#Òe’£‹üç"$€ÀR'\jL®ôJ¥ MiÊ»\QwFÏÇÔLm(£.X@ÖÔvëM³G`fo”èÔ Ó óÖ(€1ØLÃÆP5 2•tÏÃÌGø u=ÿc‘FmãPeGEæsñGlmqR›\Óðù.ÒÚ"’ú¨ô>àS§eJ[gihâ@Ûij'% ›q/½ewÊ´²…æ¡äpU·º D'å/.€XÓ1µ“(ñtY[Á1" ãbŒ²ÃV)DšÄ|A=)`ªU=5“6¶UŠŒ K\’äµ*QS kVRÕðºð3g/Âôºé™Ë,ÓËÜëhÖƒŽì¡=>€¦vgUçäðœ³/«)Ž7!€ €`{.W#lŸzõ ˆB Î#–qíX°Y#&Î2Π íÒs3ã–F³5q£d"o¿ÕGŒfÿyÔƒÔfQÓ8,¢ù¤!×u#¡*>`ÊTÇ„^§éhF­q)%•âóÌ…B›æ6O3— úGËõŽƒtH© —´ôL.¢êL°ie‡¦¬i£ñ¯/Sj' .ùšKà6ÔMQ:¥Õ†· Pë~H«ÐNUT2ÿo¯8 ˜2¬X”S鯕F:c{Z%ŸÁ՞טÙöÖŒÑä¦í42—\SÂ"ÙP„©z¡ƒô*áxðÀVòtiÁ£¦Äºšd¸}-tV?ÚjYøqO@Xà­×Ô`åZ:Ñ1Wóæ +IáØ¦C1ön°R1©øCt×ÍÚ¹|ìl±KÙíltx‹ #Û¸Ûž/{4?8qU3—"Ò"+’½½’57µU“ªO“\A{\%5@7“ææ"<Â÷Z>·㦔–(™‡w(rûjé·`{0K: ›oòŠ;o캪Zwzfz¿óc—•Y߬¸BŒ±ÿ‹ÚF!X•÷yo9ø=#2³ç zWþó!)’#ˆÑú¾òÆ©¯‹ê[¾E›´í› O{3U»™pS(^¸÷øLi•‡•ÖÀ¡|‘Y`zÛV{uùØ4a;©¥Uï:&9|ÛÍ?üÖp—YÕÙºkáŸ;3±a¹Å 2„‹ä "£2ÏÕÏëÓWÖ;",RŒ„q€ÀÈ7šC]5;Rw\7´Çr3¡3|œ [ öâŠëy]9–ñó¼Hô|Wô§Ïaâ6Ûûå*ž»œ£ ÷¼ëÈýÚÉõ´c£"è7ÒÐDÜù8;êBYœäµ4z VÝÙæ»œÂ»y·jkÕëÝ’èæ:)D_¤ÇÃù]ŠÁ§€ÉNàuºb¾Û»›ŸÃÛž¾Å¦2"ãÏÕ›?5â+ÿ³ÐjìÙ-U")U´9þã㽈Ÿñ#I—tqŽí}¸tIZ@›_à/ ¶¤{NÝÿÕ}ˆÝ]ÂskSÚ nuïæÕîËž0öFCbz“‰>÷ÞâÞÎüzó9*sEÏYsêbóóœó=‡â·ÞâKŸ3ª5uyìo–RÕ»>Ó0³ÿÊ÷qåa?õ›€ø›æWñFÔ{øÑ}ï×=Ü]®urkÿ~ða-ñ  «jKë^OñáÆÃ1ò+,1"Nò«X¸À;©i¹Yë¥~ü'Ò"/rô¹¾ô_#dŸIþ ÒwQ /õz]fÑ’ã#‚`ƒêbÞ‰y-<(à y bpèðÈ=‰îa ð€@†0¼xᆎŽ8pð Zxy HK®ÿhàQ³¦Í™õ Ôû tH=W@‹=Jôh‚C–Ös 4ÁÓ¥T€¸Š5ÕC\ é 6,®[‘H¸PáZµl×®­0턹æÚ½‹7¯^ºâN0°„³„¾ðÁðÙ „ÿe¼öâ¿x‚E yO´`QbžfÍ Z”÷µÃ{ \ĨqcGAá(%H+eÉ’'Í¡;uÎôéó§P I"uþ“)Õ¦QŸZ^ëÕT\%Œ +–ëØ± v›6½Ú´lÓÆ…ë×n]ÀuýÖß{Wð„¾“õ †,AùGÙY’Ie”õõ%°pBC›•fÚÿ ±V†÷È3‘E­b‰ØQ !‰$Ò»tÒ 2Á”ÒoÈdQÂÇSQC4]Î-Õ Ò-]‘SQ¥†lÖWàqå¤YRnÕV[ì©§ž}tá5_|ñÕu_`€Ù×}2¦Øyg2¸_|ü±¹#óˆFaiU$k§M„ç þyш²yt"Š!¡¤âIÄô[J8*£LÆáH©–^ZOSBR§\QRA…¤UWu÷¤!HPžxæIy%ºÅÖ{kÑb`Þæ­¸âÚß–’í`šŠÙJ_™sñØ^0Áœu–¶áC¬y(µ÷¸†-l9d„›‰¹åÆâÿ£‡®d€J)9Ê(¥êâè CÅ#¦?&¤SRUç)vÙ• ª¥Ž·¤«j|–ëÜ_Ž©eß­õÍ7™_n©–`å¥)ט€ýª`_ûA€#!LÀHÉÍFx!‡i˜¡µ ¾Æí¶ˆXÒ G ˆA‹(©¤èIA’J¿ýüóq4®{ô»ïÆ+¯R¢6u/¦UYůXþvå$XH¹¤yi Ù•ÿWcU2 ñcôÁÕ«]ô«¦aq!Ûæ\ O°,ÞËîÍÞx3Û¬BÄ¡†àa¶ÚÎ,R /ˆD’IµÙÆ[n,ñÜâÐ4ò°îL,ÑØÓÐ-GäèL]EUÓG&P5ÿWW£z5”OžeÞÅh¦&€ß®{aÁ2LwÄ[Î&ÜL\·]Ì.Ïw³Í›lòœ,4$íàI„ZâÙr„ÑydóH9ï ÒäŠæ‹êÓ\ç-ÝRO?%ºêØ¡¾TéÎ1½Të†Àîº'E),´cLרT–§;…1Ïï0V˜¹IL‚nےﳟÙed cÞòä´·y„poËêÛx™",…c{!\€Â¥S>bKÇ•…ƒâ¡x°æèª/F*ù–8yßùLs®HçqÜå]ËψN;]ê<‰hæåk_›€Á$Sé†1ÿ,=µbÏ’å“F´ÅÅZÒ‰9רA_ÞèFüj“µ¬¡Q+ƒÁì[ÀõòÌ`Kp‡ÐŠâí‚\7=Žj3(IÔ ´Gª8Ú=³îjãMÌÅHFÇ1Žü¼ûmï2Z“ùK¯ä,Œl^š |à¢ÁRõ{ùoCïB‚TëûµU†õ As‚X»:Ö}õ1kQ[´yz‹-]Ô‚á{<I±ÍÓ é½àx/رçá@Ï|n”úÀu3—ŽÏE>,šËgâíD_rÆ‹½ÔÔ@õÖX¼Ci`àbFwë…my¹ê®î—¾x×àê-Hå;º4ÿTghðüê'x Q`°çÖ¢Ìc¨]p’æ ¸ÃOÀFþVCÌÇž€!&€f«½6iæÉ[z.F™¯‘8C‘IÒw’tétRߦq㉣XE÷ÈÑÒéý$œ *éö樑®ç[˜NgD–ù='gæ¸T_ýƒ^ouWgÖ•Ó×åXÛ…r©ÂN³Ä…Û® D\/x!S| °™w.î$Ö¨ôÅ$%ë+¼WBØ–¿¤R6 ÷w!^žŽ;MiçåënzëX ÷¼ûÛO2’ñ;ÕÎò²^»¬,‡æµ?®ÿ›u±Wu¯p8pXvB´U2"ôÿ7fwxÆBá{;âV?c@Aw@wˆ`ó!7A/=c?SSŽN1Õ3ÐE4-÷38µXŽ?I:y޵^?ûCO—× ’,øÑ7ñ×AX•t Õ7YÅo¢×t÷'zZötû'pS÷ U'€V‡…Èu«'uˆG\fwÓ_¿'qíâwÂ'\seM·a¡|0#®P\®àr)aNå˜3.Ý$9äóá24éÂ.?aTên6æxŽÇ#L!QCT„/—¤ úzs1„Y•7˜˜„…Ì’oÄ´U§gzË£j`×ZfvBü—ŠWæY芯øŠUp §L°ÕÿFa1l'qœ€† †Ö„åññÐæ :60öñ(å.z¸>(æR´ñM|¶}9eIåÇqˆ¡“ˆˆ¨;8OòcT?V ÉS‰ñg‰íÈŽsñZƒòˆLåeM÷tOWõè Xfe]·uUèŠG`uI°{'G_ØQ©õQködmDók‚#FÇy§|ËÈf \е"-ò¿!.„—"‡r}ã3>†e’4"#5vC´SჇ(yŽ8sèGO8f+$â4‰õ@éx‘‰ ÃUñ׉`•`¦VOÈZ÷×t`–QŬ¸Q[g…Xh‰š¯xB³xe i‹ù1Æ6\Â…àRצ®ð8À›ð€Ñw³¹#°g;3NÙg9„$9ÍÉ’ä’Së3DÁ!“•d˜5¹XíÔSÉQˆÍ1•FtéŽG¸Užˆ7öW™»æ‰šéžËRk_÷uÇtp]WšöЉ5¡Ñ•ÿ 8DùSDœkVAh‡ÿ(• vÀÏ–fœTh#÷Hç"m5†äœ~%$°ÒhXåb7R˜‰¨X7¨#“¥4ŸÄ“@Ñ’ñsíf„ 厗ø7J§£½äeutOÇ™Ng`hL6`Z8©y•p­Ù•å6FS*\j4’Ó‹®`›šÏâC†5!hŒä3†u>9´>†.ÒuNª—ƒ}ÊI“ÜyE±S**y<¨4?¦4oa+ïA£Xu75„ðH„¦‡7P …MˆYfs„z¯%py•ù¹¤V—³wÔ•a%&ÿl†|ˆ”(A ›âÃwæwy÷lŒH‡ÐÅ"•£f ÿ¡X(væH·y]A„#Žâ9˜%j¢‰ÉX†i)|úc:£çÁiîtCy¨nÔ€Z¥UNø”Kù„ú˜Q`§ŠVY…išø)®•Š…[—¢¡G¡á<ûá:Äm6cC%ñ3£!UŒPeY,'Nq†Å3gš3ð:>?¢}é0Q. «>~6’é^(:O?/îR0y0ŠoòG£GGùtî锎š­[FŸ_uòI`T®ãª¤¯(Yx³Ó“XÈ•^‰G;œ(ö8/@Ú´¡¹f!aå7Ô6.ŽòMHx·Š¦0…>’ò>“ôÿ9%Ùµ/AÛÇ¡CDߦ˜áçSß·¬ëgùv‰£—7G9GÙ7x{·òX2•9Š’*©¦'…SIš3‹úéŠ7«¸åŠ©¡1‹xDw  ’`3/à-¹á‹'â=ĆÀ)Gý*«~ø(棇~•x+¶>/8Ik’Û‡.À}‰'±ÄJ±ÅZsEd§>Ö#µN²…j·y#Lu$utÇ[2ËcöGGP‡eüÇ­Åü—u¬G®6‹… 1=ÓýYx;'Œ F@@£—Ñ‹ê+>ÏFqNl"'X‹d"Ù†Ô—¡µ‡0é—¬û$J¢—© ˆ3¸ÿs9¡4ÂaDÍ¡hüÄ¿ò0z‘o{+²£§™ñw”Kè„Ì[2fV¶­T {÷‰š7+MV§¸ b.ÜÝkuáŸóðS:¹$àÑ öºf%€"¿Iq("\œµ-EXàH1§û;»ÑY¦Ìøº2òŒ¹²{ÅÀ‘6ø]+â5~Gá»ìai 2=i˜â݇Þpkz[ËL¬Ùòuø¸”I)©-[Ç¥­…Ÿ9«ÂÓãÚ‚t-}9ä+Wøœ·ý/°ªxiª‘L\#'|“³¥[Êò|Ü~}}.yá_Û±«Ååò"2†#G³œ[c#Þ)Α¬;‡h>J2<øqÁ­Ëu›Á[•žNÈo6^¦÷™`gÂñ]©y¼½ueRˆs-/$H&µ_Ç ¤ÖêÂçÈë8l 4œs(.24´Aꉡƒ§Ü´ :-د[À«ÿâ…©.h>.‡½ÊÎq4ÙÝ]4À›v 㜞ºìt{k²ÐóA%cûç¥ýÞުNj«Ÿ´¸¯MH„Ôèˆ#3liÆæ¾j*ê5”3!é"(A@¯›åbkÊhº¦_îê)fÚŒÀÁmchƒ-Ãá9Ù½»8Vˆß× T0ðwÆï¸Æ¯•·Nؼ¦×t¤XV6¾Q„nÂ'ŒÇ,,ÃÜ[RÓ"žíN_G•9Ħ¾Í–w9€"<º(Qhå#q“Ä>Í8»b]àëðœá­žï?IÝXIð£‡eËÏHŸsºÞx¼.ç³D+*·½,ìúvÙ›ÕËKÿexL¦ÈõvLÚ½ñ2<ߤÑc8ò'~`Qx$Q‘ ÞcwŸàQ»îÀyr9ÀæÒΓÓÎîìîÀ‚}9.§# ¢îsƒ´^Ïe{Ý<Ù;‰ølŽÞ6@z…jË츄ù†™çÙ™[ß™-í…Î㈛¸_}ö‘öjŸí×Rä7;¿NÛ(›/0•›wo9` x×ùl¡«á~Ü'ˆ7戇}Íá`».)ª.û—žÃÏ9÷Å_l¶=qjth„œ úµŒìÇëðŠ`\OkGÑï}½¥ÉúX¹Ú?°OHjÿqïH‰$@xÿ!à 1Ö㉩+£MîtêÓU=ªT (mÊ´Sž N¨0Aì±eÍN !–Ñ„µn¡…ÀˆÄÚ¹qÑÊÅ÷Ö¼¸rçí%1D F%öî%˜81‹,?†|²cy,*‘‡Yà==ÈñùfÆ.”¨ƒƒ# xñÀ¢F#û4>¸0$v D’dš2&LâÅc¦TdøP¨|ªJèM•I­_ÅŽÔWžÎv÷{RÙ£bÝÎS‚„ÿ _¿ž…À6~ü´oݲ½›6?Þ¹ýÝb¤¯À;¬0À +aÅ#ˆ±Ç$cBÇ$„¬²%FÛìˆÏBëŒÃÎF+¡‡dch5 Žxá…#2ÒˆE’xhè<úÈ• ˜3.Ç—lR¨˜ ó®'•PÒqG¨´3½­ü®;ì†lʪ¤˜4J+õ ’À´,M;ˬ¶Ô𫬸Äð>þè ð?Áñk/»e°Â#HA'ÃÓ²<1íB6-9mž 8"…FtÈÒÈ6ÛjË 7Š"âá…™.¨GSãV+R¸éŽc®'çNU®H˜ršò*«´ãa)£TrÉIð†2ï¼ÿ¬f]ï‚ö>à²Ka×B3¿0o¡/M°.6çZ“0£öjlp±Æ&ä¶[=+«Œ… ø4s´3 è´†Tc¢ Ž (#h‘6$àÁ…˜±!Êû”8PaR®GQ¬i'炦ƒ]µ(¬^Å»‡Љ§ <.*=Ÿ¨ŒÊ§Öëõ¯„í²¾7ï#!Ìcår+0ÿòb$Z¹ªó/:llÛ<#Ô3B>ÊìhÎ< ]Ò%ãUmD¢-R|y‹MÑ ~©—@5ÑD‘nx¹ pbîã“+¸¸”ªªªñ´«N'åV3ªá ¹³Žd“uÂÿ”/ø  ÈbY-üÞJ3@’=V0ÿÞ̹Y ã¼9ÎVèÉ$ã3By2¨OrW×PÃsxöt À€Hh-Þ‡•íD…X¤ Wú](ì!”>¡†ÎvhùFYÒÔS™¦‰¹ª{¸¦±%6{î쨊õbð†”É«+Uð‘£j˜D 1üð±“Ø·˜] r3çB¯þãšK‚3QëgópŒèFg´¤¥.Cb×ëõ4ŒÀîx lô.x=ă ™M¤Œ\„X¿xs€æyj@áŽh…–%:DñΩtí™ÍDDù^ÝZU j¯csŠKÿ6>›PÀ‰ˆx"RFÆ5ŽXxAËãè–Ý€~i“Î ³,ŸY+tC#ÍêR§F ­.‚ëêÌÓðU›Ø]0¸T¼x÷.ß]dŽÉ`$Ei 6‚¡ G‘ªýÈš*ߪ–cR²83[ §T7ñÇ/ø$NˆÊžx*ì™MV° ¬À}ðC™€•%Æ1.e©Ë]²˜¾évx™ÇÚ4 2 ¦Nt:Hº6r†\jÓÐ%¨}P]8dB©;b@›öÊf”rª&lýZä6·¹#óERnÃ!RQª œb÷DÛ&]ÕI‡íÄSÐs@ßžrÊÿ昊G(‰ÀàÊ'J@б\Ü{Ê’¿4Ií—·cËä w»5&M‡Ì_c-akAwZ`„ÆÁºNCp”]ìjSÁÁH$ÕºYÈÖd$#2ò×Bd0WÄFŒ4‚jŒ„#ãPoGCi[Ú Æ|Vl“t{•OHYJ”ð0HóŽvBvªƒªD e%õ¡ ¬ul]â@ò,,&K>kù¥²äBLf)ÈZ èæ¤˜dhFs#K]ÊÒ@¡«6~Äȼ‚À/Vƒ#!‹° ¬PœÈ£:oS1ᨊk«çJ Õ–dÒy3©'…(%²šLª_gRHI¿¡ÿ$+®+¡øÖõH…3r«(gÅEjè Í>Ò†¤EPaL´;)ðh­aì‡>ƒÁsÉ‘šYŒ. Ý1ÒƒŠšÜd<=`„#|Á\ã2aÑ9‚iá9œÔB,žåË$l³O)ÑÍ'¨=spÒ·™Š« KÎO±("Bñ‹ßŽ‹\X‚Ä–}qnš «,ç:¤;뙵´³í$™ ÂS5´4]°iämÚ4÷a›0„7 "uÊGrŠs"Ijñ&ð‚€¹Ñ&‰ì«šwù’>-$o¤G Ø·û,ÏúlI›ÔŠÂy+%x0l“ž¸ï•ÿp…hr“;ä¢ XÐM±€2ʦ/†‘¯>ëIdÆÅ`k2¨‹&x;t®@5Vv,2ŠRd¾õVVQ{¬)LØÙ $´yI&0¢¤º×%Ñ{d€¬*Ýä†C™áK,¿ÝÍUAB’T«w“7×JÏù‰„yd€áƯW±‚¢ ?C`É–ÅöŠõâbþe˜„‰“aþò9‚˜‘1 :AdކgRzš—Ž¾ª‰‘šzj5¢-C>½¨;fjwFɪƒ‡å‡Œ!æ»$§zO0K‡<ÔQQH «Rû«’d …Ì*S[‰Ò6j^0e‡”€"1¢jkJ L óáÿKŠÓ‚³ÿ‰0‰·¢Ì“ZÒáÅ´ya‡¯9ZÓ›öÉz“NP3äŽ×QpSûj„$ØÓ]±u¨¤T…íÄL;*è­GîÔä))žÄ^wgmMñ[ q;V½Ê _ÇŠŽ0 \Œ¢!}Çp \ø@‚y0>@ó¸kŠWÜ‘Ú캃w‚sÌÜ8ÝÛ×hØÝ™8 Ó˜¾WÖö‘ƒ£Sl5õÐo¾õ­E-ù BÕ…WÔx9ö|fÊ?Þðw’}UEùÛJa¹;©cF9αÉZáv§Ó}oˆß³¿ý½·æD/hÁº" v'š€÷ÿOäýÖ!¤,̲ÀÍyj ¥A»a;jÂ.õøò¿Ð‰Gy€‚­`!uR$‰ˆ 1*W°—R[/ò½(‰­P{› LR0Z«§Ó‚§‚J"93('É!"Ñ$XA9Û‰¼©$ì)¥1åè¾Qh t ÔÈ; ÐAÉàÁÂyÀ!À|ðQ`Âìð»×h“Ë«?¡á.Êø.¦i¬{ÉÕûB J½‘8ú ØÛ:‘P@Ý:„óWè'DºŠ! €žT!>t¸3\¢¯œÁ ²:Ž®r3Ûz¤éë'At'ñÁíóÁ½Ã¾½ÿ;‘Â3¼{ëá‚VÀÀz H»³Z;Ä„;| ÛÆé3•a£¨ˆiD®ÒFçðA&lÂMì¾P¼Ñ€#,<z<@”uñ;FE\€Â„–ÏÁ q;&R “z4 £@á?AÁy+ºxØp†8ð¤,ëE  €q @F_Ì ;D = ;|êÀ=<­éD¶ë-äcÄê+Ä{‰ñ(íé­8'ÿy©wüÄÖÐÄuÁÈ» ¨€|({€#4ʆ8?í#ÅSŒÄ÷ûjiÅÄ)ÂbŒÂÂ?>a©Ks­ CÛÀTCÕÉÞø5Œº‘:¸DZžßK°ÃVhý²ˆÙ†#ÁtI/£3[Ùɬ$äk$ÚÉŽA(!G Äž Á»‡8LÌ;LÜÌ#à~¨€ÍÄ$¤!ÐǾ{ÂRlÂ|Â'Œ“6±ÂEkÙ®º“Ó± ±|§ÑÅÕ{¬™"¡€é&ßÓ/Râ/¡º¬ZºTº~q€½ ÈKó£/èÜùa^ˆöÍ;ÁBž¼Bíé¤ÇèC}>@ÊbÞ¡óæ1‚ð‚|BDal|4[¢À¶­!C&\¨páCÝ (,XÀV$¾ ÜÐG°€=È.Àx£ÃÇ&#@4¢òäÊ 3n,osg~œ‹Mz£D‹&\]¢@×ü`çKxQ áˆv[àfßWl°°€Ò†È+ðAÃEÜ¥0\BjF¸AA‚Ô¬SíeetÞQ£F!Ðÿ› “£ä…•WUkÖyÈúöíX ­FZhÕª-ÿ?P€Ä$L —ò•µÖ Y°Át„Š%Va>ðsT‘QvÙd"x ˆÅ£O<ù|æÙŠuVc.º¨j±F›†¯Ñ–l ÁF#Eñ(Û@޹" l@‰^ ÜpÒÊ…AKøD×_XÖMÕ 'dÅB—[uQï½G hEÀ˜U1ET :I@ÁLl"ÁkM‰Ï|R|hnňr*ØÊ5ý°Á7à›=”Vi…ŒEUER†ˆ#ð3‚¡ò#"Fñt¦jh*®Êê«0Šÿ†›I¸Õf«A·Þ6ëc¶Ä£BCFÄÀ^+ÜPl++,0Ó­ØÔRM÷!b]ïUÃPYwG ¥í=k‚ îšG°#'ÅBS†lÀÄ+A¬õM÷æ»([HP¿ó@°Õ†Pw½?DÀ(>ˆ…¡=ü|c—BœáS’EF*©¥òS"F§¸"h®¶ø¢‹¡9VE¨©&é­Ý8cn+§¦«‘–i´²±N²uì--ЬMBã4–´`…­™EÝãô=DÉ3.TCÕUCíšòètÃY Ïûžb­…Ï(£ƒL ­ 1h\ÿ–0Á† !ÁHœ°£?Üÿ`ˆS:Yj©b•~€!‡u8™”y Ay,yh$¯èꪘ§ÌX­§1$ó­½]¤+µF¤kè°BǨW4Y‡É" ´ÐD·"­>õâ^ÞPDeu- âr ä @ñÅõš_O{N!"Ruñ%ýÁ}k-Š60£ðÙlÝ ¡Ü-×q]À–÷ŽÚ.qOLi³åCX§&q|*È’£¨jȘ¬b«W„t  ê>º…Ül" h]¯Tç¤ÈÜ YBk–^(q“¿ÅI,:ÑÎ<¾Ô%õHjc:!ñŽÇÂã]MYC“¸äŸz9I˜ÊVÆvŸ¶ðiÈè^€ÿ~°(']€õ‚ Ð'$¨oQͺ¤ ¡šÁ N1õCDðç©ÇuŒD‹ÜFR¥™½*s™K™@ 1³Ò5„~/Su³§(D ÈÃLjËXý÷¢å!8šuzR.•)]âzÚ¨†<ã±ð…XÓŽ@æ\O#”[{ÊGêØ Pø""ý†¾ Œq1ÖGD@ÝË?X€Ø(ÅK^BR{Ê·Ø©P‰È&úXÿ83¹ÏÈg43+²E7^äW Ä•­æø‚¨î2±ã |ФحÀYR*$²pˆÈ±8)>T9A#G¨Â5a€W gÿ<åeÒ(GpZ{•4y¯('àÊ‚êÄþðGajI_Án((ŠˆHXÔÙFqœ …R¿œáf££áoT¢:Ñ‰ÂØ¿} F$o<#2:†6ZÌ ÈÓÖ$0"–!ÕmL2¬ É&è¬IK"°C„`*@Ä (ðj…²Kò¬çò¶E<ãeà’ÉËÚ·Ê…”jÝ󜔇ܸr’\°, åS áÄ$¾¥^8K pÉŸ{£ˆ@T×K{äCôKI‹‰ˆŒœ*r,£™ÉªTEÓc)‹ÑD¬I³q䳩‘£A~åÙj2Õ JR P¢%VòJtV ©ÿ(úÐR™¼¤¦åÁp[àrañ,¹ÂÊ# êÊJ XÀI¬¥µ*òYm„J°Ü ‡sÉ.ø¾²§‹.ê£À0p¿Å‹b:,I¹™A$™ýóX‰^ŠÙeÆ´UÜœË:·Ó…V‚c7ãèY×€ó4'±¦ €ä&²B+ª:ŸÎKí¡'W±v¼M•´dúYµ´¦ðKôÕò žª@@¡gaVÝZµàAúƒFÁ°ï(?Œ 2ÄWÁõò°NŠI;ÕMÉ7¾Îô娪UÝ·€‘ëìøßÐzöb°á&D 2TRáo"i°K¬aD‡ÿª/˜…!ð%Nå¸SƒáW©6¼¯Š¸ÃWCáQ‹¦¨±‡¹ùD+šŠ"·€I I£°,óZcvJKKlwÙ÷$ a ø2€ÑŒ ˜—B¡”á ¢ö>Fe…rǸ¹VÉ´²™ÝçvÝSŸŽ¹7¿vc6òk òè £ê‚Œf?Kn–0´C‚ˆZÕ“TA±w¦F€ ÷EaÁ ùYIò™=-N—º¢†Ö€V¥ÑóX«ôÂ[^õ9J—W1ʧF%l_Cð4 Ò6^x}4J1¬aãÕꣅ¥C¶oªâ+Yfþϙєr•YÕ+–õúã¾)2D ÆÐ"d" ÿQ‚™ä`è<Ë9ž­ž:•„ *Þ1ŠÜz[5sãS­D±šp1és£Ïí èš<üž©¬U 4,€Ã:]E`ñ!œ.¨0ïñ+£|õÚ¢ÂÅÀ¯«ve«Ù{:ì¥,ýå8skËB!÷ãÈ?»›`{#$ŸÐ€R$D0`̾L2¥–³Ä&ЮRtnrÂXÏ{ Úm|þLò šˆ‰çí@?ïiß÷Á•Ï|² æŠmË·\\70PÒ„bò”ï>Qìz€¨ |Œ?¨öÙ%fØÄ+b!Kôsz›èíý+‘KkMÙ[Ù3˜ëxÿÍö8¿7Ep±kT‘Õ"iF•*Ð@Ç;˜% ¶ÝTª¢V§äü(.”tzœ¤m^²BÉãsY#IbânˆVh¥V32$  ×@uûf(5/öA_Ó7n¥JŸv1XQpJv‡%LìeÕ2اOfFš1wRV9w·eýõqBòwD2S·²!‰£`±$ç„T€ Ð@-áfP -Ñ ¹5CQ!€.ê"0'.ÞF¯GCYÑÞ‚5­·aY“hÈ]<å‚&rãIåJR±oóq ¸Pm‡Ò{N1À§Am(Ô‹R 1|T4?ö?ˆÿ•€hNRA¥R"×wõeY˜eq¸¦*5ÅVfG~|ç_Ý”!el%GZ+ RõZ%ÑxÔ„nÆ`,±T”ÐOUae¢.%@t–I“ô`&õÄT¡BÜæ4n˜-ɵUa‡RJwR>7à„? ŒŒ‡²Ea!‚_£ ‡…‚ÜCU@¡G?ò’¨8”ñkne$ódµÆƒu·}=˜S¦ÓS]ækåç|ÄfŠÑjIbT@³Så`LøJu‹Ke˜G8÷Ý¡÷sZa[(\"5÷ô€‚R @Dj1Š1¨éK†‹*±VþSF¼‘9ÍT¡.Ń•µ?x¡r1ã[ YròëW‚±É2) J2yωç¤iL5­†,¶³HQQPxù†m&Äaç–.\¢nÌ&çÂ;Œno’u\ÇÅ ‚ƒ'oÑM‘D"¸ C by³>ße|‰†Ðˆ ‡d÷ƒÖ_M wõØ} ¸RÛ—‰#³Y¤Xr*SéE–~*,®a,{4¶-ÿñ SEç¤TMeúÐ Nb'q²…ICÚbD:5ã)hAêH¤ê&5¨ .xiPNPùD5/÷QcÈŸ"h©dJöaWþq/£¶ 1 Qá‚N¡!‹Õ)s}D¡´‰zš¡)©’§T¹£Ó§¡–½±Á‰v$ !ÄBÆ!ŒJ |ñpˆÐ–-A¹06˜‰yû¦%(Ö<½˜&Gñ‘)†cÂŒÞÉ&IÊå4¯ªª~PÅzk¢’i°VîáIy!¦à¨ IÔDo! 4† Ç· ¸ XN¡¬¶)*„1Ž1_:eµæLÓZ­ÕŠYÿ7»©›Š=â<û§²axÄòœ-'ñ‡[˜9%J²€Ó‚…ÿw-P-0홤nø‘=·€‰6°œÄ%u&&Á#°o4¥Ûr\VBÑhBA×ó€8¦ è«ljA¹ "‹Zôñ}k¯‘Ó:FŠ›S*Yòu­Ÿ‘›úqz¢ ´ äšœ|±-·%…;PRÉBF…R[URQEq¨mfˆUšW¨€K÷4«IÀ…BlÒI:Ñ<òThË…neh¯ð–ZGwU/ÐëJöÑ“ýñC£v  ?3‰[dR÷ÿk×gqóuƒå[Fft_±é»r¹½v~/#xCØ":x1S%­–HË"}¸ÃZ86I“Œ±›BëöžáYg_kn¼ ËŒi˜UŽÄÿ‡bŽt&ro‡&·:ˆw2ÂöA/d1ˆgj Àà·À€~ÃŽ//O¡X핸ãk_vwƒä»¸ª¡ø•eÚz¨à:l¨ø§ª(Èé317s;XQUÐòÐV•s ‹z«ºnëny†¡ ¼›Ii˜BL¼›‡—rz.öË…&Ìëw¢ ½Óûø‘ÂiÃÂÝ£Ep4 d‰ã*ë1×·¸8,_ÿJ³™Hƒ.k@»¢eä—~´1ÃF?'Z$¡ãJ, v–4¡ì‘ÏÈ;àáªÀ…\ü£š‘Uó¯.(„B ËŒt]ŒUáÉÅQãbf¨\(IÀY§uóböqÂë£0¢ ²Ëð ϰ6#?5 §Xý˜¸Ôz¡Úeͪ‰g³·V9ãÄ&§É¿r¤e8ü œjöZs…ç¡B±…è©]Œg ¼¨¼ª½Û[{¦<,˽Û%‚9T¼ÅGQgëUȨ©rÓHË•¼tÌñq'ôô‚¡Y ‹ Íü 4IEêèJRM)¥¸ádD¡ •ÚÇÈœ±R6ÿK9í{Óäf±!"š~ÂöªÊr F[•·[ÛÆbß’5&¹t\ÓªœB=C¿µŒQ½Êü,Áà‘-‡èaš‹46®„' ²(_q|º½ÛÚ{X?QëJX+ËêNYê±¹R’u›R¹*§q`¯ë<?Ë• áÓ¢h–F4HèRBEêOu®ÏP­t ìOOsVÄó竪n\RŒô@Vuªò°1×rª÷¬V-°%ó¹h_Òh:„Y÷‘ÿiÛäÞÖ1á·—> ðBvôÓó¥;ü?4í²É¹„ê*re˜cbTÎk ÷­±)®&ñZAÃMÅ"¤A÷ð[•ÅJ—gÊ£€gÚ¢º¯IJÐ!€šù!@k¯žöОèÖ<¬Ì˜ûºåòºOµê{¿—'` ænéÏ|sv=?RòÂcÁ3ù5é+³-Ü÷*cÞê”Áá}:fðhž©$`;p¾{êQV¸[\+–ÙŸ-.N»&Úàòç)”¤ïñ†e?p‚í'@#¯HúվŤ¯rå¡4c[—éCø®ÛȇàÏÿ׈Þóx§r‰²¶RÉtþ0ý²ÍtF¬î)¥ãï\ÆS¦1N…ô¨YÒöN:˜Û†5æ $pïÞ‘{ @ á@ Lhðž¼ò4Ì£GÏ^>}!EæË÷!Çy'èÍcyBž¼1e²pÉâåK6uÊ+Áb#FXæ,Á’Ñ<Œ&\0D Ȁ5[lÙU«Ë~ªP`ö>ä몯‚>~ˆÐêó6¿·qáÆË'7ž]}qãå­K÷mx€#J[˜0?È/fÜØñâ|ü T(À/òeÄ‘-óqcÁgDL*=™&My >\8ðÕª[7dMÐ"ÿE‹7cv´÷1ŸZàúHšì˜òÄÆ˜òR¶téò¦<›5mâd9zNŸH‘Nø Ái«£€¿Šõ*¾]'çëÕrWD‡9óC롲ݾwýÂí;7ï]þîªK°ÀâAd„øŒ/±ÂsÐ1ÊÓL±Ê&T ‘VXC>ʨy¦{ !„ªÍ6…&j "×*rÑ¢‹^já„6¢'„±DBDC.„Žf” &ã’«é¹›h2 ºCòª )LÄF@Ë®¹à‚ë?ýòºo?Àô"p0û<°AùÔ1Ì6³ÐPÄôÁÿðD>ø@(–>ÉÔd[‘Ø *ñÒÚ^ƒ1µJcl¢¹8â-ôYaÕDPËÇd¢GÈå–k&œž+¡…œZ(!&^ŸÌµT¸“À; ÀÃGd²´ŠK`¶òªÌ ÄzϬiK„D€ó®ÿú{+¿ÿâL²¿ äó@v tÐA…l³Ê2»0¾“š¤ÇÑI¡[‚D/õT¡#²í" (})F•Tj#{BÀ±;}x¤€G|ü`%zJv¥Rm5’I{ º'•„ŽI¥º3¤©+À'Ë-«æšeðAÄ«’ø±Ç½³Ô\-~º•S.ÿôÛKé£ï¼ïiu#lj›ÿ^¬çÅLÞ 1‹ÏÚ¸û:P Ú´µÛ\tmíŠÆHž%àÆh·Ž;’Xb’xduÕW󲸕Xê¸Ö˜Šte^Yà•×\u ‚&ÀD’ªZœµ¹¼QÀt¯Ì¯¾ª ­ø­ØèoÏ]:é—^½€ÿö¼‹]Âl0ë¬å• ±ÊzçÝÞÈÎÒ‚—æá§%¦;TØ,Åô JœÆ‹ õð¹it©…%h´±#&AÑU_i…ÕŒ…ûûáŽTBiž‡á¯nž_wíUI’CYJc_v *™ [à³Zq¦ŸýLtØJK[ÞÂmiåÚ¸˜§ÁEv‹y×Õpÿ¯ YÆw“©—ï,F=ÊQšÎ’n‚O5"3¤õ(%!ÅOÚø$6ìˆU¯Ø›«Ô×CSÍh~K”_JhRž,NqPzR¤ŽE¹ïÈlfâ†/ºø,i!pt£»ÝÓ–£¥ñ«[£eü˜¾Ô]ò‹=øÁÜ5†2"áM˜(Dl(4¢JO&%"y,/TÑÓTE2ÃÅW2 JDZ… &‰BEP¾òµ‚ˆ«J_þÆ1ùÙÍ$ößüŠò°'%NIOªâ<$Ç! Áʲ€ð!•.eePšºr2.sú–œÔhºÌ%Žw£º¬¦(Åÿ %›xdL½6c¨«Œ=v§™@jH-¢™„‚šDÞä ‘á#)C…‘ –­¼dG6I€†ä“«ŠÀ+@ÄQŽr>2eo´/‰%Œ˜èü|u(Fç4´üR>ð2CLî)L˳Œkt bZÏ­Á3"@Í„“œTç½Ô…ŽjÌ»°¦ÍŌΛ»Ócïüè3¤†p3üL+(0HvEXH² !IP &…«•©Â‡£¦J ÕÐ+|0Ä4>Ph@P §$+¼#×ù).&O–¡K$$ëüåx %-~s1@…©bhªFfJÿ§sPÔÎÅMÌ^I• %C™|ø.-ÀZ èãQCYÀ–7O…¡ Ó %C†I»íË$M•ÞööÛ½½B¸Â]€(a\à~²tª- Ž(úÜê+e6©ß ^pÈ]Ѻé`£Â¥g<#ZÄì ¼{^™æ]“ Œ $ÇÆ±ŽÑfdþ¨YÅt-¿úì8IèßÐJ&2ˆHë œúÔ:ê(Õ"‰RãÚŠ`µ¶”¼Qoì±Q¬¾Ý›*€»·ƒÔ¸” ±qM\Äø¨e®ÛEYR¿-ú(‡8Xð(«fåzÌ˜ÌÆL½4ÍËÑâhSœî)›@ÿΣ~»9/°Ø7Bægµ ð3Ï^FQ7ˆ@—W@c±³G9Š<YUµYo«\] †Å"€æH$kU‡?ü[ᮀf-qŸË*—ÎÂY!#ìábùfÆ- ä(×§|çr3³ U¨Œ 0ŠÉ‹iã!+—jâtšï-šKSo QöbõP¿¹_{­Gœ“±G•ý[€Wæ, „(áÔÐDn¢âë× ç05{ •v³åú‘`ŒÃ«ò°‡kíäù%ŽÀq Jâ 8$cŽ&z×”d´Š°ôè±’iðø²fT/z6ÍéOçû¼z‰S`æB žÚ+ÕüE”ÿfÈdÔÍÖë2• ÝÁC{pÊŒsLµ®–€CDDX`è2˜C „`ÓbÄáTf Øæ%t›+%–á’ð–$!ÙÆêŒí;³J]q·íóãR"Ûâfn³ß¼`¼b”Wð“Ò ¶Ó”ÜàÞæ2ÂûŒ”ÞÀfÄ7€L o#[°²•¥lž\GY÷âz3cª¸€yÇ·SÙàýÓ˜v÷\“íã¬5™jýw¾ÿý#ô¹%„ÐˬàXŽâa*Pšì<騮Y¹ûT`7‰ÎuæsŽ6‡ÉêáO†¸Úºqàí?ïm¹c‘è°™¸œúů:˜x(pƒV\Ηã¹ú3–ÿѹÑq}wz± "ë::ÁŽ:%5ýÛYÁDÿÖ€OêÁIØ÷j…v½ùÈËä3¿×Ýg½Á5ù¹eòOüài¡>ïT},¾ÆZÎQ\2½{Ï«§bŽÄ:Öi»3²ê0UØ9"2½=ó9³2¨¶JŸø+‰CC¥×{˜'Ò2„øðð.|¨`ê=àã/j²,“); Œ[[Aÿ껾cÁ¿+㻤Aʼé›Aî¼óÛAäÁìÁô#‰|øµ/;-ùã—貉LA9ë)•r¹ˆÑ°|H-R”ŒYDø…UñÂ:û$0̹³2+Uø¹ãbÀKÂZ•ÿ‹A„q1t몎¢(H¹ X€Ë™´™)¬fè=| &ÇRÿRA@?vTOôD{ ÄvœGîÃD(XÇLtGN<¿N´G€ÔÄÈ ±ftŠø“€|yŽ´Q³•£Šb¥‡ü!¸ú¿ÀEòñ-ÿ›Àk++¶*³b«4É5TFJX+.„C“D‹.úa ¡x” €ºÐÆfa–.ººœÙ 9GžLÄ|lDF J ÌG¢ÌG¤ÇyDJx\ʤdÊ¥tJ{¤G¥´Ç6°Ç¤Äª¬Jz€GˆGî# ·A HY™P™'š(Y|¹Ý"á¨E‘ÀÅ:kÑ®j[€_üÅd«â:(>CÆm#IpkÕR°sCº«Ž‰éDÈ=ÝaȬ™ðÂ…ô@—CÊttDÿrDÎTÇÍJ|´(PÒ _æá݈ãù!KÉY^:-ã4N„lK’è$ÞšÙ‘ 9WÑ_Îó›•àçx˜»±ßÎ;WƒBà.ROË¢[1:ÿt]àKè…\Ð`ÝåÝføCˬ€Þ¥,aÞãm[åu[e­Ø®Ø¤,äÝìc^ÅÞEþÞ~dñ Qð‹øø ‚W=â+i¥57¹šÜ™»ßø«Ùô( $iÐbMú€NÂYINcö5¡‹˜‹«{}O©m‚ôÎW`ã^è…6Ð`n¯†V(“5ed†ÇâmÛã]Þ¿ ÑæÕé­æ¿•Jg²…^kQ˜fM2uРʼÅáHnlsÆiȆSEe%zÈ=ì2¡n¢®RŽSQGa®{.‰|ŽÔ” ø‘ßrbÉçô@„B¨oÌ0þêÌM-,6 x….³` ¶èÿ6nã6ÐhÝÅ:dƇ ˆ×n6MãÅUã­P(ÖåÎc¿žÓœ†ÓÂHLdÍáe%§\dmÆXðý^Àí^ýÛ;í FЇ¸Ò좎L ÔÂ,c ÃgŠ´\¿AíÈueÉNŸueˆ®E×öËm#ÏÙVhcl•³ÚÊé8vÖmáºàWhëa&æ6¸èŽö]ôéb-Ó_X~JV:[ H¤$M5]ñïØ›ïŒ%oñFäO,C0b|*õxn…!]{–9Þ‚6õ ó‘éD%wÜ»1%‰‘¥@຃¾! ÒóeH[UÇܳ fߦp¸–k9æÚô0´ÿ³õð47ÛÒTñìM(ØÊ¼–X†ÇÕÜAíŽÍáuf:‡lðÕæµ•qAgd?UUW_pïøŽ?úrGgíHErT‰ ©ôL"ráøÙ»!à± .MíÔ„¶eP‹A“Z ˆç+Iã4\`á¢ðav‚¬íh®Å4áPÓTqw„‚N\ÇÑÄu7'Í%Û4_Xÿüõ€äR§á5ÝÊ’¦qšq=ÖÞ65Ö@¯vÙüV¸äö~Ua0„ ’XZµ_§Öü•ôˆÁ-¼¹ÜŽüÖž6„:=PãfLUKŽï|%13lcUøm·þ'àhÞåZ{óA''hÁFÜuœÁ…ÿ;ÿ‡7ÊÑ„G'(SÕTñ{Ôx}¼sb­Íuvž6Ö8•ö>tFžá´ÈöÈ|g!0‹+Oò ß0ý5¢ArÉ’Ðe'—ß,ìÙÜ,Ã*ÿê[N±ï8¼nÛmU(‹®ð wk7æèf˜õQˆ€Ñô'ö¸¸Zûú¼ûzKLxöpǤD´vGö ôø<Ï^ë¶öôòæU’ñ>îÕ•°‡Æ´€¢nOoGÙ$%Ç'¨ÎËN#rw‰Ðm¥f —u÷\ÈN¯KÓ¥w…^`däBStŠp?Žë¶V±]XýÜÍÚ Ï`žu\øË!°À5GÇ}’È»ÿ±ï}ÞÏÁ²¯DJìuâGöçæÃÞã7­{ºÿë@§sè/ù½Ð #ž ÍŽï!à‡Œü»9#ÏÕ&W‚ ÊF Ðý_ŒH˜ˆ|ŽØtLŸ¶“e°^èÔd¹’Ò?ý’ˆWú¢Dq’ë  ½.üÕ 4aøáÂGQ}ü*äã÷!_>Žù…IÒdÇ’$G†,p2_˜ eÊ,`Ϧ½œö èÜÙógNö„-ªâ¨ *Ú$mªôiSzN£UZéÔ¥Y›¥÷¡" šf¡•„NœÇvÞ‰óäÒ«Â^Qôñ±â/à|?D A¯bÄsçÿÉk|OÞ z!æ…¨â_}"ü~µâ•ª(‘¦dáÒ¥Ó”¬ @aE«VðYˆ`R"ôåJè‰o‡ { ƒha0|? é3ÄÑFÌù5çKýºÆì×3RçÎäÊð7¨`Ï$Ož>Õëdß“èÐøGåk­¯ÁS­R•2•*5¿UPA¥•Ub…”=|ÐÊXÐÔÒÊ”ÐBcò¬@‰>”†Zj—¦ã_±ý`AmHÖæÙ/¾%äD.8t C™…Ï(£X@!ˆxé%XˆtÙÿ%˜^6÷eFb"¢X­Ùfn~Ç]œ#Ô“{@Á·çPEÉ'•=€ú7ŸTú©ðßT…z WL hVô$HÁXfQÀC ,ȃÁ=ZøX²Õa^Qä¢:¹›>•u¨˜W'ÎDbó`®ŸõÈcn¥Q"dB’ÆZ+«$²Dþ²ìo¿ýÒC 'D+GŽòCq©&™dªyæ›_Šû\—q–Ù?c‚•»Ñ¥×žNB5ï¼óÙKß …ögh}úv…Õ}\Aê/WN)^ˆÑŒ0DøŸrzac*ʃ‡v…З_=öø×`†ÕåâŒù¸:—éCb®ª|FÿÉ+ ðÈã+¥Ý†šj¡ýe¬lG aÁϼ¢JÂ-ÛF”½ҋÐPBÁ?Hýà ®‰+®·Wk½µš`9—µ×ϵ‰žñÆ÷½gÏ èžH *”¢.úホew~…BÊ=Œè#0ÔJ…›zZ±Åò„º„ŠvêÂf»~l#_&¬¡d&[nÙ©7暣h2û裯¨ýjújEÆl³!)¤Ž½í[ÏFÛô+CH0DµµUmµ¶ˆ‘ÖÄßà%ñ\‹{‘!Y«‰HNìå ”Ùf³-)|þ{èönË}`~Þ•Ý{ÏBXÂ@Hø ²×\n)ÞX¨Š×åÄ©š­ ÿÊè>€fãn,7Æ2yáØçT±ÐÔlf¾úѯ˜ØëH@S’ˆ­_ä¢ ¹pˆC„ ¾H@ørZq< ¬xˆ¨Ú …'ì†/\a /C׌@‡2ô!~2=ê¡íPCÁÞ·7”Œ{Þ‹Ôöæ)óLþÁÏô© Á)º˜cæ§¢»äOE\ÌTá²Íˆ ¤2`Lµ±ÑFáßI÷ÀšFX¤ÌkŠed©†jì/\Ð',«!¯‚~ñ HÀ(´ÀX¨Éãq’…/Ô– 7ùɪÕð†7Äa mÈI"²’•òŠ f„Å@ÿ(+ÊÜrɨïu{ò^XV y¼à}óÑ1½8—¶X¨ zŒ†ò1GÎô4. 45ÇäD™Ñ ªlä2—fW{$°üøG½ÆXƒÄ‡inãC2‹‘ $Î%Òb.µÊ¡! AJOª²†VûÝ'GéÃN24†¤^+#J½WÊK(«(-gI¯ë9щzØùv•¤ÌƒOS‹\ŽyÌ,&.rÌ3S—ljsWÿûK6£“¹ª0ÊH¾¹²QjÔ£ÕÉG?¶f3í|'’x”Á¡õ¢IRbÈ/.!ŒKTÆ5'ô§Ô C†jRxÕ¤k~gÐrr¬ÿ>’ |Èõö0]íŠ×I4'²Ì¨|ÔËŒÂ-Š»ä^¾ë=zðƒ5€€Jå–Le C"À3åASõå/ªZÿ®Y„æÃ qÜæ‡æHÇ_lF"§QG7¤=i+ž_ŽuÁ۰ƨÑZÈ+~ñ ­R0Dµ~¥©¥Õ«hU¨¶œûCâo h=«[íJ×óðÕ< ònwûÚY²2£²ä^ 8·ÄzT±ÿ¢G òáXÈÂ…-ò`L…îÙýr³÷ÐÐõÛrîoEÈiå¤)M¶s›\\«FÐ8©|„`iXãTØèVI4ê%|@¥¡}¶i+0.ÿr-€ dÔ©Èds¹ô;¯‡ ]á>áúCáíS uîEèúéU¯9©ÀWîÊW»þ$¯|e„N Ìä(ÿ$Pî[ßf _¢lY½Š]oWFD,@ô=A X@¡ÂY³ ú ÍÍ:xDäôŸÇˆ”SV•´¹ÈŒ ÀY#Ö˜åŒ`:щè® +pçlF!„§õE@ºÄÐ^ñŠˆˆ@޳âÿ®Ù'áúÖèúøÔ\êÒðöyT»=Œ+]=’ë"#YÉæA2^óª %ûºØ{u²”©lFÀW£Œø«–“˜Øôª ½1H¯=dÔXD|à˜` ã·áÿ,nOEs/ÛßQaæ?ª±Àô7ÈAÎÎFåR‘šÎ›ùŠH­y´mDX–°j"¾ôp›F C îÕªE-á _  v fÍ¥mm\Æ9öjóļ“|ÖcbÞÆãôlä+¨@\þr™'ؾ®ù]Q ›¯xò²ƒåg/[Ì×T ¬­eZÖ%½ðmz lEf}S.0½/(tYÌZˆ.„° Iá Æ¶Ý 4¼û¢@³ÑŒ¯5ø¡e ¬B^ØW;{Å G `@ƒZ­Ð´ˆ‡+¬„[@€@&‚V@|â˨Œ{üêæQ¾ò–§ü¶*/¦ÿ“7oã¯<°_`Ó<ô.WéIú ›çÀf=‘ñŸOà²gÄгülIAùÚÍfvzÿtk'3Ûô¨Àm' ¢—>F2“‘œw1UÀyîhù—#£•íkç „ÏýÚ×U¶æTtÝÕi,Ü I„c¹m|5u^Bú(Á ‚!$©¨ÅÄMÜ$¨!ÁåàVå)`62`å±ÉËM V Î\êÞÂ^ÎêÉí-›íåîÍ’ð_ð=ð1Ûœ›Ái!ÿÌ ‘Ý5ÙQ²ÑµÛ½aßù°ØŒRIa<¹ß™Eiøˆ —˸Àdä\@=$@ÿý_Ö Á N@9Nb\À$¡£N@%NâìM@$ÖÞ¸c:¢ÿ£:Â!"?*àÊa ¤:à"¢ ~¾¦ãW¨#<Ö#Tb N$îU¤Eö ”ÍÃ'²` ´ (“à"”*ªÅ„ÀE,.“šeŒ=˜JQù žb_¡]S0Á/Þ[9õâl=P!ÍDá"É(ƒ0àP’FÍìŠ`ä‚a׸B=ðŸÿ5ž/Ô¼¡Vº£;F$WÆ#W~¥=r¥W†eY†eXòcº| .`@ê¡ "bB&ä=â!ëÝ¥‚¸#&Z$îaÙFv$)’"`¦F&e|ÀXÀ >P@+P@«¬…‹°@[¨‡Ñæ"‰i˜hµÝˆØÿÛ€aߢŸ¾õѤ1#3"‹ARTÉžePEA€N%7&Àÿ ÅÀ¸ÂÀÜBD2qòeqz¥rZ"sž¥sVdsމt¶%:` äÂ%nçËQâC¢¥%"§EB@r2yòea’bÊÜÀY8¦ûE@Z¬[ÄE\ØJþ„ÈþHÕ¡ñ¦ ‰áT0nFh•5Ŧ4¢ß… ÉiDn4hÆ“’Ø:õlêƒ*¦ ð@=lè6–¡7öf=¸ ܉–h 0 häyâÞŠ2'Y†çŠ’î§ŒòeÈQž˜ø#?6àŽêè?úèæ¡>2ä=Þe%¢¥y§%’ÿgW.i’:)aª”q)ŒØ0…P@L€MKA€P«Xßê‘ Íüâž(NÍhögR5ÐÝÆ‚:¨¯È“PÂLìHÔŸkñ”Zd# ÁTnc7òf&€”À-”£:j ÌCŠ’@¤Bj¤N*_çpž(¥ÞÂ<4*¤¢™£ÎƒtnÞæ^?žªu^^uZg]ÞãWëÁa=N¢^š%”:éáu%y2éŠFéþ‰P-ŒYl —"“ÍÅßà‚`Ôˆ®À ´2ͨ÷ùE€š‘¡Û–S¢E£RÉæižÖnDa‰øâhY†j(‡nè¡à2C*€ ÿ€¥²€£â«¥Z*¥ŽèÈhÊ(¨îkš±€Áì˜pKÂ.,>`?î¨u ¤fç=⣭Ú*Y*©Æ†§®&©ÇâÞ<@|€X+ä‚y‘h€ŒÐPBßíÆP ´þ }–¡Ùäµb«›Æ–!ašu«OöÑúʃ2cnèˆM™ŒyB@†*¡&€¡öŸUNä!½,¾êk×ê+¤BÀ-øë- 'ŠlÁììÚ²@åe^[jžÃ²*Ý âB.d‘¢#x"isºhrö-rª(ˆE3®/˜Åp©XÑfáÂ5\šèÏËøJáì½IXÑììÒÚ-åREÿ#‚þ žÚ)Òâ†,€Ž|SaÔ†J€†²+‡ö_U^eÄa-èÚA ¬íî²ï‚-Š쿆ç§BªÚúî=<ÁHÞ" ªÆm[âm"*$žãXòíÆâ^s"gx²¨y†@\é3<ÃÉ Ó]ø‡d 4\%tÖgÈéešåº kíì/Ô$ÿø`2¢ß2Ú g6hƒ¢.êž®aŽ\Ôj(¡*ÿu¨ÿíf"C*h­îò®î‚m Œ¨¿ gÙŽ-‰>*×2/ó&/·œêäI/ ?ì˽¥\Þãv§ÞV"X®ßrìß~ìá10Hù>Ãánɰia,Dÿ_ü…œÅf»í½‰ä°VN˜é$š–NOÖ °.€+>$††$° *ìjn–a㱘¢í_0wp'w¥qŽpÚAò&o©öX ·p«ú£Arç9Òjö*©Ynoy~ï÷²(PJù®0€cZˆLN„o€>H€äjåBÐRâìžÝ/±–*‹SMWÍ|+gíÑ:¨°Ë,@äC[Ä…óÀoh·ë6ê‡ò&»Â-бñòëˆ'Іe—íCjÛúnóNgô2Ýö#¾j ) ×0:þ-;r$Cçþ C%7C-äNZ䄤TÆ 0ÿkü~¾Œ(»2:…XgºV*k„±©NBkè.ZA«¦¹®Æjˆ1k¸‘š…¬qñ€+¼n0Kmì3¢N\ÅhÛÞ«¥Ž­qâqÙB³;–( ÜB 7¯©j³ SàÃB,V’é7Óê$Öcö¾èrš§s¯xò´m A%.|2‹à…d$¦ü~FüNîé(ÓŠkA_¨òfܯk¡àõï9©ÓèmB‹qêàò ðC Ù1-0pj¡Je»æ&7šaúÂ2Tð{m×ên£’(»ãÜ.påHóqÁ®-噜Éis«J/w"2 c/Æbì‹JäX#l©OŸsfÿn3˜o3PË\Fú =ì"TÆnü‚>$¡JÕ8¡rÛAØý&ak¨(®pB›kÌ î ,"˜ DGt†Ö³[»k‚7¦B]?^=$sš]7C*‰î1‰æ1`›£H›(ÛZÞ Ac³ôÜ‚ž\BvMëídŸe“jlyÎ÷f›g+n3ø‚u&ãE p² ‚SnÌkû…k 8b„äUh"!Ux*×1ú ü0´FÞ‘.†‡ÆéÊL‰¬Éc©[o(»6p0s¨‡Î«ÿ9^Z0ëî;j_3jw×ã`¶H_@‹­ñnÞb?/KÇí>ö="%¹ÿ7NSörºãÈÊw9G2ÔêCƒå+P€˜ŒÓC>à†Q«v>°o F§´@=áMèmS5UK…ÃŒÐî‘üf¸çi‡³Æ'ÏrO´0ïy»Re*ü¹t`*¸ÂXwŒÃx¾ž´Œw7aã4W‚ð§Žpó,vô®ôt²åm'dÛ4x×°‘joÆvï9“§•¥Œ0Ì%Ÿ……æRk¹nX†óqÖn8e‚“y­]BPuNU„Gk³9hY8nd¸¸Úi¯xø‡G¢/gèDK凨ïù»Ö5VÖ+5ïîÀâ+¨–hŽ—4a3§ŒBjãè¸d@âá.ä]¦£‘RöÞjöeGÿ¤•Å{O')Ô2ˆQº&df¹– Æ\$F]˜[VoDA.ð`Q-­ý(+_ΊA-h`øjÔŒÌd¸œ›«´qKÀáehrk¨x»²+ÕRm»ÎîtWî¢4£žô˸£’Í çð~»%§‰.l6—»[®*‘sM¯;ÑçôÞ–³Oï°yêCÉ¥bî”i·A´Ñšý—LmŒ¾v¼Úˆd«ËŒH0c¡íÍŽ ûÅË †ç©{xÌìéE È»‚ž³+ìÂî‰ÇîŠcm>À¡§ïlß¼H—4Š:s£Bï¥ûü>öcÐË0>®{’}eolO[ÿâ<,©D€û ¥±ºtHˆ¹35LEÚs Nz`¬Qf«˜gH«RR|hÄ Þa<†_|žº}+¤¶@Èóy=ò3·»Î5 g´]ß5ŒèÖf7óf0ƒ°Íóôrêü-Œ‰Éõ¼ÏçáŽ=È4%­#=zü‘Úð­Þpf[¢fgv}ãÞ–~àƒÓDDú>8¡G¯ÍAƒ-6‘ׄaˆ|ú(ês±B„U­è¨ªˆˆIŠXáe‘“ªX¾ZAé•*—>^-Xá2Â+(-èI‰g@kÖ<)< ¸ª÷*¨ Ô«êj‚ ¸‚HUËÿWX±¾j¥‘ÀU‰,ØaáöH ¹%XÈeDâ.‰[îN`tk­»· 6\ø†!D‡7vlXÂá &W¦Lùæ .O¨p¡Â‡ 8O˜@Ú4ê¦Y32íšÑØ~ý&¥`A˜ ô…°gð`ƒóBlq0D”\KfTéÑäI“ÓK¦ìxråMU”^ÞŒ°"ç‚WáLJéèN›Z!ú!RJjÕ*ÕzöŸѪ«T¾«–²Ì°,$n¡«®ßb‹®¹ô"Bh Ì/¼HP¬°ÅûÄÂ*0IJË.›,2C4ÃL´ÉN»àÅÓXC5Ú\{ÍFa ÿ pÓM ’³¡ƒ4 GƒNhÁ¸‹âƒ((Ú(#}0Zá¹~9iËæLÊR¥nº‰&ñÄà MŸj:/½œNún¤à[j>¨ìÄO*ªªªê©êñ³+®Ô«Tñ˜T.ë–#àr‹®¸J4ˆ(œÀBøÒ SF TÇF„ŒÄ%0µ$0;õ³XMF d”‘Æ/œ ×{\ 7 Ê'z€;ò $•\9…Ba9}2Ò’¤-¯üe:g©mî¹0Çté•nÅ'ÂË)ŸÌ¬©ÜWZ¡€Ç –â¡>>ŸÚó¾:íÄjˆ!´òs+¯ DæÐeIà–â:Øÿà„8@-¹*¬Ó½n™ØÓÃó0TPG¤Ì²ÊPLÕDÊ8«à³ÍZõ,µ”gEÍV\sd$F ¡!„ˆ`ˆÞ‚5H¸#‰%VX"‘ áæ(ªRj1ÊèDšv¶:ì0ЉÛsÍÄn<ïj’É'ò¤–€‡¤–r¥©ªòŒjÞüêqE*x×Ös¿µûÛ Á°€ùaí \!Á$úö[”B2ý ¯[.ΘqÆ:¾LÅ7Fâ3ŽAsUÖÍdÝ|å[níeÚ’‚à6 "ÐÙ7àzF²Xzì‰ÂžeŸœèhôù…¹¤«¬ˆw¨§ëˆ[í¸…3ë“zZsñ„2ó»öÚå:óÔÿ¿§œÒsOì©: ˆ æk «?µòW@~Hå|ô¿"”+ ð»û‡oIü¯ÆqTÊ"'1òAóÿ%æhÕ¹YáG.ÃURa ¬àË V‘ZW, Ù#Qݲhg¨Ýn´]ïz÷¬•ÈD&ÝñÁ›°C®¢X­('iEœxÐ=ùÀ ^ÚÛVèE• àèÞÀ½ù¸Â)áãW¿~P Z O”¢Ï÷ƒÿ¼oo³Ðü8d¿ûõO2'¢œfXÆVÁªE¦‘jh”£Ðͦ6ˆÀnd÷› úŒÇ!–D€Eä| Y¼]ÒœÂÛQ$ÌÊGkgàÙä….ÿYòNb¦ãýäj'a×<âG'²aïúI"øòó‚pï”Ap@÷À¾¬d…nrâ,Ë•­Xñ B/ÅÅuÑ‹!ÒŸþú×1Ðâr•ñŒÒ¸Æ’†5zlüBMF\s5ø(AKhwdBœ°H &g"T¢–Ò0r»§%òœ|\$Ô><àM²…oÚÉ •g”¬ëAxA||¨½S†ò*k%‹HDTzmüÂ+û$>AÉrPåÛ×·¢K«ðc¿ ¦¨øW*ó3$[”ÆÍ4e²2 4cc#Ò¸æ=Û¤D+PWAŸ*ë7j q—4kq F•]ÿ ˆ34Ú)­žÚùœðy›ˆÇW³É ‚øÔ)¬ôÞŠP$–¡ 5e(‘èJ¨L´OZ_,3Z¾³ìëOPñŠ‘`€LÔ‹¨2‘Çþ—Ì3E*“&nʲµŒhˆ(Wo\W¬ é Çñ :…ºÈ\4k9ËÁ p‡;}ä"-CâÇy>ëžÁ“Zx*YI£\U“°á|º×[œ²ˆdõ^Ù\ÁP÷”TA"ÚÞZQ¹ò+@u T¿5 _ # ðë†cˆîv°Á_ŠPzbjÆU$ó i^ «½w¦Õ¼5O#ää§ô˜‡~vÙ×EÀVÎg ÿ\à䋵¬]­f¥tT”\G¶ØÙê„k» ÄIl¾ýá†[Öä~Ò8nCËf•¶5–ßET×A•ʼnc Þ(^ê0ú{\e@C¹V•ls™óÌhÞ»”uîFpüÜj>0IÊÊ.¿<Îq’Ç8Á ÉÉr ¶¬Áˆ,+‘Åj­k‡1Iji¦°ÔÄg¸CèoZƆ¸ÐsáæJ]nt_Õ=‹iYhûbËðEjLRK¦0äí˜19@Ž ™½ž1²‘kôRiÚô5«yMl±÷øQvû¥‡“ÆÉê¿:Á!àr.ZPà_ü‚´#ÌÇg/›œÿ£u %iö°5‰¤ ´†Ã"YQ ÜÿpÄ!.bæ¦}@òJ¡\Œ õÕµ@bQt¢SA‚ |Ê»þ1Qä¿ñvl™ž i6ã^#3öÓJ¦ iJí¢åƒHS^’ö»$%Ááµ¶u®¥eÓžV‚QÈ ÔÒ|bÛ&áÁ›áç²®ˆv¾³´§ýg}éË}­°öŸ÷¥/[ž%PÑívFÁ–D“ p x㔦ªTëqd@“™’ ™€G—‘¡©ØhÖ´¦ÕŒ}),Š„@ÕÄ9Á‘ŽÅÕ6¡ ÷hØÅÎÚöÖ·~pG˜FsJ|"%±øÅ±“ ÿ‚«˜Ç@ÇÚl –•Îiíp(ëqr“ók¢~úÓµó èo›ÛÝž¥¸í ©[c†1æþ"³ãÌœŠ™ÿÍèÝ«²h.t7’M“oð$õb^Ò’–ð‡Ü÷;“Ìnë\¨=&[¾îœå}H\â¹ÝÓl÷b»·Ìvè*u¨§OVïNÙ×¾8h™KAá¶ùÍAàŠÂPàü˜'ie(§ÒȽd@ý©&Pô4^®€1j:¾M³Õ#‚7>@!Ž£à”Äöp/÷Â.á˜å÷@è®C8bi4B#Üî´‰ùÒ ï,,©"úÏÎRÉú> +’(‰ä&¡¶ûÿïN6ªº …ÅêŠò–¡À( ÔÒÈ뼂μÞô4ô–)ô†ŒÈBoôެ4òOVŒ"b8n ÂŽî! ËŽµ–¥¢@á>ËƒÖ ZNw¨Äøôa"h‡$6°¹J¢p¼Šï¤¹+Èf¹®ç“VPnîƒ)ª¢R,– /òhÎæ|á|ýÒMýØ-20™$ǼVdþLé`¤Þ^Š™Jc ›.eDq À/$ % 'ÈàTKqïÕœ€Ë˜e[Às! ™#ÖÉKr!\€‘ÚÍ–Í2" ^à͸gñ­ÚêúúP”ÂG^¬'ÿ ïoÅØg3ªS!ýxTNEE" Œ.QE>ïó2ôFÃíïå-5ˆlefƒšr ¿ªP0ÁòÈÊlQe˲L´‰KâZv§„LHØ(`:–ïäðØÞ Ú¦¯¡ j¹êmò£)°ïC2¯\ÐûØGº,nÎ1ýX’qplY…˜R$EÖ‘M%32é”ÐECF˜n?-2ò±«&h–dÁ˜ŠÊX+µdm cÀz§´˜ÆKª$ "±£¥C rp !”q LIä:L¹œBoîƒlðã·/ýðNàJñ±_ìêÅÌ¢PÆÏÒÏ%ÿÃ1¼&±ƒè óÊ13Iv²1s'yò8Ñë¯þŒÌ™ø5P‘Ž1X ÎIZ@X NeQƒ”c׌ϴ4b!¯RÚ0"¹Ê%rãPHJà”1äÒ’[ *ÜÊSP$ƒSû9ã*/ËgÐj‰+j.ÑZR0soò¤RjÍk1 ³[¥1¨3êíþ`F`dVd š¼‹(@Hô+³ôËIHsʺ°µ¸ÌL +¢¨ ¦´Ð°9’êY’*©0,Â@õANXà,E¹Bi¸ÚJnà ERB‹s3ÐÀ/Saü^’:=t= #0©°ˆ‰T&£OåÿÑQE¿Óè K4&ó30­ï*à3W¿ Î=+ˆ\/õRÁ ˜´5?µ9Ü5{g‘zö€å›æAU`U[Õ” 8#t8É´._Ðå΂î æjûe£Fr|¨«Pœ(£rPbíôC‡•1(&•q³0‚Ð1Š5Ešµc/‘è@VdYå')sô* #(\÷KH}*Xÿ–å7þV"‘Ži’ j^+Âg]hdGfæA7‹–äNI›B¢ÈôLµÏLGrñ´ö¢,€+¬(æVPlIW­a¹V@ꔆlëôC+ÖlGм|vI…c#MYáö1õwÕ‘ôêöTµ7 nîQÆuÊ•\,ƒ¢„‘(¢ipgi*pgI•^OuY¾I¿>³äá0`U¨ÂmðÅBi•s Û"@@,`Pà7ä7£"uS·£Pr–RN×€‡5DI”lÑ1r×DŠ5m£Y›•wß6ãvn¨4|Rs’.o±.\_VÕb'v$âÊ·gçI?ßiÿv6^OõgÊ5_@Ä^€ú Ñú>2V›–iw˜V«a/ @d¯hn/ù’jeÎa×S€Å€_·€ØCa÷u½VD½ˆ¸0#'‘‹3x]ôó>£ns£°«’ÒQ“÷e"„SçT᮳‚ÑYDˆ!åU%â›bo‚`&O@†g¸•ÚJO˜b?Ú`ÕT‡µÏ‡ûäÚ²í?NÜÖ‡uÍBuYŒ@š“íô%¿6X§˜:¥XDwP3&2˜cO2ÈQO“•3±°2ÃZïv4NÅUr ˆy'uhbçTKØ„§×wlÇâAs!‚¾‰!€”9ÿx7¯õð¬ÿø£iù%‘wW¯Í}´V}¾Í@`Ì@òWÛ¬Kb•x=ËY€£8D¿”vß¹1rw”‹u” aw sc³Z¹xþBvZyÿ™vsHvdñ\¿^©Ëx=‘q¿ÆlhÐ~ƒÔë}ïN T«Èå€÷ã>­¿|ñþ‡Êä’ ÓaÕ¶Ÿð‹Ó®¯ºTÌç»ÑÛ²‹QßÍ–m)gÎѼò12>Q¥©ó=¿l4e´UfùE*õ)žýçÏØÞÁÕƒ‡ãQU[™™y™›YI‚…¼òŽÜÃp08xqƒD G rÀ:¾àh dHW\Õ3iàdÊõZºt9ä¥Ì™4ÿ]&’D‚<{îÔ "hÐT R­• ©QCH. 15*Ó§H V•À´Â­hýºõBX®`'\ø0!­Ú´Öº}›­Z $L áCݳuñúÅÛ—®à½b ök(ï¼y'N´˜GdÉóC¾bq‹•å ”Ç‚`Áƒ äÈð€âˆR;|ñ AêqŒQ¤+’¼E–L™rf̚ċ·ì‰³žÏåB‹5šôh*$ªF}**ö¨X ‰ ûý;W±HÌš­`¾­úµëá2‚;A.Zºüê5 Øoß»uïÚÅob@0 5öX‚–%XYg¢‰æ™AÞ#ÿBAAä@k=䈱…”QlAøV’I½Ù¦‘oƽø’I2á”< ·œOÍ RXQgÈvLEe]‘Õ &Yá)©[ñµå”ðM9W€yÝ…_õý•ß_| v_Xþ݇׌ O vVÙ -¡g¤Tá=ÔÐ…Î& ‘¸\XÃIŽ]‡L_"ãCšð¤‘C´T§–bªJ&±’“ôßVê©:‰¡Š`¢;tv²j`\¤2-1p>h1ÞpËãÑ’i¤% hù ddG(ˆ¡—<ÝqP9\Q¸›1óC¼™l¦FÒ†×T$6kÿÒ© :r&;üá6EGÉÑÝ@*MĤÿÐÉÉêМLÉìþ—ÂÐe‚·ª•פDFY4jcA/xÐ\©SÕåh~)-i‘po QHT˜½A9å9saG9êÇ›áÌ”;¤HœEjÓ~:é&K‹c?©‘s’AêiÕÄÒSÔeR`M¡KazÅŸx ûgý9¥ þSEè@qPT³˜(eçQ‚„†N¾$ ËŽ0=‰°P¬C kÎ:ª3@:ó{ß‹[Ý:Rˇ‡é3éúÚG×zÑ^¾UŽr‚Â×#¦ *uØ‘V÷?œ"V°áA'aº6Á´¼g ½ÅA:%ÿ NÖ³óÈlyÏ ZÐjö¼$`„TiY‚ Nà•€ˆ³ªÅ2 €•PqÅxÌǪ{Îd¡¡Ìz®uÄ7Œ¢\ov+I ¥? b]…+ÞÎ5'QL ^FÕ'^²T‚¥®tK0ê6±?]ÃöOÇr·(o|Û‹F Â2ƒf©98*’pÜmÒöždørŽR$Jd’€¢z̯×z:£e³çL¯gÿ{¶…"½×kiwM‡flgaVl/Q|7]Tw€71~7}µò†×^&8nîEc‹U6~¢e à÷‚2È/8~ŽÇxssPr“FF<ðÁ´ÓZNÑyHwù÷!pQ­%jAà öV'B€bwŠÒ=Úƒ8‡ò% C`f[¦v…ôpBÃ"¿‡|öC#œç-ÅR÷Ã|#H%…F‚Üux‡G<íu Ž'8n¶ä^íõmŠƒá'ƒå'~äG~¡Õm%`dK•P1öOÀhÁjb1uH‡t®ðiŸøG­ö_tC0fŽƒŠh([÷j`V!R8±¶ŠUˆko5ÿˆ„f‘âpˆ|ÃÆ9ÆõfÈö{y÷6ηÛ%cnŒ1ÇŒF<&nœå‡ÓZ·ðmÖˆƒãGƒ5ÈÝHƒ„~Þ67‹qF%‰ ÃF'jDØZ'ñixÁ°QŠŸø_@/ç3„Òz·¡(\w`®Ñuåv–cf¾1v,¢)¡HÀFq @/+5|¼¥a/¡+ÉXÌh‡‘x<3–Œ„cC÷O˜Gnиi%ÙˆÛgî•¡µÞ“1 ƒ‹w~;(KïcAH‰”Hš(jõzj G(I¤X0/1A(³8!‹[ç‡SÙLS 9‰’(cFi–‹ ™ÿ‹‘Òkº·v4BlÃŒÈÖlC‡‰Œ¹‘°4’Ž…ctIcÞ¥‡4ÖY$UW^~鈡…4÷’Ýx5x˜‡“5ÈxlDPÅcçAxG§‰œ(R­–L!¬FoPp…Òz {†282{‚ÂQ"…ý¨(a)–`©‹¸ˆvˆt4’M÷f”iYcD6Ƹ‘—V—„§ƒÑì%7'X^ÊZ7ˆ7Ø’‹“ ¥˜Þ¸x'^—Pf””Y‰•$š¨™AH÷¦jµ¡ExŽƒe¸uàã²!Ôã-ƒãZ4$R°6v qº%–¹è•Áa–ÀXÿÁql¿§J9Âùhv¨]ÉY¸’›¶i™…Y8vKšÕh+(‰Vcgˆ0h˜, ˜+*“Þwƒ‹£žÄs,[R„ jHò‰­Æ_Ày¤H `#š [9#`;ÓŠA=‚ÒQ@³">«˜ F (²¹‹ÊÑfš²†V½¹†-ña±wðñ–„7c*KŠF:n~x’›¶—èGۗ܈¢ÙÉ|ê.Êà£1 ^®„C€7Š£duk„”3AŠóV#J”¡9CPÉŠ€$[rš¥aŠ£¹= &4°9›µ9 L£ j˜qÄç›.ZQri!ÿœÇX¡Ú5¡ÌØ^z<Ê—Ï ¢ÇCnh´h7†~Óé’'P˜*Š˜ÖYƒÛé’0*¨‹ÁcÄãˆ@ÙªtªW_qQœø©ñÿ5oJ—˜ù¨…âG "€¨i8€„`@sH!1¥€¯4`ê"¨†ÅѪ»9d@3}öÄãƒÆiF;ÈhšÅ—È¢ ©ƒÖÈ}†è¬}º˜0¸,3é¢Ý £ùž·¨®P_¬2o<‘ö‡úÈGY6‹™ê®©±'Zf804´‘[Rúš$ÂTj¥."4Å…¥Àgw±ú*¸C%tj‡´‘†g‡†—í5’½Jÿ±Ù‡P5fdñ…¬(zÌŠ¶Ö©¬Ü¸àG“ãø]ïñaغ­ù·™­Æ ®H‘VÇz‚¶Šæ®â®þˆ`‡$…$Bš¡:CŠ–b˜–Kk/^zMǦq¿E#&m¹†„ׇÜu‚Üu x(ºä–‚!ª—zxK‹&¶9Ëê~Ú “k«§:¨Hæa× öÆd+Û”!òi8¼wÇ{Ç®²‘©°…€°Ö¸$‚(ˆÂP‰¯ý¸Š?K›*¡C¨ªfr5¦éF‚ð!ºjŠœjšºïÑhwØœ:¬ĺzX^%I¶6Gs‚¢f»˜¸»PʲÿPݨ¬ŒÁæyÿe¼…ãÈ«jTæ_AF$®8óe¥i½([[ÙšZ©(a'¹’»Ló9v»q|¼w k‡9š[£’Eër·zµÿ¤µƒÇµókxó+7<˜¿Âªsä¶hîeM|s»±Þ¨»žqÀ hò¬Ü9²Œð[RoK—LO犫fz|DHõÁ‘L+»zÍtkÅŠOjŸŒC‡’* • 6š93šÔëÂUz´‰qð2¾/rlyW¿éaƒ}T²]Óxxôkº¦K±^˺%Éhc;nŒøÄ.Ú̬ ádÜhÅ,`'ÍâdT¬»ÑÀó]jÙÚÿZvŸbõi°AA„£·å„@üvÔ»LÖ+Ìt¬p ö½YV̼£ ÷ŠH»Qª ùª˜Ã iÖê@N²ÃÈyºƒ—‡’úHÌÌÌ‹R¥$Ñ+¬Â¤ú(q¯r ÍI›È IÀæ(Ðl'§m”ºï;ÄÞ,ÉB¬œ\‹œº—˜E¶Ø¨Óàh»5XÊuÀ—2r¦ŒÙŒ9óÅdù¹'_õT`ªç Љ«'MHúQ-¬u[TJ‹ôŠCkíÖ}<Û¸[B;´æCÿÃ0BÒcˆûÑ$Ñ·Ò ÎZËÜ͵>ÉqŠY{x§8½Î$êØ3謇)ÊÚ=Ùö ÞòKºËFB3LzŸ¨‘M‡Ë>¹zU9k Ö¢ÊÚZè߯œÂ?ó½!…©ÿýšÜkCéÌМ“â(gÃhýf…!6€‡Œ>nn¿A¬Ò„ç]4v‚`N¶,yÝ> “º;ÙÔ"îÝß2—mÔùnÈó×êÈ»ójSÇÆ¯Õ33+Ÿ¬íǰ…•hý3n5Û(¼Âj ÍdW9¬8´¶àÄ‘à úp FEÄ6Žœ©«¦Æc©KꔼåÚׇqª}c^¬î<˜= ÿÏgNâ …ßM%dÙß½,á6_O‡ÞwDeõEô§·­Æ87.Ö̬u®ßΜè ö¸û©oýÌaYªc÷j¯y é"mlwÝ›'å$1Çýr¡žµ¤KÎ!¹Üa.n¯;ÞµØ~sfźë§rBBvâ<~ƒZ1ÀÅõq«¥³øùiAà²z»…Áj¶!è¡ì-ü®ú-Û*Ì•Ýû3¶ 4–Sí:Ç Yª+—žàgf™ÄÈaÓ–æÒ¦ûŒÏ8áó›¿2ªAíeKÕÝØ×ýØRLâ¥<ÙFmʼnÃï%ä<·~ë¿ÄáöP!ì­BLªõDxÿõÿ0ëç˜úeýH³f H(Œ©¸áèTèÖ^Ï(KN×ìÇK®{"qéß.¦t¯‹êBî[$Y ºYN¿^Ý䦇Í9sâæˆ6ÖØõë¤ÌøÚ=ÏûŽëJ!¨uÊM¿â†ðšÏ«Z«ö_Nè¼AÐy@‰¯®ýöÛã#’cÇÂòùãäAKÛÛcªH›qªg')åCÜ›ž5Ó·ÜäìÎíÒÊ)n<è^ÅÄ<ïóïlh¾Ý eÊünIŸôÂ4ÏœÁ~ñJ=T?eúå oN‘L\[à;ÂÍ.Û/û¹¡ÌÛƒY)ûCé,ü•RªQ¯ž+ ¬Çÿ£ÞÁòp¸Ð€ .L¸ða‡‹<~9‘HŒHL a²äÉ‘· ÜBi’F2IÌ»eç¼›·Jà,Q§Р%Xe‘T)‹#K*•ÇtÉ‘{Tï p«Ö«ª6ý9"„Ìš}!/ާ-ZôèÒ¦OŸFm*êøªXÍoÅZõ(£ÿ†$@@‹áÈÙ ‚˜Í`ä!÷íbv ¾‚pL0Ã<°1ÎL0^ L2 ˬ°%[M5Ò$RMµÍ(ëp´‚ b-¡Ö"ê«¡Û&ªHŒ^¸‘fô&^ª9‘dÊ ¹™qI§é^Ú©„é®Ë.»í¼ë®;ïÀ¯¼«Î£2«#ä)±.(ƒ 0+/ ÚÂÏ#0àˬµ0à WxxÌ0Äl³:ãTð4£Ó°¿-¢@â0Ok(C×b‘µˆ è‹ÄÒ‚h‘7Ž4ꤙBJi8‘NºQ%•‚¬n¹y~Ô)§ž^2’( æIÒ(¤˜RÊI'“ŠŠ…ÿ©¢ÔJ«óÈÊ+Y˜G¬ ÊJ LÄŽ(+?3ÕêϬèBL¡ œ3°lëĬÛÄ|ÔÞ»žT±Å$p"Ž2:[Fµ&¡S™†³§åÁIHŒì©ûVcÕ8)¾û¦µ;ñxÝu¼ó?Y€”ƒ5«)š….fßÊÁæ xàÁ 0ÐÜ^`—kå,Ê Sb  sÍx’_š&§ %æ3¡Y×ÔÄÕ w1-2]ÛÚ£Úµ"¿€ÍÉÛ×øÕ¼•DT3•Žd¢UÍðTDºO€‚¤#)i|KʰB6ž•±p†s_’ÿ,¬ŒÉehQÖŽpg™I/TÌ€çêò3(JNr ŒŒÓT‡™Á p3¼ Mw˜Ú! wŒÒÝ%S NCŽ ÔðLãÁ?Q†@!Eþ’͈% ˜Ãd7ˆ½ 'ÛžI¬³·ú)âiÊʾB8Âõª‰‰[¢'Ÿy\ ,õÛ½”?3½À”_šœ]./Ö.s2û¤™;1kL£ ÌU; â.ƒ¬ù`³Á8FÏì7c( TóÜ—E£­M%‹„áÛhˆÕínЩƖĤòQ“äѤúŽÀÄ$îCû`ßV @–EÎ,,ðær°ÿ˜ÁÒs}é¢ÁdÁké²ß2Zdc¨Ë°.[§Ë–ˆ0ˆ‡„K2²à»îè¡å+^aÚ_VЊjú‘(TaÙ4E€-'`7B ÁLèÉdn›Xt"Ytª(›•SÄó·"vÒJSò•É@™?|Z.“ã©z–f±nßý›ºiѾ†³œÅ…3²dwzÙ{3çTÌÉ«y>bé;˜¼Ç–Möå/‹R_3UwÝë”@L/p…Å…mÀ†õLýs–æê‘˜!$€Ó ¹³´i7í¶‚-Nä.‰÷ÌÂNiJ´D< <žËøÜ²º„ HxL÷QÓ²ä„h$Hoï&·†mV:Ü»…OLßoŒq,IW/œÂWÛ¾\_Î}­MðɈ-&€¬Z¥-™•ÏyiûÛÜZ잀»h¹Ï'æ.Ä@•oÒå>·_šßAh0!bLJ ÿ»;Â<ݹ¹.ÿ˜…\Œfiÿûq1ÿùcàŸÁ<òΈ§Lÿ¡z:#±¢’² ˜Ž$•ð™¬+†«½["Ë1“ˆ›™À˜œ½°8…ú®º¨8 0¸»! à4W —Â8¹è£ãº¶ë²9À?ܾ;1Ds±ß¬ ¦á#h?ù…³(B 8Â÷›y(»Ô2 y˜zxˆŸ ˜ø¹Âù8‚ëÐ,ýꉢH@²2\Á$.£=Vz8ÛËŸ{Ê+ Îi¶þÙªl“cq²A«»V°»¾È»>Ù–<[« 1ž{ùAì*¿ì˾Þñ6Àú_*7óÓ#a*BõÿCÂ+ö›KÄ€¤¸úy`?|PB$B$(Â#pºC½I'íXX™„@V²6ܵËiÃÍ;%¸xzà‹þ6 Ðɰ¸°; €>´ È€¾@$&A\ QᦜC·‘²“"›37 ª#I„&$4‹#,B÷kÅV¤¿÷c¿-Ãy  '\Å"¤Â|DÇUL ͪŽêx•ÖÓX18¥ 0©º§…´§öiÈ›éµ-ZzÏá´»ø­(ª–´‹3WÈ¢zh…ìCç;½ã»é{ m$?„ ô+¥9fúÆ 4iÊHÑÆ¾¸…žìIMÿÌ K„Gõ[8{œ?‡ \ F¸ÂUd„~dEVTKK’* ƒ,@HªØ²©B0Ì©À³Ì“[š–Íù¸/#+HAÏipÆ…à h£Æ b.éË gÚF›Ô9ÂT14Ó £Û‘¦t­<=ÂÄ÷»‡Q8­÷kʪP¿ à‡ `¬Ã §L-xÄG³¨ÊuÄ|ÀršÄŽœÅ0t½*æ"œ- %÷aÈ]܇›Á€è‰0¡Kˆ€­‚ ™ÙÑ¡N£‹IŒFs¡F“,I´”Ô#;âÁ DäÒNÄŒ0ª®|‰š»#™ nÿS¹ÂLzG!œ¿öìL~€O!Í{LM\À}…ý4 |8Í«Œ¤)ÛìˆEX³E)ëÀµ1sÐ0»±Ë€i¡ÈÎ!F¤–/J%ܺ°ˆ7¹ËVDºz>eAl«‹+GF[IísIE——L+tÙÎo4’*õ4F°{Xªx8ñ‡!½‡"=‚à‡%-ªH-y Ũ B,<‹•‘+uE¦û‰q5ÕÓ›ðZ¼$+5™Û³=|ºÛ 3½èŸµlNÃ Ëø-¶«³6!+…xξx6:±F¾›¨mSO4JLÊ+xÇQ¼’ Fy4î‚+í´»  ;scikit-bio-0.5.9/assets/horizontal_powered_by.png000066400000000000000000000352331446255456000222230ustar00rootroot00000000000000‰PNG  IHDR-Чá¥ÍsBIT|dˆ pHYs × ×B(›xtEXtSoftwarewww.inkscape.org›î< IDATxœíÝy|Tåõ?ðÏyîLK6E°Ö*.uïbõ«(¸ÐòµŠÉÌDµ?lkU°*;ãn€ÚZ¥Ö/™d2 j­uC¨u©ØZ¿Õ¯Kmë ²ˆ!Iæ>ç÷G¶™É$s'¹“¹IÎûõâ¹yîsÏ$arÏ=ÏBÌ !„B!„p*•ë„B!„¢#’´!„B!M’!„B!„£IÒ"„B!„p4IZ„B!„Ž&I‹B!„ÂÑ$iB!„B8š+×!„¢ÕÌ•¡â~Úu´VTkpÃ^ÊË«ºõê9»r—BäÉæ’B!Dn]µj•»dßÎïz*@“ô‹û´IŒ[—^?a®âBˆ\“¤E!„È¡y÷Üz¬iòï>¬ƒf&Õ¹†.=»ª»âB'‘9-B!DŽ„B!—©õ³i0¸_Ã!Ý“B8‘$-B!DŽÔ©ï€1ÒJ[&Še;!„p*IZ„Bˆ1M`µ­b³!›±!„“IÒ"„Bä.Ë«x6h—$-Bˆ>K’!„"GXk·Õ¶ù 2K’!„"W2¨´íÙ#•!DŸ%I‹‘®ºê*ËO …è©8ƒ9-7ƒf6cB'“¤EáHÛ·ï‘ë„Ⱥ *-7‡Bý²ŠB8™$-BG"2Îu Bd3³Õ¶»‹ŸÍX„ÂÉ$iB8‘’¤EôzÄTgµí¸ûg3!„p2IZ„ŽÄ #sƒÙÆŠXm[ÓRiBôY’´!œ‰Y*-¢×#Ö–+-Ê%ÃÄ}—$-BG"$-¢×c¶^ia(&„è³$iB8”TZDïGF•ÍRiBôY’´!‰@É^-¢·Ó:“J‹)•!DŸ%I‹‘TUUUë8„È&be¹ÒBÊ%•!DŸ%I‹‘(0(×q‘M™¬F2K’!„ãä5MÀ×$sZD_À»,5SRiBô]’´!‡Ù,hú‡TZD¯Ç kI‹TZ„}˜$-BÇ!j™Ë"•Ñë)‚µ¤’´!ú.W®Bˆd̪ q¨?I¥EôzÌÖ“¨iLÖ…B!U[@g‘Rã Æ*ÔÀfC«oýÅœw»#!„¤Ò"„p nFRi}[œÓ3V†Š²K“9+OÜ_hüƒH½Æ/Á4 ÿfàLnÔÊüûìK~ر! I‹‘+, H¥Eô~¤¬&-Èï†egß}ËyÌø€c:h–àšlÇ"„Í$iB8N󜂬&úë•RY×2÷Þ¥C¡UIIš`ø_ÙŒE!âIÒ"„pnY5Læ´ˆÞˆ¾´ÚV³‘ÕJ‹Ó‹X‚¦™Ë³‹BÄ“¤Eá<ªe©c©´ˆ^•剸€6³Vi™³|щþ±µÖüÄí3ü)[±!D2IZ„ÎÃ-©´ˆÞOkëI Tö*-DwÃÚ}A‘¾>kq!D ’´!¨¹Ò"sZDï§c$-¤³Ri™³|I)ÿe­5ßµtFð?ÙˆC!Ú#I‹‰š’™Ó"z¿ê¢ƒ-'-œ…JËõ+VôgâÛ-6ßbšýoµ;!„HG’!„µ$+‰ˆrŠYöÀôé j¬´%Ø_iéÇûf8ÔÒõ‰n¼ã†öÙƒB¤ãÊuB‘BsÒBg €½¹ &oåWRJ$ÍÙí}o%xLÚÂyy[víÚµÇÎþ­ÇAê †7¸Ý#•Ò#aòÀl\‡Õ)M_°al­ªªú‚™²q<¸ðtfnçûåz«ªªjw¶®ˆvµ‹ì°­IËì{B‡‚Œ›,5&¼¼tƼ¬¬VXXxað±©>ghUûeuõæLú+((æV8۞貯jÏÞDzùsžMç¼°`|®cÓ ýî½µ>ÏýÅÆñÁX6¯å†òªJbßK×.ærýeãøàlÆgm åáŠ5Œ(?Û×KÆDu†ÉÛj öm{õÔåû³uIZ„ŽC@?núw,ë&-EEE£ Å Á˜Œ¢‚ h€A€Íµ!FS¿³ƒ‹ ÷xƒ –îÚ½ûy{¯–hĈëÔ^ à§%E_3£ùµ"KE0b€‰CIQ—î#Ó¼¬¦¦f‡­ÓxŠ@)—øeŠ`“­×kñ.0K׌mÞ\’µq;ý-4Õ¤ùZ;¯Ï0p:1­O}aþÀ¸Lús¹p4˜zÌ’ÌÅÅÅ%º)A¶mÌu  4` †iê‰nðbZñüÄгv_kçP 6LK¯û>¶ûúgm 6LóF&œAŒP L¹@e„µƒ0qÃÂjÛ¼¢ßþâY‹>°ë’´!GyÍ·ÃDÓor׈ˆJŠ ~m®„Í• pCŸUR\¸dx«ªª>±û"CŠ < ú€¡v÷"`83ÝM\\¸ä«Ý{–æ0žìÐô%ˆÓ6#‚m•–›V,ú/*µÔ˜ð›¥3üÝ®k ‘E ÀÁfâó&nXðÀåaBðÝ\ÖU7Ì¿2@?`XxËÈ…¢¦?c•¦i7,\g˜ÆÕÏžìò'™Ó"„p»›ÿmuîŽÚv·ÁEƒ~à*8ä¡ßVl.·»ß’’’bÝÜ&,ÉXRR2ðÄ\b;b«“ñ²£–wÕªUnÕ˜¦G¨Š™æü®^SˆÜ ã€ØZo4ä¨`Áä^„Æ F®c±Hø‘i˜KìêL!Fµür©󋆈 Ý’ë8’10¥¸xÐ;û$6glgŸ6!bÕû*-lyƒI÷Ì¡’®^®¸vÇ\ß´Ø¥‰ð~·Äј·[ôS±áèäk÷F£ÆáDÿ†•‡&)¾²Òã1;s­\ŠÅð®[±¿«ý00šˆµóÙZ0lyX°»zwo_FºkŠØ©_†íÇx£^£ÒSÙã~žÑhû¿„݉FwµIZ„NÔrC¥9¦Ò¢¯µó™]_U×TtG%%E#ˆ¹MÒBÀáv]C)st»wÐÝöZ‡|—‰R&- ÝÞ÷¢G"¢lñ†Ä`ÕéJËáŸÿóF'[jÌ|×Òë¼ÑÙkåRÓ*s]þ9RTô]·“´PÃWÕ{ºåÿBOg˜ÆñÏž´õ!ÃY›BÅJ7¨ãˆé2€OIsJÞîⱇøÐÎ8º[yÏ{ƒ µY% 1øVÇ­,Åß!IZ„Ž …âJàZ›JZpˆƒt4tèЂ;wZÚ¤°#¤‘ mGLYC¤Éu vb†åJ‹&=¼3ט{×ÒqP´Øüƒþ5Új[!ºÝÆñÁÝ^ðÒyÏÍÂ4Ô§éÏ¢‘èI hŒJ×Î0KíN­8ï¹Ð8Ó0ßKÓlˆÁþ-*I‹èSÖF"ß«•ñÇò œáñxêíè¿¢"úh:CÌu¿÷L;úî+^ýuw~ÿÂøCކ£o”c±Ø`XÜY½#šôH‡.¥ÙJ³£¿™"Ší`‹ÃÕ È8i …BJ¿`eã9 ¦+‚ÁìoŠ'„ž=wñg7,Ü Ã*$ggs©,›°aî08éwaçäMØ0w&`{g;¤Eô)J«b&þNü±}ûjm[BC qýêì껯4h;7âØQÃìmÂ×]öxÀf&¼îr™¯ïܹg«s¾í;dÚŒ‰œô½è2ÝÐ;¹­=;ad><¬¶Àu-Óîà ¾gÙÌù¯fz !r,k;±çšiäõ7Ì:'Žiäué}[’!„Ó$?MêéO—l¥5ž2 ~¡ªjï»Ììì1\²Ûnº©föŠÅûa!1&d6<ì¦;¡\°¶Oáßýh«+‹‰nTRRx1޶£/b»vï¹Ó޾„è.’´!¥®Îå6\­÷âZ;ªÒ’sÕÕÕÿÊu ";ØÁÀ×ÓµcåJ 4Ë… °Ðœ5ó•ÁéÁnŸÈ+Ò#¦À¥vôÅ@€>—´h%zz2IZ„ŽBÄN®´Èp¿ÜÑ>ã]ÞÕÐÏå: »1°’Y®´Ì^¹xã­´%ЯoŸ9ÿOVûÂa¥k •û?݈ÈIZ„Žâr)·æÖ±»DNª´ð§ÏõèUÈø˜ß`{wРÚ÷?ûŒ{í˜u ¥Òb[ª´ÌY¹ÄÏ–7‘¤óûÅfYk+„³œ½qÁX’¦Ù®ãƒŸwK@"+$iB8JƒjpfëÚLÚAI }–ëú’]»w?ŸëºSS¥ÅŠA¡U¡ ãšµbÉ· üÕkñÿ þ,¸×j{!ríügç\Ÿ§N$ƉŠijºöÄøŸîˆKdOV“–‡£ÑQ®Œb6¶æå™_x²°«îªU«ÜEEE‡Æ€ÁyJýÛãñ|e÷5œ*54`´aèÝJ©³ñõ—Ê=úèc\.]WXXøÉ¤I“2"³víÚBv¹F+ÓUãvëÿd#ÖM›6¹¶nýj`'ŠýÇï÷i÷5ì …Ô¸qãFÇ”r:ôŸãÇå:&§0bJ%3¬­Û˜>Cêµ€\\¸)˯#¦­L´¬·Â Ïªªjžcf²ÖKa‡Õ Ôb€S}nþŠ%£ü8¬-o ¯\:cÁ Ö®,DæLÃ|oↅövê2 ¬ÏPùpßÀ½6 º[ÆIK8¼îë¬ÌHóÇýÏ€¯ôRˆD"GhÐtfœà0 ÄÐ` WDßx‚^ãóù:µ4çCO>YÐÝO˜qÀ‡*,>Ôd Ád„+*wø'À€ðû@iéºöúZ½zu~^¿Ï2Q¿–×Cú¾@iéÖ¾‘êØ–s™kÝ.:ÇÊ ùÚÊÊÓ é®Öëò®@©w2ÐþÖuk#‘sS)G¢ñÏ0(Àd‚ir]¸"ú/üšÛ _y<KC)‘ûꤖX´QLù¤¼¼ü8qó˜±G¸ÄdBUu ‡+*_"ƃ55»#Ó§OoHÙgeå`L…Æ‘L8’ ÷bÊDƒ‰úµ•ÿ&Â`¼q`@þ½W\pA§ö–Xj˜|€KŒ†‚†pEå§ ¼I ×] ¿ôx<9}ЉDŽŒ®Ó cÆõM“1€LÆÖm;êÃÑ÷Áü6½²·ºêÁö¾®®¨œÉ –ɘÖfƒû©S/Ú‘iLáŠÈ½ Õ²‹­"<î/õ,ËüÕÙG)¥tÜ\Ib²mIê.3ø“vö\,åýx; 0@h ¤¨`ËࢢeU{öüF’—žÙúþDj8R$-ׯXÑ?ø 0¶tMà™F»Áz”Bô8/˜†qù«§.ïÕÃKû‚Œ“"î¸}(”áHd ˜PÔΩÀÇX¦¡–¬-,uðð¹VŸ0G£ÑÁõ1}]>Ñ5 ”tÐt€S:ŒiáŠÊW˜ø†²ÒÒ¿$7œ6mÚòŠÊ]_Ô|ŒY™Ò&-kÖ¬f¸ér·ÞP‹áti'2’‰+¿_ó/ÑN‰DŽÐLË tAáú5}}0¥Áäk‘Ȭ@iiEºX::~o"î‰DŽd2žGÛšÀ™L ’ô9„Ãë¾eÞÀÓÜ:Å €<Žã(ö«=pMy$2×_Zº$mñV¯^Ÿ—?`…LÐÞMí¡`Êà Lüxm$r‰j·iVQ8½LK èŸâ%æ|ǹ¬ °øgååÑé~¿çµT±AÏ’Éw!îKk¸~ ”IPáðcc ègñ?Ã&øg™ô‘ ZkŠÿ¡Ñ䜤¥ªªæÙ’¢‚O`a²t7â{KŠ Êœšë`D×ѶXjѺí^-Ð,ì[ ÆÉ/ùÕ»}•YªÒ {îØõ\gÜlG_=zµ:ªØ0á–‡»² »pŽ.c+\Q¹ ™q‡5ï3áM dà›Ž@ëM–AD7nݶãÔh4êñx<Û:ºÆ#ãÔãD”*!ŠñO¶8 hóté4bz-\º \‘ü´Ý­VqI O]»vÝ!eeS:œ¬¥Ü SêfYñ…H“´D£Ñþ \œpZбÇÑhÔˆ™¼ˆA¿@Û”Àgþ À8$.iy(˜ÊÕ?×M»ÄãÉ`™Tý5“éAt¼³ì=ñÕ€P(¤F9.HŠnBÛ! ` ‚0ÀÑ6’€ÌôP8Ryµ ž6µ´ôŽ¢ ‡×Þ/À:ŽOñé:ÞgÀDc×\E;‚˜þÌŠŸ³–ÙÆ—Wnጤã_ô. h4âŽñ+k#•«ò]ëñxvœ+óxÞ G*Ÿã¿ãÿ4.MnÛ6ÌÄ ?Ã/^RZúf&/.ÚTZ´vLÒÂÌõ%%…!bXž+ÐM¾;¤¸àâ]»kËu ¢+8ƒJKÛ½ZnZ¹x!¯Å.v™“—Κ_mõš"·vîÜ·€-ÈörõLt1—o˜pË_%aé=l¸àc´$,LxÀmÐà€ß{L™Ï;ÕïóN ø¼cLƒccÒɧ7Ä8 …Úcm$2YA=ƒ6Ú  ¿[RT0(à÷ðy'|Þ‘ÄæPfL4T†= 1¾?¹ÿÚ=U°3¾c¨†¥{ÕJÙ†¦;·ÞÄ [ûÂÿú|¾¿'·kÐ|?s—°0° DW¹ ðy¿ÞôºOþðƒ÷ ´Ac^“ÔÍiÊÔ/<òÈ:KC€‰ËÚôá~ž"`=€]öÖÈ{ þœ#Çu-Db² D3̆º‚€Ïûµ€ß{vÀçývÀç-PÐßp?âËŒ“ÓóáðºÃÛ‹mõêÕù0b§HX^¦SFŽ6ÈïóžðyO9bØ 6é8~ßÔÆÆ÷­~lâŠKXbÌ|‹ÙàðyG|ž‰_é‘äø24~m›1®ŠiܘªSÒt{Ò¡áõ1ö[ *¦Æÿ'­}2Ýaõül2ÍXÂû9¨Ò»w×< àñ\Ç‘ŒAKˆÈ9óDÆ”R–‡x2'VZf­\ü#b-žÞES–ÎÊò¯¢7Ê#æ™6Oذàó7.üNÚ3D`ßÍ£F&—•zâñxÚ<¹™êñ|ð{' y áŒÑG•r™Åòòòƒˆi5ZŸ–À•|ž‰>ŸïõäIá~¿ÿË2¿÷wбqmnà ek+*¯ˆ?4}úô0‡Û)OG/µ¼¼ü €Ç·óéÃÂáè pÂ*Œ¶OmËË#×€ñã¤v•º¡nt Ô³*y¾J0Ô—x<ÿ øJ/%¦IHX…†¾®\±ÊŽcJдl ‡ëÔ.óy'|Þ››С zì´iînnŽD.eÆŒ„O» :"Pê¹{êÔ©û’¿>Ÿïã€ÏûSb: £¦Ó0Ê\ß^"›—?à60¾™ÐcÖ‡¼wF àù[üpÃñãÇÇÊʵÌ_Lž{rÅÔJK&6#a2,3ÏO•Äùýž—$ #•ô=è@ƒÉ?A\eŽ€wü~Ï3VÏÏ&Ã0’G:êFœ™Í¯vï¹HC} „§8e…±EEEN¶&:‰¬WZÐZi™s÷¢oãw°¸7?]vݼ—:¢=ÍJãÏ7,¸:׈®³oõ0E |¥ž?¤iÅŸ7®¨œàôæƒDXFïk“ìq+Zn ›:n(óy“Œ@U4½¼ÁäqZ&poyyùë~¿ÿÿZCçßiÐu­mÒ S"þFŠñRüð&}€·RF‡p^Ü¡úX½{mR›"&JxbÆ ×ì»lÚ´iio¼ý~Ï3k#‘ˉéé¸Ã§?R½àŸçÉtç7ùKýýW¦¸Ç/¢°fÍš†»_ÂÄmÞÙß?ß°0¹Þï÷ü)\Yy 46¡å.7fܸK4·¨q¾ ®IºÖ“¿7¹êÐFÀçY®¨<Àütm³€‰éRŸß÷׎ùýþíkÖ¬/3ò>£¸ép>«Ø¯LJnOŒÛ™°¾õ*8¡¼h5(Çc®]½’ þ€æ½he\à'Íí|>ßßÑʷãžà7[™òòÄjÚ§HÿBC½Ñ|€H]¤.ÓÇbÚ¢–¯;O^zéE»’Ú”7Ir‘.+³°4++-ýc¸"úÀ“›à+XKZfYI”»_)’æ™Ä—e²XÀë})\}àÖ —¦+‘”´0ÅJ“æõ×±vÅÏ¥êÐÞA–Ú[; À!Vϱá·~Ÿçe+M§N½hG8]ð½­§ãüòòòãü~ÿ?âÛúýÞ'‘÷×|ŒÏ@š9U &ˆûž°eoÍî´º‹RJÅ@&í¬áaɘYØÖôçoÝqÍ’â›)UÒ¢Õ׺ãú";‚Á ž½bñ—,ìxOÃgß}ËyPj¬&,à?ô¯Ö)‡œ ‘M†éÚðì¹Á÷³Õÿ„Cw›Aë½^2E¬Vy£Þ“+=•²ðDeËÍ€…2Ùw£i¢õ+ñǘ•/þã~ýœ`PÂuHß‹«K5++ó¼ FâäT¦6÷´:ñ@ê!bÑht0ÀgÇ5|Úçóý•ž ðqíÍË`¢K>Ö)6;¢¤ø”––þ;UaÖ»ÁqVÏuu8¾1'ôÉÀ¶ÎLæ&ÖÏ%HD(Ml‚§)–Ÿ*OŸ<¹ÀòLcë2Óµ8“æ#‡½@„zV*ÕCÔIG.X~£Ã _Ÿø1ÝÝÑËÝMk0Ä…È9ñ¸W%-CJŠ .)|ypIÁ½CJ ¯()x"%/JÒÛXš×ÂààՓ°˜°0ãnè烽}Õ(Ñm8;ø&çßväø¯3¶;âÙaK¥EiÃÒ n‡àÖ} I7¿„o'ŸÂ ýÞíT€„·øZ?äo†B!•ðæ­ckAÆmhúš´7D,¦õ¸J óú¦øŸèÊ–ã†y!’n#‘ȑſ®­n7=›®Gñ¹чTTŒÏìEŠÚl»ôõ‡ž|²ÀBä Ë›t’:6>T ÷;«ÁIùhIü×? ©1cJœËdœÈÓ{œzsÀlÙLù$“Æ —W~B뛫N¹RÜÖ4˜X„Öʉri¾q‹cÄ+/ž“”îѱúRµÍ•äJ ;l"¾“1w¸â_Ï£uˆNè4@0PRTÐ0¸¸ð]fz¨ªºúž\‡˜Û¶m’ÐñÉD;•2ÿ{éM7uj?,!zb|À”°ªf ±£tî^Räœ7õn·™ÑM€‘°/ÃÿøÇ?ö‹ÿ‰ vwfó< nó:`ܸq Ù¶ßïßÎ@|‘r1N\5¬^ë†?SâjBÌ­Ë(73™¦&µy8E…Š|lâ!ž¬ 6fúÀÝÉ}÷ßW—ÔwJ$¡‰±2x|çbå¶Ãþ\ -¿¸ÇŽ;Ie_bþÈzœ”ÒÝ;ÞŸðAgNcJüÿR)“–¦%޾Ï̸â¡'Ÿ,HÙ¯â_$ZUVV¶§31f sb¥æ$*~ߨÞË àx"|/×dÉ—6÷·ÝTjâÒÁmîW‡¡äERµ92ûqˆléò/8þÉаfÄø4ùPuuuË8ûæI†q2~ªÞÊü0ùH«1mb"þ]âÄ!b«W?^ ÆÄÖÏã…æ¾Á……σÿë{kÖ¬  ,¾?—j;4,‰ޏ=Lì§I߯Z2Ð¸Šš•±×CL™þ¯k IDAT-±jm´™‡ÂLgÚ§Rêctã¦ZÌû¹¥6ß>¬½¶nƒîŸxæï¯»"¹]yyù1à„E Øt%'¶9—¼Ä1‘³V"¢ƒ Ç•”]ZTT4:×ñˆÞƒ™ö¦oeÙ§ÚÀÝqÝܤo*DïGÜ뇗öj]Fm7´„ KÞïÇ0Œ¸'LzkœëÖÕ”2¿–a K¾M5m†?•>YU]S h;D,¯ÝˆÿgZ×üÏI“&Õ­­¨|Š€æÅ”ËU€ ¼ÖÈýœ–Áƒ‘n˜È oøvIQÁÉ($f¸@“d°y«í#b O‹­àºXM\|í¼ÏÒ·¢çc‡®4)ìcÇœ–C£Ñh^&;qƒHZP~WünõÄx'éõ°Î\§ñb4.yþ>³ÑfWÙI“&Õ…+"ý´9ŒÄUƆ™Ä±'âÏWŒÇ˜Z’°¢‹Ð”´hŗħ©öf÷³ WTV#n3M"Zï/õ,KÕ>—o–#ŸÔº7ãé€Ï³ÐîkUøÉ ½µ Ç!ã'ÜŸïÜy˜²s©ïôFtê,¢±I?³Ù‹´Òeòµh݈ôˆÑãÆ}ÀS@cUŒÉH¨ôkÇ,sÏК8.csÂæ’̱ñ=šë8,°kÂVOØAº'Ę1"ìµaÿîÿ5M}î²tjHµ=÷Ú}ª”nànzÖšU¯£ çÛƒQ—Ù„@G$Jx’ÌF›Õ«ŒXLµ»Sz‡˜Ç%ª¯ßÓ&i…Ä!bDT 4îGÆ9-ÇAöûý ck ü@ë5cÂCO>YFóˆákº/Ï Ž6{|;þÍ|z{ sO%Ä¿¸‚šVþJø̬3NZTwëxVœ¾UÊ3“â¤ÿKݮѥÏ0öû!V-›“2įaOx6y e§`N|\‘üqnpU®#°BöÄÉh³A°õˆïI¦´F+-´¡ŽÌñwÜ”„Eôç=wã@ ;÷NЯÎÝ+Þïºú:ìY=ÌÄ©€õ ÇÑh´Üfu°„e‰ÝDï4´y;@Fë|oÚ´ÉÅÀ9Iw=o¶·‰Ïç{=\^ùAÜÊMß ‡×}]¹óO¸u(ëuÉçNŸ<¹6\}à)M‡úõ«­û~=POMC΀€Gã«Jɘðâ„Í7O[µj•;Óei×F£G«˜žÐV­x‹Á¼Å0Œ­™ƒÔ>þ€–½`@øÎš5kN:5£_¼‘Häj23¶0·j·eäÈÁ[âw¸ø÷ñ+´8-Óêt ÛðÓòõ€ápôä@ÀcyÿŽŠŠŠï*a&ÝaÒì¢;ÉäihݤóåååÃý~ÿv—%´e}‡Õxº›6 ?&~t—ÖîõíœûSâŽLQ€;a W•zhX3¥ñ~×iñ ‚¢e’W~êÁÄCLô &h¦£±Âµ3ƒ~:ÄįQâƒð~.w¿{\ÙÎ))™L¿ø ¡«ûlçÎ#¸´ZÅqýÒá1,±r‡£ÑQ.Í7¤ÿe3¥àr+M£Ñ¨¡¡îK:¼#O©ÿMwn™Çón8Rù¸eÉG”ëÒ5‘È ÐI­-éïe>߆”8€2MF܈0&Îùísuuõç%E«î:+[näµV[”Ó³¦Þ™´t~NË.ŠÇ|ñáQÈhH!²Ï4ÌÍ7,´õMe àÎ,ɧ7Ò·q¬Ï¤YL‰níÞ]Z®k¥Q—ß³íÛH}L/pSº†ápôÛP-sFšp¹ÇãÝ–Ü–‰æ8w¨Fìþh4úC+Õ‚G¢ÑÑ Hž_±Ç­ÐñîßÚµFl1š†Ï18 ~Ó¶¿¶›8™õOÁp×£inßçÖyðï€×ûRG—?øàa[·mŸ¿Ó9ˆf†Ã•ïÓÆÞ$\QyßI8H¸ËãñØ–°@Yié•oøVó1®(/¯|Áï÷–[飼9—¥Yr¥@Ο3s}IqáŽ6K±`âß ..´iò´5”ò¸Ö¶ÜÈ—TWo­.j÷¿Êñƒ‹ ³¶³uj³Šd Vö¼V§!ð¾NæÆCÀ¸Ê4õU³W,ÙÈÄ÷|4jìï¥ê""¿{Ûˆfíæ\Ñ’Gëò{¶m³zˆèÆòŠÊÕ;Ƨn®¨¼Š7 K˜þ›ÍØÏSPæó< ÐS ?h0ys8=¹½XB¡Z[Qyµ2ùoHÜ-ØÔ ©é*BM Ië“hÆ †´Ä@ÔfhXë¹e{x>îÐ Ä%-DÔf™ãdãÇAÑÏÄ#(U m¦®žhW°ò[>”ùz¸":­½ë<òȺƒË+*Ÿ` Í¾;ÝÄM„ÕáŠÊEhçnä¡'Ÿ,WD`æÄï㥚šêû­^Èï÷¼ àµÖ#4ÀÕqM>5bhGó©rN™‰KÒ1ç¾ÒDhï Ý!ÆvóŸTË@ï*¨©ù¸k¯²ÑGÌÐþPÜü,½¦TÚyÿàZÓl3ï±Wж,yÌgcýáŸðöœ•‹'¦o/D_@›Ÿ=÷Žn}Àd'&þK®cè ;â·u%.k0ùüòHe¹Öx ŠßUšF1áxMjó䨣 =¾6·Û;¨é ½µÏ!îé:€“ øõpEäQfzÓ ú?ÀÜ®‰ÆÓ1cÆu’žV1_{‰ßû¤¥Cü;pâÓÿf mç³$|žø1fúAŠOi3Ò>m€€×»±¼¼ò2&<‚Öä2Ÿ9ùµ®(T–3è=Íæ{Dt€€¯éä…ÅWpÛ«>cƒÎ·:|/Se¥¥oTTD=¼­@º™1Êui¸"©w5›ï¹€½Ìê&àJ¢„ 쀦ïûþ”¬S> ‡+§Ba=Z“Á€ÿ'\^y9)zŽoidècXãxå¦Ë¸uÉì@·îþUc| óÃÑ þ31þB¤ß×DcÁtB>àèЄ3 oCÇ.Ìt.1ngBüðÅþÍÿ`æ‰ó„œG+C«¸yGĹŸÓ s!Áø:DŒK›’ {úßÌ  »ú³‘Z¾gOõ®\Ç‘ ½ÏÆç‰G1ãùÙ+=C_¿ìÚ`òþhBô[LC•¥oæ\Z¹î2Ló'è쪤¹µM+W—œÛõθ­»øgÆ "¬&¦ÍM7O78!aaЫ¦A'ø|¾¿wÔñôÉ“kÝÍÌ3‘ø„ݨ”·iðSê 0=ÂÀ´MXþMLçúý¥ÉsÚµwàÀõI›E6¡ÿKµ¿J<—ROh{cHx>“ù8~¿·\Ÿ³IŸÎŒ`~@A½DL›Áô€¹”ôÃLÀ;1ƒN-óxÞµzÝÎðù< 6Žáñ¤O èç`¾OAmÔPo4ÿLm–ÄßK7i=ð>­‰Oø} œÁÌ‹5ø)(~™Ñuq{ü¼3¨M2›]ü<_€–•Žø8W3aMóÏ,÷W‰OXê,®ß_ûí@ ñJ~¿÷ €Û>%'ìÎs©;ñ"º•‘\YQΨ´TUíû;À–†<æÀç…»k~eg‡_Uï­¨Ã÷çùÊ娅$ºŒŒ,< ¦‹aïÏZ¾d†ý} áx»ãÜãƒç:®Ø8>¸— rGg0aÁÆñÁ.?8·'iÑ´ÎlpJ\,%ÂÛÄ|mž3¦z<–v^÷x<õeþÒ•õòŽ@ãxü:+ç1ð€yõjõû=ϧ=!ÎôÉ“k‰mûî°ÊÒïW`ljs&§–ì’ÒÒÿ ”zÏgè‰ÞÌàÔW@|IqQÁ)—z<[2½ngøý¿(õ^Ä §3èUëgÒ_¸rï Ç—––ZÚAþ’ÒÒ7ÝÌÌ·H›2á>·Aã»ëk¯¬´ô)h׉ҥe¼dŸðy´·Â ¨6óVXóýÙª¶Ù‰’67%vÎŒpÃÿf^´Ýœ6GL0ÖPãí¬²33 ôkX|ÏÍ2 Â#&Ó©»víêÒ 4NÖXiÉŠþD¼böŠÅ…î u¸‘½ÄL<Û4Œc_˜ÌêƒÛîòâÙ‹~ËDSÎä~0‡è¯_ôâÙ‹~kGo¶ ›:õ¢~´&=Ôã“4øDRt"˜\Lü)4>1H?ã+í¸²Ò‘iÓ.Ü àÆh4º¸^룈Õ€dàÈÆ ²´ƒ‰·Aã—â§KKKßëÊk"è›Áê÷‰GÍ×R·Nd(¾Vk¬¤xÐ;KÓjO§D"‘ÃM“Fà1`Âh0Ü`|¶À¤WÊÊ›^/.Šïç“O>É|ÃÒv˜^tÅZû'âÏÆam¾ûH4z„ÑüÿƒÔñ€ÞC¤Þ6o³·­&òé(˜tâ3‰:6Ý÷ØÑw¶¥˜Ã☉Ä;wxÈ!÷èXì2Rz 1b`$À#*D–†PÇ ­oe`+˜?w1•ïܳ§ÃÊoWìÚUû9€Ÿ 2àV6]S:Ì#‰0Š #Á smÓøZñ€­ lQD[(¦#_ÖÔté==5®nï[FDÝ>”’HïcN5e)ek°Ü¸Ù”ý1×q7­¼ÕsûŒ¹oe_¶¦§Üˆœ%©&QL!u\h÷xŸ“³¯š¯Úðvblh»VæsÎ^œÁÃÓÌäÕC›Fú×íŠÙûÐÁŒ³±Àú‰œÏDgc€ƒÑ8Òfçv·:€·ô€/šþÞøÂ„PSÁ`‘-¡L÷¬(/l“™ø‹CÓ‰€Ç1o~BôuáŠÊ;Ð8ì¬Ù=Ÿ÷º\Å“‰‹.òž@Jµ>Ü`úùºuå¶}©n¸+tKÖVy$ü ßáŒN\ê_³tÆÇBÀÆÙ~BgˆF£CÄ/+¾ßmÐÒ\Å“)"•¸z˜Cæ´Ñ´Ê`ùlÍûo»~þx~ŽÄÕ&­Èg¦ßÌY±xuhU(+3!„°“$-Bô2õ1}#€Íá>ÇÓf$§ÒZ'$)ÊAsZ„ȶå3gî¬ýÌ3©A ð²ó¥ÁЉƒ¸¬v¯ñú¬»MßZ!rG’!z‰M›6¹Ö–G–Qü°°}.E·å,¨Np¹\ 7lNÙ§EˆnTk¥‘·<œ¸}æ‚?Ã0Oñ¼Q"K›gÝuKÊeþ… lݧEÑ}ÖVDÿBÌuLØF Ã>†ˆúÇ·aFÐãñdüô5—b*ÆÊl}žÂäŒ}Z„èFûи1q‡œÐfÙµÁOC«B§×Ö£4Ãk’ROÏY¹èê¥3¬Êð\!„È:IZ„è¡|„3×=j» 3æ–ù½]ÞÌ©»¹´KëÄÑ1ŽY=LˆnAØ ÆðôíT›Ä&8=X À7{Å’·^‚ÌFT¸˜éÙËé_£gƒAy` „p &DEÉ›kÆaÆ e~o™|¯AÅ—™%ÝíËÎ ‘Kİ6_§ØD¶É²™ó–ÔèÌr´D7ì/TÊ}!„“dœ´¸\ú €.ÿãvãÓl'„hŸ&~ˆ+x†A¯üKb ]‡õÄ K3—éNXI±ÊtU$!z4 KIK5ˆè¨Á²sÿ ´ñ]f]´¯±é¦;B#2?W!ì—ñ>-B‘M?ü¡¤áâ--¯[W±.‡! Ñ­f/_ò ˆÏk·áoDüÓ¥×-xÃJs–-+á~±J;Χ†¡~°äÚ¹ïtâ\!„° B8 3Õ'JþXˆ^¯p ép3Êñ÷–͘ŠÕ„–Ξ]õŸCÆžƽçPÓÔ/ÏY¹øìNœ+„¶‘J‹ÂQ¼^oQÌT»›?VÄç?úhäÙ\Æ$Dw›{ïÒ¡fƒ>‚H׸Xí©Óý¾ºã†¬o<ÙŽ9+Mg¦_pgxj˜¯Xvý‚GºƒBt†$-BGñz½ýc¦jÙ§‚Àg?öXdc.c¢7¹iÅ¢3èQe~6Í[6sÞ­¶%„iÈð0!„£ìܹ3aâ=3ËD|!ltûÌ2M|›˜§ÂKf­Xò€75ìL!Ú'I‹ÂQ6nÜCÜÆ3Ì2§E»ÝqÃüËûÀ¿Ïô\O?üó÷Ÿ¸ñÎ;f#6!„HE’!„µTW ÃJ‹YpÛM7Õôߣ/xYægÓ ãÀ¦ywßš~L!„°$-BÇ¡¸¤Ek&D¶ƒA½læ‚9Lt Ú®X–Î)¦Ö¯Íº{ñØlÄ&„ñ$iB8SÂ0&D–Ý6cÞZ à‹ Oýi¼:û®%§g#.!„h&I‹Âyâ&ßÇ\Z*-BtƒÛfÎÛì} „¿exê`(~~Îò%ž¬&„¤EáL-Õ•|©´ÑmÏœ·¥žþÑ OÍgâÈìåK®ÏJ`Bˆ>OöiB8ÎÅûþÃÀ7œ7|ݺ‡wä8$!úhÖÊEËÁ4£§ßÝy}0Ô¶&„賤Ò"„pœøeŽ™k¤Ò"D7c€—ÍX0“€·¹E×í/4¢¡P(?± !ú&IZ„ÎCØ×üÏaÆí먩"{–ΜÀd>LsÊþBcÃÜ_-’¸„}$-B¢š¦Ô=ðÀ2_ˆZ6sA³>@u†§~O×Ç^³2tx6âBô-’´!œ‡¸)i¡½¹ D·]¿p£©Ô lÍìL:’ÙxmÎÝ‹¾•È„}…$-BçÑÍ•–æäE‘kw\7÷Pæ©¿›á©ÃXÓÆÙ+oýAVBô ’´!œG¡¹Â"•!dÙµÁO©Î}:ÎðÔ`ýÄœ•‹~œ•À„½ž$-BçÑ-ÃäÒ"„Ã,=»*y.ÀexªÁL¿™³|ñÍYKÑËIÒ"„p¢ædEK¥E ƒúïÑ^0îÍô\&g¯Xü`(re#6!Dï$I‹ÂtcÒBRi©‚Á ^výükA4 ™ïårem¡ñÄwÞ90± !zIZ„Ô´jËœ!œnÙŒy·3ÑT-ONÀ÷ ãÀ¦ï ËRhBˆ^D’!„5UXHV¢'¸mƼµDø>€LÿÏžb¸ŒWç¬ÎF\BˆÞC’!„㘤›o|¤Ò"D±tÆü4©3|‘щŒ#Æksï^ôìD&„è $iB8‘’ÕÄènŸ1÷­˜¦S~?ÃSÒš^¼iùâÉY LÑãIÒ"„pž˜Y,•!zœ;1ï“zèÓ¼šá©áñ9+MÏF\BˆžM’!„ãhwc²B9-BôDËg¿ªÇÀ‰`<žá©3=0gùâ[²˜¢Ç’¤Eá'›š_…BùÙ‰LÑHÒ"„p$jš'ä !z‡¥3ç?§I `{fgòèú·l@)D&I‹©jPç’J‹½Ìí3æ¾iš8àZ<¥žó—\;÷¬&„p4IZ„NUs È%•!z¡;n˜ÿQLëÓü¥£v ¼Â„n»~þ’n MáPÄ̹ŽA!Ú˜r±ïÅõë"XÞ¤„èµ®_±¢¿ûBDø1%ª~™@"Å/-½nÁfä=@!I‹™¦Lñ‡×­+ä:!D÷…Bêæ`%IB¤"ÃÄÅ_ä:!D÷ ƒZ!D{$iB8IÒ"„B’´!Š[sƒB!œA’!„Ci©´!„€$-B‡"2$iB!àÿoª(çGÐ¥¡IEND®B`‚scikit-bio-0.5.9/assets/horizontal_powered_by.svg000066400000000000000000000340641446255456000222370ustar00rootroot00000000000000 image/svg+xmlscikit-bio-0.5.9/assets/logo-inverted.svg000066400000000000000000000144751446255456000204110ustar00rootroot00000000000000 image/svg+xmlscikit-bio-0.5.9/assets/logo.png000066400000000000000000000301551446255456000165510ustar00rootroot00000000000000‰PNG  IHDR„úùމsBIT|dˆ pHYs × ×B(›xtEXtSoftwarewww.inkscape.org›î< IDATxœíÝy|e™ÿñïõœÓ”¶Iš´P击€¸âè¸@Ü•ŸcÑqe\ÐQ¶Ð&iÓž94iÚI)Ž .£ã2 ø¥\EDÇmѶÐ4M÷æ<Ïõûƒ”)X '¹ÏyžsÎçýzÕí•s]—iÎ÷Ü÷sßæî4ž(íé @ƒ"@ƒ"@ƒ"@ƒ"@ƒ"@ƒÊ§=LD±XlÚÕ½0Rôr—Ž2ù I3dæRò+w»3²øÆ¾…?¤=+@ÖÓ¨5Åb1¿{zþÍæþNI/‘4õ1^²Wf…?õÔ‹/Ÿ??®Âˆ5B5ãœK/<¥4ôkÍ/6÷cËxéar_sÜŸïn—ÔU¡ñjϨ K.,9udûM&û7©¬0x°7†œ  Ö±e@æu¬<ÞeךtÌDkű޻ðüî?†˜  Ö±B ØGB„AIÊåü±ž7hB™¶lýª$ª^äù‘Pµj@¦•J>7d½‘$&Œ"È4‹Ô²^4™@p@¦yâ“‚ÖÛ«RÈzµŒ@ Ó")h ÌOmb…`@¶Eʇ,79ÙO E i¡·Œn/µFd›YÐ@8}x˜@0Š@ ÓLaa¡PàP€QB™ætË(«ƒ!È6z¨ «ƒ!È6 zí+„!È4O„•B iÆ !@Åd[Àg@ðBÙð”Q“B q!ï!t!ÀA„2.\ tgË(ÀÁ„²-ä–Q“‡ªP„²-èÅô>9\-€ÚG m¯0à BÙæ²p¥tX¨Zõ€@ ëö¬E 8@Ö*„@ Ó#d½4u÷÷Ó¹®÷;2û¼I¯”Ôô(_>MÒ[cO~¾d`åË«4"È0!€Ì‹B?Cèõ±BØ9°ò-%ó;å>¯Ì—É6tô¾®"ƒ€šA }±]!”Õþ¡2]ëzN‘ìó’ZÇY"/yŸ)èf\Pc„2/N,ì ¡¼¦açúâÜu¹&þøñKÖõücˆ™@m"ȼüÔ\Ø@h6+h½**‹yʝJ:"D½ÈíÔu@m"ȼßÍzrÐ@讚 „{Zs’ôüPõ\Ép¨Z ödÞåóçÇ’v„ªgªÍ@¸ôÒ¾#$ýkÈš–èÊõ@m!¨¶5`±ÉkÖLX¯*’RÜ+©-XA×÷ûÎ[þ³`õ@Í!¨¾%dµhRò¸õ*mɺUÏ•ôž€%“$Ьj@M0)h L<©©m£‘'—*äÏl·Ï®]°ôçÁꀚD PÜ-h 4Sͬv¬ë}›¤,¹#‰KËÖ5Š@ 6X4º¼&V‹-6›|mÈšîê[»¸°)dMP›„j‚)ð ¡jc…pϾh™\Xò{&MïXÔ0!€šXØ@èQö¯žXraÏ“$ zð‹›–¬?ûì}!k€ÚE Pâ8h ”gËh”÷I“ƒt}Í‚nî"¨ x…Pf™Þ2Ú5ÐóJÉ^°$×L€¿A PrQ®aVßÙe“\Z´(×L€C ¨ MÛGî“äá*fw…pÆ®-çHzZÀ’\3Éܾ¿*·¹YSKKKkE­QTjvÏn@5Sœ$ùqïlkÛ¹óž{|OÚ3¥ÁÌšZ[[›s¹\³Œ4'yoJ{¦±ˆJ¶_Mñ°4exppp§»'iÏ„òuôÜ/if¨z»óÓËÚ+Ë.Yõ¸8I~+©5TMw-]³¨»/T½Fcfù¶¶i'¤=G­ÚõkwÏÔß7€”¯F“ßzT<2i¶™Ÿ éIÇKú»öé-£a"‘’HVaÆË¥H‰¢œi׎Íhk%Ý#ÓrýJn¿,¹_7<<¼5íQC0³Éí--óÜü9fÑñr?A¦'·Oo™,¹””ä9“y¦×ä9Iq^ÒˆÚ§·øŒ¶Ö’ý^–üJnwÊíŽmÃÃ7dýÍÊŒé­WÉô†2_ö½Á¡áS*1O ¶(` lž%éžPõBˆ“¤Oàj욉m-×IöŠ2_VÑ?ãGL›vxÉ£Û*U¿QÌliy†¤»Óž£^͹aÅwÍõò´çHQIÒ_%»Wò{Ýì/Rr¯¹Ý+Ù½q.úå§îO{ȱš»qù—%{óĪøW6ÌYù–0UžÉlÎÆ}†Tz¦¹==‰ô s;NòIÍ’¦þš’GÒ®ÿýe;¥äæÑÝnúµýú¥7ëÎB¡lq£bÐÌ&··¶ÎwKÞiÊÏ1óÌ®þSNÒ±r+éµ2WÞ42czëufþ…Áí;¯¬ÅU¨Ã§O?91oûô–ù’ÚL&É•í´^6“Ô"ù³åöìþWûô–¡m­—[¢Ïn¾%Ýq(&mqé¡êÅžd*v ôžlÒ™!krÍ€‘—tŒäÇH’¹ëß¼¸rqÏÛ°bcÙ—§í޾ò×v§6)bîÆ/0×slùRüÉä&™KAŸ©SFþÀuIv²ÛïE¬›^¢Mó6¬¸ÒM—oœ³òf×Ķ|V$¤Í˜ÑrBûô–Ëüó&›W©>4I¦×¹ì+íÓ[n>¼µõéi4Vf6¹}zkb~«¤÷IjK{¦´I:Ë#ý°½­õ“Gyä´´ÂC¹)ìåô:iÔ$3ùz…üø…k&à€œ›N3÷ÏìžÿjÞ†ÂkÒ¨ÑúÝâÑs7®¸VÒÝt¾¤'¤=S 9ÒM–ôý9WÜcFkÈcã+bÖ¬YÍíÓ[o1ÓBÕÛZà8™ôÞ‘½»o›ÕÜ|dÚ³à IØ@èÊÎI£Kzß)é…KrÍÚ±nþ­¹ I{F5ûÆå¯ÏÅñ’^™ö,µÏ_,ŷϹaÅ™ã­4¶··?ÑÜ>£)×¶ÉJô…¬¯–Fö~Tòç¤=GÖ¸ô”8}ÑÌe…;ûBßE˜‘“F‹—[M¾:hQ®™€Çàš»qEoÚS4š¹‹ÏŒû’¤éiÏRG¦˜ë“§]¿âÆóâ otÍãÏŠß܇kM"]nf™\y›ÙÖò&¹Þ‘öYåÒìöé-ç§=`J®š2÷ŒäVI ¹Í506KçÜPxUÚC4ŠW_{Îd)¾Rƒ°òI¤¯¼ôæ®ör_,¶µµ=WÒ)¡êÕ™Û[[3¹$înç¦=C 8ÇÌri) ¾B˜~ ìè=Y¦ YÓ]}k6…¬ õÊ<é1eóƒûz³¿©m¾‡¿qÔa{óg–û¢`0’¿7T­ºdÉ‚´Gx¸#Z[Ÿ&ÓKÒž£5£µu^ÚC@²¸¾¶Œ‹Å¼É/SØÝ5uͤϞ;gc7‡ÌT…½?í ꛽¯Ü×ybfyÉߢVý²yííí™:¹3ÉÙÛÓž¡V¸%l«Í€È¢°[FÝS „{¦çH:)dM®™€ñ0¶VØì—?Mr"*ï³o\QÖ!uAa{{óÓųƒÅ"÷¤=ÄÁÜýyiÏP;,äé§d$Ú²ž¥ø áù÷>QîÅ E¹fÆëåiPï¢$" VI.ö—óõa.¦£“de݇x•¤é"—žgÒ›ÆþõñÉ’®¯àHå:±ü—X¯ä;ÃRuË$5—ñõÇqÄ-÷ÝwߎJ „Ƕº£c{ç@Ï>…;ÉxæW\‘»|þü8P½1ËEþQIS–,ÉüÃëaTÔܼC{ww¥=‡¤ãôÀ=±e1óõîö× ÌS–‘ðÏ!=ó%?èh¹ùÖðÏùÊáDû*q+o÷Q˜@hþìò^àßÚññ ½SÔÞÞz¦¼œ@h™ù‹ÐÞÞÞfÒÑå¾._Š?²eçΚ?¬¢½­u•-Þ·ïY’~P©™06.m1é˜@å¢cÿt×’ªúgº«¿w¾™^²¦K—¬Y¸ü—!kâ›6mÚ%)ìµ ãÐÞÞrŠyùφ$òß6´ãöJÌ„zc·JÉoÒžâÐ,'©]Ò I3õÀ{˜ªÙä}M³$+ÆŸ›öÃÊÊfa¡ë©\gþØìb™àîOâ·¬<žÓSE LI›.*ÊESaçš5ÓÕä—.ûç©“ã \@ƒqóÏmœ½²&>°?õ»ÅÃrq鵿ö>7¦ªÏ”ôû0µpÏL{€RÖèVÕ¤N3eçûd·Ê‰„åˆd™:¨qùfüʬÊ'Né“ëïB–4·…êa+7ŒÉ§öJºòŒ+ÎøÚÖ™OßhâÀÜ̉×À¡‹ÅH/™øûà$ò׸åb¦¬š4’ŸD¾a‚e&ŸúÝâa£OS@hRsYO6®ÌBÉ24KmH’„ïY&„})©b ìè¿àT³èa«úµ}‹º¿¶&Ô†Ëç_ŸúÝâ{sqü_­%j 1þÖNV³|š›‹}ðú¹õ}Ïîi×”&~´AÓ~µJS rʨ—÷,VÃrËÐ÷)!–ïY6xØ“F«t9}ñÒb«YôY…\Þ”öš%$ ¡ÝxJáw’†'ZÇ-aëT…Ĺn#¨2·Ò˜¿ç¡.CÎNÐÉ0÷ —OOˆ‰Õ®²±5:ÜÃ^=áîG†¬÷Hö”rë$=!dM7­ê[PøCÈšP›ìî´'À#™ñªÊJù±/dÙ2êÒ$>RyD;Lú‰K·šÛÍis€GÑ$s6ú–#rMJ{HfÉ– ÏVa…°£¿çõfúç°Uý·{rmkÃÖ€Úäæ{Ê» Õ”/å&%QÕoxjh¹8óûÖ0‡Êà€XÒ]’n5éGÊù­ƒƒ;íîIÚƒõÂÝ7›üªÂÏžqñð|”»,t]3ûÐú³ÏÞº.h,‰’t•¤¹ù­“&Mùé–-[8騠|>¿9ŽÃ}Æbî „ù(ú¸Â¯B~¹oA÷DO  NĶmÃWé@ JöïÙ’Ëå‚Õó níX×û6“ýcТ¦m9E‹‚ÖjÄ̶–7¹¬;í9æ¦Û¶ #í9`¼„jJó.Ý¿§U±¤P©ððb± … [»»z2ùGBÖ”$¹¸wáÒ¿¯ Ô——tRÚs<ÌŒ´€‰ÈÌ©—0£Áíþ€%s;§éð€õd’•䟑Ô²®LW¬^¸üKAkÓm@½ ÍÄ¡)¨gÛ%Ýêæ·¤=ôrú\. ºm´c ·KÒi!kJÚMÊýKàšPÌmòDk¸ù¯CÌÔš0[F]»ƒÔÒ5(×]2ÝåfwEnwY~ÿ]÷ß¿ûÞ´Ãߨ,éÄPÅì“F¢V׺ž¹’V†¨õ½wÕ‡º¶¯ uÁŸ>ÁÃg÷üwQ€êBNÖD­¹If›•$wy¤_7ø]›wî zá9*Ç\›=à͉Â\=ÑqiñhóÜ—x;¾»}jÍÂ¥W‡¬ õâßé>F¹hB[ôÝÂ|(Ô¢0дS\вmhx~Ú3`üÜÂnµdâ'‹Å&kÍ]!éˆ#ìS+- \ê‚ÉlNnù¿¨ô‹‰×jS¨-£;‚Ô€1½B(%„{Zrý’þ>À0Kù» ,° fކcËÏ•ôº –Ú“DQˆ™€Z$šôWTo–Â%ÂÑgÇ­c]ïÛÌô¡Pó<Ƚí¢å7¯ ‡`®WÌÛ°"ìéÈ$‘çÌ£vÉgJši®g¸EOSÝ—ßxJáwajµ'H LÌî0/'Ú¥3ÚZ×…è]]K¶KÒI;Ø*k÷¸'¿Rdw&‰ýrûöíü@*Ì£Üfy¸Ã“ \N¿lýªÌý²`Ãü¯_ížÔ–© ¸Ô½ÓÝtzÚCйI=Ÿn—ˆýxÆàÝ5øž'С2Ée~ZŸ×»šL’¦êÀ3BþÀ¿˜™äRÎ\3ÚZãî_P”ÿ¶mÛþ”Ú¨@³8ÞâQÀÂqÂâ¥ÅÖ8޾*ÙÔ`Ã<`¿¹¿cýÙgï \0Ê\¿‹’è]—ϿܷhùmÁë$ÉÍõ‘){s'}û´ÂÝi¤-È*ÝÐÐжm­ß—ô²õêDdÒyíÓ[^1sæÔWoݺûž´êÅÔAmÙÓ´ä&™kìç%wÏo/“Ùk‚N!Ée_³hÙ'C×ê%ö ™_’ö‹<º+íP–?IöîëçoL{ +‚mÛt·O™9ðoàqþ+fö2w/¥= P …ÂþΞ!I¡?ÈŸwqq¦Î+Ü?–/îX¹RfïÔûA.ý`hÚç„® Ô‹­ÃÃ?”ôôç@Íù‹dßtÓ×'ïÛvÃ5¯ZÏv|à Áasëð•»v´¬W¸7hõäEíÓ[VJêJ{ ŽlVÀŸ7ù(zœ¤Ç „+?h²Jöro>Šþñg5RÚЀìfóxñ†¹½?r•uú!ÐP‚G8–«':Öõ¼Ñd—†ì;jŸËÞØ{îÒÐÏF@ó—È¢kæl\þs7.Ó©ß-ò> 8„`P’·oÿ‚¹>²fiÙ;?í!€ºaÚ¸à£Â%+_j®/*ðÏMI2÷¬Y¸ìÇ¡ë@£s©]ÒÛ%»"Ç÷ÏÛ°üK¯üvqFÚsYüÍàðŽ÷IÖ+‰#|Æ\ïJ{ n^!L’G¾zbÙúU'D²oH:,dOI’ëÒ¾EË?¼.àá&»Ù?•òñs7®xiÚÃY<ºûÈàÐön%z¹Ë6H w{tí;ÙÌ‚ÏFäQè-£É!awï1qœ\§ <mÒ÷¦ìˆ…® xTGKºqîÆ+ŠÅ"ïËÐð*ö—`pxøÛ†¶ÏËÄG›é Õ—“T¼é%¥Ï¤=¶`§Œ>’ûvíú«¤þÑ_š9sf«J¥g&‘?Îk–%ÍfÖœ$>-Š¢šû”ƶLoë×'‘Ÿ$é7 hi³<3ÎõÐ-£KÖ÷<%2mì áºîæßN{ŽG7×Rô8Éç¦'Jš§ ¿—µwv}áóß™WÜbH U<>ÜÖ­[‡%ÝZí¾•ÒÞÞz¦yÐõŒJÎ4Šœ|s" VÏìáâKV=+—è;Ò#?W8C‰E¯X{îR>)I¤;6Î^yUÚsŒÕœº’¢˜k¤qŸ šDþ±W_{ΉÜOˆFUs+rµ.âžF ˆÒˆ…Ý2ê„¿¥ëV¾(—$ßSeÂà®ÈüÕk,½½µ ¡lœÝsïÆÙ,7×¹,õ”‘Ií܆E ¬²Ä¬5í ͘Þò–¶¶¶ç™Ùä´gÁøL›‡¾³oVÇÅÌKÜ®We>¸Ùçž¼aÕ‚å·T 64¬ëç^ðI×M¤†›wžqE±)ÐH@M!V0Ül]¤ä§íÓ[vÎhkýÅŒöÖÿ˜Ù>}a{{Ë©mmmíiχÇVø`a§¤ÝK6Y}KÒ´€5(¹ëŒ5‹VðŒ T€›®ž`‰Éƒ3ôô Ã5¦êÏ6:“³%/éD¹Ntù;L&S¢m­ÿ-é6w¿]‘Ýn–¿mpp°ÑOÉÍ Û"ù± VâÓáDòw­Y´ü¨ $ùo5ÁçÊÝ’ã%ý"Ì<@í V[kÄ%=ÑÌN—Kò’f´µ~rphø¬´ÃÁ|³¤cÓžâQ¹>¸zÑò/¥=Ô³Èó¿sÅ«‘èø@ã5…-£À™Wdõ`örúà̯^Ôý‰´Ç€zWÊMü7'¢!Ô,— ¦=Ã#³®Õ –]”ö€1{bÚi`Ë(€– Mô™‘ (¹ì½k.û\ÚƒÊÂB RE¡™åÚÛ§oIô—N–ì²äæÁm;ΩD?ÉÛîÙʃ;%oZsîŠo§=ÀXL8𙵶¶>9'½À”¼À#{Aûô–ç*Ñð«\rûñD{ÀÁÙÉû «c³%þš¾…+~–ö c5î@Ø>}úÙ2½¾}zËó%o“$—);ïÍÔ»HÉgcËè™Å¯ì;¯ð‡´€Õœö@­w 4ó·IzaÀY <mÏÀ§P?Žò¹×®:»û¾´€F•‹KOÎà3å@M˜ÈóI°)K6¾oIFæ¨%Æ÷,k‡ÒÀ¯ž2->uÕÙ]„AH‘¹ž’ö xdIÄ{¨j+ç{>î@è²]ã}mC3eâûE¾3íjŽùŽ´GÀCy”ßžbûOONN/œU˜ðÝW€‰I"{ÃÄ«xê[NêU..ñªÊ¢ÄÆü=ÿ–Q(ÆÅ-ß7÷a¶V”+N{ö¿X¨Ž}®¡¦*öséÉÞ´fÑ2NM€”;qÅñQ¢Jöž0m$L<ÜPÛÖá¶¡ÇM¸NE?wãò¶#eWdÇ…(³oòH¡ÛŽ æP{\ÙX2wf°\¬ùóÑÏÜ~ÜŸSµ~&{¼ä}ý=—¬YÔýª5€*ˆ\³çܰⰴç8sϹÙáæ~„¹á¦c"é9a»ø_ÃÖÃ?}Þ'Fæn\±WÒ„þ|™k€nc’üàÖî”ÖŒé‹'°v›ÜËoHù¢H÷¦=ƒ$%QôWó8í1j‹Gÿ“öx¨ËçÏ;zvªjÇ{NÒl3Íîè¹.ç¹sW-êúmuz@e¹4ß\óÓžãÐLæü»Wèí§y6Þ£Õ±ÿ–ô´´‡h÷xÏÄŽ?&vG™GÒ<­½½õÌq÷Ë*×KÊùróäŽJRŽmÛ¶ý÷Œ¶ÖaI­å¼ndRîÍíí­iä„ISÊ}M®©”‰ß;üíJáþ)“^™XüËŽu=S›âžÂ Ù7çƒßʺMÂj¹­œ/ÿ¡2“Jwx\ÖËO1×)ãíW/öÅ–¥Pñ+I/*çæ¾®B³dÝý÷Ý·ë/iC’tTJ½›ÌÕ±gî+¯^¸üK)͘ \œÿfÚ3Ô3sÿ¹›½%í9ƒÿ¼œ¯÷µ[·î¾GÒàx_ß\Ù±cG–î+ûeÚÔ ——õI ªÇ„iñxɾØÙßó½%ö<)íqåòÛ¿}Zá䧨gI¤Ÿ¥=C£(÷{=‘‹é%é«|}c‰ìkip07]ö µÂø³žeÙÙÂlzY”×í]ëV¾;íQcg®ËÒž¡Þ%Qþû’8¸§ò¶¶wûÆr^0¡@¹}r"¯o4‰ÛgÒžá`CC;®qisÚsÔ€=Š&}9í!ph–…‡jv·Owô|ué¿õÍL{À£sÓÆ s{>žöõîÆS %ËØ{áúdŸ½æUë÷•óŠ Âû·oÿ‰dl¥ÿùÐÐPYûy+ÍÝK&}>í92ÏuÅàà`vV¡ðP–¡Ü94ÞIDAT‡zc²?þe×@ÏiixD[¥ä]åœÈˆñ+å£OIâ¾Çʉ¥¨ìÕî‰n•[é=’ÊJ¡ h¢ÜYiq(‰¢U§j=Š{K®óÒ,ƒ+„û;—®ëèYW,3y·4*sýNʽlãì®›¨’O)üIÒùiÏQÇ–n˜S(û:¬ ÂmÛvÝ&7~c…™º†††2ù íÐÐÐ6KìŸ$•Òž%ƒFé-ÃÃÃ÷§=™Ë²¥.l=wOkîÇ+O{€$éºR>÷‚ s w¥=H£Ù0ç‚õ’x'¼«6ÎYyáx^8á@(IƒÛ·Ääó%ñÆù¡†äöö­Û†ûÓäÑlþ¡"Í–ô‡´gÉß$Š^<88|sÚƒàѹ'»ÓžaŒN”ì'ý=ÿ’ö иìÇIä¯Ù0ç‚WÝxJ!ë(Ö­ƒw¿ÝÜ—HÚ›ö,u`Ÿ¹ºf Þý¦ñn}ÿÅô³uhÇ•kn¾©4É–Êí-.Í U»m“t¹åJ=[·îþsÚÃŒÅààðMGyä³öïݽTÒ;%öL)ùƒ™}þ°©Íkï½÷ÞZ  ÍÜöÉÒžb̦ÈôÑÎþžÓ¢É¹÷®úP×Ö´€zç¦û¢Ä¯“¢/^?·øí´çtùüËcI¾â;Åoƹx±Iÿ×¥ö´çª%&msék¹8wá·O+Ü=‘ZÁ¡$mÞ¹s³¤sÍì¼öÖÖy2½VîÏ’éIm!{eÌNIwJú¥›®Úqµ»ïO{¨rmÚ´i—¤efÖÝÖÖüÒ(ÑÝì$IÇK:"åñ*å^Éï”ìæöÿ¶nß~kÚ¡\¾O5”%I¦Ó“ýñ :ú/xÇšE+nL{¨#’¶˜´É¥M’orÓÍí;7Ì^ùSÉ¦Ñ óžçÿìýhž5Ï,ù÷Üö(Š~_s§‡æôiwûn9/‰<©‰Uêñ2Eû\Aÿú ©:`emèZ׳æ°íñŠB¡Às¼’Üìã’]WÎkêýÏøQÿ.I&-,÷u¥’q`F0÷¸ÙUiÏQ æJ$Û%ÚTÊû¦()mÚ8§oð‘CßÕ0“>•˜¾;‘‘ëwÆ©¸Ñ`sÍè/IÒ«¯-¶–ò:.δFI®ÅÍ[ÜÔlîÓܬÆ> swóh·›ï0·IïÈÅ“†ó%ýášW†+Ù·Rµ â:Öõœn®¯…ªg¦n—N’k~¨šcð#³ø­} <Ç ª*È¡2–\¢ Û³Ý-^½ û —)iGÈÚâ…î¹Û;Öõ¾­Jý$Ô¸XIÐ{PÝ|²$­Y¸ìsq¬“\úAÈú¢ÅÜ¿Ð5Ðók×¶T©'hpB5Í<4FÒäÿùÂó»ÿøÇ£Ÿörwu«JwuºôkÚ[Ç@ïÉÕè@M³|àBùäƒÿûåóçÇku÷ºìE’ÿ6d¯GâI&¿¹s ·³X,òsT o4Ô´’®*±É‡úŸ×,\öÓ)Ó’çÈô‰ ýÙ$Éûö´æ®ïX[||•z€C PÓ&•,ì¡2:t ”¤ÂY…Ý«t q½NÒ–}Ål›”ûEçºU¯ªR?Ð@„jÚˆÇAW-òǼ[sí¢îoÅq|¢Iß ÙûQÌ”'ßêèí¬R?Ð „jZ”„ „~С2æÂó [úv¿N®JÚr†GIÞ×9Ðó•âeÅ©Uè@MËMk »B˜Œ-°zQ÷ÇÌýÅ’UëRù3öìÊý°k]ñØ*õuŒ@ ¦M¶ýa•1Ï•û’¾EËoÛg¥ç™éAgyd'¹ç~ÒÑÁ©Uêê@m»OA•1ÙMãyÝÀ‚ÂÐêݧ›«SRr¦Gp¸YôŽþÞsªÐ Ô)s÷´g€ éèI$YˆZIIO^»¸û÷©±d`åË#Ù—%b¦ÇdöÙݹÖ¬?ûì°«¥ î±B „Z%üòDà$­]¸ü{I)~ŽIß 1Ôcr?sjiû÷»zªJ?P7„êAˆ•±+§ ÇïPG’´vqaÓï~Ú¹¯•T­'—ä?íìï}qz€:A P&™>6e8þ§B¡P 6‘¤ËçÏW/ZÞá®Ó% …¬ýŽ”ù]ëV¾· ½@àB5¯«¿ç nz[ù¯ô«s¹\gï9Kï ?ÕCu­+çž»RÒs*ÝK’dúض©³ÎýÄYgT¥¨IB5¯s`剒Ý,©õ±¿Úþ$ù×ÝíËk-»µÒ³¬X,¶»%©™WeϤ›Jqü¦ Ï/l©F?P{„êBÇÚµ-Êü³™^/ó6¹M—<'é÷&û­Ë›Xô½µ –Þžú¬½ï2ùÇ$M©t/—îq‹N_»`éÏ+Ý Ô!¤`ñ%«ž•Küë’[…v»%{Ëê…˾Y…^ †p¨ ¤àÂs—þ"ÊG'»ôƒ*´›*ù׺V~  ½@ !@JVÝußÔáx¶IŸ«B»œË>Öµ®gUz€Á–QÈ€®þž7õI²*´û¶i³ÞÍ ¤€@Ñ9ÐûÉ¿(iZå»ÙÆ)ùÒ g†+ß d2¤³åInöM“Ž©t/“~‘“½ºgá²{+Ý dÏ@†¬^´ü/Å'KúQ¥{¹ô¬ù-ËÖ¯:¡Ò½@6 cÖ..lš2Ÿâ®ÿ¬t/“މãäæ®u=§TºÈ¶Œ@†u¬ëYn®¢*ØÌ~3;³oÁ²Š‡PBȸ®þÞùnþ9IS*ÜÊMêè[Ø}a…û€Œ @ èºxåó[Òýn•s·Ot¬\Yá> JØ2 ubÉúž§D±]'yÅ1ésƒÓf½ïg5Ré^ r„PG_Tœ•Ëå®–ôüŠ73»Þ÷OúÇ5K–ì¨x/PB¨3Õ¼«PÒí>¿fÍ’Â_ªÐ Æ3„PgªyW¡¤gÛ¤Ü-K/î{fz€ÀX!€:ÖÕßs›–W¡Õ"{Ãês—}¿ ½@ B¨s]ëVžånUåï*Ügnïê[´ì+îaË(Ô¹¾Ë/«Ò]…“Ýü?»zΫp+„Ð –^²ò…Ibß’tx¥{™|ýaÃÉÂB¡Tº?!4jÞU(éÿMŽßV(öV¡!4˜jÞUèÒF¿¾aa°Ò½@ù„Ѐª|WáoÌâWö-(ü© ½@8TЃwJÿ^…vOsÏݲdݪçV¡(+„ÐàªxWáN“æ÷-ì¾® ½À°B ®oQ÷ 3¿¤¸Â­š]úf׺•ï®p0FB€ú,¿L²ÿ«ÊßU˜w·Ow¬ë)T¸¶ŒTÍ» %}zÊpüB¡PªB/pBÀCT÷®B¿6Ž§Ì¿ðüówU¾x8!ào,¾¨8+—Ï]#×ó*ÞÌô³œE¯é=wéæŠ÷A R•ï*ü£GzÕšs»S…^`‡Êé » ?]…vÿÇý ³¿÷ÅUèF±BxL½+$/V¡Õ^“½µoᲯU¡ @“Žž6é2Iù ·JdZ°zA÷¥î@Ã#Ƭó’ ^¡$ºRRs¥{¹táÚ…Ý.ñ**„@(KWÿÊç¸Ù5’ެt/wýçÔñ™…Ba¥{Ј„€²u­+ë]+ÙÓ«Ðî»Ú?éôÕÛ«Ð €†B ŒË¢âŒ&Ë}]®—Tº—»îœ${uÏ¢e÷Tº„k'ãÒ¿°08e{ image/svg+xmlscikit-bio-0.5.9/assets/logo_and_powered.pdf000066400000000000000000001743041446255456000211120ustar00rootroot00000000000000%PDF-1.4 %âãÏÓ 8 0 obj <> endobj xref 8 6 0000000016 00000 n 0000000570 00000 n 0000000630 00000 n 0000000896 00000 n 0000001009 00000 n 0000000416 00000 n trailer <<2C780593B9ACC84D8EBE5A09F6477FED>]/Prev 63395>> startxref 0 %%EOF 13 0 obj <>stream hÞb```b``¼ÃÀÈÀÀ±‰›¸bŒ ,  r×÷1> endobj 10 0 obj <>>>/Rotate 0/TrimBox[0.0 0.0 720.0 200.0]/Type/Page>> endobj 11 0 obj <> endobj 12 0 obj <>stream H‰l—]Ž7 „ßç}Q$êÿy6ò âð:@’ûùŠR÷ô&†oSÓ’Èb±Èþë‹ñè§þþíñëñç#†^ÚCëþü?æ8¾=~úù—xüþÏã¯#‘éh9ô˜ìHf!ÚÇëûC¿|òÑC­ú­‡Víx=f¨©`ó׸:†29Êrˆ³¿Í2¼çB®ÁòÔU{§j§äŠUØnÜÕL¿Õ0›îƒˆã¥‡¿ 2cÐ[?Î ¶ù"ª¬—kE‘Í÷* tø,3äYn>k ¹ÚåгZÈùòö4w4z/dЩ~¥-·r -ÎûŠÒ@tJñüm\iÉÓÓÌÛJI¡ ‰½"‡Óذꥤ)Xî -ÖìyÊêYãÚ©¬öt³•ì¡ì•Ê‘~é^ÀÍZŽóÀÑua ­8nÛ¡M–íî4³ÂY–Þ fe›â^ÚÏÏœoc Lt|/‰-#pv¦ „Q樌<öóS˜Tg¦›5”$ÿ©+Î2ÝñÇãëãË­pi‹=ÿ°rò °ß g=ÞõùÙZ(ͧ‡-Ö+ì÷Âõ¾ÀöÒ=ˆ’É2޶HhÓY?m³ø ´ìÎzËåëÛç'ÖÃÉRn¬oŠqè™ìa»ÖYF]ehÑœ#-Ú·ØÞö÷{åN-Ä`eÖ(U)ËëâI-¬j^d™ @vº~ÅÝUÌE•íI•ŲH‹o À“‹ ÜÅÓû¢ð™„åóëJÊ.Ïi2ד2iNˆXŽ#m½Ú+¼„ý¥K²¿>2Ñuôé•öé•7ñJ,`ßòˆï)܇üeñ²/¬oÏDݵþ?f¼*Jz´^™²¹Äiz“qo¹(«ëÄXTgE¾»ÅP‹Ê Àæ Ęîµ#ù)Û±õ¬¦Rljîùlœ{™åêFæ,ÉbEÊ^\¯G YªOb:Ç-]x¦ä½-šH\¯ºYùÓ$/pû<Ú”ëh!áØÄÑRw-ú¿—z´Ñê-¸½ðŽPvï|BðÓÜVq¸aå Ü;'sK^çcQtöަ´À \ÙFçáq¹9èÒÓã’i°–ÖÉ!ø”}›ãᵈƒU2wWC.Áºíû•j±ø©ê,L¾_+Y•à·•ëØÓlÛ$_p@Òkb‚M­©pñu åÐo"Íô )›QxèéiqÖðw—ÍqÙÅt›‰ö­QTc$A¶iß("‡&‰ZYQ«0Ò XÙÄž¤]<ä^UHè7 Y}‚]£ƒÇˆõØC&¬´<)×Ä‹&€3úœ‘. ewڜݚr~Úfz²FMšì uÑ¥3B?OŽMTà4ðY.ùÛI0„ñm½véÖIg£u§Læõ‡Äö›Ð4/Há(>x­Ó8%¼Io4ÔBU•È×,Êöµ‚g‰¬ÓV¹dH´ijXC2‰µ×r]IB’rP)KJ§WMÑå#¯Ïæ=x/|Ø@=o)PŸõš&ß¡fˆáÍ\¨—LC–VÉEõaQ>–Evû +™²zâ~3'g«Ã$ö7§uôþ¯bâ|&| êÝÞÏ$¹Ÿ'5kÑ{DG*Ÿ:W8¤Q*ùÍ%eWY—wÍ}0I£F¤ŒP|̨AY}”ÆZp†V–¬ªö'˜õA€žòaU¸Œ9¥Jš•U¶˜ç«iDñc×7Nëþk.®?-¨¾OZrIvµ(‰¹8{7(è'¨ˆÔÙµER$AVã‹Òõ¶¾È2Ñ#±R˜løC£Ň|ÒåWÁ4§fDO’‚Fσ‰<4ç\¨õ&jÔŧbš¬ü›(¹f2Ûh,£+É9•’Pu¸þOÈþk @ÂòúžhîY0äöIa&&(¾*L’’«4äî#sñW«£)ÆLФ‘WÒ#hQs¥À7?˜=дg‡x˜(Ô&½mR¾¡Ñ„@15•*±ƶ5Š&¼%iYÞ§J!‹i W‹5ï`Ù«Oqzr‡Ä];¿"!FÕ¾3¿‚7÷¯vU|¼ˆÝY_ôI¤Ï&Ç®ú U}Us­‚Q3Õ'EÏ¿Fn ¶}jðæ“HcNVÚU²‰Á6V[Éokhч_ò1K³Î;÷_ÿ 0;”!R endstream endobj 1 0 obj <>>>/Rotate 0/TrimBox[0.0 0.0 390.0 175.0]/Type/Page>> endobj 2 0 obj <>stream H‰t—[®ä¸DÿkÚ@É|?VàoÃ^@ÁcÓm`ìýs"H©êv·ÑÀm¥Š"óüãŽØë‘g8žzøï?ÿ8þóg/ígëþÛÇÇï¿üõïáø×ÿñü‹|{†™ÆÑú9õÕëûC?|ËŒ:¡qv*gá§×#ŸA®¦Š<ëÃÖ¼Ý~oóE`áÌ3Þoj>ÓìïOø?õ÷†ÏÔÎËÇÏÔÏ\ûíìÑßÞÞöf}±Þ±¼NMg#CÏØÎQ¾¼a—L¿QÔ’ÒÏ6éë”VE™gÊŸ/Ø"Æ÷¹úJ¸ã‰Aß³_X^µ3æìêd'¸­ŒUÉü6UЏ×û»‡uÞz(O:®í"il÷qT‡Zëcû²á±-gÍÊãX†Vž,Y–‚®ì¶¬tÖ¢u¿ùl)jw`òz”³ÍÉïtS¾,ŸòõȆ±,0ns AŒb/0ûíñïÇo¿}ôÈ ”žæ¯{$S¥«Iò׊}}Žl?§ÁÜ[[XãÃ~ƒÝ¶ðÓ²¼.e¡«%ÂMaÃ}¡=ÖèÎ#–O´÷”?ÑNf[M_ÐNÝYÚImÚhŸÕÿ×r½O»êÕ —ùÒà¦ðµår›_ îßoŒØgLÓ©U… eŸ•TJ5ð‚H™Š8änŒ¨èoŒ(’$+Ô %+ËZZ@[É»0¸»ð¹R¾{¥ß.¿®j,Ø»x]n”D¨B…fÖºN 4'8Ž{Ä)ãÿÿþ†YJ¢éØ~ÆYø¬™wøÑ^ †öçóÑUùÑ w©ÐGËd=@fs§'v¶“LwQ€*˜(ž ¿º>!®Ê§UY…/ß-¥5Šm§ö3“¢÷•ËýÄ|¡&Ë‚žš§IÕóhUÏôŸážÛTz¿z@ígÍ—ìu6)aIì¾M@F÷шØûRŽöÑœûüï¥I ‘¼wHûÅ;.ŽO+®ë)ži\ïá²JÓO É–5ÈêŠ*r\…ù‡¼+GÓ´õSÇ“Õç³éé2ÆÐzx€ÁÆØdbôM˜Q<ÈŒ­|¹|óòÀ›jñÈàãëï÷¦Sœ+}Ÿ¸#eÛd)S„ðÓLØž'ò–æiCÔ¤ã¾SÉËRzÚZ+»;‹ß.³¥¦µ*¾æÇ< C3?EñüððfK†z÷|Iê¸+*%io~p¡Õ Œ²êÂÎrH“Ì¥×åA&zJ_Y§äJ(,½pYò}¯Ýò'-ðn纋TÖí­èDu«k§íœaíÚn2[™×¨x×áµ3C|w;ñäI˜Y*ä“@r%8^ŠAúDÕ,„! gE.…ÃëÑhÍÖ)ðýb@­ôQ©–mžT4,ØÃ)YôØ—£:ü•?O8{\îèìFR¶ÉêNÕðb¿<}×½~|¤ÏµÛÐo‡ z5¦Ë—Q(Ûíç¶VZk‡ Òm©wÀ„ö뉴ƼÎáuahYˆÚÒëzÄNj€,’¾‚Øæëq…¹_pÚNÃõÁÊѵÛNáû´áË›ÿË×ËT «ìÁ%´hQ¡õ(P}2nÌš\QDÀ@ó¨zS.¥Ÿ™CyãP-hò"­NNcŠ‹*5|»n Ñd!"&ÿ⊠‹žVu0YxXDðo+Røf¸8º­Ö¬A/vzL‰K¿ª«ÈvŽkícó`ÌA·Ã+ÃÝ5ÏÔ%Ê3øˆ¾qÀt‹92³€©Æ¢me¦™ +»V÷âbRhбbT²™Í4¸QÕ¿jCKBgS¥0”~Dø:ªŠÞžÞA`+™«¢%Y”f*Ve5ç¦ê‰¦X×åˆ:Ä‹¤‚àäìâcxh€ËŠ õg¶³¤)²¢D;™ ‚VµIž,SÖ"g1Ť̡dö̸¤Å*¯5_Cıfˆr8¹€²$¹áû]ïN§Xßä(þs[tç"9šÔs¦5 ù.øÍæ¨àš»Ù 1˜âƒªýUcàV*pC¤Q¦Æõ•a°V–ÀÐe¦ëQsfh¯¢QIÛièp±3}KÑiTD(˜¨Û% ¶Q6mPAä!hÌ誫¥>„ëIG¢˜Ò€åd¥mL'Ón¬þ ‚*®:c¢{LÐBëYZc=Iœ=•¿îÛƒ„Ã÷ëE”tÑôÁñm ·„¹m5ðjëN^ð-f[-ÌåxWÏ&£“u Ó'kÀ ŽÊh)«ÎYJ#Xi«Å¦ñB*5êoZQÜ5ÊY-A«AÃþ·ò¤ØæÒhì1Ý&9*êÉ‚w|á¿æ šñ6u¨dì6”¸ýx]¸¢5û÷¹ Ñ[]_…6(kæ1 #œŠ@Õ$§aÝ-§¯¢cÝ]H‹î.4}Þ¦3,èÝ¿“T2¦o»yJxfãæ–N7™ãT¥ê€®çÅ",\&àšú‰0$%ØŠ’­+Ép΢éÿ©OÉÞ”Z–E hºd±šb¬(Åd¸jê×Çú¯^†h=Ýl=¬C nˆž’0`aMÀpŽ›±8—«ÏŸËQiüÀ,“¿´¡†,‘&ÿÔeléFKÙQ~i1Äv XæÉÑ岜qQÀõ+äŸÝ”#šSEžÂ¿G¹s7£²)VÓÜ€ÚsëQÖ5«8¥©ÌšuãРØF0}xÉRñAŸ‰!PÚŸ=5œ¸¯¨¬Í¾ÇÑHÀ™Uƒà–ÊÈ#ÉÆ7q½ò4°Ç »›UI"!ߦÊ$à_v5qKtªÞüõ ‰n¼—´FX'«ϸtðð‰C3Q÷-7"‚·@ÝŽ];›Ž/uýi8Šø¬«HÐÇGÃyŽtå1TÉEöÑé¶a#¼¯SùèVø_ÂÒ–º'¡cÝâ&Unkzi” s˜”ijÈC Ìö>‡Ðïmó{6ârÓÅ$xLXUÚa¨Ï4dSrä÷᜞˅•l~ênæi¬ã&y&uþ80['ܦ†ïðL£‹5<Þ´Ý‘*hìäë„nŰF>Y)LžR£¬>Ü’É·Ly[<Ì1qu~´›{_À’m¿`ÎX©p(ó• ÎÓIb£ílÆÿöXì3ŠO´XRûG+ù²v/ýj^”¿röÕúeC!E@4£|Jç})\RB¿„c·n¡ê; ÛÕ2&N]‚XÜâÓÂ# }‚e6Á·h H¬›|%W$ÚeÐbƒPc 9èrßœI#—ÐfBè¼Ö¤O!FtBã¶Nƒã ­j=Ù²ý>䢶ŠÂÓÖ„iÈ·°ïl׉"»nÕ`/G´϶^äR²8¶‰ëâ:FíËi1óXüü—x(ÅSñÎä/5¬Ç¦ÉwµÆ™R*œâÄqŸäú¸pznüT$yIì‹(XŠŠE5“—3j¼Øï¿¢É{a—ö>%o”w0y ³® *þüú'À +.† endstream endobj 3 0 obj <>>>/Rotate 0/TrimBox[0.0 0.0 650.0 110.0]/Type/Page>> endobj 4 0 obj <>stream H‰tW[Ž$¹ ü¯SäJõ ¤øÛðÇ ±k;m`íûŽJYÕ=» '™¥”(2 þñÈ—Y¾¼çëɇÿþúøåúÏ#§ÑüÊɇþúÄß¹æõûãoÿg¾þõ¿Ç—]ÿì*«¤âîØ$åeóúø|ð—ÏdzXj\öã<>GZFÓÒ,ó6-åz~,iÍr=gjy^-åÒ¯ç‚Ñ®€+OË©]=õ…Ç’jîÇèÉlh̙ƨØ>LxЧc)ö}–šÚâöŽsKK ¿|Ž/4çxùyÛûñA¼A ªŽ,Éqû§yšíýö¨£ã "UÊÏ6Â6à+±R©ï/°…Ùë ýÍCfYKױ̰c¯þ¼0ÛSõkξ>öÂz¨2¡|¾Û/˜Ë&~¼ÒíÖ\ÀxK%o¤ûÒ­HÛˆ¶Íö†ôAHÜHGd½—w¤#†}½ŽÀ–ôÛôf÷ûÈyW¡UüPR,9‘³Í/@×ï7Ddçde !½3¹õ8¬0“¬Ü@H[…ù­CaÎ_áEnŒÄEH"aExgºÁkÀ3À=Á—Ë'½²§ëºAR½á®ØuÂÆu¸xEqâJ àß­› ‹¿\ð‚Y¤±Þ~†Y~Ë™6øfü²€ýþ|G„TÕ¾›ù¾E[ØÅâ9-T€é*ô‚½å$Úˆª(ƒ½ÑFÔ ~s½wüV5gj^Jsd[nígô‡1"šû =I ‹;¨‡t>Oï|¶Qö Ð#„WÔ< äi?³­T­“‰¶‚Ý· ”€ö&Hìýq%#öÑ@éWø”õïƒíL„ï_WÚ/^÷Âñ%îuž,•yÞƒwUÔ¼z£ÕD|”°:ßyV•³ÃêiÀ“Vã¥ë„1'/NTÃ3î ôÀ®ËhßHƒŽËT0ìöø¾Ë‡šÝbš^×íöô&SO¯éÝP±m¢1PÈn?ÙË©nBgQÜ€Ú$/1Âø®£XŽÅèôXK{(ˆ?Žé(PçZæžíc]è Sh¤¾©¾-Ñ·ÚKa1€¼Poý‘QÀÊ3ˬ+¯ ·P"¨Ã±=¨¸=2߱ޱ-·R8V“kí–<%°»m8§‹²±‡”Ndµž”xZy7íî7™EäM¡9ÖÇ®Ì>vž®dˆ*šÕó? à;vkHPÖÄO`Hœ„}QcÌËmûóõ!ê]„5ij}ñ(À)R†ÇÉ $±_¯ †ØŽ;<{¢lË ãZÏ‹¯lÓíþ ¢7÷zoWA_åí´ (·7¨Á6\½­¸ WÇ‹FA6uØ~î$i7°Zcw2æø°áF¥ê{ÄjuR³k`³™ú\e›sÙýÇí`œv¨öv'”÷q'ÔÛ“‡íìmÆe"ÿY¹”xaÆùHt½3/Bà ˆ†ã)'Þ˜7Ä8Z笤ËnÀ^ZP5ˆ‘7uvØ„íà¤`" *¦ üeì’@8òÀ°'a שˆý“Òy¢(»·G‰öÌ6ÔÀìú5J4(õ›ÈB¬ 4æ¨Ðû"8Îù¥4ðŸ ß¾P›ónpPóôòžµÄÀ0*xŒùYÙ¥v £VxMòÉB/Å)Ô“è!.-šGH 4\ë= |v_Éü‹[ 6Ìw#?ËûÍH¹¾ê^08¸›úÝb7›ë1‘}–8–¼€.}¶/Í ]5&è’+%Úv‘Vvy‹¦Nù$òÅÊ@×¢PÃ:eG12¯µ)´½H=Y™ `~5È`¨Ë(•y8:B¡òÐ|ZϦðûd7S{rqq%Ÿb{†™'E?Àå…!˜œQp‹µÞJ:f°H÷™¼úUn0`6šßtº,ÓÅÂ/äY‹Q ±XU}чÔÍ,T‹ò˜ÚòýÌÆ!"—Pƒƒù ºñ’òævZ‡›röCá\€ÈByP)m hQ5´À^ˆ)¿šœ‡Öd/ê™Ççnª™†¸bzRK48Á¹ŠÓUÍPÏû3r©8†¢ [Sº_ÔÚs(T_ð¢”ía<3ðÒ²âVñÅ!§Vº!}¨nú«lÄüŸû)ô7<ïe Op•%ˆÖ侘l*ÂlÁùrl§âY°QIÐ"M°lr¹‘îIÄÀܪ–g4瘑mä-ê· l/=Ò•X§@m!IqSuhÖcïB¬Qh8 ®dMbCsÊRA¦•Õ?IðyÖ‚04ÐŒû7ôÁ.àszÂmÙ­À{ÎmvE@Ÿldå:qþÞ_;‹j‘õ>gºšg‘Å!B[·—M¾ÝSÇ2¾ ‚¢5;©Ø«¯‚Ò€é’`ïõÚú#¿™¤ÐÁÐÐóƒQ%!âo〈 “«FÌo6Å÷÷·PNs½¹n]&óÑDí|ÄG*£ìÔžCÍŒø(n/¾×ýà;Ѩ9æú¢ªšs ù /¬hÜì)„ §¯ÎB°ÈàŦÁg¨«F¤ºrvj¿ß$_¨À""‚2:ˆZ!;u!u]hD¥œ®QZ4ñÉ€ä`£å+ÂÙ\,ãSÙavI›ŠL—ÔI‚xZÞT若ª‹…¿À0Ç"ɽÛè?ȾcdQJÖ„};ÀeÝу:cŠÜÚœ·õ”Aµ4Äqž Ò¤OOÔ²j-–Â%˜Øâ):l?KP·µ-ΘK\–¥"{ÅÊ$Qô×&z0¶µDÍ´ œ-ëe³Êiq(ݦK³ÃªÄ‚òµuÛ?hgÞ¤içÝ@ºØn Ô©Ñ?†˜„]½Ö”/`Ôaóìé6wº¨:›ÉÔѾ9ì´€€ »æÑg_Ñó@,#&Tô?1H~U`U¾›ib[U‘j€"¢f±«²ö˜Z˜¤k—dÂb¤F>ž™Ñ mú„Id# zÅÞým[Èר–$ÂÆ RÙHè=5³¶A?¨·Ù¥£øâ ‡÷ލ[! *=Mc覵&Öaš²‚*é_&749¾üÿì—ËyÝ: „÷©" 8Ið¥2RC–7ý¯ïüž‡ì”à`Q fy¹m’lÿö?©V„A2ûMIß”ôMIJB/t’ûe”¥æcÔ—+ŸX¤G}šýàGXõèò<€³¿Fn%M/¾g=BáòS—Z‹a6ÝàµÏ0Û<m†T„ÙV¹mó½ÆYBUeº)Gµ/'+=úÓIëk†5æ§Ú’&=GÜœô±=NÔp9ZÞèý1Œž½Ò‘W3‰#om=ZSž2}il·æ‰§! QÎË–ö f2Ï'Û™f͘ÖÚó\gÛJ²Šç ¦°l5FI—]ö€Y媫>r¾s§5•œŸþp¸Â!cÑÓáæU5 çÂð(ÃT1à³óªêFRr‚"8e×2Æݸ ­ê|m'X,Tsõƒ›ÕÒ@báEàEO•}f˜5÷W³ïTösð¤Ç`úž™ý婜›[ûŸâüC gÕ‘5—V8óÞ¥’üçS,Ð7Ó$PN—A,ÃU)v2༌Q'”VÂ…)Ï:ä厺 Ep\\…=ëþÛxƒµ¼¿ð¿Í{£Á¢«Äé)©iOzì…†\K«‡Ï¨€o–u®¨²û‰ÔÖ qæ¯Pazbn‚`Áð4¤‘M Ö Ãu´‘éY1ã¿XÕ˜szj{}õõ+r:ò¬%„‘¾üò<™rmNYVdI¿<ÜlÛ't6Ž'RÊÆª%ì&ò£-Õ!Ì".[„ çCávÖ¿úQ@а™P §'(žÓ¼Pų¿ —ƒB/¹%µrŒ£Èx¬£¥ûWÒ?rª* Õ@脘“Ô õqæÿA¸_`~i1ê*®â5·–#¯s5W"ìt†õªwº‰¿Œ¼ôhƒ`©*†œŽ¹K¦B)¶Qff•TŸd9AkiÁ,ÕÕO¾‡1‘çþóC¿aú¦Å¦ªEr'¸gà%P‹…؆Dû § ’öêÐB¦3Èåè  ˜àq[o·5D>ಱüDÓk/oµV¢Ýy}{,ÏXËe¦½âßÔ"%$æùœ0‡kl¤Û,WŒQr@•“û“?‹wMîHêGBM˜f©£~´K”"Ø8)ƒH”­Ó"Ÿ:Gv- )ÇqBõ©¾Å>é¿7ø´€±»_%bŠ|¦Ù{ N_L÷„#kacê2±ù¶tRß %#jZ ,uÕ)¯³¶+=#qÄâ0šý„¡=Ïf>%næ´=ç³zÿÖ‘Zy©Ç–X·X·¦¸“|ËÏKDkwÿÿû#ŸÞwûØmï{dÝí·¾þ–˜OY»¥ô-ׯúýþñ¿µ?zý endstream endobj 5 0 obj <> endobj 6 0 obj <>stream application/pdf scikit-bio final 2014-07-16T14:51:10-06:00 2014-07-16T14:51:10-06:00 2014-07-16T14:51:10-06:00 Adobe Illustrator CS5.1 256 68 JPEG /9j/4AAQSkZJRgABAgEBLAEsAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABABLAAAAAEA AQEsAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgARAEAAwER AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE 1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp 0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo +DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9I3WoR2UsFrplqshllll kiiVUSQmRjOqSkpF65dnlKkktxetDviqPhvYpDJGssTzxMvqRh1BVJGPplgC9OSbrX7Xt2VV45Vk BKhhSn2lZeoDftAeP8OuKrsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVWx yxyoJI3DxturqQQfkRiq7FXYq7FXYq7FXYq7FWM6hp99aauupGyTVI5GSICLjFJApmMgpHwPqjkE blJJ8L1YcFJ4qo/VdP1DmkulygXHGUPBcs7W0iuG+2aOy8XkDUSnIDidgvFVV0jy/p2lc/qYkT1X klmUyyurSzENLIRI71Zio3JNN6Uq1VUyxV2KuxV2KuZgoLE0AFScVQ2n30d9AZ41ZYuRVC1KnjsT t4NUfRiqJxV2KuxV2KuxV2KuxV2KuxV2KuxV2KqdzN6NvLNQH00Z6E8R8Ir1PTFXi2g/85A6pqWi apfy6dYwS2NvZXCAXXOIfXLqO3YyyReqqKgk5bsG2+zTcKWW+WvzLutU1bTtOdbC6F7eX1o17ps7 zwAWVtFcBkZkXkWMtDTYePbFCzQ/M1/YeTL+/giWWy8uadcu6SH4prmBWlCAgkqiooFad/bAxiVe z85ec7jzJLpqaZZTW6aZHq8aRTyC4kjnMqRQr6iJEJC8VCWYLv1wskRq3n++01o47rTFtLp7VLl7 Oe4iMis0kiemDGzK5/d1+Dl1wEut1faHgzMaH03z589vs6WmF/5se2lkj4QQql+1j9YuZfShULai 45u/E0JJ4gYssmt4SRsPXw2TQ+ni/YmWgas2qWLXLCP4ZpIg8L+pE4jbjzR6CqnEOTps3iR4tuZ5 bhMsLe7FXYqgr6e7ju7NbeOSQSMyyD4VhC7Fmlfg7gha8AKBm2JFa4qrpLcEJziVCZHVgX34Ly4s tBuWAU8dqVO+26rrRL1YlF3LHNMB8bxRtEpap3Cs8pApTbl/YqrYq7FXYq7FXYqh7OwtrNXS3X04 5G58B9kEgA8R2xVEYq7FUBdajLDqdtaqkPoyAtdSzSPEyAkJF6K+k0crNKQrKZFK1B3qBiqPxV2K uxV2KuxV2KuxV2KuxVwINfbbcUxV2KuxVJL3y3Gk6X2jFNO1CPYlEpDMhNSk0a05ddm6g4opOxWm /Xvil2KuxV2KuxV2KuxVA3umXFzcCRdSuraICL/RofQCcopll58miaSrhfTcc+JQnYH4sVU4LC+t bVY4pIpWgZ/QUoIecXpkRws0YonFuPxKnRfs1xVMsVdirsVdirsVdirsVdiqDv8ATmvHhP1qaCOI uXhi9PhLzjKASh0ckLy5AAgV+1UbYqhIbf1NZSWa6llKpMI7erRIDHMd3iL/AB8FlUIwjp+0xNY6 KpvirsVdirsVdirsVdirsVdiqE1D6yyCOBZQSQTJF6dQAdx+8ZevyxVKGOsJcQwSXVx6koLInp24 5cKFtxLtsRiqtBDrkbIXluJArKWBS3HJQd1/vu/jiqJ0xNShPG6NxcFti8ggVVNSa0R2bpQd/wAc VTPFUHc6xp9tMYZnYSAAlVjkfZthuqnFVIeYNMYVV5GAUMf3Ug+EkCu6jxxVJ/M/5haX5etVvJ7a 6vLeSWCCNbRFaUvcRySqeMjxfDxj7b1PTFUDb/mjYX0bta2F3EIGVpmmFuy+nzhUryimkCufrC/C 9GXfkBTFB2TG188rc6pLYJoupUhZ0lvOEBgDRy+i1P33qkct6iOnHfFJV185WTWa3Qs7sK37DJGr Cis3eQL+x0r1oOuDicMawcPFwy+z9af4XMdirsVdirsVdiqldwfWLWa39R4fWRo/WiPGROQI5I1D RhWoOKoDyvokuh6DaaVNqN1q0lqrK2o38hluZeTs9ZHPWnLiPYYqmmKuxVbJHHLG0cih43BV0YAq ykUIIPUHFVOW0iluILhmkElvy9NUlkRDzHE841YJJ7cwadRTFVbFXYq7FXYq7FXYq7FXYq7FWLed Py60XzdcWU+pXF3C9hHcxW4tZEj2u0CSklkdq8VFN8VULD8t9M0qEnTJSZlmFzHHOkQg5qKKnpW8 cCInsiihAOKCu0L8s/LWlW0n1eGSG4uraC3uXWQciIbdYPiZFjEpIXkS6n4qsADgpE4iUSD1TOLy lp0T2zpLNW1dXjDMjbr6YA3U0/uV+zQ9R0OPC440kRW52/Z+pO8LlOxV2KrFgjWZ5gKPIqq58Qla f8SxVcyq6lWAZWFGU7gg9jiqnaWlvaW629uvCFK8EqSFBNaCpNAK7DoOgxVVxV2KuxV2KuxV2Kux V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVj/m3WZNJtGulXnxaFApdo1Hqs4JJVl/lHU4 C05svAL5b9Uj8p+bb3XNRW3mgNvErVDpNMeY4OafEfEA420YM2SUzGQAHRkJvYpotWSITRy6fzX1 PVkKlvT5gip6juPlhcxjnmPzle6Xe6rFDbrJDpj2ylpJ5gz/AFmMvtRuoIpTw37YC6fVdpyxymBE VDh6/wA4Jo2tSRWkF24cx3DRBlDyMU9WGEqFHNeVZJafTjbsDqKgJEc6+39qtdLq07TWtvdGzuFk ZIp/jlXir255FDJuSsjD7XfFvJW+Xbi/uLC0vZrtpxcANQqyUJlRSN3YMo5Mtab9cWIJvyZNhbHY q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUo13QY9WHo3KrLZMF9 SEs0bc42JRgyg9ORxas2GOQVL8UgdO8n2+lSxS6VCkDo4Ll5pJQUowZQGXavLrgpjh08cf0/ffPd M7vTnn9aRbeJLmWF4DMJGBKuP2gEHKh6V6YW5LLjybZXd9NqF3AHvbleFy6TyojqECUMfErTiBgp xJ6DFKZmR6pc9zvtXLkjI9FlVZISkZtGVY44C3IBBGkZDc435V9MYXJ8McPDWy210KWzkX6sFWOr NJzlZ3LERBSGKdvQXrXBSiAAoIiDSjFM0iIqGVlaSj/DVWViQgRFqeHXCkRTPFk7FXYq7FXYq7FX Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq0zKv2iB88VaEsRbiHUtStARWmKpYn mry1K9xFBqlpcT2qs9zBBNHLKio/puWRGLAK/wAJqNjiqYPd2qRJM80axSUEcjMArcvs0JNDXtig yA5twXNvcKzQSpKqsUYowYBh1U074ojIHkVTFk7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX Yq7FXYq7FXYq7FXYq7FXYq7FXYqgdW/Q3pR/pX0fS5fu/X48eVD05bdMVQlr/hP65H9W+qfW/h9P 0+HPoONKe1KYqxnSf+VJfpu9/Rn6H/TFbn656Xp+rXlJ9Z/2VfVrTenLtXFSv03/AJUz+mJvq/6F /wAR82+ucvqv6T5eqtfrFP8ASK8+FfU3rTlvgacvh0OOqvr39GYaZ+ivSl/Rvp+n6p9b0qU9SgrW nfjT6MQnFwUeGuf2ozC2uxV2KuxV2Kv/2Q== uuid:c5eea29e-5a2f-4c92-a441-b709a51f3731 xmp.did:C73F93762A0DE411B42FD2453D6540A0 uuid:5D20892493BFDB11914A8590D31508C8 proof:pdf uuid:d9618e09-364d-4545-a3c8-10152cc09e2c xmp.did:2A3809C99907E41184C4D7B68ACFE949 uuid:5D20892493BFDB11914A8590D31508C8 proof:pdf saved xmp.iid:7C371A9505FEE311916CC1FAFB62AB15 2014-06-27T08:16:08-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:7D371A9505FEE311916CC1FAFB62AB15 2014-06-27T08:50:57-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:7E371A9505FEE311916CC1FAFB62AB15 2014-06-27T09:13:05-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:D713ACBD9904E4119064929701B7940E 2014-07-07T10:20:46-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:DB13ACBD9904E4119064929701B7940E 2014-07-07T14:47:34-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:DC13ACBD9904E4119064929701B7940E 2014-07-07T14:52:36-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:F24894488907E41184C4D7B68ACFE949 2014-07-09T10:51:33-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:F34894488907E41184C4D7B68ACFE949 2014-07-09T12:13:24-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:FA4894488907E41184C4D7B68ACFE949 2014-07-09T12:48:26-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:263809C99907E41184C4D7B68ACFE949 2014-07-09T12:49:41-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:2A3809C99907E41184C4D7B68ACFE949 2014-07-09T13:15:02-06:00 Adobe Illustrator CS5.1 / saved xmp.iid:C73F93762A0DE411B42FD2453D6540A0 2014-07-16T14:50:48-06:00 Adobe Illustrator CS5.1 / Print False False 1 10.000000 2.777778 Inches ArialMT Arial Regular Open Type Version 5.10 False arial.ttf BankGothicBT-Light BankGothic Lt BT Light TrueType mfgpctt-v1.67 Monday, August 30, 1993 3:58:29 pm (EST) False bgothl.ttf BankGothicBT-Medium BankGothic Md BT Medium TrueType mfgpctt-v1.52 Monday, January 25, 1993 2:11:37 pm (EST) False bgothm.ttf CenturyGothic-Bold Century Gothic Bold Open Type Version 2.35 False GOTHICB.TTF Cyan Magenta Yellow Black Default Swatch Group 0 White CMYK PROCESS 0.000000 0.000000 0.000000 0.000000 Black CMYK PROCESS 69.531298 67.187500 63.671899 73.828101 CMYK Red CMYK PROCESS 0.390601 98.828101 96.875000 0.000000 CMYK Yellow CMYK PROCESS 3.906298 0.000000 92.968798 0.000000 CMYK Green CMYK PROCESS 82.421899 6.640601 95.312500 0.390601 CMYK Cyan CMYK PROCESS 69.140601 14.062500 0.000000 0.000000 CMYK Blue CMYK PROCESS 98.828101 96.093798 3.515601 0.390601 CMYK Magenta CMYK PROCESS 0.781298 98.437500 0.390601 0.000000 C=15 M=100 Y=90 K=10 CMYK PROCESS 17.578101 100.000000 90.625000 7.812500 C=0 M=90 Y=85 K=0 CMYK PROCESS 0.000000 89.453101 84.375000 0.000000 C=0 M=80 Y=95 K=0 CMYK PROCESS 0.000000 79.687500 93.750000 0.000000 C=0 M=50 Y=100 K=0 CMYK PROCESS 0.000000 49.218798 98.046899 0.000000 C=0 M=35 Y=85 K=0 CMYK PROCESS 0.000000 34.765601 84.375000 0.000000 C=5 M=0 Y=90 K=0 CMYK PROCESS 5.468798 0.000000 89.453101 0.000000 C=20 M=0 Y=100 K=0 CMYK PROCESS 19.531298 0.000000 98.046899 0.000000 C=50 M=0 Y=100 K=0 CMYK PROCESS 49.609399 0.390601 98.437500 0.000000 C=75 M=0 Y=100 K=0 CMYK PROCESS 74.218798 0.000000 99.218798 0.000000 C=85 M=10 Y=100 K=10 CMYK PROCESS 85.937500 16.406298 100.000000 3.125000 C=90 M=30 Y=95 K=30 CMYK PROCESS 89.843798 33.203101 97.265601 25.781298 C=75 M=0 Y=75 K=0 CMYK PROCESS 74.609399 0.000000 74.609399 0.000000 C=80 M=10 Y=45 K=0 CMYK PROCESS 78.515601 10.546899 44.921899 0.000000 C=70 M=15 Y=0 K=0 CMYK PROCESS 69.921899 15.234399 0.000000 0.000000 C=85 M=50 Y=0 K=0 CMYK PROCESS 84.375000 50.000000 0.000000 0.000000 C=100 M=95 Y=5 K=0 CMYK PROCESS 98.828101 92.578101 5.859399 0.390601 C=100 M=100 Y=25 K=25 CMYK PROCESS 100.000000 100.000000 30.078101 21.484399 C=75 M=100 Y=0 K=0 CMYK PROCESS 74.218798 98.046899 0.781298 0.390601 C=50 M=100 Y=0 K=0 CMYK PROCESS 50.000000 98.828101 1.562500 0.000000 C=35 M=100 Y=35 K=10 CMYK PROCESS 35.937500 100.000000 35.156298 8.984399 C=10 M=100 Y=50 K=0 CMYK PROCESS 9.375000 99.218798 48.437500 0.390601 C=0 M=95 Y=20 K=0 CMYK PROCESS 0.000000 94.140601 20.312500 0.000000 C=25 M=25 Y=40 K=0 CMYK PROCESS 25.000000 24.609399 39.843798 0.000000 C=40 M=45 Y=50 K=5 CMYK PROCESS 39.062500 44.140601 48.828101 6.250000 C=50 M=50 Y=60 K=25 CMYK PROCESS 51.171899 50.781298 61.328101 22.656298 C=55 M=60 Y=65 K=40 CMYK PROCESS 54.687500 59.765601 64.453101 39.843798 C=25 M=40 Y=65 K=0 CMYK PROCESS 23.437500 39.062500 63.671899 1.562500 C=30 M=50 Y=75 K=10 CMYK PROCESS 30.468798 49.609399 74.609399 9.375000 C=35 M=60 Y=80 K=25 CMYK PROCESS 35.937500 59.765601 80.078101 23.437500 C=40 M=65 Y=90 K=35 CMYK PROCESS 39.062500 64.062500 88.281298 35.156298 C=40 M=70 Y=100 K=50 CMYK PROCESS 41.796899 69.140601 97.265601 48.828101 C=50 M=70 Y=80 K=70 CMYK PROCESS 51.562500 69.921899 78.906298 68.750000 R=43 G=182 B=133 CMYK PROCESS 73.828101 0.390601 64.062500 0.000000 R=48 G=161 B=112 CMYK PROCESS 77.734399 12.500000 72.656298 0.781298 R=38 G=148 B=115 CMYK PROCESS 80.468798 19.531298 67.187500 3.515601 R=125 G=143 B=135 CMYK PROCESS 53.906298 33.984399 44.921899 4.296899 Grays 1 C=0 M=0 Y=0 K=100 CMYK PROCESS 69.531298 67.187500 63.671899 73.828101 C=0 M=0 Y=0 K=90 CMYK PROCESS 67.578101 61.718798 57.812500 45.312500 C=0 M=0 Y=0 K=80 CMYK PROCESS 63.671899 55.468798 52.343798 27.343798 C=0 M=0 Y=0 K=70 CMYK PROCESS 58.203101 49.218798 46.093798 14.843798 C=0 M=0 Y=0 K=60 CMYK PROCESS 51.953101 42.578101 40.625000 6.250000 C=0 M=0 Y=0 K=50 CMYK PROCESS 44.921899 35.937500 34.765601 1.171899 C=0 M=0 Y=0 K=40 CMYK PROCESS 35.937500 28.125000 26.953101 0.000000 C=0 M=0 Y=0 K=30 CMYK PROCESS 26.171899 19.921899 19.531298 0.000000 C=0 M=0 Y=0 K=20 CMYK PROCESS 16.796899 12.109399 12.500000 0.000000 C=0 M=0 Y=0 K=10 CMYK PROCESS 8.203101 5.859399 5.859399 0.000000 C=0 M=0 Y=0 K=5 CMYK PROCESS 3.906298 2.343798 2.734399 0.000000 Brights 1 C=0 M=100 Y=100 K=0 CMYK PROCESS 0.390601 98.828101 96.875000 0.000000 C=0 M=75 Y=100 K=0 CMYK PROCESS 0.000000 74.218798 98.437500 0.000000 C=0 M=10 Y=95 K=0 CMYK PROCESS 1.562500 8.593798 96.484399 0.000000 C=85 M=10 Y=100 K=0 CMYK PROCESS 83.593798 9.375000 99.218798 0.781298 C=100 M=90 Y=0 K=0 CMYK PROCESS 99.218798 87.109399 3.125000 0.000000 C=60 M=90 Y=0 K=0 CMYK PROCESS 59.375000 89.453101 0.000000 0.000000 Adobe PDF library 9.90 endstream endobj 7 0 obj <> endobj xref 0 8 0000000000 65535 f 0000002856 00000 n 0000003119 00000 n 0000007055 00000 n 0000007315 00000 n 0000011197 00000 n 0000011261 00000 n 0000063214 00000 n trailer <<2C780593B9ACC84D8EBE5A09F6477FED>]>> startxref 116 %%EOF scikit-bio-0.5.9/assets/vertical_powered_by.png000066400000000000000000000367711446255456000216530ustar00rootroot00000000000000‰PNG  IHDRèۦɻsBIT|dˆ pHYs × ×B(›xtEXtSoftwarewww.inkscape.org›î< IDATxœíÝy|\e½?ðÏç9g’toZ -ˆâÈuWT  à­Â4EÔ{¹*?¢Ð–-„® ´UÜÀ» mÖ‘EP‘ËV¹Èu¿²Š(Ph Mº'™sžïï™´ÉÌIrfæLf’|߯W_$ç<ç9ß É|çYÎóPD ”RJ©òbJ€RJ)¥²i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª ¹¥@eK$ŽçyÕ¾ëÎt}¦µfº8²Õ³qOgç«çŸ~²Ô1*¥”*.Žöí&[['‹‘¯å{½<ÛAl‡•í$·ØNÁVÀÿÝsÏ=÷Lcc£.âl---Õ¤û g…Çò>±ÁB°à+€ý_¶=ÿÌ3cKkG+ ª3îòD}íükò­³Ok{Çu¼;èœß;wÁ‚37TkǧÅà‚…¶{beÍ>ó™Ë&>,F ¹_>Äâþ†ºù7U¦µµc¾|¡à{ „D7Dv¹ƒ‚¶ƒò¬ùmmmí‹…ÔßÒÒñ)8¸°Ð8sE‹õuuó×U¦µ=qµ@>’såB ‘m tìÁVF°`§ëâÿâñøÖ¼ƒXk{ûç¬) Š=°è¤d)/[c~Õ?ƒÔûKøXZ;΃Í<.q)—ÔÔÔ¶¡¡a{A±hiI¼ŸFn… *ãÔn±üøXH΀ŽA‡1™À?SxÏ¡‡ñÌúöö÷Za[[ÛÁ-íw ý§)ø7 ¬r€ …òxK{ÇOoK$Êéjâö€£3<((*û,IΩۢ¶ê‰D Ÿ 8ÕQH½c\5 q#üMK{ÇO‰Ä¬R4 8>,"MÆ—§ZÛ:þ£¹ùŽ7•:¨È ¦ ð¡<ÚÜÖqo{{ûÛ‡»äøã÷bæøkÀéÃèÆÖ£_;( ‰DbŒÜ d%gðœúúøo¢¼_)i‚ÎÍaFøxkkÇ9ùVÐÒÞ^kiþÁ§1ô/®ð7€÷ qxçtz•àS®•?5·v|.lL½{öÜ`gVU”ÓÂÖ‹ —€?ÚÖÖvp¾Õ÷Z{<€É™w5°?Ê·ÎqE𩤇[[[(u(£ˆ#ÀèxÏ·´%”:˜b!pª'|l]{û»†+Ç·RüÓ‘NHðé–¶Ž«£ŠkÆ nÒ—€ ÷% µñ;£ºW9õ]܃¡ `g˜²–˜lÄN·à4ÓTCpˆÃŠW ñŸÍk˜?ÿ—aãI$NÒ“€Ì3é#àãFäÛ€ÿTOOÏsçw^`"N$IkçA̹€| ™ãÕ‚é$nmiï˜3¬ÇãÛ†Ší¼óÎënnëøù§N×Wkkë sÂÀ£òw€oéw€¾˜ù†Ÿç|¢¶¶ö¥œj¹0/äÃð¬Å+ù^ÛÛ½;çÞ•ŠŠŠ ‹Í1f[b6!p²?Ì£ÎC÷Þ{ïûN;í´ž|ã¤àl€»ò½~8¾‹¿äw¥‘}Fn­¯­¹®ÐúË͘MЮˇãñøðcChmM'”Û¼5ãTŒëÖ­;lÁ‚¡Þ”’¾½y°äLàO\^_¿'L]ñx¼Àî¸í¶;gº½×üYŸêõ¥-‘HÌn,Ùnf%èc‰Ä¬x<¾%L\ýY:g3Õ5¸/âÿQp7úý“¬Ež š©^ˆD$çîmóx}}ü÷ùÄPlƒ}HF7€NO§¿oinn^D'öE×!óqäÖ®í_°6ß8{z*<ï¼3ºò½¾Xf[}]üçù^ŸH$&ôzò‹ì—qš"r}Kkûìúºš¼'ªFÄ«+àu¶¶¶%pn‘ñ¡3]_®®Žsjãw·¶'®‘e§Háú––Û­¯?ëù|cliKœGà«Y'¿ˆ¹æßò­·œi÷êêâÅ~Äÿœ>Ðu+Buu7·¶_ð‹§^xîs~æÝuuóC%çLçž{æõµ5_…Å©^Íç3Wð¸‹%~’Ž%‘YÞøÃŽUg3nvëüŸ††Ï¾œs]ãHCm¼ÀͧöëõýŽt<£E<ßÙP3ÿB7'ä[‰DbÚ‡©óÏ??i /àežóÅœ¶ž]“'~àï²NG&­Üšk\­­­Px€ÊŒúº¬Ãyçž{æ¹Ö9Zh‚¡¾>þ$À2 pô-·Ü2Øóʸå–[bOm‚uçæ:V:œsÏ=ó ßÈÙvgž#ðá&dÑÍææ'›ššrú=±05ȇ’€xÎíÈjÁ1ç-"YãϤÎÞÀcFxäHÇ2ÚÔ×ο"ß 85'é˪(bçÄã‘ýì2qtØ:Ο7o·ïà ÙkÎjmO,[×-·Ü:?9kÞ±g—ú‘·bÓ–Ø?5««ßp0iÊ´ šUpU}ýg‹2)iAMÍŸDð•€S1_t|/×å=2»Šö;ôÐ#CuoíŬǧ¶îÚ¶íH·p3»¹ 3[´Okkë~>œqX<íÞ!™tÿ7ð„á ¿ËjŸêéS Ÿmÿ×1ñØš0{¨LÓsÅ âñPx²ßO "Ë[Z:B Mš6}-€ã²N4ÔÖ>˜KL£‘&è$à1¤ôñÁ&_䢀ãÏ4{ÿÿŠ.²l uó ëM˜ä¿Üzë­A3R©ÙÞÌþ¥7ỹ×'ï€àýÊý H{Ö-løg¢…îiÈþÝýå¹ñxÞ³¥Ç“X¬çÍAÇ­ìT¦†pÚi§õ@ð­€SŽçÙÓG< ÈÙìßày8Cª«‹?&@öäUÀÀ ¥­­í¡®oiKœÇàÆÆšúšø-¹Æ3i‚‹ Z´ãõÁ?hno?†Àì€zn:þøã³Æx¢F‘ÿ8¼_å„ uÇû Z´äÔ°÷ O¦˜ Ù÷c?BƘ~z6wXYãϲƶU0¡ þY;vµ.•’ì©ø>´[ò¬„™õííïèõëõÞ•O} µóÈ·NͰ0­6l|’(Õ£&ßÍ>ß<ÿçg¾žO,£‘&艄ÀçA<9Ø5þsàqk²Æ²‹ÁuM€=Y'Ä ú6P¼#»Wà·ÝvçÌpwÎJ´[\õ?pÎ9Ÿ}À£åÞf¦hjÌ?kf¹.NR[[Û{EU!ºÒk1«R”ÉÝ™Ç ÌmnnžZŠ˜ ÕÚÚz€ó_Èx<À÷‡{z(Î>`!œúЫ›6/Ï<˜H$&;–?BÆ ‹þsPWì½ʉ&è’¾|ÀŒÌã5ÄeAÝÂëêÎz6²À†Ç·¸?ó¸@‚_Ù«®®îud6±X2hIÍÒŸzʸゞÁfÀóʃ¶ìú™4uêÇ x$øXmmíÆá®ïZZ:N±0#pùU¹9n”0Þ‰ (iÅÄus~l°”š››§6·uü«Ðù ïíŽà†˜Ã+ ©ÿøã÷¼d,HÖ¼\ÚÚšÐC—ZÐià"Q¼FØOÇãñÀ¡Æ±jÌ.T6·v\Bfì–”²•â5–œ¹¸ æ¼9AAˆÞr÷O$âñxvëºï2‘Û…ðXEúq«Ö¡n糺Ï3»·ûx^ÅœXò[è÷i]5.ʼnÂÐÌËÚ€MlaÝÛFNiiogAu bç¶m·—báþD"1Ãó¼7Yc2oòs0Ák« qsCMÍm…Ü/VÕûÙ–öö¬§"Ð[_SsGê-˜^ úE5>³‡¶Š¯ª¥­ãšá ‰ÈDCÎb…3˜A'ö6îÀŸ¸æõ^Ö¹çžùƺööÓÁÿ`àŠvÊmë×ßñîsÎùì«-í‰/L2ÝCËÓkë£}êe4Ð`ݺ;÷w+¼/ˆÈùdP¢…ÀbÁ`¿0‰DÂÕ%LÈ?¯Ç—‚rç™·´%ïºæŽ¤/7a@ OAêÑ©¡ZY™[à½úÜsOgve,8ssK[Ç#úxÓú¶¶ãΩ­ ¼${õ0›Ó.ĪôÖE‘«¨Ø¿@Þ+l5·%r&d?¨P0ôK#~6cꔋòo_5ø"ý ·!µj^ÙáKA«é‹ ˜{R|•†ÝJ•Lï—'€ ú§Ì?àòÚÚøO£ pAMÍŸZ[;q>†9˸ÞúæööŮɸL@ù\}ýüA‡Dz1› “ž\×ÜÞê“-¦8À pb˜!2øF"r]C}MÖŠ;}º»Ý™N,™5| Àˆî)+°/ïÇaÁ :¿ÖÒÖñ8>Þ°KKâ}ƒíÓÜÞ~,ÁÌÝoCŽ‘í9qà!S‹ìñi©í9A ¼‡à±ô˜ö˜DHQ༴¶&Ú7áñD„/mkÈ9%'Jñi¹aÃ7ê ­uuóïjiëhpmÆ©)|™‹‘W××ÔŒÛ  cw š8—‚ óD-ˆ@‰TËwˆ¦€ÜZáš+‡ºuEEï`ªBmÞIµ>²;eØkE²gsñ¸“2°ÝÛû®ñî@ƪEœ=èÂ(Æf¯¦‹“äb7ÁGA~å ÙûÿSÔ-¤ñÆuí`É+s’Õ(#Ÿ¥ðž¯m~¥¹µãkˆx»ÈúÚùË€ì‘ÑÍ.ÀúTÙñk̶ £Ç§`å²ú!ZÎ}Œ1›|?û“5´›P‰Ù/¨GÚˆüc¸K­kîp|ÐÝ$ài‚þ`2s£—jkkÿg¨{ÔÕÕ½ÞÒ–x(cOçýß~øáE@+Z¬ÌËx«°ƒ Ë q¥8½½û¹¥]#˜¸àƒFü'fÏžýÅzÄO€V°(EáõJ1Ƶ#á‘3ÐKle¤‡²=¬df„Ø¿oÇ.Jª÷0(ìO↖¶ÄÇz»cçE¸Šìœ<á¼É»v Á{)óËÓ¦üKD÷µ4Agól`#À"ö¶£®®î©°Äãñ­-í]Lï\Dö>ÜÁ‘˜4Ì”LVûÈÄ‚xü-mÿ àØ½õA>ØÒÒR]__? '`}[ÛqfÀR|ée7ÃÌ î0`†¸žŒH$f€øhƵºcÀçÕueº›• šk+Œu’Sk¦Xâ ÔV¡òÏÈì"|'Çy¶˜Ïß'»+¾RŽ»Y“ñ1#xدt,ºëkç_“çµlkk{“Ði±_ÊØ€œ^YÕûè½÷Þ{L![’öwþ¼y»[Zî8Æû€êŒÓ/ÅžÕ½F³±› É‹!Á]¼ËYkļáѾZiÌÆ§Ÿ~zsDÏÙýÈXQk„Ǧ9$ Cî^°àÌì5rƒÝŽ~ €Cº'#c·ÒÔf¦b‹ìÕ‚ÄÜ™ôñ=ôß‘8À€íûz}œš¹}eУZcMmmí‹!‹¶·´´TÃÄn¤ÿÖ€³|£×—¯µ¶v|¹®n~^ N¨l©½¶³ÑHØ¿¯r!é}V577—n¬‚O (¼«kÛŽF—GuÓúúÏþ½¹-ñ\ö< þ6Ÿ-nÇ¢1› cí‘´®ò$‚¿23A >šH$*Flk4ÁIÇ^ {¹ux»ÉØ ý¸ÕÞĘH$Jæ^±òBCMMðzÏâñøÖ–¶Ä@ÿñm¾­¹9qtCC|ïò‚ùtf÷6` ïÞCÒ=ó[Ú:.°ý昘-D¢µµ£¡®nþ˜ÿ`3B2÷N_’ÉÀ‰”£ACCÃö 6œþÊk›ÿHàˆþ縴½½ýÖšššçJßx3v'‰•Á{ONŠ||$î["qYPˆ ž!äœxü/þ0ð(¬âÕkí\¤Ziûî!¹MÜ’€µ¹éÈ}_' Ä€ûüE]]ݦ\î3^Ô×Î_AÁYÈÞ6Т¥¹-‘ù8œÊQSS“aÆÐLÚo¶x@:þøã=R‚&º¾˜x@ã˜&è"©ž6¹@v7•!—ÚŒŠëKÐþÏâ"p«¼AIöÚÜsZ[oß»¨G: 0Øâ$ƒIöTü™Œˆ½›x>€Œq*½=´ººùw¼0à”CHskkÇpk²«!vØ‘CÀZ@à’–£N̘A>ÈË?l$ã›&è"IOp¸9û ë¬9]ˆD"1 ‚KîýóšššœÖ[–€YÒbìÞ®="cÍqÁŸësœpuÞygt¸/£ž÷$‰É ÌZ{Û÷{]íÞF}Mü{@ð®KB¬knKÔtLc…Pš[‡òŸ#LLžÔµmÇúAä(@j•.8õ˺ºxÖæaˆdvsËñH}ÐÈÞ±ËÍ­{»µÉ»t8hðáD"1ƒþ3ɵ{;ñxÜïžPU;È~¾.a:Ö¯¿c´¯|5bZZn?” 5ø}Âý­NFæ·2"›ý¨MÐEV_;¿)µXÄ@œýŽÃøáºuë&Et+¶´u\ àšìSòw?ûl¾;ÌZUlÖºöö£ðGLàO©wøyÿc"øP¯“1ð÷Ô·ÉXY®Í\®¾ð™Ïìð OGÀJvf×K¤¶ñTCioo;Œw?R { "«jkkW‚°"×Ò’øÀ†€S{\׌Ûe7KAtñ‰ßÛó9Yã²Îqb•¿-tL:‘HÌni븩Gk2m§Ø.¤K8õÆ3p«8G8?«e äÕzî“ÝÍ-"ì©¥6h÷vîÄãƒÅ9^<棓¦M¿q¤c-Z[ogk[Ç­¾ð™ìE<µkǶ 1éQ§¥¥ãS0ò²·ÅãñÝO`¼³ÏA—“ ìZ—Hœîøò(€7gœ>ÌÂ<ÙÒ–¸ÛÀ¿¾¶¶öñ°õ¶··¿Ý/¡à<ŠxB‰×׆_mp¼À×û¸™ð¬SP‚v]Þ“ôeö­É»0p Qºµä8V_?ÿg-mËd=BCÁW›ÛO4ÔÆ[JZY¸÷Þ{+;;÷Ì'9bæ±s„f.(g`°Æ qOτʆókG~KѨ´¶ÞþN¡?À<‡àµÄÿ–ÜS±x„C÷4Añø?š››6Nl_È8M@N·0§·´u¼ÁÓ ž𠞆ç¾×{}9B€#@s GÙÒÖñ2€A³Èoövp=Ìz¶:u i ÀC¢Ý¯'›°${gill´­­­õBç·Î8=‘ŽÜ‘H$މÇãÃ/“;-öÏЃí7”*‡Gˆ`‡ÿÚPèw>&ò× Äÿ93ëkjþyÝjX:]õõó뽋ÀJQ=¶Ð ðÇÖá»ëkç7a9Q0hëu¸­%ÃÚ9iÒOì @goG¢®®îuXžàݧޑ´²o18t¼”ù1—”YrŽÚnÖÃàäçŸ}æ=5šœKF[Ð%’^7ùrW´tt| VÆ09c»AÜ+Â;à÷þ¤èK Ü‹ Õ©žÌaS‡!?oÞî–¶öŸÌ\ŽÒ3âßÅ=P_²µµ}¡ßÉ:)øtK[Çãt/Þ]€l¸ àf¡¼f,Û3©êÇ_øÌgv”:¸ˆuØb3„›!²EˆGz&V%Æàk•F}‚Ž9¸Óóœ'²ÏØÑ²ŠÔÏŸÿ ¿H$_M&q4)r ¤áì/‚.¼f­¼Jƒ×@nŒ‘ÿÇ÷ŒT Ï?óÌc‡ö®#²Ïôf=¾Sˆ˜c¾âyæšþÇDØ[W?¿ mü\—xž ˆ¿ø(CÿŒ\ƒ[<ÏѦêêj¾ÛÞÞþ€µnVOšü k’Ým••þ†¢Àuì³÷=Ä<'¯‰Lžk{ÐݽyÁ‚½7å$æðFÏ3·æ{½çÚždeåëå„iR&ô?–tmÉã* ³e¯RJ)¥F’ŽA+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReH´RJ)U†4A+¥”ReÈ-u*MMMfÆ fÖ¬YfÒ¤Iæ7Þ0$ÊÊJ³{wÌTTì1®ëšž׸®c<Ïce¥O߯ ãôßÑZK?æÓIcc–1£µ>1ÆZKëZºÖ¥çyÆu]Zk)bé8}ß7ŽãPDh­¥1ƈXZÇ¡c-}cŒc-E„â8¤O#ŽÐKkãkt}BCŸÖ8bR×!-¡I#iúÎ1´´¦ïLªŠú¾I×™þ^R߀ÒR_ )FÒe@¦Ëû#{ï#bÓ÷µé{¦îŸ® †Â}e‚¾ïûºï¸Ù{=(d¿2@R@`’úš¤XXI_"}e,ìÞ¯)©2™ßï­Ó¦ëå¾2°Ò¦§Ê’ª›Ú¾û‹X"õuVÙcß½mê}×Û~÷OßÓ¦^‡ˆØÔµV8È11bûÎù´âˆ±¤ß§F$õ‹)ÆøâÓ}Š8béû©kŒÇZë#Æ÷…4b­µÆ˜ÔyßÇq¬Ÿ>gŒÏóÄu]ëOŒ—:–ºÆ‘¤IŠIñcÖ:IGŒ1â8Iñý ë8½ÒÓãˆëºây¾­¬ô¬çy¶·w‚81i{zz¬ˆø3gδ»ví²[¶l±Ç¼mll´y¼]¨Q‚’ú;q'œp‚;kÖ¬XOOëû“݉“®ïWº¾ï¹¶Âw+l̵Öw11ëZk]q×±Öq\q¬ëˆ¸Ö2&F\#ÆF\ãˆ+BWŒ¸´Œ¥Ž‹kп] \!b)FRïãFRï°„Cˆi(0pI—ƒ!ÄÆˆaBÒå:&0Hõ\8ô1ÀýêÓeÒõQö^GÀà¤ëèÿO)5>ÙþÿøÒ÷=a!´€õ¦ËˆКþå$]ð÷]+@º- ér©ú´X°_}„…ˆ%h…°"©:)´ XV„>D¬>I!U>ÝBwúZó©ºhê%IBú¾‘êÞ%R÷L}Ïô±~_H]“jÑû¾' L}™ùuºN0u¼ÿýúßgo¹Pÿ”ê#!ÿY€écL ËAÒÇ÷}-©_ìå˜:)Yu÷ÿº¯NBDÒu¤ºçÓõQ€tK³¯Õ øH·T‘nͲ¯µÛ×Zú©–ìÀ+Ÿ€•¾V¯¤[½€#–B Ð+éòfï×"b)&õµkÒ׊ˆc,>E,Lª5lÄXéWÞì+/ðG¬µNꘓ¾Æ÷=Òx$=/Ýꪵ[YYéUWW{·Ür‹'c% bÌ$h5>‘ä5×\çžzŠ[¶láa‡ÆÎÎNîܹ“pwíÚÅîînöLŸN˜ÖÝÍžž&§LáäÞ^&“I@29‘'&éy=¯ŠPU•úÚ÷=VVzôýJ@ÿñ{ß÷YQáúãWØXú˜Ïþãù¾k 1›Ãï×·6uÜZËþãûÐl¿ïë¾²â8©1hßcÌÞq]?ý}ßשãûÆIûÊc¤ÿxiÒxŽg¤ÿ¸©ã8½&)ýÇO ·×Çq¤ÿ8j*îééqÅq\qÝnéîNwÝnq]WvïŽI,¶[ ‹ÉΊ ‰íØ!•••²­ªJ ²«KªªªdÒ¤I²iÓ&™ÿüp[d*¥THš UÙ+o€ Wvgr/¾îºi¨è½àG¾ím7{„[½ksÏâµË± W-¼ê©‘ŠG)5¶i·*;³¡»¸Á‘iA/Z}í\T$_x5€“yö}À­„ÈÉÑÔÔT1ñ(¥Æ>MЪì$½©¡´½½dõÒ÷’æ.3†):c÷4çíÅŽG)5>h‚VegõÂ…{„ZMÌŠµÝÔÔd„¼ÀäáÊ ðÒu_ùL1ãQJš UY T+š¦¸-èÝSÏ8&T,ä·‹‹Rj|Ñ­ÊC&h±ÝtSÓT+B~Â6om±bQJ?:‹[•)¾pÏZ­½Ç7öU˜fac㕽ŊE)5þh Z•©Ðëq¥}ù+ß áWÕ–{W]|ùO‹‡RjüÒ­ÊCvq“šššª¢¾½oü5b!Š&¸G}¥”Ò­Ê-B¯ÇœêFÚŠ^¼fù§ œª°È7W\²ä¹(ﯔR@ÄcÐ$Íôé“?ð­°ò&’8À¤(ï“¶ À+"òŠ!7ú¿nÛ¶óa ¹Hdaf̘ò.ñÍ{I9”­ð ¦º[Ã-• p³@^ù²û²¥ûëÎÎΣ¾ÑŒiÓê@œ>HlíÚñ½¨ïD· á‰ÝÀ+QÜ·©©©SÝÕ!‹¿&^åµQÜ7ÈŒê)7A̬ sBegçÎ?äR_õô©ÿNàÑDW\ZÞèÚ~K©ãÈÇI^u6€³KÖó:`_¡ðмÜY½ù—¿~ÿÍEY–ö¤¿Ø“‡‰êñæ^û­bÜ?CÓ‘Öx‡kæPd޳™ H1Þ—‡@²“b_¥˜×¬ÁkBùÇC'\›Óßl$ š$§OŸ|fõ´)M¼+}0ŠªÃÜÀ€¨ž>åéÓ¦­ìܾ½UDübܯºzÒ{iF§“©Ï",JVHR÷€ øÞÌéS×ù0K»ººþÙm(ïP|ŠÝF$ACÂ/÷åzÜÝSœ…€„JbY²ê²ËvDuï,ÂOò– SÆ:·Èé©ÇÅÞAdE'À¥Ž!_ó.¡þ $!@ôµ„Äô®^>éÁ«n˜¸ÇýÁÝóC­5ƒcóº"OÐsºê“/'ð c @Ò)¹¯½6Âùû~öB '=Øøk!Vzœ_?\¹‚´¿¥è?†P¾e}ÕS§ÖCpd”uFE€÷Ϙ6y~©ãˆ’¡z’ ½ßâ5KkÁpèn[qÑU¿*ôžJ•Ø¿œøðÕï/uùJµ@y}©ã(À²OÝ{aåP ƒ&éVO›rÒ §w°…Ô6 SŽ>uêÔ™Û·o¿3Ò7‘“†h.Ôku0X Ox€¢tí—BU6ïé WV` jA_~ÓÊYo Y|«1fQ!÷+ÁÛ"¨i2R¿‹Aö(xÁÙShjxŽwøM©ãÈÇ#÷5–G—:޼¥»jú{ úa¿ ]]]} ¬ø‡*tþ©³Œ3í?yòlÏ5¯3Æ‚°KFÃ’qMcñ×·o6Šû ¥ºzò{(æwAç,yP±ï?’¿Ò¸sñše{L®,a jA[ßÿB®H&ä…Ë/º|S!÷+•­Û¶,ŠzfLŸú€Ÿ•K¶víø~÷ãžøßQVH‘JkpGcø×Òñ°(cIÆš7öQ& ߌb%hxÞÁåü$µÿDôé²N€å_~¸ C†+%`Þ-èEk—MA ÁÓbü§§wízv«HÈ'‡G‹ð-hß7Qlñšå—sµÆ³îülÕ%WÝ*¥ÊŒ±xSˆ-"žPTž JÐ"òÒHl¡Rººv=`¢ˆ¼Äh "›Â®`jÌðÅ–¬Y~& ËBÞ~[ n VO›²¦kûÎkEÆöccݔغg*| ¾îó^–Á-è oº©r¢µwrÅž~6tMžõ•\âT¥!ân'üû"¬òÅë*[Y×]å]ôèq+µ!Sæ ~ÌŠ”&;¢&"ÓH^S=uê_¬/u0*vñše[€ág\S‚w´šèmûw wGþ¥ÞY7Ÿþ¸J­ººº^pj©ãäBþ°÷<0wÙ˜^Àd,)¸zë¶?X~ (KÇÞÊZããÐÙ]Ü‹V/[àœ·ê#óV/lÜ>:¥F MáçŒ5 Nùï¦Q¿×xQp‚¡“ü Àï(§Ç|™>}J¨•¢Tù2ärŸ»¸Ó+…-yDüº‹®üsŽá)5Zc„Xê;þïç>tÕ‰¥H /’•ÄÞxc÷Ë.˜5kÒr?éœ ð-9ÄABANË0æ¡ 3)8¼È÷UEF+›C<Ë 3šššÜÆÆFoÑêkO Íz„5#¸påÂ+( L¥rµ Àë×阉á·hCáýsj¬}ðĦDÄ1¨EºÔç–-»6XeaÌœ6e­e`è‰AªL‰‘M—¡Ù;-6ë²ÕËÞohH}h qÜ´ê’+Ã.û©TDäGÌ]z^1jþØcKª+zc5¬0mb†"ßþØcKÐÉbåkÔ/6>$[ zÚ´i3fN›vÊ“'çµ½âèdBvqžµçâN„Nμ_˜odJ•£G[Ùùà‰×~EÃÝ¿¢7vÙˆ¥ò2ê7ËƘJÐÆøo1?Oº3¦O} ?ü=D~o,þðúŽÏ”:ƨÑÚÍr51+þCç3Hº5ñ¸ŸwpJ•1!n%1 êg±U”Æt‚– SŒR³Îp HXx+9áo"Ý¥,JbœMÐk)„KÎÄFŸ·rÑ•ÛòL©2·g®wO² GŽP8*c»‹[z~ÔK¹þð?¶òâÆ"®W©²RÙ3-ÌBMsŠˆÊ[Á-èéÓ§¿Ýˆ|@ Ç8ä·vm» Šà”JÒÙå„oACž–¤=Y·TJy'èÕSÁ‡ 0Ü÷< EþQlJ½vWD1¿6î©+.y#’Ú”*sŽß3iŒbŽyùwq >`Ft¡D@$K6¾xQÔSl/Ž’8s«0; ®Dð IVœ¸âMÎjü°Æ}G©c(&މÝý8äkÈ;A PöÝ„^‹¢ñý¢Q{=ç˜RKî*äzo™°Ã?ùºË.ÛULJ•»ù‰¦ Çǵ¥Ž£˜„Rö9(„!_CÞý|I ‡å{ýHàå«{À~Ö1FùZËÇìÆÔ¼®ôH¬\uñWG‘R0‡Ï}èê/EY#E€3„8@˜5·GñÆ|)D¡¹'=xõ³E%‡€'į!ÿ ‘—‚RâÍÕÕSÏÈ»Þ<Ðð횯H¾ám^ðî –2·ºzê;#¼W ç­øBP¢|­e#½£Õ ¿|a&WW-^³ì R¾Õ#“›W/\¸§1*•;ù%ì.kaå´tê ‘Ç£aä‹—ìð}À“ò]òÙØ¡?d䟠 ÿŽàí–O à„¼ë’HÔ-è`ä·C,P°A“sêäØlA`sOÐ}Žá*°kÕ’µËné†ýš‹£~tK©QIˆ_–:†|%cÎßt¯3D1Cö`ä=í ×!¢IXEÒ+tZ£ªL(ÍQÕU FøŸ¥Ž¡X˜OÓ ÛL,©ç¹%k—þKSS“® Æ»WŒuï,uùzøøÆŒÚMn(øÕý'_ó‡¡Êäý&ÕÕÕõW€?È÷ú¢£ÜÜÙÙÙøJgçŽG¹/ªú¢ÅÄëÛ¶=Yê(Іˆ²Å;K„?Ø3ÕùÕ¢ÕË#îbTjÔx"'ÿ÷É£{McKDµPˆb¡ Ò Ý§ V„ëùK!xª:ŠBðT,)a÷_-eˆW£®·@¶à’RQT‚b<u )-^³üʈZèJò[kpêý'-õk÷ÿ÷É¿§p)€ÞRÇ’ƒ$Áë˜{íÿ W° ½yçÎ×:·ï8š³þ¾º¢ÁßrvçöGoÚ¹3ô.Hauvîüô®oá…jLz$OCXß¹mÇ‘©ÞŒ1­ðg¡ƒ9€,]´zù½_¿±©Œgè+U°W~üë¹KßÿÐ ×þ¦ÔEåþ“š®1Öy+7Ø^êx†°“‚µ¾ã¼íþ¹M‹Ã\Pð23""npûA4qçÎc¤Å3 N¡÷da »Y 6Zk6Nž]”{Kv…ü±nEêCçôœª§œâÒùÝâÕËkV]rEÙÌj%q­2š’µ~Yci!!í¨tÿçBS²‰ˆÙ`ÀM„³Éø;7Ý÷Éoçý¢¡í8Ì#MæÏŸwº«þR—žz_ÓŒÞ ŽceŽ€³™) ¹%^D("v ùªã›W}§çÕç®Ü:\—vP=ÅŠQ©H,^³¬@mˆ¢[cŽô­ý€ùyÜÊ#°xåÂ+oÌãZ¥”Š”ÎdU£AØOÿ“—_tù¦U ¯¬ÈÈý)W€¯Yz×µM¹µÂ•R*bš Õhv º¢©©É€ë^õ] ™ `sî·ãé•âüöÒo®ø§Ü¯UJ©hh‚V£€„?뚆½;Ô_¿ðªG]á1 ò™óVÇÚǯ]qZ×*¥TÁ4A«QÀ„NÐξ Ë.¹â¥ Ûüã¬ËãÆS öžÅk—éþæJ©§ Z•=‘ðYÅ<7kÖcccc÷Ê…WžK๮ è@ðíÅk–­ÕÕÇ”R#IßpTùcè.î§–-¼bÐçÓW.¼rˆ=Èká“‹öL5w]zà “ò¸V)¥r¦ Z•=†ƒÞHÍp…®»äêIÿ@>+àñÓŽÓýè¢ë›ÌýZ¥”Ê&hUö|ã µ@Ê?.1ÎQ«^*鮼¸ñIV|{ò罌9¿ÒÞJ©bÓ…JÔ¨°xÍÒzç踃àvKyðoþãŽx<¯=çšššÌž©f9ÀPËîeØN⬕_9jwÓQJ•7MÐjÜ[´vyEþ@UŽ—&ü×ë^ñÃbÄ¥”ß´‹[{×]|E³€Ÿ‘ëÖ{1Bn]´vÙUE L)5®i Z©´E×7H×¹ ıy\þ¶û_jllô"L)5.i Z©´ë.kÜ8a‡ÿq-y\þÅ=SÜŸ4}·iòðE•RjxÚ‚V*À¢ÕË–X†Ü?ÄþÞ¡ùÔò‹/µq)¥ÆMÐJ bÑêeŸ!±À”/ý Ÿ ûØ—RJÑ­Ô®øÖŠwù¾½À[s¼´‹Ä™+/¾rCÂRJ:­Ô–_xùŸL…s,€ 9^:]÷¥ŸßVJ©œi‚Vj+.XòFç¤ý?™ÇŽX×/Z½lIQSJiÚÅ­T–¬]¶B¹'\âæ:ü‚|W=SJ?š •ÊÑ¢5K¿Bð&äÜ%?õý 5ßøú×Cïo­”¿4A+•‡Ek—AA € 9^úkǘyË/º|S1âRJš •ÊÓåk—~Ø ï03·+ù¢±æ´_[òlQSJ š •*À¢o.;œ–?ä/Ý ËÓW}íŠÇŠ—RjôÓYÜJ຋®ü³õ¼ømŽ—Î€‘û—¬^~V1âRJ~š •*Ðõ—6¾6¡Òÿ„÷åxi•P:­^~aQSJjš •Š@ãWwNØáÍ#ëÞІ”o.Z³ì,JpJ©QIÇ •ŠØ’µË–‰àŠ\¯¢}3ísßúêW{Š—RjtÑ­T,Y³ôK~€“Ëué¦Æš‹»ŠšRj”ЭT‘¤wÃjCîÏJ?å O[vÉ/#.¥Ôè  Z©"Z´zù‡H¹À~9]HlôiNûÆE—ÿ±8‘)¥ÊNSªˆ®»äŠ'Œ8øBN t¬}tÑêkç)4¥T™Ó­T‘­¸dÉsŽáG@ü&ÇK§’æÞÅ«—žS”À”ReM´R#`ùE—ošPá/ÀÏs¼4ò6ݲR©ñGÇ •AMMMîž©Î->ŸóÅÄ÷^8èð¯ê–•Jš •*%«—]+ÄU¹^Gâ~]ãù»‹—Rª|h‚VªD–¬]z¾¿‹Ÿ•ð+ÏúónøZãëňK)U4A+UB—­^6Ïí&æv%ÿâYœtÃ×®ø{QSJ•œNSª„®¿äÊŸ#'Ø’Û•ò×HÎ]äJ©ÑC´R%¶â¢«~Eøñ×.ó…9ÏWJ"š •*+6þÅ÷üøuˆâ¿£•^wñ•?*v\J©ÒÑ1h¥ÊÈ¥7Ü0É1ÝëAœ‘qjÈÇEìÝ·Ûï766z% P)5b4A+U†–ܸôýB¾€kùme—ý&e¥ÆMÐJ)¥TÒ1h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥Ê&h¥”Rª i‚VJ)¥ÊÐÿAm›W„ðÞÐIEND®B`‚scikit-bio-0.5.9/assets/vertical_powered_by.svg000066400000000000000000000331541446255456000216560ustar00rootroot00000000000000 image/svg+xmlscikit-bio-0.5.9/checklist.py000077500000000000000000000412741446255456000161330ustar00rootroot00000000000000#!/usr/bin/env python # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import collections import os import os.path import subprocess import sys import ast import tokenize import warnings import dateutil.parser if sys.version_info.major != 3: sys.exit("scikit-bio can only be used with Python 3. You are currently " "running Python %d." % sys.version_info.major) class ChecklistWarning(Warning): """General warning class for warnings raised by checklist.py.""" pass def main(): """Go on a power trip by nitpicking the scikit-bio repo. Attempts to find things that are wrong with the repo -- these are usually annoying details introduced by human error. The code goes out of its way to nitpick as much as possible in order to maximize the effectiveness of the power trip. Returns ------- int Return code: 0 if there were no validation errors, 1 otherwise. Useful as an exit code (e.g. for use with ``sys.exit``). """ root = 'skbio' validators = [InitValidator(), CopyrightHeadersValidator(), ExecPermissionValidator(), GeneratedCythonValidator(), APIRegressionValidator()] return_code = 0 for validator in validators: success, msg = validator.validate(root) if not success: return_code = 1 sys.stderr.write('\n'.join(msg)) sys.stderr.write('\n\n') return return_code class RepoValidator: """Abstract base class representing a repository validator. Subclasses must override and implement ``_validate`` (see its docstring for more details). Subclasses should also provide a ``reason``: this is a string describing the reason for a particular type of validation failure (see subclasses for examples). ``reason`` is included in the validation error message/report created by ``validate``. """ reason = '' def validate(self, root): """Validate a directory tree recursively. Parameters ---------- root : str Root directory to validate recursively. Returns ------- tuple of (bool, list of str) First element is a ``bool`` indicating success status: ``True`` if `root` passed validation, ``False`` if there were any errors. Second element is a list of strings containing the validation error message. """ invalids = [] for root, dirs, files in os.walk(root): result = self._validate(root, dirs, files) invalids.extend(result) success = True msg = [] if invalids: success = False msg.append(self.reason) for invalid in invalids: msg.append(" %s" % invalid) return success, msg def _validate(self, root, dirs, files): """Validate a single directory. Subclasses must override and implement this method. The method is supplied with the three values yielded by ``os.walk``. Parameters ---------- root : str Path to the current directory to be validated. dirs : list of str Directory names within `root`. files : list of str Filenames within `root`. Returns ------- list of str List of filepaths or dirpaths to be considered invalid (i.e., that did not pass the validation checks). See Also -------- os.walk """ raise NotImplementedError("Subclasses must implement _validate.") def _system_call(self, cmd): """Issue a system call, returning stdout, stderr, and return value. This code was taken from verman's ``verman.Version.verman_system_call``. See licenses/verman.txt and https://github.com/biocore/verman for more details. """ proc = subprocess.Popen(cmd, shell=True, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # communicate pulls all stdout/stderr from the PIPEs to # avoid blocking -- don't remove this line! stdout, stderr = proc.communicate() return_value = proc.returncode return stdout, stderr, return_value class CopyrightHeadersValidator(RepoValidator): """Flag library files with non-standard copyright headers See the current standard for scikit-bio's copyright headers at ``http://scikit-bio.org/docs/latest/development/new_module.html`` Individual files are ignored if the first line in the file is exactly: # checklist.py:CopyrightHeadersValidator IGNORE If a file is ignored, a ``ChecklistWarning`` is raised. Parameters ---------- skip_dirs : iterable of str, optional Directory names to skip during validation. Defaults to skipping any directories named ``'data'`` or ``'__pycache__'`` (and anything contained within them). """ reason = ("Files non-conforming to standard headers as described in\n" "http://scikit-bio.org/docs/latest/development/new_module.html:") COPYRIGHT_HEADER = """\ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- """ def __init__(self, skip_dirs=None): if skip_dirs is None: skip_dirs = {'data', '__pycache__'} self.skip_dirs = set(skip_dirs) def _validate(self, root, dirs, files): for skip_dir in self.skip_dirs: if skip_dir in dirs: dirs.remove(skip_dir) invalid_files = [] for _file in files: if not _file.endswith('.py'): continue pos = 0 filepath = os.path.join(root, _file) f = open(filepath) first_line = f.readline().rstrip('\n') if first_line == '# checklist.py:CopyrightHeadersValidator IGNORE': warnings.warn( "File %s has IGNORE directive. Ignoring scikit-bio " "copyright header validation." % filepath, ChecklistWarning) continue f.seek(0) tokens = list(tokenize.generate_tokens(f.readline)) # A module docstring is fully described using just two tokens: the # main string and a terminating newline. By convention, however, it # is always followed by a newline, and thus we advance by three # positions to get to the next logical line. if tokens[pos][0] == tokenize.STRING: pos += 3 # copyright header consists of 7 lines, and by discussion in # preceding comment, spans through 14 tokens. cheader = ''.join(map(lambda x: x[1], tokens[pos:pos + 14])) # Ensure that there is no blank line at the end of the file if (cheader != self.COPYRIGHT_HEADER or (tokens[pos + 14][0] != tokenize.NL and tokens[pos + 14][0] != tokenize.ENDMARKER)): invalid_files.append(f.name) f.close() return invalid_files class InitValidator(RepoValidator): """Flag library code directories that are missing init files. This type of validation is important mainly because it is very easy to forget to add an __init__.py file to a new test directory. If this happens, nose will skip those tests unless it is run from the root of the source repository. Thus, the tests will be skipped if the package is pip-installed, e.g., as an end-user might install a release. Parameters ---------- skip_dirs : iterable of str, optional Directory names to skip during validation. Defaults to skipping any directories named ``'data'`` or ``'__pycache__'`` (and anything contained within them). """ reason = "Directories missing init files:" def __init__(self, skip_dirs=None): if skip_dirs is None: skip_dirs = {'data', '__pycache__'} self.skip_dirs = set(skip_dirs) def _validate(self, root, dirs, files): # If any of the directories yet to be visited should be skipped, remove # them from ``dirs`` so that we don't visit them in a future iteration. # This guarantees that ``root`` is a valid directory that should not be # skipped (since we're doing a top-down walk). for skip_dir in self.skip_dirs: if skip_dir in dirs: dirs.remove(skip_dir) invalid_dirs = [] if '__init__.py' not in files: invalid_dirs.append(root) return invalid_dirs class ExecPermissionValidator(RepoValidator): """Flag code files that have execute permissions. Parameters ---------- extensions : iterable of str, optional File extensions of files to validate. Defaults to Python, Cython, and C files (header and source files). """ reason = "Library code with execute permissions:" def __init__(self, extensions=None): if extensions is None: extensions = {'.py', '.pyx', '.h', '.c'} self.extensions = set(extensions) def _validate(self, root, dirs, files): invalid_fps = [] for f in files: _, ext = os.path.splitext(f) if ext in self.extensions: fp = os.path.join(root, f) if os.access(fp, os.X_OK): invalid_fps.append(fp) return invalid_fps class GeneratedCythonValidator(RepoValidator): """Flag Cython files that have missing or outdated generated C files. Flags Cython files that aren't paired with an up-to-date generated C file. The generated C file must be in the same directory as the Cython file, and its name (besides the file extension) must match. The validator also ensures that the generated C file is not empty and that it was generated at the same time or later than the Cython file's timestamp. Parameters ---------- cython_ext : str, optional File extension for Cython files. c_ext : str, optional File extension for generated C files. """ reason = "Cython code with missing or outdated generated C code:" def __init__(self, cython_ext='.pyx', c_ext='.c'): self.cython_ext = cython_ext self.c_ext = c_ext def _validate(self, root, dirs, files): invalid_fps = [] ext_to_base = collections.defaultdict(list) # Map from file extension to a list of basenames (without the # extension). for f in files: base, ext = os.path.splitext(f) ext_to_base[ext].append(base) # For each Cython file, try to find a matching C file. If we have a # match, make sure the C file isn't empty and that it was generated at # the same time or later than the Cython file. for cython_base in ext_to_base[self.cython_ext]: cython_fp = os.path.join(root, cython_base + self.cython_ext) c_fp = os.path.join(root, cython_base + self.c_ext) if cython_base not in ext_to_base[self.c_ext]: invalid_fps.append(cython_fp) elif os.path.getsize(c_fp) <= 0: invalid_fps.append(cython_fp) else: cython_ts = self._get_timestamp(cython_fp) c_ts = self._get_timestamp(c_fp) if c_ts < cython_ts: invalid_fps.append(cython_fp) return invalid_fps def _get_timestamp(self, fp): cmd = 'git log -1 --format="%%ad" -- %s' % fp stdout, stderr, retval = self._system_call(cmd) if retval != 0: raise RuntimeError("Could not execute 'git log' command to " "determine file timestamp.") return dateutil.parser.parse(stdout.strip()) class APIRegressionValidator(RepoValidator): """Flag tests that import from a non-minimized subpackage hierarchy. Flags tests that aren't imported from a minimally deep API target. (e.g. skbio.TabularMSA vs skbio.alignment.TabularMSA). This should prevent accidental regression in our API because tests will fail if any alias is removed, and this checklist will fail if any test doesn't import from the least deep API target. """ reason = ("The following tests import `A` but should import `B`" " (file: A => B):") def __init__(self): self._imports = {} def _validate(self, root, dirs, files): errors = [] test_imports = [] for file in files: current_fp = os.path.join(root, file) package, ext = os.path.splitext(current_fp) if ext == ".py": imports = self._parse_file(current_fp, root) if os.path.split(root)[1] == "tests": test_imports.append((current_fp, imports)) temp = package.split(os.sep) # Remove the __init__ if it is a directory import if temp[-1] == "__init__": temp = temp[:-1] package = ".".join(temp) self._add_imports(imports, package) for fp, imports in test_imports: for import_ in imports: substitute = self._minimal_import(import_) if substitute is not None: errors.append("%s: %s => %s" % (fp, import_, substitute)) return errors def _add_imports(self, imports, package): """Add the minimum depth import to our collection.""" for import_ in imports: value = import_ # The actual object imported will be the key. key = import_.split(".")[-1] # If package importing the behavior is shorter than its import: if len(package.split('.')) + 1 < len(import_.split('.')): value = ".".join([package, key]) if key in self._imports: sub = self._imports[key] if len(sub.split('.')) > len(value.split('.')): self._imports[key] = value else: self._imports[key] = value def _minimal_import(self, import_): """Given an normalized import, return a shorter substitute or None.""" key = import_.split(".")[-1] if key not in self._imports: return None substitute = self._imports[key] if len(substitute.split('.')) == len(import_.split('.')): return None else: return substitute def _parse_file(self, fp, root): """Parse a file and return all normalized skbio imports.""" imports = [] with open(fp) as f: # Read the file and run it through AST source = ast.parse(f.read()) # Get each top-level element, this is where API imports should be. for node in ast.iter_child_nodes(source): if isinstance(node, ast.Import): # Standard imports are easy, just get the names from the # ast.Alias list `node.names` imports += [x.name for x in node.names] elif isinstance(node, ast.ImportFrom): prefix = "" # Relative import handling. if node.level > 0: prefix = root extra = node.level - 1 while (extra > 0): # Keep dropping... prefix = os.path.split(prefix)[0] extra -= 1 # We need this in '.' form not '/' prefix = prefix.replace(os.sep, ".") + "." # Prefix should be empty unless node.level > 0 if node.module is None: node.module = "" imports += [".".join([prefix + node.module, x.name]) for x in node.names] skbio_imports = [] for import_ in imports: # Filter by skbio if import_.split(".")[0] == "skbio": skbio_imports.append(import_) return skbio_imports if __name__ == '__main__': sys.exit(main()) scikit-bio-0.5.9/ci/000077500000000000000000000000001446255456000141705ustar00rootroot00000000000000scikit-bio-0.5.9/ci/aarch64.conda_requirements.txt000066400000000000000000000002311446255456000220430ustar00rootroot00000000000000requests >= 2.20.0 decorator >= 3.4.2 ipython >= 3.2.0 matplotlib >= 1.4.3 natsort >= 4.0.3 numpy >= 1.9.2 pandas >= 1.5.0 scipy <= 1.10.1 h5py >= 3.6.0 scikit-bio-0.5.9/ci/aarch64.requirements.txt000066400000000000000000000000241446255456000206770ustar00rootroot00000000000000hdmedians >= 0.14.1 scikit-bio-0.5.9/ci/conda_host_env.yml000066400000000000000000000002001446255456000176740ustar00rootroot00000000000000name: testing channels: - conda-forge - defaults dependencies: - hdf5 - pip - pip: - "-r requirements.test.txt" scikit-bio-0.5.9/ci/conda_requirements.txt000066400000000000000000000002551446255456000206220ustar00rootroot00000000000000requests >= 2.20.0 decorator >= 3.4.2 ipython >= 3.2.0 matplotlib >= 1.4.3 natsort >= 4.0.3 numpy >= 1.9.2 pandas >= 1.5.0 scipy <= 1.10.1 h5py >= 3.6.0 hdmedians >= 0.14.1 scikit-bio-0.5.9/ci/requirements.doc.txt000066400000000000000000000000361446255456000202170ustar00rootroot00000000000000Sphinx sphinx-bootstrap-theme scikit-bio-0.5.9/ci/requirements.lint.txt000066400000000000000000000000541446255456000204200ustar00rootroot00000000000000flake8 check-manifest python-dateutil numpy scikit-bio-0.5.9/ci/requirements.test.txt000066400000000000000000000000321446255456000204250ustar00rootroot00000000000000pytest HTTPretty coverage scikit-bio-0.5.9/doc/000077500000000000000000000000001446255456000143425ustar00rootroot00000000000000scikit-bio-0.5.9/doc/Makefile000066400000000000000000000157011446255456000160060ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. # Turn warnings into errors. SPHINXOPTS = -W SPHINXBUILD = sphinx-build PAPER = BUILDDIR = build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" # In addition to removing everything from the build directory, we must also # remove the stubs for classes, functions, etc. that autosummary creates during # the build process. This differs from the original 'make clean' target that is # created by sphinx-quickstart. clean: rm -rf $(BUILDDIR)/* source/generated html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/scikit-bio.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/scikit-bio.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/scikit-bio" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/scikit-bio" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." scikit-bio-0.5.9/doc/README.md000066400000000000000000000203431446255456000156230ustar00rootroot00000000000000scikit-bio documentation ======================== This guide contains instructions for building the scikit-bio documentation, as well as guidelines for contributing to the documentation. **Note:** If you're only interested in viewing the scikit-bio documentation, visit [scikit-bio.org](http://scikit-bio.org). Building the documentation -------------------------- To build the documentation, you'll need a scikit-bio development environment set up. See [CONTRIBUTING.md](../CONTRIBUTING.md) for instructions. In addition, you will also need to install Sphinx and the theme for the documentation, you can do that with: pip install 'Sphinx<=3.0' sphinx-bootstrap-theme **Important:** The documentation will be built for whatever version of scikit-bio is *currently installed* on your system (i.e., the version imported by ```import skbio```). This may not match the code located in this repository. You will need to either install this version of scikit-bio somewhere (e.g., in a virtualenv) or point your ```PYTHONPATH``` environment variable to this code, *before* building the documentation. To build the documentation, assuming you are at the top-level scikit-bio directory: make -C doc clean html The built HTML documentation will be at ```doc/build/html/index.html```. Contributing to the documentation --------------------------------- If you would like to contribute to the documentation, whether by adding something entirely new or by modifying existing documentation, please first review our [scikit-bio contribution guide](../CONTRIBUTING.md). Before submitting your changes, ensure that the documentation builds without errors or warnings. ### Documentation guidelines Most of scikit-bio's API documentation is automatically generated from [docstrings](http://legacy.python.org/dev/peps/pep-0257/#what-is-a-docstring). The advantage to this approach is that users can access the documentation in an interactive Python session or from our website as HTML. Other output formats are also possible, such as PDF. scikit-bio docstrings follow the [numpydoc conventions](https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt). This ensures that the docstrings are easily readable both from the interpreter and HTML, PDF, etc. Please read the numpydoc guidelines before continuing. ### Documenting a module in scikit-bio In addition to following the numpydoc conventions for docstrings, we have a few more conventions that will ensure your documentation is correctly built and linked within our website, and that it maintains consistency with the rest of the scikit-bio docs. The easiest way to get started with documenting your code is to look at the docstrings in existing scikit-bio modules. A couple of modules to start with are ```skbio.sequence``` and ```skbio.stats.distance```. Go ahead and look through those now. We've structured our docs in a similar way to [SciPy's documentation](http://docs.scipy.org/doc/scipy/reference/), so that may be another good place to look for examples. We'll take a top-down approach by discussing how to document a new module that you'd like to add to scikit-bio (let's call it ```skbio/example.py```). #### Module docstring The first thing you'll need to add is a docstring for the module. The docstring must start at the first line of the file. It should start with a title for the module: """ Documentation examples (:mod:`skbio.example`) ============================================= It is important to include the ```:mod:``` Sphinx directive in the title, as this title will be included in the table of contents. Also make sure that the title underline is the same length as the title. We also need to include another Sphinx directive below this: .. currentmodule:: skbio.example This directive tells Sphinx that other classes, functions, etc. that we will reference are located in the ```skbio.example``` module. Next, include a more detailed description of the module. For example: This module consists of several example classes and functions to illustrate the scikit-bio documentation system. Following that, list any classes, functions, and exceptions that you'd like documentation generated for. Note that you do *not* need to include every single class, function, or exception that is defined in the module. Also, you do not need to list class methods, as those will be automatically included in the generated class documentation. Only include objects that should be exposed as part of the public API. For example: Classes ------- .. autosummary:: :toctree: generated/ ExampleClass1 ExampleClass2 Functions --------- .. autosummary:: :toctree: generated/ example_function1 example_function2 Exceptions ---------- .. autosummary:: :toctree: generated/ ExampleError The ```autosummary``` directives are important as they generate RST files in the ```generated/``` directory for each object. A single-line summary and link to each object is inserted into the page for you. After listing public module members, we encourage a usage example section showing how to use some of the module's functionality. Examples should be written in [doctest](http://docs.python.org/3/library/doctest.html) format so that they can be automatically tested (e.g., using ```make test``` or ```python -m skbio.test```). Examples -------- Run the ``example_function1`` function: >>> from skbio.example import example_function1 >>> example_function1("hello", "world") hello world! You can also embed the plots that an example generates into the built documentation with the ```.. plot::``` directive. For example: .. plot:: >>> import pandas as pd >>> df = pd.DataFrame({'col1': [1, 2, 3, 4], 'col2': [10, 11, 12, 13]}) >>> fig = df.boxplot() This will include the plot, a link to the source code used to generate the plot, and links to different image formats (e.g., PNG and PDF) so that users can easily download the plot. You're now ready to document the members of your module. #### Documenting module members When documenting the members of a module (e.g., classes, methods, attributes, functions, and exceptions), follow the numpydoc conventions. In addition to these conventions, there are a few things to keep in mind: - When documenting a class, only public methods and attributes are included in the built documentation. If a method or attribute starts with an underscore, it is assumed to be private. - When documenting a class, include the ```Parameters``` section in the class docstring, instead of in the ```__init__``` docstring. While numpydoc technically supports either form, ```__init__``` is not included in the list of methods by default and thus should have its documentation included in the class docstring. #### Including the module in the docs Until now, we've only been editing docstrings, which are attached to Python code. The final step is to hook up this new module's docstrings to the documentation build system: 1. Make sure you're within the ```scikit-bio/doc``` directory. 2. Create a new file with the same name as your module under the ```source``` directory. Do not include ```skbio``` as part of the name, and use ```.rst``` as the suffix. For example, ```source/example.rst```. 3. Add the following line to ```source/example.rst``` to have your module's docstring pulled into the document: ``` .. automodule:: skbio.example ``` 4. Add the following line to ```source/index.rst``` to add the new page to the top-level table of contents: ``` example ``` That's it! You can now try building the documentation, which should include the documentation for your new module! ### Documenting a subpackage in scikit-bio The process of documenting a subpackage is very similar to documenting a module in scikit-bio. The only difference is that the module docstring goes in the subpackage's ```__init__.py```. ### Troubleshooting If things aren't working correctly, try running ```make clean``` and then rebuild the docs. If things still aren't working, try building the docs *without* your changes, and see if there are any Sphinx errors or warnings. Make note of these, and then see what new errors or warnings are generated when you add your changes again. scikit-bio-0.5.9/doc/source/000077500000000000000000000000001446255456000156425ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/_static/000077500000000000000000000000001446255456000172705ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/_static/copybutton.js000066400000000000000000000053631446255456000220430ustar00rootroot00000000000000$(document).ready(function() { /* Add a [>>>] button on the top-right corner of code samples to hide * the >>> and ... prompts and the output and thus make the code * copyable. */ var div = $('.highlight-python .highlight,' + '.highlight-python3 .highlight,' + '.highlight-pycon .highlight,' + '.highlight-default .highlight') var pre = div.find('pre'); // get the styles from the current theme pre.parent().parent().css('position', 'relative'); var hide_text = 'Hide the prompts and output'; var show_text = 'Show the prompts and output'; var border_width = pre.css('border-top-width'); var border_style = pre.css('border-top-style'); var border_color = pre.css('border-top-color'); var button_styles = { 'cursor':'pointer', 'position': 'absolute', 'top': '0', 'right': '0', 'border-color': border_color, 'border-style': border_style, 'border-width': border_width, 'color': border_color, 'text-size': '75%', 'font-family': 'monospace', 'padding-left': '0.2em', 'padding-right': '0.2em', 'border-radius': '0 3px 0 0' } // create and add the button to all the code blocks that contain >>> div.each(function(index) { var jthis = $(this); if (jthis.find('.gp').length > 0) { var button = $('>>>'); button.css(button_styles) button.attr('title', hide_text); button.data('hidden', 'false'); jthis.prepend(button); } // tracebacks (.gt) contain bare text elements that need to be // wrapped in a span to work with .nextUntil() (see later) jthis.find('pre:has(.gt)').contents().filter(function() { return ((this.nodeType == 3) && (this.data.trim().length > 0)); }).wrap(''); }); // define the behavior of the button when it's clicked $('.copybutton').click(function(e){ e.preventDefault(); var button = $(this); if (button.data('hidden') === 'false') { // hide the code output button.parent().find('.go, .gp, .gt').hide(); button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden'); button.css('text-decoration', 'line-through'); button.attr('title', show_text); button.data('hidden', 'true'); } else { // show the code output button.parent().find('.go, .gp, .gt').show(); button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible'); button.css('text-decoration', 'none'); button.attr('title', hide_text); button.data('hidden', 'false'); } }); }); scikit-bio-0.5.9/doc/source/_static/style.css000066400000000000000000000045701446255456000211500ustar00rootroot00000000000000h1, h2, h3 { color: #24372C !important; } a { color: #259D57 !important; } a:active, a:hover, a:focus { color: #00B84D !important; } blockquote { font-size: 14px !important; } code { color: #259D57 !important; font-size: 100% !important; } code.descclassname, code.descname { padding: 2px 0px; } cite, code.docutils.literal:not(.xref) { padding: 1px 4px !important; font-size: 100% !important; color: #000 !important; background-color: #F5F5F5 !important; white-space: nowrap !important; border-radius: 4px !important; border: 1px solid #CCC !important; font-style: normal !important; font-family: Menlo,Monaco,Consolas,"Courier New",monospace !important; } a code.docutils.literal:not(.xref) { color: #259D57 !important; background: none !important; border: none !important; } a:active code.docutils.literal:not(.xref), a:hover code.docutils.literal:not(.xref), a:focus code.docutils.literal:not(.xref) { color: #00B84D !important; } #navbar .dropdown-menu > li > a:active code.docutils.literal:not(.xref), #navbar .dropdown-menu > li > a:hover code.docutils.literal:not(.xref), #navbar .dropdown-menu > li > a:focus code.docutils.literal:not(.xref) { color: #FFF !important; } aside > p { margin: 1px; } .label { display: table-cell !important; color: #000 !important; font-size: 100% !important; text-align: left !important; width: 6em !important; } table.citation { border-left: 1px solid #DDD !important; } table.citation td > em { display: none !important; } .table > tbody > tr > td { border-top: 1px solid #DDD !important; } #navbar { background: #24372C !important; border: none !important; border-bottom: 4px solid #259D57 !important; } #navbar a { color: #FFF !important; } .navbar-default .navbar-nav > li > a:hover, .navbar-default .navbar-nav > li > a:focus { background-color: #259D57 !important; } .navbar-default .navbar-nav > li > a:active { background-color: #00B84D !important; } #navbar .dropdown-menu > li > a { color: #259D57 !important; } #navbar .dropdown-menu > li > a:hover { color: #FFF !important; background-color: #00B84D !important; } .navbar-default .navbar-nav > .open > a, .navbar-default .navbar-nav > .open > a:hover, .navbar-default .navbar-nav > .open > a:focus { background-color: #00B84D !important; } scikit-bio-0.5.9/doc/source/_templates/000077500000000000000000000000001446255456000177775ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/_templates/autosummary/000077500000000000000000000000001446255456000223655ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/_templates/autosummary/attribute.rst000066400000000000000000000001551446255456000251230ustar00rootroot00000000000000:orphan: {{ fullname }} {{ underline }} .. currentmodule:: {{ module }} .. autoattribute:: {{ objname }} scikit-bio-0.5.9/doc/source/_templates/autosummary/class.rst000066400000000000000000000030561446255456000242300ustar00rootroot00000000000000{# This template was modified from autosummaries default format #} {{ fullname | escape | underline}} {# We need a list of the built-ins that we implemented, not the default ones #} {% set built_in_methods = [] %} {% for item in all_methods %} {% if (item not in ['__class__', '__delattr__', '__getattribute__', '__init__', '__dir__', '__format__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__subclasshook__', '__init_subclass__', '__class_getitem__'] and item.startswith('__')) %} {{ built_in_methods.append(item) or '' }} {% endif %} {% endfor %} .. currentmodule:: {{ module }} .. autoclass:: {{ objname }} {% if attributes %} .. rubric:: Attributes .. autosummary:: {% for item in attributes %} ~{{ name }}.{{ item }} {%- endfor %} {% endif %} {% if built_in_methods %} .. rubric:: Built-ins .. autosummary:: :toctree: {% for item in built_in_methods %} ~{{ name }}.{{ item }} {%- endfor %} {% endif %} {% if methods %} .. rubric:: Methods .. autosummary:: :toctree: {% for item in methods %} {% if item != '__init__' %} ~{{ name }}.{{ item }} {% endif %} {%- endfor %} {% endif %} scikit-bio-0.5.9/doc/source/_templates/autosummary/method.rst000066400000000000000000000001521446255456000243750ustar00rootroot00000000000000:orphan: {{ fullname }} {{ underline }} .. currentmodule:: {{ module }} .. automethod:: {{ objname }} scikit-bio-0.5.9/doc/source/_templates/autosummary/module.rst000066400000000000000000000006741446255456000244130ustar00rootroot00000000000000.. The extra blocks seem to be required for autosummary to populate our docstrings correctly. In the original template, these would recusively call autosummary again, but we already do that in the narratively convenient places. .. automodule:: {{ fullname }} {% block attributes %} {% endblock %} {% block functions %} {% endblock %} {% block classes %} {% endblock %} {% block exceptions %} {% endblock %} scikit-bio-0.5.9/doc/source/_templates/layout.html000066400000000000000000000024121446255456000222010ustar00rootroot00000000000000{% extends "!layout.html" %} {# Taken and modified from sphinx-bootstrap-theme demo site (https://github.com/ryan-roemer/sphinx-bootstrap-theme/blob/master/demo/source/_templates/layout.html). #} {# Add github banner (from: https://github.com/blog/273-github-ribbons). #} {% block header %} {{ super() }} {% endblock %} {% block footer %} {{ super() }} {% endblock %} scikit-bio-0.5.9/doc/source/alignment.rst000066400000000000000000000000401446255456000203440ustar00rootroot00000000000000.. automodule:: skbio.alignment scikit-bio-0.5.9/doc/source/conf.py000066400000000000000000000410401446255456000171400ustar00rootroot00000000000000# NOTE: parts of this file were taken from scipy's doc/source/conf.py. See # scikit-bio/licenses/scipy.txt for scipy's license. import glob import sys import os import types import re if sys.version_info.major != 3: raise RuntimeError("scikit-bio can only be used with Python 3. You are " "currently running Python %d." % sys.version_info.major) # Force matplotlib to not use any Xwindows backend. import matplotlib matplotlib.use('Agg') import sphinx import sphinx.ext.autosummary as autosummary class NewAuto(autosummary.Autosummary): def get_items(self, names): # Camel to snake case from http://stackoverflow.com/a/1176023/579416 first_cap_re = re.compile('(.)([A-Z][a-z]+)') all_cap_re = re.compile('([a-z0-9])([A-Z])') def fix_item(display_name, sig, summary, real_name): class_names = { 'TreeNode': 'tree', 'TabularMSA': 'msa' } class_name = real_name.split('.')[-2] if class_name in class_names: nice_name = class_names[class_name] else: s1 = first_cap_re.sub(r'\1_\2', class_name) nice_name = all_cap_re.sub(r'\1_\2', s1).lower() if len(nice_name) > 10: nice_name = ''.join([e[0] for e in nice_name.split('_')]) def fmt(string): count = string.count('%s') return string % tuple([nice_name] * count) specials = { '__eq__': fmt('%s1 == %s2'), '__ne__': fmt('%s1 != %s2'), '__gt__': fmt('%s1 > %s2'), '__lt__': fmt('%s1 < %s2'), '__ge__': fmt('%s1 >= %s2'), '__le__': fmt('%s1 <= %s2'), '__getitem__': fmt('%s[x]'), '__iter__': fmt('iter(%s)'), '__contains__': fmt('x in %s'), '__bool__': fmt('bool(%s)'), '__str__': fmt('str(%s)'), '__reversed__': fmt('reversed(%s)'), '__len__': fmt('len(%s)'), '__copy__': fmt('copy.copy(%s)'), '__deepcopy__': fmt('copy.deepcopy(%s)'), } if display_name in specials: prefixes = autosummary.get_import_prefixes_from_env(self.env) obj = autosummary.import_by_name(display_name, prefixes=prefixes) # Filter out any slot_wrappers that work their way in (more below) if type(obj[1]).__name__ == 'wrapper_descriptor': return None return specials[display_name], '', summary, real_name return display_name, sig, summary, real_name items = [] for item in super(NewAuto, self).get_items(names): temp_item = fix_item(*item) # Drop slot_wrappers (see above) if temp_item is not None: items.append(temp_item) return items autosummary.Autosummary = NewAuto import sphinx_bootstrap_theme # The extra_public_methods depends on what class we are looking at. import skbio from skbio.util._decorator import classproperty # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here: # # sys.path.insert(0, os.path.abspath('../sphinxext/foo')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # Using `sphinx_version` doesn't work, likely because Sphinx is expecting a # version string of the form X.Y, not X.Y.Z. needs_sphinx = '1.6' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.mathjax', 'sphinx.ext.napoleon', 'sphinx.ext.linkcode', 'sphinx.ext.coverage', 'sphinx.ext.doctest', 'sphinx.ext.autosummary', 'sphinx.ext.intersphinx' ] # Determine if the matplotlib has a recent enough version of the # plot_directive. try: from matplotlib.sphinxext import plot_directive except ImportError: use_matplotlib_plot_directive = False else: try: use_matplotlib_plot_directive = (plot_directive.__version__ >= 2) except AttributeError: use_matplotlib_plot_directive = False if use_matplotlib_plot_directive: extensions.append('matplotlib.sphinxext.plot_directive') else: raise RuntimeError("You need a recent enough version of matplotlib") # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'scikit-bio' copyright = u'2014--, scikit-bio development team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = skbio.__version__ # The full version, including alpha/beta/rc tags. release = skbio.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # Exclude this file since it is only used by autosummary to generate other RST # files during the build process, and it will generate sphinx errors and # warnings otherwise. exclude_patterns = ['_templates/autosummary/*.rst'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'bootstrap' html_theme_path = sphinx_bootstrap_theme.get_html_theme_path() # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = { # Navigation bar title. (Default: ``project`` value) 'navbar_title': 'scikit-bio docs', # Render the next and previous page links in navbar. (Default: true) 'navbar_sidebarrel': False, # Bootswatch (http://bootswatch.com/) theme. # # Options are nothing with "" (default) or the name of a valid theme # such as "amelia" or "cosmo". 'bootswatch_theme': 'united', # Location of link to source. # Options are "nav" (default), "footer" or anything else to exclude. 'source_link_position': False } # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static/'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'scikit-biodoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ('index', 'scikit-bio.tex', u'scikit-bio Documentation', u'scikit-bio development team', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'scikit-bio', u'scikit-bio Documentation', [u'scikit-bio development team'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'scikit-bio', u'scikit-bio Documentation', u'scikit-bio development team', 'scikit-bio', 'Data structures, algorithms, and educational resources for working with ' 'biological data in Python.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # -- Options for autosummary ---------------------------------------------- autosummary_generate = glob.glob('*.rst') #------------------------------------------------------------------------------ # Plot #------------------------------------------------------------------------------ plot_pre_code = """ import numpy as np import scipy as sp np.random.seed(123) """ plot_include_source = True plot_formats = [('png', 96), ] #plot_html_show_formats = False font_size = 13*72/96.0 # 13 px plot_rcparams = { 'font.size': font_size, 'axes.titlesize': font_size, 'axes.labelsize': font_size, 'xtick.labelsize': font_size, 'ytick.labelsize': font_size, 'legend.fontsize': font_size, 'figure.subplot.bottom': 0.2, 'figure.subplot.left': 0.2, 'figure.subplot.right': 0.9, 'figure.subplot.top': 0.9, 'figure.subplot.wspace': 0.2, 'text.usetex': False, # Some of our figures have legends outside the axes area. When they're # rendered in an interactive context, nothing gets cut off, but when # rendered in a static context (e.g., with savefig, which the plot # directive uses), the legend can get cut off. Specifying 'tight' instead # of 'standard' fixes the issue. See http://stackoverflow.com/a/10154763 'savefig.bbox': 'tight' } matplotlib.rcParams.update(plot_rcparams) # ----------------------------------------------------------------------------- # Intersphinx configuration # ----------------------------------------------------------------------------- intersphinx_mapping = { 'Python': ('http://docs.python.org/dev', None), 'NumPy': ('http://docs.scipy.org/doc/numpy', None), 'SciPy': ('http://docs.scipy.org/doc/scipy/reference', None), 'Matplotlib': ('http://matplotlib.org', None), 'Pandas': ('http://pandas.pydata.org/pandas-docs/stable', None), 'BIOM-Format': ('http://www.biom-format.org', None) } # ----------------------------------------------------------------------------- # Source code links # ----------------------------------------------------------------------------- import inspect from os.path import relpath, dirname def linkcode_resolve(domain, info): """ Determine the URL corresponding to Python object """ if domain != 'py': return None modname = info['module'] fullname = info['fullname'] submod = sys.modules.get(modname) if submod is None: return None obj = submod for part in fullname.split('.'): try: obj = getattr(obj, part) except: return None try: fn = inspect.getsourcefile(obj) except: fn = None if not fn: try: fn = inspect.getsourcefile(sys.modules[obj.__module__]) except: fn = None if not fn: return None try: source, lineno = inspect.findsource(obj) except: lineno = None if lineno: linespec = "#L%d" % (lineno + 1) else: linespec = "" fn = relpath(fn, start=dirname(skbio.__file__)) if 'dev' in skbio.__version__: return "http://github.com/biocore/scikit-bio/blob/master/skbio/%s%s" % ( fn, linespec) else: return "http://github.com/biocore/scikit-bio/blob/%s/skbio/%s%s" % ( skbio.__version__, fn, linespec) #------------------------------------------------------------------------------ # linkcheck #------------------------------------------------------------------------------ # Link-checking on Travis sometimes times out. linkcheck_timeout = 30 # You might see the following exception when building the documentation: # TypeError: 'abstractproperty' object is not iterable def _closure(): def __get__(self, cls, owner): return self classproperty.__get__ = __get__ _closure() # Add the 'copybutton' javascript, to hide/show the prompt in code # examples, originally taken from scikit-learn's doc/conf.py def setup(app): try: app.add_javascript('copybutton.js') app.add_stylesheet('style.css') except: app.add_js_file('copybutton.js') app.add_css_file('style.css') scikit-bio-0.5.9/doc/source/development/000077500000000000000000000000001446255456000201645ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/development/coding_guidelines.rst000066400000000000000000000575421446255456000244060ustar00rootroot00000000000000Coding guidelines ================= As project size increases, consistency of the code base and documentation becomes more important. We therefore provide guidelines for code and documentation that is contributed to scikit-bio. Our goal is to create a consistent code base where: * it is easy to find relevant functionality (and to determine when functionality that you're looking for doesn't exist), * you can trust that the code that you're working with is sufficiently tested, and * names and interfaces are intuitive. **As scikit-bio is in beta, our coding guidelines are presented here as a working draft. These guidelines are requirements for all code submitted to scikit-bio, but at this stage the guidelines themselves are malleable. If you disagree with something, or have a suggestion for something new to include, you should** `create an issue`_ **to initiate a discussion.** .. _`create an issue`: https://github.com/biocore/scikit-bio/issues What are the naming conventions? and How should I format my code? ----------------------------------------------------------------- We adhere to the `PEP 8`_ python coding guidelines for code and documentation standards. Before submitting any code to scikit-bio, you should read these carefully and apply the guidelines in your code. .. _`PEP 8`: http://legacy.python.org/dev/peps/pep-0008/ What should I call my variables? -------------------------------- - *Choose the name that people will most likely guess.* Make it descriptive, but not too long: ``curr_record`` is better than ``c``, or ``curr``, or ``current_genbank_record_from_database``. - *Good names are hard to find.* Don't be afraid to change names except when they are part of interfaces that other people are also using. It may take some time working with the code to come up with reasonable names for everything: if you have unit tests, it's easy to change them, especially with global search and replace. - *Use singular names for individual things, plural names for collections.* For example, you'd expect ``self.name`` to hold something like a single string, but ``self.names`` to hold something that you could loop through like a list or dictionary. Sometimes the decision can be tricky: is ``self.index`` an integer holding a positon, or a dictionary holding records keyed by name for easy lookup? If you find yourself wondering these things, the name should probably be changed to avoid the problem: try ``self.position`` or ``self.look_up``. - *Don't make the type part of the name.* You might want to change the implementation later. Use ``Records`` rather than ``RecordDict`` or ``RecordList``, etc. Don't use Hungarian Notation either (i.e. where you prefix the name with the type). - *Make the name as precise as possible.* If the variable is the path of the input file, call it ``input_fp``, not ``input`` or ``file`` (which you shouldn't use anyway, since they're keywords), and not ``infile`` (because that looks like it should be a file object, not just its name). - *Use* ``result`` *to store the value that will be returned from a method or function.* Use ``data`` for input in cases where the function or method acts on arbitrary data (e.g. sequence data, or a list of numbers, etc.) unless a more descriptive name is appropriate. - *One-letter variable names should only occur in math functions or as loop iterators with limited scope.* Limited scope covers things like ``for k in keys: print k``, where ``k`` survives only a line or two. Loop iterators should refer to the variable that they're looping through: ``for k in keys, i in items``, or ``for key in keys, item in items``. If the loop is long or there are several 1-letter variables active in the same scope, rename them. - *Limit your use of abbreviations.* A few well-known abbreviations are OK, but you don't want to come back to your code in 6 months and have to figure out what ``sptxck2`` is. It's worth it to spend the extra time typing ``species_taxon_check_2``, but that's still a horrible name: what's check number 1? Far better to go with something like ``taxon_is_species_rank`` that needs no explanation, especially if the variable is only used once or twice. Acceptable abbreviations ^^^^^^^^^^^^^^^^^^^^^^^^ The following list of abbreviations can be considered well-known and used with impunity within mixed name variables, but some should not be used by themselves as they would conflict with common functions, python built-in's, or raise an exception. Do not use the following by themselves as variable names: ``dir``, ``exp`` (a common ``math`` module function), ``in``, ``max``, and ``min``. They can, however, be used as part of a name, eg ``matrix_exp``. +--------------------+--------------+ | Full | Abbreviated | +====================+==============+ | alignment | aln | +--------------------+--------------+ | archaeal | arch | +--------------------+--------------+ | auxiliary | aux | +--------------------+--------------+ | bacterial | bact | +--------------------+--------------+ | citation | cite | +--------------------+--------------+ | current | curr | +--------------------+--------------+ | database | db | +--------------------+--------------+ | dictionary | dict | +--------------------+--------------+ | directory | dir | +--------------------+--------------+ | distance matrix | dm | +--------------------+--------------+ | end of file | eof | +--------------------+--------------+ | eukaryotic | euk | +--------------------+--------------+ | filepath | fp | +--------------------+--------------+ | frequency | freq | +--------------------+--------------+ | expected | exp | +--------------------+--------------+ | index | idx | +--------------------+--------------+ | input | in | +--------------------+--------------+ | maximum | max | +--------------------+--------------+ | minimum | min | +--------------------+--------------+ | mitochondrial | mt | +--------------------+--------------+ | number | num | +--------------------+--------------+ | observation | obs | +--------------------+--------------+ | observed | obs | +--------------------+--------------+ | original | orig | +--------------------+--------------+ | output | out | +--------------------+--------------+ | parameter | param | +--------------------+--------------+ | phylogeny | phylo | +--------------------+--------------+ | previous | prev | +--------------------+--------------+ | probability | prob | +--------------------+--------------+ | protein | prot | +--------------------+--------------+ | record | rec | +--------------------+--------------+ | reference | ref | +--------------------+--------------+ | sequence | seq | +--------------------+--------------+ | standard deviation | stdev | +--------------------+--------------+ | statistics | stats | +--------------------+--------------+ | string | str | +--------------------+--------------+ | structure | struct | +--------------------+--------------+ | temporary | temp | +--------------------+--------------+ | taxa | tax | +--------------------+--------------+ | taxon | tax | +--------------------+--------------+ | taxonomic | tax | +--------------------+--------------+ | taxonomy | tax | +--------------------+--------------+ | variance | var | +--------------------+--------------+ How do I organize my modules (source files)? -------------------------------------------- - *Have a docstring with a description of the module's functions*. If the description is long, the first line should be a short summary that makes sense on its own, separated from the rest by a newline. - *All code, including import statements, should follow the docstring.* Otherwise, the docstring will not be recognized by the interpreter, and you will not have access to it in interactive sessions (i.e. through ``obj.__doc__``) or when generating documentation with automated tools. - *Import built-in modules first, followed by third-party modules, followed by any changes to the path and your own modules.* Especially, additions to the path and names of your modules are likely to change rapidly: keeping them in one place makes them easier to find. - *Don't use* ``from module import *``, *instead use* ``from module import Name, Name2, Name3...`` *or possibly* ``import module``. This makes it *much* easier to see name collisions and to replace implementations. - If you are importing `NumPy`_, `Matplotlib`_, or another package that encourages a standard style for their import statements use them as needed for example: :: import numpy as np import numpy.testing as npt import pandas as pd from matplotlib import pyplot as plt .. _`NumPy`: http://www.numpy.org/ .. _`Matplotlib`: http://matplotlib.org/ Example of module structure ^^^^^^^^^^^^^^^^^^^^^^^^^^^ The structure of your module should be similar to the example below. scikit-bio uses the `NumPy doc`_ standard for documentation. Our `doc/README.md`_ explains how to write your docstrings using the `NumPy doc`_ standards for scikit-bio: .. _`NumPy doc`: https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt .. _`doc/README.md`: https://github.com/biocore/scikit-bio/blob/master/doc/README.md .. code-block:: python r""" Numbers (:mod:`skbio.numbers`) ============================== .. currentmodule:: skbio.numbers Numbers holds a sequence of numbers, and defines several statistical operations (mean, stdev, etc.) FrequencyDistribution holds a mapping from items (not necessarily numbers) to counts, and defines operations such as Shannon entropy and frequency normalization. Classes ------- .. autosummary:: :toctree: generated/ Numbers """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from random import choice, random import numpy as np from utils import indices class Numbers(list): pass class FrequencyDistribution(dict): pass How should I write comments? ---------------------------- - *Always update the comments when the code changes.* Incorrect comments are far worse than no comments, since they are actively misleading. - *Comments should say more than the code itself.* Examine your comments carefully: they may indicate that you'd be better off rewriting your code (especially if *renaming your variables* would allow you to get rid of the comment.) In particular, don't scatter magic numbers and other constants that have to be explained through your code. It's far better to use variables whose names are self-documenting, especially if you use the same constant more than once. Also, think about making constants into class or instance data, since it's all too common for 'constants' to need to change or to be needed in several methods. +-------+------------------------------------------------------------+ | Wrong | ``win_size -= 20 # decrement win_size by 20`` | +-------+------------------------------------------------------------+ | OK | ``win_size -= 20 # leave space for the scroll bar`` | +-------+------------------------------------------------------------+ | Right | ``self._scroll_bar_size = 20`` | +-------+------------------------------------------------------------+ | | ``win_size -= self._scroll_bar_size`` | +-------+------------------------------------------------------------+ - *Use comments starting with #, not strings, inside blocks of code.* - *Start each method, class and function with a docstring using triple double quotes (""").* Make sure the docstring follows the `NumPy doc`_ standard. - *Always update the docstring when the code changes.* Like outdated comments, outdated docstrings can waste a lot of time. "Correct examples are priceless, but incorrect examples are worse than worthless." `Jim Fulton`_. .. _`Jim Fulton`: http://www.python.org/pycon/dc2004/papers/4/PyCon2004DocTestUnit.pdf How should I test my code ? --------------------------- There are several different approaches for testing code in python: ``nose``, ``unittest`` and ``numpy.testing``. Their purpose is the same, to check that execution of code given some input produces a specified output. The cases to which the approaches lend themselves are different. Whatever approach is employed, the general principle is every line of code should be tested. It is critical that your code be fully tested before you draw conclusions from results it produces. For scientific work, bugs don't just mean unhappy users who you'll never actually meet: **they may mean retracted publications**. Tests are an opportunity to invent the interface(s) you want. Write the test for a method before you write the method: often, this helps you figure out what you would want to call it and what parameters it should take. It's OK to write the tests a few methods at a time, and to change them as your ideas about the interface change. However, you shouldn't change them once you've told other people what the interface is. In the spirit of this, your tests should also import the functionality that they test from the shortest alias possible. This way any change to the API will cause your tests to break, and rightly so! Never treat prototypes as production code. It's fine to write prototype code without tests to try things out, but when you've figured out the algorithm and interfaces you must rewrite it *with tests* to consider it finished. Often, this helps you decide what interfaces and functionality you actually need and what you can get rid of. "Code a little test a little". For production code, write a couple of tests, then a couple of methods, then a couple more tests, then a couple more methods, then maybe change some of the names or generalize some of the functionality. If you have a huge amount of code where all you have to do is write the tests', you're probably closer to 30% done than 90%. Testing vastly reduces the time spent debugging, since whatever went wrong has to be in the code you wrote since the last test suite. And remember to use python's interactive interpreter for quick checks of syntax and ideas. Run the test suite when you change `anything`. Even if a change seems trivial, it will only take a couple of seconds to run the tests and then you'll be sure. This can eliminate long and frustrating debugging sessions where the change turned out to have been made long ago, but didn't seem significant at the time. **Note that tests are executed using Travis CI**, see `this document's section`_ for further discussion. .. _`this document's section`: https://github.com/biocore/scikit-bio/blob/master/CONTRIBUTING.md#testing-guidelines Some pointers ^^^^^^^^^^^^^ - *Use the* ``unittest`` *or the* ``nose`` *framework with tests in a separate file for each module.* Name the test file ``test_module_name.py`` and include it inside the tests folder of the module. Keeping the tests separate from the code reduces the temptation to change the tests when the code doesn't work, and makes it easy to verify that a completely new implementation presents the same interface (behaves the same) as the old. - *Always include an* ``__init__.py`` *file in your tests directory*. This is required for the module to be included when the package is built and installed via ``setup.py``. - *Always import from a minimally deep API target*. That means you would use ``from skbio import DistanceMatrix`` instead of ``from skbio.stats.distance import DistanceMatrix``. This allows us prevent most cases of accidental regression in our API. - *Use* ``numpy.testing`` *if you are doing anything with floating point numbers, arrays or permutations* (use ``numpy.testing.assert_almost_equal``). Do *not* try to compare floating point numbers using ``assertEqual`` if you value your sanity. - *Test the interface of each class in your code by defining at least one* ``TestCase`` *with the name* ``ClassNameTests``. This should contain tests for everything in the public interface. - *If the class is complicated, you may want to define additional tests with names* ``ClassNameTests_test_type``. These might subclass ``ClassNameTests`` in order to share ``setUp`` methods, etc. - *Tests of private methods should be in a separate* ``TestCase`` *called* ``ClassNameTests_private``. Private methods may change if you change the implementation. It is not required that test cases for private methods pass when you change things (that's why they're private, after all), though it is often useful to have these tests for debugging. - *Test `all` the methods in your class.* You should assume that any method you haven't tested has bugs. The convention for naming tests is ``test_method_name``. Any leading and trailing underscores on the method name can be ignored for the purposes of the test; however, *all tests must start with the literal substring* ``test`` *for* ``unittest`` and ``nose`` *to find them.* If the method is particularly complex, or has several discretely different cases you need to check, use ``test_method_name_suffix``, e.g. ``test_init_empty``, ``test_init_single``, ``test_init_wrong_type``, etc. for testing ``__init__``. - *Docstrings for testing methods should be considered optional*, instead the description of what the method does should be included in the name itself, therefore the name should be descriptive enough such that when running the tests in verbose mode you can immediately see the file and test method that's failing. .. code-block:: none $ python -c "import skbio; skbio.test(verbose=True)" skbio.maths.diversity.alpha.tests.test_ace.test_ace ... ok test_berger_parker_d (skbio.maths.diversity.alpha.tests.test_base.BaseTests) ... ok ---------------------------------------------------------------------- Ran 2 tests in 0.1234s OK - *Module-level functions should be tested in their own* ``TestCase``\ *, called* ``modulenameTests``. Even if these functions are simple, it's important to check that they work as advertised. - *It is much more important to test several small cases that you can check by hand than a single large case that requires a calculator.* Don't trust spreadsheets for numerical calculations -- use R instead! - *Make sure you test all the edge cases: what happens when the input is None, or '', or 0, or negative?* What happens at values that cause a conditional to go one way or the other? Does incorrect input raise the right exceptions? Can your code accept subclasses or superclasses of the types it expects? What happens with very large input? - *To test permutations, check that the original and shuffled version are different, but that the sorted original and sorted shuffled version are the same.* Make sure that you get *different* permutations on repeated runs and when starting from different points. - *To test random choices, figure out how many of each choice you expect in a large sample (say, 1000 or a million) using the binomial distribution or its normal approximation.* Run the test several times and check that you're within, say, 3 standard deviations of the mean. - All tests that depend on a random value should be seeded, for example if using NumPy, `numpy.random.seed(0)` should be used, in any other case the appropriate API should be used to create consistent outputs between runs. It is preferable that you do this for each test case instead of doing it in the `setUp` function/method (if any exists). - Stochastic failures should occur less than 1/10,1000 times, otherwise you risk adding a significant amount of time to the total running time of the test suite. Example of a ``nose`` test module structure ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. code-block:: python # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from nose.tools import assert_almost_equal, assert_raises from skbio.math.diversity.alpha.ace import ace def test_ace(): assert_almost_equal(ace(np.array([2, 0])), 1.0) assert_almost_equal(ace(np.array([12, 0, 9])), 2.0) assert_almost_equal(ace(np.array([12, 2, 8])), 3.0) assert_almost_equal(ace(np.array([12, 2, 1])), 4.0) assert_almost_equal(ace(np.array([12, 1, 2, 1])), 7.0) assert_almost_equal(ace(np.array([12, 3, 2, 1])), 4.6) assert_almost_equal(ace(np.array([12, 3, 6, 1, 10])), 5.62749672) # Just returns the number of OTUs when all are abundant. assert_almost_equal(ace(np.array([12, 12, 13, 14])), 4.0) # Border case: only singletons and 10-tons, no abundant OTUs. assert_almost_equal(ace([0, 1, 1, 0, 0, 10, 10, 1, 0, 0]), 9.35681818182) def test_ace_only_rare_singletons(): with assert_raises(ValueError): ace([0, 0, 43, 0, 1, 0, 1, 42, 1, 43]) if __name__ == '__main__': import nose nose.runmodule() Git pointers ------------ Commit messages are a useful way to document the changes being made to a project, it additionally documents who is making these changes and when are these changes being made, all of which are relevant when tracing back problems. Authoring a commit message ^^^^^^^^^^^^^^^^^^^^^^^^^^ The most important metadata in a commit message is (arguably) the author's name and the author's e-mail. GitHub uses this information to attribute your contributions to a project, see for example the `scikit-bio list of contributors`_. .. _`scikit-bio list of contributors`: https://github.com/biocore/scikit-bio/graphs/contributors Follow `this guide`_ to set up your system and **make sure the e-mail you use in this step is the same e-mail associated to your GitHub account**. .. _`this guide`: http://git-scm.com/book/en/Getting-Started-First-Time-Git-Setup After doing this you should see your name and e-mail when you run the following commands: .. code-block:: none $ git config --global user.name Yoshiki Vázquez Baeza $ git config --global user.email yoshiki89@gmail.com Writing a commit message ^^^^^^^^^^^^^^^^^^^^^^^^ In general the writing of a commit message should adhere to `NumPy's guidelines`_ which if followed correctly will help you structure your changes better i. e. bug fixes will be in a commit followed by a commit updating the test suite and with one last commit that update the documentation as needed. GitHub provides a set of handy features that will link together a commit message to a ticket in the issue tracker, this is specially helpful because you can `close an issue automatically`_ when the change is merged into the main repository, this reduces the amount of work that has to be done making sure outdated issues are not open. .. _`NumPy's guidelines`: http://docs.scipy.org/doc/numpy/dev/gitwash/development_workflow.html#writing-the-commit-message .. _`close an issue automatically`: https://help.github.com/articles/closing-issues-via-commit-messages scikit-bio-0.5.9/doc/source/development/new_module.rst000066400000000000000000000035161446255456000230610ustar00rootroot00000000000000Adding a new module to skbio ############################ Each module needs an `__init__.py` file and a `tests` folder that also contains an `__init__.py` file. For a module, a simple one may look like this:: r""" A module (:mod:`skbio.module`) ============================== .. currentmodule:: skbio.module Documentation for this module. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.util import TestRunner test = TestRunner(__file__).test Usually, some functionality from the module will be made accessible by importing it in `__init__.py`. It's convenient to use explicit relative imports (`from .implementation import compute`), so that functionality can be neatly separated in different files but the user doesn't face a deeply nested package: `from skbio.module import compute` instead of `from skbio.module.implementation import compute`. Inside the tests folder, a simpler `__init__.py` works fine (it is necessary so that all tests can be run after installation):: # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- Finally, remember to also follow the `documentation guidelines `_. scikit-bio-0.5.9/doc/source/diversity.rst000066400000000000000000000000401446255456000204100ustar00rootroot00000000000000.. automodule:: skbio.diversity scikit-bio-0.5.9/doc/source/index.rst000066400000000000000000000014151446255456000175040ustar00rootroot00000000000000scikit-bio ========== scikit-bio (canonically pronounced *sigh-kit-buy-oh*) is a library for working with biological data in Python 3. scikit-bio is open source, BSD-licensed software that is currently under active development. API Reference ------------- .. toctree:: :maxdepth: 1 io sequence alignment tree workflow diversity stats metadata util User Documentation ------------------ The user documentation contains high-level information for users of scikit-bio. .. toctree:: :maxdepth: 1 user/api_stability Developer Documentation ----------------------- The developer documentation contains information for how to contribute to scikit-bio. .. toctree:: :maxdepth: 1 development/coding_guidelines development/new_module scikit-bio-0.5.9/doc/source/io.rst000066400000000000000000000000311446255456000167750ustar00rootroot00000000000000.. automodule:: skbio.io scikit-bio-0.5.9/doc/source/metadata.rst000066400000000000000000000000371446255456000201540ustar00rootroot00000000000000.. automodule:: skbio.metadata scikit-bio-0.5.9/doc/source/sequence.rst000066400000000000000000000000371446255456000202040ustar00rootroot00000000000000.. automodule:: skbio.sequence scikit-bio-0.5.9/doc/source/stats.rst000066400000000000000000000000341446255456000175270ustar00rootroot00000000000000.. automodule:: skbio.stats scikit-bio-0.5.9/doc/source/tree.rst000066400000000000000000000000331446255456000173270ustar00rootroot00000000000000.. automodule:: skbio.tree scikit-bio-0.5.9/doc/source/user/000077500000000000000000000000001446255456000166205ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/user/api_stability.rst000066400000000000000000000061371446255456000222160ustar00rootroot00000000000000API Stability ============= All public functionality in scikit-bio has a defined stability state. These states inform users and developers to what extent they can rely on different APIs in the package. You can find out the stability state of public functionality by looking at its docstring, which is formatted based on `numpydoc `_. This information will either be in the *Extended Summary* section of the docstring, or in the case of deprecation, this information will appear as a note following the *Short Summary*. The following diagram illustrates the API lifecycle in scikit-bio: .. image:: assets/api-lifecycle.png :align: center Definitions of the stability states and the information associated with each follow. Stable ------ Functionality defined as stable is part of scikit-bio's backward- compatible API. Users can be confident that the API will not change without first passing through the deprecated state, typically for at least two release cycles. We make every effort to maintain the API of this code. The docstrings of stable functionality will indicate the first scikit-bio version where the functionality was considered stable. Experimental ------------ Functionality defined as experimental is being considered for addition to scikit-bio's stable API. Users are encouraged to use this code, but to be aware that its API may change or be removed. Experimental functionality will typically pass through the deprecated state before it is removed, but in rare cases it may be removed directly (for example, if a serious methodological flaw is discovered that makes the functionality scientifically invalid). The docstrings of experimental functionality will indicate the first scikit-bio version where the functionality was considered experimental. We aim to move functionality through the experimental phase quickly (for example, two releases before moving to stable), but we don't make specific promises about when experimental functionality will become stable. This aligns with our philosophy that we don't make promises about experimental APIs, only about stable APIs. Deprecated ---------- Functionality defined as deprecated is targeted for removal from scikit-bio. Users should transition away from using it. The docstrings of deprecated functionality will indicate the first version of scikit-bio where the functionality was deprecated, the version of scikit-bio when the functionality will be removed, and the reason for deprecation of the code (for example, because a function was determined to be scientifically invalid, or because the API was adapted, and users should be using a different version of the function). Using deprecated functionality will raise a ``DeprecationWarning``. Since Python 2.7, these types of warnings are **silenced by default**. When developing a tool that uses scikit-bio, we recommend enabling the display of deprecation warnings to be informed of upcoming API changes. For details on how to display deprecation warnings, see `Python's deprecation warning docs `_. scikit-bio-0.5.9/doc/source/user/assets/000077500000000000000000000000001446255456000201225ustar00rootroot00000000000000scikit-bio-0.5.9/doc/source/user/assets/api-lifecycle.png000066400000000000000000001165061446255456000233470ustar00rootroot00000000000000‰PNG  IHDR¶mò) AiCCPICC ProfileH –wTSهϽ7½Ð" %ôz Ò;HQ‰I€P†„&vDF)VdTÀG‡"cE ƒ‚b× òPÆÁQDEåÝŒk ï­5óÞšýÇYßÙç·×Ùgï}׺Pü‚ÂtX€4¡XîëÁ\ËÄ÷XÀáffGøDÔü½=™™¨HƳöî.€d»Û,¿P&sÖÿ‘"7C$ EÕ6<~&å”S³Å2ÿÊô•)2†12¡ ¢¬"ãįlö§æ+»É˜—&ä¡Yμ4žŒ»PÞš%ᣌ¡\˜%àg£|e½TIšå÷(ÓÓøœL0™_Ìç&¡l‰2Eî‰ò”Ä9¼r‹ù9hžx¦g䊉Ib¦טiåèÈfúñ³Sùb1+”ÃMáˆxLÏô´ Ž0€¯o–E%Ym™h‘í­ííYÖæhù¿Ùß~Sý=ÈzûUñ&ìÏžAŒžYßlì¬/½ö$Z›³¾•U´m@åá¬Oï ò´Þœó†l^’Äâ ' ‹ììlsŸk.+è7ûŸ‚oÊ¿†9÷™ËîûV;¦?#I3eE妧¦KDÌÌ —Ïdý÷ÿãÀ9iÍÉÃ,œŸÀñ…èUQè” „‰h»…Ø A1ØvƒjpÔzÐN‚6p\WÀ p €G@ †ÁK0Þi‚ð¢Aª¤™BÖZyCAP8ÅC‰’@ùÐ&¨*ƒª¡CP=ô#tº]ƒú Ð 4ý}„˜Óa ض€Ù°;GÂËàDxœÀÛáJ¸>·Âáð,…_“@ÈÑFXñDBX$!k‘"¤©Eš¤¹H‘q䇡a˜Æã‡YŒábVaÖbJ0Õ˜c˜VLæ6f3ù‚¥bÕ±¦X'¬?v 6›-ÄV``[°—±Øaì;ÇÀâp~¸\2n5®·׌»€ëà á&ñx¼*Þï‚Ásðb|!¾ ߯¿' Zk‚!– $l$Tçý„Â4Q¨Ot"†yÄ\b)±ŽØA¼I&N“I†$R$)™´TIj"]&=&½!“É:dGrY@^O®$Ÿ _%’?P”(&OJEBÙN9J¹@y@yC¥R ¨nÔXª˜ºZO½D}J}/G“3—ó—ãÉ­“«‘k•ë—{%O”×—w—_.Ÿ'_!Jþ¦ü¸QÁ@ÁS£°V¡Fá´Â=…IEš¢•bˆbšb‰bƒâ5ÅQ%¼’’·O©@é°Ò%¥!BÓ¥yÒ¸´M´:ÚeÚ0G7¤ûÓ“éÅôè½ô e%e[å(ååå³ÊRÂ0`ø3R¥Œ“Œ»Œó4æ¹ÏãÏÛ6¯i^ÿ¼)•ù*n*|•"•f••ªLUoÕÕªmªOÔ0j&jajÙjûÕ.«Ï§ÏwžÏ_4ÿäü‡ê°º‰z¸újõÃê=ꓚ¾U—4Æ5šnšÉšåšç4Ç´hZ µZåZçµ^0•™îÌTf%³‹9¡­®í§-Ñ>¤Ý«=­c¨³Xg£N³Î]’.[7A·\·SwBOK/X/_¯Qï¡>QŸ­Ÿ¤¿G¿[ÊÀÐ Ú`‹A›Á¨¡Š¡¿aža£ác#ª‘«Ñ*£Z£;Æ8c¶qŠñ>ã[&°‰I’IÉMSØÔÞT`ºÏ´Ï kæh&4«5»Ç¢°ÜYY¬FÖ 9Ã<È|£y›ù+ =‹X‹Ý_,í,S-ë,Y)YXm´ê°úÃÚÄšk]c}džjãc³Î¦Ýæµ­©-ßv¿í};š]°Ý»N»Ïöö"û&û1=‡x‡½÷Øtv(»„}Õëèá¸ÎñŒã'{'±ÓI§ßYÎ)ΠΣ ðÔ-rÑqá¸r‘.d.Œ_xp¡ÔUÛ•ãZëúÌM×çvÄmÄÝØ=Ùý¸û+K‘G‹Ç”§“çÏ ^ˆ—¯W‘W¯·’÷bïjï§>:>‰>>¾v¾«}/øaýývúÝó×ðçú×ûO8¬ è ¤FV> 2 uÃÁÁ»‚/Ò_$\ÔBüCv…< 5 ]ús.,4¬&ìy¸Ux~xw-bEDCÄ»HÈÒÈG‹KwFÉGÅEÕGME{E—EK—X,Y³äFŒZŒ ¦={$vr©÷ÒÝK‡ãìâ ãî.3\–³ìÚrµå©ËÏ®_ÁYq*ßÿ‰©åL®ô_¹wåד»‡û’çÆ+çñ]øeü‘—„²„ÑD—Ä]‰cI®IIãOAµàu²_òä©””£)3©Ñ©Íi„´ø´ÓB%aа+]3='½/Ã4£0CºÊiÕîU¢@Ñ‘L(sYf»˜ŽþLõHŒ$›%ƒY ³j²ÞgGeŸÊQÌæôäšänËÉóÉû~5f5wug¾vþ†üÁ5îk­…Ö®\Û¹Nw]Áºáõ¾ëm mHÙðËFËeßnŠÞÔQ Q°¾`h³ïæÆB¹BQá½-Î[lÅllíÝf³­jÛ—"^ÑõbËâŠâO%Ü’ëßY}WùÝÌö„í½¥ö¥ûwàvwÜÝéºóX™bY^ÙЮà]­åÌò¢ò·»Wì¾Va[q`id´2¨²½J¯jGÕ§ê¤êšæ½ê{·íÚÇÛ׿ßmÓÅ>¼È÷Pk­AmÅaÜá¬ÃÏë¢êº¿g_DíHñ‘ÏG…G¥ÇÂuÕ;Ô×7¨7”6’ƱãqÇoýàõC{«éP3£¹ø8!9ñâÇøïž <ÙyŠ}ªé'ýŸö¶ÐZŠZ¡ÖÜÖ‰¶¤6i{L{ßé€ÓÎ-?›ÿ|ôŒö™š³ÊgKϑΜ›9Ÿw~òBÆ…ñ‹‰‡:Wt>º´äÒ®°®ÞË—¯^ñ¹r©Û½ûüU—«g®9];}}½í†ýÖ»ž–_ì~iéµïm½ép³ý–ã­Ž¾}çú]û/Þöº}åŽÿ‹úî.¾{ÿ^Ü=é}ÞýÑ©^?Ìz8ýhýcìã¢' O*žª?­ýÕø×f©½ôì ×`ϳˆg†¸C/ÿ•ù¯OÃÏ©Ï+F´FêG­GÏŒùŒÝz±ôÅðËŒ—Óã…¿)þ¶÷•Ñ«Ÿ~wû½gbÉÄðkÑë™?JÞ¨¾9úÖömçdèäÓwi獵ŠÞ«¾?öý¡ûcôÇ‘éìOøO•Ÿ?w| üòx&mfæß÷„óû2:Y~ pHYs  šœÕiTXtXML:com.adobe.xmp 5 2 1 °ã2Ý@IDATxì üTã÷ÇBe¯"K$K¡²o¡$ÊÙ•­²”%‘})»"þ¶Ò"%K*¢²…"K‹ìD–ç>çç¹îÌw¾³}ïÌÜ{çs^¯ùÎç>÷YÞÏ|gΜ{žsV±"†B$@$@$@$@'°jÄÇÏá“ € bË7 @,P±Å2r$@$@$@$@Tlù    ˆ*¶±XFN‚H€H€H€H€Š-ß$@$@$@$@± @Å6ËÈI P±å{€H€H€H€H ¨ØÆb9     *¶| Ä‚ÛX,#'A$@ÁX¶l™éÞ½»Ùi§Ìk¬aVYe>"Æë†õÃ:b=)$wTlã¾Âœ äA`Μ9¦Y³fú>|¸Y±b…±Öò1X7¬_Ó¦MM½zõ Ö•Bq&°Š|PÙ8Os# È,{P‚Æo:tèÛŬZ&L0ݺu3óæÍ3uëÖ í890¨ *¶U¡ÇkI€H †pÛºI“&fÀ€1œ]yOéÚk¯UÅväÈ‘å ‚³-º"Ävi91 È,z;vÌïb^jmÛ¶5sçÎ õ98¨ Zl«B×’ @ `Ã|3«U«ÃÙ•÷”þþûoS³fM³råÊòÁÙÇ–ÛØ.-'F$@ù@ôn¿È]®âúFa•8Æ| Ð!_r¼ŽH€H€H€H T¨Ø†j98    | P±Í—¯#   *¶¡Z†H€H€H€H _Tló%ÇëH€H€H€H€BE€Šm¨–ƒƒ!   È—Û|Éñ:    P bªåà`H€H€H€H€ò%@Å6_r¼.ö–-[fºwïnvÚi'ƒLLjÎG´`ݰ~XG¬'…H€H Þ¨ØÆ{}9»< Ì™3Ç4kÖLÇ×ô¢ÈÄÄG´ -,Ö¯iÓ¦¦^½zëJ! ˆ/¦ÔïÚrfy€eJÐøñãM‡òl…—…À„ L·nÝ̼yóLݺuÃ6¼P‡)WCµ†ë8R6"TlC´J8à¶u“&MÌ€Â1 Ž"0×^{­*¶#GŽ ¬Í86DÅ'Ž«úßœ¸¾ÿ±àQüÐ!~kÊU‘,z;v¬b+¼<ŒÚ¶mkæÎÆ¡qL$þùÇüúë¯æï¿ÿΪ>+‘@¹ b[n+Îùf$Åg—]vÉX¢G E‹j±ÞÈ£1â .¸ ÂËjÕª™­·ÞÚ{ì±æõ×_ÆDå'Ÿ|b¾ýöÛÀZ„ŸøÚk¯mÆŒX›lˆâD`µ8M†s! üùçŸ_Æ”øÀºb})…%pÞyç™Í6ÛL;ùí·ß̇~hÆgžzê)3tèPsöÙgv!iïµÆ›>}ú˜[o½5$£â0H Þ¨ØÆ{}9; (:cŽ9Æìºë® ý.Y²Äzè¡æÜsÏ5{ï½·ÙqÇÎó A€®APd$@$@i l¸á†j­Eȼ+¯¼2¡.nÕ÷îÝÛì°Ãf»í¶S çÂ… ê ¢Å½÷Þk&Mšdºtéb4h`Úµkg¦L™’PדּÎ2—]v™ ÀÉ'Ÿl<ð@ï|6ý òŒ3Ì~ûígj×®m6ÞxcÓµkW“<žÉ“'›3Ï2Ǽ*ÚÛþûïï)•p«hß¾½yì±ÇT9Ým·ÝÔÍcq~ÄÕ«W7õë××¾×Zk-=^uÕÿ}åöïßß}ôÑJ:â-÷êÕËœ~úéÞ<°9ì ƒÒH4…ÿÁ4=zôðêð€H ùõL!ðß+Æ×7óŠæËH¬–׊µ²ÒNÄò¨uÄò¨uŽ<òH+¾ÏvþüùÞ5Ÿ}ö™­S§Žíܹ³WV³fM½nÔ¨Q^Ù_|akÕªe·Ùf+Š –‹õTë‰Âh?ýôS¯n6ý  IÌb7Úh#ûÍ7ßx×Þ~ûíÚ¦øk™Xp­ÄB¶¿ÿþ»WsÆÜ/¹ä¯L,®Z&>¶^Ù{ï½gEÁµ¢ ze8¿d­ë؉Ҭ¯ìÕûñÇu|èG,¾^y®ù®o®ý°> ”‚-¶òN! ( 6Ø@#'üõ×_fñâÅj…5t«­¶ò°Å[èíyXOøá¯äà¿ëÖßO<Ñ|ðÁæóÏ?wÅÚþõ×_o5j¤eÙö3}útšXÖ¢ÜzíÁJ ßà5×\SËàv«0¬²NܼDùtE)Ÿï¸ãƒ]ØPæ¸5@`†Œ1B‰ôíÛW_ãϺë®kúõëç½æ @EÜû˜ñãÇûOWz,á‡L§NÔeâÀÔÝë•Væ   (*¶€Ê&I (.Ðgœa$p}B³ØÙ,ì5#NÀGvíµ×Ö:+äÂ%!«,»Pz¡x"£”WøëJìÍ„6Ÿ}öYÓµkWUNZ Y–öß­ŸP1éRŒ}ôÑfÅŠªTãYbšÓO?=©&_’ @ Ž-…Hà?òïöß‹!ÓÑÎ;ïì¤G¶"¿ÿþû­l«0:dzÂø¿ýö[ïœ(ª¶nݺçHüM­‡úN_”e ïʾþúkͨ„,KpAÐxôñâ‹/êkÝG ü=zèk÷GÒ§j=ô& Óú†‰‹,dä§¿c®oüÖ”3ú-¶òN!°€VUQd¤%5ˆzpï½÷IYªá¾N:é$ üžnüˆt€¼ô’îÓ«ë.,¾Bï—ýöÛO£.¸2I%j}‘.\芞áò€( }úôI(‡ëäñÇO(ç   (n+Y¶K€B*):õÑ ,>ôÐCªä"£‘ó­MÕ¥X|uÚСCͬY³4ÓÑܹsSfWÛf›m*4?Û1cƨb‹ø¹É‰ÕW_ÝÜ~ûíɧ´J1…H€H€ŠA€ÛbPf$?þøÃ V,Òn:‘[þFòÖ›k®¹FË×YgU:Q·2AÝ ˜«¯¾Z}`a}úé§+«^¡¼FZ†¾SɲeËTýé§ŸLòã ƒ2جF!  b Å¶”Ù äAŠ$ÜÚ´ic&NœX¡(µ|°A|ÛåË—›7Þ¸Bñ‘5ØØK+¬´.«˜øîj]¸#øåã?ö¿Ôc·ÁlóÍ7¯p(ÿý÷͈#L:uê@á®V­ZB_ „Ÿ€ìËÐÏoÜ‘‹’¤6ÁDi+ Ä”>LaÚ´iê>Y!RLí³-£É† 9Tl#·dp9@â…?ÿüÓ´lÙÒÜyçfúôéfΜ9êc‹4»pS@,['›nº©B™„oëÖ[o­›ÆFŽi^{í53þ|së­·šSN9EËaÑýá‡ÜåêJpøá‡¤Í}ûí·MÏž=µ‹/¾ØT技þgW",¨eyñâÅF"&˜îÝ»›Í6ÛÌtëÖÍkŸ$@$K/½T³0ÑÛHMw{÷îúd˜Kÿ À# ÿ×Pxî¹ç,Âma\þÇ&›lb%ŽmÂX%rmÞ¼¹Ö“Ø·zN”Z‹0aîÚFYq/°’ÐAËdcšÖC¸¯¾}ûÚŽ;jØ/Ô_mµÕìõ×_ŸÐGr¸/œ|÷Ýwm³fͼ>p­¤¶óæÍK¸6 /06Jzd”žOÔÏF}}=öX+wƒ¬¸XÙÁƒ[ù‘oå¿.‹ü°Ö×£Fò– ¡e¬¾–;Rö¨£Ž²â6e6lhhW®\éÕM>˜2eŠ•5zQö=xUÎ>ûl+ÊŸ½è¢‹¬$ÌñÊÝÂ.bl/¿ü²·1+éε¿¯¾úÊJ+{ì‘GiÖÑI®ý!Œ#B+¢ívÚÉÊ&a×T…gI¢c%’ŽÅwB‹-ì{ì¡añ™Ž×øžñ_ù=üðÃÚ®•H7\‚ìÁΉÜ´W]u•¶Q«V-{Øa‡YI ¯§1?p;‚öÐCµbv—䙟ðÁÊF£L ŒúbµU%ñ™gž±²ñËJt‹²ÊdÑ¢EV’$x§ñ¡ƒ• xe8W+þ¹ ex/±ðÚ_ýµÂ¹Ê çVüx-qĶ «„q}ÃÆŠŒÂ¶"ÁŽ'êë+™­¸_©¢…Ïø±~Ë-·($I>£?°%ÁŒ¾–¨1úŸMøÜa‡¬$ªÑÏ7(»ÒÐöë×/%`(Ëâ¦ÊóŒ3Tq“;WVîœi}üx‡rÜ´iS+wÔ*´ñÍ7ßèX Þpà vÀ€ó[ÜÇì\ J#Ž‚˜Or‡MûàTé”ä œÂÒí’û@YÇ{J-ó@2g¥MVl×\sÍ„ä?¸;…Vc(½òÑ C"øQK¯SlÅ¥Í;_ÈúØÊªRH€H€H€¢I@L/=86»ŠK•n‚ýüóÏÍÔ©Suf6{ölÝ+Ê›7Q¹oÄ!å]ÔåΫ‹„/ô‡`Ddšäè2 È qðŠDéÔç®`ýõ×÷ö9äÚßÌ™3uƒ.6‹ÅT؇D>ØëJÄÂlÄU@O¹g¤W‡`HÅîßw¡'þýƒ8þÈ7Ø´¼dÉe‡P~V¢ÄE÷³B”ŸbÛbPf$@$@$@! þ­a‘,a «{·ÝvÓˆ.â³jä–»ö+–Céí„X)ý/Ž¡ е7¡,¹>²Cf’ä:²Ÿ!å%¹ö‡úሠ’PFñ}F¬Ö Qpü%ç „f#Éãv =¸B/Ý/ÿý7¼¼"„¨,†P±-eöA$@$@$P°z"ì ¢ÈÈíqUÔäv¿FiU³}ûöÚ/¬•o½õ–A¨D'r;^•AœKX(]owõÅ'Õ½ ô9×þdS°ALrD­—}ˆï®÷ƒ´éÅÇ‘wœÈþ óÁŒ•ë'Õ3ÛTTXF$@$@$Z°úo·Ã*+¨LëÖ­uÌâgkd¿Þw®²S_Ã'"ü! dî¹ç#ÍL²5çQ>nÜ8ÏMÖàW^yEà â|Ð’kûí·ŸºHd Õ(Q4”#büVž1è1£=¸$ ‘ø<{?Äo×àG±Üüó¢bë§Ác   Ð]æŠ+®0矾Ž~¶È” ";ÿõ6¸sC@âjCùêÓ§&œqþ¢°v¦ÄûÞÿýÕ/Ù‘Î\B` Õ•ªz•Ëríþ°>ú¨>à Ñ!Ô-Êz±ÅÅN‡¥îHì0zôh³ÖZk{(fìL+z¯ìBL~Cü·ñUqh\ßÌÉ(3£(׈ËúbÃRõêÕõ‘ËzH0M.¡¾ŒKj“îzøïJEµþÊîÿtU9—k°efå\ß(¯Çž‰]2ây    H b‰eâ I€H 3ìà– í™+² Ä”]bº°œVþx›.vQ¸2Î당a74üÏ8ã Ó£G#);s^–83ÊF /àúÆpQ9%[Hàø¡ïwBœ×áu¬‚ðEØÄÝágžy¦9è ƒ* Úž¼âqf”<×r|Íõ-ÇU/Ÿ9S±-ŸµæL³$Àý,AE´Zœ×ׯØú—°súÐC5?þ¸ÿTÊã83J9á2+ŒÛúâ½;«¯¾z$V "ð¨Q£F•NjȘwª8¼ù6ŽÃK—.­I,ßöŠ}}l‹Mœý‘ „š¾ô£úpÖÚT€1'Jð;õÚk¯5‡~¸Æ7}øá‡ƒï$-^wÝuæ¾ûî ÁH*w#®ºêªŠ'BZ‚äHù› î½÷Þ«‰&pý`n¹å–|šJy ÚF¼ß믿>åyaòXüçJyLŶ”ôÙ7 @è †qTØîä‘GjQdd‚e'k­»žÏÙ:t¨yê©§Ìé§Ÿnúöí«Aü³»2Zµzöìi† fºvíªi\£5úp¶{÷îæÿþïÿòâéžtÒIæ·ß~ËëúLA±EûHOœI =–LýWvžŠmedXN$@#‹-non.9òJ *?yòdµ&BÉ¥O`ÆŒ¦[·n¦}ûöi\·Ûn»à; A‹È(5sæLƒ;ì°ƒ™5kVAF…ä {챇™>}ºA \XŠ!Ÿ|ò‰ú‰cc$²M™2¥ÒþÓÕ… À AƒÔbºÕV[™^½ziÛ®1¤ÌíÒ¥‹nºtãpçàò€LgMš41;ï¼s«fºk]xF½«¯¾Z‹–/_®ó}çwL§NôöÿÁlPž,Ÿ}ö™nE92ªÍ™3G«¬X±ÂôîÝ[³©íºë®Ú¾ÿÚÇ{Ì´jÕÊl±ÅæÄOLÙ6êŸvÚišè?€aGV3ü ñ x=ñÄ&ÕX ûïX|óÍ7:77—sÎ9GÛ¼øâ‹M»ví´ÙLLý}g{LÅ6[R¬G$@!'ðÚk¯<,X`.¸à‚¼""„|Š:<(XP:jÕªei)Õ­X(Dø’‡ßñN;í¤_ê¿þúkÖÓC]|ãGÚÀ1”'sçÎU…ö­·Þ2O>ù¤Z2;î83þ|W%vÏøÑt×]wX©¡\Þ|óÍÏŠço¼aŽ9æõCmݺµY¶l™*¢Èd…Ô­PÒÐ?Ø'K¦ºHŸ‹”³Pâ`D–¯K.¹D›ùóÏ?ͱÇköÚk/µÂãG nõcLX«_xás饗š~ýú´Õ¿ÿ¬®ÕJÿþ¥Š;}b¾pe9äCt,Ó¦MóÆôï%úT·n]UÄñâ¼óÎó|`±hu¤°Eºa'PjO>ùd}ÿbí/^¬i‡Ýœ\=<ãÚ†nhÚ¶m«JöW_}eÞ{ï=} …5ÕXP×8›æŸ]Èû￯ózúé§½1¦cêÚÉùYn¹QH€|äŸÈ÷Їq#Àõͼ¢ag$V!+_ÒV¬Fv„ V¬ˆVobï¾û®mܸ±]²d‰•/|{Ûm·YÙ\dEéñêd:…ÆŠUÎŽ3ÆJºR+áÓ¬¸wX±ê¥hûÖ[oµb½´bá³¢\k?bÊÔtÉϱ¾òãÉÊ Nß~ûm`súþûï-Æ'V=¯M7lØÐþóÏ?^™l„´b=Ô×:t°—]v™gª+þ­V+¯‰'ê{mKh+ʳÅÜ UÄ2ÄÊF*+ñ¡u\o¾ù¦žÃŸGyÄÖ®][ßcé®õ.ø÷@~ØæÍ›ë+QµÝ|Ы&e+>¸ÞkÿÁìÙ³µþ?ü Å¢„ÛÎ;{UDyÔó¢CµM6ÙD£d¸Ä; ·'o¼±Ê/³öÚk›O?ýT-Þp¿p‚;°žî·ß~®¨hÏp³pYqçw*cÚ Aƒ¼ÆEÅ6/l¼ˆH€H p{þ…øâ†B‰/o„&òG„€’ÿÌ#p묡èCÑEè­ª BÔ9+®*Cb¥tEêç‹!É’©.Úk®¹F] à¢w•SO=U›ÁúÃwwÔ¨Q·ËáŸÞ>ø@Xø©ûßgp€KÊÓ]›M²ª„ëÂÿ@²ˆ‘Ó€n~vøa˜¯/¸¿ä>“_ûY¹sþ±âGA:¦îš\Ÿ©ØæJŒõI€H€JFÖ¹U¬Êçšk®©ãÀf!¿à<øšöñÇ«ï$,m°RµlÙRýbý×àÖ£jÕª©Å סl¸q e¾V$×FŸáï +7üSñ£Ša*¥3ß¹c  ÁZî~¨©|¦ÓÕ…‚‡Ýþظ…(q5qMª5Ö>©xÀ"Û¬Y3õ·E»?ÿü³ÁÆ'gù‡¯)¢à5ü¯+» r)ïU¼ŸaI‡O±q{05r/+}†Ò‰’NÜ]÷:ù ¼¿>þïÒI&¦é®Mw®ê?«ÒµÎs$@$@$ 6ÚH7£@ÑÁnëo¼Q• X¨œÀÚë* Ô‡,E°°A° ·š“Ø(â …JÌ_|¡É-zè!óòË/{/zÜÆ†k6Ȥڃzå à ¥Ñ!àš0vìØÀ¦ #ÙgŸ}VCñ½òo丣$Kºº°ªBÑs›™ ˜"1kˆõ;á„TIweˆ8€(øAT§Nu‡@è<¼/N9åý uºkµƒ€þ8Ë.ÞÛ™ŠæÑG­›ä>üðCƒ¹àÇÜ1\;éÚÀÆL(§PÞ¡°b“89qm¸± >\6ðCe°Œ§“LLÓ]›ö\Ž>¹¬N±' ÿ0±Ÿc9Oë›yõÃÎH,ƒ¶zõêV¾¸uó’øAê&±Ðêän¿ývÝP†Me¢dY 8o{ôè‘yâ¾ò…nÛ´icE²â“hÅ*gï¿ÿ~¯†(¹V%í¼ðÀ˜¾üòK¯NX ½¾¯¾úªk¡•ÈV”Èœ0¸Ícذ痋.ºH7ya-°îXsQ²´Šó ÒÕŦC¼/0>ñ“¶ºÊŠO«•¨Ú–${е”P`Vvþ[±ìj9þˆÅ_ËÄMBßb µbÕ÷Χ»Ö«$©6a£•I„aÅšé^&Ã:_AÜÖ—8H1Öuù1¡¾Ðˆ‹ŠÛÎUXèaAD[°§“tua¹„›ÉÖ[o­þÀˆ¥Š÷B]A² nð±†ÕÓ/¨+J·º­ÀB™,é®M®[•×kˆlÞ“ø>Ã&2¬ÉöÛoŸ•µÖ?6X¶F 1ŒS‰,¸ƒM››o¾yÖ¾Ö™˜¦ê3]Ûttx®, ãC¿,Á†dÒ\ßÌ AF™E¹F1×±n±#ÿÎ;ïôb—F™Ç~TlÿFa‘ óC¿ÈScwB€ë›ùm@F™E¹F±×«5þ·Ø¼å|3£Ìc/n ïÚpd$@$@$y«…¨ H—‹ðZˆ¡J!B b[(²!j©á'VjO¦ð¥#û' ž¢RH¦.#Y°4¥+ÒÙRH ¨Ø‚jˆÚDÜEÙÕ¨›,J=,8•#7ÂŽPH€H€ÊÀ‰'ž¨¡»à’€¸·ˆ K! P± ’fÈÚ®`™¾ð uGc©‡‡œHmÙ³gO/…a)Ç¿/ljÀNO OSʡĢoÄ–DìPÄÿDV0õXL“(KØQžK¶¥²„”㤩oOx‡v0³fÍʱV'Ê póXål"¿ˆ¯¼òJ#qËÐSêI!ÅÂæÜzë­ªàs<èY‹$†Ÿæ•Gß3K2‚ICñ†{c…vñ?÷‚<Çwœ¦¡DF ‰g¨þta›×7óŠ” #„ñ’Øži 1Cß¾}5l•¿"ò#m/BG!ì˜ÄCÍØ–ÿúR‡i}ñyŒ¬Xþî¹ç– ûŽ \‚Þ²ntȇ®J–ÜÝÞ §OŸn%õ¡•<èöž{î±âÐod"1ÿ4è2ÎKnl{øá‡kiùà÷®ÇÁ™gžih%VŸ=餓48º« ± µ}C— >V|¨Ü©„gÉ„bå{BY!_Ì™3GûCPo™–ÿ]ï! ¿}ôÑGºÇyJnd|Å—;· KP›ë›z90Âg¤Äæ´2ŸN$þg¥ŸeK–,ÑÏB¾ÿꫯÒ5ªsa[_$9lo¶sçÎVâdžŠ=tEÿð8 nó,]ºTƒ1»ùÁª6nÜ8sÅWQJÕJ‰æò¶5|°9çœs4m\àÆpöÙg«”»Ïo¼ñ†™0a‚úíJv½•„òþýûkê>X/ºté¢VŒ^½zyù¸QÇ ‚ZÃ϶XÉ·Á¸´ÝïÏ…€í­Zµª0G7Î0=â k(Ø!P6Ö k™,'N4’F­¥’5Ç´mÛÖl¹å–y¥ú/XüáV€¸e(™ÜHÀïÉ0£ð%Ó9õÔSÕådÑ¢EÉÃãk Ü©Á|Ö¥“FUzw w%$CU(ö0¤›CØÏ!˜?öƒà³¦yóæfêÔ©a2ÇfÑÓÅ9âlˆï¨Z%E õª?ÿüóZëÂc=fEqÑsH)ïQ+>‘^]ÀêŠt’H«çD2±h]Q^-,÷Þ{OÓõ%§¬<ï¼ó´î[o½å.×gXHÑÒ^C`‘‘\ñjQD¿îkmªô—86yñÅ5•á-·ÜbEyµò£ÁÖ®]Û[CŒW~¸Ø5jXQF­(•šnq·ÝvÓù&[Þ³™Öéa݇µë%>q¶{÷îÞå°ÐŠ"k;vì¨ýàòãÈJw¯^˜¸¾a⃱„™Þû¢Y—¦SòÍÛm¶ÙÆ>üðÃF¼w‘Jwøðáš.Ç’ÃÞ;÷3þ—0OqÙ²·Ýv›•X'¿ýö›ÞÕBÛø¼K'ø_¤Å6¡ìω»˜• `öòË/÷Ræf5k’€|~B< àÃÚþüÓN±… _$ —º$$+?'œp‚¶…É [ñϲ_|ñ…+²â¥õ\njw·—0 ïâŠôyæÌ™Z·†bò‰CiG~pŒ܂ė^*Áù0 nÕIb]I(Ÿ2eŠþ¸I( é‹°¯o°…™~´ÉÝ+±P•¤7µøQ=`Àû±Þºuk+›íu×]§ ®s;À5¹¢ïånݺÙã?Þâóεéš={¶•;SV¢”ÏTlSbÉ»PR¸Z¹ÛdÛ´i© yO˜J`5ù£ÄÜãZü]+ÌNü˜ÊjÕªeöÝw_#þ¶æÉ'Ÿ4¢ «›nß§äš?\ï”øìj_bÑóÊÜÆðÉ'Ÿ¸—úܤI}†«D¡9®qk¾iÓ¦F”4sàªKnéŸrÊ)…î>°öå VSRbó›(®¦zõêêBöX;nãÁíùÍq;®¸Å'Ô„q\tÑEFüŽÊÜ‹~ýú™½÷ÞÛ¼þúëï ±|¹SúŒìAˆló{ì±GÂ9¾ bÀæS¸P9Áÿò&›lâ^ê3Ü ؤ ¼§¥1½ñù7)QfXy â©âÿ)•àZ¸äPŠK`£6R—·k®¹Æ ¹Ã<`:uêTÜA°·È md—.ýÀå6šú<®ºjÅ%–ÛÕ ÃöíÚµSZ|I`w*vª¦’äë$Ƀ:H-;¸ã’ŸhþâÀ1/|(ÂÏyÊ1?±±à¹-x…j~€r»ÕÈ­Wý"ÆÚâÇBÆ ºWqû0wÜq‡‘Û§F,»ú…°çž{&ø‹ëˆÆ‘œ6mZ…g\AŸÅãW PŽèð·Åy „”^'ø\CJ4à;âÒK/UƒÂVŸ?2¢±v¥%-¶¥^õk6r‰ß—†×J×ÍUW]¥–Œûï¿ßÈí8¯*2Ä@&À*ˆ‰#FŒ0uêÔI¨ŠpZ…ãX±qÃ…×òŸ òxòäÉfôèÑFnGzÍÊ-IƒG”DnµêF@XÄ›Vüá0ñyÖÌ>µBó²£ üaáŸjiŒ2ñ×ÅSZ¥êæ›oÖ:âŸìÕ…ÅÊ/,Â(XX¾Ï ~ôùï"¹òtÏîG?þG*³Ø¦»žçŠC?Ìq‡IÜM >‹VÍYä‹3ö5ÍyQ›Ç›’,•l"Àúk²À8AŒÆI“&éËL–Uäþ†¢Šh ~AÒ´ …×/PÀ o¼±¿8c¿%QŠ%(µtP‚F`M‡õT|‚5ºƒl¾S+4"%À?` à*.4鬺>‡)V§VöýÁ{.#øqãÞCørA¬É-ZhTWý:·(áxÀ…B…" ¾—ú#î÷ß×ä*Pv2}Na,þ:øÁ×øÜÂç—øþ¸éø3#¢ˆÿX äÚKwÞÕãsÕÀPóì³Ïªr+bU¹­Z‹¼:Öä“C¢TêÆìôuâ6a‡½_\ô¹í£›Â“ñlÝf+lr°y ñý‚ñØÅ*ú-¢0Àñÿ…^°r«Ü"¦­díñW·r«\Ç&!]Ê«úB¬³ªŠüÃWµ‰À¯Ç®mñ;SnˆÅ+¾gºÙcETˆ¸h ¬¢YÈ—¶òÇæ=ùòÍyLØü‡÷6¤‰K‚nC|cÿîoìLk—Ž cq”á}F ãú†SØáóM2Üéûð¾ÄûÔmvtÑ[ä΂¢íÝ»·¾7±áÒÿ¾”P€ÛºfÍšÑb$Ý«ÅfZˆ¤"÷ÞÏî}gDS€ : úôŸÃ±?jˆV áŒ3ªòöÛo[ÙK`Å=Á"r…’ D÷Ý<¾N – Ýù/¾²^yeŠ->È=ôP/”|`G°S¦.\¨í¤RlqâÝwßÕ/ÿ‡<¾°c9Y$^®~‰8e9ù|®¯åV¢*wr{ÊûRʵ ý°~è#º¢\à¹2 ®žBØ"(¦AˆXÁ­X±¾Ñn©Úëú–ŠGª~£ÂBª*øÑ‡ÿ›tÿWUí#l×Ge}+ã&nXÑ,­"ÕwLe×±¼<0¥®ü‡ÇU°QJ¬¯zk-“Ÿ,Àw»ìq«.ÜêÉ ·w¦6°) ·ñP›p =YP©Wq«{È!ɧózû¸ÕŽ[õbÍÌ« ÿE˜§üûû‹x#\ßÌ‹IF™E¹F\ÖÑà.…ï$¢P±ñûQ°;a®$€~(fúôÓOë5øõ"U‚\ãGqDMiqùÐ HÌâúf^P2ÊÌ(Ê5â´¾0ÆuÔQú]w÷Ýwq¡‹òÒpìàæ± †µ ìv›‰Â2ÆÁƒë榪(µþ b˜WJmX8q$@$@™ F9Âb# d˜ÓM€™¯b8 bçÕ•¹!-Üb«Ô+-¢5 À¾"Ì>ûì“ï弎H€H fà:‡pˆ×_½‘ ¯fذat'‹Ùç2º"äB‹uKJqU do‰ %qºMW(FQn—ë›yõÈ(3£(׈óúJºwÓ¥K#iŽÍC=TðxéQ~Äuì´ØÆuec6¯3fhÜJÄš,¤R3lœ ”$±AVE$™ÁcÊ”)e5NÖ*¶|D‚¢H<]ƒ,g  ¨ŒÀj«­f$Ö·¦G¢ì5ADÈ…^¨~­ŽOtEˆçºF~VÈæóú믛½öÚ«ès‰ómº¢Ã a‡\ßÌ‹BF™E¹F9­¯Äô6]»v5Ȧ‰Ð`Pt%†ºî÷À@JüÐb¿5üŒ$3i×®](6¼E&'@eF€1¨ËlÁ3LW21ÉgöÜsOõ½ElvXo?øà}žáržŽ *¶\´8¿ 9¡mÛ¶F2ËÄyªœ @§É^$u®ùôÓO5ãÆÍ&›lb$ã¡¶°bÅ sÁhvÈC‰™5kVBë7Þx£¶±ÖZk™Î;«¦¿ÔHJ]#éZuãQ«V­ÔÒç¯óÈ#¨ß¦¤æÕ¶7Õ‰¤½6’ ËÜtÓM×B¡’4åwŸ(¥'0yòdÏ£AØHI'o$ExéÇJ€Šm 8ÙXU Üpà fôèÑfÀ€UmŠ×“ Ä€ÀV[me~øaÍ‚xúé§kÌÒ[n¹Åœzê©^†Dc“Od>lݺµÞõA’'’6Wý.¡(·lÙR•NwÏhsÍ5×4ï¿ÿ¾™?¾Ùxã î9yðÁMŸ>}ÌqÇgæÎkN9åÓ¿ƒh-”C™E¬n„4D}dÆzóÍ7]|.^½z™wÞyGÝüCX¹r¥9þøãýE<ŽúØÆ`£>Ü:„ÏDr€’·*LÊÉÿ¬*œ¢z-×7óÊ…‘¬¶»ï¾»Þ>vŸ˜ ,nHF3uêT½Ûƒ2XIwÞygµÀ^rÉ%(Ò2DU¢Y³fM%VZ¤ã†Àz‡×_|±*µ°ÊΛ7Ï4oÞ\Ï7iÒÄzè¡æºë®Ó×øƒ Jˆ™ºlÙ2-C²Ä ¿êª«ô5Òš¯¿þú¦P Bò'Œë[H4XG„ÃXôñ=ãü#FT°Î»ó|ŽZl£·f±ñ“O>©–7)D?  @*½{÷ö~»óü±|ðÁªàBÉmذ¡ùñÇMõêÕõÜêׯoúõëg¾üòK3}út àÿË/¿¸fÔ•V]XskÕªevÙeµò¡|2áqÈ!‡xõq€×P†¿ûî;¯¼Y³fÞqƒ t^JBkåÉà>‚¼ø®ÁXmáö†u¤ÄƒÀjñ˜g5pà?çœsÌ„ ˜7j‹Çñ’@ˆàö?,ÈJXY8@ø×ÂÚ:|øp9,vpoðËÂ… Í‹/¾¨–]㳩oß¾æ˜cŽQy£6ÒH-ðßu‚È-p_€U–~øÁ‚¨x@fÏžmžþy3tèPÝLJô Ðbý5ŒÜ þøãµ†üôÓOúÁâ¿­†É¬¾úê › Â0&Ž!°¼a})Ñ"à6`á䃦M›ê沚ŋëÄ`ƒŸþÈ‘#õ5”R|Þ`“|h{ôèað9äo¡ °mÕUW5ðë…å¶Zµj¨ž={š»îºË øÿÆoèF±N8A¯AE{©^{ñ vÜqGõ“†uŸJm(–$˜AÈ?"…ŠJ@¾Xì½÷Þ[Ô>séL¢2XñÃËåÖ¹måË,"£-Ý0åÛ¥t'õ,Ö4‹ñø5J¨%¬D"°¢ˆÚºuëZñ¡µbiµâ> õÄ]ÁН¬•5V,¬öŠ+®°ø?K+~—Zgï½÷¶l°­S§Ž¾G$ò‚• `^?¢[¹Ë¤m ž$°'Ÿ|²w­3dÈ£¸?X‰Ö`ǯã‘î¡û¼ Óúz€y@àæ1ù§ž¬#ÎßÍ\øžsï¡{÷î¶›H(ñ"€ëØï,yñš]p³‰êæ¢ï¿ÿ^-³†ìSÉ‚(õêÕK°Äº:°Ú­»îºº±® h#• ¸?ütq~5ÖHU%ôeQ]ßЃåCA€Šm(–!Þƒ€ïÛ˜1c4 NfŠÎØl€ÐA:tˆÂ9Æ,Àg²cÇŽ„Ī—Åå[…ŠO¼×žëïõ-÷ÙÑǶÜßž?baY‰ÂŒƒë[®l5芎uˆÔ(¦M›æWÒSR©õhð€H€H€H ”¨Ø–’~Äú†eö´ÓN3÷Ýw_ÄFÎá¦" 9î ,7_ýuªÓ,#  È b¹%+Í€¿ýö[³Ë.»höÛo¿½4ƒ`¯xâ‰'LÍš5 iPH€H€H èc‡U,®»î:OÛ³gÏ"ôÆ.ŠA eË–fÆŒf½õÖ3Ë—/7ÕªU+F·ì#ÖXc ³bÅ ¾'"°V¹i¦ñƒvåÊ•¹^Êú$ ´ØFb™J?È~ýú*µ¥_‡ F€¸Ãï½÷ž6‡Ä/¼ðBPM³@b¤Â¦ÄÀ¬Y³4ÅtüfÆ‘Àÿ䥨~ôÑG¦ÿþ¦}ûöæŠ+®P?=øêá×~áùpóy衇 Ü (åEàÑG5«®ú¿ÿŸþÙÜpà 倳MK Y³fæå—_N[‡'£I`üøñ?\¢,ÔAþ[½¨ëX…ÐArvEX´h‘iÕª•éÚµ«Zð¶Ùf›ÿó(rÆŽk:wîlð+~çwŽÜø9àü4mÚÔ|üñÇÞÅÕ«W7Ÿ|ò‰iРWƃò%°lÙ2µê=òÈ#¦C‡å "f3Ÿ0a‚騱£Yºt©©[·n$gG$’ËVé  ¡ƒä¬Ø^rÉ%fß}÷å‡]¥Ë½/¾ø¢þPY°`©U«Vô&ÀçD íŽ;î¨>”îB(¶}ûö5ƒ rE|.ssæÌ1Í›77W^y¥*CØáÕW_]]à^‚ÿû¨ZjÝ2Pq$âõ¤’³b/”œ ”N:™‰'Xiÿúë/S£F ƒ]ðØ)ýæ›ošúõë—ΘH€H ¨ØÆb9 È@›6mÌàÁƒ ž)$@$@$u9EE¸ð £>_ŽŸHÀG·)á‚B! ° ö ÇørRláA‰/ÿ.ùøÎ’3ó bë§Ác 0 æÕ©úØ‚ÒArRl«>l¶fE)/TlËk½9[ + t*¶a]aŽ‹Š@`µÕVÓ dEèŠ] @Á 䤨ò6@Á׃@Q Ðb[TÜìŒH  ¨ƒT^]š“b‹î”øØzë­ã;9Î,%*¶)±°H „¨ƒ„pQRP:HNŠm€ãgS!$ðÁ„pTR! P±-$]¶M$@$- t*¶Ùg=ˆ!*¶1\TN‰H€ʘ@NŠ-cÈ•ñ;…S%n‹å²rR$KÔAb¹¬O*'Å–ŽÛóUƒAÅ Õ¤8˜´h±M‹‡'I€BD€:Hˆ£C JÉI±-À<ØdˆC.DSâP2 b›O“ …@P:Û¢,;!p bÎuá¨H€H€ò#“bËÛùAæU$VTlú2 @2ê ÉDø:œ[ÆK…0>eAÅ‹‘øÏ„Šmüט3$¸ —•L= tœÛÔCai\C..<ÊaŒŠP«Ì9’ @ø ¥ƒP± ÿZs„$P0´Ø -& (œ[Æ+Á ±K( *¶„˦I€%@$Pœ±m,'Å–ŽÛ±}èÄ‚Š!oJñšÛx­'gCq&@$ΫkLP:HNŠm¼‘rvAÅ#Éè bµâHI€H ΂ÒA¨ØÆù]¹‘@Ü<–O“ DŠ@NŠ-oDjm9XÈH€ÛŒˆXH $¨ƒ(M«@IDAT„d!B>Œœ[Æ ùjVqxAÅ«â0xy P±-"lvE$P%ÔAª„/ô¥ƒä¤Ø†ž X%AÅ«Ò xqQ P±-*nvF$@$P  t*¶•f1 ”*¶å°Êœ# ”œ[Æ+Ÿ7gZ¸y¬<Ö™³$8 ‡U,ürRl£â¸½páB³Ê*«èã•W^II±_¿~zþ‹/¾Hy¾ ƒŠ!WŽì¢:gZl£ºr7 ”¨è å·2ÁÌ8($'Å6˜¡·•Þ½{›•+W·ÓˆöT ¹ˆN¿,‡MŶ,—“& ÐJ‰µbÛ¤Ióᇚ!C†„n9 *¶aXŽH€H (9)¶Q» pÈ!‡˜ý÷ßß\}õÕfþüùY1{â‰'L§NLÆ Íhî»ï¾„ë.ºè"ƒv­µ^ùÝw߭׌;Ö+ûóÏ?õúáÇ{e< ° b¶áxH€*#5¤²y°¼°rRl£CîöÛoW‚§Ÿ~zF’ýû÷7G}´Y±b…éÒ¥‹>÷êÕËø¯­Q£†yöÙgÍܹs½ö~øa3nÜ83f̯læÌ™æ…^0uëÖõÊÂ~T ¹°Ï“ãûÛÿXðˆH Ü¢¨ƒ„›h¸F”’“b.Ù¦Q£F ëĉÍ#¢#¼ù曦Aƒ‘ Pl±ø³fÍŠœBÂäø¢lÐb[6K͉’@ä J‘ †¨ä>›5kfŽ9æóöÛoGž_U&£ÝÚk¯Ö´*íòÚœ\âCoÜ»îºKݰÉËÉ:ë¬cÆoºvíª›Ã\96ŠÝtÓM¢À" ×ø×:Ùh£4ú6¢uìØÑGæ9¨r‘™0ª~åþÿ"! °(´‚Mà;7}X'?ýôSóØciüz$aòç{y tœÛ@F^„Fà/›ÎW¿À6Yš7onÞ}÷]Mû`ÁÍ>¶ýöÛ'WÓ×íÛ·OÙüt£*AÅ‹êüËqÜ´Ø–ãªsÎ$@©pÀæÈ#¬p wl÷ÜsOua¤b[O`Aé 9¹"6ú7„MbP|‘N·2¥6ÄÃçÐH '…G‹mNÈX™H Ì´lÙRÝ.\˜0óo¿ýÖôîÝÛì°Ãºïqð“ëœrÊ)æÒK/Õý7p…lܸ±eF´_~ùE3›ÂR‰}>¸ œ,ï½÷žê#¸#¼ñÆ›#Ž8¸𣨋$R;wÖHLþk™ ŠúàÁƒ½âlÆ‹Ê0ü]vÙeê¶ …þòË/¯Ð¾×hrRlC.„+È!‘@ ¬ºêª‘ØPÅiòr ˆ(•2wî\½C»Ç{xqWwçw6HÞ„r$dzòÉ'õJ«$szâ‰'Ì>ûì£Ê,Bƒ>øàƒª¬"3)2¢¢$‚«Î9yùå—M«V­Ìüùó ”⣎:ÊLŸ>]éwÞyG«ao\$^zé%w™>c¸ƒ Év¼p¿@ˆÓ+¯¼ÒÀðò²²FFä–}Ö"“ʺ.+F€øGoÐq• T¯^Ý®X±¢Êí° ($Bé ’˜É¢í«¯¾Úʦpï!Q’ì€ì[lae¹[ozâ²`寥Ó+ûì³Ï¬„ µbAõÊ$ë©¶=|øp¯ìüóÏײÝvÛÍJ¤-ÿæ›o´½ãŽ;N_‹‚iå®±mذ¡•ÍîÞµèC"úh+›½¬X…µ<ÛñŠ?±ŽM,½^{ýÉÊl-%Ý+ú ($'MµPoª á°½üp}óãõ«ðá'II¢> ŽŸH æ õå[´_Ùãÿþïÿ<ºPBQOnõ{eî@,›VÂ(Z±Àj[±ªZ‰˜äªX±Òêõ~e'¡<¶hÑBë½ñÆZçôÓO÷®s²É]ωk‰ß¯­U«–}-nv­µÖ²Ç¼¾Îe¼mÛ¶µuëÖµ¿ßu§ÏbµÕ> ©Øµ¾±Ü<&p($@Yà²,A± @¬ \tÑEêWê&)w²t39|_á0{öl|ä2d-]ºÔœx≮º>cù_ý¥¾¶.ÂÜ‘ÉIÍš5õ1ñý‚=>Hq~´­[·öWÑc$zôÑG ÆlnC¨W^yE£:Á51gE±Õú¹ŒQ¶Ýv[uCðwŒ½GQ‘œÛBÅ‹ ,Ž“âH€ŠmW•s"ø(´"ÖRÝp•L›¶zõê¥!AÅk–-[¦U·^îv%T‡-b1õÊýÇ^¡`Ceâúpqòýõ 8Cœ²ŒHظöôÓO«b;zôh±Øú×V6ãÅ3Ì1Yœ2ž\Æ×9)¶…Ž!F@å4¦ bÈ•³8Ì•ŠmV‘s ø(•‚¨gEu²ì qîý‚ÍWP""8;Â×_­Ñ F YSä2^ÙÐf~þùgÍ ê®Çó¨Q£ü/ r”RpÅVvÓ™]vÙEã¯áD©ä»ï¾Ó_[þ7üHð‹«Ôò /è-øÅ@·&Nœè ¿q‹€BA Å6h¢lH N ÄB–,Y¢Ïp-èß¿¿?j¿~ý4;üXÏ:ë,3iÒ$-Kçf døk,Bl=÷ÜsæÚk¯5°˜Î›7Oýfa(Dl\¿ ö>pøC)öûÄæ2^‰a`ì@ßðÛ…AýÃIØö–á…,`†O‹¯‡î¤;çœs¬8UW¬P¤’K.¹$a!ºÅnÃ|æôå¶ŽMbÎiÓ¯¾úª•8rVÕõ5v:ÊÊŠMÐ]³=°Øµ+˜$A$@¡&P¨ïkúJ*ƒ˜]sÍ5­Äuµ~ø¡VË©8p †èÂ÷3ˆL ~À ðùŠH~3fLÂw¾;'VX+qcÝK+–S‹ð_®}<רQÃÞsÏ=^ÿøkÝo¼Ñ_¬ÇÙŽ•¡“¬¿þú^¿²ÉÍÊÆ4}]ȨgÁ*¸N`e%°"æP]ÛÀš¿4`!-•à×ĨS«§Ä™+Õ0Rö ‹-~m!˜r§N*ÔAf(J†sø­·ÞZá|PøÅÙ¤I“ šc;!€¬9=ôýŽÈ9L 2$RhL¸Œd 6Ÿ9·… ûýꫯ4s™„áRK¬(·y7Ÿíx‘¹lÆŒfÝu×U·¿¿mÞg¸0(¤ ®HÉöÀèTö ælÒÉ!¬F²ÀôÔmNŠîšk®Q‚c=Ö`w Ò»ÝqÇ®Š÷Œ€oKíÚµÕíAâ¼y©íp{@‚kÝ.]ºx׋Yo'xÈA¦ôu¨;uêTU@a¢‡ã8Æ´å–[ ˆl¾üòKso¢›o¾YëÃéðn¹å– ;)ýÁY»18‰Cé…<ûì³Ú²š@¾í¶Ûü—éñwÞé­ÂÉ M›6ÍPƒ§ãH€®q\UΉH  s ƒ˜Xe ¢Ôb ¶ÿþû«â\¥me;^±P‰kZ¬J-Æ”RPÅ`Ü"@ëwá"à·E4YƒmÖ¬Y^1RÑ!Vâ´Á¿ ßøê:E•Çoë þ.ˆÛ†pHs‡úøÕ!Y:Œ¡×v‘oÙý¢ÂuèÓI6éëPwñâÅê4ýª«®2’D­]ðíСƒkN­Û|°ýûï¿kJ<ä`>ûì³ õÊÊñSO=e#;+ëׯ¯Uá'ƒc(ø°€Ãž,P´‘~Ïí¨L>Ï×$L€›Ç’‰ð5 @d äâÂß‘\eذaê—´oNdÇ`ŸœCÊ:±Nºjêû'`í 7Üà•‰I^}Z$o²–!í²uˆÂj‘]Éó™Q‹RùØÂ÷E¬­^;Ù¤¯CeQšuNrÛ>¡ÏÓN;MËÅ’«mŠY]_ûÇÈV"¿€¼4¦É>¶®}¤óƒ¤ò±•°'Ú¶XoµþH>k-§v¯,—°¦”Ù@iå.DùMœ3&ˆ|tHM°Ì”’“Ŷ1ä`‚‡ÅÓ %oµÕVÙ= Ó§OWë%B[Àën çž{®Õ8Á-ÿ9sæh,8˜ê`gbÇŽ5¼†äkvÅú,ùžú„ÙâÆK1¬À't’–»?ð“AŒ8„äÈWœÅWœÐ½&Üñ1Çã•årT ¹\údÝÒ +Bé×€# ÈL :HæQ±FP‚ÒArRlƒ|.íà–zrØ (ž.ÛǧŸ~ªÍÁýÀ/¸m/ÖbuGð—Wvì/W–¾×Á±Ù/byö¿T߸±!h22Ìœ9ÓH ÜœßqÂÅ9¾€ß üQiÄ [¸EøÃ|¸sÙ<C.›¾X'<¨Ø†g-8 (WAé ¡Rløá‡ ëéür+œø·~¨ ü[’ß“K9—Mú:×C¦±!îM8–¿ñÆê+²¸,¸&ªô «-6˜A¹_°`æ±Î×Z[¥ðâH béåãàI€H€|rRl/¼ðBߥU;ô'J@KPP¥3—–‘þ «¨_°IKülÕ…À_^Ù±Ûl…ˆÉ’œ¾.ù|e¯±±Lü^Íý÷߯á@î½÷^sæ™gzîRqî°Ú:7WV•vymyàæ±òZoΖ¢J H$ª 8îÌrRlÅq;s‹YÔ€é\\uÄpÍGvÝuWÍ’H ~9r¤Æ}Eü·l$×ôuÙ´ ÷D…ð+›H‡‡Ì$ñϦ™Jë æ,Æí[Dp¹£+½(͉dW‹4Uy*Fh±Ñbr*$cAé 1Fé©¥ƒä¤ØE )vq›±l±ù ñX±AÌ…áÊ¥(É’mà -,¤Ø¸K-ÒÂAÉCl[Ȧ›nªÏ#FŒÐ¸¸úÂ÷'×ôu¾K+=Dà{„ù4hÎW¢É(¦n¸‹E7“@ñ@NhlDƒRŒ„ N 4ÃÍÉPâŠóz*†\^ó¢’ b[2ôì˜H€Hà_Aé %Ql‘cÖÅ!C†˜V­ZiÂlôÊwRH€ á¿T™ÅÆ)dè‚"K¦‹_‹„’®ÎHØ/Mªê„Ä Ýºu3_|±ÆÅ†4´!éë ;ä*˜ç¡‡jð+ 8-@F‚Dp@b‡l-ʘ“„L3íÛ·7?þø£7çS _ŒB¹ b›+1Ö' +œRê:Ônã믿V¿Ú B<@áƒÅJ-ÈT>¬H~€0\.qDª… 2}ÚGr $@º=×/,¹Øð…¹§gªq!<þ°f°ÞÖ«WOhøòVE0ŽªºGT¥^[G‡˜ÉaéJ3öJ$@© ­ƒ¤î…¥¥"”’“b[ªÉ²ßÊ ÜàÒѲeËÊ+fqFV˜ ÂmdÑ«„„@ïÞ½õnž)$@$@$P Aé «•bðì³êž{î9óÒK/¤ñEêàª*µ•Úª¯K[`T„(®ÇL$@ñ"”RÛx-Eifƒ˜¿¯¼òŠÆÈ½ï¾ûJ3ö ô±Å2r$@$@B 'Å–1äÂóžA aÄÈ5j”©_¿~xÆ‘DŽÛÈ-LeI€:HY.{ΓÎI±e ¹œùFê‚ bÈEjÒ¬¡bË7 @P‰Â*å?Æ tœÛü‡Ë+£@ ßpkQ˜ÇX9*¶•³á  âJ¡b[œõb/$ZÜ<Ú¥áÀH€H€r$“bËÛ9ÒeuˆZl#°H" €&;"ÈD 'Å6Èä ™ÆóÅ'T¢Œâœ=V…ÛªÐãµ$@Å"@¤X¤KÓOP:HNŠmi¦Ê^‹E ¨rÅ/û †Û`8²  ü ¥ƒP±Í x% Ä‚ÛX,#'A$@$ rRlCŽïˆn‹ßšrF$GÔA⸪ÁÏ)'Å–›Ç‚_€0µT ¹0͉cÉL€ÛÌŒXƒH ô¨ƒ”~ 9‚ tœÛBNˆm—ž@P1äJ?Ž Tls¡Åº$@$@… ”BŶ«Ã6I B¨ØFh±8T  ´rRly -Kž$H bÉeã I ìP)»%ÏkÂ9)¶Œ!—ãÈ\T ¹ÈL˜UTlùF ˆê QX¥üÇ”’“b›ÿpyeC. såÿ#À¨ÿ±à @i¥ƒP±-Íú±W ZlC³ @ 䤨2†\iór!*¶!\‰H ê ° œ[:n§ £¢ bÈÅIYL…ŠmY,3'I‘'@$òK˜vAé 9)¶iGÄ“‘'T ¹Èƒ(³ P±-³çtI€H „‚ÒA¨Ø†pq9$(&n+&möE$@$PH9)¶¼ PÈ¥(mÛÿüó©V­ZiÁÞKB€Û’`g§$@9 ’#°URÉI±e ¹½KrêW_}eÚµk—ãU¬Tlã°Šœ ÄŸuø®q:È*V$¾¨83 L>ÿüsÓ¦Mƒg D™@N[7Ñ9sæ¸C>“ Dœ-¶_@ŸÊŒu2[ð§›—b{ä‘G𫝾ÚÌœ9Óüý÷ß9vÉê¥&#=°ÐÝu×]¥û/1n+ñ°{ œPÉ Wè*ZÉK±}ýõ×͇~hN:é$Ó¨Q£h³gÏ6«¬²Š÷hÑ¢Ïû„Ϫ«®jªW¯nZ·nm–,YâË‘-¶å¸êœ3 D—uhëX…ÖAècÝÿí¢Ž»Q7Ø`Ó³gÏ¢öËÎ Oà—_~1m´‘Á3…ü–-[fÎ;ï<3wî\3oÞ<óçŸúOó8ðõY³ff»í¶3Æ 3uëÖÀ¨9DÈŸ@^Ûü»ã•Q%…Š]»v5?ÿüsT§Áq§ @‹m (,2ðc„B„ÇðáÃÍŠ+Ô…ÉÝFäóÿ\ºÂÎë†õCðûzõêéºòíMq&@‹mœW7à¹ýþûïæœsÎ1ãÇ7£G6Én&wÇæŠD`àÀ~¶x¦ÀR %ÿë:t ”˜˜0a‚éÖ­›Zßi¹É¢rP±­€„™<õÔSæ´ÓN3ýû÷7gŸ}v¦êáX‡B‚ë[(²l7 芆U(³1l½õÖfÆŒfýõ×7;ì°ƒ™5kV¨@ñ騱c¨ÆÄÁC mÛ¶ê3Lkl…H€H lh± ÛŠ”Ùxžzê)sÚi§™K.¹Äœ{˜ýk¬¡>µÕªU Åx8ˆàüý÷ߺyqåÊ•Á5ÖhÑ‹á¢ú¦ÄõõÁàaìP±Ý’FoB .4G}´Ù`ƒ ÌC=dêÔ©SÒIðC¿¤ø Þ9×73b2ÊÌ(Ê5¸¾Q^=Ž=º"d"Äó'°ùæ››×^{M}n›7on¦NZð>Ù D‘À?ÿüc~ýõWƒ»”ª@(ÊAƒ™u×]×¼úê«UkŒW‡†ÛÐ,EydµÕVÓH ˆšÐ¥KsÅW|€SH€¢Cà‚ .0°úpé_ý±Çk^ýõèL& ‘~òÉ'æÛo¿ ¨5c²níµ×6cÆŒ ¬Írièûï¿7=ö˜n^Ʀå6mÚ¨bûÛo¿™m¶Ù¦\0Ä~ž«Å~†œ`¤`ÓÖìÙ³5,Ó¾ûîkFe6ÞxãH̓%r'€Ä&›m¶™b€Ò€H(ãÆ3ð©:t¨9ûì³Ë’º4nÜØôéÓÇÜzë­e1ç0NrîܹªÌ~ú駦FæçŸö†¹æškš{î¹G]á¼BDšÛH/_<¿ÑFĽæšk ’;<ðÀ¦S§Nñœ,gE1$pÌ1Çh2ÿÔ–,Yb=ôPÝ$º÷Þ{›wÜÑšÇ$P00,X°@³Gú3HâNa«V­ônBÁ:gÃE'@W„¢#g‡ÙXuÕUÍ¥—^ª·ÛN>ùdƒ[œþ¤lÚ` ðØpà ÕZ‹ yW^yeÂÀp«¾wïÞþéaáĦR¿tëÖÍÜ{ï½fÒ¤Iê®Ô AÓ®];3eÊ5sÖYg™Ë.»ÌÀŸx w>›~Pá÷Ûo?S»vm½cÔµk× ã™«?Îúé'o,O<ñ„–5lØPëÝwß}Þ9w€è˜Ë^{íeöÜsOsùå—XÀ)¹þøc³ûî»›Ï>û,vsä„H \@AÛtÓMÍo¼áM–4(?þ¸Ùc=ôÿüÉ'ŸÔçwß}׫÷ôÓO››nºÉ~øáºq +\ ÜŽ;Ö«‡¶qÇY¡,"^6$Û~q°uëÖæ£>2ǼnjÅØößO©„[EûöíÕ_w“vÛm7u³ÀXœqõêÕMýúõµïµÖZKñƒÒ¿ƒ”ÏØS€gdb<ýôÓõ<þ`sØA¤? €AáðÁM=¼:<ÈŽ~LÁŸÖÂkrã7šM6Ù$»FX+:dÁ)$ ·Ür‹•`V¾d :^ùï-hûl¼´¸¾™ùçËH¬–׊µ²ÒNäǪÖË£Ö9òÈ#­(vþüùÞ5òÖJØ?Û¹sg¯¬fÍšzÜVöʾøâ [«V-+¬(‚Z.ÖS­' £ŸJ¯n6ý fÍšYq‡²ß|ówíí·ß®mа–‰×JZfûûï¿{u0gÌ]br{ebqÕ2±@{eï½÷ž׊‚ê•á@ü’µ®c'›œôµX½z?þø£ŽýˆÅ×+Ïõ ßõ͵Ÿ0Ôÿúë¯í>ûìcÅýÅŠåÜŠ­¾ßvÝu×0 c(Zlå?œ ¸ík ’9œrÊ)jåˆÆÈ9J Gñª5᯿þ2‹/6°ÎºÕV[¹*f‹-¶ÐÛóøÿᇼò¦M›øï:õ÷ÄO4|ðùüóÏ]±¶ýõ×›FiY¶ýLŸ>]S.#­6|ýÀJŠ2Øh۬°Ê:qóåÓ¥|¾ãŽ;4â Ü-ü‚Ï7¬Ã¤åÙôíÛW_ãÂRõë×Ï{̓ô`YÇ> d|ùå—Õΰ†?óÌ3é/æÙÈHt8‰ì48ðr!€)DM@¶2øµ=Úl»í¶å2}Γ"O~®Mš41·„8¢¥K—ª‚êŸÜû￯Ê/|mÝF3\—,îÿnJPˆ!Ûo¿½º<¸ºpe‚dê»æ!¸íïܶ6l˜W׉åË—«Ï0R‚ÃÍ;ïÅøäÕ©ì.«¯¾º+p…*(‡o0õ07¸!øE,Êþ—ÀÙÆ‚±úçêŽáS‹ìüðÏɵ-.îÏ)à‡|¹ñÃF¿R›¢:‹bH€Û.j¹Lé„NÐ &Gu”Þ¼ûî»õV]¹ÌŸó$¨€õì?þð”7d„@ÁÆ0¿àv1Üü·ûSm?[½,•5×µ—m?ˆPòÛ×NŸ/PÈŸ›¿¶ÜrKµÒ:‹ª‹ 7‹t‚±@é‚«Arúp°qœ0¸F€ƒ+C»‹-J×|YŸƒ[ îæa}Î9眲fQΓ§Å¶œW?s‡ÏÂêÀ¿ ·+ñ…D!çž{Î q|iñ£‚Œd°¸Â2Yn J ?!nû÷Ýw UyäõEõûÄ&TÙö#Š4$Tr±‘#Gj²¯¾úJ#³`LÇw\‚›ÀK/½¤ÝfrG@¸>º~AJWXš¡ðBiÊ2æìÜ^§$M|.î /Ô}Tjù”Ý«lHc“$PرŒÔ7Üpƒ•/Ž¼Ç y_Ë ÃO€ë›yòeä¢"Ȇ.€(;äC¬X2­l~²b­LÀ!Ct÷¿l’²â_jÅ·ÔÊ-¿V¯®‹Š –TûÊ+¯ØyóæidŒUÂ`yõ¡eË–Þkwm?§žzªŽÑÐÇm·Ýf%l—ÿ]+ЦW+Vd+ º6mšÿ]‹ˆ-ˆÎ€òÃ;ÌJêV×­•ø½V|eíĉ-¢$ˆÛ–¡=Qn5ú /¼`ÅBkÅle³œ^‹v%\ç+›ã¬¸@X _¦láˆñ~B$ ÙT¨l=ð<([ü/Û¥çÄñá/–+±%õ (ŸYæû¥žO_¼¦ø¸¾™™çËÈ)¶¸Þ=ÊKbPÛX„ºJq7°ÔLî(‰²Á'á*[q;²’vÛka³$!CB“•)¶Ùöƒ^SV•[7¹dÅ_ÓëG,¸ªèºó}ÁJüZ ÊÄ"íÕ4h?a3”bˆÄçõÂv¹6$î®*ÒÞ…rðüóÏ{Š,êIÌUUrqLÅÖZ‰S¬Æ IÜáÇÆã2'° æ/ÿ$ˆ øåÉ—¨f”yôÑG Òwæ"ð‘K÷oµ¸å•N°ÁÍùÜ¥«WìsØelJbi*v×Yõ‡á¨×’\D,^êÅ_̘~9ÓúæÒo\ë–‚\ %}×u½õÖKÀ‹P[õ…¤ cVýTábk€ýLý¸N±Ñ ¾°È˜†h —_ð7(œß\\&œ BÆŽÿ3'¿üò‹ÁÃï.ßY$˜@}øÓ"’C*A¦1dBC¨¯æÍ›'øÛ¦ªŸMY)Ö7›qe[Ÿ­bY7Hà¿Z‰cœí¥¬W¸y¬ ¹Ü¦ˆ´‰ØµŒÍG}´n&€¢‹ PH¡˜ÂW.Õë\X!¶%¾R‰ÛP’ê\)˰{Jw!z7n¬¾Œ·Þzk‡È1AdîÊFÑËeõʦ¾¿N¶ý@9E¶ÃÊÊ!ü`“Å…ó—ã.ùÿŸGÝ•)|ú\œûûŽÛñÛo¿m°a™åàœ#nóå|r'@Å6wf¼""ðÁ‡_ôÈó%AÕÅN\ñùS+HU¦Ò³gOMÓX•6Š}mªØ™Åû# |Ü|óÍF\;Ì]wÝe$“\>Mðš2 À¨e°Èå|xÁÑ`Ç6rÉãö©_Ð÷Ál¦NªÅݺu3â'f&Mš¤ãDŒLX¯’wg£2â[öîÝÛì°ÃHŒ»Ñ/¸EŠ~˜í" üäÉ“5Bá8A72Ÿ3gŽ¢‹©øêÜ:EîzÜîÅNndrJ–lÆ‚9b,Ë„NX „J‚5ýË/¿Ô&1ÞöØcVüWµ~*ÅýŠÙkÏíl‡âý믿j¹lÖÑ~%v§W/Û±8ÅVèkh#×sôyB ¯Åíªh(%”!„›_8àÏŠ+´˜Š­ŸNÕÁœ_QX_|æ!¢Â¥;6¾‹Á™N€>¶òN‰7øÖ"ƒ(ƒºÑÀE+@ô”#rüpsl\¨l“|xÀ×÷ä“OÖÌE¸…&18(jn«â6+v};AJQQÊ5G½„13H¥‰À¢Ôi{W›Up·é$¦Fpç°É·üÓ Ü50>'p[€À5W ØÍ —¸p@/^œóX°þ]áØ_9ì<Ç\S ¢#¼üòË^ VW§nݺêRw nqTøLñ €¨øLG#eä»Q048‹\ P±Í•ëGŽvK u#AÓ5+$rÐLGøÐD Kø·JlÌœCL!7|›6m²âÿTdW3fŒ¦M•'UJP„ç‚ •¨Ë|öPxýåŠ:|m‘͉XqÝa¥ÏUäe’F »¸Á ß]H.cñ‡Dµ.R:_Y‰gjÉÊ-”zp@ß‘D!ˆ|NÂÏÿŒ3ÎPÿ‰U¿IrF%@Ŷ xÙx˜@I‚õÒY0ůÓÈ-l3tèPµDbsJ¡!ÈœuVÐTÖ©Â!Ý(J­w×cqg0ÉÊ ,žxH x­ãþdcÍL¾Æ]›jŒî\>cq ³k#›çE‹(çsçÎU…ÖdX¬¡ÈÃÚK!ˆ„ûÃFVÜA=z´)äçq<ˆq• b[–Çž,›xø£jÒ_|±ùôÓOø×ªÕøž{î1²ñ+¡;X#“‘ °æ:t¯½öÒèþºˆô‹­øû‹ v쬯…ËUW]¥Jíý÷߯V7!¸5@ü–fwŽÏ$@Ñ"€;M08ÀÅH²Óyws¢5 Ž6,hãËJp±%€pWH8Ð¥Kƒ Y’~ScêÂéøì"¬_à7‹{çã .nÕ%Ë~ûíg lš[ ¿m1Æ‚Ld°:KdoZPà w @t ÀÅHÒ ëÿ8î 9¥èΈ#/5ZlK½ì?² ¬Âg¶2¨u`±…uÙÓúõë§)%a©½í¶ÛTÑ6lXJ¯ƒ 1¸[`#üi¡¸Â±zqŒ ìH¡‰¤˜§ó±…¿-RðRH€¢E1ÅÏ=÷\½ƒ%‘c4Öv´fÀц•Û°® Çz°4¤ø‹A¹… ÂwÜá¥Eâ(»HÚàwI€R‹üôpW€ÀÇõ¬³Î2Ǽ¾ÆÜ‚—\·èá ï0”àTÒ´Bþb,H6qíµ×ªâ?^(òpÑÀü0gø)÷êÕKëì¿ÿþšì·1)$@Ñ!€è*ø¼Û~ûíõÇ»ÛKp¤a&° ˆ…y€ ›ü6‹ýoK.B}AÙE¨lŽÂíþäÈŽ¬»ï¼óŽú˜¶hÑ ¯}©$è± „þÐ`ÈpöÑGiØ/·!XnÁ)_ÛR¬o©Ö&ß~É(_rѸ®”ë‹Ï8ÜqÂUüÀ§@ШØM”íEž@)>ôýŠmä†|¥Xß#©0<2ª€$V¥X_ć;6‡!ê$‹‰SN&<¸y,è ƒ4[#¢«L™2ŪðŒÄW_}µiܸ±ÆØ=üðÃ?9¢Ñ [’ð âM²ÀŸøä“O6?ü°ÆëÝsÏ=ÍØ±c5¦9â÷¢]¤\w’OHuŽ(5HäƒìŒþö\»î9×ñ ¼¢‹Þ»woõÆœ½eË–fâĉ®i“n]°!ë2}útsØa‡éæAï "…HàÿÛ; +ª+ ßDÔˆ”Æ]QÅÜ₈b%*&j ÔˆŒ¨àŠŠ¸€H”—¨€K„ åR&hʈ,*ZF-7„*1j©QIç~§¼]=7¯ß¼™7Óýæ?Uoz»}ûöwß›>}î¹ç$øßXbK«µF@ý›Þ£b”Î(Ï%ªÕ¿>®v4zôèÈÇ£Ž¼òVD> Mäã[G^i¼ÒùXâÑN;íùH v=U†HOQ§N¢‰'Fwß}wäC"FC† ±ãkÖ¬‰|ˆ¨_¿~ÑÌ™3#¯GÞ="ò WÑöúÚv?3f̈¼Âù”Þ‘W #¯LZy?TuìØ1ò®dv½ÂJ¼+FÔ®]»¨gϞѴiÓ¢>}úØv—.]"25j”µwùòåvj%×óʶ]Ê”)ÑÃ?ùˆ2‘7YØÛnh{|vɈ6!¬û¸áÑСC£'žx"òyŒ-ÇÒúeݺuq¿œp ÑÂ… 9­*¢'xU°ªÒ<¨Ö?ý<3©¥¶«Ó{SŒÒå¹D5ú÷ƒ>ˆ| nû°^-ùóŸÿl  jŸ¡1ò1®#?Ñ) Š­Ol›bÖ£GÛö–USDQÄ‚ äúøØa3^RŸŸðfÊqØéãˆG>™LäÝ+lŠ­·ºšbÊ$—(’(ÎÞ5Ãv?ÿüóÖ~”Z„vøì’‘·èZûz=?1Ïê[´h‘ÕÇx ¼ûI_ñ¾°ÒöpN¡b‹bÄ'̱k{w…(­_‚b ÿj‹4ø_¸DD@D@D 2 U8Ð 6Ì‘˜†ä2Õ²12äNªñ Äòþúë¯-®uÈDÈ0â{EØ6½bi. $Ï B(²Õ«W‡ÍxIœìO?ýÔyå.ÞGhFB•‘1®ø-×'Þ¢k‰t8NB$¸-pqÈ?ùäkC¯G” &ä‘Å’ n.ø8sO¸bJ¹í)<íB®ìƒmZ¿„¸ä}ûö唪ŠÛªâUå" " "P›…"‹)¾›Dw©¶xËßÊš·znpÙÍ6Ûlƒ}ìà|”IÉ ¤îöî a3^R)TIeî­Žq9ïj¯[)v¹P*¹ ,ÉZ¤M›6nøðá¶?ìK.ËmOòœ°^Œ+,Êí—æÈ2'Å6ô––" "P#°haºêª«l’ >‰4%RYÿâ¿0Ë)IüÐwSV_o]Xï»ï>÷í·ß:8+,ëK*xÅ*Ùm·ÝÌšùÛßþ6>¼`ÁKUïøn…ú&À1Ù !¥9)½¬m7åŸJ®Çý`qfò“é²W>ùä“ñvS¶±¾ºÒú… nÍ%Õ/h®;ÐuD@D@ê ÄC”ƒ 2…ƒYÙÉ—ˆ@SxüñÇmHzÀ€î©§žj6¥–¶3£K±Ÿˆe·‚Âtÿý÷[JòbÖÄÂû=ýôÓЬ÷ 5«ë3ÏíäÉ“]søJ–ê⢾òÊ+æÛ¡C‡RE‹#®í믿îÊ›Šô;ñ©]µj•-™8\ ê+ߨý•\ËõÊ•+m"ÙÞ{ïÝØ&T|~cû¥â 'N”b›€¡U€@%ÿôE.?ZCÿ2Tšô5Üh£ìÇLrf®ã¢,]Åz®50*vß­e_%ý{ë­·šÕrðàÁ­“î3§¤Øæ´ãÔìê¨äŸ~õZ£š›š@kè_¬iXNX2cü´ÓN³!d²•#­Q9jµŒú·V{V÷EEÐ÷@D@jŒ¡‹ø\|ñÅÎgù©7ìOݶnGD@œ,¶úˆ@Y3 €Ôئú7½CÅ(Q(Á„ªÛo¿Ý-Y²Ä’œzê©îŒ3·3¹Tÿf²[Ô¨&" ‹mT5" " ­Q&5nÜ8çS­–ô]n}ttÇ"Ðü¤Ø6?s]QD@D F€Ø¨G}tÜQþnƒˆÄlåÅ"Br >¤Âm¬»–û.'†o¹×"=1ir 3®•{~K—SÛ–î]_D@D AH>qØa‡¹­¶ÚÊÚèÎ;ïÜà|fñ|ðÁLÿ€°°N„9+W(KœVbÿe⨣Žr/½ôR|úŠ+L¡Å`øLÐÃá7ÞˆËh¥ylìØ±Ís±&¸ IzôèQQM¤Ð}à,IüñE¿ÿUîO¢nbÒþæ7¿I­¢°-©'4S)¶ÍZ—hÄ=묳,›Jí¨Q£,h¨¯¨ÿË_þ∿Jð}22}ùå—¡Hê’t±óçÏw·Ýv›[¸p¡#~i¯^½Ü›o¾içn¿ýö®gÏž•Àý¬ó)F-õ¢*Ð*üò—¿´”·•Üì»ï¾kßç/¾ø¢’ÓSÏA±å÷‚ßxšT»-iׯï¸ÛúÈh¿ˆ€ˆ@& 0ôÿÓŸþÔÍ;×Í=öØÃýío‹ÛÊCŸ´«o¿ý¶[»v­ÅîÅe€ìQðQt ?~ø¡ùå—M)&ª° ßu×]n¯½ör!Ê-Ù¯ºtéâ~üã» /¼Ð®³õÖ[[úSÂÔa_¼x±±ÇòŽý Ë,ÉèûyóæÕ{Req3fŒYL黳Ï>Ûê•…»ôohG8†ËÃe—]æöÜsOGè¼B«f©sC,)wóÍ7Û.EpF~ö³ŸÙðÿ‰'žX4;à¿ÿýo{¡ãD2¦-_¾Üêà…íüóÏ·LlŒRPRyäw衇ڨ1¬¹f1!«I}ôQ³€“ͬ0n1¼{ì1W¬-(Ä=ôP\5¿'î-\ê¼úê«m„‚iLãʰ"Ŷ°TTD@D e … wïÞö`GYeèÀdB â(¤'t’kß¾½¥B8qbœmmΜ9¦tìØ±ÎËkÈúD¸´ƒ:¨ÎÍöíÛ×2PÕÙ©&%€âùÜsÏ9¢K°~ÄGØË C÷dü"å,ý‹r‹H¡ð"Sª,/&XóQâ°N~ðÁîšk®±jx0`€;üðÃÝÿøG×½{wê§î&Œ\{íµnĈö’3räȲεBßýÁÒ‰âŽpMî÷ç?ÿ¹ãûE[,X·é»SlA‚Kdøðá±,©g„ –ê—ÁAPjÏ9çS$'MšäV¯^m¿ŸpO¡K^wØa÷“ŸüÄ”ì÷ßß1ú‘¶QX‹µ…cœ„ß*÷†Ï.B¦8îoÆŒ–Ƙ}¥˜r¼Ñä±J¨é!ðôÓO»·ÞzË̶mÛZ°Ð%…ã<øyÐó 'u* ˬY³Ü±Çë9äó‹MžÃ:“yÈÒ†‚ËyÔCÊÕ ÿüç?ce"ìÓ²:è¯`ÕD"ÙÈŸþô'Ë ‰e«:J.}™\GJ•Ýb‹-ÜwÜáúõëg§¡àaý$Å4¾Û¸®`1ŷ׬ºëÖ­sï½÷ž]Ñ¢E±,ÉO°Ôßpà %ÏE L“o¼Ñyæ™V ßÕ§žzjƒS¸/^êû-·ÜÒÖIuŒ²Ž0ºÀ‡ö2ù ÅûÜsÏ}QÚUàåŽßBRx‰ÀŸ…‹4eê“úÚR_ù°“M6q¯¾úªõ#Vjú´>¦•¦.–bhk)" "y;Y€xø3û‡?üÁü<òȸíX„¦OŸnÖ5Êã÷Ú®];³øQˆ‡wÿþýãò…+(Kݺu³!S†Â±b1<‹ëÃßÿþ÷¸8V2”¬¼X¥˜™_éÃ8®T+FëeàFrÓM7…]î³Ï>³—xÇw+ie²gý–[n1^vèCKð¾ûîk–z¾(]t‘½ð<ñĶäÅŠs”`¾‡¼•:× §üIŽðbÅ(D¹’Ì(ÈòÑGÙwŸp¬Ø¸_aÒ%ÖÓBÅ6¯æ’—â(#¼Hð2YÓJ£2H±­fªn&%À03 °¤¡`mCùÀB‹\zé¥ö°ÄŠÛµkW×¹sgS>ðƒå¼r„ðIX’ðä|¬|Xr±ŠaCþñX}XúP¤ñ·ÝtÓMÍçÅDÒ8Xƒ`1Eúä“OÂ.·ß~ûYv½xÇw+ieQh‰9L4¢eà“ŠEáøî>üðÃÖ§¸CàÓ‹…kcÒå…—¾wì/un9aÈ®‹—¶Bá{ «t’.Xe+‘d=iç'Y…²É¶¦1 ç4t)Ŷ¡ÄT^D@D E 0…,ÊfP€^‚O!QP8ð¡DÑl¨%• i(9Ä åõ(Xš¸Šr°ô…ëjY¸ƒ …‰{\?ÔbáÛJ•EÁc¶?.C‡µÆò„¡q¬¯|ø`‘År¿-õb%fâS˜„ˆ¯é“O>iÛ¥ÎEAn á;Ëo|ŠƒL:Õ^ØÂv}K~?øÉa„‚ ™õ |²<.@¥$i©sKÓä±RttLD@D “p'JmayÀn¾ù渞 b '“e¯²IDATUj“õa­Åj—Tj“ǵ^}XQdÉð†%ò?ëÿ”SNqï¼óÎ/U–>DÑ “™PLýë_[¸“ ø8ÐüwÙÉ>Ü]ˆ‚À°=.-¸Cð²CD!C†˜¯6.(¥ÎÝ ‘Ø,»(àiÂuL’{íµ×ì^x9À#ÔSª|uQNQÞQXñu†IPGh åqÙ`´„}XÆKIÓRç–:&ŶhQLôbÈŸH(—¸Ÿ0óW‘B)U¥–˜Ç×_½½¬ì¿ÿþîŠ+®0‹>þ´¸%àêÂ~,öûì³#æ,>¬LÔb¤€–P\T°ä‡I[¥Î-lcc¶i×"®2Ò„ ”( Xž‰ôÁ6!¹‚/n©ó±ôâzSŸ1úÁv¶0‘Ž2´íÀ´( ¡l±eÓb申ï{þí'*§ Êˆ@k!À[½~ ïm¬(ÌHæm†ÄK$æcÖDý›Þ#b”Î(Ï%òÚ¿ÄCÅ‚È6“KI©²Xa‰xA\b¬­ÄRŵ…I‚!äpC`BW¡,e‰õʤ',”…RêܲÙfB.ôešðû¬µ# &>˜±•¬÷opµF|W™•ͨ÷[Ÿ¥Š‰‘ƒÞ Ù¡ýÄ$#29•3Ó|ƒJZ`GkèßÀªKf„€|l3Òj†”"€ëĉ-õ ±Ép„EtÕªU±bK&ÜxÈ’Wf¦®&)W]u•[¾|yrW¼>bÄGjÒ… :Ò.’')'t’ÃÍ€ãIÅ6YFë"¸ÔðâGLS~Oõ aøFNøFJ"" rEÈF?¨"P/¾²Æøƒ¸R‹ÀóIÁŠ»dÉwÏ=÷˜;® S¦Lq½zõ2«T(»lÙ2 vNÀóÂç \“ødžIJÛ¶m-ÿ8Ç%"Ј]JÈ"B!ÄÅ÷|úôéqsm ]ê½÷Þk1GY'È|~'“&M²M–¸Ü°Ä·â—R7Aî%" ù Å6ý¤V¶bÄLäËÃ÷ð÷„X‰BM q ÷»ß9¬ª,gÏžmn X£y䑸èÌ™3-°8>…Ÿþýû[9&Šç±0øÓO?mñ±KD %Üpà î£>Š't1¡F/‚O™Q^Qx™PÉHCðûfÄåyþùçm}ñâÅ7Ÿ Äú|ðÁ-€ÿŠ+Ân-E@2N@ŠmÆ;HͬSXO'OžlÊ&™oˆv@¤^,KŠ-}&x…ÉbK—.uëÖ­3_†0`€¥‘$ÁBÈ÷2@JE2Ê•!×E FPÂùà—(j ëSr$‹êÎ;ï\çRÁu€<\kÈ.Åd¯  ž}öÙq„t£S§N5%–‰—IáߟDD ?¤Øæ§¯ÔÒVJËùÉyóÀ>ï¼ólbÑ H y饗€‘éË.bð±EA½ä’K,ýdCðáÖ€u–É5dçÁêKšÉ.]ºØ„µàSÈp0©i >‹øùòAÙùÃr]•¦$À÷0ʯ"ZŠ@íÐä±Úí[ÝY `•P_L÷6¤*d¨4¾´(š(´Xr±Ú2y¬RáÜ¿þõ¯V1i¹. oRÈ=Nh/‰4'^´‰‚ÿy‡ÂfYËð"\]©ÉceU¦B" ™! ‹mfºB Òx“¶6<‹•F©EðÁmŒR›¬› c]»vÝ@©M–Ѻ4'Þ½{›ï,/UóçÏw=öXì?[ªÁÇ–2Œ:l»í¶æ‹ÎháòˆòÚk¯ÅU°Ÿ’\¨¯ÔñPNKæ# ŶùXëJ" " M@Ùy󿙫ÌСC-2ÂØ±cÝŒ3¬öC=Ô–„¾C(CÒ’ãŽ;®Ž‹ >¸ƒ ²H$Z`¤c‡v°súôécÊo=,F-Š0ÎAæÌ™cÛìûøãÍbÌú™gžiÇõGD e(ACËp×U3L@ÁË3Ü9MÐ4õo:ļ0"ŠÁ6Ûl“~C%J`u%Ìõ” )QEîå¥sV Î)¶™è5"KôO?K½ÑômQÿ¦3£tFy.¡þÍsï©íiäŠFHÇE@D@D@D@rA@Šm.ºIH# Å6Ž‹€ˆ€ˆ€ˆ€ä‚€Û\t“)" " " "F@Šm!È)¶¹è&5RD@D@D@D €Û4B:." " " " RlsÑMj¤ˆ€ˆ@9’isË)¯2" µE@Šmmõ§îFD@jŠÀªU«Ü>ûìãºwïîÞ|óMwË-·¸=öØÃí¼óÎîå—_¶{ýòË/Ýå—_nû~ðƒ¸^½z¹¥K—ÖápÛm·Y›o¾¹¥Ö]°`Aãd#½îî»ïî¶ÞzkGZÞÓN;­N™éÓ§»ýöÛÏRðÒžûî»/>~×]w¹½÷ÞÛÝ~ûív.©y¯½öZ÷¿ÿý/.£êb[}ƺ‚ˆ€ˆ@…ºtéâzè!÷ÕW_¹¡C‡º%K–¸;ï¼Ó{î¹%a}Þ¼yÅó­·ÞrGq„;ꨣܻï¾_uÍš5nܸqEùC1¥3>èW¨³mÛ¶î•W^qo¼ñ†kß¾½ûðÃã"S§Nu\p;ãŒ3ÜŠ+Ü!CÜÈ‘#ÝwÜaeØ2{ÓM7¹aÆ9ÊO™2Å-Z´(®C+" Õ' ”ºÕg¬+äŒÀ&›lâ°m´ÑF9k¹š›F`ýúõn³Í6s_ýuZÑV}<‹)W±ÚöìÙÓMž<ÙѾ ï¿ÿ¾ëСƒ{öÙgÝ`»±’þèG?2 ì5×\ï{á…LÑä;€’Œ•vË-·´ãÇ·í«¯¾Ú”ÚvíÚ¹•+Wº}÷Ý׎ï¹çž®_¿~îÖ[oµmþ (O˜0Á­]»Ööõïßßíµ×^nìØ±¶}á…ºþð‡n̘1¶•?Yì߬°Q;òO@Ûü÷¡î ‰ 0ÄÈPR{žîÖ­[íÝX+¹£óÏ?¿ŽRËm¿þúëv÷'žx¢)¸(¹;vtÿùÏܦ›njÇè÷vÚÉ1½÷Þ{nñâÅ_ÜÏ?ÿÜŽóW¬ºXs·Új+wÐA¹—^zÉŽóB„Dß¾}ãò¬°rüñÇÇû“߯]vÙÅÚÔŠˆ@Õ ´©útÈLsçÎu=zôÈYËÕÜ4³fÍ2?Ë´r:ž ÿc|ñÅ]§NŠ6ÿZ¬­X{‘Ï>ûÌÜ’…ß~ûm7sæLó‰e}öìÙîŠ+®p§žzª)È;[¸p¡ùï†óØÆ}«¬DD d±ÍF?¨"ÀÐ"Bl’Ú!@Ž5ʆŽkç®ZÇ„ X,ù$#tíÚÕ&—]wÝunõêÕúzÚ´i¶Rúé§Ÿš‹>´gu–ûïÿ[§žË.»Ì¬¶ßÿþ÷~½Xn“îHƒv“&M2_^*}î¹çl¢ØÀç ÉvÛ¶Bú#"P]þ‡(( °lÙ²Èÿò¢Ñ£GG~òGôí·ß”ÐfÐoôßÍ7ßm·Ývý*I'Àw?+2~üxû-Ò¦ðéܹsæù a‘byEÔúÙûÐFÞÒy÷+çÝ"ï+m¼ñÆ‘·°F7Þxcäýq#?ù,òŬ̑Gm»í¶Ñ6Ûlí¿ÿþ‘¼ù `ñu¼"]rÉ%VåÚ´isÎ9‘wg°2>ZƒµÏ»?D>ZCäG¬=Þš=ðÀq=YXÉRÿf‡ÚP[4yÌÿÂ%"PŒB˜P‚õ‡YÐß|óM±bÚ—a^‘1×ÜK°Ä{å6íÍNÓò:¹hݺuf™%˜W<7J”ƒí·ß¾Ž%6Â'w‹-¶07\¨£˜ð?]Ž3Ñ4’×þÍ#kµ¹ù H±m~溢ˆ€dš€ŸLwO£§þm4BUaò±Ípç¨i" " " " åb[>+•È0)¶î5MD@D@D@D |RlËg¥’" " " " & Å6㦉€ˆ€ˆ€ˆ€”O@Šmù¬TRD@D@D@D äØf¸sÔ4ò H±-Ÿ•JŠ€ˆ€ˆ€ˆ€d˜€Û wŽš&" " " "P>)¶å³RI b›áÎQÓD@D@D@D@Ê' Ŷ|V*)" ­‚ÀÆoìÖ¯_ß*îµµÝ$ýJÿJD V H±­ÕžÕ}‰€ˆ@…ºwïî^xá… ÏÖiY&°téR×­[·,7QmFbÛ(|:YD@jŠÏܹskïÆtGnÖ¬YމÔ*ïE^jõæt_" "  '°víZ³êMŸ>ÝsÌ1 ¯@gd’ÀìÙ³]Ÿ>}Üš5kÜvÛm—É6ªQ"ÐX²Ø6– Î#€Ò3gÎS‚ÆŒã/^,ŸÛœö1>µô߸qãÜé§Ÿî–-[&¥6§}©f—G@Ûò8©”ˆ€´:Xn‡îV®\éV¬Xá¾ùæ›VÇ ï7ÌD1\p/™0a‚”Ú¼w¨ÚŸJ@Šm*"ȹ"ä¡—ÔFTRlS©€ˆ€ˆ€ˆ€ˆ@H±ÍC/©" " " " ©¤Ø¦"R<b›‡^RE@D@D@D@R H±ME¤" " " " y Å6½¤6Š€ˆ€ˆ€ˆ€¤b›ŠHD@D@D@D@ò@@ŠmzImH%ð³¢~ŽÂIEND®B`‚scikit-bio-0.5.9/doc/source/util.rst000066400000000000000000000000331446255456000173450ustar00rootroot00000000000000.. automodule:: skbio.util scikit-bio-0.5.9/doc/source/workflow.rst000066400000000000000000000000371446255456000202460ustar00rootroot00000000000000.. automodule:: skbio.workflow scikit-bio-0.5.9/licenses/000077500000000000000000000000001446255456000154025ustar00rootroot00000000000000scikit-bio-0.5.9/licenses/bx_python.txt000066400000000000000000000021571446255456000201620ustar00rootroot00000000000000Copyright (c) 2005-2015 The Pennsylvania State University Copyright (c) 2013-2015 The Johns Hopkins University 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. scikit-bio-0.5.9/licenses/fastq-example-files-readme.txt000066400000000000000000000115271446255456000232530ustar00rootroot00000000000000This README file describes the FASTQ example files provided as supplementary information to the open-access publication: P.J.A. Cock, C.J. Fields, N. Goto, M.L. Heuer and P.M. Rice (2009). The Sanger FASTQ file format for sequences with quality scores, and the Solexa/Illumina FASTQ variants. These files are provided freely and we encourage anyone writing a FASTQ parser to use them as part of your test suite. Permission is granted to freely distribute and modify the files. We request (but do not insist) that this README file is included, or at least a reference to the above paper. Please cite the above paper if appropriate. We also request (but do not insist) that the example files are not modified, in order that they may serve as a common reference. Invalid FASTQ files =================== The archive contains the following sample FASTQ files with names of the form error_NAME.fastq, which all contain errors and should be rejected (if parsed as any of the three FASTQ variants): error_diff_ids.fastq error_double_qual.fastq error_double_seq.fastq error_long_qual.fastq error_no_qual.fastq error_qual_del.fastq error_qual_escape.fastq error_qual_null.fastq error_qual_space.fastq error_qual_tab.fastq error_qual_unit_sep.fastq error_qual_vtab.fastq error_short_qual.fastq error_spaces.fastq error_tabs.fastq error_trunc_at_seq.fastq error_trunc_at_plus.fastq error_trunc_at_qual.fastq error_trunc_in_title.fastq error_trunc_in_seq.fastq error_trunc_in_plus.fastq error_trunc_in_qual.fastq Of these, those with names error_qual_XXX.fastq would be valid except for the inclusion of spaces or non-printing ASCII characters outside the range allowed in the quality string. The files named error_trunc_XXX.fastq would be valid but for being truncated (e.g. simulating a partial copy over the network). The special cases of FASTQ files which would be valid as one variant, but not another, are covered below. Valid FASTQ =========== The archive contains the following valid sample FASTQ input files for testing: longreads_original_sanger.fastq wrapping_original_sanger.fastq illumina_full_range_original_illumina.fastq sanger_full_range_original_sanger.fastq solexa_full_range_original_solexa.fastq misc_dna_original_sanger.fastq misc_rna_original_sanger.fastq These all have the form NAME_original_FORMAT.fastq, where NAME is a prefix for that example, and FORMAT is one of sanger, solexa or illumina indicating which FASTQ variant that example is using. There are three matching files called NAME_as_FORMAT.fastq showing how the original file should be converted into each of the three FASTQ variants. These converted files are standardised not to use line wrapping (so each record has exactly four lines), and omit the optional repetition of the read titles on the plus line. The file longreads_original_sanger.fastq is based on real Roche 454 reads from the Sanger Institute for the the potato cyst nematodes Globodera pallida. Ten of the reads have been presented as FASTQ records, wrapping the sequence and the quality lines at 80 characters. This means some of the quality lines start with "@" or "+" characters, which may cause problems with naive parsers. Also note that the sequence is mixed case (with upper case denoting the trimmed region), and furthermore the free format title lines are over 100 characters and encode assorted read information (and are repeated on the "+" lines). The wrapping_original_sanger.fastq is based on three real reads from the NCBI Short Read Archive, but has been carefully edited to use line wrapping for the quality lines (but not the sequence lines) such that the due to the occurrence of "@" and "+" on alternating lines, the file may be misinterpreted by a simplistic parser. While this is therefore a very artificial example, it remains a valid FASTQ file, and is useful for testing purposes. The sanger_full_range_original_sanger.fastq file uses PHRED scores from 0 to 93 inclusive, covering ASCII characters from 33 (!) to 126 (~). This means it cannot be treated as a Solexa or Illumina 1.3+ FASTQ file, and attempting to parse it as such should raise an error. The solexa_full_range_original_solexa.fastq file uses Solexa scores from -5 to 62 inclusive, covering ASCII characters from 59 (;) to 126 (~). This means it cannot be treated as a Illumina 1.3+ FASTQ file, and attempting to parse it as such should raise an error. On the basis of the quality characters, the file would also qualify as a valid Sanger FASTQ file. The illumina_full_range_original_illumina.fastq file uses PHRED scores from 0 to 62 inclusive, covering ASCII characters from 64 (@) to 126 (~). On the basis of the quality characters, the file would also qualify as a valid Sanger or Solexa FASTQ file. The misc_dna_original_sanger.fastq and misc_rna_original_sanger.fastq files are artificial reads using the full range of IUPAC DNA or RNA letters, including ambiguous character codes, and both cases. scikit-bio-0.5.9/licenses/flask.txt000066400000000000000000000030561446255456000172470ustar00rootroot00000000000000Copyright (c) 2015 by Armin Ronacher and contributors. See AUTHORS for more details. Some rights reserved. Redistribution and use in source and binary forms of the software as well as documentation, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/licenses/ipython.txt000066400000000000000000000065271446255456000176470ustar00rootroot00000000000000============================= The IPython licensing terms ============================= IPython is licensed under the terms of the Modified BSD License (also known as New or Revised or 3-Clause BSD), as follows: - Copyright (c) 2008-2014, IPython Development Team - Copyright (c) 2001-2007, Fernando Perez - Copyright (c) 2001, Janko Hauser - Copyright (c) 2001, Nathaniel Gray All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the IPython Development Team nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. About the IPython Development Team ---------------------------------- Fernando Perez began IPython in 2001 based on code from Janko Hauser and Nathaniel Gray . Fernando is still the project lead. The IPython Development Team is the set of all contributors to the IPython project. This includes all of the IPython subprojects. A full list with details is kept in the documentation directory, in the file ``about/credits.txt``. The core team that coordinates development on GitHub can be found here: https://github.com/ipython/. Our Copyright Policy -------------------- IPython uses a shared copyright model. Each contributor maintains copyright over their contributions to IPython. But, it is important to note that these contributions are typically only changes to the repositories. Thus, the IPython source code, in its entirety is not the copyright of any single person or institution. Instead, it is the collective copyright of the entire IPython Development Team. If individual contributors want to maintain a record of what changes/contributions they have specific copyright on, they should indicate their copyright in the commit message of the change, when they commit the change to one of the IPython repositories. With this in mind, the following banner should be used in any source code file to indicate the copyright and license terms: :: # Copyright (c) IPython Development Team. # Distributed under the terms of the Modified BSD License. scikit-bio-0.5.9/licenses/nb-slideshow-template.txt000066400000000000000000000030461446255456000223550ustar00rootroot00000000000000Licensed under the terms of the Simplified BSD license: http://opensource.org/licenses/BSD-3-Clause Copyright (c) 2013, Fernando Perez. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/licenses/qiita.txt000066400000000000000000000027321446255456000172560ustar00rootroot00000000000000Copyright (c) 2013, Qiita development team All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the {organization} nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/licenses/scikit-learn.txt000066400000000000000000000032601446255456000205310ustar00rootroot00000000000000------------------------------------------------------------------------------ The file doc/source/_static/copybutton.js has the following license: New BSD License Copyright (c) 2007–2014 The scikit-learn developers. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: a. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. b. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. c. Neither the name of the Scikit-learn Developers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/licenses/scipy.txt000066400000000000000000000030541446255456000172740ustar00rootroot00000000000000Copyright (c) 2001, 2002 Enthought, Inc. All rights reserved. Copyright (c) 2003-2012 SciPy Developers. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: a. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. b. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. c. Neither the name of Enthought nor the names of the SciPy Developers may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/licenses/simde.txt000066400000000000000000000020651446255456000172470ustar00rootroot00000000000000Copyright (c) 2017 Evan Nemerson 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. scikit-bio-0.5.9/licenses/sphinx-bootstrap-theme.txt000066400000000000000000000020441446255456000225670ustar00rootroot00000000000000Copyright (c) 2011-2014 Ryan Roemer 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. scikit-bio-0.5.9/licenses/ssw.txt000066400000000000000000000030251446255456000167570ustar00rootroot00000000000000/* The MIT License Copyright (c) 2012-1015 Boston College. 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. */ /* Contact: Mengyao Zhao */ /* * ssw.c * * Created by Mengyao Zhao on 6/22/10. * Copyright 2010 Boston College. All rights reserved. * Version 0.1.4 * Last revision by Mengyao Zhao on 12/07/12. * */ /* * ssw.h * * Created by Mengyao Zhao on 6/22/10. * Copyright 2010 Boston College. All rights reserved. * Version 0.1.4 * Last revision by Mengyao Zhao on 01/30/13. * */ scikit-bio-0.5.9/licenses/verman.txt000066400000000000000000000027231446255456000174370ustar00rootroot00000000000000Copyright (c) 2014, Daniel McDonald All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the {organization} nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. scikit-bio-0.5.9/pyproject.toml000066400000000000000000000010631446255456000165110ustar00rootroot00000000000000[build-system] # https://numpy.org/doc/stable/dev/depending_on_numpy.html#adding-a-dependency-on-numpy requires = ["Cython>=0.29.32", "oldest-supported-numpy", "setuptools", "wheel"] [tool.pytest.ini_options] filterwarnings = [ "ignore::skbio.util.SkbioWarning", ] [tool.check-manifest] ignore = [ ".coveragerc", ".dockerignore", ".editorconfig", "RELEASE.md", "REVIEWING.md", "aarch64.Dockerfile", "checklist.py", # created by conda-incubator/setup-miniconda@v2 action "ci/setup-miniconda-patched-conda_host_env.yml", ] scikit-bio-0.5.9/setup.py000066400000000000000000000133231446255456000153110ustar00rootroot00000000000000#!/usr/bin/env python # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import os import platform import re import ast import sys import sysconfig import subprocess from setuptools import find_packages, setup from setuptools.extension import Extension import numpy as np if sys.version_info.major != 3: sys.exit("scikit-bio can only be used with Python 3. You are currently " "running Python %d." % sys.version_info.major) clang = False icc = False try: if os.environ['CC'] == "clang": clang = True except KeyError: pass if not clang: try: if subprocess.check_output( ["gcc", "--version"], universal_newlines=True).find("clang") != -1: clang = True except (subprocess.CalledProcessError, FileNotFoundError): pass try: if os.environ['CC'] == "icc": icc = True except KeyError: pass # version parsing from __init__ pulled from Flask's setup.py # https://github.com/mitsuhiko/flask/blob/master/setup.py _version_re = re.compile(r'__version__\s+=\s+(.*)') with open('skbio/__init__.py', 'rb') as f: hit = _version_re.search(f.read().decode('utf-8')).group(1) version = str(ast.literal_eval(hit)) classes = """ Development Status :: 4 - Beta License :: OSI Approved :: BSD License Topic :: Software Development :: Libraries Topic :: Scientific/Engineering Topic :: Scientific/Engineering :: Bio-Informatics Programming Language :: Python :: 3 Programming Language :: Python :: 3 :: Only Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 Programming Language :: Python :: 3.10 Programming Language :: Python :: 3.11 Operating System :: Unix Operating System :: POSIX Operating System :: MacOS :: MacOS X """ classifiers = [s.strip() for s in classes.split('\n') if s] description = ('Data structures, algorithms and educational ' 'resources for bioinformatics.') with open('README.rst') as f: long_description = f.read() # Dealing with Cython USE_CYTHON = os.environ.get('USE_CYTHON') if USE_CYTHON is None or USE_CYTHON.lower() in {'false', 'no'}: USE_CYTHON = False else: USE_CYTHON = True ext = '.pyx' if USE_CYTHON else '.c' ssw_extra_compile_args = ['-I.'] if platform.system() != 'Windows': if icc or sysconfig.get_config_vars()['CC'] == 'icc': ssw_extra_compile_args.extend(['-qopenmp-simd', '-DSIMDE_ENABLE_OPENMP']) elif not (clang or sysconfig.get_config_vars()['CC'] == 'clang'): ssw_extra_compile_args.extend(['-fopenmp-simd', '-DSIMDE_ENABLE_OPENMP']) elif platform.system() == 'Windows': ssw_extra_compile_args.extend(['-openmp:experimental']) # Users with i686 architectures have reported that adding this flag allows # SSW to be compiled. See https://github.com/biocore/scikit-bio/issues/409 and # http://stackoverflow.com/q/26211814/3776794 for details. if platform.machine() == 'i686': ssw_extra_compile_args.append('-msse2') extensions = [ Extension("skbio.metadata._intersection", ["skbio/metadata/_intersection" + ext]), Extension("skbio.stats.__subsample", ["skbio/stats/__subsample" + ext], include_dirs=[np.get_include()]), Extension("skbio.alignment._ssw_wrapper", ["skbio/alignment/_ssw_wrapper" + ext, "skbio/alignment/_lib/ssw.c"], extra_compile_args=ssw_extra_compile_args, include_dirs=[np.get_include()]), Extension("skbio.diversity._phylogenetic", ["skbio/diversity/_phylogenetic" + ext], include_dirs=[np.get_include()]), Extension("skbio.stats.ordination._cutils", ["skbio/stats/ordination/_cutils" + ext], extra_compile_args=ssw_extra_compile_args), Extension("skbio.stats.distance._cutils", ["skbio/stats/distance/_cutils" + ext], extra_compile_args=ssw_extra_compile_args), ] if USE_CYTHON: from Cython.Build import cythonize # Always recompile the pyx files to C if USE_CYTHON is set. extensions = cythonize(extensions, force=True) setup(name='scikit-bio', version=version, license='BSD-3-Clause', description=description, long_description=long_description, author="scikit-bio development team", author_email="gregcaporaso@gmail.com", maintainer="scikit-bio development team", maintainer_email="gregcaporaso@gmail.com", url='http://scikit-bio.org', packages=find_packages(), ext_modules=extensions, include_dirs=[np.get_include()], tests_require=['pytest', 'coverage'], install_requires=[ 'requests >= 2.20.0', 'decorator >= 3.4.2', 'IPython >= 3.2.0', 'matplotlib >= 1.4.3', 'natsort >= 4.0.3', 'numpy >= 1.9.2', 'pandas >= 1.5.0', 'scipy <= 1.10.1', 'h5py >= 3.6.0', 'hdmedians >= 0.14.1', ], classifiers=classifiers, package_data={ 'skbio.diversity.alpha.tests': ['data/qiime-191-tt/*'], 'skbio.diversity.beta.tests': ['data/qiime-191-tt/*'], 'skbio.io.tests': ['data/*'], 'skbio.io.format.tests': ['data/*'], 'skbio.stats.tests': ['data/*'], 'skbio.stats.distance.tests': ['data/*'], 'skbio.stats.ordination.tests': ['data/*'] } ) scikit-bio-0.5.9/simde-sse2.h000066400000000000000000030635751446255456000157440ustar00rootroot00000000000000/* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin x86/sse2.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson * 2015-2017 John W. Ratcliff * 2015 Brandon Rowlett * 2015 Ken Fast * 2017 Hasindu Gamaarachchi * 2018 Jeff Daily */ #if !defined(SIMDE_X86_SSE2_H) #define SIMDE_X86_SSE2_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin x86/sse.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson * 2015-2017 John W. Ratcliff * 2015 Brandon Rowlett * 2015 Ken Fast */ #if !defined(SIMDE_X86_SSE_H) #define SIMDE_X86_SSE_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin x86/mmx.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson */ #if !defined(SIMDE_X86_MMX_H) #define SIMDE_X86_MMX_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-common.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson */ #if !defined(SIMDE_COMMON_H) #define SIMDE_COMMON_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin hedley.h :: */ /* Hedley - https://nemequ.github.io/hedley * Created by Evan Nemerson * * To the extent possible under law, the author(s) have dedicated all * copyright and related and neighboring rights to this software to * the public domain worldwide. This software is distributed without * any warranty. * * For details, see . * SPDX-License-Identifier: CC0-1.0 */ #if !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < 16) #if defined(HEDLEY_VERSION) # undef HEDLEY_VERSION #endif #define HEDLEY_VERSION 16 #if defined(HEDLEY_STRINGIFY_EX) # undef HEDLEY_STRINGIFY_EX #endif #define HEDLEY_STRINGIFY_EX(x) #x #if defined(HEDLEY_STRINGIFY) # undef HEDLEY_STRINGIFY #endif #define HEDLEY_STRINGIFY(x) HEDLEY_STRINGIFY_EX(x) #if defined(HEDLEY_CONCAT_EX) # undef HEDLEY_CONCAT_EX #endif #define HEDLEY_CONCAT_EX(a,b) a##b #if defined(HEDLEY_CONCAT) # undef HEDLEY_CONCAT #endif #define HEDLEY_CONCAT(a,b) HEDLEY_CONCAT_EX(a,b) #if defined(HEDLEY_CONCAT3_EX) # undef HEDLEY_CONCAT3_EX #endif #define HEDLEY_CONCAT3_EX(a,b,c) a##b##c #if defined(HEDLEY_CONCAT3) # undef HEDLEY_CONCAT3 #endif #define HEDLEY_CONCAT3(a,b,c) HEDLEY_CONCAT3_EX(a,b,c) #if defined(HEDLEY_VERSION_ENCODE) # undef HEDLEY_VERSION_ENCODE #endif #define HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) #if defined(HEDLEY_VERSION_DECODE_MAJOR) # undef HEDLEY_VERSION_DECODE_MAJOR #endif #define HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) #if defined(HEDLEY_VERSION_DECODE_MINOR) # undef HEDLEY_VERSION_DECODE_MINOR #endif #define HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) #if defined(HEDLEY_VERSION_DECODE_REVISION) # undef HEDLEY_VERSION_DECODE_REVISION #endif #define HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) #if defined(HEDLEY_GNUC_VERSION) # undef HEDLEY_GNUC_VERSION #endif #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) # define HEDLEY_GNUC_VERSION HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) #elif defined(__GNUC__) # define HEDLEY_GNUC_VERSION HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) #endif #if defined(HEDLEY_GNUC_VERSION_CHECK) # undef HEDLEY_GNUC_VERSION_CHECK #endif #if defined(HEDLEY_GNUC_VERSION) # define HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (HEDLEY_GNUC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_MSVC_VERSION) # undef HEDLEY_MSVC_VERSION #endif #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) # define HEDLEY_MSVC_VERSION HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) #elif defined(_MSC_FULL_VER) && !defined(__ICL) # define HEDLEY_MSVC_VERSION HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) #elif defined(_MSC_VER) && !defined(__ICL) # define HEDLEY_MSVC_VERSION HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) #endif #if defined(HEDLEY_MSVC_VERSION_CHECK) # undef HEDLEY_MSVC_VERSION_CHECK #endif #if !defined(HEDLEY_MSVC_VERSION) # define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) #elif defined(_MSC_VER) && (_MSC_VER >= 1400) # define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) #elif defined(_MSC_VER) && (_MSC_VER >= 1200) # define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) #else # define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) #endif #if defined(HEDLEY_INTEL_VERSION) # undef HEDLEY_INTEL_VERSION #endif #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) # define HEDLEY_INTEL_VERSION HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) #elif defined(__INTEL_COMPILER) && !defined(__ICL) # define HEDLEY_INTEL_VERSION HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) #endif #if defined(HEDLEY_INTEL_VERSION_CHECK) # undef HEDLEY_INTEL_VERSION_CHECK #endif #if defined(HEDLEY_INTEL_VERSION) # define HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (HEDLEY_INTEL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_INTEL_CL_VERSION) # undef HEDLEY_INTEL_CL_VERSION #endif #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) # define HEDLEY_INTEL_CL_VERSION HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) #endif #if defined(HEDLEY_INTEL_CL_VERSION_CHECK) # undef HEDLEY_INTEL_CL_VERSION_CHECK #endif #if defined(HEDLEY_INTEL_CL_VERSION) # define HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (HEDLEY_INTEL_CL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_PGI_VERSION) # undef HEDLEY_PGI_VERSION #endif #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) # define HEDLEY_PGI_VERSION HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) #endif #if defined(HEDLEY_PGI_VERSION_CHECK) # undef HEDLEY_PGI_VERSION_CHECK #endif #if defined(HEDLEY_PGI_VERSION) # define HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (HEDLEY_PGI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_SUNPRO_VERSION) # undef HEDLEY_SUNPRO_VERSION #endif #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) # define HEDLEY_SUNPRO_VERSION HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) #elif defined(__SUNPRO_C) # define HEDLEY_SUNPRO_VERSION HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) # define HEDLEY_SUNPRO_VERSION HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) #elif defined(__SUNPRO_CC) # define HEDLEY_SUNPRO_VERSION HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) #endif #if defined(HEDLEY_SUNPRO_VERSION_CHECK) # undef HEDLEY_SUNPRO_VERSION_CHECK #endif #if defined(HEDLEY_SUNPRO_VERSION) # define HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (HEDLEY_SUNPRO_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION) # undef HEDLEY_EMSCRIPTEN_VERSION #endif #if defined(__EMSCRIPTEN__) # define HEDLEY_EMSCRIPTEN_VERSION HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION_CHECK) # undef HEDLEY_EMSCRIPTEN_VERSION_CHECK #endif #if defined(HEDLEY_EMSCRIPTEN_VERSION) # define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (HEDLEY_EMSCRIPTEN_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_ARM_VERSION) # undef HEDLEY_ARM_VERSION #endif #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) # define HEDLEY_ARM_VERSION HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) #elif defined(__CC_ARM) && defined(__ARMCC_VERSION) # define HEDLEY_ARM_VERSION HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) #endif #if defined(HEDLEY_ARM_VERSION_CHECK) # undef HEDLEY_ARM_VERSION_CHECK #endif #if defined(HEDLEY_ARM_VERSION) # define HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (HEDLEY_ARM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_IBM_VERSION) # undef HEDLEY_IBM_VERSION #endif #if defined(__ibmxl__) # define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) #elif defined(__xlC__) && defined(__xlC_ver__) # define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) #elif defined(__xlC__) # define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) #endif #if defined(HEDLEY_IBM_VERSION_CHECK) # undef HEDLEY_IBM_VERSION_CHECK #endif #if defined(HEDLEY_IBM_VERSION) # define HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (HEDLEY_IBM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_VERSION) # undef HEDLEY_TI_VERSION #endif #if \ defined(__TI_COMPILER_VERSION__) && \ ( \ defined(__TMS470__) || defined(__TI_ARM__) || \ defined(__MSP430__) || \ defined(__TMS320C2000__) \ ) # if (__TI_COMPILER_VERSION__ >= 16000000) # define HEDLEY_TI_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) # endif #endif #if defined(HEDLEY_TI_VERSION_CHECK) # undef HEDLEY_TI_VERSION_CHECK #endif #if defined(HEDLEY_TI_VERSION) # define HEDLEY_TI_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_CL2000_VERSION) # undef HEDLEY_TI_CL2000_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) # define HEDLEY_TI_CL2000_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL2000_VERSION_CHECK) # undef HEDLEY_TI_CL2000_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL2000_VERSION) # define HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_CL2000_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_CL430_VERSION) # undef HEDLEY_TI_CL430_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) # define HEDLEY_TI_CL430_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL430_VERSION_CHECK) # undef HEDLEY_TI_CL430_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL430_VERSION) # define HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_CL430_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_ARMCL_VERSION) # undef HEDLEY_TI_ARMCL_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) # define HEDLEY_TI_ARMCL_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_ARMCL_VERSION_CHECK) # undef HEDLEY_TI_ARMCL_VERSION_CHECK #endif #if defined(HEDLEY_TI_ARMCL_VERSION) # define HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_ARMCL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_CL6X_VERSION) # undef HEDLEY_TI_CL6X_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) # define HEDLEY_TI_CL6X_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL6X_VERSION_CHECK) # undef HEDLEY_TI_CL6X_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL6X_VERSION) # define HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_CL6X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_CL7X_VERSION) # undef HEDLEY_TI_CL7X_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) # define HEDLEY_TI_CL7X_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CL7X_VERSION_CHECK) # undef HEDLEY_TI_CL7X_VERSION_CHECK #endif #if defined(HEDLEY_TI_CL7X_VERSION) # define HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_CL7X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TI_CLPRU_VERSION) # undef HEDLEY_TI_CLPRU_VERSION #endif #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) # define HEDLEY_TI_CLPRU_VERSION HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) #endif #if defined(HEDLEY_TI_CLPRU_VERSION_CHECK) # undef HEDLEY_TI_CLPRU_VERSION_CHECK #endif #if defined(HEDLEY_TI_CLPRU_VERSION) # define HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (HEDLEY_TI_CLPRU_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_CRAY_VERSION) # undef HEDLEY_CRAY_VERSION #endif #if defined(_CRAYC) # if defined(_RELEASE_PATCHLEVEL) # define HEDLEY_CRAY_VERSION HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) # else # define HEDLEY_CRAY_VERSION HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) # endif #endif #if defined(HEDLEY_CRAY_VERSION_CHECK) # undef HEDLEY_CRAY_VERSION_CHECK #endif #if defined(HEDLEY_CRAY_VERSION) # define HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (HEDLEY_CRAY_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_IAR_VERSION) # undef HEDLEY_IAR_VERSION #endif #if defined(__IAR_SYSTEMS_ICC__) # if __VER__ > 1000 # define HEDLEY_IAR_VERSION HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) # else # define HEDLEY_IAR_VERSION HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) # endif #endif #if defined(HEDLEY_IAR_VERSION_CHECK) # undef HEDLEY_IAR_VERSION_CHECK #endif #if defined(HEDLEY_IAR_VERSION) # define HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (HEDLEY_IAR_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_TINYC_VERSION) # undef HEDLEY_TINYC_VERSION #endif #if defined(__TINYC__) # define HEDLEY_TINYC_VERSION HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) #endif #if defined(HEDLEY_TINYC_VERSION_CHECK) # undef HEDLEY_TINYC_VERSION_CHECK #endif #if defined(HEDLEY_TINYC_VERSION) # define HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (HEDLEY_TINYC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_DMC_VERSION) # undef HEDLEY_DMC_VERSION #endif #if defined(__DMC__) # define HEDLEY_DMC_VERSION HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) #endif #if defined(HEDLEY_DMC_VERSION_CHECK) # undef HEDLEY_DMC_VERSION_CHECK #endif #if defined(HEDLEY_DMC_VERSION) # define HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (HEDLEY_DMC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_COMPCERT_VERSION) # undef HEDLEY_COMPCERT_VERSION #endif #if defined(__COMPCERT_VERSION__) # define HEDLEY_COMPCERT_VERSION HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) #endif #if defined(HEDLEY_COMPCERT_VERSION_CHECK) # undef HEDLEY_COMPCERT_VERSION_CHECK #endif #if defined(HEDLEY_COMPCERT_VERSION) # define HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (HEDLEY_COMPCERT_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_PELLES_VERSION) # undef HEDLEY_PELLES_VERSION #endif #if defined(__POCC__) # define HEDLEY_PELLES_VERSION HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) #endif #if defined(HEDLEY_PELLES_VERSION_CHECK) # undef HEDLEY_PELLES_VERSION_CHECK #endif #if defined(HEDLEY_PELLES_VERSION) # define HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (HEDLEY_PELLES_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_MCST_LCC_VERSION) # undef HEDLEY_MCST_LCC_VERSION #endif #if defined(__LCC__) && defined(__LCC_MINOR__) # define HEDLEY_MCST_LCC_VERSION HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) #endif #if defined(HEDLEY_MCST_LCC_VERSION_CHECK) # undef HEDLEY_MCST_LCC_VERSION_CHECK #endif #if defined(HEDLEY_MCST_LCC_VERSION) # define HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (HEDLEY_MCST_LCC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_GCC_VERSION) # undef HEDLEY_GCC_VERSION #endif #if \ defined(HEDLEY_GNUC_VERSION) && \ !defined(__clang__) && \ !defined(HEDLEY_INTEL_VERSION) && \ !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_ARM_VERSION) && \ !defined(HEDLEY_CRAY_VERSION) && \ !defined(HEDLEY_TI_VERSION) && \ !defined(HEDLEY_TI_ARMCL_VERSION) && \ !defined(HEDLEY_TI_CL430_VERSION) && \ !defined(HEDLEY_TI_CL2000_VERSION) && \ !defined(HEDLEY_TI_CL6X_VERSION) && \ !defined(HEDLEY_TI_CL7X_VERSION) && \ !defined(HEDLEY_TI_CLPRU_VERSION) && \ !defined(__COMPCERT__) && \ !defined(HEDLEY_MCST_LCC_VERSION) # define HEDLEY_GCC_VERSION HEDLEY_GNUC_VERSION #endif #if defined(HEDLEY_GCC_VERSION_CHECK) # undef HEDLEY_GCC_VERSION_CHECK #endif #if defined(HEDLEY_GCC_VERSION) # define HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (HEDLEY_GCC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else # define HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) #endif #if defined(HEDLEY_HAS_ATTRIBUTE) # undef HEDLEY_HAS_ATTRIBUTE #endif #if \ defined(__has_attribute) && \ ( \ (!defined(HEDLEY_IAR_VERSION) || HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ ) # define HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) #else # define HEDLEY_HAS_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_ATTRIBUTE) # undef HEDLEY_GNUC_HAS_ATTRIBUTE #endif #if defined(__has_attribute) # define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_HAS_ATTRIBUTE(attribute) #else # define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_ATTRIBUTE) # undef HEDLEY_GCC_HAS_ATTRIBUTE #endif #if defined(__has_attribute) # define HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_HAS_ATTRIBUTE(attribute) #else # define HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_CPP_ATTRIBUTE) # undef HEDLEY_HAS_CPP_ATTRIBUTE #endif #if \ defined(__has_cpp_attribute) && \ defined(__cplusplus) && \ (!defined(HEDLEY_SUNPRO_VERSION) || HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) # define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) #else # define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_HAS_CPP_ATTRIBUTE_NS) # undef HEDLEY_HAS_CPP_ATTRIBUTE_NS #endif #if !defined(__cplusplus) || !defined(__has_cpp_attribute) # define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) #elif \ !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_IAR_VERSION) && \ (!defined(HEDLEY_SUNPRO_VERSION) || HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,20,0)) # define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) #else # define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) # undef HEDLEY_GNUC_HAS_CPP_ATTRIBUTE #endif #if defined(__has_cpp_attribute) && defined(__cplusplus) # define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) #else # define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_CPP_ATTRIBUTE) # undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE #endif #if defined(__has_cpp_attribute) && defined(__cplusplus) # define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) #else # define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_BUILTIN) # undef HEDLEY_HAS_BUILTIN #endif #if defined(__has_builtin) # define HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) #else # define HEDLEY_HAS_BUILTIN(builtin) (0) #endif #if defined(HEDLEY_GNUC_HAS_BUILTIN) # undef HEDLEY_GNUC_HAS_BUILTIN #endif #if defined(__has_builtin) # define HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) #else # define HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_BUILTIN) # undef HEDLEY_GCC_HAS_BUILTIN #endif #if defined(__has_builtin) # define HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) #else # define HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_FEATURE) # undef HEDLEY_HAS_FEATURE #endif #if defined(__has_feature) # define HEDLEY_HAS_FEATURE(feature) __has_feature(feature) #else # define HEDLEY_HAS_FEATURE(feature) (0) #endif #if defined(HEDLEY_GNUC_HAS_FEATURE) # undef HEDLEY_GNUC_HAS_FEATURE #endif #if defined(__has_feature) # define HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) #else # define HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_FEATURE) # undef HEDLEY_GCC_HAS_FEATURE #endif #if defined(__has_feature) # define HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) #else # define HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_EXTENSION) # undef HEDLEY_HAS_EXTENSION #endif #if defined(__has_extension) # define HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) #else # define HEDLEY_HAS_EXTENSION(extension) (0) #endif #if defined(HEDLEY_GNUC_HAS_EXTENSION) # undef HEDLEY_GNUC_HAS_EXTENSION #endif #if defined(__has_extension) # define HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) #else # define HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_EXTENSION) # undef HEDLEY_GCC_HAS_EXTENSION #endif #if defined(__has_extension) # define HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) #else # define HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_DECLSPEC_ATTRIBUTE) # undef HEDLEY_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) # define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) #else # define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) #endif #if defined(HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) # undef HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) # define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) #else # define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) # undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE #endif #if defined(__has_declspec_attribute) # define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) #else # define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_HAS_WARNING) # undef HEDLEY_HAS_WARNING #endif #if defined(__has_warning) # define HEDLEY_HAS_WARNING(warning) __has_warning(warning) #else # define HEDLEY_HAS_WARNING(warning) (0) #endif #if defined(HEDLEY_GNUC_HAS_WARNING) # undef HEDLEY_GNUC_HAS_WARNING #endif #if defined(__has_warning) # define HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) #else # define HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_GCC_HAS_WARNING) # undef HEDLEY_GCC_HAS_WARNING #endif #if defined(__has_warning) # define HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) #else # define HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ defined(__clang__) || \ HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ (HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) # define HEDLEY_PRAGMA(value) _Pragma(#value) #elif HEDLEY_MSVC_VERSION_CHECK(15,0,0) # define HEDLEY_PRAGMA(value) __pragma(value) #else # define HEDLEY_PRAGMA(value) #endif #if defined(HEDLEY_DIAGNOSTIC_PUSH) # undef HEDLEY_DIAGNOSTIC_PUSH #endif #if defined(HEDLEY_DIAGNOSTIC_POP) # undef HEDLEY_DIAGNOSTIC_POP #endif #if defined(__clang__) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") # define HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") # define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") #elif HEDLEY_GCC_VERSION_CHECK(4,6,0) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") # define HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") #elif \ HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) # define HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) #elif HEDLEY_ARM_VERSION_CHECK(5,6,0) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") # define HEDLEY_DIAGNOSTIC_POP _Pragma("pop") #elif \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") # define HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") #elif HEDLEY_PELLES_VERSION_CHECK(2,90,0) # define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") # define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") #else # define HEDLEY_DIAGNOSTIC_PUSH # define HEDLEY_DIAGNOSTIC_POP #endif /* HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ #if defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) # undef HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ #endif #if defined(__cplusplus) # if HEDLEY_HAS_WARNING("-Wc++98-compat") # if HEDLEY_HAS_WARNING("-Wc++17-extensions") # if HEDLEY_HAS_WARNING("-Wc++1z-extensions") # define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ xpr \ HEDLEY_DIAGNOSTIC_POP # else # define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ xpr \ HEDLEY_DIAGNOSTIC_POP # endif # else # define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ xpr \ HEDLEY_DIAGNOSTIC_POP # endif # endif #endif #if !defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) # define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x #endif #if defined(HEDLEY_CONST_CAST) # undef HEDLEY_CONST_CAST #endif #if defined(__cplusplus) # define HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) #elif \ HEDLEY_HAS_WARNING("-Wcast-qual") || \ HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ ((T) (expr)); \ HEDLEY_DIAGNOSTIC_POP \ })) #else # define HEDLEY_CONST_CAST(T, expr) ((T) (expr)) #endif #if defined(HEDLEY_REINTERPRET_CAST) # undef HEDLEY_REINTERPRET_CAST #endif #if defined(__cplusplus) # define HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) #else # define HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) #endif #if defined(HEDLEY_STATIC_CAST) # undef HEDLEY_STATIC_CAST #endif #if defined(__cplusplus) # define HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) #else # define HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) #endif #if defined(HEDLEY_CPP_CAST) # undef HEDLEY_CPP_CAST #endif #if defined(__cplusplus) # if HEDLEY_HAS_WARNING("-Wold-style-cast") # define HEDLEY_CPP_CAST(T, expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ ((T) (expr)) \ HEDLEY_DIAGNOSTIC_POP # elif HEDLEY_IAR_VERSION_CHECK(8,3,0) # define HEDLEY_CPP_CAST(T, expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("diag_suppress=Pe137") \ HEDLEY_DIAGNOSTIC_POP # else # define HEDLEY_CPP_CAST(T, expr) ((T) (expr)) # endif #else # define HEDLEY_CPP_CAST(T, expr) (expr) #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) # undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED #endif #if HEDLEY_HAS_WARNING("-Wdeprecated-declarations") # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) #elif HEDLEY_PGI_VERSION_CHECK(20,7,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") #elif HEDLEY_PGI_VERSION_CHECK(17,10,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") #elif HEDLEY_GCC_VERSION_CHECK(4,3,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_MSVC_VERSION_CHECK(15,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) #elif HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") #elif \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") #elif HEDLEY_PELLES_VERSION_CHECK(2,90,0) # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") #else # define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) # undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) #elif HEDLEY_PGI_VERSION_CHECK(17,10,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") #elif HEDLEY_GCC_VERSION_CHECK(4,3,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") #elif HEDLEY_MSVC_VERSION_CHECK(15,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) #elif \ HEDLEY_TI_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") #elif HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") #elif HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") #else # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) # undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES #endif #if HEDLEY_HAS_WARNING("-Wunknown-attributes") # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") #elif HEDLEY_GCC_VERSION_CHECK(4,6,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #elif HEDLEY_INTEL_VERSION_CHECK(17,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") #elif HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) #elif HEDLEY_MSVC_VERSION_CHECK(19,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) #elif HEDLEY_PGI_VERSION_CHECK(20,7,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") #elif HEDLEY_PGI_VERSION_CHECK(17,10,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") #elif \ HEDLEY_TI_VERSION_CHECK(18,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") #elif HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") #else # define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) # undef HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL #endif #if HEDLEY_HAS_WARNING("-Wcast-qual") # define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") #elif HEDLEY_GCC_VERSION_CHECK(3,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") #else # define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL #endif #if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) # undef HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION #endif #if HEDLEY_HAS_WARNING("-Wunused-function") # define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") #elif HEDLEY_GCC_VERSION_CHECK(3,4,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") #elif HEDLEY_MSVC_VERSION_CHECK(1,0,0) # define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) #elif HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") #else # define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION #endif #if defined(HEDLEY_DEPRECATED) # undef HEDLEY_DEPRECATED #endif #if defined(HEDLEY_DEPRECATED_FOR) # undef HEDLEY_DEPRECATED_FOR #endif #if \ HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) # define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) #elif \ (HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(HEDLEY_IAR_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ HEDLEY_TI_VERSION_CHECK(18,1,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) # define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) #elif defined(__cplusplus) && (__cplusplus >= 201402L) # define HEDLEY_DEPRECATED(since) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) # define HEDLEY_DEPRECATED_FOR(since, replacement) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) #elif \ HEDLEY_HAS_ATTRIBUTE(deprecated) || \ HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ HEDLEY_IAR_VERSION_CHECK(8,10,0) # define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) # define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) #elif \ HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_DEPRECATED(since) __declspec(deprecated) # define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_DEPRECATED(since) _Pragma("deprecated") # define HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") #else # define HEDLEY_DEPRECATED(since) # define HEDLEY_DEPRECATED_FOR(since, replacement) #endif #if defined(HEDLEY_UNAVAILABLE) # undef HEDLEY_UNAVAILABLE #endif #if \ HEDLEY_HAS_ATTRIBUTE(warning) || \ HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) #else # define HEDLEY_UNAVAILABLE(available_since) #endif #if defined(HEDLEY_WARN_UNUSED_RESULT) # undef HEDLEY_WARN_UNUSED_RESULT #endif #if defined(HEDLEY_WARN_UNUSED_RESULT_MSG) # undef HEDLEY_WARN_UNUSED_RESULT_MSG #endif #if \ HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) # define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) #elif (HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) # define HEDLEY_WARN_UNUSED_RESULT HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) # define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) #elif HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) # define HEDLEY_WARN_UNUSED_RESULT HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) # define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) #elif defined(_Check_return_) /* SAL */ # define HEDLEY_WARN_UNUSED_RESULT _Check_return_ # define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ #else # define HEDLEY_WARN_UNUSED_RESULT # define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) #endif #if defined(HEDLEY_SENTINEL) # undef HEDLEY_SENTINEL #endif #if \ HEDLEY_HAS_ATTRIBUTE(sentinel) || \ HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) #else # define HEDLEY_SENTINEL(position) #endif #if defined(HEDLEY_NO_RETURN) # undef HEDLEY_NO_RETURN #endif #if HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_NO_RETURN __noreturn #elif \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_NO_RETURN __attribute__((__noreturn__)) #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L # define HEDLEY_NO_RETURN _Noreturn #elif defined(__cplusplus) && (__cplusplus >= 201103L) # define HEDLEY_NO_RETURN HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) #elif \ HEDLEY_HAS_ATTRIBUTE(noreturn) || \ HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_IAR_VERSION_CHECK(8,10,0) # define HEDLEY_NO_RETURN __attribute__((__noreturn__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) # define HEDLEY_NO_RETURN _Pragma("does_not_return") #elif \ HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_NO_RETURN __declspec(noreturn) #elif HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) # define HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") #elif HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) # define HEDLEY_NO_RETURN __attribute((noreturn)) #elif HEDLEY_PELLES_VERSION_CHECK(9,0,0) # define HEDLEY_NO_RETURN __declspec(noreturn) #else # define HEDLEY_NO_RETURN #endif #if defined(HEDLEY_NO_ESCAPE) # undef HEDLEY_NO_ESCAPE #endif #if HEDLEY_HAS_ATTRIBUTE(noescape) # define HEDLEY_NO_ESCAPE __attribute__((__noescape__)) #else # define HEDLEY_NO_ESCAPE #endif #if defined(HEDLEY_UNREACHABLE) # undef HEDLEY_UNREACHABLE #endif #if defined(HEDLEY_UNREACHABLE_RETURN) # undef HEDLEY_UNREACHABLE_RETURN #endif #if defined(HEDLEY_ASSUME) # undef HEDLEY_ASSUME #endif #if \ HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_ASSUME(expr) __assume(expr) #elif HEDLEY_HAS_BUILTIN(__builtin_assume) # define HEDLEY_ASSUME(expr) __builtin_assume(expr) #elif \ HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) # if defined(__cplusplus) # define HEDLEY_ASSUME(expr) std::_nassert(expr) # else # define HEDLEY_ASSUME(expr) _nassert(expr) # endif #endif #if \ (HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(HEDLEY_ARM_VERSION))) || \ HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_UNREACHABLE() __builtin_unreachable() #elif defined(HEDLEY_ASSUME) # define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0) #endif #if !defined(HEDLEY_ASSUME) # if defined(HEDLEY_UNREACHABLE) # define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (HEDLEY_UNREACHABLE(), 1))) # else # define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, expr) # endif #endif #if defined(HEDLEY_UNREACHABLE) # if \ HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) # define HEDLEY_UNREACHABLE_RETURN(value) return (HEDLEY_STATIC_CAST(void, HEDLEY_ASSUME(0)), (value)) # else # define HEDLEY_UNREACHABLE_RETURN(value) HEDLEY_UNREACHABLE() # endif #else # define HEDLEY_UNREACHABLE_RETURN(value) return (value) #endif #if !defined(HEDLEY_UNREACHABLE) # define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0) #endif HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wpedantic") # pragma clang diagnostic ignored "-Wpedantic" #endif #if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) # pragma clang diagnostic ignored "-Wc++98-compat-pedantic" #endif #if HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) # if defined(__clang__) # pragma clang diagnostic ignored "-Wvariadic-macros" # elif defined(HEDLEY_GCC_VERSION) # pragma GCC diagnostic ignored "-Wvariadic-macros" # endif #endif #if defined(HEDLEY_NON_NULL) # undef HEDLEY_NON_NULL #endif #if \ HEDLEY_HAS_ATTRIBUTE(nonnull) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) # define HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) #else # define HEDLEY_NON_NULL(...) #endif HEDLEY_DIAGNOSTIC_POP #if defined(HEDLEY_PRINTF_FORMAT) # undef HEDLEY_PRINTF_FORMAT #endif #if defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) # define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) #elif defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) # define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) #elif \ HEDLEY_HAS_ATTRIBUTE(format) || \ HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) #elif HEDLEY_PELLES_VERSION_CHECK(6,0,0) # define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) #else # define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) #endif #if defined(HEDLEY_CONSTEXPR) # undef HEDLEY_CONSTEXPR #endif #if defined(__cplusplus) # if __cplusplus >= 201103L # define HEDLEY_CONSTEXPR HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) # endif #endif #if !defined(HEDLEY_CONSTEXPR) # define HEDLEY_CONSTEXPR #endif #if defined(HEDLEY_PREDICT) # undef HEDLEY_PREDICT #endif #if defined(HEDLEY_LIKELY) # undef HEDLEY_LIKELY #endif #if defined(HEDLEY_UNLIKELY) # undef HEDLEY_UNLIKELY #endif #if defined(HEDLEY_UNPREDICTABLE) # undef HEDLEY_UNPREDICTABLE #endif #if HEDLEY_HAS_BUILTIN(__builtin_unpredictable) # define HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) #endif #if \ (HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_INTEL_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) # define HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) # define HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) # define HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) # define HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) #elif \ (HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(HEDLEY_INTEL_CL_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_PREDICT(expr, expected, probability) \ (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (HEDLEY_STATIC_CAST(void, expected), (expr))) # define HEDLEY_PREDICT_TRUE(expr, probability) \ (__extension__ ({ \ double hedley_probability_ = (probability); \ ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ })) # define HEDLEY_PREDICT_FALSE(expr, probability) \ (__extension__ ({ \ double hedley_probability_ = (probability); \ ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ })) # define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) # define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) #else # define HEDLEY_PREDICT(expr, expected, probability) (HEDLEY_STATIC_CAST(void, expected), (expr)) # define HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) # define HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) # define HEDLEY_LIKELY(expr) (!!(expr)) # define HEDLEY_UNLIKELY(expr) (!!(expr)) #endif #if !defined(HEDLEY_UNPREDICTABLE) # define HEDLEY_UNPREDICTABLE(expr) HEDLEY_PREDICT(expr, 1, 0.5) #endif #if defined(HEDLEY_MALLOC) # undef HEDLEY_MALLOC #endif #if \ HEDLEY_HAS_ATTRIBUTE(malloc) || \ HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_MALLOC __attribute__((__malloc__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) # define HEDLEY_MALLOC _Pragma("returns_new_memory") #elif \ HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_MALLOC __declspec(restrict) #else # define HEDLEY_MALLOC #endif #if defined(HEDLEY_PURE) # undef HEDLEY_PURE #endif #if \ HEDLEY_HAS_ATTRIBUTE(pure) || \ HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_PURE __attribute__((__pure__)) #elif HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) # define HEDLEY_PURE _Pragma("does_not_write_global_data") #elif defined(__cplusplus) && \ ( \ HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ ) # define HEDLEY_PURE _Pragma("FUNC_IS_PURE;") #else # define HEDLEY_PURE #endif #if defined(HEDLEY_CONST) # undef HEDLEY_CONST #endif #if \ HEDLEY_HAS_ATTRIBUTE(const) || \ HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_CONST __attribute__((__const__)) #elif \ HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) # define HEDLEY_CONST _Pragma("no_side_effect") #else # define HEDLEY_CONST HEDLEY_PURE #endif #if defined(HEDLEY_RESTRICT) # undef HEDLEY_RESTRICT #endif #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) # define HEDLEY_RESTRICT restrict #elif \ HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ defined(__clang__) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_RESTRICT __restrict #elif HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) # define HEDLEY_RESTRICT _Restrict #else # define HEDLEY_RESTRICT #endif #if defined(HEDLEY_INLINE) # undef HEDLEY_INLINE #endif #if \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ (defined(__cplusplus) && (__cplusplus >= 199711L)) # define HEDLEY_INLINE inline #elif \ defined(HEDLEY_GCC_VERSION) || \ HEDLEY_ARM_VERSION_CHECK(6,2,0) # define HEDLEY_INLINE __inline__ #elif \ HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_INLINE __inline #else # define HEDLEY_INLINE #endif #if defined(HEDLEY_ALWAYS_INLINE) # undef HEDLEY_ALWAYS_INLINE #endif #if \ HEDLEY_HAS_ATTRIBUTE(always_inline) || \ HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ HEDLEY_IAR_VERSION_CHECK(8,10,0) # define HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) HEDLEY_INLINE #elif \ HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_ALWAYS_INLINE __forceinline #elif defined(__cplusplus) && \ ( \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ ) # define HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") #else # define HEDLEY_ALWAYS_INLINE HEDLEY_INLINE #endif #if defined(HEDLEY_NEVER_INLINE) # undef HEDLEY_NEVER_INLINE #endif #if \ HEDLEY_HAS_ATTRIBUTE(noinline) || \ HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ HEDLEY_TI_VERSION_CHECK(15,12,0) || \ (HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ (HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ (HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ HEDLEY_IAR_VERSION_CHECK(8,10,0) # define HEDLEY_NEVER_INLINE __attribute__((__noinline__)) #elif \ HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_NEVER_INLINE __declspec(noinline) #elif HEDLEY_PGI_VERSION_CHECK(10,2,0) # define HEDLEY_NEVER_INLINE _Pragma("noinline") #elif HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) # define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_NEVER_INLINE _Pragma("inline=never") #elif HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) # define HEDLEY_NEVER_INLINE __attribute((noinline)) #elif HEDLEY_PELLES_VERSION_CHECK(9,0,0) # define HEDLEY_NEVER_INLINE __declspec(noinline) #else # define HEDLEY_NEVER_INLINE #endif #if defined(HEDLEY_PRIVATE) # undef HEDLEY_PRIVATE #endif #if defined(HEDLEY_PUBLIC) # undef HEDLEY_PUBLIC #endif #if defined(HEDLEY_IMPORT) # undef HEDLEY_IMPORT #endif #if defined(_WIN32) || defined(__CYGWIN__) # define HEDLEY_PRIVATE # define HEDLEY_PUBLIC __declspec(dllexport) # define HEDLEY_IMPORT __declspec(dllimport) #else # if \ HEDLEY_HAS_ATTRIBUTE(visibility) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ ( \ defined(__TI_EABI__) && \ ( \ (HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ ) \ ) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) # define HEDLEY_PUBLIC __attribute__((__visibility__("default"))) # else # define HEDLEY_PRIVATE # define HEDLEY_PUBLIC # endif # define HEDLEY_IMPORT extern #endif #if defined(HEDLEY_NO_THROW) # undef HEDLEY_NO_THROW #endif #if \ HEDLEY_HAS_ATTRIBUTE(nothrow) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_NO_THROW __attribute__((__nothrow__)) #elif \ HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) # define HEDLEY_NO_THROW __declspec(nothrow) #else # define HEDLEY_NO_THROW #endif #if defined(HEDLEY_FALL_THROUGH) # undef HEDLEY_FALL_THROUGH #endif #if defined(HEDLEY_INTEL_VERSION) # define HEDLEY_FALL_THROUGH #elif \ HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) #elif HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) # define HEDLEY_FALL_THROUGH HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) #elif HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) # define HEDLEY_FALL_THROUGH HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) #elif defined(__fallthrough) /* SAL */ # define HEDLEY_FALL_THROUGH __fallthrough #else # define HEDLEY_FALL_THROUGH #endif #if defined(HEDLEY_RETURNS_NON_NULL) # undef HEDLEY_RETURNS_NON_NULL #endif #if \ HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) #elif defined(_Ret_notnull_) /* SAL */ # define HEDLEY_RETURNS_NON_NULL _Ret_notnull_ #else # define HEDLEY_RETURNS_NON_NULL #endif #if defined(HEDLEY_ARRAY_PARAM) # undef HEDLEY_ARRAY_PARAM #endif #if \ defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ !defined(__STDC_NO_VLA__) && \ !defined(__cplusplus) && \ !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_TINYC_VERSION) # define HEDLEY_ARRAY_PARAM(name) (name) #else # define HEDLEY_ARRAY_PARAM(name) #endif #if defined(HEDLEY_IS_CONSTANT) # undef HEDLEY_IS_CONSTANT #endif #if defined(HEDLEY_REQUIRE_CONSTEXPR) # undef HEDLEY_REQUIRE_CONSTEXPR #endif /* HEDLEY_IS_CONSTEXPR_ is for HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ #if defined(HEDLEY_IS_CONSTEXPR_) # undef HEDLEY_IS_CONSTEXPR_ #endif #if \ HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) #endif #if !defined(__cplusplus) # if \ HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,24) # if defined(__INTPTR_TYPE__) # define HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) # else # include # define HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) # endif # elif \ ( \ defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ !defined(HEDLEY_SUNPRO_VERSION) && \ !defined(HEDLEY_PGI_VERSION) && \ !defined(HEDLEY_IAR_VERSION)) || \ (HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(HEDLEY_IAR_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ HEDLEY_ARM_VERSION_CHECK(5,3,0) # if defined(__INTPTR_TYPE__) # define HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) # else # include # define HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) # endif # elif \ defined(HEDLEY_GCC_VERSION) || \ defined(HEDLEY_INTEL_VERSION) || \ defined(HEDLEY_TINYC_VERSION) || \ defined(HEDLEY_TI_ARMCL_VERSION) || \ HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ defined(HEDLEY_TI_CL2000_VERSION) || \ defined(HEDLEY_TI_CL6X_VERSION) || \ defined(HEDLEY_TI_CL7X_VERSION) || \ defined(HEDLEY_TI_CLPRU_VERSION) || \ defined(__clang__) # define HEDLEY_IS_CONSTEXPR_(expr) ( \ sizeof(void) != \ sizeof(*( \ 1 ? \ ((void*) ((expr) * 0L) ) : \ ((struct { char v[sizeof(void) * 2]; } *) 1) \ ) \ ) \ ) # endif #endif #if defined(HEDLEY_IS_CONSTEXPR_) # if !defined(HEDLEY_IS_CONSTANT) # define HEDLEY_IS_CONSTANT(expr) HEDLEY_IS_CONSTEXPR_(expr) # endif # define HEDLEY_REQUIRE_CONSTEXPR(expr) (HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) #else # if !defined(HEDLEY_IS_CONSTANT) # define HEDLEY_IS_CONSTANT(expr) (0) # endif # define HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) #endif #if defined(HEDLEY_BEGIN_C_DECLS) # undef HEDLEY_BEGIN_C_DECLS #endif #if defined(HEDLEY_END_C_DECLS) # undef HEDLEY_END_C_DECLS #endif #if defined(HEDLEY_C_DECL) # undef HEDLEY_C_DECL #endif #if defined(__cplusplus) # define HEDLEY_BEGIN_C_DECLS extern "C" { # define HEDLEY_END_C_DECLS } # define HEDLEY_C_DECL extern "C" #else # define HEDLEY_BEGIN_C_DECLS # define HEDLEY_END_C_DECLS # define HEDLEY_C_DECL #endif #if defined(HEDLEY_STATIC_ASSERT) # undef HEDLEY_STATIC_ASSERT #endif #if \ !defined(__cplusplus) && ( \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ (HEDLEY_HAS_FEATURE(c_static_assert) && !defined(HEDLEY_INTEL_CL_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ defined(_Static_assert) \ ) # define HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) #elif \ (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_STATIC_ASSERT(expr, message) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) #else # define HEDLEY_STATIC_ASSERT(expr, message) #endif #if defined(HEDLEY_NULL) # undef HEDLEY_NULL #endif #if defined(__cplusplus) # if __cplusplus >= 201103L # define HEDLEY_NULL HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) # elif defined(NULL) # define HEDLEY_NULL NULL # else # define HEDLEY_NULL HEDLEY_STATIC_CAST(void*, 0) # endif #elif defined(NULL) # define HEDLEY_NULL NULL #else # define HEDLEY_NULL ((void*) 0) #endif #if defined(HEDLEY_MESSAGE) # undef HEDLEY_MESSAGE #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") # define HEDLEY_MESSAGE(msg) \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ HEDLEY_PRAGMA(message msg) \ HEDLEY_DIAGNOSTIC_POP #elif \ HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message msg) #elif HEDLEY_CRAY_VERSION_CHECK(5,0,0) # define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(_CRI message msg) #elif HEDLEY_IAR_VERSION_CHECK(8,0,0) # define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg)) #elif HEDLEY_PELLES_VERSION_CHECK(2,0,0) # define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg)) #else # define HEDLEY_MESSAGE(msg) #endif #if defined(HEDLEY_WARNING) # undef HEDLEY_WARNING #endif #if HEDLEY_HAS_WARNING("-Wunknown-pragmas") # define HEDLEY_WARNING(msg) \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ HEDLEY_PRAGMA(clang warning msg) \ HEDLEY_DIAGNOSTIC_POP #elif \ HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) # define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(GCC warning msg) #elif \ HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(message(msg)) #else # define HEDLEY_WARNING(msg) HEDLEY_MESSAGE(msg) #endif #if defined(HEDLEY_REQUIRE) # undef HEDLEY_REQUIRE #endif #if defined(HEDLEY_REQUIRE_MSG) # undef HEDLEY_REQUIRE_MSG #endif #if HEDLEY_HAS_ATTRIBUTE(diagnose_if) # if HEDLEY_HAS_WARNING("-Wgcc-compat") # define HEDLEY_REQUIRE(expr) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ __attribute__((diagnose_if(!(expr), #expr, "error"))) \ HEDLEY_DIAGNOSTIC_POP # define HEDLEY_REQUIRE_MSG(expr,msg) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ __attribute__((diagnose_if(!(expr), msg, "error"))) \ HEDLEY_DIAGNOSTIC_POP # else # define HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) # define HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) # endif #else # define HEDLEY_REQUIRE(expr) # define HEDLEY_REQUIRE_MSG(expr,msg) #endif #if defined(HEDLEY_FLAGS) # undef HEDLEY_FLAGS #endif #if HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) # define HEDLEY_FLAGS __attribute__((__flag_enum__)) #else # define HEDLEY_FLAGS #endif #if defined(HEDLEY_FLAGS_CAST) # undef HEDLEY_FLAGS_CAST #endif #if HEDLEY_INTEL_VERSION_CHECK(19,0,0) # define HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("warning(disable:188)") \ ((T) (expr)); \ HEDLEY_DIAGNOSTIC_POP \ })) #else # define HEDLEY_FLAGS_CAST(T, expr) HEDLEY_STATIC_CAST(T, expr) #endif #if defined(HEDLEY_EMPTY_BASES) # undef HEDLEY_EMPTY_BASES #endif #if \ (HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) # define HEDLEY_EMPTY_BASES __declspec(empty_bases) #else # define HEDLEY_EMPTY_BASES #endif /* Remaining macros are deprecated. */ #if defined(HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) # undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK #endif #if defined(__clang__) # define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) #else # define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch) #endif #if defined(HEDLEY_CLANG_HAS_ATTRIBUTE) # undef HEDLEY_CLANG_HAS_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) HEDLEY_HAS_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) # undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) HEDLEY_HAS_CPP_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_BUILTIN) # undef HEDLEY_CLANG_HAS_BUILTIN #endif #define HEDLEY_CLANG_HAS_BUILTIN(builtin) HEDLEY_HAS_BUILTIN(builtin) #if defined(HEDLEY_CLANG_HAS_FEATURE) # undef HEDLEY_CLANG_HAS_FEATURE #endif #define HEDLEY_CLANG_HAS_FEATURE(feature) HEDLEY_HAS_FEATURE(feature) #if defined(HEDLEY_CLANG_HAS_EXTENSION) # undef HEDLEY_CLANG_HAS_EXTENSION #endif #define HEDLEY_CLANG_HAS_EXTENSION(extension) HEDLEY_HAS_EXTENSION(extension) #if defined(HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) # undef HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE #endif #define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) #if defined(HEDLEY_CLANG_HAS_WARNING) # undef HEDLEY_CLANG_HAS_WARNING #endif #define HEDLEY_CLANG_HAS_WARNING(warning) HEDLEY_HAS_WARNING(warning) #endif /* !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < X) */ /* :: End hedley.h :: */ #define SIMDE_VERSION_MAJOR 0 #define SIMDE_VERSION_MINOR 7 #define SIMDE_VERSION_MICRO 6 #define SIMDE_VERSION HEDLEY_VERSION_ENCODE(SIMDE_VERSION_MAJOR, SIMDE_VERSION_MINOR, SIMDE_VERSION_MICRO) // Also update meson.build in the root directory of the repository #include #include /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-detect-clang.h :: */ /* Detect Clang Version * Created by Evan Nemerson * * To the extent possible under law, the author(s) have dedicated all * copyright and related and neighboring rights to this software to * the public domain worldwide. This software is distributed without * any warranty. * * For details, see . * SPDX-License-Identifier: CC0-1.0 */ /* This file was originally part of SIMDe * (). You're free to do with it as * you please, but I do have a few small requests: * * * If you make improvements, please submit them back to SIMDe * (at ) so others can * benefit from them. * * Please keep a link to SIMDe intact so people know where to submit * improvements. * * If you expose it publicly, please change the SIMDE_ prefix to * something specific to your project. * * The version numbers clang exposes (in the ___clang_major__, * __clang_minor__, and __clang_patchlevel__ macros) are unreliable. * Vendors such as Apple will define these values to their version * numbers; for example, "Apple Clang 4.0" is really clang 3.1, but * __clang_major__ and __clang_minor__ are defined to 4 and 0 * respectively, instead of 3 and 1. * * The solution is *usually* to use clang's feature detection macros * () * to determine if the feature you're interested in is available. This * generally works well, and it should probably be the first thing you * try. Unfortunately, it's not possible to check for everything. In * particular, compiler bugs. * * This file just uses the feature checking macros to detect features * added in specific versions of clang to identify which version of * clang the compiler is based on. * * Right now it only goes back to 3.6, but I'm happy to accept patches * to go back further. And, of course, newer versions are welcome if * they're not already present, and if you find a way to detect a point * release that would be great, too! */ #if !defined(SIMDE_DETECT_CLANG_H) #define SIMDE_DETECT_CLANG_H 1 /* Attempt to detect the upstream clang version number. I usually only * worry about major version numbers (at least for 4.0+), but if you * need more resolution I'm happy to accept patches that are able to * detect minor versions as well. That said, you'll probably have a * hard time with detection since AFAIK most minor releases don't add * anything we can detect. Updated based on * https://github.com/google/highway/blob/438c705a295176b96a50336527bb3e7ea365ffac/hwy/detect_compiler_arch.h#L73 * - would welcome patches/updates there as well. */ #if defined(__clang__) && !defined(SIMDE_DETECT_CLANG_VERSION) # if __has_attribute(nouwtable) // no new warnings in 16.0 # define SIMDE_DETECT_CLANG_VERSION 160000 # elif __has_warning("-Warray-parameter") # define SIMDE_DETECT_CLANG_VERSION 150000 # elif __has_warning("-Wbitwise-instead-of-logical") # define SIMDE_DETECT_CLANG_VERSION 140000 # elif __has_warning("-Wwaix-compat") # define SIMDE_DETECT_CLANG_VERSION 130000 # elif __has_warning("-Wformat-insufficient-args") # define SIMDE_DETECT_CLANG_VERSION 120000 # elif __has_warning("-Wimplicit-const-int-float-conversion") # define SIMDE_DETECT_CLANG_VERSION 110000 # elif __has_warning("-Wmisleading-indentation") # define SIMDE_DETECT_CLANG_VERSION 100000 # elif defined(__FILE_NAME__) # define SIMDE_DETECT_CLANG_VERSION 90000 # elif __has_warning("-Wextra-semi-stmt") || __has_builtin(__builtin_rotateleft32) # define SIMDE_DETECT_CLANG_VERSION 80000 // For reasons unknown, XCode 10.3 (Apple LLVM version 10.0.1) is apparently // based on Clang 7, but does not support the warning we test. // See https://en.wikipedia.org/wiki/Xcode#Toolchain_versions and // https://trac.macports.org/wiki/XcodeVersionInfo. # elif __has_warning("-Wc++98-compat-extra-semi") || \ (defined(__apple_build_version__) && __apple_build_version__ >= 10010000) # define SIMDE_DETECT_CLANG_VERSION 70000 # elif __has_warning("-Wpragma-pack") # define SIMDE_DETECT_CLANG_VERSION 60000 # elif __has_warning("-Wbitfield-enum-conversion") # define SIMDE_DETECT_CLANG_VERSION 50000 # elif __has_attribute(diagnose_if) # define SIMDE_DETECT_CLANG_VERSION 40000 # elif __has_warning("-Wcomma") # define SIMDE_DETECT_CLANG_VERSION 39000 # elif __has_warning("-Wdouble-promotion") # define SIMDE_DETECT_CLANG_VERSION 38000 # elif __has_warning("-Wshift-negative-value") # define SIMDE_DETECT_CLANG_VERSION 37000 # elif __has_warning("-Wambiguous-ellipsis") # define SIMDE_DETECT_CLANG_VERSION 36000 # else # define SIMDE_DETECT_CLANG_VERSION 1 # endif #endif /* defined(__clang__) && !defined(SIMDE_DETECT_CLANG_VERSION) */ /* The SIMDE_DETECT_CLANG_VERSION_CHECK macro is pretty * straightforward; it returns true if the compiler is a derivative * of clang >= the specified version. * * Since this file is often (primarily?) useful for working around bugs * it is also helpful to have a macro which returns true if only if the * compiler is a version of clang *older* than the specified version to * make it a bit easier to ifdef regions to add code for older versions, * such as pragmas to disable a specific warning. */ #if defined(SIMDE_DETECT_CLANG_VERSION) # define SIMDE_DETECT_CLANG_VERSION_CHECK(major, minor, revision) (SIMDE_DETECT_CLANG_VERSION >= ((major * 10000) + (minor * 1000) + (revision))) # define SIMDE_DETECT_CLANG_VERSION_NOT(major, minor, revision) (SIMDE_DETECT_CLANG_VERSION < ((major * 10000) + (minor * 1000) + (revision))) #else # define SIMDE_DETECT_CLANG_VERSION_CHECK(major, minor, revision) (0) # define SIMDE_DETECT_CLANG_VERSION_NOT(major, minor, revision) (0) #endif #endif /* !defined(SIMDE_DETECT_CLANG_H) */ /* :: End simde-detect-clang.h :: */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-arch.h :: */ /* Architecture detection * Created by Evan Nemerson * * To the extent possible under law, the authors have waived all * copyright and related or neighboring rights to this code. For * details, see the Creative Commons Zero 1.0 Universal license at * * * SPDX-License-Identifier: CC0-1.0 * * Different compilers define different preprocessor macros for the * same architecture. This is an attempt to provide a single * interface which is usable on any compiler. * * In general, a macro named SIMDE_ARCH_* is defined for each * architecture the CPU supports. When there are multiple possible * versions, we try to define the macro to the target version. For * example, if you want to check for i586+, you could do something * like: * * #if defined(SIMDE_ARCH_X86) && (SIMDE_ARCH_X86 >= 5) * ... * #endif * * You could also just check that SIMDE_ARCH_X86 >= 5 without checking * if it's defined first, but some compilers may emit a warning about * an undefined macro being used (e.g., GCC with -Wundef). * * This was originally created for SIMDe * (hence the prefix), but this * header has no dependencies and may be used anywhere. It is * originally based on information from * , though it * has been enhanced with additional information. * * If you improve this file, or find a bug, please file the issue at * . If you copy this into * your project, even if you change the prefix, please keep the links * to SIMDe intact so others know where to report issues, submit * enhancements, and find the latest version. */ #if !defined(SIMDE_ARCH_H) #define SIMDE_ARCH_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* Alpha */ #if defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA) # if defined(__alpha_ev6__) # define SIMDE_ARCH_ALPHA 6 # elif defined(__alpha_ev5__) # define SIMDE_ARCH_ALPHA 5 # elif defined(__alpha_ev4__) # define SIMDE_ARCH_ALPHA 4 # else # define SIMDE_ARCH_ALPHA 1 # endif #endif #if defined(SIMDE_ARCH_ALPHA) # define SIMDE_ARCH_ALPHA_CHECK(version) ((version) <= SIMDE_ARCH_ALPHA) #else # define SIMDE_ARCH_ALPHA_CHECK(version) (0) #endif /* Atmel AVR */ #if defined(__AVR_ARCH__) # define SIMDE_ARCH_AVR __AVR_ARCH__ #endif /* AMD64 / x86_64 */ #if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64) # if !defined(_M_ARM64EC) # define SIMDE_ARCH_AMD64 1000 # endif #endif /* ARM */ #if defined(__ARM_ARCH) # if __ARM_ARCH > 100 # define SIMDE_ARCH_ARM (__ARM_ARCH) # else # define SIMDE_ARCH_ARM (__ARM_ARCH * 100) # endif #elif defined(_M_ARM) # if _M_ARM > 100 # define SIMDE_ARCH_ARM (_M_ARM) # else # define SIMDE_ARCH_ARM (_M_ARM * 100) # endif #elif defined(_M_ARM64) || defined(_M_ARM64EC) # define SIMDE_ARCH_ARM 800 #elif defined(__arm__) || defined(__thumb__) || defined(__TARGET_ARCH_ARM) || defined(_ARM) || defined(_M_ARM) || defined(_M_ARM) # define SIMDE_ARCH_ARM 1 #endif #if defined(SIMDE_ARCH_ARM) # define SIMDE_ARCH_ARM_CHECK(major, minor) (((major * 100) + (minor)) <= SIMDE_ARCH_ARM) #else # define SIMDE_ARCH_ARM_CHECK(major, minor) (0) #endif /* AArch64 */ #if defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC) # define SIMDE_ARCH_AARCH64 1000 #endif #if defined(SIMDE_ARCH_AARCH64) # define SIMDE_ARCH_AARCH64_CHECK(version) ((version) <= SIMDE_ARCH_AARCH64) #else # define SIMDE_ARCH_AARCH64_CHECK(version) (0) #endif /* ARM SIMD ISA extensions */ #if defined(__ARM_NEON) || defined(SIMDE_ARCH_AARCH64) # if defined(SIMDE_ARCH_AARCH64) # define SIMDE_ARCH_ARM_NEON SIMDE_ARCH_AARCH64 # elif defined(SIMDE_ARCH_ARM) # define SIMDE_ARCH_ARM_NEON SIMDE_ARCH_ARM # endif #endif #if defined(__ARM_FEATURE_SVE) # define SIMDE_ARCH_ARM_SVE #endif /* Blackfin */ #if defined(__bfin) || defined(__BFIN__) || defined(__bfin__) # define SIMDE_ARCH_BLACKFIN 1 #endif /* CRIS */ #if defined(__CRIS_arch_version) # define SIMDE_ARCH_CRIS __CRIS_arch_version #elif defined(__cris__) || defined(__cris) || defined(__CRIS) || defined(__CRIS__) # define SIMDE_ARCH_CRIS 1 #endif /* Convex */ #if defined(__convex_c38__) # define SIMDE_ARCH_CONVEX 38 #elif defined(__convex_c34__) # define SIMDE_ARCH_CONVEX 34 #elif defined(__convex_c32__) # define SIMDE_ARCH_CONVEX 32 #elif defined(__convex_c2__) # define SIMDE_ARCH_CONVEX 2 #elif defined(__convex__) # define SIMDE_ARCH_CONVEX 1 #endif #if defined(SIMDE_ARCH_CONVEX) # define SIMDE_ARCH_CONVEX_CHECK(version) ((version) <= SIMDE_ARCH_CONVEX) #else # define SIMDE_ARCH_CONVEX_CHECK(version) (0) #endif /* Adapteva Epiphany */ #if defined(__epiphany__) # define SIMDE_ARCH_EPIPHANY 1 #endif /* Fujitsu FR-V */ #if defined(__frv__) # define SIMDE_ARCH_FRV 1 #endif /* H8/300 */ #if defined(__H8300__) # define SIMDE_ARCH_H8300 #endif /* Elbrus (8S, 8SV and successors) */ #if defined(__e2k__) # define SIMDE_ARCH_E2K #endif /* HP/PA / PA-RISC */ #if defined(__PA8000__) || defined(__HPPA20__) || defined(__RISC2_0__) || defined(_PA_RISC2_0) # define SIMDE_ARCH_HPPA 20 #elif defined(__PA7100__) || defined(__HPPA11__) || defined(_PA_RISC1_1) # define SIMDE_ARCH_HPPA 11 #elif defined(_PA_RISC1_0) # define SIMDE_ARCH_HPPA 10 #elif defined(__hppa__) || defined(__HPPA__) || defined(__hppa) # define SIMDE_ARCH_HPPA 1 #endif #if defined(SIMDE_ARCH_HPPA) # define SIMDE_ARCH_HPPA_CHECK(version) ((version) <= SIMDE_ARCH_HPPA) #else # define SIMDE_ARCH_HPPA_CHECK(version) (0) #endif /* x86 */ #if defined(_M_IX86) # define SIMDE_ARCH_X86 (_M_IX86 / 100) #elif defined(__I86__) # define SIMDE_ARCH_X86 __I86__ #elif defined(i686) || defined(__i686) || defined(__i686__) # define SIMDE_ARCH_X86 6 #elif defined(i586) || defined(__i586) || defined(__i586__) # define SIMDE_ARCH_X86 5 #elif defined(i486) || defined(__i486) || defined(__i486__) # define SIMDE_ARCH_X86 4 #elif defined(i386) || defined(__i386) || defined(__i386__) # define SIMDE_ARCH_X86 3 #elif defined(_X86_) || defined(__X86__) || defined(__THW_INTEL__) # define SIMDE_ARCH_X86 3 #endif #if defined(SIMDE_ARCH_X86) # define SIMDE_ARCH_X86_CHECK(version) ((version) <= SIMDE_ARCH_X86) #else # define SIMDE_ARCH_X86_CHECK(version) (0) #endif /* SIMD ISA extensions for x86/x86_64 and Elbrus */ #if defined(SIMDE_ARCH_X86) || defined(SIMDE_ARCH_AMD64) || defined(SIMDE_ARCH_E2K) # if defined(_M_IX86_FP) # define SIMDE_ARCH_X86_MMX # if (_M_IX86_FP >= 1) # define SIMDE_ARCH_X86_SSE 1 # endif # if (_M_IX86_FP >= 2) # define SIMDE_ARCH_X86_SSE2 1 # endif # elif defined(_M_X64) # define SIMDE_ARCH_X86_SSE 1 # define SIMDE_ARCH_X86_SSE2 1 # else # if defined(__MMX__) # define SIMDE_ARCH_X86_MMX 1 # endif # if defined(__SSE__) # define SIMDE_ARCH_X86_SSE 1 # endif # if defined(__SSE2__) # define SIMDE_ARCH_X86_SSE2 1 # endif # endif # if defined(__SSE3__) # define SIMDE_ARCH_X86_SSE3 1 # endif # if defined(__SSSE3__) # define SIMDE_ARCH_X86_SSSE3 1 # endif # if defined(__SSE4_1__) # define SIMDE_ARCH_X86_SSE4_1 1 # endif # if defined(__SSE4_2__) # define SIMDE_ARCH_X86_SSE4_2 1 # endif # if defined(__XOP__) # define SIMDE_ARCH_X86_XOP 1 # endif # if defined(__AVX__) # define SIMDE_ARCH_X86_AVX 1 # if !defined(SIMDE_ARCH_X86_SSE3) # define SIMDE_ARCH_X86_SSE3 1 # endif # if !defined(SIMDE_ARCH_X86_SSE4_1) # define SIMDE_ARCH_X86_SSE4_1 1 # endif # if !defined(SIMDE_ARCH_X86_SSE4_1) # define SIMDE_ARCH_X86_SSE4_2 1 # endif # endif # if defined(__AVX2__) # define SIMDE_ARCH_X86_AVX2 1 # if defined(_MSC_VER) # define SIMDE_ARCH_X86_FMA 1 # endif # endif # if defined(__FMA__) # define SIMDE_ARCH_X86_FMA 1 # if !defined(SIMDE_ARCH_X86_AVX) # define SIMDE_ARCH_X86_AVX 1 # endif # endif # if defined(__AVX512VP2INTERSECT__) # define SIMDE_ARCH_X86_AVX512VP2INTERSECT 1 # endif # if defined(__AVX512BITALG__) # define SIMDE_ARCH_X86_AVX512BITALG 1 # endif # if defined(__AVX512VPOPCNTDQ__) # define SIMDE_ARCH_X86_AVX512VPOPCNTDQ 1 # endif # if defined(__AVX512VBMI__) # define SIMDE_ARCH_X86_AVX512VBMI 1 # endif # if defined(__AVX512VBMI2__) # define SIMDE_ARCH_X86_AVX512VBMI2 1 # endif # if defined(__AVX512VNNI__) # define SIMDE_ARCH_X86_AVX512VNNI 1 # endif # if defined(__AVX5124VNNIW__) # define SIMDE_ARCH_X86_AVX5124VNNIW 1 # endif # if defined(__AVX512BW__) # define SIMDE_ARCH_X86_AVX512BW 1 # endif # if defined(__AVX512BF16__) # define SIMDE_ARCH_X86_AVX512BF16 1 # endif # if defined(__AVX512CD__) # define SIMDE_ARCH_X86_AVX512CD 1 # endif # if defined(__AVX512DQ__) # define SIMDE_ARCH_X86_AVX512DQ 1 # endif # if defined(__AVX512F__) # define SIMDE_ARCH_X86_AVX512F 1 # endif # if defined(__AVX512VL__) # define SIMDE_ARCH_X86_AVX512VL 1 # endif # if defined(__GFNI__) # define SIMDE_ARCH_X86_GFNI 1 # endif # if defined(__PCLMUL__) # define SIMDE_ARCH_X86_PCLMUL 1 # endif # if defined(__VPCLMULQDQ__) # define SIMDE_ARCH_X86_VPCLMULQDQ 1 # endif # if defined(__F16C__) || (defined(HEDLEY_MSVC_VERSION) && HEDLEY_MSVC_VERSION_CHECK(19,30,0) && defined(SIMDE_ARCH_X86_AVX2) ) # define SIMDE_ARCH_X86_F16C 1 # endif #endif /* Itanium */ #if defined(__ia64__) || defined(_IA64) || defined(__IA64__) || defined(__ia64) || defined(_M_IA64) || defined(__itanium__) # define SIMDE_ARCH_IA64 1 #endif /* Renesas M32R */ #if defined(__m32r__) || defined(__M32R__) # define SIMDE_ARCH_M32R #endif /* Motorola 68000 */ #if defined(__mc68060__) || defined(__MC68060__) # define SIMDE_ARCH_M68K 68060 #elif defined(__mc68040__) || defined(__MC68040__) # define SIMDE_ARCH_M68K 68040 #elif defined(__mc68030__) || defined(__MC68030__) # define SIMDE_ARCH_M68K 68030 #elif defined(__mc68020__) || defined(__MC68020__) # define SIMDE_ARCH_M68K 68020 #elif defined(__mc68010__) || defined(__MC68010__) # define SIMDE_ARCH_M68K 68010 #elif defined(__mc68000__) || defined(__MC68000__) # define SIMDE_ARCH_M68K 68000 #endif #if defined(SIMDE_ARCH_M68K) # define SIMDE_ARCH_M68K_CHECK(version) ((version) <= SIMDE_ARCH_M68K) #else # define SIMDE_ARCH_M68K_CHECK(version) (0) #endif /* Xilinx MicroBlaze */ #if defined(__MICROBLAZE__) || defined(__microblaze__) # define SIMDE_ARCH_MICROBLAZE #endif /* MIPS */ #if defined(_MIPS_ISA_MIPS64R2) # define SIMDE_ARCH_MIPS 642 #elif defined(_MIPS_ISA_MIPS64) # define SIMDE_ARCH_MIPS 640 #elif defined(_MIPS_ISA_MIPS32R2) # define SIMDE_ARCH_MIPS 322 #elif defined(_MIPS_ISA_MIPS32) # define SIMDE_ARCH_MIPS 320 #elif defined(_MIPS_ISA_MIPS4) # define SIMDE_ARCH_MIPS 4 #elif defined(_MIPS_ISA_MIPS3) # define SIMDE_ARCH_MIPS 3 #elif defined(_MIPS_ISA_MIPS2) # define SIMDE_ARCH_MIPS 2 #elif defined(_MIPS_ISA_MIPS1) # define SIMDE_ARCH_MIPS 1 #elif defined(_MIPS_ISA_MIPS) || defined(__mips) || defined(__MIPS__) # define SIMDE_ARCH_MIPS 1 #endif #if defined(SIMDE_ARCH_MIPS) # define SIMDE_ARCH_MIPS_CHECK(version) ((version) <= SIMDE_ARCH_MIPS) #else # define SIMDE_ARCH_MIPS_CHECK(version) (0) #endif #if defined(__mips_loongson_mmi) # define SIMDE_ARCH_MIPS_LOONGSON_MMI 1 #endif #if defined(__mips_msa) # define SIMDE_ARCH_MIPS_MSA 1 #endif /* Matsushita MN10300 */ #if defined(__MN10300__) || defined(__mn10300__) # define SIMDE_ARCH_MN10300 1 #endif /* POWER */ #if defined(_M_PPC) # define SIMDE_ARCH_POWER _M_PPC #elif defined(_ARCH_PWR9) # define SIMDE_ARCH_POWER 900 #elif defined(_ARCH_PWR8) # define SIMDE_ARCH_POWER 800 #elif defined(_ARCH_PWR7) # define SIMDE_ARCH_POWER 700 #elif defined(_ARCH_PWR6) # define SIMDE_ARCH_POWER 600 #elif defined(_ARCH_PWR5) # define SIMDE_ARCH_POWER 500 #elif defined(_ARCH_PWR4) # define SIMDE_ARCH_POWER 400 #elif defined(_ARCH_440) || defined(__ppc440__) # define SIMDE_ARCH_POWER 440 #elif defined(_ARCH_450) || defined(__ppc450__) # define SIMDE_ARCH_POWER 450 #elif defined(_ARCH_601) || defined(__ppc601__) # define SIMDE_ARCH_POWER 601 #elif defined(_ARCH_603) || defined(__ppc603__) # define SIMDE_ARCH_POWER 603 #elif defined(_ARCH_604) || defined(__ppc604__) # define SIMDE_ARCH_POWER 604 #elif defined(_ARCH_605) || defined(__ppc605__) # define SIMDE_ARCH_POWER 605 #elif defined(_ARCH_620) || defined(__ppc620__) # define SIMDE_ARCH_POWER 620 #elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) || defined(__ppc__) || defined(__PPC__) || defined(_ARCH_PPC) || defined(__ppc) # define SIMDE_ARCH_POWER 1 #endif #if defined(SIMDE_ARCH_POWER) #define SIMDE_ARCH_POWER_CHECK(version) ((version) <= SIMDE_ARCH_POWER) #else #define SIMDE_ARCH_POWER_CHECK(version) (0) #endif #if defined(__ALTIVEC__) # define SIMDE_ARCH_POWER_ALTIVEC SIMDE_ARCH_POWER #define SIMDE_ARCH_POWER_ALTIVEC_CHECK(version) ((version) <= SIMDE_ARCH_POWER) #else #define SIMDE_ARCH_POWER_ALTIVEC_CHECK(version) (0) #endif /* SPARC */ #if defined(__sparc_v9__) || defined(__sparcv9) # define SIMDE_ARCH_SPARC 9 #elif defined(__sparc_v8__) || defined(__sparcv8) # define SIMDE_ARCH_SPARC 8 #elif defined(__sparc_v7__) || defined(__sparcv7) # define SIMDE_ARCH_SPARC 7 #elif defined(__sparc_v6__) || defined(__sparcv6) # define SIMDE_ARCH_SPARC 6 #elif defined(__sparc_v5__) || defined(__sparcv5) # define SIMDE_ARCH_SPARC 5 #elif defined(__sparc_v4__) || defined(__sparcv4) # define SIMDE_ARCH_SPARC 4 #elif defined(__sparc_v3__) || defined(__sparcv3) # define SIMDE_ARCH_SPARC 3 #elif defined(__sparc_v2__) || defined(__sparcv2) # define SIMDE_ARCH_SPARC 2 #elif defined(__sparc_v1__) || defined(__sparcv1) # define SIMDE_ARCH_SPARC 1 #elif defined(__sparc__) || defined(__sparc) # define SIMDE_ARCH_SPARC 1 #endif #if defined(SIMDE_ARCH_SPARC) #define SIMDE_ARCH_SPARC_CHECK(version) ((version) <= SIMDE_ARCH_SPARC) #else #define SIMDE_ARCH_SPARC_CHECK(version) (0) #endif /* SuperH */ #if defined(__sh5__) || defined(__SH5__) # define SIMDE_ARCH_SUPERH 5 #elif defined(__sh4__) || defined(__SH4__) # define SIMDE_ARCH_SUPERH 4 #elif defined(__sh3__) || defined(__SH3__) # define SIMDE_ARCH_SUPERH 3 #elif defined(__sh2__) || defined(__SH2__) # define SIMDE_ARCH_SUPERH 2 #elif defined(__sh1__) || defined(__SH1__) # define SIMDE_ARCH_SUPERH 1 #elif defined(__sh__) || defined(__SH__) # define SIMDE_ARCH_SUPERH 1 #endif /* IBM System z */ #if defined(__370__) || defined(__THW_370__) || defined(__s390__) || defined(__s390x__) || defined(__zarch__) || defined(__SYSC_ZARCH__) # define SIMDE_ARCH_ZARCH __ARCH__ #endif #if defined(SIMDE_ARCH_ZARCH) #define SIMDE_ARCH_ZARCH_CHECK(version) ((version) <= SIMDE_ARCH_ZARCH) #else #define SIMDE_ARCH_ZARCH_CHECK(version) (0) #endif #if defined(SIMDE_ARCH_ZARCH) && defined(__VEC__) #define SIMDE_ARCH_ZARCH_ZVECTOR SIMDE_ARCH_ZARCH #endif /* TMS320 DSP */ #if defined(_TMS320C6740) || defined(__TMS320C6740__) # define SIMDE_ARCH_TMS320 6740 #elif defined(_TMS320C6700_PLUS) || defined(__TMS320C6700_PLUS__) # define SIMDE_ARCH_TMS320 6701 #elif defined(_TMS320C6700) || defined(__TMS320C6700__) # define SIMDE_ARCH_TMS320 6700 #elif defined(_TMS320C6600) || defined(__TMS320C6600__) # define SIMDE_ARCH_TMS320 6600 #elif defined(_TMS320C6400_PLUS) || defined(__TMS320C6400_PLUS__) # define SIMDE_ARCH_TMS320 6401 #elif defined(_TMS320C6400) || defined(__TMS320C6400__) # define SIMDE_ARCH_TMS320 6400 #elif defined(_TMS320C6200) || defined(__TMS320C6200__) # define SIMDE_ARCH_TMS320 6200 #elif defined(_TMS320C55X) || defined(__TMS320C55X__) # define SIMDE_ARCH_TMS320 550 #elif defined(_TMS320C54X) || defined(__TMS320C54X__) # define SIMDE_ARCH_TMS320 540 #elif defined(_TMS320C28X) || defined(__TMS320C28X__) # define SIMDE_ARCH_TMS320 280 #endif #if defined(SIMDE_ARCH_TMS320) #define SIMDE_ARCH_TMS320_CHECK(version) ((version) <= SIMDE_ARCH_TMS320) #else #define SIMDE_ARCH_TMS320_CHECK(version) (0) #endif /* WebAssembly */ #if defined(__wasm__) # define SIMDE_ARCH_WASM 1 #endif #if defined(SIMDE_ARCH_WASM) && defined(__wasm_simd128__) # define SIMDE_ARCH_WASM_SIMD128 #endif /* Xtensa */ #if defined(__xtensa__) || defined(__XTENSA__) # define SIMDE_ARCH_XTENSA 1 #endif /* Availability of 16-bit floating-point arithmetic intrinsics */ #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC) # define SIMDE_ARCH_ARM_NEON_FP16 #endif /* LoongArch */ #if defined(__loongarch32) # define SIMDE_ARCH_LOONGARCH 1 #elif defined(__loongarch64) # define SIMDE_ARCH_LOONGARCH 2 #endif /* LSX: LoongArch 128-bits SIMD extension */ #if defined(__loongarch_sx) # define SIMDE_ARCH_LOONGARCH_LSX 1 #endif /* LASX: LoongArch 256-bits SIMD extension */ #if defined(__loongarch_asx) # define SIMDE_ARCH_LOONGARCH_LASX 2 #endif #endif /* !defined(SIMDE_ARCH_H) */ /* :: End simde-arch.h :: */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-features.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2020 Evan Nemerson */ /* simde-arch.h is used to determine which features are available according to the compiler. However, we want to make it possible to forcibly enable or disable APIs */ #if !defined(SIMDE_FEATURES_H) #define SIMDE_FEATURES_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-diagnostic.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson */ /* SIMDe targets a very wide range of standards and compilers, and our * goal is to compile cleanly even with extremely aggressive warnings * (i.e., -Weverything in clang, -Wextra in GCC, /W4 for MSVC, etc.) * treated as errors. * * While our preference is to resolve the underlying issue a given * diagnostic is warning us about, sometimes that's not possible. * Fixing a warning in one compiler may cause problems in another. * Sometimes a warning doesn't really apply to us (false positives), * and sometimes adhering to a warning would mean dropping a feature * we *know* the compiler supports since we have tested specifically * for the compiler or feature. * * When practical, warnings are only disabled for specific code. For * a list of warnings which are enabled by default in all SIMDe code, * see SIMDE_DISABLE_UNWANTED_DIAGNOSTICS. Note that we restore the * warning stack when SIMDe is done parsing, so code which includes * SIMDe is not deprived of these warnings. */ #if !defined(SIMDE_DIAGNOSTIC_H) #define SIMDE_DIAGNOSTIC_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* This is only to help us implement functions like _mm_undefined_ps. */ #if defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) #undef SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ #endif #if HEDLEY_HAS_WARNING("-Wuninitialized") #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("clang diagnostic ignored \"-Wuninitialized\"") #elif HEDLEY_GCC_VERSION_CHECK(4,2,0) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") #elif HEDLEY_PGI_VERSION_CHECK(19,10,0) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("diag_suppress 549") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("error_messages(off,SEC_UNINITIALIZED_MEM_READ,SEC_UNDEFINED_RETURN_VALUE,unassigned)") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("error_messages(off,SEC_UNINITIALIZED_MEM_READ,SEC_UNDEFINED_RETURN_VALUE)") #elif HEDLEY_SUNPRO_VERSION_CHECK(5,12,0) && defined(__cplusplus) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("error_messages(off,unassigned)") #elif \ HEDLEY_TI_VERSION_CHECK(16,9,9) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,2) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("diag_suppress 551") #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ _Pragma("warning(disable:592)") #elif HEDLEY_MSVC_VERSION_CHECK(19,0,0) && !defined(__MSVC_RUNTIME_CHECKS) #define SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ __pragma(warning(disable:4700)) #endif /* GCC emits a lot of "notes" about the ABI being different for things * in newer versions of GCC. We don't really care because all our * functions are inlined and don't generate ABI. */ #if HEDLEY_GCC_VERSION_CHECK(7,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_PSABI_ _Pragma("GCC diagnostic ignored \"-Wpsabi\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_PSABI_ #endif /* Since MMX uses x87 FP registers, you're supposed to call _mm_empty() * after each MMX function before any floating point instructions. * Some compilers warn about functions which use MMX functions but * don't call _mm_empty(). However, since SIMDe is implementyng the * MMX API we shouldn't be calling _mm_empty(); we leave it to the * caller to invoke simde_mm_empty(). */ #if HEDLEY_INTEL_VERSION_CHECK(19,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_ _Pragma("warning(disable:13200 13203)") #elif defined(HEDLEY_MSVC_VERSION) #define SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_ __pragma(warning(disable:4799)) #else #define SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_ #endif /* Intel is pushing people to use OpenMP SIMD instead of Cilk+, so they * emit a diagnostic if you use #pragma simd instead of * #pragma omp simd. SIMDe supports OpenMP SIMD, you just need to * compile with -qopenmp or -qopenmp-simd and define * SIMDE_ENABLE_OPENMP. Cilk+ is just a fallback. */ #if HEDLEY_INTEL_VERSION_CHECK(18,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_SIMD_PRAGMA_DEPRECATED_ _Pragma("warning(disable:3948)") #else #define SIMDE_DIAGNOSTIC_DISABLE_SIMD_PRAGMA_DEPRECATED_ #endif /* MSVC emits a diagnostic when we call a function (like * simde_mm_set_epi32) while initializing a struct. We currently do * this a *lot* in the tests. */ #if \ defined(HEDLEY_MSVC_VERSION) #define SIMDE_DIAGNOSTIC_DISABLE_NON_CONSTANT_AGGREGATE_INITIALIZER_ __pragma(warning(disable:4204)) #else #define SIMDE_DIAGNOSTIC_DISABLE_NON_CONSTANT_AGGREGATE_INITIALIZER_ #endif /* This warning needs a lot of work. It is triggered if all you do is * pass the value to memcpy/__builtin_memcpy, or if you initialize a * member of the union, even if that member takes up the entire union. * Last tested with clang-10, hopefully things will improve in the * future; if clang fixes this I'd love to enable it. */ #if \ HEDLEY_HAS_WARNING("-Wconditional-uninitialized") #define SIMDE_DIAGNOSTIC_DISABLE_CONDITIONAL_UNINITIALIZED_ _Pragma("clang diagnostic ignored \"-Wconditional-uninitialized\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_CONDITIONAL_UNINITIALIZED_ #endif /* This warning is meant to catch things like `0.3 + 0.4 == 0.7`, which * will is false. However, SIMDe uses these operations exclusively * for things like _mm_cmpeq_ps, for which we really do want to check * for equality (or inequality). * * If someone wants to put together a SIMDE_FLOAT_EQUAL(a, op, b) macro * which just wraps a check in some code do disable this diagnostic I'd * be happy to accept it. */ #if \ HEDLEY_HAS_WARNING("-Wfloat-equal") || \ HEDLEY_GCC_VERSION_CHECK(3,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL_ _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL_ #endif /* This is because we use HEDLEY_STATIC_ASSERT for static assertions. * If Hedley can't find an implementation it will preprocess to * nothing, which means there will be a trailing semi-colon. */ #if HEDLEY_HAS_WARNING("-Wextra-semi") #define SIMDE_DIAGNOSTIC_DISABLE_EXTRA_SEMI_ _Pragma("clang diagnostic ignored \"-Wextra-semi\"") #elif HEDLEY_GCC_VERSION_CHECK(8,1,0) && defined(__cplusplus) #define SIMDE_DIAGNOSTIC_DISABLE_EXTRA_SEMI_ _Pragma("GCC diagnostic ignored \"-Wextra-semi\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_EXTRA_SEMI_ #endif /* We do use a few variadic macros, which technically aren't available * until C99 and C++11, but every compiler I'm aware of has supported * them for much longer. That said, usage is isolated to the test * suite and compilers known to support them. */ #if HEDLEY_HAS_WARNING("-Wvariadic-macros") || HEDLEY_GCC_VERSION_CHECK(4,0,0) #if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") #define SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_ \ _Pragma("clang diagnostic ignored \"-Wvariadic-macros\"") \ _Pragma("clang diagnostic ignored \"-Wc++98-compat-pedantic\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_ _Pragma("GCC diagnostic ignored \"-Wvariadic-macros\"") #endif #else #define SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_ #endif /* emscripten requires us to use a __wasm_unimplemented_simd128__ macro * before we can access certain SIMD intrinsics, but this diagnostic * warns about it being a reserved name. It is a reserved name, but * it's reserved for the compiler and we are using it to convey * information to the compiler. * * This is also used when enabling native aliases since we don't get to * choose the macro names. */ #if HEDLEY_HAS_WARNING("-Wreserved-id-macro") #define SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_MACRO_ _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_MACRO_ #endif /* Similar to above; types like simde__m128i are reserved due to the * double underscore, but we didn't choose them, Intel did. */ #if HEDLEY_HAS_WARNING("-Wreserved-identifier") #define SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_ _Pragma("clang diagnostic ignored \"-Wreserved-identifier\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_ #endif /* clang 3.8 warns about the packed attribute being unnecessary when * used in the _mm_loadu_* functions. That *may* be true for version * 3.8, but for later versions it is crucial in order to make unaligned * access safe. */ #if HEDLEY_HAS_WARNING("-Wpacked") #define SIMDE_DIAGNOSTIC_DISABLE_PACKED_ _Pragma("clang diagnostic ignored \"-Wpacked\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_PACKED_ #endif /* Triggered when assigning a float to a double implicitly. We use * explicit casts in SIMDe, this is only used in the test suite. */ #if HEDLEY_HAS_WARNING("-Wdouble-promotion") #define SIMDE_DIAGNOSTIC_DISABLE_DOUBLE_PROMOTION_ _Pragma("clang diagnostic ignored \"-Wdouble-promotion\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_DOUBLE_PROMOTION_ #endif /* Several compilers treat conformant array parameters as VLAs. We * test to make sure we're in C mode (C++ doesn't support CAPs), and * that the version of the standard supports CAPs. We also reject * some buggy compilers like MSVC (the logic is in Hedley if you want * to take a look), but with certain warnings enabled some compilers * still like to emit a diagnostic. */ #if HEDLEY_HAS_WARNING("-Wvla") #define SIMDE_DIAGNOSTIC_DISABLE_VLA_ _Pragma("clang diagnostic ignored \"-Wvla\"") #elif HEDLEY_GCC_VERSION_CHECK(4,3,0) #define SIMDE_DIAGNOSTIC_DISABLE_VLA_ _Pragma("GCC diagnostic ignored \"-Wvla\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_VLA_ #endif /* If you add an unused attribute to a function and don't use it, clang * may emit this. */ #if HEDLEY_HAS_WARNING("-Wused-but-marked-unused") #define SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ _Pragma("clang diagnostic ignored \"-Wused-but-marked-unused\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ #endif #if HEDLEY_HAS_WARNING("-Wpass-failed") #define SIMDE_DIAGNOSTIC_DISABLE_PASS_FAILED_ _Pragma("clang diagnostic ignored \"-Wpass-failed\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_PASS_FAILED_ #endif #if HEDLEY_HAS_WARNING("-Wpadded") #define SIMDE_DIAGNOSTIC_DISABLE_PADDED_ _Pragma("clang diagnostic ignored \"-Wpadded\"") #elif HEDLEY_MSVC_VERSION_CHECK(19,0,0) /* Likely goes back further */ #define SIMDE_DIAGNOSTIC_DISABLE_PADDED_ __pragma(warning(disable:4324)) #else #define SIMDE_DIAGNOSTIC_DISABLE_PADDED_ #endif #if HEDLEY_HAS_WARNING("-Wzero-as-null-pointer-constant") #define SIMDE_DIAGNOSTIC_DISABLE_ZERO_AS_NULL_POINTER_CONSTANT_ _Pragma("clang diagnostic ignored \"-Wzero-as-null-pointer-constant\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_ZERO_AS_NULL_POINTER_CONSTANT_ #endif #if HEDLEY_HAS_WARNING("-Wold-style-cast") #define SIMDE_DIAGNOSTIC_DISABLE_OLD_STYLE_CAST_ _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_OLD_STYLE_CAST_ #endif #if HEDLEY_HAS_WARNING("-Wcast-function-type") || HEDLEY_GCC_VERSION_CHECK(8,0,0) #define SIMDE_DIAGNOSTIC_DISABLE_CAST_FUNCTION_TYPE_ _Pragma("GCC diagnostic ignored \"-Wcast-function-type\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_CAST_FUNCTION_TYPE_ #endif /* clang will emit this warning when we use C99 extensions whan not in * C99 mode, even though it does support this. In such cases we check * the compiler and version first, so we know it's not a problem. */ #if HEDLEY_HAS_WARNING("-Wc99-extensions") #define SIMDE_DIAGNOSTIC_DISABLE_C99_EXTENSIONS_ _Pragma("clang diagnostic ignored \"-Wc99-extensions\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_C99_EXTENSIONS_ #endif /* Similar problm as above; we rely on some basic C99 support, but clang * has started warning obut this even in C17 mode with -Weverything. */ #if HEDLEY_HAS_WARNING("-Wdeclaration-after-statement") #define SIMDE_DIAGNOSTIC_DISABLE_DECLARATION_AFTER_STATEMENT_ _Pragma("clang diagnostic ignored \"-Wdeclaration-after-statement\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_DECLARATION_AFTER_STATEMENT_ #endif /* https://github.com/simd-everywhere/simde/issues/277 */ #if defined(HEDLEY_GCC_VERSION) && HEDLEY_GCC_VERSION_CHECK(4,6,0) && !HEDLEY_GCC_VERSION_CHECK(6,4,0) && defined(__cplusplus) #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_UNUSED_BUT_SET_VARIBALE_ _Pragma("GCC diagnostic ignored \"-Wunused-but-set-variable\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_UNUSED_BUT_SET_VARIBALE_ #endif /* This is the warning that you normally define _CRT_SECURE_NO_WARNINGS * to silence, but you have to do that before including anything and * that would require reordering includes. */ #if defined(_MSC_VER) #define SIMDE_DIAGNOSTIC_DISABLE_ANNEX_K_ __pragma(warning(disable:4996)) #else #define SIMDE_DIAGNOSTIC_DISABLE_ANNEX_K_ #endif /* Some compilers, such as clang, may use `long long` for 64-bit * integers, but `long long` triggers a diagnostic with * -Wc++98-compat-pedantic which says 'long long' is incompatible with * C++98. */ #if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") #if HEDLEY_HAS_WARNING("-Wc++11-long-long") #define SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ \ _Pragma("clang diagnostic ignored \"-Wc++98-compat-pedantic\"") \ _Pragma("clang diagnostic ignored \"-Wc++11-long-long\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ _Pragma("clang diagnostic ignored \"-Wc++98-compat-pedantic\"") #endif #else #define SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ #endif /* Some problem as above */ #if HEDLEY_HAS_WARNING("-Wc++11-long-long") #define SIMDE_DIAGNOSTIC_DISABLE_CPP11_LONG_LONG_ _Pragma("clang diagnostic ignored \"-Wc++11-long-long\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_CPP11_LONG_LONG_ #endif /* emscripten emits this whenever stdin/stdout/stderr is used in a * macro. */ #if HEDLEY_HAS_WARNING("-Wdisabled-macro-expansion") #define SIMDE_DIAGNOSTIC_DISABLE_DISABLED_MACRO_EXPANSION_ _Pragma("clang diagnostic ignored \"-Wdisabled-macro-expansion\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_DISABLED_MACRO_EXPANSION_ #endif /* Clang uses C11 generic selections to implement some AltiVec * functions, which triggers this diagnostic when not compiling * in C11 mode */ #if HEDLEY_HAS_WARNING("-Wc11-extensions") #define SIMDE_DIAGNOSTIC_DISABLE_C11_EXTENSIONS_ _Pragma("clang diagnostic ignored \"-Wc11-extensions\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_C11_EXTENSIONS_ #endif /* Clang sometimes triggers this warning in macros in the AltiVec and * NEON headers, or due to missing functions. */ #if HEDLEY_HAS_WARNING("-Wvector-conversion") #define SIMDE_DIAGNOSTIC_DISABLE_VECTOR_CONVERSION_ _Pragma("clang diagnostic ignored \"-Wvector-conversion\"") /* For NEON, the situation with -Wvector-conversion in clang < 10 is * bad enough that we just disable the warning altogether. On x86, * clang has similar issues on several sse4.2+ intrinsics before 3.8. */ #if \ (defined(SIMDE_ARCH_ARM) && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0)) || \ SIMDE_DETECT_CLANG_VERSION_NOT(3,8,0) #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_VECTOR_CONVERSION_ SIMDE_DIAGNOSTIC_DISABLE_VECTOR_CONVERSION_ #endif #else #define SIMDE_DIAGNOSTIC_DISABLE_VECTOR_CONVERSION_ #endif #if !defined(SIMDE_DIAGNOSTIC_DISABLE_BUGGY_VECTOR_CONVERSION_) #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_VECTOR_CONVERSION_ #endif /* Prior to 5.0, clang didn't support disabling diagnostics in * statement exprs. As a result, some macros we use don't * properly silence warnings. */ #if SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) && HEDLEY_HAS_WARNING("-Wcast-qual") && HEDLEY_HAS_WARNING("-Wcast-align") #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_ _Pragma("clang diagnostic ignored \"-Wcast-qual\"") _Pragma("clang diagnostic ignored \"-Wcast-align\"") #elif SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) && HEDLEY_HAS_WARNING("-Wcast-qual") #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_ _Pragma("clang diagnostic ignored \"-Wcast-qual\"") #elif SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) && HEDLEY_HAS_WARNING("-Wcast-align") #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_ _Pragma("clang diagnostic ignored \"-Wcast-align\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_ #endif /* SLEEF triggers this a *lot* in their headers */ #if HEDLEY_HAS_WARNING("-Wignored-qualifiers") #define SIMDE_DIAGNOSTIC_DISABLE_IGNORED_QUALIFIERS_ _Pragma("clang diagnostic ignored \"-Wignored-qualifiers\"") #elif HEDLEY_GCC_VERSION_CHECK(4,3,0) #define SIMDE_DIAGNOSTIC_DISABLE_IGNORED_QUALIFIERS_ _Pragma("GCC diagnostic ignored \"-Wignored-qualifiers\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_IGNORED_QUALIFIERS_ #endif /* GCC emits this under some circumstances when using __int128 */ #if HEDLEY_GCC_VERSION_CHECK(4,8,0) #define SIMDE_DIAGNOSTIC_DISABLE_PEDANTIC_ _Pragma("GCC diagnostic ignored \"-Wpedantic\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_PEDANTIC_ #endif /* MSVC doesn't like (__assume(0), code) and will warn about code being * unreachable, but we want it there because not all compilers * understand the unreachable macro and will complain if it is missing. * I'm planning on adding a new macro to Hedley to handle this a bit * more elegantly, but until then... */ #if defined(HEDLEY_MSVC_VERSION) #define SIMDE_DIAGNOSTIC_DISABLE_UNREACHABLE_ __pragma(warning(disable:4702)) #elif defined(__clang__) #define SIMDE_DIAGNOSTIC_DISABLE_UNREACHABLE_ HEDLEY_PRAGMA(clang diagnostic ignored "-Wunreachable-code") #else #define SIMDE_DIAGNOSTIC_DISABLE_UNREACHABLE_ #endif /* This is a false positive from GCC in a few places. */ #if HEDLEY_GCC_VERSION_CHECK(4,7,0) #define SIMDE_DIAGNOSTIC_DISABLE_MAYBE_UNINITIAZILED_ _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") #else #define SIMDE_DIAGNOSTIC_DISABLE_MAYBE_UNINITIAZILED_ #endif #if defined(SIMDE_ENABLE_NATIVE_ALIASES) #define SIMDE_DISABLE_UNWANTED_DIAGNOSTICS_NATIVE_ALIASES_ \ SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_MACRO_ #else #define SIMDE_DISABLE_UNWANTED_DIAGNOSTICS_NATIVE_ALIASES_ #endif /* Some native functions on E2K with instruction set < v6 are declared * as deprecated due to inefficiency. Still they are more efficient * than SIMDe implementation. So we're using them, and switching off * these deprecation warnings. */ #if defined(HEDLEY_MCST_LCC_VERSION) # define SIMDE_LCC_DISABLE_DEPRECATED_WARNINGS _Pragma("diag_suppress 1215,1444") # define SIMDE_LCC_REVERT_DEPRECATED_WARNINGS _Pragma("diag_default 1215,1444") #else # define SIMDE_LCC_DISABLE_DEPRECATED_WARNINGS # define SIMDE_LCC_REVERT_DEPRECATED_WARNINGS #endif #define SIMDE_DISABLE_UNWANTED_DIAGNOSTICS \ HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION \ SIMDE_DISABLE_UNWANTED_DIAGNOSTICS_NATIVE_ALIASES_ \ SIMDE_DIAGNOSTIC_DISABLE_PSABI_ \ SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_ \ SIMDE_DIAGNOSTIC_DISABLE_SIMD_PRAGMA_DEPRECATED_ \ SIMDE_DIAGNOSTIC_DISABLE_CONDITIONAL_UNINITIALIZED_ \ SIMDE_DIAGNOSTIC_DISABLE_DECLARATION_AFTER_STATEMENT_ \ SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL_ \ SIMDE_DIAGNOSTIC_DISABLE_NON_CONSTANT_AGGREGATE_INITIALIZER_ \ SIMDE_DIAGNOSTIC_DISABLE_EXTRA_SEMI_ \ SIMDE_DIAGNOSTIC_DISABLE_VLA_ \ SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ \ SIMDE_DIAGNOSTIC_DISABLE_PASS_FAILED_ \ SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ \ SIMDE_DIAGNOSTIC_DISABLE_CPP11_LONG_LONG_ \ SIMDE_DIAGNOSTIC_DISABLE_BUGGY_UNUSED_BUT_SET_VARIBALE_ \ SIMDE_DIAGNOSTIC_DISABLE_BUGGY_CASTS_ \ SIMDE_DIAGNOSTIC_DISABLE_BUGGY_VECTOR_CONVERSION_ \ SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_ #endif /* !defined(SIMDE_DIAGNOSTIC_H) */ /* :: End simde-diagnostic.h :: */ #if !defined(SIMDE_X86_SVML_NATIVE) && !defined(SIMDE_X86_SVML_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SVML) #define SIMDE_X86_SVML_NATIVE #endif #endif #if defined(SIMDE_X86_SVML_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VP2INTERSECT_NATIVE) && !defined(SIMDE_X86_AVX512VP2INTERSECT_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VP2INTERSECT) #define SIMDE_X86_AVX512VP2INTERSECT_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VP2INTERSECT_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VPOPCNTDQ_NATIVE) && !defined(SIMDE_X86_AVX512VPOPCNTDQ_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VPOPCNTDQ) #define SIMDE_X86_AVX512VPOPCNTDQ_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VPOPCNTDQ_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512BITALG_NATIVE) && !defined(SIMDE_X86_AVX512BITALG_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512BITALG) #define SIMDE_X86_AVX512BITALG_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512BITALG_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VBMI_NATIVE) && !defined(SIMDE_X86_AVX512VBMI_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VBMI) #define SIMDE_X86_AVX512VBMI_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VBMI_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VBMI2_NATIVE) && !defined(SIMDE_X86_AVX512VBMI2_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VBMI2) #define SIMDE_X86_AVX512VBMI2_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VBMI2_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VNNI_NATIVE) && !defined(SIMDE_X86_AVX512VNNI_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VNNI) #define SIMDE_X86_AVX512VNNI_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VNNI_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX5124VNNIW_NATIVE) && !defined(SIMDE_X86_AVX5124VNNIW_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX5124VNNIW) #define SIMDE_X86_AVX5124VNNIW_NATIVE #endif #endif #if defined(SIMDE_X86_AVX5124VNNIW_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512CD_NATIVE) && !defined(SIMDE_X86_AVX512CD_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512CD) #define SIMDE_X86_AVX512CD_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512CD_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512DQ_NATIVE) && !defined(SIMDE_X86_AVX512DQ_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512DQ) #define SIMDE_X86_AVX512DQ_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512DQ_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512VL_NATIVE) && !defined(SIMDE_X86_AVX512VL_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512VL) #define SIMDE_X86_AVX512VL_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512VL_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512BW_NATIVE) && !defined(SIMDE_X86_AVX512BW_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512BW) #define SIMDE_X86_AVX512BW_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512BW_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512BF16_NATIVE) && !defined(SIMDE_X86_AVX512BF16_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512BF16) #define SIMDE_X86_AVX512BF16_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512BF16_NATIVE) && !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_NATIVE #endif #if !defined(SIMDE_X86_AVX512F_NATIVE) && !defined(SIMDE_X86_AVX512F_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX512F) #define SIMDE_X86_AVX512F_NATIVE #endif #endif #if defined(SIMDE_X86_AVX512F_NATIVE) && !defined(SIMDE_X86_AVX2_NATIVE) #define SIMDE_X86_AVX2_NATIVE #endif #if !defined(SIMDE_X86_FMA_NATIVE) && !defined(SIMDE_X86_FMA_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_FMA) #define SIMDE_X86_FMA_NATIVE #endif #endif #if defined(SIMDE_X86_FMA_NATIVE) && !defined(SIMDE_X86_AVX_NATIVE) #define SIMDE_X86_AVX_NATIVE #endif #if !defined(SIMDE_X86_AVX2_NATIVE) && !defined(SIMDE_X86_AVX2_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX2) #define SIMDE_X86_AVX2_NATIVE #endif #endif #if defined(SIMDE_X86_AVX2_NATIVE) && !defined(SIMDE_X86_AVX_NATIVE) #define SIMDE_X86_AVX_NATIVE #endif #if !defined(SIMDE_X86_AVX_NATIVE) && !defined(SIMDE_X86_AVX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_AVX) #define SIMDE_X86_AVX_NATIVE #endif #endif #if defined(SIMDE_X86_AVX_NATIVE) && !defined(SIMDE_X86_SSE4_2_NATIVE) #define SIMDE_X86_SSE4_2_NATIVE #endif #if !defined(SIMDE_X86_XOP_NATIVE) && !defined(SIMDE_X86_XOP_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_XOP) #define SIMDE_X86_XOP_NATIVE #endif #endif #if defined(SIMDE_X86_XOP_NATIVE) && !defined(SIMDE_X86_SSE4_2_NATIVE) #define SIMDE_X86_SSE4_2_NATIVE #endif #if !defined(SIMDE_X86_SSE4_2_NATIVE) && !defined(SIMDE_X86_SSE4_2_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE4_2) #define SIMDE_X86_SSE4_2_NATIVE #endif #endif #if defined(SIMDE_X86_SSE4_2_NATIVE) && !defined(SIMDE_X86_SSE4_1_NATIVE) #define SIMDE_X86_SSE4_1_NATIVE #endif #if !defined(SIMDE_X86_SSE4_1_NATIVE) && !defined(SIMDE_X86_SSE4_1_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE4_1) #define SIMDE_X86_SSE4_1_NATIVE #endif #endif #if defined(SIMDE_X86_SSE4_1_NATIVE) && !defined(SIMDE_X86_SSSE3_NATIVE) #define SIMDE_X86_SSSE3_NATIVE #endif #if !defined(SIMDE_X86_SSSE3_NATIVE) && !defined(SIMDE_X86_SSSE3_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSSE3) #define SIMDE_X86_SSSE3_NATIVE #endif #endif #if defined(SIMDE_X86_SSSE3_NATIVE) && !defined(SIMDE_X86_SSE3_NATIVE) #define SIMDE_X86_SSE3_NATIVE #endif #if !defined(SIMDE_X86_SSE3_NATIVE) && !defined(SIMDE_X86_SSE3_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE3) #define SIMDE_X86_SSE3_NATIVE #endif #endif #if defined(SIMDE_X86_SSE3_NATIVE) && !defined(SIMDE_X86_SSE2_NATIVE) #define SIMDE_X86_SSE2_NATIVE #endif #if !defined(SIMDE_X86_SSE2_NATIVE) && !defined(SIMDE_X86_SSE2_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE2) #define SIMDE_X86_SSE2_NATIVE #endif #endif #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(SIMDE_X86_SSE_NATIVE) #define SIMDE_X86_SSE_NATIVE #endif #if !defined(SIMDE_X86_SSE_NATIVE) && !defined(SIMDE_X86_SSE_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE) #define SIMDE_X86_SSE_NATIVE #endif #endif #if !defined(SIMDE_X86_MMX_NATIVE) && !defined(SIMDE_X86_MMX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_MMX) #define SIMDE_X86_MMX_NATIVE #endif #endif #if !defined(SIMDE_X86_GFNI_NATIVE) && !defined(SIMDE_X86_GFNI_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_GFNI) #define SIMDE_X86_GFNI_NATIVE #endif #endif #if !defined(SIMDE_X86_PCLMUL_NATIVE) && !defined(SIMDE_X86_PCLMUL_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_PCLMUL) #define SIMDE_X86_PCLMUL_NATIVE #endif #endif #if !defined(SIMDE_X86_VPCLMULQDQ_NATIVE) && !defined(SIMDE_X86_VPCLMULQDQ_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_VPCLMULQDQ) #define SIMDE_X86_VPCLMULQDQ_NATIVE #endif #endif #if !defined(SIMDE_X86_F16C_NATIVE) && !defined(SIMDE_X86_F16C_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_F16C) #define SIMDE_X86_F16C_NATIVE #endif #endif #if !defined(SIMDE_X86_SVML_NATIVE) && !defined(SIMDE_X86_SVML_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(__INTEL_COMPILER) #define SIMDE_X86_SVML_NATIVE #endif #endif #if defined(HEDLEY_MSVC_VERSION) #pragma warning(push) #pragma warning(disable:4799) #endif #if \ defined(SIMDE_X86_AVX_NATIVE) || defined(SIMDE_X86_GFNI_NATIVE) #include #elif defined(SIMDE_X86_SSE4_2_NATIVE) #include #elif defined(SIMDE_X86_SSE4_1_NATIVE) #include #elif defined(SIMDE_X86_SSSE3_NATIVE) #include #elif defined(SIMDE_X86_SSE3_NATIVE) #include #elif defined(SIMDE_X86_SSE2_NATIVE) #include #elif defined(SIMDE_X86_SSE_NATIVE) #include #elif defined(SIMDE_X86_MMX_NATIVE) #include #endif #if defined(SIMDE_X86_XOP_NATIVE) #if defined(_MSC_VER) #include #else #include #endif #endif #if defined(HEDLEY_MSVC_VERSION) #pragma warning(pop) #endif #if !defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_ARM_NEON_A64V8_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_ARM_NEON) && defined(SIMDE_ARCH_AARCH64) && SIMDE_ARCH_ARM_CHECK(8,0) #define SIMDE_ARM_NEON_A64V8_NATIVE #endif #endif #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_ARM_NEON_A32V8_NATIVE) #define SIMDE_ARM_NEON_A32V8_NATIVE #endif #if !defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_ARM_NEON_A32V8_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_ARM_NEON) && SIMDE_ARCH_ARM_CHECK(8,0) && (__ARM_NEON_FP & 0x02) #define SIMDE_ARM_NEON_A32V8_NATIVE #endif #endif #if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define SIMDE_ARM_NEON_A32V7_NATIVE #endif #if !defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_ARM_NEON_A32V7_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_ARM_NEON) && SIMDE_ARCH_ARM_CHECK(7,0) #define SIMDE_ARM_NEON_A32V7_NATIVE #endif #endif #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) #include #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC) #include #endif #endif #if !defined(SIMDE_ARM_SVE_NATIVE) && !defined(SIMDE_ARM_SVE_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_ARM_SVE) #define SIMDE_ARM_SVE_NATIVE #include #endif #endif #if !defined(SIMDE_WASM_SIMD128_NATIVE) && !defined(SIMDE_WASM_SIMD128_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_WASM_SIMD128) #define SIMDE_WASM_SIMD128_NATIVE #endif #endif #if defined(SIMDE_WASM_SIMD128_NATIVE) #include #endif #if !defined(SIMDE_POWER_ALTIVEC_P9_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P9_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_POWER_ALTIVEC_CHECK(900) #define SIMDE_POWER_ALTIVEC_P9_NATIVE #endif #endif #if defined(SIMDE_POWER_ALTIVEC_P9_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P8) #define SIMDE_POWER_ALTIVEC_P8_NATIVE #endif #if !defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P8_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_POWER_ALTIVEC_CHECK(800) #define SIMDE_POWER_ALTIVEC_P8_NATIVE #endif #endif #if defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P7) #define SIMDE_POWER_ALTIVEC_P7_NATIVE #endif #if !defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P7_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_POWER_ALTIVEC_CHECK(700) #define SIMDE_POWER_ALTIVEC_P7_NATIVE #endif #endif #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P6) #define SIMDE_POWER_ALTIVEC_P6_NATIVE #endif #if !defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P6_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_POWER_ALTIVEC_CHECK(600) #define SIMDE_POWER_ALTIVEC_P6_NATIVE #endif #endif #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P5) #define SIMDE_POWER_ALTIVEC_P5_NATIVE #endif #if !defined(SIMDE_POWER_ALTIVEC_P5_NATIVE) && !defined(SIMDE_POWER_ALTIVEC_P5_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_POWER_ALTIVEC_CHECK(500) #define SIMDE_POWER_ALTIVEC_P5_NATIVE #endif #endif #if !defined(SIMDE_ZARCH_ZVECTOR_15_NATIVE) && !defined(SIMDE_ZARCH_ZVECTOR_15_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_ZARCH_CHECK(13) && defined(SIMDE_ARCH_ZARCH_ZVECTOR) #define SIMDE_ZARCH_ZVECTOR_15_NATIVE #endif #endif #if !defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) && !defined(SIMDE_ZARCH_ZVECTOR_14_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_ZARCH_CHECK(12) && defined(SIMDE_ARCH_ZARCH_ZVECTOR) #define SIMDE_ZARCH_ZVECTOR_14_NATIVE #endif #endif #if !defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) && !defined(SIMDE_ZARCH_ZVECTOR_13_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if SIMDE_ARCH_ZARCH_CHECK(11) && defined(SIMDE_ARCH_ZARCH_ZVECTOR) #define SIMDE_ZARCH_ZVECTOR_13_NATIVE #endif #endif #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) /* AltiVec conflicts with lots of stuff. The bool keyword conflicts * with the bool keyword in C++ and the bool macro in C99+ (defined * in stdbool.h). The vector keyword conflicts with std::vector in * C++ if you are `using std;`. * * Luckily AltiVec allows you to use `__vector`/`__bool`/`__pixel` * instead, but altivec.h will unconditionally define * `vector`/`bool`/`pixel` so we need to work around that. * * Unfortunately this means that if your code uses AltiVec directly * it may break. If this is the case you'll want to define * `SIMDE_POWER_ALTIVEC_NO_UNDEF` before including SIMDe. Or, even * better, port your code to use the double-underscore versions. */ #if defined(bool) #undef bool #endif #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #include #if !defined(SIMDE_POWER_ALTIVEC_NO_UNDEF) #if defined(vector) #undef vector #endif #if defined(pixel) #undef pixel #endif #if defined(bool) #undef bool #endif #endif /* !defined(SIMDE_POWER_ALTIVEC_NO_UNDEF) */ #elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) #include #endif /* Use these intsead of vector/pixel/bool in SIMDe. */ #define SIMDE_POWER_ALTIVEC_VECTOR(T) __vector T #define SIMDE_POWER_ALTIVEC_PIXEL __pixel #define SIMDE_POWER_ALTIVEC_BOOL __bool /* Re-define bool if we're using stdbool.h */ #if !defined(__cplusplus) && defined(__bool_true_false_are_defined) && !defined(SIMDE_POWER_ALTIVEC_NO_UNDEF) #define bool _Bool #endif #endif #if !defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) && !defined(SIMDE_MIPS_LOONGSON_MMI_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_MIPS_LOONGSON_MMI) #define SIMDE_MIPS_LOONGSON_MMI_NATIVE 1 #endif #endif #if defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) #include #endif #if !defined(SIMDE_MIPS_MSA_NATIVE) && !defined(SIMDE_MIPS_MSA_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_MIPS_MSA) #define SIMDE_MIPS_MSA_NATIVE 1 #endif #endif #if defined(SIMDE_MIPS_MSA_NATIVE) #include #endif /* This is used to determine whether or not to fall back on a vector * function in an earlier ISA extensions, as well as whether * we expected any attempts at vectorization to be fruitful or if we * expect to always be running serial code. * * Note that, for some architectures (okay, *one* architecture) there * can be a split where some types are supported for one vector length * but others only for a shorter length. Therefore, it is possible to * provide separate values for float/int/double types. */ #if !defined(SIMDE_NATURAL_VECTOR_SIZE) #if defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_NATURAL_VECTOR_SIZE (512) #elif defined(SIMDE_X86_AVX2_NATIVE) #define SIMDE_NATURAL_VECTOR_SIZE (256) #elif defined(SIMDE_X86_AVX_NATIVE) #define SIMDE_NATURAL_FLOAT_VECTOR_SIZE (256) #define SIMDE_NATURAL_INT_VECTOR_SIZE (128) #define SIMDE_NATURAL_DOUBLE_VECTOR_SIZE (128) #elif \ defined(SIMDE_X86_SSE2_NATIVE) || \ defined(SIMDE_ARM_NEON_A32V7_NATIVE) || \ defined(SIMDE_WASM_SIMD128_NATIVE) || \ defined(SIMDE_POWER_ALTIVEC_P5_NATIVE) || \ defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) || \ defined(SIMDE_MIPS_MSA_NATIVE) #define SIMDE_NATURAL_VECTOR_SIZE (128) #elif defined(SIMDE_X86_SSE_NATIVE) #define SIMDE_NATURAL_FLOAT_VECTOR_SIZE (128) #define SIMDE_NATURAL_INT_VECTOR_SIZE (64) #define SIMDE_NATURAL_DOUBLE_VECTOR_SIZE (0) #endif #if !defined(SIMDE_NATURAL_VECTOR_SIZE) #if defined(SIMDE_NATURAL_FLOAT_VECTOR_SIZE) #define SIMDE_NATURAL_VECTOR_SIZE SIMDE_NATURAL_FLOAT_VECTOR_SIZE #elif defined(SIMDE_NATURAL_INT_VECTOR_SIZE) #define SIMDE_NATURAL_VECTOR_SIZE SIMDE_NATURAL_INT_VECTOR_SIZE #elif defined(SIMDE_NATURAL_DOUBLE_VECTOR_SIZE) #define SIMDE_NATURAL_VECTOR_SIZE SIMDE_NATURAL_DOUBLE_VECTOR_SIZE #else #define SIMDE_NATURAL_VECTOR_SIZE (0) #endif #endif #if !defined(SIMDE_NATURAL_FLOAT_VECTOR_SIZE) #define SIMDE_NATURAL_FLOAT_VECTOR_SIZE SIMDE_NATURAL_VECTOR_SIZE #endif #if !defined(SIMDE_NATURAL_INT_VECTOR_SIZE) #define SIMDE_NATURAL_INT_VECTOR_SIZE SIMDE_NATURAL_VECTOR_SIZE #endif #if !defined(SIMDE_NATURAL_DOUBLE_VECTOR_SIZE) #define SIMDE_NATURAL_DOUBLE_VECTOR_SIZE SIMDE_NATURAL_VECTOR_SIZE #endif #endif #define SIMDE_NATURAL_VECTOR_SIZE_LE(x) ((SIMDE_NATURAL_VECTOR_SIZE > 0) && (SIMDE_NATURAL_VECTOR_SIZE <= (x))) #define SIMDE_NATURAL_VECTOR_SIZE_GE(x) ((SIMDE_NATURAL_VECTOR_SIZE > 0) && (SIMDE_NATURAL_VECTOR_SIZE >= (x))) #define SIMDE_NATURAL_FLOAT_VECTOR_SIZE_LE(x) ((SIMDE_NATURAL_FLOAT_VECTOR_SIZE > 0) && (SIMDE_NATURAL_FLOAT_VECTOR_SIZE <= (x))) #define SIMDE_NATURAL_FLOAT_VECTOR_SIZE_GE(x) ((SIMDE_NATURAL_FLOAT_VECTOR_SIZE > 0) && (SIMDE_NATURAL_FLOAT_VECTOR_SIZE >= (x))) #define SIMDE_NATURAL_INT_VECTOR_SIZE_LE(x) ((SIMDE_NATURAL_INT_VECTOR_SIZE > 0) && (SIMDE_NATURAL_INT_VECTOR_SIZE <= (x))) #define SIMDE_NATURAL_INT_VECTOR_SIZE_GE(x) ((SIMDE_NATURAL_INT_VECTOR_SIZE > 0) && (SIMDE_NATURAL_INT_VECTOR_SIZE >= (x))) #define SIMDE_NATURAL_DOUBLE_VECTOR_SIZE_LE(x) ((SIMDE_NATURAL_DOUBLE_VECTOR_SIZE > 0) && (SIMDE_NATURAL_DOUBLE_VECTOR_SIZE <= (x))) #define SIMDE_NATURAL_DOUBLE_VECTOR_SIZE_GE(x) ((SIMDE_NATURAL_DOUBLE_VECTOR_SIZE > 0) && (SIMDE_NATURAL_DOUBLE_VECTOR_SIZE >= (x))) /* Native aliases */ #if defined(SIMDE_ENABLE_NATIVE_ALIASES) #if !defined(SIMDE_X86_MMX_NATIVE) #define SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSE_NATIVE) #define SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSE2_NATIVE) #define SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSE3_NATIVE) #define SIMDE_X86_SSE3_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSSE3_NATIVE) #define SIMDE_X86_SSSE3_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSE4_1_NATIVE) #define SIMDE_X86_SSE4_1_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_SSE4_2_NATIVE) #define SIMDE_X86_SSE4_2_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX_NATIVE) #define SIMDE_X86_AVX_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX2_NATIVE) #define SIMDE_X86_AVX2_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_FMA_NATIVE) #define SIMDE_X86_FMA_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512F_NATIVE) #define SIMDE_X86_AVX512F_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512VL_NATIVE) #define SIMDE_X86_AVX512VL_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512VBMI_NATIVE) #define SIMDE_X86_AVX512VBMI_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512VBMI2_NATIVE) #define SIMDE_X86_AVX512VBMI2_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512BW_NATIVE) #define SIMDE_X86_AVX512BW_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512VNNI_NATIVE) #define SIMDE_X86_AVX512VNNI_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX5124VNNIW_NATIVE) #define SIMDE_X86_AVX5124VNNIW_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512BF16_NATIVE) #define SIMDE_X86_AVX512BF16_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512BITALG_NATIVE) #define SIMDE_X86_AVX512BITALG_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512VPOPCNTDQ_NATIVE) #define SIMDE_X86_AVX512VPOPCNTDQ_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512DQ_NATIVE) #define SIMDE_X86_AVX512DQ_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_AVX512CD_NATIVE) #define SIMDE_X86_AVX512CD_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_GFNI_NATIVE) #define SIMDE_X86_GFNI_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_PCLMUL_NATIVE) #define SIMDE_X86_PCLMUL_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_VPCLMULQDQ_NATIVE) #define SIMDE_X86_VPCLMULQDQ_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_X86_F16C_NATIVE) #define SIMDE_X86_F16C_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_ARM_NEON_A32V8_NATIVE) #define SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_ARM_NEON_A64V8_NATIVE) #define SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_ARM_SVE_NATIVE) #define SIMDE_ARM_SVE_ENABLE_NATIVE_ALIASES #endif #if !defined(SIMDE_WASM_SIMD128_NATIVE) #define SIMDE_WASM_SIMD128_ENABLE_NATIVE_ALIASES #endif #endif /* Are floating point values stored using IEEE 754? Knowing * this at during preprocessing is a bit tricky, mostly because what * we're curious about is how values are stored and not whether the * implementation is fully conformant in terms of rounding, NaN * handling, etc. * * For example, if you use -ffast-math or -Ofast on * GCC or clang IEEE 754 isn't strictly followed, therefore IEE 754 * support is not advertised (by defining __STDC_IEC_559__). * * However, what we care about is whether it is safe to assume that * floating point values are stored in IEEE 754 format, in which case * we can provide faster implementations of some functions. * * Luckily every vaugely modern architecture I'm aware of uses IEEE 754- * so we just assume IEEE 754 for now. There is a test which verifies * this, if that test fails sowewhere please let us know and we'll add * an exception for that platform. Meanwhile, you can define * SIMDE_NO_IEEE754_STORAGE. */ #if !defined(SIMDE_IEEE754_STORAGE) && !defined(SIMDE_NO_IEE754_STORAGE) #define SIMDE_IEEE754_STORAGE #endif #if defined(SIMDE_ARCH_ARM_NEON_FP16) #define SIMDE_ARM_NEON_FP16 #endif #if !defined(SIMDE_LOONGARCH_LASX_NATIVE) && !defined(SIMDE_LOONGARCH_LASX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_LOONGARCH_LASX) #define SIMDE_LOONGARCH_LASX_NATIVE #endif #endif #if !defined(SIMDE_LOONGARCH_LSX_NATIVE) && !defined(SIMDE_LOONGARCH_LSX_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_LOONGARCH_LSX) #define SIMDE_LOONGARCH_LSX_NATIVE #endif #endif #if defined(SIMDE_LOONGARCH_LASX_NATIVE) #include #endif #if defined(SIMDE_LOONGARCH_LSX_NATIVE) #include #endif #endif /* !defined(SIMDE_FEATURES_H) */ /* :: End simde-features.h :: */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-math.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2017-2020 Evan Nemerson */ /* Attempt to find math functions. Functions may be in , * , compiler built-ins/intrinsics, or platform/architecture * specific headers. In some cases, especially those not built in to * libm, we may need to define our own implementations. */ #if !defined(SIMDE_MATH_H) #define SIMDE_MATH_H 1 /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ #include #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) #include #endif HEDLEY_DIAGNOSTIC_PUSH SIMDE_DISABLE_UNWANTED_DIAGNOSTICS /* SLEEF support * https://sleef.org/ * * If you include prior to including SIMDe, SIMDe will use * SLEEF. You can also define SIMDE_MATH_SLEEF_ENABLE prior to * including SIMDe to force the issue. * * Note that SLEEF does requires linking to libsleef. * * By default, SIMDe will use the 1 ULP functions, but if you use * SIMDE_ACCURACY_PREFERENCE of 0 we will use up to 4 ULP. This is * only the case for the simde_math_* functions; for code in other * SIMDe headers which calls SLEEF directly we may use functions with * greater error if the API we're implementing is less precise (for * example, SVML guarantees 4 ULP, so we will generally use the 3.5 * ULP functions from SLEEF). */ #if !defined(SIMDE_MATH_SLEEF_DISABLE) #if defined(__SLEEF_H__) #define SIMDE_MATH_SLEEF_ENABLE #endif #endif #if defined(SIMDE_MATH_SLEEF_ENABLE) && !defined(__SLEEF_H__) HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_IGNORED_QUALIFIERS_ #include HEDLEY_DIAGNOSTIC_POP #endif #if defined(SIMDE_MATH_SLEEF_ENABLE) && defined(__SLEEF_H__) #if defined(SLEEF_VERSION_MAJOR) #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (HEDLEY_VERSION_ENCODE(SLEEF_VERSION_MAJOR, SLEEF_VERSION_MINOR, SLEEF_VERSION_PATCHLEVEL) >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #else #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (HEDLEY_VERSION_ENCODE(3,0,0) >= HEDLEY_VERSION_ENCODE(major, minor, patch)) #endif #else #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (0) #endif #if defined(__has_builtin) #define SIMDE_MATH_BUILTIN_LIBM(func) __has_builtin(__builtin_##func) #elif \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_GCC_VERSION_CHECK(4,4,0) #define SIMDE_MATH_BUILTIN_LIBM(func) (1) #else #define SIMDE_MATH_BUILTIN_LIBM(func) (0) #endif #if defined(HUGE_VAL) /* Looks like or has already been included. */ /* The math.h from libc++ (yes, the C header from the C++ standard * library) will define an isnan function, but not an isnan macro * like the C standard requires. So we detect the header guards * macro libc++ uses. */ #if defined(isnan) || (defined(_LIBCPP_MATH_H) && !defined(_LIBCPP_CMATH)) #define SIMDE_MATH_HAVE_MATH_H #elif defined(__cplusplus) #define SIMDE_MATH_HAVE_CMATH #endif #elif defined(__has_include) #if defined(__cplusplus) && (__cplusplus >= 201103L) && __has_include() #define SIMDE_MATH_HAVE_CMATH #include #elif __has_include() #define SIMDE_MATH_HAVE_MATH_H #include #elif !defined(SIMDE_MATH_NO_LIBM) #define SIMDE_MATH_NO_LIBM #endif #elif !defined(SIMDE_MATH_NO_LIBM) #if defined(__cplusplus) && (__cplusplus >= 201103L) #define SIMDE_MATH_HAVE_CMATH HEDLEY_DIAGNOSTIC_PUSH #if defined(HEDLEY_MSVC_VERSION) /* VS 14 emits this diagnostic about noexcept being used on a * function, which we can't do anything about. */ #pragma warning(disable:4996) #endif #include HEDLEY_DIAGNOSTIC_POP #else #define SIMDE_MATH_HAVE_MATH_H #include #endif #endif #if !defined(SIMDE_MATH_INFINITY) #if \ HEDLEY_HAS_BUILTIN(__builtin_inf) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) #define SIMDE_MATH_INFINITY (__builtin_inf()) #elif defined(INFINITY) #define SIMDE_MATH_INFINITY INFINITY #endif #endif #if !defined(SIMDE_INFINITYF) #if \ HEDLEY_HAS_BUILTIN(__builtin_inff) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) #define SIMDE_MATH_INFINITYF (__builtin_inff()) #elif defined(INFINITYF) #define SIMDE_MATH_INFINITYF INFINITYF #elif defined(SIMDE_MATH_INFINITY) #define SIMDE_MATH_INFINITYF HEDLEY_STATIC_CAST(float, SIMDE_MATH_INFINITY) #endif #endif #if !defined(SIMDE_MATH_NAN) #if \ HEDLEY_HAS_BUILTIN(__builtin_nan) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) #define SIMDE_MATH_NAN (__builtin_nan("")) #elif defined(NAN) #define SIMDE_MATH_NAN NAN #endif #endif #if !defined(SIMDE_NANF) #if \ HEDLEY_HAS_BUILTIN(__builtin_nanf) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) #define SIMDE_MATH_NANF (__builtin_nanf("")) #elif defined(NANF) #define SIMDE_MATH_NANF NANF #elif defined(SIMDE_MATH_NAN) #define SIMDE_MATH_NANF HEDLEY_STATIC_CAST(float, SIMDE_MATH_NAN) #endif #endif #if !defined(SIMDE_MATH_PI) #if defined(M_PI) #define SIMDE_MATH_PI M_PI #else #define SIMDE_MATH_PI 3.14159265358979323846 #endif #endif #if !defined(SIMDE_MATH_PIF) #if defined(M_PI) #define SIMDE_MATH_PIF HEDLEY_STATIC_CAST(float, M_PI) #else #define SIMDE_MATH_PIF 3.14159265358979323846f #endif #endif #if !defined(SIMDE_MATH_PI_OVER_180) #define SIMDE_MATH_PI_OVER_180 0.0174532925199432957692369076848861271344287188854172545609719144 #endif #if !defined(SIMDE_MATH_PI_OVER_180F) #define SIMDE_MATH_PI_OVER_180F 0.0174532925199432957692369076848861271344287188854172545609719144f #endif #if !defined(SIMDE_MATH_180_OVER_PI) #define SIMDE_MATH_180_OVER_PI 57.295779513082320876798154814105170332405472466564321549160243861 #endif #if !defined(SIMDE_MATH_180_OVER_PIF) #define SIMDE_MATH_180_OVER_PIF 57.295779513082320876798154814105170332405472466564321549160243861f #endif #if !defined(SIMDE_MATH_FLT_MIN) #if defined(__FLT_MIN__) #define SIMDE_MATH_FLT_MIN __FLT_MIN__ #else #if !defined(FLT_MIN) #if defined(__cplusplus) #include #else #include #endif #endif #define SIMDE_MATH_FLT_MIN FLT_MIN #endif #endif #if !defined(SIMDE_MATH_FLT_MAX) #if defined(__FLT_MAX__) #define SIMDE_MATH_FLT_MAX __FLT_MAX__ #else #if !defined(FLT_MAX) #if defined(__cplusplus) #include #else #include #endif #endif #define SIMDE_MATH_FLT_MAX FLT_MAX #endif #endif #if !defined(SIMDE_MATH_DBL_MIN) #if defined(__DBL_MIN__) #define SIMDE_MATH_DBL_MIN __DBL_MIN__ #else #if !defined(DBL_MIN) #if defined(__cplusplus) #include #else #include #endif #endif #define SIMDE_MATH_DBL_MIN DBL_MIN #endif #endif #if !defined(SIMDE_MATH_DBL_MAX) #if defined(__DBL_MAX__) #define SIMDE_MATH_DBL_MAX __DBL_MAX__ #else #if !defined(DBL_MAX) #if defined(__cplusplus) #include #else #include #endif #endif #define SIMDE_MATH_DBL_MAX DBL_MAX #endif #endif /*** Classification macros from C99 ***/ #if !defined(simde_math_isinf) #if SIMDE_MATH_BUILTIN_LIBM(isinf) #define simde_math_isinf(v) __builtin_isinf(v) #elif defined(isinf) || defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_isinf(v) isinf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isinf(v) std::isinf(v) #endif #endif #if !defined(simde_math_isinff) #if HEDLEY_HAS_BUILTIN(__builtin_isinff) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) #define simde_math_isinff(v) __builtin_isinff(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isinff(v) std::isinf(v) #elif defined(simde_math_isinf) #define simde_math_isinff(v) simde_math_isinf(HEDLEY_STATIC_CAST(double, v)) #endif #endif #if !defined(simde_math_isnan) #if SIMDE_MATH_BUILTIN_LIBM(isnan) #define simde_math_isnan(v) __builtin_isnan(v) #elif defined(isnan) || defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_isnan(v) isnan(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isnan(v) std::isnan(v) #endif #endif #if !defined(simde_math_isnanf) #if HEDLEY_HAS_BUILTIN(__builtin_isnanf) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) /* XL C/C++ has __builtin_isnan but not __builtin_isnanf */ #define simde_math_isnanf(v) __builtin_isnanf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isnanf(v) std::isnan(v) #elif defined(simde_math_isnan) #define simde_math_isnanf(v) simde_math_isnan(HEDLEY_STATIC_CAST(double, v)) #endif #endif #if !defined(simde_math_isnormal) #if SIMDE_MATH_BUILTIN_LIBM(isnormal) #define simde_math_isnormal(v) __builtin_isnormal(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_isnormal(v) isnormal(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isnormal(v) std::isnormal(v) #endif #endif #if !defined(simde_math_isnormalf) #if HEDLEY_HAS_BUILTIN(__builtin_isnormalf) #define simde_math_isnormalf(v) __builtin_isnormalf(v) #elif SIMDE_MATH_BUILTIN_LIBM(isnormal) #define simde_math_isnormalf(v) __builtin_isnormal(v) #elif defined(isnormalf) #define simde_math_isnormalf(v) isnormalf(v) #elif defined(isnormal) || defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_isnormalf(v) isnormal(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_isnormalf(v) std::isnormal(v) #elif defined(simde_math_isnormal) #define simde_math_isnormalf(v) simde_math_isnormal(v) #endif #endif #if !defined(simde_math_issubnormalf) #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) #define simde_math_issubnormalf(v) __builtin_fpclassify(0, 0, 0, 1, 0, v) #elif defined(fpclassify) #define simde_math_issubnormalf(v) (fpclassify(v) == FP_SUBNORMAL) #elif defined(SIMDE_IEEE754_STORAGE) #define simde_math_issubnormalf(v) (((simde_float32_as_uint32(v) & UINT32_C(0x7F800000)) == UINT32_C(0)) && ((simde_float32_as_uint32(v) & UINT32_C(0x007FFFFF)) != UINT32_C(0))) #endif #endif #if !defined(simde_math_issubnormal) #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) #define simde_math_issubnormal(v) __builtin_fpclassify(0, 0, 0, 1, 0, v) #elif defined(fpclassify) #define simde_math_issubnormal(v) (fpclassify(v) == FP_SUBNORMAL) #elif defined(SIMDE_IEEE754_STORAGE) #define simde_math_issubnormal(v) (((simde_float64_as_uint64(v) & UINT64_C(0x7FF0000000000000)) == UINT64_C(0)) && ((simde_float64_as_uint64(v) & UINT64_C(0x00FFFFFFFFFFFFF)) != UINT64_C(0))) #endif #endif #if defined(FP_NAN) #define SIMDE_MATH_FP_NAN FP_NAN #else #define SIMDE_MATH_FP_NAN 0 #endif #if defined(FP_INFINITE) #define SIMDE_MATH_FP_INFINITE FP_INFINITE #else #define SIMDE_MATH_FP_INFINITE 1 #endif #if defined(FP_ZERO) #define SIMDE_MATH_FP_ZERO FP_ZERO #else #define SIMDE_MATH_FP_ZERO 2 #endif #if defined(FP_SUBNORMAL) #define SIMDE_MATH_FP_SUBNORMAL FP_SUBNORMAL #else #define SIMDE_MATH_FP_SUBNORMAL 3 #endif #if defined(FP_NORMAL) #define SIMDE_MATH_FP_NORMAL FP_NORMAL #else #define SIMDE_MATH_FP_NORMAL 4 #endif static HEDLEY_INLINE int simde_math_fpclassifyf(float v) { #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) return __builtin_fpclassify(SIMDE_MATH_FP_NAN, SIMDE_MATH_FP_INFINITE, SIMDE_MATH_FP_NORMAL, SIMDE_MATH_FP_SUBNORMAL, SIMDE_MATH_FP_ZERO, v); #elif defined(fpclassify) return fpclassify(v); #else return simde_math_isnormalf(v) ? SIMDE_MATH_FP_NORMAL : (v == 0.0f) ? SIMDE_MATH_FP_ZERO : simde_math_isnanf(v) ? SIMDE_MATH_FP_NAN : simde_math_isinff(v) ? SIMDE_MATH_FP_INFINITE : SIMDE_MATH_FP_SUBNORMAL; #endif } static HEDLEY_INLINE int simde_math_fpclassify(double v) { #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) return __builtin_fpclassify(SIMDE_MATH_FP_NAN, SIMDE_MATH_FP_INFINITE, SIMDE_MATH_FP_NORMAL, SIMDE_MATH_FP_SUBNORMAL, SIMDE_MATH_FP_ZERO, v); #elif defined(fpclassify) return fpclassify(v); #else return simde_math_isnormal(v) ? SIMDE_MATH_FP_NORMAL : (v == 0.0) ? SIMDE_MATH_FP_ZERO : simde_math_isnan(v) ? SIMDE_MATH_FP_NAN : simde_math_isinf(v) ? SIMDE_MATH_FP_INFINITE : SIMDE_MATH_FP_SUBNORMAL; #endif } /*** Manipulation functions ***/ #if !defined(simde_math_nextafter) #if \ (HEDLEY_HAS_BUILTIN(__builtin_nextafter) && !defined(HEDLEY_IBM_VERSION)) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) #define simde_math_nextafter(x, y) __builtin_nextafter(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_nextafter(x, y) std::nextafter(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_nextafter(x, y) nextafter(x, y) #endif #endif #if !defined(simde_math_nextafterf) #if \ (HEDLEY_HAS_BUILTIN(__builtin_nextafterf) && !defined(HEDLEY_IBM_VERSION)) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) #define simde_math_nextafterf(x, y) __builtin_nextafterf(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_nextafterf(x, y) std::nextafter(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_nextafterf(x, y) nextafterf(x, y) #endif #endif /*** Functions from C99 ***/ #if !defined(simde_math_abs) #if SIMDE_MATH_BUILTIN_LIBM(abs) #define simde_math_abs(v) __builtin_abs(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_abs(v) std::abs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_abs(v) abs(v) #endif #endif #if !defined(simde_math_labs) #if SIMDE_MATH_BUILTIN_LIBM(labs) #define simde_math_labs(v) __builtin_labs(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_labs(v) std::labs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_labs(v) labs(v) #endif #endif #if !defined(simde_math_llabs) #if SIMDE_MATH_BUILTIN_LIBM(llabs) #define simde_math_llabs(v) __builtin_llabs(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_llabs(v) std::llabs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_llabs(v) llabs(v) #endif #endif #if !defined(simde_math_fabsf) #if SIMDE_MATH_BUILTIN_LIBM(fabsf) #define simde_math_fabsf(v) __builtin_fabsf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fabsf(v) std::abs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fabsf(v) fabsf(v) #endif #endif #if !defined(simde_math_acos) #if SIMDE_MATH_BUILTIN_LIBM(acos) #define simde_math_acos(v) __builtin_acos(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_acos(v) std::acos(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_acos(v) acos(v) #endif #endif #if !defined(simde_math_acosf) #if SIMDE_MATH_BUILTIN_LIBM(acosf) #define simde_math_acosf(v) __builtin_acosf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_acosf(v) std::acos(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_acosf(v) acosf(v) #endif #endif #if !defined(simde_math_acosh) #if SIMDE_MATH_BUILTIN_LIBM(acosh) #define simde_math_acosh(v) __builtin_acosh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_acosh(v) std::acosh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_acosh(v) acosh(v) #endif #endif #if !defined(simde_math_acoshf) #if SIMDE_MATH_BUILTIN_LIBM(acoshf) #define simde_math_acoshf(v) __builtin_acoshf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_acoshf(v) std::acosh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_acoshf(v) acoshf(v) #endif #endif #if !defined(simde_math_asin) #if SIMDE_MATH_BUILTIN_LIBM(asin) #define simde_math_asin(v) __builtin_asin(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_asin(v) std::asin(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_asin(v) asin(v) #endif #endif #if !defined(simde_math_asinf) #if SIMDE_MATH_BUILTIN_LIBM(asinf) #define simde_math_asinf(v) __builtin_asinf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_asinf(v) std::asin(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_asinf(v) asinf(v) #endif #endif #if !defined(simde_math_asinh) #if SIMDE_MATH_BUILTIN_LIBM(asinh) #define simde_math_asinh(v) __builtin_asinh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_asinh(v) std::asinh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_asinh(v) asinh(v) #endif #endif #if !defined(simde_math_asinhf) #if SIMDE_MATH_BUILTIN_LIBM(asinhf) #define simde_math_asinhf(v) __builtin_asinhf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_asinhf(v) std::asinh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_asinhf(v) asinhf(v) #endif #endif #if !defined(simde_math_atan) #if SIMDE_MATH_BUILTIN_LIBM(atan) #define simde_math_atan(v) __builtin_atan(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atan(v) std::atan(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atan(v) atan(v) #endif #endif #if !defined(simde_math_atan2) #if SIMDE_MATH_BUILTIN_LIBM(atan2) #define simde_math_atan2(y, x) __builtin_atan2(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atan2(y, x) std::atan2(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atan2(y, x) atan2(y, x) #endif #endif #if !defined(simde_math_atan2f) #if SIMDE_MATH_BUILTIN_LIBM(atan2f) #define simde_math_atan2f(y, x) __builtin_atan2f(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atan2f(y, x) std::atan2(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atan2f(y, x) atan2f(y, x) #endif #endif #if !defined(simde_math_atanf) #if SIMDE_MATH_BUILTIN_LIBM(atanf) #define simde_math_atanf(v) __builtin_atanf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atanf(v) std::atan(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atanf(v) atanf(v) #endif #endif #if !defined(simde_math_atanh) #if SIMDE_MATH_BUILTIN_LIBM(atanh) #define simde_math_atanh(v) __builtin_atanh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atanh(v) std::atanh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atanh(v) atanh(v) #endif #endif #if !defined(simde_math_atanhf) #if SIMDE_MATH_BUILTIN_LIBM(atanhf) #define simde_math_atanhf(v) __builtin_atanhf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_atanhf(v) std::atanh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_atanhf(v) atanhf(v) #endif #endif #if !defined(simde_math_cbrt) #if SIMDE_MATH_BUILTIN_LIBM(cbrt) #define simde_math_cbrt(v) __builtin_cbrt(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_cbrt(v) std::cbrt(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_cbrt(v) cbrt(v) #endif #endif #if !defined(simde_math_cbrtf) #if SIMDE_MATH_BUILTIN_LIBM(cbrtf) #define simde_math_cbrtf(v) __builtin_cbrtf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_cbrtf(v) std::cbrt(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_cbrtf(v) cbrtf(v) #endif #endif #if !defined(simde_math_ceil) #if SIMDE_MATH_BUILTIN_LIBM(ceil) #define simde_math_ceil(v) __builtin_ceil(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_ceil(v) std::ceil(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_ceil(v) ceil(v) #endif #endif #if !defined(simde_math_ceilf) #if SIMDE_MATH_BUILTIN_LIBM(ceilf) #define simde_math_ceilf(v) __builtin_ceilf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_ceilf(v) std::ceil(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_ceilf(v) ceilf(v) #endif #endif #if !defined(simde_math_copysign) #if SIMDE_MATH_BUILTIN_LIBM(copysign) #define simde_math_copysign(x, y) __builtin_copysign(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_copysign(x, y) std::copysign(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_copysign(x, y) copysign(x, y) #endif #endif #if !defined(simde_math_copysignf) #if SIMDE_MATH_BUILTIN_LIBM(copysignf) #define simde_math_copysignf(x, y) __builtin_copysignf(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_copysignf(x, y) std::copysignf(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_copysignf(x, y) copysignf(x, y) #endif #endif #if !defined(simde_math_signbit) #if SIMDE_MATH_BUILTIN_LIBM(signbit) #if (!defined(__clang__) || SIMDE_DETECT_CLANG_VERSION_CHECK(7,0,0)) #define simde_math_signbit(x) __builtin_signbit(x) #else #define simde_math_signbit(x) __builtin_signbit(HEDLEY_STATIC_CAST(double, (x))) #endif #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_signbit(x) std::signbit(x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_signbit(x) signbit(x) #endif #endif #if !defined(simde_math_cos) #if SIMDE_MATH_BUILTIN_LIBM(cos) #define simde_math_cos(v) __builtin_cos(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_cos(v) std::cos(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_cos(v) cos(v) #endif #endif #if !defined(simde_math_cosf) #if defined(SIMDE_MATH_SLEEF_ENABLE) #if SIMDE_ACCURACY_PREFERENCE < 1 #define simde_math_cosf(v) Sleef_cosf_u35(v) #else #define simde_math_cosf(v) Sleef_cosf_u10(v) #endif #elif SIMDE_MATH_BUILTIN_LIBM(cosf) #define simde_math_cosf(v) __builtin_cosf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_cosf(v) std::cos(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_cosf(v) cosf(v) #endif #endif #if !defined(simde_math_cosh) #if SIMDE_MATH_BUILTIN_LIBM(cosh) #define simde_math_cosh(v) __builtin_cosh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_cosh(v) std::cosh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_cosh(v) cosh(v) #endif #endif #if !defined(simde_math_coshf) #if SIMDE_MATH_BUILTIN_LIBM(coshf) #define simde_math_coshf(v) __builtin_coshf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_coshf(v) std::cosh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_coshf(v) coshf(v) #endif #endif #if !defined(simde_math_erf) #if SIMDE_MATH_BUILTIN_LIBM(erf) #define simde_math_erf(v) __builtin_erf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_erf(v) std::erf(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_erf(v) erf(v) #endif #endif #if !defined(simde_math_erff) #if SIMDE_MATH_BUILTIN_LIBM(erff) #define simde_math_erff(v) __builtin_erff(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_erff(v) std::erf(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_erff(v) erff(v) #endif #endif #if !defined(simde_math_erfc) #if SIMDE_MATH_BUILTIN_LIBM(erfc) #define simde_math_erfc(v) __builtin_erfc(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_erfc(v) std::erfc(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_erfc(v) erfc(v) #endif #endif #if !defined(simde_math_erfcf) #if SIMDE_MATH_BUILTIN_LIBM(erfcf) #define simde_math_erfcf(v) __builtin_erfcf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_erfcf(v) std::erfc(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_erfcf(v) erfcf(v) #endif #endif #if !defined(simde_math_exp) #if SIMDE_MATH_BUILTIN_LIBM(exp) #define simde_math_exp(v) __builtin_exp(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_exp(v) std::exp(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_exp(v) exp(v) #endif #endif #if !defined(simde_math_expf) #if SIMDE_MATH_BUILTIN_LIBM(expf) #define simde_math_expf(v) __builtin_expf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_expf(v) std::exp(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_expf(v) expf(v) #endif #endif #if !defined(simde_math_expm1) #if SIMDE_MATH_BUILTIN_LIBM(expm1) #define simde_math_expm1(v) __builtin_expm1(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_expm1(v) std::expm1(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_expm1(v) expm1(v) #endif #endif #if !defined(simde_math_expm1f) #if SIMDE_MATH_BUILTIN_LIBM(expm1f) #define simde_math_expm1f(v) __builtin_expm1f(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_expm1f(v) std::expm1(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_expm1f(v) expm1f(v) #endif #endif #if !defined(simde_math_exp2) #if SIMDE_MATH_BUILTIN_LIBM(exp2) #define simde_math_exp2(v) __builtin_exp2(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_exp2(v) std::exp2(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_exp2(v) exp2(v) #endif #endif #if !defined(simde_math_exp2f) #if SIMDE_MATH_BUILTIN_LIBM(exp2f) #define simde_math_exp2f(v) __builtin_exp2f(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_exp2f(v) std::exp2(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_exp2f(v) exp2f(v) #endif #endif #if HEDLEY_HAS_BUILTIN(__builtin_exp10) || HEDLEY_GCC_VERSION_CHECK(3,4,0) # define simde_math_exp10(v) __builtin_exp10(v) #else # define simde_math_exp10(v) pow(10.0, (v)) #endif #if HEDLEY_HAS_BUILTIN(__builtin_exp10f) || HEDLEY_GCC_VERSION_CHECK(3,4,0) # define simde_math_exp10f(v) __builtin_exp10f(v) #else # define simde_math_exp10f(v) powf(10.0f, (v)) #endif #if !defined(simde_math_fabs) #if SIMDE_MATH_BUILTIN_LIBM(fabs) #define simde_math_fabs(v) __builtin_fabs(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fabs(v) std::fabs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fabs(v) fabs(v) #endif #endif #if !defined(simde_math_fabsf) #if SIMDE_MATH_BUILTIN_LIBM(fabsf) #define simde_math_fabsf(v) __builtin_fabsf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fabsf(v) std::fabs(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fabsf(v) fabsf(v) #endif #endif #if !defined(simde_math_floor) #if SIMDE_MATH_BUILTIN_LIBM(floor) #define simde_math_floor(v) __builtin_floor(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_floor(v) std::floor(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_floor(v) floor(v) #endif #endif #if !defined(simde_math_floorf) #if SIMDE_MATH_BUILTIN_LIBM(floorf) #define simde_math_floorf(v) __builtin_floorf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_floorf(v) std::floor(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_floorf(v) floorf(v) #endif #endif #if !defined(simde_math_fma) #if SIMDE_MATH_BUILTIN_LIBM(fma) #define simde_math_fma(x, y, z) __builtin_fma(x, y, z) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fma(x, y, z) std::fma(x, y, z) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fma(x, y, z) fma(x, y, z) #endif #endif #if !defined(simde_math_fmaf) #if SIMDE_MATH_BUILTIN_LIBM(fmaf) #define simde_math_fmaf(x, y, z) __builtin_fmaf(x, y, z) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fmaf(x, y, z) std::fma(x, y, z) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fmaf(x, y, z) fmaf(x, y, z) #endif #endif #if !defined(simde_math_fmax) #if SIMDE_MATH_BUILTIN_LIBM(fmax) #define simde_math_fmax(x, y) __builtin_fmax(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fmax(x, y) std::fmax(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fmax(x, y) fmax(x, y) #endif #endif #if !defined(simde_math_fmaxf) #if SIMDE_MATH_BUILTIN_LIBM(fmaxf) #define simde_math_fmaxf(x, y) __builtin_fmaxf(x, y) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_fmaxf(x, y) std::fmax(x, y) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_fmaxf(x, y) fmaxf(x, y) #endif #endif #if !defined(simde_math_hypot) #if SIMDE_MATH_BUILTIN_LIBM(hypot) #define simde_math_hypot(y, x) __builtin_hypot(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_hypot(y, x) std::hypot(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_hypot(y, x) hypot(y, x) #endif #endif #if !defined(simde_math_hypotf) #if SIMDE_MATH_BUILTIN_LIBM(hypotf) #define simde_math_hypotf(y, x) __builtin_hypotf(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_hypotf(y, x) std::hypot(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_hypotf(y, x) hypotf(y, x) #endif #endif #if !defined(simde_math_log) #if SIMDE_MATH_BUILTIN_LIBM(log) #define simde_math_log(v) __builtin_log(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log(v) std::log(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log(v) log(v) #endif #endif #if !defined(simde_math_logf) #if SIMDE_MATH_BUILTIN_LIBM(logf) #define simde_math_logf(v) __builtin_logf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_logf(v) std::log(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_logf(v) logf(v) #endif #endif #if !defined(simde_math_logb) #if SIMDE_MATH_BUILTIN_LIBM(logb) #define simde_math_logb(v) __builtin_logb(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_logb(v) std::logb(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_logb(v) logb(v) #endif #endif #if !defined(simde_math_logbf) #if SIMDE_MATH_BUILTIN_LIBM(logbf) #define simde_math_logbf(v) __builtin_logbf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_logbf(v) std::logb(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_logbf(v) logbf(v) #endif #endif #if !defined(simde_math_log1p) #if SIMDE_MATH_BUILTIN_LIBM(log1p) #define simde_math_log1p(v) __builtin_log1p(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log1p(v) std::log1p(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log1p(v) log1p(v) #endif #endif #if !defined(simde_math_log1pf) #if SIMDE_MATH_BUILTIN_LIBM(log1pf) #define simde_math_log1pf(v) __builtin_log1pf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log1pf(v) std::log1p(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log1pf(v) log1pf(v) #endif #endif #if !defined(simde_math_log2) #if SIMDE_MATH_BUILTIN_LIBM(log2) #define simde_math_log2(v) __builtin_log2(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log2(v) std::log2(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log2(v) log2(v) #endif #endif #if !defined(simde_math_log2f) #if SIMDE_MATH_BUILTIN_LIBM(log2f) #define simde_math_log2f(v) __builtin_log2f(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log2f(v) std::log2(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log2f(v) log2f(v) #endif #endif #if !defined(simde_math_log10) #if SIMDE_MATH_BUILTIN_LIBM(log10) #define simde_math_log10(v) __builtin_log10(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log10(v) std::log10(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log10(v) log10(v) #endif #endif #if !defined(simde_math_log10f) #if SIMDE_MATH_BUILTIN_LIBM(log10f) #define simde_math_log10f(v) __builtin_log10f(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_log10f(v) std::log10(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_log10f(v) log10f(v) #endif #endif #if !defined(simde_math_modf) #if SIMDE_MATH_BUILTIN_LIBM(modf) #define simde_math_modf(x, iptr) __builtin_modf(x, iptr) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_modf(x, iptr) std::modf(x, iptr) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_modf(x, iptr) modf(x, iptr) #endif #endif #if !defined(simde_math_modff) #if SIMDE_MATH_BUILTIN_LIBM(modff) #define simde_math_modff(x, iptr) __builtin_modff(x, iptr) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_modff(x, iptr) std::modf(x, iptr) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_modff(x, iptr) modff(x, iptr) #endif #endif #if !defined(simde_math_nearbyint) #if SIMDE_MATH_BUILTIN_LIBM(nearbyint) #define simde_math_nearbyint(v) __builtin_nearbyint(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_nearbyint(v) std::nearbyint(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_nearbyint(v) nearbyint(v) #endif #endif #if !defined(simde_math_nearbyintf) #if SIMDE_MATH_BUILTIN_LIBM(nearbyintf) #define simde_math_nearbyintf(v) __builtin_nearbyintf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_nearbyintf(v) std::nearbyint(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_nearbyintf(v) nearbyintf(v) #endif #endif #if !defined(simde_math_pow) #if SIMDE_MATH_BUILTIN_LIBM(pow) #define simde_math_pow(y, x) __builtin_pow(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_pow(y, x) std::pow(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_pow(y, x) pow(y, x) #endif #endif #if !defined(simde_math_powf) #if SIMDE_MATH_BUILTIN_LIBM(powf) #define simde_math_powf(y, x) __builtin_powf(y, x) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_powf(y, x) std::pow(y, x) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_powf(y, x) powf(y, x) #endif #endif #if !defined(simde_math_rint) #if SIMDE_MATH_BUILTIN_LIBM(rint) #define simde_math_rint(v) __builtin_rint(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_rint(v) std::rint(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_rint(v) rint(v) #endif #endif #if !defined(simde_math_rintf) #if SIMDE_MATH_BUILTIN_LIBM(rintf) #define simde_math_rintf(v) __builtin_rintf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_rintf(v) std::rint(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_rintf(v) rintf(v) #endif #endif #if !defined(simde_math_round) #if SIMDE_MATH_BUILTIN_LIBM(round) #define simde_math_round(v) __builtin_round(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_round(v) std::round(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_round(v) round(v) #endif #endif #if !defined(simde_math_roundf) #if SIMDE_MATH_BUILTIN_LIBM(roundf) #define simde_math_roundf(v) __builtin_roundf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_roundf(v) std::round(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_roundf(v) roundf(v) #endif #endif #if !defined(simde_math_roundeven) #if \ (!defined(HEDLEY_EMSCRIPTEN_VERSION) && HEDLEY_HAS_BUILTIN(__builtin_roundeven)) || \ HEDLEY_GCC_VERSION_CHECK(10,0,0) #define simde_math_roundeven(v) __builtin_roundeven(v) #elif defined(simde_math_round) && defined(simde_math_fabs) static HEDLEY_INLINE double simde_math_roundeven(double v) { double rounded = simde_math_round(v); double diff = rounded - v; if (HEDLEY_UNLIKELY(simde_math_fabs(diff) == 0.5) && (HEDLEY_STATIC_CAST(int64_t, rounded) & 1)) { rounded = v - diff; } return rounded; } #define simde_math_roundeven simde_math_roundeven #endif #endif #if !defined(simde_math_roundevenf) #if \ (!defined(HEDLEY_EMSCRIPTEN_VERSION) && HEDLEY_HAS_BUILTIN(__builtin_roundevenf)) || \ HEDLEY_GCC_VERSION_CHECK(10,0,0) #define simde_math_roundevenf(v) __builtin_roundevenf(v) #elif defined(simde_math_roundf) && defined(simde_math_fabsf) static HEDLEY_INLINE float simde_math_roundevenf(float v) { float rounded = simde_math_roundf(v); float diff = rounded - v; if (HEDLEY_UNLIKELY(simde_math_fabsf(diff) == 0.5f) && (HEDLEY_STATIC_CAST(int32_t, rounded) & 1)) { rounded = v - diff; } return rounded; } #define simde_math_roundevenf simde_math_roundevenf #endif #endif #if !defined(simde_math_sin) #if SIMDE_MATH_BUILTIN_LIBM(sin) #define simde_math_sin(v) __builtin_sin(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sin(v) std::sin(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sin(v) sin(v) #endif #endif #if !defined(simde_math_sinf) #if SIMDE_MATH_BUILTIN_LIBM(sinf) #define simde_math_sinf(v) __builtin_sinf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sinf(v) std::sin(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sinf(v) sinf(v) #endif #endif #if !defined(simde_math_sinh) #if SIMDE_MATH_BUILTIN_LIBM(sinh) #define simde_math_sinh(v) __builtin_sinh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sinh(v) std::sinh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sinh(v) sinh(v) #endif #endif #if !defined(simde_math_sinhf) #if SIMDE_MATH_BUILTIN_LIBM(sinhf) #define simde_math_sinhf(v) __builtin_sinhf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sinhf(v) std::sinh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sinhf(v) sinhf(v) #endif #endif #if !defined(simde_math_sqrt) #if SIMDE_MATH_BUILTIN_LIBM(sqrt) #define simde_math_sqrt(v) __builtin_sqrt(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sqrt(v) std::sqrt(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sqrt(v) sqrt(v) #endif #endif #if !defined(simde_math_sqrtf) #if SIMDE_MATH_BUILTIN_LIBM(sqrtf) #define simde_math_sqrtf(v) __builtin_sqrtf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_sqrtf(v) std::sqrt(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_sqrtf(v) sqrtf(v) #endif #endif #if !defined(simde_math_tan) #if SIMDE_MATH_BUILTIN_LIBM(tan) #define simde_math_tan(v) __builtin_tan(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_tan(v) std::tan(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_tan(v) tan(v) #endif #endif #if !defined(simde_math_tanf) #if SIMDE_MATH_BUILTIN_LIBM(tanf) #define simde_math_tanf(v) __builtin_tanf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_tanf(v) std::tan(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_tanf(v) tanf(v) #endif #endif #if !defined(simde_math_tanh) #if SIMDE_MATH_BUILTIN_LIBM(tanh) #define simde_math_tanh(v) __builtin_tanh(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_tanh(v) std::tanh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_tanh(v) tanh(v) #endif #endif #if !defined(simde_math_tanhf) #if SIMDE_MATH_BUILTIN_LIBM(tanhf) #define simde_math_tanhf(v) __builtin_tanhf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_tanhf(v) std::tanh(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_tanhf(v) tanhf(v) #endif #endif #if !defined(simde_math_trunc) #if SIMDE_MATH_BUILTIN_LIBM(trunc) #define simde_math_trunc(v) __builtin_trunc(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_trunc(v) std::trunc(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_trunc(v) trunc(v) #endif #endif #if !defined(simde_math_truncf) #if SIMDE_MATH_BUILTIN_LIBM(truncf) #define simde_math_truncf(v) __builtin_truncf(v) #elif defined(SIMDE_MATH_HAVE_CMATH) #define simde_math_truncf(v) std::trunc(v) #elif defined(SIMDE_MATH_HAVE_MATH_H) #define simde_math_truncf(v) truncf(v) #endif #endif /*** Comparison macros (which don't raise invalid errors) ***/ #if defined(isunordered) #define simde_math_isunordered(x, y) isunordered(x, y) #elif HEDLEY_HAS_BUILTIN(__builtin_isunordered) #define simde_math_isunordered(x, y) __builtin_isunordered(x, y) #else static HEDLEY_INLINE int simde_math_isunordered(double x, double y) { return (x != y) && (x != x || y != y); } #define simde_math_isunordered simde_math_isunordered static HEDLEY_INLINE int simde_math_isunorderedf(float x, float y) { return (x != y) && (x != x || y != y); } #define simde_math_isunorderedf simde_math_isunorderedf #endif #if !defined(simde_math_isunorderedf) #define simde_math_isunorderedf simde_math_isunordered #endif /*** Additional functions not in libm ***/ #if defined(simde_math_fabs) && defined(simde_math_sqrt) && defined(simde_math_exp) static HEDLEY_INLINE double simde_math_cdfnorm(double x) { /* https://www.johndcook.com/blog/cpp_phi/ * Public Domain */ static const double a1 = 0.254829592; static const double a2 = -0.284496736; static const double a3 = 1.421413741; static const double a4 = -1.453152027; static const double a5 = 1.061405429; static const double p = 0.3275911; const int sign = x < 0; x = simde_math_fabs(x) / simde_math_sqrt(2.0); /* A&S formula 7.1.26 */ double t = 1.0 / (1.0 + p * x); double y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * simde_math_exp(-x * x); return 0.5 * (1.0 + (sign ? -y : y)); } #define simde_math_cdfnorm simde_math_cdfnorm #endif #if defined(simde_math_fabsf) && defined(simde_math_sqrtf) && defined(simde_math_expf) static HEDLEY_INLINE float simde_math_cdfnormf(float x) { /* https://www.johndcook.com/blog/cpp_phi/ * Public Domain */ static const float a1 = 0.254829592f; static const float a2 = -0.284496736f; static const float a3 = 1.421413741f; static const float a4 = -1.453152027f; static const float a5 = 1.061405429f; static const float p = 0.3275911f; const int sign = x < 0; x = simde_math_fabsf(x) / simde_math_sqrtf(2.0f); /* A&S formula 7.1.26 */ float t = 1.0f / (1.0f + p * x); float y = 1.0f - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * simde_math_expf(-x * x); return 0.5f * (1.0f + (sign ? -y : y)); } #define simde_math_cdfnormf simde_math_cdfnormf #endif #if !defined(simde_math_cdfnorminv) && defined(simde_math_log) && defined(simde_math_sqrt) /*https://web.archive.org/web/20150910081113/http://home.online.no/~pjacklam/notes/invnorm/impl/sprouse/ltqnorm.c*/ static HEDLEY_INLINE double simde_math_cdfnorminv(double p) { static const double a[] = { -3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, 1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00 }; static const double b[] = { -5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, -1.328068155288572e+01 }; static const double c[] = { -7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00 }; static const double d[] = { 7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00 }; static const double low = 0.02425; static const double high = 0.97575; double q, r; if (p < 0 || p > 1) { return 0.0; } else if (p == 0) { return -SIMDE_MATH_INFINITY; } else if (p == 1) { return SIMDE_MATH_INFINITY; } else if (p < low) { q = simde_math_sqrt(-2.0 * simde_math_log(p)); return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); } else if (p > high) { q = simde_math_sqrt(-2.0 * simde_math_log(1.0 - p)); return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); } else { q = p - 0.5; r = q * q; return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1); } } #define simde_math_cdfnorminv simde_math_cdfnorminv #endif #if !defined(simde_math_cdfnorminvf) && defined(simde_math_logf) && defined(simde_math_sqrtf) static HEDLEY_INLINE float simde_math_cdfnorminvf(float p) { static const float a[] = { -3.969683028665376e+01f, 2.209460984245205e+02f, -2.759285104469687e+02f, 1.383577518672690e+02f, -3.066479806614716e+01f, 2.506628277459239e+00f }; static const float b[] = { -5.447609879822406e+01f, 1.615858368580409e+02f, -1.556989798598866e+02f, 6.680131188771972e+01f, -1.328068155288572e+01f }; static const float c[] = { -7.784894002430293e-03f, -3.223964580411365e-01f, -2.400758277161838e+00f, -2.549732539343734e+00f, 4.374664141464968e+00f, 2.938163982698783e+00f }; static const float d[] = { 7.784695709041462e-03f, 3.224671290700398e-01f, 2.445134137142996e+00f, 3.754408661907416e+00f }; static const float low = 0.02425f; static const float high = 0.97575f; float q, r; if (p < 0 || p > 1) { return 0.0f; } else if (p == 0) { return -SIMDE_MATH_INFINITYF; } else if (p == 1) { return SIMDE_MATH_INFINITYF; } else if (p < low) { q = simde_math_sqrtf(-2.0f * simde_math_logf(p)); return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); } else if (p > high) { q = simde_math_sqrtf(-2.0f * simde_math_logf(1.0f - p)); return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); } else { q = p - 0.5f; r = q * q; return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1); } } #define simde_math_cdfnorminvf simde_math_cdfnorminvf #endif #if !defined(simde_math_erfinv) && defined(simde_math_log) && defined(simde_math_copysign) && defined(simde_math_sqrt) static HEDLEY_INLINE double simde_math_erfinv(double x) { /* https://stackoverflow.com/questions/27229371/inverse-error-function-in-c * * The original answer on SO uses a constant of 0.147, but in my * testing 0.14829094707965850830078125 gives a lower average absolute error * (0.0001410958211636170744895935 vs. 0.0001465479290345683693885803). * That said, if your goal is to minimize the *maximum* absolute * error, 0.15449436008930206298828125 provides significantly better * results; 0.0009250640869140625000000000 vs ~ 0.005. */ double tt1, tt2, lnx; double sgn = simde_math_copysign(1.0, x); x = (1.0 - x) * (1.0 + x); lnx = simde_math_log(x); tt1 = 2.0 / (SIMDE_MATH_PI * 0.14829094707965850830078125) + 0.5 * lnx; tt2 = (1.0 / 0.14829094707965850830078125) * lnx; return sgn * simde_math_sqrt(-tt1 + simde_math_sqrt(tt1 * tt1 - tt2)); } #define simde_math_erfinv simde_math_erfinv #endif #if !defined(simde_math_erfinvf) && defined(simde_math_logf) && defined(simde_math_copysignf) && defined(simde_math_sqrtf) static HEDLEY_INLINE float simde_math_erfinvf(float x) { float tt1, tt2, lnx; float sgn = simde_math_copysignf(1.0f, x); x = (1.0f - x) * (1.0f + x); lnx = simde_math_logf(x); tt1 = 2.0f / (SIMDE_MATH_PIF * 0.14829094707965850830078125f) + 0.5f * lnx; tt2 = (1.0f / 0.14829094707965850830078125f) * lnx; return sgn * simde_math_sqrtf(-tt1 + simde_math_sqrtf(tt1 * tt1 - tt2)); } #define simde_math_erfinvf simde_math_erfinvf #endif #if !defined(simde_math_erfcinv) && defined(simde_math_erfinv) && defined(simde_math_log) && defined(simde_math_sqrt) static HEDLEY_INLINE double simde_math_erfcinv(double x) { if(x >= 0.0625 && x < 2.0) { return simde_math_erfinv(1.0 - x); } else if (x < 0.0625 && x >= 1.0e-100) { static const double p[6] = { 0.1550470003116, 1.382719649631, 0.690969348887, -1.128081391617, 0.680544246825, -0.16444156791 }; static const double q[3] = { 0.155024849822, 1.385228141995, 1.000000000000 }; const double t = 1.0 / simde_math_sqrt(-simde_math_log(x)); return (p[0] / t + p[1] + t * (p[2] + t * (p[3] + t * (p[4] + t * p[5])))) / (q[0] + t * (q[1] + t * (q[2]))); } else if (x < 1.0e-100 && x >= SIMDE_MATH_DBL_MIN) { static const double p[4] = { 0.00980456202915, 0.363667889171, 0.97302949837, -0.5374947401 }; static const double q[3] = { 0.00980451277802, 0.363699971544, 1.000000000000 }; const double t = 1.0 / simde_math_sqrt(-simde_math_log(x)); return (p[0] / t + p[1] + t * (p[2] + t * p[3])) / (q[0] + t * (q[1] + t * (q[2]))); } else if (!simde_math_isnormal(x)) { return SIMDE_MATH_INFINITY; } else { return -SIMDE_MATH_INFINITY; } } #define simde_math_erfcinv simde_math_erfcinv #endif #if !defined(simde_math_erfcinvf) && defined(simde_math_erfinvf) && defined(simde_math_logf) && defined(simde_math_sqrtf) static HEDLEY_INLINE float simde_math_erfcinvf(float x) { if(x >= 0.0625f && x < 2.0f) { return simde_math_erfinvf(1.0f - x); } else if (x < 0.0625f && x >= SIMDE_MATH_FLT_MIN) { static const float p[6] = { 0.1550470003116f, 1.382719649631f, 0.690969348887f, -1.128081391617f, 0.680544246825f -0.164441567910f }; static const float q[3] = { 0.155024849822f, 1.385228141995f, 1.000000000000f }; const float t = 1.0f / simde_math_sqrtf(-simde_math_logf(x)); return (p[0] / t + p[1] + t * (p[2] + t * (p[3] + t * (p[4] + t * p[5])))) / (q[0] + t * (q[1] + t * (q[2]))); } else if (x < SIMDE_MATH_FLT_MIN && simde_math_isnormalf(x)) { static const float p[4] = { 0.00980456202915f, 0.36366788917100f, 0.97302949837000f, -0.5374947401000f }; static const float q[3] = { 0.00980451277802f, 0.36369997154400f, 1.00000000000000f }; const float t = 1.0f / simde_math_sqrtf(-simde_math_logf(x)); return (p[0] / t + p[1] + t * (p[2] + t * p[3])) / (q[0] + t * (q[1] + t * (q[2]))); } else { return simde_math_isnormalf(x) ? -SIMDE_MATH_INFINITYF : SIMDE_MATH_INFINITYF; } } #define simde_math_erfcinvf simde_math_erfcinvf #endif static HEDLEY_INLINE double simde_math_rad2deg(double radians) { return radians * SIMDE_MATH_180_OVER_PI; } static HEDLEY_INLINE float simde_math_rad2degf(float radians) { return radians * SIMDE_MATH_180_OVER_PIF; } static HEDLEY_INLINE double simde_math_deg2rad(double degrees) { return degrees * SIMDE_MATH_PI_OVER_180; } static HEDLEY_INLINE float simde_math_deg2radf(float degrees) { return degrees * (SIMDE_MATH_PI_OVER_180F); } /*** Saturated arithmetic ***/ static HEDLEY_INLINE int8_t simde_math_adds_i8(int8_t a, int8_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddb_s8(a, b); #else uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a); uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b); uint8_t r_ = a_ + b_; a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT8_MAX; if (HEDLEY_STATIC_CAST(int8_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int8_t, r_); #endif } static HEDLEY_INLINE int16_t simde_math_adds_i16(int16_t a, int16_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddh_s16(a, b); #else uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a); uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b); uint16_t r_ = a_ + b_; a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT16_MAX; if (HEDLEY_STATIC_CAST(int16_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int16_t, r_); #endif } static HEDLEY_INLINE int32_t simde_math_adds_i32(int32_t a, int32_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqadds_s32(a, b); #else uint32_t a_ = HEDLEY_STATIC_CAST(uint32_t, a); uint32_t b_ = HEDLEY_STATIC_CAST(uint32_t, b); uint32_t r_ = a_ + b_; a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT32_MAX; if (HEDLEY_STATIC_CAST(int32_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int32_t, r_); #endif } static HEDLEY_INLINE int64_t simde_math_adds_i64(int64_t a, int64_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddd_s64(a, b); #else uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a); uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b); uint64_t r_ = a_ + b_; a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT64_MAX; if (HEDLEY_STATIC_CAST(int64_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int64_t, r_); #endif } static HEDLEY_INLINE uint8_t simde_math_adds_u8(uint8_t a, uint8_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddb_u8(a, b); #else uint8_t r = a + b; r |= -(r < a); return r; #endif } static HEDLEY_INLINE uint16_t simde_math_adds_u16(uint16_t a, uint16_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddh_u16(a, b); #else uint16_t r = a + b; r |= -(r < a); return r; #endif } static HEDLEY_INLINE uint32_t simde_math_adds_u32(uint32_t a, uint32_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqadds_u32(a, b); #else uint32_t r = a + b; r |= -(r < a); return r; #endif } static HEDLEY_INLINE uint64_t simde_math_adds_u64(uint64_t a, uint64_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqaddd_u64(a, b); #else uint64_t r = a + b; r |= -(r < a); return r; #endif } static HEDLEY_INLINE int8_t simde_math_subs_i8(int8_t a, int8_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubb_s8(a, b); #else uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a); uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b); uint8_t r_ = a_ - b_; a_ = (a_ >> 7) + INT8_MAX; if (HEDLEY_STATIC_CAST(int8_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int8_t, r_); #endif } static HEDLEY_INLINE int16_t simde_math_subs_i16(int16_t a, int16_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubh_s16(a, b); #else uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a); uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b); uint16_t r_ = a_ - b_; a_ = (a_ >> 15) + INT16_MAX; if (HEDLEY_STATIC_CAST(int16_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int16_t, r_); #endif } static HEDLEY_INLINE int32_t simde_math_subs_i32(int32_t a, int32_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubs_s32(a, b); #else uint32_t a_ = HEDLEY_STATIC_CAST(uint32_t, a); uint32_t b_ = HEDLEY_STATIC_CAST(uint32_t, b); uint32_t r_ = a_ - b_; a_ = (a_ >> 31) + INT32_MAX; if (HEDLEY_STATIC_CAST(int32_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int32_t, r_); #endif } static HEDLEY_INLINE int64_t simde_math_subs_i64(int64_t a, int64_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubd_s64(a, b); #else uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a); uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b); uint64_t r_ = a_ - b_; a_ = (a_ >> 63) + INT64_MAX; if (HEDLEY_STATIC_CAST(int64_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { r_ = a_; } return HEDLEY_STATIC_CAST(int64_t, r_); #endif } static HEDLEY_INLINE uint8_t simde_math_subs_u8(uint8_t a, uint8_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubb_u8(a, b); #else uint8_t res = a - b; res &= -(res <= a); return res; #endif } static HEDLEY_INLINE uint16_t simde_math_subs_u16(uint16_t a, uint16_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubh_u16(a, b); #else uint16_t res = a - b; res &= -(res <= a); return res; #endif } static HEDLEY_INLINE uint32_t simde_math_subs_u32(uint32_t a, uint32_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubs_u32(a, b); #else uint32_t res = a - b; res &= -(res <= a); return res; #endif } static HEDLEY_INLINE uint64_t simde_math_subs_u64(uint64_t a, uint64_t b) { #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vqsubd_u64(a, b); #else uint64_t res = a - b; res &= -(res <= a); return res; #endif } HEDLEY_DIAGNOSTIC_POP #endif /* !defined(SIMDE_MATH_H) */ /* :: End simde-math.h :: */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-constify.h :: */ /* SPDX-License-Identifier: MIT * * 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. * * Copyright: * 2020 Evan Nemerson */ /* Constify macros. For internal use only. * * These are used to make it possible to call a function which takes * an Integer Constant Expression (ICE) using a compile time constant. * Technically it would also be possible to use a value not trivially * known by the compiler, but there would be a siginficant performance * hit (a switch switch is used). * * The basic idea is pretty simple; we just emit a do while loop which * contains a switch with a case for every possible value of the * constant. * * As long as the value you pass to the function in constant, pretty * much any copmiler shouldn't have a problem generating exactly the * same code as if you had used an ICE. * * This is intended to be used in the SIMDe implementations of * functions the compilers require to be an ICE, but the other benefit * is that if we also disable the warnings from * SIMDE_REQUIRE_CONSTANT_RANGE we can actually just allow the tests * to use non-ICE parameters */ #if !defined(SIMDE_CONSTIFY_H) #define SIMDE_CONSTIFY_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_ SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ #define SIMDE_CONSTIFY_2_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_4_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ case 2: result = func_name(__VA_ARGS__, 2); break; \ case 3: result = func_name(__VA_ARGS__, 3); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_8_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ case 2: result = func_name(__VA_ARGS__, 2); break; \ case 3: result = func_name(__VA_ARGS__, 3); break; \ case 4: result = func_name(__VA_ARGS__, 4); break; \ case 5: result = func_name(__VA_ARGS__, 5); break; \ case 6: result = func_name(__VA_ARGS__, 6); break; \ case 7: result = func_name(__VA_ARGS__, 7); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_16_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ case 2: result = func_name(__VA_ARGS__, 2); break; \ case 3: result = func_name(__VA_ARGS__, 3); break; \ case 4: result = func_name(__VA_ARGS__, 4); break; \ case 5: result = func_name(__VA_ARGS__, 5); break; \ case 6: result = func_name(__VA_ARGS__, 6); break; \ case 7: result = func_name(__VA_ARGS__, 7); break; \ case 8: result = func_name(__VA_ARGS__, 8); break; \ case 9: result = func_name(__VA_ARGS__, 9); break; \ case 10: result = func_name(__VA_ARGS__, 10); break; \ case 11: result = func_name(__VA_ARGS__, 11); break; \ case 12: result = func_name(__VA_ARGS__, 12); break; \ case 13: result = func_name(__VA_ARGS__, 13); break; \ case 14: result = func_name(__VA_ARGS__, 14); break; \ case 15: result = func_name(__VA_ARGS__, 15); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_32_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ case 2: result = func_name(__VA_ARGS__, 2); break; \ case 3: result = func_name(__VA_ARGS__, 3); break; \ case 4: result = func_name(__VA_ARGS__, 4); break; \ case 5: result = func_name(__VA_ARGS__, 5); break; \ case 6: result = func_name(__VA_ARGS__, 6); break; \ case 7: result = func_name(__VA_ARGS__, 7); break; \ case 8: result = func_name(__VA_ARGS__, 8); break; \ case 9: result = func_name(__VA_ARGS__, 9); break; \ case 10: result = func_name(__VA_ARGS__, 10); break; \ case 11: result = func_name(__VA_ARGS__, 11); break; \ case 12: result = func_name(__VA_ARGS__, 12); break; \ case 13: result = func_name(__VA_ARGS__, 13); break; \ case 14: result = func_name(__VA_ARGS__, 14); break; \ case 15: result = func_name(__VA_ARGS__, 15); break; \ case 16: result = func_name(__VA_ARGS__, 16); break; \ case 17: result = func_name(__VA_ARGS__, 17); break; \ case 18: result = func_name(__VA_ARGS__, 18); break; \ case 19: result = func_name(__VA_ARGS__, 19); break; \ case 20: result = func_name(__VA_ARGS__, 20); break; \ case 21: result = func_name(__VA_ARGS__, 21); break; \ case 22: result = func_name(__VA_ARGS__, 22); break; \ case 23: result = func_name(__VA_ARGS__, 23); break; \ case 24: result = func_name(__VA_ARGS__, 24); break; \ case 25: result = func_name(__VA_ARGS__, 25); break; \ case 26: result = func_name(__VA_ARGS__, 26); break; \ case 27: result = func_name(__VA_ARGS__, 27); break; \ case 28: result = func_name(__VA_ARGS__, 28); break; \ case 29: result = func_name(__VA_ARGS__, 29); break; \ case 30: result = func_name(__VA_ARGS__, 30); break; \ case 31: result = func_name(__VA_ARGS__, 31); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_64_(func_name, result, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: result = func_name(__VA_ARGS__, 0); break; \ case 1: result = func_name(__VA_ARGS__, 1); break; \ case 2: result = func_name(__VA_ARGS__, 2); break; \ case 3: result = func_name(__VA_ARGS__, 3); break; \ case 4: result = func_name(__VA_ARGS__, 4); break; \ case 5: result = func_name(__VA_ARGS__, 5); break; \ case 6: result = func_name(__VA_ARGS__, 6); break; \ case 7: result = func_name(__VA_ARGS__, 7); break; \ case 8: result = func_name(__VA_ARGS__, 8); break; \ case 9: result = func_name(__VA_ARGS__, 9); break; \ case 10: result = func_name(__VA_ARGS__, 10); break; \ case 11: result = func_name(__VA_ARGS__, 11); break; \ case 12: result = func_name(__VA_ARGS__, 12); break; \ case 13: result = func_name(__VA_ARGS__, 13); break; \ case 14: result = func_name(__VA_ARGS__, 14); break; \ case 15: result = func_name(__VA_ARGS__, 15); break; \ case 16: result = func_name(__VA_ARGS__, 16); break; \ case 17: result = func_name(__VA_ARGS__, 17); break; \ case 18: result = func_name(__VA_ARGS__, 18); break; \ case 19: result = func_name(__VA_ARGS__, 19); break; \ case 20: result = func_name(__VA_ARGS__, 20); break; \ case 21: result = func_name(__VA_ARGS__, 21); break; \ case 22: result = func_name(__VA_ARGS__, 22); break; \ case 23: result = func_name(__VA_ARGS__, 23); break; \ case 24: result = func_name(__VA_ARGS__, 24); break; \ case 25: result = func_name(__VA_ARGS__, 25); break; \ case 26: result = func_name(__VA_ARGS__, 26); break; \ case 27: result = func_name(__VA_ARGS__, 27); break; \ case 28: result = func_name(__VA_ARGS__, 28); break; \ case 29: result = func_name(__VA_ARGS__, 29); break; \ case 30: result = func_name(__VA_ARGS__, 30); break; \ case 31: result = func_name(__VA_ARGS__, 31); break; \ case 32: result = func_name(__VA_ARGS__, 32); break; \ case 33: result = func_name(__VA_ARGS__, 33); break; \ case 34: result = func_name(__VA_ARGS__, 34); break; \ case 35: result = func_name(__VA_ARGS__, 35); break; \ case 36: result = func_name(__VA_ARGS__, 36); break; \ case 37: result = func_name(__VA_ARGS__, 37); break; \ case 38: result = func_name(__VA_ARGS__, 38); break; \ case 39: result = func_name(__VA_ARGS__, 39); break; \ case 40: result = func_name(__VA_ARGS__, 40); break; \ case 41: result = func_name(__VA_ARGS__, 41); break; \ case 42: result = func_name(__VA_ARGS__, 42); break; \ case 43: result = func_name(__VA_ARGS__, 43); break; \ case 44: result = func_name(__VA_ARGS__, 44); break; \ case 45: result = func_name(__VA_ARGS__, 45); break; \ case 46: result = func_name(__VA_ARGS__, 46); break; \ case 47: result = func_name(__VA_ARGS__, 47); break; \ case 48: result = func_name(__VA_ARGS__, 48); break; \ case 49: result = func_name(__VA_ARGS__, 49); break; \ case 50: result = func_name(__VA_ARGS__, 50); break; \ case 51: result = func_name(__VA_ARGS__, 51); break; \ case 52: result = func_name(__VA_ARGS__, 52); break; \ case 53: result = func_name(__VA_ARGS__, 53); break; \ case 54: result = func_name(__VA_ARGS__, 54); break; \ case 55: result = func_name(__VA_ARGS__, 55); break; \ case 56: result = func_name(__VA_ARGS__, 56); break; \ case 57: result = func_name(__VA_ARGS__, 57); break; \ case 58: result = func_name(__VA_ARGS__, 58); break; \ case 59: result = func_name(__VA_ARGS__, 59); break; \ case 60: result = func_name(__VA_ARGS__, 60); break; \ case 61: result = func_name(__VA_ARGS__, 61); break; \ case 62: result = func_name(__VA_ARGS__, 62); break; \ case 63: result = func_name(__VA_ARGS__, 63); break; \ default: result = default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_2_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ default: default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_4_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ case 2: func_name(__VA_ARGS__, 2); break; \ case 3: func_name(__VA_ARGS__, 3); break; \ default: default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_8_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ case 2: func_name(__VA_ARGS__, 2); break; \ case 3: func_name(__VA_ARGS__, 3); break; \ case 4: func_name(__VA_ARGS__, 4); break; \ case 5: func_name(__VA_ARGS__, 5); break; \ case 6: func_name(__VA_ARGS__, 6); break; \ case 7: func_name(__VA_ARGS__, 7); break; \ default: default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_16_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ case 2: func_name(__VA_ARGS__, 2); break; \ case 3: func_name(__VA_ARGS__, 3); break; \ case 4: func_name(__VA_ARGS__, 4); break; \ case 5: func_name(__VA_ARGS__, 5); break; \ case 6: func_name(__VA_ARGS__, 6); break; \ case 7: func_name(__VA_ARGS__, 7); break; \ case 8: func_name(__VA_ARGS__, 8); break; \ case 9: func_name(__VA_ARGS__, 9); break; \ case 10: func_name(__VA_ARGS__, 10); break; \ case 11: func_name(__VA_ARGS__, 11); break; \ case 12: func_name(__VA_ARGS__, 12); break; \ case 13: func_name(__VA_ARGS__, 13); break; \ case 14: func_name(__VA_ARGS__, 14); break; \ case 15: func_name(__VA_ARGS__, 15); break; \ default: default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_32_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ case 2: func_name(__VA_ARGS__, 2); break; \ case 3: func_name(__VA_ARGS__, 3); break; \ case 4: func_name(__VA_ARGS__, 4); break; \ case 5: func_name(__VA_ARGS__, 5); break; \ case 6: func_name(__VA_ARGS__, 6); break; \ case 7: func_name(__VA_ARGS__, 7); break; \ case 8: func_name(__VA_ARGS__, 8); break; \ case 9: func_name(__VA_ARGS__, 9); break; \ case 10: func_name(__VA_ARGS__, 10); break; \ case 11: func_name(__VA_ARGS__, 11); break; \ case 12: func_name(__VA_ARGS__, 12); break; \ case 13: func_name(__VA_ARGS__, 13); break; \ case 14: func_name(__VA_ARGS__, 14); break; \ case 15: func_name(__VA_ARGS__, 15); break; \ case 16: func_name(__VA_ARGS__, 16); break; \ case 17: func_name(__VA_ARGS__, 17); break; \ case 18: func_name(__VA_ARGS__, 18); break; \ case 19: func_name(__VA_ARGS__, 19); break; \ case 20: func_name(__VA_ARGS__, 20); break; \ case 21: func_name(__VA_ARGS__, 21); break; \ case 22: func_name(__VA_ARGS__, 22); break; \ case 23: func_name(__VA_ARGS__, 23); break; \ case 24: func_name(__VA_ARGS__, 24); break; \ case 25: func_name(__VA_ARGS__, 25); break; \ case 26: func_name(__VA_ARGS__, 26); break; \ case 27: func_name(__VA_ARGS__, 27); break; \ case 28: func_name(__VA_ARGS__, 28); break; \ case 29: func_name(__VA_ARGS__, 29); break; \ case 30: func_name(__VA_ARGS__, 30); break; \ case 31: func_name(__VA_ARGS__, 31); break; \ default: default_case; break; \ } \ } while (0) #define SIMDE_CONSTIFY_64_NO_RESULT_(func_name, default_case, imm, ...) \ do { \ switch(imm) { \ case 0: func_name(__VA_ARGS__, 0); break; \ case 1: func_name(__VA_ARGS__, 1); break; \ case 2: func_name(__VA_ARGS__, 2); break; \ case 3: func_name(__VA_ARGS__, 3); break; \ case 4: func_name(__VA_ARGS__, 4); break; \ case 5: func_name(__VA_ARGS__, 5); break; \ case 6: func_name(__VA_ARGS__, 6); break; \ case 7: func_name(__VA_ARGS__, 7); break; \ case 8: func_name(__VA_ARGS__, 8); break; \ case 9: func_name(__VA_ARGS__, 9); break; \ case 10: func_name(__VA_ARGS__, 10); break; \ case 11: func_name(__VA_ARGS__, 11); break; \ case 12: func_name(__VA_ARGS__, 12); break; \ case 13: func_name(__VA_ARGS__, 13); break; \ case 14: func_name(__VA_ARGS__, 14); break; \ case 15: func_name(__VA_ARGS__, 15); break; \ case 16: func_name(__VA_ARGS__, 16); break; \ case 17: func_name(__VA_ARGS__, 17); break; \ case 18: func_name(__VA_ARGS__, 18); break; \ case 19: func_name(__VA_ARGS__, 19); break; \ case 20: func_name(__VA_ARGS__, 20); break; \ case 21: func_name(__VA_ARGS__, 21); break; \ case 22: func_name(__VA_ARGS__, 22); break; \ case 23: func_name(__VA_ARGS__, 23); break; \ case 24: func_name(__VA_ARGS__, 24); break; \ case 25: func_name(__VA_ARGS__, 25); break; \ case 26: func_name(__VA_ARGS__, 26); break; \ case 27: func_name(__VA_ARGS__, 27); break; \ case 28: func_name(__VA_ARGS__, 28); break; \ case 29: func_name(__VA_ARGS__, 29); break; \ case 30: func_name(__VA_ARGS__, 30); break; \ case 31: func_name(__VA_ARGS__, 31); break; \ case 32: func_name(__VA_ARGS__, 32); break; \ case 33: func_name(__VA_ARGS__, 33); break; \ case 34: func_name(__VA_ARGS__, 34); break; \ case 35: func_name(__VA_ARGS__, 35); break; \ case 36: func_name(__VA_ARGS__, 36); break; \ case 37: func_name(__VA_ARGS__, 37); break; \ case 38: func_name(__VA_ARGS__, 38); break; \ case 39: func_name(__VA_ARGS__, 39); break; \ case 40: func_name(__VA_ARGS__, 40); break; \ case 41: func_name(__VA_ARGS__, 41); break; \ case 42: func_name(__VA_ARGS__, 42); break; \ case 43: func_name(__VA_ARGS__, 43); break; \ case 44: func_name(__VA_ARGS__, 44); break; \ case 45: func_name(__VA_ARGS__, 45); break; \ case 46: func_name(__VA_ARGS__, 46); break; \ case 47: func_name(__VA_ARGS__, 47); break; \ case 48: func_name(__VA_ARGS__, 48); break; \ case 49: func_name(__VA_ARGS__, 49); break; \ case 50: func_name(__VA_ARGS__, 50); break; \ case 51: func_name(__VA_ARGS__, 51); break; \ case 52: func_name(__VA_ARGS__, 52); break; \ case 53: func_name(__VA_ARGS__, 53); break; \ case 54: func_name(__VA_ARGS__, 54); break; \ case 55: func_name(__VA_ARGS__, 55); break; \ case 56: func_name(__VA_ARGS__, 56); break; \ case 57: func_name(__VA_ARGS__, 57); break; \ case 58: func_name(__VA_ARGS__, 58); break; \ case 59: func_name(__VA_ARGS__, 59); break; \ case 60: func_name(__VA_ARGS__, 60); break; \ case 61: func_name(__VA_ARGS__, 61); break; \ case 62: func_name(__VA_ARGS__, 62); break; \ case 63: func_name(__VA_ARGS__, 63); break; \ default: default_case; break; \ } \ } while (0) HEDLEY_DIAGNOSTIC_POP #endif /* :: End simde-constify.h :: */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin simde-align.h :: */ /* Alignment * Created by Evan Nemerson * * To the extent possible under law, the authors have waived all * copyright and related or neighboring rights to this code. For * details, see the Creative Commons Zero 1.0 Universal license at * * * SPDX-License-Identifier: CC0-1.0 * ********************************************************************** * * This is portability layer which should help iron out some * differences across various compilers, as well as various verisons of * C and C++. * * It was originally developed for SIMD Everywhere * (), but since its only * dependency is Hedley (, also CC0) * it can easily be used in other projects, so please feel free to do * so. * * If you do use this in your project, please keep a link to SIMDe in * your code to remind you where to report any bugs and/or check for * updated versions. * * # API Overview * * The API has several parts, and most macros have a few variations. * There are APIs for declaring aligned fields/variables, optimization * hints, and run-time alignment checks. * * Briefly, macros ending with "_TO" take numeric values and are great * when you know the value you would like to use. Macros ending with * "_LIKE", on the other hand, accept a type and are used when you want * to use the alignment of a type instead of hardcoding a value. * * Documentation for each section of the API is inline. * * True to form, MSVC is the main problem and imposes several * limitations on the effectiveness of the APIs. Detailed descriptions * of the limitations of each macro are inline, but in general: * * * On C11+ or C++11+ code written using this API will work. The * ASSUME macros may or may not generate a hint to the compiler, but * that is only an optimization issue and will not actually cause * failures. * * If you're using pretty much any compiler other than MSVC, * everything should basically work as well as in C11/C++11. */ #if !defined(SIMDE_ALIGN_H) #define SIMDE_ALIGN_H /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* I know this seems a little silly, but some non-hosted compilers * don't have stddef.h, so we try to accomodate them. */ #if !defined(SIMDE_ALIGN_SIZE_T_) #if defined(__SIZE_TYPE__) #define SIMDE_ALIGN_SIZE_T_ __SIZE_TYPE__ #elif defined(__SIZE_T_TYPE__) #define SIMDE_ALIGN_SIZE_T_ __SIZE_TYPE__ #elif defined(__cplusplus) #include #define SIMDE_ALIGN_SIZE_T_ size_t #else #include #define SIMDE_ALIGN_SIZE_T_ size_t #endif #endif #if !defined(SIMDE_ALIGN_INTPTR_T_) #if defined(__INTPTR_TYPE__) #define SIMDE_ALIGN_INTPTR_T_ __INTPTR_TYPE__ #elif defined(__PTRDIFF_TYPE__) #define SIMDE_ALIGN_INTPTR_T_ __PTRDIFF_TYPE__ #elif defined(__PTRDIFF_T_TYPE__) #define SIMDE_ALIGN_INTPTR_T_ __PTRDIFF_T_TYPE__ #elif defined(__cplusplus) #include #define SIMDE_ALIGN_INTPTR_T_ ptrdiff_t #else #include #define SIMDE_ALIGN_INTPTR_T_ ptrdiff_t #endif #endif #if defined(SIMDE_ALIGN_DEBUG) #if defined(__cplusplus) #include #else #include #endif #endif /* SIMDE_ALIGN_OF(Type) * * The SIMDE_ALIGN_OF macro works like alignof, or _Alignof, or * __alignof, or __alignof__, or __ALIGNOF__, depending on the compiler. * It isn't defined everywhere (only when the compiler has some alignof- * like feature we can use to implement it), but it should work in most * modern compilers, as well as C11 and C++11. * * If we can't find an implementation for SIMDE_ALIGN_OF then the macro * will not be defined, so if you can handle that situation sensibly * you may need to sprinkle some ifdefs into your code. */ #if \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ (0 && HEDLEY_HAS_FEATURE(c_alignof)) #define SIMDE_ALIGN_OF(Type) _Alignof(Type) #elif \ (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ (0 && HEDLEY_HAS_FEATURE(cxx_alignof)) #define SIMDE_ALIGN_OF(Type) alignof(Type) #elif \ HEDLEY_GCC_VERSION_CHECK(2,95,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,24) || \ HEDLEY_PGI_VERSION_CHECK(19,10,0) || \ HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,2) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ defined(__IBM__ALIGNOF__) || \ defined(__clang__) #define SIMDE_ALIGN_OF(Type) __alignof__(Type) #elif \ HEDLEY_IAR_VERSION_CHECK(8,40,0) #define SIMDE_ALIGN_OF(Type) __ALIGNOF__(Type) #elif \ HEDLEY_MSVC_VERSION_CHECK(19,0,0) /* Probably goes back much further, but MS takes down their old docs. * If you can verify that this works in earlier versions please let * me know! */ #define SIMDE_ALIGN_OF(Type) __alignof(Type) #endif /* SIMDE_ALIGN_MAXIMUM: * * This is the maximum alignment that the compiler supports. You can * define the value prior to including SIMDe if necessary, but in that * case *please* submit an issue so we can add the platform to the * detection code. * * Most compilers are okay with types which are aligned beyond what * they think is the maximum, as long as the alignment is a power * of two. Older versions of MSVC is the exception, so we need to cap * the alignment requests at values that the implementation supports. * * XL C/C++ will accept values larger than 16 (which is the alignment * of an AltiVec vector), but will not reliably align to the larger * value, so so we cap the value at 16 there. * * If the compiler accepts any power-of-two value within reason then * this macro should be left undefined, and the SIMDE_ALIGN_CAP * macro will just return the value passed to it. */ #if !defined(SIMDE_ALIGN_MAXIMUM) #if defined(HEDLEY_MSVC_VERSION) #if HEDLEY_MSVC_VERSION_CHECK(19, 16, 0) // Visual studio 2017 and newer does not need a max #else #if defined(_M_IX86) || defined(_M_AMD64) #if HEDLEY_MSVC_VERSION_CHECK(19,14,0) #define SIMDE_ALIGN_PLATFORM_MAXIMUM 64 #elif HEDLEY_MSVC_VERSION_CHECK(16,0,0) /* VS 2010 is really a guess based on Wikipedia; if anyone can * test with old VS versions I'd really appreciate it. */ #define SIMDE_ALIGN_PLATFORM_MAXIMUM 32 #else #define SIMDE_ALIGN_PLATFORM_MAXIMUM 16 #endif #elif defined(_M_ARM) || defined(_M_ARM64) #define SIMDE_ALIGN_PLATFORM_MAXIMUM 8 #endif #endif #elif defined(HEDLEY_IBM_VERSION) #define SIMDE_ALIGN_PLATFORM_MAXIMUM 16 #endif #endif /* You can mostly ignore these; they're intended for internal use. * If you do need to use them please let me know; if they fulfill * a common use case I'll probably drop the trailing underscore * and make them part of the public API. */ #if defined(SIMDE_ALIGN_PLATFORM_MAXIMUM) #if SIMDE_ALIGN_PLATFORM_MAXIMUM >= 64 #define SIMDE_ALIGN_64_ 64 #define SIMDE_ALIGN_32_ 32 #define SIMDE_ALIGN_16_ 16 #define SIMDE_ALIGN_8_ 8 #elif SIMDE_ALIGN_PLATFORM_MAXIMUM >= 32 #define SIMDE_ALIGN_64_ 32 #define SIMDE_ALIGN_32_ 32 #define SIMDE_ALIGN_16_ 16 #define SIMDE_ALIGN_8_ 8 #elif SIMDE_ALIGN_PLATFORM_MAXIMUM >= 16 #define SIMDE_ALIGN_64_ 16 #define SIMDE_ALIGN_32_ 16 #define SIMDE_ALIGN_16_ 16 #define SIMDE_ALIGN_8_ 8 #elif SIMDE_ALIGN_PLATFORM_MAXIMUM >= 8 #define SIMDE_ALIGN_64_ 8 #define SIMDE_ALIGN_32_ 8 #define SIMDE_ALIGN_16_ 8 #define SIMDE_ALIGN_8_ 8 #else #error Max alignment expected to be >= 8 #endif #else #define SIMDE_ALIGN_64_ 64 #define SIMDE_ALIGN_32_ 32 #define SIMDE_ALIGN_16_ 16 #define SIMDE_ALIGN_8_ 8 #endif /** * SIMDE_ALIGN_CAP(Alignment) * * Returns the minimum of Alignment or SIMDE_ALIGN_MAXIMUM. */ #if defined(SIMDE_ALIGN_MAXIMUM) #define SIMDE_ALIGN_CAP(Alignment) (((Alignment) < (SIMDE_ALIGN_PLATFORM_MAXIMUM)) ? (Alignment) : (SIMDE_ALIGN_PLATFORM_MAXIMUM)) #else #define SIMDE_ALIGN_CAP(Alignment) (Alignment) #endif /* SIMDE_ALIGN_TO(Alignment) * * SIMDE_ALIGN_TO is used to declare types or variables. It basically * maps to the align attribute in most compilers, the align declspec * in MSVC, or _Alignas/alignas in C11/C++11. * * Example: * * struct i32x4 { * SIMDE_ALIGN_TO(16) int32_t values[4]; * } * * Limitations: * * MSVC requires that the Alignment parameter be numeric; you can't do * something like `SIMDE_ALIGN_TO(SIMDE_ALIGN_OF(int))`. This is * unfortunate because that's really how the LIKE macros are * implemented, and I am not aware of a way to get anything like this * to work without using the C11/C++11 keywords. * * It also means that we can't use SIMDE_ALIGN_CAP to limit the * alignment to the value specified, which MSVC also requires, so on * MSVC you should use the `SIMDE_ALIGN_TO_8/16/32/64` macros instead. * They work like `SIMDE_ALIGN_TO(SIMDE_ALIGN_CAP(Alignment))` would, * but should be safe to use on MSVC. * * All this is to say that, if you want your code to work on MSVC, you * should use the SIMDE_ALIGN_TO_8/16/32/64 macros below instead of * SIMDE_ALIGN_TO(8/16/32/64). */ #if \ HEDLEY_HAS_ATTRIBUTE(aligned) || \ HEDLEY_GCC_VERSION_CHECK(2,95,0) || \ HEDLEY_CRAY_VERSION_CHECK(8,4,0) || \ HEDLEY_IBM_VERSION_CHECK(11,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_PGI_VERSION_CHECK(19,4,0) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,24) || \ HEDLEY_TI_ARMCL_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CL2000_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ HEDLEY_TI_CL430_VERSION_CHECK(16,9,0) || \ HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,2) #define SIMDE_ALIGN_TO(Alignment) __attribute__((__aligned__(SIMDE_ALIGN_CAP(Alignment)))) #elif \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) #define SIMDE_ALIGN_TO(Alignment) _Alignas(SIMDE_ALIGN_CAP(Alignment)) #elif \ (defined(__cplusplus) && (__cplusplus >= 201103L)) #define SIMDE_ALIGN_TO(Alignment) alignas(SIMDE_ALIGN_CAP(Alignment)) #elif \ defined(HEDLEY_MSVC_VERSION) #define SIMDE_ALIGN_TO(Alignment) __declspec(align(Alignment)) /* Unfortunately MSVC can't handle __declspec(align(__alignof(Type))); * the alignment passed to the declspec has to be an integer. */ #define SIMDE_ALIGN_OF_UNUSABLE_FOR_LIKE #endif #define SIMDE_ALIGN_TO_64 SIMDE_ALIGN_TO(SIMDE_ALIGN_64_) #define SIMDE_ALIGN_TO_32 SIMDE_ALIGN_TO(SIMDE_ALIGN_32_) #define SIMDE_ALIGN_TO_16 SIMDE_ALIGN_TO(SIMDE_ALIGN_16_) #define SIMDE_ALIGN_TO_8 SIMDE_ALIGN_TO(SIMDE_ALIGN_8_) /* SIMDE_ALIGN_ASSUME_TO(Pointer, Alignment) * * SIMDE_ALIGN_ASSUME_TO is semantically similar to C++20's * std::assume_aligned, or __builtin_assume_aligned. It tells the * compiler to assume that the provided pointer is aligned to an * `Alignment`-byte boundary. * * If you define SIMDE_ALIGN_DEBUG prior to including this header then * SIMDE_ALIGN_ASSUME_TO will turn into a runtime check. We don't * integrate with NDEBUG in this header, but it may be a good idea to * put something like this in your code: * * #if !defined(NDEBUG) * #define SIMDE_ALIGN_DEBUG * #endif * #include <.../simde-align.h> */ #if \ HEDLEY_HAS_BUILTIN(__builtin_assume_aligned) || \ HEDLEY_GCC_VERSION_CHECK(4,7,0) #define SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) \ HEDLEY_REINTERPRET_CAST(__typeof__(Pointer), __builtin_assume_aligned(HEDLEY_CONST_CAST(void*, HEDLEY_REINTERPRET_CAST(const void*, Pointer)), Alignment)) #elif HEDLEY_INTEL_VERSION_CHECK(13,0,0) #define SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) (__extension__ ({ \ __typeof__(v) simde_assume_aligned_t_ = (Pointer); \ __assume_aligned(simde_assume_aligned_t_, Alignment); \ simde_assume_aligned_t_; \ })) #elif defined(__cplusplus) && (__cplusplus > 201703L) #include #define SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) std::assume_aligned(Pointer) #else #if defined(__cplusplus) template HEDLEY_ALWAYS_INLINE static T* simde_align_assume_to_unchecked(T* ptr, const size_t alignment) #else HEDLEY_ALWAYS_INLINE static void* simde_align_assume_to_unchecked(void* ptr, const size_t alignment) #endif { HEDLEY_ASSUME((HEDLEY_REINTERPRET_CAST(size_t, (ptr)) % SIMDE_ALIGN_CAP(alignment)) == 0); return ptr; } #if defined(__cplusplus) #define SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) simde_align_assume_to_unchecked((Pointer), (Alignment)) #else #define SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) simde_align_assume_to_unchecked(HEDLEY_CONST_CAST(void*, HEDLEY_REINTERPRET_CAST(const void*, Pointer)), (Alignment)) #endif #endif #if !defined(SIMDE_ALIGN_DEBUG) #define SIMDE_ALIGN_ASSUME_TO(Pointer, Alignment) SIMDE_ALIGN_ASSUME_TO_UNCHECKED(Pointer, Alignment) #else #include #if defined(__cplusplus) template static HEDLEY_ALWAYS_INLINE T* simde_align_assume_to_checked_uncapped(T* ptr, const size_t alignment, const char* file, int line, const char* ptrname) #else static HEDLEY_ALWAYS_INLINE void* simde_align_assume_to_checked_uncapped(void* ptr, const size_t alignment, const char* file, int line, const char* ptrname) #endif { if (HEDLEY_UNLIKELY((HEDLEY_REINTERPRET_CAST(SIMDE_ALIGN_INTPTR_T_, (ptr)) % HEDLEY_STATIC_CAST(SIMDE_ALIGN_INTPTR_T_, SIMDE_ALIGN_CAP(alignment))) != 0)) { fprintf(stderr, "%s:%d: alignment check failed for `%s' (%p %% %u == %u)\n", file, line, ptrname, HEDLEY_REINTERPRET_CAST(const void*, ptr), HEDLEY_STATIC_CAST(unsigned int, SIMDE_ALIGN_CAP(alignment)), HEDLEY_STATIC_CAST(unsigned int, HEDLEY_REINTERPRET_CAST(SIMDE_ALIGN_INTPTR_T_, (ptr)) % HEDLEY_STATIC_CAST(SIMDE_ALIGN_INTPTR_T_, SIMDE_ALIGN_CAP(alignment)))); } return ptr; } #if defined(__cplusplus) #define SIMDE_ALIGN_ASSUME_TO(Pointer, Alignment) simde_align_assume_to_checked_uncapped((Pointer), (Alignment), __FILE__, __LINE__, #Pointer) #else #define SIMDE_ALIGN_ASSUME_TO(Pointer, Alignment) simde_align_assume_to_checked_uncapped(HEDLEY_CONST_CAST(void*, HEDLEY_REINTERPRET_CAST(const void*, Pointer)), (Alignment), __FILE__, __LINE__, #Pointer) #endif #endif /* SIMDE_ALIGN_LIKE(Type) * SIMDE_ALIGN_LIKE_#(Type) * * The SIMDE_ALIGN_LIKE macros are similar to the SIMDE_ALIGN_TO macros * except instead of an integer they take a type; basically, it's just * a more convenient way to do something like: * * SIMDE_ALIGN_TO(SIMDE_ALIGN_OF(Type)) * * The versions with a numeric suffix will fall back on using a numeric * value in the event we can't use SIMDE_ALIGN_OF(Type). This is * mainly for MSVC, where __declspec(align()) can't handle anything * other than hard-coded numeric values. */ #if defined(SIMDE_ALIGN_OF) && defined(SIMDE_ALIGN_TO) && !defined(SIMDE_ALIGN_OF_UNUSABLE_FOR_LIKE) #define SIMDE_ALIGN_LIKE(Type) SIMDE_ALIGN_TO(SIMDE_ALIGN_OF(Type)) #define SIMDE_ALIGN_LIKE_64(Type) SIMDE_ALIGN_LIKE(Type) #define SIMDE_ALIGN_LIKE_32(Type) SIMDE_ALIGN_LIKE(Type) #define SIMDE_ALIGN_LIKE_16(Type) SIMDE_ALIGN_LIKE(Type) #define SIMDE_ALIGN_LIKE_8(Type) SIMDE_ALIGN_LIKE(Type) #else #define SIMDE_ALIGN_LIKE_64(Type) SIMDE_ALIGN_TO_64 #define SIMDE_ALIGN_LIKE_32(Type) SIMDE_ALIGN_TO_32 #define SIMDE_ALIGN_LIKE_16(Type) SIMDE_ALIGN_TO_16 #define SIMDE_ALIGN_LIKE_8(Type) SIMDE_ALIGN_TO_8 #endif /* SIMDE_ALIGN_ASSUME_LIKE(Pointer, Type) * * Tihs is similar to SIMDE_ALIGN_ASSUME_TO, except that it takes a * type instead of a numeric value. */ #if defined(SIMDE_ALIGN_OF) && defined(SIMDE_ALIGN_ASSUME_TO) #define SIMDE_ALIGN_ASSUME_LIKE(Pointer, Type) SIMDE_ALIGN_ASSUME_TO(Pointer, SIMDE_ALIGN_OF(Type)) #endif /* SIMDE_ALIGN_CAST(Type, Pointer) * * SIMDE_ALIGN_CAST is like C++'s reinterpret_cast, but it will try * to silence warnings that some compilers may produce if you try * to assign to a type with increased alignment requirements. * * Note that it does *not* actually attempt to tell the compiler that * the pointer is aligned like the destination should be; that's the * job of the next macro. This macro is necessary for stupid APIs * like _mm_loadu_si128 where the input is a __m128i* but the function * is specifically for data which isn't necessarily aligned to * _Alignof(__m128i). */ #if HEDLEY_HAS_WARNING("-Wcast-align") || defined(__clang__) || HEDLEY_GCC_VERSION_CHECK(3,4,0) #define SIMDE_ALIGN_CAST(Type, Pointer) (__extension__({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("GCC diagnostic ignored \"-Wcast-align\"") \ Type simde_r_ = HEDLEY_REINTERPRET_CAST(Type, Pointer); \ HEDLEY_DIAGNOSTIC_POP \ simde_r_; \ })) #else #define SIMDE_ALIGN_CAST(Type, Pointer) HEDLEY_REINTERPRET_CAST(Type, Pointer) #endif /* SIMDE_ALIGN_ASSUME_CAST(Type, Pointer) * * This is sort of like a combination of a reinterpret_cast and a * SIMDE_ALIGN_ASSUME_LIKE. It uses SIMDE_ALIGN_ASSUME_LIKE to tell * the compiler that the pointer is aligned like the specified type * and casts the pointer to the specified type while suppressing any * warnings from the compiler about casting to a type with greater * alignment requirements. */ #define SIMDE_ALIGN_ASSUME_CAST(Type, Pointer) SIMDE_ALIGN_ASSUME_LIKE(SIMDE_ALIGN_CAST(Type, Pointer), Type) #endif /* !defined(SIMDE_ALIGN_H) */ /* :: End simde-align.h :: */ /* In some situations, SIMDe has to make large performance sacrifices * for small increases in how faithfully it reproduces an API, but * only a relatively small number of users will actually need the API * to be completely accurate. The SIMDE_FAST_* options can be used to * disable these trade-offs. * * They can be enabled by passing -DSIMDE_FAST_MATH to the compiler, or * the individual defines (e.g., -DSIMDE_FAST_NANS) if you only want to * enable some optimizations. Using -ffast-math and/or * -ffinite-math-only will also enable the relevant options. If you * don't want that you can pass -DSIMDE_NO_FAST_* to disable them. */ /* Most programs avoid NaNs by never passing values which can result in * a NaN; for example, if you only pass non-negative values to the sqrt * functions, it won't generate a NaN. On some platforms, similar * functions handle NaNs differently; for example, the _mm_min_ps SSE * function will return 0.0 if you pass it (0.0, NaN), but the NEON * vminq_f32 function will return NaN. Making them behave like one * another is expensive; it requires generating a mask of all lanes * with NaNs, then performing the operation (e.g., vminq_f32), then * blending together the result with another vector using the mask. * * If you don't want SIMDe to worry about the differences between how * NaNs are handled on the two platforms, define this (or pass * -ffinite-math-only) */ #if !defined(SIMDE_FAST_MATH) && !defined(SIMDE_NO_FAST_MATH) && defined(__FAST_MATH__) #define SIMDE_FAST_MATH #endif #if !defined(SIMDE_FAST_NANS) && !defined(SIMDE_NO_FAST_NANS) #if defined(SIMDE_FAST_MATH) #define SIMDE_FAST_NANS #elif defined(__FINITE_MATH_ONLY__) #if __FINITE_MATH_ONLY__ #define SIMDE_FAST_NANS #endif #endif #endif /* Many functions are defined as using the current rounding mode * (i.e., the SIMD version of fegetround()) when converting to * an integer. For example, _mm_cvtpd_epi32. Unfortunately, * on some platforms (such as ARMv8+ where round-to-nearest is * always used, regardless of the FPSCR register) this means we * have to first query the current rounding mode, then choose * the proper function (rounnd , ceil, floor, etc.) */ #if !defined(SIMDE_FAST_ROUND_MODE) && !defined(SIMDE_NO_FAST_ROUND_MODE) && defined(SIMDE_FAST_MATH) #define SIMDE_FAST_ROUND_MODE #endif /* This controls how ties are rounded. For example, does 10.5 round to * 10 or 11? IEEE 754 specifies round-towards-even, but ARMv7 (for * example) doesn't support it and it must be emulated (which is rather * slow). If you're okay with just using the default for whatever arch * you're on, you should definitely define this. * * Note that we don't use this macro to avoid correct implementations * in functions which are explicitly about rounding (such as vrnd* on * NEON, _mm_round_* on x86, etc.); it is only used for code where * rounding is a component in another function, and even then it isn't * usually a problem since such functions will use the current rounding * mode. */ #if !defined(SIMDE_FAST_ROUND_TIES) && !defined(SIMDE_NO_FAST_ROUND_TIES) && defined(SIMDE_FAST_MATH) #define SIMDE_FAST_ROUND_TIES #endif /* For functions which convert from one type to another (mostly from * floating point to integer types), sometimes we need to do a range * check and potentially return a different result if the value * falls outside that range. Skipping this check can provide a * performance boost, at the expense of faithfulness to the API we're * emulating. */ #if !defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_NO_FAST_CONVERSION_RANGE) && defined(SIMDE_FAST_MATH) #define SIMDE_FAST_CONVERSION_RANGE #endif /* Due to differences across platforms, sometimes it can be much * faster for us to allow spurious floating point exceptions, * or to no generate them when we should. */ #if !defined(SIMDE_FAST_EXCEPTIONS) && !defined(SIMDE_NO_FAST_EXCEPTIONS) && defined(SIMDE_FAST_MATH) #define SIMDE_FAST_EXCEPTIONS #endif #if \ HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ (HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) #define SIMDE_CHECK_CONSTANT_(expr) (__builtin_constant_p(expr)) #elif defined(__cplusplus) && (__cplusplus > 201703L) #include #define SIMDE_CHECK_CONSTANT_(expr) (std::is_constant_evaluated()) #endif #if !defined(SIMDE_NO_CHECK_IMMEDIATE_CONSTANT) #if defined(SIMDE_CHECK_CONSTANT_) && \ SIMDE_DETECT_CLANG_VERSION_CHECK(9,0,0) && \ (!defined(__apple_build_version__) || ((__apple_build_version__ < 11000000) || (__apple_build_version__ >= 12000000))) #define SIMDE_REQUIRE_CONSTANT(arg) HEDLEY_REQUIRE_MSG(SIMDE_CHECK_CONSTANT_(arg), "`" #arg "' must be constant") #else #define SIMDE_REQUIRE_CONSTANT(arg) #endif #else #define SIMDE_REQUIRE_CONSTANT(arg) #endif #define SIMDE_REQUIRE_RANGE(arg, min, max) \ HEDLEY_REQUIRE_MSG((((arg) >= (min)) && ((arg) <= (max))), "'" #arg "' must be in [" #min ", " #max "]") #define SIMDE_REQUIRE_CONSTANT_RANGE(arg, min, max) \ SIMDE_REQUIRE_CONSTANT(arg) \ SIMDE_REQUIRE_RANGE(arg, min, max) /* A copy of HEDLEY_STATIC_ASSERT, except we don't define an empty * fallback if we can't find an implementation; instead we have to * check if SIMDE_STATIC_ASSERT is defined before using it. */ #if \ !defined(__cplusplus) && ( \ (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ HEDLEY_HAS_FEATURE(c_static_assert) || \ HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ defined(_Static_assert) \ ) /* Sometimes _Static_assert is defined (in cdefs.h) using a symbol which * starts with a double-underscore. This is a system header so we have no * control over it, but since it's a macro it will emit a diagnostic which * prevents compilation with -Werror. */ #if HEDLEY_HAS_WARNING("-Wreserved-identifier") #define SIMDE_STATIC_ASSERT(expr, message) (__extension__({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wreserved-identifier\"") \ _Static_assert(expr, message); \ HEDLEY_DIAGNOSTIC_POP \ })) #else #define SIMDE_STATIC_ASSERT(expr, message) _Static_assert(expr, message) #endif #elif \ (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ HEDLEY_MSVC_VERSION_CHECK(16,0,0) #define SIMDE_STATIC_ASSERT(expr, message) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) #endif /* Statement exprs */ #if \ HEDLEY_GNUC_VERSION_CHECK(2,95,0) || \ HEDLEY_TINYC_VERSION_CHECK(0,9,26) || \ HEDLEY_INTEL_VERSION_CHECK(9,0,0) || \ HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ HEDLEY_SUNPRO_VERSION_CHECK(5,12,0) || \ HEDLEY_IBM_VERSION_CHECK(11,1,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) #define SIMDE_STATEMENT_EXPR_(expr) (__extension__ expr) #endif /* This is just a convenience macro to make it easy to call a single * function with a specific diagnostic disabled. */ #if defined(SIMDE_STATEMENT_EXPR_) #define SIMDE_DISABLE_DIAGNOSTIC_EXPR_(diagnostic, expr) \ SIMDE_STATEMENT_EXPR_(({ \ HEDLEY_DIAGNOSTIC_PUSH \ diagnostic \ (expr); \ HEDLEY_DIAGNOSTIC_POP \ })) #endif #if defined(SIMDE_CHECK_CONSTANT_) && defined(SIMDE_STATIC_ASSERT) #define SIMDE_ASSERT_CONSTANT_(v) SIMDE_STATIC_ASSERT(SIMDE_CHECK_CONSTANT_(v), #v " must be constant.") #endif #if \ (HEDLEY_HAS_ATTRIBUTE(may_alias) && !defined(HEDLEY_SUNPRO_VERSION)) || \ HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) # define SIMDE_MAY_ALIAS __attribute__((__may_alias__)) #else # define SIMDE_MAY_ALIAS #endif /* Lots of compilers support GCC-style vector extensions, but many don't support all the features. Define different macros depending on support for * SIMDE_VECTOR - Declaring a vector. * SIMDE_VECTOR_OPS - basic operations (binary and unary). * SIMDE_VECTOR_NEGATE - negating a vector * SIMDE_VECTOR_SCALAR - For binary operators, the second argument can be a scalar, in which case the result is as if that scalar had been broadcast to all lanes of a vector. * SIMDE_VECTOR_SUBSCRIPT - Supports array subscript notation for extracting/inserting a single element.= SIMDE_VECTOR can be assumed if any others are defined, the others are independent. */ #if !defined(SIMDE_NO_VECTOR) # if \ HEDLEY_GCC_VERSION_CHECK(4,8,0) # define SIMDE_VECTOR(size) __attribute__((__vector_size__(size))) # define SIMDE_VECTOR_OPS # define SIMDE_VECTOR_NEGATE # define SIMDE_VECTOR_SCALAR # define SIMDE_VECTOR_SUBSCRIPT # elif HEDLEY_INTEL_VERSION_CHECK(16,0,0) # define SIMDE_VECTOR(size) __attribute__((__vector_size__(size))) # define SIMDE_VECTOR_OPS # define SIMDE_VECTOR_NEGATE /* ICC only supports SIMDE_VECTOR_SCALAR for constants */ # define SIMDE_VECTOR_SUBSCRIPT # elif \ HEDLEY_GCC_VERSION_CHECK(4,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) # define SIMDE_VECTOR(size) __attribute__((__vector_size__(size))) # define SIMDE_VECTOR_OPS # elif HEDLEY_SUNPRO_VERSION_CHECK(5,12,0) # define SIMDE_VECTOR(size) __attribute__((__vector_size__(size))) # elif HEDLEY_HAS_ATTRIBUTE(vector_size) # define SIMDE_VECTOR(size) __attribute__((__vector_size__(size))) # define SIMDE_VECTOR_OPS # define SIMDE_VECTOR_NEGATE # define SIMDE_VECTOR_SUBSCRIPT # if SIMDE_DETECT_CLANG_VERSION_CHECK(5,0,0) # define SIMDE_VECTOR_SCALAR # endif # endif /* GCC and clang have built-in functions to handle shuffling and converting of vectors, but the implementations are slightly different. This macro is just an abstraction over them. Note that elem_size is in bits but vec_size is in bytes. */ # if !defined(SIMDE_NO_SHUFFLE_VECTOR) && defined(SIMDE_VECTOR_SUBSCRIPT) HEDLEY_DIAGNOSTIC_PUSH /* We don't care about -Wvariadic-macros; all compilers that support * shufflevector/shuffle support them. */ # if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") # pragma clang diagnostic ignored "-Wc++98-compat-pedantic" # endif # if HEDLEY_HAS_WARNING("-Wvariadic-macros") || HEDLEY_GCC_VERSION_CHECK(4,0,0) # pragma GCC diagnostic ignored "-Wvariadic-macros" # endif # if HEDLEY_HAS_BUILTIN(__builtin_shufflevector) # define SIMDE_SHUFFLE_VECTOR_(elem_size, vec_size, a, b, ...) __builtin_shufflevector(a, b, __VA_ARGS__) # elif HEDLEY_GCC_HAS_BUILTIN(__builtin_shuffle,4,7,0) && !defined(__INTEL_COMPILER) # define SIMDE_SHUFFLE_VECTOR_(elem_size, vec_size, a, b, ...) (__extension__ ({ \ int##elem_size##_t SIMDE_VECTOR(vec_size) simde_shuffle_ = { __VA_ARGS__ }; \ __builtin_shuffle(a, b, simde_shuffle_); \ })) # endif HEDLEY_DIAGNOSTIC_POP # endif /* TODO: this actually works on XL C/C++ without SIMDE_VECTOR_SUBSCRIPT but the code needs to be refactored a bit to take advantage. */ # if !defined(SIMDE_NO_CONVERT_VECTOR) && defined(SIMDE_VECTOR_SUBSCRIPT) # if HEDLEY_HAS_BUILTIN(__builtin_convertvector) || HEDLEY_GCC_VERSION_CHECK(9,0,0) # if HEDLEY_GCC_VERSION_CHECK(9,0,0) && !HEDLEY_GCC_VERSION_CHECK(9,3,0) /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93557 */ # define SIMDE_CONVERT_VECTOR_(to, from) ((to) = (__extension__({ \ __typeof__(from) from_ = (from); \ ((void) from_); \ __builtin_convertvector(from_, __typeof__(to)); \ }))) # else # define SIMDE_CONVERT_VECTOR_(to, from) ((to) = __builtin_convertvector((from), __typeof__(to))) # endif # endif # endif #endif /* Since we currently require SUBSCRIPT before using a vector in a union, we define these as dependencies of SUBSCRIPT. They are likely to disappear in the future, once SIMDe learns how to make use of vectors without using the union members. Do not use them in your code unless you're okay with it breaking when SIMDe changes. */ #if defined(SIMDE_VECTOR_SUBSCRIPT) # if defined(SIMDE_VECTOR_OPS) # define SIMDE_VECTOR_SUBSCRIPT_OPS # endif # if defined(SIMDE_VECTOR_SCALAR) # define SIMDE_VECTOR_SUBSCRIPT_SCALAR # endif #endif #if !defined(SIMDE_DISABLE_OPENMP) #if !defined(SIMDE_ENABLE_OPENMP) && ((defined(_OPENMP) && (_OPENMP >= 201307L)) || (defined(_OPENMP_SIMD) && (_OPENMP_SIMD >= 201307L))) || defined(HEDLEY_MCST_LCC_VERSION) #define SIMDE_ENABLE_OPENMP #endif #endif #if !defined(SIMDE_ENABLE_CILKPLUS) && (defined(__cilk) || defined(HEDLEY_INTEL_VERSION)) # define SIMDE_ENABLE_CILKPLUS #endif #if defined(SIMDE_ENABLE_OPENMP) # define SIMDE_VECTORIZE HEDLEY_PRAGMA(omp simd) # define SIMDE_VECTORIZE_SAFELEN(l) HEDLEY_PRAGMA(omp simd safelen(l)) # if defined(__clang__) # define SIMDE_VECTORIZE_REDUCTION(r) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wsign-conversion\"") \ HEDLEY_PRAGMA(omp simd reduction(r)) \ HEDLEY_DIAGNOSTIC_POP # else # define SIMDE_VECTORIZE_REDUCTION(r) HEDLEY_PRAGMA(omp simd reduction(r)) # endif # if !defined(HEDLEY_MCST_LCC_VERSION) # define SIMDE_VECTORIZE_ALIGNED(a) HEDLEY_PRAGMA(omp simd aligned(a)) # else # define SIMDE_VECTORIZE_ALIGNED(a) HEDLEY_PRAGMA(omp simd) # endif #elif defined(SIMDE_ENABLE_CILKPLUS) # define SIMDE_VECTORIZE HEDLEY_PRAGMA(simd) # define SIMDE_VECTORIZE_SAFELEN(l) HEDLEY_PRAGMA(simd vectorlength(l)) # define SIMDE_VECTORIZE_REDUCTION(r) HEDLEY_PRAGMA(simd reduction(r)) # define SIMDE_VECTORIZE_ALIGNED(a) HEDLEY_PRAGMA(simd aligned(a)) #elif defined(__clang__) && !defined(HEDLEY_IBM_VERSION) # define SIMDE_VECTORIZE HEDLEY_PRAGMA(clang loop vectorize(enable)) # define SIMDE_VECTORIZE_SAFELEN(l) HEDLEY_PRAGMA(clang loop vectorize_width(l)) # define SIMDE_VECTORIZE_REDUCTION(r) SIMDE_VECTORIZE # define SIMDE_VECTORIZE_ALIGNED(a) #elif HEDLEY_GCC_VERSION_CHECK(4,9,0) # define SIMDE_VECTORIZE HEDLEY_PRAGMA(GCC ivdep) # define SIMDE_VECTORIZE_SAFELEN(l) SIMDE_VECTORIZE # define SIMDE_VECTORIZE_REDUCTION(r) SIMDE_VECTORIZE # define SIMDE_VECTORIZE_ALIGNED(a) #elif HEDLEY_CRAY_VERSION_CHECK(5,0,0) # define SIMDE_VECTORIZE HEDLEY_PRAGMA(_CRI ivdep) # define SIMDE_VECTORIZE_SAFELEN(l) SIMDE_VECTORIZE # define SIMDE_VECTORIZE_REDUCTION(r) SIMDE_VECTORIZE # define SIMDE_VECTORIZE_ALIGNED(a) #else # define SIMDE_VECTORIZE # define SIMDE_VECTORIZE_SAFELEN(l) # define SIMDE_VECTORIZE_REDUCTION(r) # define SIMDE_VECTORIZE_ALIGNED(a) #endif #define SIMDE_MASK_NZ_(v, mask) (((v) & (mask)) | !((v) & (mask))) /* Intended for checking coverage, you should never use this in production. */ #if defined(SIMDE_NO_INLINE) # define SIMDE_FUNCTION_ATTRIBUTES HEDLEY_NEVER_INLINE static #else # define SIMDE_FUNCTION_ATTRIBUTES HEDLEY_ALWAYS_INLINE static #endif #if defined(SIMDE_NO_INLINE) # define SIMDE_HUGE_FUNCTION_ATTRIBUTES HEDLEY_NEVER_INLINE static #elif defined(SIMDE_CONSTRAINED_COMPILATION) # define SIMDE_HUGE_FUNCTION_ATTRIBUTES static #else # define SIMDE_HUGE_FUNCTION_ATTRIBUTES HEDLEY_ALWAYS_INLINE static #endif #if \ HEDLEY_HAS_ATTRIBUTE(unused) || \ HEDLEY_GCC_VERSION_CHECK(2,95,0) # define SIMDE_FUNCTION_POSSIBLY_UNUSED_ __attribute__((__unused__)) #else # define SIMDE_FUNCTION_POSSIBLY_UNUSED_ #endif HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ #if defined(_MSC_VER) # define SIMDE_BEGIN_DECLS_ HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(disable:4996 4204)) HEDLEY_BEGIN_C_DECLS # define SIMDE_END_DECLS_ HEDLEY_DIAGNOSTIC_POP HEDLEY_END_C_DECLS #else # define SIMDE_BEGIN_DECLS_ \ HEDLEY_DIAGNOSTIC_PUSH \ SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ \ HEDLEY_BEGIN_C_DECLS # define SIMDE_END_DECLS_ \ HEDLEY_END_C_DECLS \ HEDLEY_DIAGNOSTIC_POP #endif #if defined(__SIZEOF_INT128__) # define SIMDE_HAVE_INT128_ HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_PEDANTIC_ typedef __int128 simde_int128; typedef unsigned __int128 simde_uint128; HEDLEY_DIAGNOSTIC_POP #endif #if !defined(SIMDE_ENDIAN_LITTLE) # define SIMDE_ENDIAN_LITTLE 1234 #endif #if !defined(SIMDE_ENDIAN_BIG) # define SIMDE_ENDIAN_BIG 4321 #endif #if !defined(SIMDE_ENDIAN_ORDER) /* GCC (and compilers masquerading as GCC) define __BYTE_ORDER__. */ # if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG /* TI defines _BIG_ENDIAN or _LITTLE_ENDIAN */ # elif defined(_BIG_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG # elif defined(_LITTLE_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE /* We know the endianness of some common architectures. Common * architectures not listed (ARM, POWER, MIPS, etc.) here are * bi-endian. */ # elif defined(__amd64) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(__s390x__) || defined(__zarch__) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG /* Looks like we'll have to rely on the platform. If we're missing a * platform, please let us know. */ # elif defined(_WIN32) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(sun) || defined(__sun) /* Solaris */ # include # if defined(_LITTLE_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(_BIG_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG # endif # elif defined(__APPLE__) # include # if defined(__LITTLE_ENDIAN__) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(__BIG_ENDIAN__) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG # endif # elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) || defined(BSD) # include # if defined(__BYTE_ORDER) && (__BYTE_ORDER == __LITTLE_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(__BYTE_ORDER) && (__BYTE_ORDER == __BIG_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG # endif # elif defined(__linux__) || defined(__linux) || defined(__gnu_linux__) # include # if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_LITTLE # elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) # define SIMDE_ENDIAN_ORDER SIMDE_ENDIAN_BIG # endif # endif #endif #if \ HEDLEY_HAS_BUILTIN(__builtin_bswap64) || \ HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) #define simde_bswap64(v) __builtin_bswap64(v) #elif HEDLEY_MSVC_VERSION_CHECK(13,10,0) #define simde_bswap64(v) _byteswap_uint64(v) #else SIMDE_FUNCTION_ATTRIBUTES uint64_t simde_bswap64(uint64_t v) { return ((v & (((uint64_t) 0xff) << 56)) >> 56) | ((v & (((uint64_t) 0xff) << 48)) >> 40) | ((v & (((uint64_t) 0xff) << 40)) >> 24) | ((v & (((uint64_t) 0xff) << 32)) >> 8) | ((v & (((uint64_t) 0xff) << 24)) << 8) | ((v & (((uint64_t) 0xff) << 16)) << 24) | ((v & (((uint64_t) 0xff) << 8)) << 40) | ((v & (((uint64_t) 0xff) )) << 56); } #endif #if !defined(SIMDE_ENDIAN_ORDER) # error Unknown byte order; please file a bug #else # if SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE # define simde_endian_bswap64_be(value) simde_bswap64(value) # define simde_endian_bswap64_le(value) (value) # elif SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_BIG # define simde_endian_bswap64_be(value) (value) # define simde_endian_bswap64_le(value) simde_bswap64(value) # endif #endif /* TODO: we should at least make an attempt to detect the correct types for simde_float32/float64 instead of just assuming float and double. */ #if !defined(SIMDE_FLOAT32_TYPE) # define SIMDE_FLOAT32_TYPE float # define SIMDE_FLOAT32_C(value) value##f #else # define SIMDE_FLOAT32_C(value) ((SIMDE_FLOAT32_TYPE) value) #endif typedef SIMDE_FLOAT32_TYPE simde_float32; #if !defined(SIMDE_FLOAT64_TYPE) # define SIMDE_FLOAT64_TYPE double # define SIMDE_FLOAT64_C(value) value #else # define SIMDE_FLOAT64_C(value) ((SIMDE_FLOAT64_TYPE) value) #endif typedef SIMDE_FLOAT64_TYPE simde_float64; #if defined(__cplusplus) typedef bool simde_bool; #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) typedef _Bool simde_bool; #elif defined(bool) typedef bool simde_bool; #else #include typedef bool simde_bool; #endif #if HEDLEY_HAS_WARNING("-Wbad-function-cast") # define SIMDE_CONVERT_FTOI(T,v) \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wbad-function-cast\"") \ HEDLEY_STATIC_CAST(T, (v)) \ HEDLEY_DIAGNOSTIC_POP #else # define SIMDE_CONVERT_FTOI(T,v) ((T) (v)) #endif /* TODO: detect compilers which support this outside of C11 mode */ #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) #define SIMDE_CHECKED_REINTERPRET_CAST(to, from, value) _Generic((value), to: (value), default: (_Generic((value), from: ((to) (value))))) #define SIMDE_CHECKED_STATIC_CAST(to, from, value) _Generic((value), to: (value), default: (_Generic((value), from: ((to) (value))))) #else #define SIMDE_CHECKED_REINTERPRET_CAST(to, from, value) HEDLEY_REINTERPRET_CAST(to, value) #define SIMDE_CHECKED_STATIC_CAST(to, from, value) HEDLEY_STATIC_CAST(to, value) #endif #if HEDLEY_HAS_WARNING("-Wfloat-equal") # define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL _Pragma("clang diagnostic ignored \"-Wfloat-equal\"") #elif HEDLEY_GCC_VERSION_CHECK(3,0,0) # define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"") #else # define SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL #endif /* Some functions can trade accuracy for speed. For those functions you can control the trade-off using this macro. Possible values: 0: prefer speed 1: reasonable trade-offs 2: prefer accuracy */ #if !defined(SIMDE_ACCURACY_PREFERENCE) # define SIMDE_ACCURACY_PREFERENCE 1 #endif #if defined(__STDC_HOSTED__) # define SIMDE_STDC_HOSTED __STDC_HOSTED__ #else # if \ defined(HEDLEY_PGI_VERSION) || \ defined(HEDLEY_MSVC_VERSION) # define SIMDE_STDC_HOSTED 1 # else # define SIMDE_STDC_HOSTED 0 # endif #endif /* Try to deal with environments without a standard library. */ #if !defined(simde_memcpy) #if HEDLEY_HAS_BUILTIN(__builtin_memcpy) #define simde_memcpy(dest, src, n) __builtin_memcpy(dest, src, n) #endif #endif #if !defined(simde_memset) #if HEDLEY_HAS_BUILTIN(__builtin_memset) #define simde_memset(s, c, n) __builtin_memset(s, c, n) #endif #endif #if !defined(simde_memcmp) #if HEDLEY_HAS_BUILTIN(__builtin_memcmp) #define simde_memcmp(s1, s2, n) __builtin_memcmp(s1, s2, n) #endif #endif #if !defined(simde_memcpy) || !defined(simde_memset) || !defined(simde_memcmp) #if !defined(SIMDE_NO_STRING_H) #if defined(__has_include) #if !__has_include() #define SIMDE_NO_STRING_H #endif #elif (SIMDE_STDC_HOSTED == 0) #define SIMDE_NO_STRING_H #endif #endif #if !defined(SIMDE_NO_STRING_H) #include #if !defined(simde_memcpy) #define simde_memcpy(dest, src, n) memcpy(dest, src, n) #endif #if !defined(simde_memset) #define simde_memset(s, c, n) memset(s, c, n) #endif #if !defined(simde_memcmp) #define simde_memcmp(s1, s2, n) memcmp(s1, s2, n) #endif #else /* These are meant to be portable, not fast. If you're hitting them you * should think about providing your own (by defining the simde_memcpy * macro prior to including any SIMDe files) or submitting a patch to * SIMDe so we can detect your system-provided memcpy/memset, like by * adding your compiler to the checks for __builtin_memcpy and/or * __builtin_memset. */ #if !defined(simde_memcpy) SIMDE_FUNCTION_ATTRIBUTES void simde_memcpy_(void* dest, const void* src, size_t len) { char* dest_ = HEDLEY_STATIC_CAST(char*, dest); char* src_ = HEDLEY_STATIC_CAST(const char*, src); for (size_t i = 0 ; i < len ; i++) { dest_[i] = src_[i]; } } #define simde_memcpy(dest, src, n) simde_memcpy_(dest, src, n) #endif #if !defined(simde_memset) SIMDE_FUNCTION_ATTRIBUTES void simde_memset_(void* s, int c, size_t len) { char* s_ = HEDLEY_STATIC_CAST(char*, s); char c_ = HEDLEY_STATIC_CAST(char, c); for (size_t i = 0 ; i < len ; i++) { s_[i] = c_[i]; } } #define simde_memset(s, c, n) simde_memset_(s, c, n) #endif #if !defined(simde_memcmp) SIMDE_FUCTION_ATTRIBUTES int simde_memcmp_(const void *s1, const void *s2, size_t n) { unsigned char* s1_ = HEDLEY_STATIC_CAST(unsigned char*, s1); unsigned char* s2_ = HEDLEY_STATIC_CAST(unsigned char*, s2); for (size_t i = 0 ; i < len ; i++) { if (s1_[i] != s2_[i]) { return (int) (s1_[i] - s2_[i]); } } return 0; } #define simde_memcmp(s1, s2, n) simde_memcmp_(s1, s2, n) #endif #endif #endif /*** Functions that quiet a signaling NaN ***/ static HEDLEY_INLINE double simde_math_quiet(double x) { uint64_t tmp, mask; if (!simde_math_isnan(x)) { return x; } simde_memcpy(&tmp, &x, 8); mask = 0x7ff80000; mask <<= 32; tmp |= mask; simde_memcpy(&x, &tmp, 8); return x; } static HEDLEY_INLINE float simde_math_quietf(float x) { uint32_t tmp; if (!simde_math_isnanf(x)) { return x; } simde_memcpy(&tmp, &x, 4); tmp |= 0x7fc00000lu; simde_memcpy(&x, &tmp, 4); return x; } #if defined(FE_ALL_EXCEPT) #define SIMDE_HAVE_FENV_H #elif defined(__has_include) #if __has_include() #include #define SIMDE_HAVE_FENV_H #endif #elif SIMDE_STDC_HOSTED == 1 #include #define SIMDE_HAVE_FENV_H #endif #if defined(EXIT_FAILURE) #define SIMDE_HAVE_STDLIB_H #elif defined(__has_include) #if __has_include() #include #define SIMDE_HAVE_STDLIB_H #endif #elif SIMDE_STDC_HOSTED == 1 #include #define SIMDE_HAVE_STDLIB_H #endif #if defined(__has_include) # if defined(__cplusplus) && (__cplusplus >= 201103L) && __has_include() # include # elif __has_include() # include # endif # if __has_include() # include # endif #elif SIMDE_STDC_HOSTED == 1 # include # include #endif #define SIMDE_DEFINE_CONVERSION_FUNCTION_(Name, T_To, T_From) \ static HEDLEY_ALWAYS_INLINE HEDLEY_CONST SIMDE_FUNCTION_POSSIBLY_UNUSED_ \ T_To \ Name (T_From value) { \ T_To r; \ simde_memcpy(&r, &value, sizeof(r)); \ return r; \ } SIMDE_DEFINE_CONVERSION_FUNCTION_(simde_float32_as_uint32, uint32_t, simde_float32) SIMDE_DEFINE_CONVERSION_FUNCTION_(simde_uint32_as_float32, simde_float32, uint32_t) SIMDE_DEFINE_CONVERSION_FUNCTION_(simde_float64_as_uint64, uint64_t, simde_float64) SIMDE_DEFINE_CONVERSION_FUNCTION_(simde_uint64_as_float64, simde_float64, uint64_t) /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin check.h :: */ /* Check (assertions) * Portable Snippets - https://github.com/nemequ/portable-snippets * Created by Evan Nemerson * * To the extent possible under law, the authors have waived all * copyright and related or neighboring rights to this code. For * details, see the Creative Commons Zero 1.0 Universal license at * https://creativecommons.org/publicdomain/zero/1.0/ * * SPDX-License-Identifier: CC0-1.0 */ #if !defined(SIMDE_CHECK_H) #define SIMDE_CHECK_H #if !defined(SIMDE_NDEBUG) && !defined(SIMDE_DEBUG) # define SIMDE_NDEBUG 1 #endif /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ #include #if !defined(_WIN32) # define SIMDE_SIZE_MODIFIER "z" # define SIMDE_CHAR_MODIFIER "hh" # define SIMDE_SHORT_MODIFIER "h" #else # if defined(_M_X64) || defined(__amd64__) # define SIMDE_SIZE_MODIFIER "I64" # else # define SIMDE_SIZE_MODIFIER "" # endif # define SIMDE_CHAR_MODIFIER "" # define SIMDE_SHORT_MODIFIER "" #endif #if defined(_MSC_VER) && (_MSC_VER >= 1500) # define SIMDE_PUSH_DISABLE_MSVC_C4127_ __pragma(warning(push)) __pragma(warning(disable:4127)) # define SIMDE_POP_DISABLE_MSVC_C4127_ __pragma(warning(pop)) #else # define SIMDE_PUSH_DISABLE_MSVC_C4127_ # define SIMDE_POP_DISABLE_MSVC_C4127_ #endif #if !defined(simde_errorf) # if defined(__has_include) # if __has_include() # include # endif # elif defined(SIMDE_STDC_HOSTED) # if SIMDE_STDC_HOSTED == 1 # include # endif # elif defined(__STDC_HOSTED__) # if __STDC_HOSTETD__ == 1 # include # endif # endif /* AUTOMATICALLY GENERATED FILE, DO NOT MODIFY */ /* 8025b06b07f4789aad472563d363f86671d9e372 */ /* :: Begin debug-trap.h :: */ /* Debugging assertions and traps * Portable Snippets - https://github.com/nemequ/portable-snippets * Created by Evan Nemerson * * To the extent possible under law, the authors have waived all * copyright and related or neighboring rights to this code. For * details, see the Creative Commons Zero 1.0 Universal license at * https://creativecommons.org/publicdomain/zero/1.0/ * * SPDX-License-Identifier: CC0-1.0 */ #if !defined(SIMDE_DEBUG_TRAP_H) #define SIMDE_DEBUG_TRAP_H #if !defined(SIMDE_NDEBUG) && defined(NDEBUG) && !defined(SIMDE_DEBUG) # define SIMDE_NDEBUG 1 #endif #if defined(__has_builtin) && !defined(__ibmxl__) # if __has_builtin(__builtin_debugtrap) # define simde_trap() __builtin_debugtrap() # elif __has_builtin(__debugbreak) # define simde_trap() __debugbreak() # endif #endif #if !defined(simde_trap) # if defined(_MSC_VER) || defined(__INTEL_COMPILER) # define simde_trap() __debugbreak() # elif defined(__ARMCC_VERSION) # define simde_trap() __breakpoint(42) # elif defined(__ibmxl__) || defined(__xlC__) # include # define simde_trap() __trap(42) # elif defined(__DMC__) && defined(_M_IX86) static inline void simde_trap(void) { __asm int 3h; } # elif defined(__i386__) || defined(__x86_64__) static inline void simde_trap(void) { __asm__ __volatile__("int $03"); } # elif defined(__thumb__) static inline void simde_trap(void) { __asm__ __volatile__(".inst 0xde01"); } # elif defined(__aarch64__) static inline void simde_trap(void) { __asm__ __volatile__(".inst 0xd4200000"); } # elif defined(__arm__) static inline void simde_trap(void) { __asm__ __volatile__(".inst 0xe7f001f0"); } # elif defined (__alpha__) && !defined(__osf__) static inline void simde_trap(void) { __asm__ __volatile__("bpt"); } # elif defined(_54_) static inline void simde_trap(void) { __asm__ __volatile__("ESTOP"); } # elif defined(_55_) static inline void simde_trap(void) { __asm__ __volatile__(";\n .if (.MNEMONIC)\n ESTOP_1\n .else\n ESTOP_1()\n .endif\n NOP"); } # elif defined(_64P_) static inline void simde_trap(void) { __asm__ __volatile__("SWBP 0"); } # elif defined(_6x_) static inline void simde_trap(void) { __asm__ __volatile__("NOP\n .word 0x10000000"); } # elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__) # define simde_trap() __builtin_trap() # else # include # if defined(SIGTRAP) # define simde_trap() raise(SIGTRAP) # else # define simde_trap() raise(SIGABRT) # endif # endif #endif #if defined(HEDLEY_LIKELY) # define SIMDE_DBG_LIKELY(expr) HEDLEY_LIKELY(expr) #elif defined(__GNUC__) && (__GNUC__ >= 3) # define SIMDE_DBG_LIKELY(expr) __builtin_expect(!!(expr), 1) #else # define SIMDE_DBG_LIKELY(expr) (!!(expr)) #endif #if !defined(SIMDE_NDEBUG) || (SIMDE_NDEBUG == 0) # define simde_dbg_assert(expr) do { \ if (!SIMDE_DBG_LIKELY(expr)) { \ simde_trap(); \ } \ } while (0) #else # define simde_dbg_assert(expr) #endif #endif /* !defined(SIMDE_DEBUG_TRAP_H) */ /* :: End debug-trap.h :: */ HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_ # if defined(EOF) # define simde_errorf(format, ...) (fprintf(stderr, format, __VA_ARGS__), abort()) # else # define simde_errorf(format, ...) (simde_trap()) # endif HEDLEY_DIAGNOSTIC_POP #endif #define simde_error(msg) simde_errorf("%s", msg) #if defined(SIMDE_NDEBUG) || \ (defined(__cplusplus) && (__cplusplus < 201103L)) || \ (defined(__STDC__) && (__STDC__ < 199901L)) # if defined(SIMDE_CHECK_FAIL_DEFINED) # define simde_assert(expr) # else # if defined(HEDLEY_ASSUME) # define simde_assert(expr) HEDLEY_ASSUME(expr) # elif HEDLEY_GCC_VERSION_CHECK(4,5,0) # define simde_assert(expr) ((void) (!!(expr) ? 1 : (__builtin_unreachable(), 1))) # elif HEDLEY_MSVC_VERSION_CHECK(13,10,0) # define simde_assert(expr) __assume(expr) # else # define simde_assert(expr) # endif # endif # define simde_assert_true(expr) simde_assert(expr) # define simde_assert_false(expr) simde_assert(!(expr)) # define simde_assert_type_full(prefix, suffix, T, fmt, a, op, b) simde_assert(((a) op (b))) # define simde_assert_double_equal(a, b, precision) # define simde_assert_string_equal(a, b) # define simde_assert_string_not_equal(a, b) # define simde_assert_memory_equal(size, a, b) # define simde_assert_memory_not_equal(size, a, b) #else # define simde_assert(expr) \ do { \ if (!HEDLEY_LIKELY(expr)) { \ simde_error("assertion failed: " #expr "\n"); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_true(expr) \ do { \ if (!HEDLEY_LIKELY(expr)) { \ simde_error("assertion failed: " #expr " is not true\n"); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_false(expr) \ do { \ if (!HEDLEY_LIKELY(!(expr))) { \ simde_error("assertion failed: " #expr " is not false\n"); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_type_full(prefix, suffix, T, fmt, a, op, b) \ do { \ T simde_tmp_a_ = (a); \ T simde_tmp_b_ = (b); \ if (!(simde_tmp_a_ op simde_tmp_b_)) { \ simde_errorf("assertion failed: %s %s %s (" prefix "%" fmt suffix " %s " prefix "%" fmt suffix ")\n", \ #a, #op, #b, simde_tmp_a_, #op, simde_tmp_b_); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_double_equal(a, b, precision) \ do { \ const double simde_tmp_a_ = (a); \ const double simde_tmp_b_ = (b); \ const double simde_tmp_diff_ = ((simde_tmp_a_ - simde_tmp_b_) < 0) ? \ -(simde_tmp_a_ - simde_tmp_b_) : \ (simde_tmp_a_ - simde_tmp_b_); \ if (HEDLEY_UNLIKELY(simde_tmp_diff_ > 1e-##precision)) { \ simde_errorf("assertion failed: %s == %s (%0." #precision "g == %0." #precision "g)\n", \ #a, #b, simde_tmp_a_, simde_tmp_b_); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # include # define simde_assert_string_equal(a, b) \ do { \ const char* simde_tmp_a_ = a; \ const char* simde_tmp_b_ = b; \ if (HEDLEY_UNLIKELY(strcmp(simde_tmp_a_, simde_tmp_b_) != 0)) { \ simde_errorf("assertion failed: string %s == %s (\"%s\" == \"%s\")\n", \ #a, #b, simde_tmp_a_, simde_tmp_b_); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_string_not_equal(a, b) \ do { \ const char* simde_tmp_a_ = a; \ const char* simde_tmp_b_ = b; \ if (HEDLEY_UNLIKELY(strcmp(simde_tmp_a_, simde_tmp_b_) == 0)) { \ simde_errorf("assertion failed: string %s != %s (\"%s\" == \"%s\")\n", \ #a, #b, simde_tmp_a_, simde_tmp_b_); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_memory_equal(size, a, b) \ do { \ const unsigned char* simde_tmp_a_ = (const unsigned char*) (a); \ const unsigned char* simde_tmp_b_ = (const unsigned char*) (b); \ const size_t simde_tmp_size_ = (size); \ if (HEDLEY_UNLIKELY(memcmp(simde_tmp_a_, simde_tmp_b_, simde_tmp_size_)) != 0) { \ size_t simde_tmp_pos_; \ for (simde_tmp_pos_ = 0 ; simde_tmp_pos_ < simde_tmp_size_ ; simde_tmp_pos_++) { \ if (simde_tmp_a_[simde_tmp_pos_] != simde_tmp_b_[simde_tmp_pos_]) { \ simde_errorf("assertion failed: memory %s == %s, at offset %" SIMDE_SIZE_MODIFIER "u\n", \ #a, #b, simde_tmp_pos_); \ break; \ } \ } \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ # define simde_assert_memory_not_equal(size, a, b) \ do { \ const unsigned char* simde_tmp_a_ = (const unsigned char*) (a); \ const unsigned char* simde_tmp_b_ = (const unsigned char*) (b); \ const size_t simde_tmp_size_ = (size); \ if (HEDLEY_UNLIKELY(memcmp(simde_tmp_a_, simde_tmp_b_, simde_tmp_size_)) == 0) { \ simde_errorf("assertion failed: memory %s != %s (%" SIMDE_SIZE_MODIFIER "u bytes)\n", \ #a, #b, simde_tmp_size_); \ } \ SIMDE_PUSH_DISABLE_MSVC_C4127_ \ } while (0) \ SIMDE_POP_DISABLE_MSVC_C4127_ #endif #define simde_assert_type(T, fmt, a, op, b) \ simde_assert_type_full("", "", T, fmt, a, op, b) #define simde_assert_char(a, op, b) \ simde_assert_type_full("'\\x", "'", char, "02" SIMDE_CHAR_MODIFIER "x", a, op, b) #define simde_assert_uchar(a, op, b) \ simde_assert_type_full("'\\x", "'", unsigned char, "02" SIMDE_CHAR_MODIFIER "x", a, op, b) #define simde_assert_short(a, op, b) \ simde_assert_type(short, SIMDE_SHORT_MODIFIER "d", a, op, b) #define simde_assert_ushort(a, op, b) \ simde_assert_type(unsigned short, SIMDE_SHORT_MODIFIER "u", a, op, b) #define simde_assert_int(a, op, b) \ simde_assert_type(int, "d", a, op, b) #define simde_assert_uint(a, op, b) \ simde_assert_type(unsigned int, "u", a, op, b) #define simde_assert_long(a, op, b) \ simde_assert_type(long int, "ld", a, op, b) #define simde_assert_ulong(a, op, b) \ simde_assert_type(unsigned long int, "lu", a, op, b) #define simde_assert_llong(a, op, b) \ simde_assert_type(long long int, "lld", a, op, b) #define simde_assert_ullong(a, op, b) \ simde_assert_type(unsigned long long int, "llu", a, op, b) #define simde_assert_size(a, op, b) \ simde_assert_type(size_t, SIMDE_SIZE_MODIFIER "u", a, op, b) #define simde_assert_float(a, op, b) \ simde_assert_type(float, "f", a, op, b) #define simde_assert_double(a, op, b) \ simde_assert_type(double, "g", a, op, b) #define simde_assert_ptr(a, op, b) \ simde_assert_type(const void*, "p", a, op, b) #define simde_assert_int8(a, op, b) \ simde_assert_type(int8_t, PRIi8, a, op, b) #define simde_assert_uint8(a, op, b) \ simde_assert_type(uint8_t, PRIu8, a, op, b) #define simde_assert_int16(a, op, b) \ simde_assert_type(int16_t, PRIi16, a, op, b) #define simde_assert_uint16(a, op, b) \ simde_assert_type(uint16_t, PRIu16, a, op, b) #define simde_assert_int32(a, op, b) \ simde_assert_type(int32_t, PRIi32, a, op, b) #define simde_assert_uint32(a, op, b) \ simde_assert_type(uint32_t, PRIu32, a, op, b) #define simde_assert_int64(a, op, b) \ simde_assert_type(int64_t, PRIi64, a, op, b) #define simde_assert_uint64(a, op, b) \ simde_assert_type(uint64_t, PRIu64, a, op, b) #define simde_assert_ptr_equal(a, b) \ simde_assert_ptr(a, ==, b) #define simde_assert_ptr_not_equal(a, b) \ simde_assert_ptr(a, !=, b) #define simde_assert_null(ptr) \ simde_assert_ptr(ptr, ==, NULL) #define simde_assert_not_null(ptr) \ simde_assert_ptr(ptr, !=, NULL) #define simde_assert_ptr_null(ptr) \ simde_assert_ptr(ptr, ==, NULL) #define simde_assert_ptr_not_null(ptr) \ simde_assert_ptr(ptr, !=, NULL) #endif /* !defined(SIMDE_CHECK_H) */ /* :: End check.h :: */ /* GCC/clang have a bunch of functionality in builtins which we would * like to access, but the suffixes indicate whether the operate on * int, long, or long long, not fixed width types (e.g., int32_t). * we use these macros to attempt to map from fixed-width to the * names GCC uses. Note that you should still cast the input(s) and * return values (to/from SIMDE_BUILTIN_TYPE_*_) since often even if * types are the same size they may not be compatible according to the * compiler. For example, on x86 long and long lonsg are generally * both 64 bits, but platforms vary on whether an int64_t is mapped * to a long or long long. */ #include HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ #if (INT8_MAX == INT_MAX) && (INT8_MIN == INT_MIN) #define SIMDE_BUILTIN_SUFFIX_8_ #define SIMDE_BUILTIN_TYPE_8_ int #elif (INT8_MAX == LONG_MAX) && (INT8_MIN == LONG_MIN) #define SIMDE_BUILTIN_SUFFIX_8_ l #define SIMDE_BUILTIN_TYPE_8_ long #elif (INT8_MAX == LLONG_MAX) && (INT8_MIN == LLONG_MIN) #define SIMDE_BUILTIN_SUFFIX_8_ ll #define SIMDE_BUILTIN_TYPE_8_ long long #endif #if (INT16_MAX == INT_MAX) && (INT16_MIN == INT_MIN) #define SIMDE_BUILTIN_SUFFIX_16_ #define SIMDE_BUILTIN_TYPE_16_ int #elif (INT16_MAX == LONG_MAX) && (INT16_MIN == LONG_MIN) #define SIMDE_BUILTIN_SUFFIX_16_ l #define SIMDE_BUILTIN_TYPE_16_ long #elif (INT16_MAX == LLONG_MAX) && (INT16_MIN == LLONG_MIN) #define SIMDE_BUILTIN_SUFFIX_16_ ll #define SIMDE_BUILTIN_TYPE_16_ long long #endif #if (INT32_MAX == INT_MAX) && (INT32_MIN == INT_MIN) #define SIMDE_BUILTIN_SUFFIX_32_ #define SIMDE_BUILTIN_TYPE_32_ int #elif (INT32_MAX == LONG_MAX) && (INT32_MIN == LONG_MIN) #define SIMDE_BUILTIN_SUFFIX_32_ l #define SIMDE_BUILTIN_TYPE_32_ long #elif (INT32_MAX == LLONG_MAX) && (INT32_MIN == LLONG_MIN) #define SIMDE_BUILTIN_SUFFIX_32_ ll #define SIMDE_BUILTIN_TYPE_32_ long long #endif #if (INT64_MAX == INT_MAX) && (INT64_MIN == INT_MIN) #define SIMDE_BUILTIN_SUFFIX_64_ #define SIMDE_BUILTIN_TYPE_64_ int #elif (INT64_MAX == LONG_MAX) && (INT64_MIN == LONG_MIN) #define SIMDE_BUILTIN_SUFFIX_64_ l #define SIMDE_BUILTIN_TYPE_64_ long #elif (INT64_MAX == LLONG_MAX) && (INT64_MIN == LLONG_MIN) #define SIMDE_BUILTIN_SUFFIX_64_ ll #define SIMDE_BUILTIN_TYPE_64_ long long #endif /* SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_ */ HEDLEY_DIAGNOSTIC_POP #if defined(SIMDE_BUILTIN_SUFFIX_8_) #define SIMDE_BUILTIN_8_(name) HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_8_) #define SIMDE_BUILTIN_HAS_8_(name) HEDLEY_HAS_BUILTIN(HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_8_)) #else #define SIMDE_BUILTIN_HAS_8_(name) 0 #endif #if defined(SIMDE_BUILTIN_SUFFIX_16_) #define SIMDE_BUILTIN_16_(name) HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_16_) #define SIMDE_BUILTIN_HAS_16_(name) HEDLEY_HAS_BUILTIN(HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_16_)) #else #define SIMDE_BUILTIN_HAS_16_(name) 0 #endif #if defined(SIMDE_BUILTIN_SUFFIX_32_) #define SIMDE_BUILTIN_32_(name) HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_32_) #define SIMDE_BUILTIN_HAS_32_(name) HEDLEY_HAS_BUILTIN(HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_32_)) #else #define SIMDE_BUILTIN_HAS_32_(name) 0 #endif #if defined(SIMDE_BUILTIN_SUFFIX_64_) #define SIMDE_BUILTIN_64_(name) HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_64_) #define SIMDE_BUILTIN_HAS_64_(name) HEDLEY_HAS_BUILTIN(HEDLEY_CONCAT3(__builtin_, name, SIMDE_BUILTIN_SUFFIX_64_)) #else #define SIMDE_BUILTIN_HAS_64_(name) 0 #endif #if !defined(__cplusplus) #if defined(__clang__) #if HEDLEY_HAS_WARNING("-Wc11-extensions") #define SIMDE_GENERIC_(...) (__extension__ ({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc11-extensions\"") \ _Generic(__VA_ARGS__); \ HEDLEY_DIAGNOSTIC_POP \ })) #elif HEDLEY_HAS_WARNING("-Wc1x-extensions") #define SIMDE_GENERIC_(...) (__extension__ ({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("clang diagnostic ignored \"-Wc1x-extensions\"") \ _Generic(__VA_ARGS__); \ HEDLEY_DIAGNOSTIC_POP \ })) #endif #elif \ defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) || \ HEDLEY_HAS_EXTENSION(c_generic_selections) || \ HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ HEDLEY_ARM_VERSION_CHECK(5,3,0) #define SIMDE_GENERIC_(...) _Generic(__VA_ARGS__) #endif #endif /* Sometimes we run into problems with specific versions of compilers which make the native versions unusable for us. Often this is due to missing functions, sometimes buggy implementations, etc. These macros are how we check for specific bugs. As they are fixed we'll start only defining them for problematic compiler versions. */ #if !defined(SIMDE_IGNORE_COMPILER_BUGS) # if defined(HEDLEY_GCC_VERSION) # if !HEDLEY_GCC_VERSION_CHECK(4,9,0) # define SIMDE_BUG_GCC_REV_208793 # endif # if !HEDLEY_GCC_VERSION_CHECK(5,0,0) # define SIMDE_BUG_GCC_BAD_MM_SRA_EPI32 /* TODO: find relevant bug or commit */ # endif # if !HEDLEY_GCC_VERSION_CHECK(6,0,0) # define SIMDE_BUG_GCC_SIZEOF_IMMEDIATE # endif # if !HEDLEY_GCC_VERSION_CHECK(4,6,0) # define SIMDE_BUG_GCC_BAD_MM_EXTRACT_EPI8 /* TODO: find relevant bug or commit */ # endif # if !HEDLEY_GCC_VERSION_CHECK(8,0,0) # define SIMDE_BUG_GCC_REV_247851 # endif # if !HEDLEY_GCC_VERSION_CHECK(10,0,0) # define SIMDE_BUG_GCC_REV_274313 # define SIMDE_BUG_GCC_91341 # define SIMDE_BUG_GCC_92035 # endif # if !HEDLEY_GCC_VERSION_CHECK(9,0,0) && defined(SIMDE_ARCH_AARCH64) # define SIMDE_BUG_GCC_ARM_SHIFT_SCALAR # endif # if !HEDLEY_GCC_VERSION_CHECK(9,0,0) && defined(SIMDE_ARCH_AARCH64) # define SIMDE_BUG_GCC_BAD_VEXT_REV32 # endif # if defined(SIMDE_ARCH_X86) && !defined(SIMDE_ARCH_AMD64) # define SIMDE_BUG_GCC_94482 # endif # if (defined(SIMDE_ARCH_X86) && !defined(SIMDE_ARCH_AMD64)) || defined(SIMDE_ARCH_ZARCH) # define SIMDE_BUG_GCC_53784 # endif # if defined(SIMDE_ARCH_X86) || defined(SIMDE_ARCH_AMD64) # if HEDLEY_GCC_VERSION_CHECK(4,3,0) /* -Wsign-conversion */ # define SIMDE_BUG_GCC_95144 # endif # if !HEDLEY_GCC_VERSION_CHECK(11,2,0) # define SIMDE_BUG_GCC_95483 # endif # if defined(__OPTIMIZE__) # define SIMDE_BUG_GCC_100927 # endif # define SIMDE_BUG_GCC_98521 # endif # if !HEDLEY_GCC_VERSION_CHECK(9,4,0) && defined(SIMDE_ARCH_AARCH64) # define SIMDE_BUG_GCC_94488 # endif # if !HEDLEY_GCC_VERSION_CHECK(9,1,0) && defined(SIMDE_ARCH_AARCH64) # define SIMDE_BUG_GCC_REV_264019 # endif # if defined(SIMDE_ARCH_ARM) # define SIMDE_BUG_GCC_95399 # define SIMDE_BUG_GCC_95471 # elif defined(SIMDE_ARCH_POWER) # define SIMDE_BUG_GCC_95227 # define SIMDE_BUG_GCC_95782 # if !HEDLEY_GCC_VERSION_CHECK(12,0,0) # define SIMDE_BUG_VEC_CPSGN_REVERSED_ARGS # endif # elif defined(SIMDE_ARCH_X86) || defined(SIMDE_ARCH_AMD64) # if !HEDLEY_GCC_VERSION_CHECK(10,2,0) && !defined(__OPTIMIZE__) # define SIMDE_BUG_GCC_96174 # endif # elif defined(SIMDE_ARCH_ZARCH) # define SIMDE_BUG_GCC_95782 # if HEDLEY_GCC_VERSION_CHECK(10,0,0) # define SIMDE_BUG_GCC_101614 # endif # endif # if defined(SIMDE_ARCH_MIPS_MSA) # define SIMDE_BUG_GCC_97248 # if !HEDLEY_GCC_VERSION_CHECK(12,1,0) # define SIMDE_BUG_GCC_100760 # define SIMDE_BUG_GCC_100761 # define SIMDE_BUG_GCC_100762 # endif # endif # define SIMDE_BUG_GCC_95399 # if !defined(__OPTIMIZE__) # define SIMDE_BUG_GCC_105339 # endif # elif defined(__clang__) # if defined(SIMDE_ARCH_AARCH64) # define SIMDE_BUG_CLANG_45541 # define SIMDE_BUG_CLANG_48257 # if !SIMDE_DETECT_CLANG_VERSION_CHECK(12,0,0) # define SIMDE_BUG_CLANG_46840 # define SIMDE_BUG_CLANG_46844 # endif # if SIMDE_DETECT_CLANG_VERSION_CHECK(10,0,0) && SIMDE_DETECT_CLANG_VERSION_NOT(11,0,0) # define SIMDE_BUG_CLANG_BAD_VI64_OPS # endif # if SIMDE_DETECT_CLANG_VERSION_NOT(9,0,0) # define SIMDE_BUG_CLANG_GIT_4EC445B8 # define SIMDE_BUG_CLANG_REV_365298 /* 0464e07c8f6e3310c28eb210a4513bc2243c2a7e */ # endif # endif # if defined(SIMDE_ARCH_ARM) # if !SIMDE_DETECT_CLANG_VERSION_CHECK(11,0,0) # define SIMDE_BUG_CLANG_BAD_VGET_SET_LANE_TYPES # endif # endif # if defined(SIMDE_ARCH_POWER) && !SIMDE_DETECT_CLANG_VERSION_CHECK(12,0,0) # define SIMDE_BUG_CLANG_46770 # endif # if defined(SIMDE_ARCH_POWER) && (SIMDE_ARCH_POWER == 700) && (SIMDE_DETECT_CLANG_VERSION_CHECK(11,0,0)) # if !SIMDE_DETECT_CLANG_VERSION_CHECK(13,0,0) # define SIMDE_BUG_CLANG_50893 # define SIMDE_BUG_CLANG_50901 # endif # endif # if defined(_ARCH_PWR9) && !SIMDE_DETECT_CLANG_VERSION_CHECK(12,0,0) && !defined(__OPTIMIZE__) # define SIMDE_BUG_CLANG_POWER9_16x4_BAD_SHIFT # endif # if defined(SIMDE_ARCH_POWER) # define SIMDE_BUG_CLANG_50932 # if !SIMDE_DETECT_CLANG_VERSION_CHECK(12,0,0) # define SIMDE_BUG_VEC_CPSGN_REVERSED_ARGS # endif # endif # if defined(SIMDE_ARCH_X86) || defined(SIMDE_ARCH_AMD64) # if SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) # define SIMDE_BUG_CLANG_REV_298042 /* 6afc436a7817a52e78ae7bcdc3faafd460124cac */ # endif # if SIMDE_DETECT_CLANG_VERSION_NOT(3,7,0) # define SIMDE_BUG_CLANG_REV_234560 /* b929ad7b1726a32650a8051f69a747fb6836c540 */ # endif # if SIMDE_DETECT_CLANG_VERSION_CHECK(3,8,0) && SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) # define SIMDE_BUG_CLANG_BAD_MADD # endif # if SIMDE_DETECT_CLANG_VERSION_CHECK(4,0,0) && SIMDE_DETECT_CLANG_VERSION_NOT(5,0,0) # define SIMDE_BUG_CLANG_REV_299346 /* ac9959eb533a58482ea4da6c4db1e635a98de384 */ # endif # if SIMDE_DETECT_CLANG_VERSION_NOT(8,0,0) # define SIMDE_BUG_CLANG_REV_344862 /* eae26bf73715994c2bd145f9b6dc3836aa4ffd4f */ # endif # if HEDLEY_HAS_WARNING("-Wsign-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(11,0,0) # define SIMDE_BUG_CLANG_45931 # endif # if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(11,0,0) # define SIMDE_BUG_CLANG_44589 # endif # define SIMDE_BUG_CLANG_48673 # endif # define SIMDE_BUG_CLANG_45959 # if defined(SIMDE_ARCH_WASM_SIMD128) # define SIMDE_BUG_CLANG_60655 # endif # elif defined(HEDLEY_MSVC_VERSION) # if defined(SIMDE_ARCH_X86) # define SIMDE_BUG_MSVC_ROUND_EXTRACT # endif # elif defined(HEDLEY_INTEL_VERSION) # define SIMDE_BUG_INTEL_857088 # elif defined(HEDLEY_MCST_LCC_VERSION) # define SIMDE_BUG_MCST_LCC_MISSING_AVX_LOAD_STORE_M128_FUNCS # define SIMDE_BUG_MCST_LCC_MISSING_CMOV_M256 # define SIMDE_BUG_MCST_LCC_FMA_WRONG_RESULT # elif defined(HEDLEY_PGI_VERSION) # define SIMDE_BUG_PGI_30104 # define SIMDE_BUG_PGI_30107 # define SIMDE_BUG_PGI_30106 # endif #endif /* GCC and Clang both have the same issue: * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95144 * https://bugs.llvm.org/show_bug.cgi?id=45931 * This is just an easy way to work around it. */ #if \ (HEDLEY_HAS_WARNING("-Wsign-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(11,0,0)) || \ HEDLEY_GCC_VERSION_CHECK(4,3,0) # define SIMDE_BUG_IGNORE_SIGN_CONVERSION(expr) (__extension__ ({ \ HEDLEY_DIAGNOSTIC_PUSH \ _Pragma("GCC diagnostic ignored \"-Wsign-conversion\"") \ __typeof__(expr) simde_bug_ignore_sign_conversion_v_= (expr); \ HEDLEY_DIAGNOSTIC_POP \ simde_bug_ignore_sign_conversion_v_; \ })) #else # define SIMDE_BUG_IGNORE_SIGN_CONVERSION(expr) (expr) #endif /* Usually the shift count is signed (for example, NEON or SSE). * OTOH, unsigned is good for PPC (vec_srl uses unsigned), and the only option for E2K. * Further info: https://github.com/simd-everywhere/simde/pull/700 */ #if defined(SIMDE_ARCH_E2K) || defined(SIMDE_ARCH_POWER) #define SIMDE_CAST_VECTOR_SHIFT_COUNT(width, value) HEDLEY_STATIC_CAST(uint##width##_t, (value)) #else #define SIMDE_CAST_VECTOR_SHIFT_COUNT(width, value) HEDLEY_STATIC_CAST(int##width##_t, (value)) #endif /* SIMDE_DIAGNOSTIC_DISABLE_USED_BUT_MARKED_UNUSED_ */ HEDLEY_DIAGNOSTIC_POP #endif /* !defined(SIMDE_COMMON_H) */ /* :: End simde-common.h :: */ HEDLEY_DIAGNOSTIC_PUSH SIMDE_DISABLE_UNWANTED_DIAGNOSTICS #if defined(SIMDE_X86_MMX_NATIVE) #define SIMDE_X86_MMX_USE_NATIVE_TYPE #elif defined(SIMDE_X86_SSE_NATIVE) #define SIMDE_X86_MMX_USE_NATIVE_TYPE #endif #if defined(SIMDE_X86_MMX_USE_NATIVE_TYPE) #include #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #include #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) #include #endif #include #include SIMDE_BEGIN_DECLS_ typedef union { #if defined(SIMDE_VECTOR_SUBSCRIPT) SIMDE_ALIGN_TO_8 int8_t i8 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 int16_t i16 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 int32_t i32 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 int64_t i64 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 uint8_t u8 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 uint16_t u16 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 uint32_t u32 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 uint64_t u64 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 simde_float32 f32 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 int_fast32_t i32f SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_8 uint_fast32_t u32f SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; #else SIMDE_ALIGN_TO_8 int8_t i8[8]; SIMDE_ALIGN_TO_8 int16_t i16[4]; SIMDE_ALIGN_TO_8 int32_t i32[2]; SIMDE_ALIGN_TO_8 int64_t i64[1]; SIMDE_ALIGN_TO_8 uint8_t u8[8]; SIMDE_ALIGN_TO_8 uint16_t u16[4]; SIMDE_ALIGN_TO_8 uint32_t u32[2]; SIMDE_ALIGN_TO_8 uint64_t u64[1]; SIMDE_ALIGN_TO_8 simde_float32 f32[2]; SIMDE_ALIGN_TO_8 int_fast32_t i32f[8 / sizeof(int_fast32_t)]; SIMDE_ALIGN_TO_8 uint_fast32_t u32f[8 / sizeof(uint_fast32_t)]; #endif #if defined(SIMDE_X86_MMX_USE_NATIVE_TYPE) __m64 n; #endif #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) int8x8_t neon_i8; int16x4_t neon_i16; int32x2_t neon_i32; int64x1_t neon_i64; uint8x8_t neon_u8; uint16x4_t neon_u16; uint32x2_t neon_u32; uint64x1_t neon_u64; float32x2_t neon_f32; #endif #if defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) int8x8_t mmi_i8; int16x4_t mmi_i16; int32x2_t mmi_i32; int64_t mmi_i64; uint8x8_t mmi_u8; uint16x4_t mmi_u16; uint32x2_t mmi_u32; uint64_t mmi_u64; #endif } simde__m64_private; #if defined(SIMDE_X86_MMX_USE_NATIVE_TYPE) typedef __m64 simde__m64; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) typedef int32x2_t simde__m64; #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) typedef int32x2_t simde__m64; #elif defined(SIMDE_VECTOR_SUBSCRIPT) typedef int32_t simde__m64 SIMDE_ALIGN_TO_8 SIMDE_VECTOR(8) SIMDE_MAY_ALIAS; #else typedef simde__m64_private simde__m64; #endif #if !defined(SIMDE_X86_MMX_USE_NATIVE_TYPE) && defined(SIMDE_ENABLE_NATIVE_ALIASES) #define SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES typedef simde__m64 __m64; #endif HEDLEY_STATIC_ASSERT(8 == sizeof(simde__m64), "__m64 size incorrect"); HEDLEY_STATIC_ASSERT(8 == sizeof(simde__m64_private), "__m64 size incorrect"); #if defined(SIMDE_CHECK_ALIGNMENT) && defined(SIMDE_ALIGN_OF) HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m64) == 8, "simde__m64 is not 8-byte aligned"); HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m64_private) == 8, "simde__m64_private is not 8-byte aligned"); #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde__m64_from_private(simde__m64_private v) { simde__m64 r; simde_memcpy(&r, &v, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m64_private simde__m64_to_private(simde__m64 v) { simde__m64_private r; simde_memcpy(&r, &v, sizeof(r)); return r; } #define SIMDE_X86_GENERATE_CONVERSION_FUNCTION(simde_type, source_type, isax, fragment) \ SIMDE_FUNCTION_ATTRIBUTES \ simde__##simde_type \ simde__##simde_type##_from_##isax##_##fragment(source_type value) { \ simde__##simde_type##_private r_; \ r_.isax##_##fragment = value; \ return simde__##simde_type##_from_private(r_); \ } \ \ SIMDE_FUNCTION_ATTRIBUTES \ source_type \ simde__##simde_type##_to_##isax##_##fragment(simde__##simde_type value) { \ simde__##simde_type##_private r_ = simde__##simde_type##_to_private(value); \ return r_.isax##_##fragment; \ } #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int8x8_t, neon, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int16x4_t, neon, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int32x2_t, neon, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int64x1_t, neon, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint8x8_t, neon, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint16x4_t, neon, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint32x2_t, neon, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint64x1_t, neon, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, float32x2_t, neon, f32) #endif /* defined(SIMDE_ARM_NEON_A32V7_NATIVE) */ #if defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int8x8_t, mmi, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int16x4_t, mmi, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int32x2_t, mmi, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, int64_t, mmi, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint8x8_t, mmi, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint16x4_t, mmi, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint32x2_t, mmi, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m64, uint64_t, mmi, u64) #endif /* defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) */ SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_add_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_add_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vadd_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = paddb_s(a_.mmi_i8, b_.mmi_i8); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = a_.i8 + b_.i8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a_.i8[i] + b_.i8[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddb(a, b) simde_mm_add_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_add_pi8(a, b) simde_mm_add_pi8(a, b) # define _m_paddb(a, b) simde_m_paddb(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_add_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_add_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vadd_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = paddh_s(a_.mmi_i16, b_.mmi_i16); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = a_.i16 + b_.i16; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] + b_.i16[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddw(a, b) simde_mm_add_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_add_pi16(a, b) simde_mm_add_pi16(a, b) # define _m_paddw(a, b) simde_mm_add_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_add_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_add_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vadd_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = paddw_s(a_.mmi_i32, b_.mmi_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 + b_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] + b_.i32[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddd(a, b) simde_mm_add_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_add_pi32(a, b) simde_mm_add_pi32(a, b) # define _m_paddd(a, b) simde_mm_add_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_adds_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_adds_pi8(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vqadd_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = paddsb(a_.mmi_i8, b_.mmi_i8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { if ((((b_.i8[i]) > 0) && ((a_.i8[i]) > (INT8_MAX - (b_.i8[i]))))) { r_.i8[i] = INT8_MAX; } else if ((((b_.i8[i]) < 0) && ((a_.i8[i]) < (INT8_MIN - (b_.i8[i]))))) { r_.i8[i] = INT8_MIN; } else { r_.i8[i] = (a_.i8[i]) + (b_.i8[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddsb(a, b) simde_mm_adds_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_adds_pi8(a, b) simde_mm_adds_pi8(a, b) # define _m_paddsb(a, b) simde_mm_adds_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_adds_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_adds_pu8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vqadd_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_u8 = paddusb(a_.mmi_u8, b_.mmi_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { const uint_fast16_t x = HEDLEY_STATIC_CAST(uint_fast16_t, a_.u8[i]) + HEDLEY_STATIC_CAST(uint_fast16_t, b_.u8[i]); if (x > UINT8_MAX) r_.u8[i] = UINT8_MAX; else r_.u8[i] = HEDLEY_STATIC_CAST(uint8_t, x); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddusb(a, b) simde_mm_adds_pu8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_adds_pu8(a, b) simde_mm_adds_pu8(a, b) # define _m_paddusb(a, b) simde_mm_adds_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_adds_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_adds_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vqadd_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = paddsh(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if ((((b_.i16[i]) > 0) && ((a_.i16[i]) > (INT16_MAX - (b_.i16[i]))))) { r_.i16[i] = INT16_MAX; } else if ((((b_.i16[i]) < 0) && ((a_.i16[i]) < (SHRT_MIN - (b_.i16[i]))))) { r_.i16[i] = SHRT_MIN; } else { r_.i16[i] = (a_.i16[i]) + (b_.i16[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddsw(a, b) simde_mm_adds_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_adds_pi16(a, b) simde_mm_adds_pi16(a, b) # define _m_paddsw(a, b) simde_mm_adds_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_adds_pu16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_adds_pu16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vqadd_u16(a_.neon_u16, b_.neon_u16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_u16 = paddush(a_.mmi_u16, b_.mmi_u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { const uint32_t x = a_.u16[i] + b_.u16[i]; if (x > UINT16_MAX) r_.u16[i] = UINT16_MAX; else r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, x); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_paddusw(a, b) simde_mm_adds_pu16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_adds_pu16(a, b) simde_mm_adds_pu16(a, b) # define _m_paddusw(a, b) simde_mm_adds_pu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_and_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_and_si64(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vand_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 & b_.i64; #else r_.i64[0] = a_.i64[0] & b_.i64[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_pand(a, b) simde_mm_and_si64(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_and_si64(a, b) simde_mm_and_si64(a, b) # define _m_pand(a, b) simde_mm_and_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_andnot_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_andnot_si64(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vbic_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = pandn_sw(a_.mmi_i32, b_.mmi_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = ~a_.i32f & b_.i32f; #else r_.u64[0] = (~(a_.u64[0])) & (b_.u64[0]); #endif return simde__m64_from_private(r_); #endif } #define simde_m_pandn(a, b) simde_mm_andnot_si64(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_andnot_si64(a, b) simde_mm_andnot_si64(a, b) # define _m_pandn(a, b) simde_mm_andnot_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpeq_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpeq_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vceq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = pcmpeqb_s(a_.mmi_i8, b_.mmi_i8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = (a_.i8[i] == b_.i8[i]) ? ~INT8_C(0) : INT8_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpeqb(a, b) simde_mm_cmpeq_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpeq_pi8(a, b) simde_mm_cmpeq_pi8(a, b) # define _m_pcmpeqb(a, b) simde_mm_cmpeq_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpeq_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpeq_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vceq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = pcmpeqh_s(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] == b_.i16[i]) ? ~INT16_C(0) : INT16_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpeqw(a, b) simde_mm_cmpeq_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpeq_pi16(a, b) simde_mm_cmpeq_pi16(a, b) # define _m_pcmpeqw(a, b) simde_mm_cmpeq_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpeq_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpeq_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vceq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = pcmpeqw_s(a_.mmi_i32, b_.mmi_i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = (a_.i32[i] == b_.i32[i]) ? ~INT32_C(0) : INT32_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpeqd(a, b) simde_mm_cmpeq_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpeq_pi32(a, b) simde_mm_cmpeq_pi32(a, b) # define _m_pcmpeqd(a, b) simde_mm_cmpeq_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpgt_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpgt_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vcgt_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = pcmpgtb_s(a_.mmi_i8, b_.mmi_i8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = (a_.i8[i] > b_.i8[i]) ? ~INT8_C(0) : INT8_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpgtb(a, b) simde_mm_cmpgt_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpgt_pi8(a, b) simde_mm_cmpgt_pi8(a, b) # define _m_pcmpgtb(a, b) simde_mm_cmpgt_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpgt_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpgt_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vcgt_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = pcmpgth_s(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] > b_.i16[i]) ? ~INT16_C(0) : INT16_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpgtw(a, b) simde_mm_cmpgt_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpgt_pi16(a, b) simde_mm_cmpgt_pi16(a, b) # define _m_pcmpgtw(a, b) simde_mm_cmpgt_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cmpgt_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cmpgt_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcgt_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = pcmpgtw_s(a_.mmi_i32, b_.mmi_i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = (a_.i32[i] > b_.i32[i]) ? ~INT32_C(0) : INT32_C(0); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pcmpgtd(a, b) simde_mm_cmpgt_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cmpgt_pi32(a, b) simde_mm_cmpgt_pi32(a, b) # define _m_pcmpgtd(a, b) simde_mm_cmpgt_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvtm64_si64 (simde__m64 a) { #if defined(SIMDE_X86_MMX_NATIVE) && defined(SIMDE_ARCH_AMD64) && !defined(__PGI) return _mm_cvtm64_si64(a); #else simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0) #pragma clang diagnostic ignored "-Wvector-conversion" #endif return vget_lane_s64(a_.neon_i64, 0); HEDLEY_DIAGNOSTIC_POP #else return a_.i64[0]; #endif #endif } #define simde_m_to_int64(a) simde_mm_cvtm64_si64(a) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) # define _mm_cvtm64_si64(a) simde_mm_cvtm64_si64(a) # define _m_to_int64(a) simde_mm_cvtm64_si64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtsi32_si64 (int32_t a) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtsi32_si64(a); #else simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int32_t av[2] = { a, 0 }; r_.neon_i32 = vld1_s32(av); #else r_.i32[0] = a; r_.i32[1] = 0; #endif return simde__m64_from_private(r_); #endif } #define simde_m_from_int(a) simde_mm_cvtsi32_si64(a) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cvtsi32_si64(a) simde_mm_cvtsi32_si64(a) # define _m_from_int(a) simde_mm_cvtsi32_si64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtsi64_m64 (int64_t a) { #if defined(SIMDE_X86_MMX_NATIVE) && defined(SIMDE_ARCH_AMD64) && !defined(__PGI) return _mm_cvtsi64_m64(a); #else simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vld1_s64(&a); #else r_.i64[0] = a; #endif return simde__m64_from_private(r_); #endif } #define simde_m_from_int64(a) simde_mm_cvtsi64_m64(a) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) # define _mm_cvtsi64_m64(a) simde_mm_cvtsi64_m64(a) # define _m_from_int64(a) simde_mm_cvtsi64_m64(a) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvtsi64_si32 (simde__m64 a) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtsi64_si32(a); #else simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0) #pragma clang diagnostic ignored "-Wvector-conversion" #endif return vget_lane_s32(a_.neon_i32, 0); HEDLEY_DIAGNOSTIC_POP #else return a_.i32[0]; #endif #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_cvtsi64_si32(a) simde_mm_cvtsi64_si32(a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_empty (void) { #if defined(SIMDE_X86_MMX_NATIVE) _mm_empty(); #else /* noop */ #endif } #define simde_m_empty() simde_mm_empty() #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_empty() simde_mm_empty() # define _m_empty() simde_mm_empty() #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_madd_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_madd_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) int32x4_t i1 = vmull_s16(a_.neon_i16, b_.neon_i16); r_.neon_i32 = vpadd_s32(vget_low_s32(i1), vget_high_s32(i1)); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = pmaddhw(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i += 2) { r_.i32[i / 2] = (a_.i16[i] * b_.i16[i]) + (a_.i16[i + 1] * b_.i16[i + 1]); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmaddwd(a, b) simde_mm_madd_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_madd_pi16(a, b) simde_mm_madd_pi16(a, b) # define _m_pmaddwd(a, b) simde_mm_madd_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_mulhi_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_mulhi_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int32x4_t t1 = vmull_s16(a_.neon_i16, b_.neon_i16); const uint32x4_t t2 = vshrq_n_u32(vreinterpretq_u32_s32(t1), 16); const uint16x4_t t3 = vmovn_u32(t2); r_.neon_u16 = t3; #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = pmulhh(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = HEDLEY_STATIC_CAST(int16_t, ((a_.i16[i] * b_.i16[i]) >> 16)); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmulhw(a, b) simde_mm_mulhi_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_mulhi_pi16(a, b) simde_mm_mulhi_pi16(a, b) # define _m_pmulhw(a, b) simde_mm_mulhi_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_mullo_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_mullo_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int32x4_t t1 = vmull_s16(a_.neon_i16, b_.neon_i16); const uint16x4_t t2 = vmovn_u32(vreinterpretq_u32_s32(t1)); r_.neon_u16 = t2; #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = pmullh(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = HEDLEY_STATIC_CAST(int16_t, ((a_.i16[i] * b_.i16[i]) & 0xffff)); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmullw(a, b) simde_mm_mullo_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_mullo_pi16(a, b) simde_mm_mullo_pi16(a, b) # define _m_pmullw(a, b) simde_mm_mullo_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_or_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_or_si64(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vorr_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 | b_.i64; #else r_.i64[0] = a_.i64[0] | b_.i64[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_por(a, b) simde_mm_or_si64(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_or_si64(a, b) simde_mm_or_si64(a, b) # define _m_por(a, b) simde_mm_or_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_packs_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_packs_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vqmovn_s16(vcombine_s16(a_.neon_i16, b_.neon_i16)); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = packsshb(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if (a_.i16[i] < INT8_MIN) { r_.i8[i] = INT8_MIN; } else if (a_.i16[i] > INT8_MAX) { r_.i8[i] = INT8_MAX; } else { r_.i8[i] = HEDLEY_STATIC_CAST(int8_t, a_.i16[i]); } } SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if (b_.i16[i] < INT8_MIN) { r_.i8[i + 4] = INT8_MIN; } else if (b_.i16[i] > INT8_MAX) { r_.i8[i + 4] = INT8_MAX; } else { r_.i8[i + 4] = HEDLEY_STATIC_CAST(int8_t, b_.i16[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_packsswb(a, b) simde_mm_packs_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_packs_pi16(a, b) simde_mm_packs_pi16(a, b) # define _m_packsswb(a, b) simde_mm_packs_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_packs_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_packs_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vqmovn_s32(vcombine_s32(a_.neon_i32, b_.neon_i32)); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = packsswh(a_.mmi_i32, b_.mmi_i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (8 / sizeof(a_.i32[0])) ; i++) { if (a_.i32[i] < SHRT_MIN) { r_.i16[i] = SHRT_MIN; } else if (a_.i32[i] > INT16_MAX) { r_.i16[i] = INT16_MAX; } else { r_.i16[i] = HEDLEY_STATIC_CAST(int16_t, a_.i32[i]); } } SIMDE_VECTORIZE for (size_t i = 0 ; i < (8 / sizeof(b_.i32[0])) ; i++) { if (b_.i32[i] < SHRT_MIN) { r_.i16[i + 2] = SHRT_MIN; } else if (b_.i32[i] > INT16_MAX) { r_.i16[i + 2] = INT16_MAX; } else { r_.i16[i + 2] = HEDLEY_STATIC_CAST(int16_t, b_.i32[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_packssdw(a, b) simde_mm_packs_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_packs_pi32(a, b) simde_mm_packs_pi32(a, b) # define _m_packssdw(a, b) simde_mm_packs_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_packs_pu16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_packs_pu16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) const int16x8_t t1 = vcombine_s16(a_.neon_i16, b_.neon_i16); /* Set elements which are < 0 to 0 */ const int16x8_t t2 = vandq_s16(t1, vreinterpretq_s16_u16(vcgezq_s16(t1))); /* Vector with all s16 elements set to UINT8_MAX */ const int16x8_t vmax = vmovq_n_s16(HEDLEY_STATIC_CAST(int16_t, UINT8_MAX)); /* Elements which are within the acceptable range */ const int16x8_t le_max = vandq_s16(t2, vreinterpretq_s16_u16(vcleq_s16(t2, vmax))); const int16x8_t gt_max = vandq_s16(vmax, vreinterpretq_s16_u16(vcgtq_s16(t2, vmax))); /* Final values as 16-bit integers */ const int16x8_t values = vorrq_s16(le_max, gt_max); r_.neon_u8 = vmovn_u16(vreinterpretq_u16_s16(values)); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_u8 = packushb(a_.mmi_u16, b_.mmi_u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if (a_.i16[i] > UINT8_MAX) { r_.u8[i] = UINT8_MAX; } else if (a_.i16[i] < 0) { r_.u8[i] = 0; } else { r_.u8[i] = HEDLEY_STATIC_CAST(uint8_t, a_.i16[i]); } } SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if (b_.i16[i] > UINT8_MAX) { r_.u8[i + 4] = UINT8_MAX; } else if (b_.i16[i] < 0) { r_.u8[i + 4] = 0; } else { r_.u8[i + 4] = HEDLEY_STATIC_CAST(uint8_t, b_.i16[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_packuswb(a, b) simde_mm_packs_pu16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_packs_pu16(a, b) simde_mm_packs_pu16(a, b) # define _m_packuswb(a, b) simde_mm_packs_pu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set_pi8 (int8_t e7, int8_t e6, int8_t e5, int8_t e4, int8_t e3, int8_t e2, int8_t e1, int8_t e0) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_set_pi8(e7, e6, e5, e4, e3, e2, e1, e0); #else simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int8_t v[sizeof(r_.i8) / sizeof(r_.i8[0])] = { e0, e1, e2, e3, e4, e5, e6, e7 }; r_.neon_i8 = vld1_s8(v); #else r_.i8[0] = e0; r_.i8[1] = e1; r_.i8[2] = e2; r_.i8[3] = e3; r_.i8[4] = e4; r_.i8[5] = e5; r_.i8[6] = e6; r_.i8[7] = e7; #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set_pi8(e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_set_pi8(e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_set_pu8 (uint8_t e7, uint8_t e6, uint8_t e5, uint8_t e4, uint8_t e3, uint8_t e2, uint8_t e1, uint8_t e0) { simde__m64_private r_; #if defined(SIMDE_X86_MMX_NATIVE) r_.n = _mm_set_pi8( HEDLEY_STATIC_CAST(int8_t, e7), HEDLEY_STATIC_CAST(int8_t, e6), HEDLEY_STATIC_CAST(int8_t, e5), HEDLEY_STATIC_CAST(int8_t, e4), HEDLEY_STATIC_CAST(int8_t, e3), HEDLEY_STATIC_CAST(int8_t, e2), HEDLEY_STATIC_CAST(int8_t, e1), HEDLEY_STATIC_CAST(int8_t, e0)); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint8_t v[sizeof(r_.u8) / sizeof(r_.u8[0])] = { e0, e1, e2, e3, e4, e5, e6, e7 }; r_.neon_u8 = vld1_u8(v); #else r_.u8[0] = e0; r_.u8[1] = e1; r_.u8[2] = e2; r_.u8[3] = e3; r_.u8[4] = e4; r_.u8[5] = e5; r_.u8[6] = e6; r_.u8[7] = e7; #endif return simde__m64_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set_pi16 (int16_t e3, int16_t e2, int16_t e1, int16_t e0) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_set_pi16(e3, e2, e1, e0); #else simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int16_t v[sizeof(r_.i16) / sizeof(r_.i16[0])] = { e0, e1, e2, e3 }; r_.neon_i16 = vld1_s16(v); #else r_.i16[0] = e0; r_.i16[1] = e1; r_.i16[2] = e2; r_.i16[3] = e3; #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set_pi16(e3, e2, e1, e0) simde_mm_set_pi16(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_set_pu16 (uint16_t e3, uint16_t e2, uint16_t e1, uint16_t e0) { simde__m64_private r_; #if defined(SIMDE_X86_MMX_NATIVE) r_.n = _mm_set_pi16( HEDLEY_STATIC_CAST(int16_t, e3), HEDLEY_STATIC_CAST(int16_t, e2), HEDLEY_STATIC_CAST(int16_t, e1), HEDLEY_STATIC_CAST(int16_t, e0) ); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint16_t v[sizeof(r_.u16) / sizeof(r_.u16[0])] = { e0, e1, e2, e3 }; r_.neon_u16 = vld1_u16(v); #else r_.u16[0] = e0; r_.u16[1] = e1; r_.u16[2] = e2; r_.u16[3] = e3; #endif return simde__m64_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_set_pu32 (uint32_t e1, uint32_t e0) { simde__m64_private r_; #if defined(SIMDE_X86_MMX_NATIVE) r_.n = _mm_set_pi32( HEDLEY_STATIC_CAST(int32_t, e1), HEDLEY_STATIC_CAST(int32_t, e0)); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint32_t v[sizeof(r_.u32) / sizeof(r_.u32[0])] = { e0, e1 }; r_.neon_u32 = vld1_u32(v); #else r_.u32[0] = e0; r_.u32[1] = e1; #endif return simde__m64_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set_pi32 (int32_t e1, int32_t e0) { simde__m64_private r_; #if defined(SIMDE_X86_MMX_NATIVE) r_.n = _mm_set_pi32(e1, e0); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int32_t v[sizeof(r_.i32) / sizeof(r_.i32[0])] = { e0, e1 }; r_.neon_i32 = vld1_s32(v); #else r_.i32[0] = e0; r_.i32[1] = e1; #endif return simde__m64_from_private(r_); } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set_pi32(e1, e0) simde_mm_set_pi32(e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_set_pi64 (int64_t e0) { simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int64_t v[sizeof(r_.i64) / sizeof(r_.i64[0])] = { e0 }; r_.neon_i64 = vld1_s64(v); #else r_.i64[0] = e0; #endif return simde__m64_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_set_f32x2 (simde_float32 e1, simde_float32 e0) { simde__m64_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const simde_float32 v[sizeof(r_.f32) / sizeof(r_.f32[0])] = { e0, e1 }; r_.neon_f32 = vld1_f32(v); #else r_.f32[0] = e0; r_.f32[1] = e1; #endif return simde__m64_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set1_pi8 (int8_t a) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_set1_pi8(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) simde__m64_private r_; r_.neon_i8 = vmov_n_s8(a); return simde__m64_from_private(r_); #else return simde_mm_set_pi8(a, a, a, a, a, a, a, a); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set1_pi8(a) simde_mm_set1_pi8(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set1_pi16 (int16_t a) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_set1_pi16(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) simde__m64_private r_; r_.neon_i16 = vmov_n_s16(a); return simde__m64_from_private(r_); #else return simde_mm_set_pi16(a, a, a, a); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set1_pi16(a) simde_mm_set1_pi16(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_set1_pi32 (int32_t a) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_set1_pi32(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) simde__m64_private r_; r_.neon_i32 = vmov_n_s32(a); return simde__m64_from_private(r_); #else return simde_mm_set_pi32(a, a); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_set1_pi32(a) simde_mm_set1_pi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_setr_pi8 (int8_t e7, int8_t e6, int8_t e5, int8_t e4, int8_t e3, int8_t e2, int8_t e1, int8_t e0) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_setr_pi8(e7, e6, e5, e4, e3, e2, e1, e0); #else return simde_mm_set_pi8(e0, e1, e2, e3, e4, e5, e6, e7); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_setr_pi8(e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_setr_pi8(e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_setr_pi16 (int16_t e3, int16_t e2, int16_t e1, int16_t e0) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_setr_pi16(e3, e2, e1, e0); #else return simde_mm_set_pi16(e0, e1, e2, e3); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_setr_pi16(e3, e2, e1, e0) simde_mm_setr_pi16(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_setr_pi32 (int32_t e1, int32_t e0) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_setr_pi32(e1, e0); #else return simde_mm_set_pi32(e0, e1); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_setr_pi32(e1, e0) simde_mm_setr_pi32(e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_setzero_si64 (void) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_setzero_si64(); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) simde__m64_private r_; r_.neon_u32 = vmov_n_u32(0); return simde__m64_from_private(r_); #else return simde_mm_set_pi32(0, 0); #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_setzero_si64() simde_mm_setzero_si64() #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_load_si64 (const void* mem_addr) { simde__m64 r; simde_memcpy(&r, SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m64), sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_loadu_si64 (const void* mem_addr) { simde__m64 r; simde_memcpy(&r, mem_addr, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES void simde_x_mm_store_si64 (void* mem_addr, simde__m64 value) { simde_memcpy(SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m64), &value, sizeof(value)); } SIMDE_FUNCTION_ATTRIBUTES void simde_x_mm_storeu_si64 (void* mem_addr, simde__m64 value) { simde_memcpy(mem_addr, &value, sizeof(value)); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_x_mm_setone_si64 (void) { return simde_mm_set1_pi32(~INT32_C(0)); } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sll_pi16 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sll_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0) #pragma clang diagnostic ignored "-Wvector-conversion" #endif r_.neon_i16 = vshl_s16(a_.neon_i16, vmov_n_s16(HEDLEY_STATIC_CAST(int16_t, vget_lane_u64(count_.neon_u64, 0)))); HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_BUG_CLANG_POWER9_16x4_BAD_SHIFT) if (HEDLEY_UNLIKELY(count_.u64[0] > 15)) return simde_mm_setzero_si64(); r_.i16 = a_.i16 << HEDLEY_STATIC_CAST(int16_t, count_.u64[0]); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i16 = a_.i16 << count_.u64[0]; #else if (HEDLEY_UNLIKELY(count_.u64[0] > 15)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, a_.u16[i] << count_.u64[0]); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psllw(a, count) simde_mm_sll_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sll_pi16(a, count) simde_mm_sll_pi16(a, count) # define _m_psllw(a, count) simde_mm_sll_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sll_pi32 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sll_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0) #pragma clang diagnostic ignored "-Wvector-conversion" #endif r_.neon_i32 = vshl_s32(a_.neon_i32, vmov_n_s32(HEDLEY_STATIC_CAST(int32_t, vget_lane_u64(count_.neon_u64, 0)))); HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i32 = a_.i32 << count_.u64[0]; #else if (HEDLEY_UNLIKELY(count_.u64[0] > 31)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] << count_.u64[0]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pslld(a, count) simde_mm_sll_pi32(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sll_pi32(a, count) simde_mm_sll_pi32(a, count) # define _m_pslld(a, count) simde_mm_sll_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_slli_pi16 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_slli_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = psllh_s(a_.mmi_i16, count); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_BUG_CLANG_POWER9_16x4_BAD_SHIFT) if (HEDLEY_UNLIKELY(count > 15)) return simde_mm_setzero_si64(); r_.i16 = a_.i16 << HEDLEY_STATIC_CAST(int16_t, count); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i16 = a_.i16 << count; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vshl_s16(a_.neon_i16, vmov_n_s16((int16_t) count)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, a_.u16[i] << count); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psllwi(a, count) simde_mm_slli_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_slli_pi16(a, count) simde_mm_slli_pi16(a, count) # define _m_psllwi(a, count) simde_mm_slli_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_slli_pi32 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_slli_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i32 = a_.i32 << count; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vshl_s32(a_.neon_i32, vmov_n_s32((int32_t) count)); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = psllw_s(a_.mmi_i32, b_.mmi_i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] << count; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pslldi(a, b) simde_mm_slli_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_slli_pi32(a, count) simde_mm_slli_pi32(a, count) # define _m_pslldi(a, count) simde_mm_slli_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_slli_si64 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_slli_si64(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i64 = a_.i64 << count; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vshl_s64(a_.neon_i64, vmov_n_s64((int64_t) count)); #else r_.u64[0] = a_.u64[0] << count; #endif return simde__m64_from_private(r_); #endif } #define simde_m_psllqi(a, count) simde_mm_slli_si64(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_slli_si64(a, count) simde_mm_slli_si64(a, count) # define _m_psllqi(a, count) simde_mm_slli_si64(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sll_si64 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sll_si64(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vshl_s64(a_.neon_i64, count_.neon_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 << count_.i64; #else if (HEDLEY_UNLIKELY(count_.u64[0] > 63)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } r_.u64[0] = a_.u64[0] << count_.u64[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_psllq(a, count) simde_mm_sll_si64(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sll_si64(a, count) simde_mm_sll_si64(a, count) # define _m_psllq(a, count) simde_mm_sll_si64(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srl_pi16 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_srl_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_BUG_CLANG_POWER9_16x4_BAD_SHIFT) if (HEDLEY_UNLIKELY(count_.u64[0] > 15)) return simde_mm_setzero_si64(); r_.u16 = a_.u16 >> HEDLEY_STATIC_CAST(uint16_t, count_.u64[0]); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u16 = a_.u16 >> count_.u64[0]; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vshl_u16(a_.neon_u16, vmov_n_s16(-((int16_t) vget_lane_u64(count_.neon_u64, 0)))); #else if (HEDLEY_UNLIKELY(count_.u64[0] > 15)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } SIMDE_VECTORIZE for (size_t i = 0 ; i < sizeof(r_.u16) / sizeof(r_.u16[0]) ; i++) { r_.u16[i] = a_.u16[i] >> count_.u64[0]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrlw(a, count) simde_mm_srl_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srl_pi16(a, count) simde_mm_srl_pi16(a, count) # define _m_psrlw(a, count) simde_mm_srl_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srl_pi32 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_srl_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u32 = a_.u32 >> count_.u64[0]; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vshl_u32(a_.neon_u32, vmov_n_s32(-((int32_t) vget_lane_u64(count_.neon_u64, 0)))); #else if (HEDLEY_UNLIKELY(count_.u64[0] > 31)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } SIMDE_VECTORIZE for (size_t i = 0 ; i < sizeof(r_.u32) / sizeof(r_.u32[0]) ; i++) { r_.u32[i] = a_.u32[i] >> count_.u64[0]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrld(a, count) simde_mm_srl_pi32(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srl_pi32(a, count) simde_mm_srl_pi32(a, count) # define _m_psrld(a, count) simde_mm_srl_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srli_pi16 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_srli_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u16 = a_.u16 >> count; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vshl_u16(a_.neon_u16, vmov_n_s16(-((int16_t) count))); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = psrlh_s(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = a_.u16[i] >> count; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrlwi(a, count) simde_mm_srli_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srli_pi16(a, count) simde_mm_srli_pi16(a, count) # define _m_psrlwi(a, count) simde_mm_srli_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srli_pi32 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_srli_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u32 = a_.u32 >> count; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vshl_u32(a_.neon_u32, vmov_n_s32(-((int32_t) count))); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = psrlw_s(a_.mmi_i32, b_.mmi_i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] >> count; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrldi(a, count) simde_mm_srli_pi32(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srli_pi32(a, count) simde_mm_srli_pi32(a, count) # define _m_psrldi(a, count) simde_mm_srli_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srli_si64 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_srli_si64(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u64 = vshl_u64(a_.neon_u64, vmov_n_s64(-count)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u64 = a_.u64 >> count; #else r_.u64[0] = a_.u64[0] >> count; #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrlqi(a, count) simde_mm_srli_si64(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srli_si64(a, count) simde_mm_srli_si64(a, count) # define _m_psrlqi(a, count) simde_mm_srli_si64(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srl_si64 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_srl_si64(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vshl_u64(a_.neon_u64, vneg_s64(count_.neon_i64)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.u64 = a_.u64 >> count_.u64; #else if (HEDLEY_UNLIKELY(count_.u64[0] > 63)) { simde_memset(&r_, 0, sizeof(r_)); return simde__m64_from_private(r_); } r_.u64[0] = a_.u64[0] >> count_.u64[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrlq(a, count) simde_mm_srl_si64(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srl_si64(a, count) simde_mm_srl_si64(a, count) # define _m_psrlq(a, count) simde_mm_srl_si64(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srai_pi16 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_srai_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i16 = a_.i16 >> (count & 0xff); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vshl_s16(a_.neon_i16, vmov_n_s16(-HEDLEY_STATIC_CAST(int16_t, count))); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = psrah_s(a_.mmi_i16, count); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] >> (count & 0xff); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrawi(a, count) simde_mm_srai_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srai_pi16(a, count) simde_mm_srai_pi16(a, count) # define _m_psrawi(a, count) simde_mm_srai_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_srai_pi32 (simde__m64 a, int count) { #if defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_srai_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i32 = a_.i32 >> (count & 0xff); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vshl_s32(a_.neon_i32, vmov_n_s32(-HEDLEY_STATIC_CAST(int32_t, count))); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = psraw_s(a_.mmi_i32, count); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] >> (count & 0xff); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psradi(a, count) simde_mm_srai_pi32(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_srai_pi32(a, count) simde_mm_srai_pi32(a, count) # define _m_psradi(a, count) simde_mm_srai_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sra_pi16 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sra_pi16(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); const int cnt = HEDLEY_STATIC_CAST(int, (count_.i64[0] > 15 ? 15 : count_.i64[0])); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i16 = a_.i16 >> cnt; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vshl_s16(a_.neon_i16, vmov_n_s16(-HEDLEY_STATIC_CAST(int16_t, vget_lane_u64(count_.neon_u64, 0)))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] >> cnt; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psraw(a, count) simde_mm_sra_pi16(a, count) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sra_pi16(a, count) simde_mm_sra_pi16(a, count) # define _m_psraw(a, count) simde_mm_sra_pi16(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sra_pi32 (simde__m64 a, simde__m64 count) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sra_pi32(a, count); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private count_ = simde__m64_to_private(count); const int32_t cnt = (count_.u64[0] > 31) ? 31 : HEDLEY_STATIC_CAST(int32_t, count_.u64[0]); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i32 = a_.i32 >> cnt; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vshl_s32(a_.neon_i32, vmov_n_s32(-HEDLEY_STATIC_CAST(int32_t, vget_lane_u64(count_.neon_u64, 0)))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] >> cnt; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psrad(a, b) simde_mm_sra_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sra_pi32(a, count) simde_mm_sra_pi32(a, count) # define _m_psrad(a, count) simde_mm_sra_pi32(a, count) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sub_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sub_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vsub_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = psubb_s(a_.mmi_i8, b_.mmi_i8); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = a_.i8 - b_.i8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a_.i8[i] - b_.i8[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubb(a, b) simde_mm_sub_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sub_pi8(a, b) simde_mm_sub_pi8(a, b) # define _m_psubb(a, b) simde_mm_sub_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sub_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sub_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vsub_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = psubh_s(a_.mmi_i16, b_.mmi_i16); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = a_.i16 - b_.i16; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] - b_.i16[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubw(a, b) simde_mm_sub_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sub_pi16(a, b) simde_mm_sub_pi16(a, b) # define _m_psubw(a, b) simde_mm_sub_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sub_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_sub_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vsub_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = psubw_s(a_.mmi_i32, b_.mmi_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 - b_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] - b_.i32[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubd(a, b) simde_mm_sub_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_sub_pi32(a, b) simde_mm_sub_pi32(a, b) # define _m_psubd(a, b) simde_mm_sub_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_subs_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_subs_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vqsub_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = psubsb(a_.mmi_i8, b_.mmi_i8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { if (((b_.i8[i]) > 0 && (a_.i8[i]) < INT8_MIN + (b_.i8[i]))) { r_.i8[i] = INT8_MIN; } else if ((b_.i8[i]) < 0 && (a_.i8[i]) > INT8_MAX + (b_.i8[i])) { r_.i8[i] = INT8_MAX; } else { r_.i8[i] = (a_.i8[i]) - (b_.i8[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubsb(a, b) simde_mm_subs_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_subs_pi8(a, b) simde_mm_subs_pi8(a, b) # define _m_psubsb(a, b) simde_mm_subs_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_subs_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_subs_pu8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vqsub_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_u8 = psubusb(a_.mmi_u8, b_.mmi_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { const int32_t x = a_.u8[i] - b_.u8[i]; if (x < 0) { r_.u8[i] = 0; } else if (x > UINT8_MAX) { r_.u8[i] = UINT8_MAX; } else { r_.u8[i] = HEDLEY_STATIC_CAST(uint8_t, x); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubusb(a, b) simde_mm_subs_pu8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_subs_pu8(a, b) simde_mm_subs_pu8(a, b) # define _m_psubusb(a, b) simde_mm_subs_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_subs_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_subs_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vqsub_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = psubsh(a_.mmi_i16, b_.mmi_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { if (((b_.i16[i]) > 0 && (a_.i16[i]) < SHRT_MIN + (b_.i16[i]))) { r_.i16[i] = SHRT_MIN; } else if ((b_.i16[i]) < 0 && (a_.i16[i]) > INT16_MAX + (b_.i16[i])) { r_.i16[i] = INT16_MAX; } else { r_.i16[i] = (a_.i16[i]) - (b_.i16[i]); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubsw(a, b) simde_mm_subs_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_subs_pi16(a, b) simde_mm_subs_pi16(a, b) # define _m_psubsw(a, b) simde_mm_subs_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_subs_pu16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_subs_pu16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vqsub_u16(a_.neon_u16, b_.neon_u16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_u16 = psubush(a_.mmi_u16, b_.mmi_u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { const int x = a_.u16[i] - b_.u16[i]; if (x < 0) { r_.u16[i] = 0; } else if (x > UINT16_MAX) { r_.u16[i] = UINT16_MAX; } else { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, x); } } #endif return simde__m64_from_private(r_); #endif } #define simde_m_psubusw(a, b) simde_mm_subs_pu16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_subs_pu16(a, b) simde_mm_subs_pu16(a, b) # define _m_psubusw(a, b) simde_mm_subs_pu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpackhi_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpackhi_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i8 = vzip2_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = punpckhbh_s(a_.mmi_i8, b_.mmi_i8); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i8 = SIMDE_SHUFFLE_VECTOR_(8, 8, a_.i8, b_.i8, 4, 12, 5, 13, 6, 14, 7, 15); #else r_.i8[0] = a_.i8[4]; r_.i8[1] = b_.i8[4]; r_.i8[2] = a_.i8[5]; r_.i8[3] = b_.i8[5]; r_.i8[4] = a_.i8[6]; r_.i8[5] = b_.i8[6]; r_.i8[6] = a_.i8[7]; r_.i8[7] = b_.i8[7]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpckhbw(a, b) simde_mm_unpackhi_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpackhi_pi8(a, b) simde_mm_unpackhi_pi8(a, b) # define _m_punpckhbw(a, b) simde_mm_unpackhi_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpackhi_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpackhi_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i16 = vzip2_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = punpckhhw_s(a_.mmi_i16, b_.mmi_i16); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i16 = SIMDE_SHUFFLE_VECTOR_(16, 8, a_.i16, b_.i16, 2, 6, 3, 7); #else r_.i16[0] = a_.i16[2]; r_.i16[1] = b_.i16[2]; r_.i16[2] = a_.i16[3]; r_.i16[3] = b_.i16[3]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpckhwd(a, b) simde_mm_unpackhi_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpackhi_pi16(a, b) simde_mm_unpackhi_pi16(a, b) # define _m_punpckhwd(a, b) simde_mm_unpackhi_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpackhi_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpackhi_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i32 = vzip2_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = punpckhwd_s(a_.mmi_i32, b_.mmi_i32); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i32 = SIMDE_SHUFFLE_VECTOR_(32, 8, a_.i32, b_.i32, 1, 3); #else r_.i32[0] = a_.i32[1]; r_.i32[1] = b_.i32[1]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpckhdq(a, b) simde_mm_unpackhi_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpackhi_pi32(a, b) simde_mm_unpackhi_pi32(a, b) # define _m_punpckhdq(a, b) simde_mm_unpackhi_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpacklo_pi8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpacklo_pi8(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i8 = vzip1_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i8 = punpcklbh_s(a_.mmi_i8, b_.mmi_i8); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i8 = SIMDE_SHUFFLE_VECTOR_(8, 8, a_.i8, b_.i8, 0, 8, 1, 9, 2, 10, 3, 11); #else r_.i8[0] = a_.i8[0]; r_.i8[1] = b_.i8[0]; r_.i8[2] = a_.i8[1]; r_.i8[3] = b_.i8[1]; r_.i8[4] = a_.i8[2]; r_.i8[5] = b_.i8[2]; r_.i8[6] = a_.i8[3]; r_.i8[7] = b_.i8[3]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpcklbw(a, b) simde_mm_unpacklo_pi8(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpacklo_pi8(a, b) simde_mm_unpacklo_pi8(a, b) # define _m_punpcklbw(a, b) simde_mm_unpacklo_pi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpacklo_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpacklo_pi16(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i16 = vzip1_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i16 = punpcklhw_s(a_.mmi_i16, b_.mmi_i16); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i16 = SIMDE_SHUFFLE_VECTOR_(16, 8, a_.i16, b_.i16, 0, 4, 1, 5); #else r_.i16[0] = a_.i16[0]; r_.i16[1] = b_.i16[0]; r_.i16[2] = a_.i16[1]; r_.i16[3] = b_.i16[1]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpcklwd(a, b) simde_mm_unpacklo_pi16(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpacklo_pi16(a, b) simde_mm_unpacklo_pi16(a, b) # define _m_punpcklwd(a, b) simde_mm_unpacklo_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_unpacklo_pi32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_unpacklo_pi32(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i32 = vzip1_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_MIPS_LOONGSON_MMI_NATIVE) r_.mmi_i32 = punpcklwd_s(a_.mmi_i32, b_.mmi_i32); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i32 = SIMDE_SHUFFLE_VECTOR_(32, 8, a_.i32, b_.i32, 0, 2); #else r_.i32[0] = a_.i32[0]; r_.i32[1] = b_.i32[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_punpckldq(a, b) simde_mm_unpacklo_pi32(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_unpacklo_pi32(a, b) simde_mm_unpacklo_pi32(a, b) # define _m_punpckldq(a, b) simde_mm_unpacklo_pi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_xor_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_MMX_NATIVE) return _mm_xor_si64(a, b); #else simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = veor_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f ^ b_.i32f; #else r_.u64[0] = a_.u64[0] ^ b_.u64[0]; #endif return simde__m64_from_private(r_); #endif } #define simde_m_pxor(a, b) simde_mm_xor_si64(a, b) #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _mm_xor_si64(a, b) simde_mm_xor_si64(a, b) # define _m_pxor(a, b) simde_mm_xor_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_m_to_int (simde__m64 a) { #if defined(SIMDE_X86_MMX_NATIVE) return _m_to_int(a); #else simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wvector-conversion") && SIMDE_DETECT_CLANG_VERSION_NOT(10,0,0) #pragma clang diagnostic ignored "-Wvector-conversion" #endif return vget_lane_s32(a_.neon_i32, 0); HEDLEY_DIAGNOSTIC_POP #else return a_.i32[0]; #endif #endif } #if defined(SIMDE_X86_MMX_ENABLE_NATIVE_ALIASES) # define _m_to_int(a) simde_m_to_int(a) #endif SIMDE_END_DECLS_ HEDLEY_DIAGNOSTIC_POP #endif /* !defined(SIMDE_X86_MMX_H) */ /* :: End x86/mmx.h :: */ #if defined(_WIN32) && !defined(SIMDE_X86_SSE_NATIVE) && defined(_MSC_VER) #define NOMINMAX #include #endif #if defined(__ARM_ACLE) #include #endif HEDLEY_DIAGNOSTIC_PUSH SIMDE_DISABLE_UNWANTED_DIAGNOSTICS SIMDE_BEGIN_DECLS_ typedef union { #if defined(SIMDE_VECTOR_SUBSCRIPT) SIMDE_ALIGN_TO_16 int8_t i8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int16_t i16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int32_t i32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int64_t i64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint8_t u8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint16_t u16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint32_t u32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint64_t u64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #if defined(SIMDE_HAVE_INT128_) SIMDE_ALIGN_TO_16 simde_int128 i128 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 simde_uint128 u128 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #endif SIMDE_ALIGN_TO_16 simde_float32 f32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int_fast32_t i32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint_fast32_t u32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #else SIMDE_ALIGN_TO_16 int8_t i8[16]; SIMDE_ALIGN_TO_16 int16_t i16[8]; SIMDE_ALIGN_TO_16 int32_t i32[4]; SIMDE_ALIGN_TO_16 int64_t i64[2]; SIMDE_ALIGN_TO_16 uint8_t u8[16]; SIMDE_ALIGN_TO_16 uint16_t u16[8]; SIMDE_ALIGN_TO_16 uint32_t u32[4]; SIMDE_ALIGN_TO_16 uint64_t u64[2]; #if defined(SIMDE_HAVE_INT128_) SIMDE_ALIGN_TO_16 simde_int128 i128[1]; SIMDE_ALIGN_TO_16 simde_uint128 u128[1]; #endif SIMDE_ALIGN_TO_16 simde_float32 f32[4]; SIMDE_ALIGN_TO_16 int_fast32_t i32f[16 / sizeof(int_fast32_t)]; SIMDE_ALIGN_TO_16 uint_fast32_t u32f[16 / sizeof(uint_fast32_t)]; #endif SIMDE_ALIGN_TO_16 simde__m64_private m64_private[2]; SIMDE_ALIGN_TO_16 simde__m64 m64[2]; #if defined(SIMDE_X86_SSE_NATIVE) SIMDE_ALIGN_TO_16 __m128 n; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_TO_16 int8x16_t neon_i8; SIMDE_ALIGN_TO_16 int16x8_t neon_i16; SIMDE_ALIGN_TO_16 int32x4_t neon_i32; SIMDE_ALIGN_TO_16 int64x2_t neon_i64; SIMDE_ALIGN_TO_16 uint8x16_t neon_u8; SIMDE_ALIGN_TO_16 uint16x8_t neon_u16; SIMDE_ALIGN_TO_16 uint32x4_t neon_u32; SIMDE_ALIGN_TO_16 uint64x2_t neon_u64; SIMDE_ALIGN_TO_16 float32x4_t neon_f32; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_ALIGN_TO_16 float64x2_t neon_f64; #endif #elif defined(SIMDE_MIPS_MSA_NATIVE) v16i8 msa_i8; v8i16 msa_i16; v4i32 msa_i32; v2i64 msa_i64; v16u8 msa_u8; v8u16 msa_u16; v4u32 msa_u32; v2u64 msa_u64; #elif defined(SIMDE_WASM_SIMD128_NATIVE) SIMDE_ALIGN_TO_16 v128_t wasm_v128; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) altivec_u8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned short) altivec_u16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) altivec_u32; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed char) altivec_i8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed short) altivec_i16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed int) altivec_i32; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(float) altivec_f32; #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long) altivec_u64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed long long) altivec_i64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(double) altivec_f64; #endif #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) v16i8 lsx_i8; v8i16 lsx_i16; v4i32 lsx_i32; v2i64 lsx_i64; v16u8 lsx_u8; v8u16 lsx_u16; v4u32 lsx_u32; v2u64 lsx_u64; v4f32 lsx_f32; v2f64 lsx_f64; #endif } simde__m128_private; #if defined(SIMDE_X86_SSE_NATIVE) typedef __m128 simde__m128; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) typedef float32x4_t simde__m128; #elif defined(SIMDE_WASM_SIMD128_NATIVE) typedef v128_t simde__m128; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) typedef SIMDE_POWER_ALTIVEC_VECTOR(float) simde__m128; #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) typedef v4f32 simde__m128; #elif defined(SIMDE_VECTOR_SUBSCRIPT) typedef simde_float32 simde__m128 SIMDE_ALIGN_TO_16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #else typedef simde__m128_private simde__m128; #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) typedef simde__m128 __m128; #endif HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128), "simde__m128 size incorrect"); HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128_private), "simde__m128_private size incorrect"); #if defined(SIMDE_CHECK_ALIGNMENT) && defined(SIMDE_ALIGN_OF) HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128) == 16, "simde__m128 is not 16-byte aligned"); HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128_private) == 16, "simde__m128_private is not 16-byte aligned"); #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde__m128_from_private(simde__m128_private v) { simde__m128 r; simde_memcpy(&r, &v, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m128_private simde__m128_to_private(simde__m128 v) { simde__m128_private r; simde_memcpy(&r, &v, sizeof(r)); return r; } #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, int8x16_t, neon, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, int16x8_t, neon, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, int32x4_t, neon, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, int64x2_t, neon, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, uint8x16_t, neon, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, uint16x8_t, neon, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, uint32x4_t, neon, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, uint64x2_t, neon, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, float32x4_t, neon, f32) #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, float64x2_t, neon, f64) #endif #endif /* defined(SIMDE_ARM_NEON_A32V7_NATIVE) */ #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(signed char), altivec, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(signed short), altivec, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(signed int), altivec, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(unsigned char), altivec, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(unsigned short), altivec, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(unsigned int), altivec, u32) #if defined(SIMDE_BUG_GCC_95782) SIMDE_FUNCTION_ATTRIBUTES SIMDE_POWER_ALTIVEC_VECTOR(float) simde__m128_to_altivec_f32(simde__m128 value) { simde__m128_private r_ = simde__m128_to_private(value); return r_.altivec_f32; } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde__m128_from_altivec_f32(SIMDE_POWER_ALTIVEC_VECTOR(float) value) { simde__m128_private r_; r_.altivec_f32 = value; return simde__m128_from_private(r_); } #else SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(float), altivec, f32) #endif #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(signed long long), altivec, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long), altivec, u64) #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v128_t, wasm, v128); #endif /* defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) */ #if defined(SIMDE_LOONGARCH_LSX_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v16i8, lsx, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v8i16, lsx, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v4i32, lsx, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v2i64, lsx, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v16u8, lsx, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v8u16, lsx, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v4u32, lsx, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v2u64, lsx, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v4f32, lsx, f32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128, v2f64, lsx, f64) #endif /* defined(SIMDE_LOONGARCH_LSX_NATIVE) */ enum { #if defined(SIMDE_X86_SSE_NATIVE) SIMDE_MM_ROUND_NEAREST = _MM_ROUND_NEAREST, SIMDE_MM_ROUND_DOWN = _MM_ROUND_DOWN, SIMDE_MM_ROUND_UP = _MM_ROUND_UP, SIMDE_MM_ROUND_TOWARD_ZERO = _MM_ROUND_TOWARD_ZERO #else SIMDE_MM_ROUND_NEAREST = 0x0000, SIMDE_MM_ROUND_DOWN = 0x2000, SIMDE_MM_ROUND_UP = 0x4000, SIMDE_MM_ROUND_TOWARD_ZERO = 0x6000 #endif }; #if defined(_MM_FROUND_TO_NEAREST_INT) # define SIMDE_MM_FROUND_TO_NEAREST_INT _MM_FROUND_TO_NEAREST_INT # define SIMDE_MM_FROUND_TO_NEG_INF _MM_FROUND_TO_NEG_INF # define SIMDE_MM_FROUND_TO_POS_INF _MM_FROUND_TO_POS_INF # define SIMDE_MM_FROUND_TO_ZERO _MM_FROUND_TO_ZERO # define SIMDE_MM_FROUND_CUR_DIRECTION _MM_FROUND_CUR_DIRECTION # define SIMDE_MM_FROUND_RAISE_EXC _MM_FROUND_RAISE_EXC # define SIMDE_MM_FROUND_NO_EXC _MM_FROUND_NO_EXC #else # define SIMDE_MM_FROUND_TO_NEAREST_INT 0x00 # define SIMDE_MM_FROUND_TO_NEG_INF 0x01 # define SIMDE_MM_FROUND_TO_POS_INF 0x02 # define SIMDE_MM_FROUND_TO_ZERO 0x03 # define SIMDE_MM_FROUND_CUR_DIRECTION 0x04 # define SIMDE_MM_FROUND_RAISE_EXC 0x00 # define SIMDE_MM_FROUND_NO_EXC 0x08 #endif #define SIMDE_MM_FROUND_NINT \ (SIMDE_MM_FROUND_TO_NEAREST_INT | SIMDE_MM_FROUND_RAISE_EXC) #define SIMDE_MM_FROUND_FLOOR \ (SIMDE_MM_FROUND_TO_NEG_INF | SIMDE_MM_FROUND_RAISE_EXC) #define SIMDE_MM_FROUND_CEIL \ (SIMDE_MM_FROUND_TO_POS_INF | SIMDE_MM_FROUND_RAISE_EXC) #define SIMDE_MM_FROUND_TRUNC \ (SIMDE_MM_FROUND_TO_ZERO | SIMDE_MM_FROUND_RAISE_EXC) #define SIMDE_MM_FROUND_RINT \ (SIMDE_MM_FROUND_CUR_DIRECTION | SIMDE_MM_FROUND_RAISE_EXC) #define SIMDE_MM_FROUND_NEARBYINT \ (SIMDE_MM_FROUND_CUR_DIRECTION | SIMDE_MM_FROUND_NO_EXC) #if defined(SIMDE_X86_SSE4_1_ENABLE_NATIVE_ALIASES) && !defined(_MM_FROUND_TO_NEAREST_INT) # define _MM_FROUND_TO_NEAREST_INT SIMDE_MM_FROUND_TO_NEAREST_INT # define _MM_FROUND_TO_NEG_INF SIMDE_MM_FROUND_TO_NEG_INF # define _MM_FROUND_TO_POS_INF SIMDE_MM_FROUND_TO_POS_INF # define _MM_FROUND_TO_ZERO SIMDE_MM_FROUND_TO_ZERO # define _MM_FROUND_CUR_DIRECTION SIMDE_MM_FROUND_CUR_DIRECTION # define _MM_FROUND_RAISE_EXC SIMDE_MM_FROUND_RAISE_EXC # define _MM_FROUND_NINT SIMDE_MM_FROUND_NINT # define _MM_FROUND_FLOOR SIMDE_MM_FROUND_FLOOR # define _MM_FROUND_CEIL SIMDE_MM_FROUND_CEIL # define _MM_FROUND_TRUNC SIMDE_MM_FROUND_TRUNC # define _MM_FROUND_RINT SIMDE_MM_FROUND_RINT # define _MM_FROUND_NEARBYINT SIMDE_MM_FROUND_NEARBYINT #endif #if defined(_MM_EXCEPT_INVALID) # define SIMDE_MM_EXCEPT_INVALID _MM_EXCEPT_INVALID #else # define SIMDE_MM_EXCEPT_INVALID (0x0001) #endif #if defined(_MM_EXCEPT_DENORM) # define SIMDE_MM_EXCEPT_DENORM _MM_EXCEPT_DENORM #else # define SIMDE_MM_EXCEPT_DENORM (0x0002) #endif #if defined(_MM_EXCEPT_DIV_ZERO) # define SIMDE_MM_EXCEPT_DIV_ZERO _MM_EXCEPT_DIV_ZERO #else # define SIMDE_MM_EXCEPT_DIV_ZERO (0x0004) #endif #if defined(_MM_EXCEPT_OVERFLOW) # define SIMDE_MM_EXCEPT_OVERFLOW _MM_EXCEPT_OVERFLOW #else # define SIMDE_MM_EXCEPT_OVERFLOW (0x0008) #endif #if defined(_MM_EXCEPT_UNDERFLOW) # define SIMDE_MM_EXCEPT_UNDERFLOW _MM_EXCEPT_UNDERFLOW #else # define SIMDE_MM_EXCEPT_UNDERFLOW (0x0010) #endif #if defined(_MM_EXCEPT_INEXACT) # define SIMDE_MM_EXCEPT_INEXACT _MM_EXCEPT_INEXACT #else # define SIMDE_MM_EXCEPT_INEXACT (0x0020) #endif #if defined(_MM_EXCEPT_MASK) # define SIMDE_MM_EXCEPT_MASK _MM_EXCEPT_MASK #else # define SIMDE_MM_EXCEPT_MASK \ (SIMDE_MM_EXCEPT_INVALID | SIMDE_MM_EXCEPT_DENORM | \ SIMDE_MM_EXCEPT_DIV_ZERO | SIMDE_MM_EXCEPT_OVERFLOW | \ SIMDE_MM_EXCEPT_UNDERFLOW | SIMDE_MM_EXCEPT_INEXACT) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_EXCEPT_INVALID SIMDE_MM_EXCEPT_INVALID #define _MM_EXCEPT_DENORM SIMDE_MM_EXCEPT_DENORM #define _MM_EXCEPT_DIV_ZERO SIMDE_MM_EXCEPT_DIV_ZERO #define _MM_EXCEPT_OVERFLOW SIMDE_MM_EXCEPT_OVERFLOW #define _MM_EXCEPT_UNDERFLOW SIMDE_MM_EXCEPT_UNDERFLOW #define _MM_EXCEPT_INEXACT SIMDE_MM_EXCEPT_INEXACT #define _MM_EXCEPT_MASK SIMDE_MM_EXCEPT_MASK #endif #if defined(_MM_MASK_INVALID) # define SIMDE_MM_MASK_INVALID _MM_MASK_INVALID #else # define SIMDE_MM_MASK_INVALID (0x0080) #endif #if defined(_MM_MASK_DENORM) # define SIMDE_MM_MASK_DENORM _MM_MASK_DENORM #else # define SIMDE_MM_MASK_DENORM (0x0100) #endif #if defined(_MM_MASK_DIV_ZERO) # define SIMDE_MM_MASK_DIV_ZERO _MM_MASK_DIV_ZERO #else # define SIMDE_MM_MASK_DIV_ZERO (0x0200) #endif #if defined(_MM_MASK_OVERFLOW) # define SIMDE_MM_MASK_OVERFLOW _MM_MASK_OVERFLOW #else # define SIMDE_MM_MASK_OVERFLOW (0x0400) #endif #if defined(_MM_MASK_UNDERFLOW) # define SIMDE_MM_MASK_UNDERFLOW _MM_MASK_UNDERFLOW #else # define SIMDE_MM_MASK_UNDERFLOW (0x0800) #endif #if defined(_MM_MASK_INEXACT) # define SIMDE_MM_MASK_INEXACT _MM_MASK_INEXACT #else # define SIMDE_MM_MASK_INEXACT (0x1000) #endif #if defined(_MM_MASK_MASK) # define SIMDE_MM_MASK_MASK _MM_MASK_MASK #else # define SIMDE_MM_MASK_MASK \ (SIMDE_MM_MASK_INVALID | SIMDE_MM_MASK_DENORM | \ SIMDE_MM_MASK_DIV_ZERO | SIMDE_MM_MASK_OVERFLOW | \ SIMDE_MM_MASK_UNDERFLOW | SIMDE_MM_MASK_INEXACT) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_MASK_INVALID SIMDE_MM_MASK_INVALID #define _MM_MASK_DENORM SIMDE_MM_MASK_DENORM #define _MM_MASK_DIV_ZERO SIMDE_MM_MASK_DIV_ZERO #define _MM_MASK_OVERFLOW SIMDE_MM_MASK_OVERFLOW #define _MM_MASK_UNDERFLOW SIMDE_MM_MASK_UNDERFLOW #define _MM_MASK_INEXACT SIMDE_MM_MASK_INEXACT #define _MM_MASK_MASK SIMDE_MM_MASK_MASK #endif #if defined(_MM_FLUSH_ZERO_MASK) # define SIMDE_MM_FLUSH_ZERO_MASK _MM_FLUSH_ZERO_MASK #else # define SIMDE_MM_FLUSH_ZERO_MASK (0x8000) #endif #if defined(_MM_FLUSH_ZERO_ON) # define SIMDE_MM_FLUSH_ZERO_ON _MM_FLUSH_ZERO_ON #else # define SIMDE_MM_FLUSH_ZERO_ON (0x8000) #endif #if defined(_MM_FLUSH_ZERO_OFF) # define SIMDE_MM_FLUSH_ZERO_OFF _MM_FLUSH_ZERO_OFF #else # define SIMDE_MM_FLUSH_ZERO_OFF (0x0000) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_FLUSH_ZERO_MASK SIMDE_MM_FLUSH_ZERO_MASK #define _MM_FLUSH_ZERO_ON SIMDE_MM_FLUSH_ZERO_ON #define _MM_FLUSH_ZERO_OFF SIMDE_MM_FLUSH_ZERO_OFF #endif SIMDE_FUNCTION_ATTRIBUTES unsigned int SIMDE_MM_GET_ROUNDING_MODE(void) { #if defined(SIMDE_X86_SSE_NATIVE) return _MM_GET_ROUNDING_MODE(); #elif defined(SIMDE_HAVE_FENV_H) unsigned int vfe_mode; switch (fegetround()) { #if defined(FE_TONEAREST) case FE_TONEAREST: vfe_mode = SIMDE_MM_ROUND_NEAREST; break; #endif #if defined(FE_TOWARDZERO) case FE_TOWARDZERO: vfe_mode = SIMDE_MM_ROUND_DOWN; break; #endif #if defined(FE_UPWARD) case FE_UPWARD: vfe_mode = SIMDE_MM_ROUND_UP; break; #endif #if defined(FE_DOWNWARD) case FE_DOWNWARD: vfe_mode = SIMDE_MM_ROUND_TOWARD_ZERO; break; #endif default: vfe_mode = SIMDE_MM_ROUND_NEAREST; break; } return vfe_mode; #else return SIMDE_MM_ROUND_NEAREST; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_GET_ROUNDING_MODE() SIMDE_MM_GET_ROUNDING_MODE() #endif SIMDE_FUNCTION_ATTRIBUTES void SIMDE_MM_SET_ROUNDING_MODE(unsigned int a) { #if defined(SIMDE_X86_SSE_NATIVE) _MM_SET_ROUNDING_MODE(a); #elif defined(SIMDE_HAVE_FENV_H) int fe_mode = FE_TONEAREST; switch (a) { #if defined(FE_TONEAREST) case SIMDE_MM_ROUND_NEAREST: fe_mode = FE_TONEAREST; break; #endif #if defined(FE_TOWARDZERO) case SIMDE_MM_ROUND_TOWARD_ZERO: fe_mode = FE_TOWARDZERO; break; #endif #if defined(FE_DOWNWARD) case SIMDE_MM_ROUND_DOWN: fe_mode = FE_DOWNWARD; break; #endif #if defined(FE_UPWARD) case SIMDE_MM_ROUND_UP: fe_mode = FE_UPWARD; break; #endif default: return; } fesetround(fe_mode); #else (void) a; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_SET_ROUNDING_MODE(a) SIMDE_MM_SET_ROUNDING_MODE(a) #endif SIMDE_FUNCTION_ATTRIBUTES uint32_t SIMDE_MM_GET_FLUSH_ZERO_MODE (void) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_getcsr() & _MM_FLUSH_ZERO_MASK; #else return SIMDE_MM_FLUSH_ZERO_OFF; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_SET_FLUSH_ZERO_MODE(a) SIMDE_MM_SET_FLUSH_ZERO_MODE(a) #endif SIMDE_FUNCTION_ATTRIBUTES void SIMDE_MM_SET_FLUSH_ZERO_MODE (uint32_t a) { #if defined(SIMDE_X86_SSE_NATIVE) _MM_SET_FLUSH_ZERO_MODE(a); #else (void) a; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _MM_SET_FLUSH_ZERO_MODE(a) SIMDE_MM_SET_FLUSH_ZERO_MODE(a) #endif SIMDE_FUNCTION_ATTRIBUTES uint32_t simde_mm_getcsr (void) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_getcsr(); #else return SIMDE_MM_GET_ROUNDING_MODE(); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _mm_getcsr() simde_mm_getcsr() #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_setcsr (uint32_t a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_setcsr(a); #else SIMDE_MM_SET_ROUNDING_MODE(HEDLEY_STATIC_CAST(unsigned int, a)); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _mm_setcsr(a) simde_mm_setcsr(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_round_ps (simde__m128 a, int rounding, int lax_rounding) SIMDE_REQUIRE_CONSTANT_RANGE(rounding, 0, 15) SIMDE_REQUIRE_CONSTANT_RANGE(lax_rounding, 0, 1) { simde__m128_private r_, a_ = simde__m128_to_private(a); (void) lax_rounding; /* For architectures which lack a current direction SIMD instruction. * * Note that NEON actually has a current rounding mode instruction, * but in ARMv8+ the rounding mode is ignored and nearest is always * used, so we treat ARMv7 as having a rounding mode but ARMv8 as * not. */ #if \ defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || \ defined(SIMDE_ARM_NEON_A32V8) if ((rounding & 7) == SIMDE_MM_FROUND_CUR_DIRECTION) rounding = HEDLEY_STATIC_CAST(int, SIMDE_MM_GET_ROUNDING_MODE()) << 13; #endif switch (rounding & ~SIMDE_MM_FROUND_NO_EXC) { case SIMDE_MM_FROUND_CUR_DIRECTION: #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_round(a_.altivec_f32)); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_BUG_GCC_95399) r_.neon_f32 = vrndiq_f32(a_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_nearest(a_.wasm_v128); #elif defined(simde_math_nearbyintf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_nearbyintf(a_.f32[i]); } #else HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); #endif break; case SIMDE_MM_FROUND_TO_NEAREST_INT: #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_rint(a_.altivec_f32)); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) r_.neon_f32 = vrndnq_f32(a_.neon_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfrintrne_s(a_.lsx_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_nearest(a_.wasm_v128); #elif defined(simde_math_roundevenf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_roundevenf(a_.f32[i]); } #else HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); #endif break; case SIMDE_MM_FROUND_TO_NEG_INF: #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_floor(a_.altivec_f32)); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) r_.neon_f32 = vrndmq_f32(a_.neon_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfrintrm_s(a_.lsx_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_floor(a_.wasm_v128); #elif defined(simde_math_floorf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_floorf(a_.f32[i]); } #else HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); #endif break; case SIMDE_MM_FROUND_TO_POS_INF: #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_ceil(a_.altivec_f32)); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) r_.neon_f32 = vrndpq_f32(a_.neon_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfrintrp_s(a_.lsx_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_ceil(a_.wasm_v128); #elif defined(simde_math_ceilf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_ceilf(a_.f32[i]); } #else HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); #endif break; case SIMDE_MM_FROUND_TO_ZERO: #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_trunc(a_.altivec_f32)); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) r_.neon_f32 = vrndq_f32(a_.neon_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfrintrz_s(a_.lsx_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_trunc(a_.wasm_v128); #elif defined(simde_math_truncf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_truncf(a_.f32[i]); } #else HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); #endif break; default: HEDLEY_UNREACHABLE_RETURN(simde_mm_undefined_pd()); } return simde__m128_from_private(r_); } #if defined(SIMDE_X86_SSE4_1_NATIVE) #define simde_mm_round_ps(a, rounding) _mm_round_ps((a), (rounding)) #else #define simde_mm_round_ps(a, rounding) simde_x_mm_round_ps((a), (rounding), 0) #endif #if defined(SIMDE_X86_SSE4_1_ENABLE_NATIVE_ALIASES) #define _mm_round_ps(a, rounding) simde_mm_round_ps((a), (rounding)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_set_ps (simde_float32 e3, simde_float32 e2, simde_float32 e1, simde_float32 e0) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_set_ps(e3, e2, e1, e0); #else simde__m128_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_TO_16 simde_float32 data[4] = { e0, e1, e2, e3 }; r_.neon_f32 = vld1q_f32(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_make(e0, e1, e2, e3); #else r_.f32[0] = e0; r_.f32[1] = e1; r_.f32[2] = e2; r_.f32[3] = e3; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_set_ps(e3, e2, e1, e0) simde_mm_set_ps(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_set_ps1 (simde_float32 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_set_ps1(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vdupq_n_f32(a); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) (void) a; return vec_splats(a); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) return (simde__m128)__lsx_vldrepl_w(&a, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_splat(a); #else return simde_mm_set_ps(a, a, a, a); #endif } #define simde_mm_set1_ps(a) simde_mm_set_ps1(a) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_set_ps1(a) simde_mm_set_ps1(a) # define _mm_set1_ps(a) simde_mm_set1_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_move_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_move_ss(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(vgetq_lane_f32(b_.neon_f32, 0), a_.neon_f32, 0); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) static const SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) m = { ~0U, 0U, 0U, 0U }; r_.altivec_f32 = vec_sel(a_.altivec_f32, b_.altivec_f32, m); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_shuffle(b_.wasm_v128, a_.wasm_v128, 0, 1, 2, 3, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vextrins_w(a_.lsx_i64, b_.lsx_i64, 0); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, b_.f32, 4, 1, 2, 3); #else r_.f32[0] = b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_move_ss(a, b) simde_mm_move_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_broadcastlow_ps(simde__m128 a) { /* This function broadcasts the first element in the inpu vector to * all lanes. It is used to avoid generating spurious exceptions in * *_ss functions since there may be garbage in the upper lanes. */ #if defined(SIMDE_X86_SSE_NATIVE) return _mm_shuffle_ps(a, a, 0); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vdupq_laneq_f32(a_.neon_f32, 0); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_splat(a_.altivec_f32, 0); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vreplvei_w(a_.lsx_i64, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_splat(a_.f32[0]); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, a_.f32, 0, 0, 0, 0); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[0]; } #endif return simde__m128_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_add_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_add_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vaddq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_add(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfadd_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f32 = a_.f32 + b_.f32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[i] + b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_add_ps(a, b) simde_mm_add_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_add_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_add_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_add_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_add_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32_t b0 = vgetq_lane_f32(b_.neon_f32, 0); float32x4_t value = vsetq_lane_f32(b0, vdupq_n_f32(0), 0); // the upper values in the result must be the remnants of . r_.neon_f32 = vaddq_f32(a_.neon_f32, value); #else r_.f32[0] = a_.f32[0] + b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_add_ss(a, b) simde_mm_add_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_and_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_and_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vandq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_and(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vand_v(a_.lsx_i64, b_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 & b_.i32; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_and(a_.altivec_f32, b_.altivec_f32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] & b_.i32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_and_ps(a, b) simde_mm_and_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_andnot_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_andnot_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vbicq_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_andnot(b_.wasm_v128, a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = vec_andc(b_.altivec_f32, a_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vandn_v(a_.lsx_i64, b_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = ~a_.i32 & b_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = ~(a_.i32[i]) & b_.i32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_andnot_ps(a, b) simde_mm_andnot_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_xor_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_xor_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = veorq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_xor(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_xor(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vxor_v(a_.lsx_i64, b_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f ^ b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] ^ b_.u32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_xor_ps(a, b) simde_mm_xor_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_or_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_or_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vorrq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_or(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_or(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vor_v(a_.lsx_i64, b_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f | b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] | b_.u32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_or_ps(a, b) simde_mm_or_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_not_ps(simde__m128 a) { #if defined(SIMDE_X86_AVX512VL_NATIVE) __m128i ai = _mm_castps_si128(a); return _mm_castsi128_ps(_mm_ternarylogic_epi32(ai, ai, ai, 0x55)); #elif defined(SIMDE_X86_SSE2_NATIVE) /* Note: we use ints instead of floats because we don't want cmpeq * to return false for (NaN, NaN) */ __m128i ai = _mm_castps_si128(a); return _mm_castsi128_ps(_mm_andnot_si128(ai, _mm_cmpeq_epi32(ai, ai))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vmvnq_s32(a_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_nor(a_.altivec_i32, a_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_not(a_.wasm_v128); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vnor_v(a_.lsx_i64, a_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = ~a_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = ~(a_.i32[i]); } #endif return simde__m128_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_select_ps(simde__m128 a, simde__m128 b, simde__m128 mask) { /* This function is for when you want to blend two elements together * according to a mask. It is similar to _mm_blendv_ps, except that * it is undefined whether the blend is based on the highest bit in * each lane (like blendv) or just bitwise operations. This allows * us to implement the function efficiently everywhere. * * Basically, you promise that all the lanes in mask are either 0 or * ~0. */ #if defined(SIMDE_X86_SSE4_1_NATIVE) return _mm_blendv_ps(a, b, mask); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b), mask_ = simde__m128_to_private(mask); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vbslq_s32(mask_.neon_u32, b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_bitselect(b_.wasm_v128, a_.wasm_v128, mask_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = vec_sel(a_.altivec_i32, b_.altivec_i32, mask_.altivec_u32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vbitsel_v(a_.lsx_i64, b_.lsx_i64, mask_.lsx_i64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 ^ ((a_.i32 ^ b_.i32) & mask_.i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] ^ ((a_.i32[i] ^ b_.i32[i]) & mask_.i32[i]); } #endif return simde__m128_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_avg_pu16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_avg_pu16(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vrhadd_u16(b_.neon_u16, a_.neon_u16); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_CONVERT_VECTOR_) && !defined(SIMDE_BUG_GCC_100761) uint32_t wa SIMDE_VECTOR(16); uint32_t wb SIMDE_VECTOR(16); uint32_t wr SIMDE_VECTOR(16); SIMDE_CONVERT_VECTOR_(wa, a_.u16); SIMDE_CONVERT_VECTOR_(wb, b_.u16); wr = (wa + wb + 1) >> 1; SIMDE_CONVERT_VECTOR_(r_.u16, wr); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = (a_.u16[i] + b_.u16[i] + 1) >> 1; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pavgw(a, b) simde_mm_avg_pu16(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_avg_pu16(a, b) simde_mm_avg_pu16(a, b) # define _m_pavgw(a, b) simde_mm_avg_pu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_avg_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_avg_pu8(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vrhadd_u8(b_.neon_u8, a_.neon_u8); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_CONVERT_VECTOR_) && !defined(SIMDE_BUG_GCC_100761) uint16_t wa SIMDE_VECTOR(16); uint16_t wb SIMDE_VECTOR(16); uint16_t wr SIMDE_VECTOR(16); SIMDE_CONVERT_VECTOR_(wa, a_.u8); SIMDE_CONVERT_VECTOR_(wb, b_.u8); wr = (wa + wb + 1) >> 1; SIMDE_CONVERT_VECTOR_(r_.u8, wr); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] + b_.u8[i] + 1) >> 1; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pavgb(a, b) simde_mm_avg_pu8(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_avg_pu8(a, b) simde_mm_avg_pu8(a, b) # define _m_pavgb(a, b) simde_mm_avg_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_abs_ps(simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) simde_float32 mask_; uint32_t u32_ = UINT32_C(0x7FFFFFFF); simde_memcpy(&mask_, &u32_, sizeof(u32_)); return _mm_and_ps(_mm_set1_ps(mask_), a); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vabsq_f32(a_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = vec_abs(a_.altivec_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_abs(a_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_fabsf(a_.f32[i]); } #endif return simde__m128_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpeq_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpeq_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vceqq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_eq(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmpeq(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_ceq_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), a_.f32 == b_.f32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] == b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpeq_ps(a, b) simde_mm_cmpeq_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpeq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpeq_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpeq_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpeq_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] == b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpeq_ss(a, b) simde_mm_cmpeq_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpge_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpge_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcgeq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_ge(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmpge(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_cle_s(b_.lsx_f32, a_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.f32 >= b_.f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] >= b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpge_ps(a, b) simde_mm_cmpge_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpge_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) && !defined(__PGI) return _mm_cmpge_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpge_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpge_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] >= b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpge_ss(a, b) simde_mm_cmpge_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpgt_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpgt_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcgtq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_gt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmpgt(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_clt_s(b_.lsx_f32, a_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.f32 > b_.f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] > b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpgt_ps(a, b) simde_mm_cmpgt_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpgt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) && !defined(__PGI) return _mm_cmpgt_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpgt_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpgt_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] > b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpgt_ss(a, b) simde_mm_cmpgt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmple_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmple_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcleq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_le(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmple(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_cle_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.f32 <= b_.f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] <= b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmple_ps(a, b) simde_mm_cmple_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmple_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmple_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmple_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmple_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] <= b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmple_ss(a, b) simde_mm_cmple_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmplt_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmplt_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcltq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_lt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmplt(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_clt_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.f32 < b_.f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] < b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmplt_ps(a, b) simde_mm_cmplt_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmplt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmplt_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmplt_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmplt_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] < b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmplt_ss(a, b) simde_mm_cmplt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpneq_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpneq_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vmvnq_u32(vceqq_f32(a_.neon_f32, b_.neon_f32)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_ne(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_cmpeq(a_.altivec_f32, b_.altivec_f32)); r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_nor(r_.altivec_f32, r_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_cune_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.f32 != b_.f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (a_.f32[i] != b_.f32[i]) ? ~UINT32_C(0) : UINT32_C(0); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpneq_ps(a, b) simde_mm_cmpneq_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpneq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpneq_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpneq_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpneq_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.u32[0] = (a_.f32[0] != b_.f32[0]) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpneq_ss(a, b) simde_mm_cmpneq_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnge_ps (simde__m128 a, simde__m128 b) { return simde_mm_cmplt_ps(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnge_ps(a, b) simde_mm_cmpnge_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnge_ss (simde__m128 a, simde__m128 b) { return simde_mm_cmplt_ss(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnge_ss(a, b) simde_mm_cmpnge_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpngt_ps (simde__m128 a, simde__m128 b) { return simde_mm_cmple_ps(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpngt_ps(a, b) simde_mm_cmpngt_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpngt_ss (simde__m128 a, simde__m128 b) { return simde_mm_cmple_ss(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpngt_ss(a, b) simde_mm_cmpngt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnle_ps (simde__m128 a, simde__m128 b) { return simde_mm_cmpgt_ps(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnle_ps(a, b) simde_mm_cmpnle_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnle_ss (simde__m128 a, simde__m128 b) { return simde_mm_cmpgt_ss(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnle_ss(a, b) simde_mm_cmpnle_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnlt_ps (simde__m128 a, simde__m128 b) { return simde_mm_cmpge_ps(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnlt_ps(a, b) simde_mm_cmpnlt_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpnlt_ss (simde__m128 a, simde__m128 b) { return simde_mm_cmpge_ss(a, b); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpnlt_ss(a, b) simde_mm_cmpnlt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpord_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpord_ps(a, b); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_v128_and(wasm_f32x4_eq(a, a), wasm_f32x4_eq(b, b)); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) /* Note: NEON does not have ordered compare builtin Need to compare a eq a and b eq b to check for NaN Do AND of results to get final */ uint32x4_t ceqaa = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t ceqbb = vceqq_f32(b_.neon_f32, b_.neon_f32); r_.neon_u32 = vandq_u32(ceqaa, ceqbb); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_and(wasm_f32x4_eq(a_.wasm_v128, a_.wasm_v128), wasm_f32x4_eq(b_.wasm_v128, b_.wasm_v128)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_and(vec_cmpeq(a_.altivec_f32, a_.altivec_f32), vec_cmpeq(b_.altivec_f32, b_.altivec_f32))); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_cun_s(a_.lsx_f32, b_.lsx_f32); r_.lsx_i64 = __lsx_vnor_v(r_.lsx_i64, r_.lsx_i64); #elif defined(simde_math_isnanf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (simde_math_isnanf(a_.f32[i]) || simde_math_isnanf(b_.f32[i])) ? UINT32_C(0) : ~UINT32_C(0); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpord_ps(a, b) simde_mm_cmpord_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpunord_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpunord_ps(a, b); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_v128_or(wasm_f32x4_ne(a, a), wasm_f32x4_ne(b, b)); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t ceqaa = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t ceqbb = vceqq_f32(b_.neon_f32, b_.neon_f32); r_.neon_u32 = vmvnq_u32(vandq_u32(ceqaa, ceqbb)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_or(wasm_f32x4_ne(a_.wasm_v128, a_.wasm_v128), wasm_f32x4_ne(b_.wasm_v128, b_.wasm_v128)); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_nand(vec_cmpeq(a_.altivec_f32, a_.altivec_f32), vec_cmpeq(b_.altivec_f32, b_.altivec_f32))); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_and(vec_cmpeq(a_.altivec_f32, a_.altivec_f32), vec_cmpeq(b_.altivec_f32, b_.altivec_f32))); r_.altivec_f32 = vec_nor(r_.altivec_f32, r_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vfcmp_cun_s(a_.lsx_f32, b_.lsx_f32); #elif defined(simde_math_isnanf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = (simde_math_isnanf(a_.f32[i]) || simde_math_isnanf(b_.f32[i])) ? ~UINT32_C(0) : UINT32_C(0); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpunord_ps(a, b) simde_mm_cmpunord_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpunord_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) && !defined(__PGI) return _mm_cmpunord_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpunord_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpunord_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(simde_math_isnanf) r_.u32[0] = (simde_math_isnanf(a_.f32[0]) || simde_math_isnanf(b_.f32[0])) ? ~UINT32_C(0) : UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpunord_ss(a, b) simde_mm_cmpunord_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comieq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comieq_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_eq_b = vceqq_f32(a_.neon_f32, b_.neon_f32); return !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_eq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) == wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] == b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comieq_ss(a, b) simde_mm_comieq_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comige_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comige_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_ge_b = vcgeq_f32(a_.neon_f32, b_.neon_f32); return !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_ge_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) >= wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] >= b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comige_ss(a, b) simde_mm_comige_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comigt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comigt_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_gt_b = vcgtq_f32(a_.neon_f32, b_.neon_f32); return !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_gt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) > wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] > b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comigt_ss(a, b) simde_mm_comigt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comile_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comile_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_le_b = vcleq_f32(a_.neon_f32, b_.neon_f32); return !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_le_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) <= wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] <= b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comile_ss(a, b) simde_mm_comile_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comilt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comilt_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_lt_b = vcltq_f32(a_.neon_f32, b_.neon_f32); return !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_lt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) < wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] < b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comilt_ss(a, b) simde_mm_comilt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comineq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_comineq_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_neq_b = vmvnq_u32(vceqq_f32(a_.neon_f32, b_.neon_f32)); return !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_neq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_extract_lane(a_.wasm_v128, 0) != wasm_f32x4_extract_lane(b_.wasm_v128, 0); #else return a_.f32[0] != b_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_comineq_ss(a, b) simde_mm_comineq_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_copysign_ps(simde__m128 dest, simde__m128 src) { simde__m128_private r_, dest_ = simde__m128_to_private(dest), src_ = simde__m128_to_private(src); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint32x4_t sign_pos = vreinterpretq_u32_f32(vdupq_n_f32(-SIMDE_FLOAT32_C(0.0))); r_.neon_u32 = vbslq_u32(sign_pos, src_.neon_u32, dest_.neon_u32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) const v128_t sign_pos = wasm_f32x4_splat(-0.0f); r_.wasm_v128 = wasm_v128_bitselect(src_.wasm_v128, dest_.wasm_v128, sign_pos); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #if defined(SIMDE_BUG_VEC_CPSGN_REVERSED_ARGS) r_.altivec_f32 = vec_cpsgn(dest_.altivec_f32, src_.altivec_f32); #else r_.altivec_f32 = vec_cpsgn(src_.altivec_f32, dest_.altivec_f32); #endif #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) const SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) sign_pos = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(unsigned int), vec_splats(-0.0f)); r_.altivec_f32 = vec_sel(dest_.altivec_f32, src_.altivec_f32, sign_pos); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) const v4f32 sign_pos = {-0.0f, -0.0f, -0.0f, -0.0f}; r_.lsx_i64 = __lsx_vbitsel_v(dest_.lsx_i64, src_.lsx_i64, (v2i64)sign_pos); #elif defined(SIMDE_IEEE754_STORAGE) (void) src_; (void) dest_; simde__m128 sign_pos = simde_mm_set1_ps(-0.0f); r_ = simde__m128_to_private(simde_mm_xor_ps(dest, simde_mm_and_ps(simde_mm_xor_ps(dest, src), sign_pos))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = simde_math_copysignf(dest_.f32[i], src_.f32[i]); } #endif return simde__m128_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_xorsign_ps(simde__m128 dest, simde__m128 src) { return simde_mm_xor_ps(simde_mm_and_ps(simde_mm_set1_ps(-0.0f), src), dest); } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvt_pi2ps (simde__m128 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvt_pi2ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcombine_f32(vcvt_f32_s32(b_.neon_i32), vget_high_f32(a_.neon_f32)); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.m64_private[0].f32, b_.i32); r_.m64_private[1] = a_.m64_private[1]; #else r_.f32[0] = (simde_float32) b_.i32[0]; r_.f32[1] = (simde_float32) b_.i32[1]; r_.i32[2] = a_.i32[2]; r_.i32[3] = a_.i32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvt_pi2ps(a, b) simde_mm_cvt_pi2ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvt_ps2pi (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvt_ps2pi(a); #else simde__m64_private r_; simde__m128_private a_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) a_ = simde__m128_to_private(simde_mm_round_ps(a, SIMDE_MM_FROUND_CUR_DIRECTION)); r_.neon_i32 = vcvt_s32_f32(vget_low_f32(a_.neon_f32)); #elif defined(SIMDE_CONVERT_VECTOR_) && SIMDE_NATURAL_VECTOR_SIZE_GE(128) && !defined(SIMDE_BUG_GCC_100761) a_ = simde__m128_to_private(simde_mm_round_ps(a, SIMDE_MM_FROUND_CUR_DIRECTION)); SIMDE_CONVERT_VECTOR_(r_.i32, a_.m64_private[0].f32); #else a_ = simde__m128_to_private(a); SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = HEDLEY_STATIC_CAST(int32_t, simde_math_nearbyintf(a_.f32[i])); } #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvt_ps2pi(a) simde_mm_cvt_ps2pi((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvt_si2ss (simde__m128 a, int32_t b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cvt_si2ss(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(HEDLEY_STATIC_CAST(float, b), a_.neon_f32, 0); #else r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, b); r_.i32[1] = a_.i32[1]; r_.i32[2] = a_.i32[2]; r_.i32[3] = a_.i32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvt_si2ss(a, b) simde_mm_cvt_si2ss((a), b) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvt_ss2si (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cvt_ss2si(a); #elif defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_BUG_GCC_95399) return vgetq_lane_s32(vcvtnq_s32_f32(simde__m128_to_neon_f32(a)), 0); #else simde__m128_private a_ = simde__m128_to_private(simde_mm_round_ps(a, SIMDE_MM_FROUND_CUR_DIRECTION)); #if !defined(SIMDE_FAST_CONVERSION_RANGE) return ((a_.f32[0] > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (a_.f32[0] < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, a_.f32[0]) : INT32_MIN; #else return SIMDE_CONVERT_FTOI(int32_t, a_.f32[0]); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvt_ss2si(a) simde_mm_cvt_ss2si((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpi16_ps (simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpi16_ps(a); #else simde__m128_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_s32(vmovl_s16(a_.neon_i16)); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f32, a_.i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { simde_float32 v = a_.i16[i]; r_.f32[i] = v; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpi16_ps(a) simde_mm_cvtpi16_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpi32_ps (simde__m128 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpi32_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a); simde__m64_private b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcombine_f32(vcvt_f32_s32(b_.neon_i32), vget_high_f32(a_.neon_f32)); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.m64_private[0].f32, b_.i32); r_.m64_private[1] = a_.m64_private[1]; #else r_.f32[0] = (simde_float32) b_.i32[0]; r_.f32[1] = (simde_float32) b_.i32[1]; r_.i32[2] = a_.i32[2]; r_.i32[3] = a_.i32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpi32_ps(a, b) simde_mm_cvtpi32_ps((a), b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpi32x2_ps (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpi32x2_ps(a, b); #else simde__m128_private r_; simde__m64_private a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_s32(vcombine_s32(a_.neon_i32, b_.neon_i32)); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.m64_private[0].f32, a_.i32); SIMDE_CONVERT_VECTOR_(r_.m64_private[1].f32, b_.i32); #else r_.f32[0] = (simde_float32) a_.i32[0]; r_.f32[1] = (simde_float32) a_.i32[1]; r_.f32[2] = (simde_float32) b_.i32[0]; r_.f32[3] = (simde_float32) b_.i32[1]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpi32x2_ps(a, b) simde_mm_cvtpi32x2_ps(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpi8_ps (simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpi8_ps(a); #else simde__m128_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_s32(vmovl_s16(vget_low_s16(vmovl_s8(a_.neon_i8)))); #else r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, a_.i8[0]); r_.f32[1] = HEDLEY_STATIC_CAST(simde_float32, a_.i8[1]); r_.f32[2] = HEDLEY_STATIC_CAST(simde_float32, a_.i8[2]); r_.f32[3] = HEDLEY_STATIC_CAST(simde_float32, a_.i8[3]); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpi8_ps(a) simde_mm_cvtpi8_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtps_pi16 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtps_pi16(a); #else simde__m64_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_BUG_GCC_95399) r_.neon_i16 = vmovn_s32(vcvtq_s32_f32(vrndiq_f32(a_.neon_f32))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = SIMDE_CONVERT_FTOI(int16_t, simde_math_roundf(a_.f32[i])); } #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtps_pi16(a) simde_mm_cvtps_pi16((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtps_pi32 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtps_pi32(a); #else simde__m64_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_BUG_GCC_95399) r_.neon_i32 = vcvt_s32_f32(vget_low_f32(vrndiq_f32(a_.neon_f32))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { simde_float32 v = simde_math_roundf(a_.f32[i]); #if !defined(SIMDE_FAST_CONVERSION_RANGE) r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #else r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #endif } #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtps_pi32(a) simde_mm_cvtps_pi32((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtps_pi8 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtps_pi8(a); #else simde__m64_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_BUG_GCC_95471) /* Clamp the input to [INT8_MIN, INT8_MAX], round, convert to i32, narrow to * i16, combine with an all-zero vector of i16 (which will become the upper * half), narrow to i8. */ float32x4_t max = vdupq_n_f32(HEDLEY_STATIC_CAST(simde_float32, INT8_MAX)); float32x4_t min = vdupq_n_f32(HEDLEY_STATIC_CAST(simde_float32, INT8_MIN)); float32x4_t values = vrndnq_f32(vmaxq_f32(vminq_f32(max, a_.neon_f32), min)); r_.neon_i8 = vmovn_s16(vcombine_s16(vmovn_s32(vcvtq_s32_f32(values)), vdup_n_s16(0))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(a_.f32) / sizeof(a_.f32[0])) ; i++) { if (a_.f32[i] > HEDLEY_STATIC_CAST(simde_float32, INT8_MAX)) r_.i8[i] = INT8_MAX; else if (a_.f32[i] < HEDLEY_STATIC_CAST(simde_float32, INT8_MIN)) r_.i8[i] = INT8_MIN; else r_.i8[i] = SIMDE_CONVERT_FTOI(int8_t, simde_math_roundf(a_.f32[i])); } /* Note: the upper half is undefined */ #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtps_pi8(a) simde_mm_cvtps_pi8((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpu16_ps (simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpu16_ps(a); #else simde__m128_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_u32(vmovl_u16(a_.neon_u16)); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f32, a_.u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = (simde_float32) a_.u16[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpu16_ps(a) simde_mm_cvtpu16_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpu8_ps (simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpu8_ps(a); #else simde__m128_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_u32(vmovl_u16(vget_low_u16(vmovl_u8(a_.neon_u8)))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = HEDLEY_STATIC_CAST(simde_float32, a_.u8[i]); } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtpu8_ps(a) simde_mm_cvtpu8_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtsi32_ss (simde__m128 a, int32_t b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cvtsi32_ss(a, b); #else simde__m128_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(HEDLEY_STATIC_CAST(float32_t, b), a_.neon_f32, 0); #else r_ = a_; r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, b); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtsi32_ss(a, b) simde_mm_cvtsi32_ss((a), b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtsi64_ss (simde__m128 a, int64_t b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_ARCH_AMD64) #if !defined(__PGI) return _mm_cvtsi64_ss(a, b); #else return _mm_cvtsi64x_ss(a, b); #endif #else simde__m128_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(HEDLEY_STATIC_CAST(float32_t, b), a_.neon_f32, 0); #else r_ = a_; r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, b); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) # define _mm_cvtsi64_ss(a, b) simde_mm_cvtsi64_ss((a), b) #endif SIMDE_FUNCTION_ATTRIBUTES simde_float32 simde_mm_cvtss_f32 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cvtss_f32(a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vgetq_lane_f32(a_.neon_f32, 0); #else return a_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtss_f32(a) simde_mm_cvtss_f32((a)) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvtss_si32 (simde__m128 a) { return simde_mm_cvt_ss2si(a); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtss_si32(a) simde_mm_cvtss_si32((a)) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvtss_si64 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_ARCH_AMD64) #if !defined(__PGI) return _mm_cvtss_si64(a); #else return _mm_cvtss_si64x(a); #endif #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) return SIMDE_CONVERT_FTOI(int64_t, simde_math_roundf(vgetq_lane_f32(a_.neon_f32, 0))); #else return SIMDE_CONVERT_FTOI(int64_t, simde_math_roundf(a_.f32[0])); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) # define _mm_cvtss_si64(a) simde_mm_cvtss_si64((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtt_ps2pi (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtt_ps2pi(a); #else simde__m64_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) r_.neon_i32 = vcvt_s32_f32(vget_low_f32(a_.neon_f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { simde_float32 v = a_.f32[i]; #if !defined(SIMDE_FAST_CONVERSION_RANGE) r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #else r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #endif } #endif return simde__m64_from_private(r_); #endif } #define simde_mm_cvttps_pi32(a) simde_mm_cvtt_ps2pi(a) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtt_ps2pi(a) simde_mm_cvtt_ps2pi((a)) # define _mm_cvttps_pi32(a) simde_mm_cvttps_pi32((a)) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvtt_ss2si (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cvtt_ss2si(a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) return SIMDE_CONVERT_FTOI(int32_t, vgetq_lane_f32(a_.neon_f32, 0)); #else simde_float32 v = a_.f32[0]; #if !defined(SIMDE_FAST_CONVERSION_RANGE) return ((v > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #else return SIMDE_CONVERT_FTOI(int32_t, v); #endif #endif #endif } #define simde_mm_cvttss_si32(a) simde_mm_cvtt_ss2si((a)) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cvtt_ss2si(a) simde_mm_cvtt_ss2si((a)) # define _mm_cvttss_si32(a) simde_mm_cvtt_ss2si((a)) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvttss_si64 (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_ARCH_AMD64) && !defined(_MSC_VER) #if defined(__PGI) return _mm_cvttss_si64x(a); #else return _mm_cvttss_si64(a); #endif #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) return SIMDE_CONVERT_FTOI(int64_t, vgetq_lane_f32(a_.neon_f32, 0)); #else return SIMDE_CONVERT_FTOI(int64_t, a_.f32[0]); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) # define _mm_cvttss_si64(a) simde_mm_cvttss_si64((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cmpord_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_cmpord_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_cmpord_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_cmpord_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(simde_math_isnanf) r_.u32[0] = (simde_math_isnanf(simde_mm_cvtss_f32(a)) || simde_math_isnanf(simde_mm_cvtss_f32(b))) ? UINT32_C(0) : ~UINT32_C(0); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.u32[i] = a_.u32[i]; } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_cmpord_ss(a, b) simde_mm_cmpord_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_div_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_div_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vdivq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x4_t recip0 = vrecpeq_f32(b_.neon_f32); float32x4_t recip1 = vmulq_f32(recip0, vrecpsq_f32(recip0, b_.neon_f32)); r_.neon_f32 = vmulq_f32(a_.neon_f32, recip1); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_div(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f32 = vec_div(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LASX_NATIVE) r_.lsx_f32 = __lsx_vfdiv_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f32 = a_.f32 / b_.f32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[i] / b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_div_ps(a, b) simde_mm_div_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_div_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_div_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_div_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_div_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32_t value = vgetq_lane_f32(simde__m128_to_private(simde_mm_div_ps(a, b)).neon_f32, 0); r_.neon_f32 = vsetq_lane_f32(value, a_.neon_f32, 0); #else r_.f32[0] = a_.f32[0] / b_.f32[0]; SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_div_ss(a, b) simde_mm_div_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int16_t simde_mm_extract_pi16 (simde__m64 a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 3) { simde__m64_private a_ = simde__m64_to_private(a); return a_.i16[imm8]; } #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) && !defined(HEDLEY_PGI_VERSION) && !defined(SIMDE_BUG_CLANG_44589) #define simde_mm_extract_pi16(a, imm8) HEDLEY_STATIC_CAST(int16_t, _mm_extract_pi16(a, imm8)) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_extract_pi16(a, imm8) vget_lane_s16(simde__m64_to_private(a).neon_i16, imm8) #endif #define simde_m_pextrw(a, imm8) simde_mm_extract_pi16(a, imm8) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_extract_pi16(a, imm8) simde_mm_extract_pi16((a), (imm8)) # define _m_pextrw(a, imm8) simde_mm_extract_pi16((a), (imm8)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_insert_pi16 (simde__m64 a, int16_t i, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 3) { simde__m64_private a_ = simde__m64_to_private(a); a_.i16[imm8] = i; return simde__m64_from_private(a_); } #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) && !defined(SIMDE_BUG_CLANG_44589) #define simde_mm_insert_pi16(a, i, imm8) _mm_insert_pi16(a, i, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_insert_pi16(a, i, imm8) simde__m64_from_neon_i16(vset_lane_s16((i), simde__m64_to_neon_i16(a), (imm8))) #endif #define simde_m_pinsrw(a, i, imm8) (simde_mm_insert_pi16(a, i, imm8)) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_insert_pi16(a, i, imm8) simde_mm_insert_pi16(a, i, imm8) # define _m_pinsrw(a, i, imm8) simde_mm_insert_pi16(a, i, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_load_ps (simde_float32 const mem_addr[HEDLEY_ARRAY_PARAM(4)]) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_load_ps(mem_addr); #else simde__m128_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vld1q_f32(mem_addr); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f32 = vec_vsx_ld(0, mem_addr); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_ld(0, mem_addr); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vld(mem_addr, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load(mem_addr); #else simde_memcpy(&r_, SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128), sizeof(r_)); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_load_ps(mem_addr) simde_mm_load_ps(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_load1_ps (simde_float32 const* mem_addr) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_load_ps1(mem_addr); #else simde__m128_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vld1q_dup_f32(mem_addr); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vldrepl_w(mem_addr, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load32_splat(mem_addr); #else r_ = simde__m128_to_private(simde_mm_set1_ps(*mem_addr)); #endif return simde__m128_from_private(r_); #endif } #define simde_mm_load_ps1(mem_addr) simde_mm_load1_ps(mem_addr) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_load_ps1(mem_addr) simde_mm_load1_ps(mem_addr) # define _mm_load1_ps(mem_addr) simde_mm_load1_ps(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_load_ss (simde_float32 const* mem_addr) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_load_ss(mem_addr); #else simde__m128_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(*mem_addr, vdupq_n_f32(0), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load32_zero(mem_addr); #else r_.f32[0] = *mem_addr; r_.i32[1] = 0; r_.i32[2] = 0; r_.i32[3] = 0; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_load_ss(mem_addr) simde_mm_load_ss(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_loadh_pi (simde__m128 a, simde__m64 const* mem_addr) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_loadh_pi(a, HEDLEY_REINTERPRET_CAST(__m64 const*, mem_addr)); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcombine_f32(vget_low_f32(a_.neon_f32), vld1_f32(HEDLEY_REINTERPRET_CAST(const float32_t*, mem_addr))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load64_lane(mem_addr, a_.wasm_v128, 1); #else simde__m64_private b_ = *HEDLEY_REINTERPRET_CAST(simde__m64_private const*, mem_addr); r_.f32[0] = a_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = b_.f32[0]; r_.f32[3] = b_.f32[1]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #if HEDLEY_HAS_WARNING("-Wold-style-cast") #define _mm_loadh_pi(a, mem_addr) simde_mm_loadh_pi((a), HEDLEY_REINTERPRET_CAST(simde__m64 const*, (mem_addr))) #else #define _mm_loadh_pi(a, mem_addr) simde_mm_loadh_pi((a), (simde__m64 const*) (mem_addr)) #endif #endif /* The SSE documentation says that there are no alignment requirements for mem_addr. Unfortunately they used the __m64 type for the argument which is supposed to be 8-byte aligned, so some compilers (like clang with -Wcast-align) will generate a warning if you try to cast, say, a simde_float32* to a simde__m64* for this function. I think the choice of argument type is unfortunate, but I do think we need to stick to it here. If there is demand I can always add something like simde_x_mm_loadl_f32(simde__m128, simde_float32 mem_addr[2]) */ SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_loadl_pi (simde__m128 a, simde__m64 const* mem_addr) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_loadl_pi(a, HEDLEY_REINTERPRET_CAST(__m64 const*, mem_addr)); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcombine_f32(vld1_f32( HEDLEY_REINTERPRET_CAST(const float32_t*, mem_addr)), vget_high_f32(a_.neon_f32)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load64_lane(mem_addr, a_.wasm_v128, 0); #else simde__m64_private b_; simde_memcpy(&b_, mem_addr, sizeof(b_)); r_.i32[0] = b_.i32[0]; r_.i32[1] = b_.i32[1]; r_.i32[2] = a_.i32[2]; r_.i32[3] = a_.i32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #if HEDLEY_HAS_WARNING("-Wold-style-cast") #define _mm_loadl_pi(a, mem_addr) simde_mm_loadl_pi((a), HEDLEY_REINTERPRET_CAST(simde__m64 const*, (mem_addr))) #else #define _mm_loadl_pi(a, mem_addr) simde_mm_loadl_pi((a), (simde__m64 const*) (mem_addr)) #endif #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_loadr_ps (simde_float32 const mem_addr[HEDLEY_ARRAY_PARAM(4)]) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_loadr_ps(mem_addr); #else simde__m128_private r_, v_ = simde__m128_to_private(simde_mm_load_ps(mem_addr)); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vrev64q_f32(v_.neon_f32); r_.neon_f32 = vextq_f32(r_.neon_f32, r_.neon_f32, 2); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) && defined(__PPC64__) r_.altivec_f32 = vec_reve(v_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vshuf4i_w(v_.lsx_i64, 0x1b); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, v_.f32, v_.f32, 3, 2, 1, 0); #else r_.f32[0] = v_.f32[3]; r_.f32[1] = v_.f32[2]; r_.f32[2] = v_.f32[1]; r_.f32[3] = v_.f32[0]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_loadr_ps(mem_addr) simde_mm_loadr_ps(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_loadu_ps (simde_float32 const mem_addr[HEDLEY_ARRAY_PARAM(4)]) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_loadu_ps(mem_addr); #else simde__m128_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vld1q_f32(HEDLEY_REINTERPRET_CAST(const float32_t*, mem_addr)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load(mem_addr); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) && defined(__PPC64__) r_.altivec_f32 = vec_vsx_ld(0, mem_addr); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vld(mem_addr, 0); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_loadu_ps(mem_addr) simde_mm_loadu_ps(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_maskmove_si64 (simde__m64 a, simde__m64 mask, int8_t* mem_addr) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) _mm_maskmove_si64(a, mask, HEDLEY_REINTERPRET_CAST(char*, mem_addr)); #else simde__m64_private a_ = simde__m64_to_private(a), mask_ = simde__m64_to_private(mask); SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(a_.i8) / sizeof(a_.i8[0])) ; i++) if (mask_.i8[i] < 0) mem_addr[i] = a_.i8[i]; #endif } #define simde_m_maskmovq(a, mask, mem_addr) simde_mm_maskmove_si64(a, mask, mem_addr) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_maskmove_si64(a, mask, mem_addr) simde_mm_maskmove_si64((a), (mask), SIMDE_CHECKED_REINTERPRET_CAST(int8_t*, char*, (mem_addr))) # define _m_maskmovq(a, mask, mem_addr) simde_mm_maskmove_si64((a), (mask), SIMDE_CHECKED_REINTERPRET_CAST(int8_t*, char*, (mem_addr))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_max_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_max_pi16(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vmax_s16(a_.neon_i16, b_.neon_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] > b_.i16[i]) ? a_.i16[i] : b_.i16[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmaxsw(a, b) simde_mm_max_pi16(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_max_pi16(a, b) simde_mm_max_pi16(a, b) # define _m_pmaxsw(a, b) simde_mm_max_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_max_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_max_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_FAST_NANS) r_.neon_f32 = vmaxq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vbslq_f32(vcgtq_f32(a_.neon_f32, b_.neon_f32), a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) && defined(SIMDE_FAST_NANS) r_.wasm_v128 = wasm_f32x4_max(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_bitselect(a_.wasm_v128, b_.wasm_v128, wasm_f32x4_gt(a_.wasm_v128, b_.wasm_v128)); #elif (defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE)) && defined(SIMDE_FAST_NANS) r_.altivec_f32 = vec_max(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = vec_sel(b_.altivec_f32, a_.altivec_f32, vec_cmpgt(a_.altivec_f32, b_.altivec_f32)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) && defined(SIMDE_FAST_NANS) r_.lsx_f32 = __lsx_vfmax_s(a_.lsx_f32, b_.lsx_f32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = (a_.f32[i] > b_.f32[i]) ? a_.f32[i] : b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_max_ps(a, b) simde_mm_max_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_max_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_max_pu8(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vmax_u8(a_.neon_u8, b_.neon_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] > b_.u8[i]) ? a_.u8[i] : b_.u8[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmaxub(a, b) simde_mm_max_pu8(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_max_pu8(a, b) simde_mm_max_pu8(a, b) # define _m_pmaxub(a, b) simde_mm_max_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_max_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_max_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_max_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_max_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32_t value = vgetq_lane_f32(maxq_f32(a_.neon_f32, b_.neon_f32), 0); r_.neon_f32 = vsetq_lane_f32(value, a_.neon_f32, 0); #else r_.f32[0] = (a_.f32[0] > b_.f32[0]) ? a_.f32[0] : b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_max_ss(a, b) simde_mm_max_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_min_pi16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_min_pi16(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vmin_s16(a_.neon_i16, b_.neon_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] < b_.i16[i]) ? a_.i16[i] : b_.i16[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pminsw(a, b) simde_mm_min_pi16(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_min_pi16(a, b) simde_mm_min_pi16(a, b) # define _m_pminsw(a, b) simde_mm_min_pi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_min_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_min_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_FAST_NANS) && defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vminq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_pmin(b_.wasm_v128, a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) #if defined(SIMDE_FAST_NANS) r_.altivec_f32 = vec_min(a_.altivec_f32, b_.altivec_f32); #else r_.altivec_f32 = vec_sel(b_.altivec_f32, a_.altivec_f32, vec_cmpgt(b_.altivec_f32, a_.altivec_f32)); #endif #elif defined(SIMDE_FAST_NANS) && defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfmin_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) uint32_t SIMDE_VECTOR(16) m = HEDLEY_REINTERPRET_CAST(__typeof__(m), a_.f32 < b_.f32); r_.f32 = HEDLEY_REINTERPRET_CAST( __typeof__(r_.f32), ( (HEDLEY_REINTERPRET_CAST(__typeof__(m), a_.f32) & m) | (HEDLEY_REINTERPRET_CAST(__typeof__(m), b_.f32) & ~m) ) ); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = (a_.f32[i] < b_.f32[i]) ? a_.f32[i] : b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_min_ps(a, b) simde_mm_min_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_min_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_min_pu8(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vmin_u8(a_.neon_u8, b_.neon_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] < b_.u8[i]) ? a_.u8[i] : b_.u8[i]; } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pminub(a, b) simde_mm_min_pu8(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_min_pu8(a, b) simde_mm_min_pu8(a, b) # define _m_pminub(a, b) simde_mm_min_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_min_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_min_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_min_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_min_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32_t value = vgetq_lane_f32(vminq_f32(a_.neon_f32, b_.neon_f32), 0); r_.neon_f32 = vsetq_lane_f32(value, a_.neon_f32, 0); #else r_.f32[0] = (a_.f32[0] < b_.f32[0]) ? a_.f32[0] : b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_min_ss(a, b) simde_mm_min_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_movehl_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_movehl_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x2_t a32 = vget_high_f32(a_.neon_f32); float32x2_t b32 = vget_high_f32(b_.neon_f32); r_.neon_f32 = vcombine_f32(b32, a32); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_mergel(b_.altivec_i64, a_.altivec_i64)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vilvh_d(a_.lsx_i64, b_.lsx_i64); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, b_.f32, 6, 7, 2, 3); #else r_.f32[0] = b_.f32[2]; r_.f32[1] = b_.f32[3]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_movehl_ps(a, b) simde_mm_movehl_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_movelh_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_movelh_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x2_t a10 = vget_low_f32(a_.neon_f32); float32x2_t b10 = vget_low_f32(b_.neon_f32); r_.neon_f32 = vcombine_f32(a10, b10); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), vec_mergeh(a_.altivec_i64, b_.altivec_i64)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vilvl_d(b_.lsx_i64, a_.lsx_i64); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, b_.f32, 0, 1, 4, 5); #else r_.f32[0] = a_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = b_.f32[0]; r_.f32[3] = b_.f32[1]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_movelh_ps(a, b) simde_mm_movelh_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_movemask_pi8 (simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_movemask_pi8(a); #else simde__m64_private a_ = simde__m64_to_private(a); int r = 0; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint8x8_t input = a_.neon_u8; const int8_t xr[8] = {-7, -6, -5, -4, -3, -2, -1, 0}; const uint8x8_t mask_and = vdup_n_u8(0x80); const int8x8_t mask_shift = vld1_s8(xr); const uint8x8_t mask_result = vshl_u8(vand_u8(input, mask_and), mask_shift); uint8x8_t lo = mask_result; r = vaddv_u8(lo); #else const size_t nmemb = sizeof(a_.i8) / sizeof(a_.i8[0]); SIMDE_VECTORIZE_REDUCTION(|:r) for (size_t i = 0 ; i < nmemb ; i++) { r |= (a_.u8[nmemb - 1 - i] >> 7) << (nmemb - 1 - i); } #endif return r; #endif } #define simde_m_pmovmskb(a) simde_mm_movemask_pi8(a) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_movemask_pi8(a) simde_mm_movemask_pi8(a) # define _m_pmovmskb(a) simde_mm_movemask_pi8(a) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_movemask_ps (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_movemask_ps(a); #else int r = 0; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) // Shift out everything but the sign bits with a 32-bit unsigned shift right. uint64x2_t high_bits = vreinterpretq_u64_u32(vshrq_n_u32(a_.neon_u32, 31)); // Merge the two pairs together with a 64-bit unsigned shift right + add. uint8x16_t paired = vreinterpretq_u8_u64(vsraq_n_u64(high_bits, high_bits, 31)); // Extract the result. return vgetq_lane_u8(paired, 0) | (vgetq_lane_u8(paired, 8) << 2); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) static const uint32_t md[4] = { 1 << 0, 1 << 1, 1 << 2, 1 << 3 }; uint32x4_t extended = vreinterpretq_u32_s32(vshrq_n_s32(a_.neon_i32, 31)); uint32x4_t masked = vandq_u32(vld1q_u32(md), extended); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return HEDLEY_STATIC_CAST(int32_t, vaddvq_u32(masked)); #else uint64x2_t t64 = vpaddlq_u32(masked); return HEDLEY_STATIC_CAST(int, vgetq_lane_u64(t64, 0)) + HEDLEY_STATIC_CAST(int, vgetq_lane_u64(t64, 1)); #endif #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && defined(SIMDE_BUG_CLANG_50932) SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) idx = { 96, 64, 32, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) res = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(unsigned char), vec_bperm(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(unsigned __int128), a_.altivec_u64), idx)); return HEDLEY_STATIC_CAST(int32_t, vec_extract(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), res), 2)); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) idx = { 96, 64, 32, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) res = vec_bperm(a_.altivec_u8, idx); return HEDLEY_STATIC_CAST(int32_t, vec_extract(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), res), 2)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) v2i64 t64 = __lsx_vmskltz_w(a_.lsx_i64); r = __lsx_vpickve2gr_wu(t64, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return HEDLEY_STATIC_CAST(int32_t, wasm_i32x4_bitmask(a_.wasm_v128)); #else SIMDE_VECTORIZE_REDUCTION(|:r) for (size_t i = 0 ; i < sizeof(a_.u32) / sizeof(a_.u32[0]) ; i++) { r |= (a_.u32[i] >> ((sizeof(a_.u32[i]) * CHAR_BIT) - 1)) << i; } #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_movemask_ps(a) simde_mm_movemask_ps((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_mul_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_mul_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vmulq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_mul(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f32 = a_.f32 * b_.f32; #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f32 = vec_mul(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfmul_s(a_.lsx_f32, b_.lsx_f32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[i] * b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_mul_ps(a, b) simde_mm_mul_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_mul_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_mul_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_mul_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_mul_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.f32[0] = a_.f32[0] * b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_mul_ss(a, b) simde_mm_mul_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_mulhi_pu16 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_mulhi_pu16(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint32x4_t t1 = vmull_u16(a_.neon_u16, b_.neon_u16); const uint32x4_t t2 = vshrq_n_u32(t1, 16); const uint16x4_t t3 = vmovn_u32(t2); r_.neon_u16 = t3; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, ((HEDLEY_STATIC_CAST(uint32_t, a_.u16[i]) * HEDLEY_STATIC_CAST(uint32_t, b_.u16[i])) >> UINT32_C(16))); } #endif return simde__m64_from_private(r_); #endif } #define simde_m_pmulhuw(a, b) simde_mm_mulhi_pu16(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_mulhi_pu16(a, b) simde_mm_mulhi_pu16(a, b) # define _m_pmulhuw(a, b) simde_mm_mulhi_pu16(a, b) #endif #if defined(SIMDE_X86_SSE_NATIVE) && defined(HEDLEY_GCC_VERSION) #define SIMDE_MM_HINT_NTA HEDLEY_STATIC_CAST(enum _mm_hint, 0) #define SIMDE_MM_HINT_T0 HEDLEY_STATIC_CAST(enum _mm_hint, 1) #define SIMDE_MM_HINT_T1 HEDLEY_STATIC_CAST(enum _mm_hint, 2) #define SIMDE_MM_HINT_T2 HEDLEY_STATIC_CAST(enum _mm_hint, 3) #define SIMDE_MM_HINT_ENTA HEDLEY_STATIC_CAST(enum _mm_hint, 4) #define SIMDE_MM_HINT_ET0 HEDLEY_STATIC_CAST(enum _mm_hint, 5) #define SIMDE_MM_HINT_ET1 HEDLEY_STATIC_CAST(enum _mm_hint, 6) #define SIMDE_MM_HINT_ET2 HEDLEY_STATIC_CAST(enum _mm_hint, 7) #else #define SIMDE_MM_HINT_NTA 0 #define SIMDE_MM_HINT_T0 1 #define SIMDE_MM_HINT_T1 2 #define SIMDE_MM_HINT_T2 3 #define SIMDE_MM_HINT_ENTA 4 #define SIMDE_MM_HINT_ET0 5 #define SIMDE_MM_HINT_ET1 6 #define SIMDE_MM_HINT_ET2 7 #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wreserved-id-macro") _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"") #endif #undef _MM_HINT_NTA #define _MM_HINT_NTA SIMDE_MM_HINT_NTA #undef _MM_HINT_T0 #define _MM_HINT_T0 SIMDE_MM_HINT_T0 #undef _MM_HINT_T1 #define _MM_HINT_T1 SIMDE_MM_HINT_T1 #undef _MM_HINT_T2 #define _MM_HINT_T2 SIMDE_MM_HINT_T2 #undef _MM_HINT_ENTA #define _MM_HINT_ETNA SIMDE_MM_HINT_ENTA #undef _MM_HINT_ET0 #define _MM_HINT_ET0 SIMDE_MM_HINT_ET0 #undef _MM_HINT_ET1 #define _MM_HINT_ET1 SIMDE_MM_HINT_ET1 #undef _MM_HINT_ET1 #define _MM_HINT_ET2 SIMDE_MM_HINT_ET2 HEDLEY_DIAGNOSTIC_POP #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_prefetch (const void* p, int i) { #if \ HEDLEY_HAS_BUILTIN(__builtin_prefetch) || \ HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ HEDLEY_INTEL_VERSION_CHECK(13,0,0) switch(i) { case SIMDE_MM_HINT_NTA: __builtin_prefetch(p, 0, 0); break; case SIMDE_MM_HINT_T0: __builtin_prefetch(p, 0, 3); break; case SIMDE_MM_HINT_T1: __builtin_prefetch(p, 0, 2); break; case SIMDE_MM_HINT_T2: __builtin_prefetch(p, 0, 1); break; case SIMDE_MM_HINT_ENTA: __builtin_prefetch(p, 1, 0); break; case SIMDE_MM_HINT_ET0: __builtin_prefetch(p, 1, 3); break; case SIMDE_MM_HINT_ET1: __builtin_prefetch(p, 1, 2); break; case SIMDE_MM_HINT_ET2: __builtin_prefetch(p, 0, 1); break; } #elif defined(__ARM_ACLE) #if (__ARM_ACLE >= 101) switch(i) { case SIMDE_MM_HINT_NTA: __pldx(0, 0, 1, p); break; case SIMDE_MM_HINT_T0: __pldx(0, 0, 0, p); break; case SIMDE_MM_HINT_T1: __pldx(0, 1, 0, p); break; case SIMDE_MM_HINT_T2: __pldx(0, 2, 0, p); break; case SIMDE_MM_HINT_ENTA: __pldx(1, 0, 1, p); break; case SIMDE_MM_HINT_ET0: __pldx(1, 0, 0, p); break; case SIMDE_MM_HINT_ET1: __pldx(1, 1, 0, p); break; case SIMDE_MM_HINT_ET2: __pldx(1, 2, 0, p); break; } #else (void) i; __pld(p) #endif #elif HEDLEY_PGI_VERSION_CHECK(10,0,0) (void) i; #pragma mem prefetch p #elif HEDLEY_CRAY_VERSION_CHECK(8,1,0) switch (i) { case SIMDE_MM_HINT_NTA: #pragma _CRI prefetch (nt) p break; case SIMDE_MM_HINT_T0: case SIMDE_MM_HINT_T1: case SIMDE_MM_HINT_T2: #pragma _CRI prefetch p break; case SIMDE_MM_HINT_ENTA: #pragma _CRI prefetch (write, nt) p break; case SIMDE_MM_HINT_ET0: case SIMDE_MM_HINT_ET1: case SIMDE_MM_HINT_ET2: #pragma _CRI prefetch (write) p break; } #elif HEDLEY_IBM_VERSION_CHECK(11,0,0) switch(i) { case SIMDE_MM_HINT_NTA: __prefetch_by_load(p, 0, 0); break; case SIMDE_MM_HINT_T0: __prefetch_by_load(p, 0, 3); break; case SIMDE_MM_HINT_T1: __prefetch_by_load(p, 0, 2); break; case SIMDE_MM_HINT_T2: __prefetch_by_load(p, 0, 1); break; case SIMDE_MM_HINT_ENTA: __prefetch_by_load(p, 1, 0); break; case SIMDE_MM_HINT_ET0: __prefetch_by_load(p, 1, 3); break; case SIMDE_MM_HINT_ET1: __prefetch_by_load(p, 1, 2); break; case SIMDE_MM_HINT_ET2: __prefetch_by_load(p, 0, 1); break; } #elif HEDLEY_MSVC_VERSION (void) i; (void) p; #endif } #if defined(SIMDE_X86_SSE_NATIVE) #if defined(__clang__) && !SIMDE_DETECT_CLANG_VERSION_CHECK(10,0,0) /* https://reviews.llvm.org/D71718 */ #define simde_mm_prefetch(p, i) \ (__extension__({ \ HEDLEY_DIAGNOSTIC_PUSH \ HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ _mm_prefetch((p), (i)); \ HEDLEY_DIAGNOSTIC_POP \ })) #else #define simde_mm_prefetch(p, i) _mm_prefetch(p, i) #endif #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) #define _mm_prefetch(p, i) simde_mm_prefetch(p, i) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_negate_ps(simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return simde_mm_xor_ps(a, _mm_set1_ps(SIMDE_FLOAT32_C(-0.0))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vnegq_f32(a_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_neg(a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) r_.altivec_f32 = vec_neg(a_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) const v4f32 f32 = {0.0f, 0.0f, 0.0f, 0.0f}; r_.lsx_f32 = __lsx_vfsub_s(f32, a_.lsx_f32); #elif defined(SIMDE_VECTOR_NEGATE) r_.f32 = -a_.f32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = -a_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_rcp_ps (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_rcp_ps(a); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x4_t recip = vrecpeq_f32(a_.neon_f32); #if SIMDE_ACCURACY_PREFERENCE > 0 for (int i = 0; i < SIMDE_ACCURACY_PREFERENCE ; ++i) { recip = vmulq_f32(recip, vrecpsq_f32(recip, a_.neon_f32)); } #endif r_.neon_f32 = recip; #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_div(simde_mm_set1_ps(1.0f), a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_re(a_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfrecip_s(a_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.f32 = 1.0f / a_.f32; #elif defined(SIMDE_IEEE754_STORAGE) /* https://stackoverflow.com/questions/12227126/division-as-multiply-and-lut-fast-float-division-reciprocal/12228234#12228234 */ SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { int32_t ix; simde_float32 fx = a_.f32[i]; simde_memcpy(&ix, &fx, sizeof(ix)); int32_t x = INT32_C(0x7EF311C3) - ix; simde_float32 temp; simde_memcpy(&temp, &x, sizeof(temp)); r_.f32[i] = temp * (SIMDE_FLOAT32_C(2.0) - temp * fx); } #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = 1.0f / a_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_rcp_ps(a) simde_mm_rcp_ps((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_rcp_ss (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_rcp_ss(a); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_rcp_ps(a)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_rcp_ps(simde_x_mm_broadcastlow_ps(a))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); r_.f32[0] = 1.0f / a_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_rcp_ss(a) simde_mm_rcp_ss((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_rsqrt_ps (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_rsqrt_ps(a); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vrsqrteq_f32(a_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_rsqrte(a_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfrsqrt_s(a_.lsx_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_div(simde_mm_set1_ps(1.0f), wasm_f32x4_sqrt(a_.wasm_v128)); #elif defined(SIMDE_IEEE754_STORAGE) /* https://basesandframes.files.wordpress.com/2020/04/even_faster_math_functions_green_2020.pdf Pages 100 - 103 */ SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { #if SIMDE_ACCURACY_PREFERENCE <= 0 r_.i32[i] = INT32_C(0x5F37624F) - (a_.i32[i] >> 1); #else simde_float32 x = a_.f32[i]; simde_float32 xhalf = SIMDE_FLOAT32_C(0.5) * x; int32_t ix; simde_memcpy(&ix, &x, sizeof(ix)); #if SIMDE_ACCURACY_PREFERENCE == 1 ix = INT32_C(0x5F375A82) - (ix >> 1); #else ix = INT32_C(0x5F37599E) - (ix >> 1); #endif simde_memcpy(&x, &ix, sizeof(x)); #if SIMDE_ACCURACY_PREFERENCE >= 2 x = x * (SIMDE_FLOAT32_C(1.5008909) - xhalf * x * x); #endif x = x * (SIMDE_FLOAT32_C(1.5008909) - xhalf * x * x); r_.f32[i] = x; #endif } #elif defined(simde_math_sqrtf) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = 1.0f / simde_math_sqrtf(a_.f32[i]); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_rsqrt_ps(a) simde_mm_rsqrt_ps((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_rsqrt_ss (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_rsqrt_ss(a); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_rsqrt_ps(a)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_rsqrt_ps(simde_x_mm_broadcastlow_ps(a))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsetq_lane_f32(vgetq_lane_f32(simde_mm_rsqrt_ps(a).neon_f32, 0), a_.neon_f32, 0); #elif defined(SIMDE_IEEE754_STORAGE) { #if SIMDE_ACCURACY_PREFERENCE <= 0 r_.i32[0] = INT32_C(0x5F37624F) - (a_.i32[0] >> 1); #else simde_float32 x = a_.f32[0]; simde_float32 xhalf = SIMDE_FLOAT32_C(0.5) * x; int32_t ix; simde_memcpy(&ix, &x, sizeof(ix)); #if SIMDE_ACCURACY_PREFERENCE == 1 ix = INT32_C(0x5F375A82) - (ix >> 1); #else ix = INT32_C(0x5F37599E) - (ix >> 1); #endif simde_memcpy(&x, &ix, sizeof(x)); #if SIMDE_ACCURACY_PREFERENCE >= 2 x = x * (SIMDE_FLOAT32_C(1.5008909) - xhalf * x * x); #endif x = x * (SIMDE_FLOAT32_C(1.5008909) - xhalf * x * x); r_.f32[0] = x; #endif } r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #elif defined(simde_math_sqrtf) r_.f32[0] = 1.0f / simde_math_sqrtf(a_.f32[0]); r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_rsqrt_ss(a) simde_mm_rsqrt_ss((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sad_pu8 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_sad_pu8(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint64x1_t t = vpaddl_u32(vpaddl_u16(vpaddl_u8(vabd_u8(a_.neon_u8, b_.neon_u8)))); r_.neon_u16 = vset_lane_u16(HEDLEY_STATIC_CAST(uint64_t, vget_lane_u64(t, 0)), vdup_n_u16(0), 0); #else uint16_t sum = 0; SIMDE_VECTORIZE_REDUCTION(+:sum) for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { sum += HEDLEY_STATIC_CAST(uint8_t, simde_math_abs(a_.u8[i] - b_.u8[i])); } r_.i16[0] = HEDLEY_STATIC_CAST(int16_t, sum); r_.i16[1] = 0; r_.i16[2] = 0; r_.i16[3] = 0; #endif return simde__m64_from_private(r_); #endif } #define simde_m_psadbw(a, b) simde_mm_sad_pu8(a, b) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sad_pu8(a, b) simde_mm_sad_pu8(a, b) # define _m_psadbw(a, b) simde_mm_sad_pu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_set_ss (simde_float32 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_set_ss(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vsetq_lane_f32(a, vdupq_n_f32(SIMDE_FLOAT32_C(0.0)), 0); #else return simde_mm_set_ps(SIMDE_FLOAT32_C(0.0), SIMDE_FLOAT32_C(0.0), SIMDE_FLOAT32_C(0.0), a); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_set_ss(a) simde_mm_set_ss(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_setr_ps (simde_float32 e3, simde_float32 e2, simde_float32 e1, simde_float32 e0) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_setr_ps(e3, e2, e1, e0); #else return simde_mm_set_ps(e0, e1, e2, e3); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_setr_ps(e3, e2, e1, e0) simde_mm_setr_ps(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_setzero_ps (void) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_setzero_ps(); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vdupq_n_f32(SIMDE_FLOAT32_C(0.0)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) return vec_splats(SIMDE_FLOAT32_C(0.0)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f32x4_const(0.f, 0.f, 0.f, 0.f); #else simde__m128 r; simde_memset(&r, 0, sizeof(r)); return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_setzero_ps() simde_mm_setzero_ps() #endif #if defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_undefined_ps (void) { simde__m128_private r_; #if defined(SIMDE_HAVE_UNDEFINED128) r_.n = _mm_undefined_ps(); #elif !defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) r_ = simde__m128_to_private(simde_mm_setzero_ps()); #endif return simde__m128_from_private(r_); } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_undefined_ps() simde_mm_undefined_ps() #endif #if defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) HEDLEY_DIAGNOSTIC_POP #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_x_mm_setone_ps (void) { simde__m128 t = simde_mm_setzero_ps(); return simde_mm_cmpeq_ps(t, t); } SIMDE_FUNCTION_ATTRIBUTES void simde_mm_sfence (void) { /* TODO: Use Hedley. */ #if defined(SIMDE_X86_SSE_NATIVE) _mm_sfence(); #elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) __atomic_thread_fence(__ATOMIC_SEQ_CST); #elif !defined(__INTEL_COMPILER) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_ATOMICS__) #if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 9) __atomic_thread_fence(__ATOMIC_SEQ_CST); #else atomic_thread_fence(memory_order_seq_cst); #endif #elif defined(_MSC_VER) MemoryBarrier(); #elif HEDLEY_HAS_EXTENSION(c_atomic) __c11_atomic_thread_fence(__ATOMIC_SEQ_CST); #elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) __sync_synchronize(); #elif defined(_OPENMP) #pragma omp critical(simde_mm_sfence_) { } #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sfence() simde_mm_sfence() #endif #define SIMDE_MM_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w)) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _MM_SHUFFLE(z, y, x, w) SIMDE_MM_SHUFFLE(z, y, x, w) #endif #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) # define simde_mm_shuffle_pi16(a, imm8) _mm_shuffle_pi16(a, imm8) #elif defined(SIMDE_SHUFFLE_VECTOR_) # define simde_mm_shuffle_pi16(a, imm8) (__extension__ ({ \ const simde__m64_private simde_tmp_a_ = simde__m64_to_private(a); \ simde__m64_from_private((simde__m64_private) { .i16 = \ SIMDE_SHUFFLE_VECTOR_(16, 8, \ (simde_tmp_a_).i16, \ (simde_tmp_a_).i16, \ (((imm8) ) & 3), \ (((imm8) >> 2) & 3), \ (((imm8) >> 4) & 3), \ (((imm8) >> 6) & 3)) }); })) #else SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_shuffle_pi16 (simde__m64 a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m64_private r_; simde__m64_private a_ = simde__m64_to_private(a); for (size_t i = 0 ; i < sizeof(r_.i16) / sizeof(r_.i16[0]) ; i++) { r_.i16[i] = a_.i16[(imm8 >> (i * 2)) & 3]; } HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wconditional-uninitialized") # pragma clang diagnostic ignored "-Wconditional-uninitialized" #endif return simde__m64_from_private(r_); HEDLEY_DIAGNOSTIC_POP } #endif #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) # define simde_m_pshufw(a, imm8) _m_pshufw(a, imm8) #else # define simde_m_pshufw(a, imm8) simde_mm_shuffle_pi16(a, imm8) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_shuffle_pi16(a, imm8) simde_mm_shuffle_pi16(a, imm8) # define _m_pshufw(a, imm8) simde_mm_shuffle_pi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_shuffle_ps (simde__m128 a, simde__m128 b, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.f32[0] = a_.f32[(imm8 >> 0) & 3]; r_.f32[1] = a_.f32[(imm8 >> 2) & 3]; r_.f32[2] = b_.f32[(imm8 >> 4) & 3]; r_.f32[3] = b_.f32[(imm8 >> 6) & 3]; return simde__m128_from_private(r_); } #if defined(SIMDE_X86_SSE_NATIVE) && !defined(__PGI) # define simde_mm_shuffle_ps(a, b, imm8) _mm_shuffle_ps(a, b, imm8) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_shuffle_ps(a, b, imm8) (__extension__ ({ \ simde__m128_from_private((simde__m128_private) { .wasm_v128 = \ wasm_i32x4_shuffle( \ simde__m128_to_private(a).wasm_v128, \ simde__m128_to_private(b).wasm_v128, \ (((imm8) ) & 3), \ (((imm8) >> 2) & 3), \ (((imm8) >> 4) & 3) + 4, \ (((imm8) >> 6) & 3) + 4) }); })) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_STATEMENT_EXPR_) #define simde_mm_shuffle_ps(a, b, imm8) \ (__extension__({ \ float32x4_t simde_mm_shuffle_ps_a_ = simde__m128_to_neon_f32(a); \ float32x4_t simde_mm_shuffle_ps_b_ = simde__m128_to_neon_f32(b); \ float32x4_t simde_mm_shuffle_ps_r_; \ \ simde_mm_shuffle_ps_r_ = vmovq_n_f32(vgetq_lane_f32(simde_mm_shuffle_ps_a_, (imm8) & (0x3))); \ simde_mm_shuffle_ps_r_ = vsetq_lane_f32(vgetq_lane_f32(simde_mm_shuffle_ps_a_, ((imm8) >> 2) & 0x3), simde_mm_shuffle_ps_r_, 1); \ simde_mm_shuffle_ps_r_ = vsetq_lane_f32(vgetq_lane_f32(simde_mm_shuffle_ps_b_, ((imm8) >> 4) & 0x3), simde_mm_shuffle_ps_r_, 2); \ vsetq_lane_f32(vgetq_lane_f32(simde_mm_shuffle_ps_b_, ((imm8) >> 6) & 0x3), simde_mm_shuffle_ps_r_, 3); \ })) #elif defined(SIMDE_SHUFFLE_VECTOR_) #define simde_mm_shuffle_ps(a, b, imm8) (__extension__ ({ \ simde__m128_from_private((simde__m128_private) { .f32 = \ SIMDE_SHUFFLE_VECTOR_(32, 16, \ simde__m128_to_private(a).f32, \ simde__m128_to_private(b).f32, \ (((imm8) ) & 3), \ (((imm8) >> 2) & 3), \ (((imm8) >> 4) & 3) + 4, \ (((imm8) >> 6) & 3) + 4) }); })) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_shuffle_ps(a, b, imm8) simde_mm_shuffle_ps((a), (b), imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_sqrt_ps (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_sqrt_ps(a); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vsqrtq_f32(a_.neon_f32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x4_t est = vrsqrteq_f32(a_.neon_f32); for (int i = 0 ; i <= SIMDE_ACCURACY_PREFERENCE ; i++) { est = vmulq_f32(vrsqrtsq_f32(vmulq_f32(a_.neon_f32, est), est), est); } r_.neon_f32 = vmulq_f32(a_.neon_f32, est); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_sqrt(a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_14_NATIVE) r_.altivec_f32 = vec_sqrt(a_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfsqrt_s(a_.lsx_f32); #elif defined(simde_math_sqrt) SIMDE_VECTORIZE for (size_t i = 0 ; i < sizeof(r_.f32) / sizeof(r_.f32[0]) ; i++) { r_.f32[i] = simde_math_sqrtf(a_.f32[i]); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sqrt_ps(a) simde_mm_sqrt_ps((a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_sqrt_ss (simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_sqrt_ss(a); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_sqrt_ps(a)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_sqrt_ps(simde_x_mm_broadcastlow_ps(a))); #else simde__m128_private r_, a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32_t value = vgetq_lane_f32(simde__m128_to_private(simde_mm_sqrt_ps(a)).neon_f32, 0); r_.neon_f32 = vsetq_lane_f32(value, a_.neon_f32, 0); #elif defined(simde_math_sqrtf) r_.f32[0] = simde_math_sqrtf(a_.f32[0]); r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; #else HEDLEY_UNREACHABLE(); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sqrt_ss(a) simde_mm_sqrt_ss((a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store_ps (simde_float32 mem_addr[4], simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_store_ps(mem_addr, a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_f32(mem_addr, a_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) vec_st(a_.altivec_f32, 0, mem_addr); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store(mem_addr, a_.wasm_v128); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) __lsx_vst(a_.lsx_f32, mem_addr, 0); #else simde_memcpy(mem_addr, &a_, sizeof(a)); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_store_ps(mem_addr, a) simde_mm_store_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store1_ps (simde_float32 mem_addr[4], simde__m128 a) { simde_float32* mem_addr_ = SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128); #if defined(SIMDE_X86_SSE_NATIVE) _mm_store_ps1(mem_addr_, a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_f32(mem_addr_, vdupq_lane_f32(vget_low_f32(a_.neon_f32), 0)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store(mem_addr_, wasm_i32x4_shuffle(a_.wasm_v128, a_.wasm_v128, 0, 0, 0, 0)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) vec_st(vec_splat(a_.altivec_f32, 0), 0, mem_addr_); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) __lsx_vst(__lsx_vreplvei_w(a_.lsx_f32, 0), mem_addr_, 0); #elif defined(SIMDE_SHUFFLE_VECTOR_) simde__m128_private tmp_; tmp_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, a_.f32, 0, 0, 0, 0); simde_mm_store_ps(mem_addr_, tmp_.f32); #else SIMDE_VECTORIZE_ALIGNED(mem_addr_:16) for (size_t i = 0 ; i < sizeof(a_.f32) / sizeof(a_.f32[0]) ; i++) { mem_addr_[i] = a_.f32[0]; } #endif #endif } #define simde_mm_store_ps1(mem_addr, a) simde_mm_store1_ps(mem_addr, a) #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_store_ps1(mem_addr, a) simde_mm_store1_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) # define _mm_store1_ps(mem_addr, a) simde_mm_store1_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store_ss (simde_float32* mem_addr, simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_store_ss(mem_addr, a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_lane_f32(mem_addr, a_.neon_f32, 0); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) __lsx_vstelm_w(a_.lsx_f32, mem_addr, 0, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store32_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), a_.wasm_v128, 0); #else *mem_addr = a_.f32[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_store_ss(mem_addr, a) simde_mm_store_ss(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeh_pi (simde__m64* mem_addr, simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_storeh_pi(HEDLEY_REINTERPRET_CAST(__m64*, mem_addr), a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1_f32(HEDLEY_REINTERPRET_CAST(float32_t*, mem_addr), vget_high_f32(a_.neon_f32)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store64_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), a_.wasm_v128, 1); #else simde_memcpy(mem_addr, &(a_.m64[1]), sizeof(a_.m64[1])); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_storeh_pi(mem_addr, a) simde_mm_storeh_pi(mem_addr, (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storel_pi (simde__m64* mem_addr, simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_storel_pi(HEDLEY_REINTERPRET_CAST(__m64*, mem_addr), a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) simde__m128_private a_ = simde__m128_to_private(a); wasm_v128_store64_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), a_.wasm_v128, 0); #else simde__m64_private* dest_ = HEDLEY_REINTERPRET_CAST(simde__m64_private*, mem_addr); simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) dest_->neon_f32 = vget_low_f32(a_.neon_f32); #else dest_->f32[0] = a_.f32[0]; dest_->f32[1] = a_.f32[1]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_storel_pi(mem_addr, a) simde_mm_storel_pi(mem_addr, (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storer_ps (simde_float32 mem_addr[4], simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_storer_ps(mem_addr, a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) vec_st(vec_reve(a_.altivec_f32), 0, mem_addr); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x4_t tmp = vrev64q_f32(a_.neon_f32); vst1q_f32(mem_addr, vextq_f32(tmp, tmp, 2)); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) __lsx_vst(__lsx_vshuf4i_w(a_.lsx_f32, 0x1b), mem_addr, 0); #elif defined(SIMDE_SHUFFLE_VECTOR_) a_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, a_.f32, 3, 2, 1, 0); simde_mm_store_ps(mem_addr, simde__m128_from_private(a_)); #else SIMDE_VECTORIZE_ALIGNED(mem_addr:16) for (size_t i = 0 ; i < sizeof(a_.f32) / sizeof(a_.f32[0]) ; i++) { mem_addr[i] = a_.f32[((sizeof(a_.f32) / sizeof(a_.f32[0])) - 1) - i]; } #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_storer_ps(mem_addr, a) simde_mm_storer_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_ps (simde_float32 mem_addr[4], simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_storeu_ps(mem_addr, a); #else simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_f32(mem_addr, a_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) vec_vsx_st(a_.altivec_f32, 0, mem_addr); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) __lsx_vst(a_.lsx_f32, mem_addr, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store(mem_addr, a_.wasm_v128); #else simde_memcpy(mem_addr, &a_, sizeof(a_)); #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_storeu_ps(mem_addr, a) simde_mm_storeu_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_sub_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_sub_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vsubq_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_sub(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_sub(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_f32 = __lsx_vfsub_s(a_.lsx_f32, b_.lsx_f32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f32 = a_.f32 - b_.f32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = a_.f32[i] - b_.f32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sub_ps(a, b) simde_mm_sub_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_sub_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_sub_ss(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_ss(a, simde_mm_sub_ps(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_ss(a, simde_mm_sub_ps(simde_x_mm_broadcastlow_ps(a), simde_x_mm_broadcastlow_ps(b))); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); r_.f32[0] = a_.f32[0] - b_.f32[0]; r_.f32[1] = a_.f32[1]; r_.f32[2] = a_.f32[2]; r_.f32[3] = a_.f32[3]; return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_sub_ss(a, b) simde_mm_sub_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomieq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomieq_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_eq_b = vceqq_f32(a_.neon_f32, b_.neon_f32); r = !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_eq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) == wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] == b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] == b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomieq_ss(a, b) simde_mm_ucomieq_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomige_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomige_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_ge_b = vcgeq_f32(a_.neon_f32, b_.neon_f32); r = !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_ge_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) >= wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] >= b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] >= b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomige_ss(a, b) simde_mm_ucomige_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomigt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomigt_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_gt_b = vcgtq_f32(a_.neon_f32, b_.neon_f32); r = !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_gt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) > wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] > b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] > b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomigt_ss(a, b) simde_mm_ucomigt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomile_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomile_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_le_b = vcleq_f32(a_.neon_f32, b_.neon_f32); r = !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_le_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) <= wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] <= b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] <= b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomile_ss(a, b) simde_mm_ucomile_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomilt_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomilt_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); uint32x4_t a_lt_b = vcltq_f32(a_.neon_f32, b_.neon_f32); r = !!(vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_lt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) < wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] < b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] < b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomilt_ss(a, b) simde_mm_ucomilt_ss((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomineq_ss (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_ucomineq_ss(a, b); #else simde__m128_private a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x4_t a_not_nan = vceqq_f32(a_.neon_f32, a_.neon_f32); uint32x4_t b_not_nan = vceqq_f32(b_.neon_f32, b_.neon_f32); uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); uint32x4_t a_neq_b = vmvnq_u32(vceqq_f32(a_.neon_f32, b_.neon_f32)); r = !!(vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_neq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = wasm_f32x4_extract_lane(a_.wasm_v128, 0) != wasm_f32x4_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f32[0] != b_.f32[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f32[0] != b_.f32[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_ucomineq_ss(a, b) simde_mm_ucomineq_ss((a), (b)) #endif #if defined(SIMDE_X86_SSE_NATIVE) # if defined(__has_builtin) # if __has_builtin(__builtin_ia32_undef128) # define SIMDE_HAVE_UNDEFINED128 # endif # elif !defined(__PGI) && !defined(SIMDE_BUG_GCC_REV_208793) && !defined(_MSC_VER) # define SIMDE_HAVE_UNDEFINED128 # endif #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_unpackhi_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_unpackhi_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vzip2q_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x2_t a1 = vget_high_f32(a_.neon_f32); float32x2_t b1 = vget_high_f32(b_.neon_f32); float32x2x2_t result = vzip_f32(a1, b1); r_.neon_f32 = vcombine_f32(result.val[0], result.val[1]); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vilvh_w(b_.lsx_i64, a_.lsx_i64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shuffle(a_.wasm_v128, b_.wasm_v128, 2, 6, 3, 7); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, b_.f32, 2, 6, 3, 7); #else r_.f32[0] = a_.f32[2]; r_.f32[1] = b_.f32[2]; r_.f32[2] = a_.f32[3]; r_.f32[3] = b_.f32[3]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_unpackhi_ps(a, b) simde_mm_unpackhi_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_unpacklo_ps (simde__m128 a, simde__m128 b) { #if defined(SIMDE_X86_SSE_NATIVE) return _mm_unpacklo_ps(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a), b_ = simde__m128_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vzip1q_f32(a_.neon_f32, b_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_f32 = vec_mergeh(a_.altivec_f32, b_.altivec_f32); #elif defined(SIMDE_LOONGARCH_LSX_NATIVE) r_.lsx_i64 = __lsx_vilvl_w(b_.lsx_i64, a_.lsx_i64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 4, 1, 5); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) float32x2_t a1 = vget_low_f32(a_.neon_f32); float32x2_t b1 = vget_low_f32(b_.neon_f32); float32x2x2_t result = vzip_f32(a1, b1); r_.neon_f32 = vcombine_f32(result.val[0], result.val[1]); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.f32, b_.f32, 0, 4, 1, 5); #else r_.f32[0] = a_.f32[0]; r_.f32[1] = b_.f32[0]; r_.f32[2] = a_.f32[1]; r_.f32[3] = b_.f32[1]; #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_unpacklo_ps(a, b) simde_mm_unpacklo_ps((a), (b)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_pi (simde__m64* mem_addr, simde__m64 a) { #if defined(SIMDE_X86_SSE_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) _mm_stream_pi(HEDLEY_REINTERPRET_CAST(__m64*, mem_addr), a); #else simde__m64_private* dest = HEDLEY_REINTERPRET_CAST(simde__m64_private*, mem_addr), a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) dest->i64[0] = vget_lane_s64(a_.neon_i64, 0); #else dest->i64[0] = a_.i64[0]; #endif #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_stream_pi(mem_addr, a) simde_mm_stream_pi(mem_addr, (a)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_ps (simde_float32 mem_addr[4], simde__m128 a) { #if defined(SIMDE_X86_SSE_NATIVE) _mm_stream_ps(mem_addr, a); #elif HEDLEY_HAS_BUILTIN(__builtin_nontemporal_store) && defined(SIMDE_VECTOR_SUBSCRIPT_OPS) simde__m128_private a_ = simde__m128_to_private(a); __builtin_nontemporal_store(a_.f32, SIMDE_ALIGN_CAST(__typeof__(a_.f32)*, mem_addr)); #else simde_mm_store_ps(mem_addr, a); #endif } #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _mm_stream_ps(mem_addr, a) simde_mm_stream_ps(SIMDE_CHECKED_REINTERPRET_CAST(float*, simde_float32*, mem_addr), (a)) #endif #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_ARM_NEON_A64V8_NATIVE) #define SIMDE_MM_TRANSPOSE4_PS(row0, row1, row2, row3) \ do { \ float32x4x2_t SIMDE_MM_TRANSPOSE4_PS_ROW01 = vtrnq_f32(row0, row1); \ float32x4x2_t SIMDE_MM_TRANSPOSE4_PS_ROW23 = vtrnq_f32(row2, row3); \ row0 = vcombine_f32(vget_low_f32(SIMDE_MM_TRANSPOSE4_PS_ROW01.val[0]), \ vget_low_f32(SIMDE_MM_TRANSPOSE4_PS_ROW23.val[0])); \ row1 = vcombine_f32(vget_low_f32(SIMDE_MM_TRANSPOSE4_PS_ROW01.val[1]), \ vget_low_f32(SIMDE_MM_TRANSPOSE4_PS_ROW23.val[1])); \ row2 = vcombine_f32(vget_high_f32(SIMDE_MM_TRANSPOSE4_PS_ROW01.val[0]), \ vget_high_f32(SIMDE_MM_TRANSPOSE4_PS_ROW23.val[0])); \ row3 = vcombine_f32(vget_high_f32(SIMDE_MM_TRANSPOSE4_PS_ROW01.val[1]), \ vget_high_f32(SIMDE_MM_TRANSPOSE4_PS_ROW23.val[1])); \ } while (0) #else #define SIMDE_MM_TRANSPOSE4_PS(row0, row1, row2, row3) \ do { \ simde__m128 SIMDE_MM_TRANSPOSE4_PS_tmp3, SIMDE_MM_TRANSPOSE4_PS_tmp2, SIMDE_MM_TRANSPOSE4_PS_tmp1, SIMDE_MM_TRANSPOSE4_PS_tmp0; \ SIMDE_MM_TRANSPOSE4_PS_tmp0 = simde_mm_unpacklo_ps((row0), (row1)); \ SIMDE_MM_TRANSPOSE4_PS_tmp2 = simde_mm_unpacklo_ps((row2), (row3)); \ SIMDE_MM_TRANSPOSE4_PS_tmp1 = simde_mm_unpackhi_ps((row0), (row1)); \ SIMDE_MM_TRANSPOSE4_PS_tmp3 = simde_mm_unpackhi_ps((row2), (row3)); \ row0 = simde_mm_movelh_ps(SIMDE_MM_TRANSPOSE4_PS_tmp0, SIMDE_MM_TRANSPOSE4_PS_tmp2); \ row1 = simde_mm_movehl_ps(SIMDE_MM_TRANSPOSE4_PS_tmp2, SIMDE_MM_TRANSPOSE4_PS_tmp0); \ row2 = simde_mm_movelh_ps(SIMDE_MM_TRANSPOSE4_PS_tmp1, SIMDE_MM_TRANSPOSE4_PS_tmp3); \ row3 = simde_mm_movehl_ps(SIMDE_MM_TRANSPOSE4_PS_tmp3, SIMDE_MM_TRANSPOSE4_PS_tmp1); \ } while (0) #endif #if defined(SIMDE_X86_SSE_ENABLE_NATIVE_ALIASES) # define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) SIMDE_MM_TRANSPOSE4_PS(row0, row1, row2, row3) #endif SIMDE_END_DECLS_ HEDLEY_DIAGNOSTIC_POP #endif /* !defined(SIMDE_X86_SSE_H) */ /* :: End x86/sse.h :: */ HEDLEY_DIAGNOSTIC_PUSH SIMDE_DISABLE_UNWANTED_DIAGNOSTICS SIMDE_BEGIN_DECLS_ typedef union { #if defined(SIMDE_VECTOR_SUBSCRIPT) SIMDE_ALIGN_TO_16 int8_t i8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int16_t i16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int32_t i32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int64_t i64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint8_t u8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint16_t u16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint32_t u32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint64_t u64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #if defined(SIMDE_HAVE_INT128_) SIMDE_ALIGN_TO_16 simde_int128 i128 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 simde_uint128 u128 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #endif SIMDE_ALIGN_TO_16 simde_float32 f32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 simde_float64 f64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int_fast32_t i32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint_fast32_t u32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #else SIMDE_ALIGN_TO_16 int8_t i8[16]; SIMDE_ALIGN_TO_16 int16_t i16[8]; SIMDE_ALIGN_TO_16 int32_t i32[4]; SIMDE_ALIGN_TO_16 int64_t i64[2]; SIMDE_ALIGN_TO_16 uint8_t u8[16]; SIMDE_ALIGN_TO_16 uint16_t u16[8]; SIMDE_ALIGN_TO_16 uint32_t u32[4]; SIMDE_ALIGN_TO_16 uint64_t u64[2]; #if defined(SIMDE_HAVE_INT128_) SIMDE_ALIGN_TO_16 simde_int128 i128[1]; SIMDE_ALIGN_TO_16 simde_uint128 u128[1]; #endif SIMDE_ALIGN_TO_16 simde_float32 f32[4]; SIMDE_ALIGN_TO_16 simde_float64 f64[2]; SIMDE_ALIGN_TO_16 int_fast32_t i32f[16 / sizeof(int_fast32_t)]; SIMDE_ALIGN_TO_16 uint_fast32_t u32f[16 / sizeof(uint_fast32_t)]; #endif SIMDE_ALIGN_TO_16 simde__m64_private m64_private[2]; SIMDE_ALIGN_TO_16 simde__m64 m64[2]; #if defined(SIMDE_X86_SSE2_NATIVE) SIMDE_ALIGN_TO_16 __m128i n; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_TO_16 int8x16_t neon_i8; SIMDE_ALIGN_TO_16 int16x8_t neon_i16; SIMDE_ALIGN_TO_16 int32x4_t neon_i32; SIMDE_ALIGN_TO_16 int64x2_t neon_i64; SIMDE_ALIGN_TO_16 uint8x16_t neon_u8; SIMDE_ALIGN_TO_16 uint16x8_t neon_u16; SIMDE_ALIGN_TO_16 uint32x4_t neon_u32; SIMDE_ALIGN_TO_16 uint64x2_t neon_u64; #if defined(__ARM_FP16_FORMAT_IEEE) SIMDE_ALIGN_TO_16 float16x8_t neon_f16; #endif SIMDE_ALIGN_TO_16 float32x4_t neon_f32; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_ALIGN_TO_16 float64x2_t neon_f64; #endif #elif defined(SIMDE_MIPS_MSA_NATIVE) v16i8 msa_i8; v8i16 msa_i16; v4i32 msa_i32; v2i64 msa_i64; v16u8 msa_u8; v8u16 msa_u16; v4u32 msa_u32; v2u64 msa_u64; #elif defined(SIMDE_WASM_SIMD128_NATIVE) SIMDE_ALIGN_TO_16 v128_t wasm_v128; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed char) altivec_i8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed short) altivec_i16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed int) altivec_i32; #if defined(__UINT_FAST32_TYPE__) && (defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(__INT_FAST32_TYPE__) altivec_i32f; #else SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed int) altivec_i32f; #endif SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) altivec_u8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned short) altivec_u16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) altivec_u32; #if defined(__UINT_FAST32_TYPE__) && (defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(__UINT_FAST32_TYPE__) altivec_u32f; #else SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) altivec_u32f; #endif SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(float) altivec_f32; #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed long long) altivec_i64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long) altivec_u64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(double) altivec_f64; #endif #endif } simde__m128i_private; typedef union { #if defined(SIMDE_VECTOR_SUBSCRIPT) SIMDE_ALIGN_TO_16 int8_t i8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int16_t i16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int32_t i32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int64_t i64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint8_t u8 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint16_t u16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint32_t u32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint64_t u64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 simde_float32 f32 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 simde_float64 f64 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 int_fast32_t i32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; SIMDE_ALIGN_TO_16 uint_fast32_t u32f SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #else SIMDE_ALIGN_TO_16 int8_t i8[16]; SIMDE_ALIGN_TO_16 int16_t i16[8]; SIMDE_ALIGN_TO_16 int32_t i32[4]; SIMDE_ALIGN_TO_16 int64_t i64[2]; SIMDE_ALIGN_TO_16 uint8_t u8[16]; SIMDE_ALIGN_TO_16 uint16_t u16[8]; SIMDE_ALIGN_TO_16 uint32_t u32[4]; SIMDE_ALIGN_TO_16 uint64_t u64[2]; SIMDE_ALIGN_TO_16 simde_float32 f32[4]; SIMDE_ALIGN_TO_16 simde_float64 f64[2]; SIMDE_ALIGN_TO_16 int_fast32_t i32f[16 / sizeof(int_fast32_t)]; SIMDE_ALIGN_TO_16 uint_fast32_t u32f[16 / sizeof(uint_fast32_t)]; #endif SIMDE_ALIGN_TO_16 simde__m64_private m64_private[2]; SIMDE_ALIGN_TO_16 simde__m64 m64[2]; #if defined(SIMDE_X86_SSE2_NATIVE) SIMDE_ALIGN_TO_16 __m128d n; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_TO_16 int8x16_t neon_i8; SIMDE_ALIGN_TO_16 int16x8_t neon_i16; SIMDE_ALIGN_TO_16 int32x4_t neon_i32; SIMDE_ALIGN_TO_16 int64x2_t neon_i64; SIMDE_ALIGN_TO_16 uint8x16_t neon_u8; SIMDE_ALIGN_TO_16 uint16x8_t neon_u16; SIMDE_ALIGN_TO_16 uint32x4_t neon_u32; SIMDE_ALIGN_TO_16 uint64x2_t neon_u64; SIMDE_ALIGN_TO_16 float32x4_t neon_f32; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_ALIGN_TO_16 float64x2_t neon_f64; #endif #elif defined(SIMDE_MIPS_MSA_NATIVE) v16i8 msa_i8; v8i16 msa_i16; v4i32 msa_i32; v2i64 msa_i64; v16u8 msa_u8; v8u16 msa_u16; v4u32 msa_u32; v2u64 msa_u64; #elif defined(SIMDE_WASM_SIMD128_NATIVE) SIMDE_ALIGN_TO_16 v128_t wasm_v128; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed char) altivec_i8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed short) altivec_i16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed int) altivec_i32; #if defined(__INT_FAST32_TYPE__) && (defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(__INT_FAST32_TYPE__) altivec_i32f; #else SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed int) altivec_i32f; #endif SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) altivec_u8; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned short) altivec_u16; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) altivec_u32; #if defined(__UINT_FAST32_TYPE__) && (defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(__UINT_FAST32_TYPE__) altivec_u32f; #else SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned int) altivec_u32f; #endif SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(float) altivec_f32; #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(signed long long) altivec_i64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long) altivec_u64; SIMDE_ALIGN_TO_16 SIMDE_POWER_ALTIVEC_VECTOR(double) altivec_f64; #endif #endif } simde__m128d_private; #if defined(SIMDE_X86_SSE2_NATIVE) typedef __m128i simde__m128i; typedef __m128d simde__m128d; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) typedef int64x2_t simde__m128i; # if defined(SIMDE_ARM_NEON_A64V8_NATIVE) typedef float64x2_t simde__m128d; # elif defined(SIMDE_VECTOR_SUBSCRIPT) typedef simde_float64 simde__m128d SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; # else typedef simde__m128d_private simde__m128d; # endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) typedef v128_t simde__m128i; typedef v128_t simde__m128d; #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) typedef SIMDE_POWER_ALTIVEC_VECTOR(float) simde__m128i; #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) typedef SIMDE_POWER_ALTIVEC_VECTOR(double) simde__m128d; #else typedef simde__m128d_private simde__m128d; #endif #elif defined(SIMDE_VECTOR_SUBSCRIPT) typedef int64_t simde__m128i SIMDE_ALIGN_TO_16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; typedef simde_float64 simde__m128d SIMDE_ALIGN_TO_16 SIMDE_VECTOR(16) SIMDE_MAY_ALIAS; #else typedef simde__m128i_private simde__m128i; typedef simde__m128d_private simde__m128d; #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) typedef simde__m128i __m128i; typedef simde__m128d __m128d; #endif HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128i), "simde__m128i size incorrect"); HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128i_private), "simde__m128i_private size incorrect"); HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128d), "simde__m128d size incorrect"); HEDLEY_STATIC_ASSERT(16 == sizeof(simde__m128d_private), "simde__m128d_private size incorrect"); #if defined(SIMDE_CHECK_ALIGNMENT) && defined(SIMDE_ALIGN_OF) HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128i) == 16, "simde__m128i is not 16-byte aligned"); HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128i_private) == 16, "simde__m128i_private is not 16-byte aligned"); HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128d) == 16, "simde__m128d is not 16-byte aligned"); HEDLEY_STATIC_ASSERT(SIMDE_ALIGN_OF(simde__m128d_private) == 16, "simde__m128d_private is not 16-byte aligned"); #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde__m128i_from_private(simde__m128i_private v) { simde__m128i r; simde_memcpy(&r, &v, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m128i_private simde__m128i_to_private(simde__m128i v) { simde__m128i_private r; simde_memcpy(&r, &v, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde__m128d_from_private(simde__m128d_private v) { simde__m128d r; simde_memcpy(&r, &v, sizeof(r)); return r; } SIMDE_FUNCTION_ATTRIBUTES simde__m128d_private simde__m128d_to_private(simde__m128d v) { simde__m128d_private r; simde_memcpy(&r, &v, sizeof(r)); return r; } #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, int8x16_t, neon, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, int16x8_t, neon, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, int32x4_t, neon, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, int64x2_t, neon, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, uint8x16_t, neon, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, uint16x8_t, neon, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, uint32x4_t, neon, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, uint64x2_t, neon, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, float32x4_t, neon, f32) #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, float64x2_t, neon, f64) #endif #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(signed char), altivec, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(signed short), altivec, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(signed int), altivec, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(unsigned char), altivec, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(unsigned short), altivec, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(unsigned int), altivec, u32) #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long), altivec, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, SIMDE_POWER_ALTIVEC_VECTOR(signed long long), altivec, i64) #endif #endif /* defined(SIMDE_ARM_NEON_A32V7_NATIVE) */ #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, int8x16_t, neon, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, int16x8_t, neon, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, int32x4_t, neon, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, int64x2_t, neon, i64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, uint8x16_t, neon, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, uint16x8_t, neon, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, uint32x4_t, neon, u32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, uint64x2_t, neon, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, float32x4_t, neon, f32) #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, float64x2_t, neon, f64) #endif #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(signed char), altivec, i8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(signed short), altivec, i16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(signed int), altivec, i32) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(unsigned char), altivec, u8) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(unsigned short), altivec, u16) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(unsigned int), altivec, u32) #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(unsigned long long), altivec, u64) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(signed long long), altivec, i64) #if defined(SIMDE_BUG_GCC_95782) SIMDE_FUNCTION_ATTRIBUTES SIMDE_POWER_ALTIVEC_VECTOR(double) simde__m128d_to_altivec_f64(simde__m128d value) { simde__m128d_private r_ = simde__m128d_to_private(value); return r_.altivec_f64; } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde__m128d_from_altivec_f64(SIMDE_POWER_ALTIVEC_VECTOR(double) value) { simde__m128d_private r_; r_.altivec_f64 = value; return simde__m128d_from_private(r_); } #else SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, SIMDE_POWER_ALTIVEC_VECTOR(double), altivec, f64) #endif #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128d, v128_t, wasm, v128); SIMDE_X86_GENERATE_CONVERSION_FUNCTION(m128i, v128_t, wasm, v128); #endif /* defined(SIMDE_ARM_NEON_A32V7_NATIVE) */ SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_set_pd (simde_float64 e1, simde_float64 e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_pd(e1, e0); #else simde__m128d_private r_; #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_make(e0, e1); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) SIMDE_ALIGN_TO_16 simde_float64 data[2] = { e0, e1 }; r_.neon_f64 = vld1q_f64(data); #else r_.f64[0] = e0; r_.f64[1] = e1; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_pd(e1, e0) simde_mm_set_pd(e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_set1_pd (simde_float64 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set1_pd(a); #else simde__m128d_private r_; #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_splat(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vdupq_n_f64(a); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_splats(HEDLEY_STATIC_CAST(double, a)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.f64[i] = a; } #endif return simde__m128d_from_private(r_); #endif } #define simde_mm_set_pd1(a) simde_mm_set1_pd(a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_pd(a) simde_mm_set1_pd(a) #define _mm_set_pd1(a) simde_mm_set1_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_abs_pd(simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) simde_float64 mask_; uint64_t u64_ = UINT64_C(0x7FFFFFFFFFFFFFFF); simde_memcpy(&mask_, &u64_, sizeof(u64_)); return _mm_and_pd(_mm_set1_pd(mask_), a); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vabsq_f64(a_.neon_f64); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_abs(a_.altivec_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_abs(a_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = simde_math_fabs(a_.f64[i]); } #endif return simde__m128d_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_not_pd(simde__m128d a) { #if defined(SIMDE_X86_AVX512VL_NATIVE) __m128i ai = _mm_castpd_si128(a); return _mm_castsi128_pd(_mm_ternarylogic_epi64(ai, ai, ai, 0x55)); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vmvnq_s32(a_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f64 = vec_nor(a_.altivec_f64, a_.altivec_f64); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_nor(a_.altivec_i32, a_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_not(a_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = ~a_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = ~(a_.i32f[i]); } #endif return simde__m128d_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_select_pd(simde__m128d a, simde__m128d b, simde__m128d mask) { /* This function is for when you want to blend two elements together * according to a mask. It is similar to _mm_blendv_pd, except that * it is undefined whether the blend is based on the highest bit in * each lane (like blendv) or just bitwise operations. This allows * us to implement the function efficiently everywhere. * * Basically, you promise that all the lanes in mask are either 0 or * ~0. */ #if defined(SIMDE_X86_SSE4_1_NATIVE) return _mm_blendv_pd(a, b, mask); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b), mask_ = simde__m128d_to_private(mask); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 ^ ((a_.i64 ^ b_.i64) & mask_.i64); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vbslq_s64(mask_.neon_u64, b_.neon_i64, a_.neon_i64); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] ^ ((a_.i64[i] ^ b_.i64[i]) & mask_.i64[i]); } #endif return simde__m128d_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_add_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vaddq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i8 = vec_add(a_.altivec_i8, b_.altivec_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = a_.i8 + b_.i8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a_.i8[i] + b_.i8[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_epi8(a, b) simde_mm_add_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_add_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vaddq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i16 = vec_add(a_.altivec_i16, b_.altivec_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = a_.i16 + b_.i16; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] + b_.i16[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_epi16(a, b) simde_mm_add_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_add_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vaddq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_add(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 + b_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] + b_.i32[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_epi32(a, b) simde_mm_add_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_add_epi64 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_epi64(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vaddq_s64(a_.neon_i64, b_.neon_i64); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) r_.altivec_i64 = vec_add(a_.altivec_i64, b_.altivec_i64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 + b_.i64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] + b_.i64[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_epi64(a, b) simde_mm_add_epi64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_add_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vaddq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f64 = vec_add(a_.altivec_f64, b_.altivec_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_add(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f64 = a_.f64 + b_.f64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f64[i] + b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_pd(a, b) simde_mm_add_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_move_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_move_sd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsetq_lane_f64(vgetq_lane_f64(b_.neon_f64, 0), a_.neon_f64, 0); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) #if defined(HEDLEY_IBM_VERSION) r_.altivec_f64 = vec_xxpermdi(a_.altivec_f64, b_.altivec_f64, 1); #else r_.altivec_f64 = vec_xxpermdi(b_.altivec_f64, a_.altivec_f64, 1); #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, b_.wasm_v128, 2, 1); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.f64, b_.f64, 2, 1); #else r_.f64[0] = b_.f64[0]; r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_move_sd(a, b) simde_mm_move_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_broadcastlow_pd(simde__m128d a) { /* This function broadcasts the first element in the input vector to * all lanes. It is used to avoid generating spurious exceptions in * *_sd functions since there may be garbage in the upper lanes. */ #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castsi128_pd(_mm_shuffle_epi32(_mm_castpd_si128(a), 0x44)); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vdupq_laneq_f64(a_.neon_f64, 0); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f64 = vec_splat(a_.altivec_f64, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_splat(a_.f64[0]); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.f64, a_.f64, 0, 0); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f64[0]; } #endif return simde__m128d_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_add_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_add_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_add_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_add_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.f64[0] = a_.f64[0] + b_.f64[0]; r_.f64[1] = a_.f64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_sd(a, b) simde_mm_add_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_add_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_add_si64(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vadd_s64(a_.neon_i64, b_.neon_i64); #else r_.i64[0] = a_.i64[0] + b_.i64[0]; #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_add_si64(a, b) simde_mm_add_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_adds_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_adds_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vqaddq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_add_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i8 = vec_adds(a_.altivec_i8, b_.altivec_i8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = simde_math_adds_i8(a_.i8[i], b_.i8[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_adds_epi8(a, b) simde_mm_adds_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_adds_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_adds_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vqaddq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_add_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i16 = vec_adds(a_.altivec_i16, b_.altivec_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = simde_math_adds_i16(a_.i16[i], b_.i16[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_adds_epi16(a, b) simde_mm_adds_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_adds_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_adds_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vqaddq_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_add_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_u8 = vec_adds(a_.altivec_u8, b_.altivec_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = simde_math_adds_u8(a_.u8[i], b_.u8[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_adds_epu8(a, b) simde_mm_adds_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_adds_epu16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_adds_epu16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vqaddq_u16(a_.neon_u16, b_.neon_u16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u16x8_add_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_u16 = vec_adds(a_.altivec_u16, b_.altivec_u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = simde_math_adds_u16(a_.u16[i], b_.u16[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_adds_epu16(a, b) simde_mm_adds_epu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_and_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_and_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vandq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_and(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f64 = vec_and(a_.altivec_f64, b_.altivec_f64); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f & b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] & b_.i32f[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_and_pd(a, b) simde_mm_and_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_and_si128 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_and_si128(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vandq_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_u32f = vec_and(a_.altivec_u32f, b_.altivec_u32f); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_and(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f & b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] & b_.i32f[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_and_si128(a, b) simde_mm_and_si128(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_andnot_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_andnot_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vbicq_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_andnot(b_.wasm_v128, a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_andc(b_.altivec_f64, a_.altivec_f64); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32f = vec_andc(b_.altivec_i32f, a_.altivec_i32f); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = ~a_.i32f & b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u64) / sizeof(r_.u64[0])) ; i++) { r_.u64[i] = ~a_.u64[i] & b_.u64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_andnot_pd(a, b) simde_mm_andnot_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_andnot_si128 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_andnot_si128(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vbicq_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = vec_andc(b_.altivec_i32, a_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_andnot(b_.wasm_v128, a_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = ~a_.i32f & b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = ~(a_.i32f[i]) & b_.i32f[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_andnot_si128(a, b) simde_mm_andnot_si128(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_xor_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_xor_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f ^ b_.i32f; #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_xor(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = veorq_s64(a_.neon_i64, b_.neon_i64); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] ^ b_.i32f[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_xor_pd(a, b) simde_mm_xor_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_avg_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_avg_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vrhaddq_u8(b_.neon_u8, a_.neon_u8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_avgr(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_u8 = vec_avg(a_.altivec_u8, b_.altivec_u8); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_CONVERT_VECTOR_) uint16_t wa SIMDE_VECTOR(32); uint16_t wb SIMDE_VECTOR(32); uint16_t wr SIMDE_VECTOR(32); SIMDE_CONVERT_VECTOR_(wa, a_.u8); SIMDE_CONVERT_VECTOR_(wb, b_.u8); wr = (wa + wb + 1) >> 1; SIMDE_CONVERT_VECTOR_(r_.u8, wr); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] + b_.u8[i] + 1) >> 1; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_avg_epu8(a, b) simde_mm_avg_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_avg_epu16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_avg_epu16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vrhaddq_u16(b_.neon_u16, a_.neon_u16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u16x8_avgr(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_u16 = vec_avg(a_.altivec_u16, b_.altivec_u16); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && defined(SIMDE_CONVERT_VECTOR_) uint32_t wa SIMDE_VECTOR(32); uint32_t wb SIMDE_VECTOR(32); uint32_t wr SIMDE_VECTOR(32); SIMDE_CONVERT_VECTOR_(wa, a_.u16); SIMDE_CONVERT_VECTOR_(wb, b_.u16); wr = (wa + wb + 1) >> 1; SIMDE_CONVERT_VECTOR_(r_.u16, wr); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = (a_.u16[i] + b_.u16[i] + 1) >> 1; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_avg_epu16(a, b) simde_mm_avg_epu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_setzero_si128 (void) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setzero_si128(); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vdupq_n_s32(0); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = vec_splats(HEDLEY_STATIC_CAST(signed int, 0)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_splat(INT32_C(0)); #elif defined(SIMDE_VECTOR_SUBSCRIPT) r_.i32 = __extension__ (__typeof__(r_.i32)) { 0, 0, 0, 0 }; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = 0; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setzero_si128() (simde_mm_setzero_si128()) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_bslli_si128 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); if (HEDLEY_UNLIKELY((imm8 & ~15))) { return simde_mm_setzero_si128(); } #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && defined(SIMDE_ENDIAN_ORDER) r_.altivec_i8 = #if (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE) vec_slo #else /* SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_BIG */ vec_sro #endif (a_.altivec_i8, vec_splats(HEDLEY_STATIC_CAST(unsigned char, imm8 * 8))); #elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = vec_srb(a_.altivec_i8, vec_splats(HEDLEY_STATIC_CAST(unsigned char, (imm8 & 15) << 3))); #elif defined(SIMDE_HAVE_INT128_) && (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE) r_.u128[0] = a_.u128[0] << (imm8 * 8); #else r_ = simde__m128i_to_private(simde_mm_setzero_si128()); for (int i = imm8 ; i < HEDLEY_STATIC_CAST(int, sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a_.i8[i - imm8]; } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) #define simde_mm_bslli_si128(a, imm8) _mm_slli_si128(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(__clang__) #define simde_mm_bslli_si128(a, imm8) \ simde__m128i_from_neon_i8(((imm8) <= 0) ? simde__m128i_to_neon_i8(a) : (((imm8) > 15) ? (vdupq_n_s8(0)) : (vextq_s8(vdupq_n_s8(0), simde__m128i_to_neon_i8(a), 16 - (imm8))))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_bslli_si128(a, imm8) __extension__ ({ \ simde__m128i_from_wasm_v128( \ wasm_i8x16_shuffle(wasm_i32x4_splat(INT32_C(0)), \ simde__m128i_to_wasm_v128((a)), \ ((imm8)&0xF0) ? 0 : 16 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 17 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 18 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 19 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 20 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 21 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 22 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 23 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 24 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 25 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 26 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 27 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 28 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 29 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 30 - ((imm8)&0xF), \ ((imm8)&0xF0) ? 0 : 31 - ((imm8)&0xF))); }) #elif defined(SIMDE_SHUFFLE_VECTOR_) && !defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && !defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) #define simde_mm_bslli_si128(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ const simde__m128i_private simde_tmp_z_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ simde__m128i_private simde_tmp_r_; \ if (HEDLEY_UNLIKELY(imm8 > 15)) { \ simde_tmp_r_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ } else { \ simde_tmp_r_.i8 = \ SIMDE_SHUFFLE_VECTOR_(8, 16, \ simde_tmp_z_.i8, \ (simde_tmp_a_).i8, \ HEDLEY_STATIC_CAST(int8_t, (16 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (17 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (18 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (19 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (20 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (21 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (22 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (23 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (24 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (25 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (26 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (27 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (28 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (29 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (30 - imm8) & 31), \ HEDLEY_STATIC_CAST(int8_t, (31 - imm8) & 31)); \ } \ simde__m128i_from_private(simde_tmp_r_); })) #endif #define simde_mm_slli_si128(a, imm8) simde_mm_bslli_si128(a, imm8) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_bslli_si128(a, imm8) simde_mm_bslli_si128(a, imm8) #define _mm_slli_si128(a, imm8) simde_mm_bslli_si128(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_bsrli_si128 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); if (HEDLEY_UNLIKELY((imm8 & ~15))) { return simde_mm_setzero_si128(); } #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && defined(SIMDE_ENDIAN_ORDER) r_.altivec_i8 = #if (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE) vec_sro #else /* SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_BIG */ vec_slo #endif (a_.altivec_i8, vec_splats(HEDLEY_STATIC_CAST(unsigned char, imm8 * 8))); #elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = vec_slb(a_.altivec_i8, vec_splats(HEDLEY_STATIC_CAST(unsigned char, (imm8 & 15) << 3))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { const int e = HEDLEY_STATIC_CAST(int, i) + imm8; r_.i8[i] = (e < 16) ? a_.i8[e] : 0; } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) #define simde_mm_bsrli_si128(a, imm8) _mm_srli_si128(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(__clang__) #define simde_mm_bsrli_si128(a, imm8) \ simde__m128i_from_neon_i8(((imm8 < 0) || (imm8 > 15)) ? vdupq_n_s8(0) : (vextq_s8(simde__m128i_to_private(a).neon_i8, vdupq_n_s8(0), ((imm8 & 15) != 0) ? imm8 : (imm8 & 15)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_bsrli_si128(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ const simde__m128i_private simde_tmp_z_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ simde__m128i_private simde_tmp_r_ = simde__m128i_to_private(a); \ if (HEDLEY_UNLIKELY(imm8 > 15)) { \ simde_tmp_r_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ } else { \ simde_tmp_r_.wasm_v128 = \ wasm_i8x16_shuffle( \ simde_tmp_z_.wasm_v128, \ simde_tmp_a_.wasm_v128, \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 16) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 17) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 18) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 19) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 20) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 21) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 22) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 23) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 24) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 25) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 26) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 27) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 28) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 29) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 30) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 31) & 31)); \ } \ simde__m128i_from_private(simde_tmp_r_); })) #elif defined(SIMDE_SHUFFLE_VECTOR_) && !defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && !defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) #define simde_mm_bsrli_si128(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ const simde__m128i_private simde_tmp_z_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ simde__m128i_private simde_tmp_r_ = simde__m128i_to_private(a); \ if (HEDLEY_UNLIKELY(imm8 > 15)) { \ simde_tmp_r_ = simde__m128i_to_private(simde_mm_setzero_si128()); \ } else { \ simde_tmp_r_.i8 = \ SIMDE_SHUFFLE_VECTOR_(8, 16, \ simde_tmp_z_.i8, \ (simde_tmp_a_).i8, \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 16) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 17) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 18) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 19) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 20) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 21) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 22) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 23) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 24) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 25) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 26) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 27) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 28) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 29) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 30) & 31), \ HEDLEY_STATIC_CAST(int8_t, (imm8 + 31) & 31)); \ } \ simde__m128i_from_private(simde_tmp_r_); })) #endif #define simde_mm_srli_si128(a, imm8) simde_mm_bsrli_si128((a), (imm8)) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_bsrli_si128(a, imm8) simde_mm_bsrli_si128((a), (imm8)) #define _mm_srli_si128(a, imm8) simde_mm_bsrli_si128((a), (imm8)) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_clflush (void const* p) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_clflush(p); #else (void) p; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_clflush(p) simde_mm_clflush(p) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comieq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comieq_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !!vgetq_lane_u64(vceqq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) == wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] == b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comieq_sd(a, b) simde_mm_comieq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comige_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comige_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !!vgetq_lane_u64(vcgeq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) >= wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] >= b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comige_sd(a, b) simde_mm_comige_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comigt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comigt_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !!vgetq_lane_u64(vcgtq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) > wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] > b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comigt_sd(a, b) simde_mm_comigt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comile_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comile_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !!vgetq_lane_u64(vcleq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) <= wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] <= b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comile_sd(a, b) simde_mm_comile_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comilt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comilt_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !!vgetq_lane_u64(vcltq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) < wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] < b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comilt_sd(a, b) simde_mm_comilt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_comineq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_comineq_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return !vgetq_lane_u64(vceqq_f64(a_.neon_f64, b_.neon_f64), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) != wasm_f64x2_extract_lane(b_.wasm_v128, 0); #else return a_.f64[0] != b_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_comineq_sd(a, b) simde_mm_comineq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_copysign_pd(simde__m128d dest, simde__m128d src) { simde__m128d_private r_, dest_ = simde__m128d_to_private(dest), src_ = simde__m128d_to_private(src); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t sign_pos = vreinterpretq_u64_f64(vdupq_n_f64(-SIMDE_FLOAT64_C(0.0))); #else simde_float64 dbl_nz = -SIMDE_FLOAT64_C(0.0); uint64_t u64_nz; simde_memcpy(&u64_nz, &dbl_nz, sizeof(u64_nz)); uint64x2_t sign_pos = vdupq_n_u64(u64_nz); #endif r_.neon_u64 = vbslq_u64(sign_pos, src_.neon_u64, dest_.neon_u64); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) #if defined(SIMDE_BUG_VEC_CPSGN_REVERSED_ARGS) r_.altivec_f64 = vec_cpsgn(dest_.altivec_f64, src_.altivec_f64); #else r_.altivec_f64 = vec_cpsgn(src_.altivec_f64, dest_.altivec_f64); #endif #elif defined(simde_math_copysign) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = simde_math_copysign(dest_.f64[i], src_.f64[i]); } #else simde__m128d sgnbit = simde_mm_set1_pd(-SIMDE_FLOAT64_C(0.0)); return simde_mm_xor_pd(simde_mm_and_pd(sgnbit, src), simde_mm_andnot_pd(sgnbit, dest)); #endif return simde__m128d_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_xorsign_pd(simde__m128d dest, simde__m128d src) { return simde_mm_xor_pd(simde_mm_and_pd(simde_mm_set1_pd(-0.0), src), dest); } SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_castpd_ps (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castpd_ps(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vreinterpretq_f32_f64(a); #else simde__m128 r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castpd_ps(a) simde_mm_castpd_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_castpd_si128 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castpd_si128(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vreinterpretq_s64_f64(a); #else simde__m128i r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castpd_si128(a) simde_mm_castpd_si128(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_castps_pd (simde__m128 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castps_pd(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vreinterpretq_f64_f32(a); #else simde__m128d r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castps_pd(a) simde_mm_castps_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_castps_si128 (simde__m128 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castps_si128(a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return simde__m128i_from_neon_i32(simde__m128_to_private(a).neon_i32); #else simde__m128i r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castps_si128(a) simde_mm_castps_si128(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_castsi128_pd (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castsi128_pd(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vreinterpretq_f64_s64(a); #else simde__m128d r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castsi128_pd(a) simde_mm_castsi128_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_castsi128_ps (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_castsi128_ps(a); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) return HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(float), a); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return simde__m128_from_neon_i32(simde__m128i_to_private(a).neon_i32); #else simde__m128 r; simde_memcpy(&r, &a, sizeof(a)); return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_castsi128_ps(a) simde_mm_castsi128_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpeq_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpeq_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vceqq_s8(b_.neon_i8, a_.neon_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_eq(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed char), vec_cmpeq(a_.altivec_i8, b_.altivec_i8)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i8), (a_.i8 == b_.i8)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = (a_.i8[i] == b_.i8[i]) ? ~INT8_C(0) : INT8_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpeq_epi8(a, b) simde_mm_cmpeq_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpeq_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpeq_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vceqq_s16(b_.neon_i16, a_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_eq(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed short), vec_cmpeq(a_.altivec_i16, b_.altivec_i16)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = (a_.i16 == b_.i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] == b_.i16[i]) ? ~INT16_C(0) : INT16_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpeq_epi16(a, b) simde_mm_cmpeq_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpeq_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpeq_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vceqq_s32(b_.neon_i32, a_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_eq(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), vec_cmpeq(a_.altivec_i32, b_.altivec_i32)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), a_.i32 == b_.i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = (a_.i32[i] == b_.i32[i]) ? ~INT32_C(0) : INT32_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpeq_epi32(a, b) simde_mm_cmpeq_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpeq_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpeq_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vceqq_f64(b_.neon_f64, a_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_eq(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(double), vec_cmpeq(a_.altivec_f64, b_.altivec_f64)); #elif defined(SIMDE_MIPS_MSA_NATIVE) r_.msa_i32 = __msa_addv_w(a_.msa_i32, b_.msa_i32); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 == b_.f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] == b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpeq_pd(a, b) simde_mm_cmpeq_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpeq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpeq_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpeq_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpeq_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.u64[0] == b_.u64[0]) ? ~UINT64_C(0) : 0; r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpeq_sd(a, b) simde_mm_cmpeq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpneq_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpneq_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u32 = vmvnq_u32(vreinterpretq_u32_u64(vceqq_f64(b_.neon_f64, a_.neon_f64))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_ne(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 != b_.f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] != b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpneq_pd(a, b) simde_mm_cmpneq_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpneq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpneq_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpneq_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpneq_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.f64[0] != b_.f64[0]) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpneq_sd(a, b) simde_mm_cmpneq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmplt_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmplt_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vcltq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed char),vec_cmplt(a_.altivec_i8, b_.altivec_i8)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_lt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i8), (a_.i8 < b_.i8)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = (a_.i8[i] < b_.i8[i]) ? ~INT8_C(0) : INT8_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmplt_epi8(a, b) simde_mm_cmplt_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmplt_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmplt_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vcltq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed short), vec_cmplt(a_.altivec_i16, b_.altivec_i16)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_lt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i16), (a_.i16 < b_.i16)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] < b_.i16[i]) ? ~INT16_C(0) : INT16_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmplt_epi16(a, b) simde_mm_cmplt_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmplt_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmplt_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcltq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), vec_cmplt(a_.altivec_i32, b_.altivec_i32)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_lt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.i32 < b_.i32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = (a_.i32[i] < b_.i32[i]) ? ~INT32_C(0) : INT32_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmplt_epi32(a, b) simde_mm_cmplt_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmplt_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmplt_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vcltq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(double), vec_cmplt(a_.altivec_f64, b_.altivec_f64)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_lt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 < b_.f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] < b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmplt_pd(a, b) simde_mm_cmplt_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmplt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmplt_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmplt_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmplt_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.f64[0] < b_.f64[0]) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmplt_sd(a, b) simde_mm_cmplt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmple_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmple_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 <= b_.f64)); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vcleq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_le(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(double), vec_cmple(a_.altivec_f64, b_.altivec_f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] <= b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmple_pd(a, b) simde_mm_cmple_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmple_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmple_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmple_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmple_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.f64[0] <= b_.f64[0]) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmple_sd(a, b) simde_mm_cmple_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpgt_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpgt_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vcgtq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_gt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed char), vec_cmpgt(a_.altivec_i8, b_.altivec_i8)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i8), (a_.i8 > b_.i8)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = (a_.i8[i] > b_.i8[i]) ? ~INT8_C(0) : INT8_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpgt_epi8(a, b) simde_mm_cmpgt_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpgt_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpgt_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vcgtq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_gt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed short), vec_cmpgt(a_.altivec_i16, b_.altivec_i16)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i16), (a_.i16 > b_.i16)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] > b_.i16[i]) ? ~INT16_C(0) : INT16_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpgt_epi16(a, b) simde_mm_cmpgt_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cmpgt_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpgt_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vcgtq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_gt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), vec_cmpgt(a_.altivec_i32, b_.altivec_i32)); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i32), (a_.i32 > b_.i32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = (a_.i32[i] > b_.i32[i]) ? ~INT32_C(0) : INT32_C(0); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpgt_epi32(a, b) simde_mm_cmpgt_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpgt_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpgt_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 > b_.f64)); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vcgtq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_gt(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(double), vec_cmpgt(a_.altivec_f64, b_.altivec_f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] > b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpgt_pd(a, b) simde_mm_cmpgt_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpgt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_cmpgt_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpgt_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpgt_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.f64[0] > b_.f64[0]) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpgt_sd(a, b) simde_mm_cmpgt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpge_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpge_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.i64), (a_.f64 >= b_.f64)); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_u64 = vcgeq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_ge(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(double), vec_cmpge(a_.altivec_f64, b_.altivec_f64)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (a_.f64[i] >= b_.f64[i]) ? ~UINT64_C(0) : UINT64_C(0); } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpge_pd(a, b) simde_mm_cmpge_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpge_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_cmpge_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpge_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpge_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.u64[0] = (a_.f64[0] >= b_.f64[0]) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpge_sd(a, b) simde_mm_cmpge_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpngt_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpngt_pd(a, b); #else return simde_mm_cmple_pd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpngt_pd(a, b) simde_mm_cmpngt_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpngt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_cmpngt_sd(a, b); #else return simde_mm_cmple_sd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpngt_sd(a, b) simde_mm_cmpngt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnge_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpnge_pd(a, b); #else return simde_mm_cmplt_pd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnge_pd(a, b) simde_mm_cmpnge_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnge_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_cmpnge_sd(a, b); #else return simde_mm_cmplt_sd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnge_sd(a, b) simde_mm_cmpnge_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnlt_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpnlt_pd(a, b); #else return simde_mm_cmpge_pd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnlt_pd(a, b) simde_mm_cmpnlt_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnlt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpnlt_sd(a, b); #else return simde_mm_cmpge_sd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnlt_sd(a, b) simde_mm_cmpnlt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnle_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpnle_pd(a, b); #else return simde_mm_cmpgt_pd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnle_pd(a, b) simde_mm_cmpnle_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpnle_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpnle_sd(a, b); #else return simde_mm_cmpgt_sd(a, b); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpnle_sd(a, b) simde_mm_cmpnle_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpord_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpord_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) /* Note: NEON does not have ordered compare builtin Need to compare a eq a and b eq b to check for NaN Do AND of results to get final */ uint64x2_t ceqaa = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t ceqbb = vceqq_f64(b_.neon_f64, b_.neon_f64); r_.neon_u64 = vandq_u64(ceqaa, ceqbb); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_and(wasm_f64x2_eq(a_.wasm_v128, a_.wasm_v128), wasm_f64x2_eq(b_.wasm_v128, b_.wasm_v128)); #elif defined(simde_math_isnan) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (!simde_math_isnan(a_.f64[i]) && !simde_math_isnan(b_.f64[i])) ? ~UINT64_C(0) : UINT64_C(0); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpord_pd(a, b) simde_mm_cmpord_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde_float64 simde_mm_cvtsd_f64 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_cvtsd_f64(a); #else simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) return HEDLEY_STATIC_CAST(simde_float64, vgetq_lane_f64(a_.neon_f64, 0)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return HEDLEY_STATIC_CAST(simde_float64, wasm_f64x2_extract_lane(a_.wasm_v128, 0)); #else return a_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsd_f64(a) simde_mm_cvtsd_f64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpord_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpord_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpord_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpord_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(simde_math_isnan) r_.u64[0] = (!simde_math_isnan(a_.f64[0]) && !simde_math_isnan(b_.f64[0])) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpord_sd(a, b) simde_mm_cmpord_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpunord_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpunord_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t ceqaa = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t ceqbb = vceqq_f64(b_.neon_f64, b_.neon_f64); r_.neon_u64 = vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(vandq_u64(ceqaa, ceqbb)))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_or(wasm_f64x2_ne(a_.wasm_v128, a_.wasm_v128), wasm_f64x2_ne(b_.wasm_v128, b_.wasm_v128)); #elif defined(simde_math_isnan) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.u64[i] = (simde_math_isnan(a_.f64[i]) || simde_math_isnan(b_.f64[i])) ? ~UINT64_C(0) : UINT64_C(0); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpunord_pd(a, b) simde_mm_cmpunord_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cmpunord_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cmpunord_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_cmpunord_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_cmpunord_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(simde_math_isnan) r_.u64[0] = (simde_math_isnan(a_.f64[0]) || simde_math_isnan(b_.f64[0])) ? ~UINT64_C(0) : UINT64_C(0); r_.u64[1] = a_.u64[1]; #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cmpunord_sd(a, b) simde_mm_cmpunord_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtepi32_pd (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtepi32_pd(a); #else simde__m128d_private r_; simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_convert_low_i32x4(a_.wasm_v128); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f64, a_.m64_private[0].i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = (simde_float64) a_.i32[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtepi32_pd(a) simde_mm_cvtepi32_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtepi32_ps (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtepi32_ps(a); #else simde__m128_private r_; simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_f32 = vcvtq_f32_s32(a_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_convert_i32x4(a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) HEDLEY_DIAGNOSTIC_PUSH #if HEDLEY_HAS_WARNING("-Wc11-extensions") #pragma clang diagnostic ignored "-Wc11-extensions" #endif r_.altivec_f32 = vec_ctf(a_.altivec_i32, 0); HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f32, a_.i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f32) / sizeof(r_.f32[0])) ; i++) { r_.f32[i] = (simde_float32) a_.i32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtepi32_ps(a) simde_mm_cvtepi32_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvtpd_pi32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpd_pi32(a); #else simde__m64_private r_; simde__m128d_private a_ = simde__m128d_to_private(a); SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { simde_float64 v = simde_math_round(a_.f64[i]); #if defined(SIMDE_FAST_CONVERSION_RANGE) r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #else r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float64, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float64, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif } return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtpd_pi32(a) simde_mm_cvtpd_pi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvtpd_epi32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(SIMDE_BUG_PGI_30107) return _mm_cvtpd_epi32(a); #else simde__m128i_private r_; r_.m64[0] = simde_mm_cvtpd_pi32(a); r_.m64[1] = simde_mm_setzero_si64(); return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtpd_epi32(a) simde_mm_cvtpd_epi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtpd_ps (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtpd_ps(a); #else simde__m128_private r_; simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vcombine_f32(vcvt_f32_f64(a_.neon_f64), vdup_n_f32(0.0f)); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) r_.altivec_f32 = vec_float2(a_.altivec_f64, vec_splats(0.0)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f32x4_demote_f64x2_zero(a_.wasm_v128); #elif HEDLEY_HAS_BUILTIN(__builtin_shufflevector) && HEDLEY_HAS_BUILTIN(__builtin_convertvector) float __attribute__((__vector_size__(8))) z = { 0.0f, 0.0f }; r_.f32 = __builtin_shufflevector( __builtin_convertvector(__builtin_shufflevector(a_.f64, a_.f64, 0, 1), __typeof__(z)), z, 0, 1, 2, 3 ); #else r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, a_.f64[0]); r_.f32[1] = HEDLEY_STATIC_CAST(simde_float32, a_.f64[1]); r_.f32[2] = SIMDE_FLOAT32_C(0.0); r_.f32[3] = SIMDE_FLOAT32_C(0.0); #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtpd_ps(a) simde_mm_cvtpd_ps(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtpi32_pd (simde__m64 a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvtpi32_pd(a); #else simde__m128d_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f64, a_.i32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = (simde_float64) a_.i32[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtpi32_pd(a) simde_mm_cvtpi32_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvtps_epi32 (simde__m128 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtps_epi32(a); #else simde__m128i_private r_; simde__m128_private a_; #if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FAST_ROUND_TIES) && !defined(SIMDE_BUG_GCC_95399) a_ = simde__m128_to_private(a); r_.neon_i32 = vcvtnq_s32_f32(a_.neon_f32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FAST_ROUND_TIES) a_ = simde__m128_to_private(a); HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_C11_EXTENSIONS_ SIMDE_DIAGNOSTIC_DISABLE_VECTOR_CONVERSION_ r_.altivec_i32 = vec_cts(a_.altivec_f32, 1); HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_WASM_SIMD128_NATIVE) && defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FAST_ROUND_TIES) a_ = simde__m128_to_private(a); r_.wasm_v128 = wasm_i32x4_trunc_sat_f32x4(a_.wasm_v128); #else a_ = simde__m128_to_private(simde_x_mm_round_ps(a, SIMDE_MM_FROUND_TO_NEAREST_INT, 1)); SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { simde_float32 v = simde_math_roundf(a_.f32[i]); #if defined(SIMDE_FAST_CONVERSION_RANGE) r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #else r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtps_epi32(a) simde_mm_cvtps_epi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtps_pd (simde__m128 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtps_pd(a); #else simde__m128d_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_promote_low_f32x4(a_.wasm_v128); #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.f64, a_.m64_private[0].f32); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vcvt_f64_f32(vget_low_f32(a_.neon_f32)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f32[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtps_pd(a) simde_mm_cvtps_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvtsd_si32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtsd_si32(a); #else simde__m128d_private a_ = simde__m128d_to_private(a); simde_float64 v = simde_math_round(a_.f64[0]); #if defined(SIMDE_FAST_CONVERSION_RANGE) return SIMDE_CONVERT_FTOI(int32_t, v); #else return ((v > HEDLEY_STATIC_CAST(simde_float64, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float64, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsd_si32(a) simde_mm_cvtsd_si32(a) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvtsd_si64 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) #if defined(__PGI) return _mm_cvtsd_si64x(a); #else return _mm_cvtsd_si64(a); #endif #else simde__m128d_private a_ = simde__m128d_to_private(a); return SIMDE_CONVERT_FTOI(int64_t, simde_math_round(a_.f64[0])); #endif } #define simde_mm_cvtsd_si64x(a) simde_mm_cvtsd_si64(a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_cvtsd_si64(a) simde_mm_cvtsd_si64(a) #define _mm_cvtsd_si64x(a) simde_mm_cvtsd_si64x(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128 simde_mm_cvtsd_ss (simde__m128 a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtsd_ss(a, b); #else simde__m128_private r_, a_ = simde__m128_to_private(a); simde__m128d_private b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f32 = vsetq_lane_f32(vcvtxd_f32_f64(vgetq_lane_f64(b_.neon_f64, 0)), a_.neon_f32, 0); #else r_.f32[0] = HEDLEY_STATIC_CAST(simde_float32, b_.f64[0]); SIMDE_VECTORIZE for (size_t i = 1 ; i < (sizeof(r_) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i]; } #endif return simde__m128_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsd_ss(a, b) simde_mm_cvtsd_ss(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int16_t simde_x_mm_cvtsi128_si16 (simde__m128i a) { simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vgetq_lane_s16(a_.neon_i16, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return HEDLEY_STATIC_CAST(int16_t, wasm_i16x8_extract_lane(a_.wasm_v128, 0)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #if defined(SIMDE_BUG_GCC_95227) (void) a_; #endif return vec_extract(a_.altivec_i16, 0); #else return a_.i16[0]; #endif } SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvtsi128_si32 (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtsi128_si32(a); #else simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vgetq_lane_s32(a_.neon_i32, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return HEDLEY_STATIC_CAST(int32_t, wasm_i32x4_extract_lane(a_.wasm_v128, 0)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #if defined(SIMDE_BUG_GCC_95227) (void) a_; #endif return vec_extract(a_.altivec_i32, 0); #else return a_.i32[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsi128_si32(a) simde_mm_cvtsi128_si32(a) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvtsi128_si64 (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) #if defined(__PGI) return _mm_cvtsi128_si64x(a); #else return _mm_cvtsi128_si64(a); #endif #else simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) && !defined(HEDLEY_IBM_VERSION) return vec_extract(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed long long), a_.i64), 0); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) return vgetq_lane_s64(a_.neon_i64, 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return HEDLEY_STATIC_CAST(int64_t, wasm_i64x2_extract_lane(a_.wasm_v128, 0)); #endif return a_.i64[0]; #endif } #define simde_mm_cvtsi128_si64x(a) simde_mm_cvtsi128_si64(a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_cvtsi128_si64(a) simde_mm_cvtsi128_si64(a) #define _mm_cvtsi128_si64x(a) simde_mm_cvtsi128_si64x(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtsi32_sd (simde__m128d a, int32_t b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtsi32_sd(a, b); #else simde__m128d_private r_; simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsetq_lane_f64(HEDLEY_STATIC_CAST(float64_t, b), a_.neon_f64, 0); #else r_.f64[0] = HEDLEY_STATIC_CAST(simde_float64, b); r_.i64[1] = a_.i64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsi32_sd(a, b) simde_mm_cvtsi32_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_cvtsi16_si128 (int16_t a) { simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vsetq_lane_s16(a, vdupq_n_s16(0), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_make(a, 0, 0, 0, 0, 0, 0, 0); #else r_.i16[0] = a; r_.i16[1] = 0; r_.i16[2] = 0; r_.i16[3] = 0; r_.i16[4] = 0; r_.i16[5] = 0; r_.i16[6] = 0; r_.i16[7] = 0; #endif return simde__m128i_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvtsi32_si128 (int32_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtsi32_si128(a); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vsetq_lane_s32(a, vdupq_n_s32(0), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_make(a, 0, 0, 0); #else r_.i32[0] = a; r_.i32[1] = 0; r_.i32[2] = 0; r_.i32[3] = 0; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtsi32_si128(a) simde_mm_cvtsi32_si128(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtsi64_sd (simde__m128d a, int64_t b) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) #if !defined(__PGI) return _mm_cvtsi64_sd(a, b); #else return _mm_cvtsi64x_sd(a, b); #endif #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsetq_lane_f64(HEDLEY_STATIC_CAST(float64_t, b), a_.neon_f64, 0); #else r_.f64[0] = HEDLEY_STATIC_CAST(simde_float64, b); r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #define simde_mm_cvtsi64x_sd(a, b) simde_mm_cvtsi64_sd(a, b) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_cvtsi64_sd(a, b) simde_mm_cvtsi64_sd(a, b) #define _mm_cvtsi64x_sd(a, b) simde_mm_cvtsi64x_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvtsi64_si128 (int64_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) #if !defined(__PGI) return _mm_cvtsi64_si128(a); #else return _mm_cvtsi64x_si128(a); #endif #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vsetq_lane_s64(a, vdupq_n_s64(0), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_make(a, 0); #else r_.i64[0] = a; r_.i64[1] = 0; #endif return simde__m128i_from_private(r_); #endif } #define simde_mm_cvtsi64x_si128(a) simde_mm_cvtsi64_si128(a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_cvtsi64_si128(a) simde_mm_cvtsi64_si128(a) #define _mm_cvtsi64x_si128(a) simde_mm_cvtsi64x_si128(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_cvtss_sd (simde__m128d a, simde__m128 b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvtss_sd(a, b); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) float64x2_t temp = vcvt_f64_f32(vset_lane_f32(vgetq_lane_f32(simde__m128_to_private(b).neon_f32, 0), vdup_n_f32(0), 0)); return vsetq_lane_f64(vgetq_lane_f64(simde__m128d_to_private(a).neon_f64, 1), temp, 1); #else simde__m128d_private a_ = simde__m128d_to_private(a); simde__m128_private b_ = simde__m128_to_private(b); a_.f64[0] = HEDLEY_STATIC_CAST(simde_float64, b_.f32[0]); return simde__m128d_from_private(a_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvtss_sd(a, b) simde_mm_cvtss_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_cvttpd_pi32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_cvttpd_pi32(a); #else simde__m64_private r_; simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE) SIMDE_CONVERT_VECTOR_(r_.i32, a_.f64); #else for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { simde_float64 v = a_.f64[i]; #if defined(SIMDE_FAST_CONVERSION_RANGE) r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #else r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float64, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float64, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif } #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvttpd_pi32(a) simde_mm_cvttpd_pi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvttpd_epi32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvttpd_epi32(a); #else simde__m128i_private r_; r_.m64[0] = simde_mm_cvttpd_pi32(a); r_.m64[1] = simde_mm_setzero_si64(); return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvttpd_epi32(a) simde_mm_cvttpd_epi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_cvttps_epi32 (simde__m128 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvttps_epi32(a); #else simde__m128i_private r_; simde__m128_private a_ = simde__m128_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vcvtq_s32_f32(a_.neon_f32); #if !defined(SIMDE_FAST_CONVERSION_RANGE) || !defined(SIMDE_FAST_NANS) /* Values below INT32_MIN saturate anyways, so we don't need to * test for that. */ #if !defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_FAST_NANS) uint32x4_t valid_input = vandq_u32( vcltq_f32(a_.neon_f32, vdupq_n_f32(SIMDE_FLOAT32_C(2147483648.0))), vceqq_f32(a_.neon_f32, a_.neon_f32) ); #elif !defined(SIMDE_FAST_CONVERSION_RANGE) uint32x4_t valid_input = vcltq_f32(a_.neon_f32, vdupq_n_f32(SIMDE_FLOAT32_C(2147483648.0))); #elif !defined(SIMDE_FAST_NANS) uint32x4_t valid_input = vceqq_f32(a_.neon_f32, a_.neon_f32); #endif r_.neon_i32 = vbslq_s32(valid_input, r_.neon_i32, vdupq_n_s32(INT32_MIN)); #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_trunc_sat_f32x4(a_.wasm_v128); #if !defined(SIMDE_FAST_CONVERSION_RANGE) || !defined(SIMDE_FAST_NANS) #if !defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_FAST_NANS) v128_t valid_input = wasm_v128_and( wasm_f32x4_lt(a_.wasm_v128, wasm_f32x4_splat(SIMDE_FLOAT32_C(2147483648.0))), wasm_f32x4_eq(a_.wasm_v128, a_.wasm_v128) ); #elif !defined(SIMDE_FAST_CONVERSION_RANGE) v128_t valid_input = wasm_f32x4_lt(a_.wasm_v128, wasm_f32x4_splat(SIMDE_FLOAT32_C(2147483648.0))); #elif !defined(SIMDE_FAST_NANS) v128_t valid_input = wasm_f32x4_eq(a_.wasm_v128, a_.wasm_v128); #endif r_.wasm_v128 = wasm_v128_bitselect(r_.wasm_v128, wasm_i32x4_splat(INT32_MIN), valid_input); #endif #elif defined(SIMDE_CONVERT_VECTOR_) SIMDE_CONVERT_VECTOR_(r_.i32, a_.f32); #if !defined(SIMDE_FAST_CONVERSION_RANGE) || !defined(SIMDE_FAST_NANS) #if !defined(SIMDE_FAST_CONVERSION_RANGE) static const simde_float32 SIMDE_VECTOR(16) first_too_high = { SIMDE_FLOAT32_C(2147483648.0), SIMDE_FLOAT32_C(2147483648.0), SIMDE_FLOAT32_C(2147483648.0), SIMDE_FLOAT32_C(2147483648.0) }; __typeof__(r_.i32) valid_input = HEDLEY_REINTERPRET_CAST( __typeof__(r_.i32), (a_.f32 < first_too_high) & (a_.f32 >= -first_too_high) ); #elif !defined(SIMDE_FAST_NANS) __typeof__(r_.i32) valid_input = HEDLEY_REINTERPRET_CAST( __typeof__(valid_input), a_.f32 == a_.f32); #endif __typeof__(r_.i32) invalid_output = { INT32_MIN, INT32_MIN, INT32_MIN, INT32_MIN }; r_.i32 = (r_.i32 & valid_input) | (invalid_output & ~valid_input); #endif #else for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { simde_float32 v = a_.f32[i]; #if defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FAST_NANS) r_.i32[i] = SIMDE_CONVERT_FTOI(int32_t, v); #else r_.i32[i] = ((v > HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvttps_epi32(a) simde_mm_cvttps_epi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_cvttsd_si32 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_cvttsd_si32(a); #else simde__m128d_private a_ = simde__m128d_to_private(a); simde_float64 v = a_.f64[0]; #if defined(SIMDE_FAST_CONVERSION_RANGE) return SIMDE_CONVERT_FTOI(int32_t, v); #else return ((v > HEDLEY_STATIC_CAST(simde_float64, INT32_MIN)) && (v < HEDLEY_STATIC_CAST(simde_float64, INT32_MAX))) ? SIMDE_CONVERT_FTOI(int32_t, v) : INT32_MIN; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_cvttsd_si32(a) simde_mm_cvttsd_si32(a) #endif SIMDE_FUNCTION_ATTRIBUTES int64_t simde_mm_cvttsd_si64 (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) #if !defined(__PGI) return _mm_cvttsd_si64(a); #else return _mm_cvttsd_si64x(a); #endif #else simde__m128d_private a_ = simde__m128d_to_private(a); return SIMDE_CONVERT_FTOI(int64_t, a_.f64[0]); #endif } #define simde_mm_cvttsd_si64x(a) simde_mm_cvttsd_si64(a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_cvttsd_si64(a) simde_mm_cvttsd_si64(a) #define _mm_cvttsd_si64x(a) simde_mm_cvttsd_si64x(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_div_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_div_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f64 = a_.f64 / b_.f64; #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vdivq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_div(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f64[i] / b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_div_pd(a, b) simde_mm_div_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_div_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_div_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_div_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_div_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) float64x2_t temp = vdivq_f64(a_.neon_f64, b_.neon_f64); r_.neon_f64 = vsetq_lane_f64(vgetq_lane(a_.neon_f64, 1), temp, 1); #else r_.f64[0] = a_.f64[0] / b_.f64[0]; r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_div_sd(a, b) simde_mm_div_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_extract_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 7) { uint16_t r; simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #if defined(SIMDE_BUG_GCC_95227) (void) a_; (void) imm8; #endif r = HEDLEY_STATIC_CAST(uint16_t, vec_extract(a_.altivec_i16, imm8)); #else r = a_.u16[imm8 & 7]; #endif return HEDLEY_STATIC_CAST(int32_t, r); } #if defined(SIMDE_X86_SSE2_NATIVE) && (!defined(HEDLEY_GCC_VERSION) || HEDLEY_GCC_VERSION_CHECK(4,6,0)) #define simde_mm_extract_epi16(a, imm8) _mm_extract_epi16(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_extract_epi16(a, imm8) (HEDLEY_STATIC_CAST(int32_t, vgetq_lane_s16(simde__m128i_to_private(a).neon_i16, (imm8))) & (INT32_C(0x0000ffff))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_extract_epi16(a, imm8) HEDLEY_STATIC_CAST(int32_t, wasm_u16x8_extract_lane(simde__m128i_to_wasm_v128((a)), (imm8) & 7)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_extract_epi16(a, imm8) simde_mm_extract_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_insert_epi16 (simde__m128i a, int16_t i, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 7) { simde__m128i_private a_ = simde__m128i_to_private(a); a_.i16[imm8 & 7] = i; return simde__m128i_from_private(a_); } #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) #define simde_mm_insert_epi16(a, i, imm8) _mm_insert_epi16((a), (i), (imm8)) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_insert_epi16(a, i, imm8) simde__m128i_from_neon_i16(vsetq_lane_s16((i), simde__m128i_to_neon_i16(a), (imm8))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_insert_epi16(a, i, imm8) wasm_i16x8_replace_lane(simde__m128i_to_wasm_v128((a)), (imm8) & 7, (i)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_insert_epi16(a, i, imm8) simde_mm_insert_epi16(a, i, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_load_pd (simde_float64 const mem_addr[HEDLEY_ARRAY_PARAM(2)]) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_load_pd(mem_addr); #else simde__m128d_private r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vld1q_f64(mem_addr); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vld1q_u32(HEDLEY_REINTERPRET_CAST(uint32_t const*, mem_addr)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load(mem_addr); #else simde_memcpy(&r_, SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128d), sizeof(r_)); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_load_pd(mem_addr) simde_mm_load_pd(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_load1_pd (simde_float64 const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_load1_pd(mem_addr); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return simde__m128d_from_neon_f64(vld1q_dup_f64(mem_addr)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128d_from_wasm_v128(wasm_v128_load64_splat(mem_addr)); #else return simde_mm_set1_pd(*mem_addr); #endif } #define simde_mm_load_pd1(mem_addr) simde_mm_load1_pd(mem_addr) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_load_pd1(mem_addr) simde_mm_load1_pd(mem_addr) #define _mm_load1_pd(mem_addr) simde_mm_load1_pd(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_load_sd (simde_float64 const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_load_sd(mem_addr); #else simde__m128d_private r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsetq_lane_f64(*mem_addr, vdupq_n_f64(0), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load64_zero(HEDLEY_REINTERPRET_CAST(const void*, mem_addr)); #else r_.f64[0] = *mem_addr; r_.u64[1] = UINT64_C(0); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_load_sd(mem_addr) simde_mm_load_sd(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_load_si128 (simde__m128i const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_load_si128(HEDLEY_REINTERPRET_CAST(__m128i const*, mem_addr)); #else simde__m128i_private r_; #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_ld(0, HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(int) const*, mem_addr)); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vld1q_s32(HEDLEY_REINTERPRET_CAST(int32_t const*, mem_addr)); #else simde_memcpy(&r_, SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128i), sizeof(simde__m128i)); #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_load_si128(mem_addr) simde_mm_load_si128(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_loadh_pd (simde__m128d a, simde_float64 const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadh_pd(a, mem_addr); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vcombine_f64(vget_low_f64(a_.neon_f64), vld1_f64(HEDLEY_REINTERPRET_CAST(const float64_t*, mem_addr))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load64_lane(HEDLEY_REINTERPRET_CAST(const void*, mem_addr), a_.wasm_v128, 1); #else simde_float64 t; simde_memcpy(&t, mem_addr, sizeof(t)); r_.f64[0] = a_.f64[0]; r_.f64[1] = t; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadh_pd(a, mem_addr) simde_mm_loadh_pd(a, mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadl_epi64 (simde__m128i const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadl_epi64(mem_addr); #else simde__m128i_private r_; int64_t value; simde_memcpy(&value, mem_addr, sizeof(value)); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vcombine_s64(vld1_s64(HEDLEY_REINTERPRET_CAST(int64_t const *, mem_addr)), vdup_n_s64(0)); #else r_.i64[0] = value; r_.i64[1] = 0; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadl_epi64(mem_addr) simde_mm_loadl_epi64(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_loadl_pd (simde__m128d a, simde_float64 const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadl_pd(a, mem_addr); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vcombine_f64(vld1_f64( HEDLEY_REINTERPRET_CAST(const float64_t*, mem_addr)), vget_high_f64(a_.neon_f64)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_load64_lane(HEDLEY_REINTERPRET_CAST(const void*, mem_addr), a_.wasm_v128, 0); #else r_.f64[0] = *mem_addr; r_.u64[1] = a_.u64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadl_pd(a, mem_addr) simde_mm_loadl_pd(a, mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_loadr_pd (simde_float64 const mem_addr[HEDLEY_ARRAY_PARAM(2)]) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadr_pd(mem_addr); #else simde__m128d_private r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vld1q_f64(mem_addr); r_.neon_f64 = vextq_f64(r_.neon_f64, r_.neon_f64, 1); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vld1q_s64(HEDLEY_REINTERPRET_CAST(int64_t const *, mem_addr)); r_.neon_i64 = vextq_s64(r_.neon_i64, r_.neon_i64, 1); #elif defined(SIMDE_WASM_SIMD128_NATIVE) v128_t tmp = wasm_v128_load(mem_addr); r_.wasm_v128 = wasm_i64x2_shuffle(tmp, tmp, 1, 0); #else r_.f64[0] = mem_addr[1]; r_.f64[1] = mem_addr[0]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadr_pd(mem_addr) simde_mm_loadr_pd(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_loadu_pd (simde_float64 const mem_addr[HEDLEY_ARRAY_PARAM(2)]) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_pd(mem_addr); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vld1q_f64(mem_addr); #else simde__m128d_private r_; simde_memcpy(&r_, mem_addr, sizeof(r_)); return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadu_pd(mem_addr) simde_mm_loadu_pd(mem_addr) #endif #if defined(SIMDE_X86_AVX512VL_NATIVE) && defined(SIMDE_X86_AVX512BW_NATIVE) \ && !defined(SIMDE_BUG_GCC_95483) && !defined(SIMDE_BUG_CLANG_REV_344862) \ && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,20,0)) #define simde_mm_loadu_epi8(mem_addr) _mm_loadu_epi8(mem_addr) #else SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_epi8(void const * mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_si128(SIMDE_ALIGN_CAST(__m128i const *, mem_addr)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vld1q_s8(HEDLEY_REINTERPRET_CAST(int8_t const*, mem_addr)); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128i_from_private(r_); #endif } #endif #define simde_x_mm_loadu_epi8(mem_addr) simde_mm_loadu_epi8(mem_addr) #if defined(SIMDE_X86_AVX512VL_ENABLE_NATIVE_ALIASES) || defined(SIMDE_X86_AVX512BW_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && (defined(SIMDE_BUG_GCC_95483) || defined(SIMDE_BUG_CLANG_REV_344862))) #undef _mm_loadu_epi8 #define _mm_loadu_epi8(a) simde_mm_loadu_epi8(a) #endif #if defined(SIMDE_X86_AVX512VL_NATIVE) && defined(SIMDE_X86_AVX512BW_NATIVE) \ && !defined(SIMDE_BUG_GCC_95483) && !defined(SIMDE_BUG_CLANG_REV_344862) \ && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,20,0)) #define simde_mm_loadu_epi16(mem_addr) _mm_loadu_epi16(mem_addr) #else SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_epi16(void const * mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_si128(SIMDE_ALIGN_CAST(__m128i const *, mem_addr)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vreinterpretq_s16_s8(vld1q_s8(HEDLEY_REINTERPRET_CAST(int8_t const*, mem_addr))); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128i_from_private(r_); #endif } #endif #define simde_x_mm_loadu_epi16(mem_addr) simde_mm_loadu_epi16(mem_addr) #if defined(SIMDE_X86_AVX512VL_ENABLE_NATIVE_ALIASES) || defined(SIMDE_X86_AVX512BW_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && (defined(SIMDE_BUG_GCC_95483) || defined(SIMDE_BUG_CLANG_REV_344862))) #undef _mm_loadu_epi16 #define _mm_loadu_epi16(a) simde_mm_loadu_epi16(a) #endif #if defined(SIMDE_X86_AVX512VL_NATIVE) && !defined(SIMDE_BUG_GCC_95483) \ && !defined(SIMDE_BUG_CLANG_REV_344862) && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,20,0)) #define simde_mm_loadu_epi32(mem_addr) _mm_loadu_epi32(mem_addr) #else SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_epi32(void const * mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_si128(SIMDE_ALIGN_CAST(__m128i const *, mem_addr)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vreinterpretq_s32_s8(vld1q_s8(HEDLEY_REINTERPRET_CAST(int8_t const*, mem_addr))); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128i_from_private(r_); #endif } #endif #define simde_x_mm_loadu_epi32(mem_addr) simde_mm_loadu_epi32(mem_addr) #if defined(SIMDE_X86_AVX512VL_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && (defined(SIMDE_BUG_GCC_95483) || defined(SIMDE_BUG_CLANG_REV_344862))) #undef _mm_loadu_epi32 #define _mm_loadu_epi32(a) simde_mm_loadu_epi32(a) #endif #if defined(SIMDE_X86_AVX512VL_NATIVE) && !defined(SIMDE_BUG_GCC_95483) \ && !defined(SIMDE_BUG_CLANG_REV_344862) \ && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,20,0)) #define simde_mm_loadu_epi64(mem_addr) _mm_loadu_epi64(mem_addr) #else SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_epi64(void const * mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_si128(SIMDE_ALIGN_CAST(__m128i const *, mem_addr)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vreinterpretq_s64_s8(vld1q_s8(HEDLEY_REINTERPRET_CAST(int8_t const*, mem_addr))); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128i_from_private(r_); #endif } #endif #define simde_x_mm_loadu_epi64(mem_addr) simde_mm_loadu_epi64(mem_addr) #if defined(SIMDE_X86_AVX512VL_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && (defined(SIMDE_BUG_GCC_95483) || defined(SIMDE_BUG_CLANG_REV_344862))) #undef _mm_loadu_epi64 #define _mm_loadu_epi64(a) simde_mm_loadu_epi64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_si128 (void const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_loadu_si128(HEDLEY_STATIC_CAST(__m128i const*, mem_addr)); #else simde__m128i_private r_; #if HEDLEY_GNUC_HAS_ATTRIBUTE(may_alias,3,3,0) HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_PACKED_ struct simde_mm_loadu_si128_s { __typeof__(r_) v; } __attribute__((__packed__, __may_alias__)); r_ = HEDLEY_REINTERPRET_CAST(const struct simde_mm_loadu_si128_s *, mem_addr)->v; HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vld1q_s8(HEDLEY_REINTERPRET_CAST(int8_t const*, mem_addr)); #else simde_memcpy(&r_, mem_addr, sizeof(r_)); #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadu_si128(mem_addr) simde_mm_loadu_si128(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_madd_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_madd_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) int32x4_t pl = vmull_s16(vget_low_s16(a_.neon_i16), vget_low_s16(b_.neon_i16)); int32x4_t ph = vmull_high_s16(a_.neon_i16, b_.neon_i16); r_.neon_i32 = vpaddq_s32(pl, ph); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int32x4_t pl = vmull_s16(vget_low_s16(a_.neon_i16), vget_low_s16(b_.neon_i16)); int32x4_t ph = vmull_s16(vget_high_s16(a_.neon_i16), vget_high_s16(b_.neon_i16)); int32x2_t rl = vpadd_s32(vget_low_s32(pl), vget_high_s32(pl)); int32x2_t rh = vpadd_s32(vget_low_s32(ph), vget_high_s32(ph)); r_.neon_i32 = vcombine_s32(rl, rh); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_msum(a_.altivec_i16, b_.altivec_i16, vec_splats(0)); #elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = vec_mule(a_.altivec_i16, b_.altivec_i16) + vec_mulo(a_.altivec_i16, b_.altivec_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_dot_i16x8(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && defined(SIMDE_CONVERT_VECTOR_) && HEDLEY_HAS_BUILTIN(__builtin_shufflevector) int32_t SIMDE_VECTOR(32) a32, b32, p32; SIMDE_CONVERT_VECTOR_(a32, a_.i16); SIMDE_CONVERT_VECTOR_(b32, b_.i16); p32 = a32 * b32; r_.i32 = __builtin_shufflevector(p32, p32, 0, 2, 4, 6) + __builtin_shufflevector(p32, p32, 1, 3, 5, 7); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.i16[0])) ; i += 2) { r_.i32[i / 2] = (a_.i16[i] * b_.i16[i]) + (a_.i16[i + 1] * b_.i16[i + 1]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_madd_epi16(a, b) simde_mm_madd_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_maskmoveu_si128 (simde__m128i a, simde__m128i mask, int8_t mem_addr[HEDLEY_ARRAY_PARAM(16)]) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_maskmoveu_si128(a, mask, HEDLEY_REINTERPRET_CAST(char*, mem_addr)); #else simde__m128i_private a_ = simde__m128i_to_private(a), mask_ = simde__m128i_to_private(mask); for (size_t i = 0 ; i < (sizeof(a_.i8) / sizeof(a_.i8[0])) ; i++) { if (mask_.u8[i] & 0x80) { mem_addr[i] = a_.i8[i]; } } #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_maskmoveu_si128(a, mask, mem_addr) simde_mm_maskmoveu_si128((a), (mask), SIMDE_CHECKED_REINTERPRET_CAST(int8_t*, char*, (mem_addr))) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_movemask_epi8 (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__INTEL_COMPILER) /* ICC has trouble with _mm_movemask_epi8 at -O2 and above: */ return _mm_movemask_epi8(a); #else int32_t r = 0; simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) /* https://github.com/WebAssembly/simd/pull/201#issue-380682845 */ static const uint8_t md[16] = { 1 << 0, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7, 1 << 0, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7, }; /* Extend sign bit over entire lane */ uint8x16_t extended = vreinterpretq_u8_s8(vshrq_n_s8(a_.neon_i8, 7)); /* Clear all but the bit we're interested in. */ uint8x16_t masked = vandq_u8(vld1q_u8(md), extended); /* Alternate bytes from low half and high half */ uint8x8x2_t tmp = vzip_u8(vget_low_u8(masked), vget_high_u8(masked)); uint16x8_t x = vreinterpretq_u16_u8(vcombine_u8(tmp.val[0], tmp.val[1])); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r = vaddvq_u16(x); #else uint64x2_t t64 = vpaddlq_u32(vpaddlq_u16(x)); r = HEDLEY_STATIC_CAST(int32_t, vgetq_lane_u64(t64, 0)) + HEDLEY_STATIC_CAST(int32_t, vgetq_lane_u64(t64, 1)); #endif #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && !defined(HEDLEY_IBM_VERSION) && (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE) static const SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) perm = { 120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0 }; r = HEDLEY_STATIC_CAST(int32_t, vec_extract(vec_vbpermq(a_.altivec_u8, perm), 1)); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && !defined(HEDLEY_IBM_VERSION) && (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_BIG) static const SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) perm = { 120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0 }; r = HEDLEY_STATIC_CAST(int32_t, vec_extract(vec_vbpermq(a_.altivec_u8, perm), 14)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = HEDLEY_STATIC_CAST(int32_t, wasm_i8x16_bitmask(a_.wasm_v128)); #else SIMDE_VECTORIZE_REDUCTION(|:r) for (size_t i = 0 ; i < (sizeof(a_.u8) / sizeof(a_.u8[0])) ; i++) { r |= (a_.u8[15 - i] >> 7) << (15 - i); } #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_movemask_epi8(a) simde_mm_movemask_epi8(a) #endif SIMDE_FUNCTION_ATTRIBUTES int32_t simde_mm_movemask_pd (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_movemask_pd(a); #else int32_t r = 0; simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_VECTOR_CONVERSION_ uint64x2_t shifted = vshrq_n_u64(a_.neon_u64, 63); r = HEDLEY_STATIC_CAST(int32_t, vgetq_lane_u64(shifted, 0)) + (HEDLEY_STATIC_CAST(int32_t, vgetq_lane_u64(shifted, 1)) << 1); HEDLEY_DIAGNOSTIC_POP #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && defined(SIMDE_BUG_CLANG_50932) SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) idx = { 64, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) res = HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(unsigned char), vec_bperm(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(unsigned __int128), a_.altivec_u64), idx)); r = HEDLEY_STATIC_CAST(int32_t, vec_extract(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), res), 2)); #elif defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) idx = { 64, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; SIMDE_POWER_ALTIVEC_VECTOR(unsigned char) res = vec_bperm(a_.altivec_u8, idx); r = HEDLEY_STATIC_CAST(int32_t, vec_extract(HEDLEY_REINTERPRET_CAST(SIMDE_POWER_ALTIVEC_VECTOR(signed int), res), 2)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r = HEDLEY_STATIC_CAST(int32_t, wasm_i64x2_bitmask(a_.wasm_v128)); #else SIMDE_VECTORIZE_REDUCTION(|:r) for (size_t i = 0 ; i < (sizeof(a_.u64) / sizeof(a_.u64[0])) ; i++) { r |= (a_.u64[i] >> 63) << i; } #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_movemask_pd(a) simde_mm_movemask_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_movepi64_pi64 (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_movepi64_pi64(a); #else simde__m64_private r_; simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i64 = vget_low_s64(a_.neon_i64); #else r_.i64[0] = a_.i64[0]; #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_movepi64_pi64(a) simde_mm_movepi64_pi64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_movpi64_epi64 (simde__m64 a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_movpi64_epi64(a); #else simde__m128i_private r_; simde__m64_private a_ = simde__m64_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vcombine_s64(a_.neon_i64, vdup_n_s64(0)); #else r_.i64[0] = a_.i64[0]; r_.i64[1] = 0; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_movpi64_epi64(a) simde_mm_movpi64_epi64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_min_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_min_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vminq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_min(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = vec_min(a_.altivec_i16, b_.altivec_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] < b_.i16[i]) ? a_.i16[i] : b_.i16[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_min_epi16(a, b) simde_mm_min_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_min_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_min_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vminq_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_min(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_u8 = vec_min(a_.altivec_u8, b_.altivec_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] < b_.u8[i]) ? a_.u8[i] : b_.u8[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_min_epu8(a, b) simde_mm_min_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_min_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_min_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_min(a_.altivec_f64, b_.altivec_f64); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vminq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_min(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = (a_.f64[i] < b_.f64[i]) ? a_.f64[i] : b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_min_pd(a, b) simde_mm_min_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_min_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_min_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_min_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_min_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) float64x2_t temp = vminq_f64(a_.neon_f64, b_.neon_f64); r_.neon_f64 = vsetq_lane_f64(vgetq_lane(a_.neon_f64, 1), temp, 1); #else r_.f64[0] = (a_.f64[0] < b_.f64[0]) ? a_.f64[0] : b_.f64[0]; r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_min_sd(a, b) simde_mm_min_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_max_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_max_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vmaxq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_max(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = vec_max(a_.altivec_i16, b_.altivec_i16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = (a_.i16[i] > b_.i16[i]) ? a_.i16[i] : b_.i16[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_max_epi16(a, b) simde_mm_max_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_max_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_max_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vmaxq_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_max(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_u8 = vec_max(a_.altivec_u8, b_.altivec_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u8) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = (a_.u8[i] > b_.u8[i]) ? a_.u8[i] : b_.u8[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_max_epu8(a, b) simde_mm_max_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_max_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_max_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_max(a_.altivec_f64, b_.altivec_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_max(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vmaxq_f64(a_.neon_f64, b_.neon_f64); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = (a_.f64[i] > b_.f64[i]) ? a_.f64[i] : b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_max_pd(a, b) simde_mm_max_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_max_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_max_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_max_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_max_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) float64x2_t temp = vmaxq_f64(a_.neon_f64, b_.neon_f64); r_.neon_f64 = vsetq_lane_f64(vgetq_lane(a_.neon_f64, 1), temp, 1); #else r_.f64[0] = (a_.f64[0] > b_.f64[0]) ? a_.f64[0] : b_.f64[0]; r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_max_sd(a, b) simde_mm_max_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_move_epi64 (simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_move_epi64(a); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vsetq_lane_s64(0, a_.neon_i64, 1); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, wasm_i64x2_const(0, 0), 0, 2); #else r_.i64[0] = a_.i64[0]; r_.i64[1] = 0; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_move_epi64(a) simde_mm_move_epi64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_mul_epu32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_mul_epu32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint32x2_t a_lo = vmovn_u64(a_.neon_u64); uint32x2_t b_lo = vmovn_u64(b_.neon_u64); r_.neon_u64 = vmull_u32(a_lo, b_lo); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u64x2_extmul_low_u32x4( wasm_i32x4_shuffle(a_.wasm_v128, a_.wasm_v128, 0, 2, 0, 2), wasm_i32x4_shuffle(b_.wasm_v128, b_.wasm_v128, 0, 2, 0, 2)); #elif defined(SIMDE_SHUFFLE_VECTOR_) && (SIMDE_ENDIAN_ORDER == SIMDE_ENDIAN_LITTLE) __typeof__(a_.u32) z = { 0, }; a_.u32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.u32, z, 0, 4, 2, 6); b_.u32 = SIMDE_SHUFFLE_VECTOR_(32, 16, b_.u32, z, 0, 4, 2, 6); r_.u64 = HEDLEY_REINTERPRET_CAST(__typeof__(r_.u64), a_.u32) * HEDLEY_REINTERPRET_CAST(__typeof__(r_.u64), b_.u32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u64) / sizeof(r_.u64[0])) ; i++) { r_.u64[i] = HEDLEY_STATIC_CAST(uint64_t, a_.u32[i * 2]) * HEDLEY_STATIC_CAST(uint64_t, b_.u32[i * 2]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mul_epu32(a, b) simde_mm_mul_epu32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_mul_epi64 (simde__m128i a, simde__m128i b) { simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_mul(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 * b_.i64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] * b_.i64[i]; } #endif return simde__m128i_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_mod_epi64 (simde__m128i a, simde__m128i b) { simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) && !defined(SIMDE_BUG_PGI_30104) r_.i64 = a_.i64 % b_.i64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] % b_.i64[i]; } #endif return simde__m128i_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_mul_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_mul_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f64 = a_.f64 * b_.f64; #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vmulq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_mul(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f64[i] * b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mul_pd(a, b) simde_mm_mul_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_mul_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_mul_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_mul_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_mul_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) float64x2_t temp = vmulq_f64(a_.neon_f64, b_.neon_f64); r_.neon_f64 = vsetq_lane_f64(vgetq_lane(a_.neon_f64, 1), temp, 1); #else r_.f64[0] = a_.f64[0] * b_.f64[0]; r_.f64[1] = a_.f64[1]; #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mul_sd(a, b) simde_mm_mul_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_mul_su32 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) && !defined(__PGI) return _mm_mul_su32(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.u64[0] = vget_lane_u64(vget_low_u64(vmull_u32(vreinterpret_u32_s64(a_.neon_i64), vreinterpret_u32_s64(b_.neon_i64))), 0); #else r_.u64[0] = HEDLEY_STATIC_CAST(uint64_t, a_.u32[0]) * HEDLEY_STATIC_CAST(uint64_t, b_.u32[0]); #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mul_su32(a, b) simde_mm_mul_su32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_mulhi_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_mulhi_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) int16x4_t a3210 = vget_low_s16(a_.neon_i16); int16x4_t b3210 = vget_low_s16(b_.neon_i16); int32x4_t ab3210 = vmull_s16(a3210, b3210); /* 3333222211110000 */ #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) int32x4_t ab7654 = vmull_high_s16(a_.neon_i16, b_.neon_i16); r_.neon_i16 = vuzp2q_s16(vreinterpretq_s16_s32(ab3210), vreinterpretq_s16_s32(ab7654)); #else int16x4_t a7654 = vget_high_s16(a_.neon_i16); int16x4_t b7654 = vget_high_s16(b_.neon_i16); int32x4_t ab7654 = vmull_s16(a7654, b7654); /* 7777666655554444 */ uint16x8x2_t rv = vuzpq_u16(vreinterpretq_u16_s32(ab3210), vreinterpretq_u16_s32(ab7654)); r_.neon_u16 = rv.val[1]; #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) const v128_t lo = wasm_i32x4_extmul_low_i16x8(a_.wasm_v128, b_.wasm_v128); const v128_t hi = wasm_i32x4_extmul_high_i16x8(a_.wasm_v128, b_.wasm_v128); r_.wasm_v128 = wasm_i16x8_shuffle(lo, hi, 1, 3, 5, 7, 9, 11, 13, 15); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, (HEDLEY_STATIC_CAST(uint32_t, HEDLEY_STATIC_CAST(int32_t, a_.i16[i]) * HEDLEY_STATIC_CAST(int32_t, b_.i16[i])) >> 16)); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mulhi_epi16(a, b) simde_mm_mulhi_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_mulhi_epu16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) return _mm_mulhi_epu16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) uint16x4_t a3210 = vget_low_u16(a_.neon_u16); uint16x4_t b3210 = vget_low_u16(b_.neon_u16); uint32x4_t ab3210 = vmull_u16(a3210, b3210); /* 3333222211110000 */ #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint32x4_t ab7654 = vmull_high_u16(a_.neon_u16, b_.neon_u16); r_.neon_u16 = vuzp2q_u16(vreinterpretq_u16_u32(ab3210), vreinterpretq_u16_u32(ab7654)); #else uint16x4_t a7654 = vget_high_u16(a_.neon_u16); uint16x4_t b7654 = vget_high_u16(b_.neon_u16); uint32x4_t ab7654 = vmull_u16(a7654, b7654); /* 7777666655554444 */ uint16x8x2_t neon_r = vuzpq_u16(vreinterpretq_u16_u32(ab3210), vreinterpretq_u16_u32(ab7654)); r_.neon_u16 = neon_r.val[1]; #endif #elif defined(SIMDE_WASM_SIMD128_NATIVE) const v128_t lo = wasm_u32x4_extmul_low_u16x8(a_.wasm_v128, b_.wasm_v128); const v128_t hi = wasm_u32x4_extmul_high_u16x8(a_.wasm_v128, b_.wasm_v128); r_.wasm_v128 = wasm_i16x8_shuffle(lo, hi, 1, 3, 5, 7, 9, 11, 13, 15); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, HEDLEY_STATIC_CAST(uint32_t, a_.u16[i]) * HEDLEY_STATIC_CAST(uint32_t, b_.u16[i]) >> 16); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mulhi_epu16(a, b) simde_mm_mulhi_epu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_mullo_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_mullo_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vmulq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) (void) a_; (void) b_; r_.altivec_i16 = vec_mul(a_.altivec_i16, b_.altivec_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_mul(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, HEDLEY_STATIC_CAST(uint32_t, a_.u16[i]) * HEDLEY_STATIC_CAST(uint32_t, b_.u16[i])); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mullo_epi16(a, b) simde_mm_mullo_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_or_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_or_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f | b_.i32f; #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_or(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vorrq_s64(a_.neon_i64, b_.neon_i64); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] | b_.i32f[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_or_pd(a, b) simde_mm_or_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_or_si128 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_or_si128(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vorrq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_or(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_or(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f | b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] | b_.i32f[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_or_si128(a, b) simde_mm_or_si128(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_packs_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_packs_epi16(a, b); #else simde__m128i_private a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b), r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i8 = vqmovn_high_s16(vqmovn_s16(a_.neon_i16), b_.neon_i16); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vcombine_s8(vqmovn_s16(a_.neon_i16), vqmovn_s16(b_.neon_i16)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i8 = vec_packs(a_.altivec_i16, b_.altivec_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_narrow_i16x8(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_CONVERT_VECTOR_) && HEDLEY_HAS_BUILTIN(__builtin_shufflevector) int16_t SIMDE_VECTOR(32) v = SIMDE_SHUFFLE_VECTOR_(16, 32, a_.i16, b_.i16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); const int16_t SIMDE_VECTOR(32) min = { INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN, INT8_MIN }; const int16_t SIMDE_VECTOR(32) max = { INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX, INT8_MAX }; int16_t m SIMDE_VECTOR(32); m = HEDLEY_REINTERPRET_CAST(__typeof__(m), v < min); v = (v & ~m) | (min & m); m = v > max; v = (v & ~m) | (max & m); SIMDE_CONVERT_VECTOR_(r_.i8, v); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { int16_t v = (i < (sizeof(a_.i16) / sizeof(a_.i16[0]))) ? a_.i16[i] : b_.i16[i & 7]; r_.i8[i] = (v < INT8_MIN) ? INT8_MIN : ((v > INT8_MAX) ? INT8_MAX : HEDLEY_STATIC_CAST(int8_t, v)); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_packs_epi16(a, b) simde_mm_packs_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_packs_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_packs_epi32(a, b); #else simde__m128i_private a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b), r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i16 = vqmovn_high_s32(vqmovn_s32(a_.neon_i32), b_.neon_i32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vcombine_s16(vqmovn_s32(a_.neon_i32), vqmovn_s32(b_.neon_i32)); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i16 = vec_packs(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_X86_SSE2_NATIVE) r_.sse_m128i = _mm_packs_epi32(a_.sse_m128i, b_.sse_m128i); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_narrow_i32x4(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_CONVERT_VECTOR_) && HEDLEY_HAS_BUILTIN(__builtin_shufflevector) int32_t SIMDE_VECTOR(32) v = SIMDE_SHUFFLE_VECTOR_(32, 32, a_.i32, b_.i32, 0, 1, 2, 3, 4, 5, 6, 7); const int32_t SIMDE_VECTOR(32) min = { INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN, INT16_MIN }; const int32_t SIMDE_VECTOR(32) max = { INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX, INT16_MAX }; int32_t m SIMDE_VECTOR(32); m = HEDLEY_REINTERPRET_CAST(__typeof__(m), v < min); v = (v & ~m) | (min & m); m = HEDLEY_REINTERPRET_CAST(__typeof__(m), v > max); v = (v & ~m) | (max & m); SIMDE_CONVERT_VECTOR_(r_.i16, v); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { int32_t v = (i < (sizeof(a_.i32) / sizeof(a_.i32[0]))) ? a_.i32[i] : b_.i32[i & 3]; r_.i16[i] = (v < INT16_MIN) ? INT16_MIN : ((v > INT16_MAX) ? INT16_MAX : HEDLEY_STATIC_CAST(int16_t, v)); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_packs_epi32(a, b) simde_mm_packs_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_packus_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_packus_epi16(a, b); #else simde__m128i_private a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b), r_; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) #if defined(SIMDE_BUG_CLANG_46840) r_.neon_u8 = vqmovun_high_s16(vreinterpret_s8_u8(vqmovun_s16(a_.neon_i16)), b_.neon_i16); #else r_.neon_u8 = vqmovun_high_s16(vqmovun_s16(a_.neon_i16), b_.neon_i16); #endif #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vcombine_u8( vqmovun_s16(a_.neon_i16), vqmovun_s16(b_.neon_i16) ); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_u8 = vec_packsu(a_.altivec_i16, b_.altivec_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_narrow_i16x8(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_CONVERT_VECTOR_) && HEDLEY_HAS_BUILTIN(__builtin_shufflevector) && defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) int16_t v SIMDE_VECTOR(32) = SIMDE_SHUFFLE_VECTOR_(16, 32, a_.i16, b_.i16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); v &= ~(v >> 15); v |= HEDLEY_REINTERPRET_CAST(__typeof__(v), v > UINT8_MAX); SIMDE_CONVERT_VECTOR_(r_.i8, v); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { int16_t v = (i < (sizeof(a_.i16) / sizeof(a_.i16[0]))) ? a_.i16[i] : b_.i16[i & 7]; r_.u8[i] = (v < 0) ? UINT8_C(0) : ((v > UINT8_MAX) ? UINT8_MAX : HEDLEY_STATIC_CAST(uint8_t, v)); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_packus_epi16(a, b) simde_mm_packus_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_pause (void) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_pause(); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_pause() (simde_mm_pause()) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sad_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sad_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) const uint16x8_t t = vpaddlq_u8(vabdq_u8(a_.neon_u8, b_.neon_u8)); r_.neon_u64 = vcombine_u64( vpaddl_u32(vpaddl_u16(vget_low_u16(t))), vpaddl_u32(vpaddl_u16(vget_high_u16(t)))); #else for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { uint16_t tmp = 0; SIMDE_VECTORIZE_REDUCTION(+:tmp) for (size_t j = 0 ; j < ((sizeof(r_.u8) / sizeof(r_.u8[0])) / 2) ; j++) { const size_t e = j + (i * 8); tmp += (a_.u8[e] > b_.u8[e]) ? (a_.u8[e] - b_.u8[e]) : (b_.u8[e] - a_.u8[e]); } r_.i64[i] = tmp; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sad_epu8(a, b) simde_mm_sad_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set_epi8 (int8_t e15, int8_t e14, int8_t e13, int8_t e12, int8_t e11, int8_t e10, int8_t e9, int8_t e8, int8_t e7, int8_t e6, int8_t e5, int8_t e4, int8_t e3, int8_t e2, int8_t e1, int8_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi8( e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); #else simde__m128i_private r_; #if defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_make( e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(int8x16_t) int8_t data[16] = { e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15}; r_.neon_i8 = vld1q_s8(data); #else r_.i8[ 0] = e0; r_.i8[ 1] = e1; r_.i8[ 2] = e2; r_.i8[ 3] = e3; r_.i8[ 4] = e4; r_.i8[ 5] = e5; r_.i8[ 6] = e6; r_.i8[ 7] = e7; r_.i8[ 8] = e8; r_.i8[ 9] = e9; r_.i8[10] = e10; r_.i8[11] = e11; r_.i8[12] = e12; r_.i8[13] = e13; r_.i8[14] = e14; r_.i8[15] = e15; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_epi8(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_set_epi8(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set_epi16 (int16_t e7, int16_t e6, int16_t e5, int16_t e4, int16_t e3, int16_t e2, int16_t e1, int16_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi16(e7, e6, e5, e4, e3, e2, e1, e0); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(int16x8_t) int16_t data[8] = { e0, e1, e2, e3, e4, e5, e6, e7 }; r_.neon_i16 = vld1q_s16(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_make(e0, e1, e2, e3, e4, e5, e6, e7); #else r_.i16[0] = e0; r_.i16[1] = e1; r_.i16[2] = e2; r_.i16[3] = e3; r_.i16[4] = e4; r_.i16[5] = e5; r_.i16[6] = e6; r_.i16[7] = e7; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_epi16(e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_set_epi16(e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_si16 (void const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1) || \ HEDLEY_GCC_VERSION_CHECK(12,1,0)) return _mm_loadu_si16(mem_addr); #else int16_t val; simde_memcpy(&val, mem_addr, sizeof(val)); return simde_x_mm_cvtsi16_si128(val); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadu_si16(mem_addr) simde_mm_loadu_si16(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set_epi32 (int32_t e3, int32_t e2, int32_t e1, int32_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi32(e3, e2, e1, e0); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(int32x4_t) int32_t data[4] = { e0, e1, e2, e3 }; r_.neon_i32 = vld1q_s32(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_make(e0, e1, e2, e3); #else r_.i32[0] = e0; r_.i32[1] = e1; r_.i32[2] = e2; r_.i32[3] = e3; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_epi32(e3, e2, e1, e0) simde_mm_set_epi32(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_si32 (void const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1) || \ HEDLEY_GCC_VERSION_CHECK(12,1,0)) return _mm_loadu_si32(mem_addr); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128i_from_wasm_v128(wasm_v128_load32_zero(mem_addr)); #else int32_t val; simde_memcpy(&val, mem_addr, sizeof(val)); return simde_mm_cvtsi32_si128(val); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadu_si32(mem_addr) simde_mm_loadu_si32(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set_epi64 (simde__m64 e1, simde__m64 e0) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_set_epi64(e1, e0); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vcombine_s64(simde__m64_to_neon_i64(e0), simde__m64_to_neon_i64(e1)); #else r_.m64[0] = e0; r_.m64[1] = e1; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_epi64(e1, e0) (simde_mm_set_epi64((e1), (e0))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set_epi64x (int64_t e1, int64_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,0,0)) return _mm_set_epi64x(e1, e0); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(int64x2_t) int64_t data[2] = {e0, e1}; r_.neon_i64 = vld1q_s64(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_make(e0, e1); #else r_.i64[0] = e0; r_.i64[1] = e1; #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_epi64x(e1, e0) simde_mm_set_epi64x(e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_loadu_si64 (void const* mem_addr) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_GCC_VERSION_CHECK(11,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1)) return _mm_loadu_si64(mem_addr); #else int64_t val; simde_memcpy(&val, mem_addr, sizeof(val)); return simde_mm_cvtsi64_si128(val); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_loadu_si64(mem_addr) simde_mm_loadu_si64(mem_addr) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set_epu8 (uint8_t e15, uint8_t e14, uint8_t e13, uint8_t e12, uint8_t e11, uint8_t e10, uint8_t e9, uint8_t e8, uint8_t e7, uint8_t e6, uint8_t e5, uint8_t e4, uint8_t e3, uint8_t e2, uint8_t e1, uint8_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi8( HEDLEY_STATIC_CAST(char, e15), HEDLEY_STATIC_CAST(char, e14), HEDLEY_STATIC_CAST(char, e13), HEDLEY_STATIC_CAST(char, e12), HEDLEY_STATIC_CAST(char, e11), HEDLEY_STATIC_CAST(char, e10), HEDLEY_STATIC_CAST(char, e9), HEDLEY_STATIC_CAST(char, e8), HEDLEY_STATIC_CAST(char, e7), HEDLEY_STATIC_CAST(char, e6), HEDLEY_STATIC_CAST(char, e5), HEDLEY_STATIC_CAST(char, e4), HEDLEY_STATIC_CAST(char, e3), HEDLEY_STATIC_CAST(char, e2), HEDLEY_STATIC_CAST(char, e1), HEDLEY_STATIC_CAST(char, e0)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(uint8x16_t) uint8_t data[16] = { e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15}; r_.neon_u8 = vld1q_u8(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_make(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); #else r_.u8[ 0] = e0; r_.u8[ 1] = e1; r_.u8[ 2] = e2; r_.u8[ 3] = e3; r_.u8[ 4] = e4; r_.u8[ 5] = e5; r_.u8[ 6] = e6; r_.u8[ 7] = e7; r_.u8[ 8] = e8; r_.u8[ 9] = e9; r_.u8[10] = e10; r_.u8[11] = e11; r_.u8[12] = e12; r_.u8[13] = e13; r_.u8[14] = e14; r_.u8[15] = e15; #endif return simde__m128i_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set_epu16 (uint16_t e7, uint16_t e6, uint16_t e5, uint16_t e4, uint16_t e3, uint16_t e2, uint16_t e1, uint16_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi16( HEDLEY_STATIC_CAST(short, e7), HEDLEY_STATIC_CAST(short, e6), HEDLEY_STATIC_CAST(short, e5), HEDLEY_STATIC_CAST(short, e4), HEDLEY_STATIC_CAST(short, e3), HEDLEY_STATIC_CAST(short, e2), HEDLEY_STATIC_CAST(short, e1), HEDLEY_STATIC_CAST(short, e0)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(uint16x8_t) uint16_t data[8] = { e0, e1, e2, e3, e4, e5, e6, e7 }; r_.neon_u16 = vld1q_u16(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u16x8_make(e0, e1, e2, e3, e4, e5, e6, e7); #else r_.u16[0] = e0; r_.u16[1] = e1; r_.u16[2] = e2; r_.u16[3] = e3; r_.u16[4] = e4; r_.u16[5] = e5; r_.u16[6] = e6; r_.u16[7] = e7; #endif return simde__m128i_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set_epu32 (uint32_t e3, uint32_t e2, uint32_t e1, uint32_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_epi32( HEDLEY_STATIC_CAST(int, e3), HEDLEY_STATIC_CAST(int, e2), HEDLEY_STATIC_CAST(int, e1), HEDLEY_STATIC_CAST(int, e0)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(uint32x4_t) uint32_t data[4] = { e0, e1, e2, e3 }; r_.neon_u32 = vld1q_u32(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u32x4_make(e0, e1, e2, e3); #else r_.u32[0] = e0; r_.u32[1] = e1; r_.u32[2] = e2; r_.u32[3] = e3; #endif return simde__m128i_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set_epu64x (uint64_t e1, uint64_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,0,0)) return _mm_set_epi64x(HEDLEY_STATIC_CAST(int64_t, e1), HEDLEY_STATIC_CAST(int64_t, e0)); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) SIMDE_ALIGN_LIKE_16(uint64x2_t) uint64_t data[2] = {e0, e1}; r_.neon_u64 = vld1q_u64(data); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u64x2_make(e0, e1); #else r_.u64[0] = e0; r_.u64[1] = e1; #endif return simde__m128i_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_set_sd (simde_float64 a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set_sd(a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) return vsetq_lane_f64(a, vdupq_n_f64(SIMDE_FLOAT64_C(0.0)), 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128d_from_wasm_v128(wasm_f64x2_make(a, 0)); #else return simde_mm_set_pd(SIMDE_FLOAT64_C(0.0), a); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set_sd(a) simde_mm_set_sd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set1_epi8 (int8_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set1_epi8(a); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vdupq_n_s8(a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_splat(a); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i8 = vec_splats(HEDLEY_STATIC_CAST(signed char, a)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_epi8(a) simde_mm_set1_epi8(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set1_epi16 (int16_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set1_epi16(a); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vdupq_n_s16(a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_splat(a); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i16 = vec_splats(HEDLEY_STATIC_CAST(signed short, a)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_epi16(a) simde_mm_set1_epi16(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set1_epi32 (int32_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_set1_epi32(a); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vdupq_n_s32(a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_splat(a); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i32 = vec_splats(HEDLEY_STATIC_CAST(signed int, a)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_epi32(a) simde_mm_set1_epi32(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set1_epi64x (int64_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) && (!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19,0,0)) return _mm_set1_epi64x(a); #else simde__m128i_private r_; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vdupq_n_s64(a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_splat(a); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_i64 = vec_splats(HEDLEY_STATIC_CAST(signed long long, a)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_epi64x(a) simde_mm_set1_epi64x(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_set1_epi64 (simde__m64 a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_set1_epi64(a); #else simde__m64_private a_ = simde__m64_to_private(a); return simde_mm_set1_epi64x(a_.i64[0]); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_set1_epi64(a) simde_mm_set1_epi64(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set1_epu8 (uint8_t value) { #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) return simde__m128i_from_altivec_u8(vec_splats(HEDLEY_STATIC_CAST(unsigned char, value))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128i_from_wasm_v128(wasm_u8x16_splat(value)); #else return simde_mm_set1_epi8(HEDLEY_STATIC_CAST(int8_t, value)); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set1_epu16 (uint16_t value) { #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) return simde__m128i_from_altivec_u16(vec_splats(HEDLEY_STATIC_CAST(unsigned short, value))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128i_from_wasm_v128(wasm_u16x8_splat(value)); #else return simde_mm_set1_epi16(HEDLEY_STATIC_CAST(int16_t, value)); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set1_epu32 (uint32_t value) { #if defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) return simde__m128i_from_altivec_u32(vec_splats(HEDLEY_STATIC_CAST(unsigned int, value))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128i_from_wasm_v128(wasm_u32x4_splat(value)); #else return simde_mm_set1_epi32(HEDLEY_STATIC_CAST(int32_t, value)); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_set1_epu64 (uint64_t value) { #if defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) return simde__m128i_from_altivec_u64(vec_splats(HEDLEY_STATIC_CAST(unsigned long long, value))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128i_from_wasm_v128(wasm_u64x2_splat(value)); #else return simde_mm_set1_epi64x(HEDLEY_STATIC_CAST(int64_t, value)); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_setr_epi8 (int8_t e15, int8_t e14, int8_t e13, int8_t e12, int8_t e11, int8_t e10, int8_t e9, int8_t e8, int8_t e7, int8_t e6, int8_t e5, int8_t e4, int8_t e3, int8_t e2, int8_t e1, int8_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setr_epi8( e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); #else return simde_mm_set_epi8( e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setr_epi8(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_setr_epi8(e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_setr_epi16 (int16_t e7, int16_t e6, int16_t e5, int16_t e4, int16_t e3, int16_t e2, int16_t e1, int16_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setr_epi16(e7, e6, e5, e4, e3, e2, e1, e0); #else return simde_mm_set_epi16(e0, e1, e2, e3, e4, e5, e6, e7); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setr_epi16(e7, e6, e5, e4, e3, e2, e1, e0) simde_mm_setr_epi16(e7, e6, e5, e4, e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_setr_epi32 (int32_t e3, int32_t e2, int32_t e1, int32_t e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setr_epi32(e3, e2, e1, e0); #else return simde_mm_set_epi32(e0, e1, e2, e3); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setr_epi32(e3, e2, e1, e0) simde_mm_setr_epi32(e3, e2, e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_setr_epi64 (simde__m64 e1, simde__m64 e0) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_setr_epi64(e1, e0); #else return simde_mm_set_epi64(e0, e1); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setr_epi64(e1, e0) (simde_mm_setr_epi64((e1), (e0))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_setr_pd (simde_float64 e1, simde_float64 e0) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setr_pd(e1, e0); #else return simde_mm_set_pd(e0, e1); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setr_pd(e1, e0) simde_mm_setr_pd(e1, e0) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_setzero_pd (void) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_setzero_pd(); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return simde__m128d_from_wasm_v128(wasm_f64x2_const(0.0, 0.0)); #else return simde_mm_castsi128_pd(simde_mm_setzero_si128()); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_setzero_pd() simde_mm_setzero_pd() #endif #if defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) HEDLEY_DIAGNOSTIC_PUSH SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_ #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_undefined_pd (void) { simde__m128d_private r_; #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE__HAVE_UNDEFINED128) r_.n = _mm_undefined_pd(); #elif !defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) r_ = simde__m128d_to_private(simde_mm_setzero_pd()); #endif return simde__m128d_from_private(r_); } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_undefined_pd() simde_mm_undefined_pd() #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_undefined_si128 (void) { simde__m128i_private r_; #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE__HAVE_UNDEFINED128) r_.n = _mm_undefined_si128(); #elif !defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) r_ = simde__m128i_to_private(simde_mm_setzero_si128()); #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_undefined_si128() (simde_mm_undefined_si128()) #endif #if defined(SIMDE_DIAGNOSTIC_DISABLE_UNINITIALIZED_) HEDLEY_DIAGNOSTIC_POP #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_setone_pd (void) { return simde_mm_castps_pd(simde_x_mm_setone_ps()); } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_setone_si128 (void) { return simde_mm_castps_si128(simde_x_mm_setone_ps()); } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_shuffle_epi32 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[(imm8 >> (i * 2)) & 3]; } return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_shuffle_epi32(a, imm8) _mm_shuffle_epi32((a), (imm8)) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_shuffle_epi32(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ simde__m128i_from_wasm_v128( \ wasm_i32x4_shuffle( \ (simde_tmp_a_).wasm_v128, \ (simde_tmp_a_).wasm_v128, \ ((imm8) ) & 3, \ ((imm8) >> 2) & 3, \ ((imm8) >> 4) & 3, \ ((imm8) >> 6) & 3)); })) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_STATEMENT_EXPR_) #define simde_mm_shuffle_epi32(a, imm8) \ (__extension__ ({ \ const int32x4_t simde_mm_shuffle_epi32_a_ = simde__m128i_to_neon_i32(a); \ int32x4_t simde_mm_shuffle_epi32_r_; \ simde_mm_shuffle_epi32_r_ = vmovq_n_s32(vgetq_lane_s32(simde_mm_shuffle_epi32_a_, (imm8) & (0x3))); \ simde_mm_shuffle_epi32_r_ = vsetq_lane_s32(vgetq_lane_s32(simde_mm_shuffle_epi32_a_, ((imm8) >> 2) & 0x3), simde_mm_shuffle_epi32_r_, 1); \ simde_mm_shuffle_epi32_r_ = vsetq_lane_s32(vgetq_lane_s32(simde_mm_shuffle_epi32_a_, ((imm8) >> 4) & 0x3), simde_mm_shuffle_epi32_r_, 2); \ simde_mm_shuffle_epi32_r_ = vsetq_lane_s32(vgetq_lane_s32(simde_mm_shuffle_epi32_a_, ((imm8) >> 6) & 0x3), simde_mm_shuffle_epi32_r_, 3); \ vreinterpretq_s64_s32(simde_mm_shuffle_epi32_r_); \ })) #elif defined(SIMDE_SHUFFLE_VECTOR_) #define simde_mm_shuffle_epi32(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ simde__m128i_from_private((simde__m128i_private) { .i32 = \ SIMDE_SHUFFLE_VECTOR_(32, 16, \ (simde_tmp_a_).i32, \ (simde_tmp_a_).i32, \ ((imm8) ) & 3, \ ((imm8) >> 2) & 3, \ ((imm8) >> 4) & 3, \ ((imm8) >> 6) & 3) }); })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_shuffle_epi32(a, imm8) simde_mm_shuffle_epi32(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_shuffle_pd (simde__m128d a, simde__m128d b, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 3) { simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.f64[0] = ((imm8 & 1) == 0) ? a_.f64[0] : a_.f64[1]; r_.f64[1] = ((imm8 & 2) == 0) ? b_.f64[0] : b_.f64[1]; return simde__m128d_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(__PGI) #define simde_mm_shuffle_pd(a, b, imm8) _mm_shuffle_pd((a), (b), (imm8)) #elif defined(SIMDE_SHUFFLE_VECTOR_) #define simde_mm_shuffle_pd(a, b, imm8) (__extension__ ({ \ simde__m128d_from_private((simde__m128d_private) { .f64 = \ SIMDE_SHUFFLE_VECTOR_(64, 16, \ simde__m128d_to_private(a).f64, \ simde__m128d_to_private(b).f64, \ (((imm8) ) & 1), \ (((imm8) >> 1) & 1) + 2) }); })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_shuffle_pd(a, b, imm8) simde_mm_shuffle_pd(a, b, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_shufflehi_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(a_.i16) / sizeof(a_.i16[0])) / 2) ; i++) { r_.i16[i] = a_.i16[i]; } for (size_t i = ((sizeof(a_.i16) / sizeof(a_.i16[0])) / 2) ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[((imm8 >> ((i - 4) * 2)) & 3) + 4]; } return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_shufflehi_epi16(a, imm8) _mm_shufflehi_epi16((a), (imm8)) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_STATEMENT_EXPR_) #define simde_mm_shufflehi_epi16(a, imm8) \ (__extension__ ({ \ int16x8_t simde_mm_shufflehi_epi16_a_ = simde__m128i_to_neon_i16(a); \ int16x8_t simde_mm_shufflehi_epi16_r_ = simde_mm_shufflehi_epi16_a_; \ simde_mm_shufflehi_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflehi_epi16_a_, (((imm8) ) & 0x3) + 4), simde_mm_shufflehi_epi16_r_, 4); \ simde_mm_shufflehi_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflehi_epi16_a_, (((imm8) >> 2) & 0x3) + 4), simde_mm_shufflehi_epi16_r_, 5); \ simde_mm_shufflehi_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflehi_epi16_a_, (((imm8) >> 4) & 0x3) + 4), simde_mm_shufflehi_epi16_r_, 6); \ simde_mm_shufflehi_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflehi_epi16_a_, (((imm8) >> 6) & 0x3) + 4), simde_mm_shufflehi_epi16_r_, 7); \ simde__m128i_from_neon_i16(simde_mm_shufflehi_epi16_r_); \ })) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_shufflehi_epi16(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ simde__m128i_from_private((simde__m128i_private) { .wasm_v128 = \ wasm_i16x8_shuffle( \ (simde_tmp_a_).wasm_v128, \ (simde_tmp_a_).wasm_v128, \ 0, 1, 2, 3, \ (((imm8) ) & 3) + 4, \ (((imm8) >> 2) & 3) + 4, \ (((imm8) >> 4) & 3) + 4, \ (((imm8) >> 6) & 3) + 4) }); })) #elif defined(SIMDE_SHUFFLE_VECTOR_) #define simde_mm_shufflehi_epi16(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ simde__m128i_from_private((simde__m128i_private) { .i16 = \ SIMDE_SHUFFLE_VECTOR_(16, 16, \ (simde_tmp_a_).i16, \ (simde_tmp_a_).i16, \ 0, 1, 2, 3, \ (((imm8) ) & 3) + 4, \ (((imm8) >> 2) & 3) + 4, \ (((imm8) >> 4) & 3) + 4, \ (((imm8) >> 6) & 3) + 4) }); })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_shufflehi_epi16(a, imm8) simde_mm_shufflehi_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_shufflelo_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); for (size_t i = 0 ; i < ((sizeof(r_.i16) / sizeof(r_.i16[0])) / 2) ; i++) { r_.i16[i] = a_.i16[((imm8 >> (i * 2)) & 3)]; } SIMDE_VECTORIZE for (size_t i = ((sizeof(a_.i16) / sizeof(a_.i16[0])) / 2) ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i]; } return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_shufflelo_epi16(a, imm8) _mm_shufflelo_epi16((a), (imm8)) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_shufflelo_epi16(a, imm8) \ simde__m128i_from_wasm_v128( \ wasm_i16x8_shuffle( \ simde__m128i_to_wasm_v128((a)), \ wasm_i16x8_splat(0), \ (((imm8) & 0x03) ), \ (((imm8) & 0x0c) >> 2), \ (((imm8) & 0x30) >> 4), \ (((imm8) & 0xc0) >> 6), \ 4, 5, 6, 7)) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_STATEMENT_EXPR_) #define simde_mm_shufflelo_epi16(a, imm8) \ (__extension__({ \ int16x8_t simde_mm_shufflelo_epi16_a_ = simde__m128i_to_neon_i16(a); \ int16x8_t simde_mm_shufflelo_epi16_r_ = simde_mm_shufflelo_epi16_a_; \ simde_mm_shufflelo_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflelo_epi16_a_, (((imm8) ) & 0x3)), simde_mm_shufflelo_epi16_r_, 0); \ simde_mm_shufflelo_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflelo_epi16_a_, (((imm8) >> 2) & 0x3)), simde_mm_shufflelo_epi16_r_, 1); \ simde_mm_shufflelo_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflelo_epi16_a_, (((imm8) >> 4) & 0x3)), simde_mm_shufflelo_epi16_r_, 2); \ simde_mm_shufflelo_epi16_r_ = vsetq_lane_s16(vgetq_lane_s16(simde_mm_shufflelo_epi16_a_, (((imm8) >> 6) & 0x3)), simde_mm_shufflelo_epi16_r_, 3); \ simde__m128i_from_neon_i16(simde_mm_shufflelo_epi16_r_); \ })) #elif defined(SIMDE_SHUFFLE_VECTOR_) #define simde_mm_shufflelo_epi16(a, imm8) (__extension__ ({ \ const simde__m128i_private simde_tmp_a_ = simde__m128i_to_private(a); \ simde__m128i_from_private((simde__m128i_private) { .i16 = \ SIMDE_SHUFFLE_VECTOR_(16, 16, \ (simde_tmp_a_).i16, \ (simde_tmp_a_).i16, \ (((imm8) ) & 3), \ (((imm8) >> 2) & 3), \ (((imm8) >> 4) & 3), \ (((imm8) >> 6) & 3), \ 4, 5, 6, 7) }); })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_shufflelo_epi16(a, imm8) simde_mm_shufflelo_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sll_epi16 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sll_epi16(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); if (count_.u64[0] > 15) return simde_mm_setzero_si128(); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u16 = (a_.u16 << count_.u64[0]); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vshlq_u16(a_.neon_u16, vdupq_n_s16(HEDLEY_STATIC_CAST(int16_t, count_.u64[0]))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = ((wasm_i64x2_extract_lane(count_.wasm_v128, 0) < 16) ? wasm_i16x8_shl(a_.wasm_v128, HEDLEY_STATIC_CAST(int32_t, wasm_i64x2_extract_lane(count_.wasm_v128, 0))) : wasm_i16x8_const(0,0,0,0,0,0,0,0)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = HEDLEY_STATIC_CAST(uint16_t, (a_.u16[i] << count_.u64[0])); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sll_epi16(a, count) simde_mm_sll_epi16((a), (count)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sll_epi32 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sll_epi32(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); if (count_.u64[0] > 31) return simde_mm_setzero_si128(); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u32 = (a_.u32 << count_.u64[0]); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vshlq_u32(a_.neon_u32, vdupq_n_s32(HEDLEY_STATIC_CAST(int32_t, count_.u64[0]))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = ((wasm_i64x2_extract_lane(count_.wasm_v128, 0) < 32) ? wasm_i32x4_shl(a_.wasm_v128, HEDLEY_STATIC_CAST(int32_t, wasm_i64x2_extract_lane(count_.wasm_v128, 0))) : wasm_i32x4_const(0,0,0,0)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = HEDLEY_STATIC_CAST(uint32_t, (a_.u32[i] << count_.u64[0])); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sll_epi32(a, count) (simde_mm_sll_epi32(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sll_epi64 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sll_epi64(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); if (count_.u64[0] > 63) return simde_mm_setzero_si128(); const int_fast16_t s = HEDLEY_STATIC_CAST(int_fast16_t, count_.u64[0]); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u64 = vshlq_u64(a_.neon_u64, vdupq_n_s64(HEDLEY_STATIC_CAST(int64_t, s))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = (s < 64) ? wasm_i64x2_shl(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, s)) : wasm_i64x2_const(0,0); #else #if !defined(SIMDE_BUG_GCC_94488) SIMDE_VECTORIZE #endif for (size_t i = 0 ; i < (sizeof(r_.u64) / sizeof(r_.u64[0])) ; i++) { r_.u64[i] = a_.u64[i] << s; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sll_epi64(a, count) (simde_mm_sll_epi64(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_sqrt_pd (simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sqrt_pd(a); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsqrtq_f64(a_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_sqrt(a_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) || defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) r_.altivec_f64 = vec_sqrt(a_.altivec_f64); #elif defined(simde_math_sqrt) SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = simde_math_sqrt(a_.f64[i]); } #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sqrt_pd(a) simde_mm_sqrt_pd(a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_sqrt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sqrt_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_sqrt_pd(b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_sqrt_pd(simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(simde_math_sqrt) r_.f64[0] = simde_math_sqrt(b_.f64[0]); r_.f64[1] = a_.f64[1]; #else HEDLEY_UNREACHABLE(); #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sqrt_sd(a, b) simde_mm_sqrt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srl_epi16 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_srl_epi16(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); const int cnt = HEDLEY_STATIC_CAST(int, (count_.i64[0] > 16 ? 16 : count_.i64[0])); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vshlq_u16(a_.neon_u16, vdupq_n_s16(HEDLEY_STATIC_CAST(int16_t, -cnt))); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u16) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = a_.u16[i] >> cnt; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srl_epi16(a, count) (simde_mm_srl_epi16(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srl_epi32 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_srl_epi32(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); const int cnt = HEDLEY_STATIC_CAST(int, (count_.i64[0] > 32 ? 32 : count_.i64[0])); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vshlq_u32(a_.neon_u32, vdupq_n_s32(HEDLEY_STATIC_CAST(int32_t, -cnt))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u32x4_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] >> cnt; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srl_epi32(a, count) (simde_mm_srl_epi32(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srl_epi64 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_srl_epi64(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); const int cnt = HEDLEY_STATIC_CAST(int, (count_.i64[0] > 64 ? 64 : count_.i64[0])); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u64 = vshlq_u64(a_.neon_u64, vdupq_n_s64(HEDLEY_STATIC_CAST(int64_t, -cnt))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u64x2_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else #if !defined(SIMDE_BUG_GCC_94488) SIMDE_VECTORIZE #endif for (size_t i = 0 ; i < (sizeof(r_.u64) / sizeof(r_.u64[0])) ; i++) { r_.u64[i] = a_.u64[i] >> cnt; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srl_epi64(a, count) (simde_mm_srl_epi64(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srai_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_RANGE(imm8, 0, 255) { /* MSVC requires a range of (0, 255). */ simde__m128i_private r_, a_ = simde__m128i_to_private(a); const int cnt = (imm8 & ~15) ? 15 : imm8; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vshlq_s16(a_.neon_i16, vdupq_n_s16(HEDLEY_STATIC_CAST(int16_t, -cnt))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] >> cnt; } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_srai_epi16(a, imm8) _mm_srai_epi16((a), (imm8)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srai_epi16(a, imm8) simde_mm_srai_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srai_epi32 (simde__m128i a, const int imm8) SIMDE_REQUIRE_RANGE(imm8, 0, 255) { /* MSVC requires a range of (0, 255). */ simde__m128i_private r_, a_ = simde__m128i_to_private(a); const int cnt = (imm8 & ~31) ? 31 : imm8; #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vshlq_s32(a_.neon_i32, vdupq_n_s32(-cnt)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] >> cnt; } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_srai_epi32(a, imm8) _mm_srai_epi32((a), (imm8)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srai_epi32(a, imm8) simde_mm_srai_epi32(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sra_epi16 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sra_epi16(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); const int cnt = HEDLEY_STATIC_CAST(int, (count_.i64[0] > 15 ? 15 : count_.i64[0])); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vshlq_s16(a_.neon_i16, vdupq_n_s16(HEDLEY_STATIC_CAST(int16_t, -cnt))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] >> cnt; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sra_epi16(a, count) (simde_mm_sra_epi16(a, count)) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sra_epi32 (simde__m128i a, simde__m128i count) { #if defined(SIMDE_X86_SSE2_NATIVE) && !defined(SIMDE_BUG_GCC_BAD_MM_SRA_EPI32) return _mm_sra_epi32(a, count); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), count_ = simde__m128i_to_private(count); const int cnt = count_.u64[0] > 31 ? 31 : HEDLEY_STATIC_CAST(int, count_.u64[0]); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vshlq_s32(a_.neon_i32, vdupq_n_s32(HEDLEY_STATIC_CAST(int32_t, -cnt))); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shr(a_.wasm_v128, HEDLEY_STATIC_CAST(uint32_t, cnt)); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] >> cnt; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sra_epi32(a, count) (simde_mm_sra_epi32(a, (count))) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_slli_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { if (HEDLEY_UNLIKELY((imm8 > 15))) { return simde_mm_setzero_si128(); } simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i16 = a_.i16 << SIMDE_CAST_VECTOR_SHIFT_COUNT(8, imm8 & 0xff); #else const int s = (imm8 > HEDLEY_STATIC_CAST(int, sizeof(r_.i16[0]) * CHAR_BIT) - 1) ? 0 : imm8; SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = HEDLEY_STATIC_CAST(int16_t, a_.i16[i] << s); } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_slli_epi16(a, imm8) _mm_slli_epi16(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_slli_epi16(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_i16( \ ((imm8) > 15) ? \ vandq_s16(simde__m128i_to_neon_i16(a), vdupq_n_s16(0)) : \ vshlq_n_s16(simde__m128i_to_neon_i16(a), ((imm8) & 15)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_slli_epi16(a, imm8) \ ((imm8 < 16) ? wasm_i16x8_shl(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i16x8_const(0,0,0,0,0,0,0,0)) #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #define simde_mm_slli_epi16(a, imm8) \ ((imm8 & ~15) ? simde_mm_setzero_si128() : simde__m128i_from_altivec_i16(vec_sl(simde__m128i_to_altivec_i16(a), vec_splat_u16(HEDLEY_STATIC_CAST(unsigned short, imm8))))) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_slli_epi16(a, imm8) simde_mm_slli_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_slli_epi32 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { if (HEDLEY_UNLIKELY((imm8 > 31))) { return simde_mm_setzero_si128(); } simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i32 = a_.i32 << imm8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] << (imm8 & 0xff); } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_slli_epi32(a, imm8) _mm_slli_epi32(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_slli_epi32(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_i32( \ ((imm8) > 31) ? \ vandq_s32(simde__m128i_to_neon_i32(a), vdupq_n_s32(0)) : \ vshlq_n_s32(simde__m128i_to_neon_i32(a), ((imm8) & 31)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_slli_epi32(a, imm8) \ ((imm8 < 32) ? wasm_i32x4_shl(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i32x4_const(0,0,0,0)) #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #define simde_mm_slli_epi32(a, imm8) \ (__extension__ ({ \ simde__m128i ret; \ if ((imm8) <= 0) { \ ret = a; \ } else if ((imm8) > 31) { \ ret = simde_mm_setzero_si128(); \ } else { \ ret = simde__m128i_from_altivec_i32( \ vec_sl(simde__m128i_to_altivec_i32(a), \ vec_splats(HEDLEY_STATIC_CAST(unsigned int, (imm8) & 31)))); \ } \ ret; \ })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_slli_epi32(a, imm8) simde_mm_slli_epi32(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_slli_epi64 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { if (HEDLEY_UNLIKELY((imm8 > 63))) { return simde_mm_setzero_si128(); } simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.i64 = a_.i64 << imm8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] << (imm8 & 0xff); } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_slli_epi64(a, imm8) _mm_slli_epi64(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_slli_epi64(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_i64( \ ((imm8) > 63) ? \ vandq_s64(simde__m128i_to_neon_i64(a), vdupq_n_s64(0)) : \ vshlq_n_s64(simde__m128i_to_neon_i64(a), ((imm8) & 63)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_slli_epi64(a, imm8) \ ((imm8 < 64) ? wasm_i64x2_shl(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i64x2_const(0,0)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_slli_epi64(a, imm8) simde_mm_slli_epi64(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srli_epi16 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { if (HEDLEY_UNLIKELY((imm8 > 15))) { return simde_mm_setzero_si128(); } simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u16 = a_.u16 >> SIMDE_CAST_VECTOR_SHIFT_COUNT(8, imm8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.u16[i] = a_.u16[i] >> (imm8 & 0xff); } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_srli_epi16(a, imm8) _mm_srli_epi16(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_srli_epi16(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_u16( \ ((imm8) > 15) ? \ vandq_u16(simde__m128i_to_neon_u16(a), vdupq_n_u16(0)) : \ vshrq_n_u16(simde__m128i_to_neon_u16(a), ((imm8) & 15) | (((imm8) & 15) == 0)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_srli_epi16(a, imm8) \ ((imm8 < 16) ? wasm_u16x8_shr(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i16x8_const(0,0,0,0,0,0,0,0)) #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #define simde_mm_srli_epi16(a, imm8) \ ((imm8 & ~15) ? simde_mm_setzero_si128() : simde__m128i_from_altivec_i16(vec_sr(simde__m128i_to_altivec_i16(a), vec_splat_u16(HEDLEY_STATIC_CAST(unsigned short, imm8))))) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srli_epi16(a, imm8) simde_mm_srli_epi16(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srli_epi32 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { if (HEDLEY_UNLIKELY((imm8 > 31))) { return simde_mm_setzero_si128(); } simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) r_.u32 = a_.u32 >> SIMDE_CAST_VECTOR_SHIFT_COUNT(8, imm8 & 0xff); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.u32[i] = a_.u32[i] >> (imm8 & 0xff); } #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_srli_epi32(a, imm8) _mm_srli_epi32(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_srli_epi32(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_u32( \ ((imm8) > 31) ? \ vandq_u32(simde__m128i_to_neon_u32(a), vdupq_n_u32(0)) : \ vshrq_n_u32(simde__m128i_to_neon_u32(a), ((imm8) & 31) | (((imm8) & 31) == 0)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_srli_epi32(a, imm8) \ ((imm8 < 32) ? wasm_u32x4_shr(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i32x4_const(0,0,0,0)) #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) #define simde_mm_srli_epi32(a, imm8) \ (__extension__ ({ \ simde__m128i ret; \ if ((imm8) <= 0) { \ ret = a; \ } else if ((imm8) > 31) { \ ret = simde_mm_setzero_si128(); \ } else { \ ret = simde__m128i_from_altivec_i32( \ vec_sr(simde__m128i_to_altivec_i32(a), \ vec_splats(HEDLEY_STATIC_CAST(unsigned int, (imm8) & 31)))); \ } \ ret; \ })) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srli_epi32(a, imm8) simde_mm_srli_epi32(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_srli_epi64 (simde__m128i a, const int imm8) SIMDE_REQUIRE_CONSTANT_RANGE(imm8, 0, 255) { simde__m128i_private r_, a_ = simde__m128i_to_private(a); if (HEDLEY_UNLIKELY((imm8 & 63) != imm8)) return simde_mm_setzero_si128(); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u64 = vshlq_u64(a_.neon_u64, vdupq_n_s64(-imm8)); #else #if defined(SIMDE_VECTOR_SUBSCRIPT_SCALAR) && !defined(SIMDE_BUG_GCC_94488) r_.u64 = a_.u64 >> SIMDE_CAST_VECTOR_SHIFT_COUNT(8, imm8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.u64[i] = a_.u64[i] >> imm8; } #endif #endif return simde__m128i_from_private(r_); } #if defined(SIMDE_X86_SSE2_NATIVE) #define simde_mm_srli_epi64(a, imm8) _mm_srli_epi64(a, imm8) #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define simde_mm_srli_epi64(a, imm8) \ (((imm8) <= 0) ? \ (a) : \ simde__m128i_from_neon_u64( \ ((imm8) > 63) ? \ vandq_u64(simde__m128i_to_neon_u64(a), vdupq_n_u64(0)) : \ vshrq_n_u64(simde__m128i_to_neon_u64(a), ((imm8) & 63) | (((imm8) & 63) == 0)))) #elif defined(SIMDE_WASM_SIMD128_NATIVE) #define simde_mm_srli_epi64(a, imm8) \ ((imm8 < 64) ? wasm_u64x2_shr(simde__m128i_to_private(a).wasm_v128, imm8) : wasm_i64x2_const(0,0)) #endif #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_srli_epi64(a, imm8) simde_mm_srli_epi64(a, imm8) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store_pd (simde_float64 mem_addr[HEDLEY_ARRAY_PARAM(2)], simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_store_pd(mem_addr, a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) vst1q_f64(mem_addr, simde__m128d_to_private(a).neon_f64); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_s64(HEDLEY_REINTERPRET_CAST(int64_t*, mem_addr), simde__m128d_to_private(a).neon_i64); #else simde_memcpy(SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128d), &a, sizeof(a)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_store_pd(mem_addr, a) simde_mm_store_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store1_pd (simde_float64 mem_addr[HEDLEY_ARRAY_PARAM(2)], simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_store1_pd(mem_addr, a); #else simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) vst1q_f64(mem_addr, vdupq_laneq_f64(a_.neon_f64, 0)); #else mem_addr[0] = a_.f64[0]; mem_addr[1] = a_.f64[0]; #endif #endif } #define simde_mm_store_pd1(mem_addr, a) simde_mm_store1_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_store1_pd(mem_addr, a) simde_mm_store1_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #define _mm_store_pd1(mem_addr, a) simde_mm_store_pd1(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store_sd (simde_float64* mem_addr, simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_store_sd(mem_addr, a); #else simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) const simde_float64 v = vgetq_lane_f64(a_.neon_f64, 0); simde_memcpy(mem_addr, &v, sizeof(v)); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) const int64_t v = vgetq_lane_s64(a_.neon_i64, 0); simde_memcpy(HEDLEY_REINTERPRET_CAST(int64_t*, mem_addr), &v, sizeof(v)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store64_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), a_.wasm_v128, 0); #else simde_float64 v = a_.f64[0]; simde_memcpy(mem_addr, &v, sizeof(simde_float64)); #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_store_sd(mem_addr, a) simde_mm_store_sd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_store_si128 (simde__m128i* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_store_si128(HEDLEY_STATIC_CAST(__m128i*, mem_addr), a); #else simde__m128i_private a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_s32(HEDLEY_REINTERPRET_CAST(int32_t*, mem_addr), a_.neon_i32); #else simde_memcpy(SIMDE_ALIGN_ASSUME_LIKE(mem_addr, simde__m128i), &a_, sizeof(a_)); #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_store_si128(mem_addr, a) simde_mm_store_si128(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeh_pd (simde_float64* mem_addr, simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storeh_pd(mem_addr, a); #else simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) *mem_addr = vgetq_lane_f64(a_.neon_f64, 1); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store64_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), a_.wasm_v128, 1); #else *mem_addr = a_.f64[1]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeh_pd(mem_addr, a) simde_mm_storeh_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storel_epi64 (simde__m128i* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storel_epi64(HEDLEY_STATIC_CAST(__m128i*, mem_addr), a); #else simde__m128i_private a_ = simde__m128i_to_private(a); int64_t tmp; /* memcpy to prevent aliasing, tmp because we can't take the * address of a vector element. */ #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) tmp = vgetq_lane_s64(a_.neon_i64, 0); #elif defined(SIMDE_POWER_ALTIVEC_P7_NATIVE) #if defined(SIMDE_BUG_GCC_95227) (void) a_; #endif tmp = vec_extract(a_.altivec_i64, 0); #else tmp = a_.i64[0]; #endif simde_memcpy(mem_addr, &tmp, sizeof(tmp)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storel_epi64(mem_addr, a) simde_mm_storel_epi64(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storel_pd (simde_float64* mem_addr, simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storel_pd(mem_addr, a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store64_lane(HEDLEY_REINTERPRET_CAST(void*, mem_addr), simde__m128d_to_wasm_v128(a), 0); #else simde__m128d_private a_ = simde__m128d_to_private(a); simde_float64 tmp; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) tmp = vgetq_lane_f64(a_.neon_f64, 0); #else tmp = a_.f64[0]; #endif simde_memcpy(mem_addr, &tmp, sizeof(tmp)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storel_pd(mem_addr, a) simde_mm_storel_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storer_pd (simde_float64 mem_addr[2], simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storer_pd(mem_addr, a); #else simde__m128d_private a_ = simde__m128d_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) vst1q_s64(HEDLEY_REINTERPRET_CAST(int64_t*, mem_addr), vextq_s64(a_.neon_i64, a_.neon_i64, 1)); #elif defined(SIMDE_WASM_SIMD128_NATIVE) a_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, a_.wasm_v128, 1, 0); simde_mm_store_pd(mem_addr, simde__m128d_from_private(a_)); #elif defined(SIMDE_SHUFFLE_VECTOR_) a_.f64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.f64, a_.f64, 1, 0); simde_mm_store_pd(mem_addr, simde__m128d_from_private(a_)); #else mem_addr[0] = a_.f64[1]; mem_addr[1] = a_.f64[0]; #endif #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storer_pd(mem_addr, a) simde_mm_storer_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_pd (simde_float64* mem_addr, simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storeu_pd(mem_addr, a); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) vst1q_f64(mem_addr, simde__m128d_to_private(a).neon_f64); #else simde_memcpy(mem_addr, &a, sizeof(a)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeu_pd(mem_addr, a) simde_mm_storeu_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_si128 (void* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_storeu_si128(HEDLEY_STATIC_CAST(__m128i*, mem_addr), a); #else simde_memcpy(mem_addr, &a, sizeof(a)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeu_si128(mem_addr, a) simde_mm_storeu_si128(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_si16 (void* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_GCC_VERSION_CHECK(11,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1)) _mm_storeu_si16(mem_addr, a); #else int16_t val = simde_x_mm_cvtsi128_si16(a); simde_memcpy(mem_addr, &val, sizeof(val)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeu_si16(mem_addr, a) simde_mm_storeu_si16(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_si32 (void* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_GCC_VERSION_CHECK(11,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1)) _mm_storeu_si32(mem_addr, a); #elif defined(SIMDE_WASM_SIMD128_NATIVE) wasm_v128_store32_lane(mem_addr, simde__m128i_to_wasm_v128(a), 0); #else int32_t val = simde_mm_cvtsi128_si32(a); simde_memcpy(mem_addr, &val, sizeof(val)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeu_si32(mem_addr, a) simde_mm_storeu_si32(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_storeu_si64 (void* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && ( \ SIMDE_DETECT_CLANG_VERSION_CHECK(8,0,0) || \ HEDLEY_GCC_VERSION_CHECK(11,0,0) || \ HEDLEY_INTEL_VERSION_CHECK(20,21,1)) _mm_storeu_si64(mem_addr, a); #else int64_t val = simde_mm_cvtsi128_si64(a); simde_memcpy(mem_addr, &val, sizeof(val)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_storeu_si64(mem_addr, a) simde_mm_storeu_si64(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_pd (simde_float64 mem_addr[HEDLEY_ARRAY_PARAM(2)], simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_stream_pd(mem_addr, a); #else simde_memcpy(mem_addr, &a, sizeof(a)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_stream_pd(mem_addr, a) simde_mm_stream_pd(HEDLEY_REINTERPRET_CAST(double*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_si128 (simde__m128i* mem_addr, simde__m128i a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) _mm_stream_si128(HEDLEY_STATIC_CAST(__m128i*, mem_addr), a); #else simde_memcpy(mem_addr, &a, sizeof(a)); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_stream_si128(mem_addr, a) simde_mm_stream_si128(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_si32 (int32_t* mem_addr, int32_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_stream_si32(mem_addr, a); #else *mem_addr = a; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_stream_si32(mem_addr, a) simde_mm_stream_si32(mem_addr, a) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_stream_si64 (int64_t* mem_addr, int64_t a) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_ARCH_AMD64) && !defined(HEDLEY_MSVC_VERSION) _mm_stream_si64(SIMDE_CHECKED_REINTERPRET_CAST(long long int*, int64_t*, mem_addr), a); #else *mem_addr = a; #endif } #define simde_mm_stream_si64x(mem_addr, a) simde_mm_stream_si64(mem_addr, a) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) || (defined(SIMDE_ENABLE_NATIVE_ALIASES) && !defined(SIMDE_ARCH_AMD64)) #define _mm_stream_si64(mem_addr, a) simde_mm_stream_si64(SIMDE_CHECKED_REINTERPRET_CAST(int64_t*, __int64*, mem_addr), a) #define _mm_stream_si64x(mem_addr, a) simde_mm_stream_si64(SIMDE_CHECKED_REINTERPRET_CAST(int64_t*, __int64*, mem_addr), a) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sub_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vsubq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_sub(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i8 = a_.i8 - b_.i8; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i8) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = a_.i8[i] - b_.i8[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_epi8(a, b) simde_mm_sub_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sub_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vsubq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_sub(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i16 = a_.i16 - b_.i16; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i16) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = a_.i16[i] - b_.i16[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_epi16(a, b) simde_mm_sub_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sub_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vsubq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_sub(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32 = a_.i32 - b_.i32; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32) / sizeof(r_.i32[0])) ; i++) { r_.i32[i] = a_.i32[i] - b_.i32[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_epi32(a, b) simde_mm_sub_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_sub_epi64 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_epi64(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vsubq_s64(a_.neon_i64, b_.neon_i64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_sub(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 - b_.i64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i64) / sizeof(r_.i64[0])) ; i++) { r_.i64[i] = a_.i64[i] - b_.i64[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_epi64(a, b) simde_mm_sub_epi64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_sub_epu32 (simde__m128i a, simde__m128i b) { simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.u32 = a_.u32 - b_.u32; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u32 = vsubq_u32(a_.neon_u32, b_.neon_u32); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.u32) / sizeof(r_.u32[0])) ; i++) { r_.u32[i] = a_.u32[i] - b_.u32[i]; } #endif return simde__m128i_from_private(r_); } SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_sub_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.f64 = a_.f64 - b_.f64; #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vsubq_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_sub(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = a_.f64[i] - b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_pd(a, b) simde_mm_sub_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_sub_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_sub_sd(a, b); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) && defined(SIMDE_FAST_EXCEPTIONS) return simde_mm_move_sd(a, simde_mm_sub_pd(a, b)); #elif (SIMDE_NATURAL_VECTOR_SIZE > 0) return simde_mm_move_sd(a, simde_mm_sub_pd(simde_x_mm_broadcastlow_pd(a), simde_x_mm_broadcastlow_pd(b))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); r_.f64[0] = a_.f64[0] - b_.f64[0]; r_.f64[1] = a_.f64[1]; return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_sd(a, b) simde_mm_sub_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m64 simde_mm_sub_si64 (simde__m64 a, simde__m64 b) { #if defined(SIMDE_X86_SSE2_NATIVE) && defined(SIMDE_X86_MMX_NATIVE) return _mm_sub_si64(a, b); #else simde__m64_private r_, a_ = simde__m64_to_private(a), b_ = simde__m64_to_private(b); #if defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i64 = a_.i64 - b_.i64; #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i64 = vsub_s64(a_.neon_i64, b_.neon_i64); #else r_.i64[0] = a_.i64[0] - b_.i64[0]; #endif return simde__m64_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_sub_si64(a, b) simde_mm_sub_si64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_subs_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_subs_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i8 = vqsubq_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_sub_sat(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.i8[0])) ; i++) { r_.i8[i] = simde_math_subs_i8(a_.i8[i], b_.i8[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_subs_epi8(a, b) simde_mm_subs_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_subs_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_subs_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i16 = vqsubq_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_sub_sat(a_.wasm_v128, b_.wasm_v128); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.i16[0])) ; i++) { r_.i16[i] = simde_math_subs_i16(a_.i16[i], b_.i16[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_subs_epi16(a, b) simde_mm_subs_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_subs_epu8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_subs_epu8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u8 = vqsubq_u8(a_.neon_u8, b_.neon_u8); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u8x16_sub_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_u8 = vec_subs(a_.altivec_u8, b_.altivec_u8); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.u8[0])) ; i++) { r_.u8[i] = simde_math_subs_u8(a_.u8[i], b_.u8[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_subs_epu8(a, b) simde_mm_subs_epu8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_subs_epu16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_subs_epu16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_u16 = vqsubq_u16(a_.neon_u16, b_.neon_u16); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_u16x8_sub_sat(a_.wasm_v128, b_.wasm_v128); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_u16 = vec_subs(a_.altivec_u16, b_.altivec_u16); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_) / sizeof(r_.u16[0])) ; i++) { r_.u16[i] = simde_math_subs_u16(a_.u16[i], b_.u16[i]); } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_subs_epu16(a, b) simde_mm_subs_epu16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomieq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomieq_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_or_b_nan = vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(vandq_u64(a_not_nan, b_not_nan)))); uint64x2_t a_eq_b = vceqq_f64(a_.neon_f64, b_.neon_f64); r = !!(vgetq_lane_u64(vorrq_u64(a_or_b_nan, a_eq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) == wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] == b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] == b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomieq_sd(a, b) simde_mm_ucomieq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomige_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomige_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_and_b_not_nan = vandq_u64(a_not_nan, b_not_nan); uint64x2_t a_ge_b = vcgeq_f64(a_.neon_f64, b_.neon_f64); r = !!(vgetq_lane_u64(vandq_u64(a_and_b_not_nan, a_ge_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) >= wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] >= b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] >= b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomige_sd(a, b) simde_mm_ucomige_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomigt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomigt_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_and_b_not_nan = vandq_u64(a_not_nan, b_not_nan); uint64x2_t a_gt_b = vcgtq_f64(a_.neon_f64, b_.neon_f64); r = !!(vgetq_lane_u64(vandq_u64(a_and_b_not_nan, a_gt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) > wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] > b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] > b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomigt_sd(a, b) simde_mm_ucomigt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomile_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomile_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_or_b_nan = vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(vandq_u64(a_not_nan, b_not_nan)))); uint64x2_t a_le_b = vcleq_f64(a_.neon_f64, b_.neon_f64); r = !!(vgetq_lane_u64(vorrq_u64(a_or_b_nan, a_le_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) <= wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] <= b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] <= b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomile_sd(a, b) simde_mm_ucomile_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomilt_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomilt_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_or_b_nan = vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(vandq_u64(a_not_nan, b_not_nan)))); uint64x2_t a_lt_b = vcltq_f64(a_.neon_f64, b_.neon_f64); r = !!(vgetq_lane_u64(vorrq_u64(a_or_b_nan, a_lt_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) < wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] < b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] < b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomilt_sd(a, b) simde_mm_ucomilt_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES int simde_mm_ucomineq_sd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_ucomineq_sd(a, b); #else simde__m128d_private a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); int r; #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) uint64x2_t a_not_nan = vceqq_f64(a_.neon_f64, a_.neon_f64); uint64x2_t b_not_nan = vceqq_f64(b_.neon_f64, b_.neon_f64); uint64x2_t a_and_b_not_nan = vandq_u64(a_not_nan, b_not_nan); uint64x2_t a_neq_b = vreinterpretq_u64_u32(vmvnq_u32(vreinterpretq_u32_u64(vceqq_f64(a_.neon_f64, b_.neon_f64)))); r = !!(vgetq_lane_u64(vandq_u64(a_and_b_not_nan, a_neq_b), 0) != 0); #elif defined(SIMDE_WASM_SIMD128_NATIVE) return wasm_f64x2_extract_lane(a_.wasm_v128, 0) != wasm_f64x2_extract_lane(b_.wasm_v128, 0); #elif defined(SIMDE_HAVE_FENV_H) fenv_t envp; int x = feholdexcept(&envp); r = a_.f64[0] != b_.f64[0]; if (HEDLEY_LIKELY(x == 0)) fesetenv(&envp); #else r = a_.f64[0] != b_.f64[0]; #endif return r; #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_ucomineq_sd(a, b) simde_mm_ucomineq_sd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_lfence (void) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_lfence(); #else simde_mm_sfence(); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_lfence() simde_mm_lfence() #endif SIMDE_FUNCTION_ATTRIBUTES void simde_mm_mfence (void) { #if defined(SIMDE_X86_SSE2_NATIVE) _mm_mfence(); #else simde_mm_sfence(); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_mfence() simde_mm_mfence() #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpackhi_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpackhi_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i8 = vzip2q_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int8x8_t a1 = vreinterpret_s8_s16(vget_high_s16(a_.neon_i16)); int8x8_t b1 = vreinterpret_s8_s16(vget_high_s16(b_.neon_i16)); int8x8x2_t result = vzip_s8(a1, b1); r_.neon_i8 = vcombine_s8(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_shuffle(a_.wasm_v128, b_.wasm_v128, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i8 = SIMDE_SHUFFLE_VECTOR_(8, 16, a_.i8, b_.i8, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i8[0])) / 2) ; i++) { r_.i8[(i * 2)] = a_.i8[i + ((sizeof(r_) / sizeof(r_.i8[0])) / 2)]; r_.i8[(i * 2) + 1] = b_.i8[i + ((sizeof(r_) / sizeof(r_.i8[0])) / 2)]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpackhi_epi8(a, b) simde_mm_unpackhi_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpackhi_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpackhi_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i16 = vzip2q_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int16x4_t a1 = vget_high_s16(a_.neon_i16); int16x4_t b1 = vget_high_s16(b_.neon_i16); int16x4x2_t result = vzip_s16(a1, b1); r_.neon_i16 = vcombine_s16(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_shuffle(a_.wasm_v128, b_.wasm_v128, 4, 12, 5, 13, 6, 14, 7, 15); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i16 = SIMDE_SHUFFLE_VECTOR_(16, 16, a_.i16, b_.i16, 4, 12, 5, 13, 6, 14, 7, 15); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i16[0])) / 2) ; i++) { r_.i16[(i * 2)] = a_.i16[i + ((sizeof(r_) / sizeof(r_.i16[0])) / 2)]; r_.i16[(i * 2) + 1] = b_.i16[i + ((sizeof(r_) / sizeof(r_.i16[0])) / 2)]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpackhi_epi16(a, b) simde_mm_unpackhi_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpackhi_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpackhi_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i32 = vzip2q_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int32x2_t a1 = vget_high_s32(a_.neon_i32); int32x2_t b1 = vget_high_s32(b_.neon_i32); int32x2x2_t result = vzip_s32(a1, b1); r_.neon_i32 = vcombine_s32(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shuffle(a_.wasm_v128, b_.wasm_v128, 2, 6, 3, 7); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.i32, b_.i32, 2, 6, 3, 7); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i32[0])) / 2) ; i++) { r_.i32[(i * 2)] = a_.i32[i + ((sizeof(r_) / sizeof(r_.i32[0])) / 2)]; r_.i32[(i * 2) + 1] = b_.i32[i + ((sizeof(r_) / sizeof(r_.i32[0])) / 2)]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpackhi_epi32(a, b) simde_mm_unpackhi_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpackhi_epi64 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpackhi_epi64(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) int64x1_t a_h = vget_high_s64(a_.neon_i64); int64x1_t b_h = vget_high_s64(b_.neon_i64); r_.neon_i64 = vcombine_s64(a_h, b_h); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, b_.wasm_v128, 1, 3); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.i64, b_.i64, 1, 3); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i64[0])) / 2) ; i++) { r_.i64[(i * 2)] = a_.i64[i + ((sizeof(r_) / sizeof(r_.i64[0])) / 2)]; r_.i64[(i * 2) + 1] = b_.i64[i + ((sizeof(r_) / sizeof(r_.i64[0])) / 2)]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpackhi_epi64(a, b) simde_mm_unpackhi_epi64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_unpackhi_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpackhi_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vzip2q_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, b_.wasm_v128, 1, 3); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.f64, b_.f64, 1, 3); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.f64[0])) / 2) ; i++) { r_.f64[(i * 2)] = a_.f64[i + ((sizeof(r_) / sizeof(r_.f64[0])) / 2)]; r_.f64[(i * 2) + 1] = b_.f64[i + ((sizeof(r_) / sizeof(r_.f64[0])) / 2)]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpackhi_pd(a, b) simde_mm_unpackhi_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpacklo_epi8 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpacklo_epi8(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i8 = vzip1q_s8(a_.neon_i8, b_.neon_i8); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int8x8_t a1 = vreinterpret_s8_s16(vget_low_s16(a_.neon_i16)); int8x8_t b1 = vreinterpret_s8_s16(vget_low_s16(b_.neon_i16)); int8x8x2_t result = vzip_s8(a1, b1); r_.neon_i8 = vcombine_s8(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i8x16_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i8 = SIMDE_SHUFFLE_VECTOR_(8, 16, a_.i8, b_.i8, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i8[0])) / 2) ; i++) { r_.i8[(i * 2)] = a_.i8[i]; r_.i8[(i * 2) + 1] = b_.i8[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpacklo_epi8(a, b) simde_mm_unpacklo_epi8(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpacklo_epi16 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpacklo_epi16(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i16 = vzip1q_s16(a_.neon_i16, b_.neon_i16); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int16x4_t a1 = vget_low_s16(a_.neon_i16); int16x4_t b1 = vget_low_s16(b_.neon_i16); int16x4x2_t result = vzip_s16(a1, b1); r_.neon_i16 = vcombine_s16(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i16x8_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 8, 1, 9, 2, 10, 3, 11); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i16 = SIMDE_SHUFFLE_VECTOR_(16, 16, a_.i16, b_.i16, 0, 8, 1, 9, 2, 10, 3, 11); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i16[0])) / 2) ; i++) { r_.i16[(i * 2)] = a_.i16[i]; r_.i16[(i * 2) + 1] = b_.i16[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpacklo_epi16(a, b) simde_mm_unpacklo_epi16(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpacklo_epi32 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpacklo_epi32(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_i32 = vzip1q_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_ARM_NEON_A32V7_NATIVE) int32x2_t a1 = vget_low_s32(a_.neon_i32); int32x2_t b1 = vget_low_s32(b_.neon_i32); int32x2x2_t result = vzip_s32(a1, b1); r_.neon_i32 = vcombine_s32(result.val[0], result.val[1]); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i32x4_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 4, 1, 5); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i32 = SIMDE_SHUFFLE_VECTOR_(32, 16, a_.i32, b_.i32, 0, 4, 1, 5); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i32[0])) / 2) ; i++) { r_.i32[(i * 2)] = a_.i32[i]; r_.i32[(i * 2) + 1] = b_.i32[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpacklo_epi32(a, b) simde_mm_unpacklo_epi32(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_unpacklo_epi64 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpacklo_epi64(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) int64x1_t a_l = vget_low_s64(a_.neon_i64); int64x1_t b_l = vget_low_s64(b_.neon_i64); r_.neon_i64 = vcombine_s64(a_l, b_l); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 2); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.i64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.i64, b_.i64, 0, 2); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.i64[0])) / 2) ; i++) { r_.i64[(i * 2)] = a_.i64[i]; r_.i64[(i * 2) + 1] = b_.i64[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpacklo_epi64(a, b) simde_mm_unpacklo_epi64(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_mm_unpacklo_pd (simde__m128d a, simde__m128d b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_unpacklo_pd(a, b); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a), b_ = simde__m128d_to_private(b); #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vzip1q_f64(a_.neon_f64, b_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_i64x2_shuffle(a_.wasm_v128, b_.wasm_v128, 0, 2); #elif defined(SIMDE_SHUFFLE_VECTOR_) r_.f64 = SIMDE_SHUFFLE_VECTOR_(64, 16, a_.f64, b_.f64, 0, 2); #else SIMDE_VECTORIZE for (size_t i = 0 ; i < ((sizeof(r_) / sizeof(r_.f64[0])) / 2) ; i++) { r_.f64[(i * 2)] = a_.f64[i]; r_.f64[(i * 2) + 1] = b_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_unpacklo_pd(a, b) simde_mm_unpacklo_pd(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128d simde_x_mm_negate_pd(simde__m128d a) { #if defined(SIMDE_X86_SSE2_NATIVE) return simde_mm_xor_pd(a, _mm_set1_pd(SIMDE_FLOAT64_C(-0.0))); #else simde__m128d_private r_, a_ = simde__m128d_to_private(a); #if defined(SIMDE_POWER_ALTIVEC_P8_NATIVE) && \ (!defined(HEDLEY_GCC_VERSION) || HEDLEY_GCC_VERSION_CHECK(8,1,0)) r_.altivec_f64 = vec_neg(a_.altivec_f64); #elif defined(SIMDE_ARM_NEON_A64V8_NATIVE) r_.neon_f64 = vnegq_f64(a_.neon_f64); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_f64x2_neg(a_.wasm_v128); #elif defined(SIMDE_VECTOR_NEGATE) r_.f64 = -a_.f64; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.f64) / sizeof(r_.f64[0])) ; i++) { r_.f64[i] = -a_.f64[i]; } #endif return simde__m128d_from_private(r_); #endif } SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_mm_xor_si128 (simde__m128i a, simde__m128i b) { #if defined(SIMDE_X86_SSE2_NATIVE) return _mm_xor_si128(a, b); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a), b_ = simde__m128i_to_private(b); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = veorq_s32(a_.neon_i32, b_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_xor(a_.altivec_i32, b_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_xor(b_.wasm_v128, a_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = a_.i32f ^ b_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = a_.i32f[i] ^ b_.i32f[i]; } #endif return simde__m128i_from_private(r_); #endif } #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _mm_xor_si128(a, b) simde_mm_xor_si128(a, b) #endif SIMDE_FUNCTION_ATTRIBUTES simde__m128i simde_x_mm_not_si128 (simde__m128i a) { #if defined(SIMDE_X86_AVX512VL_NATIVE) return _mm_ternarylogic_epi32(a, a, a, 0x55); #else simde__m128i_private r_, a_ = simde__m128i_to_private(a); #if defined(SIMDE_ARM_NEON_A32V7_NATIVE) r_.neon_i32 = vmvnq_s32(a_.neon_i32); #elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE) r_.altivec_i32 = vec_nor(a_.altivec_i32, a_.altivec_i32); #elif defined(SIMDE_WASM_SIMD128_NATIVE) r_.wasm_v128 = wasm_v128_not(a_.wasm_v128); #elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS) r_.i32f = ~a_.i32f; #else SIMDE_VECTORIZE for (size_t i = 0 ; i < (sizeof(r_.i32f) / sizeof(r_.i32f[0])) ; i++) { r_.i32f[i] = ~(a_.i32f[i]); } #endif return simde__m128i_from_private(r_); #endif } #define SIMDE_MM_SHUFFLE2(x, y) (((x) << 1) | (y)) #if defined(SIMDE_X86_SSE2_ENABLE_NATIVE_ALIASES) #define _MM_SHUFFLE2(x, y) SIMDE_MM_SHUFFLE2(x, y) #endif SIMDE_END_DECLS_ HEDLEY_DIAGNOSTIC_POP #endif /* !defined(SIMDE_X86_SSE2_H) */ /* :: End x86/sse2.h :: */ scikit-bio-0.5.9/skbio/000077500000000000000000000000001446255456000147045ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/__init__.py000066400000000000000000000044311446255456000170170ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- # Add skbio.io to sys.modules to prevent cycles in our imports import skbio.io # noqa # imports included for convenience from skbio.sequence import Sequence, DNA, RNA, Protein, GeneticCode from skbio.stats.distance import DistanceMatrix from skbio.alignment import local_pairwise_align_ssw, TabularMSA from skbio.tree import TreeNode, nj from skbio.io import read, write from skbio.stats.ordination import OrdinationResults import skbio.diversity # noqa import skbio.stats.evolve # noqa __all__ = ['Sequence', 'DNA', 'RNA', 'Protein', 'GeneticCode', 'DistanceMatrix', 'local_pairwise_align_ssw', 'TabularMSA', 'TreeNode', 'nj', 'read', 'write', 'OrdinationResults'] __credits__ = "https://github.com/biocore/scikit-bio/graphs/contributors" __version__ = "0.5.9" mottos = [ # 03/15/2014 "It's gonna get weird, bro.", # 05/14/2014 "no cog yay", # 03/18/2015 "bincount!", ] motto = mottos[-1] # Created at patorjk.com title = r""" * * _ _ _ _ _ _ (_) | (_) | | | (_) ___ ___ _| | ___| |_ ______| |__ _ ___ / __|/ __| | |/ / | __|______| '_ \| |/ _ \ \__ \ (__| | <| | |_ | |_) | | (_) | |___/\___|_|_|\_\_|\__| |_.__/|_|\___/ * * """ # Created by @gregcaporaso art = r""" Opisthokonta \ Amoebozoa \ / * Euryarchaeota \ |_ Crenarchaeota \ * \ / * / / / * / \ / \ Proteobacteria \ Cyanobacteria """ if __doc__ is None: __doc__ = title + art else: __doc__ = title + art + __doc__ scikit-bio-0.5.9/skbio/_base.py000066400000000000000000000032271446255456000163330ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import abc class SkbioObject(metaclass=abc.ABCMeta): """Abstract base class defining core API common to all scikit-bio objects. Public scikit-bio classes should subclass this class to ensure a common, core API is present. All abstract methods and properties defined here must be implemented in subclasses, otherwise they will not be instantiable. """ @abc.abstractmethod def __str__(self): raise NotImplementedError class ElasticLines: """Store blocks of content separated by dashed lines. Each dashed line (separator) is as long as the longest content (non-separator) line. """ def __init__(self): self._lines = [] self._separator_idxs = [] self._max_line_len = -1 def add_line(self, line): line_len = len(line) if line_len > self._max_line_len: self._max_line_len = line_len self._lines.append(line) def add_lines(self, lines): for line in lines: self.add_line(line) def add_separator(self): self._lines.append(None) self._separator_idxs.append(len(self._lines) - 1) def to_str(self): separator = '-' * self._max_line_len for idx in self._separator_idxs: self._lines[idx] = separator return '\n'.join(self._lines) scikit-bio-0.5.9/skbio/alignment/000077500000000000000000000000001446255456000166625ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/alignment/__init__.py000066400000000000000000000147241446255456000210030ustar00rootroot00000000000000r""" Alignments (:mod:`skbio.alignment`) =================================== .. currentmodule:: skbio.alignment This module provides functionality for computing and manipulating sequence alignments. DNA, RNA, and protein sequences can be aligned, as well as sequences with custom alphabets. Data Structures --------------- .. autosummary:: :toctree: generated/ TabularMSA Optimized (i.e., production-ready) Alignment Algorithms ------------------------------------------------------- .. autosummary:: :toctree: generated/ StripedSmithWaterman AlignmentStructure local_pairwise_align_ssw Slow (i.e., educational-purposes only) Alignment Algorithms ----------------------------------------------------------- .. autosummary:: :toctree: generated/ global_pairwise_align_nucleotide global_pairwise_align_protein global_pairwise_align local_pairwise_align_nucleotide local_pairwise_align_protein local_pairwise_align General functionality --------------------- .. autosummary:: :toctree: generated/ make_identity_substitution_matrix Data Structure Examples ----------------------- Load two DNA sequences that have been previously aligned into a ``TabularMSA`` object, using sequence IDs as the MSA's index: >>> from skbio import TabularMSA, DNA >>> seqs = [DNA("ACC--G-GGTA..", metadata={'id': "seq1"}), ... DNA("TCC--G-GGCA..", metadata={'id': "seq2"})] >>> msa = TabularMSA(seqs, minter='id') >>> msa TabularMSA[DNA] ---------------------- Stats: sequence count: 2 position count: 13 ---------------------- ACC--G-GGTA.. TCC--G-GGCA.. >>> msa.index Index(['seq1', 'seq2'], dtype='object') Alignment Algorithm Examples ---------------------------- Optimized Alignment Algorithm Examples -------------------------------------- Using the convenient ``local_pairwise_align_ssw`` function: >>> from skbio.alignment import local_pairwise_align_ssw >>> alignment, score, start_end_positions = local_pairwise_align_ssw( ... DNA("ACTAAGGCTCTCTACCCCTCTCAGAGA"), ... DNA("ACTAAGGCTCCTAACCCCCTTTTCTCAGA") ... ) >>> alignment TabularMSA[DNA] ------------------------------ Stats: sequence count: 2 position count: 30 ------------------------------ ACTAAGGCTCTCT-ACCCC----TCTCAGA ACTAAGGCTC-CTAACCCCCTTTTCTCAGA >>> score 27 >>> start_end_positions [(0, 24), (0, 28)] Using the ``StripedSmithWaterman`` object: >>> from skbio.alignment import StripedSmithWaterman >>> query = StripedSmithWaterman("ACTAAGGCTCTCTACCCCTCTCAGAGA") >>> alignment = query("AAAAAACTCTCTAAACTCACTAAGGCTCTCTACCCCTCTTCAGAGAAGTCGA") >>> print(alignment) ACTAAGGCTC... ACTAAGGCTC... Score: 49 Length: 28 Using the ``StripedSmithWaterman`` object for multiple targets in an efficient way and finding the aligned sequence representations: >>> from skbio.alignment import StripedSmithWaterman >>> alignments = [] >>> target_sequences = [ ... "GCTAACTAGGCTCCCTTCTACCCCTCTCAGAGA", ... "GCCCAGTAGCTTCCCAATATGAGAGCATCAATTGTAGATCGGGCC", ... "TCTATAAGATTCCGCATGCGTTACTTATAAGATGTCTCAACGG", ... "TAGAGATTAATTGCCACTGCCAAAATTCTG" ... ] >>> query_sequence = "ACTAAGGCTCTCTACCCCTCTCAGAGA" >>> query = StripedSmithWaterman(query_sequence) >>> for target_sequence in target_sequences: ... alignment = query(target_sequence) ... alignments.append(alignment) ... >>> print(alignments[0]) ACTAAGGCTC... ACT-AGGCTC... Score: 38 Length: 30 >>> print(alignments[0].aligned_query_sequence) ACTAAGGCTC---TCTACCCCTCTCAGAGA >>> print(alignments[0].aligned_target_sequence) ACT-AGGCTCCCTTCTACCCCTCTCAGAGA Slow Alignment Algorithm Examples --------------------------------- scikit-bio also provides pure-Python implementations of Smith-Waterman and Needleman-Wunsch alignment. These are much slower than the methods described above, but serve as useful educational examples as they're simpler to experiment with. Functions are provided for local and global alignment of protein and nucleotide sequences. The ``global*`` and ``local*`` functions differ in the underlying algorithm that is applied (``global*`` uses Needleman- Wunsch while ``local*`` uses Smith-Waterman), and ``*protein`` and ``*nucleotide`` differ in their default scoring of matches, mismatches, and gaps. Here we locally align a pair of protein sequences using gap open penalty of 11 and a gap extend penalty of 1 (in other words, it is much more costly to open a new gap than extend an existing one). >>> from skbio import Protein >>> from skbio.alignment import local_pairwise_align_protein >>> s1 = Protein("HEAGAWGHEE") >>> s2 = Protein("PAWHEAE") >>> alignment, score, start_end_positions = local_pairwise_align_protein( ... s1, s2, 11, 1) This returns an ``skbio.TabularMSA`` object, the alignment score, and start/end positions of each aligned sequence: >>> alignment TabularMSA[Protein] --------------------- Stats: sequence count: 2 position count: 5 --------------------- AWGHE AW-HE >>> score 25.0 >>> start_end_positions [(4, 8), (1, 4)] Similarly, we can perform global alignment of nucleotide sequences: >>> from skbio import DNA >>> from skbio.alignment import global_pairwise_align_nucleotide >>> s1 = DNA("GCGTGCCTAAGGTATGCAAG") >>> s2 = DNA("ACGTGCCTAGGTACGCAAG") >>> alignment, score, start_end_positions = global_pairwise_align_nucleotide( ... s1, s2) >>> alignment TabularMSA[DNA] ---------------------- Stats: sequence count: 2 position count: 20 ---------------------- GCGTGCCTAAGGTATGCAAG ACGTGCCTA-GGTACGCAAG """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._tabular_msa import TabularMSA from ._pairwise import ( local_pairwise_align_nucleotide, local_pairwise_align_protein, local_pairwise_align, global_pairwise_align_nucleotide, global_pairwise_align_protein, global_pairwise_align, make_identity_substitution_matrix, local_pairwise_align_ssw ) from skbio.alignment._ssw_wrapper import ( StripedSmithWaterman, AlignmentStructure) __all__ = ['TabularMSA', 'StripedSmithWaterman', 'AlignmentStructure', 'local_pairwise_align_ssw', 'global_pairwise_align', 'global_pairwise_align_nucleotide', 'global_pairwise_align_protein', 'local_pairwise_align', 'local_pairwise_align_nucleotide', 'local_pairwise_align_protein', 'make_identity_substitution_matrix'] scikit-bio-0.5.9/skbio/alignment/_indexing.py000066400000000000000000000206031446255456000212010ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from abc import ABCMeta, abstractmethod import collections.abc import numpy as np import pandas as pd class _Indexing(metaclass=ABCMeta): def __init__(self, instance, axis=None): self._obj = instance self._axis = axis def __call__(self, axis=None): """Set the axis to index on.""" # verify axis param, discard value self._obj._is_sequence_axis(axis) return self.__class__(self._obj, axis=axis) def __getitem__(self, indexable): if self._axis is not None: if self._obj._is_sequence_axis(self._axis): return self._slice_on_first_axis(self._obj, indexable) else: return self._slice_on_second_axis(self._obj, indexable) if type(indexable) is tuple: if len(indexable) > 2: raise ValueError("Can only slice on two axes. Tuple is length:" " %r" % len(indexable)) elif len(indexable) > 1: return self._handle_both_axes(*indexable) else: indexable, = indexable return self._slice_on_first_axis(self._obj, indexable) def _handle_both_axes(self, seq_index, pos_index): seq_index = self._convert_ellipsis(seq_index) pos_index = self._convert_ellipsis(pos_index) if not hasattr(seq_index, '__iter__') and seq_index == slice(None): # Only slice second axis return self._slice_on_second_axis(self._obj, pos_index) else: r = self._slice_on_first_axis(self._obj, seq_index) if type(r) is self._obj.dtype: # [1, 1] [1, *] return r[pos_index] else: # [*, 1] [*, *] return self._slice_on_second_axis(r, pos_index) def _slice_on_second_axis(self, obj, indexable): indexable = self._convert_ellipsis(indexable) if self.is_scalar(indexable, axis=1): # [..., 1] return self._get_position(obj, indexable) else: # [..., *] return self._slice_positions(obj, indexable) def _slice_on_first_axis(self, obj, indexable): indexable = self._convert_ellipsis(indexable) if self.is_scalar(indexable, axis=0): # [1] return self._get_sequence(obj, indexable) else: # [*] return self._slice_sequences(obj, indexable) def _convert_ellipsis(self, indexable): if indexable is Ellipsis: return slice(None) return indexable @abstractmethod def is_scalar(self, indexable, axis): raise NotImplementedError @abstractmethod def _get_sequence(self, obj, indexable): raise NotImplementedError @abstractmethod def _slice_sequences(self, obj, indexable): raise NotImplementedError def _get_position(self, obj, indexable): return obj._get_position_(indexable) def _slice_positions(self, obj, indexable): indexable = self._assert_bool_vector_right_size(indexable, axis=1) indexable = self._convert_iterable_of_slices(indexable) return obj._slice_positions_(indexable) def _convert_iterable_of_slices(self, indexable): # _assert_bool_vector_right_size will have converted the iterable to # an ndarray if it wasn't yet. if isinstance(indexable, np.ndarray) and indexable.dtype == object: indexable = np.r_[tuple(indexable)] return indexable def _assert_bool_vector_right_size(self, indexable, axis): if isinstance(indexable, np.ndarray): pass elif hasattr(indexable, '__iter__'): indexable = np.asarray(list(indexable)) else: return indexable if indexable.dtype == bool and len(indexable) != self._obj.shape[axis]: raise IndexError("Boolean index's length (%r) does not match the" " axis length (%r)" % (len(indexable), self._obj.shape[axis])) return indexable class TabularMSAILoc(_Indexing): def is_scalar(self, indexable, axis): return np.isscalar(indexable) def _get_sequence(self, obj, indexable): return obj._get_sequence_iloc_(indexable) def _slice_sequences(self, obj, indexable): indexable = self._assert_bool_vector_right_size(indexable, axis=0) indexable = self._convert_iterable_of_slices(indexable) return obj._slice_sequences_iloc_(indexable) class TabularMSALoc(_Indexing): def is_scalar(self, indexable, axis): """ Sometimes (MultiIndex!) something that looks like a scalar, isn't and vice-versa. Consider: A 0 1 2 B 0 1 2 'A' looks like a scalar, but isn't. ('A', 0) doesn't look like a scalar, but it is. """ index = self._obj.index complete_key = False partial_key = False duplicated_key = False if not isinstance(indexable, collections.abc.Hashable): return False if axis == 0 and self._has_fancy_index(): try: if type(indexable) is tuple: complete_key = (len(indexable) == len(index.levshape) and indexable in index) partial_key = not complete_key and indexable in index except TypeError: # Unhashable type, no biggie pass if index.has_duplicates: # for a given Index object index, # index[index.duplicated()].unique() is pandas' recommended # replacement for index.get_duplicates(), per the pandas 0.23 docs duplicated_key = indexable in index[index.duplicated()].unique() return (not duplicated_key and ((np.isscalar(indexable) and not partial_key) or complete_key)) def _get_sequence(self, obj, indexable): self._assert_tuple_rules(indexable) return obj._get_sequence_loc_(indexable) def _slice_sequences(self, obj, indexable): self._assert_tuple_rules(indexable) if (self._has_fancy_index() and type(indexable) is not tuple and pd.api.types.is_list_like(indexable) and len(indexable) > 0): if not self.is_scalar(indexable[0], axis=0): raise TypeError("A list is used with complete labels, try" " using a tuple to indicate independent" " selections of a `pd.MultiIndex`.") # prevents # pd.Series.loc[['x', 'b', 'b', 'a']] from being interepereted as # pd.Series.loc[[('a', 0), ('b', 1)]] who knows why it does this. elif indexable[0] not in self._obj.index: raise KeyError(repr(indexable[0])) # pandas acts normal if the first element is actually a scalar self._assert_bool_vector_right_size(indexable, axis=0) return obj._slice_sequences_loc_(indexable) def _assert_tuple_rules(self, indexable): # pandas is scary in what it will accept sometimes... if type(indexable) is tuple: if not self._has_fancy_index(): # prevents unfriendly errors raise TypeError("Cannot provide a tuple to the first axis of" " `loc` unless the MSA's `index` is a" " `pd.MultiIndex`.") elif self.is_scalar(indexable[0], axis=0): # prevents unreasonable results # pd.Series.loc[('a', 0), ('b', 1)] would be interpreted as # pd.Series.loc[('a', 1)] which is horrifying. raise TypeError("A tuple provided to the first axis of `loc`" " represents a selection for each index of a" " `pd.MultiIndex`; it should not contain a" " complete label.") def _has_fancy_index(self): return hasattr(self._obj.index, 'levshape') scikit-bio-0.5.9/skbio/alignment/_lib/000077500000000000000000000000001446255456000175675ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/alignment/_lib/__init__.py000066400000000000000000000005411446255456000217000ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/alignment/_lib/ssw.c000066400000000000000000000764061446255456000205640ustar00rootroot00000000000000/* The MIT License Copyright (c) 2012-1015 Boston College. 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. */ /* Contact: Mengyao Zhao */ /* * ssw.c * * Created by Mengyao Zhao on 6/22/10. * Copyright 2010 Boston College. All rights reserved. * Version 0.1.4 * Last revision by Mengyao Zhao on 12/07/12. * */ #define SIMDE_ENABLE_NATIVE_ALIASES #include "simde-sse2.h" #include #include #include #include #include #include "ssw.h" #ifdef __GNUC__ #define LIKELY(x) __builtin_expect((x),1) #define UNLIKELY(x) __builtin_expect((x),0) #else #define LIKELY(x) (x) #define UNLIKELY(x) (x) #endif /* Convert the coordinate in the scoring matrix into the coordinate in one line of the band. */ #define set_u(u, w, i, j) { int x=(i)-(w); x=x>0?x:0; (u)=(j)-x+1; } /* Convert the coordinate in the direction matrix into the coordinate in one line of the band. */ #define set_d(u, w, i, j, p) { int x=(i)-(w); x=x>0?x:0; x=(j)-x; (u)=x*3+p; } /*! @function @abstract Round an integer to the next closest power-2 integer. @param x integer to be rounded (in place) @discussion x will be modified. */ #define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x)) typedef struct { uint16_t score; int32_t ref; //0-based position int32_t read; //alignment ending position on read, 0-based } alignment_end; typedef struct { uint32_t* seq; int32_t length; } cigar; struct _profile{ __m128i* profile_byte; // 0: none __m128i* profile_word; // 0: none const int8_t* read; const int8_t* mat; int32_t readLen; int32_t n; uint8_t bias; }; /* Generate query profile rearrange query sequence & calculate the weight of match/mismatch. */ __m128i* qP_byte (const int8_t* read_num, const int8_t* mat, const int32_t readLen, const int32_t n, /* the edge length of the squre matrix mat */ uint8_t bias) { int32_t segLen = (readLen + 15) / 16; /* Split the 128 bit register into 16 pieces. Each piece is 8 bit. Split the read into 16 segments. Calculat 16 segments in parallel. */ __m128i* vProfile = (__m128i*)malloc(n * segLen * sizeof(__m128i)); int8_t* t = (int8_t*)vProfile; int32_t nt, i, j, segNum; /* Generate query profile rearrange query sequence & calculate the weight of match/mismatch */ for (nt = 0; LIKELY(nt < n); nt ++) { for (i = 0; i < segLen; i ++) { j = i; for (segNum = 0; LIKELY(segNum < 16) ; segNum ++) { *t++ = j>= readLen ? bias : mat[nt * n + read_num[j]] + bias; j += segLen; } } } return vProfile; } /* Striped Smith-Waterman Record the highest score of each reference position. Return the alignment score and ending position of the best alignment, 2nd best alignment, etc. Gap begin and gap extension are different. wight_match > 0, all other weights < 0. The returned positions are 0-based. */ alignment_end* sw_sse2_byte (const int8_t* ref, int8_t ref_dir, // 0: forward ref; 1: reverse ref int32_t refLen, int32_t readLen, const uint8_t weight_gapO, /* will be used as - */ const uint8_t weight_gapE, /* will be used as - */ __m128i* vProfile, uint8_t terminate, /* the best alignment score: used to terminate the matrix calculation when locating the alignment beginning point. If this score is set to 0, it will not be used */ uint8_t bias, /* Shift 0 point to a positive value. */ int32_t maskLen) { #define max16(m, vm) (vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 8)); \ (vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 4)); \ (vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 2)); \ (vm) = _mm_max_epu8((vm), _mm_srli_si128((vm), 1)); \ (m) = _mm_extract_epi16((vm), 0) uint8_t max = 0; /* the max alignment score */ int32_t end_read = readLen - 1; int32_t end_ref = -1; /* 0_based best alignment ending point; Initialized as isn't aligned -1. */ int32_t segLen = (readLen + 15) / 16; /* number of segment */ /* array to record the largest score of each reference position */ uint8_t* maxColumn = (uint8_t*) calloc(refLen, 1); /* array to record the alignment read ending position of the largest score of each reference position */ int32_t* end_read_column = (int32_t*) calloc(refLen, sizeof(int32_t)); /* Define 16 byte 0 vector. */ __m128i vZero = _mm_set1_epi32(0); __m128i* pvHStore = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvHLoad = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvE = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvHmax = (__m128i*) calloc(segLen, sizeof(__m128i)); int32_t i, j; /* 16 byte insertion begin vector */ __m128i vGapO = _mm_set1_epi8(weight_gapO); /* 16 byte insertion extension vector */ __m128i vGapE = _mm_set1_epi8(weight_gapE); /* 16 byte bias vector */ __m128i vBias = _mm_set1_epi8(bias); __m128i vMaxScore = vZero; /* Trace the highest score of the whole SW matrix. */ __m128i vMaxMark = vZero; /* Trace the highest score till the previous column. */ __m128i vTemp; int32_t edge, begin = 0, end = refLen, step = 1; // int32_t distance = readLen * 2 / 3; // int32_t distance = readLen / 2; // int32_t distance = readLen; /* outer loop to process the reference sequence */ if (ref_dir == 1) { begin = refLen - 1; end = -1; step = -1; } for (i = begin; LIKELY(i != end); i += step) { int32_t cmp; __m128i e = vZero, vF = vZero, vMaxColumn = vZero; /* Initialize F value to 0. Any errors to vH values will be corrected in the Lazy_F loop. */ // max16(maxColumn[i], vMaxColumn); // fprintf(stderr, "middle[%d]: %d\n", i, maxColumn[i]); __m128i vH = pvHStore[segLen - 1]; vH = _mm_slli_si128 (vH, 1); /* Shift the 128-bit value in vH left by 1 byte. */ __m128i* vP = vProfile + ref[i] * segLen; /* Right part of the vProfile */ /* Swap the 2 H buffers. */ __m128i* pv = pvHLoad; pvHLoad = pvHStore; pvHStore = pv; /* inner loop to process the query sequence */ for (j = 0; LIKELY(j < segLen); ++j) { vH = _mm_adds_epu8(vH, _mm_load_si128(vP + j)); vH = _mm_subs_epu8(vH, vBias); /* vH will be always > 0 */ // max16(maxColumn[i], vH); // fprintf(stderr, "H[%d]: %d\n", i, maxColumn[i]); // int8_t* t; // int32_t ti; //for (t = (int8_t*)&vH, ti = 0; ti < 16; ++ti) fprintf(stderr, "%d\t", *t++); /* Get max from vH, vE and vF. */ e = _mm_load_si128(pvE + j); vH = _mm_max_epu8(vH, e); vH = _mm_max_epu8(vH, vF); vMaxColumn = _mm_max_epu8(vMaxColumn, vH); // max16(maxColumn[i], vMaxColumn); // fprintf(stderr, "middle[%d]: %d\n", i, maxColumn[i]); // for (t = (int8_t*)&vMaxColumn, ti = 0; ti < 16; ++ti) fprintf(stderr, "%d\t", *t++); /* Save vH values. */ _mm_store_si128(pvHStore + j, vH); /* Update vE value. */ vH = _mm_subs_epu8(vH, vGapO); /* saturation arithmetic, result >= 0 */ e = _mm_subs_epu8(e, vGapE); e = _mm_max_epu8(e, vH); _mm_store_si128(pvE + j, e); /* Update vF value. */ vF = _mm_subs_epu8(vF, vGapE); vF = _mm_max_epu8(vF, vH); /* Load the next vH. */ vH = _mm_load_si128(pvHLoad + j); } /* Lazy_F loop: has been revised to disallow adjecent insertion and then deletion, so don't update E(i, j), learn from SWPS3 */ /* reset pointers to the start of the saved data */ j = 0; vH = _mm_load_si128 (pvHStore + j); /* the computed vF value is for the given column. since */ /* we are at the end, we need to shift the vF value over */ /* to the next column. */ vF = _mm_slli_si128 (vF, 1); vTemp = _mm_subs_epu8 (vH, vGapO); vTemp = _mm_subs_epu8 (vF, vTemp); vTemp = _mm_cmpeq_epi8 (vTemp, vZero); cmp = _mm_movemask_epi8 (vTemp); while (cmp != 0xffff) { vH = _mm_max_epu8 (vH, vF); vMaxColumn = _mm_max_epu8(vMaxColumn, vH); _mm_store_si128 (pvHStore + j, vH); vF = _mm_subs_epu8 (vF, vGapE); j++; if (j >= segLen) { j = 0; vF = _mm_slli_si128 (vF, 1); } vH = _mm_load_si128 (pvHStore + j); vTemp = _mm_subs_epu8 (vH, vGapO); vTemp = _mm_subs_epu8 (vF, vTemp); vTemp = _mm_cmpeq_epi8 (vTemp, vZero); cmp = _mm_movemask_epi8 (vTemp); } vMaxScore = _mm_max_epu8(vMaxScore, vMaxColumn); vTemp = _mm_cmpeq_epi8(vMaxMark, vMaxScore); cmp = _mm_movemask_epi8(vTemp); if (cmp != 0xffff) { uint8_t temp; vMaxMark = vMaxScore; max16(temp, vMaxScore); vMaxScore = vMaxMark; if (LIKELY(temp > max)) { max = temp; if (max + bias >= 255) break; //overflow end_ref = i; /* Store the column with the highest alignment score in order to trace the alignment ending position on read. */ for (j = 0; LIKELY(j < segLen); ++j) pvHmax[j] = pvHStore[j]; } } /* Record the max score of current column. */ max16(maxColumn[i], vMaxColumn); // fprintf(stderr, "maxColumn[%d]: %d\n", i, maxColumn[i]); if (maxColumn[i] == terminate) break; } /* Trace the alignment ending position on read. */ uint8_t *t = (uint8_t*)pvHmax; int32_t column_len = segLen * 16; for (i = 0; LIKELY(i < column_len); ++i, ++t) { int32_t temp; if (*t == max) { temp = i / 16 + i % 16 * segLen; if (temp < end_read) end_read = temp; } } free(pvHmax); free(pvE); free(pvHLoad); free(pvHStore); /* Find the most possible 2nd best alignment. */ alignment_end* bests = (alignment_end*) calloc(2, sizeof(alignment_end)); bests[0].score = max + bias >= 255 ? 255 : max; bests[0].ref = end_ref; bests[0].read = end_read; bests[1].score = 0; bests[1].ref = 0; bests[1].read = 0; edge = (end_ref - maskLen) > 0 ? (end_ref - maskLen) : 0; for (i = 0; i < edge; i ++) { // fprintf (stderr, "maxColumn[%d]: %d\n", i, maxColumn[i]); if (maxColumn[i] > bests[1].score) { bests[1].score = maxColumn[i]; bests[1].ref = i; } } edge = (end_ref + maskLen) > refLen ? refLen : (end_ref + maskLen); for (i = edge + 1; i < refLen; i ++) { // fprintf (stderr, "refLen: %d\tmaxColumn[%d]: %d\n", refLen, i, maxColumn[i]); if (maxColumn[i] > bests[1].score) { bests[1].score = maxColumn[i]; bests[1].ref = i; } } free(maxColumn); free(end_read_column); return bests; } __m128i* qP_word (const int8_t* read_num, const int8_t* mat, const int32_t readLen, const int32_t n) { int32_t segLen = (readLen + 7) / 8; __m128i* vProfile = (__m128i*)malloc(n * segLen * sizeof(__m128i)); int16_t* t = (int16_t*)vProfile; int32_t nt, i, j; int32_t segNum; /* Generate query profile rearrange query sequence & calculate the weight of match/mismatch */ for (nt = 0; LIKELY(nt < n); nt ++) { for (i = 0; i < segLen; i ++) { j = i; for (segNum = 0; LIKELY(segNum < 8) ; segNum ++) { *t++ = j>= readLen ? 0 : mat[nt * n + read_num[j]]; j += segLen; } } } return vProfile; } alignment_end* sw_sse2_word (const int8_t* ref, int8_t ref_dir, // 0: forward ref; 1: reverse ref int32_t refLen, int32_t readLen, const uint8_t weight_gapO, /* will be used as - */ const uint8_t weight_gapE, /* will be used as - */ __m128i* vProfile, uint16_t terminate, int32_t maskLen) { #define max8(m, vm) (vm) = _mm_max_epi16((vm), _mm_srli_si128((vm), 8)); \ (vm) = _mm_max_epi16((vm), _mm_srli_si128((vm), 4)); \ (vm) = _mm_max_epi16((vm), _mm_srli_si128((vm), 2)); \ (m) = _mm_extract_epi16((vm), 0) uint16_t max = 0; /* the max alignment score */ int32_t end_read = readLen - 1; int32_t end_ref = 0; /* 1_based best alignment ending point; Initialized as isn't aligned - 0. */ int32_t segLen = (readLen + 7) / 8; /* number of segment */ /* array to record the largest score of each reference position */ uint16_t* maxColumn = (uint16_t*) calloc(refLen, 2); /* array to record the alignment read ending position of the largest score of each reference position */ int32_t* end_read_column = (int32_t*) calloc(refLen, sizeof(int32_t)); /* Define 16 byte 0 vector. */ __m128i vZero = _mm_set1_epi32(0); __m128i* pvHStore = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvHLoad = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvE = (__m128i*) calloc(segLen, sizeof(__m128i)); __m128i* pvHmax = (__m128i*) calloc(segLen, sizeof(__m128i)); int32_t i, j, k; /* 16 byte insertion begin vector */ __m128i vGapO = _mm_set1_epi16(weight_gapO); /* 16 byte insertion extension vector */ __m128i vGapE = _mm_set1_epi16(weight_gapE); /* 16 byte bias vector */ __m128i vMaxScore = vZero; /* Trace the highest score of the whole SW matrix. */ __m128i vMaxMark = vZero; /* Trace the highest score till the previous column. */ __m128i vTemp; int32_t edge, begin = 0, end = refLen, step = 1; /* outer loop to process the reference sequence */ if (ref_dir == 1) { begin = refLen - 1; end = -1; step = -1; } for (i = begin; LIKELY(i != end); i += step) { int32_t cmp; __m128i e = vZero, vF = vZero; /* Initialize F value to 0. Any errors to vH values will be corrected in the Lazy_F loop. */ __m128i vH = pvHStore[segLen - 1]; vH = _mm_slli_si128 (vH, 2); /* Shift the 128-bit value in vH left by 2 byte. */ /* Swap the 2 H buffers. */ __m128i* pv = pvHLoad; __m128i vMaxColumn = vZero; /* vMaxColumn is used to record the max values of column i. */ __m128i* vP = vProfile + ref[i] * segLen; /* Right part of the vProfile */ pvHLoad = pvHStore; pvHStore = pv; /* inner loop to process the query sequence */ for (j = 0; LIKELY(j < segLen); j ++) { vH = _mm_adds_epi16(vH, _mm_load_si128(vP + j)); /* Get max from vH, vE and vF. */ e = _mm_load_si128(pvE + j); vH = _mm_max_epi16(vH, e); vH = _mm_max_epi16(vH, vF); vMaxColumn = _mm_max_epi16(vMaxColumn, vH); /* Save vH values. */ _mm_store_si128(pvHStore + j, vH); /* Update vE value. */ vH = _mm_subs_epu16(vH, vGapO); /* saturation arithmetic, result >= 0 */ e = _mm_subs_epu16(e, vGapE); e = _mm_max_epi16(e, vH); _mm_store_si128(pvE + j, e); /* Update vF value. */ vF = _mm_subs_epu16(vF, vGapE); vF = _mm_max_epi16(vF, vH); /* Load the next vH. */ vH = _mm_load_si128(pvHLoad + j); } /* Lazy_F loop: has been revised to disallow adjecent insertion and then deletion, so don't update E(i, j), learn from SWPS3 */ for (k = 0; LIKELY(k < 8); ++k) { vF = _mm_slli_si128 (vF, 2); for (j = 0; LIKELY(j < segLen); ++j) { vH = _mm_load_si128(pvHStore + j); vH = _mm_max_epi16(vH, vF); _mm_store_si128(pvHStore + j, vH); vH = _mm_subs_epu16(vH, vGapO); vF = _mm_subs_epu16(vF, vGapE); if (UNLIKELY(! _mm_movemask_epi8(_mm_cmpgt_epi16(vF, vH)))) goto end; } } end: vMaxScore = _mm_max_epi16(vMaxScore, vMaxColumn); vTemp = _mm_cmpeq_epi16(vMaxMark, vMaxScore); cmp = _mm_movemask_epi8(vTemp); if (cmp != 0xffff) { uint16_t temp; vMaxMark = vMaxScore; max8(temp, vMaxScore); vMaxScore = vMaxMark; if (LIKELY(temp > max)) { max = temp; end_ref = i; for (j = 0; LIKELY(j < segLen); ++j) pvHmax[j] = pvHStore[j]; } } /* Record the max score of current column. */ max8(maxColumn[i], vMaxColumn); if (maxColumn[i] == terminate) break; } /* Trace the alignment ending position on read. */ uint16_t *t = (uint16_t*)pvHmax; int32_t column_len = segLen * 8; for (i = 0; LIKELY(i < column_len); ++i, ++t) { int32_t temp; if (*t == max) { temp = i / 8 + i % 8 * segLen; if (temp < end_read) end_read = temp; } } free(pvHmax); free(pvE); free(pvHLoad); free(pvHStore); /* Find the most possible 2nd best alignment. */ alignment_end* bests = (alignment_end*) calloc(2, sizeof(alignment_end)); bests[0].score = max; bests[0].ref = end_ref; bests[0].read = end_read; bests[1].score = 0; bests[1].ref = 0; bests[1].read = 0; edge = (end_ref - maskLen) > 0 ? (end_ref - maskLen) : 0; for (i = 0; i < edge; i ++) { if (maxColumn[i] > bests[1].score) { bests[1].score = maxColumn[i]; bests[1].ref = i; } } edge = (end_ref + maskLen) > refLen ? refLen : (end_ref + maskLen); for (i = edge; i < refLen; i ++) { if (maxColumn[i] > bests[1].score) { bests[1].score = maxColumn[i]; bests[1].ref = i; } } free(maxColumn); free(end_read_column); return bests; } cigar* banded_sw (const int8_t* ref, const int8_t* read, int32_t refLen, int32_t readLen, int32_t score, const uint32_t weight_gapO, /* will be used as - */ const uint32_t weight_gapE, /* will be used as - */ int32_t band_width, const int8_t* mat, /* pointer to the weight matrix */ int32_t n) { uint32_t *c = (uint32_t*)malloc(16 * sizeof(uint32_t)), *c1; int32_t i, j, e, f, temp1, temp2, s = 16, s1 = 8, s2 = 1024, l, max = 0; int32_t width, width_d, *h_b, *e_b, *h_c; int8_t *direction, *direction_line; cigar* result = (cigar*)malloc(sizeof(cigar)); h_b = (int32_t*)malloc(s1 * sizeof(int32_t)); e_b = (int32_t*)malloc(s1 * sizeof(int32_t)); h_c = (int32_t*)malloc(s1 * sizeof(int32_t)); direction = (int8_t*)malloc(s2 * sizeof(int8_t)); do { width = band_width * 2 + 3, width_d = band_width * 2 + 1; while (width >= s1) { ++s1; kroundup32(s1); h_b = (int32_t*)realloc(h_b, s1 * sizeof(int32_t)); e_b = (int32_t*)realloc(e_b, s1 * sizeof(int32_t)); h_c = (int32_t*)realloc(h_c, s1 * sizeof(int32_t)); } while (width_d * readLen * 3 >= s2) { ++s2; kroundup32(s2); if (s2 < 0) { fprintf(stderr, "Alignment score and position are not consensus.\n"); exit(1); } direction = (int8_t*)realloc(direction, s2 * sizeof(int8_t)); } direction_line = direction; for (j = 1; LIKELY(j < width - 1); j ++) h_b[j] = 0; for (i = 0; LIKELY(i < readLen); i ++) { int32_t beg = 0, end = refLen - 1, u = 0, edge; j = i - band_width; beg = beg > j ? beg : j; // band start j = i + band_width; end = end < j ? end : j; // band end edge = end + 1 < width - 1 ? end + 1 : width - 1; f = h_b[0] = e_b[0] = h_b[edge] = e_b[edge] = h_c[0] = 0; direction_line = direction + width_d * i * 3; for (j = beg; LIKELY(j <= end); j ++) { int32_t b, e1, f1, d, de, df, dh; set_u(u, band_width, i, j); set_u(e, band_width, i - 1, j); set_u(b, band_width, i, j - 1); set_u(d, band_width, i - 1, j - 1); set_d(de, band_width, i, j, 0); set_d(df, band_width, i, j, 1); set_d(dh, band_width, i, j, 2); temp1 = i == 0 ? -weight_gapO : h_b[e] - weight_gapO; temp2 = i == 0 ? -weight_gapE : e_b[e] - weight_gapE; e_b[u] = temp1 > temp2 ? temp1 : temp2; direction_line[de] = temp1 > temp2 ? 3 : 2; temp1 = h_c[b] - weight_gapO; temp2 = f - weight_gapE; f = temp1 > temp2 ? temp1 : temp2; direction_line[df] = temp1 > temp2 ? 5 : 4; e1 = e_b[u] > 0 ? e_b[u] : 0; f1 = f > 0 ? f : 0; temp1 = e1 > f1 ? e1 : f1; temp2 = h_b[d] + mat[ref[j] * n + read[i]]; h_c[u] = temp1 > temp2 ? temp1 : temp2; if (h_c[u] > max) max = h_c[u]; if (temp1 <= temp2) direction_line[dh] = 1; else direction_line[dh] = e1 > f1 ? direction_line[de] : direction_line[df]; } for (j = 1; j <= u; j ++) h_b[j] = h_c[j]; } band_width *= 2; } while (LIKELY(max < score)); band_width /= 2; // trace back i = readLen - 1; j = refLen - 1; e = 0; // Count the number of M, D or I. l = 0; // record length of current cigar f = max = 0; // M temp2 = 2; // h while (LIKELY(i > 0)) { set_d(temp1, band_width, i, j, temp2); switch (direction_line[temp1]) { case 1: --i; --j; temp2 = 2; direction_line -= width_d * 3; f = 0; // M break; case 2: --i; temp2 = 0; // e direction_line -= width_d * 3; f = 1; // I break; case 3: --i; temp2 = 2; direction_line -= width_d * 3; f = 1; // I break; case 4: --j; temp2 = 1; f = 2; // D break; case 5: --j; temp2 = 2; f = 2; // D break; default: fprintf(stderr, "Trace back error: %d.\n", direction_line[temp1 - 1]); return 0; } if (f == max) ++e; else { ++l; while (l >= s) { ++s; kroundup32(s); c = (uint32_t*)realloc(c, s * sizeof(uint32_t)); } c[l - 1] = e<<4|max; max = f; e = 1; } } if (f == 0) { ++l; while (l >= s) { ++s; kroundup32(s); c = (uint32_t*)realloc(c, s * sizeof(uint32_t)); } c[l - 1] = (e+1)<<4; }else { l += 2; while (l >= s) { ++s; kroundup32(s); c = (uint32_t*)realloc(c, s * sizeof(uint32_t)); } c[l - 2] = e<<4|f; c[l - 1] = 16; // 1M } // reverse cigar c1 = (uint32_t*)malloc(l * sizeof(uint32_t)); s = 0; e = l - 1; while (LIKELY(s <= e)) { c1[s] = c[e]; c1[e] = c[s]; ++ s; -- e; } result->seq = c1; result->length = l; free(direction); free(h_c); free(e_b); free(h_b); free(c); return result; } int8_t* seq_reverse(const int8_t* seq, int32_t end) /* end is 0-based alignment ending position */ { int8_t* reverse = (int8_t*)calloc(end + 1, sizeof(int8_t)); int32_t start = 0; while (LIKELY(start <= end)) { reverse[start] = seq[end]; reverse[end] = seq[start]; ++ start; -- end; } return reverse; } s_profile* ssw_init (const int8_t* read, const int32_t readLen, const int8_t* mat, const int32_t n, const int8_t score_size) { s_profile* p = (s_profile*)calloc(1, sizeof(struct _profile)); p->profile_byte = 0; p->profile_word = 0; p->bias = 0; if (score_size == 0 || score_size == 2) { /* Find the bias to use in the substitution matrix */ int32_t bias = 0, i; for (i = 0; i < n*n; i++) if (mat[i] < bias) bias = mat[i]; bias = abs(bias); p->bias = bias; p->profile_byte = qP_byte (read, mat, readLen, n, bias); } if (score_size == 1 || score_size == 2) p->profile_word = qP_word (read, mat, readLen, n); p->read = read; p->mat = mat; p->readLen = readLen; p->n = n; return p; } void init_destroy (s_profile* p) { free(p->profile_byte); free(p->profile_word); free(p); } s_align* ssw_align (const s_profile* prof, const int8_t* ref, int32_t refLen, const uint8_t weight_gapO, const uint8_t weight_gapE, const uint8_t flag, // (from high to low) bit 5: return the best alignment beginning position; 6: if (ref_end1 - ref_begin1 <= filterd) && (read_end1 - read_begin1 <= filterd), return cigar; 7: if max score >= filters, return cigar; 8: always return cigar; if 6 & 7 are both setted, only return cigar when both filter fulfilled const uint16_t filters, const int32_t filterd, const int32_t maskLen) { alignment_end* bests = 0, *bests_reverse = 0; __m128i* vP = 0; int32_t word = 0, band_width = 0, readLen = prof->readLen; int8_t* read_reverse = 0; cigar* path; s_align* r = (s_align*)calloc(1, sizeof(s_align)); r->ref_begin1 = -1; r->read_begin1 = -1; r->cigar = 0; r->cigarLen = 0; if (maskLen < 15) { fprintf(stderr, "When maskLen < 15, the function ssw_align doesn't return 2nd best alignment information.\n"); } // Find the alignment scores and ending positions if (prof->profile_byte) { bests = sw_sse2_byte(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_byte, -1, prof->bias, maskLen); if (prof->profile_word && bests[0].score == 255) { free(bests); bests = sw_sse2_word(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_word, -1, maskLen); word = 1; } else if (bests[0].score == 255) { fprintf(stderr, "Please set 2 to the score_size parameter of the function ssw_init, otherwise the alignment results will be incorrect.\n"); return 0; } }else if (prof->profile_word) { bests = sw_sse2_word(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_word, -1, maskLen); word = 1; }else { fprintf(stderr, "Please call the function ssw_init before ssw_align.\n"); return 0; } r->score1 = bests[0].score; r->ref_end1 = bests[0].ref; r->read_end1 = bests[0].read; if (maskLen >= 15) { r->score2 = bests[1].score; r->ref_end2 = bests[1].ref; } else { r->score2 = 0; r->ref_end2 = -1; } free(bests); if (flag == 0 || (flag == 2 && r->score1 < filters)) goto end; // Find the beginning position of the best alignment. read_reverse = seq_reverse(prof->read, r->read_end1); if (word == 0) { vP = qP_byte(read_reverse, prof->mat, r->read_end1 + 1, prof->n, prof->bias); bests_reverse = sw_sse2_byte(ref, 1, r->ref_end1 + 1, r->read_end1 + 1, weight_gapO, weight_gapE, vP, r->score1, prof->bias, maskLen); } else { vP = qP_word(read_reverse, prof->mat, r->read_end1 + 1, prof->n); bests_reverse = sw_sse2_word(ref, 1, r->ref_end1 + 1, r->read_end1 + 1, weight_gapO, weight_gapE, vP, r->score1, maskLen); } free(vP); free(read_reverse); r->ref_begin1 = bests_reverse[0].ref; r->read_begin1 = r->read_end1 - bests_reverse[0].read; free(bests_reverse); if ((7&flag) == 0 || ((2&flag) != 0 && r->score1 < filters) || ((4&flag) != 0 && (r->ref_end1 - r->ref_begin1 > filterd || r->read_end1 - r->read_begin1 > filterd))) goto end; // Generate cigar. refLen = r->ref_end1 - r->ref_begin1 + 1; readLen = r->read_end1 - r->read_begin1 + 1; band_width = abs(refLen - readLen) + 1; path = banded_sw(ref + r->ref_begin1, prof->read + r->read_begin1, refLen, readLen, r->score1, weight_gapO, weight_gapE, band_width, prof->mat, prof->n); if (path == 0) r = 0; else { r->cigar = path->seq; r->cigarLen = path->length; free(path); } end: return r; } void align_destroy (s_align* a) { free(a->cigar); free(a); } scikit-bio-0.5.9/skbio/alignment/_lib/ssw.h000066400000000000000000000157641446255456000205710ustar00rootroot00000000000000/* * ssw.h * * Created by Mengyao Zhao on 6/22/10. * Copyright 2010 Boston College. All rights reserved. * Version 0.1.4 * Last revision by Mengyao Zhao on 01/30/13. * */ #ifndef SSW_H #define SSW_H #include #include #include #define SIMDE_ENABLE_NATIVE_ALIASES #include "simde-sse2.h" /*! @typedef structure of the query profile */ struct _profile; typedef struct _profile s_profile; /*! @typedef structure of the alignment result @field score1 the best alignment score @field score2 sub-optimal alignment score @field ref_begin1 0-based best alignment beginning position on reference; ref_begin1 = -1 when the best alignment beginning position is not available @field ref_end1 0-based best alignment ending position on reference @field read_begin1 0-based best alignment beginning position on read; read_begin1 = -1 when the best alignment beginning position is not available @field read_end1 0-based best alignment ending position on read @field read_end2 0-based sub-optimal alignment ending position on read @field cigar best alignment cigar; stored the same as that in BAM format, high 28 bits: length, low 4 bits: M/I/D (0/1/2); cigar = 0 when the best alignment path is not available @field cigarLen length of the cigar string; cigarLen = 0 when the best alignment path is not available */ typedef struct { uint16_t score1; uint16_t score2; int32_t ref_begin1; int32_t ref_end1; int32_t read_begin1; int32_t read_end1; int32_t ref_end2; uint32_t* cigar; int32_t cigarLen; } s_align; #ifdef __cplusplus extern "C" { #endif // __cplusplus /*! @function Create the query profile using the query sequence. @param read pointer to the query sequence; the query sequence needs to be numbers @param readLen length of the query sequence @param mat pointer to the substitution matrix; mat needs to be corresponding to the read sequence @param n the square root of the number of elements in mat (mat has n*n elements) @param score_size estimated Smith-Waterman score; if your estimated best alignment score is surely < 255 please set 0; if your estimated best alignment score >= 255, please set 1; if you don't know, please set 2 @return pointer to the query profile structure @note example for parameter read and mat: If the query sequence is: ACGTATC, the sequence that read points to can be: 1234142 Then if the penalty for match is 2 and for mismatch is -2, the substitution matrix of parameter mat will be: //A C G T 2 -2 -2 -2 //A -2 2 -2 -2 //C -2 -2 2 -2 //G -2 -2 -2 2 //T mat is the pointer to the array {2, -2, -2, -2, -2, 2, -2, -2, -2, -2, 2, -2, -2, -2, -2, 2} */ s_profile* ssw_init (const int8_t* read, const int32_t readLen, const int8_t* mat, const int32_t n, const int8_t score_size); /*! @function Release the memory allocated by function ssw_init. @param p pointer to the query profile structure */ void init_destroy (s_profile* p); // @function ssw alignment. /*! @function Do Striped Smith-Waterman alignment. @param prof pointer to the query profile structure @param ref pointer to the target sequence; the target sequence needs to be numbers and corresponding to the mat parameter of function ssw_init @param refLen length of the target sequence @param weight_gapO the absolute value of gap open penalty @param weight_gapE the absolute value of gap extension penalty @param flag bitwise FLAG; (from high to low) bit 5: when setted as 1, function ssw_align will return the best alignment beginning position; bit 6: when setted as 1, if (ref_end1 - ref_begin1 < filterd && read_end1 - read_begin1 < filterd), (whatever bit 5 is setted) the function will return the best alignment beginning position and cigar; bit 7: when setted as 1, if the best alignment score >= filters, (whatever bit 5 is setted) the function will return the best alignment beginning position and cigar; bit 8: when setted as 1, (whatever bit 5, 6 or 7 is setted) the function will always return the best alignment beginning position and cigar. When flag == 0, only the optimal and sub-optimal scores and the optimal alignment ending position will be returned. @param filters score filter: when bit 7 of flag is setted as 1 and bit 8 is setted as 0, filters will be used (Please check the decription of the flag parameter for detailed usage.) @param filterd distance filter: when bit 6 of flag is setted as 1 and bit 8 is setted as 0, filterd will be used (Please check the decription of the flag parameter for detailed usage.) @param maskLen The distance between the optimal and suboptimal alignment ending position >= maskLen. We suggest to use readLen/2, if you don't have special concerns. Note: maskLen has to be >= 15, otherwise this function will NOT return the suboptimal alignment information. Detailed description of maskLen: After locating the optimal alignment ending position, the suboptimal alignment score can be heuristically found by checking the second largest score in the array that contains the maximal score of each column of the SW matrix. In order to avoid picking the scores that belong to the alignments sharing the partial best alignment, SSW C library masks the reference loci nearby (mask length = maskLen) the best alignment ending position and locates the second largest score from the unmasked elements. @return pointer to the alignment result structure @note Whatever the parameter flag is setted, this function will at least return the optimal and sub-optimal alignment score, and the optimal alignment ending positions on target and query sequences. If both bit 6 and 7 of the flag are setted while bit 8 is not, the function will return cigar only when both criteria are fulfilled. All returned positions are 0-based coordinate. */ s_align* ssw_align (const s_profile* prof, const int8_t* ref, int32_t refLen, const uint8_t weight_gapO, const uint8_t weight_gapE, const uint8_t flag, const uint16_t filters, const int32_t filterd, const int32_t maskLen); /*! @function Release the memory allocated by function ssw_align. @param a pointer to the alignment result structure */ void align_destroy (s_align* a); #ifdef __cplusplus } #endif // __cplusplus #endif // SSW_H scikit-bio-0.5.9/skbio/alignment/_pairwise.py000066400000000000000000001274371446255456000212340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from warnings import warn from itertools import product import numpy as np from skbio.alignment import TabularMSA from skbio.alignment._ssw_wrapper import StripedSmithWaterman from skbio.sequence import DNA, RNA, Protein from skbio.sequence import GrammaredSequence from skbio.util import EfficiencyWarning from skbio.util._decorator import experimental, deprecated # This is temporary: blosum50 does not exist in skbio yet as per # issue 161. When the issue is resolved, this should be removed in favor # of an import. blosum50 = \ { '*': {'*': 1, 'A': -5, 'C': -5, 'B': -5, 'E': -5, 'D': -5, 'G': -5, 'F': -5, 'I': -5, 'H': -5, 'K': -5, 'M': -5, 'L': -5, 'N': -5, 'Q': -5, 'P': -5, 'S': -5, 'R': -5, 'T': -5, 'W': -5, 'V': -5, 'Y': -5, 'X': -5, 'Z': -5}, 'A': {'*': -5, 'A': 5, 'C': -1, 'B': -2, 'E': -1, 'D': -2, 'G': 0, 'F': -3, 'I': -1, 'H': -2, 'K': -1, 'M': -1, 'L': -2, 'N': -1, 'Q': -1, 'P': -1, 'S': 1, 'R': -2, 'T': 0, 'W': -3, 'V': 0, 'Y': -2, 'X': -1, 'Z': -1}, 'C': {'*': -5, 'A': -1, 'C': 13, 'B': -3, 'E': -3, 'D': -4, 'G': -3, 'F': -2, 'I': -2, 'H': -3, 'K': -3, 'M': -2, 'L': -2, 'N': -2, 'Q': -3, 'P': -4, 'S': -1, 'R': -4, 'T': -1, 'W': -5, 'V': -1, 'Y': -3, 'X': -1, 'Z': -3}, 'B': {'*': -5, 'A': -2, 'C': -3, 'B': 6, 'E': 1, 'D': 6, 'G': -1, 'F': -4, 'I': -4, 'H': 0, 'K': 0, 'M': -3, 'L': -4, 'N': 5, 'Q': 0, 'P': -2, 'S': 0, 'R': -1, 'T': 0, 'W': -5, 'V': -3, 'Y': -3, 'X': -1, 'Z': 1}, 'E': {'*': -5, 'A': -1, 'C': -3, 'B': 1, 'E': 6, 'D': 2, 'G': -3, 'F': -3, 'I': -4, 'H': 0, 'K': 1, 'M': -2, 'L': -3, 'N': 0, 'Q': 2, 'P': -1, 'S': -1, 'R': 0, 'T': -1, 'W': -3, 'V': -3, 'Y': -2, 'X': -1, 'Z': 5}, 'D': {'*': -5, 'A': -2, 'C': -4, 'B': 6, 'E': 2, 'D': 8, 'G': -1, 'F': -5, 'I': -4, 'H': -1, 'K': -1, 'M': -4, 'L': -4, 'N': 2, 'Q': 0, 'P': -1, 'S': 0, 'R': -2, 'T': -1, 'W': -5, 'V': -4, 'Y': -3, 'X': -1, 'Z': 1}, 'G': {'*': -5, 'A': 0, 'C': -3, 'B': -1, 'E': -3, 'D': -1, 'G': 8, 'F': -4, 'I': -4, 'H': -2, 'K': -2, 'M': -3, 'L': -4, 'N': 0, 'Q': -2, 'P': -2, 'S': 0, 'R': -3, 'T': -2, 'W': -3, 'V': -4, 'Y': -3, 'X': -1, 'Z': -2}, 'F': {'*': -5, 'A': -3, 'C': -2, 'B': -4, 'E': -3, 'D': -5, 'G': -4, 'F': 8, 'I': 0, 'H': -1, 'K': -4, 'M': 0, 'L': 1, 'N': -4, 'Q': -4, 'P': -4, 'S': -3, 'R': -3, 'T': -2, 'W': 1, 'V': -1, 'Y': 4, 'X': -1, 'Z': -4}, 'I': {'*': -5, 'A': -1, 'C': -2, 'B': -4, 'E': -4, 'D': -4, 'G': -4, 'F': 0, 'I': 5, 'H': -4, 'K': -3, 'M': 2, 'L': 2, 'N': -3, 'Q': -3, 'P': -3, 'S': -3, 'R': -4, 'T': -1, 'W': -3, 'V': 4, 'Y': -1, 'X': -1, 'Z': -3}, 'H': {'*': -5, 'A': -2, 'C': -3, 'B': 0, 'E': 0, 'D': -1, 'G': -2, 'F': -1, 'I': -4, 'H': 10, 'K': 0, 'M': -1, 'L': -3, 'N': 1, 'Q': 1, 'P': -2, 'S': -1, 'R': 0, 'T': -2, 'W': -3, 'V': -4, 'Y': 2, 'X': -1, 'Z': 0}, 'K': {'*': -5, 'A': -1, 'C': -3, 'B': 0, 'E': 1, 'D': -1, 'G': -2, 'F': -4, 'I': -3, 'H': 0, 'K': 6, 'M': -2, 'L': -3, 'N': 0, 'Q': 2, 'P': -1, 'S': 0, 'R': 3, 'T': -1, 'W': -3, 'V': -3, 'Y': -2, 'X': -1, 'Z': 1}, 'M': {'*': -5, 'A': -1, 'C': -2, 'B': -3, 'E': -2, 'D': -4, 'G': -3, 'F': 0, 'I': 2, 'H': -1, 'K': -2, 'M': 7, 'L': 3, 'N': -2, 'Q': 0, 'P': -3, 'S': -2, 'R': -2, 'T': -1, 'W': -1, 'V': 1, 'Y': 0, 'X': -1, 'Z': -1}, 'L': {'*': -5, 'A': -2, 'C': -2, 'B': -4, 'E': -3, 'D': -4, 'G': -4, 'F': 1, 'I': 2, 'H': -3, 'K': -3, 'M': 3, 'L': 5, 'N': -4, 'Q': -2, 'P': -4, 'S': -3, 'R': -3, 'T': -1, 'W': -2, 'V': 1, 'Y': -1, 'X': -1, 'Z': -3}, 'N': {'*': -5, 'A': -1, 'C': -2, 'B': 5, 'E': 0, 'D': 2, 'G': 0, 'F': -4, 'I': -3, 'H': 1, 'K': 0, 'M': -2, 'L': -4, 'N': 7, 'Q': 0, 'P': -2, 'S': 1, 'R': -1, 'T': 0, 'W': -4, 'V': -3, 'Y': -2, 'X': -1, 'Z': 0}, 'Q': {'*': -5, 'A': -1, 'C': -3, 'B': 0, 'E': 2, 'D': 0, 'G': -2, 'F': -4, 'I': -3, 'H': 1, 'K': 2, 'M': 0, 'L': -2, 'N': 0, 'Q': 7, 'P': -1, 'S': 0, 'R': 1, 'T': -1, 'W': -1, 'V': -3, 'Y': -1, 'X': -1, 'Z': 4}, 'P': {'*': -5, 'A': -1, 'C': -4, 'B': -2, 'E': -1, 'D': -1, 'G': -2, 'F': -4, 'I': -3, 'H': -2, 'K': -1, 'M': -3, 'L': -4, 'N': -2, 'Q': -1, 'P': 10, 'S': -1, 'R': -3, 'T': -1, 'W': -4, 'V': -3, 'Y': -3, 'X': -1, 'Z': -1}, 'S': {'*': -5, 'A': 1, 'C': -1, 'B': 0, 'E': -1, 'D': 0, 'G': 0, 'F': -3, 'I': -3, 'H': -1, 'K': 0, 'M': -2, 'L': -3, 'N': 1, 'Q': 0, 'P': -1, 'S': 5, 'R': -1, 'T': 2, 'W': -4, 'V': -2, 'Y': -2, 'X': -1, 'Z': 0}, 'R': {'*': -5, 'A': -2, 'C': -4, 'B': -1, 'E': 0, 'D': -2, 'G': -3, 'F': -3, 'I': -4, 'H': 0, 'K': 3, 'M': -2, 'L': -3, 'N': -1, 'Q': 1, 'P': -3, 'S': -1, 'R': 7, 'T': -1, 'W': -3, 'V': -3, 'Y': -1, 'X': -1, 'Z': 0}, 'T': {'*': -5, 'A': 0, 'C': -1, 'B': 0, 'E': -1, 'D': -1, 'G': -2, 'F': -2, 'I': -1, 'H': -2, 'K': -1, 'M': -1, 'L': -1, 'N': 0, 'Q': -1, 'P': -1, 'S': 2, 'R': -1, 'T': 5, 'W': -3, 'V': 0, 'Y': -2, 'X': -1, 'Z': -1}, 'W': {'*': -5, 'A': -3, 'C': -5, 'B': -5, 'E': -3, 'D': -5, 'G': -3, 'F': 1, 'I': -3, 'H': -3, 'K': -3, 'M': -1, 'L': -2, 'N': -4, 'Q': -1, 'P': -4, 'S': -4, 'R': -3, 'T': -3, 'W': 15, 'V': -3, 'Y': 2, 'X': -1, 'Z': -2}, 'V': {'*': -5, 'A': 0, 'C': -1, 'B': -3, 'E': -3, 'D': -4, 'G': -4, 'F': -1, 'I': 4, 'H': -4, 'K': -3, 'M': 1, 'L': 1, 'N': -3, 'Q': -3, 'P': -3, 'S': -2, 'R': -3, 'T': 0, 'W': -3, 'V': 5, 'Y': -1, 'X': -1, 'Z': -3}, 'Y': {'*': -5, 'A': -2, 'C': -3, 'B': -3, 'E': -2, 'D': -3, 'G': -3, 'F': 4, 'I': -1, 'H': 2, 'K': -2, 'M': 0, 'L': -1, 'N': -2, 'Q': -1, 'P': -3, 'S': -2, 'R': -1, 'T': -2, 'W': 2, 'V': -1, 'Y': 8, 'X': -1, 'Z': -2}, 'X': {'*': -5, 'A': -1, 'C': -1, 'B': -1, 'E': -1, 'D': -1, 'G': -1, 'F': -1, 'I': -1, 'H': -1, 'K': -1, 'M': -1, 'L': -1, 'N': -1, 'Q': -1, 'P': -1, 'S': -1, 'R': -1, 'T': -1, 'W': -1, 'V': -1, 'Y': -1, 'X': -1, 'Z': -1}, 'Z': {'*': -5, 'A': -1, 'C': -3, 'B': 1, 'E': 5, 'D': 1, 'G': -2, 'F': -4, 'I': -3, 'H': 0, 'K': 1, 'M': -1, 'L': -3, 'N': 0, 'Q': 4, 'P': -1, 'S': 0, 'R': 0, 'T': -1, 'W': -2, 'V': -3, 'Y': -2, 'X': -1, 'Z': 5}} @experimental(as_of="0.4.0") def local_pairwise_align_nucleotide(seq1, seq2, gap_open_penalty=5, gap_extend_penalty=2, match_score=2, mismatch_score=-3, substitution_matrix=None): """Locally align exactly two nucleotide seqs with Smith-Waterman Parameters ---------- seq1 : DNA or RNA The first unaligned sequence. seq2 : DNA or RNA The second unaligned sequence. gap_open_penalty : int or float, optional Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float, optional Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). match_score : int or float, optional The score to add for a match between a pair of bases (this is added to the previous best alignment score, so is typically positive). mismatch_score : int or float, optional The score to add for a mismatch between a pair of bases (this is added to the previous best alignment score, so is typically negative). substitution_matrix: 2D dict (or similar) Lookup for substitution scores (these values are added to the previous best alignment score). If provided, this overrides ``match_score`` and ``mismatch_score``. Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align local_pairwise_align_protein skbio.alignment.local_pairwise_align_ssw global_pairwise_align global_pairwise_align_protein global_pairwise_align_nucelotide Notes ----- Default ``match_score``, ``mismatch_score``, ``gap_open_penalty`` and ``gap_extend_penalty`` parameters are derived from the NCBI BLAST Server [1]_. References ---------- .. [1] http://blast.ncbi.nlm.nih.gov/Blast.cgi """ for seq in seq1, seq2: if not isinstance(seq, (DNA, RNA)): raise TypeError( "`seq1` and `seq2` must be DNA or RNA, not type %r" % type(seq).__name__) # use the substitution matrix provided by the user, or compute from # match_score and mismatch_score if a substitution matrix was not provided if substitution_matrix is None: substitution_matrix = \ make_identity_substitution_matrix(match_score, mismatch_score) return local_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix) @experimental(as_of="0.4.0") def local_pairwise_align_protein(seq1, seq2, gap_open_penalty=11, gap_extend_penalty=1, substitution_matrix=None): """Locally align exactly two protein seqs with Smith-Waterman Parameters ---------- seq1 : Protein The first unaligned sequence. seq2 : Protein The second unaligned sequence. gap_open_penalty : int or float, optional Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float, optional Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). substitution_matrix: 2D dict (or similar), optional Lookup for substitution scores (these values are added to the previous best alignment score); default is BLOSUM 50. Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align local_pairwise_align_nucleotide skbio.alignment.local_pairwise_align_ssw global_pairwise_align global_pairwise_align_protein global_pairwise_align_nucelotide Notes ----- Default ``gap_open_penalty`` and ``gap_extend_penalty`` parameters are derived from the NCBI BLAST Server [1]_. The BLOSUM (blocks substitution matrices) amino acid substitution matrices were originally defined in [2]_. References ---------- .. [1] http://blast.ncbi.nlm.nih.gov/Blast.cgi .. [2] Amino acid substitution matrices from protein blocks. S Henikoff and J G Henikoff. Proc Natl Acad Sci U S A. Nov 15, 1992; 89(22): 10915-10919. """ for seq in seq1, seq2: if not isinstance(seq, Protein): raise TypeError( "`seq1` and `seq2` must be Protein, not type %r" % type(seq).__name__) if substitution_matrix is None: substitution_matrix = blosum50 return local_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix) @experimental(as_of="0.4.0") def local_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix): """Locally align exactly two seqs with Smith-Waterman Parameters ---------- seq1 : GrammaredSequence The first unaligned sequence. seq2 : GrammaredSequence The second unaligned sequence. gap_open_penalty : int or float Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). substitution_matrix: 2D dict (or similar) Lookup for substitution scores (these values are added to the previous best alignment score). Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align_protein local_pairwise_align_nucleotide skbio.alignment.local_pairwise_align_ssw global_pairwise_align global_pairwise_align_protein global_pairwise_align_nucelotide Notes ----- This algorithm was originally described in [1]_. The scikit-bio implementation was validated against the EMBOSS water web server [2]_. References ---------- .. [1] Identification of common molecular subsequences. Smith TF, Waterman MS. J Mol Biol. 1981 Mar 25;147(1):195-7. .. [2] http://www.ebi.ac.uk/Tools/psa/emboss_water/ """ warn("You're using skbio's python implementation of Smith-Waterman " "alignment. This will be very slow (e.g., thousands of times slower) " "than skbio.alignment.local_pairwise_align_ssw.", EfficiencyWarning) for seq in seq1, seq2: if not isinstance(seq, GrammaredSequence): raise TypeError( "`seq1` and `seq2` must be %r subclasses, not type %r" % (GrammaredSequence.__name__, type(seq).__name__)) if type(seq1) is not type(seq2): raise TypeError( "`seq1` and `seq2` must be the same type: %r != %r" % (type(seq1).__name__, type(seq2).__name__)) seq1 = _coerce_alignment_input_type(seq1) seq2 = _coerce_alignment_input_type(seq2) score_matrix, traceback_matrix = _compute_score_and_traceback_matrices( seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix, new_alignment_score=0.0, init_matrices_f=_init_matrices_sw) end_row_position, end_col_position =\ np.unravel_index(np.argmax(score_matrix), score_matrix.shape) aligned1, aligned2, score, seq1_start_position, seq2_start_position = \ _traceback(traceback_matrix, score_matrix, seq1, seq2, end_row_position, end_col_position) start_end_positions = [(seq1_start_position, end_col_position-1), (seq2_start_position, end_row_position-1)] msa = TabularMSA(aligned1 + aligned2) return msa, score, start_end_positions @experimental(as_of="0.4.0") def global_pairwise_align_nucleotide(seq1, seq2, gap_open_penalty=5, gap_extend_penalty=2, match_score=1, mismatch_score=-2, substitution_matrix=None, penalize_terminal_gaps=False): """Globally align nucleotide seqs or alignments with Needleman-Wunsch Parameters ---------- seq1 : DNA, RNA, or TabularMSA[DNA|RNA] The first unaligned sequence(s). seq2 : DNA, RNA, or TabularMSA[DNA|RNA] The second unaligned sequence(s). gap_open_penalty : int or float, optional Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float, optional Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). match_score : int or float, optional The score to add for a match between a pair of bases (this is added to the previous best alignment score, so is typically positive). mismatch_score : int or float, optional The score to add for a mismatch between a pair of bases (this is added to the previous best alignment score, so is typically negative). substitution_matrix: 2D dict (or similar) Lookup for substitution scores (these values are added to the previous best alignment score). If provided, this overrides ``match_score`` and ``mismatch_score``. penalize_terminal_gaps: bool, optional If True, will continue to penalize gaps even after one sequence has been aligned through its end. This behavior is true Needleman-Wunsch alignment, but results in (biologically irrelevant) artifacts when the sequences being aligned are of different length. This is ``False`` by default, which is very likely to be the behavior you want in all or nearly all cases. Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align local_pairwise_align_protein local_pairwise_align_nucleotide skbio.alignment.local_pairwise_align_ssw global_pairwise_align global_pairwise_align_protein Notes ----- Default ``match_score``, ``mismatch_score``, ``gap_open_penalty`` and ``gap_extend_penalty`` parameters are derived from the NCBI BLAST Server [1]_. This function can be use to align either a pair of sequences, a pair of alignments, or a sequence and an alignment. References ---------- .. [1] http://blast.ncbi.nlm.nih.gov/Blast.cgi """ for seq in seq1, seq2: if not isinstance(seq, (DNA, RNA, TabularMSA)): raise TypeError( "`seq1` and `seq2` must be DNA, RNA, or TabularMSA, not type " "%r" % type(seq).__name__) if isinstance(seq, TabularMSA) and not issubclass(seq.dtype, (DNA, RNA)): raise TypeError( "`seq1` and `seq2` must be TabularMSA with DNA or RNA dtype, " "not dtype %r" % seq.dtype.__name__) # use the substitution matrix provided by the user, or compute from # match_score and mismatch_score if a substitution matrix was not provided if substitution_matrix is None: substitution_matrix = \ make_identity_substitution_matrix(match_score, mismatch_score) return global_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix, penalize_terminal_gaps=penalize_terminal_gaps) @experimental(as_of="0.4.0") def global_pairwise_align_protein(seq1, seq2, gap_open_penalty=11, gap_extend_penalty=1, substitution_matrix=None, penalize_terminal_gaps=False): """Globally align pair of protein seqs or alignments with Needleman-Wunsch Parameters ---------- seq1 : Protein or TabularMSA[Protein] The first unaligned sequence(s). seq2 : Protein or TabularMSA[Protein] The second unaligned sequence(s). gap_open_penalty : int or float, optional Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float, optional Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). substitution_matrix: 2D dict (or similar), optional Lookup for substitution scores (these values are added to the previous best alignment score); default is BLOSUM 50. penalize_terminal_gaps: bool, optional If True, will continue to penalize gaps even after one sequence has been aligned through its end. This behavior is true Needleman-Wunsch alignment, but results in (biologically irrelevant) artifacts when the sequences being aligned are of different length. This is ``False`` by default, which is very likely to be the behavior you want in all or nearly all cases. Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align local_pairwise_align_protein local_pairwise_align_nucleotide skbio.alignment.local_pairwise_align_ssw global_pairwise_align global_pairwise_align_nucelotide Notes ----- Default ``gap_open_penalty`` and ``gap_extend_penalty`` parameters are derived from the NCBI BLAST Server [1]_. The BLOSUM (blocks substitution matrices) amino acid substitution matrices were originally defined in [2]_. This function can be use to align either a pair of sequences, a pair of alignments, or a sequence and an alignment. References ---------- .. [1] http://blast.ncbi.nlm.nih.gov/Blast.cgi .. [2] Amino acid substitution matrices from protein blocks. S Henikoff and J G Henikoff. Proc Natl Acad Sci U S A. Nov 15, 1992; 89(22): 10915-10919. """ for seq in seq1, seq2: if not isinstance(seq, (Protein, TabularMSA)): raise TypeError( "`seq1` and `seq2` must be Protein or TabularMSA, not type %r" % type(seq).__name__) if isinstance(seq, TabularMSA) and not issubclass(seq.dtype, Protein): raise TypeError( "`seq1` and `seq2` must be TabularMSA with Protein dtype, " "not dtype %r" % seq.dtype.__name__) if substitution_matrix is None: substitution_matrix = blosum50 return global_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix, penalize_terminal_gaps=penalize_terminal_gaps) @experimental(as_of="0.4.0") def global_pairwise_align(seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix, penalize_terminal_gaps=False): """Globally align a pair of seqs or alignments with Needleman-Wunsch Parameters ---------- seq1 : GrammaredSequence or TabularMSA The first unaligned sequence(s). seq2 : GrammaredSequence or TabularMSA The second unaligned sequence(s). gap_open_penalty : int or float Penalty for opening a gap (this is substracted from previous best alignment score, so is typically positive). gap_extend_penalty : int or float Penalty for extending a gap (this is substracted from previous best alignment score, so is typically positive). substitution_matrix: 2D dict (or similar) Lookup for substitution scores (these values are added to the previous best alignment score). penalize_terminal_gaps: bool, optional If True, will continue to penalize gaps even after one sequence has been aligned through its end. This behavior is true Needleman-Wunsch alignment, but results in (biologically irrelevant) artifacts when the sequences being aligned are of different length. This is ``False`` by default, which is very likely to be the behavior you want in all or nearly all cases. Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. See Also -------- local_pairwise_align local_pairwise_align_protein local_pairwise_align_nucleotide skbio.alignment.local_pairwise_align_ssw global_pairwise_align_protein global_pairwise_align_nucelotide Notes ----- This algorithm (in a slightly more basic form) was originally described in [1]_. The scikit-bio implementation was validated against the EMBOSS needle web server [2]_. This function can be use to align either a pair of sequences, a pair of alignments, or a sequence and an alignment. References ---------- .. [1] A general method applicable to the search for similarities in the amino acid sequence of two proteins. Needleman SB, Wunsch CD. J Mol Biol. 1970 Mar;48(3):443-53. .. [2] http://www.ebi.ac.uk/Tools/psa/emboss_needle/ """ warn("You're using skbio's python implementation of Needleman-Wunsch " "alignment. This is known to be very slow (e.g., thousands of times " "slower than a native C implementation). We'll be adding a faster " "version soon (see https://github.com/biocore/scikit-bio/issues/254 " "to track progress on this).", EfficiencyWarning) for seq in seq1, seq2: # We don't need to check the case where `seq` is a `TabularMSA` with a # dtype that isn't a subclass of `GrammaredSequence`, this is # guaranteed by `TabularMSA`. if not isinstance(seq, (GrammaredSequence, TabularMSA)): raise TypeError( "`seq1` and `seq2` must be GrammaredSequence subclasses or " "TabularMSA, not type %r" % type(seq).__name__) seq1 = _coerce_alignment_input_type(seq1) seq2 = _coerce_alignment_input_type(seq2) if seq1.dtype is not seq2.dtype: raise TypeError( "`seq1` and `seq2` must have the same dtype: %r != %r" % (seq1.dtype.__name__, seq2.dtype.__name__)) if penalize_terminal_gaps: init_matrices_f = _init_matrices_nw else: init_matrices_f = _init_matrices_nw_no_terminal_gap_penalty score_matrix, traceback_matrix = \ _compute_score_and_traceback_matrices( seq1, seq2, gap_open_penalty, gap_extend_penalty, substitution_matrix, new_alignment_score=-np.inf, init_matrices_f=init_matrices_f, penalize_terminal_gaps=penalize_terminal_gaps) end_row_position = traceback_matrix.shape[0] - 1 end_col_position = traceback_matrix.shape[1] - 1 aligned1, aligned2, score, seq1_start_position, seq2_start_position = \ _traceback(traceback_matrix, score_matrix, seq1, seq2, end_row_position, end_col_position) start_end_positions = [(seq1_start_position, end_col_position-1), (seq2_start_position, end_row_position-1)] msa = TabularMSA(aligned1 + aligned2) return msa, score, start_end_positions @deprecated(as_of="0.5.8", until="0.6.0", reason="This will be removed or replaced, in favor of more general" "-purpose performant aligners. Additional details at " "https://github.com/biocore/scikit-bio/issues/1814") def local_pairwise_align_ssw(sequence1, sequence2, **kwargs): """Align query and target sequences with Striped Smith-Waterman. Parameters ---------- sequence1 : DNA, RNA, or Protein The first unaligned sequence sequence2 : DNA, RNA, or Protein The second unaligned sequence Returns ------- tuple ``TabularMSA`` object containing the aligned sequences, alignment score (float), and start/end positions of each input sequence (iterable of two-item tuples). Note that start/end positions are indexes into the unaligned sequences. Notes ----- This is a wrapper for the SSW package [1]_. For a complete list of optional keyword-arguments that can be provided, see ``skbio.alignment.StripedSmithWaterman``. The following kwargs will not have any effect: `suppress_sequences`, `zero_index`, and `protein` If an alignment does not meet a provided filter, `None` will be returned. References ---------- .. [1] Zhao, Mengyao, Wan-Ping Lee, Erik P. Garrison, & Gabor T. Marth. "SSW Library: An SIMD Smith-Waterman C/C++ Library for Applications". PLOS ONE (2013). Web. 11 July 2014. http://www.plosone.org/article/info:doi/10.1371/journal.pone.0082138 See Also -------- skbio.alignment.StripedSmithWaterman """ for seq in sequence1, sequence2: if not isinstance(seq, (DNA, RNA, Protein)): raise TypeError( "`sequence1` and `sequence2` must be DNA, RNA, or Protein, " "not type %r" % type(seq).__name__) if type(sequence1) is not type(sequence2): raise TypeError( "`sequence1` and `sequence2` must be the same type: %r != %r" % (type(sequence1).__name__, type(sequence2).__name__)) # We need the sequences for `TabularMSA` to make sense, so don't let the # user suppress them. kwargs['suppress_sequences'] = False kwargs['zero_index'] = True kwargs['protein'] = False if isinstance(sequence1, Protein): kwargs['protein'] = True query = StripedSmithWaterman(str(sequence1), **kwargs) alignment = query(str(sequence2)) # If there is no cigar, then it has failed a filter. Return None. if not alignment.cigar: return None start_end = None if alignment.query_begin != -1: start_end = [ (alignment.query_begin, alignment.query_end), (alignment.target_begin, alignment.target_end_optimal) ] metadata1 = metadata2 = None if sequence1.has_metadata(): metadata1 = sequence1.metadata if sequence2.has_metadata(): metadata2 = sequence2.metadata constructor = type(sequence1) msa = TabularMSA([ constructor(alignment.aligned_query_sequence, metadata=metadata1, validate=False), constructor(alignment.aligned_target_sequence, metadata=metadata2, validate=False) ]) return msa, alignment.optimal_alignment_score, start_end @deprecated(as_of="0.4.0", until="0.6.0", reason="Will be replaced by a SubstitutionMatrix class. To track " "progress, see [#161]" "(https://github.com/biocore/scikit-bio/issues/161).") def make_identity_substitution_matrix(match_score, mismatch_score, alphabet='ACGTU'): """Generate substitution matrix where all matches are scored equally Parameters ---------- match_score : int, float The score that should be assigned for all matches. This value is typically positive. mismatch_score : int, float The score that should be assigned for all mismatches. This value is typically negative. alphabet : iterable of str, optional The characters that should be included in the substitution matrix. Returns ------- dict of dicts All characters in alphabet are keys in both dictionaries, so that any pair of characters can be looked up to get their match or mismatch score. """ result = {} for c1 in alphabet: row = {} for c2 in alphabet: if c1 == c2: row[c2] = match_score else: row[c2] = mismatch_score result[c1] = row return result # Functions from here allow for generalized (global or local) alignment. I # will likely want to put these in a single object to make the naming a little # less clunky. def _coerce_alignment_input_type(seq): if isinstance(seq, GrammaredSequence): return TabularMSA([seq]) else: return seq _traceback_encoding = {'match': 1, 'vertical-gap': 2, 'horizontal-gap': 3, 'uninitialized': -1, 'alignment-end': 0} def _init_matrices_sw(aln1, aln2, gap_open_penalty, gap_extend_penalty): shape = (aln2.shape.position+1, aln1.shape.position+1) score_matrix = np.zeros(shape) traceback_matrix = np.zeros(shape, dtype=int) traceback_matrix += _traceback_encoding['uninitialized'] traceback_matrix[0, :] = _traceback_encoding['alignment-end'] traceback_matrix[:, 0] = _traceback_encoding['alignment-end'] return score_matrix, traceback_matrix def _init_matrices_nw(aln1, aln2, gap_open_penalty, gap_extend_penalty): shape = (aln2.shape.position+1, aln1.shape.position+1) score_matrix = np.zeros(shape) traceback_matrix = np.zeros(shape, dtype=int) traceback_matrix += _traceback_encoding['uninitialized'] traceback_matrix[0, 0] = _traceback_encoding['alignment-end'] # cache some values for quicker access vgap = _traceback_encoding['vertical-gap'] hgap = _traceback_encoding['horizontal-gap'] for i in range(1, shape[0]): score_matrix[i, 0] = -gap_open_penalty - ((i-1) * gap_extend_penalty) traceback_matrix[i, 0] = vgap for i in range(1, shape[1]): score_matrix[0, i] = -gap_open_penalty - ((i-1) * gap_extend_penalty) traceback_matrix[0, i] = hgap return score_matrix, traceback_matrix def _init_matrices_nw_no_terminal_gap_penalty( aln1, aln2, gap_open_penalty, gap_extend_penalty): shape = (aln2.shape.position+1, aln1.shape.position+1) score_matrix = np.zeros(shape) traceback_matrix = np.zeros(shape, dtype=int) traceback_matrix += _traceback_encoding['uninitialized'] traceback_matrix[0, 0] = _traceback_encoding['alignment-end'] # cache some values for quicker access vgap = _traceback_encoding['vertical-gap'] hgap = _traceback_encoding['horizontal-gap'] for i in range(1, shape[0]): traceback_matrix[i, 0] = vgap for i in range(1, shape[1]): traceback_matrix[0, i] = hgap return score_matrix, traceback_matrix def _compute_substitution_score(aln1_chars, aln2_chars, substitution_matrix, gap_substitution_score, gap_chars): substitution_score = 0 for aln1_char, aln2_char in product(aln1_chars, aln2_chars): if aln1_char in gap_chars or aln2_char in gap_chars: substitution_score += gap_substitution_score else: try: substitution_score += \ substitution_matrix[aln1_char][aln2_char] except KeyError: offending_chars = \ [c for c in (aln1_char, aln2_char) if c not in substitution_matrix] raise ValueError( "One of the sequences contains a character that is " "not contained in the substitution matrix. Are you " "using an appropriate substitution matrix for your " "sequence type (e.g., a nucleotide substitution " "matrix does not make sense for aligning protein " "sequences)? Does your sequence contain invalid " "characters? The offending character(s) is: " " %s." % ', '.join(offending_chars)) substitution_score /= (len(aln1_chars) * len(aln2_chars)) return substitution_score def _compute_score_and_traceback_matrices( aln1, aln2, gap_open_penalty, gap_extend_penalty, substitution_matrix, new_alignment_score=-np.inf, init_matrices_f=_init_matrices_nw, penalize_terminal_gaps=True, gap_substitution_score=0): """Return dynamic programming (score) and traceback matrices. A note on the ``penalize_terminal_gaps`` parameter. When this value is ``False``, this function is no longer true Smith-Waterman/Needleman-Wunsch scoring, but when ``True`` it can result in biologically irrelevant artifacts in Needleman-Wunsch (global) alignments. Specifically, if one sequence is longer than the other (e.g., if aligning a primer sequence to an amplification product, or searching for a gene in a genome) the shorter sequence will have a long gap inserted. The parameter is ``True`` by default (so that this function computes the score and traceback matrices as described by the original authors) but the global alignment wrappers pass ``False`` by default, so that the global alignment API returns the result that users are most likely to be looking for. """ aln1_length = aln1.shape.position aln2_length = aln2.shape.position # cache some values for quicker/simpler access aend = _traceback_encoding['alignment-end'] match = _traceback_encoding['match'] vgap = _traceback_encoding['vertical-gap'] hgap = _traceback_encoding['horizontal-gap'] new_alignment_score = (new_alignment_score, aend) # Initialize a matrix to use for scoring the alignment and for tracing # back the best alignment score_matrix, traceback_matrix = init_matrices_f( aln1, aln2, gap_open_penalty, gap_extend_penalty) # Iterate over the characters in aln2 (which corresponds to the vertical # sequence in the matrix) for aln2_pos, aln2_chars in enumerate(aln2.iter_positions( ignore_metadata=True), 1): aln2_chars = str(aln2_chars) # Iterate over the characters in aln1 (which corresponds to the # horizontal sequence in the matrix) for aln1_pos, aln1_chars in enumerate(aln1.iter_positions( ignore_metadata=True), 1): aln1_chars = str(aln1_chars) # compute the score for a match/mismatch substitution_score = _compute_substitution_score( aln1_chars, aln2_chars, substitution_matrix, gap_substitution_score, aln1.dtype.gap_chars) diag_score = \ (score_matrix[aln2_pos-1, aln1_pos-1] + substitution_score, match) # compute the score for adding a gap in aln2 (vertical) if not penalize_terminal_gaps and (aln1_pos == aln1_length): # we've reached the end of aln1, so adding vertical gaps # (which become gaps in aln1) should no longer # be penalized (if penalize_terminal_gaps == False) up_score = (score_matrix[aln2_pos-1, aln1_pos], vgap) elif traceback_matrix[aln2_pos-1, aln1_pos] == vgap: # gap extend, because the cell above was also a gap up_score = \ (score_matrix[aln2_pos-1, aln1_pos] - gap_extend_penalty, vgap) else: # gap open, because the cell above was not a gap up_score = \ (score_matrix[aln2_pos-1, aln1_pos] - gap_open_penalty, vgap) # compute the score for adding a gap in aln1 (horizontal) if not penalize_terminal_gaps and (aln2_pos == aln2_length): # we've reached the end of aln2, so adding horizontal gaps # (which become gaps in aln2) should no longer # be penalized (if penalize_terminal_gaps == False) left_score = (score_matrix[aln2_pos, aln1_pos-1], hgap) elif traceback_matrix[aln2_pos, aln1_pos-1] == hgap: # gap extend, because the cell to the left was also a gap left_score = \ (score_matrix[aln2_pos, aln1_pos-1] - gap_extend_penalty, hgap) else: # gap open, because the cell to the left was not a gap left_score = \ (score_matrix[aln2_pos, aln1_pos-1] - gap_open_penalty, hgap) # identify the largest score, and use that information to populate # the score and traceback matrices best_score = _first_largest([new_alignment_score, left_score, diag_score, up_score]) score_matrix[aln2_pos, aln1_pos] = best_score[0] traceback_matrix[aln2_pos, aln1_pos] = best_score[1] return score_matrix, traceback_matrix def _traceback(traceback_matrix, score_matrix, aln1, aln2, start_row, start_col): # cache some values for simpler reference aend = _traceback_encoding['alignment-end'] match = _traceback_encoding['match'] vgap = _traceback_encoding['vertical-gap'] hgap = _traceback_encoding['horizontal-gap'] gap_character = aln1.dtype.default_gap_char # initialize the result alignments aln1_sequence_count = aln1.shape.sequence aligned_seqs1 = [[] for e in range(aln1_sequence_count)] aln2_sequence_count = aln2.shape.sequence aligned_seqs2 = [[] for e in range(aln2_sequence_count)] current_row = start_row current_col = start_col best_score = score_matrix[current_row, current_col] current_value = None while current_value != aend: current_value = traceback_matrix[current_row, current_col] if current_value == match: for aligned_seq, input_seq in zip(aligned_seqs1, aln1): aligned_seq.append(str(input_seq[current_col-1])) for aligned_seq, input_seq in zip(aligned_seqs2, aln2): aligned_seq.append(str(input_seq[current_row-1])) current_row -= 1 current_col -= 1 elif current_value == vgap: for aligned_seq in aligned_seqs1: aligned_seq.append(gap_character) for aligned_seq, input_seq in zip(aligned_seqs2, aln2): aligned_seq.append(str(input_seq[current_row-1])) current_row -= 1 elif current_value == hgap: for aligned_seq, input_seq in zip(aligned_seqs1, aln1): aligned_seq.append(str(input_seq[current_col-1])) for aligned_seq in aligned_seqs2: aligned_seq.append(gap_character) current_col -= 1 elif current_value == aend: continue else: raise ValueError( "Invalid value in traceback matrix: %s" % current_value) for i, (aligned_seq, original) in enumerate(zip(aligned_seqs1, aln1)): aligned_seq = ''.join(aligned_seq)[::-1] constructor = aln1.dtype metadata = None if original.has_metadata(): metadata = original.metadata aligned_seqs1[i] = constructor(aligned_seq, metadata=metadata, validate=False) for i, (aligned_seq, original) in enumerate(zip(aligned_seqs2, aln2)): aligned_seq = ''.join(aligned_seq)[::-1] constructor = aln2.dtype metadata = None if original.has_metadata(): metadata = original.metadata aligned_seqs2[i] = constructor(aligned_seq, metadata=metadata, validate=False) return aligned_seqs1, aligned_seqs2, best_score, current_col, current_row def _first_largest(scores): """ Similar to max, but returns the first element achieving the high score If max receives a tuple, it will break a tie for the highest value of entry[i] with entry[i+1]. We don't want that here - to better match with the results of other tools, we want to be able to define which entry is returned in the case of a tie. """ result = scores[0] for score, direction in scores[1:]: if score > result[0]: result = (score, direction) return result scikit-bio-0.5.9/skbio/alignment/_repr.py000066400000000000000000000050551446255456000203500ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.metadata._repr import _MetadataReprBuilder class _TabularMSAReprBuilder(_MetadataReprBuilder): def __init__(self, msa, width, indent): super(_TabularMSAReprBuilder, self).__init__(msa, width, indent) self._ellipse_insert = ' ... ' def _process_header(self): cls_name = self._obj.__class__.__name__ if self._obj.dtype is not None: dtype_class = '[' + self._obj.dtype.__name__ + ']' else: dtype_class = '' self._lines.add_line(cls_name + dtype_class) self._lines.add_separator() def _process_data(self): num_sequences = self._obj.shape.sequence num_positions = self._obj.shape.position # catch case of all empty sequences if num_positions > 0: # display all sequences if we can, else display the first two and # last two sequences separated by ellipsis if num_sequences <= 5: self._lines.add_lines( self._format_sequences(range(num_sequences))) else: self._lines.add_lines(self._format_sequences(range(2))) self._lines.add_line('...') self._lines.add_lines(self._format_sequences( range(num_sequences - 2, num_sequences))) def _format_sequences(self, sequence_indices): lines = [] for line_index in sequence_indices: seq_str = str(self._obj._get_sequence_iloc_(line_index)) if len(seq_str) <= self._width: formatted_seq = seq_str else: formatted_seq = ( seq_str[0:self._num_characters_before_ellipse()] + self._ellipse_insert + seq_str[-self._num_characters_after_ellipse():] ) lines.append(formatted_seq) return lines def _num_characters_before_ellipse(self): return int(self._num_characters_to_display() / 2) def _num_characters_after_ellipse(self): return (self._num_characters_to_display() - self._num_characters_before_ellipse()) def _num_characters_to_display(self): return self._width - len(self._ellipse_insert) scikit-bio-0.5.9/skbio/alignment/_ssw_wrapper.c000066400000000000000000024357431446255456000215630ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayscalars.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarraytypes.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ufuncobject.h", "skbio/alignment/_lib/ssw.h" ], "extra_compile_args": [ "-I.", "-fopenmp-simd", "-DSIMDE_ENABLE_OPENMP" ], "include_dirs": [ "skbio/alignment", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include" ], "name": "skbio.alignment._ssw_wrapper", "sources": [ "skbio/alignment/_ssw_wrapper.pyx", "skbio/alignment/_lib/ssw.c" ] }, "module_name": "skbio.alignment._ssw_wrapper" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__alignment___ssw_wrapper #define __PYX_HAVE_API__skbio__alignment___ssw_wrapper /* Early includes */ #include #include #include "pythread.h" #include "numpy/arrayobject.h" #include "numpy/ndarrayobject.h" #include "numpy/ndarraytypes.h" #include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ #include "_lib/ssw.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "skbio/alignment/_ssw_wrapper.pyx", "stringsource", "__init__.pxd", "type.pxd", "bool.pxd", "complex.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":689 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":690 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":691 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":696 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":697 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":698 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":703 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":704 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":713 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":714 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":715 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":717 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":718 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":719 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":721 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":722 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":724 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":725 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":726 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":728 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":729 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":730 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":732 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* "skbio/alignment/_ssw_wrapper.pyx":73 * * * cdef class AlignmentStructure: # <<<<<<<<<<<<<< * """Wraps the result of an alignment c struct so it is accessible to Python * */ struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure { PyObject_HEAD struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_vtab; s_align *p; PyObject *read_sequence; PyObject *reference_sequence; int index_starts_at; PyObject *_cigar_string; }; /* "skbio/alignment/_ssw_wrapper.pyx":397 * return tuples * * cdef class StripedSmithWaterman: # <<<<<<<<<<<<<< * """Performs a striped (banded) Smith Waterman Alignment. * */ struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman { PyObject_HEAD struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_vtab; s_profile *profile; __pyx_t_5numpy_uint8_t gap_open_penalty; __pyx_t_5numpy_uint8_t gap_extend_penalty; __pyx_t_5numpy_uint8_t bit_flag; __pyx_t_5numpy_uint16_t score_filter; __pyx_t_5numpy_int32_t distance_filter; __pyx_t_5numpy_int32_t mask_length; PyObject *read_sequence; int index_starts_at; PyBoolObject *is_protein; PyBoolObject *suppress_sequences; PyArrayObject *__pyx___KEEP_IT_IN_SCOPE_read; PyArrayObject *__pyx___KEEP_IT_IN_SCOPE_matrix; }; /* "skbio/alignment/_ssw_wrapper.pyx":73 * * * cdef class AlignmentStructure: # <<<<<<<<<<<<<< * """Wraps the result of an alignment c struct so it is accessible to Python * */ struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure { PyObject *(*__pyx___constructor)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *, s_align *); }; static struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; /* "skbio/alignment/_ssw_wrapper.pyx":397 * return tuples * * cdef class StripedSmithWaterman: # <<<<<<<<<<<<<< * """Performs a striped (banded) Smith Waterman Alignment. * */ struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman { PyArrayObject *(*_seq_converter)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *); PyArrayObject *(*_build_match_matrix)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *, PyObject *); PyArrayObject *(*_convert_dict2d_to_matrix)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *); }; static struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* StringJoin.proto */ #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join #define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) #else #define __Pyx_PyString_Join PyUnicode_Join #define __Pyx_PyBaseString_Join PyUnicode_Join #endif #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_Join _PyString_Join #else #define __Pyx_PyBytes_Join _PyBytes_Join #endif #else static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); #endif /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* BufferFallbackError.proto */ static void __Pyx_RaiseBufferFallbackError(void); /* DivInt[Py_ssize_t].proto */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); /* UnicodeAsUCS4.proto */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); /* object_ord.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyObject_Ord(c)\ (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) #else #define __Pyx_PyObject_Ord(c) __Pyx__PyObject_Ord(c) #endif static long __Pyx__PyObject_Ord(PyObject* c); /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrCContig1d(type, buf, i0, s0) ((type)buf + i0) /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_uint16(npy_uint16 value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int32(npy_int32 value); /* CIntFromPy.proto */ static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE npy_uint8 __Pyx_PyInt_As_npy_uint8(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE npy_uint16 __Pyx_PyInt_As_npy_uint16(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE npy_int8 __Pyx_PyInt_As_npy_int8(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___constructor(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, s_align *__pyx_v_pointer); /* proto*/ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__seq_converter(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_sequence); /* proto*/ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__build_match_matrix(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_match_score, PyObject *__pyx_v_mismatch_score); /* proto*/ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__convert_dict2d_to_matrix(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_dict2d); /* proto*/ /* Module declarations from 'cpython.version' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_generic = 0; static PyTypeObject *__pyx_ptype_5numpy_number = 0; static PyTypeObject *__pyx_ptype_5numpy_integer = 0; static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; static PyTypeObject *__pyx_ptype_5numpy_floating = 0; static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'skbio.alignment._ssw_wrapper' */ static PyTypeObject *__pyx_ptype_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure = 0; static PyTypeObject *__pyx_ptype_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman = 0; static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t = { "int8_t", NULL, sizeof(__pyx_t_5numpy_int8_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int8_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int8_t), 0 }; #define __Pyx_MODULE_NAME "skbio.alignment._ssw_wrapper" extern int __pyx_module_is_main_skbio__alignment___ssw_wrapper; int __pyx_module_is_main_skbio__alignment___ssw_wrapper = 0; /* Implementation of 'skbio.alignment._ssw_wrapper' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_[] = ",\n"; static const char __pyx_k_D[] = "D"; static const char __pyx_k_I[] = "I"; static const char __pyx_k_M[] = "M"; static const char __pyx_k_N[] = "N"; static const char __pyx_k_s[] = "{\n%s\n}"; static const char __pyx_k__3[] = "..."; static const char __pyx_k__4[] = "\n"; static const char __pyx_k__5[] = ""; static const char __pyx_k__6[] = "-"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_end[] = "end"; static const char __pyx_k_r_r[] = " {!r}: {!r}"; static const char __pyx_k_int8[] = "int8"; static const char __pyx_k_join[] = "join"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_ACGTN[] = "ACGTN"; static const char __pyx_k_array[] = "array"; static const char __pyx_k_begin[] = "begin"; static const char __pyx_k_cigar[] = "cigar"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_empty[] = "empty"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_Protein[] = "Protein"; static const char __pyx_k_Score_d[] = "Score: %d"; static const char __pyx_k_isdigit[] = "isdigit"; static const char __pyx_k_protein[] = "protein"; static const char __pyx_k_Length_d[] = "Length: %d"; static const char __pyx_k_Sequence[] = "Sequence"; static const char __pyx_k_gap_type[] = "gap_type"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_sequence[] = "sequence"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_mask_auto[] = "mask_auto"; static const char __pyx_k_mid_table[] = "mid_table"; static const char __pyx_k_query_end[] = "query_end"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_score_only[] = "score_only"; static const char __pyx_k_score_size[] = "score_size"; static const char __pyx_k_zero_index[] = "zero_index"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_mask_length[] = "mask_length"; static const char __pyx_k_match_score[] = "match_score"; static const char __pyx_k_np_aa_table[] = "np_aa_table"; static const char __pyx_k_np_nt_table[] = "np_nt_table"; static const char __pyx_k_query_begin[] = "query_begin"; static const char __pyx_k_tuple_cigar[] = "tuple_cigar"; static const char __pyx_k_get_bit_flag[] = "_get_bit_flag"; static const char __pyx_k_score_filter[] = "score_filter"; static const char __pyx_k_target_begin[] = "target_begin"; static const char __pyx_k_is_zero_based[] = "is_zero_based"; static const char __pyx_k_read_sequence[] = "read_sequence"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_mismatch_score[] = "mismatch_score"; static const char __pyx_k_query_sequence[] = "query_sequence"; static const char __pyx_k_set_zero_based[] = "set_zero_based"; static const char __pyx_k_skbio_sequence[] = "skbio.sequence"; static const char __pyx_k_distance_filter[] = "distance_filter"; static const char __pyx_k_index_starts_at[] = "index_starts_at"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_target_sequence[] = "target_sequence"; static const char __pyx_k_gap_open_penalty[] = "gap_open_penalty"; static const char __pyx_k_tuples_from_cigar[] = "_tuples_from_cigar"; static const char __pyx_k_AlignmentStructure[] = "AlignmentStructure"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_gap_extend_penalty[] = "gap_extend_penalty"; static const char __pyx_k_override_skip_babp[] = "override_skip_babp"; static const char __pyx_k_reference_sequence[] = "reference_sequence"; static const char __pyx_k_suppress_sequences[] = "suppress_sequences"; static const char __pyx_k_target_end_optimal[] = "target_end_optimal"; static const char __pyx_k_substitution_matrix[] = "substitution_matrix"; static const char __pyx_k_StripedSmithWaterman[] = "StripedSmithWaterman"; static const char __pyx_k_get_aligned_sequence[] = "_get_aligned_sequence"; static const char __pyx_k_target_end_suboptimal[] = "target_end_suboptimal"; static const char __pyx_k_aligned_query_sequence[] = "aligned_query_sequence"; static const char __pyx_k_ARNDCQEGHILKMFPSTWYVBZX[] = "ARNDCQEGHILKMFPSTWYVBZX*"; static const char __pyx_k_aligned_target_sequence[] = "aligned_target_sequence"; static const char __pyx_k_optimal_alignment_score[] = "optimal_alignment_score"; static const char __pyx_k_gap_open_penalty_must_be_0[] = "`gap_open_penalty` must be > 0"; static const char __pyx_k_suboptimal_alignment_score[] = "suboptimal_alignment_score"; static const char __pyx_k_gap_extend_penalty_must_be_0[] = "`gap_extend_penalty` must be > 0"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_Must_provide_a_substitution_matr[] = "Must provide a substitution matrix for protein sequences"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static PyObject *__pyx_kp_s_; static PyObject *__pyx_n_s_ACGTN; static PyObject *__pyx_kp_s_ARNDCQEGHILKMFPSTWYVBZX; static PyObject *__pyx_n_s_AlignmentStructure; static PyObject *__pyx_n_s_D; static PyObject *__pyx_n_s_I; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_s_Length_d; static PyObject *__pyx_n_s_M; static PyObject *__pyx_kp_s_Must_provide_a_substitution_matr; static PyObject *__pyx_n_s_N; static PyObject *__pyx_n_s_Protein; static PyObject *__pyx_kp_s_Score_d; static PyObject *__pyx_n_s_Sequence; static PyObject *__pyx_n_s_StripedSmithWaterman; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_s__3; static PyObject *__pyx_kp_s__4; static PyObject *__pyx_kp_s__5; static PyObject *__pyx_kp_s__6; static PyObject *__pyx_n_s_aligned_query_sequence; static PyObject *__pyx_n_s_aligned_target_sequence; static PyObject *__pyx_n_s_array; static PyObject *__pyx_n_s_begin; static PyObject *__pyx_n_s_cigar; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_distance_filter; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_empty; static PyObject *__pyx_n_s_end; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_format; static PyObject *__pyx_n_s_gap_extend_penalty; static PyObject *__pyx_kp_s_gap_extend_penalty_must_be_0; static PyObject *__pyx_n_s_gap_open_penalty; static PyObject *__pyx_kp_s_gap_open_penalty_must_be_0; static PyObject *__pyx_n_s_gap_type; static PyObject *__pyx_n_s_get_aligned_sequence; static PyObject *__pyx_n_s_get_bit_flag; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_index_starts_at; static PyObject *__pyx_n_s_int8; static PyObject *__pyx_n_s_is_zero_based; static PyObject *__pyx_n_s_isdigit; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mask_auto; static PyObject *__pyx_n_s_mask_length; static PyObject *__pyx_n_s_match_score; static PyObject *__pyx_n_s_mid_table; static PyObject *__pyx_n_s_mismatch_score; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_np_aa_table; static PyObject *__pyx_n_s_np_nt_table; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_optimal_alignment_score; static PyObject *__pyx_n_s_override_skip_babp; static PyObject *__pyx_n_s_protein; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_query_begin; static PyObject *__pyx_n_s_query_end; static PyObject *__pyx_n_s_query_sequence; static PyObject *__pyx_kp_s_r_r; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_read_sequence; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_reference_sequence; static PyObject *__pyx_kp_s_s; static PyObject *__pyx_n_s_score_filter; static PyObject *__pyx_n_s_score_only; static PyObject *__pyx_n_s_score_size; static PyObject *__pyx_n_s_sequence; static PyObject *__pyx_n_s_set_zero_based; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_skbio_sequence; static PyObject *__pyx_n_s_suboptimal_alignment_score; static PyObject *__pyx_n_s_substitution_matrix; static PyObject *__pyx_n_s_suppress_sequences; static PyObject *__pyx_n_s_target_begin; static PyObject *__pyx_n_s_target_end_optimal; static PyObject *__pyx_n_s_target_end_suboptimal; static PyObject *__pyx_n_s_target_sequence; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_tuple_cigar; static PyObject *__pyx_n_s_tuples_from_cigar; static PyObject *__pyx_n_s_zero_index; static int __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___cinit__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_read_sequence, PyObject *__pyx_v_reference_sequence, PyObject *__pyx_v_index_starts_at); /* proto */ static void __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_2__dealloc__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_4__getitem__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_6__repr__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_8__str__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_10set_zero_based(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_is_zero_based); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12is_zero_based(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14_get_aligned_sequence(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_sequence, PyObject *__pyx_v_tuple_cigar, PyObject *__pyx_v_begin, PyObject *__pyx_v_end, PyObject *__pyx_v_gap_type); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_16_tuples_from_cigar(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman___cinit__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_query_sequence, PyObject *__pyx_v_gap_open_penalty, PyObject *__pyx_v_gap_extend_penalty, PyObject *__pyx_v_score_size, PyObject *__pyx_v_mask_length, PyObject *__pyx_v_mask_auto, PyObject *__pyx_v_score_only, PyObject *__pyx_v_score_filter, PyObject *__pyx_v_distance_filter, PyObject *__pyx_v_override_skip_babp, PyObject *__pyx_v_protein, PyObject *__pyx_v_match_score, PyObject *__pyx_v_mismatch_score, PyObject *__pyx_v_substitution_matrix, PyObject *__pyx_v_suppress_sequences, PyObject *__pyx_v_zero_index); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_target_sequence); /* proto */ static void __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_4__dealloc__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_6_get_bit_flag(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_override_skip_babp, PyObject *__pyx_v_score_only); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; static PyObject *__pyx_int_3; static PyObject *__pyx_int_4; static PyObject *__pyx_int_5; static PyObject *__pyx_int_6; static PyObject *__pyx_int_7; static PyObject *__pyx_int_8; static PyObject *__pyx_int_9; static PyObject *__pyx_int_10; static PyObject *__pyx_int_11; static PyObject *__pyx_int_12; static PyObject *__pyx_int_13; static PyObject *__pyx_int_14; static PyObject *__pyx_int_15; static PyObject *__pyx_int_16; static PyObject *__pyx_int_17; static PyObject *__pyx_int_18; static PyObject *__pyx_int_19; static PyObject *__pyx_int_20; static PyObject *__pyx_int_21; static PyObject *__pyx_int_22; static PyObject *__pyx_int_23; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_int_neg_3; static PyObject *__pyx_slice__2; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; /* Late includes */ /* "skbio/alignment/_ssw_wrapper.pyx":91 * cdef str _cigar_string * * def __cinit__(self, read_sequence, reference_sequence, index_starts_at): # <<<<<<<<<<<<<< * # We use `read_sequence` and `reference_sequence` here as they are * # treated sematically as a private output of ssw.c like the `s_align` */ /* Python wrapper */ static int __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_read_sequence = 0; PyObject *__pyx_v_reference_sequence = 0; PyObject *__pyx_v_index_starts_at = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_read_sequence,&__pyx_n_s_reference_sequence,&__pyx_n_s_index_starts_at,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_read_sequence)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reference_sequence)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(0, 91, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_index_starts_at)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(0, 91, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 91, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_read_sequence = values[0]; __pyx_v_reference_sequence = values[1]; __pyx_v_index_starts_at = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 91, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___cinit__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self), __pyx_v_read_sequence, __pyx_v_reference_sequence, __pyx_v_index_starts_at); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___cinit__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_read_sequence, PyObject *__pyx_v_reference_sequence, PyObject *__pyx_v_index_starts_at) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":95 * # treated sematically as a private output of ssw.c like the `s_align` * # struct * self.read_sequence = read_sequence # <<<<<<<<<<<<<< * self.reference_sequence = reference_sequence * self.index_starts_at = index_starts_at */ if (!(likely(PyString_CheckExact(__pyx_v_read_sequence))||((__pyx_v_read_sequence) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_read_sequence)->tp_name), 0))) __PYX_ERR(0, 95, __pyx_L1_error) __pyx_t_1 = __pyx_v_read_sequence; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->read_sequence); __Pyx_DECREF(__pyx_v_self->read_sequence); __pyx_v_self->read_sequence = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":96 * # struct * self.read_sequence = read_sequence * self.reference_sequence = reference_sequence # <<<<<<<<<<<<<< * self.index_starts_at = index_starts_at * */ if (!(likely(PyString_CheckExact(__pyx_v_reference_sequence))||((__pyx_v_reference_sequence) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_reference_sequence)->tp_name), 0))) __PYX_ERR(0, 96, __pyx_L1_error) __pyx_t_1 = __pyx_v_reference_sequence; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->reference_sequence); __Pyx_DECREF(__pyx_v_self->reference_sequence); __pyx_v_self->reference_sequence = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":97 * self.read_sequence = read_sequence * self.reference_sequence = reference_sequence * self.index_starts_at = index_starts_at # <<<<<<<<<<<<<< * * cdef __constructor(self, s_align* pointer): */ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_index_starts_at); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) __pyx_v_self->index_starts_at = __pyx_t_2; /* "skbio/alignment/_ssw_wrapper.pyx":91 * cdef str _cigar_string * * def __cinit__(self, read_sequence, reference_sequence, index_starts_at): # <<<<<<<<<<<<<< * # We use `read_sequence` and `reference_sequence` here as they are * # treated sematically as a private output of ssw.c like the `s_align` */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":99 * self.index_starts_at = index_starts_at * * cdef __constructor(self, s_align* pointer): # <<<<<<<<<<<<<< * self.p = pointer * */ static PyObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___constructor(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, s_align *__pyx_v_pointer) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__constructor", 0); /* "skbio/alignment/_ssw_wrapper.pyx":100 * * cdef __constructor(self, s_align* pointer): * self.p = pointer # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_v_self->p = __pyx_v_pointer; /* "skbio/alignment/_ssw_wrapper.pyx":99 * self.index_starts_at = index_starts_at * * cdef __constructor(self, s_align* pointer): # <<<<<<<<<<<<<< * self.p = pointer * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":102 * self.p = pointer * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self.p is not NULL: * align_destroy(self.p) */ /* Python wrapper */ static void __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_3__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_2__dealloc__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_2__dealloc__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":103 * * def __dealloc__(self): * if self.p is not NULL: # <<<<<<<<<<<<<< * align_destroy(self.p) * */ __pyx_t_1 = ((__pyx_v_self->p != NULL) != 0); if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":104 * def __dealloc__(self): * if self.p is not NULL: * align_destroy(self.p) # <<<<<<<<<<<<<< * * def __getitem__(self, key): */ align_destroy(__pyx_v_self->p); /* "skbio/alignment/_ssw_wrapper.pyx":103 * * def __dealloc__(self): * if self.p is not NULL: # <<<<<<<<<<<<<< * align_destroy(self.p) * */ } /* "skbio/alignment/_ssw_wrapper.pyx":102 * self.p = pointer * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self.p is not NULL: * align_destroy(self.p) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "skbio/alignment/_ssw_wrapper.pyx":106 * align_destroy(self.p) * * def __getitem__(self, key): # <<<<<<<<<<<<<< * return getattr(self, key) * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_4__getitem__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self), ((PyObject *)__pyx_v_key)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_4__getitem__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":107 * * def __getitem__(self, key): * return getattr(self, key) # <<<<<<<<<<<<<< * * def __repr__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":106 * align_destroy(self.p) * * def __getitem__(self, key): # <<<<<<<<<<<<<< * return getattr(self, key) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":109 * return getattr(self, key) * * def __repr__(self): # <<<<<<<<<<<<<< * data = ['optimal_alignment_score', 'suboptimal_alignment_score', * 'query_begin', 'query_end', 'target_begin', */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_7__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_7__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_6__repr__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_6__repr__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_v_data = NULL; PyObject *__pyx_v_k = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":110 * * def __repr__(self): * data = ['optimal_alignment_score', 'suboptimal_alignment_score', # <<<<<<<<<<<<<< * 'query_begin', 'query_end', 'target_begin', * 'target_end_optimal', 'target_end_suboptimal', 'cigar', */ __pyx_t_1 = PyList_New(10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_optimal_alignment_score); __Pyx_GIVEREF(__pyx_n_s_optimal_alignment_score); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_optimal_alignment_score); __Pyx_INCREF(__pyx_n_s_suboptimal_alignment_score); __Pyx_GIVEREF(__pyx_n_s_suboptimal_alignment_score); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_suboptimal_alignment_score); __Pyx_INCREF(__pyx_n_s_query_begin); __Pyx_GIVEREF(__pyx_n_s_query_begin); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_query_begin); __Pyx_INCREF(__pyx_n_s_query_end); __Pyx_GIVEREF(__pyx_n_s_query_end); PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_query_end); __Pyx_INCREF(__pyx_n_s_target_begin); __Pyx_GIVEREF(__pyx_n_s_target_begin); PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_target_begin); __Pyx_INCREF(__pyx_n_s_target_end_optimal); __Pyx_GIVEREF(__pyx_n_s_target_end_optimal); PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_target_end_optimal); __Pyx_INCREF(__pyx_n_s_target_end_suboptimal); __Pyx_GIVEREF(__pyx_n_s_target_end_suboptimal); PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_target_end_suboptimal); __Pyx_INCREF(__pyx_n_s_cigar); __Pyx_GIVEREF(__pyx_n_s_cigar); PyList_SET_ITEM(__pyx_t_1, 7, __pyx_n_s_cigar); __Pyx_INCREF(__pyx_n_s_query_sequence); __Pyx_GIVEREF(__pyx_n_s_query_sequence); PyList_SET_ITEM(__pyx_t_1, 8, __pyx_n_s_query_sequence); __Pyx_INCREF(__pyx_n_s_target_sequence); __Pyx_GIVEREF(__pyx_n_s_target_sequence); PyList_SET_ITEM(__pyx_t_1, 9, __pyx_n_s_target_sequence); __pyx_v_data = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":114 * 'target_end_optimal', 'target_end_suboptimal', 'cigar', * 'query_sequence', 'target_sequence'] * return "{\n%s\n}" % ',\n'.join([ # <<<<<<<<<<<<<< * " {!r}: {!r}".format(k, self[k]) for k in data]) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "skbio/alignment/_ssw_wrapper.pyx":115 * 'query_sequence', 'target_sequence'] * return "{\n%s\n}" % ',\n'.join([ * " {!r}: {!r}".format(k, self[k]) for k in data]) # <<<<<<<<<<<<<< * * def __str__(self): */ __pyx_t_2 = __pyx_v_data; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; for (;;) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 115, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_r_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_k); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_k, __pyx_t_6}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_k, __pyx_t_6}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_v_k); __Pyx_GIVEREF(__pyx_v_k); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_k); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":114 * 'target_end_optimal', 'target_end_suboptimal', 'cigar', * 'query_sequence', 'target_sequence'] * return "{\n%s\n}" % ',\n'.join([ # <<<<<<<<<<<<<< * " {!r}: {!r}".format(k, self[k]) for k in data]) * */ __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s_, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":109 * return getattr(self, key) * * def __repr__(self): # <<<<<<<<<<<<<< * data = ['optimal_alignment_score', 'suboptimal_alignment_score', * 'query_begin', 'query_end', 'target_begin', */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_data); __Pyx_XDECREF(__pyx_v_k); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":117 * " {!r}: {!r}".format(k, self[k]) for k in data]) * * def __str__(self): # <<<<<<<<<<<<<< * score = "Score: %d" % self.optimal_alignment_score * if self.query_sequence and self.cigar: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9__str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_8__str__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_8__str__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_v_score = NULL; PyObject *__pyx_v_target = NULL; PyObject *__pyx_v_query = NULL; PyObject *__pyx_v_align_len = NULL; PyObject *__pyx_v_length = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":118 * * def __str__(self): * score = "Score: %d" % self.optimal_alignment_score # <<<<<<<<<<<<<< * if self.query_sequence and self.cigar: * target = self.aligned_target_sequence */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_optimal_alignment_score); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Score_d, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_score = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":119 * def __str__(self): * score = "Score: %d" % self.optimal_alignment_score * if self.query_sequence and self.cigar: # <<<<<<<<<<<<<< * target = self.aligned_target_sequence * query = self.aligned_query_sequence */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_query_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cigar); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __pyx_t_4; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "skbio/alignment/_ssw_wrapper.pyx":120 * score = "Score: %d" % self.optimal_alignment_score * if self.query_sequence and self.cigar: * target = self.aligned_target_sequence # <<<<<<<<<<<<<< * query = self.aligned_query_sequence * align_len = len(query) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_aligned_target_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_target = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":121 * if self.query_sequence and self.cigar: * target = self.aligned_target_sequence * query = self.aligned_query_sequence # <<<<<<<<<<<<<< * align_len = len(query) * if align_len > 13: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_aligned_query_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_query = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":122 * target = self.aligned_target_sequence * query = self.aligned_query_sequence * align_len = len(query) # <<<<<<<<<<<<<< * if align_len > 13: * target = target[:10] + "..." */ __pyx_t_5 = PyObject_Length(__pyx_v_query); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 122, __pyx_L1_error) __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_align_len = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":123 * query = self.aligned_query_sequence * align_len = len(query) * if align_len > 13: # <<<<<<<<<<<<<< * target = target[:10] + "..." * query = query[:10] + "..." */ __pyx_t_2 = PyObject_RichCompare(__pyx_v_align_len, __pyx_int_13, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { /* "skbio/alignment/_ssw_wrapper.pyx":124 * align_len = len(query) * if align_len > 13: * target = target[:10] + "..." # <<<<<<<<<<<<<< * query = query[:10] + "..." * */ __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_target, 0, 10, NULL, NULL, &__pyx_slice__2, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_kp_s__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_target, __pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":125 * if align_len > 13: * target = target[:10] + "..." * query = query[:10] + "..." # <<<<<<<<<<<<<< * * length = "Length: %d" % align_len */ __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_query, 0, 10, NULL, NULL, &__pyx_slice__2, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_kp_s__3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_query, __pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":123 * query = self.aligned_query_sequence * align_len = len(query) * if align_len > 13: # <<<<<<<<<<<<<< * target = target[:10] + "..." * query = query[:10] + "..." */ } /* "skbio/alignment/_ssw_wrapper.pyx":127 * query = query[:10] + "..." * * length = "Length: %d" % align_len # <<<<<<<<<<<<<< * return "\n".join([query, target, score, length]) * return score */ __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Length_d, __pyx_v_align_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_length = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":128 * * length = "Length: %d" % align_len * return "\n".join([query, target, score, length]) # <<<<<<<<<<<<<< * return score * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyList_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_query); __Pyx_GIVEREF(__pyx_v_query); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_query); __Pyx_INCREF(__pyx_v_target); __Pyx_GIVEREF(__pyx_v_target); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_v_target); __Pyx_INCREF(__pyx_v_score); __Pyx_GIVEREF(__pyx_v_score); PyList_SET_ITEM(__pyx_t_2, 2, __pyx_v_score); __Pyx_INCREF(__pyx_v_length); __Pyx_GIVEREF(__pyx_v_length); PyList_SET_ITEM(__pyx_t_2, 3, __pyx_v_length); __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":119 * def __str__(self): * score = "Score: %d" % self.optimal_alignment_score * if self.query_sequence and self.cigar: # <<<<<<<<<<<<<< * target = self.aligned_target_sequence * query = self.aligned_query_sequence */ } /* "skbio/alignment/_ssw_wrapper.pyx":129 * length = "Length: %d" % align_len * return "\n".join([query, target, score, length]) * return score # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_score); __pyx_r = __pyx_v_score; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":117 * " {!r}: {!r}".format(k, self[k]) for k in data]) * * def __str__(self): # <<<<<<<<<<<<<< * score = "Score: %d" % self.optimal_alignment_score * if self.query_sequence and self.cigar: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_score); __Pyx_XDECREF(__pyx_v_target); __Pyx_XDECREF(__pyx_v_query); __Pyx_XDECREF(__pyx_v_align_len); __Pyx_XDECREF(__pyx_v_length); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":132 * * @property * def optimal_alignment_score(self): # <<<<<<<<<<<<<< * """Optimal alignment score * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":141 * * """ * return self.p.score1 # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_npy_uint16(__pyx_v_self->p->score1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":132 * * @property * def optimal_alignment_score(self): # <<<<<<<<<<<<<< * """Optimal alignment score * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.optimal_alignment_score.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":144 * * @property * def suboptimal_alignment_score(self): # <<<<<<<<<<<<<< * """Suboptimal alignment score * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":153 * * """ * return self.p.score2 # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_npy_uint16(__pyx_v_self->p->score2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":144 * * @property * def suboptimal_alignment_score(self): # <<<<<<<<<<<<<< * """Suboptimal alignment score * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.suboptimal_alignment_score.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":156 * * @property * def target_begin(self): # <<<<<<<<<<<<<< * """Character index where the target's alignment begins * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":169 * * """ * return self.p.ref_begin1 + self.index_starts_at if (self.p.ref_begin1 # <<<<<<<<<<<<<< * >= 0) else -1 * */ __Pyx_XDECREF(__pyx_r); /* "skbio/alignment/_ssw_wrapper.pyx":170 * """ * return self.p.ref_begin1 + self.index_starts_at if (self.p.ref_begin1 * >= 0) else -1 # <<<<<<<<<<<<<< * * @property */ if (((__pyx_v_self->p->ref_begin1 >= 0) != 0)) { /* "skbio/alignment/_ssw_wrapper.pyx":169 * * """ * return self.p.ref_begin1 + self.index_starts_at if (self.p.ref_begin1 # <<<<<<<<<<<<<< * >= 0) else -1 * */ __pyx_t_2 = __Pyx_PyInt_From_npy_int32((__pyx_v_self->p->ref_begin1 + __pyx_v_self->index_starts_at)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_t_2; __pyx_t_2 = 0; } else { __Pyx_INCREF(__pyx_int_neg_1); __pyx_t_1 = __pyx_int_neg_1; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":156 * * @property * def target_begin(self): # <<<<<<<<<<<<<< * """Character index where the target's alignment begins * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.target_begin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":173 * * @property * def target_end_optimal(self): # <<<<<<<<<<<<<< * """Character index where the target's optimal alignment ends * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":187 * * """ * return self.p.ref_end1 + self.index_starts_at # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_npy_int32((__pyx_v_self->p->ref_end1 + __pyx_v_self->index_starts_at)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":173 * * @property * def target_end_optimal(self): # <<<<<<<<<<<<<< * """Character index where the target's optimal alignment ends * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.target_end_optimal.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":190 * * @property * def target_end_suboptimal(self): # <<<<<<<<<<<<<< * """Character index where the target's suboptimal alignment ends * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":204 * * """ * return self.p.ref_end2 + self.index_starts_at # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_npy_int32((__pyx_v_self->p->ref_end2 + __pyx_v_self->index_starts_at)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":190 * * @property * def target_end_suboptimal(self): # <<<<<<<<<<<<<< * """Character index where the target's suboptimal alignment ends * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.target_end_suboptimal.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":207 * * @property * def query_begin(self): # <<<<<<<<<<<<<< * """Returns the character index at which the query sequence begins * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":220 * * """ * return self.p.read_begin1 + self.index_starts_at if (self.p.read_begin1 # <<<<<<<<<<<<<< * >= 0) else -1 * */ __Pyx_XDECREF(__pyx_r); /* "skbio/alignment/_ssw_wrapper.pyx":221 * """ * return self.p.read_begin1 + self.index_starts_at if (self.p.read_begin1 * >= 0) else -1 # <<<<<<<<<<<<<< * * @property */ if (((__pyx_v_self->p->read_begin1 >= 0) != 0)) { /* "skbio/alignment/_ssw_wrapper.pyx":220 * * """ * return self.p.read_begin1 + self.index_starts_at if (self.p.read_begin1 # <<<<<<<<<<<<<< * >= 0) else -1 * */ __pyx_t_2 = __Pyx_PyInt_From_npy_int32((__pyx_v_self->p->read_begin1 + __pyx_v_self->index_starts_at)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_t_2; __pyx_t_2 = 0; } else { __Pyx_INCREF(__pyx_int_neg_1); __pyx_t_1 = __pyx_int_neg_1; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":207 * * @property * def query_begin(self): # <<<<<<<<<<<<<< * """Returns the character index at which the query sequence begins * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.query_begin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":224 * * @property * def query_end(self): # <<<<<<<<<<<<<< * """Character index at where query sequence ends * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":237 * * """ * return self.p.read_end1 + self.index_starts_at # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_npy_int32((__pyx_v_self->p->read_end1 + __pyx_v_self->index_starts_at)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":224 * * @property * def query_end(self): # <<<<<<<<<<<<<< * """Character index at where query sequence ends * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.query_end.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":240 * * @property * def cigar(self): # <<<<<<<<<<<<<< * """Cigar formatted string for the optimal alignment * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_v_cigar_list = NULL; __pyx_t_5numpy_int32_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; __pyx_t_5numpy_int32_t __pyx_t_4; __pyx_t_5numpy_int32_t __pyx_t_5; __pyx_t_5numpy_int32_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; long __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":262 * """ * # Memoization! (1/2) * if self._cigar_string is not None: # <<<<<<<<<<<<<< * return self._cigar_string * cigar_list = [] */ __pyx_t_1 = (__pyx_v_self->_cigar_string != ((PyObject*)Py_None)); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/alignment/_ssw_wrapper.pyx":263 * # Memoization! (1/2) * if self._cigar_string is not None: * return self._cigar_string # <<<<<<<<<<<<<< * cigar_list = [] * for i in range(self.p.cigarLen): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_cigar_string); __pyx_r = __pyx_v_self->_cigar_string; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":262 * """ * # Memoization! (1/2) * if self._cigar_string is not None: # <<<<<<<<<<<<<< * return self._cigar_string * cigar_list = [] */ } /* "skbio/alignment/_ssw_wrapper.pyx":264 * if self._cigar_string is not None: * return self._cigar_string * cigar_list = [] # <<<<<<<<<<<<<< * for i in range(self.p.cigarLen): * # stored the same as that in BAM format, */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_cigar_list = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":265 * return self._cigar_string * cigar_list = [] * for i in range(self.p.cigarLen): # <<<<<<<<<<<<<< * # stored the same as that in BAM format, * # high 28 bits: length, low 4 bits: M/I/D (0/1/2) */ __pyx_t_4 = __pyx_v_self->p->cigarLen; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "skbio/alignment/_ssw_wrapper.pyx":270 * * # Length, remove first 4 bits * cigar_list.append(str(self.p.cigar[i] >> 4)) # <<<<<<<<<<<<<< * # M/I/D, lookup first 4 bits in the mid_table * cigar_list.append(mid_table[self.p.cigar[i] & 0xf]) */ __pyx_t_3 = __Pyx_PyInt_From_long(((__pyx_v_self->p->cigar[__pyx_v_i]) >> 4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cigar_list, __pyx_t_7); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":272 * cigar_list.append(str(self.p.cigar[i] >> 4)) * # M/I/D, lookup first 4 bits in the mid_table * cigar_list.append(mid_table[self.p.cigar[i] & 0xf]) # <<<<<<<<<<<<<< * # Memoization! (2/2) * self._cigar_string = "".join(cigar_list) */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_mid_table); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = ((__pyx_v_self->p->cigar[__pyx_v_i]) & 0xf); __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_7, __pyx_t_9, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cigar_list, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 272, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } /* "skbio/alignment/_ssw_wrapper.pyx":274 * cigar_list.append(mid_table[self.p.cigar[i] & 0xf]) * # Memoization! (2/2) * self._cigar_string = "".join(cigar_list) # <<<<<<<<<<<<<< * return self._cigar_string * */ __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_v_cigar_list); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 274, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_cigar_string); __Pyx_DECREF(__pyx_v_self->_cigar_string); __pyx_v_self->_cigar_string = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":275 * # Memoization! (2/2) * self._cigar_string = "".join(cigar_list) * return self._cigar_string # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_cigar_string); __pyx_r = __pyx_v_self->_cigar_string; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":240 * * @property * def cigar(self): # <<<<<<<<<<<<<< * """Cigar formatted string for the optimal alignment * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.cigar.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_cigar_list); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":278 * * @property * def query_sequence(self): # <<<<<<<<<<<<<< * """Query sequence * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":287 * * """ * return self.read_sequence # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->read_sequence); __pyx_r = __pyx_v_self->read_sequence; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":278 * * @property * def query_sequence(self): # <<<<<<<<<<<<<< * """Query sequence * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":290 * * @property * def target_sequence(self): # <<<<<<<<<<<<<< * """Target sequence * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":299 * * """ * return self.reference_sequence # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->reference_sequence); __pyx_r = __pyx_v_self->reference_sequence; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":290 * * @property * def target_sequence(self): # <<<<<<<<<<<<<< * """Target sequence * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":302 * * @property * def aligned_query_sequence(self): # <<<<<<<<<<<<<< * """Returns the query sequence aligned by the cigar * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":316 * * """ * if self.query_sequence: # <<<<<<<<<<<<<< * return self._get_aligned_sequence(self.query_sequence, * self._tuples_from_cigar(), */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_query_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 316, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/alignment/_ssw_wrapper.pyx":317 * """ * if self.query_sequence: * return self._get_aligned_sequence(self.query_sequence, # <<<<<<<<<<<<<< * self._tuples_from_cigar(), * self.query_begin, self.query_end, */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_aligned_sequence); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_query_sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "skbio/alignment/_ssw_wrapper.pyx":318 * if self.query_sequence: * return self._get_aligned_sequence(self.query_sequence, * self._tuples_from_cigar(), # <<<<<<<<<<<<<< * self.query_begin, self.query_end, * "D") */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_tuples_from_cigar); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":319 * return self._get_aligned_sequence(self.query_sequence, * self._tuples_from_cigar(), * self.query_begin, self.query_end, # <<<<<<<<<<<<<< * "D") * return None */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_query_begin); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_query_end); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_n_s_D}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_n_s_D}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(5+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_n_s_D); __Pyx_GIVEREF(__pyx_n_s_D); PyTuple_SET_ITEM(__pyx_t_10, 4+__pyx_t_9, __pyx_n_s_D); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":316 * * """ * if self.query_sequence: # <<<<<<<<<<<<<< * return self._get_aligned_sequence(self.query_sequence, * self._tuples_from_cigar(), */ } /* "skbio/alignment/_ssw_wrapper.pyx":321 * self.query_begin, self.query_end, * "D") * return None # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":302 * * @property * def aligned_query_sequence(self): # <<<<<<<<<<<<<< * """Returns the query sequence aligned by the cigar * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.aligned_query_sequence.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":324 * * @property * def aligned_target_sequence(self): # <<<<<<<<<<<<<< * """Returns the target sequence aligned by the cigar * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence___get__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence___get__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":338 * * """ * if self.target_sequence: # <<<<<<<<<<<<<< * return self._get_aligned_sequence(self.target_sequence, * self._tuples_from_cigar(), */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_target_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/alignment/_ssw_wrapper.pyx":339 * """ * if self.target_sequence: * return self._get_aligned_sequence(self.target_sequence, # <<<<<<<<<<<<<< * self._tuples_from_cigar(), * self.target_begin, */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_aligned_sequence); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_target_sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); /* "skbio/alignment/_ssw_wrapper.pyx":340 * if self.target_sequence: * return self._get_aligned_sequence(self.target_sequence, * self._tuples_from_cigar(), # <<<<<<<<<<<<<< * self.target_begin, * self.target_end_optimal, */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_tuples_from_cigar); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":341 * return self._get_aligned_sequence(self.target_sequence, * self._tuples_from_cigar(), * self.target_begin, # <<<<<<<<<<<<<< * self.target_end_optimal, * "I") */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_target_begin); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); /* "skbio/alignment/_ssw_wrapper.pyx":342 * self._tuples_from_cigar(), * self.target_begin, * self.target_end_optimal, # <<<<<<<<<<<<<< * "I") * return None */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_target_end_optimal); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_n_s_I}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_n_s_I}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_9, 5+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(5+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_n_s_I); __Pyx_GIVEREF(__pyx_n_s_I); PyTuple_SET_ITEM(__pyx_t_10, 4+__pyx_t_9, __pyx_n_s_I); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 339, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":338 * * """ * if self.target_sequence: # <<<<<<<<<<<<<< * return self._get_aligned_sequence(self.target_sequence, * self._tuples_from_cigar(), */ } /* "skbio/alignment/_ssw_wrapper.pyx":344 * self.target_end_optimal, * "I") * return None # <<<<<<<<<<<<<< * * def set_zero_based(self, is_zero_based): */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":324 * * @property * def aligned_target_sequence(self): # <<<<<<<<<<<<<< * """Returns the target sequence aligned by the cigar * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.aligned_target_sequence.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":346 * return None * * def set_zero_based(self, is_zero_based): # <<<<<<<<<<<<<< * """Set the aligment indices to start at 0 if True else 1 if False * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11set_zero_based(PyObject *__pyx_v_self, PyObject *__pyx_v_is_zero_based); /*proto*/ static char __pyx_doc_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_10set_zero_based[] = "Set the aligment indices to start at 0 if True else 1 if False\n\n "; static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11set_zero_based(PyObject *__pyx_v_self, PyObject *__pyx_v_is_zero_based) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_zero_based (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_10set_zero_based(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self), ((PyObject *)__pyx_v_is_zero_based)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_10set_zero_based(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_is_zero_based) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_zero_based", 0); /* "skbio/alignment/_ssw_wrapper.pyx":350 * * """ * if is_zero_based: # <<<<<<<<<<<<<< * self.index_starts_at = 0 * else: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_is_zero_based); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 350, __pyx_L1_error) if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":351 * """ * if is_zero_based: * self.index_starts_at = 0 # <<<<<<<<<<<<<< * else: * self.index_starts_at = 1 */ __pyx_v_self->index_starts_at = 0; /* "skbio/alignment/_ssw_wrapper.pyx":350 * * """ * if is_zero_based: # <<<<<<<<<<<<<< * self.index_starts_at = 0 * else: */ goto __pyx_L3; } /* "skbio/alignment/_ssw_wrapper.pyx":353 * self.index_starts_at = 0 * else: * self.index_starts_at = 1 # <<<<<<<<<<<<<< * * def is_zero_based(self): */ /*else*/ { __pyx_v_self->index_starts_at = 1; } __pyx_L3:; /* "skbio/alignment/_ssw_wrapper.pyx":346 * return None * * def set_zero_based(self, is_zero_based): # <<<<<<<<<<<<<< * """Set the aligment indices to start at 0 if True else 1 if False * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.set_zero_based", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":355 * self.index_starts_at = 1 * * def is_zero_based(self): # <<<<<<<<<<<<<< * """Returns True if alignment inidices start at 0 else False * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_13is_zero_based(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12is_zero_based[] = "Returns True if alignment inidices start at 0 else False\n\n Returns\n -------\n bool\n Whether the alignment inidices start at 0\n\n "; static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_13is_zero_based(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_zero_based (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12is_zero_based(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12is_zero_based(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_zero_based", 0); /* "skbio/alignment/_ssw_wrapper.pyx":364 * * """ * return self.index_starts_at == 0 # <<<<<<<<<<<<<< * * def _get_aligned_sequence(self, sequence, tuple_cigar, begin, end, */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong((__pyx_v_self->index_starts_at == 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":355 * self.index_starts_at = 1 * * def is_zero_based(self): # <<<<<<<<<<<<<< * """Returns True if alignment inidices start at 0 else False * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.is_zero_based", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":366 * return self.index_starts_at == 0 * * def _get_aligned_sequence(self, sequence, tuple_cigar, begin, end, # <<<<<<<<<<<<<< * gap_type): * # Save the original index scheme and then set it to 0 (1/2) */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15_get_aligned_sequence(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15_get_aligned_sequence(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_sequence = 0; PyObject *__pyx_v_tuple_cigar = 0; PyObject *__pyx_v_begin = 0; PyObject *__pyx_v_end = 0; PyObject *__pyx_v_gap_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_aligned_sequence (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sequence,&__pyx_n_s_tuple_cigar,&__pyx_n_s_begin,&__pyx_n_s_end,&__pyx_n_s_gap_type,0}; PyObject* values[5] = {0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sequence)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tuple_cigar)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get_aligned_sequence", 1, 5, 5, 1); __PYX_ERR(0, 366, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_begin)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get_aligned_sequence", 1, 5, 5, 2); __PYX_ERR(0, 366, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get_aligned_sequence", 1, 5, 5, 3); __PYX_ERR(0, 366, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gap_type)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get_aligned_sequence", 1, 5, 5, 4); __PYX_ERR(0, 366, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get_aligned_sequence") < 0)) __PYX_ERR(0, 366, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); } __pyx_v_sequence = values[0]; __pyx_v_tuple_cigar = values[1]; __pyx_v_begin = values[2]; __pyx_v_end = values[3]; __pyx_v_gap_type = values[4]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_get_aligned_sequence", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 366, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure._get_aligned_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14_get_aligned_sequence(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self), __pyx_v_sequence, __pyx_v_tuple_cigar, __pyx_v_begin, __pyx_v_end, __pyx_v_gap_type); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14_get_aligned_sequence(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, PyObject *__pyx_v_sequence, PyObject *__pyx_v_tuple_cigar, PyObject *__pyx_v_begin, PyObject *__pyx_v_end, PyObject *__pyx_v_gap_type) { PyObject *__pyx_v_orig_z_base = NULL; PyObject *__pyx_v_aligned_sequence = NULL; PyObject *__pyx_v_seq = NULL; PyObject *__pyx_v_index = NULL; PyObject *__pyx_v_length = NULL; PyObject *__pyx_v_mid = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *(*__pyx_t_5)(PyObject *); PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_aligned_sequence", 0); /* "skbio/alignment/_ssw_wrapper.pyx":369 * gap_type): * # Save the original index scheme and then set it to 0 (1/2) * orig_z_base = self.is_zero_based() # <<<<<<<<<<<<<< * self.set_zero_based(True) * aligned_sequence = [] */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_zero_based); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_orig_z_base = __pyx_t_1; __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":370 * # Save the original index scheme and then set it to 0 (1/2) * orig_z_base = self.is_zero_based() * self.set_zero_based(True) # <<<<<<<<<<<<<< * aligned_sequence = [] * seq = sequence[begin:end + 1] */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_zero_based); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, Py_True) : __Pyx_PyObject_CallOneArg(__pyx_t_2, Py_True); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":371 * orig_z_base = self.is_zero_based() * self.set_zero_based(True) * aligned_sequence = [] # <<<<<<<<<<<<<< * seq = sequence[begin:end + 1] * index = 0 */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_aligned_sequence = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":372 * self.set_zero_based(True) * aligned_sequence = [] * seq = sequence[begin:end + 1] # <<<<<<<<<<<<<< * index = 0 * for length, mid in tuple_cigar: */ __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_v_end, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_sequence, 0, 0, &__pyx_v_begin, &__pyx_t_1, NULL, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_seq = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":373 * aligned_sequence = [] * seq = sequence[begin:end + 1] * index = 0 # <<<<<<<<<<<<<< * for length, mid in tuple_cigar: * if mid == gap_type: */ __Pyx_INCREF(__pyx_int_0); __pyx_v_index = __pyx_int_0; /* "skbio/alignment/_ssw_wrapper.pyx":374 * seq = sequence[begin:end + 1] * index = 0 * for length, mid in tuple_cigar: # <<<<<<<<<<<<<< * if mid == gap_type: * aligned_sequence += ['-' * length] */ if (likely(PyList_CheckExact(__pyx_v_tuple_cigar)) || PyTuple_CheckExact(__pyx_v_tuple_cigar)) { __pyx_t_2 = __pyx_v_tuple_cigar; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_tuple_cigar); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 374, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 374, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 374, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 374, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 374, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 374, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; __pyx_L5_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 374, __pyx_L1_error) __pyx_L6_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_mid, __pyx_t_6); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":375 * index = 0 * for length, mid in tuple_cigar: * if mid == gap_type: # <<<<<<<<<<<<<< * aligned_sequence += ['-' * length] * else: */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_mid, __pyx_v_gap_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __pyx_L1_error) __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_9) { /* "skbio/alignment/_ssw_wrapper.pyx":376 * for length, mid in tuple_cigar: * if mid == gap_type: * aligned_sequence += ['-' * length] # <<<<<<<<<<<<<< * else: * aligned_sequence += [seq[index:index + length]] */ __pyx_t_1 = PyNumber_Multiply(__pyx_kp_s__6, __pyx_v_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_aligned_sequence, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_aligned_sequence, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":375 * index = 0 * for length, mid in tuple_cigar: * if mid == gap_type: # <<<<<<<<<<<<<< * aligned_sequence += ['-' * length] * else: */ goto __pyx_L7; } /* "skbio/alignment/_ssw_wrapper.pyx":378 * aligned_sequence += ['-' * length] * else: * aligned_sequence += [seq[index:index + length]] # <<<<<<<<<<<<<< * index += length * # Our sequence end is sometimes beyond the cigar: */ /*else*/ { __pyx_t_1 = PyNumber_Add(__pyx_v_index, __pyx_v_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_v_seq, 0, 0, &__pyx_v_index, &__pyx_t_1, NULL, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_6); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_aligned_sequence, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_aligned_sequence, ((PyObject*)__pyx_t_6)); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":379 * else: * aligned_sequence += [seq[index:index + length]] * index += length # <<<<<<<<<<<<<< * # Our sequence end is sometimes beyond the cigar: * aligned_sequence += [seq[index:end - begin + 1]] */ __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_index, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_6); __pyx_t_6 = 0; } __pyx_L7:; /* "skbio/alignment/_ssw_wrapper.pyx":374 * seq = sequence[begin:end + 1] * index = 0 * for length, mid in tuple_cigar: # <<<<<<<<<<<<<< * if mid == gap_type: * aligned_sequence += ['-' * length] */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":381 * index += length * # Our sequence end is sometimes beyond the cigar: * aligned_sequence += [seq[index:end - begin + 1]] # <<<<<<<<<<<<<< * # Revert our index scheme to the original (2/2) * self.set_zero_based(orig_z_base) */ __pyx_t_2 = PyNumber_Subtract(__pyx_v_end, __pyx_v_begin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_seq, 0, 0, &__pyx_v_index, &__pyx_t_6, NULL, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_2); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_aligned_sequence, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_aligned_sequence, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":383 * aligned_sequence += [seq[index:end - begin + 1]] * # Revert our index scheme to the original (2/2) * self.set_zero_based(orig_z_base) # <<<<<<<<<<<<<< * return "".join(aligned_sequence) * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_zero_based); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_1, __pyx_v_orig_z_base) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_orig_z_base); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 383, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":384 * # Revert our index scheme to the original (2/2) * self.set_zero_based(orig_z_base) * return "".join(aligned_sequence) # <<<<<<<<<<<<<< * * def _tuples_from_cigar(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_v_aligned_sequence); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":366 * return self.index_starts_at == 0 * * def _get_aligned_sequence(self, sequence, tuple_cigar, begin, end, # <<<<<<<<<<<<<< * gap_type): * # Save the original index scheme and then set it to 0 (1/2) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure._get_aligned_sequence", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_orig_z_base); __Pyx_XDECREF(__pyx_v_aligned_sequence); __Pyx_XDECREF(__pyx_v_seq); __Pyx_XDECREF(__pyx_v_index); __Pyx_XDECREF(__pyx_v_length); __Pyx_XDECREF(__pyx_v_mid); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":386 * return "".join(aligned_sequence) * * def _tuples_from_cigar(self): # <<<<<<<<<<<<<< * tuples = [] * length_stack = [] */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_17_tuples_from_cigar(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_17_tuples_from_cigar(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_tuples_from_cigar (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_16_tuples_from_cigar(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_16_tuples_from_cigar(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_v_tuples = NULL; PyObject *__pyx_v_length_stack = NULL; PyObject *__pyx_v_character = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_tuples_from_cigar", 0); /* "skbio/alignment/_ssw_wrapper.pyx":387 * * def _tuples_from_cigar(self): * tuples = [] # <<<<<<<<<<<<<< * length_stack = [] * for character in self.cigar: */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_tuples = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":388 * def _tuples_from_cigar(self): * tuples = [] * length_stack = [] # <<<<<<<<<<<<<< * for character in self.cigar: * if character.isdigit(): */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_length_stack = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":389 * tuples = [] * length_stack = [] * for character in self.cigar: # <<<<<<<<<<<<<< * if character.isdigit(): * length_stack.append(character) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cigar); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 389, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 389, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 389, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 389, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_character, __pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":390 * length_stack = [] * for character in self.cigar: * if character.isdigit(): # <<<<<<<<<<<<<< * length_stack.append(character) * else: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_character, __pyx_n_s_isdigit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 390, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_7) { /* "skbio/alignment/_ssw_wrapper.pyx":391 * for character in self.cigar: * if character.isdigit(): * length_stack.append(character) # <<<<<<<<<<<<<< * else: * tuples.append((int("".join(length_stack)), character)) */ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_length_stack, __pyx_v_character); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 391, __pyx_L1_error) /* "skbio/alignment/_ssw_wrapper.pyx":390 * length_stack = [] * for character in self.cigar: * if character.isdigit(): # <<<<<<<<<<<<<< * length_stack.append(character) * else: */ goto __pyx_L5; } /* "skbio/alignment/_ssw_wrapper.pyx":393 * length_stack.append(character) * else: * tuples.append((int("".join(length_stack)), character)) # <<<<<<<<<<<<<< * length_stack = [] * return tuples */ /*else*/ { __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_v_length_stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __Pyx_INCREF(__pyx_v_character); __Pyx_GIVEREF(__pyx_v_character); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_character); __pyx_t_5 = 0; __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_tuples, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 393, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":394 * else: * tuples.append((int("".join(length_stack)), character)) * length_stack = [] # <<<<<<<<<<<<<< * return tuples * */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_length_stack, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; } __pyx_L5:; /* "skbio/alignment/_ssw_wrapper.pyx":389 * tuples = [] * length_stack = [] * for character in self.cigar: # <<<<<<<<<<<<<< * if character.isdigit(): * length_stack.append(character) */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":395 * tuples.append((int("".join(length_stack)), character)) * length_stack = [] * return tuples # <<<<<<<<<<<<<< * * cdef class StripedSmithWaterman: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_tuples); __pyx_r = __pyx_v_tuples; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":386 * return "".join(aligned_sequence) * * def _tuples_from_cigar(self): # <<<<<<<<<<<<<< * tuples = [] * length_stack = [] */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure._tuples_from_cigar", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tuples); __Pyx_XDECREF(__pyx_v_length_stack); __Pyx_XDECREF(__pyx_v_character); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18__reduce_cython__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_20__setstate_cython__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.AlignmentStructure.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":539 * cdef cnp.ndarray __KEEP_IT_IN_SCOPE_matrix * * def __cinit__(self, query_sequence, # <<<<<<<<<<<<<< * gap_open_penalty=5, # BLASTN Default * gap_extend_penalty=2, # BLASTN Default */ /* Python wrapper */ static int __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_query_sequence = 0; PyObject *__pyx_v_gap_open_penalty = 0; PyObject *__pyx_v_gap_extend_penalty = 0; PyObject *__pyx_v_score_size = 0; PyObject *__pyx_v_mask_length = 0; PyObject *__pyx_v_mask_auto = 0; PyObject *__pyx_v_score_only = 0; PyObject *__pyx_v_score_filter = 0; PyObject *__pyx_v_distance_filter = 0; PyObject *__pyx_v_override_skip_babp = 0; PyObject *__pyx_v_protein = 0; PyObject *__pyx_v_match_score = 0; PyObject *__pyx_v_mismatch_score = 0; PyObject *__pyx_v_substitution_matrix = 0; PyObject *__pyx_v_suppress_sequences = 0; PyObject *__pyx_v_zero_index = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_query_sequence,&__pyx_n_s_gap_open_penalty,&__pyx_n_s_gap_extend_penalty,&__pyx_n_s_score_size,&__pyx_n_s_mask_length,&__pyx_n_s_mask_auto,&__pyx_n_s_score_only,&__pyx_n_s_score_filter,&__pyx_n_s_distance_filter,&__pyx_n_s_override_skip_babp,&__pyx_n_s_protein,&__pyx_n_s_match_score,&__pyx_n_s_mismatch_score,&__pyx_n_s_substitution_matrix,&__pyx_n_s_suppress_sequences,&__pyx_n_s_zero_index,0}; PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; values[1] = ((PyObject *)__pyx_int_5); values[2] = ((PyObject *)__pyx_int_2); values[3] = ((PyObject *)__pyx_int_2); values[4] = ((PyObject *)__pyx_int_15); /* "skbio/alignment/_ssw_wrapper.pyx":544 * score_size=2, # BLASTN Default * mask_length=15, # Minimum length for a suboptimal alignment * mask_auto=True, # <<<<<<<<<<<<<< * score_only=False, * score_filter=None, */ values[5] = ((PyObject *)Py_True); /* "skbio/alignment/_ssw_wrapper.pyx":545 * mask_length=15, # Minimum length for a suboptimal alignment * mask_auto=True, * score_only=False, # <<<<<<<<<<<<<< * score_filter=None, * distance_filter=None, */ values[6] = ((PyObject *)Py_False); /* "skbio/alignment/_ssw_wrapper.pyx":546 * mask_auto=True, * score_only=False, * score_filter=None, # <<<<<<<<<<<<<< * distance_filter=None, * override_skip_babp=False, */ values[7] = ((PyObject *)Py_None); /* "skbio/alignment/_ssw_wrapper.pyx":547 * score_only=False, * score_filter=None, * distance_filter=None, # <<<<<<<<<<<<<< * override_skip_babp=False, * protein=False, */ values[8] = ((PyObject *)Py_None); /* "skbio/alignment/_ssw_wrapper.pyx":548 * score_filter=None, * distance_filter=None, * override_skip_babp=False, # <<<<<<<<<<<<<< * protein=False, * match_score=2, # BLASTN Default */ values[9] = ((PyObject *)Py_False); /* "skbio/alignment/_ssw_wrapper.pyx":549 * distance_filter=None, * override_skip_babp=False, * protein=False, # <<<<<<<<<<<<<< * match_score=2, # BLASTN Default * mismatch_score=-3, # BLASTN Default */ values[10] = ((PyObject *)Py_False); values[11] = ((PyObject *)__pyx_int_2); values[12] = ((PyObject *)__pyx_int_neg_3); /* "skbio/alignment/_ssw_wrapper.pyx":552 * match_score=2, # BLASTN Default * mismatch_score=-3, # BLASTN Default * substitution_matrix=None, # <<<<<<<<<<<<<< * suppress_sequences=False, * zero_index=True): */ values[13] = ((PyObject *)Py_None); /* "skbio/alignment/_ssw_wrapper.pyx":553 * mismatch_score=-3, # BLASTN Default * substitution_matrix=None, * suppress_sequences=False, # <<<<<<<<<<<<<< * zero_index=True): * # initialize our values */ values[14] = ((PyObject *)Py_False); /* "skbio/alignment/_ssw_wrapper.pyx":554 * substitution_matrix=None, * suppress_sequences=False, * zero_index=True): # <<<<<<<<<<<<<< * # initialize our values * self.read_sequence = query_sequence */ values[15] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); CYTHON_FALLTHROUGH; case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); CYTHON_FALLTHROUGH; case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); CYTHON_FALLTHROUGH; case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); CYTHON_FALLTHROUGH; case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); CYTHON_FALLTHROUGH; case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_query_sequence)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gap_open_penalty); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gap_extend_penalty); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_score_size); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask_length); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask_auto); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_score_only); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_score_filter); if (value) { values[7] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_distance_filter); if (value) { values[8] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 9: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_override_skip_babp); if (value) { values[9] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 10: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_protein); if (value) { values[10] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 11: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_match_score); if (value) { values[11] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 12: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mismatch_score); if (value) { values[12] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 13: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_substitution_matrix); if (value) { values[13] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 14: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_suppress_sequences); if (value) { values[14] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 15: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_zero_index); if (value) { values[15] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 539, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); CYTHON_FALLTHROUGH; case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); CYTHON_FALLTHROUGH; case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); CYTHON_FALLTHROUGH; case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); CYTHON_FALLTHROUGH; case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); CYTHON_FALLTHROUGH; case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_query_sequence = values[0]; __pyx_v_gap_open_penalty = values[1]; __pyx_v_gap_extend_penalty = values[2]; __pyx_v_score_size = values[3]; __pyx_v_mask_length = values[4]; __pyx_v_mask_auto = values[5]; __pyx_v_score_only = values[6]; __pyx_v_score_filter = values[7]; __pyx_v_distance_filter = values[8]; __pyx_v_override_skip_babp = values[9]; __pyx_v_protein = values[10]; __pyx_v_match_score = values[11]; __pyx_v_mismatch_score = values[12]; __pyx_v_substitution_matrix = values[13]; __pyx_v_suppress_sequences = values[14]; __pyx_v_zero_index = values[15]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 16, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 539, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman___cinit__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self), __pyx_v_query_sequence, __pyx_v_gap_open_penalty, __pyx_v_gap_extend_penalty, __pyx_v_score_size, __pyx_v_mask_length, __pyx_v_mask_auto, __pyx_v_score_only, __pyx_v_score_filter, __pyx_v_distance_filter, __pyx_v_override_skip_babp, __pyx_v_protein, __pyx_v_match_score, __pyx_v_mismatch_score, __pyx_v_substitution_matrix, __pyx_v_suppress_sequences, __pyx_v_zero_index); /* "skbio/alignment/_ssw_wrapper.pyx":539 * cdef cnp.ndarray __KEEP_IT_IN_SCOPE_matrix * * def __cinit__(self, query_sequence, # <<<<<<<<<<<<<< * gap_open_penalty=5, # BLASTN Default * gap_extend_penalty=2, # BLASTN Default */ /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman___cinit__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_query_sequence, PyObject *__pyx_v_gap_open_penalty, PyObject *__pyx_v_gap_extend_penalty, PyObject *__pyx_v_score_size, PyObject *__pyx_v_mask_length, PyObject *__pyx_v_mask_auto, PyObject *__pyx_v_score_only, PyObject *__pyx_v_score_filter, PyObject *__pyx_v_distance_filter, PyObject *__pyx_v_override_skip_babp, PyObject *__pyx_v_protein, PyObject *__pyx_v_match_score, PyObject *__pyx_v_mismatch_score, PyObject *__pyx_v_substitution_matrix, PyObject *__pyx_v_suppress_sequences, PyObject *__pyx_v_zero_index) { PyArrayObject *__pyx_v_matrix = 0; PyArrayObject *__pyx_v_read_seq = 0; __pyx_t_5numpy_int32_t __pyx_v_read_length; __pyx_t_5numpy_int8_t __pyx_v_s_size; __pyx_t_5numpy_int32_t __pyx_v_m_width; __Pyx_LocalBuf_ND __pyx_pybuffernd_matrix; __Pyx_Buffer __pyx_pybuffer_matrix; __Pyx_LocalBuf_ND __pyx_pybuffernd_read_seq; __Pyx_Buffer __pyx_pybuffer_read_seq; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; __pyx_t_5numpy_uint8_t __pyx_t_3; __pyx_t_5numpy_int32_t __pyx_t_4; __pyx_t_5numpy_int32_t __pyx_t_5; __pyx_t_5numpy_uint16_t __pyx_t_6; __pyx_t_5numpy_uint16_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; Py_ssize_t __pyx_t_16; __pyx_t_5numpy_int8_t __pyx_t_17; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __pyx_pybuffer_matrix.pybuffer.buf = NULL; __pyx_pybuffer_matrix.refcount = 0; __pyx_pybuffernd_matrix.data = NULL; __pyx_pybuffernd_matrix.rcbuffer = &__pyx_pybuffer_matrix; __pyx_pybuffer_read_seq.pybuffer.buf = NULL; __pyx_pybuffer_read_seq.refcount = 0; __pyx_pybuffernd_read_seq.data = NULL; __pyx_pybuffernd_read_seq.rcbuffer = &__pyx_pybuffer_read_seq; /* "skbio/alignment/_ssw_wrapper.pyx":556 * zero_index=True): * # initialize our values * self.read_sequence = query_sequence # <<<<<<<<<<<<<< * if gap_open_penalty <= 0: * raise ValueError("`gap_open_penalty` must be > 0") */ if (!(likely(PyString_CheckExact(__pyx_v_query_sequence))||((__pyx_v_query_sequence) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_query_sequence)->tp_name), 0))) __PYX_ERR(0, 556, __pyx_L1_error) __pyx_t_1 = __pyx_v_query_sequence; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->read_sequence); __Pyx_DECREF(__pyx_v_self->read_sequence); __pyx_v_self->read_sequence = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":557 * # initialize our values * self.read_sequence = query_sequence * if gap_open_penalty <= 0: # <<<<<<<<<<<<<< * raise ValueError("`gap_open_penalty` must be > 0") * self.gap_open_penalty = gap_open_penalty */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_gap_open_penalty, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_2)) { /* "skbio/alignment/_ssw_wrapper.pyx":558 * self.read_sequence = query_sequence * if gap_open_penalty <= 0: * raise ValueError("`gap_open_penalty` must be > 0") # <<<<<<<<<<<<<< * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 558, __pyx_L1_error) /* "skbio/alignment/_ssw_wrapper.pyx":557 * # initialize our values * self.read_sequence = query_sequence * if gap_open_penalty <= 0: # <<<<<<<<<<<<<< * raise ValueError("`gap_open_penalty` must be > 0") * self.gap_open_penalty = gap_open_penalty */ } /* "skbio/alignment/_ssw_wrapper.pyx":559 * if gap_open_penalty <= 0: * raise ValueError("`gap_open_penalty` must be > 0") * self.gap_open_penalty = gap_open_penalty # <<<<<<<<<<<<<< * if gap_extend_penalty <= 0: * raise ValueError("`gap_extend_penalty` must be > 0") */ __pyx_t_3 = __Pyx_PyInt_As_npy_uint8(__pyx_v_gap_open_penalty); if (unlikely((__pyx_t_3 == ((npy_uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 559, __pyx_L1_error) __pyx_v_self->gap_open_penalty = __pyx_t_3; /* "skbio/alignment/_ssw_wrapper.pyx":560 * raise ValueError("`gap_open_penalty` must be > 0") * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: # <<<<<<<<<<<<<< * raise ValueError("`gap_extend_penalty` must be > 0") * self.gap_extend_penalty = gap_extend_penalty */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_gap_extend_penalty, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 560, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_2)) { /* "skbio/alignment/_ssw_wrapper.pyx":561 * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: * raise ValueError("`gap_extend_penalty` must be > 0") # <<<<<<<<<<<<<< * self.gap_extend_penalty = gap_extend_penalty * self.distance_filter = 0 if distance_filter is None else \ */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 561, __pyx_L1_error) /* "skbio/alignment/_ssw_wrapper.pyx":560 * raise ValueError("`gap_open_penalty` must be > 0") * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: # <<<<<<<<<<<<<< * raise ValueError("`gap_extend_penalty` must be > 0") * self.gap_extend_penalty = gap_extend_penalty */ } /* "skbio/alignment/_ssw_wrapper.pyx":562 * if gap_extend_penalty <= 0: * raise ValueError("`gap_extend_penalty` must be > 0") * self.gap_extend_penalty = gap_extend_penalty # <<<<<<<<<<<<<< * self.distance_filter = 0 if distance_filter is None else \ * distance_filter */ __pyx_t_3 = __Pyx_PyInt_As_npy_uint8(__pyx_v_gap_extend_penalty); if (unlikely((__pyx_t_3 == ((npy_uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 562, __pyx_L1_error) __pyx_v_self->gap_extend_penalty = __pyx_t_3; /* "skbio/alignment/_ssw_wrapper.pyx":563 * raise ValueError("`gap_extend_penalty` must be > 0") * self.gap_extend_penalty = gap_extend_penalty * self.distance_filter = 0 if distance_filter is None else \ # <<<<<<<<<<<<<< * distance_filter * self.score_filter = 0 if score_filter is None else score_filter */ __pyx_t_2 = (__pyx_v_distance_filter == Py_None); if ((__pyx_t_2 != 0)) { __pyx_t_4 = 0; } else { /* "skbio/alignment/_ssw_wrapper.pyx":564 * self.gap_extend_penalty = gap_extend_penalty * self.distance_filter = 0 if distance_filter is None else \ * distance_filter # <<<<<<<<<<<<<< * self.score_filter = 0 if score_filter is None else score_filter * self.suppress_sequences = suppress_sequences */ __pyx_t_5 = __Pyx_PyInt_As_npy_int32(__pyx_v_distance_filter); if (unlikely((__pyx_t_5 == ((npy_int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 564, __pyx_L1_error) __pyx_t_4 = __pyx_t_5; } /* "skbio/alignment/_ssw_wrapper.pyx":563 * raise ValueError("`gap_extend_penalty` must be > 0") * self.gap_extend_penalty = gap_extend_penalty * self.distance_filter = 0 if distance_filter is None else \ # <<<<<<<<<<<<<< * distance_filter * self.score_filter = 0 if score_filter is None else score_filter */ __pyx_v_self->distance_filter = __pyx_t_4; /* "skbio/alignment/_ssw_wrapper.pyx":565 * self.distance_filter = 0 if distance_filter is None else \ * distance_filter * self.score_filter = 0 if score_filter is None else score_filter # <<<<<<<<<<<<<< * self.suppress_sequences = suppress_sequences * self.is_protein = protein */ __pyx_t_2 = (__pyx_v_score_filter == Py_None); if ((__pyx_t_2 != 0)) { __pyx_t_6 = 0; } else { __pyx_t_7 = __Pyx_PyInt_As_npy_uint16(__pyx_v_score_filter); if (unlikely((__pyx_t_7 == ((npy_uint16)-1)) && PyErr_Occurred())) __PYX_ERR(0, 565, __pyx_L1_error) __pyx_t_6 = __pyx_t_7; } __pyx_v_self->score_filter = __pyx_t_6; /* "skbio/alignment/_ssw_wrapper.pyx":566 * distance_filter * self.score_filter = 0 if score_filter is None else score_filter * self.suppress_sequences = suppress_sequences # <<<<<<<<<<<<<< * self.is_protein = protein * self.bit_flag = self._get_bit_flag(override_skip_babp, score_only) */ if (!(likely(((__pyx_v_suppress_sequences) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_suppress_sequences, __pyx_ptype_7cpython_4bool_bool))))) __PYX_ERR(0, 566, __pyx_L1_error) __pyx_t_1 = __pyx_v_suppress_sequences; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->suppress_sequences); __Pyx_DECREF(((PyObject *)__pyx_v_self->suppress_sequences)); __pyx_v_self->suppress_sequences = ((PyBoolObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":567 * self.score_filter = 0 if score_filter is None else score_filter * self.suppress_sequences = suppress_sequences * self.is_protein = protein # <<<<<<<<<<<<<< * self.bit_flag = self._get_bit_flag(override_skip_babp, score_only) * # http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html */ if (!(likely(((__pyx_v_protein) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_protein, __pyx_ptype_7cpython_4bool_bool))))) __PYX_ERR(0, 567, __pyx_L1_error) __pyx_t_1 = __pyx_v_protein; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->is_protein); __Pyx_DECREF(((PyObject *)__pyx_v_self->is_protein)); __pyx_v_self->is_protein = ((PyBoolObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":568 * self.suppress_sequences = suppress_sequences * self.is_protein = protein * self.bit_flag = self._get_bit_flag(override_skip_babp, score_only) # <<<<<<<<<<<<<< * # http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html * # Dijkstra knows what's up: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_bit_flag); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_override_skip_babp, __pyx_v_score_only}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_override_skip_babp, __pyx_v_score_only}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_v_override_skip_babp); __Pyx_GIVEREF(__pyx_v_override_skip_babp); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_override_skip_babp); __Pyx_INCREF(__pyx_v_score_only); __Pyx_GIVEREF(__pyx_v_score_only); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_score_only); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_3 = __Pyx_PyInt_As_npy_uint8(__pyx_t_1); if (unlikely((__pyx_t_3 == ((npy_uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->bit_flag = __pyx_t_3; /* "skbio/alignment/_ssw_wrapper.pyx":571 * # http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html * # Dijkstra knows what's up: * self.index_starts_at = 0 if zero_index else 1 # <<<<<<<<<<<<<< * # set up our matrix * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_zero_index); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) if (__pyx_t_2) { __pyx_t_10 = 0; } else { __pyx_t_10 = 1; } __pyx_v_self->index_starts_at = __pyx_t_10; /* "skbio/alignment/_ssw_wrapper.pyx":574 * # set up our matrix * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix * if substitution_matrix is None: # <<<<<<<<<<<<<< * if protein: * raise Exception("Must provide a substitution matrix for" */ __pyx_t_2 = (__pyx_v_substitution_matrix == Py_None); __pyx_t_12 = (__pyx_t_2 != 0); if (__pyx_t_12) { /* "skbio/alignment/_ssw_wrapper.pyx":575 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix * if substitution_matrix is None: * if protein: # <<<<<<<<<<<<<< * raise Exception("Must provide a substitution matrix for" * " protein sequences") */ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_protein); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 575, __pyx_L1_error) if (unlikely(__pyx_t_12)) { /* "skbio/alignment/_ssw_wrapper.pyx":576 * if substitution_matrix is None: * if protein: * raise Exception("Must provide a substitution matrix for" # <<<<<<<<<<<<<< * " protein sequences") * matrix = self._build_match_matrix(match_score, mismatch_score) */ __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 576, __pyx_L1_error) /* "skbio/alignment/_ssw_wrapper.pyx":575 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix * if substitution_matrix is None: * if protein: # <<<<<<<<<<<<<< * raise Exception("Must provide a substitution matrix for" * " protein sequences") */ } /* "skbio/alignment/_ssw_wrapper.pyx":578 * raise Exception("Must provide a substitution matrix for" * " protein sequences") * matrix = self._build_match_matrix(match_score, mismatch_score) # <<<<<<<<<<<<<< * else: * matrix = self._convert_dict2d_to_matrix(substitution_matrix) */ __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self->__pyx_vtab)->_build_match_matrix(__pyx_v_self, __pyx_v_match_score, __pyx_v_mismatch_score)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer); __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack); if (unlikely(__pyx_t_10 < 0)) { PyErr_Fetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer, (PyObject*)__pyx_v_matrix, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_15); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_13, __pyx_t_14, __pyx_t_15); } __pyx_t_13 = __pyx_t_14 = __pyx_t_15 = 0; } __pyx_pybuffernd_matrix.diminfo[0].strides = __pyx_pybuffernd_matrix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_matrix.diminfo[0].shape = __pyx_pybuffernd_matrix.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 578, __pyx_L1_error) } __pyx_v_matrix = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":574 * # set up our matrix * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix * if substitution_matrix is None: # <<<<<<<<<<<<<< * if protein: * raise Exception("Must provide a substitution matrix for" */ goto __pyx_L5; } /* "skbio/alignment/_ssw_wrapper.pyx":580 * matrix = self._build_match_matrix(match_score, mismatch_score) * else: * matrix = self._convert_dict2d_to_matrix(substitution_matrix) # <<<<<<<<<<<<<< * # Set up our mask_length * # Mask is recommended to be max(query_sequence/2, 15) */ /*else*/ { __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self->__pyx_vtab)->_convert_dict2d_to_matrix(__pyx_v_self, __pyx_v_substitution_matrix)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer); __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack); if (unlikely(__pyx_t_10 < 0)) { PyErr_Fetch(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer, (PyObject*)__pyx_v_matrix, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_15); Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_13); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_15, __pyx_t_14, __pyx_t_13); } __pyx_t_15 = __pyx_t_14 = __pyx_t_13 = 0; } __pyx_pybuffernd_matrix.diminfo[0].strides = __pyx_pybuffernd_matrix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_matrix.diminfo[0].shape = __pyx_pybuffernd_matrix.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 580, __pyx_L1_error) } __pyx_v_matrix = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; } __pyx_L5:; /* "skbio/alignment/_ssw_wrapper.pyx":583 * # Set up our mask_length * # Mask is recommended to be max(query_sequence/2, 15) * if mask_auto: # <<<<<<<<<<<<<< * self.mask_length = len(query_sequence) / 2 * if self.mask_length < mask_length: */ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_mask_auto); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 583, __pyx_L1_error) if (__pyx_t_12) { /* "skbio/alignment/_ssw_wrapper.pyx":584 * # Mask is recommended to be max(query_sequence/2, 15) * if mask_auto: * self.mask_length = len(query_sequence) / 2 # <<<<<<<<<<<<<< * if self.mask_length < mask_length: * self.mask_length = mask_length */ __pyx_t_16 = PyObject_Length(__pyx_v_query_sequence); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(0, 584, __pyx_L1_error) __pyx_v_self->mask_length = __Pyx_div_Py_ssize_t(__pyx_t_16, 2); /* "skbio/alignment/_ssw_wrapper.pyx":585 * if mask_auto: * self.mask_length = len(query_sequence) / 2 * if self.mask_length < mask_length: # <<<<<<<<<<<<<< * self.mask_length = mask_length * else: */ __pyx_t_1 = __Pyx_PyInt_From_npy_int32(__pyx_v_self->mask_length); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = PyObject_RichCompare(__pyx_t_1, __pyx_v_mask_length, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_12) { /* "skbio/alignment/_ssw_wrapper.pyx":586 * self.mask_length = len(query_sequence) / 2 * if self.mask_length < mask_length: * self.mask_length = mask_length # <<<<<<<<<<<<<< * else: * self.mask_length = mask_length */ __pyx_t_4 = __Pyx_PyInt_As_npy_int32(__pyx_v_mask_length); if (unlikely((__pyx_t_4 == ((npy_int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 586, __pyx_L1_error) __pyx_v_self->mask_length = __pyx_t_4; /* "skbio/alignment/_ssw_wrapper.pyx":585 * if mask_auto: * self.mask_length = len(query_sequence) / 2 * if self.mask_length < mask_length: # <<<<<<<<<<<<<< * self.mask_length = mask_length * else: */ } /* "skbio/alignment/_ssw_wrapper.pyx":583 * # Set up our mask_length * # Mask is recommended to be max(query_sequence/2, 15) * if mask_auto: # <<<<<<<<<<<<<< * self.mask_length = len(query_sequence) / 2 * if self.mask_length < mask_length: */ goto __pyx_L7; } /* "skbio/alignment/_ssw_wrapper.pyx":588 * self.mask_length = mask_length * else: * self.mask_length = mask_length # <<<<<<<<<<<<<< * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] read_seq */ /*else*/ { __pyx_t_4 = __Pyx_PyInt_As_npy_int32(__pyx_v_mask_length); if (unlikely((__pyx_t_4 == ((npy_int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 588, __pyx_L1_error) __pyx_v_self->mask_length = __pyx_t_4; } __pyx_L7:; /* "skbio/alignment/_ssw_wrapper.pyx":591 * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] read_seq * read_seq = self._seq_converter(query_sequence) # <<<<<<<<<<<<<< * * cdef cnp.int32_t read_length */ __pyx_t_8 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self->__pyx_vtab)->_seq_converter(__pyx_v_self, __pyx_v_query_sequence)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_read_seq.rcbuffer->pybuffer); __pyx_t_10 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_read_seq.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_8), &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack); if (unlikely(__pyx_t_10 < 0)) { PyErr_Fetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_read_seq.rcbuffer->pybuffer, (PyObject*)__pyx_v_read_seq, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_13); Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_15); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_13, __pyx_t_14, __pyx_t_15); } __pyx_t_13 = __pyx_t_14 = __pyx_t_15 = 0; } __pyx_pybuffernd_read_seq.diminfo[0].strides = __pyx_pybuffernd_read_seq.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_read_seq.diminfo[0].shape = __pyx_pybuffernd_read_seq.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) } __pyx_v_read_seq = ((PyArrayObject *)__pyx_t_8); __pyx_t_8 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":594 * * cdef cnp.int32_t read_length * read_length = len(query_sequence) # <<<<<<<<<<<<<< * * cdef cnp.int8_t s_size */ __pyx_t_16 = PyObject_Length(__pyx_v_query_sequence); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(0, 594, __pyx_L1_error) __pyx_v_read_length = __pyx_t_16; /* "skbio/alignment/_ssw_wrapper.pyx":597 * * cdef cnp.int8_t s_size * s_size = score_size # <<<<<<<<<<<<<< * * cdef cnp.int32_t m_width */ __pyx_t_17 = __Pyx_PyInt_As_npy_int8(__pyx_v_score_size); if (unlikely((__pyx_t_17 == ((npy_int8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 597, __pyx_L1_error) __pyx_v_s_size = __pyx_t_17; /* "skbio/alignment/_ssw_wrapper.pyx":600 * * cdef cnp.int32_t m_width * m_width = 24 if self.is_protein else 5 # <<<<<<<<<<<<<< * * cdef s_profile* p */ __pyx_t_12 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_self->is_protein)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 600, __pyx_L1_error) if (__pyx_t_12) { __pyx_t_4 = 24; } else { __pyx_t_4 = 5; } __pyx_v_m_width = __pyx_t_4; /* "skbio/alignment/_ssw_wrapper.pyx":603 * * cdef s_profile* p * self.profile = ssw_init( read_seq.data, # <<<<<<<<<<<<<< * read_length, * matrix.data, */ __pyx_v_self->profile = ssw_init(((__pyx_t_5numpy_int8_t *)__pyx_v_read_seq->data), __pyx_v_read_length, ((__pyx_t_5numpy_int8_t *)__pyx_v_matrix->data), __pyx_v_m_width, __pyx_v_s_size); /* "skbio/alignment/_ssw_wrapper.pyx":610 * * # A hack to keep the python GC from eating our data * self.__KEEP_IT_IN_SCOPE_read = read_seq # <<<<<<<<<<<<<< * self.__KEEP_IT_IN_SCOPE_matrix = matrix * */ __Pyx_INCREF(((PyObject *)__pyx_v_read_seq)); __Pyx_GIVEREF(((PyObject *)__pyx_v_read_seq)); __Pyx_GOTREF(__pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_read); __Pyx_DECREF(((PyObject *)__pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_read)); __pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_read = ((PyArrayObject *)__pyx_v_read_seq); /* "skbio/alignment/_ssw_wrapper.pyx":611 * # A hack to keep the python GC from eating our data * self.__KEEP_IT_IN_SCOPE_read = read_seq * self.__KEEP_IT_IN_SCOPE_matrix = matrix # <<<<<<<<<<<<<< * * def __call__(self, target_sequence): */ __Pyx_INCREF(((PyObject *)__pyx_v_matrix)); __Pyx_GIVEREF(((PyObject *)__pyx_v_matrix)); __Pyx_GOTREF(__pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_matrix); __Pyx_DECREF(((PyObject *)__pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_matrix)); __pyx_v_self->__pyx___KEEP_IT_IN_SCOPE_matrix = ((PyArrayObject *)__pyx_v_matrix); /* "skbio/alignment/_ssw_wrapper.pyx":539 * cdef cnp.ndarray __KEEP_IT_IN_SCOPE_matrix * * def __cinit__(self, query_sequence, # <<<<<<<<<<<<<< * gap_open_penalty=5, # BLASTN Default * gap_extend_penalty=2, # BLASTN Default */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_11); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_read_seq.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_matrix.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_read_seq.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_matrix); __Pyx_XDECREF((PyObject *)__pyx_v_read_seq); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":613 * self.__KEEP_IT_IN_SCOPE_matrix = matrix * * def __call__(self, target_sequence): # <<<<<<<<<<<<<< * """Align `target_sequence` to `query_sequence` * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_3__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__[] = "Align `target_sequence` to `query_sequence`\n\n Parameters\n ----------\n target_sequence : str\n\n Returns\n -------\n skbio.alignment.AlignmentStructure\n The resulting alignment.\n\n "; #if CYTHON_UPDATE_DESCRIPTOR_DOC struct wrapperbase __pyx_wrapperbase_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__; #endif static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_3__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_target_sequence = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__call__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_target_sequence,0}; PyObject* values[1] = {0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_target_sequence)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 613, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); } __pyx_v_target_sequence = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__call__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 613, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self), __pyx_v_target_sequence); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_target_sequence) { PyObject *__pyx_v_reference_sequence = NULL; PyArrayObject *__pyx_v_reference = 0; __pyx_t_5numpy_int32_t __pyx_v_ref_length; s_align *__pyx_v_align; struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *__pyx_v_alignment = NULL; __Pyx_LocalBuf_ND __pyx_pybuffernd_reference; __Pyx_Buffer __pyx_pybuffer_reference; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); __pyx_pybuffer_reference.pybuffer.buf = NULL; __pyx_pybuffer_reference.refcount = 0; __pyx_pybuffernd_reference.data = NULL; __pyx_pybuffernd_reference.rcbuffer = &__pyx_pybuffer_reference; /* "skbio/alignment/_ssw_wrapper.pyx":626 * * """ * reference_sequence = target_sequence # <<<<<<<<<<<<<< * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] reference * reference = self._seq_converter(reference_sequence) */ __Pyx_INCREF(__pyx_v_target_sequence); __pyx_v_reference_sequence = __pyx_v_target_sequence; /* "skbio/alignment/_ssw_wrapper.pyx":628 * reference_sequence = target_sequence * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] reference * reference = self._seq_converter(reference_sequence) # <<<<<<<<<<<<<< * * cdef cnp.int32_t ref_length */ __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self->__pyx_vtab)->_seq_converter(__pyx_v_self, __pyx_v_reference_sequence)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_reference.rcbuffer->pybuffer); __pyx_t_2 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_reference.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack); if (unlikely(__pyx_t_2 < 0)) { PyErr_Fetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_reference.rcbuffer->pybuffer, (PyObject*)__pyx_v_reference, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_3); Py_XDECREF(__pyx_t_4); Py_XDECREF(__pyx_t_5); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_3, __pyx_t_4, __pyx_t_5); } __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; } __pyx_pybuffernd_reference.diminfo[0].strides = __pyx_pybuffernd_reference.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_reference.diminfo[0].shape = __pyx_pybuffernd_reference.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 628, __pyx_L1_error) } __pyx_v_reference = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":631 * * cdef cnp.int32_t ref_length * ref_length = len(reference_sequence) # <<<<<<<<<<<<<< * * cdef s_align *align */ __pyx_t_6 = PyObject_Length(__pyx_v_reference_sequence); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 631, __pyx_L1_error) __pyx_v_ref_length = __pyx_t_6; /* "skbio/alignment/_ssw_wrapper.pyx":634 * * cdef s_align *align * align = ssw_align(self.profile, reference.data, # <<<<<<<<<<<<<< * ref_length, self.gap_open_penalty, * self.gap_extend_penalty, self.bit_flag, */ __pyx_v_align = ssw_align(__pyx_v_self->profile, ((__pyx_t_5numpy_int8_t *)__pyx_v_reference->data), __pyx_v_ref_length, __pyx_v_self->gap_open_penalty, __pyx_v_self->gap_extend_penalty, __pyx_v_self->bit_flag, __pyx_v_self->score_filter, __pyx_v_self->distance_filter, __pyx_v_self->mask_length); /* "skbio/alignment/_ssw_wrapper.pyx":641 * * # Cython won't let me do this correctly, so duplicate code ahoy: * if self.suppress_sequences: # <<<<<<<<<<<<<< * alignment = AlignmentStructure("", "", self.index_starts_at) * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_self->suppress_sequences)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 641, __pyx_L1_error) if (__pyx_t_7) { /* "skbio/alignment/_ssw_wrapper.pyx":642 * # Cython won't let me do this correctly, so duplicate code ahoy: * if self.suppress_sequences: * alignment = AlignmentStructure("", "", self.index_starts_at) # <<<<<<<<<<<<<< * else: * alignment = AlignmentStructure(self.read_sequence, */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->index_starts_at); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_kp_s__5); __Pyx_GIVEREF(__pyx_kp_s__5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_s__5); __Pyx_INCREF(__pyx_kp_s__5); __Pyx_GIVEREF(__pyx_kp_s__5); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_kp_s__5); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 642, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_alignment = ((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":641 * * # Cython won't let me do this correctly, so duplicate code ahoy: * if self.suppress_sequences: # <<<<<<<<<<<<<< * alignment = AlignmentStructure("", "", self.index_starts_at) * else: */ goto __pyx_L3; } /* "skbio/alignment/_ssw_wrapper.pyx":644 * alignment = AlignmentStructure("", "", self.index_starts_at) * else: * alignment = AlignmentStructure(self.read_sequence, # <<<<<<<<<<<<<< * reference_sequence, * self.index_starts_at) */ /*else*/ { /* "skbio/alignment/_ssw_wrapper.pyx":646 * alignment = AlignmentStructure(self.read_sequence, * reference_sequence, * self.index_starts_at) # <<<<<<<<<<<<<< * alignment.__constructor(align) # Hack to get a pointer through * return alignment */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->index_starts_at); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "skbio/alignment/_ssw_wrapper.pyx":644 * alignment = AlignmentStructure("", "", self.index_starts_at) * else: * alignment = AlignmentStructure(self.read_sequence, # <<<<<<<<<<<<<< * reference_sequence, * self.index_starts_at) */ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_self->read_sequence); __Pyx_GIVEREF(__pyx_v_self->read_sequence); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_self->read_sequence); __Pyx_INCREF(__pyx_v_reference_sequence); __Pyx_GIVEREF(__pyx_v_reference_sequence); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_reference_sequence); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_alignment = ((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_t_1); __pyx_t_1 = 0; } __pyx_L3:; /* "skbio/alignment/_ssw_wrapper.pyx":647 * reference_sequence, * self.index_starts_at) * alignment.__constructor(align) # Hack to get a pointer through # <<<<<<<<<<<<<< * return alignment * */ __pyx_t_1 = ((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)__pyx_v_alignment->__pyx_vtab)->__pyx___constructor(__pyx_v_alignment, __pyx_v_align); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":648 * self.index_starts_at) * alignment.__constructor(align) # Hack to get a pointer through * return alignment # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_alignment)); __pyx_r = ((PyObject *)__pyx_v_alignment); goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":613 * self.__KEEP_IT_IN_SCOPE_matrix = matrix * * def __call__(self, target_sequence): # <<<<<<<<<<<<<< * """Align `target_sequence` to `query_sequence` * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_8); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_reference.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_reference.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF(__pyx_v_reference_sequence); __Pyx_XDECREF((PyObject *)__pyx_v_reference); __Pyx_XDECREF((PyObject *)__pyx_v_alignment); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":650 * return alignment * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self.profile is not NULL: * init_destroy(self.profile) */ /* Python wrapper */ static void __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_5__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_4__dealloc__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_4__dealloc__(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "skbio/alignment/_ssw_wrapper.pyx":651 * * def __dealloc__(self): * if self.profile is not NULL: # <<<<<<<<<<<<<< * init_destroy(self.profile) * */ __pyx_t_1 = ((__pyx_v_self->profile != NULL) != 0); if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":652 * def __dealloc__(self): * if self.profile is not NULL: * init_destroy(self.profile) # <<<<<<<<<<<<<< * * def _get_bit_flag(self, override_skip_babp, score_only): */ init_destroy(__pyx_v_self->profile); /* "skbio/alignment/_ssw_wrapper.pyx":651 * * def __dealloc__(self): * if self.profile is not NULL: # <<<<<<<<<<<<<< * init_destroy(self.profile) * */ } /* "skbio/alignment/_ssw_wrapper.pyx":650 * return alignment * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self.profile is not NULL: * init_destroy(self.profile) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "skbio/alignment/_ssw_wrapper.pyx":654 * init_destroy(self.profile) * * def _get_bit_flag(self, override_skip_babp, score_only): # <<<<<<<<<<<<<< * bit_flag = 0 * if score_only: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_7_get_bit_flag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_7_get_bit_flag(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_override_skip_babp = 0; PyObject *__pyx_v_score_only = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_bit_flag (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_override_skip_babp,&__pyx_n_s_score_only,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_override_skip_babp)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_score_only)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get_bit_flag", 1, 2, 2, 1); __PYX_ERR(0, 654, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get_bit_flag") < 0)) __PYX_ERR(0, 654, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_override_skip_babp = values[0]; __pyx_v_score_only = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_get_bit_flag", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 654, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman._get_bit_flag", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_6_get_bit_flag(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self), __pyx_v_override_skip_babp, __pyx_v_score_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_6_get_bit_flag(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_override_skip_babp, PyObject *__pyx_v_score_only) { long __pyx_v_bit_flag; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_bit_flag", 0); /* "skbio/alignment/_ssw_wrapper.pyx":655 * * def _get_bit_flag(self, override_skip_babp, score_only): * bit_flag = 0 # <<<<<<<<<<<<<< * if score_only: * return bit_flag */ __pyx_v_bit_flag = 0; /* "skbio/alignment/_ssw_wrapper.pyx":656 * def _get_bit_flag(self, override_skip_babp, score_only): * bit_flag = 0 * if score_only: # <<<<<<<<<<<<<< * return bit_flag * if override_skip_babp: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_score_only); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 656, __pyx_L1_error) if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":657 * bit_flag = 0 * if score_only: * return bit_flag # <<<<<<<<<<<<<< * if override_skip_babp: * bit_flag = bit_flag | 0x8 */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v_bit_flag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":656 * def _get_bit_flag(self, override_skip_babp, score_only): * bit_flag = 0 * if score_only: # <<<<<<<<<<<<<< * return bit_flag * if override_skip_babp: */ } /* "skbio/alignment/_ssw_wrapper.pyx":658 * if score_only: * return bit_flag * if override_skip_babp: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x8 * if self.distance_filter != 0: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_override_skip_babp); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 658, __pyx_L1_error) if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":659 * return bit_flag * if override_skip_babp: * bit_flag = bit_flag | 0x8 # <<<<<<<<<<<<<< * if self.distance_filter != 0: * bit_flag = bit_flag | 0x4 */ __pyx_v_bit_flag = (__pyx_v_bit_flag | 0x8); /* "skbio/alignment/_ssw_wrapper.pyx":658 * if score_only: * return bit_flag * if override_skip_babp: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x8 * if self.distance_filter != 0: */ } /* "skbio/alignment/_ssw_wrapper.pyx":660 * if override_skip_babp: * bit_flag = bit_flag | 0x8 * if self.distance_filter != 0: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x4 * if self.score_filter != 0: */ __pyx_t_1 = ((__pyx_v_self->distance_filter != 0) != 0); if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":661 * bit_flag = bit_flag | 0x8 * if self.distance_filter != 0: * bit_flag = bit_flag | 0x4 # <<<<<<<<<<<<<< * if self.score_filter != 0: * bit_flag = bit_flag | 0x2 */ __pyx_v_bit_flag = (__pyx_v_bit_flag | 0x4); /* "skbio/alignment/_ssw_wrapper.pyx":660 * if override_skip_babp: * bit_flag = bit_flag | 0x8 * if self.distance_filter != 0: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x4 * if self.score_filter != 0: */ } /* "skbio/alignment/_ssw_wrapper.pyx":662 * if self.distance_filter != 0: * bit_flag = bit_flag | 0x4 * if self.score_filter != 0: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x2 * if bit_flag == 0 or bit_flag == 8: */ __pyx_t_1 = ((__pyx_v_self->score_filter != 0) != 0); if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":663 * bit_flag = bit_flag | 0x4 * if self.score_filter != 0: * bit_flag = bit_flag | 0x2 # <<<<<<<<<<<<<< * if bit_flag == 0 or bit_flag == 8: * bit_flag = bit_flag | 0x1 */ __pyx_v_bit_flag = (__pyx_v_bit_flag | 0x2); /* "skbio/alignment/_ssw_wrapper.pyx":662 * if self.distance_filter != 0: * bit_flag = bit_flag | 0x4 * if self.score_filter != 0: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x2 * if bit_flag == 0 or bit_flag == 8: */ } /* "skbio/alignment/_ssw_wrapper.pyx":664 * if self.score_filter != 0: * bit_flag = bit_flag | 0x2 * if bit_flag == 0 or bit_flag == 8: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x1 * return bit_flag */ switch (__pyx_v_bit_flag) { case 0: case 8: /* "skbio/alignment/_ssw_wrapper.pyx":665 * bit_flag = bit_flag | 0x2 * if bit_flag == 0 or bit_flag == 8: * bit_flag = bit_flag | 0x1 # <<<<<<<<<<<<<< * return bit_flag * */ __pyx_v_bit_flag = (__pyx_v_bit_flag | 0x1); /* "skbio/alignment/_ssw_wrapper.pyx":664 * if self.score_filter != 0: * bit_flag = bit_flag | 0x2 * if bit_flag == 0 or bit_flag == 8: # <<<<<<<<<<<<<< * bit_flag = bit_flag | 0x1 * return bit_flag */ break; default: break; } /* "skbio/alignment/_ssw_wrapper.pyx":666 * if bit_flag == 0 or bit_flag == 8: * bit_flag = bit_flag | 0x1 * return bit_flag # <<<<<<<<<<<<<< * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] _seq_converter( */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v_bit_flag); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":654 * init_destroy(self.profile) * * def _get_bit_flag(self, override_skip_babp, score_only): # <<<<<<<<<<<<<< * bit_flag = 0 * if score_only: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman._get_bit_flag", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":668 * return bit_flag * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] _seq_converter( # <<<<<<<<<<<<<< * self, * sequence): */ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__seq_converter(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_sequence) { PyArrayObject *__pyx_v_seq = 0; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_char = NULL; __Pyx_LocalBuf_ND __pyx_pybuffernd_seq; __Pyx_Buffer __pyx_pybuffer_seq; PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyArrayObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; PyObject *(*__pyx_t_13)(PyObject *); long __pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_seq_converter", 0); __pyx_pybuffer_seq.pybuffer.buf = NULL; __pyx_pybuffer_seq.refcount = 0; __pyx_pybuffernd_seq.data = NULL; __pyx_pybuffernd_seq.rcbuffer = &__pyx_pybuffer_seq; /* "skbio/alignment/_ssw_wrapper.pyx":672 * sequence): * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] seq * seq = np.empty(len(sequence), dtype=np.int8) # <<<<<<<<<<<<<< * if self.is_protein: * for i, char in enumerate(sequence): */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = PyObject_Length(__pyx_v_sequence); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 672, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 672, __pyx_L1_error) __pyx_t_7 = ((PyArrayObject *)__pyx_t_6); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_seq.rcbuffer->pybuffer); __pyx_t_8 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_seq.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack); if (unlikely(__pyx_t_8 < 0)) { PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_seq.rcbuffer->pybuffer, (PyObject*)__pyx_v_seq, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11); } __pyx_t_9 = __pyx_t_10 = __pyx_t_11 = 0; } __pyx_pybuffernd_seq.diminfo[0].strides = __pyx_pybuffernd_seq.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_seq.diminfo[0].shape = __pyx_pybuffernd_seq.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 672, __pyx_L1_error) } __pyx_t_7 = 0; __pyx_v_seq = ((PyArrayObject *)__pyx_t_6); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":673 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] seq * seq = np.empty(len(sequence), dtype=np.int8) * if self.is_protein: # <<<<<<<<<<<<<< * for i, char in enumerate(sequence): * seq[i] = np_aa_table[ord(char)] */ __pyx_t_12 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_self->is_protein)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 673, __pyx_L1_error) if (__pyx_t_12) { /* "skbio/alignment/_ssw_wrapper.pyx":674 * seq = np.empty(len(sequence), dtype=np.int8) * if self.is_protein: * for i, char in enumerate(sequence): # <<<<<<<<<<<<<< * seq[i] = np_aa_table[ord(char)] * else: */ __Pyx_INCREF(__pyx_int_0); __pyx_t_6 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_sequence)) || PyTuple_CheckExact(__pyx_v_sequence)) { __pyx_t_1 = __pyx_v_sequence; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0; __pyx_t_13 = NULL; } else { __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 674, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 674, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 674, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } } else { __pyx_t_4 = __pyx_t_13(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 674, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_char, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_4; __pyx_t_4 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":675 * if self.is_protein: * for i, char in enumerate(sequence): * seq[i] = np_aa_table[ord(char)] # <<<<<<<<<<<<<< * else: * for i, char in enumerate(sequence): */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np_aa_table); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_14 = __Pyx_PyObject_Ord(__pyx_v_char); if (unlikely(__pyx_t_14 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 675, __pyx_L1_error) __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, __pyx_t_14, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_seq), __pyx_v_i, __pyx_t_2) < 0)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":674 * seq = np.empty(len(sequence), dtype=np.int8) * if self.is_protein: * for i, char in enumerate(sequence): # <<<<<<<<<<<<<< * seq[i] = np_aa_table[ord(char)] * else: */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":673 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] seq * seq = np.empty(len(sequence), dtype=np.int8) * if self.is_protein: # <<<<<<<<<<<<<< * for i, char in enumerate(sequence): * seq[i] = np_aa_table[ord(char)] */ goto __pyx_L3; } /* "skbio/alignment/_ssw_wrapper.pyx":677 * seq[i] = np_aa_table[ord(char)] * else: * for i, char in enumerate(sequence): # <<<<<<<<<<<<<< * seq[i] = np_nt_table[ord(char)] * return seq */ /*else*/ { __Pyx_INCREF(__pyx_int_0); __pyx_t_6 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_sequence)) || PyTuple_CheckExact(__pyx_v_sequence)) { __pyx_t_1 = __pyx_v_sequence; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0; __pyx_t_13 = NULL; } else { __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 677, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 677, __pyx_L1_error) #else __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 677, __pyx_L1_error) #else __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } } else { __pyx_t_2 = __pyx_t_13(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 677, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_2); } __Pyx_XDECREF_SET(__pyx_v_char, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":678 * else: * for i, char in enumerate(sequence): * seq[i] = np_nt_table[ord(char)] # <<<<<<<<<<<<<< * return seq * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np_nt_table); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_14 = __Pyx_PyObject_Ord(__pyx_v_char); if (unlikely(__pyx_t_14 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 678, __pyx_L1_error) __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, __pyx_t_14, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_seq), __pyx_v_i, __pyx_t_4) < 0)) __PYX_ERR(0, 678, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":677 * seq[i] = np_aa_table[ord(char)] * else: * for i, char in enumerate(sequence): # <<<<<<<<<<<<<< * seq[i] = np_nt_table[ord(char)] * return seq */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_L3:; /* "skbio/alignment/_ssw_wrapper.pyx":679 * for i, char in enumerate(sequence): * seq[i] = np_nt_table[ord(char)] * return seq # <<<<<<<<<<<<<< * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_seq)); __pyx_r = ((PyArrayObject *)__pyx_v_seq); goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":668 * return bit_flag * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] _seq_converter( # <<<<<<<<<<<<<< * self, * sequence): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_seq.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman._seq_converter", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_seq.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_seq); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_char); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":681 * return seq * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ # <<<<<<<<<<<<<< * _build_match_matrix(self, match_score, mismatch_score): * sequence_order = "ACGTN" */ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__build_match_matrix(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_match_score, PyObject *__pyx_v_mismatch_score) { PyObject *__pyx_v_sequence_order = NULL; PyObject *__pyx_v_dict2d = NULL; PyObject *__pyx_v_row = NULL; PyObject *__pyx_v_column = NULL; PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_build_match_matrix", 0); /* "skbio/alignment/_ssw_wrapper.pyx":683 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ * _build_match_matrix(self, match_score, mismatch_score): * sequence_order = "ACGTN" # <<<<<<<<<<<<<< * dict2d = {} * for row in sequence_order: */ __Pyx_INCREF(__pyx_n_s_ACGTN); __pyx_v_sequence_order = __pyx_n_s_ACGTN; /* "skbio/alignment/_ssw_wrapper.pyx":684 * _build_match_matrix(self, match_score, mismatch_score): * sequence_order = "ACGTN" * dict2d = {} # <<<<<<<<<<<<<< * for row in sequence_order: * dict2d[row] = {} */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_dict2d = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":685 * sequence_order = "ACGTN" * dict2d = {} * for row in sequence_order: # <<<<<<<<<<<<<< * dict2d[row] = {} * for column in sequence_order: */ if (likely(PyList_CheckExact(__pyx_v_sequence_order)) || PyTuple_CheckExact(__pyx_v_sequence_order)) { __pyx_t_1 = __pyx_v_sequence_order; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_sequence_order); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 685, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 685, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 685, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 685, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_row, __pyx_t_4); __pyx_t_4 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":686 * dict2d = {} * for row in sequence_order: * dict2d[row] = {} # <<<<<<<<<<<<<< * for column in sequence_order: * if column == 'N' or row == 'N': */ __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (unlikely(PyDict_SetItem(__pyx_v_dict2d, __pyx_v_row, __pyx_t_4) < 0)) __PYX_ERR(0, 686, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":687 * for row in sequence_order: * dict2d[row] = {} * for column in sequence_order: # <<<<<<<<<<<<<< * if column == 'N' or row == 'N': * dict2d[row][column] = 0 */ if (likely(PyList_CheckExact(__pyx_v_sequence_order)) || PyTuple_CheckExact(__pyx_v_sequence_order)) { __pyx_t_4 = __pyx_v_sequence_order; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_sequence_order); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 687, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 687, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 687, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } } else { __pyx_t_7 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 687, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_7); } __Pyx_XDECREF_SET(__pyx_v_column, __pyx_t_7); __pyx_t_7 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":688 * dict2d[row] = {} * for column in sequence_order: * if column == 'N' or row == 'N': # <<<<<<<<<<<<<< * dict2d[row][column] = 0 * else: */ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_column, __pyx_n_s_N, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 688, __pyx_L1_error) if (!__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L8_bool_binop_done; } __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_row, __pyx_n_s_N, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 688, __pyx_L1_error) __pyx_t_8 = __pyx_t_9; __pyx_L8_bool_binop_done:; if (__pyx_t_8) { /* "skbio/alignment/_ssw_wrapper.pyx":689 * for column in sequence_order: * if column == 'N' or row == 'N': * dict2d[row][column] = 0 # <<<<<<<<<<<<<< * else: * dict2d[row][column] = match_score if row == column \ */ __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_dict2d, __pyx_v_row); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (unlikely(PyObject_SetItem(__pyx_t_7, __pyx_v_column, __pyx_int_0) < 0)) __PYX_ERR(0, 689, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":688 * dict2d[row] = {} * for column in sequence_order: * if column == 'N' or row == 'N': # <<<<<<<<<<<<<< * dict2d[row][column] = 0 * else: */ goto __pyx_L7; } /* "skbio/alignment/_ssw_wrapper.pyx":691 * dict2d[row][column] = 0 * else: * dict2d[row][column] = match_score if row == column \ # <<<<<<<<<<<<<< * else mismatch_score * return self._convert_dict2d_to_matrix(dict2d) */ /*else*/ { __pyx_t_10 = PyObject_RichCompare(__pyx_v_row, __pyx_v_column, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 691, __pyx_L1_error) __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 691, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__pyx_t_8) { __Pyx_INCREF(__pyx_v_match_score); __pyx_t_7 = __pyx_v_match_score; } else { /* "skbio/alignment/_ssw_wrapper.pyx":692 * else: * dict2d[row][column] = match_score if row == column \ * else mismatch_score # <<<<<<<<<<<<<< * return self._convert_dict2d_to_matrix(dict2d) * */ __Pyx_INCREF(__pyx_v_mismatch_score); __pyx_t_7 = __pyx_v_mismatch_score; } /* "skbio/alignment/_ssw_wrapper.pyx":691 * dict2d[row][column] = 0 * else: * dict2d[row][column] = match_score if row == column \ # <<<<<<<<<<<<<< * else mismatch_score * return self._convert_dict2d_to_matrix(dict2d) */ __pyx_t_10 = __Pyx_PyDict_GetItem(__pyx_v_dict2d, __pyx_v_row); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (unlikely(PyObject_SetItem(__pyx_t_10, __pyx_v_column, __pyx_t_7) < 0)) __PYX_ERR(0, 691, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __pyx_L7:; /* "skbio/alignment/_ssw_wrapper.pyx":687 * for row in sequence_order: * dict2d[row] = {} * for column in sequence_order: # <<<<<<<<<<<<<< * if column == 'N' or row == 'N': * dict2d[row][column] = 0 */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":685 * sequence_order = "ACGTN" * dict2d = {} * for row in sequence_order: # <<<<<<<<<<<<<< * dict2d[row] = {} * for column in sequence_order: */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":693 * dict2d[row][column] = match_score if row == column \ * else mismatch_score * return self._convert_dict2d_to_matrix(dict2d) # <<<<<<<<<<<<<< * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self->__pyx_vtab)->_convert_dict2d_to_matrix(__pyx_v_self, __pyx_v_dict2d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":681 * return seq * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ # <<<<<<<<<<<<<< * _build_match_matrix(self, match_score, mismatch_score): * sequence_order = "ACGTN" */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman._build_match_matrix", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_sequence_order); __Pyx_XDECREF(__pyx_v_dict2d); __Pyx_XDECREF(__pyx_v_row); __Pyx_XDECREF(__pyx_v_column); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/alignment/_ssw_wrapper.pyx":695 * return self._convert_dict2d_to_matrix(dict2d) * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ # <<<<<<<<<<<<<< * _convert_dict2d_to_matrix(self, dict2d): * if self.is_protein: */ static PyArrayObject *__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__convert_dict2d_to_matrix(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, PyObject *__pyx_v_dict2d) { PyObject *__pyx_v_sequence_order = NULL; int __pyx_v_i; PyObject *__pyx_v_length = NULL; PyArrayObject *__pyx_v_py_list_matrix = 0; PyObject *__pyx_v_row = NULL; PyObject *__pyx_v_column = NULL; __Pyx_LocalBuf_ND __pyx_pybuffernd_py_list_matrix; __Pyx_Buffer __pyx_pybuffer_py_list_matrix; PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyArrayObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); Py_ssize_t __pyx_t_10; PyObject *(*__pyx_t_11)(PyObject *); __pyx_t_5numpy_int8_t __pyx_t_12; Py_ssize_t __pyx_t_13; int __pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_convert_dict2d_to_matrix", 0); __pyx_pybuffer_py_list_matrix.pybuffer.buf = NULL; __pyx_pybuffer_py_list_matrix.refcount = 0; __pyx_pybuffernd_py_list_matrix.data = NULL; __pyx_pybuffernd_py_list_matrix.rcbuffer = &__pyx_pybuffer_py_list_matrix; /* "skbio/alignment/_ssw_wrapper.pyx":697 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ * _convert_dict2d_to_matrix(self, dict2d): * if self.is_protein: # <<<<<<<<<<<<<< * sequence_order = "ARNDCQEGHILKMFPSTWYVBZX*" * else: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_self->is_protein)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 697, __pyx_L1_error) if (__pyx_t_1) { /* "skbio/alignment/_ssw_wrapper.pyx":698 * _convert_dict2d_to_matrix(self, dict2d): * if self.is_protein: * sequence_order = "ARNDCQEGHILKMFPSTWYVBZX*" # <<<<<<<<<<<<<< * else: * sequence_order = "ACGTN" */ __Pyx_INCREF(__pyx_kp_s_ARNDCQEGHILKMFPSTWYVBZX); __pyx_v_sequence_order = __pyx_kp_s_ARNDCQEGHILKMFPSTWYVBZX; /* "skbio/alignment/_ssw_wrapper.pyx":697 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ * _convert_dict2d_to_matrix(self, dict2d): * if self.is_protein: # <<<<<<<<<<<<<< * sequence_order = "ARNDCQEGHILKMFPSTWYVBZX*" * else: */ goto __pyx_L3; } /* "skbio/alignment/_ssw_wrapper.pyx":700 * sequence_order = "ARNDCQEGHILKMFPSTWYVBZX*" * else: * sequence_order = "ACGTN" # <<<<<<<<<<<<<< * cdef int i = 0 * length = len(sequence_order) */ /*else*/ { __Pyx_INCREF(__pyx_n_s_ACGTN); __pyx_v_sequence_order = __pyx_n_s_ACGTN; } __pyx_L3:; /* "skbio/alignment/_ssw_wrapper.pyx":701 * else: * sequence_order = "ACGTN" * cdef int i = 0 # <<<<<<<<<<<<<< * length = len(sequence_order) * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ */ __pyx_v_i = 0; /* "skbio/alignment/_ssw_wrapper.pyx":702 * sequence_order = "ACGTN" * cdef int i = 0 * length = len(sequence_order) # <<<<<<<<<<<<<< * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ * np.empty(length*length, dtype=np.int8) */ __pyx_t_2 = PyObject_Length(__pyx_v_sequence_order); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 702, __pyx_L1_error) __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_length = __pyx_t_3; __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":704 * length = len(sequence_order) * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ * np.empty(length*length, dtype=np.int8) # <<<<<<<<<<<<<< * for row in sequence_order: * for column in sequence_order: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyNumber_Multiply(__pyx_v_length, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 704, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { __pyx_v_py_list_matrix = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 703, __pyx_L1_error) } else {__pyx_pybuffernd_py_list_matrix.diminfo[0].strides = __pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_py_list_matrix.diminfo[0].shape = __pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer.shape[0]; } } __pyx_t_8 = 0; __pyx_v_py_list_matrix = ((PyArrayObject *)__pyx_t_7); __pyx_t_7 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":705 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ * np.empty(length*length, dtype=np.int8) * for row in sequence_order: # <<<<<<<<<<<<<< * for column in sequence_order: * py_list_matrix[i] = dict2d[row][column] */ if (likely(PyList_CheckExact(__pyx_v_sequence_order)) || PyTuple_CheckExact(__pyx_v_sequence_order)) { __pyx_t_7 = __pyx_v_sequence_order; __Pyx_INCREF(__pyx_t_7); __pyx_t_2 = 0; __pyx_t_9 = NULL; } else { __pyx_t_2 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_sequence_order); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 705, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_9)) { if (likely(PyList_CheckExact(__pyx_t_7))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_7)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 705, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_7, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_7)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 705, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_7, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 705, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_v_row, __pyx_t_3); __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":706 * np.empty(length*length, dtype=np.int8) * for row in sequence_order: * for column in sequence_order: # <<<<<<<<<<<<<< * py_list_matrix[i] = dict2d[row][column] * i += 1 */ if (likely(PyList_CheckExact(__pyx_v_sequence_order)) || PyTuple_CheckExact(__pyx_v_sequence_order)) { __pyx_t_3 = __pyx_v_sequence_order; __Pyx_INCREF(__pyx_t_3); __pyx_t_10 = 0; __pyx_t_11 = NULL; } else { __pyx_t_10 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_sequence_order); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_11 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 706, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_11)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 706, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_5); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 706, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } } else { __pyx_t_5 = __pyx_t_11(__pyx_t_3); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 706, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } __Pyx_XDECREF_SET(__pyx_v_column, __pyx_t_5); __pyx_t_5 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":707 * for row in sequence_order: * for column in sequence_order: * py_list_matrix[i] = dict2d[row][column] # <<<<<<<<<<<<<< * i += 1 * return py_list_matrix */ __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_dict2d, __pyx_v_row); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_5, __pyx_v_column); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_12 = __Pyx_PyInt_As_npy_int8(__pyx_t_4); if (unlikely((__pyx_t_12 == ((npy_int8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 707, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_13 = __pyx_v_i; __pyx_t_14 = -1; if (__pyx_t_13 < 0) { __pyx_t_13 += __pyx_pybuffernd_py_list_matrix.diminfo[0].shape; if (unlikely(__pyx_t_13 < 0)) __pyx_t_14 = 0; } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_py_list_matrix.diminfo[0].shape)) __pyx_t_14 = 0; if (unlikely(__pyx_t_14 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_14); __PYX_ERR(0, 707, __pyx_L1_error) } *__Pyx_BufPtrCContig1d(__pyx_t_5numpy_int8_t *, __pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_py_list_matrix.diminfo[0].strides) = __pyx_t_12; /* "skbio/alignment/_ssw_wrapper.pyx":708 * for column in sequence_order: * py_list_matrix[i] = dict2d[row][column] * i += 1 # <<<<<<<<<<<<<< * return py_list_matrix */ __pyx_v_i = (__pyx_v_i + 1); /* "skbio/alignment/_ssw_wrapper.pyx":706 * np.empty(length*length, dtype=np.int8) * for row in sequence_order: * for column in sequence_order: # <<<<<<<<<<<<<< * py_list_matrix[i] = dict2d[row][column] * i += 1 */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":705 * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ * np.empty(length*length, dtype=np.int8) * for row in sequence_order: # <<<<<<<<<<<<<< * for column in sequence_order: * py_list_matrix[i] = dict2d[row][column] */ } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":709 * py_list_matrix[i] = dict2d[row][column] * i += 1 * return py_list_matrix # <<<<<<<<<<<<<< */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_py_list_matrix)); __pyx_r = ((PyArrayObject *)__pyx_v_py_list_matrix); goto __pyx_L0; /* "skbio/alignment/_ssw_wrapper.pyx":695 * return self._convert_dict2d_to_matrix(dict2d) * * cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ # <<<<<<<<<<<<<< * _convert_dict2d_to_matrix(self, dict2d): * if self.is_protein: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman._convert_dict2d_to_matrix", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_py_list_matrix.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF(__pyx_v_sequence_order); __Pyx_XDECREF(__pyx_v_length); __Pyx_XDECREF((PyObject *)__pyx_v_py_list_matrix); __Pyx_XDECREF(__pyx_v_row); __Pyx_XDECREF(__pyx_v_column); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_8__reduce_cython__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_10__setstate_cython__(((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.alignment._ssw_wrapper.StripedSmithWaterman.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":735 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":738 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":741 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":744 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":747 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":751 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":753 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":929 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":930 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":933 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":935 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":936 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":942 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 942, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":943 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 943, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(2, 944, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":948 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 948, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":949 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 949, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(2, 950, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":954 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 954, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":955 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 955, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":956 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(2, 956, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_timedelta64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":978 * bool * """ * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_datetime64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":993 * bool * """ * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1003 * also needed. That can be found using `get_datetime64_unit`. * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1010 * returns the int64 value underlying scalar numpy timedelta64 object * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1017 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /* function exit code */ __pyx_L0:; return __pyx_r; } static struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; static PyObject *__pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)o); p->__pyx_vtab = __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; p->read_sequence = ((PyObject*)Py_None); Py_INCREF(Py_None); p->reference_sequence = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_cigar_string = ((PyObject*)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure(PyObject *o) { struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *p = (struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_3__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->read_sequence); Py_CLEAR(p->reference_sequence); Py_CLEAR(p->_cigar_string); (*Py_TYPE(o)->tp_free)(o); } static PyObject *__pyx_sq_item_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_optimal_alignment_score(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23optimal_alignment_score_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_suboptimal_alignment_score(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_26suboptimal_alignment_score_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_begin(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12target_begin_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_end_optimal(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_18target_end_optimal_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_end_suboptimal(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21target_end_suboptimal_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_begin(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11query_begin_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_end(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9query_end_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_cigar(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5cigar_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_sequence(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_14query_sequence_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_sequence(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15target_sequence_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_aligned_query_sequence(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_22aligned_query_sequence_1__get__(o); } static PyObject *__pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_aligned_target_sequence(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_23aligned_target_sequence_1__get__(o); } static PyMethodDef __pyx_methods_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure[] = { {"set_zero_based", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_11set_zero_based, METH_O, __pyx_doc_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_10set_zero_based}, {"is_zero_based", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_13is_zero_based, METH_NOARGS, __pyx_doc_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_12is_zero_based}, {"_get_aligned_sequence", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_15_get_aligned_sequence, METH_VARARGS|METH_KEYWORDS, 0}, {"_tuples_from_cigar", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_17_tuples_from_cigar, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_19__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_21__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure[] = { {(char *)"optimal_alignment_score", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_optimal_alignment_score, 0, (char *)"Optimal alignment score\n\n Returns\n -------\n int\n The optimal alignment score\n\n ", 0}, {(char *)"suboptimal_alignment_score", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_suboptimal_alignment_score, 0, (char *)"Suboptimal alignment score\n\n Returns\n -------\n int\n The suboptimal alignment score\n\n ", 0}, {(char *)"target_begin", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_begin, 0, (char *)"Character index where the target's alignment begins\n\n Returns\n -------\n int\n The character index of the target sequence's alignment's beginning\n\n Notes\n -----\n The result is a 0-based index by default\n\n ", 0}, {(char *)"target_end_optimal", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_end_optimal, 0, (char *)"Character index where the target's optimal alignment ends\n\n Returns\n -------\n int\n The character index of the target sequence's optimal alignment's\n end\n\n Notes\n -----\n The result is a 0-based index by default\n\n ", 0}, {(char *)"target_end_suboptimal", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_end_suboptimal, 0, (char *)"Character index where the target's suboptimal alignment ends\n\n Returns\n -------\n int\n The character index of the target sequence's suboptimal alignment's\n end\n\n Notes\n -----\n The result is a 0-based index by default\n\n ", 0}, {(char *)"query_begin", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_begin, 0, (char *)"Returns the character index at which the query sequence begins\n\n Returns\n -------\n int\n The character index of the query sequence beginning\n\n Notes\n -----\n The result is a 0-based index by default\n\n ", 0}, {(char *)"query_end", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_end, 0, (char *)"Character index at where query sequence ends\n\n Returns\n -------\n int\n The character index of the query sequence ending\n\n Notes\n -----\n The result is a 0-based index by default\n\n ", 0}, {(char *)"cigar", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_cigar, 0, (char *)"Cigar formatted string for the optimal alignment\n\n Returns\n -------\n str\n The cigar string of the optimal alignment\n\n Notes\n -----\n The cigar string format is described in [1]_ and [2]_.\n\n If there is no cigar or optimal alignment, this will return an empty\n string\n\n References\n ----------\n .. [1] http://genome.sph.umich.edu/wiki/SAM\n .. [2] http://samtools.github.io/hts-specs/SAMv1.pdf\n\n ", 0}, {(char *)"query_sequence", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_query_sequence, 0, (char *)"Query sequence\n\n Returns\n -------\n str\n The query sequence\n\n ", 0}, {(char *)"target_sequence", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_target_sequence, 0, (char *)"Target sequence\n\n Returns\n -------\n str\n The target sequence\n\n ", 0}, {(char *)"aligned_query_sequence", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_aligned_query_sequence, 0, (char *)"Returns the query sequence aligned by the cigar\n\n Returns\n -------\n str\n Aligned query sequence\n\n Notes\n -----\n This will return `None` if `suppress_sequences` was True when this\n object was created\n\n ", 0}, {(char *)"aligned_target_sequence", __pyx_getprop_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_aligned_target_sequence, 0, (char *)"Returns the target sequence aligned by the cigar\n\n Returns\n -------\n str\n Aligned target sequence\n\n Notes\n -----\n This will return `None` if `suppress_sequences` was True when this\n object was created\n\n ", 0}, {0, 0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_AlignmentStructure = { 0, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_AlignmentStructure = { 0, /*mp_length*/ __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_5__getitem__, /*mp_subscript*/ 0, /*mp_ass_subscript*/ }; static PyTypeObject __pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure = { PyVarObject_HEAD_INIT(0, 0) "skbio.alignment._ssw_wrapper.AlignmentStructure", /*tp_name*/ sizeof(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_7__repr__, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_AlignmentStructure, /*tp_as_sequence*/ &__pyx_tp_as_mapping_AlignmentStructure, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_pw_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure_9__str__, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "Wraps the result of an alignment c struct so it is accessible to Python\n\n Notes\n -----\n `cigar` may be empty depending on parameters used.\n\n `target_begin` and `query_begin` may be -1 depending on parameters used.\n\n Developer note: `read_sequence` is an alias for `query_sequence` used by\n ssw.c as is `reference_sequence` for `target_sequence`\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; static PyObject *__pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)o); p->__pyx_vtab = __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; p->read_sequence = ((PyObject*)Py_None); Py_INCREF(Py_None); p->is_protein = ((PyBoolObject *)Py_None); Py_INCREF(Py_None); p->suppress_sequences = ((PyBoolObject *)Py_None); Py_INCREF(Py_None); p->__pyx___KEEP_IT_IN_SCOPE_read = ((PyArrayObject *)Py_None); Py_INCREF(Py_None); p->__pyx___KEEP_IT_IN_SCOPE_matrix = ((PyArrayObject *)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman(PyObject *o) { struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *p = (struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_5__dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->read_sequence); Py_CLEAR(p->is_protein); Py_CLEAR(p->suppress_sequences); Py_CLEAR(p->__pyx___KEEP_IT_IN_SCOPE_read); Py_CLEAR(p->__pyx___KEEP_IT_IN_SCOPE_matrix); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *p = (struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)o; if (p->is_protein) { e = (*v)(((PyObject *)p->is_protein), a); if (e) return e; } if (p->suppress_sequences) { e = (*v)(((PyObject *)p->suppress_sequences), a); if (e) return e; } if (p->__pyx___KEEP_IT_IN_SCOPE_read) { e = (*v)(((PyObject *)p->__pyx___KEEP_IT_IN_SCOPE_read), a); if (e) return e; } if (p->__pyx___KEEP_IT_IN_SCOPE_matrix) { e = (*v)(((PyObject *)p->__pyx___KEEP_IT_IN_SCOPE_matrix), a); if (e) return e; } return 0; } static int __pyx_tp_clear_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman(PyObject *o) { PyObject* tmp; struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *p = (struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *)o; tmp = ((PyObject*)p->is_protein); p->is_protein = ((PyBoolObject *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->suppress_sequences); p->suppress_sequences = ((PyBoolObject *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->__pyx___KEEP_IT_IN_SCOPE_read); p->__pyx___KEEP_IT_IN_SCOPE_read = ((PyArrayObject *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->__pyx___KEEP_IT_IN_SCOPE_matrix); p->__pyx___KEEP_IT_IN_SCOPE_matrix = ((PyArrayObject *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman[] = { {"_get_bit_flag", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_7_get_bit_flag, METH_VARARGS|METH_KEYWORDS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_9__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_11__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman = { PyVarObject_HEAD_INIT(0, 0) "skbio.alignment._ssw_wrapper.StripedSmithWaterman", /*tp_name*/ sizeof(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ __pyx_pw_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_3__call__, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "Performs a striped (banded) Smith Waterman Alignment.\n\n First a StripedSmithWaterman object must be instantiated with a query\n sequence. The resulting object is then callable with a target sequence and\n may be reused on a large collection of target sequences.\n\n Parameters\n ----------\n query_sequence : string\n The query sequence, this may be upper or lowercase from the set of\n {A, C, G, T, N} (nucleotide) or from the set of\n {A, R, N, D, C, Q, E, G, H, I, L, K, M, F, P, S, T, W, Y, V, B, Z, X, *\n } (protein)\n gap_open_penalty : int, optional\n The penalty applied to creating a gap in the alignment. This CANNOT\n be 0.\n Default is 5.\n gap_extend_penalty : int, optional\n The penalty applied to extending a gap in the alignment. This CANNOT\n be 0.\n Default is 2.\n score_size : int, optional\n If your estimated best alignment score is < 255 this should be 0.\n If your estimated best alignment score is >= 255, this should be 1.\n If you don't know, this should be 2.\n Default is 2.\n mask_length : int, optional\n The distance between the optimal and suboptimal alignment ending\n position >= mask_length. We suggest to use len(query_sequence)/2, if\n you don't have special concerns.\n Detailed description of mask_length: After locating the optimal\n alignment ending position, the suboptimal alignment score can be\n heuristically found by checking the second largest score in the array\n that contains the maximal score of each column of the SW matrix. In\n order to avoid picking the scores that belong to the alignments\n sharing the partial best alignment, SSW C library masks the reference\n loci nearby (mask length = mask_length) the best alignment ending\n position and locates the second largest score from the unmasked\n elements.\n Default i""s 15.\n mask_auto : bool, optional\n This will automatically set the used mask length to be\n max(int(len(`query_sequence`)/2), `mask_length`).\n Default is True.\n score_only : bool, optional\n This will prevent the best alignment beginning positions (BABP) and the\n cigar from being returned as a result. This overrides any setting on\n `score_filter`, `distance_filter`, and `override_skip_babp`. It has the\n highest precedence.\n Default is False.\n score_filter : int, optional\n If set, this will prevent the cigar and best alignment beginning\n positions (BABP) from being returned if the optimal alignment score is\n less than `score_filter` saving some time computationally. This filter\n may be overridden by `score_only` (prevents BABP and cigar, regardless\n of other arguments), `distance_filter` (may prevent cigar, but will\n cause BABP to be calculated), and `override_skip_babp` (will ensure\n BABP) returned.\n Default is None.\n distance_filter : int, optional\n If set, this will prevent the cigar from being returned if the length\n of the `query_sequence` or the `target_sequence` is less than\n `distance_filter` saving some time computationally. The results of\n this filter may be overridden by `score_only` (prevents BABP and cigar,\n regardless of other arguments), and `score_filter` (may prevent cigar).\n `override_skip_babp` has no effect with this filter applied, as BABP\n must be calculated to perform the filter.\n Default is None.\n override_skip_babp : bool, optional\n When True, the best alignment beginning positions (BABP) will always be\n returned unless `score_only` is set to True.\n Default is False.\n protein : bool, optional\n When True, the `query_sequence` and `target_sequence` will be read as\n protein sequence. When False, ""the `query_sequence` and\n `target_sequence` will be read as nucleotide sequence. If True, a\n `substitution_matrix` must be supplied.\n Default is False.\n match_score : int, optional\n When using a nucleotide sequence, the match_score is the score added\n when a match occurs. This is ignored if `substitution_matrix` is\n provided.\n Default is 2.\n mismatch_score : int, optional\n When using a nucleotide sequence, the mismatch is the score subtracted\n when a mismatch occurs. This should be a negative integer.\n This is ignored if `substitution_matrix` is provided.\n Default is -3.\n substitution_matrix : 2D dict, optional\n Provides the score for each possible substitution of sequence\n characters. This may be used for protein or nucleotide sequences. The\n entire set of possible combinations for the relevant sequence type MUST\n be enumerated in the dict of dicts. This will override `match_score`\n and `mismatch_score`. Required when `protein` is True.\n Default is None.\n suppress_sequences : bool, optional\n If True, the query and target sequences will not be returned for\n convenience.\n Default is False.\n zero_index : bool, optional\n If True, all inidices will start at 0. If False, all inidices will\n start at 1.\n Default is True.\n\n Notes\n -----\n This is a wrapper for the SSW package [1]_.\n\n `mask_length` has to be >= 15, otherwise the suboptimal alignment\n information will NOT be returned.\n\n `match_score` is a positive integer and `mismatch_score` is a negative\n integer.\n\n `match_score` and `mismatch_score` are only meaningful in the context of\n nucleotide sequences.\n\n A substitution matrix must be provided when working with protein sequences.\n\n References\n ----------\n .. [1] Zhao, Mengyao, Wan-Ping Lee, Erik P. Garrison, & ""Gabor T.\n Marth. \"SSW Library: An SIMD Smith-Waterman C/C++ Library for\n Applications\". PLOS ONE (2013). Web. 11 July 2014.\n http://www.plosone.org/article/info:doi/10.1371/journal.pone.0082138\n\n ", /*tp_doc*/ __pyx_tp_traverse_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, /*tp_traverse*/ __pyx_tp_clear_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__ssw_wrapper(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__ssw_wrapper}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_ssw_wrapper", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_n_s_ACGTN, __pyx_k_ACGTN, sizeof(__pyx_k_ACGTN), 0, 0, 1, 1}, {&__pyx_kp_s_ARNDCQEGHILKMFPSTWYVBZX, __pyx_k_ARNDCQEGHILKMFPSTWYVBZX, sizeof(__pyx_k_ARNDCQEGHILKMFPSTWYVBZX), 0, 0, 1, 0}, {&__pyx_n_s_AlignmentStructure, __pyx_k_AlignmentStructure, sizeof(__pyx_k_AlignmentStructure), 0, 0, 1, 1}, {&__pyx_n_s_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 0, 1, 1}, {&__pyx_n_s_I, __pyx_k_I, sizeof(__pyx_k_I), 0, 0, 1, 1}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_s_Length_d, __pyx_k_Length_d, sizeof(__pyx_k_Length_d), 0, 0, 1, 0}, {&__pyx_n_s_M, __pyx_k_M, sizeof(__pyx_k_M), 0, 0, 1, 1}, {&__pyx_kp_s_Must_provide_a_substitution_matr, __pyx_k_Must_provide_a_substitution_matr, sizeof(__pyx_k_Must_provide_a_substitution_matr), 0, 0, 1, 0}, {&__pyx_n_s_N, __pyx_k_N, sizeof(__pyx_k_N), 0, 0, 1, 1}, {&__pyx_n_s_Protein, __pyx_k_Protein, sizeof(__pyx_k_Protein), 0, 0, 1, 1}, {&__pyx_kp_s_Score_d, __pyx_k_Score_d, sizeof(__pyx_k_Score_d), 0, 0, 1, 0}, {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, {&__pyx_n_s_StripedSmithWaterman, __pyx_k_StripedSmithWaterman, sizeof(__pyx_k_StripedSmithWaterman), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, {&__pyx_kp_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 0}, {&__pyx_kp_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 0}, {&__pyx_n_s_aligned_query_sequence, __pyx_k_aligned_query_sequence, sizeof(__pyx_k_aligned_query_sequence), 0, 0, 1, 1}, {&__pyx_n_s_aligned_target_sequence, __pyx_k_aligned_target_sequence, sizeof(__pyx_k_aligned_target_sequence), 0, 0, 1, 1}, {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, {&__pyx_n_s_begin, __pyx_k_begin, sizeof(__pyx_k_begin), 0, 0, 1, 1}, {&__pyx_n_s_cigar, __pyx_k_cigar, sizeof(__pyx_k_cigar), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_distance_filter, __pyx_k_distance_filter, sizeof(__pyx_k_distance_filter), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, {&__pyx_n_s_gap_extend_penalty, __pyx_k_gap_extend_penalty, sizeof(__pyx_k_gap_extend_penalty), 0, 0, 1, 1}, {&__pyx_kp_s_gap_extend_penalty_must_be_0, __pyx_k_gap_extend_penalty_must_be_0, sizeof(__pyx_k_gap_extend_penalty_must_be_0), 0, 0, 1, 0}, {&__pyx_n_s_gap_open_penalty, __pyx_k_gap_open_penalty, sizeof(__pyx_k_gap_open_penalty), 0, 0, 1, 1}, {&__pyx_kp_s_gap_open_penalty_must_be_0, __pyx_k_gap_open_penalty_must_be_0, sizeof(__pyx_k_gap_open_penalty_must_be_0), 0, 0, 1, 0}, {&__pyx_n_s_gap_type, __pyx_k_gap_type, sizeof(__pyx_k_gap_type), 0, 0, 1, 1}, {&__pyx_n_s_get_aligned_sequence, __pyx_k_get_aligned_sequence, sizeof(__pyx_k_get_aligned_sequence), 0, 0, 1, 1}, {&__pyx_n_s_get_bit_flag, __pyx_k_get_bit_flag, sizeof(__pyx_k_get_bit_flag), 0, 0, 1, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_index_starts_at, __pyx_k_index_starts_at, sizeof(__pyx_k_index_starts_at), 0, 0, 1, 1}, {&__pyx_n_s_int8, __pyx_k_int8, sizeof(__pyx_k_int8), 0, 0, 1, 1}, {&__pyx_n_s_is_zero_based, __pyx_k_is_zero_based, sizeof(__pyx_k_is_zero_based), 0, 0, 1, 1}, {&__pyx_n_s_isdigit, __pyx_k_isdigit, sizeof(__pyx_k_isdigit), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mask_auto, __pyx_k_mask_auto, sizeof(__pyx_k_mask_auto), 0, 0, 1, 1}, {&__pyx_n_s_mask_length, __pyx_k_mask_length, sizeof(__pyx_k_mask_length), 0, 0, 1, 1}, {&__pyx_n_s_match_score, __pyx_k_match_score, sizeof(__pyx_k_match_score), 0, 0, 1, 1}, {&__pyx_n_s_mid_table, __pyx_k_mid_table, sizeof(__pyx_k_mid_table), 0, 0, 1, 1}, {&__pyx_n_s_mismatch_score, __pyx_k_mismatch_score, sizeof(__pyx_k_mismatch_score), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_np_aa_table, __pyx_k_np_aa_table, sizeof(__pyx_k_np_aa_table), 0, 0, 1, 1}, {&__pyx_n_s_np_nt_table, __pyx_k_np_nt_table, sizeof(__pyx_k_np_nt_table), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, {&__pyx_n_s_optimal_alignment_score, __pyx_k_optimal_alignment_score, sizeof(__pyx_k_optimal_alignment_score), 0, 0, 1, 1}, {&__pyx_n_s_override_skip_babp, __pyx_k_override_skip_babp, sizeof(__pyx_k_override_skip_babp), 0, 0, 1, 1}, {&__pyx_n_s_protein, __pyx_k_protein, sizeof(__pyx_k_protein), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_query_begin, __pyx_k_query_begin, sizeof(__pyx_k_query_begin), 0, 0, 1, 1}, {&__pyx_n_s_query_end, __pyx_k_query_end, sizeof(__pyx_k_query_end), 0, 0, 1, 1}, {&__pyx_n_s_query_sequence, __pyx_k_query_sequence, sizeof(__pyx_k_query_sequence), 0, 0, 1, 1}, {&__pyx_kp_s_r_r, __pyx_k_r_r, sizeof(__pyx_k_r_r), 0, 0, 1, 0}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_read_sequence, __pyx_k_read_sequence, sizeof(__pyx_k_read_sequence), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_reference_sequence, __pyx_k_reference_sequence, sizeof(__pyx_k_reference_sequence), 0, 0, 1, 1}, {&__pyx_kp_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 0}, {&__pyx_n_s_score_filter, __pyx_k_score_filter, sizeof(__pyx_k_score_filter), 0, 0, 1, 1}, {&__pyx_n_s_score_only, __pyx_k_score_only, sizeof(__pyx_k_score_only), 0, 0, 1, 1}, {&__pyx_n_s_score_size, __pyx_k_score_size, sizeof(__pyx_k_score_size), 0, 0, 1, 1}, {&__pyx_n_s_sequence, __pyx_k_sequence, sizeof(__pyx_k_sequence), 0, 0, 1, 1}, {&__pyx_n_s_set_zero_based, __pyx_k_set_zero_based, sizeof(__pyx_k_set_zero_based), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_skbio_sequence, __pyx_k_skbio_sequence, sizeof(__pyx_k_skbio_sequence), 0, 0, 1, 1}, {&__pyx_n_s_suboptimal_alignment_score, __pyx_k_suboptimal_alignment_score, sizeof(__pyx_k_suboptimal_alignment_score), 0, 0, 1, 1}, {&__pyx_n_s_substitution_matrix, __pyx_k_substitution_matrix, sizeof(__pyx_k_substitution_matrix), 0, 0, 1, 1}, {&__pyx_n_s_suppress_sequences, __pyx_k_suppress_sequences, sizeof(__pyx_k_suppress_sequences), 0, 0, 1, 1}, {&__pyx_n_s_target_begin, __pyx_k_target_begin, sizeof(__pyx_k_target_begin), 0, 0, 1, 1}, {&__pyx_n_s_target_end_optimal, __pyx_k_target_end_optimal, sizeof(__pyx_k_target_end_optimal), 0, 0, 1, 1}, {&__pyx_n_s_target_end_suboptimal, __pyx_k_target_end_suboptimal, sizeof(__pyx_k_target_end_suboptimal), 0, 0, 1, 1}, {&__pyx_n_s_target_sequence, __pyx_k_target_sequence, sizeof(__pyx_k_target_sequence), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_tuple_cigar, __pyx_k_tuple_cigar, sizeof(__pyx_k_tuple_cigar), 0, 0, 1, 1}, {&__pyx_n_s_tuples_from_cigar, __pyx_k_tuples_from_cigar, sizeof(__pyx_k_tuples_from_cigar), 0, 0, 1, 1}, {&__pyx_n_s_zero_index, __pyx_k_zero_index, sizeof(__pyx_k_zero_index), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 265, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 558, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 674, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 944, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "skbio/alignment/_ssw_wrapper.pyx":124 * align_len = len(query) * if align_len > 13: * target = target[:10] + "..." # <<<<<<<<<<<<<< * query = query[:10] + "..." * */ __pyx_slice__2 = PySlice_New(Py_None, __pyx_int_10, Py_None); if (unlikely(!__pyx_slice__2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__2); __Pyx_GIVEREF(__pyx_slice__2); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "skbio/alignment/_ssw_wrapper.pyx":558 * self.read_sequence = query_sequence * if gap_open_penalty <= 0: * raise ValueError("`gap_open_penalty` must be > 0") # <<<<<<<<<<<<<< * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_gap_open_penalty_must_be_0); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "skbio/alignment/_ssw_wrapper.pyx":561 * self.gap_open_penalty = gap_open_penalty * if gap_extend_penalty <= 0: * raise ValueError("`gap_extend_penalty` must be > 0") # <<<<<<<<<<<<<< * self.gap_extend_penalty = gap_extend_penalty * self.distance_filter = 0 if distance_filter is None else \ */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_gap_extend_penalty_must_be_0); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 561, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "skbio/alignment/_ssw_wrapper.pyx":576 * if substitution_matrix is None: * if protein: * raise Exception("Must provide a substitution matrix for" # <<<<<<<<<<<<<< * " protein sequences") * matrix = self._build_match_matrix(match_score, mismatch_score) */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Must_provide_a_substitution_matr); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 944, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_11 = PyInt_FromLong(11); if (unlikely(!__pyx_int_11)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_13 = PyInt_FromLong(13); if (unlikely(!__pyx_int_13)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_14 = PyInt_FromLong(14); if (unlikely(!__pyx_int_14)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_17 = PyInt_FromLong(17); if (unlikely(!__pyx_int_17)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_18 = PyInt_FromLong(18); if (unlikely(!__pyx_int_18)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_19 = PyInt_FromLong(19); if (unlikely(!__pyx_int_19)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_20 = PyInt_FromLong(20); if (unlikely(!__pyx_int_20)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_21 = PyInt_FromLong(21); if (unlikely(!__pyx_int_21)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_22 = PyInt_FromLong(22); if (unlikely(!__pyx_int_22)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_23 = PyInt_FromLong(23); if (unlikely(!__pyx_int_23)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_3 = PyInt_FromLong(-3); if (unlikely(!__pyx_int_neg_3)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure = &__pyx_vtable_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.__pyx___constructor = (PyObject *(*)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure *, s_align *))__pyx_f_5skbio_9alignment_12_ssw_wrapper_18AlignmentStructure___constructor; if (PyType_Ready(&__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure) < 0) __PYX_ERR(0, 73, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.tp_dictoffset && __pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure.tp_dict, __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure) < 0) __PYX_ERR(0, 73, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AlignmentStructure, (PyObject *)&__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure) < 0) __PYX_ERR(0, 73, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure) < 0) __PYX_ERR(0, 73, __pyx_L1_error) __pyx_ptype_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure = &__pyx_type_5skbio_9alignment_12_ssw_wrapper_AlignmentStructure; __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman = &__pyx_vtable_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman._seq_converter = (PyArrayObject *(*)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *))__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__seq_converter; __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman._build_match_matrix = (PyArrayObject *(*)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *, PyObject *))__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__build_match_matrix; __pyx_vtable_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman._convert_dict2d_to_matrix = (PyArrayObject *(*)(struct __pyx_obj_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman *, PyObject *))__pyx_f_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman__convert_dict2d_to_matrix; if (PyType_Ready(&__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman) < 0) __PYX_ERR(0, 397, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman.tp_dictoffset && __pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman.tp_getattro = __Pyx_PyObject_GenericGetAttr; } #if CYTHON_UPDATE_DESCRIPTOR_DOC { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(0, 397, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__.doc = __pyx_doc_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_5skbio_9alignment_12_ssw_wrapper_20StripedSmithWaterman_2__call__; } } #endif if (__Pyx_SetVtable(__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman.tp_dict, __pyx_vtabptr_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman) < 0) __PYX_ERR(0, 397, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StripedSmithWaterman, (PyObject *)&__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman) < 0) __PYX_ERR(0, 397, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman) < 0) __PYX_ERR(0, 397, __pyx_L1_error) __pyx_ptype_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman = &__pyx_type_5skbio_9alignment_12_ssw_wrapper_StripedSmithWaterman; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(4, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(5, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 199, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 222, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 226, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 238, __pyx_L1_error) __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(2, 770, __pyx_L1_error) __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_number) __PYX_ERR(2, 772, __pyx_L1_error) __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(2, 774, __pyx_L1_error) __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 776, __pyx_L1_error) __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 778, __pyx_L1_error) __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 780, __pyx_L1_error) __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(2, 782, __pyx_L1_error) __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 784, __pyx_L1_error) __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 786, __pyx_L1_error) __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_character) __PYX_ERR(2, 788, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_ssw_wrapper(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_ssw_wrapper(void) #else __Pyx_PyMODINIT_FUNC PyInit__ssw_wrapper(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__ssw_wrapper(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__ssw_wrapper(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_ssw_wrapper' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__ssw_wrapper(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_ssw_wrapper", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__alignment___ssw_wrapper) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.alignment._ssw_wrapper")) { if (unlikely(PyDict_SetItemString(modules, "skbio.alignment._ssw_wrapper", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "skbio/alignment/_ssw_wrapper.pyx":10 * * from cpython cimport bool * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as cnp * from skbio.sequence import Protein, Sequence */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":12 * import numpy as np * cimport numpy as cnp * from skbio.sequence import Protein, Sequence # <<<<<<<<<<<<<< * * cdef extern from "_lib/ssw.h": */ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Protein); __Pyx_GIVEREF(__pyx_n_s_Protein); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Protein); __Pyx_INCREF(__pyx_n_s_Sequence); __Pyx_GIVEREF(__pyx_n_s_Sequence); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Sequence); __pyx_t_2 = __Pyx_Import(__pyx_n_s_skbio_sequence, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Protein); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Protein, __pyx_t_1) < 0) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sequence, __pyx_t_1) < 0) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":50 * cdef void align_destroy(s_align* a) * * np_aa_table = np.array([ # <<<<<<<<<<<<<< * 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, * 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyList_New(128); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 2, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 3, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 4, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 5, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 6, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 7, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 8, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 9, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 10, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 11, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 12, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 13, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 14, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 15, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 16, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 17, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 18, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 19, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 20, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 21, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 22, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 23, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 24, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 25, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 26, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 27, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 28, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 29, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 30, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 31, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 32, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 33, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 34, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 35, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 36, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 37, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 38, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 39, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 40, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 41, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 42, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 43, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 44, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 45, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 46, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 47, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 48, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 49, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 50, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 51, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 52, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 53, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 54, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 55, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 56, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 57, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 58, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 59, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 60, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 61, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 62, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 63, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 64, __pyx_int_23); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_2, 65, __pyx_int_0); __Pyx_INCREF(__pyx_int_20); __Pyx_GIVEREF(__pyx_int_20); PyList_SET_ITEM(__pyx_t_2, 66, __pyx_int_20); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_2, 67, __pyx_int_4); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyList_SET_ITEM(__pyx_t_2, 68, __pyx_int_3); __Pyx_INCREF(__pyx_int_6); __Pyx_GIVEREF(__pyx_int_6); PyList_SET_ITEM(__pyx_t_2, 69, __pyx_int_6); __Pyx_INCREF(__pyx_int_13); __Pyx_GIVEREF(__pyx_int_13); PyList_SET_ITEM(__pyx_t_2, 70, __pyx_int_13); __Pyx_INCREF(__pyx_int_7); __Pyx_GIVEREF(__pyx_int_7); PyList_SET_ITEM(__pyx_t_2, 71, __pyx_int_7); __Pyx_INCREF(__pyx_int_8); __Pyx_GIVEREF(__pyx_int_8); PyList_SET_ITEM(__pyx_t_2, 72, __pyx_int_8); __Pyx_INCREF(__pyx_int_9); __Pyx_GIVEREF(__pyx_int_9); PyList_SET_ITEM(__pyx_t_2, 73, __pyx_int_9); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 74, __pyx_int_23); __Pyx_INCREF(__pyx_int_11); __Pyx_GIVEREF(__pyx_int_11); PyList_SET_ITEM(__pyx_t_2, 75, __pyx_int_11); __Pyx_INCREF(__pyx_int_10); __Pyx_GIVEREF(__pyx_int_10); PyList_SET_ITEM(__pyx_t_2, 76, __pyx_int_10); __Pyx_INCREF(__pyx_int_12); __Pyx_GIVEREF(__pyx_int_12); PyList_SET_ITEM(__pyx_t_2, 77, __pyx_int_12); __Pyx_INCREF(__pyx_int_2); __Pyx_GIVEREF(__pyx_int_2); PyList_SET_ITEM(__pyx_t_2, 78, __pyx_int_2); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 79, __pyx_int_23); __Pyx_INCREF(__pyx_int_14); __Pyx_GIVEREF(__pyx_int_14); PyList_SET_ITEM(__pyx_t_2, 80, __pyx_int_14); __Pyx_INCREF(__pyx_int_5); __Pyx_GIVEREF(__pyx_int_5); PyList_SET_ITEM(__pyx_t_2, 81, __pyx_int_5); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyList_SET_ITEM(__pyx_t_2, 82, __pyx_int_1); __Pyx_INCREF(__pyx_int_15); __Pyx_GIVEREF(__pyx_int_15); PyList_SET_ITEM(__pyx_t_2, 83, __pyx_int_15); __Pyx_INCREF(__pyx_int_16); __Pyx_GIVEREF(__pyx_int_16); PyList_SET_ITEM(__pyx_t_2, 84, __pyx_int_16); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 85, __pyx_int_23); __Pyx_INCREF(__pyx_int_19); __Pyx_GIVEREF(__pyx_int_19); PyList_SET_ITEM(__pyx_t_2, 86, __pyx_int_19); __Pyx_INCREF(__pyx_int_17); __Pyx_GIVEREF(__pyx_int_17); PyList_SET_ITEM(__pyx_t_2, 87, __pyx_int_17); __Pyx_INCREF(__pyx_int_22); __Pyx_GIVEREF(__pyx_int_22); PyList_SET_ITEM(__pyx_t_2, 88, __pyx_int_22); __Pyx_INCREF(__pyx_int_18); __Pyx_GIVEREF(__pyx_int_18); PyList_SET_ITEM(__pyx_t_2, 89, __pyx_int_18); __Pyx_INCREF(__pyx_int_21); __Pyx_GIVEREF(__pyx_int_21); PyList_SET_ITEM(__pyx_t_2, 90, __pyx_int_21); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 91, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 92, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 93, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 94, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 95, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 96, __pyx_int_23); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_2, 97, __pyx_int_0); __Pyx_INCREF(__pyx_int_20); __Pyx_GIVEREF(__pyx_int_20); PyList_SET_ITEM(__pyx_t_2, 98, __pyx_int_20); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_2, 99, __pyx_int_4); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyList_SET_ITEM(__pyx_t_2, 100, __pyx_int_3); __Pyx_INCREF(__pyx_int_6); __Pyx_GIVEREF(__pyx_int_6); PyList_SET_ITEM(__pyx_t_2, 101, __pyx_int_6); __Pyx_INCREF(__pyx_int_13); __Pyx_GIVEREF(__pyx_int_13); PyList_SET_ITEM(__pyx_t_2, 102, __pyx_int_13); __Pyx_INCREF(__pyx_int_7); __Pyx_GIVEREF(__pyx_int_7); PyList_SET_ITEM(__pyx_t_2, 103, __pyx_int_7); __Pyx_INCREF(__pyx_int_8); __Pyx_GIVEREF(__pyx_int_8); PyList_SET_ITEM(__pyx_t_2, 104, __pyx_int_8); __Pyx_INCREF(__pyx_int_9); __Pyx_GIVEREF(__pyx_int_9); PyList_SET_ITEM(__pyx_t_2, 105, __pyx_int_9); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 106, __pyx_int_23); __Pyx_INCREF(__pyx_int_11); __Pyx_GIVEREF(__pyx_int_11); PyList_SET_ITEM(__pyx_t_2, 107, __pyx_int_11); __Pyx_INCREF(__pyx_int_10); __Pyx_GIVEREF(__pyx_int_10); PyList_SET_ITEM(__pyx_t_2, 108, __pyx_int_10); __Pyx_INCREF(__pyx_int_12); __Pyx_GIVEREF(__pyx_int_12); PyList_SET_ITEM(__pyx_t_2, 109, __pyx_int_12); __Pyx_INCREF(__pyx_int_2); __Pyx_GIVEREF(__pyx_int_2); PyList_SET_ITEM(__pyx_t_2, 110, __pyx_int_2); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 111, __pyx_int_23); __Pyx_INCREF(__pyx_int_14); __Pyx_GIVEREF(__pyx_int_14); PyList_SET_ITEM(__pyx_t_2, 112, __pyx_int_14); __Pyx_INCREF(__pyx_int_5); __Pyx_GIVEREF(__pyx_int_5); PyList_SET_ITEM(__pyx_t_2, 113, __pyx_int_5); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyList_SET_ITEM(__pyx_t_2, 114, __pyx_int_1); __Pyx_INCREF(__pyx_int_15); __Pyx_GIVEREF(__pyx_int_15); PyList_SET_ITEM(__pyx_t_2, 115, __pyx_int_15); __Pyx_INCREF(__pyx_int_16); __Pyx_GIVEREF(__pyx_int_16); PyList_SET_ITEM(__pyx_t_2, 116, __pyx_int_16); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 117, __pyx_int_23); __Pyx_INCREF(__pyx_int_19); __Pyx_GIVEREF(__pyx_int_19); PyList_SET_ITEM(__pyx_t_2, 118, __pyx_int_19); __Pyx_INCREF(__pyx_int_17); __Pyx_GIVEREF(__pyx_int_17); PyList_SET_ITEM(__pyx_t_2, 119, __pyx_int_17); __Pyx_INCREF(__pyx_int_22); __Pyx_GIVEREF(__pyx_int_22); PyList_SET_ITEM(__pyx_t_2, 120, __pyx_int_22); __Pyx_INCREF(__pyx_int_18); __Pyx_GIVEREF(__pyx_int_18); PyList_SET_ITEM(__pyx_t_2, 121, __pyx_int_18); __Pyx_INCREF(__pyx_int_21); __Pyx_GIVEREF(__pyx_int_21); PyList_SET_ITEM(__pyx_t_2, 122, __pyx_int_21); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 123, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 124, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 125, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 126, __pyx_int_23); __Pyx_INCREF(__pyx_int_23); __Pyx_GIVEREF(__pyx_int_23); PyList_SET_ITEM(__pyx_t_2, 127, __pyx_int_23); __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_aa_table, __pyx_t_3) < 0) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":60 * 14, 5, 1, 15, 16, 23, 19, 17, 22, 18, 21, 23, 23, 23, 23, 23]) * * np_nt_table = np.array([ # <<<<<<<<<<<<<< * 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, 4, 4, 4, 4, 4, */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyList_New(128); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 0, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 2, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 3, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 4, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 5, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 6, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 7, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 8, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 9, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 10, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 11, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 12, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 13, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 14, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 15, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 16, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 17, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 18, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 19, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 20, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 21, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 22, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 23, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 24, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 25, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 26, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 27, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 28, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 29, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 30, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 31, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 32, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 33, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 34, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 35, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 36, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 37, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 38, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 39, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 40, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 41, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 42, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 43, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 44, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 45, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 46, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 47, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 48, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 49, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 50, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 51, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 52, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 53, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 54, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 55, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 56, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 57, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 58, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 59, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 60, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 61, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 62, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 63, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 64, __pyx_int_4); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_3, 65, __pyx_int_0); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 66, __pyx_int_4); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyList_SET_ITEM(__pyx_t_3, 67, __pyx_int_1); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 68, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 69, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 70, __pyx_int_4); __Pyx_INCREF(__pyx_int_2); __Pyx_GIVEREF(__pyx_int_2); PyList_SET_ITEM(__pyx_t_3, 71, __pyx_int_2); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 72, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 73, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 74, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 75, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 76, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 77, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 78, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 79, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 80, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 81, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 82, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 83, __pyx_int_4); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyList_SET_ITEM(__pyx_t_3, 84, __pyx_int_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_3, 85, __pyx_int_0); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 86, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 87, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 88, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 89, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 90, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 91, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 92, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 93, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 94, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 95, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 96, __pyx_int_4); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_3, 97, __pyx_int_0); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 98, __pyx_int_4); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyList_SET_ITEM(__pyx_t_3, 99, __pyx_int_1); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 100, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 101, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 102, __pyx_int_4); __Pyx_INCREF(__pyx_int_2); __Pyx_GIVEREF(__pyx_int_2); PyList_SET_ITEM(__pyx_t_3, 103, __pyx_int_2); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 104, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 105, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 106, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 107, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 108, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 109, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 110, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 111, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 112, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 113, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 114, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 115, __pyx_int_4); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyList_SET_ITEM(__pyx_t_3, 116, __pyx_int_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyList_SET_ITEM(__pyx_t_3, 117, __pyx_int_0); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 118, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 119, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 120, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 121, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 122, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 123, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 124, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 125, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 126, __pyx_int_4); __Pyx_INCREF(__pyx_int_4); __Pyx_GIVEREF(__pyx_int_4); PyList_SET_ITEM(__pyx_t_3, 127, __pyx_int_4); __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_nt_table, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":70 * 4, 4, 4, 4, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]) * * mid_table = np.array(['M', 'I', 'D']) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_M); __Pyx_GIVEREF(__pyx_n_s_M); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_M); __Pyx_INCREF(__pyx_n_s_I); __Pyx_GIVEREF(__pyx_n_s_I); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_I); __Pyx_INCREF(__pyx_n_s_D); __Pyx_GIVEREF(__pyx_n_s_D); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_D); __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_mid_table, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/alignment/_ssw_wrapper.pyx":1 * # ----------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # Copyright (c) 2013--, scikit-bio development team. * # */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.alignment._ssw_wrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.alignment._ssw_wrapper"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* StringJoin */ #if !CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; if (unlikely(!(m && m->sq_item))) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; } key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; if (likely(m && m->mp_subscript)) { return m->mp_subscript(obj, key); } return __Pyx_PyObject_GetIndex(obj, key); } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* SliceObject */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a + b); if (likely((x^a) >= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* BufferFallbackError */ static void __Pyx_RaiseBufferFallbackError(void) { PyErr_SetString(PyExc_ValueError, "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } /* DivInt[Py_ssize_t] */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { Py_ssize_t q = a / b; Py_ssize_t r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); return q; } /* UnicodeAsUCS4 */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { Py_ssize_t length; #if CYTHON_PEP393_ENABLED length = PyUnicode_GET_LENGTH(x); if (likely(length == 1)) { return PyUnicode_READ_CHAR(x, 0); } #else length = PyUnicode_GET_SIZE(x); if (likely(length == 1)) { return PyUnicode_AS_UNICODE(x)[0]; } #if Py_UNICODE_SIZE == 2 else if (PyUnicode_GET_SIZE(x) == 2) { Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; if (high_val >= 0xD800 && high_val <= 0xDBFF) { Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; if (low_val >= 0xDC00 && low_val <= 0xDFFF) { return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); } } } #endif #endif PyErr_Format(PyExc_ValueError, "only single character unicode strings can be converted to Py_UCS4, " "got length %" CYTHON_FORMAT_SSIZE_T "d", length); return (Py_UCS4)-1; } /* object_ord */ static long __Pyx__PyObject_Ord(PyObject* c) { Py_ssize_t size; if (PyBytes_Check(c)) { size = PyBytes_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyBytes_AS_STRING(c)[0]; } #if PY_MAJOR_VERSION < 3 } else if (PyUnicode_Check(c)) { return (long)__Pyx_PyUnicode_AsPy_UCS4(c); #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) } else if (PyByteArray_Check(c)) { size = PyByteArray_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyByteArray_AS_STRING(c)[0]; } #endif } else { PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but %.200s found", Py_TYPE(c)->tp_name); return (long)(Py_UCS4)-1; } PyErr_Format(PyExc_TypeError, "ord() expected a character, but string of length %zd found", size); return (long)(Py_UCS4)-1; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_uint16(npy_uint16 value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_uint16 neg_one = (npy_uint16) -1, const_zero = (npy_uint16) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(npy_uint16) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(npy_uint16) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint16) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(npy_uint16) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint16) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(npy_uint16), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int32(npy_int32 value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int32 neg_one = (npy_int32) -1, const_zero = (npy_int32) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(npy_int32) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(npy_int32) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int32) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(npy_int32) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int32) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(npy_int32), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE npy_int32 __Pyx_PyInt_As_npy_int32(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int32 neg_one = (npy_int32) -1, const_zero = (npy_int32) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(npy_int32) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(npy_int32, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (npy_int32) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int32) 0; case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, digits[0]) case 2: if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) >= 2 * PyLong_SHIFT) { return (npy_int32) (((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); } } break; case 3: if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) >= 3 * PyLong_SHIFT) { return (npy_int32) (((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); } } break; case 4: if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) >= 4 * PyLong_SHIFT) { return (npy_int32) (((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (npy_int32) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(npy_int32) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int32) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int32, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int32) 0; case -1: __PYX_VERIFY_RETURN_INT(npy_int32, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(npy_int32, digit, +digits[0]) case -2: if (8 * sizeof(npy_int32) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { return (npy_int32) (((npy_int32)-1)*(((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; case 2: if (8 * sizeof(npy_int32) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { return (npy_int32) ((((((npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; case -3: if (8 * sizeof(npy_int32) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { return (npy_int32) (((npy_int32)-1)*(((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; case 3: if (8 * sizeof(npy_int32) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { return (npy_int32) ((((((((npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; case -4: if (8 * sizeof(npy_int32) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { return (npy_int32) (((npy_int32)-1)*(((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; case 4: if (8 * sizeof(npy_int32) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int32, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int32) - 1 > 4 * PyLong_SHIFT) { return (npy_int32) ((((((((((npy_int32)digits[3]) << PyLong_SHIFT) | (npy_int32)digits[2]) << PyLong_SHIFT) | (npy_int32)digits[1]) << PyLong_SHIFT) | (npy_int32)digits[0]))); } } break; } #endif if (sizeof(npy_int32) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int32, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int32) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int32, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else npy_int32 val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (npy_int32) -1; } } else { npy_int32 val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (npy_int32) -1; val = __Pyx_PyInt_As_npy_int32(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to npy_int32"); return (npy_int32) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to npy_int32"); return (npy_int32) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE npy_uint8 __Pyx_PyInt_As_npy_uint8(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_uint8 neg_one = (npy_uint8) -1, const_zero = (npy_uint8) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(npy_uint8) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(npy_uint8, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (npy_uint8) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_uint8) 0; case 1: __PYX_VERIFY_RETURN_INT(npy_uint8, digit, digits[0]) case 2: if (8 * sizeof(npy_uint8) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) >= 2 * PyLong_SHIFT) { return (npy_uint8) (((((npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0])); } } break; case 3: if (8 * sizeof(npy_uint8) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) >= 3 * PyLong_SHIFT) { return (npy_uint8) (((((((npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0])); } } break; case 4: if (8 * sizeof(npy_uint8) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) >= 4 * PyLong_SHIFT) { return (npy_uint8) (((((((((npy_uint8)digits[3]) << PyLong_SHIFT) | (npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (npy_uint8) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(npy_uint8) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint8, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint8) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint8, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_uint8) 0; case -1: __PYX_VERIFY_RETURN_INT(npy_uint8, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(npy_uint8, digit, +digits[0]) case -2: if (8 * sizeof(npy_uint8) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 2 * PyLong_SHIFT) { return (npy_uint8) (((npy_uint8)-1)*(((((npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; case 2: if (8 * sizeof(npy_uint8) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 2 * PyLong_SHIFT) { return (npy_uint8) ((((((npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; case -3: if (8 * sizeof(npy_uint8) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 3 * PyLong_SHIFT) { return (npy_uint8) (((npy_uint8)-1)*(((((((npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; case 3: if (8 * sizeof(npy_uint8) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 3 * PyLong_SHIFT) { return (npy_uint8) ((((((((npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; case -4: if (8 * sizeof(npy_uint8) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 4 * PyLong_SHIFT) { return (npy_uint8) (((npy_uint8)-1)*(((((((((npy_uint8)digits[3]) << PyLong_SHIFT) | (npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; case 4: if (8 * sizeof(npy_uint8) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint8, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint8) - 1 > 4 * PyLong_SHIFT) { return (npy_uint8) ((((((((((npy_uint8)digits[3]) << PyLong_SHIFT) | (npy_uint8)digits[2]) << PyLong_SHIFT) | (npy_uint8)digits[1]) << PyLong_SHIFT) | (npy_uint8)digits[0]))); } } break; } #endif if (sizeof(npy_uint8) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint8, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint8) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint8, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else npy_uint8 val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (npy_uint8) -1; } } else { npy_uint8 val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (npy_uint8) -1; val = __Pyx_PyInt_As_npy_uint8(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to npy_uint8"); return (npy_uint8) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to npy_uint8"); return (npy_uint8) -1; } /* CIntFromPy */ static CYTHON_INLINE npy_uint16 __Pyx_PyInt_As_npy_uint16(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_uint16 neg_one = (npy_uint16) -1, const_zero = (npy_uint16) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(npy_uint16) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(npy_uint16, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (npy_uint16) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_uint16) 0; case 1: __PYX_VERIFY_RETURN_INT(npy_uint16, digit, digits[0]) case 2: if (8 * sizeof(npy_uint16) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) >= 2 * PyLong_SHIFT) { return (npy_uint16) (((((npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0])); } } break; case 3: if (8 * sizeof(npy_uint16) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) >= 3 * PyLong_SHIFT) { return (npy_uint16) (((((((npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0])); } } break; case 4: if (8 * sizeof(npy_uint16) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) >= 4 * PyLong_SHIFT) { return (npy_uint16) (((((((((npy_uint16)digits[3]) << PyLong_SHIFT) | (npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (npy_uint16) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(npy_uint16) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint16, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint16) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint16, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_uint16) 0; case -1: __PYX_VERIFY_RETURN_INT(npy_uint16, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(npy_uint16, digit, +digits[0]) case -2: if (8 * sizeof(npy_uint16) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 2 * PyLong_SHIFT) { return (npy_uint16) (((npy_uint16)-1)*(((((npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; case 2: if (8 * sizeof(npy_uint16) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 2 * PyLong_SHIFT) { return (npy_uint16) ((((((npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; case -3: if (8 * sizeof(npy_uint16) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 3 * PyLong_SHIFT) { return (npy_uint16) (((npy_uint16)-1)*(((((((npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; case 3: if (8 * sizeof(npy_uint16) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 3 * PyLong_SHIFT) { return (npy_uint16) ((((((((npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; case -4: if (8 * sizeof(npy_uint16) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 4 * PyLong_SHIFT) { return (npy_uint16) (((npy_uint16)-1)*(((((((((npy_uint16)digits[3]) << PyLong_SHIFT) | (npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; case 4: if (8 * sizeof(npy_uint16) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_uint16, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_uint16) - 1 > 4 * PyLong_SHIFT) { return (npy_uint16) ((((((((((npy_uint16)digits[3]) << PyLong_SHIFT) | (npy_uint16)digits[2]) << PyLong_SHIFT) | (npy_uint16)digits[1]) << PyLong_SHIFT) | (npy_uint16)digits[0]))); } } break; } #endif if (sizeof(npy_uint16) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint16, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_uint16) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_uint16, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else npy_uint16 val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (npy_uint16) -1; } } else { npy_uint16 val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (npy_uint16) -1; val = __Pyx_PyInt_As_npy_uint16(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to npy_uint16"); return (npy_uint16) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to npy_uint16"); return (npy_uint16) -1; } /* CIntFromPy */ static CYTHON_INLINE npy_int8 __Pyx_PyInt_As_npy_int8(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int8 neg_one = (npy_int8) -1, const_zero = (npy_int8) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(npy_int8) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(npy_int8, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (npy_int8) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int8) 0; case 1: __PYX_VERIFY_RETURN_INT(npy_int8, digit, digits[0]) case 2: if (8 * sizeof(npy_int8) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) >= 2 * PyLong_SHIFT) { return (npy_int8) (((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); } } break; case 3: if (8 * sizeof(npy_int8) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) >= 3 * PyLong_SHIFT) { return (npy_int8) (((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); } } break; case 4: if (8 * sizeof(npy_int8) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) >= 4 * PyLong_SHIFT) { return (npy_int8) (((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (npy_int8) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(npy_int8) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int8, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int8) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int8, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int8) 0; case -1: __PYX_VERIFY_RETURN_INT(npy_int8, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(npy_int8, digit, +digits[0]) case -2: if (8 * sizeof(npy_int8) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT) { return (npy_int8) (((npy_int8)-1)*(((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; case 2: if (8 * sizeof(npy_int8) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT) { return (npy_int8) ((((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; case -3: if (8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT) { return (npy_int8) (((npy_int8)-1)*(((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; case 3: if (8 * sizeof(npy_int8) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT) { return (npy_int8) ((((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; case -4: if (8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 4 * PyLong_SHIFT) { return (npy_int8) (((npy_int8)-1)*(((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; case 4: if (8 * sizeof(npy_int8) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int8) - 1 > 4 * PyLong_SHIFT) { return (npy_int8) ((((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); } } break; } #endif if (sizeof(npy_int8) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int8, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int8) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int8, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else npy_int8 val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (npy_int8) -1; } } else { npy_int8 val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (npy_int8) -1; val = __Pyx_PyInt_As_npy_int8(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to npy_int8"); return (npy_int8) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to npy_int8"); return (npy_int8) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/alignment/_ssw_wrapper.pyx000066400000000000000000000615441446255456000221510ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ----------------------------------------------------------------------------- from cpython cimport bool import numpy as np cimport numpy as cnp from skbio.sequence import Protein, Sequence cdef extern from "_lib/ssw.h": ctypedef struct s_align: cnp.uint16_t score1 cnp.uint16_t score2 cnp.int32_t ref_begin1 cnp.int32_t ref_end1 cnp.int32_t read_begin1 cnp.int32_t read_end1 cnp.int32_t ref_end2 cnp.uint32_t* cigar cnp.int32_t cigarLen ctypedef struct s_profile: pass cdef s_profile* ssw_init(const cnp.int8_t* read, const cnp.int32_t readLen, const cnp.int8_t* mat, const cnp.int32_t n, const cnp.int8_t score_size) cdef void init_destroy(s_profile* p) cdef s_align* ssw_align(const s_profile* prof, const cnp.int8_t* ref, cnp.int32_t refLen, const cnp.uint8_t weight_gapO, const cnp.uint8_t weight_gapE, const cnp.uint8_t flag, const cnp.uint16_t filters, const cnp.int32_t filterd, const cnp.int32_t maskLen) cdef void align_destroy(s_align* a) np_aa_table = np.array([ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 20, 4, 3, 6, 13, 7, 8, 9, 23, 11, 10, 12, 2, 23, 14, 5, 1, 15, 16, 23, 19, 17, 22, 18, 21, 23, 23, 23, 23, 23, 23, 0, 20, 4, 3, 6, 13, 7, 8, 9, 23, 11, 10, 12, 2, 23, 14, 5, 1, 15, 16, 23, 19, 17, 22, 18, 21, 23, 23, 23, 23, 23]) np_nt_table = np.array([ 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, 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, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 1, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 1, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]) mid_table = np.array(['M', 'I', 'D']) cdef class AlignmentStructure: """Wraps the result of an alignment c struct so it is accessible to Python Notes ----- `cigar` may be empty depending on parameters used. `target_begin` and `query_begin` may be -1 depending on parameters used. Developer note: `read_sequence` is an alias for `query_sequence` used by ssw.c as is `reference_sequence` for `target_sequence` """ cdef s_align *p cdef str read_sequence cdef str reference_sequence cdef int index_starts_at cdef str _cigar_string def __cinit__(self, read_sequence, reference_sequence, index_starts_at): # We use `read_sequence` and `reference_sequence` here as they are # treated sematically as a private output of ssw.c like the `s_align` # struct self.read_sequence = read_sequence self.reference_sequence = reference_sequence self.index_starts_at = index_starts_at cdef __constructor(self, s_align* pointer): self.p = pointer def __dealloc__(self): if self.p is not NULL: align_destroy(self.p) def __getitem__(self, key): return getattr(self, key) def __repr__(self): data = ['optimal_alignment_score', 'suboptimal_alignment_score', 'query_begin', 'query_end', 'target_begin', 'target_end_optimal', 'target_end_suboptimal', 'cigar', 'query_sequence', 'target_sequence'] return "{\n%s\n}" % ',\n'.join([ " {!r}: {!r}".format(k, self[k]) for k in data]) def __str__(self): score = "Score: %d" % self.optimal_alignment_score if self.query_sequence and self.cigar: target = self.aligned_target_sequence query = self.aligned_query_sequence align_len = len(query) if align_len > 13: target = target[:10] + "..." query = query[:10] + "..." length = "Length: %d" % align_len return "\n".join([query, target, score, length]) return score @property def optimal_alignment_score(self): """Optimal alignment score Returns ------- int The optimal alignment score """ return self.p.score1 @property def suboptimal_alignment_score(self): """Suboptimal alignment score Returns ------- int The suboptimal alignment score """ return self.p.score2 @property def target_begin(self): """Character index where the target's alignment begins Returns ------- int The character index of the target sequence's alignment's beginning Notes ----- The result is a 0-based index by default """ return self.p.ref_begin1 + self.index_starts_at if (self.p.ref_begin1 >= 0) else -1 @property def target_end_optimal(self): """Character index where the target's optimal alignment ends Returns ------- int The character index of the target sequence's optimal alignment's end Notes ----- The result is a 0-based index by default """ return self.p.ref_end1 + self.index_starts_at @property def target_end_suboptimal(self): """Character index where the target's suboptimal alignment ends Returns ------- int The character index of the target sequence's suboptimal alignment's end Notes ----- The result is a 0-based index by default """ return self.p.ref_end2 + self.index_starts_at @property def query_begin(self): """Returns the character index at which the query sequence begins Returns ------- int The character index of the query sequence beginning Notes ----- The result is a 0-based index by default """ return self.p.read_begin1 + self.index_starts_at if (self.p.read_begin1 >= 0) else -1 @property def query_end(self): """Character index at where query sequence ends Returns ------- int The character index of the query sequence ending Notes ----- The result is a 0-based index by default """ return self.p.read_end1 + self.index_starts_at @property def cigar(self): """Cigar formatted string for the optimal alignment Returns ------- str The cigar string of the optimal alignment Notes ----- The cigar string format is described in [1]_ and [2]_. If there is no cigar or optimal alignment, this will return an empty string References ---------- .. [1] http://genome.sph.umich.edu/wiki/SAM .. [2] http://samtools.github.io/hts-specs/SAMv1.pdf """ # Memoization! (1/2) if self._cigar_string is not None: return self._cigar_string cigar_list = [] for i in range(self.p.cigarLen): # stored the same as that in BAM format, # high 28 bits: length, low 4 bits: M/I/D (0/1/2) # Length, remove first 4 bits cigar_list.append(str(self.p.cigar[i] >> 4)) # M/I/D, lookup first 4 bits in the mid_table cigar_list.append(mid_table[self.p.cigar[i] & 0xf]) # Memoization! (2/2) self._cigar_string = "".join(cigar_list) return self._cigar_string @property def query_sequence(self): """Query sequence Returns ------- str The query sequence """ return self.read_sequence @property def target_sequence(self): """Target sequence Returns ------- str The target sequence """ return self.reference_sequence @property def aligned_query_sequence(self): """Returns the query sequence aligned by the cigar Returns ------- str Aligned query sequence Notes ----- This will return `None` if `suppress_sequences` was True when this object was created """ if self.query_sequence: return self._get_aligned_sequence(self.query_sequence, self._tuples_from_cigar(), self.query_begin, self.query_end, "D") return None @property def aligned_target_sequence(self): """Returns the target sequence aligned by the cigar Returns ------- str Aligned target sequence Notes ----- This will return `None` if `suppress_sequences` was True when this object was created """ if self.target_sequence: return self._get_aligned_sequence(self.target_sequence, self._tuples_from_cigar(), self.target_begin, self.target_end_optimal, "I") return None def set_zero_based(self, is_zero_based): """Set the aligment indices to start at 0 if True else 1 if False """ if is_zero_based: self.index_starts_at = 0 else: self.index_starts_at = 1 def is_zero_based(self): """Returns True if alignment inidices start at 0 else False Returns ------- bool Whether the alignment inidices start at 0 """ return self.index_starts_at == 0 def _get_aligned_sequence(self, sequence, tuple_cigar, begin, end, gap_type): # Save the original index scheme and then set it to 0 (1/2) orig_z_base = self.is_zero_based() self.set_zero_based(True) aligned_sequence = [] seq = sequence[begin:end + 1] index = 0 for length, mid in tuple_cigar: if mid == gap_type: aligned_sequence += ['-' * length] else: aligned_sequence += [seq[index:index + length]] index += length # Our sequence end is sometimes beyond the cigar: aligned_sequence += [seq[index:end - begin + 1]] # Revert our index scheme to the original (2/2) self.set_zero_based(orig_z_base) return "".join(aligned_sequence) def _tuples_from_cigar(self): tuples = [] length_stack = [] for character in self.cigar: if character.isdigit(): length_stack.append(character) else: tuples.append((int("".join(length_stack)), character)) length_stack = [] return tuples cdef class StripedSmithWaterman: """Performs a striped (banded) Smith Waterman Alignment. First a StripedSmithWaterman object must be instantiated with a query sequence. The resulting object is then callable with a target sequence and may be reused on a large collection of target sequences. Parameters ---------- query_sequence : string The query sequence, this may be upper or lowercase from the set of {A, C, G, T, N} (nucleotide) or from the set of {A, R, N, D, C, Q, E, G, H, I, L, K, M, F, P, S, T, W, Y, V, B, Z, X, * } (protein) gap_open_penalty : int, optional The penalty applied to creating a gap in the alignment. This CANNOT be 0. Default is 5. gap_extend_penalty : int, optional The penalty applied to extending a gap in the alignment. This CANNOT be 0. Default is 2. score_size : int, optional If your estimated best alignment score is < 255 this should be 0. If your estimated best alignment score is >= 255, this should be 1. If you don't know, this should be 2. Default is 2. mask_length : int, optional The distance between the optimal and suboptimal alignment ending position >= mask_length. We suggest to use len(query_sequence)/2, if you don't have special concerns. Detailed description of mask_length: After locating the optimal alignment ending position, the suboptimal alignment score can be heuristically found by checking the second largest score in the array that contains the maximal score of each column of the SW matrix. In order to avoid picking the scores that belong to the alignments sharing the partial best alignment, SSW C library masks the reference loci nearby (mask length = mask_length) the best alignment ending position and locates the second largest score from the unmasked elements. Default is 15. mask_auto : bool, optional This will automatically set the used mask length to be max(int(len(`query_sequence`)/2), `mask_length`). Default is True. score_only : bool, optional This will prevent the best alignment beginning positions (BABP) and the cigar from being returned as a result. This overrides any setting on `score_filter`, `distance_filter`, and `override_skip_babp`. It has the highest precedence. Default is False. score_filter : int, optional If set, this will prevent the cigar and best alignment beginning positions (BABP) from being returned if the optimal alignment score is less than `score_filter` saving some time computationally. This filter may be overridden by `score_only` (prevents BABP and cigar, regardless of other arguments), `distance_filter` (may prevent cigar, but will cause BABP to be calculated), and `override_skip_babp` (will ensure BABP) returned. Default is None. distance_filter : int, optional If set, this will prevent the cigar from being returned if the length of the `query_sequence` or the `target_sequence` is less than `distance_filter` saving some time computationally. The results of this filter may be overridden by `score_only` (prevents BABP and cigar, regardless of other arguments), and `score_filter` (may prevent cigar). `override_skip_babp` has no effect with this filter applied, as BABP must be calculated to perform the filter. Default is None. override_skip_babp : bool, optional When True, the best alignment beginning positions (BABP) will always be returned unless `score_only` is set to True. Default is False. protein : bool, optional When True, the `query_sequence` and `target_sequence` will be read as protein sequence. When False, the `query_sequence` and `target_sequence` will be read as nucleotide sequence. If True, a `substitution_matrix` must be supplied. Default is False. match_score : int, optional When using a nucleotide sequence, the match_score is the score added when a match occurs. This is ignored if `substitution_matrix` is provided. Default is 2. mismatch_score : int, optional When using a nucleotide sequence, the mismatch is the score subtracted when a mismatch occurs. This should be a negative integer. This is ignored if `substitution_matrix` is provided. Default is -3. substitution_matrix : 2D dict, optional Provides the score for each possible substitution of sequence characters. This may be used for protein or nucleotide sequences. The entire set of possible combinations for the relevant sequence type MUST be enumerated in the dict of dicts. This will override `match_score` and `mismatch_score`. Required when `protein` is True. Default is None. suppress_sequences : bool, optional If True, the query and target sequences will not be returned for convenience. Default is False. zero_index : bool, optional If True, all inidices will start at 0. If False, all inidices will start at 1. Default is True. Notes ----- This is a wrapper for the SSW package [1]_. `mask_length` has to be >= 15, otherwise the suboptimal alignment information will NOT be returned. `match_score` is a positive integer and `mismatch_score` is a negative integer. `match_score` and `mismatch_score` are only meaningful in the context of nucleotide sequences. A substitution matrix must be provided when working with protein sequences. References ---------- .. [1] Zhao, Mengyao, Wan-Ping Lee, Erik P. Garrison, & Gabor T. Marth. "SSW Library: An SIMD Smith-Waterman C/C++ Library for Applications". PLOS ONE (2013). Web. 11 July 2014. http://www.plosone.org/article/info:doi/10.1371/journal.pone.0082138 """ cdef s_profile *profile cdef cnp.uint8_t gap_open_penalty cdef cnp.uint8_t gap_extend_penalty cdef cnp.uint8_t bit_flag cdef cnp.uint16_t score_filter cdef cnp.int32_t distance_filter cdef cnp.int32_t mask_length cdef str read_sequence cdef int index_starts_at cdef bool is_protein cdef bool suppress_sequences cdef cnp.ndarray __KEEP_IT_IN_SCOPE_read cdef cnp.ndarray __KEEP_IT_IN_SCOPE_matrix def __cinit__(self, query_sequence, gap_open_penalty=5, # BLASTN Default gap_extend_penalty=2, # BLASTN Default score_size=2, # BLASTN Default mask_length=15, # Minimum length for a suboptimal alignment mask_auto=True, score_only=False, score_filter=None, distance_filter=None, override_skip_babp=False, protein=False, match_score=2, # BLASTN Default mismatch_score=-3, # BLASTN Default substitution_matrix=None, suppress_sequences=False, zero_index=True): # initialize our values self.read_sequence = query_sequence if gap_open_penalty <= 0: raise ValueError("`gap_open_penalty` must be > 0") self.gap_open_penalty = gap_open_penalty if gap_extend_penalty <= 0: raise ValueError("`gap_extend_penalty` must be > 0") self.gap_extend_penalty = gap_extend_penalty self.distance_filter = 0 if distance_filter is None else \ distance_filter self.score_filter = 0 if score_filter is None else score_filter self.suppress_sequences = suppress_sequences self.is_protein = protein self.bit_flag = self._get_bit_flag(override_skip_babp, score_only) # http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html # Dijkstra knows what's up: self.index_starts_at = 0 if zero_index else 1 # set up our matrix cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] matrix if substitution_matrix is None: if protein: raise Exception("Must provide a substitution matrix for" " protein sequences") matrix = self._build_match_matrix(match_score, mismatch_score) else: matrix = self._convert_dict2d_to_matrix(substitution_matrix) # Set up our mask_length # Mask is recommended to be max(query_sequence/2, 15) if mask_auto: self.mask_length = len(query_sequence) // 2 if self.mask_length < mask_length: self.mask_length = mask_length else: self.mask_length = mask_length cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] read_seq read_seq = self._seq_converter(query_sequence) cdef cnp.int32_t read_length read_length = len(query_sequence) cdef cnp.int8_t s_size s_size = score_size cdef cnp.int32_t m_width m_width = 24 if self.is_protein else 5 cdef s_profile* p self.profile = ssw_init( read_seq.data, read_length, matrix.data, m_width, s_size) # A hack to keep the python GC from eating our data self.__KEEP_IT_IN_SCOPE_read = read_seq self.__KEEP_IT_IN_SCOPE_matrix = matrix def __call__(self, target_sequence): """Align `target_sequence` to `query_sequence` Parameters ---------- target_sequence : str Returns ------- skbio.alignment.AlignmentStructure The resulting alignment. """ reference_sequence = target_sequence cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] reference reference = self._seq_converter(reference_sequence) cdef cnp.int32_t ref_length ref_length = len(reference_sequence) cdef s_align *align align = ssw_align(self.profile, reference.data, ref_length, self.gap_open_penalty, self.gap_extend_penalty, self.bit_flag, self.score_filter, self.distance_filter, self.mask_length) # Cython won't let me do this correctly, so duplicate code ahoy: if self.suppress_sequences: alignment = AlignmentStructure("", "", self.index_starts_at) else: alignment = AlignmentStructure(self.read_sequence, reference_sequence, self.index_starts_at) alignment.__constructor(align) # Hack to get a pointer through return alignment def __dealloc__(self): if self.profile is not NULL: init_destroy(self.profile) def _get_bit_flag(self, override_skip_babp, score_only): bit_flag = 0 if score_only: return bit_flag if override_skip_babp: bit_flag = bit_flag | 0x8 if self.distance_filter != 0: bit_flag = bit_flag | 0x4 if self.score_filter != 0: bit_flag = bit_flag | 0x2 if bit_flag == 0 or bit_flag == 8: bit_flag = bit_flag | 0x1 return bit_flag cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] _seq_converter( self, sequence): cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] seq seq = np.empty(len(sequence), dtype=np.int8) if self.is_protein: for i, char in enumerate(sequence): seq[i] = np_aa_table[ord(char)] else: for i, char in enumerate(sequence): seq[i] = np_nt_table[ord(char)] return seq cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ _build_match_matrix(self, match_score, mismatch_score): sequence_order = "ACGTN" dict2d = {} for row in sequence_order: dict2d[row] = {} for column in sequence_order: if column == 'N' or row == 'N': dict2d[row][column] = 0 else: dict2d[row][column] = match_score if row == column \ else mismatch_score return self._convert_dict2d_to_matrix(dict2d) cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] \ _convert_dict2d_to_matrix(self, dict2d): if self.is_protein: sequence_order = "ARNDCQEGHILKMFPSTWYVBZX*" else: sequence_order = "ACGTN" cdef int i = 0 length = len(sequence_order) cdef cnp.ndarray[cnp.int8_t, ndim = 1, mode = "c"] py_list_matrix = \ np.empty(length*length, dtype=np.int8) for row in sequence_order: for column in sequence_order: py_list_matrix[i] = dict2d[row][column] i += 1 return py_list_matrix scikit-bio-0.5.9/skbio/alignment/_tabular_msa.py000066400000000000000000002365561446255456000217060ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import collections import copy import numpy as np import pandas as pd import scipy.stats from skbio._base import SkbioObject from skbio.metadata._mixin import MetadataMixin, PositionalMetadataMixin from skbio.sequence import Sequence from skbio.sequence._grammared_sequence import GrammaredSequence from skbio.util._decorator import experimental, classonlymethod, overrides from skbio.util._misc import resolve_key from skbio.alignment._indexing import TabularMSAILoc, TabularMSALoc from skbio.alignment._repr import _TabularMSAReprBuilder _Shape = collections.namedtuple('Shape', ['sequence', 'position']) class TabularMSA(MetadataMixin, PositionalMetadataMixin, SkbioObject): """Store a multiple sequence alignment in tabular (row/column) form. Parameters ---------- sequences : iterable of GrammaredSequence, TabularMSA Aligned sequences in the MSA. Sequences must all be the same type and length. For example, `sequences` could be an iterable of ``DNA``, ``RNA``, or ``Protein`` sequences. If `sequences` is a ``TabularMSA``, its `metadata`, `positional_metadata`, and `index` will be used unless overridden by parameters `metadata`, `positional_metadata`, and `minter`/`index`, respectively. metadata : dict, optional Arbitrary metadata which applies to the entire MSA. A shallow copy of the ``dict`` will be made. positional_metadata : pd.DataFrame consumable, optional Arbitrary metadata which applies to each position in the MSA. Must be able to be passed directly to ``pd.DataFrame`` constructor. Each column of metadata must be the same length as the number of positions in the MSA. A shallow copy of the positional metadata will be made. minter : callable or metadata key, optional If provided, defines an index label for each sequence in `sequences`. Can either be a callable accepting a single argument (each sequence) or a key into each sequence's ``metadata`` attribute. Note that `minter` cannot be combined with `index`. index : pd.Index consumable, optional Index containing labels for `sequences`. Must be the same length as `sequences`. Must be able to be passed directly to ``pd.Index`` constructor. Note that `index` cannot be combined with `minter` and the contents of `index` must be hashable. Raises ------ ValueError If `minter` and `index` are both provided. ValueError If `index` is not the same length as `sequences`. TypeError If `sequences` contains an object that isn't a ``GrammaredSequence``. TypeError If `sequences` does not contain exactly the same type of ``GrammaredSequence`` objects. ValueError If `sequences` does not contain ``GrammaredSequence`` objects of the same length. See Also -------- skbio.sequence.DNA skbio.sequence.RNA skbio.sequence.Protein pandas.DataFrame pandas.Index reassign_index Notes ----- If neither `minter` nor `index` are provided, default index labels will be used: ``pd.RangeIndex(start=0, stop=len(sequences), step=1)``. Examples -------- Create a ``TabularMSA`` object with three DNA sequences and four positions: >>> from skbio import DNA, TabularMSA >>> seqs = [ ... DNA('ACGT'), ... DNA('AG-T'), ... DNA('-C-T') ... ] >>> msa = TabularMSA(seqs) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 4 --------------------- ACGT AG-T -C-T Since `minter` or `index` wasn't provided, the MSA has default index labels: >>> msa.index RangeIndex(start=0, stop=3, step=1) Create an MSA with metadata, positional metadata, and non-default index labels: >>> msa = TabularMSA(seqs, index=['seq1', 'seq2', 'seq3'], ... metadata={'id': 'msa-id'}, ... positional_metadata={'prob': [3, 4, 2, 2]}) >>> msa TabularMSA[DNA] -------------------------- Metadata: 'id': 'msa-id' Positional metadata: 'prob': Stats: sequence count: 3 position count: 4 -------------------------- ACGT AG-T -C-T >>> msa.index Index(['seq1', 'seq2', 'seq3'], dtype='object') """ default_write_format = 'fasta' __hash__ = None @property @experimental(as_of='0.4.1') def dtype(self): """Data type of the stored sequences. Notes ----- This property is not writeable. Examples -------- >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> msa.dtype >>> msa.dtype is DNA True """ return type(self._get_sequence_iloc_(0)) if len(self) > 0 else None @property @experimental(as_of='0.4.1') def shape(self): """Number of sequences (rows) and positions (columns). Notes ----- This property is not writeable. Examples -------- >>> from skbio import DNA, TabularMSA Create a ``TabularMSA`` object with 2 sequences and 3 positions: >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> msa.shape Shape(sequence=2, position=3) >>> msa.shape == (2, 3) True Dimensions can be accessed by index or by name: >>> msa.shape[0] 2 >>> msa.shape.sequence 2 >>> msa.shape[1] 3 >>> msa.shape.position 3 """ sequence_count = len(self) if sequence_count > 0: position_count = len(self._get_sequence_iloc_(0)) else: position_count = 0 return _Shape(sequence=sequence_count, position=position_count) @property @experimental(as_of='0.4.1') def index(self): """Index containing labels along the sequence axis. Returns ------- pd.Index Index containing sequence labels. See Also -------- reassign_index Notes ----- This property can be set and deleted. Deleting the index will reset the index to the ``TabularMSA`` constructor's default. Examples -------- Create a ``TabularMSA`` object with sequences labeled by sequence identifier: >>> from skbio import DNA, TabularMSA >>> seqs = [DNA('ACG', metadata={'id': 'a'}), ... DNA('AC-', metadata={'id': 'b'}), ... DNA('AC-', metadata={'id': 'c'})] >>> msa = TabularMSA(seqs, minter='id') Retrieve index: >>> msa.index Index(['a', 'b', 'c'], dtype='object') Set index: >>> msa.index = ['seq1', 'seq2', 'seq3'] >>> msa.index Index(['seq1', 'seq2', 'seq3'], dtype='object') Deleting the index resets it to the ``TabularMSA`` constructor's default: >>> del msa.index >>> msa.index RangeIndex(start=0, stop=3, step=1) """ return self._seqs.index @index.setter def index(self, index): # Cast to Index to identify tuples as a MultiIndex to match # pandas constructor. Just setting would make an index of tuples. if not isinstance(index, pd.Index): index = pd.Index(index) self._seqs.index = index @index.deleter def index(self): # Create a memory-efficient integer index as the default MSA index. self._seqs.index = pd.RangeIndex(start=0, stop=len(self), step=1) @property @experimental(as_of="0.4.1") def loc(self): """Slice the MSA on first axis by index label, second axis by position. This will return an object with the following interface: .. code-block:: python msa.loc[seq_idx] msa.loc[seq_idx, pos_idx] msa.loc(axis='sequence')[seq_idx] msa.loc(axis='position')[pos_idx] Parameters ---------- seq_idx : label, slice, 1D array_like (bool or label) Slice the first axis of the MSA. When this value is a scalar, a sequence of ``msa.dtype`` will be returned. This may be further sliced by `pos_idx`. pos_idx : (same as seq_idx), optional Slice the second axis of the MSA. When this value is a scalar, a sequence of type :class:`skbio.sequence.Sequence` will be returned. This represents a column of the MSA and may have been additionally sliced by `seq_idx`. axis : {'sequence', 'position', 0, 1, None}, optional Limit the axis to slice on. When set, a tuple as the argument will no longer be split into `seq_idx` and `pos_idx`. Returns ------- TabularMSA, GrammaredSequence, Sequence A ``TabularMSA`` is returned when `seq_idx` and `pos_idx` are non-scalars. A ``GrammaredSequence`` of type ``msa.dtype`` is returned when `seq_idx` is a scalar (this object will match the dtype of the MSA). A ``Sequence`` is returned when `seq_idx` is non-scalar and `pos_idx` is scalar. See Also -------- iloc __getitem__ Notes ----- If the slice operation results in a ``TabularMSA`` without any sequences, the MSA's ``positional_metadata`` will be unset. When the MSA's index is a ``pd.MultiIndex`` a tuple may be given to `seq_idx` to indicate the slicing operations to perform on each component index. Examples -------- First we need to set up an MSA to slice: >>> from skbio import TabularMSA, DNA >>> msa = TabularMSA([DNA("ACGT"), DNA("A-GT"), DNA("AC-T"), ... DNA("ACGA")], index=['a', 'b', 'c', 'd']) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 4 position count: 4 --------------------- ACGT A-GT AC-T ACGA >>> msa.index Index(['a', 'b', 'c', 'd'], dtype='object') When we slice by a scalar we get the original sequence back out of the MSA: >>> msa.loc['b'] DNA -------------------------- Stats: length: 4 has gaps: True has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 A-GT Similarly when we slice the second axis by a scalar we get a column of the MSA: >>> msa.loc[..., 1] Sequence ------------- Stats: length: 4 ------------- 0 C-CC Note: we return an ``skbio.Sequence`` object because the column of an alignment has no biological meaning and many operations defined for the MSA's sequence `dtype` would be meaningless. When we slice both axes by a scalar, operations are applied left to right: >>> msa.loc['a', 0] DNA -------------------------- Stats: length: 1 has gaps: False has degenerates: False has definites: True GC-content: 0.00% -------------------------- 0 A In other words, it exactly matches slicing the resulting sequence object directly: >>> msa.loc['a'][0] DNA -------------------------- Stats: length: 1 has gaps: False has degenerates: False has definites: True GC-content: 0.00% -------------------------- 0 A When our slice is non-scalar we get back an MSA of the same `dtype`: >>> msa.loc[['a', 'c']] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- ACGT AC-T We can similarly slice out a column of that: >>> msa.loc[['a', 'c'], 2] Sequence ------------- Stats: length: 2 ------------- 0 G- Slice syntax works as well: >>> msa.loc[:'c'] TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 4 --------------------- ACGT A-GT AC-T Notice how the end label is included in the results. This is different from how positional slices behave: >>> msa.loc[[True, False, False, True], 2:3] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 1 --------------------- G G Here we sliced the first axis by a boolean vector, but then restricted the columns to a single column. Because the second axis was given a nonscalar we still recieve an MSA even though only one column is present. Duplicate labels can be an unfortunate reality in the real world, however `loc` is capable of handling this: >>> msa.index = ['a', 'a', 'b', 'c'] Notice how the label 'a' happens twice. If we were to access 'a' we get back an MSA with both sequences: >>> msa.loc['a'] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- ACGT A-GT Remember that `iloc` can always be used to differentiate sequences with duplicate labels. More advanced slicing patterns are possible with different index types. Let's use a `pd.MultiIndex`: >>> msa.index = [('a', 0), ('a', 1), ('b', 0), ('b', 1)] Here we will explicitly set the axis that we are slicing by to make things easier to read: >>> msa.loc(axis='sequence')['a', 0] DNA -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True GC-content: 50.00% -------------------------- 0 ACGT This selected the first sequence because the complete label was provided. In other words `('a', 0)` was treated as a scalar for this index. We can also slice along the component indices of the multi-index: >>> msa.loc(axis='sequence')[:, 1] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- A-GT ACGA If we were to do that again without the `axis` argument, it would look like this: >>> msa.loc[(slice(None), 1), ...] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- A-GT ACGA Notice how we needed to specify the second axis. If we had left that out we would have simply gotten the 2nd column back instead. We also lost the syntactic sugar for slice objects. These are a few of the reasons specifying the `axis` preemptively can be useful. """ return self._loc @property @experimental(as_of="0.4.1") def iloc(self): """Slice the MSA on either axis by index position. This will return an object with the following interface: .. code-block:: python msa.iloc[seq_idx] msa.iloc[seq_idx, pos_idx] msa.iloc(axis='sequence')[seq_idx] msa.iloc(axis='position')[pos_idx] Parameters ---------- seq_idx : int, slice, iterable (int and slice), 1D array_like (bool) Slice the first axis of the MSA. When this value is a scalar, a sequence of ``msa.dtype`` will be returned. This may be further sliced by `pos_idx`. pos_idx : (same as seq_idx), optional Slice the second axis of the MSA. When this value is a scalar, a sequence of type :class:`skbio.sequence.Sequence` will be returned. This represents a column of the MSA and may have been additionally sliced by `seq_idx`. axis : {'sequence', 'position', 0, 1, None}, optional Limit the axis to slice on. When set, a tuple as the argument will no longer be split into `seq_idx` and `pos_idx`. Returns ------- TabularMSA, GrammaredSequence, Sequence A ``TabularMSA`` is returned when `seq_idx` and `pos_idx` are non-scalars. A ``GrammaredSequence`` of type ``msa.dtype`` is returned when `seq_idx` is a scalar (this object will match the dtype of the MSA). A ``Sequence`` is returned when `seq_idx` is non-scalar and `pos_idx` is scalar. See Also -------- __getitem__ loc Notes ----- If the slice operation results in a ``TabularMSA`` without any sequences, the MSA's ``positional_metadata`` will be unset. Examples -------- First we need to set up an MSA to slice: >>> from skbio import TabularMSA, DNA >>> msa = TabularMSA([DNA("ACGT"), DNA("A-GT"), DNA("AC-T"), ... DNA("ACGA")]) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 4 position count: 4 --------------------- ACGT A-GT AC-T ACGA When we slice by a scalar we get the original sequence back out of the MSA: >>> msa.iloc[1] DNA -------------------------- Stats: length: 4 has gaps: True has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 A-GT Similarly when we slice the second axis by a scalar we get a column of the MSA: >>> msa.iloc[..., 1] Sequence ------------- Stats: length: 4 ------------- 0 C-CC Note: we return an ``skbio.Sequence`` object because the column of an alignment has no biological meaning and many operations defined for the MSA's sequence `dtype` would be meaningless. When we slice both axes by a scalar, operations are applied left to right: >>> msa.iloc[0, 0] DNA -------------------------- Stats: length: 1 has gaps: False has degenerates: False has definites: True GC-content: 0.00% -------------------------- 0 A In other words, it exactly matches slicing the resulting sequence object directly: >>> msa.iloc[0][0] DNA -------------------------- Stats: length: 1 has gaps: False has degenerates: False has definites: True GC-content: 0.00% -------------------------- 0 A When our slice is non-scalar we get back an MSA of the same `dtype`: >>> msa.iloc[[0, 2]] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- ACGT AC-T We can similarly slice out a column of that: >>> msa.iloc[[0, 2], 2] Sequence ------------- Stats: length: 2 ------------- 0 G- Slice syntax works as well: >>> msa.iloc[:3] TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 4 --------------------- ACGT A-GT AC-T We can also use boolean vectors: >>> msa.iloc[[True, False, False, True], 2:3] TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 1 --------------------- G G Here we sliced the first axis by a boolean vector, but then restricted the columns to a single column. Because the second axis was given a nonscalar we still recieve an MSA even though only one column is present. """ return self._iloc @classonlymethod @experimental(as_of="0.4.1") def from_dict(cls, dictionary): """Create a ``TabularMSA`` from a ``dict``. Parameters ---------- dictionary : dict Dictionary mapping keys to ``GrammaredSequence`` sequence objects. The ``TabularMSA`` object will have its index labels set to the keys in the dictionary. Returns ------- TabularMSA ``TabularMSA`` object constructed from the keys and sequences in `dictionary`. See Also -------- to_dict sort Notes ----- The order of sequences and index labels in the resulting ``TabularMSA`` object is arbitrary. Use ``TabularMSA.sort`` to set a different order. Examples -------- >>> from skbio import DNA, TabularMSA >>> seqs = {'a': DNA('ACGT'), 'b': DNA('A--T')} >>> msa = TabularMSA.from_dict(seqs) >>> msa.shape Shape(sequence=2, position=4) >>> 'a' in msa True >>> 'b' in msa True """ # Python 3 guarantees same order of iteration as long as no # modifications are made to the dictionary between calls: # https://docs.python.org/3/library/stdtypes.html# # dictionary-view-objects return cls(dictionary.values(), index=dictionary.keys()) @experimental(as_of='0.4.1') def __init__(self, sequences, metadata=None, positional_metadata=None, minter=None, index=None): if isinstance(sequences, TabularMSA): if metadata is None and sequences.has_metadata(): metadata = sequences.metadata if (positional_metadata is None and sequences.has_positional_metadata()): positional_metadata = sequences.positional_metadata if minter is None and index is None: index = sequences.index # Give a better error message than the one raised by `extend` (it # references `reset_index`, which isn't a constructor parameter). if minter is not None and index is not None: raise ValueError( "Cannot use both `minter` and `index` at the same time.") self._seqs = pd.Series([], dtype=object) self.extend(sequences, minter=minter, index=index, reset_index=minter is None and index is None) MetadataMixin._init_(self, metadata=metadata) PositionalMetadataMixin._init_( self, positional_metadata=positional_metadata) # Set up our indexers self._loc = TabularMSALoc(self) self._iloc = TabularMSAILoc(self) def _constructor_(self, sequences=NotImplemented, metadata=NotImplemented, positional_metadata=NotImplemented, index=NotImplemented): """Return new copy of the MSA with overridden properties. NotImplemented is used as a sentinel so that None may be used to override values. """ if metadata is NotImplemented: if self.has_metadata(): metadata = self.metadata else: metadata = None if positional_metadata is NotImplemented: if self.has_positional_metadata(): positional_metadata = self.positional_metadata else: positional_metadata = None if index is NotImplemented: if isinstance(sequences, pd.Series): index = sequences.index else: index = self.index if sequences is NotImplemented: sequences = self._seqs sequences = [copy.copy(s) for s in sequences] return self.__class__(sequences, metadata=metadata, positional_metadata=positional_metadata, index=index) @experimental(as_of='0.4.1') def __repr__(self): """String summary of this MSA.""" pep8_line_length_limit = 79 length_taken_by_docstring_indent = 8 width = pep8_line_length_limit - length_taken_by_docstring_indent return _TabularMSAReprBuilder( msa=self, width=width, indent=4).build() def _repr_stats(self): return [("sequence count", str(self.shape.sequence)), ("position count", str(self.shape.position))] @experimental(as_of='0.4.1') def __bool__(self): """Boolean indicating whether the MSA is empty or not. Returns ------- bool ``False`` if there are no sequences, OR if there are no positions (i.e., all sequences are empty). ``True`` otherwise. Examples -------- >>> from skbio import DNA, TabularMSA MSA with sequences and positions: >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> bool(msa) True No sequences: >>> msa = TabularMSA([]) >>> bool(msa) False No positions: >>> msa = TabularMSA([DNA(''), DNA('')]) >>> bool(msa) False """ # It is impossible to have 0 sequences and >0 positions. # TODO: change for #1198 return self.shape.position > 0 @experimental(as_of='0.4.1') def __contains__(self, label): """Determine if an index label is in this MSA. Parameters ---------- label : hashable Label to search for in this MSA. Returns ------- bool Indicates whether `label` is in this MSA. Examples -------- >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')], index=['l1', 'l2']) >>> 'l1' in msa True >>> 'l2' in msa True >>> 'l3' in msa False """ return label in self.index @experimental(as_of='0.4.1') def __len__(self): """Number of sequences in the MSA. Returns ------- int Number of sequences in the MSA (i.e., size of the 1st dimension). Notes ----- This is equivalent to ``msa.shape[0]``. Examples -------- >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> len(msa) 2 >>> msa = TabularMSA([]) >>> len(msa) 0 """ return len(self._seqs) @experimental(as_of='0.4.1') def __iter__(self): """Iterate over sequences in the MSA. Yields ------ GrammaredSequence Each sequence in the order they are stored in the MSA. Examples -------- >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> for seq in msa: ... str(seq) 'ACG' 'AC-' """ return iter(self._seqs) @experimental(as_of='0.4.1') def __reversed__(self): """Iterate in reverse order over sequences in the MSA. Yields ------ GrammaredSequence Each sequence in reverse order from how they are stored in the MSA. Examples -------- >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> for seq in reversed(msa): ... str(seq) 'AC-' 'ACG' """ return reversed(self._seqs) @experimental(as_of='0.4.1') def __str__(self): """String summary of this MSA.""" return self.__repr__() @experimental(as_of='0.4.1') def __eq__(self, other): """Determine if this MSA is equal to another. ``TabularMSA`` objects are equal if their sequences, index, metadata, and positional metadata are equal. Parameters ---------- other : TabularMSA MSA to test for equality against. Returns ------- bool Indicates whether this MSA is equal to `other`. Examples -------- >>> from skbio import DNA, RNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> msa == msa True MSAs with different sequence characters are not equal: >>> msa == TabularMSA([DNA('ACG'), DNA('--G')]) False MSAs with different types of sequences (different ``dtype``) are not equal: >>> msa == TabularMSA([RNA('ACG'), RNA('AC-')]) False MSAs with different sequence metadata are not equal: >>> msa == TabularMSA([DNA('ACG', metadata={'id': 'a'}), DNA('AC-')]) False MSAs with different index labels are not equal: >>> msa == TabularMSA([DNA('ACG'), DNA('AC-')], minter=str) False MSAs with different metadata are not equal: >>> msa == TabularMSA([DNA('ACG'), DNA('AC-')], ... metadata={'id': 'msa-id'}) False MSAs with different positional metadata are not equal: >>> msa == TabularMSA([DNA('ACG'), DNA('AC-')], ... positional_metadata={'prob': [3, 2, 1]}) False """ if not isinstance(other, TabularMSA): return False if not MetadataMixin._eq_(self, other): return False if not PositionalMetadataMixin._eq_(self, other): return False return self._seqs.equals(other._seqs) @experimental(as_of='0.4.1') def __ne__(self, other): """Determine if this MSA is not equal to another. ``TabularMSA`` objects are not equal if their sequences, index, metadata, or positional metadata are not equal. Parameters ---------- other : TabularMSA MSA to test for inequality against. Returns ------- bool Indicates whether this MSA is not equal to `other`. See Also -------- __eq__ """ return not (self == other) @experimental(as_of='0.4.1') def __copy__(self): """Return a shallow copy of this MSA. Returns ------- TabularMSA Shallow copy of this MSA. Sequence objects will be shallow-copied. See Also -------- __deepcopy__ Examples -------- >>> import copy >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> msa_copy = copy.copy(msa) >>> msa_copy == msa True >>> msa_copy is msa False """ msa_copy = self._constructor_() msa_copy._metadata = MetadataMixin._copy_(self) msa_copy._positional_metadata = PositionalMetadataMixin._copy_(self) return msa_copy @experimental(as_of='0.4.1') def __deepcopy__(self, memo): """Return a deep copy of this MSA. Returns ------- TabularMSA Deep copy of this MSA. Sequence objects will be deep-copied. See Also -------- __copy__ Examples -------- >>> import copy >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), DNA('AC-')]) >>> msa_copy = copy.deepcopy(msa) >>> msa_copy == msa True >>> msa_copy is msa False """ seqs = (copy.deepcopy(seq, memo) for seq in self._seqs) msa_copy = self._constructor_(sequences=seqs) msa_copy._metadata = MetadataMixin._deepcopy_(self, memo) msa_copy._positional_metadata = \ PositionalMetadataMixin._deepcopy_(self, memo) return msa_copy @experimental(as_of="0.4.1") def __getitem__(self, indexable): """Slice the MSA on either axis. This is a pass-through for :func:`skbio.alignment.TabularMSA.iloc`. Please refer to the associated documentation. See Also -------- iloc loc Notes ----- Axis restriction is not possible for this method. To slice by labels, use ``loc``. """ return self.iloc[indexable] # Helpers for TabularMSAILoc and TabularMSALoc def _get_sequence_iloc_(self, i): return self._seqs.iloc[i] def _slice_sequences_iloc_(self, i): new_seqs = self._seqs.iloc[i] # TODO: change for #1198 if len(new_seqs) == 0: return self._constructor_(new_seqs, positional_metadata=None) return self._constructor_(new_seqs) def _get_sequence_loc_(self, ids): new_seqs = self._seqs.loc[ids] if type(new_seqs) is self.dtype: return new_seqs else: # Thanks CategoricalIndex, you understand no such thing as a scalar if len(new_seqs) == 1: return new_seqs.iloc[0] else: # This was a common failure mode; shouldn't happen anymore, but # it could strike again. raise AssertionError( "Something went wrong with the index %r provided to" " `_get_sequence_loc_`, please report this stack trace to" "\nhttps://github.com/biocore/scikit-bio/issues" % ids) def _slice_sequences_loc_(self, ids): new_seqs = self._seqs.loc[ids] try: # TODO: change for #1198 if len(new_seqs) == 0: return self._constructor_(new_seqs, positional_metadata=None) return self._constructor_(new_seqs) except TypeError: # NaN hit the constructor, key was bad... probably raise KeyError("Part of `%r` was not in the index." % ids) def _get_position_(self, i, ignore_metadata=False): if ignore_metadata: return Sequence(''.join([str(s[i]) for s in self._seqs])) seq = Sequence.concat([s[i] for s in self._seqs], how='outer') # TODO: change for #1198 if len(self) and self.has_positional_metadata(): seq.metadata = dict(self.positional_metadata.iloc[i]) return seq def _slice_positions_(self, i): seqs = self._seqs.apply(lambda seq: seq[i]) # TODO: change for #1198 pm = None if len(self) and self.has_positional_metadata(): pm = self.positional_metadata.iloc[i] return self._constructor_(seqs, positional_metadata=pm) # end of helpers @experimental(as_of='0.4.1') def iter_positions(self, reverse=False, ignore_metadata=False): """Iterate over positions (columns) in the MSA. Parameters ---------- reverse : bool, optional If ``True``, iterate over positions in reverse order. ignore_metadata : bool, optional If ``True``, ``Sequence.metadata`` and ``Sequence.positional_metadata`` will not be included. This can significantly improve performance if metadata is not needed. Yields ------ Sequence Each position in the order they are stored in the MSA. See Also -------- __iter__ __reversed__ skbio.sequence.Sequence.concat Notes ----- Each position will be yielded as *exactly* a ``Sequence`` object, regardless of this MSA's ``dtype``. ``Sequence`` is used because a position is an artifact of multiple sequence alignment and is not a real biological sequence. Each ``Sequence`` object will have its corresponding MSA positional metadata stored as ``metadata`` unless ``ignore_metadata`` is set to ``True``. Sequences will have their positional metadata concatenated using an outer join unless ``ignore_metadata`` is set to ``True``. See ``Sequence.concat(how='outer')`` for details. Examples -------- Create an MSA with positional metadata: >>> from skbio import DNA, TabularMSA >>> sequences = [DNA('ACG'), ... DNA('A-T')] >>> msa = TabularMSA(sequences, ... positional_metadata={'prob': [3, 1, 2]}) Iterate over positions: >>> for position in msa.iter_positions(): ... position ... print() Sequence ------------- Metadata: 'prob': 3 Stats: length: 2 ------------- 0 AA Sequence ------------- Metadata: 'prob': 1 Stats: length: 2 ------------- 0 C- Sequence ------------- Metadata: 'prob': 2 Stats: length: 2 ------------- 0 GT Note that MSA positional metadata is stored as ``metadata`` on each ``Sequence`` object. Iterate over positions in reverse order: >>> for position in msa.iter_positions(reverse=True): ... position ... print('') Sequence ------------- Metadata: 'prob': 2 Stats: length: 2 ------------- 0 GT Sequence ------------- Metadata: 'prob': 1 Stats: length: 2 ------------- 0 C- Sequence ------------- Metadata: 'prob': 3 Stats: length: 2 ------------- 0 AA """ indices = range(self.shape.position) if reverse: indices = reversed(indices) return (self._get_position_(index, ignore_metadata=ignore_metadata) for index in indices) @experimental(as_of='0.4.1') def consensus(self): """Compute the majority consensus sequence for this MSA. The majority consensus sequence contains the most common character at each position in this MSA. Ties will be broken in an arbitrary manner. Returns ------- Sequence The majority consensus sequence for this MSA. The type of sequence returned will be the same as this MSA's ``dtype`` or ``Sequence`` if this MSA does not contain any sequences. The majority consensus sequence will have its positional metadata set to this MSA's positional metadata if present. Notes ----- The majority consensus sequence will use this MSA's default gap character (``dtype.default_gap_char``) to represent gap majority at a position, regardless of the gap characters present at that position. Different gap characters at a position are **not** treated as distinct characters. All gap characters at a position contribute to that position's gap consensus. Examples -------- >>> from skbio import DNA, TabularMSA >>> sequences = [DNA('AC---'), ... DNA('AT-C.'), ... DNA('TT-CG')] >>> msa = TabularMSA(sequences, ... positional_metadata={'prob': [2, 1, 2, 3, 5]}) >>> msa.consensus() DNA -------------------------- Positional metadata: 'prob': Stats: length: 5 has gaps: True has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 AT-C- Note that the last position in the MSA has more than one type of gap character. These are not treated as distinct characters; both types of gap characters contribute to the position's consensus. Also note that ``DNA.default_gap_char`` is used to represent gap majority at a position (``'-'``). """ dtype = self.dtype if dtype is None: dtype = Sequence positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata consensus = [] for position in self.iter_positions(ignore_metadata=True): freqs = position.frequencies() gap_freq = 0 for gap_char in dtype.gap_chars: if gap_char in freqs: gap_freq += freqs.pop(gap_char) assert dtype.default_gap_char not in freqs freqs[dtype.default_gap_char] = gap_freq consensus.append(collections.Counter(freqs).most_common(1)[0][0]) return dtype(''.join(consensus), positional_metadata=positional_metadata) def _build_inverse_shannon_uncertainty_f(self, include_gaps): base = len(self.dtype.definite_chars) if include_gaps: # Increment the base by one to reflect the possible inclusion of # the default gap character. base += 1 def f(p): freqs = list(p.frequencies().values()) return 1. - scipy.stats.entropy(freqs, base=base) return f @experimental(as_of='0.4.1') def conservation(self, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='nan'): """Apply metric to compute conservation for all alignment positions Parameters ---------- metric : {'inverse_shannon_uncertainty'}, optional Metric that should be applied for computing conservation. Resulting values should be larger when a position is more conserved. degenerate_mode : {'nan', 'error'}, optional Mode for handling positions with degenerate characters. If ``"nan"``, positions with degenerate characters will be assigned a conservation score of ``np.nan``. If ``"error"``, an error will be raised if one or more degenerate characters are present. gap_mode : {'nan', 'ignore', 'error', 'include'}, optional Mode for handling positions with gap characters. If ``"nan"``, positions with gaps will be assigned a conservation score of ``np.nan``. If ``"ignore"``, positions with gaps will be filtered to remove gaps before ``metric`` is applied. If ``"error"``, an error will be raised if one or more gap characters are present. If ``"include"``, conservation will be computed on alignment positions with gaps included. In this case, it is up to the metric to ensure that gaps are handled as they should be or to raise an error if gaps are not supported by that metric. Returns ------- np.array of floats Values resulting from the application of ``metric`` to each position in the alignment. Raises ------ ValueError If an unknown ``metric``, ``degenerate_mode`` or ``gap_mode`` is provided. ValueError If any degenerate characters are present in the alignment when ``degenerate_mode`` is ``"error"``. ValueError If any gaps are present in the alignment when ``gap_mode`` is ``"error"``. Notes ----- Users should be careful interpreting results when ``gap_mode = "include"`` as the results may be misleading. For example, as pointed out in [1]_, a protein alignment position composed of 90% gaps and 10% tryptophans would score as more highly conserved than a position composed of alanine and glycine in equal frequencies with the ``"inverse_shannon_uncertainty"`` metric. ``gap_mode = "include"`` will result in all gap characters being recoded to ``TabularMSA.dtype.default_gap_char``. Because no conservation metrics that we are aware of consider different gap characters differently (e.g., none of the metrics described in [1]_), they are all treated the same within this method. The ``inverse_shannon_uncertainty`` metric is simply one minus Shannon's uncertainty metric. This method uses the inverse of Shannon's uncertainty so that larger values imply higher conservation. Shannon's uncertainty is also referred to as Shannon's entropy, but when making computations from symbols, as is done here, "uncertainty" is the preferred term ([2]_). References ---------- .. [1] Valdar WS. Scoring residue conservation. Proteins. (2002) .. [2] Schneider T. Pitfalls in information theory (website, ca. 2015). https://schneider.ncifcrf.gov/glossary.html#Shannon_entropy """ if gap_mode not in {'nan', 'error', 'include', 'ignore'}: raise ValueError("Unknown gap_mode provided: %s" % gap_mode) if degenerate_mode not in {'nan', 'error'}: raise ValueError("Unknown degenerate_mode provided: %s" % degenerate_mode) if metric not in {'inverse_shannon_uncertainty'}: raise ValueError("Unknown metric provided: %s" % metric) if self.shape[0] == 0: # handle empty alignment to avoid error on lookup of character sets return np.array([]) # Since the only currently allowed metric is # inverse_shannon_uncertainty, and we already know that a valid metric # was provided, we just define metric_f here. When additional metrics # are supported, this will be handled differently (e.g., via a lookup # or if/elif/else). metric_f = self._build_inverse_shannon_uncertainty_f( gap_mode == 'include') result = [] for p in self.iter_positions(ignore_metadata=True): cons = None # cast p to self.dtype for access to gap/degenerate related # functionality pos_seq = self.dtype(p) # handle degenerate characters if present if pos_seq.has_degenerates(): if degenerate_mode == 'nan': cons = np.nan else: # degenerate_mode == 'error' is the only choice left degenerate_chars = pos_seq[pos_seq.degenerates()] raise ValueError("Conservation is undefined for positions " "with degenerate characters. The " "following degenerate characters were " "observed: %s." % degenerate_chars) # handle gap characters if present if pos_seq.has_gaps(): if gap_mode == 'nan': cons = np.nan elif gap_mode == 'error': raise ValueError("Gap characters present in alignment.") elif gap_mode == 'ignore': pos_seq = pos_seq.degap() else: # gap_mode == 'include' is the only choice left # Recode all gap characters with pos_seq.default_gap_char. pos_seq = pos_seq.replace(pos_seq.gaps(), pos_seq.default_gap_char) if cons is None: cons = metric_f(pos_seq) result.append(cons) return np.array(result) @experimental(as_of='0.4.1') def gap_frequencies(self, axis='sequence', relative=False): """Compute frequency of gap characters across an axis. Parameters ---------- axis : {'sequence', 'position'}, optional Axis to compute gap character frequencies across. If 'sequence' or 0, frequencies are computed for each position in the MSA. If 'position' or 1, frequencies are computed for each sequence. relative : bool, optional If ``True``, return the relative frequency of gap characters instead of the count. Returns ------- 1D np.ndarray (int or float) Vector of gap character frequencies across the specified axis. Will have ``int`` dtype if ``relative=False`` and ``float`` dtype if ``relative=True``. Raises ------ ValueError If `axis` is invalid. Notes ----- If there are no positions in the MSA, ``axis='position'``, **and** ``relative=True``, the relative frequency of gap characters in each sequence will be ``np.nan``. Examples -------- Compute frequency of gap characters for each position in the MSA (i.e., *across* the sequence axis): >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACG'), ... DNA('A--'), ... DNA('AC.'), ... DNA('AG.')]) >>> msa.gap_frequencies() array([0, 1, 3]) Compute relative frequencies across the same axis: >>> msa.gap_frequencies(relative=True) array([ 0. , 0.25, 0.75]) Compute frequency of gap characters for each sequence (i.e., *across* the position axis): >>> msa.gap_frequencies(axis='position') array([0, 2, 1, 1]) """ if self._is_sequence_axis(axis): seq_iterator = self.iter_positions(ignore_metadata=True) length = self.shape.sequence else: seq_iterator = self length = self.shape.position gap_freqs = [] for seq in seq_iterator: # Not using Sequence.frequencies(relative=relative) because each # gap character's relative frequency is computed separately and # must be summed. This is less precise than summing the absolute # frequencies of gap characters and dividing by the length. Likely # not a big deal for typical gap characters ('-', '.') but can be # problematic as the number of gap characters grows (we aren't # guaranteed to always have two gap characters). See unit tests for # an example. freqs = seq.frequencies(chars=self.dtype.gap_chars) gap_freqs.append(sum(freqs.values())) gap_freqs = np.asarray(gap_freqs, dtype=float if relative else int) if relative: gap_freqs /= length return gap_freqs @experimental(as_of='0.4.1') def reassign_index(self, mapping=None, minter=None): """Reassign index labels to sequences in this MSA. Parameters ---------- mapping : dict or callable, optional Dictionary or callable that maps existing labels to new labels. Any label without a mapping will remain the same. minter : callable or metadata key, optional If provided, defines an index label for each sequence. Can either be a callable accepting a single argument (each sequence) or a key into each sequence's ``metadata`` attribute. Raises ------ ValueError If `mapping` and `minter` are both provided. See Also -------- index Notes ----- If neither `mapping` nor `minter` are provided, index labels will be reset to the ``TabularMSA`` constructor's default. Examples -------- Create a ``TabularMSA`` object with default index labels: >>> from skbio import DNA, TabularMSA >>> seqs = [DNA('ACG', metadata={'id': 'a'}), ... DNA('AC-', metadata={'id': 'b'}), ... DNA('CCG', metadata={'id': 'c'})] >>> msa = TabularMSA(seqs) >>> msa.index RangeIndex(start=0, stop=3, step=1) Assign new index to the MSA using each sequence's ID as a label: >>> msa.reassign_index(minter='id') >>> msa.index Index(['a', 'b', 'c'], dtype='object') Assign default index: >>> msa.reassign_index() >>> msa.index RangeIndex(start=0, stop=3, step=1) Alternatively, a mapping of existing labels to new labels may be passed via `mapping`: >>> msa.reassign_index(mapping={0: 'seq1', 1: 'seq2'}) >>> msa.index Index(['seq1', 'seq2', 2], dtype='object') """ if mapping is not None and minter is not None: raise ValueError( "Cannot use both `mapping` and `minter` at the same time.") if mapping is not None: if isinstance(mapping, dict): self.index = [mapping[label] if label in mapping else label for label in self.index] elif callable(mapping): self.index = [mapping(label) for label in self.index] else: raise TypeError( "`mapping` must be a dict or callable, not type %r" % type(mapping).__name__) elif minter is not None: self.index = [resolve_key(seq, minter) for seq in self._seqs] else: del self.index @experimental(as_of='0.4.1') def append(self, sequence, minter=None, index=None, reset_index=False): """Append a sequence to the MSA without recomputing alignment. Parameters ---------- sequence : GrammaredSequence Sequence to be appended. Must match the dtype of the MSA and the number of positions in the MSA. minter : callable or metadata key, optional Used to create an index label for the sequence being appended. If callable, it generates a label directly. Otherwise it's treated as a key into the sequence metadata. Note that `minter` cannot be combined with `index` nor `reset_index`. index : object, optional Index label to use for the appended sequence. Note that `index` cannot be combined with `minter` nor `reset_index`. reset_index : bool, optional If ``True``, this MSA's index is reset to the ``TabularMSA`` constructor's default after appending. Note that `reset_index` cannot be combined with `minter` nor `index`. Raises ------ ValueError If exactly one choice of `minter`, `index`, or `reset_index` is not provided. TypeError If the sequence object isn't a ``GrammaredSequence``. TypeError If the type of the sequence does not match the dtype of the MSA. ValueError If the length of the sequence does not match the number of positions in the MSA. See Also -------- extend reassign_index Notes ----- The MSA is not automatically re-aligned when a sequence is appended. Therefore, this operation is not necessarily meaningful on its own. Examples -------- Create an MSA with a single sequence labeled ``'seq1'``: >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACGT')], index=['seq1']) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 1 position count: 4 --------------------- ACGT >>> msa.index Index(['seq1'], dtype='object') Append a new sequence to the MSA, providing its index label via `index`: >>> msa.append(DNA('AG-T'), index='seq2') >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 4 --------------------- ACGT AG-T >>> msa.index Index(['seq1', 'seq2'], dtype='object') Append another sequence, this time resetting the MSA's index labels to the default with `reset_index`. Note that since the MSA's index is reset, we do not need to provide an index label for the new sequence via `index` or `minter`: >>> msa.append(DNA('ACGA'), reset_index=True) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 4 --------------------- ACGT AG-T ACGA >>> msa.index RangeIndex(start=0, stop=3, step=1) """ if index is not None: index = [index] self.extend([sequence], minter=minter, index=index, reset_index=reset_index) @experimental(as_of='0.4.1') def extend(self, sequences, minter=None, index=None, reset_index=False): """Extend this MSA with sequences without recomputing alignment. Parameters ---------- sequences : iterable of GrammaredSequence Sequences to be appended. Must match the dtype of the MSA and the number of positions in the MSA. minter : callable or metadata key, optional Used to create index labels for the sequences being appended. If callable, it generates a label directly. Otherwise it's treated as a key into the sequence metadata. Note that `minter` cannot be combined with `index` nor `reset_index`. index : pd.Index consumable, optional Index labels to use for the appended sequences. Must be the same length as `sequences`. Must be able to be passed directly to ``pd.Index`` constructor. Note that `index` cannot be combined with `minter` nor `reset_index`. reset_index : bool, optional If ``True``, this MSA's index is reset to the ``TabularMSA`` constructor's default after extending. Note that `reset_index` cannot be combined with `minter` nor `index`. Raises ------ ValueError If exactly one choice of `minter`, `index`, or `reset_index` is not provided. ValueError If `index` is not the same length as `sequences`. TypeError If `sequences` contains an object that isn't a ``GrammaredSequence``. TypeError If `sequences` contains a type that does not match the dtype of the MSA. ValueError If the length of a sequence does not match the number of positions in the MSA. See Also -------- append reassign_index Notes ----- The MSA is not automatically re-aligned when appending sequences. Therefore, this operation is not necessarily meaningful on its own. Examples -------- Create an MSA with a single sequence labeled ``'seq1'``: >>> from skbio import DNA, TabularMSA >>> msa = TabularMSA([DNA('ACGT')], index=['seq1']) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 1 position count: 4 --------------------- ACGT >>> msa.index Index(['seq1'], dtype='object') Extend the MSA with sequences, providing their index labels via `index`: >>> msa.extend([DNA('AG-T'), DNA('-G-T')], index=['seq2', 'seq3']) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 4 --------------------- ACGT AG-T -G-T >>> msa.index Index(['seq1', 'seq2', 'seq3'], dtype='object') Extend with more sequences, this time resetting the MSA's index labels to the default with `reset_index`. Note that since the MSA's index is reset, we do not need to provide index labels for the new sequences via `index` or `minter`: >>> msa.extend([DNA('ACGA'), DNA('AC-T'), DNA('----')], ... reset_index=True) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 6 position count: 4 --------------------- ACGT AG-T ... AC-T ---- >>> msa.index RangeIndex(start=0, stop=6, step=1) """ if sum([minter is not None, index is not None, bool(reset_index)]) != 1: raise ValueError( "Must provide exactly one of the following parameters: " "`minter`, `index`, `reset_index`") # Verify `sequences` first because `minter` could interact with each # sequence's `metadata`. sequences = list(sequences) self._assert_valid_sequences(sequences) if minter is not None: # Convert to Index to identify tuples as a MultiIndex instead of an # index of tuples. index = pd.Index([resolve_key(seq, minter) for seq in sequences]) elif index is not None: # Convert to Index to identify tuples as a MultiIndex instead of an # index of tuples. if not isinstance(index, pd.Index): index = pd.Index(index) # pandas doesn't give a user-friendly error message if we pass # through. if len(sequences) != len(index): raise ValueError( "Number of sequences (%d) must match index length (%d)" % (len(sequences), len(index))) else: # Case for `reset_index=True`. We could simply set `index=None` # since it will be reset after appending below, but we can avoid a # memory spike if Series.append creates a new RangeIndex from # adjacent RangeIndexes in the future (pandas 0.18.0 creates an # Int64Index). index = pd.RangeIndex(start=len(self), stop=len(self) + len(sequences), step=1) if len(self): self._seqs = pd.concat([self._seqs, pd.Series(sequences, index=index, dtype=object)]) else: # Not using Series.append to avoid turning a RangeIndex supplied # via `index` parameter into an Int64Index (this happens in pandas # 0.18.0). self._seqs = pd.Series(sequences, index=index, dtype=object) # When extending a TabularMSA without sequences, the number of # positions in the TabularMSA may change from zero to non-zero. If # this happens, the TabularMSA's positional_metadata must be reset # to its default "empty" representation for the new number of # positions, otherwise the number of positions in the TabularMSA # and positional_metadata will differ. # # TODO: change for #1198 if self.shape.position > 0: del self.positional_metadata if reset_index: self.reassign_index() def _assert_valid_sequences(self, sequences): if not sequences: return if len(self): expected_dtype = self.dtype expected_length = self.shape.position else: sequence = sequences[0] expected_dtype = type(sequence) if not issubclass(expected_dtype, GrammaredSequence): raise TypeError( "Each sequence must be of type %r, not type %r" % (GrammaredSequence.__name__, expected_dtype.__name__)) expected_length = len(sequence) for sequence in sequences: dtype = type(sequence) if dtype is not expected_dtype: raise TypeError( "Sequences in MSA must have matching type. Type %r does " "not match type %r" % (dtype.__name__, expected_dtype.__name__)) length = len(sequence) if length != expected_length: raise ValueError( "Each sequence's length must match the number of " "positions in the MSA: %d != %d" % (length, expected_length)) def join(self, other, how='strict'): """Join this MSA with another by sequence (horizontally). Sequences will be joined by index labels. MSA ``positional_metadata`` will be joined by columns. Use `how` to control join behavior. Alignment is **not** recomputed during join operation (see *Notes* section for details). Parameters ---------- other : TabularMSA MSA to join with. Must have same ``dtype`` as this MSA. how : {'strict', 'inner', 'outer', 'left', 'right'}, optional How to join the sequences and MSA `positional_metadata`: * ``'strict'``: MSA indexes and `positional_metadata` columns must match * ``'inner'``: an inner-join of the MSA indexes and ``positional_metadata`` columns (only the shared set of index labels and columns are used) * ``'outer'``: an outer-join of the MSA indexes and ``positional_metadata`` columns (all index labels and columns are used). Unshared sequences will be padded with the MSA's default gap character (``TabularMSA.dtype.default_gap_char``). Unshared columns will be padded with NaN. * ``'left'``: a left-outer-join of the MSA indexes and ``positional_metadata`` columns (this MSA's index labels and columns are used). Padding of unshared data is handled the same as ``'outer'``. * ``'right'``: a right-outer-join of the MSA indexes and ``positional_metadata`` columns (`other` index labels and columns are used). Padding of unshared data is handled the same as ``'outer'``. Returns ------- TabularMSA Joined MSA. There is no guaranteed ordering to its index (call ``sort`` to define one). Raises ------ ValueError If `how` is invalid. ValueError If either the index of this MSA or the index of `other` contains duplicates. ValueError If ``how='strict'`` and this MSA's index doesn't match with `other`. ValueError If ``how='strict'`` and this MSA's ``positional_metadata`` columns don't match with `other`. TypeError If `other` is not a subclass of ``TabularMSA``. TypeError If the ``dtype`` of `other` does not match this MSA's ``dtype``. See Also -------- extend sort skbio.sequence.Sequence.concat Notes ----- The join operation does not automatically perform re-alignment; sequences are simply joined together. Therefore, this operation is not necessarily meaningful on its own. The index labels of this MSA must be unique. Likewise, the index labels of `other` must be unique. The MSA-wide and per-sequence metadata (``TabularMSA.metadata`` and ``Sequence.metadata``) are not retained on the joined ``TabularMSA``. The positional metadata of the sequences will be outer-joined, regardless of `how` (using ``Sequence.concat(how='outer')``). If the join operation results in a ``TabularMSA`` without any sequences, the MSA's ``positional_metadata`` will not be set. Examples -------- .. note:: The following examples call `.sort()` on the joined MSA because there isn't a guaranteed ordering to the index. The joined MSA is sorted in these examples to make the output reproducible. When using this method with your own data, sorting the joined MSA is not necessary. Join MSAs by sequence: >>> from skbio import DNA, TabularMSA >>> msa1 = TabularMSA([DNA('AC'), ... DNA('A-')]) >>> msa2 = TabularMSA([DNA('G-T'), ... DNA('T--')]) >>> joined = msa1.join(msa2) >>> joined.sort() # unnecessary in practice, see note above >>> joined TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 5 --------------------- ACG-T A-T-- Sequences are joined based on MSA index labels: >>> msa1 = TabularMSA([DNA('AC'), ... DNA('A-')], index=['a', 'b']) >>> msa2 = TabularMSA([DNA('G-T'), ... DNA('T--')], index=['b', 'a']) >>> joined = msa1.join(msa2) >>> joined.sort() # unnecessary in practice, see note above >>> joined TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 5 --------------------- ACT-- A-G-T >>> joined.index Index(['a', 'b'], dtype='object') By default both MSA indexes must match. Use ``how`` to specify an inner join: >>> msa1 = TabularMSA([DNA('AC'), ... DNA('A-'), ... DNA('-C')], index=['a', 'b', 'c'], ... positional_metadata={'col1': [42, 43], ... 'col2': [1, 2]}) >>> msa2 = TabularMSA([DNA('G-T'), ... DNA('T--'), ... DNA('ACG')], index=['b', 'a', 'z'], ... positional_metadata={'col2': [3, 4, 5], ... 'col3': ['f', 'o', 'o']}) >>> joined = msa1.join(msa2, how='inner') >>> joined.sort() # unnecessary in practice, see note above >>> joined TabularMSA[DNA] -------------------------- Positional metadata: 'col2': Stats: sequence count: 2 position count: 5 -------------------------- ACT-- A-G-T >>> joined.index Index(['a', 'b'], dtype='object') >>> joined.positional_metadata col2 0 1 1 2 2 3 3 4 4 5 When performing an outer join (``'outer'``, ``'left'``, or ``'right'``), unshared sequences are padded with gaps and unshared ``positional_metadata`` columns are padded with NaN: >>> joined = msa1.join(msa2, how='outer') >>> joined.sort() # unnecessary in practice, see note above >>> joined TabularMSA[DNA] ---------------------------- Positional metadata: 'col1': 'col2': 'col3': Stats: sequence count: 4 position count: 5 ---------------------------- ACT-- A-G-T -C--- --ACG >>> joined.index Index(['a', 'b', 'c', 'z'], dtype='object') >>> joined.positional_metadata col1 col2 col3 0 42.0 1 NaN 1 43.0 2 NaN 2 NaN 3 f 3 NaN 4 o 4 NaN 5 o """ if how not in {'strict', 'inner', 'outer', 'left', 'right'}: raise ValueError( "`how` must be 'strict', 'inner', 'outer', 'left', or " "'right'.") self._assert_joinable(other) join_index, concat_kwargs = self._get_join_index(other, how) joined_seqs = [] for label in join_index: left_seq = self._get_sequence_for_join(label) right_seq = other._get_sequence_for_join(label) joined_seqs.append( self.dtype.concat([left_seq, right_seq], how='outer')) # TODO: update when #1198 is implemented. joined_positional_metadata = None if joined_seqs: if how == 'left': joined_positional_metadata = pd.concat( [self.positional_metadata, other.positional_metadata.reindex( columns=self.positional_metadata.columns)], ignore_index=True, sort=True) elif how == 'right': joined_positional_metadata = pd.concat( [self.positional_metadata.reindex( columns=other.positional_metadata.columns), other.positional_metadata], ignore_index=True, sort=True) else: joined_positional_metadata = pd.concat( [self.positional_metadata, other.positional_metadata], ignore_index=True, sort=True, **concat_kwargs) if not self.has_positional_metadata(): del self.positional_metadata if not other.has_positional_metadata(): del other.positional_metadata joined = self.__class__(joined_seqs, index=join_index, positional_metadata=joined_positional_metadata) if not joined.has_positional_metadata(): del joined.positional_metadata return joined def _assert_joinable(self, other): if not isinstance(other, TabularMSA): raise TypeError( "`other` must be a `TabularMSA` object, not type %r" % type(other).__name__) if self.dtype is not other.dtype: raise TypeError( "`other` dtype %r does not match this MSA's dtype %r" % (other.dtype if other.dtype is None else other.dtype.__name__, self.dtype if self.dtype is None else self.dtype.__name__)) if not self.index.is_unique: raise ValueError( "This MSA's index labels must be unique.") if not other.index.is_unique: raise ValueError( "`other`'s index labels must be unique.") def _get_join_index(self, other, how): if how == 'strict': diff = self.index.symmetric_difference(other.index) if len(diff) > 0: raise ValueError( "Index labels must all match with `how='strict'`") diff = self.positional_metadata.columns.symmetric_difference( other.positional_metadata.columns) if not self.has_positional_metadata(): del self.positional_metadata if not other.has_positional_metadata(): del other.positional_metadata if len(diff) > 0: raise ValueError( "Positional metadata columns must all match with " "`how='strict'`") join_index = self.index concat_kwargs = {'join': 'inner'} elif how == 'inner': join_index = self.index.intersection(other.index) concat_kwargs = {'join': 'inner'} elif how == 'outer': join_index = self.index.union(other.index) concat_kwargs = {'join': 'outer'} elif how == 'left': join_index = self.index concat_kwargs = {'join_axes': [self.positional_metadata.columns]} else: # how='right' join_index = other.index concat_kwargs = {'join_axes': [other.positional_metadata.columns]} return join_index, concat_kwargs def _get_sequence_for_join(self, label): if label in self.index: return self.loc[label] else: return self.dtype( self.dtype.default_gap_char * self.shape.position) def sort(self, level=None, ascending=True): """Sort sequences by index label in-place. Parameters ---------- level : int or object, optional Index level to sort on when index is a ``pd.MultiIndex``. Does nothing otherwise. ascending: bool, optional If ``False``, sort in descending (i.e., reverse) order. See Also -------- index reassign_index pandas.Series.sort_index Notes ----- This is a passthrough to ``pd.Series.sort_index`` internally. Examples -------- Create a ``TabularMSA`` object with sequence identifiers as index labels: >>> from skbio import DNA, TabularMSA >>> seqs = [DNA('ACG', metadata={'id': 'c'}), ... DNA('AC-', metadata={'id': 'b'}), ... DNA('AC-', metadata={'id': 'a'})] >>> msa = TabularMSA(seqs, minter='id') >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 3 --------------------- ACG AC- AC- >>> msa.index Index(['c', 'b', 'a'], dtype='object') Sort the sequences in alphabetical order by index label: >>> msa.sort() >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 3 position count: 3 --------------------- AC- AC- ACG >>> msa.index Index(['a', 'b', 'c'], dtype='object') Note that since the sort is in-place, the ``TabularMSA`` object is modified (a new object is *not* returned). """ self._seqs.sort_index(ascending=ascending, level=level, inplace=True) self.positional_metadata.sort_index(axis=1, inplace=True) @experimental(as_of='0.4.1') def to_dict(self): """Create a ``dict`` from this ``TabularMSA``. Returns ------- dict Dictionary constructed from the index labels and sequences in this ``TabularMSA``. Raises ------ ValueError If index labels are not unique. See Also -------- from_dict index reassign_index Examples -------- >>> from skbio import DNA, TabularMSA >>> seqs = [DNA('ACGT'), DNA('A--T')] >>> msa = TabularMSA(seqs, index=['a', 'b']) >>> dictionary = msa.to_dict() >>> dictionary == {'a': DNA('ACGT'), 'b': DNA('A--T')} True """ if self.index.is_unique: return self._seqs.to_dict() else: raise ValueError("Cannot convert to dict. Index labels are not" " unique.") def _is_sequence_axis(self, axis): if axis == 'sequence' or axis == 0: return True elif axis == 'position' or axis == 1: return False else: raise ValueError( "`axis` must be 'sequence' (0) or 'position' (1), not %r" % axis) @overrides(PositionalMetadataMixin) def _positional_metadata_axis_len_(self): return self.shape.position scikit-bio-0.5.9/skbio/alignment/tests/000077500000000000000000000000001446255456000200245ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/alignment/tests/__init__.py000066400000000000000000000005411446255456000221350ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/alignment/tests/test_pairwise.py000066400000000000000000001043571446255456000232720ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import warnings import numpy as np from skbio import Sequence, Protein, DNA, RNA, TabularMSA from skbio.alignment import ( global_pairwise_align_protein, local_pairwise_align_protein, global_pairwise_align_nucleotide, local_pairwise_align_nucleotide, make_identity_substitution_matrix, local_pairwise_align, global_pairwise_align) from skbio.alignment._pairwise import ( _init_matrices_sw, _init_matrices_nw, _compute_score_and_traceback_matrices, _traceback, _first_largest, _compute_substitution_score) from skbio.sequence import GrammaredSequence from skbio.util import classproperty from skbio.util._decorator import overrides class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('^$') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '^' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set('WXYZ') @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {} class PairwiseAlignmentTests(TestCase): """ Note: In the high-level tests, the expected results were derived with assistance from the EMBOSS web server: http://www.ebi.ac.uk/Tools/psa/emboss_needle/ http://www.ebi.ac.uk/Tools/psa/emboss_water/ In some cases, placement of non-gap characters surrounded by gap characters are slighly different between scikit-bio and the EMBOSS server. These differences arise from arbitrary implementation differences, and always result in the same score (which tells us that the alignments are equivalent). In cases where the expected results included here differ from those generated by the EMBOSS server, I note the EMBOSS result as a comment below the expected value. """ def setUp(self): """Ignore warnings during tests.""" warnings.simplefilter("ignore") def tearDown(self): """Clear the list of warning filters, so that no filters are active.""" warnings.resetwarnings() def test_make_identity_substitution_matrix(self): expected = {'A': {'A': 1, 'C': -2, 'G': -2, 'T': -2, 'U': -2}, 'C': {'A': -2, 'C': 1, 'G': -2, 'T': -2, 'U': -2}, 'G': {'A': -2, 'C': -2, 'G': 1, 'T': -2, 'U': -2}, 'T': {'A': -2, 'C': -2, 'G': -2, 'T': 1, 'U': -2}, 'U': {'A': -2, 'C': -2, 'G': -2, 'T': -2, 'U': 1}} self.assertEqual(make_identity_substitution_matrix(1, -2), expected) expected = {'A': {'A': 5, 'C': -4, 'G': -4, 'T': -4, 'U': -4}, 'C': {'A': -4, 'C': 5, 'G': -4, 'T': -4, 'U': -4}, 'G': {'A': -4, 'C': -4, 'G': 5, 'T': -4, 'U': -4}, 'T': {'A': -4, 'C': -4, 'G': -4, 'T': 5, 'U': -4}, 'U': {'A': -4, 'C': -4, 'G': -4, 'T': -4, 'U': 5}} self.assertEqual(make_identity_substitution_matrix(5, -4), expected) # TODO: duplicate of test_global_pairwise_align_custom_alphabet, remove # when nondegenerate_chars is removed def test_global_pairwise_align_custom_alphabet_nondegenerate_chars(self): custom_substitution_matrix = make_identity_substitution_matrix( 1, -1, alphabet=CustomSequence.nondegenerate_chars) custom_msa, custom_score, custom_start_end = global_pairwise_align( CustomSequence("WXYZ"), CustomSequence("WXYYZZ"), 10.0, 5.0, custom_substitution_matrix) # Expected values computed by running an equivalent alignment using the # DNA alphabet with the following mapping: # # W X Y Z # | | | | # A C G T # self.assertEqual(custom_msa, TabularMSA([CustomSequence('WXYZ^^'), CustomSequence('WXYYZZ')])) self.assertEqual(custom_score, 2.0) self.assertEqual(custom_start_end, [(0, 3), (0, 5)]) def test_global_pairwise_align_custom_alphabet(self): custom_substitution_matrix = make_identity_substitution_matrix( 1, -1, alphabet=CustomSequence.definite_chars) custom_msa, custom_score, custom_start_end = global_pairwise_align( CustomSequence("WXYZ"), CustomSequence("WXYYZZ"), 10.0, 5.0, custom_substitution_matrix) # Expected values computed by running an equivalent alignment using the # DNA alphabet with the following mapping: # # W X Y Z # | | | | # A C G T # self.assertEqual(custom_msa, TabularMSA([CustomSequence('WXYZ^^'), CustomSequence('WXYYZZ')])) self.assertEqual(custom_score, 2.0) self.assertEqual(custom_start_end, [(0, 3), (0, 5)]) # TODO: duplicate of test_local_pairwise_align_custom_alphabet, remove # when nondegenerate_chars is removed. def test_local_pairwise_align_custom_alphabet_nondegenerate_chars(self): custom_substitution_matrix = make_identity_substitution_matrix( 5, -4, alphabet=CustomSequence.nondegenerate_chars) custom_msa, custom_score, custom_start_end = local_pairwise_align( CustomSequence("YWXXZZYWXXWYYZWXX"), CustomSequence("YWWXZZZYWXYZWWX"), 5.0, 0.5, custom_substitution_matrix) # Expected values computed by running an equivalent alignment using the # DNA alphabet with the following mapping: # # W X Y Z # | | | | # A C G T # self.assertEqual( custom_msa, TabularMSA([CustomSequence('WXXZZYWXXWYYZWXX'), CustomSequence('WXZZZYWX^^^YZWWX')])) self.assertEqual(custom_score, 41.0) self.assertEqual(custom_start_end, [(1, 16), (2, 14)]) def test_local_pairwise_align_custom_alphabet(self): custom_substitution_matrix = make_identity_substitution_matrix( 5, -4, alphabet=CustomSequence.definite_chars) custom_msa, custom_score, custom_start_end = local_pairwise_align( CustomSequence("YWXXZZYWXXWYYZWXX"), CustomSequence("YWWXZZZYWXYZWWX"), 5.0, 0.5, custom_substitution_matrix) # Expected values computed by running an equivalent alignment using the # DNA alphabet with the following mapping: # # W X Y Z # | | | | # A C G T # self.assertEqual( custom_msa, TabularMSA([CustomSequence('WXXZZYWXXWYYZWXX'), CustomSequence('WXZZZYWX^^^YZWWX')])) self.assertEqual(custom_score, 41.0) self.assertEqual(custom_start_end, [(1, 16), (2, 14)]) def test_global_pairwise_align_invalid_type(self): with self.assertRaisesRegex(TypeError, r"GrammaredSequence.*" "TabularMSA.*'Sequence'"): global_pairwise_align(DNA('ACGT'), Sequence('ACGT'), 1.0, 1.0, {}) def test_global_pairwise_align_dtype_mismatch(self): with self.assertRaisesRegex(TypeError, r"same dtype: 'DNA' != 'RNA'"): global_pairwise_align(DNA('ACGT'), TabularMSA([RNA('ACGU')]), 1.0, 1.0, {}) with self.assertRaisesRegex(TypeError, r"same dtype: 'DNA' != 'RNA'"): global_pairwise_align(TabularMSA([DNA('ACGT')]), TabularMSA([RNA('ACGU')]), 1.0, 1.0, {}) def test_global_pairwise_align_protein(self): obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( Protein("HEAGAWGHEE"), Protein("PAWHEAE"), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual(obs_msa, TabularMSA([Protein("HEAGAWGHEE-"), Protein("---PAW-HEAE")])) self.assertEqual(obs_score, 23.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) # EMBOSS result: P---AW-HEAE obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( Protein("HEAGAWGHEE"), Protein("PAWHEAE"), gap_open_penalty=5., gap_extend_penalty=0.5) self.assertEqual(obs_msa, TabularMSA([Protein("HEAGAWGHE-E"), Protein("---PAW-HEAE")])) self.assertEqual(obs_score, 30.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) # Protein sequences with metadata obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( Protein("HEAGAWGHEE", metadata={'id': "s1"}), Protein("PAWHEAE", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual( obs_msa, TabularMSA([Protein("HEAGAWGHEE-", metadata={'id': "s1"}), Protein("---PAW-HEAE", metadata={'id': "s2"})])) self.assertEqual(obs_score, 23.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) # One TabularMSA and one Protein as input obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( TabularMSA([Protein("HEAGAWGHEE", metadata={'id': "s1"})]), Protein("PAWHEAE", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual( obs_msa, TabularMSA([Protein("HEAGAWGHEE-", metadata={'id': "s1"}), Protein("---PAW-HEAE", metadata={'id': "s2"})])) self.assertEqual(obs_score, 23.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) # One single-sequence alignment as input and one double-sequence # alignment as input. Score confirmed manually. obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( TabularMSA([Protein("HEAGAWGHEE", metadata={'id': "s1"}), Protein("HDAGAWGHDE", metadata={'id': "s2"})]), TabularMSA([Protein("PAWHEAE", metadata={'id': "s3"})]), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual( obs_msa, TabularMSA([Protein("HEAGAWGHEE-", metadata={'id': "s1"}), Protein("HDAGAWGHDE-", metadata={'id': "s2"}), Protein("---PAW-HEAE", metadata={'id': "s3"})])) self.assertEqual(obs_score, 21.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) # TypeError on invalid input self.assertRaises(TypeError, global_pairwise_align_protein, 42, Protein("HEAGAWGHEE")) self.assertRaises(TypeError, global_pairwise_align_protein, Protein("HEAGAWGHEE"), 42) def test_global_pairwise_align_protein_invalid_dtype(self): with self.assertRaisesRegex(TypeError, r"TabularMSA with Protein dtype.*dtype " "'DNA'"): global_pairwise_align_protein(TabularMSA([Protein('PAW')]), TabularMSA([DNA('ACGT')])) def test_global_pairwise_align_protein_penalize_terminal_gaps(self): obs_msa, obs_score, obs_start_end = global_pairwise_align_protein( Protein("HEAGAWGHEE"), Protein("PAWHEAE"), gap_open_penalty=10., gap_extend_penalty=5., penalize_terminal_gaps=True) self.assertEqual(obs_msa, TabularMSA([Protein("HEAGAWGHEE"), Protein("---PAWHEAE")])) self.assertEqual(obs_score, 1.0) self.assertEqual(obs_start_end, [(0, 9), (0, 6)]) def test_global_pairwise_align_nucleotide_penalize_terminal_gaps(self): # in these tests one sequence is about 3x the length of the other. # we toggle penalize_terminal_gaps to confirm that it results in # different alignments and alignment scores. seq1 = DNA("ACCGTGGACCGTTAGGATTGGACCCAAGGTTG") seq2 = DNA("T"*25 + "ACCGTGGACCGTAGGATTGGACCAAGGTTA" + "A"*25) obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( seq1, seq2, gap_open_penalty=5., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4, penalize_terminal_gaps=False) self.assertEqual( obs_msa, TabularMSA([DNA("-------------------------ACCGTGGACCGTTAGGA" "TTGGACCCAAGGTTG-------------------------"), DNA("TTTTTTTTTTTTTTTTTTTTTTTTTACCGTGGACCGT-AGGA" "TTGGACC-AAGGTTAAAAAAAAAAAAAAAAAAAAAAAAAA")])) self.assertEqual(obs_score, 131.0) obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( seq1, seq2, gap_open_penalty=5., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4, penalize_terminal_gaps=True) self.assertEqual( obs_msa, TabularMSA([DNA("-------------------------ACCGTGGACCGTTAGGA" "TTGGACCCAAGGTT-------------------------G"), DNA("TTTTTTTTTTTTTTTTTTTTTTTTTACCGTGGACCGT-AGGA" "TTGGACC-AAGGTTAAAAAAAAAAAAAAAAAAAAAAAAAA")])) self.assertEqual(obs_score, 97.0) def test_local_pairwise_align_protein(self): obs_msa, obs_score, obs_start_end = local_pairwise_align_protein( Protein("HEAGAWGHEE"), Protein("PAWHEAE"), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual(obs_msa, TabularMSA([Protein("AWGHE"), Protein("AW-HE")])) self.assertEqual(obs_score, 26.0) self.assertEqual(obs_start_end, [(4, 8), (1, 4)]) obs_msa, obs_score, obs_start_end = local_pairwise_align_protein( Protein("HEAGAWGHEE"), Protein("PAWHEAE"), gap_open_penalty=5., gap_extend_penalty=0.5) self.assertEqual(obs_msa, TabularMSA([Protein("AWGHE-E"), Protein("AW-HEAE")])) self.assertEqual(obs_score, 32.0) self.assertEqual(obs_start_end, [(4, 9), (1, 6)]) # Protein sequences with metadata obs_msa, obs_score, obs_start_end = local_pairwise_align_protein( Protein("HEAGAWGHEE", metadata={'id': "s1"}), Protein("PAWHEAE", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5.) self.assertEqual( obs_msa, TabularMSA([Protein("AWGHE", metadata={'id': "s1"}), Protein("AW-HE", metadata={'id': "s2"})])) self.assertEqual(obs_score, 26.0) self.assertEqual(obs_start_end, [(4, 8), (1, 4)]) # Fails when either input is passed as a TabularMSA self.assertRaises(TypeError, local_pairwise_align_protein, TabularMSA([Protein("HEAGAWGHEE", metadata={'id': "s1"})]), Protein("PAWHEAE", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5.) self.assertRaises(TypeError, local_pairwise_align_protein, Protein("HEAGAWGHEE", metadata={'id': "s1"}), TabularMSA([Protein("PAWHEAE", metadata={'id': "s2"})]), gap_open_penalty=10., gap_extend_penalty=5.) # TypeError on invalid input self.assertRaises(TypeError, local_pairwise_align_protein, 42, Protein("HEAGAWGHEE")) self.assertRaises(TypeError, local_pairwise_align_protein, Protein("HEAGAWGHEE"), 42) def test_global_pairwise_align_nucleotide(self): obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=5., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4) self.assertEqual(obs_msa, TabularMSA([DNA("G-ACCTTGACCAGGTACC"), DNA("GAACTTTGAC---GTAAC")])) self.assertEqual(obs_score, 41.0) self.assertEqual(obs_start_end, [(0, 16), (0, 14)]) obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4) self.assertEqual(obs_msa, TabularMSA([DNA("-GACCTTGACCAGGTACC"), DNA("GAACTTTGAC---GTAAC")])) self.assertEqual(obs_score, 32.0) self.assertEqual(obs_start_end, [(0, 16), (0, 14)]) # DNA sequences with metadata obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC", metadata={'id': "s1"}), DNA("GAACTTTGACGTAAC", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4) self.assertEqual( obs_msa, TabularMSA([DNA("-GACCTTGACCAGGTACC", metadata={'id': "s1"}), DNA("GAACTTTGAC---GTAAC", metadata={'id': "s2"})])) self.assertEqual(obs_score, 32.0) self.assertEqual(obs_start_end, [(0, 16), (0, 14)]) # Align one DNA sequence and one TabularMSA, score computed manually obs_msa, obs_score, obs_start_end = global_pairwise_align_nucleotide( TabularMSA([DNA("GACCTTGACCAGGTACC", metadata={'id': "s1"}), DNA("GACCATGACCAGGTACC", metadata={'id': "s2"})]), DNA("GAACTTTGACGTAAC", metadata={'id': "s3"}), gap_open_penalty=10., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4) self.assertEqual( obs_msa, TabularMSA([DNA("-GACCTTGACCAGGTACC", metadata={'id': "s1"}), DNA("-GACCATGACCAGGTACC", metadata={'id': "s2"}), DNA("GAACTTTGAC---GTAAC", metadata={'id': "s3"})])) self.assertEqual(obs_score, 27.5) self.assertEqual(obs_start_end, [(0, 16), (0, 14)]) # TypeError on invalid input self.assertRaises(TypeError, global_pairwise_align_nucleotide, 42, DNA("ACGT")) self.assertRaises(TypeError, global_pairwise_align_nucleotide, DNA("ACGT"), 42) def test_global_pairwise_align_nucleotide_invalid_dtype(self): with self.assertRaisesRegex(TypeError, r"TabularMSA with DNA or RNA dtype.*dtype " "'Protein'"): global_pairwise_align_nucleotide(TabularMSA([DNA('ACGT')]), TabularMSA([Protein('PAW')])) def test_local_pairwise_align_nucleotide(self): obs_msa, obs_score, obs_start_end = local_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=5., gap_extend_penalty=0.5, match_score=5, mismatch_score=-4) self.assertEqual(obs_msa, TabularMSA([DNA("ACCTTGACCAGGTACC"), DNA("ACTTTGAC---GTAAC")])) self.assertEqual(obs_score, 41.0) self.assertEqual(obs_start_end, [(1, 16), (2, 14)]) obs_msa, obs_score, obs_start_end = local_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) self.assertEqual(obs_msa, TabularMSA([DNA("ACCTTGAC"), DNA("ACTTTGAC")])) self.assertEqual(obs_score, 31.0) self.assertEqual(obs_start_end, [(1, 8), (2, 9)]) # DNA sequences with metadata obs_msa, obs_score, obs_start_end = local_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC", metadata={'id': "s1"}), DNA("GAACTTTGACGTAAC", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) self.assertEqual( obs_msa, TabularMSA([DNA("ACCTTGAC", metadata={'id': "s1"}), DNA("ACTTTGAC", metadata={'id': "s2"})])) self.assertEqual(obs_score, 31.0) self.assertEqual(obs_start_end, [(1, 8), (2, 9)]) # Fails when either input is passed as a TabularMSA self.assertRaises(TypeError, local_pairwise_align_nucleotide, TabularMSA([DNA("GACCTTGACCAGGTACC", metadata={'id': "s1"})]), DNA("GAACTTTGACGTAAC", metadata={'id': "s2"}), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) self.assertRaises(TypeError, local_pairwise_align_nucleotide, DNA("GACCTTGACCAGGTACC", metadata={'id': "s1"}), TabularMSA([DNA("GAACTTTGACGTAAC", metadata={'id': "s2"})]), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) # TypeError on invalid input self.assertRaises(TypeError, local_pairwise_align_nucleotide, 42, DNA("ACGT")) self.assertRaises(TypeError, local_pairwise_align_nucleotide, DNA("ACGT"), 42) def test_nucleotide_aligners_use_substitution_matrices(self): alt_sub = make_identity_substitution_matrix(10, -10) # alternate substitution matrix yields different alignment (the # aligned sequences and the scores are different) with local alignment msa_no_sub, score_no_sub, start_end_no_sub = \ local_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) msa_alt_sub, score_alt_sub, start_end_alt_sub = \ local_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4, substitution_matrix=alt_sub) self.assertNotEqual(msa_no_sub, msa_alt_sub) self.assertNotEqual(score_no_sub, score_alt_sub) self.assertNotEqual(start_end_no_sub, start_end_alt_sub) # alternate substitution matrix yields different alignment (the # aligned sequences and the scores are different) with global alignment msa_no_sub, score_no_sub, start_end_no_sub = \ global_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4) msa_alt_sub, score_alt_sub, start_end_alt_sub = \ global_pairwise_align_nucleotide( DNA("GACCTTGACCAGGTACC"), DNA("GAACTTTGACGTAAC"), gap_open_penalty=10., gap_extend_penalty=5., match_score=5, mismatch_score=-4, substitution_matrix=alt_sub) self.assertNotEqual(msa_no_sub, msa_alt_sub) self.assertNotEqual(score_no_sub, score_alt_sub) self.assertEqual(start_end_no_sub, start_end_alt_sub) def test_local_pairwise_align_invalid_type(self): with self.assertRaisesRegex(TypeError, r'GrammaredSequence.*Sequence'): local_pairwise_align(DNA('ACGT'), Sequence('ACGT'), 1.0, 1.0, {}) def test_local_pairwise_align_type_mismatch(self): with self.assertRaisesRegex(TypeError, r"same type: 'DNA' != 'RNA'"): local_pairwise_align(DNA('ACGT'), RNA('ACGU'), 1.0, 1.0, {}) def test_init_matrices_sw(self): expected_score_m = np.zeros((5, 4)) expected_tback_m = [[0, 0, 0, 0], [0, -1, -1, -1], [0, -1, -1, -1], [0, -1, -1, -1], [0, -1, -1, -1]] actual_score_m, actual_tback_m = _init_matrices_sw( TabularMSA([DNA('AAA', metadata={'id': 'id'})]), TabularMSA([DNA('AAAA', metadata={'id': 'id'})]), 5, 2) np.testing.assert_array_equal(actual_score_m, expected_score_m) np.testing.assert_array_equal(actual_tback_m, expected_tback_m) def test_init_matrices_nw(self): expected_score_m = [[0, -5, -7, -9], [-5, 0, 0, 0], [-7, 0, 0, 0], [-9, 0, 0, 0], [-11, 0, 0, 0]] expected_tback_m = [[0, 3, 3, 3], [2, -1, -1, -1], [2, -1, -1, -1], [2, -1, -1, -1], [2, -1, -1, -1]] actual_score_m, actual_tback_m = _init_matrices_nw( TabularMSA([DNA('AAA', metadata={'id': 'id'})]), TabularMSA([DNA('AAAA', metadata={'id': 'id'})]), 5, 2) np.testing.assert_array_equal(actual_score_m, expected_score_m) np.testing.assert_array_equal(actual_tback_m, expected_tback_m) def test_compute_substitution_score(self): # these results were computed manually subs_m = make_identity_substitution_matrix(5, -4) gap_chars = set('-.') self.assertEqual( _compute_substitution_score(['A'], ['A'], subs_m, 0, gap_chars), 5.0) self.assertEqual( _compute_substitution_score(['A', 'A'], ['A'], subs_m, 0, gap_chars), 5.0) self.assertEqual( _compute_substitution_score(['A', 'C'], ['A'], subs_m, 0, gap_chars), 0.5) self.assertEqual( _compute_substitution_score(['A', 'C'], ['A', 'C'], subs_m, 0, gap_chars), 0.5) self.assertEqual( _compute_substitution_score(['A', 'A'], ['A', '-'], subs_m, 0, gap_chars), 2.5) self.assertEqual( _compute_substitution_score(['A', 'A'], ['A', '-'], subs_m, 1, gap_chars), 3) # alt subs_m subs_m = make_identity_substitution_matrix(1, -2) self.assertEqual( _compute_substitution_score(['A', 'A'], ['A', '-'], subs_m, 0, gap_chars), 0.5) def test_compute_score_and_traceback_matrices(self): # these results were computed manually expected_score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1], [-9, -5, -1, 6], [-11, -7, -3, 1]] expected_tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1], [2, 2, 2, 2]] m = make_identity_substitution_matrix(2, -1) actual_score_m, actual_tback_m = _compute_score_and_traceback_matrices( TabularMSA([DNA('ACG', metadata={'id': 'id'})]), TabularMSA([DNA('ACGT', metadata={'id': 'id'})]), 5, 2, m) np.testing.assert_array_equal(actual_score_m, expected_score_m) np.testing.assert_array_equal(actual_tback_m, expected_tback_m) # different sequences # these results were computed manually expected_score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1], [-9, -5, -1, 3], [-11, -7, -3, -2]] expected_tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1], [2, 2, 2, 1]] m = make_identity_substitution_matrix(2, -1) actual_score_m, actual_tback_m = _compute_score_and_traceback_matrices( TabularMSA([DNA('ACC', metadata={'id': 'id'})]), TabularMSA([DNA('ACGT', metadata={'id': 'id'})]), 5, 2, m) np.testing.assert_array_equal(actual_score_m, expected_score_m) np.testing.assert_array_equal(actual_tback_m, expected_tback_m) # four sequences provided in two alignments # these results were computed manually expected_score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1], [-9, -5, -1, 3], [-11, -7, -3, -2]] expected_tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1], [2, 2, 2, 1]] m = make_identity_substitution_matrix(2, -1) actual_score_m, actual_tback_m = _compute_score_and_traceback_matrices( TabularMSA([DNA('ACC', metadata={'id': 's1'}), DNA('ACC', metadata={'id': 's2'})]), TabularMSA([DNA('ACGT', metadata={'id': 's3'}), DNA('ACGT', metadata={'id': 's4'})]), 5, 2, m) np.testing.assert_array_equal(actual_score_m, expected_score_m) np.testing.assert_array_equal(actual_tback_m, expected_tback_m) def test_compute_score_and_traceback_matrices_invalid(self): # if the sequence contains a character that is not in the # substitution matrix, an informative error should be raised m = make_identity_substitution_matrix(2, -1) self.assertRaises(ValueError, _compute_score_and_traceback_matrices, TabularMSA([DNA('AWG', metadata={'id': 'id'})]), TabularMSA([DNA('ACGT', metadata={'id': 'id'})]), 5, 2, m) def test_traceback(self): score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1], [-9, -5, -1, 6], [-11, -7, -3, 1]] score_m = np.array(score_m) tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1], [2, 2, 2, 2]] tback_m = np.array(tback_m) # start at bottom-right expected = ([DNA("ACG-", metadata={'id': 'foo'})], [DNA("ACGT", metadata={'id': 'bar'})], 1, 0, 0) actual = _traceback(tback_m, score_m, TabularMSA([DNA('ACG', metadata={'id': 'foo'})]), TabularMSA([DNA('ACGT', metadata={'id': 'bar'})]), 4, 3) self.assertEqual(actual, expected) # four sequences in two alignments score_m = [[0, -5, -7, -9], [-5, 2, -3, -5], [-7, -3, 4, -1], [-9, -5, -1, 6], [-11, -7, -3, 1]] score_m = np.array(score_m) tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 1, 3], [2, 2, 2, 1], [2, 2, 2, 2]] tback_m = np.array(tback_m) # start at bottom-right expected = ([DNA("ACG-", metadata={'id': 's1'}), DNA("ACG-", metadata={'id': 's2'})], [DNA("ACGT", metadata={'id': 's3'}), DNA("ACGT", metadata={'id': 's4'})], 1, 0, 0) actual = _traceback(tback_m, score_m, TabularMSA([DNA('ACG', metadata={'id': 's1'}), DNA('ACG', metadata={'id': 's2'})]), TabularMSA([DNA('ACGT', metadata={'id': 's3'}), DNA('ACGT', metadata={'id': 's4'})]), 4, 3) self.assertEqual(actual, expected) # start at highest-score expected = ([DNA("ACG", metadata={'id': 'foo'})], [DNA("ACG", metadata={'id': 'bar'})], 6, 0, 0) actual = _traceback(tback_m, score_m, TabularMSA([DNA('ACG', metadata={'id': 'foo'})]), TabularMSA([DNA('ACGT', metadata={'id': 'bar'})]), 3, 3) self.assertEqual(actual, expected) # terminate traceback before top-right tback_m = [[0, 3, 3, 3], [2, 1, 3, 3], [2, 2, 0, 3], [2, 2, 2, 1], [2, 2, 2, 2]] tback_m = np.array(tback_m) expected = ([DNA("G", metadata={'id': 'a'})], [DNA("G", metadata={'id': 'a'})], 6, 2, 2) actual = _traceback(tback_m, score_m, TabularMSA([DNA('ACG', metadata={'id': 'a'})]), TabularMSA([DNA('ACGT', metadata={'id': 'a'})]), 3, 3) self.assertEqual(actual, expected) def test_first_largest(self): input = [(5, 'a'), (5, 'b'), (5, 'c')] self.assertEqual(_first_largest(input), (5, 'a')) input = [(5, 'c'), (5, 'b'), (5, 'a')] self.assertEqual(_first_largest(input), (5, 'c')) input = [(5, 'c'), (6, 'b'), (5, 'a')] self.assertEqual(_first_largest(input), (6, 'b')) # works for more than three entries input = [(5, 'c'), (6, 'b'), (5, 'a'), (7, 'd')] self.assertEqual(_first_largest(input), (7, 'd')) # Note that max([(5, 'a'), (5, 'c')]) == max([(5, 'c'), (5, 'a')]) # but for the purposes needed here, we want the max to be the same # regardless of what the second item in the tuple is. if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/alignment/tests/test_ssw.py000066400000000000000000000775251446255456000222710ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- # Special thanks to http://www.faculty.ucr.edu/~mmaduro/random.htm for the # random DNA generator. # These tests confirm that StripedSmithWaterman returns the same results as # SSW. We don't test for correctness of those results (i.e., we assume that # ssw.c and ssw.h are correct) as that testing is beyond the scope of skbio. # Furthermore all expected results are created by running StripedSmithWaterman # the resulting alignments are verified by hand. Creating tests from the base # C API is impractical at this time. from unittest import TestCase, main from skbio import (local_pairwise_align_ssw, Sequence, DNA, RNA, Protein, TabularMSA) from skbio.alignment import StripedSmithWaterman, AlignmentStructure from skbio.alignment._pairwise import blosum50 class TestSSW(TestCase): align_attributes = [ "optimal_alignment_score", "suboptimal_alignment_score", "target_begin", "target_end_optimal", "target_end_suboptimal", "query_begin", "query_end", "cigar", "query_sequence", "target_sequence" ] def _check_alignment(self, alignment, expected): for attribute in self.align_attributes: # The first element of this tuple is to identify # the broken sequence if one should fail self.assertEqual((expected['target_sequence'], expected[attribute]), (alignment['target_sequence'], alignment[attribute])) def _check_argument_with_inequality_on_optimal_align_score( self, query_sequences=None, target_sequences=None, arg=None, default=None, i_range=None, compare_lt=None, compare_gt=None): iterable_kwarg = {} default_kwarg = {} default_kwarg[arg] = default for query_sequence in query_sequences: for target_sequence in target_sequences: for i in i_range: iterable_kwarg[arg] = i query1 = StripedSmithWaterman(query_sequence, **iterable_kwarg) align1 = query1(target_sequence) query2 = StripedSmithWaterman(query_sequence, **default_kwarg) align2 = query2(target_sequence) if i == default: self.assertEqual(align1.optimal_alignment_score, align2.optimal_alignment_score) if i < default: compare_lt(align1.optimal_alignment_score, align2.optimal_alignment_score) if i > default: compare_gt(align1.optimal_alignment_score, align2.optimal_alignment_score) def _check_bit_flag_sets_properties_falsy_or_negative( self, query_sequences=None, target_sequences=None, arg_settings=[], properties_to_null=[]): kwarg = {} def falsy_or_negative(alignment, prop): if type(alignment[prop]) is int: return alignment[prop] < 0 else: return not alignment[prop] for query_sequence in query_sequences: for target_sequence in target_sequences: for arg, setting in arg_settings: kwarg[arg] = setting query = StripedSmithWaterman(query_sequence, **kwarg) alignment = query(target_sequence) for prop in properties_to_null: self.assertTrue(falsy_or_negative(alignment, prop)) # Every property not in our null list for prop in [p for p in self.align_attributes if p not in properties_to_null]: self.assertFalse(falsy_or_negative(alignment, prop)) class TestStripedSmithWaterman(TestSSW): def test_object_is_reusable(self): q_seq = "AGGGTAATTAGGCGTGTTCACCTA" expected_alignments = [ { 'optimal_alignment_score': 10, 'suboptimal_alignment_score': 10, 'query_begin': 4, 'query_end': 8, 'target_begin': 3, 'target_end_optimal': 7, 'target_end_suboptimal': 34, 'cigar': '5M', 'query_sequence': q_seq, 'target_sequence': ('TTATAATTTTCTTATTATTATCAATATTTATAATTTGATTT' 'TGTTGTAAT') }, { 'optimal_alignment_score': 36, 'suboptimal_alignment_score': 16, 'query_begin': 0, 'query_end': 23, 'target_begin': 6, 'target_end_optimal': 29, 'target_end_suboptimal': 13, 'cigar': '8M1D8M1I7M', 'query_sequence': q_seq, 'target_sequence': 'AGTCGAAGGGTAATATAGGCGTGTCACCTA' }, { 'optimal_alignment_score': 16, 'suboptimal_alignment_score': 0, 'query_begin': 0, 'query_end': 7, 'target_begin': 6, 'target_end_optimal': 13, 'target_end_suboptimal': 0, 'cigar': '8M', 'query_sequence': q_seq, 'target_sequence': 'AGTCGAAGGGTAATA' }, { 'optimal_alignment_score': 8, 'suboptimal_alignment_score': 8, 'query_begin': 0, 'query_end': 3, 'target_begin': 7, 'target_end_optimal': 10, 'target_end_suboptimal': 42, 'cigar': '4M', 'query_sequence': q_seq, 'target_sequence': ('CTGCCTCAGGGGGAGGAAAGCGTCAGCGCGGCTGCCGTCGG' 'CGCAGGGGC') }, { 'optimal_alignment_score': 48, 'suboptimal_alignment_score': 16, 'query_begin': 0, 'query_end': 23, 'target_begin': 0, 'target_end_optimal': 23, 'target_end_suboptimal': 7, 'cigar': '24M', 'query_sequence': q_seq, 'target_sequence': q_seq } ] query = StripedSmithWaterman(q_seq) results = [] for expected in expected_alignments: alignment = query(expected['target_sequence']) results.append(alignment) for result, expected in zip(results, expected_alignments): self._check_alignment(result, expected) def test_regression_on_instantiation_arguments(self): expected = { 'optimal_alignment_score': 23, 'suboptimal_alignment_score': 10, 'query_begin': 0, 'query_end': 16, 'target_begin': 0, 'target_end_optimal': 20, 'target_end_suboptimal': 4, 'cigar': '6M4D11M', 'query_sequence': 'AAACGATAAATCCGCGTA', 'target_sequence': 'AAACGACTACTAAATCCGCGTGATAGGGGA' } query = StripedSmithWaterman(expected['query_sequence'], gap_open_penalty=5, gap_extend_penalty=2, score_size=2, mask_length=15, mask_auto=True, score_only=False, score_filter=None, distance_filter=None, override_skip_babp=False, protein=False, match_score=2, mismatch_score=-3, substitution_matrix=None, suppress_sequences=False, zero_index=True) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_protein_sequence_is_usable(self): expected = { 'optimal_alignment_score': 316, 'suboptimal_alignment_score': 95, 'query_begin': 0, 'query_end': 52, 'target_begin': 0, 'target_end_optimal': 52, 'target_end_suboptimal': 18, 'cigar': '15M1D15M1I22M', 'query_sequence': ('VHLTGEEKSAVAALWGKVNVDEVGGEALGRXLLVVYPWTQRFFESF' 'SDLSTPDABVMSNPKVKAHGK'), 'target_sequence': ('VHLTPEEKSAVTALWBGKVNVDEVGGEALGRLLVVYPWTQRFFES' 'FGDLSTPD*') } query = StripedSmithWaterman(expected['query_sequence'], protein=True, substitution_matrix=blosum50) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_lowercase_is_valid_sequence(self): expected = { 'optimal_alignment_score': 23, 'suboptimal_alignment_score': 10, 'query_begin': 0, 'query_end': 16, 'target_begin': 0, 'target_end_optimal': 20, 'target_end_suboptimal': 4, 'cigar': '6M4D11M', 'query_sequence': 'aaacgataaatccgcgta', 'target_sequence': 'aaacgactactaaatccgcgtgatagggga' } query = StripedSmithWaterman(expected['query_sequence']) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_align_with_N_in_nucleotide_sequence(self): expected = { 'optimal_alignment_score': 9, 'suboptimal_alignment_score': 0, 'query_begin': 0, 'query_end': 8, 'target_begin': 0, 'target_end_optimal': 9, 'target_end_suboptimal': 0, 'cigar': '4M1D5M', 'query_sequence': 'ACTCANNATCGANCTAGC', 'target_sequence': 'ACTCGAAAATGTNNGCA' } query = StripedSmithWaterman(expected['query_sequence']) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_arg_match_score(self): query_sequences = [ "TTTTTTCTTATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTCAATATAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "CTGCCTCAAGGGGGAGGAAAGCGTCAGCGCGGCTGCCGTCGGCGCAGGGGC", "AGGGTAATTTTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_argument_with_inequality_on_optimal_align_score( query_sequences=query_sequences, target_sequences=target_sequences, arg='match_score', default=2, i_range=range(0, 5), compare_lt=self.assertLess, compare_gt=self.assertGreater ) # The above is a strict bound, so we don't need a expected align def test_arg_mismatch_score(self): query_sequences = [ "TTATAATTAATTCTTATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAAGGGGTATAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "CTGCCTCAGGGGCGAGGAAAGCGTCAGCGCGGCTGCCGTCGGCGCAGGGGC", "AGGGTAATTAGCGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_argument_with_inequality_on_optimal_align_score( query_sequences=query_sequences, target_sequences=target_sequences, arg='mismatch_score', default=-3, i_range=range(-6, 1), # These are intentionally inverted compare_lt=self.assertLessEqual, compare_gt=self.assertGreaterEqual ) # The above is not a strict bound, so lets use an expected align # to plug the hole where every align is exactly equal to default expected = { 'optimal_alignment_score': 8, 'suboptimal_alignment_score': 0, 'query_begin': 5, 'query_end': 8, 'target_begin': 10, 'target_end_optimal': 13, 'target_end_suboptimal': 0, 'cigar': '4M', 'query_sequence': 'AGAGGGTAATCAGCCGTGTCCACCGGAACACAACGCTATCGGGCGA', 'target_sequence': 'GTTCGCCCCAGTAAAGTTGCTACCAAATCCGCATG' } query = StripedSmithWaterman(expected['query_sequence'], mismatch_score=-8) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_arg_matrix_overrides_match_and_mismatch(self): query_sequences = [ "TTATAATTAATTCTTATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAAGGGGTATAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "CTGCCTCAGGGGCGAGGAAAGCGTCAGCGCGGCTGCCGTCGGCGCAGGGGC", "AGGGTAATTAGCGCGTGTTCACCTA" ] target_sequences = query_sequences matrix = { # This is a biologically meaningless matrix "A": {"A": 4, "T": -1, "C": -2, "G": -3, "N": 4}, "T": {"A": -1, "T": 1, "C": -1, "G": -4, "N": 1}, "C": {"A": -2, "T": -1, "C": 10, "G": 1, "N": 1}, "G": {"A": -3, "T": -4, "C": 1, "G": 3, "N": 1}, "N": {"A": 4, "T": 1, "C": 1, "G": 1, "N": 0} } for query_sequence in query_sequences: for target_sequence in target_sequences: query1 = StripedSmithWaterman(query_sequence) align1 = query1(target_sequence) query2 = StripedSmithWaterman(query_sequence, substitution_matrix=matrix) align2 = query2(target_sequence) self.assertNotEqual(align1.optimal_alignment_score, align2.optimal_alignment_score) def test_arg_gap_open_penalty(self): query_sequences = [ "TTATAATTTTCTTAGTTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCCGAAGGGTAATATAGGCGTGTCACCTA", "AGTCGAAGGCGGTAATA", "CTGCCTCGGCAGGGGGAGGAAAGCGTCAGCGCGGCTGCCGTCGGCGCAGGGGC", "AGGGTAATTAAAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_argument_with_inequality_on_optimal_align_score( query_sequences=query_sequences, target_sequences=target_sequences, arg='gap_open_penalty', default=5, i_range=range(1, 12), # These are intentionally inverted compare_lt=self.assertGreaterEqual, compare_gt=self.assertLessEqual ) # The above is not a strict bound, so lets use an expected align # to plug the hole where every align is exactly equal to default expected = { 'optimal_alignment_score': 51, 'suboptimal_alignment_score': 20, 'query_begin': 0, 'query_end': 37, 'target_begin': 0, 'target_end_optimal': 29, 'target_end_suboptimal': 9, 'cigar': '5M4I3M3I1M1I21M', 'query_sequence': 'TAGAGATTAATTGCCACATTGCCACTGCCAAAATTCTG', 'target_sequence': 'TAGAGATTAATTGCCACTGCCAAAATTCTG' } query = StripedSmithWaterman(expected['query_sequence'], gap_open_penalty=1) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_arg_gap_extend_penalty(self): query_sequences = [ "TTATAATTTTCTTATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAATACTAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "CTGCCTCAGGGGGAGGCAAAGCGTCAGCGCGGCTGCCGTCGGCGCAGGGGC", "AGGGTAATTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_argument_with_inequality_on_optimal_align_score( query_sequences=query_sequences, target_sequences=target_sequences, arg='gap_extend_penalty', default=2, i_range=range(1, 10), # These are intentionally inverted compare_lt=self.assertGreaterEqual, compare_gt=self.assertLessEqual ) # The above is not a strict bound, so lets use an expected align # to plug the hole where every align is exactly equal to default expected = { 'optimal_alignment_score': 9, 'suboptimal_alignment_score': 8, 'query_begin': 6, 'query_end': 12, 'target_begin': 7, 'target_end_optimal': 13, 'target_end_suboptimal': 38, 'cigar': '7M', 'query_sequence': 'TCTATAAGATTCCGCATGCGTTACTTATAAGATGTCTCAACGG', 'target_sequence': 'GCCCAGTAGCTTCCCAATATGAGAGCATCAATTGTAGATCGGGCC' } query = StripedSmithWaterman(expected['query_sequence'], gap_extend_penalty=10) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_arg_score_only(self): query_sequences = [ "TTATCGTGATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAATACTATAAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "AGGGTAATTAGGCGTGCGTGCGTGTTCACCTA", "AGGGTATTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_bit_flag_sets_properties_falsy_or_negative( query_sequences=query_sequences, target_sequences=target_sequences, arg_settings=[('score_only', True)], properties_to_null=['query_begin', 'target_begin', 'cigar'] ) def test_arg_score_filter_is_used(self): query_sequences = [ "TTATCGTGATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAATACTATAAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "AGGGTAATTAGGCGTGCGTGCGTGTTCACCTA", "AGGGTATTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_bit_flag_sets_properties_falsy_or_negative( query_sequences=query_sequences, target_sequences=target_sequences, # score_filter will force a BABP and cigar to be falsy arg_settings=[('score_filter', 9001)], properties_to_null=['query_begin', 'target_begin', 'cigar'] ) def test_arg_distance_filter_is_used(self): query_sequences = [ "TTATCGTGATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAATACTATAAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "AGGGTAATTAGGCGTGCGTGCGTGTTCACCTA", "AGGGTATTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_bit_flag_sets_properties_falsy_or_negative( query_sequences=query_sequences, target_sequences=target_sequences, # distance_filter will force cigar to be falsy only arg_settings=[('distance_filter', 1)], properties_to_null=['cigar'] ) def test_arg_override_skip_babp(self): query_sequences = [ "TTATCGTGATTATTATCAATATTTATAATTTGATTTTGTTGTAAT", "AGTCGAAGGGTAATACTATAAGGCGTGTCACCTA", "AGTCGAAGGGTAATA", "AGGGTAATTAGGCGTGCGTGCGTGTTCACCTA", "AGGGTATTAGGCGTGTTCACCTA" ] target_sequences = query_sequences self._check_bit_flag_sets_properties_falsy_or_negative( query_sequences=query_sequences, target_sequences=target_sequences, # score_filter will force a BABP and cigar to be falsy if not for # override_skip_babp preventing this for all but the cigar arg_settings=[('override_skip_babp', True), ('score_filter', 9001)], properties_to_null=['cigar'] ) def test_arg_zero_index_changes_base_of_index_to_0_or_1(self): expected_alignments = [ ({ 'optimal_alignment_score': 100, 'suboptimal_alignment_score': 44, 'query_begin': 5, 'query_end': 54, 'target_begin': 0, 'target_end_optimal': 49, 'target_end_suboptimal': 21, 'cigar': '50M', 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, True), ({ 'optimal_alignment_score': 100, 'suboptimal_alignment_score': 44, 'query_begin': 6, 'query_end': 55, 'target_begin': 1, 'target_end_optimal': 50, 'target_end_suboptimal': 22, 'cigar': '50M', 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, False) ] for expected, z in expected_alignments: query = StripedSmithWaterman(expected['query_sequence'], zero_index=z) alignment = query(expected['target_sequence']) self._check_alignment(alignment, expected) def test_arg_suppress_sequences(self): expected = { 'optimal_alignment_score': 100, 'suboptimal_alignment_score': 44, 'query_begin': 5, 'query_end': 54, 'target_begin': 0, 'target_end_optimal': 49, 'target_end_suboptimal': 21, 'cigar': '50M', 'query_sequence': '', 'target_sequence': '' } query = StripedSmithWaterman( "AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCCGGGCGGGGC", suppress_sequences=True) alignment = query("CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCCGGGCGGGGC") self._check_alignment(alignment, expected) class TestAlignStripedSmithWaterman(TestSSW): def _check_TabularMSA_to_AlignmentStructure(self, alignment, structure, expected_dtype): msa, score, start_end = alignment self.assertEqual(score, structure.optimal_alignment_score) self.assertEqual( msa, TabularMSA([expected_dtype(structure.aligned_query_sequence), expected_dtype(structure.aligned_target_sequence)])) if structure.query_begin == -1: self.assertEqual(start_end, None) else: for (start, end), (expected_start, expected_end) in \ zip(start_end, [(structure.query_begin, structure.query_end), (structure.target_begin, structure.target_end_optimal)]): self.assertEqual(start, expected_start) self.assertEqual(end, expected_end) def test_same_as_using_StripedSmithWaterman_object_DNA(self): query_sequence = 'ATGGAAGCTATAAGCGCGGGTGAG' target_sequence = 'AACTTATATAATAAAAATTATATATTCGTTGGGTTCTTTTGATATAAATC' query = StripedSmithWaterman(query_sequence) align1 = query(target_sequence) align2 = local_pairwise_align_ssw(DNA(query_sequence), DNA(target_sequence)) self._check_TabularMSA_to_AlignmentStructure(align2, align1, DNA) def test_same_as_using_StripedSmithWaterman_object_Protein(self): query_sequence = 'HEAGAWGHEE' target_sequence = 'PAWHEAE' query = StripedSmithWaterman(query_sequence, protein=True, substitution_matrix=blosum50) align1 = query(target_sequence) align2 = local_pairwise_align_ssw(Protein(query_sequence), Protein(target_sequence), substitution_matrix=blosum50) self._check_TabularMSA_to_AlignmentStructure(align2, align1, Protein) def test_kwargs_are_usable(self): kwargs = {} kwargs['mismatch_score'] = -2 kwargs['match_score'] = 5 query_sequence = 'AGGGTAATTAGGCGTGTTCACCTA' target_sequence = 'TACTTATAAGATGTCTCAACGGCATGCGCAACTTGTGAAGTG' query = StripedSmithWaterman(query_sequence, **kwargs) align1 = query(target_sequence) align2 = local_pairwise_align_ssw(DNA(query_sequence), DNA(target_sequence), **kwargs) self._check_TabularMSA_to_AlignmentStructure(align2, align1, DNA) def test_invalid_type(self): with self.assertRaisesRegex(TypeError, r"not type 'Sequence'"): local_pairwise_align_ssw(DNA('ACGT'), Sequence('ACGT')) with self.assertRaisesRegex(TypeError, r"not type 'str'"): local_pairwise_align_ssw('ACGU', RNA('ACGU')) def test_type_mismatch(self): with self.assertRaisesRegex(TypeError, r"same type: 'DNA' != 'RNA'"): local_pairwise_align_ssw(DNA('ACGT'), RNA('ACGU')) class TestAlignmentStructure(TestSSW): def mock_object_factory(self, dictionary): class MockAlignmentStructure(AlignmentStructure): def __init__(self, _a, _b, _c): for key in dictionary: setattr(self, key, dictionary[key]) return MockAlignmentStructure(None, None, 0) def test_works_for_dot_and_square_bracket_access(self): q_seq = "AGGGTAATTAGGCGTGTTCACCTA" query = StripedSmithWaterman(q_seq) alignment = query("TACTTATAAGATGTCTCAACGGCATGCGCAACTTGTGAAGTG") for accessible in self.align_attributes: self.assertEqual(getattr(alignment, accessible), alignment[accessible]) def test_is_zero_based_returns_true_if_index_base_is_zero(self): expected_alignments = [ ({ 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, True), ({ 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, False) ] for expected, z in expected_alignments: query = StripedSmithWaterman(expected['query_sequence'], zero_index=z) alignment = query(expected['target_sequence']) self.assertEqual(z, alignment.is_zero_based()) def test_set_zero_based_changes_the_index_base(self): expected_alignments = [ ({ 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, True), ({ 'query_sequence': ('AGTCACGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCG' 'CCCCGGGCGGGGC'), 'target_sequence': ('CGCGCGCCGCCGGGGGGCCGGCCGGCGCCGGGGGGCGCCCC' 'GGGCGGGGC') }, False) ] for expected, z in expected_alignments: query = StripedSmithWaterman(expected['query_sequence'], zero_index=z) alignment = query(expected['target_sequence']) alignment.set_zero_based(not z) self.assertEqual(not z, alignment.is_zero_based()) def test__get_aligned_sequences(self): generic_sequence = "123456789abcdefghijklmnopqrstuvwxyz" tests = [ # `end_after_cigar` is how far end extends beyond the cigar. # Negative values on this should not be possible with SSW { 'cigar_tuples': [ (4, 'M'), (3, 'I'), (1, 'D'), (15, 'M') ], 'begin': 4, 'end_after_cigar': 2, 'gap_type': 'I', 'expected': "5678---9abcdefghijklmnopq" }, { 'cigar_tuples': [ (12, 'M') ], 'begin': 10, 'end_after_cigar': 0, 'gap_type': 'D', 'expected': "bcdefghijklm" }, { 'cigar_tuples': [ (10, 'D'), (1, 'M'), (3, 'I'), (2, 'M') ], 'begin': 0, 'end_after_cigar': 5, 'gap_type': 'I', 'expected': "123456789ab---cdefghi" }, { 'cigar_tuples': [ (10, 'D'), (1, 'M'), (3, 'I'), (2, 'M') ], 'begin': 3, 'end_after_cigar': 0, 'gap_type': 'D', 'expected': "----------456789" }, { 'cigar_tuples': [ (1, 'I'), (4, 'M'), (3, 'I'), (1, 'D'), (8, 'M'), (8, 'D'), (2, 'I'), (6, 'M'), (1, 'I') ], 'begin': 4, 'end_after_cigar': 3, 'gap_type': 'I', 'expected': "-5678---9abcdefghijklmnop--qrstuv-wxy" } ] for test in tests: mock_object = self.mock_object_factory({}) # Because SSW's output is [a, b] and Python's list ranges use # [a, b) a 1 is added in the calculation of aligned sequences. # We just have to subtract 1 while we are testing with the easy to # verify interface of `end_after_cigar` to cancel this range effect # out. end = test['end_after_cigar'] - 1 + test['begin'] + \ sum(le if t != test['gap_type'] else 0 for le, t in test['cigar_tuples']) self.assertEqual(test['expected'], AlignmentStructure._get_aligned_sequence( mock_object, generic_sequence, test['cigar_tuples'], test['begin'], end, test['gap_type'])) def test_aligned_query_target_sequence(self): query = StripedSmithWaterman("AGGGTAATTAGGCGTGTTCACCTA") alignment = query("AGTCGAAGGGTAATATAGGCGTGTCACCTA") self.assertEqual("AGGGTAATATAGGCGTG-TCACCTA", alignment.aligned_target_sequence) self.assertEqual("AGGGTAAT-TAGGCGTGTTCACCTA", alignment.aligned_query_sequence) def test_aligned_query_target_sequence_with_suppressed_sequences(self): query = StripedSmithWaterman("AGGGTAATTAGGCGTGTTCACCTA", suppress_sequences=True) alignment = query("AGTCGAAGGGTAATATAGGCGTGTCACCTA") self.assertEqual(None, alignment.aligned_target_sequence) self.assertEqual(None, alignment.aligned_query_sequence) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/alignment/tests/test_tabular_msa.py000066400000000000000000004361741446255456000237460ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import collections.abc import copy import unittest import functools import itertools import types import numpy as np import numpy.testing as npt import pandas as pd import scipy.stats from skbio import Sequence, DNA, RNA, Protein, TabularMSA from skbio.sequence import GrammaredSequence from skbio.util import classproperty from skbio.util._decorator import overrides from skbio.util._testing import ReallyEqualMixin from skbio.metadata._testing import (MetadataMixinTests, PositionalMetadataMixinTests) from skbio.util import assert_data_frame_almost_equal from skbio.util._testing import assert_index_equal class TabularMSASubclass(TabularMSA): """Used for testing purposes.""" pass class TestTabularMSAMetadata(unittest.TestCase, ReallyEqualMixin, MetadataMixinTests): def setUp(self): self._metadata_constructor_ = functools.partial(TabularMSA, []) class TestTabularMSAPositionalMetadata(unittest.TestCase, ReallyEqualMixin, PositionalMetadataMixinTests): def setUp(self): def factory(axis_len, positional_metadata=None): return TabularMSA([DNA('A' * axis_len)], positional_metadata=positional_metadata) self._positional_metadata_constructor_ = factory class TestTabularMSA(unittest.TestCase, ReallyEqualMixin): def test_from_dict_empty(self): self.assertEqual(TabularMSA.from_dict({}), TabularMSA([], index=[])) def test_from_dict_single_sequence(self): self.assertEqual(TabularMSA.from_dict({'foo': DNA('ACGT')}), TabularMSA([DNA('ACGT')], index=['foo'])) def test_from_dict_multiple_sequences(self): msa = TabularMSA.from_dict( {1: DNA('ACG'), 2: DNA('GGG'), 3: DNA('TAG')}) # Sort because order is arbitrary. msa.sort() self.assertEqual( msa, TabularMSA([DNA('ACG'), DNA('GGG'), DNA('TAG')], index=[1, 2, 3])) def test_from_dict_invalid_input(self): # Basic test to make sure error-checking in the TabularMSA constructor # is being invoked. with self.assertRaisesRegex( ValueError, r'must match the number of positions'): TabularMSA.from_dict({'a': DNA('ACG'), 'b': DNA('ACGT')}) def test_constructor_invalid_dtype(self): with self.assertRaisesRegex(TypeError, r'GrammaredSequence.*Sequence'): TabularMSA([Sequence('')]) with self.assertRaisesRegex(TypeError, r'GrammaredSequence.*int'): TabularMSA([42, DNA('')]) def test_constructor_not_monomorphic(self): with self.assertRaisesRegex(TypeError, r'matching type.*RNA.*DNA'): TabularMSA([DNA(''), RNA('')]) with self.assertRaisesRegex(TypeError, r'matching type.*float.*Protein'): TabularMSA([Protein(''), Protein(''), 42.0, Protein('')]) def test_constructor_unequal_length(self): with self.assertRaisesRegex( ValueError, r'must match the number of positions.*1 != 0'): TabularMSA([Protein(''), Protein('P')]) with self.assertRaisesRegex( ValueError, r'must match the number of positions.*1 != 3'): TabularMSA([Protein('PAW'), Protein('ABC'), Protein('A')]) def test_constructor_non_iterable(self): with self.assertRaises(TypeError): TabularMSA(42) def test_constructor_minter_and_index_both_provided(self): with self.assertRaisesRegex(ValueError, r'both.*minter.*index'): TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=str, index=['a', 'b']) def test_constructor_invalid_minter_callable(self): with self.assertRaises(TypeError): TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=float) def test_constructor_missing_minter_metadata_key(self): with self.assertRaises(KeyError): TabularMSA([DNA('ACGT', metadata={'foo': 'bar'}), DNA('TGCA')], minter='foo') def test_constructor_unhashable_minter_metadata_key(self): with self.assertRaises(TypeError): TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=[]) def test_constructor_index_length_mismatch_iterable(self): with self.assertRaisesRegex(ValueError, r'sequences.*2.*index length.*0'): TabularMSA([DNA('ACGT'), DNA('TGCA')], index=iter([])) def test_constructor_index_length_mismatch_index_object(self): with self.assertRaisesRegex(ValueError, r'sequences.*2.*index length.*0'): TabularMSA([DNA('ACGT'), DNA('TGCA')], index=pd.Index([])) def test_constructor_invalid_index_scalar(self): with self.assertRaises(TypeError): TabularMSA([DNA('ACGT'), DNA('TGCA')], index=42) def test_constructor_non_unique_labels(self): msa = TabularMSA([DNA('ACGT'), DNA('ACGT')], index=[1, 1]) assert_index_equal(msa.index, pd.Index([1, 1], dtype=np.int64)) def test_constructor_empty_no_index(self): # sequence empty msa = TabularMSA([]) self.assertIsNone(msa.dtype) self.assertEqual(msa.shape, (0, 0)) assert_index_equal(msa.index, pd.RangeIndex(0)) with self.assertRaises(StopIteration): next(iter(msa)) # position empty seqs = [DNA(''), DNA('')] msa = TabularMSA(seqs) self.assertIs(msa.dtype, DNA) self.assertEqual(msa.shape, (2, 0)) assert_index_equal(msa.index, pd.RangeIndex(2)) self.assertEqual(list(msa), seqs) def test_constructor_empty_with_labels(self): # sequence empty msa = TabularMSA([], minter=lambda x: x) assert_index_equal(msa.index, pd.Index([])) msa = TabularMSA([], index=iter([])) assert_index_equal(msa.index, pd.Index([])) # position empty msa = TabularMSA([DNA('', metadata={'id': 42}), DNA('', metadata={'id': 43})], minter='id') assert_index_equal(msa.index, pd.Index([42, 43])) msa = TabularMSA([DNA(''), DNA('')], index=iter([42, 43])) assert_index_equal(msa.index, pd.Index([42, 43])) def test_constructor_non_empty_no_labels_provided(self): # 1x3 seqs = [DNA('ACG')] msa = TabularMSA(seqs) self.assertIs(msa.dtype, DNA) self.assertEqual(msa.shape, (1, 3)) assert_index_equal(msa.index, pd.RangeIndex(1)) self.assertEqual(list(msa), seqs) # 3x1 seqs = [DNA('A'), DNA('C'), DNA('G')] msa = TabularMSA(seqs) self.assertIs(msa.dtype, DNA) self.assertEqual(msa.shape, (3, 1)) assert_index_equal(msa.index, pd.RangeIndex(3)) self.assertEqual(list(msa), seqs) def test_constructor_non_empty_with_labels_provided(self): seqs = [DNA('ACG'), DNA('CGA'), DNA('GTT')] msa = TabularMSA(seqs, minter=str) self.assertIs(msa.dtype, DNA) self.assertEqual(msa.shape, (3, 3)) assert_index_equal(msa.index, pd.Index(['ACG', 'CGA', 'GTT'])) self.assertEqual(list(msa), seqs) msa = TabularMSA(seqs, index=iter([42, 43, 44])) assert_index_equal(msa.index, pd.Index([42, 43, 44])) def test_constructor_works_with_iterator(self): seqs = [DNA('ACG'), DNA('CGA'), DNA('GTT')] msa = TabularMSA(iter(seqs), minter=str) self.assertIs(msa.dtype, DNA) self.assertEqual(msa.shape, (3, 3)) assert_index_equal(msa.index, pd.Index(['ACG', 'CGA', 'GTT'])) self.assertEqual(list(msa), seqs) def test_constructor_with_multiindex_index(self): msa = TabularMSA([DNA('AA'), DNA('GG')], index=[('foo', 42), ('bar', 43)]) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43)])) def test_constructor_with_multiindex_minter(self): def multiindex_minter(seq): if str(seq) == 'AC': return ('foo', 42) else: return ('bar', 43) msa = TabularMSA([DNA('AC'), DNA('GG')], minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43)])) def test_copy_constructor_respects_default_index(self): msa = TabularMSA([DNA('ACGT'), DNA('----'), DNA('AAAA')]) copy = TabularMSA(msa) self.assertEqual(msa, copy) self.assertIsNot(msa, copy) assert_index_equal(msa.index, pd.RangeIndex(3)) assert_index_equal(copy.index, pd.RangeIndex(3)) def test_copy_constructor_without_metadata(self): msa = TabularMSA([DNA('ACGT'), DNA('----')]) copy = TabularMSA(msa) self.assertEqual(msa, copy) self.assertIsNot(msa, copy) assert_index_equal(copy.index, pd.RangeIndex(2)) def test_copy_constructor_with_metadata(self): msa = TabularMSA([DNA('ACGT'), DNA('----')], metadata={'foo': 42}, positional_metadata={'bar': range(4)}, index=['idx1', 'idx2']) copy = TabularMSA(msa) self.assertEqual(msa, copy) self.assertIsNot(msa, copy) self.assertIsNot(msa.metadata, copy.metadata) self.assertIsNot(msa.positional_metadata, copy.positional_metadata) # pd.Index is immutable, no copy necessary. self.assertIs(msa.index, copy.index) def test_copy_constructor_state_override_with_minter(self): msa = TabularMSA([DNA('ACGT'), DNA('----')], metadata={'foo': 42}, positional_metadata={'bar': range(4)}, index=['idx1', 'idx2']) copy = TabularMSA(msa, metadata={'foo': 43}, positional_metadata={'bar': range(4, 8)}, minter=str) self.assertNotEqual(msa, copy) self.assertEqual( copy, TabularMSA([DNA('ACGT'), DNA('----')], metadata={'foo': 43}, positional_metadata={'bar': range(4, 8)}, minter=str)) def test_copy_constructor_state_override_with_index(self): msa = TabularMSA([DNA('ACGT'), DNA('----')], metadata={'foo': 42}, positional_metadata={'bar': range(4)}, index=['idx1', 'idx2']) copy = TabularMSA(msa, metadata={'foo': 43}, positional_metadata={'bar': range(4, 8)}, index=['a', 'b']) self.assertNotEqual(msa, copy) self.assertEqual( copy, TabularMSA([DNA('ACGT'), DNA('----')], metadata={'foo': 43}, positional_metadata={'bar': range(4, 8)}, index=['a', 'b'])) def test_copy_constructor_with_minter_and_index(self): msa = TabularMSA([DNA('ACGT'), DNA('----')], index=['idx1', 'idx2']) with self.assertRaisesRegex(ValueError, r'both.*minter.*index'): TabularMSA(msa, index=['a', 'b'], minter=str) def test_dtype(self): self.assertIsNone(TabularMSA([]).dtype) self.assertIs(TabularMSA([Protein('')]).dtype, Protein) with self.assertRaises(AttributeError): TabularMSA([]).dtype = DNA with self.assertRaises(AttributeError): del TabularMSA([]).dtype def test_shape(self): shape = TabularMSA([DNA('ACG'), DNA('GCA')]).shape self.assertEqual(shape, (2, 3)) self.assertEqual(shape.sequence, shape[0]) self.assertEqual(shape.position, shape[1]) with self.assertRaises(TypeError): shape[0] = 3 with self.assertRaises(AttributeError): TabularMSA([]).shape = (3, 3) with self.assertRaises(AttributeError): del TabularMSA([]).shape def test_index_getter_default_index(self): msa = TabularMSA([DNA('AC'), DNA('AG'), DNA('AT')]) assert_index_equal(msa.index, pd.RangeIndex(3)) # immutable with self.assertRaises(TypeError): msa.index[1] = 2 # original state is maintained assert_index_equal(msa.index, pd.RangeIndex(3)) def test_index_getter(self): index = TabularMSA([DNA('AC'), DNA('AG'), DNA('AT')], minter=str).index self.assertIsInstance(index, pd.Index) assert_index_equal(index, pd.Index(['AC', 'AG', 'AT'])) # immutable with self.assertRaises(TypeError): index[1] = 'AA' # original state is maintained assert_index_equal(index, pd.Index(['AC', 'AG', 'AT'])) def test_index_mixed_type(self): msa = TabularMSA([DNA('AC'), DNA('CA'), DNA('AA')], index=['abc', 'd', 42]) assert_index_equal(msa.index, pd.Index(['abc', 'd', 42])) def test_index_setter_empty(self): msa = TabularMSA([]) msa.index = iter([]) assert_index_equal(msa.index, pd.Index([])) def test_index_setter_non_empty(self): msa = TabularMSA([DNA('AC'), DNA('AG'), DNA('AT')]) msa.index = range(3) assert_index_equal(msa.index, pd.RangeIndex(3)) msa.index = range(3, 6) assert_index_equal(msa.index, pd.RangeIndex(3, 6)) def test_index_setter_length_mismatch(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=str) index = pd.Index(['ACGT', 'TGCA']) assert_index_equal(msa.index, index) with self.assertRaisesRegex(ValueError, r'Length mismatch.*2.*3'): msa.index = iter(['ab', 'cd', 'ef']) # original state is maintained assert_index_equal(msa.index, index) def test_index_setter_non_unique_index(self): msa = TabularMSA([RNA('UUU'), RNA('AAA')], minter=str) msa.index = ['1', '1'] self.assertEqual(msa, TabularMSA([RNA('UUU'), RNA('AAA')], index=['1', '1'])) def test_index_setter_tuples(self): msa = TabularMSA([RNA('UUU'), RNA('AAA')]) msa.index = [('foo', 42), ('bar', 43)] self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal( msa.index, pd.Index([('foo', 42), ('bar', 43)], tupleize_cols=True)) def test_index_setter_preserves_range_index(self): msa = TabularMSA([RNA('UUU'), RNA('AAA')], minter=str) msa.index = pd.RangeIndex(2) self.assertEqual(msa, TabularMSA([RNA('UUU'), RNA('AAA')])) assert_index_equal(msa.index, pd.RangeIndex(2)) def test_index_deleter(self): msa = TabularMSA([RNA('UUU'), RNA('AAA')], minter=str) assert_index_equal(msa.index, pd.Index(['UUU', 'AAA'])) del msa.index assert_index_equal(msa.index, pd.RangeIndex(2)) # Delete again. del msa.index assert_index_equal(msa.index, pd.RangeIndex(2)) def test_bool(self): self.assertFalse(TabularMSA([])) self.assertFalse(TabularMSA([RNA('')])) self.assertFalse( TabularMSA([RNA('', metadata={'id': 1}), RNA('', metadata={'id': 2})], minter='id')) self.assertTrue(TabularMSA([RNA('U')])) self.assertTrue(TabularMSA([RNA('--'), RNA('..')])) self.assertTrue(TabularMSA([RNA('AUC'), RNA('GCA')])) def test_len(self): self.assertEqual(len(TabularMSA([])), 0) self.assertEqual(len(TabularMSA([DNA('')])), 1) self.assertEqual(len(TabularMSA([DNA('AT'), DNA('AG'), DNA('AT')])), 3) def test_iter(self): with self.assertRaises(StopIteration): next(iter(TabularMSA([]))) seqs = [DNA(''), DNA('')] self.assertEqual(list(iter(TabularMSA(seqs))), seqs) seqs = [DNA('AAA'), DNA('GCT')] self.assertEqual(list(iter(TabularMSA(seqs))), seqs) def test_reversed(self): with self.assertRaises(StopIteration): next(reversed(TabularMSA([]))) seqs = [DNA(''), DNA('', metadata={'id': 42})] self.assertEqual(list(reversed(TabularMSA(seqs))), seqs[::-1]) seqs = [DNA('AAA'), DNA('GCT')] self.assertEqual(list(reversed(TabularMSA(seqs))), seqs[::-1]) def test_eq_and_ne(self): # Each element contains the components necessary to construct a # TabularMSA object: seqs and kwargs. None of these objects (once # constructed) should compare equal to one another. components = [ # empties ([], {}), ([RNA('')], {}), ([RNA('')], {'minter': str}), # 1x1 ([RNA('U')], {'minter': str}), # 2x3 ([RNA('AUG'), RNA('GUA')], {'minter': str}), ([RNA('AG'), RNA('GG')], {}), # has labels ([RNA('AG'), RNA('GG')], {'minter': str}), # different dtype ([DNA('AG'), DNA('GG')], {'minter': str}), # different labels ([RNA('AG'), RNA('GG')], {'minter': lambda x: str(x) + '42'}), # different sequence metadata ([RNA('AG', metadata={'id': 42}), RNA('GG')], {'minter': str}), # different sequence data, same labels ([RNA('AG'), RNA('GA')], {'minter': lambda x: 'AG' if 'AG' in x else 'GG'}), # different MSA metadata ([RNA('AG'), RNA('GG')], {'metadata': {'foo': 42}}), ([RNA('AG'), RNA('GG')], {'metadata': {'foo': 43}}), ([RNA('AG'), RNA('GG')], {'metadata': {'foo': 42, 'bar': 43}}), # different MSA positional metadata ([RNA('AG'), RNA('GG')], {'positional_metadata': {'foo': [42, 43]}}), ([RNA('AG'), RNA('GG')], {'positional_metadata': {'foo': [43, 44]}}), ([RNA('AG'), RNA('GG')], {'positional_metadata': {'foo': [42, 43], 'bar': [43, 44]}}), ] for seqs, kwargs in components: obj = TabularMSA(seqs, **kwargs) self.assertReallyEqual(obj, obj) self.assertReallyEqual(obj, TabularMSA(seqs, **kwargs)) self.assertReallyEqual(obj, TabularMSASubclass(seqs, **kwargs)) for (seqs1, kwargs1), (seqs2, kwargs2) in \ itertools.combinations(components, 2): obj1 = TabularMSA(seqs1, **kwargs1) obj2 = TabularMSA(seqs2, **kwargs2) self.assertReallyNotEqual(obj1, obj2) self.assertReallyNotEqual(obj1, TabularMSASubclass(seqs2, **kwargs2)) # completely different types msa = TabularMSA([]) self.assertReallyNotEqual(msa, 42) self.assertReallyNotEqual(msa, []) self.assertReallyNotEqual(msa, {}) self.assertReallyNotEqual(msa, '') def test_eq_constructed_from_different_iterables_compare_equal(self): msa1 = TabularMSA([DNA('ACGT')]) msa2 = TabularMSA((DNA('ACGT'),)) self.assertReallyEqual(msa1, msa2) def test_eq_ignores_minter_str_and_lambda(self): # as long as the labels generated by the minters are the same, it # doesn't matter whether the minters are equal. msa1 = TabularMSA([DNA('ACGT', metadata={'id': 'a'})], minter='id') msa2 = TabularMSA([DNA('ACGT', metadata={'id': 'a'})], minter=lambda x: x.metadata['id']) self.assertReallyEqual(msa1, msa2) def test_eq_minter_and_index(self): # as long as the labels generated by the minters are the same, it # doesn't matter whether the minters are equal. msa1 = TabularMSA([DNA('ACGT', metadata={'id': 'a'})], index=['a']) msa2 = TabularMSA([DNA('ACGT', metadata={'id': 'a'})], minter='id') self.assertReallyEqual(msa1, msa2) def test_eq_default_index_and_equivalent_provided_index(self): msa1 = TabularMSA([DNA('ACGT'), DNA('----'), DNA('....')]) msa2 = TabularMSA([DNA('ACGT'), DNA('----'), DNA('....')], index=[0, 1, 2]) self.assertReallyEqual(msa1, msa2) assert_index_equal(msa1.index, pd.RangeIndex(3)) assert_index_equal(msa2.index, pd.Index([0, 1, 2], dtype=np.int64)) def test_reassign_index_empty(self): # sequence empty msa = TabularMSA([]) msa.reassign_index() self.assertEqual(msa, TabularMSA([])) assert_index_equal(msa.index, pd.RangeIndex(0)) msa.reassign_index(minter=str) self.assertEqual(msa, TabularMSA([], minter=str)) assert_index_equal(msa.index, pd.Index([])) # position empty msa = TabularMSA([DNA('')]) msa.reassign_index() self.assertEqual(msa, TabularMSA([DNA('')])) assert_index_equal(msa.index, pd.RangeIndex(1)) msa.reassign_index(minter=str) self.assertEqual(msa, TabularMSA([DNA('')], minter=str)) assert_index_equal(msa.index, pd.Index([''])) def test_reassign_index_non_empty(self): msa = TabularMSA([DNA('ACG', metadata={'id': 1}), DNA('AAA', metadata={'id': 2})], minter=str) assert_index_equal(msa.index, pd.Index(['ACG', 'AAA'])) msa.reassign_index(minter='id') self.assertEqual( msa, TabularMSA([DNA('ACG', metadata={'id': 1}), DNA('AAA', metadata={'id': 2})], minter='id')) assert_index_equal(msa.index, pd.Index([1, 2])) msa.reassign_index(mapping={1: 5}) self.assertEqual( msa, TabularMSA([DNA('ACG', metadata={'id': 1}), DNA('AAA', metadata={'id': 2})], index=[5, 2])) assert_index_equal(msa.index, pd.Index([5, 2])) msa.reassign_index() assert_index_equal(msa.index, pd.RangeIndex(2)) def test_reassign_index_minter_and_mapping_both_provided(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=str) with self.assertRaisesRegex(ValueError, r'both.*mapping.*minter.*'): msa.reassign_index(minter=str, mapping={"ACGT": "fleventy"}) # original state is maintained assert_index_equal(msa.index, pd.Index(['ACGT', 'TGCA'])) def test_reassign_index_mapping_invalid_type(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')], minter=str) with self.assertRaisesRegex(TypeError, r'mapping.*dict.*callable.*list'): msa.reassign_index(mapping=['abc', 'def']) # original state is maintained assert_index_equal(msa.index, pd.Index(['ACGT', 'TGCA'])) def test_reassign_index_with_mapping_dict_empty(self): seqs = [DNA("A"), DNA("C"), DNA("G")] msa = TabularMSA(seqs, index=[0.5, 1.5, 2.5]) msa.reassign_index(mapping={}) self.assertEqual(msa, TabularMSA(seqs, index=[0.5, 1.5, 2.5])) def test_reassign_index_with_mapping_dict_subset(self): seqs = [DNA("A"), DNA("C"), DNA("G")] mapping = {0.5: "a", 2.5: "c"} msa = TabularMSA(seqs, index=[0.5, 1.5, 2.5]) msa.reassign_index(mapping=mapping) self.assertEqual(msa, TabularMSA(seqs, index=['a', 1.5, 'c'])) def test_reassign_index_with_mapping_dict_superset(self): seqs = [DNA("A"), DNA("C"), DNA("G")] mapping = {0.5: "a", 1.5: "b", 2.5: "c", 3.5: "d"} msa = TabularMSA(seqs, index=[0.5, 1.5, 2.5]) msa.reassign_index(mapping=mapping) self.assertEqual(msa, TabularMSA(seqs, index=['a', 'b', 'c'])) def test_reassign_index_with_mapping_callable(self): seqs = [DNA("A"), DNA("C"), DNA("G")] msa = TabularMSA(seqs, index=[0, 1, 2]) msa.reassign_index(mapping=str) self.assertEqual(msa, TabularMSA(seqs, index=['0', '1', '2'])) msa.reassign_index(mapping=lambda e: int(e) + 42) self.assertEqual(msa, TabularMSA(seqs, index=[42, 43, 44])) def test_reassign_index_non_unique_existing_index(self): seqs = [DNA("A"), DNA("C"), DNA("G")] mapping = {0.5: "a", 1.5: "b", 2.5: "c", 3.5: "d"} msa = TabularMSA(seqs, index=[0.5, 0.5, 0.5]) msa.reassign_index(mapping=mapping) self.assertEqual(msa, TabularMSA(seqs, index=['a', 'a', 'a'])) def test_reassign_index_non_unique_new_index(self): seqs = [DNA("A"), DNA("C"), DNA("G")] mapping = {0.5: "a", 1.5: "a", 2.5: "a"} msa = TabularMSA(seqs, index=[0.5, 1.5, 2.5]) msa.reassign_index(mapping=mapping) self.assertEqual(msa, TabularMSA(seqs, index=['a', 'a', 'a'])) def test_reassign_index_to_multiindex_with_minter(self): msa = TabularMSA([DNA('AC'), DNA('.G')]) def multiindex_minter(seq): if str(seq) == 'AC': return ('foo', 42) else: return ('bar', 43) msa.reassign_index(minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) self.assertEqual( msa, TabularMSA([DNA('AC'), DNA('.G')], index=[('foo', 42), ('bar', 43)])) def test_reassign_index_to_multiindex_with_mapping(self): msa = TabularMSA([DNA('AC'), DNA('.G')]) mapping = {0: ('foo', 42), 1: ('bar', 43)} msa.reassign_index(mapping=mapping) self.assertIsInstance(msa.index, pd.MultiIndex) self.assertEqual( msa, TabularMSA([DNA('AC'), DNA('.G')], index=[('foo', 42), ('bar', 43)])) def test_sort_on_unorderable_msa_index(self): msa = TabularMSA([DNA('AAA'), DNA('ACG'), DNA('---')], index=[42, 41, 'foo']) with self.assertRaises(TypeError): msa.sort() self.assertEqual( msa, TabularMSA([DNA('AAA'), DNA('ACG'), DNA('---')], index=[42, 41, 'foo'])) def test_sort_empty_on_msa_index(self): msa = TabularMSA([], index=[]) msa.sort() self.assertEqual(msa, TabularMSA([], index=[])) msa = TabularMSA([], index=[]) msa.sort(ascending=False) self.assertEqual(msa, TabularMSA([], index=[])) def test_sort_single_sequence_on_msa_index(self): msa = TabularMSA([DNA('ACGT')], index=[42]) msa.sort() self.assertEqual(msa, TabularMSA([DNA('ACGT')], index=[42])) msa = TabularMSA([DNA('ACGT')], index=[42]) msa.sort(ascending=False) self.assertEqual(msa, TabularMSA([DNA('ACGT')], index=[42])) def test_sort_multiple_sequences_on_msa_index(self): msa = TabularMSA([ DNA('TC'), DNA('GG'), DNA('CC')], index=['z', 'a', 'b']) msa.sort(ascending=True) self.assertEqual( msa, TabularMSA([ DNA('GG'), DNA('CC'), DNA('TC')], index=['a', 'b', 'z'])) msa = TabularMSA([ DNA('TC'), DNA('GG'), DNA('CC')], index=['z', 'a', 'b']) msa.sort(ascending=False) self.assertEqual( msa, TabularMSA([ DNA('TC'), DNA('CC'), DNA('GG')], index=['z', 'b', 'a'])) def test_sort_on_labels_with_some_repeats(self): msa = TabularMSA([ DNA('TCCG', metadata={'id': 10}), DNA('TAGG', metadata={'id': 10}), DNA('GGGG', metadata={'id': 8}), DNA('TGGG', metadata={'id': 10}), DNA('ACGT', metadata={'id': 0}), DNA('TAGA', metadata={'id': 10})], minter='id') msa.sort() self.assertEqual(msa._seqs.index.to_list(), [0, 8, 10, 10, 10, 10]) vals = list(msa._seqs.values) self.assertEqual(vals[0], DNA('ACGT', metadata={'id': 0})) self.assertEqual(vals[1], DNA('GGGG', metadata={'id': 8})) self.assertIn(DNA('TCCG', metadata={'id': 10}), vals) self.assertIn(DNA('TAGG', metadata={'id': 10}), vals[2:]) self.assertIn(DNA('TGGG', metadata={'id': 10}), vals[2:]) self.assertIn(DNA('TAGA', metadata={'id': 10}), vals[2:]) def test_sort_on_key_with_all_repeats(self): msa = TabularMSA([ DNA('TTT', metadata={'id': 'a'}), DNA('TTT', metadata={'id': 'b'}), DNA('TTT', metadata={'id': 'c'})], minter=str) msa.sort() self.assertEqual( msa, TabularMSA([ DNA('TTT', metadata={'id': 'a'}), DNA('TTT', metadata={'id': 'b'}), DNA('TTT', metadata={'id': 'c'})], minter=str)) def test_sort_default_index(self): msa = TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')]) msa.sort() self.assertEqual( msa, TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')])) def test_sort_default_index_descending(self): msa = TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')]) msa.sort(ascending=False) self.assertEqual( msa, TabularMSA([DNA('CC'), DNA('GG'), DNA('TC')], index=[2, 1, 0])) def test_sort_already_sorted(self): msa = TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')], index=[1, 2, 3]) msa.sort() self.assertEqual( msa, TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')], index=[1, 2, 3])) msa = TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')], index=[3, 2, 1]) msa.sort(ascending=False) self.assertEqual( msa, TabularMSA([DNA('TC'), DNA('GG'), DNA('CC')], index=[3, 2, 1])) def test_sort_reverse_sorted(self): msa = TabularMSA([DNA('T'), DNA('G'), DNA('A')], index=[3, 2, 1]) msa.sort() self.assertEqual( msa, TabularMSA([DNA('A'), DNA('G'), DNA('T')], index=[1, 2, 3])) msa = TabularMSA([DNA('T'), DNA('G'), DNA('A')], index=[1, 2, 3]) msa.sort(ascending=False) self.assertEqual( msa, TabularMSA([DNA('A'), DNA('G'), DNA('T')], index=[3, 2, 1])) def test_sort_multiindex(self): multiindex = [(2, 'a'), (1, 'c'), (3, 'b')] sortedindex = [(1, 'c'), (2, 'a'), (3, 'b')] msa = TabularMSA([DNA('A'), DNA('C'), DNA('G')], index=multiindex) msa.sort() self.assertEqual(msa, TabularMSA([DNA('C'), DNA('A'), DNA('G')], index=sortedindex)) def test_sort_multiindex_with_level(self): multiindex = [(2, 'a'), (1, 'c'), (3, 'b')] first_sorted = [(1, 'c'), (2, 'a'), (3, 'b')] second_sorted = [(2, 'a'), (3, 'b'), (1, 'c')] msa = TabularMSA([DNA('A'), DNA('C'), DNA('G')], index=multiindex) self.assertIsInstance(msa.index, pd.MultiIndex) msa.sort(level=0) self.assertEqual(msa, TabularMSA([DNA('C'), DNA('A'), DNA('G')], index=first_sorted)) msa.sort(level=1) self.assertEqual(msa, TabularMSA([DNA('A'), DNA('G'), DNA('C')], index=second_sorted)) def test_to_dict_falsey_msa(self): self.assertEqual(TabularMSA([]).to_dict(), {}) self.assertEqual(TabularMSA([RNA('')], index=['foo']).to_dict(), {'foo': RNA('')}) def test_to_dict_non_empty(self): seqs = [Protein('PAW', metadata={'id': 42}), Protein('WAP', metadata={'id': -999})] msa = TabularMSA(seqs, minter='id') self.assertEqual(msa.to_dict(), {42: seqs[0], -999: seqs[1]}) def test_to_dict_default_index(self): msa = TabularMSA([RNA('UUA'), RNA('-C-'), RNA('AAA')]) d = msa.to_dict() self.assertEqual(d, {0: RNA('UUA'), 1: RNA('-C-'), 2: RNA('AAA')}) def test_to_dict_duplicate_labels(self): msa = TabularMSA([DNA("A"), DNA("G")], index=[0, 0]) with self.assertRaises(ValueError) as cm: msa.to_dict() self.assertIn("unique", str(cm.exception)) def test_from_dict_to_dict_roundtrip(self): d = {} self.assertEqual(TabularMSA.from_dict(d).to_dict(), d) # can roundtrip even with mixed key types d1 = {'a': DNA('CAT'), 42: DNA('TAG')} d2 = TabularMSA.from_dict(d1).to_dict() self.assertEqual(d2, d1) self.assertIs(d1['a'], d2['a']) self.assertIs(d1[42], d2[42]) class TestContains(unittest.TestCase): def test_no_sequences(self): msa = TabularMSA([], index=[]) self.assertFalse('' in msa) self.assertFalse('foo' in msa) def test_with_str_labels(self): msa = TabularMSA([RNA('AU'), RNA('A.')], index=['foo', 'bar']) self.assertTrue('foo' in msa) self.assertTrue('bar' in msa) self.assertFalse('baz' in msa) self.assertFalse(0 in msa) def test_with_int_labels(self): msa = TabularMSA([RNA('AU'), RNA('A.')], index=[42, -1]) self.assertTrue(42 in msa) self.assertTrue(-1 in msa) self.assertFalse(0 in msa) self.assertFalse('foo' in msa) class TestCopy(unittest.TestCase): # Note: tests for metadata/positional_metadata are in mixin tests above. def test_no_sequences(self): msa = TabularMSA([]) msa_copy = copy.copy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) self.assertIsNot(msa._seqs, msa_copy._seqs) def test_with_sequences(self): msa = TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')]) msa_copy = copy.copy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) self.assertIsNot(msa._seqs, msa_copy._seqs) self.assertIsNot(msa[0], msa_copy[0]) self.assertIsNot(msa[1], msa_copy[1]) msa_copy.append(DNA('AAAA'), reset_index=True) self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')])) msa_copy._seqs[0].metadata['bar'] = 42 self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')])) msa_copy._seqs[0].metadata['foo'].append(2) self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1, 2]}), DNA('TGCA')])) def test_with_index(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')], index=['foo', 'bar']) msa_copy = copy.copy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) # pd.Index is immutable, no copy necessary. self.assertIs(msa.index, msa_copy.index) msa_copy.index = [1, 2] assert_index_equal(msa_copy.index, pd.Index([1, 2])) assert_index_equal(msa.index, pd.Index(['foo', 'bar'])) class TestDeepCopy(unittest.TestCase): # Note: tests for metadata/positional_metadata are in mixin tests above. def test_no_sequences(self): msa = TabularMSA([]) msa_copy = copy.deepcopy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) self.assertIsNot(msa._seqs, msa_copy._seqs) def test_with_sequences(self): msa = TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')]) msa_copy = copy.deepcopy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) self.assertIsNot(msa._seqs, msa_copy._seqs) self.assertIsNot(msa[0], msa_copy[0]) self.assertIsNot(msa[1], msa_copy[1]) msa_copy.append(DNA('AAAA'), reset_index=True) self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')])) msa_copy._seqs[0].metadata['bar'] = 42 self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')])) msa_copy._seqs[0].metadata['foo'].append(2) self.assertEqual( msa, TabularMSA([DNA('ACGT', metadata={'foo': [1]}), DNA('TGCA')])) def test_with_index(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')], index=['foo', 'bar']) msa_copy = copy.deepcopy(msa) self.assertEqual(msa, msa_copy) self.assertIsNot(msa, msa_copy) # pd.Index is immutable, no copy necessary. self.assertIs(msa.index, msa_copy.index) msa_copy.index = [1, 2] assert_index_equal(msa_copy.index, pd.Index([1, 2])) assert_index_equal(msa.index, pd.Index(['foo', 'bar'])) class SharedIndexTests: def get(self, obj, indexable): raise NotImplementedError() def test_tuple_too_big(self): with self.assertRaises(ValueError): self.get(TabularMSA([]), (None, None, None)) def test_empty_msa_slice(self): msa = TabularMSA([]) new = self.get(msa, slice(None, None)) self.assertIsNot(msa, new) self.assertEqual(msa, new) def test_msa_slice_all_first_axis(self): msa = TabularMSA([RNA("AAA", metadata={1: 1}), RNA("AAU", positional_metadata={0: [1, 2, 3]})], metadata={0: 0}, positional_metadata={1: [3, 2, 1]}) new_slice = self.get(msa, slice(None)) new_ellipsis = self.get(msa, Ellipsis) self.assertIsNot(msa, new_slice) for s1, s2 in zip(msa, new_slice): self.assertIsNot(s1, s2) self.assertEqual(msa, new_slice) self.assertIsNot(msa, new_ellipsis) for s1, s2 in zip(msa, new_ellipsis): self.assertIsNot(s1, s2) self.assertEqual(msa, new_ellipsis) def test_msa_slice_all_both_axes(self): msa = TabularMSA([RNA("AAA", metadata={1: 1}), RNA("AAU", positional_metadata={0: [1, 2, 3]})], metadata={0: 0}, positional_metadata={1: [3, 2, 1]}) new_slice = self.get(msa, (slice(None), slice(None))) new_ellipsis = self.get(msa, (Ellipsis, Ellipsis)) self.assertIsNot(msa, new_slice) for s1, s2 in zip(msa, new_slice): self.assertIsNot(s1, s2) self.assertEqual(msa, new_slice) self.assertIsNot(msa, new_ellipsis) for s1, s2 in zip(msa, new_ellipsis): self.assertIsNot(s1, s2) self.assertEqual(msa, new_ellipsis) def test_bool_index_first_axis(self): a = DNA("AAA", metadata={1: 1}) b = DNA("NNN", positional_metadata={1: ['x', 'y', 'z']}) c = DNA("AAC") msa = TabularMSA([a, b, c], metadata={0: 'x'}, positional_metadata={0: [1, 2, 3]}, index=[True, False, True]) new = self.get(msa, [True, True, False]) self.assertEqual(new, TabularMSA([a, b], metadata={0: 'x'}, positional_metadata={0: [1, 2, 3]}, index=[True, False])) def test_bool_index_second_axis(self): a = DNA("AAA", metadata={1: 1}) b = DNA("NNN", positional_metadata={1: ['x', 'y', 'z']}) c = DNA("AAC") msa = TabularMSA([a, b, c], metadata={0: 'x'}, positional_metadata={0: [1, 2, 3]}, index=[True, False, True]) new = self.get(msa, (Ellipsis, [True, True, False])) self.assertEqual(new, TabularMSA([a[0, 1], b[0, 1], c[0, 1]], metadata={0: 'x'}, positional_metadata={0: [1, 2]}, index=[True, False, True])) def test_bool_index_both_axes(self): a = DNA("AAA", metadata={1: 1}) b = DNA("NNN", positional_metadata={1: ['x', 'y', 'z']}) c = DNA("AAC") msa = TabularMSA([a, b, c], metadata={0: 'x'}, positional_metadata={0: [1, 2, 3]}, index=[True, False, True]) new = self.get(msa, ([False, True, True], [True, True, False])) self.assertEqual(new, TabularMSA([b[0, 1], c[0, 1]], metadata={0: 'x'}, positional_metadata={0: [1, 2]}, index=[False, True])) def test_bool_index_too_big(self): msa = TabularMSA([DNA("ABCD"), DNA("GHKM"), DNA("NRST")], index=[False, True, False]) with self.assertRaises(IndexError): self.get(msa, [False, False, False, False]) with self.assertRaises(IndexError): self.get(msa, [True, True, True, True]) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, [True, False, True, False, True])) with self.assertRaises(IndexError): self.get(msa, ([True, False, True, False], [True, False, True, False, False])) def test_bool_index_too_small(self): msa = TabularMSA([DNA("ABCD"), DNA("GHKM"), DNA("NRST")], index=[False, True, False]) with self.assertRaises(IndexError): self.get(msa, [False]) with self.assertRaises(IndexError): self.get(msa, [True]) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, [True])) with self.assertRaises(IndexError): self.get(msa, ([True, False], [True, False, True, False])) def test_bad_scalar(self): msa = TabularMSA([DNA("ABCD"), DNA("GHKM"), DNA("NRST")]) with self.assertRaises((KeyError, TypeError)): self.get(msa, "foo") with self.assertRaises(IndexError): self.get(msa, (Ellipsis, "foo")) def test_bad_fancy_index(self): msa = TabularMSA([DNA("ABCD"), DNA("GHKM"), DNA("NRST")]) with self.assertRaises((KeyError, TypeError, ValueError)): self.get(msa, [0, "foo"]) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, [0, "foo"])) def test_asburd_slice(self): msa = TabularMSA([DNA("ABCD"), DNA("GHKM"), DNA("NRST")]) with self.assertRaises(TypeError): self.get(msa, {set(1): 0}) class SharedPropertyIndexTests(SharedIndexTests): def setUp(self): self.combo_msa = TabularMSA([ DNA('ACGTA', metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4, 5]}), DNA('CGTAC', metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4, 5]}), DNA('GTACG', metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4, 5]}), DNA('TACGT', metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4, 5]}), DNA('ACGTT', metadata={4: 4}, positional_metadata={4: [1, 2, 3, 4, 5]}) ], index=list('ABCDE'), metadata={'x': 'x'}, positional_metadata={'y': [5, 4, 3, 2, 1]}) """First off, sorry to the next person who has to deal with this. The next few tests will try and slice by a bunch of stuff, with all combinations. Each element in the two lists is a tuple where the first element is the thing to slice with, and the second is the equivalent fancy index which describes the same range. This lets us describe the results a little more declaratively without setting up a thousand tests for each possible combination. This does mean the iloc via a fancy index and simple scalar must work correctly. """ # This will be overriden for TestLoc because the first axis are labels self.combo_first_axis = [ ([], []), (slice(0, 0), []), (Ellipsis, [0, 1, 2, 3, 4]), (slice(None), [0, 1, 2, 3, 4]), (slice(0, 10000), [0, 1, 2, 3, 4]), (3, 3), (-4, 1), ([0], [0]), ([2], [2]), (slice(1, 3), [1, 2]), (slice(3, 0, -1), [3, 2, 1]), ([-3, 2, 1], [2, 2, 1]), ([-4, -3, -2, -1], [1, 2, 3, 4]), (np.array([-3, 2, 1]), [2, 2, 1]), ([True, True, False, False, True], [0, 1, 4]), (np.array([True, True, False, True, False]), [0, 1, 3]), (range(3), [0, 1, 2]), ([slice(0, 2), slice(3, 4), 4], [0, 1, 3, 4]) ] # Same in both TestLoc and TestILoc self.combo_second_axis = self.combo_first_axis def test_combo_single_axis_natural(self): for idx, exp in self.combo_first_axis: self.assertEqual(self.get(self.combo_msa, idx), self.combo_msa.iloc[exp], msg="%r did not match iloc[%r]" % (idx, exp)) def test_combo_first_axis_only(self): for idx, exp in self.combo_first_axis: self.assertEqual(self.get(self.combo_msa, idx, axis=0), self.combo_msa.iloc[exp, ...], msg="%r did not match iloc[%r, ...]" % (idx, exp)) def test_combo_second_axis_only(self): for idx, exp in self.combo_second_axis: self.assertEqual(self.get(self.combo_msa, idx, axis=1), self.combo_msa.iloc[..., exp], msg="%r did not match iloc[..., %r]" % (idx, exp)) def test_combo_both_axes(self): for idx1, exp1 in self.combo_first_axis: for idx2, exp2 in self.combo_second_axis: self.assertEqual(self.get(self.combo_msa, (idx1, idx2)), self.combo_msa.iloc[exp1, exp2], msg=("%r did not match iloc[%r, %r]" % ((idx1, idx2), exp1, exp2))) class TestLoc(SharedPropertyIndexTests, unittest.TestCase): def setUp(self): SharedPropertyIndexTests.setUp(self) self.combo_first_axis = [ ([], []), (slice('X', "Z"), []), ('A', 0), ('E', 4), (['B'], [1]), (np.asarray(['B']), [1]), (slice('A', 'C', 2), [0, 2]), (slice('C', 'A', -2), [2, 0]), (slice('A', 'B'), [0, 1]), (slice(None), [0, 1, 2, 3, 4]), (slice('A', None), [0, 1, 2, 3, 4]), (slice(None, 'C'), [0, 1, 2]), (Ellipsis, [0, 1, 2, 3, 4]), (self.combo_msa.index, [0, 1, 2, 3, 4]), (['B', 'A', 'A', 'C'], [1, 0, 0, 2]), (np.asarray(['B', 'A', 'A', 'C']), [1, 0, 0, 2]), ([True, False, True, True, False], [0, 2, 3]), (np.asarray([True, False, True, True, False]), [0, 2, 3]), ] def test_forced_axis_returns_copy(self): msa = TabularMSA([Protein("EVANTHQMVS"), Protein("EVANTH*MVS")]) self.assertIsNot(msa.loc(axis=1), msa.loc) def test_forced_axis_no_mutate(self): msa = TabularMSA([Protein("EVANTHQMVS"), Protein("EVANTH*MVS")]) self.assertEqual(msa.loc(axis=1)[0], Sequence("EE")) self.assertEqual(msa.loc[0], Protein("EVANTHQMVS")) self.assertIsNone(msa.loc._axis) def get(self, obj, indexable, axis=None): if axis is None: return obj.loc[indexable] else: return obj.loc(axis=axis)[indexable] def test_complex_single_label(self): a = DNA("ACG") b = DNA("ACT") c = DNA("ACA") msa = TabularMSA([a, b, c], index=[('a', 0), ('a', 1), ('b', 0)]) self.assertIs(a, self.get(msa, (('a', 0),))) self.assertIs(b, self.get(msa, (('a', 1),))) self.assertIs(c, self.get(msa, (('b', 0),))) def test_partial_label(self): a = DNA("ACG") b = DNA("ACT") c = DNA("ACA") msa = TabularMSA([a, b, c], index=[('a', 0), ('a', 1), ('b', 0)]) exp_a = TabularMSA([a, b], index=[0, 1]) exp_b = TabularMSA([c], index=[0]) self.assertEqual(self.get(msa, 'a'), exp_a) self.assertEqual(self.get(msa, 'b'), exp_b) def test_label_not_exists(self): msa = TabularMSA([DNA("ACG")], index=['foo']) with self.assertRaises(KeyError): self.get(msa, 'bar') def test_duplicate_index_nonscalar_label(self): a = DNA("ACGA", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("A-GA", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("AAGA", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) d = DNA("ACCA", metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c, d], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[0, 0, 1, 2]) self.assertEqual(self.get(msa, 0), TabularMSA([a, b], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[0, 0])) def test_duplicate_index_scalar_label(self): a = DNA("ACGA", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("A-GA", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("AAGA", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) d = DNA("ACCA", metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c, d], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[0, 0, 1, 2]) self.assertEqual(self.get(msa, 1), c) def test_multiindex_complex(self): a = DNA("ACG") b = DNA("ACT") c = DNA("ACA") msa = TabularMSA([a, b, c], index=[('a', 0), ('a', 1), ('b', 0)]) exp = TabularMSA([a, c], index=[('a', 0), ('b', 0)]) self.assertEqual(self.get(msa, [('a', 0), ('b', 0)]), exp) def test_fancy_index_missing_label(self): msa = TabularMSA([DNA("ACG")], index=['foo']) with self.assertRaises(KeyError): self.get(msa, ['foo', 'bar']) with self.assertRaises(KeyError): self.get(msa, ['bar']) def test_multiindex_fancy_indexing_incomplete_label(self): a = RNA("UUAG", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = RNA("UAAG", metadata={1: 0}, positional_metadata={1: [1, 2, 3, 4]}) c = RNA("UAA-", metadata={2: 0}, positional_metadata={2: [1, 2, 3, 4]}) d = RNA("UA-G", metadata={3: 0}, positional_metadata={3: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c, d], metadata={'x': 'y'}, positional_metadata={'c': ['a', 'b', 'c', 'd']}, index=[('a', 'x', 0), ('a', 'x', 1), ('a', 'y', 2), ('b', 'x', 0)]) self.assertEqual(self.get(msa, (('a', 'x'), Ellipsis)), TabularMSA([a, b], metadata={'x': 'y'}, positional_metadata={'c': ['a', 'b', 'c', 'd']}, index=[0, 1])) def test_bool_index_scalar_bool_label(self): a = DNA("ACGA", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("A-GA", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("AAGA", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) d = DNA("ACCA", metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c, d], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[False, True, False, False]) self.assertEqual(self.get(msa, True), b) def test_bool_index_nonscalar_bool_label(self): a = DNA("ACGA", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("A-GA", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("AAGA", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) d = DNA("ACCA", metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c, d], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[False, True, False, True]) self.assertEqual(self.get(msa, True), TabularMSA([b, d], metadata={'x': 'y'}, positional_metadata={'z': [1, 2, 3, 4]}, index=[True, True])) def test_categorical_index_scalar_label(self): msa = TabularMSA([RNA("ACUG"), RNA("ACUA"), RNA("AAUG"), RNA("AC-G")], index=pd.CategoricalIndex(['a', 'b', 'b', 'c'])) self.assertEqual(self.get(msa, 'a'), RNA("ACUG")) def test_categorical_index_nonscalar_label(self): msa = TabularMSA([RNA("ACUG"), RNA("ACUA"), RNA("AAUG"), RNA("AC-G")], index=pd.CategoricalIndex(['a', 'b', 'b', 'c'])) self.assertEqual(self.get(msa, 'b'), TabularMSA([RNA("ACUA"), RNA("AAUG")], index=pd.CategoricalIndex( ['b', 'b'], categories=['a', 'b', 'c']) )) def test_float_index_out_of_order_slice(self): msa = TabularMSA([DNA("ACGG"), DNA("AAGC"), DNA("AAAA"), DNA("ACTC")], index=[0.1, 2.4, 5.1, 2.6]) with self.assertRaises(KeyError): self.get(msa, slice(0.1, 2.7)) msa.sort() result = self.get(msa, slice(0.1, 2.7)) self.assertEqual(result, TabularMSA([DNA("ACGG"), DNA("AAGC"), DNA("ACTC")], index=[0.1, 2.4, 2.6])) def test_nonscalar_fancy_index(self): msa = TabularMSA([DNA('ACGT'), DNA('ACGT'), DNA('ACGT')], index=[('a', 0, 1), ('a', 1, 1), ('b', 0, 1)]) with self.assertRaisesRegex(TypeError, r'tuple.*independent.*MultiIndex'): self.get(msa, ['a', 'b']) def test_missing_first_nonscalar_fancy_index(self): msa = TabularMSA([DNA('ACGT'), DNA('ACGT'), DNA('ACGT')], index=[('a', 0, 1), ('a', 1, 1), ('b', 0, 1)]) with self.assertRaises(KeyError): self.get(msa, ['x', 'a', 'b']) def test_tuple_fancy_index(self): msa = TabularMSA([DNA('ACGT'), DNA('ACGT'), DNA('ACGT')], index=[('a', 0, 1), ('a', 1, 1), ('b', 0, 1)]) with self.assertRaisesRegex(TypeError, r'tuple.*pd.MultiIndex.*label'): self.get(msa, ((('a', 0, 1), ('b', 0, 1)), Ellipsis)) def test_non_multiindex_tuple(self): msa = TabularMSA([DNA('ACGT'), DNA('ACGT'), DNA('ACGT')]) with self.assertRaisesRegex(TypeError, r'tuple.*first axis'): self.get(msa, ((0, 1), Ellipsis)) def test_assertion_exists_for_future_failure_of_get_sequence_loc(self): # Ideally we wouldn't need this test or the branch, but the most common # failure for pandas would be returning a series instead of the value. # We should make sure that the user get's an error should this ever # happen again. Getting a series of DNA looks pretty weird... msa = TabularMSA([DNA('ACGT'), DNA('ACGT'), DNA('ACGT')]) with self.assertRaises(AssertionError): msa._get_sequence_loc_([1, 2]) class TestILoc(SharedPropertyIndexTests, unittest.TestCase): def setUp(self): SharedPropertyIndexTests.setUp(self) self.combo_first_axis = self.combo_second_axis def test_forced_axis_returns_copy(self): msa = TabularMSA([Protein("EVANTHQMVS"), Protein("EVANTH*MVS")]) self.assertIsNot(msa.iloc(axis=1), msa.iloc) def test_forced_axis_no_mutate(self): msa = TabularMSA([Protein("EVANTHQMVS"), Protein("EVANTH*MVS")]) self.assertEqual(msa.iloc(axis=1)[0], Sequence("EE")) self.assertEqual(msa.iloc[0], Protein("EVANTHQMVS")) self.assertIsNone(msa.iloc._axis) def get(self, obj, indexable, axis=None): if axis is None: return obj.iloc[indexable] else: return obj.iloc(axis=axis)[indexable] def test_entire_fancy_first_axis(self): msa = TabularMSA([ DNA("ACCA", metadata={'a': 'foo'}, positional_metadata={'a': [7, 6, 5, 4]}), DNA("GGAA", metadata={'b': 'bar'}, positional_metadata={'b': [3, 4, 5, 6]}) ], metadata={'c': 'baz'}, positional_metadata={'foo': [1, 2, 3, 4]}) new_np_simple = self.get(msa, np.arange(2)) new_list_simple = self.get(msa, [0, 1]) new_list_backwards = self.get(msa, [-2, -1]) self.assertIsNot(msa, new_np_simple) self.assertEqual(msa, new_np_simple) self.assertIsNot(msa, new_list_simple) self.assertEqual(msa, new_list_simple) self.assertIsNot(msa, new_list_backwards) self.assertEqual(msa, new_list_backwards) def test_fancy_entire_second_axis(self): msa = TabularMSA([ DNA("ACCA", metadata={'a': 'foo'}, positional_metadata={'a': [7, 6, 5, 4]}), DNA("GGAA", metadata={'b': 'bar'}, positional_metadata={'b': [3, 4, 5, 6]}) ], metadata={'c': 'baz'}, positional_metadata={'foo': [1, 2, 3, 4]}) new_np_simple = self.get(msa, (Ellipsis, np.arange(4))) new_list_simple = self.get(msa, (Ellipsis, [0, 1, 2, 3])) new_list_backwards = self.get(msa, (Ellipsis, [-4, -3, -2, -1])) self.assertIsNot(msa, new_np_simple) self.assertEqual(msa, new_np_simple) self.assertIsNot(msa, new_list_simple) self.assertEqual(msa, new_list_simple) self.assertIsNot(msa, new_list_backwards) self.assertEqual(msa, new_list_backwards) def test_fancy_entire_both_axes(self): msa = TabularMSA([ DNA("ACCA", metadata={'a': 'foo'}, positional_metadata={'a': [7, 6, 5, 4]}), DNA("GGAA", metadata={'b': 'bar'}, positional_metadata={'b': [3, 4, 5, 6]}) ], metadata={'c': 'baz'}, positional_metadata={'foo': [1, 2, 3, 4]}) new_np_simple = self.get(msa, (np.arange(2), np.arange(4))) new_list_simple = self.get(msa, ([0, 1], [0, 1, 2, 3])) new_list_backwards = self.get(msa, ([-2, -1], [-4, -3, -2, -1])) self.assertIsNot(msa, new_np_simple) self.assertEqual(msa, new_np_simple) self.assertIsNot(msa, new_list_simple) self.assertEqual(msa, new_list_simple) self.assertIsNot(msa, new_list_backwards) self.assertEqual(msa, new_list_backwards) def test_fancy_out_of_bound(self): with self.assertRaises(IndexError): self.get(TabularMSA([DNA('AC')]), [0, 1, 2]) with self.assertRaises(IndexError): self.get(TabularMSA([DNA('AC')]), (Ellipsis, [0, 1, 2])) def test_fancy_empty_both_axis(self): msa = TabularMSA([DNA("ACGT", metadata={'x': 1}), DNA("TGCA", metadata={'y': 2})], index=list("AB")) new_np_simple = self.get(msa, (np.arange(0), np.arange(0))) new_list_simple = self.get(msa, ([], [])) self.assertEqual(TabularMSA([]), new_np_simple) self.assertEqual(TabularMSA([]), new_list_simple) def test_fancy_standard_first_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, [0, 2]), TabularMSA([a, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}, index=[0, 2])) def test_fancy_standard_second_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, (Ellipsis, [0, 2])), TabularMSA([a[0, 2], b[0, 2], c[0, 2]], metadata={3: 3}, positional_metadata={3: [1, 3]}, index=[0, 1, 2])) def test_fancy_standard_both_axes(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, ([0, 2], [0, 2])), TabularMSA([a[0, 2], c[0, 2]], metadata={3: 3}, positional_metadata={3: [1, 3]}, index=[0, 2])) def test_fancy_empty_first_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) # TODO: Change for #1198 self.assertEqual(self.get(msa, []), TabularMSA([], metadata={3: 3})) def test_fancy_empty_second_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, (Ellipsis, [])), TabularMSA([a[0:0], b[0:0], c[0:0]], metadata={3: 3}, positional_metadata={3: np.array( [], dtype=int)})) def test_fancy_empty_both_axes(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) # TODO: Change for #1198 self.assertEqual(self.get(msa, ([], [])), TabularMSA([], metadata={3: 3})) def test_fancy_out_of_bounds_first_axis(self): msa = TabularMSA([DNA("ACGT"), DNA("GCAT")]) with self.assertRaises(IndexError): self.get(msa, [10]) with self.assertRaises(IndexError): self.get(msa, [0, 1, 10]) def test_fancy_out_of_bounds_second_axis(self): msa = TabularMSA([DNA("ACGT"), DNA("GCAT")]) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, [10])) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, [1, 2, 4])) def test_get_scalar_first_axis(self): a = DNA("AA", metadata={'a': 'foo'}, positional_metadata={'x': [1, 2]}) b = DNA("GG", metadata={'b': 'bar'}, positional_metadata={'y': [3, 4]}) msa = TabularMSA([a, b]) new0 = self.get(msa, 0) new1 = self.get(msa, 1) self.assertEqual(new0, a) self.assertEqual(new1, b) def test_get_scalar_second_axis(self): a = DNA("AA", metadata={'a': 'foo'}, positional_metadata={'x': [1, 2]}) b = DNA("GC", metadata={'b': 'bar'}, positional_metadata={'y': [3, 4]}) msa = TabularMSA([a, b], positional_metadata={'z': [5, 6]}) new0 = self.get(msa, (Ellipsis, 0)) new1 = self.get(msa, (Ellipsis, 1)) self.assertEqual(new0, Sequence("AG", metadata={'z': 5}, positional_metadata={'x': [1, np.nan], 'y': [np.nan, 3]})) self.assertEqual(new1, Sequence("AC", metadata={'z': 6}, positional_metadata={'x': [2, np.nan], 'y': [np.nan, 4]})) def test_scalar_sliced_first_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGT", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, (1, [1, 3])), DNA("CT", metadata={1: 1}, positional_metadata={1: [2, 4]})) def test_scalar_sliced_second_axis(self): a = DNA("ACGT", metadata={0: 0}, positional_metadata={0: [1, 2, 3, 4]}) b = DNA("ACGA", metadata={1: 1}, positional_metadata={1: [1, 2, 3, 4]}) c = DNA("ACGT", metadata={2: 2}, positional_metadata={2: [1, 2, 3, 4]}) msa = TabularMSA([a, b, c], metadata={3: 3}, positional_metadata={3: [1, 2, 3, 4]}) self.assertEqual(self.get(msa, ([1, 2], 3)), Sequence("AT", metadata={3: 4}, positional_metadata={1: [4, np.nan], 2: [np.nan, 4]})) def test_get_scalar_out_of_bound_first_axis(self): a = DNA("AA", metadata={'a': 'foo'}, positional_metadata={'x': [1, 2]}) b = DNA("GC", metadata={'b': 'bar'}, positional_metadata={'y': [3, 4]}) msa = TabularMSA([a, b], positional_metadata={'z': [5, 6]}) with self.assertRaises(IndexError): self.get(msa, 3) def test_get_scalar_out_of_bound_second_axis(self): a = DNA("AA", metadata={'a': 'foo'}, positional_metadata={'x': [1, 2]}) b = DNA("GC", metadata={'b': 'bar'}, positional_metadata={'y': [3, 4]}) msa = TabularMSA([a, b], positional_metadata={'z': [5, 6]}) with self.assertRaises(IndexError): self.get(msa, (Ellipsis, 3)) class TestGetItem(SharedIndexTests, unittest.TestCase): def get(self, obj, indexable): return obj[indexable] def test_uses_iloc_not_loc(self): a = DNA("ACGA") b = DNA("ACGT") msa = TabularMSA([a, b], index=[1, 0]) self.assertIs(msa[0], a) self.assertIs(msa[1], b) class TestConstructor(unittest.TestCase): def setUp(self): self.seqs = [DNA("ACGT"), DNA("GCTA")] self.m = {'x': 'y', 0: 1} self.pm = pd.DataFrame({'foo': [1, 2, 3, 4]}) self.index = pd.Index(['a', 'b']) self.msa = TabularMSA(self.seqs, metadata=self.m, positional_metadata=self.pm, index=self.index) def test_no_override(self): result = self.msa._constructor_() self.assertEqual(self.msa, result) for seq1, seq2 in zip(result, self.msa): self.assertIsNot(seq1, seq2) self.assertIsNot(result.metadata, self.msa.metadata) self.assertIsNot(result.positional_metadata, self.msa.positional_metadata) def test_sequence_override_same_seqs(self): result = self.msa._constructor_(sequences=self.seqs) self.assertEqual(self.msa, result) for seq1, seq2 in zip(result, self.msa): self.assertIsNot(seq1, seq2) self.assertIsNot(result.metadata, self.msa.metadata) self.assertIsNot(result.positional_metadata, self.msa.positional_metadata) def test_sequence_override(self): seqs = [RNA("ACGU"), RNA("GCUA")] result = self.msa._constructor_(sequences=seqs) self.assertNotEqual(result, self.msa) self.assertEqual(list(result), seqs) assert_index_equal(result.index, self.index) self.assertEqual(result.metadata, self.m) assert_data_frame_almost_equal(result.positional_metadata, self.pm) def test_no_override_no_md(self): msa = TabularMSA(self.seqs, index=self.index) self.assertEqual(msa, msa._constructor_()) def test_metadata_override(self): new_md = {'foo': {'x': 0}} result = self.msa._constructor_(metadata=new_md) self.assertNotEqual(result, self.msa) self.assertEqual(list(result), self.seqs) assert_index_equal(result.index, self.index) self.assertEqual(result.metadata, new_md) assert_data_frame_almost_equal(result.positional_metadata, self.pm) def test_positional_metadata_override(self): new_pm = pd.DataFrame({'x': [1, 2, 3, 4]}) result = self.msa._constructor_(positional_metadata=new_pm) self.assertNotEqual(result, self.msa) self.assertEqual(list(result), self.seqs) assert_index_equal(result.index, self.index) self.assertEqual(result.metadata, self.m) assert_data_frame_almost_equal(result.positional_metadata, new_pm) def test_index_override(self): new_index = pd.Index([('a', 0), ('b', 1)]) result = self.msa._constructor_(index=new_index) self.assertNotEqual(result, self.msa) self.assertEqual(list(result), self.seqs) assert_index_equal(result.index, new_index) self.assertEqual(result.metadata, self.m) assert_data_frame_almost_equal(result.positional_metadata, self.pm) class TestAppend(unittest.TestCase): # Error cases def test_invalid_minter_index_reset_index_parameter_combos(self): msa = TabularMSA([]) param_combos = ( {}, {'minter': str, 'index': 'foo', 'reset_index': True}, {'minter': str, 'index': 'foo'}, {'minter': str, 'reset_index': True}, {'index': 'foo', 'reset_index': True} ) for params in param_combos: with self.assertRaisesRegex(ValueError, r"one of.*minter.*index.*reset_index"): msa.append(DNA('ACGT'), **params) self.assertEqual(msa, TabularMSA([])) def test_invalid_dtype(self): msa = TabularMSA([]) with self.assertRaisesRegex(TypeError, r'GrammaredSequence.*Sequence'): msa.append(Sequence(''), reset_index=True) self.assertEqual(msa, TabularMSA([])) def test_dtype_mismatch_rna(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex(TypeError, r'matching type.*RNA.*DNA'): msa.append(RNA('UUUU'), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_dtype_mismatch_float(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex(TypeError, r'matching type.*float.*DNA'): msa.append(42.0, reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_length_mismatch(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex( ValueError, r'must match the number of positions.*5 != 4'): msa.append(DNA('ACGTA'), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_invalid_minter(self): msa = TabularMSA([DNA('ACGT')], index=['foo']) with self.assertRaises(KeyError): msa.append(DNA('AAAA'), minter='id') self.assertEqual(msa, TabularMSA([DNA('ACGT')], index=['foo'])) # Valid cases: `minter` def test_minter_empty_msa(self): msa = TabularMSA([]) msa.append(DNA('ACGT'), minter=str) self.assertEqual(msa, TabularMSA([DNA('ACGT')], minter=str)) def test_minter_metadata_key(self): msa = TabularMSA([DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'})], minter='id') msa.append(DNA('', metadata={'id': 'c'}), minter='id') self.assertEqual( msa, TabularMSA([ DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'}), DNA('', metadata={'id': 'c'})], minter='id')) def test_minter_callable(self): msa = TabularMSA([DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'})], minter='id') msa.append(DNA(''), minter=str) self.assertEqual( msa, TabularMSA([ DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'}), DNA('')], index=['a', 'b', ''])) def test_multiindex_minter_empty_msa(self): def multiindex_minter(seq): return ('foo', 42) msa = TabularMSA([]) msa.append(DNA('AC'), minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42)])) def test_multiindex_minter_non_empty_msa(self): def multiindex_minter(seq): return ('baz', 44) msa = TabularMSA([RNA('UU'), RNA('CA')], index=[('foo', 42), ('bar', 43)]) msa.append(RNA('AC'), minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43), ('baz', 44)])) # Valid cases: `index` def test_index_empty_msa(self): msa = TabularMSA([]) msa.append(DNA('ACGT'), index='a') self.assertEqual( msa, TabularMSA([DNA('ACGT')], index=['a'])) def test_index_non_empty_msa(self): msa = TabularMSA([DNA('AC'), DNA('GT')], index=['a', 'b']) msa.append(DNA('--'), index='foo') self.assertEqual( msa, TabularMSA([DNA('AC'), DNA('GT'), DNA('--')], index=['a', 'b', 'foo'])) def test_multiindex_index_empty_msa(self): msa = TabularMSA([]) msa.append(DNA('AA'), index=('foo', 42)) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42)])) def test_multiindex_index_non_empty_msa(self): msa = TabularMSA([RNA('A'), RNA('C')], index=[('foo', 42), ('bar', 43)]) msa.append(RNA('U'), index=('baz', 44)) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43), ('baz', 44)])) # Valid cases: `reset_index` def test_reset_index_empty_msa(self): msa = TabularMSA([]) msa.append(DNA('ACGT'), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT')])) assert_index_equal(msa.index, pd.RangeIndex(1)) def test_reset_index_default_index(self): msa = TabularMSA([DNA('ACGT'), DNA('CCCC')]) msa.append(DNA('ACGT'), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('CCCC'), DNA('ACGT')])) assert_index_equal(msa.index, pd.RangeIndex(3)) def test_reset_index_non_default_index(self): msa = TabularMSA([DNA('ACGT'), DNA('CCCC')], index=['foo', 'bar']) msa.append(DNA('ACGT'), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('CCCC'), DNA('ACGT')])) assert_index_equal(msa.index, pd.RangeIndex(3)) def test_reset_index_bool_cast(self): msa = TabularMSA([RNA('AC'), RNA('UU')], index=[42, 43]) msa.append(RNA('..'), reset_index='abc') self.assertEqual(msa, TabularMSA([RNA('AC'), RNA('UU'), RNA('..')])) assert_index_equal(msa.index, pd.RangeIndex(3)) # Valid cases (misc) def test_index_type_change(self): msa = TabularMSA([DNA('A'), DNA('.')]) msa.append(DNA('C'), index='foo') self.assertEqual( msa, TabularMSA([DNA('A'), DNA('.'), DNA('C')], index=[0, 1, 'foo'])) def test_duplicate_index(self): msa = TabularMSA([DNA('A'), DNA('.')], index=['foo', 'bar']) msa.append(DNA('C'), index='foo') self.assertEqual( msa, TabularMSA([DNA('A'), DNA('.'), DNA('C')], index=['foo', 'bar', 'foo'])) def test_empty_msa_with_positional_metadata_no_new_positions(self): msa = TabularMSA([], positional_metadata={'foo': []}) msa.append(DNA(''), reset_index=True) self.assertEqual( msa, TabularMSA([DNA('')], positional_metadata={'foo': []})) def test_empty_msa_with_positional_metadata_add_new_positions(self): # bug in 0.4.2 msa = TabularMSA([], positional_metadata={'foo': []}) msa.append(DNA('AA'), reset_index=True) self.assertEqual( msa, TabularMSA([DNA('AA')])) class TestExtend(unittest.TestCase): # Error cases # # Note: these tests check that the MSA isn't mutated when an error is # raised. Where applicable, the "invalid" sequence is preceded by valid # sequence(s) to test one possible (buggy) implementation of `extend`: # looping over `sequences` and calling `append`. These tests ensure that # valid sequences aren't appended to the MSA before the error is raised. def test_invalid_minter_index_reset_index_parameter_combos(self): msa = TabularMSA([]) param_combos = ( {}, {'minter': str, 'index': 'foo', 'reset_index': True}, {'minter': str, 'index': 'foo'}, {'minter': str, 'reset_index': True}, {'index': 'foo', 'reset_index': True} ) for params in param_combos: with self.assertRaisesRegex(ValueError, r"one of.*minter.*index.*reset_index"): msa.extend([DNA('ACGT')], **params) self.assertEqual(msa, TabularMSA([])) def test_from_tabular_msa_index_param_still_required(self): msa = TabularMSA([DNA('AC'), DNA('TG')]) with self.assertRaisesRegex(ValueError, r"one of.*minter.*index.*reset_index"): msa.extend(TabularMSA([DNA('GG'), DNA('CC')])) self.assertEqual(msa, TabularMSA([DNA('AC'), DNA('TG')])) def test_invalid_dtype(self): msa = TabularMSA([]) with self.assertRaisesRegex(TypeError, r'GrammaredSequence.*Sequence'): msa.extend([Sequence('')], reset_index=True) self.assertEqual(msa, TabularMSA([])) def test_dtype_mismatch_rna(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex(TypeError, r'matching type.*RNA.*DNA'): msa.extend([DNA('----'), RNA('UUUU')], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_dtype_mismatch_float(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex(TypeError, r'matching type.*float.*DNA'): msa.extend([DNA('GGGG'), 42.0], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_length_mismatch(self): msa = TabularMSA([DNA('ACGT'), DNA('TGCA')]) with self.assertRaisesRegex( ValueError, r'must match the number of positions.*5 != 4'): msa.extend([DNA('TTTT'), DNA('ACGTA')], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_invalid_minter(self): msa = TabularMSA([DNA('ACGT')], index=['foo']) with self.assertRaises(KeyError): msa.extend([DNA('AAAA', metadata={'id': 'foo'}), DNA('----')], minter='id') self.assertEqual(msa, TabularMSA([DNA('ACGT')], index=['foo'])) def test_invalid_index(self): msa = TabularMSA([DNA('ACGT')], index=['foo']) with self.assertRaises(TypeError): msa.extend([DNA('----')], index=42) self.assertEqual(msa, TabularMSA([DNA('ACGT')], index=['foo'])) def test_sequences_index_length_mismatch(self): msa = TabularMSA([]) with self.assertRaisesRegex(ValueError, r'sequences.*2.*index length.*3'): msa.extend([DNA('TTTT'), DNA('ACGT')], index=['a', 'b', 'c']) self.assertEqual(msa, TabularMSA([])) # Valid cases: `minter` def test_minter_empty_msa(self): msa = TabularMSA([]) msa.extend([RNA('UU'), RNA('--')], minter=str) self.assertEqual(msa, TabularMSA([RNA('UU'), RNA('--')], minter=str)) def test_minter_metadata_key(self): msa = TabularMSA([DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'})], minter='id') msa.extend([DNA('', metadata={'id': 'c'}), DNA('', metadata={'id': 'd'})], minter='id') self.assertEqual( msa, TabularMSA([ DNA('', metadata={'id': 'a'}), DNA('', metadata={'id': 'b'}), DNA('', metadata={'id': 'c'}), DNA('', metadata={'id': 'd'})], minter='id')) def test_minter_callable(self): msa = TabularMSA([DNA('A', metadata={'id': 'a'}), DNA('C', metadata={'id': 'b'})], minter='id') msa.extend([DNA('G'), DNA('T')], minter=str) self.assertEqual( msa, TabularMSA([ DNA('A', metadata={'id': 'a'}), DNA('C', metadata={'id': 'b'}), DNA('G'), DNA('T')], index=['a', 'b', 'G', 'T'])) def test_multiindex_minter_empty_msa(self): def multiindex_minter(seq): if str(seq) == 'AC': return ('foo', 42) else: return ('bar', 43) msa = TabularMSA([]) msa.extend([DNA('AC'), DNA('GG')], minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43)])) def test_multiindex_minter_non_empty_msa(self): def multiindex_minter(seq): if str(seq) == 'C': return ('baz', 44) else: return ('baz', 45) msa = TabularMSA([DNA('A'), DNA('G')], index=[('foo', 42), ('bar', 43)]) msa.extend([DNA('C'), DNA('T')], minter=multiindex_minter) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal( msa.index, pd.Index([('foo', 42), ('bar', 43), ('baz', 44), ('baz', 45)])) # Valid cases: `index` def test_index_empty_msa(self): msa = TabularMSA([]) msa.extend([RNA('UAC'), RNA('AAU')], index=['foo', 'bar']) self.assertEqual(msa, TabularMSA([RNA('UAC'), RNA('AAU')], index=['foo', 'bar'])) def test_index_non_empty_msa(self): msa = TabularMSA([DNA('AC'), DNA('GT')], index=['a', 'b']) msa.extend([DNA('--'), DNA('..')], index=['foo', 'bar']) self.assertEqual( msa, TabularMSA([DNA('AC'), DNA('GT'), DNA('--'), DNA('..')], index=['a', 'b', 'foo', 'bar'])) def test_multiindex_index_empty_msa(self): msa = TabularMSA([]) msa.extend([DNA('AA'), DNA('GG')], index=[('foo', 42), ('bar', 43)]) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal(msa.index, pd.Index([('foo', 42), ('bar', 43)])) def test_multiindex_index_non_empty_msa(self): msa = TabularMSA([DNA('.'), DNA('-')], index=[('foo', 42), ('bar', 43)]) msa.extend([DNA('A'), DNA('G')], index=[('baz', 44), ('baz', 45)]) self.assertIsInstance(msa.index, pd.MultiIndex) assert_index_equal( msa.index, pd.Index([('foo', 42), ('bar', 43), ('baz', 44), ('baz', 45)])) def test_index_object_empty_msa(self): msa = TabularMSA([]) msa.extend([DNA('AA'), DNA('GG')], index=pd.RangeIndex(2)) self.assertEqual(msa, TabularMSA([DNA('AA'), DNA('GG')])) assert_index_equal(msa.index, pd.RangeIndex(2)) def test_index_object_non_empty_msa(self): msa = TabularMSA([DNA('CT'), DNA('GG')]) msa.extend([DNA('AA'), DNA('GG')], index=pd.RangeIndex(2)) self.assertEqual( msa, TabularMSA([DNA('CT'), DNA('GG'), DNA('AA'), DNA('GG')], index=[0, 1, 0, 1])) # Valid cases: `reset_index` def test_reset_index_empty_msa(self): msa = TabularMSA([]) msa.extend([DNA('ACGT'), DNA('----')], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('----')])) assert_index_equal(msa.index, pd.RangeIndex(2)) def test_reset_index_empty_msa_empty_iterable(self): msa = TabularMSA([]) msa.extend([], reset_index=True) self.assertEqual(msa, TabularMSA([])) assert_index_equal(msa.index, pd.RangeIndex(0)) def test_reset_index_non_empty_msa_empty_iterable(self): msa = TabularMSA([RNA('UU'), RNA('CC')], index=['a', 'b']) msa.extend([], reset_index=True) self.assertEqual(msa, TabularMSA([RNA('UU'), RNA('CC')])) assert_index_equal(msa.index, pd.RangeIndex(2)) def test_reset_index_default_index(self): msa = TabularMSA([DNA('A'), DNA('G')]) msa.extend([DNA('.'), DNA('-')], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('A'), DNA('G'), DNA('.'), DNA('-')])) assert_index_equal(msa.index, pd.RangeIndex(4)) def test_reset_index_non_default_index(self): msa = TabularMSA([DNA('A'), DNA('G')], index=['a', 'b']) msa.extend([DNA('.'), DNA('-')], reset_index=True) self.assertEqual(msa, TabularMSA([DNA('A'), DNA('G'), DNA('.'), DNA('-')])) assert_index_equal(msa.index, pd.RangeIndex(4)) def test_reset_index_from_tabular_msa(self): msa = TabularMSA([DNA('AC'), DNA('TG')], index=[42, 43]) msa.extend(TabularMSA([DNA('GG'), DNA('CC'), DNA('AA')], index=['a', 'b', 'c']), reset_index=True) self.assertEqual( msa, TabularMSA([DNA('AC'), DNA('TG'), DNA('GG'), DNA('CC'), DNA('AA')])) assert_index_equal(msa.index, pd.RangeIndex(5)) def test_reset_index_bool_cast(self): msa = TabularMSA([RNA('AC'), RNA('UU')], index=[42, 43]) msa.extend([RNA('..')], reset_index='abc') self.assertEqual(msa, TabularMSA([RNA('AC'), RNA('UU'), RNA('..')])) assert_index_equal(msa.index, pd.RangeIndex(3)) # Valid cases (misc) def test_index_type_change(self): msa = TabularMSA([DNA('A'), DNA('.')]) msa.extend([DNA('C')], index=['foo']) self.assertEqual( msa, TabularMSA([DNA('A'), DNA('.'), DNA('C')], index=[0, 1, 'foo'])) def test_duplicate_index(self): msa = TabularMSA([DNA('A'), DNA('.')], index=['foo', 'bar']) msa.extend([DNA('C'), DNA('.')], index=['foo', 'baz']) self.assertEqual( msa, TabularMSA([DNA('A'), DNA('.'), DNA('C'), DNA('.')], index=['foo', 'bar', 'foo', 'baz'])) def test_empty_msa_with_positional_metadata_no_new_positions(self): msa = TabularMSA([], positional_metadata={'foo': []}) msa.extend([DNA(''), DNA('')], reset_index=True) self.assertEqual( msa, TabularMSA([DNA(''), DNA('')], positional_metadata={'foo': []})) def test_empty_msa_with_positional_metadata_add_new_positions(self): # bug in 0.4.2 msa = TabularMSA([], positional_metadata={'foo': []}) msa.extend([DNA('AA'), DNA('GG')], reset_index=True) self.assertEqual( msa, TabularMSA([DNA('AA'), DNA('GG')])) def test_empty_msa_empty_iterable(self): msa = TabularMSA([]) msa.extend([], minter=str) self.assertEqual(msa, TabularMSA([])) def test_non_empty_msa_empty_iterable(self): msa = TabularMSA([DNA('AC')], index=['foo']) msa.extend([], index=[]) self.assertEqual(msa, TabularMSA([DNA('AC')], index=['foo'])) def test_single_sequence(self): msa = TabularMSA([DNA('AC')]) msa.extend([DNA('-C')], minter=str) self.assertEqual(msa, TabularMSA([DNA('AC'), DNA('-C')], index=[0, '-C'])) def test_multiple_sequences(self): msa = TabularMSA([DNA('AC')]) msa.extend([DNA('-C'), DNA('AG')], minter=str) self.assertEqual(msa, TabularMSA([DNA('AC'), DNA('-C'), DNA('AG')], index=[0, '-C', 'AG'])) def test_from_iterable(self): msa = TabularMSA([]) msa.extend(iter([DNA('ACGT'), DNA('TGCA')]), reset_index=True) self.assertEqual(msa, TabularMSA([DNA('ACGT'), DNA('TGCA')])) def test_from_tabular_msa_with_index(self): msa1 = TabularMSA([DNA('AC'), DNA('TG')]) msa2 = TabularMSA([DNA('GG'), DNA('CC'), DNA('AA')]) msa1.extend(msa2, index=msa2.index) self.assertEqual( msa1, TabularMSA([DNA('AC'), DNA('TG'), DNA('GG'), DNA('CC'), DNA('AA')], index=[0, 1, 0, 1, 2])) class TestJoin(unittest.TestCase): def assertEqualJoinedMSA(self, msa1, msa2): # `TabularMSA.join` doesn't guarantee index order in the joined MSA. # The order differs across pandas versions, so sort each MSA before # comparing for equality. # copy because `TabularMSA.sort` is in-place. msa1 = copy.copy(msa1) msa2 = copy.copy(msa2) msa1.sort() msa2.sort() self.assertEqual(msa1, msa2) def test_invalid_how(self): with self.assertRaisesRegex(ValueError, r'`how`'): TabularMSA([]).join(TabularMSA([]), how='really') def test_invalid_other_type(self): with self.assertRaisesRegex(TypeError, r'TabularMSA.*DNA'): TabularMSA([]).join(DNA('ACGT')) def test_dtype_mismatch(self): with self.assertRaisesRegex(TypeError, r'dtype.*RNA.*DNA'): TabularMSA([DNA('AC')]).join(TabularMSA([RNA('UG')])) with self.assertRaisesRegex(TypeError, r'dtype.*None.*DNA'): TabularMSA([DNA('AC')]).join(TabularMSA([])) with self.assertRaisesRegex(TypeError, r'dtype.*DNA.*None'): TabularMSA([]).join(TabularMSA([DNA('AC')])) def test_duplicate_index_labels(self): with self.assertRaisesRegex(ValueError, r"This MSA's index labels.*unique"): TabularMSA([DNA('AC'), DNA('--')], index=[0, 0]).join( TabularMSA([DNA('GT'), DNA('..')])) with self.assertRaisesRegex(ValueError, r"`other`'s index labels.*unique"): TabularMSA([DNA('AC'), DNA('--')]).join( TabularMSA([DNA('GT'), DNA('..')], index=[0, 0])) def test_no_metadata(self): msa1 = TabularMSA([DNA('AC'), DNA('G.')]) msa2 = TabularMSA([DNA('-C'), DNA('.G')]) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([DNA('AC-C'), DNA('G..G')])) def test_ignores_metadata(self): msa1 = TabularMSA([DNA('AC', metadata={'id': 'a'}), DNA('G.', metadata={'id': 'b'}), DNA('C-', metadata={'id': 'c'})], metadata={'id': 'msa1'}) msa2 = TabularMSA([DNA('-C', metadata={'id': 'd'}), DNA('.G', metadata={'id': 'e'}), DNA('CA', metadata={'id': 'f'})], index=[2, 1, 0], metadata={'id': 'msa2'}) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([DNA('ACCA'), DNA('G..G'), DNA('C--C')])) def test_outer_join_on_per_sequence_positional_metadata(self): msa1 = TabularMSA([ DNA('AC', positional_metadata={'1': [1, 2], 'foo': ['a', 'b']}), DNA('GT', positional_metadata={'2': [3, 4], 'foo': ['c', 'd']})]) msa2 = TabularMSA([ DNA('CA', positional_metadata={'3': [5, 6], 'foo': ['e', 'f']}), DNA('TG', positional_metadata={'4': [7, 8], 'foo': ['g', 'h']})]) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([ DNA('ACCA', positional_metadata={'1': [1, 2, np.nan, np.nan], '3': [np.nan, np.nan, 5, 6], 'foo': ['a', 'b', 'e', 'f']}), DNA('GTTG', positional_metadata={'2': [3, 4, np.nan, np.nan], '4': [np.nan, np.nan, 7, 8], 'foo': ['c', 'd', 'g', 'h']})])) def test_no_sequences(self): msa1 = TabularMSA([], positional_metadata={'foo': []}) msa2 = TabularMSA([], positional_metadata={'foo': []}) joined = msa1.join(msa2) self.assertEqualJoinedMSA(joined, TabularMSA([])) def test_no_positions(self): msa1 = TabularMSA([DNA('', positional_metadata={'1': []}), DNA('', positional_metadata={'2': []})], positional_metadata={'foo': []}) msa2 = TabularMSA([DNA('', positional_metadata={'3': []}), DNA('', positional_metadata={'4': []})], positional_metadata={'foo': []}) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([DNA('', positional_metadata={'1': [], '3': []}), DNA('', positional_metadata={'2': [], '4': []})], positional_metadata={'foo': []})) def test_one_with_positions_one_without_positions(self): msa1 = TabularMSA([DNA('A', positional_metadata={'1': ['a']}), DNA('C', positional_metadata={'2': ['b']})], positional_metadata={'foo': ['bar']}) msa2 = TabularMSA([DNA('', positional_metadata={'3': []}), DNA('', positional_metadata={'4': []})], positional_metadata={'foo': []}) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([DNA('A', positional_metadata={'1': ['a'], '3': [np.nan]}), DNA('C', positional_metadata={'2': ['b'], '4': [np.nan]})], positional_metadata={'foo': ['bar']})) def test_how_strict(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-')], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-C'), DNA('.G'), DNA('CA')], index=[2, 1, 0], positional_metadata={'foo': [3, 4], 'bar': ['c', 'd']}) joined = msa1.join(msa2) self.assertEqualJoinedMSA( joined, TabularMSA([DNA('ACCA'), DNA('G..G'), DNA('C--C')], positional_metadata={'bar': ['a', 'b', 'c', 'd'], 'foo': [1, 2, 3, 4]})) def test_how_strict_failure_index_mismatch(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-')]) msa2 = TabularMSA([DNA('-C'), DNA('.G'), DNA('CA'), DNA('--')]) with self.assertRaisesRegex(ValueError, r'Index labels must all ' 'match'): msa1.join(msa2) def test_how_strict_failure_positional_metadata_mismatch(self): msa1 = TabularMSA([DNA('AC'), DNA('G.')], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-C'), DNA('.G')], positional_metadata={'foo': [3, 4]}) with self.assertRaisesRegex(ValueError, r'Positional metadata columns.*match'): msa1.join(msa2) def test_how_inner(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-'), DNA('--')], index=[0, 1, 2, 3], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-C'), DNA('.G'), DNA('CA'), DNA('..')], index=[2, 1, 0, -1], positional_metadata={'foo': [3, 4], 'baz': ['c', 'd']}) joined = msa1.join(msa2, how='inner') self.assertEqualJoinedMSA( joined, TabularMSA([DNA('C--C'), DNA('G..G'), DNA('ACCA')], index=[2, 1, 0], positional_metadata={'foo': [1, 2, 3, 4]})) def test_how_inner_no_positional_metadata_overlap(self): msa1 = TabularMSA([DNA('AC'), DNA('G.')], index=['b', 'a'], positional_metadata={'foo': [1, 2]}) msa2 = TabularMSA([DNA('-C'), DNA('.G')], index=['a', 'b'], positional_metadata={'bar': ['c', 'd']}) joined = msa1.join(msa2, how='inner') self.assertEqualJoinedMSA( joined, TabularMSA([DNA('G.-C'), DNA('AC.G')], index=['a', 'b'])) def test_how_inner_no_index_overlap_with_positional_metadata_overlap(self): msa1 = TabularMSA([DNA('AC'), DNA('G.')], positional_metadata={'foo': [1, 2]}) msa2 = TabularMSA([DNA('-C'), DNA('.G')], index=['a', 'b'], positional_metadata={'foo': [3, 4]}) joined = msa1.join(msa2, how='inner') self.assertEqualJoinedMSA(joined, TabularMSA([])) def test_how_outer(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-'), DNA('--')], index=[0, 1, 2, 3], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-CC'), DNA('.GG'), DNA('CAA'), DNA('...')], index=[2, 1, 0, -1], positional_metadata={'foo': [3, 4, 5], 'baz': ['c', 'd', 'e']}) joined = msa1.join(msa2, how='outer') self.assertEqualJoinedMSA( joined, TabularMSA([DNA('--...'), DNA('ACCAA'), DNA('G..GG'), DNA('C--CC'), DNA('-----')], index=range(-1, 4), positional_metadata={ 'bar': ['a', 'b', np.nan, np.nan, np.nan], 'baz': [np.nan, np.nan, 'c', 'd', 'e'], 'foo': [1, 2, 3, 4, 5]})) def test_how_left(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-'), DNA('--')], index=[0, 1, 2, 3], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-CC'), DNA('.GG'), DNA('CAA'), DNA('...')], index=[2, 1, 0, -1], positional_metadata={'foo': [3, 4, 5], 'baz': ['c', 'd', 'e']}) joined = msa1.join(msa2, how='left') self.assertEqualJoinedMSA( joined, TabularMSA([DNA('ACCAA'), DNA('G..GG'), DNA('C--CC'), DNA('-----')], positional_metadata={ 'foo': [1, 2, 3, 4, 5], 'bar': ['a', 'b', np.nan, np.nan, np.nan]})) def test_how_right(self): msa1 = TabularMSA([DNA('AC'), DNA('G.'), DNA('C-'), DNA('--')], index=[0, 1, 2, 3], positional_metadata={'foo': [1, 2], 'bar': ['a', 'b']}) msa2 = TabularMSA([DNA('-CC'), DNA('.GG'), DNA('CAA'), DNA('...')], index=[2, 1, 0, -1], positional_metadata={'foo': [3, 4, 5], 'baz': ['c', 'd', 'e']}) joined = msa1.join(msa2, how='right') self.assertEqualJoinedMSA( joined, TabularMSA([DNA('C--CC'), DNA('G..GG'), DNA('ACCAA'), DNA('--...')], index=[2, 1, 0, -1], positional_metadata={ 'foo': [1, 2, 3, 4, 5], 'baz': [np.nan, np.nan, 'c', 'd', 'e']})) class TestIterPositions(unittest.TestCase): def test_method_return_type(self): msa = TabularMSA([DNA('AC'), DNA('GT')]) obs = msa.iter_positions() self.assertIsInstance(obs, types.GeneratorType) def test_position_type(self): msa = TabularMSA([DNA('AC'), DNA('GT')]) first_position = next(msa.iter_positions()) # Type should be *exactly* Sequence. self.assertIs(type(first_position), Sequence) def test_no_sequences(self): msa = TabularMSA([]) obs = list(msa.iter_positions()) self.assertEqual(obs, []) def test_no_sequences_ignore_metadata(self): msa = TabularMSA([]) obs = list(msa.iter_positions(ignore_metadata=True)) self.assertEqual(obs, []) def test_no_sequences_reverse(self): msa = TabularMSA([]) obs = list(msa.iter_positions(reverse=True)) self.assertEqual(obs, []) def test_no_sequences_reverse_ignore_metadata(self): msa = TabularMSA([]) obs = list(msa.iter_positions(reverse=True, ignore_metadata=True)) self.assertEqual(obs, []) def test_no_positions(self): msa = TabularMSA([DNA(''), DNA('')]) obs = list(msa.iter_positions()) self.assertEqual(obs, []) def test_no_positions_ignore_metadata(self): msa = TabularMSA([DNA(''), DNA('')]) obs = list(msa.iter_positions(ignore_metadata=True)) self.assertEqual(obs, []) def test_no_positions_reverse(self): msa = TabularMSA([DNA(''), DNA('')]) obs = list(msa.iter_positions(reverse=True)) self.assertEqual(obs, []) def test_no_positions_reverse_ignore_metadata(self): msa = TabularMSA([DNA(''), DNA('')]) obs = list(msa.iter_positions(reverse=True, ignore_metadata=True)) self.assertEqual(obs, []) def test_single_position(self): msa = TabularMSA([DNA('A')]) obs = list(msa.iter_positions()) self.assertEqual(obs, [Sequence('A')]) def test_single_position_reverse(self): msa = TabularMSA([DNA('A'), DNA('T')]) obs = list(msa.iter_positions(reverse=True)) self.assertEqual(obs, [Sequence('AT')]) def test_multiple_positions(self): msa = TabularMSA([DNA('ACGT'), DNA('A-G.'), DNA('----')]) obs = list(msa.iter_positions()) self.assertEqual(obs, [Sequence('AA-'), Sequence('C--'), Sequence('GG-'), Sequence('T.-')]) def test_multiple_positions_reverse(self): msa = TabularMSA([DNA('AC'), DNA('A-'), DNA('--')]) obs = list(msa.iter_positions(reverse=True)) self.assertEqual(obs, [Sequence('C--'), Sequence('AA-')]) def test_with_positional_metadata(self): # MSA *and* sequence positional metadata. msa_positional_metadata = {'pm1': [0.5, 1.5], 'foo': [9, 99]} seqs = [ DNA('AC', positional_metadata={'foo': [42, 43]}), DNA('A-'), DNA('--', positional_metadata={'foo': [-1, -2], 'bar': ['baz', 'bazz']})] msa = TabularMSA(seqs, positional_metadata=msa_positional_metadata) obs = list(msa.iter_positions()) self.assertEqual( obs, [Sequence('AA-', metadata={'pm1': 0.5, 'foo': 9}, positional_metadata={'bar': [np.nan, np.nan, 'baz'], 'foo': [42, np.nan, -1]}), Sequence('C--', metadata={'pm1': 1.5, 'foo': 99}, positional_metadata={'bar': [np.nan, np.nan, 'bazz'], 'foo': [43, np.nan, -2]})]) def test_with_positional_metadata_reverse(self): # MSA *and* sequence positional metadata. msa_positional_metadata = {'pm1': [0.5, 1.5], 'foo': [9, 99]} seqs = [ DNA('AC', positional_metadata={'foo': [42, 43]}), DNA('A-'), DNA('--', positional_metadata={'foo': [-1, -2], 'bar': ['baz', 'bazz']})] msa = TabularMSA(seqs, positional_metadata=msa_positional_metadata) obs = list(msa.iter_positions(reverse=True)) self.assertEqual( obs, [Sequence('C--', metadata={'pm1': 1.5, 'foo': 99}, positional_metadata={'bar': [np.nan, np.nan, 'bazz'], 'foo': [43, np.nan, -2]}), Sequence('AA-', metadata={'pm1': 0.5, 'foo': 9}, positional_metadata={'bar': [np.nan, np.nan, 'baz'], 'foo': [42, np.nan, -1]})]) def test_with_positional_metadata_ignore_metadata(self): # MSA *and* sequence positional metadata. msa_positional_metadata = {'pm1': [0.5, 1.5], 'foo': [9, 99]} seqs = [ DNA('AC', positional_metadata={'foo': [42, 43]}), DNA('A-'), DNA('--', positional_metadata={'foo': [-1, -2], 'bar': ['baz', 'bazz']})] msa = TabularMSA(seqs, positional_metadata=msa_positional_metadata) obs = list(msa.iter_positions(ignore_metadata=True)) self.assertEqual(obs, [Sequence('AA-'), Sequence('C--')]) class TestConsensus(unittest.TestCase): def test_no_sequences(self): msa = TabularMSA([]) cons = msa.consensus() self.assertEqual(cons, Sequence('')) def test_no_positions(self): msa = TabularMSA([DNA(''), DNA('')]) cons = msa.consensus() self.assertEqual(cons, DNA('')) def test_single_sequence(self): msa = TabularMSA([DNA('ACGT-.')]) cons = msa.consensus() self.assertEqual(cons, DNA('ACGT--')) def test_multiple_sequences(self): msa = TabularMSA([DNA('ACGT'), DNA('AG-.'), DNA('AC-.')]) cons = msa.consensus() self.assertEqual(cons, DNA('AC--')) def test_ties(self): msa = TabularMSA([DNA('A-'), DNA('C-'), DNA('G-')]) cons = msa.consensus() self.assertTrue(cons in [DNA('A-'), DNA('C-'), DNA('G-')]) def test_ties_with_gaps(self): msa = TabularMSA([DNA('-'), DNA('.'), DNA('T'), DNA('T')]) cons = msa.consensus() self.assertTrue(cons in [DNA('T'), DNA('-')]) def test_default_gap_char(self): msa = TabularMSA([DNA('.'), DNA('.'), DNA('.')]) cons = msa.consensus() self.assertEqual(cons, DNA('-')) def test_different_dtype(self): msa = TabularMSA([RNA('---'), RNA('AG-'), RNA('AGG')]) cons = msa.consensus() self.assertEqual(cons, RNA('AG-')) def test_with_positional_metadata(self): # Defining *all* types of metadata to ensure correct metadata is # propagated to majority consensus sequence. seqs = [ DNA('-.-', metadata={'id': 'seq1'}, positional_metadata={'qual': range(0, 3)}), DNA('A.T', metadata={'id': 'seq2'}, positional_metadata={'qual': range(3, 6)}), DNA('ACT', metadata={'id': 'seq3'}, positional_metadata={'qual': range(6, 9)}) ] msa = TabularMSA(seqs, metadata={'pubmed': 123456}, positional_metadata={'foo': [42, 43, 42], 'bar': ['a', 'b', 'c']}) cons = msa.consensus() self.assertEqual( cons, DNA('A-T', positional_metadata={'foo': [42, 43, 42], 'bar': ['a', 'b', 'c']})) def test_mixed_gap_characters_as_majority(self): seqs = [ DNA('A'), DNA('A'), DNA('A'), DNA('A'), DNA('.'), DNA('.'), DNA('.'), DNA('-'), DNA('-') ] msa = TabularMSA(seqs) cons = msa.consensus() self.assertEqual(cons, DNA('-')) class TestConservation(unittest.TestCase): def test_no_sequences(self): msa = TabularMSA([]) cons = msa.conservation() npt.assert_array_equal(cons, np.array([])) def test_shannon_entropy_dna(self): msa = TabularMSA([DNA('A'), DNA('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([DNA('A'), DNA('G'), DNA('C'), DNA('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.25, 0.25], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([DNA('AAC'), DNA('GAC')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([1.0], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([DNA('AACT'), DNA('GACA')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) def test_shannon_entropy_rna(self): msa = TabularMSA([RNA('A'), RNA('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([RNA('A'), RNA('G'), RNA('C'), RNA('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.25, 0.25], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([RNA('AAC'), RNA('GAC')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([1.0], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([RNA('AACU'), RNA('GACA')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) def test_shannon_entropy_protein(self): msa = TabularMSA([Protein('A'), Protein('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=22)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([Protein('A'), Protein('G'), Protein('C'), Protein('G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.25, 0.25], base=22)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([Protein('AAC'), Protein('GAC')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=22), 1. - scipy.stats.entropy([1.0], base=22), 1. - scipy.stats.entropy([1.0], base=22)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([Protein('AACT'), Protein('GACA')]) actual = msa.conservation(metric='inverse_shannon_uncertainty') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=22), 1. - scipy.stats.entropy([1.0], base=22), 1. - scipy.stats.entropy([1.0], base=22), 1. - scipy.stats.entropy([0.5, 0.5], base=22)]) npt.assert_array_equal(actual, expected) def test_degenerate_mode_nan(self): msa = TabularMSA([DNA('NAC'), DNA('NNC')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', degenerate_mode='nan') expected = np.array([np.nan, np.nan, 1. - scipy.stats.entropy([1.0], base=4)]) npt.assert_array_equal(actual, expected) def test_degenerate_mode_error(self): msa = TabularMSA([DNA('NACN'), DNA('NNCA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error') msa = TabularMSA([DNA('AACA'), DNA('ANCA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error') def test_error_on_degenerate_w_nan_on_gap(self): msa = TabularMSA([DNA('-ACA'), DNA('-NCA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='nan') def test_column_with_degen_and_gap(self): msa = TabularMSA([DNA('N'), DNA('-')]) # test all eight combinations of gap_mode and degenerate_mode actual = msa.conservation(metric='inverse_shannon_uncertainty', degenerate_mode='nan', gap_mode='nan') npt.assert_array_equal(actual, np.array([np.nan])) actual = msa.conservation(metric='inverse_shannon_uncertainty', degenerate_mode='nan', gap_mode='ignore') npt.assert_array_equal(actual, np.array([np.nan])) actual = msa.conservation(metric='inverse_shannon_uncertainty', degenerate_mode='nan', gap_mode='include') npt.assert_array_equal(actual, np.array([np.nan])) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='nan', gap_mode='error') self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='nan') self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='error') self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='include') self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', degenerate_mode='error', gap_mode='ignore') def test_gap_mode_nan(self): msa = TabularMSA([DNA('-AC.'), DNA('--CA')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='nan') expected = np.array([np.nan, np.nan, 1. - scipy.stats.entropy([1.0], base=4), np.nan]) npt.assert_array_equal(actual, expected) def test_gap_mode_include(self): msa = TabularMSA([DNA('AC'), DNA('-G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='include') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=5), 1. - scipy.stats.entropy([0.5, 0.5], base=5)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([DNA('AC'), DNA('.G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='include') expected = np.array([1. - scipy.stats.entropy([0.5, 0.5], base=5), 1. - scipy.stats.entropy([0.5, 0.5], base=5)]) npt.assert_array_equal(actual, expected) def test_gap_mode_include_gaps_treated_as_single_char(self): msa = TabularMSA([DNA('.'), DNA('-')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='include') expected = np.array([1. - scipy.stats.entropy([1.0], base=5)]) npt.assert_array_equal(actual, expected) def test_gap_mode_ignore(self): msa = TabularMSA([DNA('AC'), DNA('-G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='ignore') expected = np.array([1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) msa = TabularMSA([DNA('AC'), DNA('.G')]) actual = msa.conservation(metric='inverse_shannon_uncertainty', gap_mode='ignore') expected = np.array([1. - scipy.stats.entropy([1.0], base=4), 1. - scipy.stats.entropy([0.5, 0.5], base=4)]) npt.assert_array_equal(actual, expected) def test_gap_mode_error(self): msa = TabularMSA([DNA('-AC-'), DNA('--CA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', gap_mode="error") msa = TabularMSA([DNA('AACA'), DNA('A-CA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', gap_mode="error") msa = TabularMSA([DNA('AACA'), DNA('A.CA')]) self.assertRaises(ValueError, msa.conservation, metric='inverse_shannon_uncertainty', gap_mode="error") def test_bad_metric(self): msa = TabularMSA([DNA('AA'), DNA('A-')]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(metric='xyz') msa = TabularMSA([]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(metric='xyz') def test_bad_gap_mode(self): msa = TabularMSA([DNA('AA'), DNA('A-')]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(gap_mode='xyz') msa = TabularMSA([]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(gap_mode='xyz') def test_bad_degenerate_mode(self): msa = TabularMSA([DNA('AA'), DNA('A-')]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(degenerate_mode='xyz') msa = TabularMSA([]) with self.assertRaisesRegex(ValueError, r'xyz'): msa.conservation(degenerate_mode='xyz') class TestGapFrequencies(unittest.TestCase): def test_default_behavior(self): msa = TabularMSA([DNA('AA.'), DNA('-A-')]) freqs = msa.gap_frequencies() npt.assert_array_equal(np.array([1, 0, 2]), freqs) def test_invalid_axis_str(self): with self.assertRaisesRegex(ValueError, r"axis.*'foo'"): TabularMSA([]).gap_frequencies(axis='foo') def test_invalid_axis_int(self): with self.assertRaisesRegex(ValueError, r"axis.*2"): TabularMSA([]).gap_frequencies(axis=2) def test_position_axis_str_and_int_equivalent(self): msa = TabularMSA([DNA('ACGT'), DNA('A.G-'), DNA('----')]) str_freqs = msa.gap_frequencies(axis='position') int_freqs = msa.gap_frequencies(axis=1) npt.assert_array_equal(str_freqs, int_freqs) npt.assert_array_equal(np.array([0, 2, 4]), str_freqs) def test_sequence_axis_str_and_int_equivalent(self): msa = TabularMSA([DNA('ACGT'), DNA('A.G-'), DNA('----')]) str_freqs = msa.gap_frequencies(axis='sequence') int_freqs = msa.gap_frequencies(axis=0) npt.assert_array_equal(str_freqs, int_freqs) npt.assert_array_equal(np.array([1, 2, 1, 2]), str_freqs) def test_correct_dtype_absolute_empty(self): msa = TabularMSA([]) freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([]), freqs) self.assertEqual(int, freqs.dtype) def test_correct_dtype_relative_empty(self): msa = TabularMSA([]) freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([]), freqs) self.assertEqual(float, freqs.dtype) def test_correct_dtype_absolute_non_empty(self): msa = TabularMSA([DNA('AC'), DNA('-.')]) freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([0, 2]), freqs) self.assertEqual(int, freqs.dtype) def test_correct_dtype_relative_non_empty(self): msa = TabularMSA([DNA('AC'), DNA('-.')]) freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([0.0, 1.0]), freqs) self.assertEqual(float, freqs.dtype) def test_no_sequences_absolute(self): msa = TabularMSA([]) seq_freqs = msa.gap_frequencies(axis='sequence') pos_freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([]), seq_freqs) npt.assert_array_equal(np.array([]), pos_freqs) def test_no_sequences_relative(self): msa = TabularMSA([]) seq_freqs = msa.gap_frequencies(axis='sequence', relative=True) pos_freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([]), seq_freqs) npt.assert_array_equal(np.array([]), pos_freqs) def test_no_positions_absolute(self): msa = TabularMSA([DNA('')]) seq_freqs = msa.gap_frequencies(axis='sequence') pos_freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([]), seq_freqs) npt.assert_array_equal(np.array([0]), pos_freqs) def test_no_positions_relative(self): msa = TabularMSA([DNA('')]) seq_freqs = msa.gap_frequencies(axis='sequence', relative=True) pos_freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([]), seq_freqs) npt.assert_array_equal(np.array([np.nan]), pos_freqs) def test_single_sequence_absolute(self): msa = TabularMSA([DNA('.T')]) seq_freqs = msa.gap_frequencies(axis='sequence') pos_freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([1, 0]), seq_freqs) npt.assert_array_equal(np.array([1]), pos_freqs) def test_single_sequence_relative(self): msa = TabularMSA([DNA('.T')]) seq_freqs = msa.gap_frequencies(axis='sequence', relative=True) pos_freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([1.0, 0.0]), seq_freqs) npt.assert_array_equal(np.array([0.5]), pos_freqs) def test_single_position_absolute(self): msa = TabularMSA([DNA('.'), DNA('T')]) seq_freqs = msa.gap_frequencies(axis='sequence') pos_freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([1]), seq_freqs) npt.assert_array_equal(np.array([1, 0]), pos_freqs) def test_single_position_relative(self): msa = TabularMSA([DNA('.'), DNA('T')]) seq_freqs = msa.gap_frequencies(axis='sequence', relative=True) pos_freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([0.5]), seq_freqs) npt.assert_array_equal(np.array([1.0, 0.0]), pos_freqs) def test_position_axis_absolute(self): msa = TabularMSA([ DNA('ACGT'), # no gaps DNA('A.G-'), # some gaps (mixed gap chars) DNA('----'), # all gaps DNA('....')]) # all gaps freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([0, 2, 4, 4]), freqs) def test_position_axis_relative(self): msa = TabularMSA([DNA('ACGT'), DNA('A.G-'), DNA('CCC.'), DNA('----'), DNA('....')]) freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([0.0, 0.5, 0.25, 1.0, 1.0]), freqs) def test_sequence_axis_absolute(self): msa = TabularMSA([DNA('AC-.'), DNA('A.-.'), DNA('G--.')]) freqs = msa.gap_frequencies(axis='sequence') npt.assert_array_equal(np.array([0, 2, 3, 3]), freqs) def test_sequence_axis_relative(self): msa = TabularMSA([DNA('AC--.'), DNA('A.A-.'), DNA('G-A-.')]) freqs = msa.gap_frequencies(axis='sequence', relative=True) npt.assert_array_equal(np.array([0.0, 2/3, 1/3, 1.0, 1.0]), freqs) def test_relative_frequencies_precise(self): class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('0123456789') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '0' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set('') @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {} msa = TabularMSA([CustomSequence('0123456789')]) freqs = msa.gap_frequencies(axis='position', relative=True) npt.assert_array_equal(np.array([1.0]), freqs) def test_custom_gap_characters(self): class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('#$*') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '#' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set('ABC-.') @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {'D': 'ABC-.'} msa = TabularMSA([CustomSequence('ABCD'), CustomSequence('-.-.'), CustomSequence('A#C*'), CustomSequence('####'), CustomSequence('$$$$')]) freqs = msa.gap_frequencies(axis='position') npt.assert_array_equal(np.array([0, 0, 2, 4, 4]), freqs) class TestGetPosition(unittest.TestCase): def test_without_positional_metadata(self): msa = TabularMSA([DNA('ACG'), DNA('A-G')]) position = msa._get_position_(1) self.assertEqual(position, Sequence('C-')) def test_with_positional_metadata(self): msa = TabularMSA([DNA('ACG'), DNA('A-G')], positional_metadata={'foo': [42, 43, 44], 'bar': ['abc', 'def', 'ghi']}) position = msa._get_position_(1) self.assertEqual(position, Sequence('C-', metadata={'foo': 43, 'bar': 'def'})) class TestIsSequenceAxis(unittest.TestCase): def setUp(self): self.msa = TabularMSA([]) def test_invalid_str(self): with self.assertRaisesRegex(ValueError, r"axis.*'foo'"): self.msa._is_sequence_axis('foo') def test_invalid_int(self): with self.assertRaisesRegex(ValueError, r"axis.*2"): self.msa._is_sequence_axis(2) def test_positive_str(self): self.assertTrue(self.msa._is_sequence_axis('sequence')) def test_positive_int(self): self.assertTrue(self.msa._is_sequence_axis(0)) def test_negative_str(self): self.assertFalse(self.msa._is_sequence_axis('position')) def test_negative_int(self): self.assertFalse(self.msa._is_sequence_axis(1)) class TestHashable(unittest.TestCase): def test_unhashable_type(self): self.assertNotIsInstance(TabularMSA([]), collections.abc.Hashable) def test_unhashable_object(self): with self.assertRaisesRegex(TypeError, r'unhashable'): hash(TabularMSA([])) class TestRepr(unittest.TestCase): def test_repr(self): # basic sanity checks -- more extensive testing of formatting and # special cases is performed in TabularMSAReprDoctests below. here we # only test that pieces of the repr are present. these tests also # exercise coverage in case doctests stop counting towards coverage in # the future # str calls repr self.assertEqual(repr(TabularMSA([])), str(TabularMSA([]))) self.assertEqual(repr(TabularMSA([DNA('')])), str(TabularMSA([DNA('')]))) self.assertEqual(repr(TabularMSA([DNA('ACGT')])), str(TabularMSA([DNA('ACGT')]))) self.assertEqual(repr(TabularMSA([DNA('ACGT'*25) for x in range(10)])), str(TabularMSA([DNA('ACGT'*25) for x in range(10)]))) # empty obs = repr(TabularMSA([])) self.assertEqual(obs.count('\n'), 5) self.assertTrue(obs.startswith('TabularMSA')) self.assertIn('sequence count: 0', obs) self.assertIn('position count: 0', obs) # minimal obs = repr(TabularMSA([DNA('')])) self.assertEqual(obs.count('\n'), 5) self.assertTrue(obs.startswith('TabularMSA')) self.assertIn('sequence count: 1', obs) self.assertIn('position count: 0', obs) self.assertIn('[DNA]', obs) # no metadata obs = repr(TabularMSA([DNA('ACGT')])) self.assertEqual(obs.count('\n'), 6) self.assertTrue(obs.startswith('TabularMSA')) self.assertIn('sequence count: 1', obs) self.assertIn('position count: 4', obs) self.assertIn('[DNA]', obs) self.assertTrue(obs.endswith('ACGT')) # sequence spanning > 5 lines obs = repr(TabularMSA([DNA('A' * 71) for x in range(6)])) self.assertEqual(obs.count('\n'), 10) self.assertTrue(obs.startswith('TabularMSA')) self.assertIn('sequence count: 6', obs) self.assertIn('position count: 71', obs) self.assertIn('\n...\n', obs) self.assertIn('[DNA]', obs) self.assertTrue(obs.endswith('AAAA')) # sequences overflowing obs = repr(TabularMSA([DNA('A' * 72)])) self.assertEqual(obs.count('\n'), 6) self.assertTrue(obs.startswith('TabularMSA')) self.assertIn('sequence count: 1', obs) self.assertIn('position count: 72', obs) self.assertIn('[DNA]', obs) self.assertTrue(obs.endswith(' ... ' + 'A'*33)) # NOTE: this must be a *separate* class for doctests only (no unit tests). nose # will not run the unit tests otherwise # # these doctests exercise the correct formatting of TabularMSA's repr in a # variety of situations. they are more extensive than the unit tests above # (TestRepr.test_repr) but cannot be relied upon for coverage (the unit tests # take care of this) class TabularMSAReprDoctests: r""" >>> from skbio import DNA, TabularMSA Empty (minimal) MSA: >>> TabularMSA([]) TabularMSA --------------------- Stats: sequence count: 0 position count: 0 --------------------- MSA with single empty sequence: >>> TabularMSA([DNA('')]) TabularMSA[DNA] --------------------- Stats: sequence count: 1 position count: 0 --------------------- MSA with single sequence with single character: >>> TabularMSA([DNA('G')]) TabularMSA[DNA] --------------------- Stats: sequence count: 1 position count: 1 --------------------- G MSA with multicharacter sequence: >>> TabularMSA([DNA('ACGT')]) TabularMSA[DNA] --------------------- Stats: sequence count: 1 position count: 4 --------------------- ACGT Full single line: >>> TabularMSA([DNA('A' * 71)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 1 position count: 71 ----------------------------------------------------------------------- AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Full single line with 1 character overflow: >>> TabularMSA([DNA('A' * 72)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 1 position count: 72 ----------------------------------------------------------------------- AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ... AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Two sequences with full lines: >>> TabularMSA([DNA('T' * 71), DNA('T' * 71)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 2 position count: 71 ----------------------------------------------------------------------- TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Two sequences with full lines with 1 character overflow: >>> TabularMSA([DNA('T' * 72), DNA('T' * 72)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 2 position count: 72 ----------------------------------------------------------------------- TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT ... TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT ... TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT Five full lines (maximum amount of information): >>> TabularMSA([DNA('A' * 71) for x in range(5)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 5 position count: 71 ----------------------------------------------------------------------- AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Six lines starts "summarized" output: >>> TabularMSA([DNA('A' * 71) for x in range(6)]) TabularMSA[DNA] ----------------------------------------------------------------------- Stats: sequence count: 6 position count: 71 ----------------------------------------------------------------------- AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ... AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Supply horrendous metadata and positional metadata to exercise a variety of metadata formatting cases and rules. Sorting should be by type, then by value within each type (Python 3 doesn't allow sorting of mixed types): >>> metadata = { ... # str key, str value ... 'abc': 'some description', ... # int value ... 'foo': 42, ... # unsupported type (dict) value ... 'bar': {}, ... # int key, wrapped str (single line) ... 42: 'some words to test text wrapping and such... yada yada yada ' ... 'yada yada yada yada yada.', ... # bool key, wrapped str (multi-line) ... True: 'abc ' * 34, ... # float key, truncated str (too long) ... 42.5: 'abc ' * 200, ... # unsupported type (tuple) key, unsupported type (list) value ... ('foo', 'bar'): [1, 2, 3], ... # bytes key, single long word that wraps ... b'long word': 'abc' * 30, ... # truncated key (too long), None value ... 'too long of a key name to display in repr': None, ... # wrapped bytes value (has b'' prefix) ... 'bytes wrapped value': b'abcd' * 25, ... # float value ... 0.1: 99.9999, ... # bool value ... 43: False, ... # None key, complex value ... None: complex(-1.0, 0.0), ... # nested quotes ... 10: '"\'' ... } >>> positional_metadata = pd.DataFrame({ ... # str key, int list value ... 'foo': [1, 2, 3, 4], ... # float key, float list value ... 42.5: [2.5, 3.0, 4.2, -0.00001], ... # int key, object list value ... 42: [[], 4, 5, {}], ... # truncated key (too long), bool list value ... 'abc' * 90: [True, False, False, True], ... # None key ... None: range(4)}) >>> positional_metadata = positional_metadata.reindex( ... columns=['foo', 42.5, 42, 'abc' * 90, None]) >>> TabularMSA([DNA('ACGT')], metadata=metadata, ... positional_metadata=positional_metadata) TabularMSA[DNA] ----------------------------------------------------------------------- Metadata: None: (-1+0j) True: 'abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc ' b'long word': 'abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabca bcabcabcabcabcabcabcabcabcabcabcabcabc' 0.1: 99.9999 42.5: 10: '"\'' 42: 'some words to test text wrapping and such... yada yada yada yada yada yada yada yada.' 43: False 'abc': 'some description' 'bar': 'bytes wrapped value': b'abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdab cdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd abcdabcdabcdabcd' 'foo': 42 : None : Positional metadata: 'foo': 42.5: 42: : None: Stats: sequence count: 1 position count: 4 ----------------------------------------------------------------------- ACGT """ pass if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/diversity/000077500000000000000000000000001446255456000167265ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/__init__.py000066400000000000000000000413671446255456000210520ustar00rootroot00000000000000""" Diversity calculations (:mod:`skbio.diversity`) =============================================== .. currentmodule:: skbio.diversity This package provides functionality for analyzing biological diversity. It implements metrics of alpha and beta diversity, and provides two "driver functions" that are intended to be the primary interface for computing alpha and beta diversity with scikit-bio. Functions are additionally provided that support discovery of the available diversity metrics. This document provides a high-level discussion of how to work with the ``skbio.diversity`` module, and should be the first document you read before working with the module. Driver functions ---------------- The driver functions, ``skbio.diversity.alpha_diversity`` and ``skbio.diversity.beta_diversity``, are designed to compute alpha diversity for one or more samples, or beta diversity for one or more pairs of samples. The diversity driver functions accept a matrix containing vectors of frequencies of OTUs within each sample. We use the term "OTU" here very loosely, as these can in practice represent diverse feature types including bacterial species, genes, and metabolites. The term "sample" is also loosely defined for these purposes. These are intended to represent a single unit of sampling, and as such what a single sample represents can vary widely. For example, in a microbiome survey, these could represent all 16S rRNA gene sequences from a single oral swab. In a comparative genomics study on the other hand, a sample could represent an individual organism's genome. Each frequency in a given vector represents the number of individuals observed for a particular OTU. We will refer to the frequencies associated with a single sample as a *counts vector* or ``counts`` throughout the documentation. Counts vectors are `array_like`: anything that can be converted into a 1-D numpy array is acceptable input. For example, you can provide a numpy array or a native Python list and the results will be identical. As mentioned above, the driver functions accept one or more of these vectors (representing one or more samples) in a matrix which is also `array_like`. Each row in the matrix represents a single sample's count vector, so that rows represent samples and columns represent OTUs. Some diversity metrics incorporate relationships between the OTUs in their computation through reference to a phylogenetic tree. These metrics additionally take a ``skbio.TreeNode`` object and a list of OTU identifiers mapping the values in the counts vector to tips in the tree. The driver functions are optimized so that computing a diversity metric more than one time (i.e., for more than one sample for alpha diversity metrics, or more than one pair of samples for beta diversity metrics) is often much faster than repeated calls to the metric. For this reason, the driver functions take matrices of counts vectors rather than a single counts vector for alpha diversity metrics or two counts vectors for beta diversity metrics. The ``alpha_diversity`` driver function will thus compute alpha diversity for all counts vectors in the matrix, and the ``beta_diversity`` driver function will compute beta diversity for all pairs of counts vectors in the matrix. Input validation ---------------- The driver functions perform validation of input by default. Validation can be slow so it is possible to disable this step by passing ``validate=False``. This can be dangerous however. If invalid input is encountered when validation is disabled it can result in difficult-to-interpret error messages or incorrect results. We therefore recommend that users are careful to ensure that their input data is valid before disabling validation. The conditions that the driver functions validate follow. If disabling validation, users should be confident that these conditions are met. * the data in the counts vectors can be safely cast to integers * there are no negative values in the counts vectors * each counts vector is one dimensional * the counts matrix is two dimensional * all counts vectors are of equal length Additionally, if a phylogenetic diversity metric is being computed, the following conditions are also confirmed: * the provided OTU identifiers are all unique * the length of each counts vector is equal to the number of OTU identifiers * the provided tree is rooted * the tree has more than one node * all nodes in the provided tree except for the root node have branch lengths * all tip names in the provided tree are unique * all provided OTU identifiers correspond to tip names in the provided tree Count vectors ------------- There are different ways that count vectors are represented in the ecological literature and in related software. The diversity measures provided here *always* assume that the input contains abundance data: each count represents the number of individuals observed for a particular OTU in the sample. For example, if you have two OTUs, where three individuals were observed from the first OTU and only a single individual was observed from the second OTU, you could represent this data in the following forms (among others). As a vector of counts. This is the expected type of input for the diversity measures in this module. There are 3 individuals from the OTU at index 0, and 1 individual from the OTU at index 1: >>> counts = [3, 1] As a vector of indices. The OTU at index 0 is observed 3 times, while the OTU at index 1 is observed 1 time: >>> indices = [0, 0, 0, 1] As a vector of frequencies. We have 1 OTU that is a singleton and 1 OTU that is a tripleton. We do not have any 0-tons or doubletons: >>> frequencies = [0, 1, 0, 1] Always use the first representation (a counts vector) with this module. Specifying a diversity metric ----------------------------- The driver functions take a parameter, ``metric``, that specifies which diversity metric should be applied. The value that you provide for ``metric`` can be either a string (e.g., ``"faith_pd"``) or a function (e.g., ``skbio.diversity.alpha.faith_pd``). The metric should generally be passed as a string, as this often uses an optimized version of the metric. For example, passing ``metric="faith_pd"`` (a string) to ``alpha_diversity`` will be tens of times faster than passing ``metric=skbio.diversity.alpha.faith_pd`` (a function) when computing Faith's PD on about 100 samples. Similarly, passing ``metric="unweighted_unifrac"`` (a string) will be hundreds of times faster than passing ``metric=skbio.diversity.beta.unweighted_unifrac`` (a function) when computing unweighted UniFrac on about 100 samples. The latter may be faster if computing only one alpha or beta diversity value, but in these cases the run times will likely be so small that the difference will be negligible. **We therefore recommend that you always pass the metric as a string when possible.** Passing a metric as a string will not be possible if the metric you'd like to run is not one that scikit-bio knows about. This might be the case, for example, if you're applying a custom metric that you've developed. To discover the metric names that scikit-bio knows about as strings that can be passed as ``metric`` to ``alpha_diversity`` or ``beta_diversity``, you can call ``get_alpha_diversity_metrices`` or ``get_beta_diversity_metrics``, respectively. These functions return lists of alpha and beta diversity metrics that are implemented in scikit-bio. There may be additional metrics that can be passed as strings which won't be listed here, such as those implemented in ``scipy.spatial.distance.pdist``. Subpackages ----------- .. autosummary:: :toctree: generated/ alpha beta Functions --------- .. autosummary:: :toctree: generated/ alpha_diversity beta_diversity partial_beta_diversity block_beta_diversity get_alpha_diversity_metrics get_beta_diversity_metrics Examples -------- Create a matrix containing 6 samples (rows) and 7 OTUs (columns): .. plot:: :context: >>> data = [[23, 64, 14, 0, 0, 3, 1], ... [0, 3, 35, 42, 0, 12, 1], ... [0, 5, 5, 0, 40, 40, 0], ... [44, 35, 9, 0, 1, 0, 0], ... [0, 2, 8, 0, 35, 45, 1], ... [0, 0, 25, 35, 0, 19, 0]] >>> ids = list('ABCDEF') First, we'll compute observed OTUs, an alpha diversity metric, for each sample using the ``alpha_diversity`` driver function: >>> from skbio.diversity import alpha_diversity >>> adiv_obs_otus = alpha_diversity('observed_otus', data, ids) >>> adiv_obs_otus A 5 B 5 C 4 D 4 E 5 F 3 dtype: int64 Next we'll compute Faith's PD on the same samples. Since this is a phylogenetic diversity metric, we'll first create a tree and an ordered list of OTU identifiers. >>> from skbio import TreeNode >>> from io import StringIO >>> tree = TreeNode.read(StringIO( ... '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,' ... '(OTU4:0.75,(OTU5:0.5,(OTU6:0.5,OTU7:0.5):0.5):' ... '0.5):1.25):0.0)root;')) >>> otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5', 'OTU6', 'OTU7'] >>> adiv_faith_pd = alpha_diversity('faith_pd', data, ids=ids, ... otu_ids=otu_ids, tree=tree) >>> adiv_faith_pd A 6.75 B 7.00 C 6.25 D 5.75 E 6.75 F 5.50 dtype: float64 Now we'll compute Bray-Curtis distances, a beta diversity metric, between all pairs of samples. Notice that the ``data`` and ``ids`` parameters provided to ``beta_diversity`` are the same as those provided to ``alpha_diversity``. >>> from skbio.diversity import beta_diversity >>> bc_dm = beta_diversity("braycurtis", data, ids) >>> print(bc_dm) 6x6 distance matrix IDs: 'A', 'B', 'C', 'D', 'E', 'F' Data: [[ 0. 0.78787879 0.86666667 0.30927835 0.85714286 0.81521739] [ 0.78787879 0. 0.78142077 0.86813187 0.75 0.1627907 ] [ 0.86666667 0.78142077 0. 0.87709497 0.09392265 0.71597633] [ 0.30927835 0.86813187 0.87709497 0. 0.87777778 0.89285714] [ 0.85714286 0.75 0.09392265 0.87777778 0. 0.68235294] [ 0.81521739 0.1627907 0.71597633 0.89285714 0.68235294 0. ]] Next, we'll compute weighted UniFrac distances between all pairs of samples. Because weighted UniFrac is a phylogenetic beta diversity metric, we'll need to pass the ``skbio.TreeNode`` and list of OTU ids that we created above. Again, these are the same values that were provided to ``alpha_diversity``. >>> wu_dm = beta_diversity("weighted_unifrac", data, ids, tree=tree, ... otu_ids=otu_ids) >>> print(wu_dm) 6x6 distance matrix IDs: 'A', 'B', 'C', 'D', 'E', 'F' Data: [[ 0. 2.77549923 3.82857143 0.42512039 3.8547619 3.10937312] [ 2.77549923 0. 2.26433692 2.98435423 2.24270353 0.46774194] [ 3.82857143 2.26433692 0. 3.95224719 0.16025641 1.86111111] [ 0.42512039 2.98435423 3.95224719 0. 3.98796148 3.30870431] [ 3.8547619 2.24270353 0.16025641 3.98796148 0. 1.82967033] [ 3.10937312 0.46774194 1.86111111 3.30870431 1.82967033 0. ]] Next we'll do some work with these beta diversity distance matrices. First, we'll determine if the UniFrac and Bray-Curtis distance matrices are significantly correlated by computing the Mantel correlation between them. Then we'll determine if the p-value is significant based on an alpha of 0.05. >>> from skbio.stats.distance import mantel >>> r, p_value, n = mantel(wu_dm, bc_dm) >>> print(r) 0.922404392093 >>> alpha = 0.05 >>> print(p_value < alpha) True Next, we'll perform principal coordinates analysis (PCoA) on our weighted UniFrac distance matrix. >>> from skbio.stats.ordination import pcoa >>> wu_pc = pcoa(wu_dm) PCoA plots are only really interesting in the context of sample metadata, so let's define some before we visualize these results. >>> import pandas as pd >>> sample_md = pd.DataFrame([ ... ['gut', 's1'], ... ['skin', 's1'], ... ['tongue', 's1'], ... ['gut', 's2'], ... ['tongue', 's2'], ... ['skin', 's2']], ... index=['A', 'B', 'C', 'D', 'E', 'F'], ... columns=['body_site', 'subject']) >>> sample_md body_site subject A gut s1 B skin s1 C tongue s1 D gut s2 E tongue s2 F skin s2 Now let's plot our PCoA results, coloring each sample by the subject it was taken from: >>> fig = wu_pc.plot(sample_md, 'subject', ... axis_labels=('PC 1', 'PC 2', 'PC 3'), ... title='Samples colored by subject', cmap='jet', s=50) .. plot:: :context: We don't see any clustering/grouping of samples. If we were to instead color the samples by the body site they were taken from, we see that the samples from the same body site (those that are colored the same) appear to be closer to one another in the 3-D space then they are to samples from other body sites. >>> import matplotlib.pyplot as plt >>> plt.close('all') # not necessary for normal use >>> fig = wu_pc.plot(sample_md, 'body_site', ... axis_labels=('PC 1', 'PC 2', 'PC 3'), ... title='Samples colored by body site', cmap='jet', s=50) .. plot:: :context: Ordination techniques, such as PCoA, are useful for exploratory analysis. The next step is to quantify the strength of the grouping/clustering that we see in ordination plots. There are many statistical methods available to accomplish this; many operate on distance matrices. Let's use ANOSIM to quantify the strength of the clustering we see in the ordination plots above, using our weighted UniFrac distance matrix and sample metadata. First test the grouping of samples by subject: >>> from skbio.stats.distance import anosim >>> results = anosim(wu_dm, sample_md, column='subject', permutations=999) >>> results['test statistic'] -0.33333333333333331 >>> results['p-value'] < 0.1 False The negative value of ANOSIM's R statistic indicates anti-clustering and the p-value is insignificant at an alpha of 0.1. Now let's test the grouping of samples by body site: >>> results = anosim(wu_dm, sample_md, column='body_site', permutations=999) >>> results['test statistic'] 1.0 >>> results['p-value'] < 0.1 True The R statistic indicates strong separation of samples based on body site. The p-value is significant at an alpha of 0.1. We can also explore the alpha diversity in the context of sample metadata. To do this, let's add the Observed OTU and Faith PD data to our sample metadata. This is straight-forward beause ``alpha_diversity`` returns a Pandas ``Series`` object, and we're representing our sample metadata in a Pandas ``DataFrame`` object. >>> sample_md['Observed OTUs'] = adiv_obs_otus >>> sample_md['Faith PD'] = adiv_faith_pd >>> sample_md body_site subject Observed OTUs Faith PD A gut s1 5 6.75 B skin s1 5 7.00 C tongue s1 4 6.25 D gut s2 4 5.75 E tongue s2 5 6.75 F skin s2 3 5.50 We can investigate these alpha diversity data in the context of our metadata categories. For example, we can generate boxplots showing Faith PD by body site. >>> import matplotlib.pyplot as plt >>> plt.close('all') # not necessary for normal use >>> fig = sample_md.boxplot(column='Faith PD', by='body_site') We can also compute Spearman correlations between all pairs of columns in this ``DataFrame``. Since our alpha diversity metrics are the only two numeric columns (and thus the only columns for which Spearman correlation is relevant), this will give us a symmetric 2x2 correlation matrix. >>> sample_md.corr(method="spearman", numeric_only=True) Observed OTUs Faith PD Observed OTUs 1.000000 0.939336 Faith PD 0.939336 1.000000 """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._driver import (alpha_diversity, beta_diversity, partial_beta_diversity, get_alpha_diversity_metrics, get_beta_diversity_metrics) from ._block import block_beta_diversity __all__ = ["alpha_diversity", "beta_diversity", "get_alpha_diversity_metrics", "get_beta_diversity_metrics", "partial_beta_diversity", "block_beta_diversity"] scikit-bio-0.5.9/skbio/diversity/_block.py000066400000000000000000000245521446255456000205410ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.util._decorator import experimental from skbio.diversity._driver import partial_beta_diversity from skbio.stats.distance import DistanceMatrix from skbio.diversity._util import _validate_counts_matrix def _generate_id_blocks(ids, k=64): """Generate blocks of IDs that map into a DistanceMatrix Parameters ---------- ids : Iterable object An iterable of IDs of whatever type. k : int, optional The size of a block to generate IDs for, defaults to 64. Notes ----- This method is intended to facilitate partial beta diversity calculations. Blocks of IDs are generated from the upper triangle of the subsequent distance matrix. For instance, given the following distance matrix with IDs {A, B, C, D, E}: A B C D E A 0 # # # # B # 0 # # # C # # 0 # # D # # # 0 # E # # # # 0 The goal of this method is to generate tuples of IDs of at most size k over the upper triangle which correspond to blocks of the matrix to compute. IDs are remapped as well into integers to facilitate downstream indexing. Given k=3, the following ID tuples would be generated: ((0, 1, 2), (0, 1, 2)) ((0, 1, 2), (3, 4)) ((3, 4), (3, 4)) This method is not responsible for describing which specific pairs of IDs are to be computed, only the subset of the matrix of interest. Returns ------- tuple of 1D np.array Index 0 contains the row IDs, and index 1 contains the column IDs """ n = len(ids) ids_idx = np.arange(n) for row_start in range(0, n, k): for col_start in range(row_start, n, k): row_ids = ids_idx[row_start:row_start + k] col_ids = ids_idx[col_start:col_start + k] yield (row_ids, col_ids) def _block_party(counts=None, row_ids=None, col_ids=None, **kwargs): """Subset counts to relevant rows and columns Parameters ---------- counts : 2D array_like of ints or floats Matrix containing count/abundance data where each row contains counts of OTUs in a given sample. row_ids : 1D np.ndarray of int Block row IDs to keep in the counts matrix. col_ids : 1D np.ndarray of int Block column IDs to keep in the counts matrix. Note, these correspond to rows in the counts matrix, but columns in a subsequent distance matrix. kwargs : dict Keyword arguments containing information about the block to compute. Returns ------- dict kwargs that describe the block to compute. A filtered ``counts`` matrix is stored in kwargs. If applicable, a filtered ``tree`` and ``otu_ids`` are also stored. """ ids_to_keep = np.unique(np.hstack([row_ids, col_ids])) # create a view of the relevant samples counts_block = counts[ids_to_keep] # remove from the block any empty observations # NOTE: this will perform an implicit copy nonzero_cols = (counts_block != 0).any(axis=0) counts_block = counts_block[:, nonzero_cols] kwargs['counts'] = counts_block kwargs['ids'] = ids_to_keep if 'tree' in kwargs and 'otu_ids' in kwargs: kwargs['otu_ids'] = np.asarray(kwargs['otu_ids'])[nonzero_cols] kwargs['tree'] = kwargs['tree'].shear(kwargs['otu_ids']) return kwargs def _pairs_to_compute(rids, cids): """Determine the pairs of samples to compute distances between Parameters ---------- rids : Iterable The row IDs in the partial pairwise computation. cids : Iterable The column IDs in the partial pairwise computation. Raises ------ ValueError When determining ID pairs for blocks that fall outside of the diagonal of the resulting distance matrix, if a pair corresponds to the lower triangle, complain loudly. Returns ------- list of tuple The ID pairs to compute distances between. """ # if identical, gather the upper triangle if len(rids) == len(cids) and (rids == cids).all(): return [(i, j) for idx, i in enumerate(rids) for j in rids[idx+1:]] # otherwise, grab pairwise combinations disregarding the diagonal else: if set(rids).intersection(set(cids)): raise ValueError("Attempting to compute a lower triangle") return [(i, j) for i in rids for j in cids if i != j] def _block_kwargs(**kwargs): """Construct arguments describing a block to compute Returns ------- dict The parameters for the block of the distance matrix to compute. """ valid_block_keys = {'counts', 'ids', 'tree', 'otu_ids', 'metric', 'id_pairs', 'validate'} for row_ids, col_ids in _generate_id_blocks(kwargs['ids'], kwargs['k']): id_pairs = _pairs_to_compute(row_ids, col_ids) if id_pairs: kw = {k: v for k, v in kwargs.items() if k in valid_block_keys} kw['id_pairs'] = id_pairs kw['row_ids'] = row_ids kw['col_ids'] = col_ids yield kw def _block_compute(**kwargs): """Compute a block within the resulting distance matrix Notes ----- This method encapsulates the two expensive operations to perform for each block, namely, the "shearing" of the phylogenetic tree to correspond to only the OTUs of interest, and the actual beta diversity calculations. Returns ------- DistanceMatrix """ block_kw = _block_party(**kwargs) return partial_beta_diversity(**block_kw) def _map(func, kw_gen): """Map a function over arguments Notes ----- builtin map does not allow for mapping with kwargs. Parallel uses of block decomposition will likely replace this method with one which can distribute compute. """ for kwargs in kw_gen: yield func(**kwargs) def _reduce(blocks): """Reduce an iterable of partial distance matrices into a full matrix Note, the reduce doesn't actually care about what pairs are computed so if a distance between pairs exists multiple times, it'll get added. as such, this reduction is only safe to perform if by the block_beta_diversity method which assures that distances are not computed multiple times. """ all_blocks = list(blocks) # Determine the maximum integer ID observed in the blocks. There exists a # 1-1 mapping between the integer ID and a sample ID. We increment by 1 # as the integer ID space begins with zero, and we'll be using this value # to determine the size of the resulting full distance matrix. n_ids = max(map(lambda x: max(x.ids), all_blocks)) + 1 mat = np.zeros((n_ids, n_ids), dtype=float) # TODO: something smarter. for block in all_blocks: n_blk_ids = len(block.ids) # get the corresponding coordinates in the master matrix master_idx = [(i, j) for row, i in enumerate(block.ids) for j in block.ids[row+1:]] # get the corresponding coordinates within the current block block_idx = [(i, j) for row, i in enumerate(range(n_blk_ids)) for j in range(row+1, n_blk_ids)] for (m_i, m_j), (b_i, b_j) in zip(master_idx, block_idx): mat[m_i, m_j] += block.data[b_i, b_j] return DistanceMatrix(mat + mat.T, list(range(n_ids))) @experimental(as_of="0.5.1") def block_beta_diversity(metric, counts, ids, validate=True, k=64, reduce_f=None, map_f=None, **kwargs): """Perform a block-decomposition beta diversity calculation Parameters ---------- metric : str or callable The pairwise distance function to apply. If ``metric`` is a string, it must be resolvable by scikit-bio (e.g., UniFrac methods), or must be callable. counts : 2D array_like of ints or floats Matrix containing count/abundance data where each row contains counts of OTUs in a given sample. ids : iterable of strs Identifiers for each sample in ``counts``. validate : bool, optional See ``skbio.diversity.beta_diversity`` for details. reduce_f : function, optional A method to reduce `PartialDistanceMatrix` objects into a single `DistanceMatrix`. The expected signature is: `f(Iterable of DistanceMatrix) -> DistanceMatrix` Note, this is the reduce within a map/reduce. map_f: function, optional A method that accepts a `_block_compute`. The expected signature is: `f(**kwargs) -> DistanceMatrix` NOTE: ipyparallel's `map_async` will not work here as we need to be able to pass around `**kwargs``. k : int, optional The blocksize used when computing distances kwargs : kwargs, optional Metric-specific parameters. Returns ------- DistanceMatrix A distance matrix relating all samples represented by counts to each other. Notes ----- This method is designed to facilitate computing beta diversity in parallel. In general, if you are processing a few hundred samples or less, then it is likely the case that `skbio.diversity.beta_diversity` will be faster. The original need which motivated the development of this method was processing the Earth Microbiome Project [1]_ dataset which at the time spanned over 25,000 samples and 7.5 million open reference OTUs. See Also -------- skbio.diversity.beta_diversity skbio.diversity.partial_beta_diversity References ---------- .. [1] http://www.earthmicrobiome.org/ """ if validate: counts = _validate_counts_matrix(counts, ids=ids) if reduce_f is None: reduce_f = _reduce if map_f is None: map_f = _map # The block method uses numeric IDs to take advantage of fancy indexing # with numpy. tmp_ids = np.arange(len(counts)) kwargs['ids'] = tmp_ids kwargs['metric'] = metric kwargs['counts'] = counts kwargs['k'] = k kwargs['validate'] = False # we've already validated if necessary dm = reduce_f(map_f(_block_compute, _block_kwargs(**kwargs))) dm.ids = ids return dm scikit-bio-0.5.9/skbio/diversity/_driver.py000066400000000000000000000412161446255456000207360ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import functools import itertools import numpy as np import scipy.spatial.distance import pandas as pd import skbio from skbio.diversity.alpha._faith_pd import _faith_pd, _setup_faith_pd from skbio.diversity.beta._unifrac import ( _setup_multiple_unweighted_unifrac, _setup_multiple_weighted_unifrac, _normalize_weighted_unifrac_by_default) from skbio.util._decorator import experimental, deprecated from skbio.stats.distance import DistanceMatrix from skbio.diversity._util import (_validate_counts_matrix, _get_phylogenetic_kwargs, _quantitative_to_qualitative_counts) def _get_alpha_diversity_metric_map(): return { 'ace': skbio.diversity.alpha.ace, 'chao1': skbio.diversity.alpha.chao1, 'chao1_ci': skbio.diversity.alpha.chao1_ci, 'berger_parker_d': skbio.diversity.alpha.berger_parker_d, 'brillouin_d': skbio.diversity.alpha.brillouin_d, 'dominance': skbio.diversity.alpha.dominance, 'doubles': skbio.diversity.alpha.doubles, 'enspie': skbio.diversity.alpha.enspie, 'esty_ci': skbio.diversity.alpha.esty_ci, 'faith_pd': skbio.diversity.alpha.faith_pd, 'fisher_alpha': skbio.diversity.alpha.fisher_alpha, 'goods_coverage': skbio.diversity.alpha.goods_coverage, 'heip_e': skbio.diversity.alpha.heip_e, 'kempton_taylor_q': skbio.diversity.alpha.kempton_taylor_q, 'margalef': skbio.diversity.alpha.margalef, 'mcintosh_d': skbio.diversity.alpha.mcintosh_d, 'mcintosh_e': skbio.diversity.alpha.mcintosh_e, 'menhinick': skbio.diversity.alpha.menhinick, 'michaelis_menten_fit': skbio.diversity.alpha.michaelis_menten_fit, 'observed_otus': skbio.diversity.alpha.observed_otus, 'osd': skbio.diversity.alpha.osd, 'pielou_e': skbio.diversity.alpha.pielou_e, 'robbins': skbio.diversity.alpha.robbins, 'shannon': skbio.diversity.alpha.shannon, 'simpson': skbio.diversity.alpha.simpson, 'simpson_e': skbio.diversity.alpha.simpson_e, 'singles': skbio.diversity.alpha.singles, 'strong': skbio.diversity.alpha.strong, 'gini_index': skbio.diversity.alpha.gini_index, 'lladser_pe': skbio.diversity.alpha.lladser_pe, 'lladser_ci': skbio.diversity.alpha.lladser_ci} @experimental(as_of="0.4.1") def get_alpha_diversity_metrics(): """ List scikit-bio's alpha diversity metrics The alpha diversity metrics listed here can be passed as metrics to ``skbio.diversity.alpha_diversity``. Returns ------- list of str Alphabetically sorted list of alpha diversity metrics implemented in scikit-bio. See Also -------- alpha_diversity get_beta_diversity_metrics """ metrics = _get_alpha_diversity_metric_map() return sorted(metrics.keys()) @experimental(as_of="0.4.1") def get_beta_diversity_metrics(): """ List scikit-bio's beta diversity metrics The beta diversity metrics listed here can be passed as metrics to ``skbio.diversity.beta_diversity``. Returns ------- list of str Alphabetically sorted list of beta diversity metrics implemented in scikit-bio. See Also -------- beta_diversity get_alpha_diversity_metrics scipy.spatial.distance.pdist Notes ----- SciPy implements many additional beta diversity metrics that are not included in this list. See documentation for ``scipy.spatial.distance.pdist`` for more details. """ return sorted(['unweighted_unifrac', 'weighted_unifrac']) @experimental(as_of="0.4.1") def alpha_diversity(metric, counts, ids=None, validate=True, **kwargs): """ Compute alpha diversity for one or more samples Parameters ---------- metric : str, callable The alpha diversity metric to apply to the sample(s). Passing metric as a string is preferable as this often results in an optimized version of the metric being used. counts : 1D or 2D array_like of ints or floats Vector or matrix containing count/abundance data. If a matrix, each row should contain counts of OTUs in a given sample. ids : iterable of strs, optional Identifiers for each sample in ``counts``. By default, samples will be assigned integer identifiers in the order that they were provided. validate: bool, optional If `False`, validation of the input won't be performed. This step can be slow, so if validation is run elsewhere it can be disabled here. However, invalid input data can lead to invalid results or error messages that are hard to interpret, so this step should not be bypassed if you're not certain that your input data are valid. See :mod:`skbio.diversity` for the description of what validation entails so you can determine if you can safely disable validation. kwargs : kwargs, optional Metric-specific parameters. Returns ------- pd.Series Values of ``metric`` for all vectors provided in ``counts``. The index will be ``ids``, if provided. Raises ------ ValueError, MissingNodeError, DuplicateNodeError If validation fails. Exact error will depend on what was invalid. TypeError If invalid method-specific parameters are provided. See Also -------- skbio.diversity skbio.diversity.alpha skbio.diversity.get_alpha_diversity_metrics skbio.diversity.beta_diversity """ metric_map = _get_alpha_diversity_metric_map() if validate: counts = _validate_counts_matrix(counts, ids=ids) if metric == 'faith_pd': otu_ids, tree, kwargs = _get_phylogenetic_kwargs(counts, **kwargs) counts_by_node, branch_lengths = _setup_faith_pd( counts, otu_ids, tree, validate, single_sample=False) counts = counts_by_node metric = functools.partial(_faith_pd, branch_lengths=branch_lengths) elif callable(metric): metric = functools.partial(metric, **kwargs) elif metric in metric_map: metric = functools.partial(metric_map[metric], **kwargs) else: raise ValueError('Unknown metric provided: %r.' % metric) # kwargs is provided here so an error is raised on extra kwargs results = [metric(c, **kwargs) for c in counts] return pd.Series(results, index=ids) @deprecated(as_of='0.5.0', until='0.6.0', reason=('The return type is unstable. Developer caution is ' 'advised. The resulting DistanceMatrix object will ' 'include zeros when distance has not been calculated, and ' 'therefore can be misleading.')) def partial_beta_diversity(metric, counts, ids, id_pairs, validate=True, **kwargs): """Compute distances only between specified ID pairs Parameters ---------- metric : str or callable The pairwise distance function to apply. If ``metric`` is a string, it must be resolvable by scikit-bio (e.g., UniFrac methods), or must be callable. counts : 2D array_like of ints or floats Matrix containing count/abundance data where each row contains counts of OTUs in a given sample. ids : iterable of strs Identifiers for each sample in ``counts``. id_pairs : iterable of tuple An iterable of tuples of IDs to compare (e.g., ``[('a', 'b'), ('a', 'c'), ...])``. If specified, the set of IDs described must be a subset of ``ids``. validate : bool, optional See ``skbio.diversity.beta_diversity`` for details. kwargs : kwargs, optional Metric-specific parameters. Returns ------- skbio.DistanceMatrix Distances between pairs of samples indicated by id_pairs. Pairwise distances not defined by id_pairs will be 0.0. Use this resulting DistanceMatrix with caution as 0.0 is a valid distance. Raises ------ ValueError If ``ids`` are not specified. If ``id_pairs`` are not a subset of ``ids``. If ``metric`` is not a callable or is unresolvable string by scikit-bio. If duplicates are observed in ``id_pairs``. See Also -------- skbio.diversity.beta_diversity skbio.diversity.get_beta_diversity_metrics """ if validate: counts = _validate_counts_matrix(counts, ids=ids) id_pairs = list(id_pairs) all_ids_in_pairs = set(itertools.chain.from_iterable(id_pairs)) if not all_ids_in_pairs.issubset(ids): raise ValueError("`id_pairs` are not a subset of `ids`") hashes = {i for i in id_pairs}.union({i[::-1] for i in id_pairs}) if len(hashes) != len(id_pairs) * 2: raise ValueError("A duplicate or a self-self pair was observed.") if metric == 'unweighted_unifrac': counts = _quantitative_to_qualitative_counts(counts) otu_ids, tree, kwargs = _get_phylogenetic_kwargs(counts, **kwargs) metric, counts_by_node = _setup_multiple_unweighted_unifrac( counts, otu_ids=otu_ids, tree=tree, validate=validate) counts = counts_by_node elif metric == 'weighted_unifrac': # get the value for normalized. if it was not provided, it will fall # back to the default value inside of _weighted_unifrac_pdist_f normalized = kwargs.pop('normalized', _normalize_weighted_unifrac_by_default) otu_ids, tree, kwargs = _get_phylogenetic_kwargs(counts, **kwargs) metric, counts_by_node = _setup_multiple_weighted_unifrac( counts, otu_ids=otu_ids, tree=tree, normalized=normalized, validate=validate) counts = counts_by_node elif callable(metric): metric = functools.partial(metric, **kwargs) # remove all values from kwargs, since they have already been provided # through the partial kwargs = {} else: raise ValueError("partial_beta_diversity is only compatible with " "optimized unifrac methods and callable functions.") dm = np.zeros((len(ids), len(ids)), dtype=float) id_index = {id_: idx for idx, id_ in enumerate(ids)} id_pairs_indexed = ((id_index[u], id_index[v]) for u, v in id_pairs) for u, v in id_pairs_indexed: dm[u, v] = metric(counts[u], counts[v], **kwargs) return DistanceMatrix(dm + dm.T, ids) # The following two lists are adapted from sklearn.metrics.pairwise. Metrics # that are not available in SciPy (only in sklearn) have been removed from # the list of _valid_beta_metrics here (those are: manhatten, wminkowski, # nan_euclidean, and haversine) _valid_beta_metrics = [ "euclidean", "cityblock", "braycurtis", "canberra", "chebyshev", "correlation", "cosine", "dice", "hamming", "jaccard", "kulsinski", "mahalanobis", "manhattan", # aliases to "cityblock" in beta_diversity "matching", "minkowski", "rogerstanimoto", "russellrao", "seuclidean", "sokalmichener", "sokalsneath", "sqeuclidean", "yule", ] _qualitative_beta_metrics = [ "dice", "jaccard", "kulsinski", "matching", "rogerstanimoto", "russellrao", "sokalmichener", "sokalsneath", "yule" ] @experimental(as_of="0.4.0") def beta_diversity(metric, counts, ids=None, validate=True, pairwise_func=None, **kwargs): """Compute distances between all pairs of samples Parameters ---------- metric : str, callable The pairwise distance function to apply. See the scipy ``pdist`` docs and the scikit-bio functions linked under *See Also* for available metrics. Passing metrics as a strings is preferable as this often results in an optimized version of the metric being used. counts : 2D array_like of ints or floats or 2D pandas DataFrame Matrix containing count/abundance data where each row contains counts of OTUs in a given sample. ids : iterable of strs, optional Identifiers for each sample in ``counts``. By default, samples will be assigned integer identifiers in the order that they were provided (where the type of the identifiers will be ``str``). validate : bool, optional If `False`, validation of the input won't be performed. This step can be slow, so if validation is run elsewhere it can be disabled here. However, invalid input data can lead to invalid results or error messages that are hard to interpret, so this step should not be bypassed if you're not certain that your input data are valid. See :mod:`skbio.diversity` for the description of what validation entails so you can determine if you can safely disable validation. pairwise_func : callable, optional The function to use for computing pairwise distances. This function must take ``counts`` and ``metric`` and return a square, hollow, 2-D ``numpy.ndarray`` of dissimilarities (floats). Examples of functions that can be provided are ``scipy.spatial.distance.pdist`` and ``sklearn.metrics.pairwise_distances``. By default, ``scipy.spatial.distance.pdist`` will be used. kwargs : kwargs, optional Metric-specific parameters. Returns ------- skbio.DistanceMatrix Distances between all pairs of samples (i.e., rows). The number of rows and columns will be equal to the number of rows in ``counts``. Raises ------ ValueError, MissingNodeError, DuplicateNodeError If validation fails. Exact error will depend on what was invalid. TypeError If invalid method-specific parameters are provided. See Also -------- skbio.diversity skbio.diversity.beta skbio.diversity.get_beta_diversity_metrics skbio.diversity.alpha_diversity scipy.spatial.distance.pdist sklearn.metrics.pairwise_distances """ if validate: counts = _validate_counts_matrix(counts, ids=ids) if 0 in counts.shape: # if the input counts are empty, return an empty DistanceMatrix. # this check is not necessary for scipy.spatial.distance.pdist but # it is necessary for sklearn.metrics.pairwise_distances where the # latter raises an exception over empty data. return DistanceMatrix(np.zeros((len(ids), len(ids))), ids) if metric == 'unweighted_unifrac': counts = _quantitative_to_qualitative_counts(counts) otu_ids, tree, kwargs = _get_phylogenetic_kwargs(counts, **kwargs) metric, counts_by_node = _setup_multiple_unweighted_unifrac( counts, otu_ids=otu_ids, tree=tree, validate=validate) counts = counts_by_node elif metric == 'weighted_unifrac': # get the value for normalized. if it was not provided, it will fall # back to the default value inside of _weighted_unifrac_pdist_f normalized = kwargs.pop('normalized', _normalize_weighted_unifrac_by_default) otu_ids, tree, kwargs = _get_phylogenetic_kwargs(counts, **kwargs) metric, counts_by_node = _setup_multiple_weighted_unifrac( counts, otu_ids=otu_ids, tree=tree, normalized=normalized, validate=validate) counts = counts_by_node elif metric == "manhattan": metric = "cityblock" elif callable(metric): metric = functools.partial(metric, **kwargs) # remove all values from kwargs, since they have already been provided # through the partial kwargs = {} elif metric in _qualitative_beta_metrics: counts = _quantitative_to_qualitative_counts(counts) elif metric not in _valid_beta_metrics: raise ValueError( "Metric %s is not available. " "Only the following metrics can be passed as strings to " "beta_diversity as we know whether each of these should be " "treated as a qualitative or quantitative metric. Other metrics " "can be provided as functions.\n Available metrics are: %s" % (metric, ', '.join(_valid_beta_metrics))) else: # metric is a string that scikit-bio doesn't know about, for # example one of the SciPy metrics pass if pairwise_func is None: pairwise_func = scipy.spatial.distance.pdist distances = pairwise_func(counts, metric=metric, **kwargs) return DistanceMatrix(distances, ids) scikit-bio-0.5.9/skbio/diversity/_phylogenetic.c000066400000000000000000012460651446255456000217410ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayscalars.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarraytypes.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ufuncobject.h" ], "include_dirs": [ "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include" ], "name": "skbio.diversity._phylogenetic", "sources": [ "skbio/diversity/_phylogenetic.pyx" ] }, "module_name": "skbio.diversity._phylogenetic" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__diversity___phylogenetic #define __PYX_HAVE_API__skbio__diversity___phylogenetic /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ndarrayobject.h" #include "numpy/ndarraytypes.h" #include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "skbio/diversity/_phylogenetic.pyx", "__init__.pxd", "type.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":689 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":690 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":691 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":696 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":697 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":698 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":703 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":704 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":713 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":714 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":715 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":717 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":718 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":719 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":721 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":722 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":724 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":725 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":726 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "skbio/diversity/_phylogenetic.pyx":14 * * DTYPE = np.int64 * ctypedef np.int64_t DTYPE_t # <<<<<<<<<<<<<< * * */ typedef __pyx_t_5numpy_int64_t __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":728 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":729 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":730 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":732 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); #define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* BufferFallbackError.proto */ static void __Pyx_RaiseBufferFallbackError(void); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif #define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* pyfrozenset_new.proto */ static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it); /* PySetContains.proto */ static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int64(npy_int64 value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE npy_int64 __Pyx_PyInt_As_npy_int64(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_generic = 0; static PyTypeObject *__pyx_ptype_5numpy_number = 0; static PyTypeObject *__pyx_ptype_5numpy_integer = 0; static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; static PyTypeObject *__pyx_ptype_5numpy_floating = 0; static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'cython' */ /* Module declarations from 'skbio.diversity._phylogenetic' */ static PyObject *__pyx_f_5skbio_9diversity_13_phylogenetic__traverse_reduce(PyArrayObject *, PyArrayObject *); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_double_t = { "double_t", NULL, sizeof(__pyx_t_5numpy_double_t), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t), 0 }; #define __Pyx_MODULE_NAME "skbio.diversity._phylogenetic" extern int __pyx_module_is_main_skbio__diversity___phylogenetic; int __pyx_module_is_main_skbio__diversity___phylogenetic = 0; /* Implementation of 'skbio.diversity._phylogenetic' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_a[] = "a"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_n[] = "n"; static const char __pyx_k_t[] = "t"; static const char __pyx_k_id[] = "id"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_p_i[] = "p_i"; static const char __pyx_k_sum[] = "sum"; static const char __pyx_k_copy[] = "copy"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mask[] = "mask"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_int64[] = "int64"; static const char __pyx_k_nodes[] = "nodes"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_astype[] = "astype"; static const char __pyx_k_counts[] = "counts"; static const char __pyx_k_double[] = "double"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_n_rows[] = "n_rows"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_parent[] = "parent"; static const char __pyx_k_tip_ds[] = "tip_ds"; static const char __pyx_k_indexed[] = "indexed"; static const char __pyx_k_nonzero[] = "nonzero"; static const char __pyx_k_tip_ids[] = "tip_ids"; static const char __pyx_k_counts_t[] = "counts_t"; static const char __pyx_k_preorder[] = "preorder"; static const char __pyx_k_transpose[] = "transpose"; static const char __pyx_k_atleast_2d[] = "atleast_2d"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_child_index[] = "child_index"; static const char __pyx_k_count_array[] = "count_array"; static const char __pyx_k_node_lookup[] = "node_lookup"; static const char __pyx_k_tip_indices[] = "tip_indices"; static const char __pyx_k_include_self[] = "include_self"; static const char __pyx_k_n_count_otus[] = "n_count_otus"; static const char __pyx_k_observed_ids[] = "observed_ids"; static const char __pyx_k_otus_in_nodes[] = "otus_in_nodes"; static const char __pyx_k_tip_distances[] = "_tip_distances"; static const char __pyx_k_n_count_vectors[] = "n_count_vectors"; static const char __pyx_k_nodes_by_counts[] = "_nodes_by_counts"; static const char __pyx_k_observed_ids_set[] = "observed_ids_set"; static const char __pyx_k_observed_indices[] = "observed_indices"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_skbio_diversity__phylogenetic[] = "skbio.diversity._phylogenetic"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_skbio_diversity__phylogenetic_py[] = "skbio/diversity/_phylogenetic.pyx"; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_n_s_a; static PyObject *__pyx_n_s_astype; static PyObject *__pyx_n_s_atleast_2d; static PyObject *__pyx_n_s_child_index; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_copy; static PyObject *__pyx_n_s_count_array; static PyObject *__pyx_n_s_counts; static PyObject *__pyx_n_s_counts_t; static PyObject *__pyx_n_s_double; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_id; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_include_self; static PyObject *__pyx_n_s_indexed; static PyObject *__pyx_n_s_int64; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mask; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_n_count_otus; static PyObject *__pyx_n_s_n_count_vectors; static PyObject *__pyx_n_s_n_rows; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_n_s_node_lookup; static PyObject *__pyx_n_s_nodes; static PyObject *__pyx_n_s_nodes_by_counts; static PyObject *__pyx_n_s_nonzero; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_observed_ids; static PyObject *__pyx_n_s_observed_ids_set; static PyObject *__pyx_n_s_observed_indices; static PyObject *__pyx_n_s_otus_in_nodes; static PyObject *__pyx_n_s_p_i; static PyObject *__pyx_n_s_parent; static PyObject *__pyx_n_s_preorder; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_skbio_diversity__phylogenetic; static PyObject *__pyx_kp_s_skbio_diversity__phylogenetic_py; static PyObject *__pyx_n_s_sum; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_tip_distances; static PyObject *__pyx_n_s_tip_ds; static PyObject *__pyx_n_s_tip_ids; static PyObject *__pyx_n_s_tip_indices; static PyObject *__pyx_n_s_transpose; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_5skbio_9diversity_13_phylogenetic__tip_distances(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_a, PyObject *__pyx_v_t, PyArrayObject *__pyx_v_tip_indices); /* proto */ static PyObject *__pyx_pf_5skbio_9diversity_13_phylogenetic_2_nodes_by_counts(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_counts, PyArrayObject *__pyx_v_tip_ids, PyObject *__pyx_v_indexed); /* proto */ static PyObject *__pyx_int_0; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__5; static PyObject *__pyx_codeobj__4; static PyObject *__pyx_codeobj__6; /* Late includes */ /* "skbio/diversity/_phylogenetic.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def _tip_distances(np.ndarray[np.double_t, ndim=1] a, object t, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] tip_indices): * """Sets each tip to its distance from the root */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9diversity_13_phylogenetic_1_tip_distances(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_9diversity_13_phylogenetic__tip_distances[] = "Sets each tip to its distance from the root\n\n Parameters\n ----------\n a : np.ndarray of double\n A matrix in which each row corresponds to a node in ``t``.\n t : skbio.tree.TreeNode\n The tree that corresponds to the rows in ``a``.\n tip_indices : np.ndarray of int\n The index positions in ``a`` of the tips in ``t``.\n\n Returns\n -------\n np.ndarray of double\n A matrix in which each row corresponds to a node in ``t``, Only the\n rows that correspond to tips are nonzero, and the values in these rows\n are the distance from that tip to the root of the tree.\n "; static PyMethodDef __pyx_mdef_5skbio_9diversity_13_phylogenetic_1_tip_distances = {"_tip_distances", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_9diversity_13_phylogenetic_1_tip_distances, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_9diversity_13_phylogenetic__tip_distances}; static PyObject *__pyx_pw_5skbio_9diversity_13_phylogenetic_1_tip_distances(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_a = 0; PyObject *__pyx_v_t = 0; PyArrayObject *__pyx_v_tip_indices = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_tip_distances (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,&__pyx_n_s_t,&__pyx_n_s_tip_indices,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_a)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_t)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_tip_distances", 1, 3, 3, 1); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tip_indices)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_tip_distances", 1, 3, 3, 2); __PYX_ERR(0, 19, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_tip_distances") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_a = ((PyArrayObject *)values[0]); __pyx_v_t = values[1]; __pyx_v_tip_indices = ((PyArrayObject *)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_tip_distances", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.diversity._phylogenetic._tip_distances", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 19, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_tip_indices), __pyx_ptype_5numpy_ndarray, 1, "tip_indices", 0))) __PYX_ERR(0, 20, __pyx_L1_error) __pyx_r = __pyx_pf_5skbio_9diversity_13_phylogenetic__tip_distances(__pyx_self, __pyx_v_a, __pyx_v_t, __pyx_v_tip_indices); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9diversity_13_phylogenetic__tip_distances(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_a, PyObject *__pyx_v_t, PyArrayObject *__pyx_v_tip_indices) { PyObject *__pyx_v_n = 0; Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_p_i; Py_ssize_t __pyx_v_n_rows; PyArrayObject *__pyx_v_mask = 0; PyArrayObject *__pyx_v_tip_ds = 0; __Pyx_LocalBuf_ND __pyx_pybuffernd_a; __Pyx_Buffer __pyx_pybuffer_a; __Pyx_LocalBuf_ND __pyx_pybuffernd_mask; __Pyx_Buffer __pyx_pybuffer_mask; __Pyx_LocalBuf_ND __pyx_pybuffernd_tip_ds; __Pyx_Buffer __pyx_pybuffer_tip_ds; __Pyx_LocalBuf_ND __pyx_pybuffernd_tip_indices; __Pyx_Buffer __pyx_pybuffer_tip_indices; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyArrayObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyArrayObject *__pyx_t_12 = NULL; int __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; npy_intp __pyx_t_17; npy_intp __pyx_t_18; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_19; Py_ssize_t __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_tip_distances", 0); __pyx_pybuffer_mask.pybuffer.buf = NULL; __pyx_pybuffer_mask.refcount = 0; __pyx_pybuffernd_mask.data = NULL; __pyx_pybuffernd_mask.rcbuffer = &__pyx_pybuffer_mask; __pyx_pybuffer_tip_ds.pybuffer.buf = NULL; __pyx_pybuffer_tip_ds.refcount = 0; __pyx_pybuffernd_tip_ds.data = NULL; __pyx_pybuffernd_tip_ds.rcbuffer = &__pyx_pybuffer_tip_ds; __pyx_pybuffer_a.pybuffer.buf = NULL; __pyx_pybuffer_a.refcount = 0; __pyx_pybuffernd_a.data = NULL; __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; __pyx_pybuffer_tip_indices.pybuffer.buf = NULL; __pyx_pybuffer_tip_indices.refcount = 0; __pyx_pybuffernd_tip_indices.data = NULL; __pyx_pybuffernd_tip_indices.rcbuffer = &__pyx_pybuffer_tip_indices; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tip_indices.rcbuffer->pybuffer, (PyObject*)__pyx_v_tip_indices, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_pybuffernd_tip_indices.diminfo[0].strides = __pyx_pybuffernd_tip_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_tip_indices.diminfo[0].shape = __pyx_pybuffernd_tip_indices.rcbuffer->pybuffer.shape[0]; /* "skbio/diversity/_phylogenetic.pyx":43 * Py_ssize_t i, p_i, n_rows * np.ndarray[np.double_t, ndim=1] mask * np.ndarray[np.double_t, ndim=1] tip_ds = a.copy() # <<<<<<<<<<<<<< * * # preorder reduction over the tree to gather distances at the tips */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_a), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 43, __pyx_L1_error) __pyx_t_4 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tip_ds.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { __pyx_v_tip_ds = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 43, __pyx_L1_error) } else {__pyx_pybuffernd_tip_ds.diminfo[0].strides = __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_tip_ds.diminfo[0].shape = __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.shape[0]; } } __pyx_t_4 = 0; __pyx_v_tip_ds = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":46 * * # preorder reduction over the tree to gather distances at the tips * n_rows = tip_ds.shape[0] # <<<<<<<<<<<<<< * for n in t.preorder(include_self=False): * i = n.id */ __pyx_v_n_rows = (__pyx_v_tip_ds->dimensions[0]); /* "skbio/diversity/_phylogenetic.pyx":47 * # preorder reduction over the tree to gather distances at the tips * n_rows = tip_ds.shape[0] * for n in t.preorder(include_self=False): # <<<<<<<<<<<<<< * i = n.id * p_i = n.parent.id */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_preorder); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_include_self, Py_False) < 0) __PYX_ERR(0, 47, __pyx_L1_error) __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 47, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 47, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 47, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif } } else { __pyx_t_3 = __pyx_t_6(__pyx_t_2); if (unlikely(!__pyx_t_3)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 47, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_3); } __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_3); __pyx_t_3 = 0; /* "skbio/diversity/_phylogenetic.pyx":48 * n_rows = tip_ds.shape[0] * for n in t.preorder(include_self=False): * i = n.id # <<<<<<<<<<<<<< * p_i = n.parent.id * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_n, __pyx_n_s_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_i = __pyx_t_7; /* "skbio/diversity/_phylogenetic.pyx":49 * for n in t.preorder(include_self=False): * i = n.id * p_i = n.parent.id # <<<<<<<<<<<<<< * * tip_ds[i] += tip_ds[p_i] */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_n, __pyx_n_s_parent); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_p_i = __pyx_t_7; /* "skbio/diversity/_phylogenetic.pyx":51 * p_i = n.parent.id * * tip_ds[i] += tip_ds[p_i] # <<<<<<<<<<<<<< * * # construct a mask that represents the locations of the tips */ __pyx_t_8 = __pyx_v_p_i; __pyx_t_9 = __pyx_v_i; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_tip_ds.diminfo[0].strides) += (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_tip_ds.diminfo[0].strides)); /* "skbio/diversity/_phylogenetic.pyx":47 * # preorder reduction over the tree to gather distances at the tips * n_rows = tip_ds.shape[0] * for n in t.preorder(include_self=False): # <<<<<<<<<<<<<< * i = n.id * p_i = n.parent.id */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":54 * * # construct a mask that represents the locations of the tips * mask = np.zeros(n_rows, dtype=np.double) # <<<<<<<<<<<<<< * for i in range(tip_indices.shape[0]): * mask[tip_indices[i]] = 1.0 */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_n_rows); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_np); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_double); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_11) < 0) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(((__pyx_t_11) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_11, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 54, __pyx_L1_error) __pyx_t_12 = ((PyArrayObject *)__pyx_t_11); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer); __pyx_t_13 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); if (unlikely(__pyx_t_13 < 0)) { PyErr_Fetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_v_mask, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_14); Py_XDECREF(__pyx_t_15); Py_XDECREF(__pyx_t_16); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __pyx_t_14 = __pyx_t_15 = __pyx_t_16 = 0; } __pyx_pybuffernd_mask.diminfo[0].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mask.diminfo[0].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 54, __pyx_L1_error) } __pyx_t_12 = 0; __pyx_v_mask = ((PyArrayObject *)__pyx_t_11); __pyx_t_11 = 0; /* "skbio/diversity/_phylogenetic.pyx":55 * # construct a mask that represents the locations of the tips * mask = np.zeros(n_rows, dtype=np.double) * for i in range(tip_indices.shape[0]): # <<<<<<<<<<<<<< * mask[tip_indices[i]] = 1.0 * */ __pyx_t_17 = (__pyx_v_tip_indices->dimensions[0]); __pyx_t_18 = __pyx_t_17; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_18; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; /* "skbio/diversity/_phylogenetic.pyx":56 * mask = np.zeros(n_rows, dtype=np.double) * for i in range(tip_indices.shape[0]): * mask[tip_indices[i]] = 1.0 # <<<<<<<<<<<<<< * * # apply the mask such that tip_ds only includes values which correspond to */ __pyx_t_8 = __pyx_v_i; __pyx_t_19 = (*__Pyx_BufPtrStrided1d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_tip_indices.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_tip_indices.diminfo[0].strides)); *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_mask.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_mask.diminfo[0].strides) = 1.0; } /* "skbio/diversity/_phylogenetic.pyx":60 * # apply the mask such that tip_ds only includes values which correspond to * # the tips of the tree. * for i in range(n_rows): # <<<<<<<<<<<<<< * tip_ds[i] *= mask[i] * */ __pyx_t_5 = __pyx_v_n_rows; __pyx_t_7 = __pyx_t_5; for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_7; __pyx_t_20+=1) { __pyx_v_i = __pyx_t_20; /* "skbio/diversity/_phylogenetic.pyx":61 * # the tips of the tree. * for i in range(n_rows): * tip_ds[i] *= mask[i] # <<<<<<<<<<<<<< * * return tip_ds */ __pyx_t_8 = __pyx_v_i; __pyx_t_9 = __pyx_v_i; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_tip_ds.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_tip_ds.diminfo[0].strides) *= (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_mask.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_mask.diminfo[0].strides)); } /* "skbio/diversity/_phylogenetic.pyx":63 * tip_ds[i] *= mask[i] * * return tip_ds # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_tip_ds)); __pyx_r = ((PyObject *)__pyx_v_tip_ds); goto __pyx_L0; /* "skbio/diversity/_phylogenetic.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def _tip_distances(np.ndarray[np.double_t, ndim=1] a, object t, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] tip_indices): * """Sets each tip to its distance from the root */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tip_ds.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tip_indices.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.diversity._phylogenetic._tip_distances", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tip_ds.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tip_indices.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF(__pyx_v_n); __Pyx_XDECREF((PyObject *)__pyx_v_mask); __Pyx_XDECREF((PyObject *)__pyx_v_tip_ds); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/diversity/_phylogenetic.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * cdef _traverse_reduce(np.ndarray[DTYPE_t, ndim=2] child_index, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=2] a): * """Apply a[k] = sum[i:j] */ static PyObject *__pyx_f_5skbio_9diversity_13_phylogenetic__traverse_reduce(PyArrayObject *__pyx_v_child_index, PyArrayObject *__pyx_v_a) { Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_j; Py_ssize_t __pyx_v_k; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_node; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_start; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_end; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_n_envs; __Pyx_LocalBuf_ND __pyx_pybuffernd_a; __Pyx_Buffer __pyx_pybuffer_a; __Pyx_LocalBuf_ND __pyx_pybuffernd_child_index; __Pyx_Buffer __pyx_pybuffer_child_index; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations npy_intp __pyx_t_1; npy_intp __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_6; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_7; Py_ssize_t __pyx_t_8; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_9; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_10; Py_ssize_t __pyx_t_11; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_12; Py_ssize_t __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_traverse_reduce", 0); __pyx_pybuffer_child_index.pybuffer.buf = NULL; __pyx_pybuffer_child_index.refcount = 0; __pyx_pybuffernd_child_index.data = NULL; __pyx_pybuffernd_child_index.rcbuffer = &__pyx_pybuffer_child_index; __pyx_pybuffer_a.pybuffer.buf = NULL; __pyx_pybuffer_a.refcount = 0; __pyx_pybuffernd_a.data = NULL; __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_child_index.rcbuffer->pybuffer, (PyObject*)__pyx_v_child_index, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_pybuffernd_child_index.diminfo[0].strides = __pyx_pybuffernd_child_index.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_child_index.diminfo[0].shape = __pyx_pybuffernd_child_index.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_child_index.diminfo[1].strides = __pyx_pybuffernd_child_index.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_child_index.diminfo[1].shape = __pyx_pybuffernd_child_index.rcbuffer->pybuffer.shape[1]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; /* "skbio/diversity/_phylogenetic.pyx":128 * Py_ssize_t i, j, k * DTYPE_t node, start, end * DTYPE_t n_envs = a.shape[1] # <<<<<<<<<<<<<< * * # possible GPGPU target */ __pyx_v_n_envs = (__pyx_v_a->dimensions[1]); /* "skbio/diversity/_phylogenetic.pyx":131 * * # possible GPGPU target * for i in range(child_index.shape[0]): # <<<<<<<<<<<<<< * node = child_index[i, 0] * start = child_index[i, 1] */ __pyx_t_1 = (__pyx_v_child_index->dimensions[0]); __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "skbio/diversity/_phylogenetic.pyx":132 * # possible GPGPU target * for i in range(child_index.shape[0]): * node = child_index[i, 0] # <<<<<<<<<<<<<< * start = child_index[i, 1] * end = child_index[i, 2] */ __pyx_t_4 = __pyx_v_i; __pyx_t_5 = 0; __pyx_v_node = (*__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_child_index.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_child_index.diminfo[0].strides, __pyx_t_5, __pyx_pybuffernd_child_index.diminfo[1].strides)); /* "skbio/diversity/_phylogenetic.pyx":133 * for i in range(child_index.shape[0]): * node = child_index[i, 0] * start = child_index[i, 1] # <<<<<<<<<<<<<< * end = child_index[i, 2] * */ __pyx_t_5 = __pyx_v_i; __pyx_t_4 = 1; __pyx_v_start = (*__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_child_index.rcbuffer->pybuffer.buf, __pyx_t_5, __pyx_pybuffernd_child_index.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_child_index.diminfo[1].strides)); /* "skbio/diversity/_phylogenetic.pyx":134 * node = child_index[i, 0] * start = child_index[i, 1] * end = child_index[i, 2] # <<<<<<<<<<<<<< * * for j in range(start, end + 1): */ __pyx_t_4 = __pyx_v_i; __pyx_t_5 = 2; __pyx_v_end = (*__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_child_index.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_child_index.diminfo[0].strides, __pyx_t_5, __pyx_pybuffernd_child_index.diminfo[1].strides)); /* "skbio/diversity/_phylogenetic.pyx":136 * end = child_index[i, 2] * * for j in range(start, end + 1): # <<<<<<<<<<<<<< * for k in range(n_envs): * a[node, k] += a[j, k] */ __pyx_t_6 = (__pyx_v_end + 1); __pyx_t_7 = __pyx_t_6; for (__pyx_t_8 = __pyx_v_start; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_j = __pyx_t_8; /* "skbio/diversity/_phylogenetic.pyx":137 * * for j in range(start, end + 1): * for k in range(n_envs): # <<<<<<<<<<<<<< * a[node, k] += a[j, k] * */ __pyx_t_9 = __pyx_v_n_envs; __pyx_t_10 = __pyx_t_9; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_k = __pyx_t_11; /* "skbio/diversity/_phylogenetic.pyx":138 * for j in range(start, end + 1): * for k in range(n_envs): * a[node, k] += a[j, k] # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __pyx_v_j; __pyx_t_4 = __pyx_v_k; __pyx_t_12 = __pyx_v_node; __pyx_t_13 = __pyx_v_k; *__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_a.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_a.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_a.diminfo[1].strides) += (*__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_a.rcbuffer->pybuffer.buf, __pyx_t_5, __pyx_pybuffernd_a.diminfo[0].strides, __pyx_t_4, __pyx_pybuffernd_a.diminfo[1].strides)); } } } /* "skbio/diversity/_phylogenetic.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * cdef _traverse_reduce(np.ndarray[DTYPE_t, ndim=2] child_index, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=2] a): * """Apply a[k] = sum[i:j] */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_child_index.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.diversity._phylogenetic._traverse_reduce", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_child_index.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/diversity/_phylogenetic.pyx":143 * @cython.boundscheck(False) * @cython.wraparound(False) * def _nodes_by_counts(np.ndarray counts, # <<<<<<<<<<<<<< * np.ndarray tip_ids, * dict indexed): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_9diversity_13_phylogenetic_3_nodes_by_counts(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_9diversity_13_phylogenetic_2_nodes_by_counts[] = "Construct the count array, and the counts up the tree\n\n Parameters\n ----------\n counts : np.array of int\n A 1D or 2D vector in which each row corresponds to the observed counts\n in an environment. The rows are expected to be in order with respect to\n `tip_ids`.\n tip_ids : np.array of str\n A vector of tip names that correspond to the columns in the `counts`\n matrix.\n indexed : dict\n The result of `index_tree`.\n\n Returns\n -------\n np.array of int\n The observed counts of every node and the counts if its descendents.\n\n "; static PyMethodDef __pyx_mdef_5skbio_9diversity_13_phylogenetic_3_nodes_by_counts = {"_nodes_by_counts", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_9diversity_13_phylogenetic_3_nodes_by_counts, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_9diversity_13_phylogenetic_2_nodes_by_counts}; static PyObject *__pyx_pw_5skbio_9diversity_13_phylogenetic_3_nodes_by_counts(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_counts = 0; PyArrayObject *__pyx_v_tip_ids = 0; PyObject *__pyx_v_indexed = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_nodes_by_counts (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_counts,&__pyx_n_s_tip_ids,&__pyx_n_s_indexed,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_counts)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tip_ids)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_nodes_by_counts", 1, 3, 3, 1); __PYX_ERR(0, 143, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_indexed)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_nodes_by_counts", 1, 3, 3, 2); __PYX_ERR(0, 143, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_nodes_by_counts") < 0)) __PYX_ERR(0, 143, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_counts = ((PyArrayObject *)values[0]); __pyx_v_tip_ids = ((PyArrayObject *)values[1]); __pyx_v_indexed = ((PyObject*)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_nodes_by_counts", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 143, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.diversity._phylogenetic._nodes_by_counts", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_counts), __pyx_ptype_5numpy_ndarray, 1, "counts", 0))) __PYX_ERR(0, 143, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_tip_ids), __pyx_ptype_5numpy_ndarray, 1, "tip_ids", 0))) __PYX_ERR(0, 144, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_indexed), (&PyDict_Type), 1, "indexed", 1))) __PYX_ERR(0, 145, __pyx_L1_error) __pyx_r = __pyx_pf_5skbio_9diversity_13_phylogenetic_2_nodes_by_counts(__pyx_self, __pyx_v_counts, __pyx_v_tip_ids, __pyx_v_indexed); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_9diversity_13_phylogenetic_2_nodes_by_counts(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_counts, PyArrayObject *__pyx_v_tip_ids, PyObject *__pyx_v_indexed) { PyArrayObject *__pyx_v_nodes = 0; PyArrayObject *__pyx_v_observed_ids = 0; PyArrayObject *__pyx_v_count_array = 0; PyArrayObject *__pyx_v_counts_t = 0; PyArrayObject *__pyx_v_observed_indices = 0; PyArrayObject *__pyx_v_otus_in_nodes = 0; Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_j; PyObject *__pyx_v_observed_ids_set = 0; PyObject *__pyx_v_n = 0; PyObject *__pyx_v_node_lookup = 0; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_n_count_vectors; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_v_n_count_otus; PyObject *__pyx_v_child_index = NULL; __Pyx_LocalBuf_ND __pyx_pybuffernd_count_array; __Pyx_Buffer __pyx_pybuffer_count_array; __Pyx_LocalBuf_ND __pyx_pybuffernd_counts_t; __Pyx_Buffer __pyx_pybuffer_counts_t; __Pyx_LocalBuf_ND __pyx_pybuffernd_observed_indices; __Pyx_Buffer __pyx_pybuffer_observed_indices; __Pyx_LocalBuf_ND __pyx_pybuffernd_otus_in_nodes; __Pyx_Buffer __pyx_pybuffer_otus_in_nodes; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; npy_intp __pyx_t_10; npy_intp __pyx_t_11; Py_ssize_t __pyx_t_12; int __pyx_t_13; int __pyx_t_14; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_15; Py_ssize_t __pyx_t_16; PyArrayObject *__pyx_t_17 = NULL; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_18; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_19; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_20; Py_ssize_t __pyx_t_21; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_22; Py_ssize_t __pyx_t_23; Py_ssize_t __pyx_t_24; __pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t __pyx_t_25; Py_ssize_t __pyx_t_26; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_nodes_by_counts", 0); __Pyx_INCREF((PyObject *)__pyx_v_counts); __pyx_pybuffer_count_array.pybuffer.buf = NULL; __pyx_pybuffer_count_array.refcount = 0; __pyx_pybuffernd_count_array.data = NULL; __pyx_pybuffernd_count_array.rcbuffer = &__pyx_pybuffer_count_array; __pyx_pybuffer_counts_t.pybuffer.buf = NULL; __pyx_pybuffer_counts_t.refcount = 0; __pyx_pybuffernd_counts_t.data = NULL; __pyx_pybuffernd_counts_t.rcbuffer = &__pyx_pybuffer_counts_t; __pyx_pybuffer_observed_indices.pybuffer.buf = NULL; __pyx_pybuffer_observed_indices.refcount = 0; __pyx_pybuffernd_observed_indices.data = NULL; __pyx_pybuffernd_observed_indices.rcbuffer = &__pyx_pybuffer_observed_indices; __pyx_pybuffer_otus_in_nodes.pybuffer.buf = NULL; __pyx_pybuffer_otus_in_nodes.refcount = 0; __pyx_pybuffernd_otus_in_nodes.data = NULL; __pyx_pybuffernd_otus_in_nodes.rcbuffer = &__pyx_pybuffer_otus_in_nodes; /* "skbio/diversity/_phylogenetic.pyx":176 * DTYPE_t n_count_vectors, n_count_otus * * nodes = indexed['name'] # <<<<<<<<<<<<<< * * # allow counts to be a vector */ if (unlikely(__pyx_v_indexed == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 176, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_indexed, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 176, __pyx_L1_error) __pyx_v_nodes = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":179 * * # allow counts to be a vector * counts = np.atleast_2d(counts) # <<<<<<<<<<<<<< * counts = counts.astype(DTYPE, copy=False) * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_atleast_2d); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, ((PyObject *)__pyx_v_counts)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_counts)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 179, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_counts, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":180 * # allow counts to be a vector * counts = np.atleast_2d(counts) * counts = counts.astype(DTYPE, copy=False) # <<<<<<<<<<<<<< * * # determine observed IDs. It may be possible to unroll these calls to */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_counts), __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_copy, Py_False) < 0) __PYX_ERR(0, 180, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 180, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_counts, ((PyArrayObject *)__pyx_t_4)); __pyx_t_4 = 0; /* "skbio/diversity/_phylogenetic.pyx":184 * # determine observed IDs. It may be possible to unroll these calls to * # squeeze a little more performance * observed_indices = counts.sum(0).nonzero()[0] # <<<<<<<<<<<<<< * observed_ids = tip_ids[observed_indices] * observed_ids_set = set(observed_ids) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_counts), __pyx_n_s_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_int_0) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_int_0); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_nonzero); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 184, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_observed_indices.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_observed_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_observed_indices.rcbuffer->pybuffer, (PyObject*)__pyx_v_observed_indices, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_7); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_7, __pyx_t_8, __pyx_t_9); } __pyx_t_7 = __pyx_t_8 = __pyx_t_9 = 0; } __pyx_pybuffernd_observed_indices.diminfo[0].strides = __pyx_pybuffernd_observed_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_observed_indices.diminfo[0].shape = __pyx_pybuffernd_observed_indices.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) } __pyx_t_5 = 0; __pyx_v_observed_indices = ((PyArrayObject *)__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":185 * # squeeze a little more performance * observed_indices = counts.sum(0).nonzero()[0] * observed_ids = tip_ids[observed_indices] # <<<<<<<<<<<<<< * observed_ids_set = set(observed_ids) * */ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_tip_ids), ((PyObject *)__pyx_v_observed_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 185, __pyx_L1_error) __pyx_v_observed_ids = ((PyArrayObject *)__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":186 * observed_indices = counts.sum(0).nonzero()[0] * observed_ids = tip_ids[observed_indices] * observed_ids_set = set(observed_ids) # <<<<<<<<<<<<<< * * # construct mappings of the observed to their positions in the node array */ __pyx_t_2 = PySet_New(((PyObject *)__pyx_v_observed_ids)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_observed_ids_set = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":189 * * # construct mappings of the observed to their positions in the node array * node_lookup = {} # <<<<<<<<<<<<<< * for i in range(nodes.shape[0]): * n = nodes[i] */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_node_lookup = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":190 * # construct mappings of the observed to their positions in the node array * node_lookup = {} * for i in range(nodes.shape[0]): # <<<<<<<<<<<<<< * n = nodes[i] * if n in observed_ids_set: */ __pyx_t_10 = (__pyx_v_nodes->dimensions[0]); __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; /* "skbio/diversity/_phylogenetic.pyx":191 * node_lookup = {} * for i in range(nodes.shape[0]): * n = nodes[i] # <<<<<<<<<<<<<< * if n in observed_ids_set: * node_lookup[n] = i */ __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_nodes), __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":192 * for i in range(nodes.shape[0]): * n = nodes[i] * if n in observed_ids_set: # <<<<<<<<<<<<<< * node_lookup[n] = i * */ __pyx_t_13 = (__Pyx_PySet_ContainsTF(__pyx_v_n, __pyx_v_observed_ids_set, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 192, __pyx_L1_error) __pyx_t_14 = (__pyx_t_13 != 0); if (__pyx_t_14) { /* "skbio/diversity/_phylogenetic.pyx":193 * n = nodes[i] * if n in observed_ids_set: * node_lookup[n] = i # <<<<<<<<<<<<<< * * # determine the positions of the observed IDs in nodes */ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (unlikely(PyDict_SetItem(__pyx_v_node_lookup, __pyx_v_n, __pyx_t_2) < 0)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":192 * for i in range(nodes.shape[0]): * n = nodes[i] * if n in observed_ids_set: # <<<<<<<<<<<<<< * node_lookup[n] = i * */ } } /* "skbio/diversity/_phylogenetic.pyx":196 * * # determine the positions of the observed IDs in nodes * otus_in_nodes = np.zeros(observed_ids.shape[0], dtype=DTYPE) # <<<<<<<<<<<<<< * for i in range(observed_ids.shape[0]): * n = observed_ids[i] */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_observed_ids->dimensions[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 196, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer, (PyObject*)__pyx_v_otus_in_nodes, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_7); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_9, __pyx_t_8, __pyx_t_7); } __pyx_t_9 = __pyx_t_8 = __pyx_t_7 = 0; } __pyx_pybuffernd_otus_in_nodes.diminfo[0].strides = __pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_otus_in_nodes.diminfo[0].shape = __pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 196, __pyx_L1_error) } __pyx_t_5 = 0; __pyx_v_otus_in_nodes = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":197 * # determine the positions of the observed IDs in nodes * otus_in_nodes = np.zeros(observed_ids.shape[0], dtype=DTYPE) * for i in range(observed_ids.shape[0]): # <<<<<<<<<<<<<< * n = observed_ids[i] * otus_in_nodes[i] = node_lookup[n] */ __pyx_t_10 = (__pyx_v_observed_ids->dimensions[0]); __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; /* "skbio/diversity/_phylogenetic.pyx":198 * otus_in_nodes = np.zeros(observed_ids.shape[0], dtype=DTYPE) * for i in range(observed_ids.shape[0]): * n = observed_ids[i] # <<<<<<<<<<<<<< * otus_in_nodes[i] = node_lookup[n] * */ __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_observed_ids), __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":199 * for i in range(observed_ids.shape[0]): * n = observed_ids[i] * otus_in_nodes[i] = node_lookup[n] # <<<<<<<<<<<<<< * * # count_array has a row per node (not tip) and a column per env. */ __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_node_lookup, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_15 = __Pyx_PyInt_As_npy_int64(__pyx_t_1); if (unlikely((__pyx_t_15 == ((npy_int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_16 = __pyx_v_i; *__Pyx_BufPtrStrided1d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_otus_in_nodes.diminfo[0].strides) = __pyx_t_15; } /* "skbio/diversity/_phylogenetic.pyx":202 * * # count_array has a row per node (not tip) and a column per env. * n_count_vectors = counts.shape[0] # <<<<<<<<<<<<<< * count_array = np.zeros((nodes.shape[0], n_count_vectors), dtype=DTYPE) * */ __pyx_v_n_count_vectors = (__pyx_v_counts->dimensions[0]); /* "skbio/diversity/_phylogenetic.pyx":203 * # count_array has a row per node (not tip) and a column per env. * n_count_vectors = counts.shape[0] * count_array = np.zeros((nodes.shape[0], n_count_vectors), dtype=DTYPE) # <<<<<<<<<<<<<< * * # populate the counts array with the counts of each observation in each */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t((__pyx_v_nodes->dimensions[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_npy_int64(__pyx_v_n_count_vectors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 203, __pyx_L1_error) __pyx_t_17 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_count_array.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_count_array.rcbuffer->pybuffer, (PyObject*)__pyx_t_17, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_count_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_count_array, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_7); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_7, __pyx_t_8, __pyx_t_9); } __pyx_t_7 = __pyx_t_8 = __pyx_t_9 = 0; } __pyx_pybuffernd_count_array.diminfo[0].strides = __pyx_pybuffernd_count_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_count_array.diminfo[0].shape = __pyx_pybuffernd_count_array.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_count_array.diminfo[1].strides = __pyx_pybuffernd_count_array.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_count_array.diminfo[1].shape = __pyx_pybuffernd_count_array.rcbuffer->pybuffer.shape[1]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 203, __pyx_L1_error) } __pyx_t_17 = 0; __pyx_v_count_array = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":207 * # populate the counts array with the counts of each observation in each * # env * counts_t = counts.transpose() # <<<<<<<<<<<<<< * n_count_otus = otus_in_nodes.shape[0] * for i in range(n_count_otus): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_counts), __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 207, __pyx_L1_error) __pyx_t_17 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_counts_t.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_counts_t.rcbuffer->pybuffer, (PyObject*)__pyx_t_17, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_counts_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_counts_t, &__Pyx_TypeInfo_nn___pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_7); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_9, __pyx_t_8, __pyx_t_7); } __pyx_t_9 = __pyx_t_8 = __pyx_t_7 = 0; } __pyx_pybuffernd_counts_t.diminfo[0].strides = __pyx_pybuffernd_counts_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_counts_t.diminfo[0].shape = __pyx_pybuffernd_counts_t.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_counts_t.diminfo[1].strides = __pyx_pybuffernd_counts_t.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_counts_t.diminfo[1].shape = __pyx_pybuffernd_counts_t.rcbuffer->pybuffer.shape[1]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 207, __pyx_L1_error) } __pyx_t_17 = 0; __pyx_v_counts_t = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":208 * # env * counts_t = counts.transpose() * n_count_otus = otus_in_nodes.shape[0] # <<<<<<<<<<<<<< * for i in range(n_count_otus): * for j in range(n_count_vectors): */ __pyx_v_n_count_otus = (__pyx_v_otus_in_nodes->dimensions[0]); /* "skbio/diversity/_phylogenetic.pyx":209 * counts_t = counts.transpose() * n_count_otus = otus_in_nodes.shape[0] * for i in range(n_count_otus): # <<<<<<<<<<<<<< * for j in range(n_count_vectors): * count_array[otus_in_nodes[i], j] = counts_t[observed_indices[i], j] */ __pyx_t_15 = __pyx_v_n_count_otus; __pyx_t_18 = __pyx_t_15; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_18; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; /* "skbio/diversity/_phylogenetic.pyx":210 * n_count_otus = otus_in_nodes.shape[0] * for i in range(n_count_otus): * for j in range(n_count_vectors): # <<<<<<<<<<<<<< * count_array[otus_in_nodes[i], j] = counts_t[observed_indices[i], j] * */ __pyx_t_19 = __pyx_v_n_count_vectors; __pyx_t_20 = __pyx_t_19; for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { __pyx_v_j = __pyx_t_21; /* "skbio/diversity/_phylogenetic.pyx":211 * for i in range(n_count_otus): * for j in range(n_count_vectors): * count_array[otus_in_nodes[i], j] = counts_t[observed_indices[i], j] # <<<<<<<<<<<<<< * * child_index = indexed['child_index'].astype(DTYPE, copy=False) */ __pyx_t_16 = __pyx_v_i; __pyx_t_22 = (*__Pyx_BufPtrStrided1d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_observed_indices.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_observed_indices.diminfo[0].strides)); __pyx_t_23 = __pyx_v_j; __pyx_t_24 = __pyx_v_i; __pyx_t_25 = (*__Pyx_BufPtrStrided1d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_otus_in_nodes.diminfo[0].strides)); __pyx_t_26 = __pyx_v_j; *__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_count_array.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_count_array.diminfo[0].strides, __pyx_t_26, __pyx_pybuffernd_count_array.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(__pyx_t_5skbio_9diversity_13_phylogenetic_DTYPE_t *, __pyx_pybuffernd_counts_t.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_counts_t.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_counts_t.diminfo[1].strides)); } } /* "skbio/diversity/_phylogenetic.pyx":213 * count_array[otus_in_nodes[i], j] = counts_t[observed_indices[i], j] * * child_index = indexed['child_index'].astype(DTYPE, copy=False) # <<<<<<<<<<<<<< * _traverse_reduce(child_index, count_array) * */ if (unlikely(__pyx_v_indexed == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 213, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_indexed, __pyx_n_s_child_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_astype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_copy, Py_False) < 0) __PYX_ERR(0, 213, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_child_index = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":214 * * child_index = indexed['child_index'].astype(DTYPE, copy=False) * _traverse_reduce(child_index, count_array) # <<<<<<<<<<<<<< * * return count_array */ if (!(likely(((__pyx_v_child_index) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_child_index, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 214, __pyx_L1_error) __pyx_t_2 = __pyx_f_5skbio_9diversity_13_phylogenetic__traverse_reduce(((PyArrayObject *)__pyx_v_child_index), ((PyArrayObject *)__pyx_v_count_array)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":216 * _traverse_reduce(child_index, count_array) * * return count_array # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_count_array)); __pyx_r = ((PyObject *)__pyx_v_count_array); goto __pyx_L0; /* "skbio/diversity/_phylogenetic.pyx":143 * @cython.boundscheck(False) * @cython.wraparound(False) * def _nodes_by_counts(np.ndarray counts, # <<<<<<<<<<<<<< * np.ndarray tip_ids, * dict indexed): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_count_array.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_counts_t.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_observed_indices.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.diversity._phylogenetic._nodes_by_counts", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_count_array.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_counts_t.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_observed_indices.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_otus_in_nodes.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_nodes); __Pyx_XDECREF((PyObject *)__pyx_v_observed_ids); __Pyx_XDECREF((PyObject *)__pyx_v_count_array); __Pyx_XDECREF((PyObject *)__pyx_v_counts_t); __Pyx_XDECREF((PyObject *)__pyx_v_observed_indices); __Pyx_XDECREF((PyObject *)__pyx_v_otus_in_nodes); __Pyx_XDECREF(__pyx_v_observed_ids_set); __Pyx_XDECREF(__pyx_v_n); __Pyx_XDECREF(__pyx_v_node_lookup); __Pyx_XDECREF(__pyx_v_child_index); __Pyx_XDECREF((PyObject *)__pyx_v_counts); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":735 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":738 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":741 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":744 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":747 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":751 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":753 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":929 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":930 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":933 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":935 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":936 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":942 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 942, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":943 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 943, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 944, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":948 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 948, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":949 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 949, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 950, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":954 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 954, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":955 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 955, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":956 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 956, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_timedelta64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":978 * bool * """ * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_datetime64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":993 * bool * """ * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1003 * also needed. That can be found using `get_datetime64_unit`. * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1010 * returns the int64 value underlying scalar numpy timedelta64 object * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1017 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /* function exit code */ __pyx_L0:; return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__phylogenetic(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__phylogenetic}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_phylogenetic", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, {&__pyx_n_s_atleast_2d, __pyx_k_atleast_2d, sizeof(__pyx_k_atleast_2d), 0, 0, 1, 1}, {&__pyx_n_s_child_index, __pyx_k_child_index, sizeof(__pyx_k_child_index), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, {&__pyx_n_s_count_array, __pyx_k_count_array, sizeof(__pyx_k_count_array), 0, 0, 1, 1}, {&__pyx_n_s_counts, __pyx_k_counts, sizeof(__pyx_k_counts), 0, 0, 1, 1}, {&__pyx_n_s_counts_t, __pyx_k_counts_t, sizeof(__pyx_k_counts_t), 0, 0, 1, 1}, {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_include_self, __pyx_k_include_self, sizeof(__pyx_k_include_self), 0, 0, 1, 1}, {&__pyx_n_s_indexed, __pyx_k_indexed, sizeof(__pyx_k_indexed), 0, 0, 1, 1}, {&__pyx_n_s_int64, __pyx_k_int64, sizeof(__pyx_k_int64), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_n_count_otus, __pyx_k_n_count_otus, sizeof(__pyx_k_n_count_otus), 0, 0, 1, 1}, {&__pyx_n_s_n_count_vectors, __pyx_k_n_count_vectors, sizeof(__pyx_k_n_count_vectors), 0, 0, 1, 1}, {&__pyx_n_s_n_rows, __pyx_k_n_rows, sizeof(__pyx_k_n_rows), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_n_s_node_lookup, __pyx_k_node_lookup, sizeof(__pyx_k_node_lookup), 0, 0, 1, 1}, {&__pyx_n_s_nodes, __pyx_k_nodes, sizeof(__pyx_k_nodes), 0, 0, 1, 1}, {&__pyx_n_s_nodes_by_counts, __pyx_k_nodes_by_counts, sizeof(__pyx_k_nodes_by_counts), 0, 0, 1, 1}, {&__pyx_n_s_nonzero, __pyx_k_nonzero, sizeof(__pyx_k_nonzero), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, {&__pyx_n_s_observed_ids, __pyx_k_observed_ids, sizeof(__pyx_k_observed_ids), 0, 0, 1, 1}, {&__pyx_n_s_observed_ids_set, __pyx_k_observed_ids_set, sizeof(__pyx_k_observed_ids_set), 0, 0, 1, 1}, {&__pyx_n_s_observed_indices, __pyx_k_observed_indices, sizeof(__pyx_k_observed_indices), 0, 0, 1, 1}, {&__pyx_n_s_otus_in_nodes, __pyx_k_otus_in_nodes, sizeof(__pyx_k_otus_in_nodes), 0, 0, 1, 1}, {&__pyx_n_s_p_i, __pyx_k_p_i, sizeof(__pyx_k_p_i), 0, 0, 1, 1}, {&__pyx_n_s_parent, __pyx_k_parent, sizeof(__pyx_k_parent), 0, 0, 1, 1}, {&__pyx_n_s_preorder, __pyx_k_preorder, sizeof(__pyx_k_preorder), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_skbio_diversity__phylogenetic, __pyx_k_skbio_diversity__phylogenetic, sizeof(__pyx_k_skbio_diversity__phylogenetic), 0, 0, 1, 1}, {&__pyx_kp_s_skbio_diversity__phylogenetic_py, __pyx_k_skbio_diversity__phylogenetic_py, sizeof(__pyx_k_skbio_diversity__phylogenetic_py), 0, 0, 1, 0}, {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_tip_distances, __pyx_k_tip_distances, sizeof(__pyx_k_tip_distances), 0, 0, 1, 1}, {&__pyx_n_s_tip_ds, __pyx_k_tip_ds, sizeof(__pyx_k_tip_ds), 0, 0, 1, 1}, {&__pyx_n_s_tip_ids, __pyx_k_tip_ids, sizeof(__pyx_k_tip_ids), 0, 0, 1, 1}, {&__pyx_n_s_tip_indices, __pyx_k_tip_indices, sizeof(__pyx_k_tip_indices), 0, 0, 1, 1}, {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 55, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 944, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 944, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "skbio/diversity/_phylogenetic.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def _tip_distances(np.ndarray[np.double_t, ndim=1] a, object t, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] tip_indices): * """Sets each tip to its distance from the root */ __pyx_tuple__3 = PyTuple_Pack(9, __pyx_n_s_a, __pyx_n_s_t, __pyx_n_s_tip_indices, __pyx_n_s_n, __pyx_n_s_i, __pyx_n_s_p_i, __pyx_n_s_n_rows, __pyx_n_s_mask, __pyx_n_s_tip_ds); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_diversity__phylogenetic_py, __pyx_n_s_tip_distances, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 19, __pyx_L1_error) /* "skbio/diversity/_phylogenetic.pyx":143 * @cython.boundscheck(False) * @cython.wraparound(False) * def _nodes_by_counts(np.ndarray counts, # <<<<<<<<<<<<<< * np.ndarray tip_ids, * dict indexed): */ __pyx_tuple__5 = PyTuple_Pack(17, __pyx_n_s_counts, __pyx_n_s_tip_ids, __pyx_n_s_indexed, __pyx_n_s_nodes, __pyx_n_s_observed_ids, __pyx_n_s_count_array, __pyx_n_s_counts_t, __pyx_n_s_observed_indices, __pyx_n_s_otus_in_nodes, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_observed_ids_set, __pyx_n_s_n, __pyx_n_s_node_lookup, __pyx_n_s_n_count_vectors, __pyx_n_s_n_count_otus, __pyx_n_s_child_index); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(3, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_diversity__phylogenetic_py, __pyx_n_s_nodes_by_counts, 143, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 770, __pyx_L1_error) __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 772, __pyx_L1_error) __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 774, __pyx_L1_error) __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 776, __pyx_L1_error) __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 778, __pyx_L1_error) __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 780, __pyx_L1_error) __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 782, __pyx_L1_error) __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 784, __pyx_L1_error) __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 786, __pyx_L1_error) __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 788, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_phylogenetic(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_phylogenetic(void) #else __Pyx_PyMODINIT_FUNC PyInit__phylogenetic(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__phylogenetic(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__phylogenetic(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_phylogenetic' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__phylogenetic(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_phylogenetic", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__diversity___phylogenetic) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.diversity._phylogenetic")) { if (unlikely(PyDict_SetItemString(modules, "skbio.diversity._phylogenetic", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "skbio/diversity/_phylogenetic.pyx":9 * # ---------------------------------------------------------------------------- * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * cimport cython */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/diversity/_phylogenetic.pyx":13 * cimport cython * * DTYPE = np.int64 # <<<<<<<<<<<<<< * ctypedef np.int64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_int64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def _tip_distances(np.ndarray[np.double_t, ndim=1] a, object t, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] tip_indices): * """Sets each tip to its distance from the root */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5skbio_9diversity_13_phylogenetic_1_tip_distances, NULL, __pyx_n_s_skbio_diversity__phylogenetic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_tip_distances, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":143 * @cython.boundscheck(False) * @cython.wraparound(False) * def _nodes_by_counts(np.ndarray counts, # <<<<<<<<<<<<<< * np.ndarray tip_ids, * dict indexed): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5skbio_9diversity_13_phylogenetic_3_nodes_by_counts, NULL, __pyx_n_s_skbio_diversity__phylogenetic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_nodes_by_counts, __pyx_t_2) < 0) __PYX_ERR(0, 143, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/diversity/_phylogenetic.pyx":1 * # ---------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # Copyright (c) 2013--, scikit-bio development team. * # */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.diversity._phylogenetic", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.diversity._phylogenetic"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* BufferFallbackError */ static void __Pyx_RaiseBufferFallbackError(void) { PyErr_SetString(PyExc_ValueError, "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; if (unlikely(!(m && m->sq_item))) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; } key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; if (likely(m && m->mp_subscript)) { return m->mp_subscript(obj, key); } return __Pyx_PyObject_GetIndex(obj, key); } #endif /* pyfrozenset_new */ static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { if (it) { PyObject* result; #if CYTHON_COMPILING_IN_PYPY PyObject* args; args = PyTuple_Pack(1, it); if (unlikely(!args)) return NULL; result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL); Py_DECREF(args); return result; #else if (PyFrozenSet_CheckExact(it)) { Py_INCREF(it); return it; } result = PyFrozenSet_New(it); if (unlikely(!result)) return NULL; if ((PY_VERSION_HEX >= 0x031000A1) || likely(PySet_GET_SIZE(result))) return result; Py_DECREF(result); #endif } #if CYTHON_USE_TYPE_SLOTS return PyFrozenSet_Type.tp_new(&PyFrozenSet_Type, __pyx_empty_tuple, NULL); #else return PyObject_Call((PyObject*)&PyFrozenSet_Type, __pyx_empty_tuple, NULL); #endif } /* PySetContains */ static int __Pyx_PySet_ContainsUnhashable(PyObject *set, PyObject *key) { int result = -1; if (PySet_Check(key) && PyErr_ExceptionMatches(PyExc_TypeError)) { PyObject *tmpkey; PyErr_Clear(); tmpkey = __Pyx_PyFrozenSet_New(key); if (tmpkey != NULL) { result = PySet_Contains(set, tmpkey); Py_DECREF(tmpkey); } } return result; } static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq) { int result = PySet_Contains(set, key); if (unlikely(result < 0)) { result = __Pyx_PySet_ContainsUnhashable(set, key); } return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(Py_intptr_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(Py_intptr_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int64(npy_int64 value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int64 neg_one = (npy_int64) -1, const_zero = (npy_int64) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(npy_int64) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(npy_int64) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(npy_int64) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(npy_int64), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE npy_int64 __Pyx_PyInt_As_npy_int64(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int64 neg_one = (npy_int64) -1, const_zero = (npy_int64) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(npy_int64) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(npy_int64, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (npy_int64) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int64) 0; case 1: __PYX_VERIFY_RETURN_INT(npy_int64, digit, digits[0]) case 2: if (8 * sizeof(npy_int64) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) >= 2 * PyLong_SHIFT) { return (npy_int64) (((((npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0])); } } break; case 3: if (8 * sizeof(npy_int64) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) >= 3 * PyLong_SHIFT) { return (npy_int64) (((((((npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0])); } } break; case 4: if (8 * sizeof(npy_int64) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) >= 4 * PyLong_SHIFT) { return (npy_int64) (((((((((npy_int64)digits[3]) << PyLong_SHIFT) | (npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (npy_int64) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(npy_int64) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int64, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int64, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (npy_int64) 0; case -1: __PYX_VERIFY_RETURN_INT(npy_int64, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(npy_int64, digit, +digits[0]) case -2: if (8 * sizeof(npy_int64) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 2 * PyLong_SHIFT) { return (npy_int64) (((npy_int64)-1)*(((((npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; case 2: if (8 * sizeof(npy_int64) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 2 * PyLong_SHIFT) { return (npy_int64) ((((((npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; case -3: if (8 * sizeof(npy_int64) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 3 * PyLong_SHIFT) { return (npy_int64) (((npy_int64)-1)*(((((((npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; case 3: if (8 * sizeof(npy_int64) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 3 * PyLong_SHIFT) { return (npy_int64) ((((((((npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; case -4: if (8 * sizeof(npy_int64) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 4 * PyLong_SHIFT) { return (npy_int64) (((npy_int64)-1)*(((((((((npy_int64)digits[3]) << PyLong_SHIFT) | (npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; case 4: if (8 * sizeof(npy_int64) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(npy_int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(npy_int64) - 1 > 4 * PyLong_SHIFT) { return (npy_int64) ((((((((((npy_int64)digits[3]) << PyLong_SHIFT) | (npy_int64)digits[2]) << PyLong_SHIFT) | (npy_int64)digits[1]) << PyLong_SHIFT) | (npy_int64)digits[0]))); } } break; } #endif if (sizeof(npy_int64) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int64, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(npy_int64, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else npy_int64 val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (npy_int64) -1; } } else { npy_int64 val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (npy_int64) -1; val = __Pyx_PyInt_As_npy_int64(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to npy_int64"); return (npy_int64) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to npy_int64"); return (npy_int64) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/diversity/_phylogenetic.pyx000066400000000000000000000155521446255456000223310ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np cimport numpy as np cimport cython DTYPE = np.int64 ctypedef np.int64_t DTYPE_t @cython.boundscheck(False) @cython.wraparound(False) def _tip_distances(np.ndarray[np.double_t, ndim=1] a, object t, np.ndarray[DTYPE_t, ndim=1] tip_indices): """Sets each tip to its distance from the root Parameters ---------- a : np.ndarray of double A matrix in which each row corresponds to a node in ``t``. t : skbio.tree.TreeNode The tree that corresponds to the rows in ``a``. tip_indices : np.ndarray of int The index positions in ``a`` of the tips in ``t``. Returns ------- np.ndarray of double A matrix in which each row corresponds to a node in ``t``, Only the rows that correspond to tips are nonzero, and the values in these rows are the distance from that tip to the root of the tree. """ cdef: object n Py_ssize_t i, p_i, n_rows np.ndarray[np.double_t, ndim=1] mask np.ndarray[np.double_t, ndim=1] tip_ds = a.copy() # preorder reduction over the tree to gather distances at the tips n_rows = tip_ds.shape[0] for n in t.preorder(include_self=False): i = n.id p_i = n.parent.id tip_ds[i] += tip_ds[p_i] # construct a mask that represents the locations of the tips mask = np.zeros(n_rows, dtype=np.double) for i in range(tip_indices.shape[0]): mask[tip_indices[i]] = 1.0 # apply the mask such that tip_ds only includes values which correspond to # the tips of the tree. for i in range(n_rows): tip_ds[i] *= mask[i] return tip_ds @cython.boundscheck(False) @cython.wraparound(False) cdef _traverse_reduce(np.ndarray[DTYPE_t, ndim=2] child_index, np.ndarray[DTYPE_t, ndim=2] a): """Apply a[k] = sum[i:j] Parameters ---------- child_index: np.array of int A matrix in which the first column corresponds to an index position in ``a``, which represents a node in a tree. The second column is the starting index in ``a`` for the node's children, and the third column is the ending index in ``a`` for the node's children. a : np.ndarray of int A matrix of the environment data. Each row corresponds to a node in a tree, and each column corresponds to an environment. On input, it is assumed that only tips have counts. Notes ----- This is effectively a postorder reduction over the tree. For example, given the following tree: /-A /E-------| | \-B -root----| | /-C \F-------| \-D And assuming counts for [A, B, C, D] in environment FOO of [1, 1, 1, 0] and counts for environment BAR of [0, 1, 1, 1], the input counts matrix ``a`` would be: [1 0 -> A 1 1 -> B 1 1 -> C 0 1 -> D 0 0 -> E 0 0 -> F 0 0] -> root The method will perform the following reduction: [1 0 [1 0 [1 0 [1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 -> 0 1 -> 0 1 -> 0 1 0 0 2 1 2 1 2 1 0 0 0 0 1 2 1 2 0 0] 0 0] 0 0] 3 3] The index positions of the above are encoded in ``child_index`` which describes the node to aggregate into, and the start and stop index positions of the nodes immediate descendents. This method operates inplace on ``a`` """ cdef: Py_ssize_t i, j, k DTYPE_t node, start, end DTYPE_t n_envs = a.shape[1] # possible GPGPU target for i in range(child_index.shape[0]): node = child_index[i, 0] start = child_index[i, 1] end = child_index[i, 2] for j in range(start, end + 1): for k in range(n_envs): a[node, k] += a[j, k] @cython.boundscheck(False) @cython.wraparound(False) def _nodes_by_counts(np.ndarray counts, np.ndarray tip_ids, dict indexed): """Construct the count array, and the counts up the tree Parameters ---------- counts : np.array of int A 1D or 2D vector in which each row corresponds to the observed counts in an environment. The rows are expected to be in order with respect to `tip_ids`. tip_ids : np.array of str A vector of tip names that correspond to the columns in the `counts` matrix. indexed : dict The result of `index_tree`. Returns ------- np.array of int The observed counts of every node and the counts if its descendents. """ cdef: np.ndarray nodes, observed_ids np.ndarray[DTYPE_t, ndim=2] count_array, counts_t np.ndarray[DTYPE_t, ndim=1] observed_indices, otus_in_nodes Py_ssize_t i, j set observed_ids_set object n dict node_lookup DTYPE_t n_count_vectors, n_count_otus nodes = indexed['name'] # allow counts to be a vector counts = np.atleast_2d(counts) counts = counts.astype(DTYPE, copy=False) # determine observed IDs. It may be possible to unroll these calls to # squeeze a little more performance observed_indices = counts.sum(0).nonzero()[0] observed_ids = tip_ids[observed_indices] observed_ids_set = set(observed_ids) # construct mappings of the observed to their positions in the node array node_lookup = {} for i in range(nodes.shape[0]): n = nodes[i] if n in observed_ids_set: node_lookup[n] = i # determine the positions of the observed IDs in nodes otus_in_nodes = np.zeros(observed_ids.shape[0], dtype=DTYPE) for i in range(observed_ids.shape[0]): n = observed_ids[i] otus_in_nodes[i] = node_lookup[n] # count_array has a row per node (not tip) and a column per env. n_count_vectors = counts.shape[0] count_array = np.zeros((nodes.shape[0], n_count_vectors), dtype=DTYPE) # populate the counts array with the counts of each observation in each # env counts_t = counts.transpose() n_count_otus = otus_in_nodes.shape[0] for i in range(n_count_otus): for j in range(n_count_vectors): count_array[otus_in_nodes[i], j] = counts_t[observed_indices[i], j] child_index = indexed['child_index'].astype(DTYPE, copy=False) _traverse_reduce(child_index, count_array) return count_array scikit-bio-0.5.9/skbio/diversity/_util.py000066400000000000000000000130661446255456000204220ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import collections.abc import numpy as np import pandas as pd from skbio.tree import DuplicateNodeError, MissingNodeError from skbio.diversity._phylogenetic import _nodes_by_counts def _validate_counts_vector(counts, suppress_cast=False): """Validate and convert input to an acceptable counts vector type. Note: may not always return a copy of `counts`! """ counts = np.asarray(counts) try: if not np.all(np.isreal(counts)): raise Exception except Exception: raise ValueError("Counts vector must contain real-valued entries.") if counts.ndim != 1: raise ValueError("Only 1-D vectors are supported.") elif (counts < 0).any(): raise ValueError("Counts vector cannot contain negative values.") return counts def _validate_counts_matrix(counts, ids=None, suppress_cast=False): results = [] # handle case of where counts is a single vector by making it a matrix. # this has to be done before forcing counts into an ndarray because we # don't yet know that all of the entries are of equal length if isinstance(counts, pd.core.frame.DataFrame): if ids is not None and len(counts.index) != len(ids): raise ValueError( "Number of rows in ``counts``" " must be equal to number of provided ``ids``." ) return np.asarray(counts) else: if len(counts) == 0 or not isinstance(counts[0], collections.abc.Iterable): counts = [counts] counts = np.asarray(counts) if counts.ndim > 2: raise ValueError( "Only 1-D and 2-D array-like objects can be provided " "as input. Provided object has %d dimensions." % counts.ndim) if ids is not None and len(counts) != len(ids): raise ValueError( "Number of rows in ``counts`` must be equal " "to number of provided ``ids``." ) lens = [] for v in counts: results.append(_validate_counts_vector(v, suppress_cast)) lens.append(len(v)) if len(set(lens)) > 1: raise ValueError( "All rows in ``counts`` must be of equal length." ) return np.asarray(results) def _validate_otu_ids_and_tree(counts, otu_ids, tree): len_otu_ids = len(otu_ids) set_otu_ids = set(otu_ids) if len_otu_ids != len(set_otu_ids): raise ValueError("``otu_ids`` cannot contain duplicated ids.") if len(counts) != len_otu_ids: raise ValueError("``otu_ids`` must be the same length as ``counts`` " "vector(s).") if len(tree.root().children) == 0: raise ValueError("``tree`` must contain more than just a root node.") if len(tree.root().children) > 2: # this is an imperfect check for whether the tree is rooted or not. # can this be improved? raise ValueError("``tree`` must be rooted.") # all nodes (except the root node) have corresponding branch lengths # all tip names in tree are unique # all otu_ids correspond to tip names in tree branch_lengths = [] tip_names = [] for e in tree.traverse(): if not e.is_root(): branch_lengths.append(e.length) if e.is_tip(): tip_names.append(e.name) set_tip_names = set(tip_names) if len(tip_names) != len(set_tip_names): raise DuplicateNodeError("All tip names must be unique.") if np.array([branch is None for branch in branch_lengths]).any(): raise ValueError("All non-root nodes in ``tree`` must have a branch " "length.") missing_tip_names = set_otu_ids - set_tip_names if missing_tip_names != set(): n_missing_tip_names = len(missing_tip_names) raise MissingNodeError("All ``otu_ids`` must be present as tip names " "in ``tree``. ``otu_ids`` not corresponding to " "tip names (n=%d): %s" % (n_missing_tip_names, " ".join(missing_tip_names))) def _vectorize_counts_and_tree(counts, otu_ids, tree): """ Index tree and convert counts to np.array in corresponding order """ tree_index = tree.to_array(nan_length_value=0.0) otu_ids = np.asarray(otu_ids) counts = np.atleast_2d(counts) counts_by_node = _nodes_by_counts(counts, otu_ids, tree_index) branch_lengths = tree_index['length'] # branch_lengths is just a reference to the array inside of tree_index, # but it's used so much that it's convenient to just pull it out here. return counts_by_node.T, tree_index, branch_lengths def _get_phylogenetic_kwargs(counts, **kwargs): try: otu_ids = kwargs.pop('otu_ids') except KeyError: raise ValueError("``otu_ids`` is required for phylogenetic diversity " "metrics.") try: tree = kwargs.pop('tree') except KeyError: raise ValueError("``tree`` is required for phylogenetic diversity " "metrics.") return otu_ids, tree, kwargs def _quantitative_to_qualitative_counts(counts): return counts > 0.0 scikit-bio-0.5.9/skbio/diversity/alpha/000077500000000000000000000000001446255456000200135ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/alpha/__init__.py000066400000000000000000000041571446255456000221330ustar00rootroot00000000000000""" Alpha diversity measures (:mod:`skbio.diversity.alpha`) ======================================================= .. currentmodule:: skbio.diversity.alpha This package provides implementations of alpha diversity measures, including measures of richness, dominance, and evenness. Some functions generate confidence intervals (CIs). These functions have the suffix ``_ci``. Functions --------- .. autosummary:: :toctree: ace berger_parker_d brillouin_d chao1 chao1_ci dominance doubles enspie esty_ci faith_pd fisher_alpha gini_index goods_coverage heip_e kempton_taylor_q lladser_ci lladser_pe margalef mcintosh_d mcintosh_e menhinick michaelis_menten_fit observed_otus osd pielou_e robbins shannon simpson simpson_e singles strong """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._ace import ace from ._chao1 import chao1, chao1_ci from ._faith_pd import faith_pd from ._base import ( berger_parker_d, brillouin_d, dominance, doubles, enspie, esty_ci, fisher_alpha, goods_coverage, heip_e, kempton_taylor_q, margalef, mcintosh_d, mcintosh_e, menhinick, michaelis_menten_fit, observed_otus, osd, pielou_e, robbins, shannon, simpson, simpson_e, singles, strong) from ._gini import gini_index from ._lladser import lladser_pe, lladser_ci __all__ = ['ace', 'chao1', 'chao1_ci', 'berger_parker_d', 'brillouin_d', 'dominance', 'doubles', 'enspie', 'esty_ci', 'faith_pd', 'fisher_alpha', 'gini_index', 'goods_coverage', 'heip_e', 'kempton_taylor_q', 'margalef', 'mcintosh_d', 'mcintosh_e', 'menhinick', 'michaelis_menten_fit', 'observed_otus', 'osd', 'pielou_e', 'robbins', 'shannon', 'simpson', 'simpson_e', 'singles', 'strong', 'lladser_pe', 'lladser_ci'] scikit-bio-0.5.9/skbio/diversity/alpha/_ace.py000066400000000000000000000110521446255456000212530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.diversity._util import _validate_counts_vector from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def ace(counts, rare_threshold=10): r"""Calculate the ACE metric (Abundance-based Coverage Estimator). The ACE metric is defined as: .. math:: S_{ace}=S_{abund}+\frac{S_{rare}}{C_{ace}}+ \frac{F_1}{C_{ace}}\gamma^2_{ace} where :math:`S_{abund}` is the number of abundant OTUs (with more than `rare_threshold` individuals) when all samples are pooled, :math:`S_{rare}` is the number of rare OTUs (with less than or equal to `rare_threshold` individuals) when all samples are pooled, :math:`C_{ace}` is the sample abundance coverage estimator, :math:`F_1` is the frequency of singletons, and :math:`\gamma^2_{ace}` is the estimated coefficient of variation for rare OTUs. The estimated coefficient of variation is defined as (assuming `rare_threshold` is 10, the default): .. math:: \gamma^2_{ace}=max\left[\frac{S_{rare}}{C_{ace}} \frac{\sum^{10}_{i=1}{{i\left(i-1\right)}}F_i} {\left(N_{rare}\right)\left(N_{rare}-1\right)} -1,0\right] Parameters ---------- counts : 1-D array_like, int Vector of counts. rare_threshold : int, optional Threshold at which an OTU containing as many or fewer individuals will be considered rare. Returns ------- double Computed ACE metric. Raises ------ ValueError If every rare OTU is a singleton. Notes ----- ACE was first introduced in [1]_ and [2]_. The implementation here is based on the description given in the EstimateS manual [3]_. If no rare OTUs exist, returns the number of abundant OTUs. The default value of 10 for `rare_threshold` is based on [4]_. If `counts` contains zeros, indicating OTUs which are known to exist in the environment but did not appear in the sample, they will be ignored for the purpose of calculating the number of rare OTUs. References ---------- .. [1] Chao, A. & S.-M Lee. 1992 Estimating the number of classes via sample coverage. Journal of the American Statistical Association 87, 210-217. .. [2] Chao, A., M.-C. Ma, & M. C. K. Yang. 1993. Stopping rules and estimation for recapture debugging with unequal failure rates. Biometrika 80, 193-201. .. [3] http://viceroy.eeb.uconn.edu/estimates/ .. [4] Chao, A., W.-H. Hwang, Y.-C. Chen, and C.-Y. Kuo. 2000. Estimating the number of shared species in two communities. Statistica Sinica 10:227-246. """ counts = _validate_counts_vector(counts) freq_counts = np.bincount(counts) s_rare = _otus_rare(freq_counts, rare_threshold) singles = freq_counts[1] if singles > 0 and singles == s_rare: raise ValueError("The only rare OTUs are singletons, so the ACE " "metric is undefined. EstimateS suggests using " "bias-corrected Chao1 instead.") s_abun = _otus_abundant(freq_counts, rare_threshold) if s_rare == 0: return s_abun n_rare = _number_rare(freq_counts, rare_threshold) c_ace = 1 - singles / n_rare top = s_rare * _number_rare(freq_counts, rare_threshold, gamma=True) bottom = c_ace * n_rare * (n_rare - 1) gamma_ace = (top / bottom) - 1 if gamma_ace < 0: gamma_ace = 0 return s_abun + (s_rare / c_ace) + ((singles / c_ace) * gamma_ace) def _otus_rare(freq_counts, rare_threshold): """Count number of rare OTUs.""" return freq_counts[1:rare_threshold + 1].sum() def _otus_abundant(freq_counts, rare_threshold): """Count number of abundant OTUs.""" return freq_counts[rare_threshold + 1:].sum() def _number_rare(freq_counts, rare_threshold, gamma=False): """Return number of individuals in rare OTUs. ``gamma=True`` generates the ``n_rare`` used for the variation coefficient. """ n_rare = 0 if gamma: for i, j in enumerate(freq_counts[:rare_threshold + 1]): n_rare = n_rare + (i * j) * (i - 1) else: for i, j in enumerate(freq_counts[:rare_threshold + 1]): n_rare = n_rare + (i * j) return n_rare scikit-bio-0.5.9/skbio/diversity/alpha/_base.py000066400000000000000000000611311446255456000214400ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from scipy.special import gammaln from scipy.optimize import fmin_powell, minimize_scalar from skbio.stats import subsample_counts from skbio.util._decorator import experimental from skbio.diversity._util import _validate_counts_vector @experimental(as_of="0.4.0") def berger_parker_d(counts): r"""Calculate Berger-Parker dominance. Berger-Parker dominance is defined as the fraction of the sample that belongs to the most abundant OTU: .. math:: d = \frac{N_{max}}{N} where :math:`N_{max}` is defined as the number of individuals in the most abundant OTU (or any of the most abundant OTUs in the case of ties), and :math:`N` is defined as the total number of individuals in the sample. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Berger-Parker dominance. Notes ----- Berger-Parker dominance is defined in [1]_. The implementation here is based on the description given in the SDR-IV online manual [2]_. References ---------- .. [1] Berger & Parker (1970). SDR-IV online help. .. [2] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) return counts.max() / counts.sum() @experimental(as_of="0.4.0") def brillouin_d(counts): r"""Calculate Brillouin index of alpha diversity. This is calculated as follows: .. math:: HB = \frac{\ln N!-\sum^s_{i=1}{\ln n_i!}}{N} where :math:`N` is defined as the total number of individuals in the sample, :math:`s` is the number of OTUs, and :math:`n_i` is defined as the number of individuals in the :math:`i^{\text{th}}` OTU. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Brillouin index. Notes ----- The implementation here is based on the description given in the SDR-IV online manual [1]_. References ---------- .. [1] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) nz = counts[counts.nonzero()] n = nz.sum() return (gammaln(n + 1) - gammaln(nz + 1).sum()) / n @experimental(as_of="0.4.0") def dominance(counts): r"""Calculate dominance. Dominance is defined as .. math:: \sum{p_i^2} where :math:`p_i` is the proportion of the entire community that OTU :math:`i` represents. Dominance can also be defined as 1 - Simpson's index. It ranges between 0 and 1. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Dominance. See Also -------- simpson Notes ----- The implementation here is based on the description given in [1]_. References ---------- .. [1] http://folk.uio.no/ohammer/past/diversity.html """ counts = _validate_counts_vector(counts) freqs = counts / counts.sum() return (freqs * freqs).sum() @experimental(as_of="0.4.0") def doubles(counts): """Calculate number of double occurrences (doubletons). Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- int Doubleton count. """ counts = _validate_counts_vector(counts) return (counts == 2).sum() @experimental(as_of="0.4.0") def enspie(counts): r"""Calculate ENS_pie alpha diversity measure. ENS_pie is equivalent to ``1 / dominance``: .. math:: ENS_{pie} = \frac{1}{\sum_{i=1}^s{p_i^2}} where :math:`s` is the number of OTUs and :math:`p_i` is the proportion of the community represented by OTU :math:`i`. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double ENS_pie alpha diversity measure. See Also -------- dominance Notes ----- ENS_pie is defined in [1]_. References ---------- .. [1] Chase and Knight (2013). "Scale-dependent effect sizes of ecological drivers on biodiversity: why standardised sampling is not enough". Ecology Letters, Volume 16, Issue Supplement s1, pgs 17-26. """ counts = _validate_counts_vector(counts) return 1 / dominance(counts) @experimental(as_of="0.4.0") def esty_ci(counts): r"""Calculate Esty's CI. Esty's CI is defined as .. math:: F_1/N \pm z\sqrt{W} where :math:`F_1` is the number of singleton OTUs, :math:`N` is the total number of individuals (sum of abundances for all OTUs), and :math:`z` is a constant that depends on the targeted confidence and based on the normal distribution. :math:`W` is defined as .. math:: \frac{F_1(N-F_1)+2NF_2}{N^3} where :math:`F_2` is the number of doubleton OTUs. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- tuple Esty's confidence interval as ``(lower_bound, upper_bound)``. Notes ----- Esty's CI is defined in [1]_. :math:`z` is hardcoded for a 95% confidence interval. References ---------- .. [1] Esty, W. W. (1983). "A normal limit law for a nonparametric estimator of the coverage of a random sample". Ann Statist 11: 905-912. """ counts = _validate_counts_vector(counts) f1 = singles(counts) f2 = doubles(counts) n = counts.sum() z = 1.959963985 W = (f1 * (n - f1) + 2 * n * f2) / (n ** 3) return f1 / n - z * np.sqrt(W), f1 / n + z * np.sqrt(W) @experimental(as_of="0.4.0") def fisher_alpha(counts): r"""Calculate Fisher's alpha, a metric of diversity. Fisher's alpha is estimated by solving the following equation for :math:`\alpha`: .. math:: S=\alpha\ln(1+\frac{N}{\alpha}) where :math:`S` is the number of OTUs and :math:`N` is the total number of individuals in the sample. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Fisher's alpha. Raises ------ RuntimeError If the optimizer fails to converge (error > 1.0). Notes ----- The implementation here is based on the description given in the SDR-IV online manual [1]_. Uses ``scipy.optimize.minimize_scalar`` to find Fisher's alpha. References ---------- .. [1] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) n = counts.sum() s = observed_otus(counts) def f(alpha): return (alpha * np.log(1 + (n / alpha)) - s) ** 2 # Temporarily silence RuntimeWarnings (invalid and division by zero) during # optimization in case invalid input is provided to the objective function # (e.g. alpha=0). orig_settings = np.seterr(divide='ignore', invalid='ignore') try: alpha = minimize_scalar(f).x finally: np.seterr(**orig_settings) if f(alpha) > 1.0: raise RuntimeError("Optimizer failed to converge (error > 1.0), so " "could not compute Fisher's alpha.") return alpha @experimental(as_of="0.4.0") def goods_coverage(counts): r"""Calculate Good's coverage of counts. Good's coverage estimator is defined as .. math:: 1-\frac{F_1}{N} where :math:`F_1` is the number of singleton OTUs and :math:`N` is the total number of individuals (sum of abundances for all OTUs). Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Good's coverage estimator. """ counts = _validate_counts_vector(counts) f1 = singles(counts) N = counts.sum() return 1 - (f1 / N) @experimental(as_of="0.4.0") def heip_e(counts): r"""Calculate Heip's evenness measure. Heip's evenness is defined as: .. math:: \frac{(e^H-1)}{(S-1)} where :math:`H` is the Shannon-Wiener entropy of counts (using logarithm base :math:`e`) and :math:`S` is the number of OTUs in the sample. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Heip's evenness measure. See Also -------- shannon pielou_e Notes ----- The implementation here is based on the description in [1]_. References ---------- .. [1] Heip, C. 1974. A new index measuring evenness. J. Mar. Biol. Ass. UK., 54, 555-557. """ counts = _validate_counts_vector(counts) return ((np.exp(shannon(counts, base=np.e)) - 1) / (observed_otus(counts) - 1)) @experimental(as_of="0.4.0") def kempton_taylor_q(counts, lower_quantile=0.25, upper_quantile=0.75): """Calculate Kempton-Taylor Q index of alpha diversity. Estimates the slope of the cumulative abundance curve in the interquantile range. By default, uses lower and upper quartiles, rounding inwards. Parameters ---------- counts : 1-D array_like, int Vector of counts. lower_quantile : float, optional Lower bound of the interquantile range. Defaults to lower quartile. upper_quantile : float, optional Upper bound of the interquantile range. Defaults to upper quartile. Returns ------- double Kempton-Taylor Q index of alpha diversity. Notes ----- The index is defined in [1]_. The implementation here is based on the description given in the SDR-IV online manual [2]_. The implementation provided here differs slightly from the results given in Magurran 1998. Specifically, we have 14 in the numerator rather than 15. Magurran recommends counting half of the OTUs with the same # counts as the point where the UQ falls and the point where the LQ falls, but the justification for this is unclear (e.g. if there were a very large # OTUs that just overlapped one of the quantiles, the results would be considerably off). Leaving the calculation as-is for now, but consider changing. References ---------- .. [1] Kempton, R. A. and Taylor, L. R. (1976) Models and statistics for species diversity. Nature, 262, 818-820. .. [2] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) n = len(counts) lower = int(np.ceil(n * lower_quantile)) upper = int(n * upper_quantile) sorted_counts = np.sort(counts) return (upper - lower) / np.log(sorted_counts[upper] / sorted_counts[lower]) @experimental(as_of="0.4.0") def margalef(counts): r"""Calculate Margalef's richness index. Margalef's D is defined as: .. math:: D = \frac{(S - 1)}{\ln N} where :math:`S` is the number of OTUs and :math:`N` is the total number of individuals in the sample. Assumes log accumulation. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Margalef's richness index. Notes ----- Based on the description in [1]_. References ---------- .. [1] Magurran, A E 2004. Measuring biological diversity. Blackwell. pp. 76-77. """ counts = _validate_counts_vector(counts) return (observed_otus(counts) - 1) / np.log(counts.sum()) @experimental(as_of="0.4.0") def mcintosh_d(counts): r"""Calculate McIntosh dominance index D. McIntosh dominance index D is defined as: .. math:: D = \frac{N - U}{N - \sqrt{N}} where :math:`N` is the total number of individuals in the sample and :math:`U` is defined as: .. math:: U = \sqrt{\sum{{n_i}^2}} where :math:`n_i` is the number of individuals in the :math:`i^{\text{th}}` OTU. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double McIntosh dominance index D. See Also -------- mcintosh_e Notes ----- The index was proposed in [1]_. The implementation here is based on the description given in the SDR-IV online manual [2]_. References ---------- .. [1] McIntosh, R. P. 1967 An index of diversity and the relation of certain concepts to diversity. Ecology 48, 1115-1126. .. [2] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) u = np.sqrt((counts * counts).sum()) n = counts.sum() return (n - u) / (n - np.sqrt(n)) @experimental(as_of="0.4.0") def mcintosh_e(counts): r"""Calculate McIntosh's evenness measure E. McIntosh evenness measure E is defined as: .. math:: E = \frac{\sqrt{\sum{n_i^2}}}{\sqrt{((N-S+1)^2 + S -1}} where :math:`n_i` is the number of individuals in the :math:`i^{\text{th}}` OTU, :math:`N` is the total number of individuals, and :math:`S` is the number of OTUs in the sample. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double McIntosh evenness measure E. See Also -------- mcintosh_d Notes ----- The implementation here is based on the description given in [1]_, **NOT** the one in the SDR-IV online manual, which is wrong. References ---------- .. [1] Heip & Engels (1974) Comparing Species Diversity and Evenness Indices. p 560. """ counts = _validate_counts_vector(counts) numerator = np.sqrt((counts * counts).sum()) n = counts.sum() s = observed_otus(counts) denominator = np.sqrt((n - s + 1) ** 2 + s - 1) return numerator / denominator @experimental(as_of="0.4.0") def menhinick(counts): r"""Calculate Menhinick's richness index. Menhinick's richness index is defined as: .. math:: D_{Mn} = \frac{S}{\sqrt{N}} where :math:`S` is the number of OTUs and :math:`N` is the total number of individuals in the sample. Assumes square-root accumulation. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Menhinick's richness index. Notes ----- Based on the description in [1]_. References ---------- .. [1] Magurran, A E 2004. Measuring biological diversity. Blackwell. pp. 76-77. """ counts = _validate_counts_vector(counts) return observed_otus(counts) / np.sqrt(counts.sum()) @experimental(as_of="0.4.0") def michaelis_menten_fit(counts, num_repeats=1, params_guess=None): r"""Calculate Michaelis-Menten fit to rarefaction curve of observed OTUs. The Michaelis-Menten equation is defined as: .. math:: S=\frac{nS_{max}}{n+B} where :math:`n` is the number of individuals and :math:`S` is the number of OTUs. This function estimates the :math:`S_{max}` parameter. The fit is made to datapoints for :math:`n=1,2,...,N`, where :math:`N` is the total number of individuals (sum of abundances for all OTUs). :math:`S` is the number of OTUs represented in a random sample of :math:`n` individuals. Parameters ---------- counts : 1-D array_like, int Vector of counts. num_repeats : int, optional The number of times to perform rarefaction (subsampling without replacement) at each value of :math:`n`. params_guess : tuple, optional Initial guess of :math:`S_{max}` and :math:`B`. If ``None``, default guess for :math:`S_{max}` is :math:`S` (as :math:`S_{max}` should be >= :math:`S`) and default guess for :math:`B` is ``round(N / 2)``. Returns ------- S_max : double Estimate of the :math:`S_{max}` parameter in the Michaelis-Menten equation. See Also -------- skbio.stats.subsample_counts Notes ----- There is some controversy about how to do the fitting. The ML model given in [1]_ is based on the assumption that error is roughly proportional to magnitude of observation, reasonable for enzyme kinetics but not reasonable for rarefaction data. Here we just do a nonlinear curve fit for the parameters using least-squares. References ---------- .. [1] Raaijmakers, J. G. W. 1987 Statistical analysis of the Michaelis-Menten equation. Biometrics 43, 793-803. """ counts = _validate_counts_vector(counts) n_indiv = counts.sum() if params_guess is None: S_max_guess = observed_otus(counts) B_guess = int(round(n_indiv / 2)) params_guess = (S_max_guess, B_guess) # observed # of OTUs vs # of individuals sampled, S vs n xvals = np.arange(1, n_indiv + 1) ymtx = np.empty((num_repeats, len(xvals)), dtype=int) for i in range(num_repeats): ymtx[i] = np.asarray([observed_otus(subsample_counts(counts, n)) for n in xvals], dtype=int) yvals = ymtx.mean(0) # Vectors of actual vals y and number of individuals n. def errfn(p, n, y): return (((p[0] * n / (p[1] + n)) - y) ** 2).sum() # Return S_max. return fmin_powell(errfn, params_guess, ftol=1e-5, args=(xvals, yvals), disp=False)[0] @experimental(as_of="0.4.0") def observed_otus(counts): """Calculate the number of distinct OTUs. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- int Distinct OTU count. """ counts = _validate_counts_vector(counts) return (counts != 0).sum() @experimental(as_of="0.4.0") def osd(counts): """Calculate observed OTUs, singles, and doubles. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- osd : tuple Observed OTUs, singles, and doubles. See Also -------- observed_otus singles doubles Notes ----- This is a convenience function used by many of the other measures that rely on these three measures. """ counts = _validate_counts_vector(counts) return observed_otus(counts), singles(counts), doubles(counts) @experimental(as_of="0.4.1") def pielou_e(counts): r"""Calculate Pielou's Evenness index J'. Pielou's Evenness is defined as: .. math:: J' = \frac{(H)}{\ln(S)} where :math:`H` is the Shannon-Wiener entropy of counts and :math:`S` is the number of OTUs in the sample. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Pielou's Evenness. See Also -------- shannon heip_e Notes ----- The implementation here is based on the description in Wikipedia [1]_. It was first proposed by E. C. Pielou [2]_ and is similar to Heip's evenness [3]_. References ---------- .. [1] https://en.wikipedia.org/wiki/Species_evenness .. [2] Pielou, E. C., 1966. The measurement of diversity in different types of biological collections. Journal of Theoretical Biology, 13, 131-44. .. [3] Heip, C. 1974. A new index measuring evenness. J. Mar. Biol. Ass. UK., 54, 555-557. """ counts = _validate_counts_vector(counts) return shannon(counts, base=np.e) / np.log(observed_otus(counts)) @experimental(as_of="0.4.0") def robbins(counts): r"""Calculate Robbins' estimator for probability of unobserved outcomes. Robbins' estimator is defined as: .. math:: \frac{F_1}{n+1} where :math:`F_1` is the number of singleton OTUs. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Robbins' estimate. Notes ----- Robbins' estimator is defined in [1]_. The estimate computed here is for :math:`n-1` counts, i.e. the x-axis is off by 1. References ---------- .. [1] Robbins, H. E (1968). Ann. of Stats. Vol 36, pp. 256-257. """ counts = _validate_counts_vector(counts) return singles(counts) / counts.sum() @experimental(as_of="0.4.0") def shannon(counts, base=2): r"""Calculate Shannon entropy of counts, default in bits. Shannon-Wiener diversity index is defined as: .. math:: H = -\sum_{i=1}^s\left(p_i\log_2 p_i\right) where :math:`s` is the number of OTUs and :math:`p_i` is the proportion of the community represented by OTU :math:`i`. Parameters ---------- counts : 1-D array_like, int Vector of counts. base : scalar, optional Logarithm base to use in the calculations. Returns ------- double Shannon diversity index H. Notes ----- The implementation here is based on the description given in the SDR-IV online manual [1]_ except that the default logarithm base used here is 2 instead of :math:`e`. References ---------- .. [1] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) freqs = counts / counts.sum() nonzero_freqs = freqs[freqs.nonzero()] return -(nonzero_freqs * np.log(nonzero_freqs)).sum() / np.log(base) @experimental(as_of="0.4.0") def simpson(counts): r"""Calculate Simpson's index. Simpson's index is defined as ``1 - dominance``: .. math:: 1 - \sum{p_i^2} where :math:`p_i` is the proportion of the community represented by OTU :math:`i`. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Simpson's index. See Also -------- dominance Notes ----- The implementation here is ``1 - dominance`` as described in [1]_. Other references (such as [2]_) define Simpson's index as ``1 / dominance``. References ---------- .. [1] http://folk.uio.no/ohammer/past/diversity.html .. [2] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) return 1 - dominance(counts) @experimental(as_of="0.4.0") def simpson_e(counts): r"""Calculate Simpson's evenness measure E. Simpson's E is defined as .. math:: E=\frac{1 / D}{S_{obs}} where :math:`D` is dominance and :math:`S_{obs}` is the number of observed OTUs. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Simpson's evenness measure E. See Also -------- dominance enspie simpson Notes ----- The implementation here is based on the description given in [1]_. References ---------- .. [1] http://www.tiem.utk.edu/~gross/bioed/bealsmodules/simpsonDI.html """ counts = _validate_counts_vector(counts) return enspie(counts) / observed_otus(counts) @experimental(as_of="0.4.0") def singles(counts): """Calculate number of single occurrences (singletons). Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- int Singleton count. """ counts = _validate_counts_vector(counts) return (counts == 1).sum() @experimental(as_of="0.4.0") def strong(counts): r"""Calculate Strong's dominance index. Strong's dominance index is defined as: .. math:: D_w = max_i[(\frac{b_i}{N})-\frac{i}{S}] where :math:`b_i` is the sequential cumulative totaling of the :math:`i^{\text{th}}` OTU abundance values ranked from largest to smallest, :math:`N` is the total number of individuals in the sample, and :math:`S` is the number of OTUs in the sample. The expression in brackets is computed for all OTUs, and :math:`max_i` denotes the maximum value in brackets for any OTU. Parameters ---------- counts : 1-D array_like, int Vector of counts. Returns ------- double Strong's dominance index (Dw). Notes ----- Strong's dominance index is defined in [1]_. The implementation here is based on the description given in the SDR-IV online manual [2]_. References ---------- .. [1] Strong, W. L., 2002 Assessing species abundance unevenness within and between plant communities. Community Ecology, 3, 237-246. .. [2] http://www.pisces-conservation.com/sdrhelp/index.html """ counts = _validate_counts_vector(counts) n = counts.sum() s = observed_otus(counts) i = np.arange(1, len(counts) + 1) sorted_sum = np.sort(counts)[::-1].cumsum() return (sorted_sum / n - (i / s)).max() scikit-bio-0.5.9/skbio/diversity/alpha/_chao1.py000066400000000000000000000144521446255456000215250ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from ._base import osd from skbio.diversity._util import _validate_counts_vector from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def chao1(counts, bias_corrected=True): r"""Calculate chao1 richness estimator. Uses the bias-corrected version unless `bias_corrected` is ``False`` *and* there are both singletons and doubletons. Parameters ---------- counts : 1-D array_like, int Vector of counts. bias_corrected : bool, optional Indicates whether or not to use the bias-corrected version of the equation. If ``False`` *and* there are both singletons and doubletons, the uncorrected version will be used. The biased-corrected version will be used otherwise. Returns ------- double Computed chao1 richness estimator. See Also -------- chao1_ci Notes ----- The uncorrected version is based on Equation 6 in [1]_: .. math:: chao1=S_{obs}+\frac{F_1^2}{2F_2} where :math:`F_1` and :math:`F_2` are the count of singletons and doubletons, respectively. The bias-corrected version is defined as .. math:: chao1=S_{obs}+\frac{F_1(F_1-1)}{2(F_2+1)} References ---------- .. [1] Chao, A. 1984. Non-parametric estimation of the number of classes in a population. Scandinavian Journal of Statistics 11, 265-270. """ counts = _validate_counts_vector(counts) o, s, d = osd(counts) if not bias_corrected and s and d: return o + s ** 2 / (d * 2) else: return o + s * (s - 1) / (2 * (d + 1)) @experimental(as_of="0.4.0") def chao1_ci(counts, bias_corrected=True, zscore=1.96): """Calculate chao1 confidence interval. Parameters ---------- counts : 1-D array_like, int Vector of counts. bias_corrected : bool, optional Indicates whether or not to use the bias-corrected version of the equation. If ``False`` *and* there are both singletons and doubletons, the uncorrected version will be used. The biased-corrected version will be used otherwise. zscore : scalar, optional Score to use for confidence. Default of 1.96 is for a 95% confidence interval. Returns ------- tuple chao1 confidence interval as ``(lower_bound, upper_bound)``. See Also -------- chao1 Notes ----- The implementation here is based on the equations in the EstimateS manual [1]_. Different equations are employed to calculate the chao1 variance and confidence interval depending on `bias_corrected` and the presence/absence of singletons and/or doubletons. Specifically, the following EstimateS equations are used: 1. No singletons, Equation 14. 2. Singletons but no doubletons, Equations 7, 13. 3. Singletons and doubletons, ``bias_corrected=True``, Equations 6, 13. 4. Singletons and doubletons, ``bias_corrected=False``, Equations 5, 13. References ---------- .. [1] http://viceroy.eeb.uconn.edu/estimates/ """ counts = _validate_counts_vector(counts) o, s, d = osd(counts) if s: chao = chao1(counts, bias_corrected) chaovar = _chao1_var(counts, bias_corrected) return _chao_confidence_with_singletons(chao, o, chaovar, zscore) else: n = counts.sum() return _chao_confidence_no_singletons(n, o, zscore) def _chao1_var(counts, bias_corrected=True): """Calculates chao1 variance using decision rules in EstimateS.""" o, s, d = osd(counts) if not d: c = chao1(counts, bias_corrected) return _chao1_var_no_doubletons(s, c) if not s: n = counts.sum() return _chao1_var_no_singletons(n, o) if bias_corrected: return _chao1_var_bias_corrected(s, d) else: return _chao1_var_uncorrected(s, d) def _chao1_var_uncorrected(singles, doubles): """Calculates chao1, uncorrected. From EstimateS manual, equation 5. """ r = singles / doubles return doubles * (.5 * r ** 2 + r ** 3 + .24 * r ** 4) def _chao1_var_bias_corrected(s, d): """Calculates chao1 variance, bias-corrected. `s` is the number of singletons and `d` is the number of doubletons. From EstimateS manual, equation 6. """ return (s * (s - 1) / (2 * (d + 1)) + (s * (2 * s - 1) ** 2) / (4 * (d + 1) ** 2) + (s ** 2 * d * (s - 1) ** 2) / (4 * (d + 1) ** 4)) def _chao1_var_no_doubletons(s, chao1): """Calculates chao1 variance in absence of doubletons. From EstimateS manual, equation 7. `s` is the number of singletons, and `chao1` is the estimate of the mean of Chao1 from the same dataset. """ return s * (s - 1) / 2 + s * (2 * s - 1) ** 2 / 4 - s ** 4 / (4 * chao1) def _chao1_var_no_singletons(n, o): """Calculates chao1 variance in absence of singletons. `n` is the number of individuals and `o` is the number of observed OTUs. From EstimateS manual, equation 8. """ return o * np.exp(-n / o) * (1 - np.exp(-n / o)) def _chao_confidence_with_singletons(chao, observed, var_chao, zscore=1.96): """Calculates confidence bounds for chao1 or chao2. Uses Eq. 13 of EstimateS manual. `zscore` is the score to use for confidence. The default of 1.96 is for 95% confidence. """ T = chao - observed # if no diff betweeh chao and observed, CI is just point estimate of # observed if T == 0: return observed, observed K = np.exp(abs(zscore) * np.sqrt(np.log(1 + (var_chao / T ** 2)))) return observed + T / K, observed + T * K def _chao_confidence_no_singletons(n, s, zscore=1.96): """Calculates confidence bounds for chao1/chao2 in absence of singletons. Uses Eq. 14 of EstimateS manual. `n` is the number of individuals and `s` is the number of OTUs. """ P = np.exp(-n / s) return (max(s, s / (1 - P) - zscore * np.sqrt((s * P / (1 - P)))), s / (1 - P) + zscore * np.sqrt(s * P / (1 - P))) scikit-bio-0.5.9/skbio/diversity/alpha/_faith_pd.py000066400000000000000000000126651446255456000223140ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.util._decorator import experimental from skbio.diversity._util import (_validate_counts_vector, _validate_otu_ids_and_tree, _vectorize_counts_and_tree) def _faith_pd(counts_by_node, branch_lengths): return (branch_lengths * (counts_by_node > 0)).sum() @experimental(as_of="0.4.1") def faith_pd(counts, otu_ids, tree, validate=True): """ Compute Faith's phylogenetic diversity metric (PD) Parameters ---------- counts : 1-D array_like, int Vectors of counts/abundances of OTUs for one sample. otu_ids: list, np.array Vector of OTU ids corresponding to tip names in ``tree``. Must be the same length as ``counts``. tree: skbio.TreeNode Tree relating the OTUs in otu_ids. The set of tip names in the tree can be a superset of ``otu_ids``, but not a subset. validate: bool, optional If `False`, validation of the input won't be performed. This step can be slow, so if validation is run elsewhere it can be disabled here. However, invalid input data can lead to invalid results or error messages that are hard to interpret, so this step should not be bypassed if you're not certain that your input data are valid. See :mod:`skbio.diversity` for the description of what validation entails so you can determine if you can safely disable validation. Returns ------- float The phylogenetic diversity (PD) of the samples. Raises ------ ValueError, MissingNodeError, DuplicateNodeError If validation fails. Exact error will depend on what was invalid. See Also -------- skbio.diversity skbio.diversity.alpha_diversity Notes ----- Faith's phylogenetic diversity, often referred to as PD, was originally described in [1]_. If computing Faith's PD for multiple samples, using ``skbio.diversity.alpha_diversity`` will be much faster than calling this function individually on each sample. This implementation differs from that in PyCogent (and therefore QIIME versions less than 2.0.0) by imposing a few additional restrictions on the inputs. First, the input tree must be rooted. In PyCogent, if an unrooted tree was provided that had a single trifurcating node (a newick convention for unrooted trees) that node was considered the root of the tree. Next, all OTU IDs must be tips in the tree. PyCogent would silently ignore OTU IDs that were not present the tree. To reproduce Faith PD results from PyCogent with scikit-bio, ensure that your PyCogent Faith PD calculations are performed on a rooted tree and that all OTU IDs are present in the tree. This implementation of Faith's PD is based on the array-based implementation of UniFrac described in [2]_. References ---------- .. [1] Faith, D. P. Conservation evaluation and phylogenetic diversity. Biol. Conserv. (1992). .. [2] Hamady M, Lozupone C, Knight R. Fast UniFrac: facilitating high- throughput phylogenetic analyses of microbial communities including analysis of pyrosequencing and PhyloChip data. ISME J. 4(1):17-27 (2010). Examples -------- Assume we have the following abundance data for a sample ``u``, represented as a counts vector. These counts represent the number of times specific Operational Taxonomic Units, or OTUs, were observed in the sample. >>> u_counts = [1, 0, 0, 4, 1, 2, 3, 0] Because Faith PD is a phylogenetic diversity metric, we need to know which OTU each count corresponds to, which we'll provide as ``otu_ids``. >>> otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5', 'OTU6', 'OTU7', ... 'OTU8'] We also need a phylogenetic tree that relates the OTUs to one another. >>> from io import StringIO >>> from skbio import TreeNode >>> tree = TreeNode.read(StringIO( ... '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,' ... '(OTU4:0.75,(OTU5:0.5,((OTU6:0.33,OTU7:0.62):0.5' ... ',OTU8:0.5):0.5):0.5):1.25):0.0)root;')) We can then compute the Faith PD of the sample. >>> from skbio.diversity.alpha import faith_pd >>> pd = faith_pd(u_counts, otu_ids, tree) >>> print(round(pd, 2)) 6.95 """ counts_by_node, branch_lengths = _setup_faith_pd( counts, otu_ids, tree, validate, single_sample=True) return _faith_pd(counts_by_node, branch_lengths) def _setup_faith_pd(counts, otu_ids, tree, validate, single_sample): if validate: if single_sample: # only validate count if operating in single sample mode, they # will have already been validated otherwise counts = _validate_counts_vector(counts) _validate_otu_ids_and_tree(counts, otu_ids, tree) else: _validate_otu_ids_and_tree(counts[0], otu_ids, tree) counts_by_node, tree_index, branch_lengths = \ _vectorize_counts_and_tree(counts, otu_ids, tree) return counts_by_node, branch_lengths scikit-bio-0.5.9/skbio/diversity/alpha/_gini.py000066400000000000000000000071371446255456000214620ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.diversity._util import _validate_counts_vector from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def gini_index(data, method='rectangles'): r"""Calculate the Gini index. The Gini index is defined as .. math:: G=\frac{A}{A+B} where :math:`A` is the area between :math:`y=x` and the Lorenz curve and :math:`B` is the area under the Lorenz curve. Simplifies to :math:`1-2B` since :math:`A+B=0.5`. Parameters ---------- data : 1-D array_like Vector of counts, abundances, proportions, etc. All entries must be non-negative. method : {'rectangles', 'trapezoids'} Method for calculating the area under the Lorenz curve. If ``'rectangles'``, connects the Lorenz curve points by lines parallel to the x axis. This is the correct method (in our opinion) though ``'trapezoids'`` might be desirable in some circumstances. If ``'trapezoids'``, connects the Lorenz curve points by linear segments between them. Basically assumes that the given sampling is accurate and that more features of given data would fall on linear gradients between the values of this data. Returns ------- double Gini index. Raises ------ ValueError If `method` isn't one of the supported methods for calculating the area under the curve. Notes ----- The Gini index was introduced in [1]_. The formula for ``method='rectangles'`` is .. math:: dx\sum_{i=1}^n h_i The formula for ``method='trapezoids'`` is .. math:: dx(\frac{h_0+h_n}{2}+\sum_{i=1}^{n-1} h_i) References ---------- .. [1] Gini, C. (1912). "Variability and Mutability", C. Cuppini, Bologna, 156 pages. Reprinted in Memorie di metodologica statistica (Ed. Pizetti E, Salvemini, T). Rome: Libreria Eredi Virgilio Veschi (1955). """ # Suppress cast to int because this method supports ints and floats. data = _validate_counts_vector(data, suppress_cast=True) lorenz_points = _lorenz_curve(data) B = _lorenz_curve_integrator(lorenz_points, method) return max(0.0, 1 - 2 * B) def _lorenz_curve(data): """Calculate the Lorenz curve for input data. Notes ----- Formula available on wikipedia. """ sorted_data = np.sort(data) Sn = sorted_data.sum() n = sorted_data.shape[0] return np.arange(1, n + 1) / n, sorted_data.cumsum() / Sn def _lorenz_curve_integrator(lc_pts, method): """Calculates the area under a Lorenz curve. Notes ----- Could be utilized for integrating other simple, non-pathological "functions" where width of the trapezoids is constant. """ x, y = lc_pts # each point differs by 1/n dx = 1 / x.shape[0] if method == 'trapezoids': # 0 percent of the population has zero percent of the goods h_0 = 0.0 h_n = y[-1] # the 0th entry is at x=1/n sum_hs = y[:-1].sum() return dx * ((h_0 + h_n) / 2 + sum_hs) elif method == 'rectangles': return dx * y.sum() else: raise ValueError("Method '%s' not implemented. Available methods: " "'rectangles', 'trapezoids'." % method) scikit-bio-0.5.9/skbio/diversity/alpha/_lladser.py000066400000000000000000000420501446255456000221530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.diversity._util import _validate_counts_vector from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def lladser_pe(counts, r=10): """Calculate single point estimate of conditional uncovered probability. Parameters ---------- counts : 1-D array_like, int Vector of counts. r : int, optional Number of new colors that are required for the next prediction. Returns ------- double Single point estimate of the conditional uncovered probability. May be ``np.nan`` if a point estimate could not be computed. See Also -------- lladser_ci Notes ----- This function is just a wrapper around the full point estimator described in Theorem 2 (i) in [1]_, intended to be called for a single best estimate on a complete sample. This function is not guaranteed to return estimated uncovered probabilities less than 1 if the coverage is too low. References ---------- .. [1] Lladser, Gouet, and Reeder, "Extrapolation of Urn Models via Poissonization: Accurate Measurements of the Microbial Unknown" PLoS 2011. """ counts = _validate_counts_vector(counts) sample = _expand_counts(counts) np.random.shuffle(sample) try: pe = list(_lladser_point_estimates(sample, r))[-1][0] except IndexError: pe = np.nan return pe @experimental(as_of="0.4.0") def lladser_ci(counts, r, alpha=0.95, f=10, ci_type='ULCL'): """Calculate single CI of the conditional uncovered probability. Parameters ---------- counts : 1-D array_like, int Vector of counts. r : int Number of new colors that are required for the next prediction. alpha : float, optional Desired confidence level. f : float, optional Ratio between upper and lower bound. ci_type : {'ULCL', 'ULCU', 'U', 'L'} Type of confidence interval. If ``'ULCL'``, upper and lower bounds with conservative lower bound. If ``'ULCU'``, upper and lower bounds with conservative upper bound. If ``'U'``, upper bound only, lower bound fixed to 0.0. If ``'L'``, lower bound only, upper bound fixed to 1.0. Returns ------- tuple Confidence interval as ``(lower_bound, upper_bound)``. See Also -------- lladser_pe Notes ----- This function is just a wrapper around the full CI estimator described in Theorem 2 (iii) in [1]_, intended to be called for a single best CI estimate on a complete sample. References ---------- .. [1] Lladser, Gouet, and Reeder, "Extrapolation of Urn Models via Poissonization: Accurate Measurements of the Microbial Unknown" PLoS 2011. """ counts = _validate_counts_vector(counts) sample = _expand_counts(counts) np.random.shuffle(sample) try: ci = list(_lladser_ci_series(sample, r, alpha, f, ci_type))[-1] except IndexError: ci = (np.nan, np.nan) return ci def _expand_counts(counts): """Convert vector of counts at each index to vector of indices.""" # From http://stackoverflow.com/a/22671394 return np.repeat(np.arange(counts.size), counts) def _lladser_point_estimates(sample, r=10): """Series of point estimates of the conditional uncovered probability. Parameters ---------- sample : 1-D array_like, int Series of random observations. r : int, optional Number of new colors that are required for the next prediction. Returns ------- generator Each new color yields a tuple of three elements: the point estimate, position in sample of prediction, and random variable from Poisson process (mostly to make testing easier). Raises ------ ValueError If `r` is less than or equal to 2. Notes ----- This is the point estimator described in Theorem 2 (i) in [1]_. References ---------- .. [1] Lladser, Gouet, and Reeder, "Extrapolation of Urn Models via Poissonization: Accurate Measurements of the Microbial Unknown" PLoS 2011. """ if r <= 2: raise ValueError("r must be greater than or equal to 3.") for count, seen, cost, i in _get_interval_for_r_new_otus(sample, r): t = np.random.gamma(count, 1) point_est = (r - 1) / t yield point_est, i, t def _get_interval_for_r_new_otus(seq, r): """Compute interval between r new OTUs for seq of samples. Imagine an urn with colored balls. Given a drawing of balls from the urn, compute how many balls need to be looked at to discover r new colors. Colors can be repeated. Parameters ---------- seq : sequence Series of observations (the actual sample, not the frequencies). r : int Number of new colors that need to be observed for a new interval. Returns ------- generator For each new color seen for the first time, yields a tuple of four elements: the length of interval (i.e. number of observations looked at), the set of seen colors, position in seq after seeing last new color (end of interval), and position in seq where interval is started. """ seen = set() seq_len = len(seq) # note: first iteration is after looking at first char for i, curr in enumerate(seq): # bail out if there's nothing new if curr in seen: continue else: seen.add(curr) # otherwise, need to see distance to get k colors unseen = 0 j = i + 1 while unseen < r and j < seq_len: if seq[j] not in seen: unseen += 1 # note: increments after termination condition j += 1 # the interval to see r new colors count = j - i - 1 # the position in seq after seeing r new ones cost = j # bail out if not enough unseen if not count or (unseen < r): return # make a copy of seen before yielding, as we'll continue to add to the # set in subsequent iterations yield count, set(seen), cost, i def _lladser_ci_series(seq, r, alpha=0.95, f=10, ci_type='ULCL'): """Construct r-color confidence intervals for uncovered conditional prob. Parameters ---------- seq : sequence Sequence of colors (the actual sample, not the counts). r : int Number of new colors that are required for the next prediction. alpha : float, optional Desired confidence level. f : float, optional Ratio between upper and lower bound. ci_type : {'ULCL', 'ULCU', 'U', 'L'} Type of confidence interval. If ``'ULCL'``, upper and lower bounds with conservative lower bound. If ``'ULCU'``, upper and lower bounds with conservative upper bound. If ``'U'``, upper bound only, lower bound fixed to 0.0. If ``'L'``, lower bound only, upper bound fixed to 1.0. Returns ------- generator Yields one CI prediction for each new color that is detected and where. """ for count, seen, cost, i in _get_interval_for_r_new_otus(seq, r): t = np.random.gamma(count, 1) yield _lladser_ci_from_r(r, t, alpha, f, ci_type) def _lladser_ci_from_r(r, t, alpha=0.95, f=10, ci_type='ULCL'): """Construct r-color confidence interval for uncovered conditional prob. Returns ------- tuple Confidence interval that contains the true conditional uncovered probability with a probability of 100% * `alpha`. Raises ------ ValueError For combinations of `r`, `f`, and `alpha` that do not have precomputed results. """ alpha = round(alpha, 2) if ci_type == 'U': if alpha != 0.95: raise ValueError("alpha must be 0.95 if ci_type is 'U'.") if r not in _UPPER_CONFIDENCE_BOUND: raise ValueError("r must be between 1-25 or 50 if ci_type is 'U'.") return 0.0, _UPPER_CONFIDENCE_BOUND[r] / t elif ci_type == 'L': if alpha != 0.95: raise ValueError("alpha must be 0.95 if ci_type is 'L'.") if r not in _LOWER_CONFIDENCE_BOUND: raise ValueError("r must be between 1-25 if ci_type is 'L'.") return _LOWER_CONFIDENCE_BOUND[r] / t, 1.0 bound_params = _ul_confidence_bounds(f, r, alpha) if ci_type == 'ULCL': bound_param = bound_params[0] elif ci_type == 'ULCU': bound_param = bound_params[1] else: raise ValueError("Unknown ci_type '%s'." % ci_type) upper_bound = bound_param * f / t lower_bound = bound_param / t # make sure upper bound is at most 1 if upper_bound > 1: upper_bound = 1.0 return lower_bound, upper_bound def _ul_confidence_bounds(f, r, alpha): """Return confidence bounds based on ratio and alpha. This function is just a lookup of some precomputed values. Parameters ---------- f : float Desired ratio of upper to lower bound. r : int Number of new colors. alpha : float Confidence interval (for 95% confidence use 0.95). Returns ------- tuple Constants ``(c_1, c_2)`` such that the confidence interval is ``[c_1/T_r, c_1*f/T_r]`` for conservative lower bound intervals and ``[c_2/T_r, c_2*f/T_r]`` for conservative upper bound intervals. """ a = None b = None if (f, r, alpha) in _PRECOMPUTED_TABLE: return _PRECOMPUTED_TABLE[(f, r, alpha)] # all others combination are only computed for f=10 # and alpha = 0.90, 0.95 and 0.99 if f == 10 and r <= 50: if alpha in _CBS and r < len(_CBS[alpha]): a, b = _CBS[alpha][r] if a is None or b is None: raise ValueError("No constants are precomputed for the combination of " "f=%f, r=%d, and alpha=%.2f" % (f, r, alpha)) return a, b # Maps r to a constant c such that the 95% confidence interval with lower bound # fixed at 0 is [0, c/T_r]. This constant is constant b according to # Theorem 2 (iii) in the paper with a=0, aka c_0 from Table 3. _UPPER_CONFIDENCE_BOUND = { 1: 2.995732274, 2: 4.743864518, 3: 6.295793622, 4: 7.753656528, 5: 9.153519027, 6: 10.51303491, 7: 11.84239565, 8: 13.14811380, 9: 14.43464972, 10: 15.70521642, 11: 16.96221924, 12: 18.20751425, 13: 19.44256933, 14: 20.66856908, 15: 21.88648591, 16: 23.09712976, 17: 24.30118368, 18: 25.49923008, 19: 26.69177031, 20: 27.87923964, 21: 29.06201884, 22: 30.24044329, 23: 31.41481021, 24: 32.58538445, 25: 33.75240327, 50: 62.17105670 } # Maps r to a constant c such that the 95% confidence interval with upper bound # fixed at 1 is [c/T_r, 1]. This constant is constant b according to # Theorem 2 (iii) in the paper with b=1, aka c_3 from Table 3. _LOWER_CONFIDENCE_BOUND = { 1: 0.051293294, 2: 0.355361510, 3: 0.817691447, 4: 1.366318397, 5: 1.970149568, 6: 2.613014744, 7: 3.285315692, 8: 3.980822786, 9: 4.695227540, 10: 5.425405697, 11: 6.169007289, 12: 6.924212514, 13: 7.689578292, 14: 8.463937522, 15: 9.246330491, 16: 10.03595673, 17: 10.83214036, 18: 11.63430451, 19: 12.44195219, 20: 13.25465160, 21: 14.07202475, 22: 14.89373854, 23: 15.71949763, 24: 16.54903871, 25: 17.38212584 } # Hack in some special values we used for the paper. # Since Manuel needs to compute those semi-automatically # using Maple, we pre-calculate only a few common ones # precomputed table is {(f, r, alpha):(c_1, c_2)} _PRECOMPUTED_TABLE = { (2, 50, 0.95): (31.13026306, 38.94718565), (2, 33, 0.95): (22.3203508, 23.4487304), (1.5, 100, 0.95): (79.0424349, 83.22790086), (1.5, 94, 0.95): (75.9077267, 76.5492088), (2.5, 19, 0.95): (11.26109001, 11.96814857), # In the next block for each f, we report the smallest possible value # of r from table 4 in the paper (80, 2, 0.95): (0.0598276655, 0.355361510), (48, 2, 0.95): (0.1013728884, 0.355358676), (40, 2, 0.95): (0.1231379857, 0.355320458), (24, 2, 0.95): (0.226833483, 0.346045204), (20, 3, 0.95): (0.320984257, 0.817610455), (12, 3, 0.95): (0.590243030, 0.787721610), (10, 4, 0.95): (0.806026244, 1.360288674), (6, 6, 0.95): (1.8207383, 2.58658608), (5, 7, 0.95): (2.48303930, 3.22806682), (3, 14, 0.95): (7.17185045, 8.27008349), (2.5, 19, 0.95): (11.26109001, 11.96814857), (1.5, 94, 0.95): (75.9077267, 76.5492088), (1.25, 309, 0.95): (275.661191, 275.949782) } # Below are the values used for Theorem 3 iii # Values hand computed by Manuel Lladser using Maple. For each alpha (0.90, # 0.95, and 0.99), there is a list mapping r to (c_1, c_2), where r is used as # an index into the list. _CB_90 = [ (None, None), # 0, makes indexing easier (None, None), # no feasible solution (None, None), # no feasible solution (.5635941995, 1.095834700), (.6764656264, 1.744588615), (.8018565594, 2.432587343), (.9282215025, 3.151897973), (1.053433716, 3.894766804), (1.177158858, 4.656118177), (1.299491033, 5.432468058), (1.420604842, 6.221304605), # 10 (1.540665805, 7.020746595), (1.659812701, 7.829342026), (1.778158703, 8.645942495), (1.895796167, 9.469621185), (2.012801198, 10.29961731), (2.129237257, 11.13529724), (2.245157877, 11.97612664), (2.360608695, 12.82164994), (2.475628991, 13.67147502), (2.590252861, 14.52526147), # 20 (2.704510123, 15.38271151), (2.818427036, 16.24356290), (2.932026869, 17.10758326), (3.045330351, 17.97456551), (3.158356050, 18.84432420), (None, None), # not computed (None, None), (None, None), (None, None), (3.719850286, 23.22944415), # 30 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (4.828910181, 32.13892224), # 40 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (5.924900191, 41.17906791) # 50 ] _CB_95 = [ (None, None), # 0 (None, None), (None, None), (None, None), (.8060262438, 1.360288674), # 4 (.9240311584, 1.969902537), (1.053998892, 2.613007253), (1.185086998, 3.285315518), (1.315076337, 3.980822783), (4.695227540, 4.695227541), (1.570546801, 5.425405698), # 10 (1.696229569, 6.169007289), (1.820753729, 6.924212513), (1.944257622, 7.689578291), (2.066857113, 8.463937522), (2.188648652, 9.246330491), (2.309712994, 10.03595673), (2.430118373, 10.83214036), (2.549923010, 11.63430451), (2.669177032, 12.44195219), (2.787923964, 13.25465160), # 20 (2.906201884, 14.07202475), (3.024044329, 14.89373854), (3.141481020, 15.71949763), (3.258538445, 16.54903871), (3.375240327, 17.38212584), (None, None), (None, None), (None, None), (None, None), (3.954097220, 21.59397923), # 30 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (5.093973695, 30.19573919), # 40 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (6.217105673, 38.96473258) # 50 ] _CB_99 = [ (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (1.360316290, 1.768978323), (1.470856924, 2.329171347), (1.604478487, 2.906049304), (1.741759456, 3.507452949), (1.878809285, 4.130199076), # 10 (2.014632329, 4.771246173), (2.149044735, 5.428180734), (2.282101533, 6.099073460), (2.413917374, 6.782354878), (2.544610844, 7.476728267), (2.674289153, 8.181107778), (2.803045614, 8.894573463), (2.930960779, 9.616337916), (3.058104355, 10.34572103), (3.184536992, 11.08213063), # 20 (3.310311816, 11.82504734), (3.435475649, 12.57401269), (3.560070013, 13.32861956), (3.684131925, 14.08850448), (3.807694563, 14.85334135), (None, None), (None, None), (None, None), (None, None), (4.41897094, 18.7424258), # 30 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (5.61643962, 26.7700386), # 40 (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (None, None), (6.79033616, 35.0324474) # 50 ] _CBS = { 0.90: _CB_90, 0.95: _CB_95, 0.99: _CB_99 } scikit-bio-0.5.9/skbio/diversity/alpha/tests/000077500000000000000000000000001446255456000211555ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/alpha/tests/__init__.py000066400000000000000000000005411446255456000232660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/000077500000000000000000000000001446255456000220665ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/qiime-191-tt/000077500000000000000000000000001446255456000241275ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/qiime-191-tt/README.md000066400000000000000000000002411446255456000254030ustar00rootroot00000000000000Files in this directory are the QIIME 1.9.1 "tiny test" files. For detail on how these were created, see skbio/diversity/beta/tests/data/qiime-191-tt/README.md. scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/qiime-191-tt/faith-pd.txt000066400000000000000000000001461446255456000263650ustar00rootroot00000000000000 PD_whole_tree f2 0.64607 f1 0.47803 f3 0.47803 f4 0.306525 p2 1.4239 p1 0.604145 t1 0.6574 t2 0.6574 scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/qiime-191-tt/otu-table.tsv000066400000000000000000000004431446255456000265620ustar00rootroot00000000000000# Constructed from biom file #OTU ID f2 f1 f3 f4 p2 p1 t1 t2 295053 20 18 18 22 4 0 0 0 42684 0 0 0 0 1 0 0 0 None11 1 0 0 0 1 1 0 0 None7 0 0 0 0 1 0 0 0 None5 0 0 0 0 1 0 0 0 None4 0 0 0 0 1 1 0 0 None3 0 0 0 0 1 0 2 3 879972 0 0 0 0 9 20 1 4 None9 0 0 0 0 3 0 19 15 None8 1 4 4 0 0 0 0 0 scikit-bio-0.5.9/skbio/diversity/alpha/tests/data/qiime-191-tt/tree.nwk000066400000000000000000000004121446255456000256040ustar00rootroot00000000000000(((879972:0.05039,None3:0.00778)0.980:0.15948,((None11:0.07161,None4:0.06965)0.917:0.09643,(295053:0.06096,42684:0.15599)0.910:0.08898)0.899:0.09227)0.958:0.064315,(None8:0.09606,(None7:0.10435,(None5:0.02626,None9:0.00014)1.000:0.25335)0.753:0.0465):0.075445)root; scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_ace.py000066400000000000000000000027311446255456000233210ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy as np import numpy.testing as npt from skbio.diversity.alpha import ace class AceTests(unittest.TestCase): def test_ace(self): npt.assert_almost_equal(ace(np.array([2, 0])), 1.0) npt.assert_almost_equal(ace(np.array([12, 0, 9])), 2.0) npt.assert_almost_equal(ace(np.array([12, 2, 8])), 3.0) npt.assert_almost_equal(ace(np.array([12, 2, 1])), 4.0) npt.assert_almost_equal(ace(np.array([12, 1, 2, 1])), 7.0) npt.assert_almost_equal(ace(np.array([12, 3, 2, 1])), 4.6) npt.assert_almost_equal(ace(np.array([12, 3, 6, 1, 10])), 5.62749672) # Just returns the number of OTUs when all are abundant. npt.assert_almost_equal(ace(np.array([12, 12, 13, 14])), 4.0) # Border case: only singletons and 10-tons, no abundant OTUs. npt.assert_almost_equal(ace([0, 1, 1, 0, 0, 10, 10, 1, 0, 0]), 9.35681818182) def test_ace_only_rare_singletons(self): with self.assertRaises(ValueError): ace([0, 0, 43, 0, 1, 0, 1, 42, 1, 43]) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_base.py000066400000000000000000000241271446255456000235060ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main from io import StringIO import numpy as np import numpy.testing as npt from skbio import TreeNode from skbio.diversity.alpha import ( berger_parker_d, brillouin_d, dominance, doubles, enspie, esty_ci, fisher_alpha, goods_coverage, heip_e, kempton_taylor_q, margalef, mcintosh_d, mcintosh_e, menhinick, michaelis_menten_fit, observed_otus, osd, pielou_e, robbins, shannon, simpson, simpson_e, singles, strong) class BaseTests(TestCase): def setUp(self): self.counts = np.array([0, 1, 1, 4, 2, 5, 2, 4, 1, 2]) self.sids1 = list('ABCD') self.oids1 = ['OTU%d' % i for i in range(1, 6)] self.t1 = TreeNode.read(StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):' '0.0,(OTU4:0.75,OTU5:0.75):1.25):0.0)root;')) self.t1_w_extra_tips = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,(OTU5:0.25,(OTU6:0.5,OTU7:0.5):0.5):0.5):1.25):0.0' ')root;')) def test_berger_parker_d(self): self.assertEqual(berger_parker_d(np.array([5])), 1) self.assertEqual(berger_parker_d(np.array([5, 5])), 0.5) self.assertEqual(berger_parker_d(np.array([1, 1, 1, 1, 0])), 0.25) self.assertEqual(berger_parker_d(self.counts), 5 / 22) def test_brillouin_d(self): self.assertAlmostEqual(brillouin_d(np.array([1, 2, 0, 0, 3, 1])), 0.86289353018248782) def test_dominance(self): self.assertEqual(dominance(np.array([5])), 1) self.assertAlmostEqual(dominance(np.array([1, 0, 2, 5, 2])), 0.34) def test_doubles(self): self.assertEqual(doubles(self.counts), 3) self.assertEqual(doubles(np.array([0, 3, 4])), 0) self.assertEqual(doubles(np.array([2])), 1) self.assertEqual(doubles(np.array([0, 0])), 0) def test_enspie(self): # Totally even community should have ENS_pie = number of OTUs. self.assertAlmostEqual(enspie(np.array([1, 1, 1, 1, 1, 1])), 6) self.assertAlmostEqual(enspie(np.array([13, 13, 13, 13])), 4) # Hand calculated. arr = np.array([1, 41, 0, 0, 12, 13]) exp = 1 / ((arr / arr.sum()) ** 2).sum() self.assertAlmostEqual(enspie(arr), exp) # Using dominance. exp = 1 / dominance(arr) self.assertAlmostEqual(enspie(arr), exp) arr = np.array([1, 0, 2, 5, 2]) exp = 1 / dominance(arr) self.assertAlmostEqual(enspie(arr), exp) def test_esty_ci(self): def _diversity(indices, f): """Calculate diversity index for each window of size 1. indices: vector of indices of OTUs f: f(counts) -> diversity measure """ result = [] max_size = max(indices) + 1 freqs = np.zeros(max_size, dtype=int) for i in range(len(indices)): freqs += np.bincount(indices[i:i + 1], minlength=max_size) try: curr = f(freqs) except (ZeroDivisionError, FloatingPointError): curr = 0 result.append(curr) return np.array(result) data = [1, 1, 2, 1, 1, 3, 2, 1, 3, 4] observed_lower, observed_upper = zip(*_diversity(data, esty_ci)) expected_lower = np.array([1, -1.38590382, -0.73353593, -0.17434465, -0.15060902, -0.04386191, -0.33042054, -0.29041008, -0.43554755, -0.33385652]) expected_upper = np.array([1, 1.38590382, 1.40020259, 0.67434465, 0.55060902, 0.71052858, 0.61613483, 0.54041008, 0.43554755, 0.53385652]) npt.assert_array_almost_equal(observed_lower, expected_lower) npt.assert_array_almost_equal(observed_upper, expected_upper) def test_fisher_alpha(self): exp = 2.7823795367398798 arr = np.array([4, 3, 4, 0, 1, 0, 2]) obs = fisher_alpha(arr) self.assertAlmostEqual(obs, exp) # Should depend only on S and N (number of OTUs, number of # individuals / seqs), so we should obtain the same output as above. obs = fisher_alpha([1, 6, 1, 0, 1, 0, 5]) self.assertAlmostEqual(obs, exp) # Should match another by hand: # 2 OTUs, 62 seqs, alpha is 0.39509 obs = fisher_alpha([61, 0, 0, 1]) self.assertAlmostEqual(obs, 0.39509, delta=0.0001) # Test case where we have >1000 individuals (SDR-IV makes note of this # case). Verified against R's vegan::fisher.alpha. obs = fisher_alpha([999, 0, 10]) self.assertAlmostEqual(obs, 0.2396492) def test_goods_coverage(self): counts = [1] * 75 + [2, 2, 2, 2, 2, 2, 3, 4, 4] obs = goods_coverage(counts) self.assertAlmostEqual(obs, 0.23469387755) def test_heip_e(self): # Calculate "by hand". arr = np.array([1, 2, 3, 1]) h = shannon(arr, base=np.e) expected = (np.exp(h) - 1) / 3 self.assertEqual(heip_e(arr), expected) # From Statistical Ecology: A Primer in Methods and Computing, page 94, # table 8.1. self.assertAlmostEqual(heip_e([500, 300, 200]), 0.90, places=2) self.assertAlmostEqual(heip_e([500, 299, 200, 1]), 0.61, places=2) def test_kempton_taylor_q(self): # Approximate Magurran 1998 calculation p143. arr = np.array([2, 3, 3, 3, 3, 3, 4, 4, 4, 6, 6, 7, 7, 9, 9, 11, 14, 15, 15, 20, 29, 33, 34, 36, 37, 53, 57, 138, 146, 170]) exp = 14 / np.log(34 / 4) self.assertAlmostEqual(kempton_taylor_q(arr), exp) # Should get same answer regardless of input order. np.random.shuffle(arr) self.assertAlmostEqual(kempton_taylor_q(arr), exp) def test_margalef(self): self.assertEqual(margalef(self.counts), 8 / np.log(22)) def test_mcintosh_d(self): self.assertAlmostEqual(mcintosh_d(np.array([1, 2, 3])), 0.636061424871458) def test_mcintosh_e(self): num = np.sqrt(15) den = np.sqrt(19) exp = num / den self.assertEqual(mcintosh_e(np.array([1, 2, 3, 1])), exp) def test_menhinick(self): # observed_otus = 9, total # of individuals = 22 self.assertEqual(menhinick(self.counts), 9 / np.sqrt(22)) def test_michaelis_menten_fit(self): obs = michaelis_menten_fit([22]) self.assertAlmostEqual(obs, 1.0) obs = michaelis_menten_fit([42]) self.assertAlmostEqual(obs, 1.0) obs = michaelis_menten_fit([34], num_repeats=3, params_guess=(13, 13)) self.assertAlmostEqual(obs, 1.0) obs = michaelis_menten_fit([70, 70], num_repeats=5) self.assertAlmostEqual(obs, 2.0, places=1) obs_few = michaelis_menten_fit(np.arange(4) * 2, num_repeats=10) obs_many = michaelis_menten_fit(np.arange(4) * 100, num_repeats=10) # [0,100,200,300] looks like only 3 OTUs. self.assertAlmostEqual(obs_many, 3.0, places=1) # [0,2,4,6] looks like 3 OTUs with maybe more to be found. self.assertTrue(obs_few > obs_many) def test_observed_otus(self): obs = observed_otus(np.array([4, 3, 4, 0, 1, 0, 2])) self.assertEqual(obs, 5) obs = observed_otus(np.array([0, 0, 0])) self.assertEqual(obs, 0) obs = observed_otus(self.counts) self.assertEqual(obs, 9) def test_osd(self): self.assertEqual(osd(self.counts), (9, 3, 3)) def test_pielou_e(self): # Calculate "by hand". arr = np.array([1, 2, 3, 1]) h = shannon(arr, np.e) s = 4 expected = h / np.log(s) self.assertAlmostEqual(pielou_e(arr), expected) self.assertAlmostEqual(pielou_e(self.counts), 0.92485490560) self.assertAlmostEqual(pielou_e([1, 1]), 1.0) self.assertAlmostEqual(pielou_e([1, 1, 1, 1]), 1.0) self.assertAlmostEqual(pielou_e([1, 1, 1, 1, 0, 0]), 1.0) # Examples from # http://ww2.mdsg.umd.edu/interactive_lessons/biofilm/diverse.htm#3 self.assertAlmostEqual(pielou_e([1, 1, 196, 1, 1]), 0.078, 3) self.assertTrue(np.isnan(pielou_e([0, 0, 200, 0, 0]))) self.assertTrue(np.isnan(pielou_e([0, 0, 0, 0, 0]))) def test_robbins(self): self.assertEqual(robbins(np.array([1, 2, 3, 0, 1])), 2 / 7) def test_shannon(self): self.assertEqual(shannon(np.array([5])), 0) self.assertEqual(shannon(np.array([5, 5])), 1) self.assertEqual(shannon(np.array([1, 1, 1, 1, 0])), 2) def test_simpson(self): self.assertAlmostEqual(simpson(np.array([1, 0, 2, 5, 2])), 0.66) self.assertAlmostEqual(simpson(np.array([5])), 0) def test_simpson_e(self): # A totally even community should have simpson_e = 1. self.assertEqual(simpson_e(np.array([1, 1, 1, 1, 1, 1, 1])), 1) arr = np.array([0, 30, 25, 40, 0, 0, 5]) freq_arr = arr / arr.sum() D = (freq_arr ** 2).sum() exp = 1 / (D * 4) obs = simpson_e(arr) self.assertEqual(obs, exp) # From: # https://groups.nceas.ucsb.edu/sun/meetings/calculating-evenness- # of-habitat-distributions arr = np.array([500, 400, 600, 500]) D = 0.0625 + 0.04 + 0.09 + 0.0625 exp = 1 / (D * 4) self.assertEqual(simpson_e(arr), exp) def test_singles(self): self.assertEqual(singles(self.counts), 3) self.assertEqual(singles(np.array([0, 3, 4])), 0) self.assertEqual(singles(np.array([1])), 1) self.assertEqual(singles(np.array([0, 0])), 0) def test_strong(self): self.assertAlmostEqual(strong(np.array([1, 2, 3, 1])), 0.214285714) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_chao1.py000066400000000000000000000054611446255456000235670ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt from skbio.diversity.alpha import chao1, chao1_ci from skbio.diversity.alpha._chao1 import _chao1_var class Chao1Tests(TestCase): def setUp(self): self.counts = np.array([0, 1, 1, 4, 2, 5, 2, 4, 1, 2]) self.no_singles = np.array([0, 2, 2, 4, 5, 0, 0, 0, 0, 0]) self.no_doubles = np.array([0, 1, 1, 4, 5, 0, 0, 0, 0, 0]) def test_chao1(self): self.assertEqual(chao1(self.counts), 9.75) self.assertEqual(chao1(self.counts, bias_corrected=False), 10.5) self.assertEqual(chao1(self.no_singles), 4) self.assertEqual(chao1(self.no_singles, bias_corrected=False), 4) self.assertEqual(chao1(self.no_doubles), 5) self.assertEqual(chao1(self.no_doubles, bias_corrected=False), 5) def test_chao1_ci(self): # Should match observed results from EstimateS. NOTE: EstimateS rounds # to 2 dp. obs = chao1_ci(self.counts) npt.assert_allclose(obs, (9.07, 17.45), rtol=0.01) obs = chao1_ci(self.counts, bias_corrected=False) npt.assert_allclose(obs, (9.17, 21.89), rtol=0.01) obs = chao1_ci(self.no_singles) npt.assert_array_almost_equal(obs, (4, 4.95), decimal=2) obs = chao1_ci(self.no_singles, bias_corrected=False) npt.assert_array_almost_equal(obs, (4, 4.95), decimal=2) obs = chao1_ci(self.no_doubles) npt.assert_array_almost_equal(obs, (4.08, 17.27), decimal=2) obs = chao1_ci(self.no_doubles, bias_corrected=False) npt.assert_array_almost_equal(obs, (4.08, 17.27), decimal=2) def test_chao1_var(self): # Should match observed results from EstimateS.NOTE: EstimateS reports # sd, not var, and rounds to 2 dp. obs = _chao1_var(self.counts) npt.assert_allclose(obs, 1.42 ** 2, rtol=0.01) obs = _chao1_var(self.counts, bias_corrected=False) npt.assert_allclose(obs, 2.29 ** 2, rtol=0.01) obs = _chao1_var(self.no_singles) self.assertAlmostEqual(obs, 0.39 ** 2, delta=0.01) obs = _chao1_var(self.no_singles, bias_corrected=False) self.assertAlmostEqual(obs, 0.39 ** 2, delta=0.01) obs = _chao1_var(self.no_doubles) self.assertAlmostEqual(obs, 2.17 ** 2, delta=0.01) obs = _chao1_var(self.no_doubles, bias_corrected=False) self.assertAlmostEqual(obs, 2.17 ** 2, delta=0.01) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_faith_pd.py000066400000000000000000000207061446255456000243510ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main from io import StringIO import os import numpy as np import pandas as pd from skbio import TreeNode from skbio.util import get_data_path from skbio.tree import DuplicateNodeError, MissingNodeError from skbio.diversity.alpha import faith_pd class FaithPDTests(TestCase): def setUp(self): self.counts = np.array([0, 1, 1, 4, 2, 5, 2, 4, 1, 2]) self.b1 = np.array([[1, 3, 0, 1, 0], [0, 2, 0, 4, 4], [0, 0, 6, 2, 1], [0, 0, 1, 1, 1]]) self.sids1 = list('ABCD') self.oids1 = ['OTU%d' % i for i in range(1, 6)] self.t1 = TreeNode.read(StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):' '0.0,(OTU4:0.75,OTU5:0.75):1.25):0.0)root;')) self.t1_w_extra_tips = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,(OTU5:0.25,(OTU6:0.5,OTU7:0.5):0.5):0.5):1.25):0.0' ')root;')) def test_faith_pd_none_observed(self): actual = faith_pd(np.array([], dtype=int), np.array([], dtype=int), self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) actual = faith_pd([0, 0, 0, 0, 0], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_faith_pd_all_observed(self): actual = faith_pd([1, 1, 1, 1, 1], self.oids1, self.t1) expected = sum(n.length for n in self.t1.traverse() if n.length is not None) self.assertAlmostEqual(actual, expected) actual = faith_pd([1, 2, 3, 4, 5], self.oids1, self.t1) expected = sum(n.length for n in self.t1.traverse() if n.length is not None) self.assertAlmostEqual(actual, expected) def test_faith_pd(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # phylogenetic diversity implementation actual = faith_pd(self.b1[0], self.oids1, self.t1) expected = 4.5 self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[1], self.oids1, self.t1) expected = 4.75 self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[2], self.oids1, self.t1) expected = 4.75 self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[3], self.oids1, self.t1) expected = 4.75 self.assertAlmostEqual(actual, expected) def test_faith_pd_extra_tips(self): # results are the same despite presences of unobserved tips in tree actual = faith_pd(self.b1[0], self.oids1, self.t1_w_extra_tips) expected = faith_pd(self.b1[0], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[1], self.oids1, self.t1_w_extra_tips) expected = faith_pd(self.b1[1], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[2], self.oids1, self.t1_w_extra_tips) expected = faith_pd(self.b1[2], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) actual = faith_pd(self.b1[3], self.oids1, self.t1_w_extra_tips) expected = faith_pd(self.b1[3], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) def test_faith_pd_minimal(self): # two tips tree = TreeNode.read(StringIO('(OTU1:0.25, OTU2:0.25)root;')) actual = faith_pd([1, 0], ['OTU1', 'OTU2'], tree) expected = 0.25 self.assertEqual(actual, expected) def test_faith_pd_qiime_tiny_test(self): # the following table and tree are derived from the QIIME 1.9.1 # "tiny-test" data tt_table_fp = get_data_path( os.path.join('qiime-191-tt', 'otu-table.tsv'), 'data') tt_tree_fp = get_data_path( os.path.join('qiime-191-tt', 'tree.nwk'), 'data') self.q_table = pd.read_csv(tt_table_fp, sep='\t', skiprows=1, index_col=0) self.q_tree = TreeNode.read(tt_tree_fp) expected_fp = get_data_path( os.path.join('qiime-191-tt', 'faith-pd.txt'), 'data') expected = pd.read_csv(expected_fp, sep='\t', index_col=0) for sid in self.q_table.columns: actual = faith_pd(self.q_table[sid], otu_ids=self.q_table.index, tree=self.q_tree) self.assertAlmostEqual(actual, expected['PD_whole_tree'][sid]) def test_faith_pd_root_not_observed(self): # expected values computed by hand tree = TreeNode.read( StringIO('((OTU1:0.1, OTU2:0.2):0.3, (OTU3:0.5, OTU4:0.7):1.1)' 'root;')) otu_ids = ['OTU%d' % i for i in range(1, 5)] # root node not observed, but branch between (OTU1, OTU2) and root # is considered observed actual = faith_pd([1, 1, 0, 0], otu_ids, tree) expected = 0.6 self.assertAlmostEqual(actual, expected) # root node not observed, but branch between (OTU3, OTU4) and root # is considered observed actual = faith_pd([0, 0, 1, 1], otu_ids, tree) expected = 2.3 self.assertAlmostEqual(actual, expected) def test_faith_pd_invalid_input(self): # tree has duplicated tip ids t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(DuplicateNodeError, faith_pd, counts, otu_ids, t) # unrooted tree as input t = TreeNode.read(StringIO('((OTU1:0.1, OTU2:0.2):0.3, OTU3:0.5,' 'OTU4:0.7);')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # otu_ids has duplicated ids t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU2'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # len of vectors not equal t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # negative counts t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, -3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # tree with no branch lengths t = TreeNode.read( StringIO('((((OTU1,OTU2),OTU3)),(OTU4,OTU5));')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # tree missing some branch lengths t = TreeNode.read( StringIO('(((((OTU1,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, faith_pd, counts, otu_ids, t) # otu_ids not present in tree t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU42'] self.assertRaises(MissingNodeError, faith_pd, counts, otu_ids, t) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_gini.py000066400000000000000000000044121446255456000235150ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt from skbio.diversity.alpha import gini_index from skbio.diversity.alpha._gini import ( _lorenz_curve, _lorenz_curve_integrator) class GiniTests(TestCase): def setUp(self): self.data = np.array([4.5, 6.7, 3.4, 15., 18., 3.5, 6.7, 14.1]) self.lorenz_curve_points = ( np.array([0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]), np.array([0.047287899860917935, 0.095966620305980521, 0.15855354659248957, 0.2517385257301808, 0.34492350486787204, 0.541029207232267, 0.74965229485396379, 1.0])) def test_gini_index_bug_1844(self): exp = 0.0 obs = gini_index([2, 2, 2, 2, 2]) self.assertAlmostEqual(obs, exp) def test_gini_index(self): exp = 0.32771210013908214 obs = gini_index(self.data, 'trapezoids') self.assertAlmostEqual(obs, exp) exp = 0.20271210013908214 obs = gini_index(self.data, 'rectangles') self.assertAlmostEqual(obs, exp) # Raises error on negative data. with self.assertRaises(ValueError): gini_index([1.0, -3.1, 4.5]) def test_lorenz_curve(self): npt.assert_array_almost_equal(_lorenz_curve(self.data), self.lorenz_curve_points) def test_lorenz_curve_integrator(self): exp = 0.33614394993045893 obs = _lorenz_curve_integrator(self.lorenz_curve_points, 'trapezoids') self.assertAlmostEqual(obs, exp) exp = 0.39864394993045893 obs = _lorenz_curve_integrator(self.lorenz_curve_points, 'rectangles') self.assertAlmostEqual(obs, exp) # Raises error on invalid method. with self.assertRaises(ValueError): _lorenz_curve_integrator(self.lorenz_curve_points, 'brofist') if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/diversity/alpha/tests/test_lladser.py000066400000000000000000000203111446255456000242110ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy as np import numpy.testing as npt from skbio.stats import subsample_counts from skbio.diversity.alpha import lladser_pe, lladser_ci from skbio.diversity.alpha._lladser import ( _expand_counts, _lladser_point_estimates, _get_interval_for_r_new_otus, _lladser_ci_series, _lladser_ci_from_r) def create_fake_observation(): """Create a subsample with defined property""" # Create a subsample of a larger sample such that we can compute # the expected probability of the unseen portion. # This is used in the tests of lladser_pe and lladser_ci counts = np.ones(1001, dtype='int64') counts[0] = 9000 total = counts.sum() fake_obs = subsample_counts(counts, 1000) exp_p = 1 - sum([x/total for (x, y) in zip(counts, fake_obs) if y > 0]) return fake_obs, exp_p class LladserTests(unittest.TestCase): def test_lladser_pe(self): """lladser_pe returns point estimates within the expected variance""" obs = lladser_pe([3], r=4) self.assertTrue(np.isnan(obs)) np.random.seed(123456789) fake_obs, exp_p = create_fake_observation() reps = 100 sum = 0 for i in range(reps): sum += lladser_pe(fake_obs, r=30) obs = sum / reps # Estimator has variance of (1-p)^2/(r-2), # which for r=30 and p~=0.9 is 0.0289 npt.assert_almost_equal(obs, exp_p, decimal=2) def test_lladser_ci_nan(self): """lladser_ci returns nan if sample is too short to make an estimate""" obs = lladser_ci([3], r=4) self.assertTrue(len(obs) == 2 and np.isnan(obs[0]) and np.isnan(obs[1])) def test_lladser_ci(self): """lladser_ci estimate using defaults contains p with 95% prob""" np.random.seed(12345678) reps = 100 sum = 0 for i in range(reps): fake_obs, exp_p = create_fake_observation() (low, high) = lladser_ci(fake_obs, r=10) if (low <= exp_p <= high): sum += 1 self.assertTrue(sum/reps >= 0.95) def test_lladser_ci_f3(self): """lladser_ci estimate using f=3 contains p with 95% prob""" # Test different values of f=3 and r=14, which lie exactly on the # 95% interval line. For 100 reps using simple cumulative binomial # probs we expect to have more than 5 misses of the interval in 38% # of all test runs. To make this test pass reliable we thus have to # set a defined seed np.random.seed(12345678) reps = 100 sum = 0 for i in range(reps): # re-create the obs for every estimate, such that they are truly # independent events fake_obs, exp_p = create_fake_observation() (low, high) = lladser_ci(fake_obs, r=14, f=3) if (low <= exp_p <= high): sum += 1 self.assertTrue(sum/reps >= 0.95) def test_expand_counts(self): arr = np.array([2, 0, 1, 2]) npt.assert_array_equal(_expand_counts(arr), np.array([0, 0, 2, 3, 3])) def test_lladser_point_estimates(self): s = [5, 1, 5, 1, 2, 3, 1, 5, 3, 2, 5, 3] r = 3 observed = list(_lladser_point_estimates(s, r)) self.assertEqual(len(observed), 3) for k in range(3): x = observed[k] t = x[2] self.assertEqual(x[0], (r - 1) / t) # Estimator has variance of (1-p)^2/(r-2), # which for r=7 and p=0.5 is 0.05 seq = "WBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBW" reps = 1000 sum = 0 for i in range(reps): p, _, _ = list(_lladser_point_estimates(seq, r=7))[0] sum += p self.assertTrue(0.45 < sum / reps and sum / reps < 0.55) def test_lladser_point_estimates_invalid_r(self): with self.assertRaises(ValueError): list(_lladser_point_estimates([5, 1, 5, 1, 2, 3, 1, 5, 3, 2, 5, 3], 2)) def test_get_interval_for_r_new_otus(self): s = [5, 1, 5, 1, 2, 3, 1, 5, 3, 2, 5] expected = [(3, set([5]), 4, 0), (4, set([5, 1]), 6, 1), (4, set([5, 1, 2]), 9, 4)] for x, y in zip(_get_interval_for_r_new_otus(s, 2), expected): self.assertEqual(x, y) s = [5, 5, 5, 5, 5] # never saw new one self.assertEqual(list(_get_interval_for_r_new_otus(s, 2)), []) def test_lladser_ci_series_exact(self): # have seen RWB urn_1 = 'RWBWWBWRRWRYWRPPZ' results = list(_lladser_ci_series(urn_1, r=4)) self.assertEqual(len(results), 3) def test_lladser_ci_series_random(self): seq = "WBWBWBWBWBWB" observations = [] alpha = 0.95 reps = 1000 for i in range(reps): obs = list(_lladser_ci_series(seq, r=4, alpha=alpha))[0] observations.append(obs) tps = list(filter(lambda a_b: a_b[0] < 0.5 and 0.5 < a_b[1], observations)) self.assertTrue(len(tps) >= alpha * reps) # 100%-95% def test_lladser_ci_from_r(self): f = 10 t = 10 r = 4 obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f) npt.assert_almost_equal(obs_low, 0.0806026244) npt.assert_almost_equal(obs_high, 0.806026244) r = 20 t = 100 obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f) npt.assert_almost_equal(obs_low, 0.02787923964) npt.assert_almost_equal(obs_high, 0.2787923964) # make sure we test with each possible alpha alpha = 0.99 obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f, alpha=alpha) npt.assert_almost_equal(obs_low, 0.03184536992) npt.assert_almost_equal(obs_high, 0.3184536992) alpha = 0.9 r = 3 obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f, alpha=alpha) npt.assert_almost_equal(obs_low, 0.005635941995) npt.assert_almost_equal(obs_high, 0.05635941995) # test other ci_types ci_type = 'ULCU' obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f, alpha=alpha, ci_type=ci_type) npt.assert_almost_equal(obs_low, 0.01095834700) npt.assert_almost_equal(obs_high, 0.1095834700) alpha = 0.95 t = 10 ci_type = 'U' obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f, alpha=alpha, ci_type=ci_type) npt.assert_almost_equal(obs_low, 0) npt.assert_almost_equal(obs_high, 0.6295793622) ci_type = 'L' obs_low, obs_high = _lladser_ci_from_r(r=r, t=t, f=f, alpha=alpha, ci_type=ci_type) npt.assert_almost_equal(obs_low, 0.0817691447) npt.assert_almost_equal(obs_high, 1) def test_lladser_ci_from_r_invalid_input(self): # unsupported alpha for ci_type='U' with self.assertRaises(ValueError): _lladser_ci_from_r(r=3, t=10, f=10, alpha=0.90, ci_type='U') # unsupported r for ci_type='U' with self.assertRaises(ValueError): _lladser_ci_from_r(r=42, t=10, f=10, alpha=0.95, ci_type='U') # unsupported alpha for ci_type='L' with self.assertRaises(ValueError): _lladser_ci_from_r(r=3, t=10, f=10, alpha=0.90, ci_type='L') # unsupported r for ci_type='L' with self.assertRaises(ValueError): _lladser_ci_from_r(r=50, t=10, f=10, alpha=0.95, ci_type='L') # unknown ci_type with self.assertRaises(ValueError): _lladser_ci_from_r(r=4, t=10, f=10, alpha=0.95, ci_type='brofist') # requesting CI for not precomputed values with self.assertRaises(ValueError): _lladser_ci_from_r(r=500, t=10, f=10) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/diversity/beta/000077500000000000000000000000001446255456000176415ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/beta/__init__.py000066400000000000000000000017711446255456000217600ustar00rootroot00000000000000""" Beta diversity measures (:mod:`skbio.diversity.beta`) ===================================================== .. currentmodule:: skbio.diversity.beta This package provides implementations of beta diversity measures for computing sample dissimilarity. Users of this package should also explore ``scipy.spatial.distance.pdist``, as it contains implementations of additional beta diversity metrics with interfaces similar to those provided here. Functions --------- .. autosummary:: :toctree: unweighted_unifrac weighted_unifrac """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._unifrac import unweighted_unifrac, weighted_unifrac __all__ = ["unweighted_unifrac", "weighted_unifrac"] scikit-bio-0.5.9/skbio/diversity/beta/_unifrac.py000066400000000000000000000557031446255456000220130ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import functools import numpy as np from skbio.util._decorator import experimental from skbio.diversity._util import (_validate_counts_matrix, _validate_otu_ids_and_tree, _vectorize_counts_and_tree) from skbio.diversity._phylogenetic import _tip_distances # The default value indicating whether normalization should be applied # for weighted UniFrac. This is used in two locations, so set in a single # variable to avoid the code base becoming out of sync in the event of a # change in this default value. _normalize_weighted_unifrac_by_default = False @experimental(as_of="0.4.1") def unweighted_unifrac(u_counts, v_counts, otu_ids, tree, validate=True): """ Compute unweighted UniFrac Parameters ---------- u_counts, v_counts: list, np.array Vectors of counts/abundances of OTUs for two samples. Must be equal length. otu_ids: list, np.array Vector of OTU ids corresponding to tip names in ``tree``. Must be the same length as ``u_counts`` and ``v_counts``. tree: skbio.TreeNode Tree relating the OTUs in otu_ids. The set of tip names in the tree can be a superset of ``otu_ids``, but not a subset. validate: bool, optional If `False`, validation of the input won't be performed. This step can be slow, so if validation is run elsewhere it can be disabled here. However, invalid input data can lead to invalid results or error messages that are hard to interpret, so this step should not be bypassed if you're not certain that your input data are valid. See :mod:`skbio.diversity` for the description of what validation entails so you can determine if you can safely disable validation. Returns ------- float The unweighted UniFrac distance between the two samples. Raises ------ ValueError, MissingNodeError, DuplicateNodeError If validation fails. Exact error will depend on what was invalid. See Also -------- weighted_unifrac skbio.diversity skbio.diversity.beta_diversity Notes ----- Unweighted UniFrac was originally described in [1]_. A discussion of unweighted (qualitative) versus weighted (quantitative) diversity metrics is presented in [2]_. Deeper mathematical discussions of this metric is presented in [3]_. If computing unweighted UniFrac for multiple pairs of samples, using ``skbio.diversity.beta_diversity`` will be much faster than calling this function individually on each sample. This implementation differs from that in PyCogent (and therefore QIIME versions less than 2.0.0) by imposing a few additional restrictions on the inputs. First, the input tree must be rooted. In PyCogent, if an unrooted tree was provided that had a single trifurcating node (a newick convention for unrooted trees) that node was considered the root of the tree. Next, all OTU IDs must be tips in the tree. PyCogent would silently ignore OTU IDs that were not present the tree. To reproduce UniFrac results from PyCogent with scikit-bio, ensure that your PyCogent UniFrac calculations are performed on a rooted tree and that all OTU IDs are present in the tree. This implementation of unweighted UniFrac is the array-based implementation described in [4]_. If using large number of samples or a large tree, we advise using the optimized UniFrac library [5]_. References ---------- .. [1] Lozupone, C. & Knight, R. UniFrac: a new phylogenetic method for comparing microbial communities. Appl. Environ. Microbiol. 71, 8228-8235 (2005). .. [2] Lozupone, C. A., Hamady, M., Kelley, S. T. & Knight, R. Quantitative and qualitative beta diversity measures lead to different insights into factors that structure microbial communities. Appl. Environ. Microbiol. 73, 1576-1585 (2007). .. [3] Lozupone, C., Lladser, M. E., Knights, D., Stombaugh, J. & Knight, R. UniFrac: an effective distance metric for microbial community comparison. ISME J. 5, 169-172 (2011). .. [4] Hamady M, Lozupone C, Knight R. Fast UniFrac: facilitating high- throughput phylogenetic analyses of microbial communities including analysis of pyrosequencing and PhyloChip data. ISME J. 4(1):17-27 (2010). .. [5] https://github.com/biocore/unifrac Examples -------- Assume we have the following abundance data for two samples, ``u`` and ``v``, represented as a pair of counts vectors. These counts represent the number of times specific Operational Taxonomic Units, or OTUs, were observed in each of the samples. >>> u_counts = [1, 0, 0, 4, 1, 2, 3, 0] >>> v_counts = [0, 1, 1, 6, 0, 1, 0, 0] Because UniFrac is a phylogenetic diversity metric, we need to know which OTU each count corresponds to, which we'll provide as ``otu_ids``. >>> otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5', 'OTU6', 'OTU7', ... 'OTU8'] We also need a phylogenetic tree that relates the OTUs to one another. >>> from io import StringIO >>> from skbio import TreeNode >>> tree = TreeNode.read(StringIO( ... '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,' ... '(OTU4:0.75,(OTU5:0.5,((OTU6:0.33,OTU7:0.62):0.5' ... ',OTU8:0.5):0.5):0.5):1.25):0.0)root;')) We can then compute the unweighted UniFrac distance between the samples. >>> from skbio.diversity.beta import unweighted_unifrac >>> uu = unweighted_unifrac(u_counts, v_counts, otu_ids, tree) >>> print(round(uu, 2)) 0.37 """ u_node_counts, v_node_counts, _, _, tree_index =\ _setup_pairwise_unifrac(u_counts, v_counts, otu_ids, tree, validate, normalized=False, unweighted=True) return _unweighted_unifrac(u_node_counts, v_node_counts, tree_index['length']) @experimental(as_of="0.4.1") def weighted_unifrac(u_counts, v_counts, otu_ids, tree, normalized=_normalize_weighted_unifrac_by_default, validate=True): """ Compute weighted UniFrac with or without branch length normalization Parameters ---------- u_counts, v_counts: list, np.array Vectors of counts/abundances of OTUs for two samples. Must be equal length. otu_ids: list, np.array Vector of OTU ids corresponding to tip names in ``tree``. Must be the same length as ``u_counts`` and ``v_counts``. tree: skbio.TreeNode Tree relating the OTUs in otu_ids. The set of tip names in the tree can be a superset of ``otu_ids``, but not a subset. normalized: boolean, optional If ``True``, apply branch length normalization, which is described in [1]_. Resulting distances will then be in the range ``[0, 1]``. validate: bool, optional If `False`, validation of the input won't be performed. This step can be slow, so if validation is run elsewhere it can be disabled here. However, invalid input data can lead to invalid results or error messages that are hard to interpret, so this step should not be bypassed if you're not certain that your input data are valid. See :mod:`skbio.diversity` for the description of what validation entails so you can determine if you can safely disable validation. Returns ------- float The weighted UniFrac distance between the two samples. Raises ------ ValueError, MissingNodeError, DuplicateNodeError If validation fails. Exact error will depend on what was invalid. See Also -------- unweighted_unifrac skbio.diversity skbio.diversity.beta_diversity Notes ----- Weighted UniFrac was originally described in [1]_, which includes a discussion of unweighted (qualitative) versus weighted (quantitiative) diversity metrics. Deeper mathemtical discussions of this metric is presented in [2]_. If computing weighted UniFrac for multiple pairs of samples, using ``skbio.diversity.beta_diversity`` will be much faster than calling this function individually on each sample. This implementation differs from that in PyCogent (and therefore QIIME versions less than 2.0.0) by imposing a few additional restrictions on the inputs. First, the input tree must be rooted. In PyCogent, if an unrooted tree was provided that had a single trifurcating node (a newick convention for unrooted trees) that node was considered the root of the tree. Next, all OTU IDs must be tips in the tree. PyCogent would silently ignore OTU IDs that were not present the tree. To reproduce UniFrac results from PyCogent with scikit-bio, ensure that your PyCogent UniFrac calculations are performed on a rooted tree and that all OTU IDs are present in the tree. This implementation of weighted UniFrac is the array-based implementation described in [3]_. If using large number of samples or a large tree, we advise using the optimized UniFrac library [4]_. References ---------- .. [1] Lozupone, C. A., Hamady, M., Kelley, S. T. & Knight, R. Quantitative and qualitative beta diversity measures lead to different insights into factors that structure microbial communities. Appl. Environ. Microbiol. 73, 1576-1585 (2007). .. [2] Lozupone, C., Lladser, M. E., Knights, D., Stombaugh, J. & Knight, R. UniFrac: an effective distance metric for microbial community comparison. ISME J. 5, 169-172 (2011). .. [3] Hamady M, Lozupone C, Knight R. Fast UniFrac: facilitating high- throughput phylogenetic analyses of microbial communities including analysis of pyrosequencing and PhyloChip data. ISME J. 4(1):17-27 (2010). .. [4] https://github.com/biocore/unifrac Examples -------- Assume we have the following abundance data for two samples, ``u`` and ``v``, represented as a pair of counts vectors. These counts represent the number of times specific Operational Taxonomic Units, or OTUs, were observed in each of the samples. >>> u_counts = [1, 0, 0, 4, 1, 2, 3, 0] >>> v_counts = [0, 1, 1, 6, 0, 1, 0, 0] Because UniFrac is a phylogenetic diversity metric, we need to know which OTU each count corresponds to, which we'll provide as ``otu_ids``. >>> otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5', 'OTU6', 'OTU7', ... 'OTU8'] We also need a phylogenetic tree that relates the OTUs to one another. >>> from io import StringIO >>> from skbio import TreeNode >>> tree = TreeNode.read(StringIO( ... '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,' ... '(OTU4:0.75,(OTU5:0.5,((OTU6:0.33,OTU7:0.62):0.5' ... ',OTU8:0.5):0.5):0.5):1.25):0.0)root;')) Compute the weighted UniFrac distance between the samples. >>> from skbio.diversity.beta import weighted_unifrac >>> wu = weighted_unifrac(u_counts, v_counts, otu_ids, tree) >>> print(round(wu, 2)) 1.54 Compute the weighted UniFrac distance between the samples including branch length normalization so the value falls in the range ``[0.0, 1.0]``. >>> wu = weighted_unifrac(u_counts, v_counts, otu_ids, tree, ... normalized=True) >>> print(round(wu, 2)) 0.33 """ u_node_counts, v_node_counts, u_total_count, v_total_count, tree_index =\ _setup_pairwise_unifrac(u_counts, v_counts, otu_ids, tree, validate, normalized=normalized, unweighted=False) branch_lengths = tree_index['length'] if normalized: tip_indices = _get_tip_indices(tree_index) node_to_root_distances = _tip_distances(branch_lengths, tree, tip_indices) return _weighted_unifrac_normalized(u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths, node_to_root_distances) else: return _weighted_unifrac(u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths)[0] def _validate(u_counts, v_counts, otu_ids, tree): _validate_counts_matrix([u_counts, v_counts], suppress_cast=True) _validate_otu_ids_and_tree(counts=u_counts, otu_ids=otu_ids, tree=tree) def _setup_pairwise_unifrac(u_counts, v_counts, otu_ids, tree, validate, normalized, unweighted): if validate: _validate(u_counts, v_counts, otu_ids, tree) # temporarily store u_counts and v_counts in a 2-D array as that's what # _vectorize_counts_and_tree takes u_counts = np.asarray(u_counts) v_counts = np.asarray(v_counts) counts = np.vstack([u_counts, v_counts]) counts_by_node, tree_index, branch_lengths = \ _vectorize_counts_and_tree(counts, otu_ids, tree) # unpack counts vectors for single pairwise UniFrac calculation u_node_counts = counts_by_node[0] v_node_counts = counts_by_node[1] u_total_count = u_counts.sum() v_total_count = v_counts.sum() return (u_node_counts, v_node_counts, u_total_count, v_total_count, tree_index) def _unweighted_unifrac(u_node_counts, v_node_counts, branch_lengths): """ Parameters ---------- u_node_counts, v_node_counts : np.array Vectors indicating presence (value greater than zero) and absence (value equal to zero) of nodes in two samples, `u` and `v`. Order is assumed to be the same as in `branch_lengths`. branch_lengths : np.array Vector of branch lengths of all nodes (tips and internal nodes) in postorder representation of their tree. Returns ------- float Unweighted UniFrac distance between samples. Notes ----- The count vectors passed here correspond to all nodes in the tree, not just the tips. """ unique_nodes = np.logical_xor(u_node_counts, v_node_counts) observed_nodes = np.logical_or(u_node_counts, v_node_counts) unique_branch_length = (branch_lengths * unique_nodes).sum() observed_branch_length = (branch_lengths * observed_nodes).sum() if observed_branch_length == 0.0: # handle special case to avoid division by zero return 0.0 return unique_branch_length / observed_branch_length def _weighted_unifrac(u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths): """ Parameters ---------- u_node_counts, v_node_counts : np.array Vectors indicating presence (value greater than zero) and absence (value equal to zero) of nodes in two samples, `u` and `v`. Order is assumed to be the same as in `branch_lengths`. u_total_count, v_total_counts : int The sum of ``u_node_counts`` and ``v_node_counts`` vectors, respectively. This could be computed internally, but since this is a private method and the calling function has already generated these values, this saves an iteration over each of these vectors. branch_lengths : np.array Vector of branch lengths of all nodes (tips and internal nodes) in postorder representation of their tree. Returns ------- float Weighted UniFrac distance between samples. np.array of float Proportional abundance of each node in tree in sample `u` np.array of float Proportional abundance of each node in tree in sample `v` """ if u_total_count > 0: # convert to relative abundances if there are any counts u_node_proportions = u_node_counts / u_total_count else: # otherwise, we'll just do the computation with u_node_counts, which # is necessarily all zeros u_node_proportions = u_node_counts if v_total_count > 0: v_node_proportions = v_node_counts / v_total_count else: v_node_proportions = v_node_counts wu = (branch_lengths * np.absolute(u_node_proportions - v_node_proportions)).sum() return wu, u_node_proportions, v_node_proportions def _weighted_unifrac_normalized(u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths, node_to_root_distances): """ Parameters ---------- u_node_counts, v_node_counts : np.array Vectors indicating presence (value greater than zero) and absence (value equal to zero) of nodes in two samples, `u` and `v`. Order is assumed to be the same as in `branch_lengths`. u_total_count, v_total_counts : int The sum of ``u_node_counts`` and ``v_node_counts`` vectors, respectively. This could be computed internally, but since this is a private method and the calling function has already generated these values, this saves an iteration over each of these vectors. tree: skbio.TreeNode Tree relating the OTUs. Returns ------- float Normalized weighted UniFrac distance between samples. Notes ----- The count vectors passed here correspond to all nodes in the tree, not just the tips. """ if u_total_count == 0.0 and v_total_count == 0.0: # handle special case to avoid division by zero return 0.0 u, u_node_proportions, v_node_proportions = _weighted_unifrac( u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths) c = _weighted_unifrac_branch_correction( node_to_root_distances, u_node_proportions, v_node_proportions) return u / c def _setup_multiple_unifrac(counts, otu_ids, tree, validate): if validate: _validate_otu_ids_and_tree(counts[0], otu_ids, tree) counts_by_node, tree_index, branch_lengths = \ _vectorize_counts_and_tree(counts, otu_ids, tree) return counts_by_node, tree_index, branch_lengths def _setup_multiple_unweighted_unifrac(counts, otu_ids, tree, validate): """ Create optimized pdist-compatible unweighted UniFrac function Parameters ---------- counts : 2D array_like of ints or floats Matrix containing count/abundance data where each row contains counts of observations in a given sample. otu_ids: list, np.array Vector of OTU ids corresponding to tip names in ``tree``. Must be the same length as ``u_counts`` and ``v_counts``. These IDs do not need to be in tip order with respect to the tree. tree: skbio.TreeNode Tree relating the OTUs in otu_ids. The set of tip names in the tree can be a superset of ``otu_ids``, but not a subset. validate: bool, optional If `False`, validation of the input won't be performed. Returns ------- function Optimized pairwise unweighted UniFrac calculator that can be passed to ``scipy.spatial.distance.pdist``. 2D np.array of ints, floats Counts of all nodes in ``tree``. """ counts_by_node, _, branch_lengths = \ _setup_multiple_unifrac(counts, otu_ids, tree, validate) f = functools.partial(_unweighted_unifrac, branch_lengths=branch_lengths) return f, counts_by_node def _setup_multiple_weighted_unifrac(counts, otu_ids, tree, normalized, validate): """ Create optimized pdist-compatible weighted UniFrac function Parameters ---------- counts : 2D array_like of ints or floats Matrix containing count/abundance data where each row contains counts of observations in a given sample. otu_ids: list, np.array Vector of OTU ids corresponding to tip names in ``tree``. Must be the same length as ``u_counts`` and ``v_counts``. These IDs do not need to be in tip order with respect to the tree. tree: skbio.TreeNode Tree relating the OTUs in otu_ids. The set of tip names in the tree can be a superset of ``otu_ids``, but not a subset. validate: bool, optional If `False`, validation of the input won't be performed. Returns ------- function Optimized pairwise unweighted UniFrac calculator that can be passed to ``scipy.spatial.distance.pdist``. 2D np.array of ints, floats Counts of all nodes in ``tree``. """ counts_by_node, tree_index, branch_lengths = \ _setup_multiple_unifrac(counts, otu_ids, tree, validate) tip_indices = _get_tip_indices(tree_index) if normalized: node_to_root_distances = _tip_distances(branch_lengths, tree, tip_indices) def f(u_node_counts, v_node_counts): u_total_count = np.take(u_node_counts, tip_indices).sum() v_total_count = np.take(v_node_counts, tip_indices).sum() u = _weighted_unifrac_normalized( u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths, node_to_root_distances) return u else: def f(u_node_counts, v_node_counts): u_total_count = np.take(u_node_counts, tip_indices).sum() v_total_count = np.take(v_node_counts, tip_indices).sum() u, _, _ = _weighted_unifrac(u_node_counts, v_node_counts, u_total_count, v_total_count, branch_lengths) return u return f, counts_by_node def _get_tip_indices(tree_index): tip_indices = np.array([n.id for n in tree_index['id_index'].values() if n.is_tip()]) return tip_indices def _weighted_unifrac_branch_correction(node_to_root_distances, u_node_proportions, v_node_proportions): """Calculates weighted unifrac branch length correction. Parameters ---------- node_to_root_distances : np.ndarray 1D column vector of branch lengths in post order form. There should be positions in this vector for all nodes in the tree, but only tips should be non-zero. u_node_proportions, v_node_proportions : np.ndarray Proportional abundace of observations of all nodes in the tree in samples ``u`` and ``v``, respectively. u_total_count, v_total_count : float The sum of the observations in samples ``u`` and ``v``, respectively. Returns ------- np.ndarray The corrected branch lengths """ return (node_to_root_distances.ravel() * (u_node_proportions + v_node_proportions)).sum() scikit-bio-0.5.9/skbio/diversity/beta/tests/000077500000000000000000000000001446255456000210035ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/beta/tests/__init__.py000066400000000000000000000005411446255456000231140ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/diversity/beta/tests/data/000077500000000000000000000000001446255456000217145ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/000077500000000000000000000000001446255456000237555ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/README.md000066400000000000000000000025701446255456000252400ustar00rootroot00000000000000Files in this directory are the QIIME 1.9.1 "tiny test" files. These data were developed by @gregcaporaso, who gave permission to reproduce them in scikit-bio. If you have a [QIIME 1.9.1 base installation](http://install.qiime.org), the raw input files in this directory can be obtained by running: ```bash python -c "from qiime.test import write_test_data; write_test_data('.')" biom convert -i biom --to-tsv -o otu-table.tsv ``` After converting to tsv, the following OTUs are removed because they are not present in the tree (they're not 16S sequences, so can't be aligned with PyNAST): ``None1``, ``None10``, ``None6``, and ``None2``. The ``not16S.1`` sample is also removed because, after removing those OTUs, it has a total count of 0. This boundary case is tested directly in the ``unifrac_*`` and ``faith_pd`` tests. Then, in the python interpreter, we midpoint root the tree (since this is a QIIME 1.9.1 installation, this step is performed with scikit-bio 0.2.3): ```python from skbio import TreeNode t = TreeNode.read('./tree') t = t.root_at_midpoint() t.write('tree', format='newick') ``` The output files (alpha diversity values and beta diversity distance matrices) can then be obtained by running: ```bash alpha_diversity.py -i biom -t tree -m PD_whole_tree -o pd.txt beta_diversity.py -m weighted_unifrac,unweighted_unifrac,weighted_normalized_unifrac -i biom -t tree -o o ``` scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/otu-table.tsv000066400000000000000000000004431446255456000264100ustar00rootroot00000000000000# Constructed from biom file #OTU ID f2 f1 f3 f4 p2 p1 t1 t2 295053 20 18 18 22 4 0 0 0 42684 0 0 0 0 1 0 0 0 None11 1 0 0 0 1 1 0 0 None7 0 0 0 0 1 0 0 0 None5 0 0 0 0 1 0 0 0 None4 0 0 0 0 1 1 0 0 None3 0 0 0 0 1 0 2 3 879972 0 0 0 0 9 20 1 4 None9 0 0 0 0 3 0 19 15 None8 1 4 4 0 0 0 0 0 scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/tree.nwk000066400000000000000000000004121446255456000254320ustar00rootroot00000000000000(((879972:0.05039,None3:0.00778)0.980:0.15948,((None11:0.07161,None4:0.06965)0.917:0.09643,(295053:0.06096,42684:0.15599)0.910:0.08898)0.899:0.09227)0.958:0.064315,(None8:0.09606,(None7:0.10435,(None5:0.02626,None9:0.00014)1.000:0.25335)0.753:0.0465):0.075445)root; scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/unweighted_unifrac_dm.txt000066400000000000000000000016661446255456000310610ustar00rootroot00000000000000 f2 f1 f3 f4 p2 p1 t1 not16S.1 t2 f2 0.0 0.26009565527 0.26009565527 0.525554506478 0.638141793205 0.649277757971 0.879901349993 1.0 0.879901349993 f1 0.26009565527 0.0 0.0 0.358774553898 0.74869733414 0.830826823972 0.859632207458 1.0 0.859632207458 f3 0.26009565527 0.0 0.0 0.358774553898 0.74869733414 0.830826823972 0.859632207458 1.0 0.859632207458 f4 0.525554506478 0.358774553898 0.358774553898 0.0 0.784728562399 0.792350994914 0.928507908983 1.0 0.928507908983 p2 0.638141793205 0.74869733414 0.74869733414 0.784728562399 0.0 0.575711075216 0.538310274598 1.0 0.538310274598 p1 0.649277757971 0.830826823972 0.830826823972 0.792350994914 0.575711075216 0.0 0.72230493437 1.0 0.72230493437 t1 0.879901349993 0.859632207458 0.859632207458 0.928507908983 0.538310274598 0.72230493437 0.0 1.0 0.0 not16S.1 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 1.0 t2 0.879901349993 0.859632207458 0.859632207458 0.928507908983 0.538310274598 0.72230493437 0.0 1.0 0.0scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/weighted_normalized_unifrac_dm.txt000066400000000000000000000017261446255456000327370ustar00rootroot00000000000000 f2 f1 f3 f4 p2 p1 t1 not16S.1 t2 f2 0.0 0.113186179375 0.113186179375 0.0595362216515 0.599928715677 0.732991733568 0.962973616339 1.0 0.925172353416 f1 0.113186179375 0.0 0.0 0.14768803941 0.577821666109 0.782364205648 0.929696953333 1.0 0.889628707676 f3 0.113186179375 0.0 0.0 0.14768803941 0.577821666109 0.782364205648 0.929696953333 1.0 0.889628707676 f4 0.0595362216515 0.14768803941 0.14768803941 0.0 0.639547977307 0.751529763393 0.973594769453 1.0 0.936441078767 p2 0.599928715677 0.577821666109 0.577821666109 0.639547977307 0.0 0.430712953163 0.677634129601 1.0 0.519557525688 p1 0.732991733568 0.782364205648 0.782364205648 0.751529763393 0.430712953163 0.0 0.896900994816 1.0 0.739098773939 t1 0.962973616339 0.929696953333 0.929696953333 0.973594769453 0.677634129601 0.896900994816 0.0 1.0 0.167120342575 not16S.1 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 1.0 t2 0.925172353416 0.889628707676 0.889628707676 0.936441078767 0.519557525688 0.739098773939 0.167120342575 1.0 0.0scikit-bio-0.5.9/skbio/diversity/beta/tests/data/qiime-191-tt/weighted_unifrac_dm.txt000066400000000000000000000016661446255456000305160ustar00rootroot00000000000000 f2 f1 f3 f4 p2 p1 t1 not16S.1 t2 f2 0.0 0.0660086363636 0.0660086363636 0.0361822727273 0.364183181818 0.425055909091 0.634565909091 1.0 0.590832727273 f1 0.0660086363636 0.0 0.0 0.0869145454545 0.339649090909 0.438638181818 0.594755454545 1.0 0.551022272727 f3 0.0660086363636 0.0 0.0 0.0869145454545 0.339649090909 0.438638181818 0.594755454545 1.0 0.551022272727 f4 0.0361822727273 0.0869145454545 0.0869145454545 0.0 0.391632727273 0.4398 0.646739090909 1.0 0.603005909091 p2 0.364183181818 0.339649090909 0.339649090909 0.391632727273 0.0 0.251758181818 0.44967 1.0 0.334201363636 p1 0.425055909091 0.438638181818 0.438638181818 0.4398 0.251758181818 0.0 0.57082 1.0 0.455351363636 t1 0.634565909091 0.594755454545 0.594755454545 0.646739090909 0.44967 0.57082 0.0 1.0 0.116175909091 not16S.1 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 1.0 t2 0.590832727273 0.551022272727 0.551022272727 0.603005909091 0.334201363636 0.455351363636 0.116175909091 1.0 0.0scikit-bio-0.5.9/skbio/diversity/beta/tests/test_unifrac.py000066400000000000000000000722701446255456000240530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from io import StringIO from unittest import main, TestCase import numpy as np from skbio import TreeNode from skbio.tree import DuplicateNodeError, MissingNodeError from skbio.diversity.beta import unweighted_unifrac, weighted_unifrac from skbio.diversity.beta._unifrac import (_unweighted_unifrac, _weighted_unifrac, _weighted_unifrac_branch_correction) class UnifracTests(TestCase): def setUp(self): self.b1 = np.array( [[1, 3, 0, 1, 0], [0, 2, 0, 4, 4], [0, 0, 6, 2, 1], [0, 0, 1, 1, 1], [5, 3, 5, 0, 0], [0, 0, 0, 3, 5]]) self.sids1 = list('ABCDEF') self.oids1 = ['OTU%d' % i for i in range(1, 6)] self.t1 = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) self.t1_w_extra_tips = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,(OTU5:0.25,(OTU6:0.5,OTU7:0.5):0.5):0.5):1.25):0.0' ')root;')) self.t2 = TreeNode.read( StringIO('((OTU1:0.1, OTU2:0.2):0.3, (OTU3:0.5, OTU4:0.7):1.1)' 'root;')) self.oids2 = ['OTU%d' % i for i in range(1, 5)] def test_unweighted_otus_out_of_order(self): # UniFrac API does not assert the observations are in tip order of the # input tree shuffled_ids = self.oids1[:] shuffled_b1 = self.b1.copy() shuffled_ids[0], shuffled_ids[-1] = shuffled_ids[-1], shuffled_ids[0] shuffled_b1[:, [0, -1]] = shuffled_b1[:, [-1, 0]] for i in range(len(self.b1)): for j in range(len(self.b1)): actual = unweighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) expected = unweighted_unifrac( shuffled_b1[i], shuffled_b1[j], shuffled_ids, self.t1) self.assertAlmostEqual(actual, expected) def test_weighted_otus_out_of_order(self): # UniFrac API does not assert the observations are in tip order of the # input tree shuffled_ids = self.oids1[:] shuffled_b1 = self.b1.copy() shuffled_ids[0], shuffled_ids[-1] = shuffled_ids[-1], shuffled_ids[0] shuffled_b1[:, [0, -1]] = shuffled_b1[:, [-1, 0]] for i in range(len(self.b1)): for j in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) expected = weighted_unifrac( shuffled_b1[i], shuffled_b1[j], shuffled_ids, self.t1) self.assertAlmostEqual(actual, expected) def test_unweighted_extra_tips(self): # UniFrac values are the same despite unobserved tips in the tree for i in range(len(self.b1)): for j in range(len(self.b1)): actual = unweighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1_w_extra_tips) expected = unweighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) def test_weighted_extra_tips(self): # UniFrac values are the same despite unobserved tips in the tree for i in range(len(self.b1)): for j in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1_w_extra_tips) expected = weighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) def test_unweighted_minimal_trees(self): # two tips tree = TreeNode.read(StringIO('(OTU1:0.25, OTU2:0.25)root;')) actual = unweighted_unifrac([1, 0], [0, 0], ['OTU1', 'OTU2'], tree) expected = 1.0 self.assertEqual(actual, expected) def test_weighted_minimal_trees(self): # two tips tree = TreeNode.read(StringIO('(OTU1:0.25, OTU2:0.25)root;')) actual = weighted_unifrac([1, 0], [0, 0], ['OTU1', 'OTU2'], tree) expected = 0.25 self.assertEqual(actual, expected) def test_unweighted_root_not_observed(self): # expected values computed with QIIME 1.9.1 and by hand # root node not observed, but branch between (OTU1, OTU2) and root # is considered shared actual = unweighted_unifrac([1, 1, 0, 0], [1, 0, 0, 0], self.oids2, self.t2) # for clarity of what I'm testing, compute expected as it would # based on the branch lengths. the values that compose shared was # a point of confusion for me here, so leaving these in for # future reference expected = 0.2 / (0.1 + 0.2 + 0.3) # 0.3333333333 self.assertAlmostEqual(actual, expected) # root node not observed, but branch between (OTU3, OTU4) and root # is considered shared actual = unweighted_unifrac([0, 0, 1, 1], [0, 0, 1, 0], self.oids2, self.t2) # for clarity of what I'm testing, compute expected as it would # based on the branch lengths. the values that compose shared was # a point of confusion for me here, so leaving these in for # future reference expected = 0.7 / (1.1 + 0.5 + 0.7) # 0.3043478261 self.assertAlmostEqual(actual, expected) def test_weighted_root_not_observed(self): # expected values computed by hand, these disagree with QIIME 1.9.1 # root node not observed, but branch between (OTU1, OTU2) and root # is considered shared actual = weighted_unifrac([1, 0, 0, 0], [1, 1, 0, 0], self.oids2, self.t2) expected = 0.15 self.assertAlmostEqual(actual, expected) # root node not observed, but branch between (OTU3, OTU4) and root # is considered shared actual = weighted_unifrac([0, 0, 1, 1], [0, 0, 1, 0], self.oids2, self.t2) expected = 0.6 self.assertAlmostEqual(actual, expected) def test_weighted_normalized_root_not_observed(self): # expected values computed by hand, these disagree with QIIME 1.9.1 # root node not observed, but branch between (OTU1, OTU2) and root # is considered shared actual = weighted_unifrac([1, 0, 0, 0], [1, 1, 0, 0], self.oids2, self.t2, normalized=True) expected = 0.1764705882 self.assertAlmostEqual(actual, expected) # root node not observed, but branch between (OTU3, OTU4) and root # is considered shared actual = weighted_unifrac([0, 0, 1, 1], [0, 0, 1, 0], self.oids2, self.t2, normalized=True) expected = 0.1818181818 self.assertAlmostEqual(actual, expected) def test_unweighted_unifrac_identity(self): for i in range(len(self.b1)): actual = unweighted_unifrac( self.b1[i], self.b1[i], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_unweighted_unifrac_symmetry(self): for i in range(len(self.b1)): for j in range(len(self.b1)): actual = unweighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) expected = unweighted_unifrac( self.b1[j], self.b1[i], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) def test_invalid_input(self): # Many of these tests are duplicated from # skbio.diversity.tests.test_base, but I think it's important to # confirm that they are being run when *unifrac is called. # tree has duplicated tip ids t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(DuplicateNodeError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(DuplicateNodeError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # unrooted tree as input t = TreeNode.read(StringIO('((OTU1:0.1, OTU2:0.2):0.3, OTU3:0.5,' 'OTU4:0.7);')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # otu_ids has duplicated ids t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU2'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # len of vectors not equal t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) u_counts = [1, 2] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) u_counts = [1, 2, 3] v_counts = [1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # negative counts t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) u_counts = [1, 2, -3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) u_counts = [1, 2, 3] v_counts = [1, 1, -1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # tree with no branch lengths t = TreeNode.read( StringIO('((((OTU1,OTU2),OTU3)),(OTU4,OTU5));')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # tree missing some branch lengths t = TreeNode.read( StringIO('(((((OTU1,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(ValueError, weighted_unifrac, u_counts, v_counts, otu_ids, t) # otu_ids not present in tree t = TreeNode.read( StringIO('(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) u_counts = [1, 2, 3] v_counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU42'] self.assertRaises(MissingNodeError, unweighted_unifrac, u_counts, v_counts, otu_ids, t) self.assertRaises(MissingNodeError, weighted_unifrac, u_counts, v_counts, otu_ids, t) def test_unweighted_unifrac_non_overlapping(self): # these communities only share the root node actual = unweighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1) expected = 1.0 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( [1, 1, 1, 0, 0], [0, 0, 0, 1, 1], self.oids1, self.t1) expected = 1.0 self.assertAlmostEqual(actual, expected) def test_unweighted_unifrac_zero_counts(self): actual = unweighted_unifrac( [1, 1, 1, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1) expected = 1.0 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( [], [], [], self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_unweighted_unifrac(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # unweighted unifrac implementation # sample A versus all actual = unweighted_unifrac( self.b1[0], self.b1[1], self.oids1, self.t1) expected = 0.238095238095 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[0], self.b1[2], self.oids1, self.t1) expected = 0.52 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[0], self.b1[3], self.oids1, self.t1) expected = 0.52 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[0], self.b1[4], self.oids1, self.t1) expected = 0.545454545455 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[0], self.b1[5], self.oids1, self.t1) expected = 0.619047619048 self.assertAlmostEqual(actual, expected) # sample B versus remaining actual = unweighted_unifrac( self.b1[1], self.b1[2], self.oids1, self.t1) expected = 0.347826086957 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[1], self.b1[3], self.oids1, self.t1) expected = 0.347826086957 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[1], self.b1[4], self.oids1, self.t1) expected = 0.68 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[1], self.b1[5], self.oids1, self.t1) expected = 0.421052631579 self.assertAlmostEqual(actual, expected) # sample C versus remaining actual = unweighted_unifrac( self.b1[2], self.b1[3], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[2], self.b1[4], self.oids1, self.t1) expected = 0.68 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[2], self.b1[5], self.oids1, self.t1) expected = 0.421052631579 self.assertAlmostEqual(actual, expected) # sample D versus remaining actual = unweighted_unifrac( self.b1[3], self.b1[4], self.oids1, self.t1) expected = 0.68 self.assertAlmostEqual(actual, expected) actual = unweighted_unifrac( self.b1[3], self.b1[5], self.oids1, self.t1) expected = 0.421052631579 self.assertAlmostEqual(actual, expected) # sample E versus remaining actual = unweighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1) expected = 1.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_identity(self): for i in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[i], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_symmetry(self): for i in range(len(self.b1)): for j in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1) expected = weighted_unifrac( self.b1[j], self.b1[i], self.oids1, self.t1) self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_non_overlapping(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # weighted unifrac implementation # these communities only share the root node actual = weighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1) expected = 4.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_zero_counts(self): actual = weighted_unifrac( [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) # calculated the following by hand, as QIIME 1.9.1 tells the user # that values involving empty vectors will be uninformative, and # returns 1.0 actual = weighted_unifrac( [1, 1, 1, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1) expected = 2.0 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( [], [], [], self.t1) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # weighted unifrac implementation actual = weighted_unifrac( self.b1[0], self.b1[1], self.oids1, self.t1) expected = 2.4 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[2], self.oids1, self.t1) expected = 1.86666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[3], self.oids1, self.t1) expected = 2.53333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[4], self.oids1, self.t1) expected = 1.35384615385 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[5], self.oids1, self.t1) expected = 3.2 self.assertAlmostEqual(actual, expected) # sample B versus remaining actual = weighted_unifrac( self.b1[1], self.b1[2], self.oids1, self.t1) expected = 2.26666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[3], self.oids1, self.t1) expected = 0.933333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[4], self.oids1, self.t1) expected = 3.2 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[5], self.oids1, self.t1) expected = 0.8375 self.assertAlmostEqual(actual, expected) # sample C versus remaining actual = weighted_unifrac( self.b1[2], self.b1[3], self.oids1, self.t1) expected = 1.33333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[2], self.b1[4], self.oids1, self.t1) expected = 1.89743589744 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[2], self.b1[5], self.oids1, self.t1) expected = 2.66666666667 self.assertAlmostEqual(actual, expected) # sample D versus remaining actual = weighted_unifrac( self.b1[3], self.b1[4], self.oids1, self.t1) expected = 2.66666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[3], self.b1[5], self.oids1, self.t1) expected = 1.33333333333 self.assertAlmostEqual(actual, expected) # sample E versus remaining actual = weighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1) expected = 4.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_identity_normalized(self): for i in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[i], self.oids1, self.t1, normalized=True) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_symmetry_normalized(self): for i in range(len(self.b1)): for j in range(len(self.b1)): actual = weighted_unifrac( self.b1[i], self.b1[j], self.oids1, self.t1, normalized=True) expected = weighted_unifrac( self.b1[j], self.b1[i], self.oids1, self.t1, normalized=True) self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_non_overlapping_normalized(self): # these communities only share the root node actual = weighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1, normalized=True) expected = 1.0 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( [1, 1, 1, 0, 0], [0, 0, 0, 1, 1], self.oids1, self.t1, normalized=True) expected = 1.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_zero_counts_normalized(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # weighted unifrac implementation actual = weighted_unifrac( [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1, normalized=True) expected = 0.0 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( [1, 1, 1, 0, 0], [0, 0, 0, 0, 0], self.oids1, self.t1, normalized=True) expected = 1.0 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( [], [], [], self.t1, normalized=True) expected = 0.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_normalized(self): # expected results derived from QIIME 1.9.1, which # is a completely different implementation skbio's initial # weighted unifrac implementation actual = weighted_unifrac( self.b1[0], self.b1[1], self.oids1, self.t1, normalized=True) expected = 0.6 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[2], self.oids1, self.t1, normalized=True) expected = 0.466666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[3], self.oids1, self.t1, normalized=True) expected = 0.633333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[4], self.oids1, self.t1, normalized=True) expected = 0.338461538462 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[0], self.b1[5], self.oids1, self.t1, normalized=True) expected = 0.8 self.assertAlmostEqual(actual, expected) # sample B versus remaining actual = weighted_unifrac( self.b1[1], self.b1[2], self.oids1, self.t1, normalized=True) expected = 0.566666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[3], self.oids1, self.t1, normalized=True) expected = 0.233333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[4], self.oids1, self.t1, normalized=True) expected = 0.8 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[1], self.b1[5], self.oids1, self.t1, normalized=True) expected = 0.209375 self.assertAlmostEqual(actual, expected) # sample C versus remaining actual = weighted_unifrac( self.b1[2], self.b1[3], self.oids1, self.t1, normalized=True) expected = 0.333333333333 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[2], self.b1[4], self.oids1, self.t1, normalized=True) expected = 0.474358974359 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[2], self.b1[5], self.oids1, self.t1, normalized=True) expected = 0.666666666667 self.assertAlmostEqual(actual, expected) # sample D versus remaining actual = weighted_unifrac( self.b1[3], self.b1[4], self.oids1, self.t1, normalized=True) expected = 0.666666666667 self.assertAlmostEqual(actual, expected) actual = weighted_unifrac( self.b1[3], self.b1[5], self.oids1, self.t1, normalized=True) expected = 0.333333333333 self.assertAlmostEqual(actual, expected) # sample E versus remaining actual = weighted_unifrac( self.b1[4], self.b1[5], self.oids1, self.t1, normalized=True) expected = 1.0 self.assertAlmostEqual(actual, expected) def test_weighted_unifrac_branch_correction(self): # for ((a:1, b:2)c:3,(d:4,e:5)f:6)root;" tip_ds = np.array([4, 5, 10, 11, 0, 0, 0])[:, np.newaxis] u_counts = np.array([1, 1, 0, 0, 2, 0, 2]) v_counts = np.array([0, 2, 1, 0, 2, 1, 3]) u_sum = 2 # counts at the tips v_sum = 3 exp = np.array([2.0, 5.0 * (.5 + (2.0/3.0)), 10.0 * (1.0 / 3.0), 0.0]).sum() obs = _weighted_unifrac_branch_correction( tip_ds, u_counts/u_sum, v_counts/v_sum) self.assertEqual(obs, exp) def test_unweighted_unifrac_pycogent_adapted(self): # adapted from PyCogent unit tests m = np.array([[1, 0, 1], [1, 1, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 1, 1], [0, 1, 1], [1, 1, 1]]) # lengths from ((a:1,b:2):4,(c:3,(d:1,e:1):2):3) bl = np.array([1, 2, 1, 1, 3, 2, 4, 3, 0], dtype=float) self.assertEqual(_unweighted_unifrac(m[:, 0], m[:, 1], bl), 10/16.0) self.assertEqual(_unweighted_unifrac(m[:, 0], m[:, 2], bl), 8/13.0) self.assertEqual(_unweighted_unifrac(m[:, 1], m[:, 2], bl), 8/17.0) def test_weighted_unifrac_pycogent_adapted(self): # lengths from ((a:1,b:2):4,(c:3,(d:1,e:1):2):3) bl = np.array([1, 2, 1, 1, 3, 2, 4, 3, 0], dtype=float) # adapted from PyCogent unit tests m = np.array([[1, 0, 1], # a [1, 1, 0], # b [0, 1, 0], # d [0, 0, 1], # e [0, 1, 0], # c [0, 1, 1], # parent of (d, e) [2, 1, 1], # parent of a, b [0, 2, 1], # parent of c (d, e) [2, 3, 2]]) # root # sum just the counts at the tips m0s = m[:5, 0].sum() m1s = m[:5, 1].sum() m2s = m[:5, 2].sum() # scores computed by educational implementation self.assertAlmostEqual( _weighted_unifrac(m[:, 0], m[:, 1], m0s, m1s, bl)[0], 7.5) self.assertAlmostEqual( _weighted_unifrac(m[:, 0], m[:, 2], m0s, m2s, bl)[0], 6.0) self.assertAlmostEqual( _weighted_unifrac(m[:, 1], m[:, 2], m1s, m2s, bl)[0], 4.5) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/diversity/tests/000077500000000000000000000000001446255456000200705ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/diversity/tests/__init__.py000066400000000000000000000005411446255456000222010ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/diversity/tests/test_block.py000066400000000000000000000202461446255456000225770ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt from skbio import TreeNode, DistanceMatrix from skbio.diversity import beta_diversity, block_beta_diversity from skbio.diversity._block import (_block_party, _generate_id_blocks, _pairs_to_compute, _block_compute, _block_kwargs, _map, _reduce) class ParallelBetaDiversity(TestCase): def setUp(self): self.table1 = [[1, 5], [2, 3], [0, 1]] self.sids1 = list('ABC') self.tree1 = TreeNode.read([ '((O1:0.25, O2:0.50):0.25, O3:0.75)root;']) self.oids1 = ['O1', 'O2'] def test_block_kwargs(self): kws = {'ids': [1, 2, 3, 4, 5], 'foo': 'bar', 'k': 2} exp = [{'row_ids': np.array((0, 1)), 'col_ids': np.array((0, 1)), 'id_pairs': [(0, 1)], 'ids': [1, 2, 3, 4, 5]}, {'row_ids': np.array((0, 1)), 'col_ids': np.array((2, 3)), 'id_pairs': [(0, 2), (0, 3), (1, 2), (1, 3)], 'ids': [1, 2, 3, 4, 5]}, {'row_ids': np.array((0, 1)), 'col_ids': np.array((4,)), 'id_pairs': [(0, 4), (1, 4)], 'ids': [1, 2, 3, 4, 5]}, {'row_ids': np.array((2, 3)), 'col_ids': np.array((2, 3)), 'id_pairs': [(2, 3), ], 'ids': [1, 2, 3, 4, 5]}, {'row_ids': np.array((2, 3)), 'col_ids': np.array((4,)), 'id_pairs': [(2, 4), (3, 4)], 'ids': [1, 2, 3, 4, 5]}] obs = list(_block_kwargs(**kws)) npt.assert_equal(obs, exp) def test_block_compute(self): def mock_metric(u, v): return (u + v).sum() counts = np.array([[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 0], [2, 3, 4, 5, 0, 1], [10, 2, 3, 6, 8, 2], [9, 9, 2, 2, 3, 4]]) kwargs = {'metric': mock_metric, 'counts': counts, 'row_ids': np.array((2, 3)), 'col_ids': np.array((4, )), 'id_pairs': [(2, 4), (3, 4)], 'ids': [1, 2, 3, 4, 5]} exp = DistanceMatrix(np.array([[0, 0, 44], [0, 0, 60], [44, 60, 0]]), (2, 3, 4)) obs = _block_compute(**kwargs) npt.assert_equal(obs.data, exp.data) self.assertEqual(obs.ids, exp.ids) def test_map(self): def func(a, b, c=5): return a + b + c kwargs = [{'a': 0, 'b': 1, 'c': 0}, {'a': 2, 'b': 3}] exp = [1, 10] obs = list(_map(func, kwargs)) self.assertEqual(obs, exp) def test_reduce(self): dm1 = DistanceMatrix(np.array([[0, 0, 44], [0, 0, 60], [44, 60, 0]]), (2, 3, 4)) dm2 = DistanceMatrix(np.array([[0, 123], [123, 0]]), (1, 5)) dm3 = DistanceMatrix(np.array([[0, 1, 2, 3], [1, 0, 4, 5], [2, 4, 0, 6], [3, 5, 6, 0]]), (0, 3, 4, 5)) exp = DistanceMatrix(np.array([[0, 0, 0, 1, 2, 3], [0, 0, 0, 0, 0, 123], [0, 0, 0, 0, 44, 0], [1, 0, 0, 0, 64, 5], [2, 0, 44, 64, 0, 6], [3, 123, 0, 5, 6, 0]]), list(range(6))) obs = _reduce([dm1, dm2, dm3]) npt.assert_equal(obs.data, exp.data) self.assertEqual(obs.ids, exp.ids) def test_block_beta_diversity(self): exp = beta_diversity('unweighted_unifrac', self.table1, self.sids1, tree=self.tree1, otu_ids=self.oids1) obs = block_beta_diversity('unweighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, k=2) npt.assert_equal(obs.data, exp.data) self.assertEqual(obs.ids, exp.ids) def test_generate_id_blocks(self): ids = [1, 2, 3, 4, 5] exp = [(np.array((0, 1)), np.array((0, 1))), (np.array((0, 1)), np.array((2, 3))), (np.array((0, 1)), np.array((4,))), (np.array((2, 3)), np.array((2, 3))), (np.array((2, 3)), np.array((4,))), (np.array((4,)), np.array((4,)))] obs = list(_generate_id_blocks(ids, 2)) npt.assert_equal(obs, exp) def test_block_party_notree(self): counts = np.arange(15).reshape(5, 3) exp = [{'counts': np.array([[0, 1, 2], [3, 4, 5]]), 'ids': np.array([0, 1])}, {'counts': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]), 'ids': np.array([0, 1, 2, 3])}, {'counts': np.array([[0, 1, 2], [3, 4, 5], [12, 13, 14]]), 'ids': np.array([0, 1, 4])}, {'counts': np.array([[6, 7, 8], [9, 10, 11]]), 'ids': np.array([2, 3])}, {'counts': np.array([[6, 7, 8], [9, 10, 11], [12, 13, 14]]), 'ids': np.array([2, 3, 4])}, {'counts': np.array([[12, 13, 14]]), 'ids': np.array([4])}] obs = [_block_party(counts, rids, cids) for rids, cids in _generate_id_blocks(list(range(5)), 2)] npt.assert_equal(obs, exp) def test_block_party_tree(self): counts = np.array([[1, 1, 1], [1, 0, 1], [1, 0, 1], [0, 0, 1], [0, 1, 1]]) tree = TreeNode.read(['(a:1,b:2,c:3);']) otu_ids = ['a', 'b', 'c'] kw = {'tree': tree, 'otu_ids': otu_ids} kw_no_a = {'tree': tree.shear(['b', 'c']), 'otu_ids': ['b', 'c']} kw_no_b = {'tree': tree.shear(['a', 'c']), 'otu_ids': ['a', 'c']} # python >= 3.5 supports {foo: bar, **baz} exp = [dict(counts=np.array([[1, 1, 1], [1, 0, 1]]), **kw), dict(counts=np.array([[1, 1, 1], [1, 0, 1], [1, 0, 1], [0, 0, 1]]), **kw), dict(counts=np.array([[1, 1, 1], [1, 0, 1], [0, 1, 1]]), **kw), dict(counts=np.array([[1, 1], [0, 1]]), **kw_no_b), dict(counts=np.array([[1, 0, 1], [0, 0, 1], [0, 1, 1]]), **kw), dict(counts=np.array([[1, 1]]), **kw_no_a)] obs = [_block_party(counts, rids, cids, **kw) for rids, cids in _generate_id_blocks(list(range(5)), 2)] for okw, ekw in zip(obs, exp): npt.assert_equal(okw['counts'], ekw['counts']) npt.assert_equal(okw['otu_ids'], ekw['otu_ids']) self.assertEqual(str(okw['tree']), str(ekw['tree'])) def test_pairs_to_compute_rids_are_cids(self): rids = np.array([0, 1, 2, 10]) cids = rids exp = [(0, 1), (0, 2), (0, 10), (1, 2), (1, 10), (2, 10)] self.assertEqual(_pairs_to_compute(rids, cids), exp) def test_pairs_to_compute_rids_are_not_cids(self): rids = np.array([0, 1, 2]) cids = np.array([3, 4, 5]) exp = [(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)] self.assertEqual(_pairs_to_compute(rids, cids), exp) def test_pairs_to_compute_rids_overlap_cids(self): rids = np.array([0, 1, 2]) cids = np.array([0, 10, 20]) with self.assertRaises(ValueError): _pairs_to_compute(rids, cids) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/diversity/tests/test_driver.py000066400000000000000000001103351446255456000227770ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import pandas as pd import numpy as np import numpy.testing as npt from skbio import DistanceMatrix, TreeNode from skbio.util._testing import assert_series_almost_equal from skbio.diversity import (alpha_diversity, beta_diversity, partial_beta_diversity, get_alpha_diversity_metrics, get_beta_diversity_metrics) from skbio.diversity.alpha import faith_pd, observed_otus from skbio.diversity.beta import unweighted_unifrac, weighted_unifrac from skbio.tree import DuplicateNodeError, MissingNodeError from skbio.diversity._driver import (_qualitative_beta_metrics, _valid_beta_metrics) class AlphaDiversityTests(TestCase): def setUp(self): self.table1 = np.array([[1, 3, 0, 1, 0], [0, 2, 0, 4, 4], [0, 0, 6, 2, 1], [0, 0, 1, 1, 1]]) self.sids1 = list('ABCD') self.oids1 = ['OTU%d' % i for i in range(1, 6)] self.tree1 = TreeNode.read(io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):' '0.0,(OTU4:0.75,OTU5:0.75):1.25):0.0)root;')) self.table2 = np.array([[1, 3], [0, 2], [0, 0]]) self.sids2 = list('xyz') self.oids2 = ['OTU1', 'OTU5'] self.tree2 = TreeNode.read(io.StringIO( '(((((OTU1:42.5,OTU2:0.5):0.5,OTU3:1.0):1.0):' '0.0,(OTU4:0.75,OTU5:0.0001):1.25):0.0)root;')) def test_invalid_input(self): # number of ids doesn't match the number of samples self.assertRaises(ValueError, alpha_diversity, 'observed_otus', self.table1, list('ABC')) # unknown metric provided self.assertRaises(ValueError, alpha_diversity, 'not-a-metric', self.table1) # 3-D list provided as input self.assertRaises(ValueError, alpha_diversity, 'observed_otus', [[[43]]]) # negative counts self.assertRaises(ValueError, alpha_diversity, 'observed_otus', [0, 3, -12, 42]) # additional kwargs self.assertRaises(TypeError, alpha_diversity, 'observed_otus', [0, 1], not_a_real_kwarg=42.0) self.assertRaises(TypeError, alpha_diversity, 'faith_pd', [0, 1], tree=self.tree1, otu_ids=['OTU1', 'OTU2'], not_a_real_kwarg=42.0) self.assertRaises(TypeError, alpha_diversity, faith_pd, [0, 1], tree=self.tree1, otu_ids=['OTU1', 'OTU2'], not_a_real_kwarg=42.0) def test_invalid_input_phylogenetic(self): # otu_ids not provided self.assertRaises(ValueError, alpha_diversity, 'faith_pd', self.table1, list('ABC'), tree=self.tree1) # tree not provided self.assertRaises(ValueError, alpha_diversity, 'faith_pd', self.table1, list('ABC'), otu_ids=self.oids1) # tree has duplicated tip ids t = TreeNode.read( io.StringIO( '(((((OTU2:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(DuplicateNodeError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # unrooted tree as input t = TreeNode.read(io.StringIO( '((OTU1:0.1, OTU2:0.2):0.3, OTU3:0.5,OTU4:0.7);')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # otu_ids has duplicated ids t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU2'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # count and OTU vectors are not equal length t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # tree with no branch lengths t = TreeNode.read( io.StringIO('((((OTU1,OTU2),OTU3)),(OTU4,OTU5));')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # tree missing some branch lengths t = TreeNode.read( io.StringIO('(((((OTU1,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) # some otu_ids not present in tree t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU42'] self.assertRaises(MissingNodeError, alpha_diversity, 'faith_pd', counts, otu_ids=otu_ids, tree=t) def test_empty(self): # empty vector actual = alpha_diversity('observed_otus', np.array([], dtype=np.int64)) expected = pd.Series([0]) assert_series_almost_equal(actual, expected) # array of empty vector actual = alpha_diversity('observed_otus', np.array([[]], dtype=np.int64)) expected = pd.Series([0]) assert_series_almost_equal(actual, expected) # array of empty vectors actual = alpha_diversity('observed_otus', np.array([[], []], dtype=np.int64)) expected = pd.Series([0, 0]) assert_series_almost_equal(actual, expected) # empty vector actual = alpha_diversity('faith_pd', np.array([], dtype=np.int64), tree=self.tree1, otu_ids=[]) expected = pd.Series([0.]) assert_series_almost_equal(actual, expected) # array of empty vector actual = alpha_diversity('faith_pd', np.array([[]], dtype=np.int64), tree=self.tree1, otu_ids=[]) expected = pd.Series([0.]) assert_series_almost_equal(actual, expected) # array of empty vectors actual = alpha_diversity('faith_pd', np.array([[], []], dtype=np.int64), tree=self.tree1, otu_ids=[]) expected = pd.Series([0., 0.]) assert_series_almost_equal(actual, expected) def test_single_count_vector(self): actual = alpha_diversity('observed_otus', np.array([1, 0, 2])) expected = pd.Series([2]) assert_series_almost_equal(actual, expected) actual = alpha_diversity('faith_pd', np.array([1, 3, 0, 1, 0]), tree=self.tree1, otu_ids=self.oids1) self.assertAlmostEqual(actual[0], 4.5) def test_input_types(self): list_result = alpha_diversity('observed_otus', [1, 3, 0, 1, 0]) array_result = alpha_diversity('observed_otus', np.array([1, 3, 0, 1, 0])) self.assertAlmostEqual(list_result[0], 3) assert_series_almost_equal(list_result, array_result) list_result = alpha_diversity('faith_pd', [1, 3, 0, 1, 0], tree=self.tree1, otu_ids=self.oids1) array_result = alpha_diversity('faith_pd', np.array([1, 3, 0, 1, 0]), tree=self.tree1, otu_ids=self.oids1) self.assertAlmostEqual(list_result[0], 4.5) assert_series_almost_equal(list_result, array_result) def test_observed_otus(self): # expected values hand-calculated expected = pd.Series([3, 3, 3, 3], index=self.sids1) actual = alpha_diversity('observed_otus', self.table1, self.sids1) assert_series_almost_equal(actual, expected) # function passed instead of string actual = alpha_diversity(observed_otus, self.table1, self.sids1) assert_series_almost_equal(actual, expected) # alt input table expected = pd.Series([2, 1, 0], index=self.sids2) actual = alpha_diversity('observed_otus', self.table2, self.sids2) assert_series_almost_equal(actual, expected) def test_faith_pd(self): # calling faith_pd through alpha_diversity gives same results as # calling it directly expected = [] for e in self.table1: expected.append(faith_pd(e, tree=self.tree1, otu_ids=self.oids1)) expected = pd.Series(expected) actual = alpha_diversity('faith_pd', self.table1, tree=self.tree1, otu_ids=self.oids1) assert_series_almost_equal(actual, expected) # alt input table and tree expected = [] for e in self.table2: expected.append(faith_pd(e, tree=self.tree2, otu_ids=self.oids2)) expected = pd.Series(expected) actual = alpha_diversity('faith_pd', self.table2, tree=self.tree2, otu_ids=self.oids2) assert_series_almost_equal(actual, expected) def test_no_ids(self): # expected values hand-calculated expected = pd.Series([3, 3, 3, 3]) actual = alpha_diversity('observed_otus', self.table1) assert_series_almost_equal(actual, expected) def test_optimized(self): # calling optimized faith_pd gives same results as calling unoptimized # version optimized = alpha_diversity('faith_pd', self.table1, tree=self.tree1, otu_ids=self.oids1) unoptimized = alpha_diversity(faith_pd, self.table1, tree=self.tree1, otu_ids=self.oids1) assert_series_almost_equal(optimized, unoptimized) class BetaDiversityTests(TestCase): def setUp(self): self.table1 = [[1, 5], [2, 3], [0, 1]] self.sids1 = list('ABC') self.tree1 = TreeNode.read(io.StringIO( '((O1:0.25, O2:0.50):0.25, O3:0.75)root;')) self.oids1 = ['O1', 'O2'] self.table2 = [[23, 64, 14, 0, 0, 3, 1], [0, 3, 35, 42, 0, 12, 1], [0, 5, 5, 0, 40, 40, 0], [44, 35, 9, 0, 1, 0, 0], [0, 2, 8, 0, 35, 45, 1], [0, 0, 25, 35, 0, 19, 0]] self.sids2 = list('ABCDEF') self.table3 = [[23, 64, 14, 0, 0, 3, 1], [0, 3, 35, 42, 0, 12, 1], [0, 5, 5, 0, 40, 40, 0], [44, 35, 9, 0, 1, 0, 0], [0, 2, 8, 0, 35, 45, 1], [0, 0, 25, 35, 0, 19, 0], [88, 31, 0, 5, 5, 5, 5], [44, 39, 0, 0, 0, 0, 0]] def test_available_metrics(self): for metric in _valid_beta_metrics: try: beta_diversity(metric, self.table3) except Exception as exc: raise ValueError( f'Metric {metric} failed with exception:\n {exc}') def test_qualitative_bug_issue_1549(self): as_presence_absence = np.asarray(self.table3) > 0 for metric in _valid_beta_metrics: obs_mat = beta_diversity(metric, self.table3) obs_presence_absence = beta_diversity(metric, as_presence_absence) if metric in _qualitative_beta_metrics: self.assertEqual(obs_mat, obs_presence_absence) else: self.assertNotEqual(obs_mat, obs_presence_absence) def test_invalid_input(self): # number of ids doesn't match the number of samples error_msg = (r"Number of rows") with self.assertRaisesRegex(ValueError, error_msg): beta_diversity(self.table1, list('AB'), 'euclidean') # unknown metric provided error_msg = r"not-a-metric" with self.assertRaisesRegex(ValueError, error_msg): beta_diversity('not-a-metric', self.table1) # 3-D list provided as input error_msg = (r"Only 1-D and 2-D") with self.assertRaisesRegex(ValueError, error_msg): beta_diversity('euclidean', [[[43]]]) # negative counts error_msg = r"negative values." with self.assertRaisesRegex(ValueError, error_msg): beta_diversity('euclidean', [[0, 1, 3, 4], [0, 3, -12, 42]]) with self.assertRaisesRegex(ValueError, error_msg): beta_diversity('euclidean', [[0, 1, 3, -4], [0, 3, 12, 42]]) # additional kwargs error_msg = r"argument" with self.assertRaisesRegex(TypeError, error_msg): beta_diversity('euclidean', [[0, 1, 3], [0, 3, 12]], not_a_real_kwarg=42.0) with self.assertRaisesRegex(TypeError, error_msg): beta_diversity('unweighted_unifrac', [[0, 1, 3], [0, 3, 12]], not_a_real_kwarg=42.0, tree=self.tree1, otu_ids=['O1', 'O2', 'O3']) with self.assertRaisesRegex(TypeError, error_msg): beta_diversity('weighted_unifrac', [[0, 1, 3], [0, 3, 12]], not_a_real_kwarg=42.0, tree=self.tree1, otu_ids=['O1', 'O2', 'O3']) with self.assertRaisesRegex(TypeError, error_msg): beta_diversity(weighted_unifrac, [[0, 1, 3], [0, 3, 12]], not_a_real_kwarg=42.0, tree=self.tree1, otu_ids=['O1', 'O2', 'O3']) def test_invalid_input_phylogenetic(self): # otu_ids not provided self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', self.table1, list('ABC'), tree=self.tree1) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', self.table1, list('ABC'), tree=self.tree1) # tree not provided self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', self.table1, list('ABC'), otu_ids=self.oids1) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', self.table1, list('ABC'), otu_ids=self.oids1) # tree has duplicated tip ids t = TreeNode.read( io.StringIO( '(((((OTU2:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(DuplicateNodeError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(DuplicateNodeError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # unrooted tree as input t = TreeNode.read(io.StringIO('((OTU1:0.1, OTU2:0.2):0.3, OTU3:0.5,' 'OTU4:0.7);')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # otu_ids has duplicated ids t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU2'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # count and OTU vectors are not equal length t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 2] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # tree with no branch lengths t = TreeNode.read( io.StringIO('((((OTU1,OTU2),OTU3)),(OTU4,OTU5));')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # tree missing some branch lengths t = TreeNode.read( io.StringIO('(((((OTU1,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(ValueError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) # some otu_ids not present in tree t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU42'] self.assertRaises(MissingNodeError, beta_diversity, 'weighted_unifrac', counts, otu_ids=otu_ids, tree=t) self.assertRaises(MissingNodeError, beta_diversity, 'unweighted_unifrac', counts, otu_ids=otu_ids, tree=t) def test_empty(self): # array of empty vectors actual = beta_diversity('euclidean', np.array([[], []], dtype=np.int64), ids=['a', 'b']) expected_dm = DistanceMatrix([[0.0, 0.0], [0.0, 0.0]], ['a', 'b']) npt.assert_array_equal(actual, expected_dm) actual = beta_diversity('unweighted_unifrac', np.array([[], []], dtype=np.int64), ids=['a', 'b'], tree=self.tree1, otu_ids=[]) expected_dm = DistanceMatrix([[0.0, 0.0], [0.0, 0.0]], ['a', 'b']) self.assertEqual(actual, expected_dm) def test_input_types(self): actual_array = beta_diversity('euclidean', np.array([[1, 5], [2, 3]]), ids=['a', 'b']) actual_list = beta_diversity('euclidean', [[1, 5], [2, 3]], ids=['a', 'b']) self.assertEqual(actual_array, actual_list) def test_euclidean(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available actual_dm = beta_diversity('euclidean', self.table1, self.sids1) self.assertEqual(actual_dm.shape, (3, 3)) npt.assert_almost_equal(actual_dm['A', 'A'], 0.0) npt.assert_almost_equal(actual_dm['B', 'B'], 0.0) npt.assert_almost_equal(actual_dm['C', 'C'], 0.0) npt.assert_almost_equal(actual_dm['A', 'B'], 2.23606798) npt.assert_almost_equal(actual_dm['B', 'A'], 2.23606798) npt.assert_almost_equal(actual_dm['A', 'C'], 4.12310563) npt.assert_almost_equal(actual_dm['C', 'A'], 4.12310563) npt.assert_almost_equal(actual_dm['B', 'C'], 2.82842712) npt.assert_almost_equal(actual_dm['C', 'B'], 2.82842712) actual_dm = beta_diversity('euclidean', self.table2, self.sids2) expected_data = [ [0., 80.8455317, 84.0297566, 36.3042697, 86.0116271, 78.9176786], [80.8455317, 0., 71.0844568, 74.4714710, 69.3397433, 14.422205], [84.0297566, 71.0844568, 0., 77.2851861, 8.3066238, 60.7536007], [36.3042697, 74.4714710, 77.2851861, 0., 78.7908624, 70.7389567], [86.0116271, 69.3397433, 8.3066238, 78.7908624, 0., 58.4807660], [78.9176786, 14.422205, 60.7536007, 70.7389567, 58.4807660, 0.]] expected_dm = DistanceMatrix(expected_data, self.sids2) for id1 in self.sids2: for id2 in self.sids2: npt.assert_almost_equal(actual_dm[id1, id2], expected_dm[id1, id2], 6) def test_braycurtis(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available actual_dm = beta_diversity('braycurtis', self.table1, self.sids1) self.assertEqual(actual_dm.shape, (3, 3)) npt.assert_almost_equal(actual_dm['A', 'A'], 0.0) npt.assert_almost_equal(actual_dm['B', 'B'], 0.0) npt.assert_almost_equal(actual_dm['C', 'C'], 0.0) npt.assert_almost_equal(actual_dm['A', 'B'], 0.27272727) npt.assert_almost_equal(actual_dm['B', 'A'], 0.27272727) npt.assert_almost_equal(actual_dm['A', 'C'], 0.71428571) npt.assert_almost_equal(actual_dm['C', 'A'], 0.71428571) npt.assert_almost_equal(actual_dm['B', 'C'], 0.66666667) npt.assert_almost_equal(actual_dm['C', 'B'], 0.66666667) actual_dm = beta_diversity('braycurtis', self.table2, self.sids2) expected_data = [ [0., 0.78787879, 0.86666667, 0.30927835, 0.85714286, 0.81521739], [0.78787879, 0., 0.78142077, 0.86813187, 0.75, 0.1627907], [0.86666667, 0.78142077, 0., 0.87709497, 0.09392265, 0.71597633], [0.30927835, 0.86813187, 0.87709497, 0., 0.87777778, 0.89285714], [0.85714286, 0.75, 0.09392265, 0.87777778, 0., 0.68235294], [0.81521739, 0.1627907, 0.71597633, 0.89285714, 0.68235294, 0.]] expected_dm = DistanceMatrix(expected_data, self.sids2) for id1 in self.sids2: for id2 in self.sids2: npt.assert_almost_equal(actual_dm[id1, id2], expected_dm[id1, id2], 6) def test_unweighted_unifrac(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available # expected values calculated by hand dm1 = beta_diversity('unweighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1) dm2 = beta_diversity(unweighted_unifrac, self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1) self.assertEqual(dm1.shape, (3, 3)) self.assertEqual(dm1, dm2) expected_data = [[0.0, 0.0, 0.25], [0.0, 0.0, 0.25], [0.25, 0.25, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm1[id1, id2], expected_dm[id1, id2], 6) def test_weighted_unifrac(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available # expected values calculated by hand dm1 = beta_diversity('weighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1) dm2 = beta_diversity(weighted_unifrac, self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1) self.assertEqual(dm1.shape, (3, 3)) self.assertEqual(dm1, dm2) expected_data = [ [0.0, 0.1750000, 0.12499999], [0.1750000, 0.0, 0.3000000], [0.12499999, 0.3000000, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm1[id1, id2], expected_dm[id1, id2], 6) def test_weighted_unifrac_normalized(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available # expected values calculated by hand dm1 = beta_diversity('weighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, normalized=True) dm2 = beta_diversity(weighted_unifrac, self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, normalized=True) self.assertEqual(dm1.shape, (3, 3)) self.assertEqual(dm1, dm2) expected_data = [ [0.0, 0.128834, 0.085714], [0.128834, 0.0, 0.2142857], [0.085714, 0.2142857, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm1[id1, id2], expected_dm[id1, id2], 6) def test_scipy_kwargs(self): # confirm that p can be passed to SciPy's minkowski, and that it # gives a different result than not passing it (the off-diagonal # entries are not equal). dm1 = beta_diversity('minkowski', self.table1, self.sids1) dm2 = beta_diversity('minkowski', self.table1, self.sids1, p=42.0) for id1 in self.sids1: for id2 in self.sids1: if id1 != id2: self.assertNotEqual(dm1[id1, id2], dm2[id1, id2]) def test_alt_pairwise_func(self): # confirm that pairwise_func is actually being used def not_a_real_pdist(counts, metric): return [[0.0, 42.0], [42.0, 0.0]] dm1 = beta_diversity('unweighted_unifrac', self.table1, otu_ids=self.oids1, tree=self.tree1, pairwise_func=not_a_real_pdist) expected = DistanceMatrix([[0.0, 42.0], [42.0, 0.0]]) self.assertEqual(dm1, expected) dm1 = beta_diversity('weighted_unifrac', self.table1, otu_ids=self.oids1, tree=self.tree1, pairwise_func=not_a_real_pdist) expected = DistanceMatrix([[0.0, 42.0], [42.0, 0.0]]) self.assertEqual(dm1, expected) dm1 = beta_diversity(unweighted_unifrac, self.table1, otu_ids=self.oids1, tree=self.tree1, pairwise_func=not_a_real_pdist) expected = DistanceMatrix([[0.0, 42.0], [42.0, 0.0]]) self.assertEqual(dm1, expected) dm1 = beta_diversity("euclidean", self.table1, pairwise_func=not_a_real_pdist) expected = DistanceMatrix([[0.0, 42.0], [42.0, 0.0]]) self.assertEqual(dm1, expected) class MetricGetters(TestCase): def test_get_alpha_diversity_metrics(self): m = get_alpha_diversity_metrics() # basic sanity checks self.assertTrue('faith_pd' in m) self.assertTrue('chao1' in m) def test_get_alpha_diversity_metrics_sorted(self): m = get_alpha_diversity_metrics() n = sorted(list(m)) self.assertEqual(m, n) def test_get_beta_diversity_metrics(self): m = get_beta_diversity_metrics() # basic sanity checks self.assertTrue('unweighted_unifrac' in m) self.assertTrue('weighted_unifrac' in m) def test_get_beta_diversity_metrics_sorted(self): m = get_beta_diversity_metrics() n = sorted(list(m)) self.assertEqual(m, n) class TestPartialBetaDiversity(TestCase): def setUp(self): self.table1 = [[1, 5], [2, 3], [0, 1]] self.sids1 = list('ABC') self.tree1 = TreeNode.read(io.StringIO( '((O1:0.25, O2:0.50):0.25, O3:0.75)root;')) self.oids1 = ['O1', 'O2'] self.table2 = [[23, 64, 14, 0, 0, 3, 1], [0, 3, 35, 42, 0, 12, 1], [0, 5, 5, 0, 40, 40, 0], [44, 35, 9, 0, 1, 0, 0], [0, 2, 8, 0, 35, 45, 1], [0, 0, 25, 35, 0, 19, 0]] self.sids2 = list('ABCDEF') def test_id_pairs_as_iterable(self): id_pairs = iter([('B', 'C'), ]) dm = partial_beta_diversity('unweighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, id_pairs=id_pairs) self.assertEqual(dm.shape, (3, 3)) expected_data = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.25], [0.0, 0.25, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm[id1, id2], expected_dm[id1, id2], 6) # pass in iter(foo) def test_unweighted_unifrac_partial(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available # expected values calculated by hand dm = partial_beta_diversity('unweighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, id_pairs=[('B', 'C'), ]) self.assertEqual(dm.shape, (3, 3)) expected_data = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.25], [0.0, 0.25, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm[id1, id2], expected_dm[id1, id2], 6) def test_weighted_unifrac_partial_full(self): # TODO: update npt.assert_almost_equal calls to use DistanceMatrix # near-equality testing when that support is available # expected values calculated by hand dm1 = partial_beta_diversity('weighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1, id_pairs=[('A', 'B'), ('A', 'C'), ('B', 'C')]) dm2 = beta_diversity('weighted_unifrac', self.table1, self.sids1, otu_ids=self.oids1, tree=self.tree1) self.assertEqual(dm1.shape, (3, 3)) self.assertEqual(dm1, dm2) expected_data = [ [0.0, 0.1750000, 0.12499999], [0.1750000, 0.0, 0.3000000], [0.12499999, 0.3000000, 0.0]] expected_dm = DistanceMatrix(expected_data, ids=self.sids1) for id1 in self.sids1: for id2 in self.sids1: npt.assert_almost_equal(dm1[id1, id2], expected_dm[id1, id2], 6) def test_self_self_pair(self): error_msg = (r"A duplicate or a self-self pair was observed.") with self.assertRaisesRegex(ValueError, error_msg): partial_beta_diversity((lambda x, y: x + y), self.table1, self.sids1, id_pairs=[('A', 'B'), ('A', 'A')]) def test_duplicate_pairs(self): # confirm that partial pairwise execution fails if duplicate pairs are # observed error_msg = (r"A duplicate or a self-self pair was observed.") with self.assertRaisesRegex(ValueError, error_msg): partial_beta_diversity((lambda x, y: x + y), self.table1, self.sids1, id_pairs=[('A', 'B'), ('A', 'B')]) def test_duplicate_transpose_pairs(self): # confirm that partial pairwise execution fails if a transpose # duplicate is observed error_msg = (r"A duplicate or a self-self pair was observed.") with self.assertRaisesRegex(ValueError, error_msg): partial_beta_diversity((lambda x, y: x + y), self.table1, self.sids1, id_pairs=[('A', 'B'), ('A', 'B')]) def test_pairs_not_subset(self): # confirm raise when pairs are not a subset of IDs error_msg = (r"`id_pairs` are not a subset of `ids`") with self.assertRaisesRegex(ValueError, error_msg): partial_beta_diversity((lambda x, y: x + y), self.table1, self.sids1, id_pairs=[('x', 'b'), ]) def test_euclidean(self): # confirm that pw execution through partial is identical def euclidean(u, v, **kwargs): return np.sqrt(((u - v)**2).sum()) id_pairs = [('A', 'B'), ('B', 'F'), ('D', 'E')] actual_dm = partial_beta_diversity(euclidean, self.table2, self.sids2, id_pairs=id_pairs) actual_dm = DistanceMatrix(actual_dm, self.sids2) expected_data = [ [0., 80.8455317, 0., 0., 0., 0.], [80.8455317, 0., 0., 0., 0., 14.422205], [0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 78.7908624, 0.], [0., 0., 0., 78.7908624, 0., 0.], [0., 14.422205, 0., 0., 0., 0.]] expected_dm = DistanceMatrix(expected_data, self.sids2) for id1 in self.sids2: for id2 in self.sids2: npt.assert_almost_equal(actual_dm[id1, id2], expected_dm[id1, id2], 6) def test_unusable_metric(self): id_pairs = [('A', 'B'), ('B', 'F'), ('D', 'E')] error_msg = r"partial_beta_diversity is only compatible" with self.assertRaisesRegex(ValueError, error_msg): partial_beta_diversity('hamming', self.table2, self.sids2, id_pairs=id_pairs) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/diversity/tests/test_util.py000066400000000000000000000251051446255456000224610ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import numpy as np import pandas as pd import numpy.testing as npt from skbio import TreeNode from skbio.diversity._util import (_validate_counts_vector, _validate_counts_matrix, _validate_otu_ids_and_tree, _vectorize_counts_and_tree, _quantitative_to_qualitative_counts) from skbio.tree import DuplicateNodeError, MissingNodeError class ValidationTests(TestCase): def test_validate_counts_vector(self): # python list obs = _validate_counts_vector([0, 2, 1, 3]) npt.assert_array_equal(obs, np.array([0, 2, 1, 3])) self.assertEqual(obs.dtype, int) # numpy array (no copy made) data = np.array([0, 2, 1, 3]) obs = _validate_counts_vector(data) npt.assert_array_equal(obs, data) self.assertEqual(obs.dtype, int) self.assertTrue(obs is data) # single element obs = _validate_counts_vector([42]) npt.assert_array_equal(obs, np.array([42])) self.assertEqual(obs.dtype, int) self.assertEqual(obs.shape, (1,)) # suppress casting to int obs = _validate_counts_vector([42.2, 42.1, 0], suppress_cast=True) npt.assert_array_equal(obs, np.array([42.2, 42.1, 0])) self.assertEqual(obs.dtype, float) # all zeros obs = _validate_counts_vector([0, 0, 0]) npt.assert_array_equal(obs, np.array([0, 0, 0])) self.assertEqual(obs.dtype, int) # all zeros (single value) obs = _validate_counts_vector([0]) npt.assert_array_equal(obs, np.array([0])) self.assertEqual(obs.dtype, int) def test_validate_counts_vector_invalid_input(self): # wrong number of dimensions (2-D) with self.assertRaises(ValueError): _validate_counts_vector([[0, 2, 1, 3], [4, 5, 6, 7]]) # wrong number of dimensions (scalar) with self.assertRaises(ValueError): _validate_counts_vector(1) # negative values with self.assertRaises(ValueError): _validate_counts_vector([0, 0, 2, -1, 3]) # strings with self.assertRaises(ValueError): _validate_counts_vector([0, 0, 'a', -1, 3]) def test_validate_counts_matrix(self): # basic valid input (n=2) obs = _validate_counts_matrix([[0, 1, 1, 0, 2], [0, 0, 2, 1, 3]]) npt.assert_array_equal(obs[0], np.array([0, 1, 1, 0, 2])) npt.assert_array_equal(obs[1], np.array([0, 0, 2, 1, 3])) # basic valid input (n=3) obs = _validate_counts_matrix([[0, 1, 1, 0, 2], [0, 0, 2, 1, 3], [1, 1, 1, 1, 1]]) npt.assert_array_equal(obs[0], np.array([0, 1, 1, 0, 2])) npt.assert_array_equal(obs[1], np.array([0, 0, 2, 1, 3])) npt.assert_array_equal(obs[2], np.array([1, 1, 1, 1, 1])) # empty counts vectors obs = _validate_counts_matrix(np.array([[], []], dtype=int)) npt.assert_array_equal(obs[0], np.array([])) npt.assert_array_equal(obs[1], np.array([])) def test_validate_counts_matrix_pandas(self): obs = _validate_counts_matrix(pd.DataFrame([[0, 1, 1, 0, 2], [0, 0, 2, 1, 3], [1, 1, 1, 1, 1]])) npt.assert_array_equal(obs[0], np.array([0, 1, 1, 0, 2])) npt.assert_array_equal(obs[1], np.array([0, 0, 2, 1, 3])) npt.assert_array_equal(obs[2], np.array([1, 1, 1, 1, 1])) def test_validate_counts_matrix_suppress_cast(self): # suppress_cast is passed through to _validate_counts_vector obs = _validate_counts_matrix( [[42.2, 42.1, 0], [42.2, 42.1, 1.0]], suppress_cast=True) npt.assert_array_equal(obs[0], np.array([42.2, 42.1, 0])) npt.assert_array_equal(obs[1], np.array([42.2, 42.1, 1.0])) self.assertEqual(obs[0].dtype, float) self.assertEqual(obs[1].dtype, float) def test_validate_counts_matrix_negative_counts(self): with self.assertRaises(ValueError): _validate_counts_matrix([[0, 1, 1, 0, 2], [0, 0, 2, -1, 3]]) with self.assertRaises(ValueError): _validate_counts_matrix([[0, 0, 2, -1, 3], [0, 1, 1, 0, 2]]) def test_validate_counts_matrix_unequal_lengths(self): # len of vectors not equal with self.assertRaises(ValueError): _validate_counts_matrix([[0], [0, 0], [9, 8]]) with self.assertRaises(ValueError): _validate_counts_matrix([[0, 0], [0, 0, 8], [9, 8]]) with self.assertRaises(ValueError): _validate_counts_matrix([[0, 0, 75], [0, 0, 3], [9, 8, 22, 44]]) def test_validate_otu_ids_and_tree(self): # basic valid input t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertTrue(_validate_otu_ids_and_tree(counts, otu_ids, t) is None) # all tips observed t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 1, 1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5'] self.assertTrue(_validate_otu_ids_and_tree(counts, otu_ids, t) is None) # no tips observed t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [] otu_ids = [] self.assertTrue(_validate_otu_ids_and_tree(counts, otu_ids, t) is None) # all counts zero t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [0, 0, 0, 0, 0] otu_ids = ['OTU1', 'OTU2', 'OTU3', 'OTU4', 'OTU5'] self.assertTrue(_validate_otu_ids_and_tree(counts, otu_ids, t) is None) def test_validate_otu_ids_and_tree_invalid_input(self): # tree has duplicated tip ids t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU2:0.75):1.25):0.0)root;')) counts = [1, 1, 1] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(DuplicateNodeError, _validate_otu_ids_and_tree, counts, otu_ids, t) # unrooted tree as input t = TreeNode.read(io.StringIO('((OTU1:0.1, OTU2:0.2):0.3, OTU3:0.5,' 'OTU4:0.7);')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) # otu_ids has duplicated ids t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU2'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) # len of vectors not equal t = TreeNode.read( io.StringIO( '(((((OTU1:0.5,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) # tree with no branch lengths t = TreeNode.read( io.StringIO('((((OTU1,OTU2),OTU3)),(OTU4,OTU5));')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) # tree missing some branch lengths t = TreeNode.read( io.StringIO( '(((((OTU1,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU3'] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) # otu_ids not present in tree t = TreeNode.read( io.StringIO( '(((((OTU1:0.25,OTU2:0.5):0.5,OTU3:1.0):1.0):0.0,(OTU4:' '0.75,OTU5:0.75):1.25):0.0)root;')) counts = [1, 2, 3] otu_ids = ['OTU1', 'OTU2', 'OTU32'] self.assertRaises(MissingNodeError, _validate_otu_ids_and_tree, counts, otu_ids, t) # single node tree t = TreeNode.read(io.StringIO('root;')) counts = [] otu_ids = [] self.assertRaises(ValueError, _validate_otu_ids_and_tree, counts, otu_ids, t) def test_vectorize_counts_and_tree(self): t = TreeNode.read(io.StringIO("((a:1, b:2)c:3)root;")) counts = np.array([[0, 1], [1, 5], [10, 1]]) count_array, indexed, branch_lengths = \ _vectorize_counts_and_tree(counts, np.array(['a', 'b']), t) exp_counts = np.array([[0, 1, 10], [1, 5, 1], [1, 6, 11], [1, 6, 11]]) npt.assert_equal(count_array, exp_counts.T) def test_quantitative_to_qualitative_counts(self): counts = np.array([[0, 1], [1, 5], [10, 1]]) exp = np.array([[False, True], [True, True], [True, True]]) obs = _quantitative_to_qualitative_counts(counts) npt.assert_equal(obs, exp) counts = np.array([[0, 0, 0], [1, 0, 42]]) exp = np.array([[False, False, False], [True, False, True]]) obs = _quantitative_to_qualitative_counts(counts) npt.assert_equal(obs, exp) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/io/000077500000000000000000000000001446255456000153135ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/__init__.py000066400000000000000000000177651446255456000174440ustar00rootroot00000000000000r""" File I/O (:mod:`skbio.io`) ========================== .. currentmodule:: skbio.io This package provides I/O functionality for skbio. Supported file formats ---------------------- For details on what objects are supported by each format, see the associated documentation. .. currentmodule:: skbio.io.format .. autosummary:: :toctree: generated/ binary_dm blast6 blast7 clustal embl fasta fastq genbank gff3 lsmat newick ordination phylip qseq stockholm taxdump .. currentmodule:: skbio.io.registry User functions -------------- .. autosummary:: :toctree: generated/ write read sniff .. currentmodule:: skbio.io User exceptions and warnings ---------------------------- .. autosummary:: :toctree: generated/ FormatIdentificationWarning ArgumentOverrideWarning UnrecognizedFormatError IOSourceError FileFormatError BLAST7FormatError ClustalFormatError EMBLFormatError FASTAFormatError FASTQFormatError GenBankFormatError GFF3FormatError LSMatFormatError NewickFormatError OrdinationFormatError PhylipFormatError QSeqFormatError QUALFormatError StockholmFormatError Subpackages ----------- .. autosummary:: :toctree: generated/ registry util For developer documentation on extending I/O, see :mod:`skbio.io.registry`. Introduction to I/O ------------------- Reading and writing files (I/O) can be a complicated task: * A file format can sometimes be read into more than one in-memory representation (i.e., object). For example, a FASTA file can be read into an :mod:`skbio.alignment.TabularMSA` or :mod:`skbio.sequence.DNA` depending on what operations you'd like to perform on your data. * A single object might be writeable to more than one file format. For example, an :mod:`skbio.alignment.TabularMSA` object could be written to FASTA, FASTQ, CLUSTAL, or PHYLIP formats, just to name a few. * You might not know the exact file format of your file, but you want to read it into an appropriate object. * You might want to read multiple files into a single object, or write an object to multiple files. * Instead of reading a file into an object, you might want to stream the file using a generator (e.g., if the file cannot be fully loaded into memory). To address these issues (and others), scikit-bio provides a simple, powerful interface for dealing with I/O. We accomplish this by using a single I/O registry. What kinds of files scikit-bio can use ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To see a complete list of file-like inputs that can be used for reading, writing, and sniffing, see the documentation for :func:`skbio.io.util.open`. Reading files into scikit-bio ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ There are two ways to read files. The first way is to use the procedural interface: .. code-block:: python my_obj = skbio.io.read(file, format='someformat', into=SomeSkbioClass) The second is to use the object-oriented (OO) interface which is automatically constructed from the procedural interface: .. code-block:: python my_obj = SomeSkbioClass.read(file, format='someformat') For example, to read a `newick` file using both interfaces you would type: >>> from skbio import read >>> from skbio import TreeNode >>> from io import StringIO >>> open_filehandle = StringIO('(a, b);') >>> tree = read(open_filehandle, format='newick', into=TreeNode) >>> tree For the OO interface: >>> open_filehandle = StringIO('(a, b);') >>> tree = TreeNode.read(open_filehandle, format='newick') >>> tree In the case of :func:`skbio.io.registry.read` if `into` is not provided, then a generator will be returned. What the generator yields will depend on what format is being read. When `into` is provided, format may be omitted and the registry will use its knowledge of the available formats for the requested class to infer the correct format. This format inference is also available in the OO interface, meaning that `format` may be omitted there as well. As an example: >>> open_filehandle = StringIO('(a, b);') >>> tree = TreeNode.read(open_filehandle) >>> tree We call format inference `sniffing`, much like the :class:`csv.Sniffer` class of Python's standard library. The goal of a `sniffer` is twofold: to identify if a file is a specific format, and if it is, to provide `**kwargs` which can be used to better parse the file. .. note:: There is a built-in `sniffer` which results in a useful error message if an empty file is provided as input and the format was omitted. Writing files from scikit-bio ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Just as when reading files, there are two ways to write files. Procedural Interface: .. code-block:: python skbio.io.write(my_obj, format='someformat', into=file) OO Interface: .. code-block:: python my_obj.write(file, format='someformat') In the procedural interface, `format` is required. Without it, scikit-bio does not know how you want to serialize an object. OO interfaces define a default `format`, so it may not be necessary to include it. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from importlib import import_module from ._warning import FormatIdentificationWarning, ArgumentOverrideWarning from ._exception import (UnrecognizedFormatError, FileFormatError, BLAST7FormatError, ClustalFormatError, FASTAFormatError, GenBankFormatError, IOSourceError, FASTQFormatError, LSMatFormatError, NewickFormatError, OrdinationFormatError, PhylipFormatError, QSeqFormatError, QUALFormatError, StockholmFormatError, GFF3FormatError, EMBLFormatError) from .registry import write, read, sniff, create_format, io_registry from .util import open __all__ = ['write', 'read', 'sniff', 'open', 'io_registry', 'create_format', 'FormatIdentificationWarning', 'ArgumentOverrideWarning', 'UnrecognizedFormatError', 'IOSourceError', 'FileFormatError', 'BLAST7FormatError', 'ClustalFormatError', 'EMBLFormatError', 'FASTAFormatError', 'FASTQFormatError', 'GenBankFormatError', 'GFF3FormatError', 'LSMatFormatError', 'NewickFormatError', 'OrdinationFormatError', 'PhylipFormatError', 'QSeqFormatError', 'QUALFormatError', 'StockholmFormatError'] # Necessary to import each file format module to have them added to the I/O # registry. We use import_module instead of a typical import to avoid flake8 # unused import errors. import_module('skbio.io.format.blast6') import_module('skbio.io.format.blast7') import_module('skbio.io.format.clustal') import_module('skbio.io.format.embl') import_module('skbio.io.format.fasta') import_module('skbio.io.format.fastq') import_module('skbio.io.format.lsmat') import_module('skbio.io.format.newick') import_module('skbio.io.format.ordination') import_module('skbio.io.format.phylip') import_module('skbio.io.format.qseq') import_module('skbio.io.format.genbank') import_module('skbio.io.format.gff3') import_module('skbio.io.format.stockholm') import_module('skbio.io.format.binary_dm') import_module('skbio.io.format.taxdump') # This is meant to be a handy indicator to the user that they have done # something wrong. import_module('skbio.io.format.emptyfile') # Now that all of our I/O has loaded, we can add the object oriented methods # (read and write) to each class which has registered I/O operations. io_registry.monkey_patch() scikit-bio-0.5.9/skbio/io/_exception.py000066400000000000000000000052701446255456000200260ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- class IOSourceError(Exception): """Raised when a file source cannot be resolved.""" pass class FileFormatError(Exception): """Raised when a file cannot be parsed.""" pass class UnrecognizedFormatError(FileFormatError): """Raised when a file's format is unknown, ambiguous, or unidentifiable.""" pass class GenBankFormatError(FileFormatError): """Raised when a ``genbank`` formatted file cannot be parsed.""" pass class EMBLFormatError(FileFormatError): """Raised when a ``EMBL`` formatted file cannot be parsed.""" pass class GFF3FormatError(FileFormatError): """Raised when a ``GFF3`` formatted file cannot be parsed.""" pass class BLAST7FormatError(FileFormatError): """Raised when a ``blast7`` formatted file cannot be parsed.""" pass class ClustalFormatError(FileFormatError): """Raised when a ``clustal`` formatted file cannot be parsed.""" pass class FASTAFormatError(FileFormatError): """Raised when a ``fasta`` formatted file cannot be parsed.""" pass class QUALFormatError(FASTAFormatError): """Raised when a ``qual`` formatted file cannot be parsed.""" pass class LSMatFormatError(FileFormatError): """Raised when a ``lsmat`` formatted file cannot be parsed.""" pass class OrdinationFormatError(FileFormatError): """Raised when an ``ordination`` formatted file cannot be parsed.""" pass class NewickFormatError(FileFormatError): """Raised when a ``newick`` formatted file cannot be parsed.""" pass class FASTQFormatError(FileFormatError): """Raised when a ``fastq`` formatted file cannot be parsed.""" pass class PhylipFormatError(FileFormatError): """Raised when a ``phylip`` formatted file cannot be parsed. May also be raised when an object (e.g., ``TabularMSA``) cannot be written in ``phylip`` format. """ pass class QSeqFormatError(FileFormatError): """Raised when a ``qseq`` formatted file cannot be parsed.""" pass class StockholmFormatError(FileFormatError): """Raised when a ``stockholm`` formatted file cannot be parsed.""" pass class InvalidRegistrationError(Exception): """Raised if function doesn't meet the expected API of its registration.""" pass class DuplicateRegistrationError(Exception): """Raised when a function is already registered in skbio.io""" pass scikit-bio-0.5.9/skbio/io/_fileobject.py000066400000000000000000000050671446255456000201420ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io def is_binary_file(file): return isinstance(file, (io.BufferedReader, io.BufferedWriter, io.BufferedRandom)) # Everything beyond this point will be some kind of hack needed to make # everything work. It's not pretty and it doesn't make great sense much # of the time. I am very sorry to the poor soul who has to read beyond. class FlushDestructorMixin: def __del__(self): # By default, the destructor calls close(), which flushes and closes # the underlying buffer. Override to only flush. if not self.closed: self.flush() class SaneTextIOWrapper(FlushDestructorMixin, io.TextIOWrapper): pass class WrappedBufferedRandom(FlushDestructorMixin, io.BufferedRandom): pass class CompressedMixin(FlushDestructorMixin): """Act as a bridge between worlds""" def __init__(self, before_file, *args, **kwargs): self.streamable = kwargs.pop('streamable', True) self._before_file = before_file super(CompressedMixin, self).__init__(*args, **kwargs) @property def closed(self): return self.raw.closed or self._before_file.closed def close(self): super(CompressedMixin, self).close() # The above will not usually close before_file. We want the # decompression to be transparent, so we don't want users to deal with # this edge case. Instead we can just close the original now that we # are being closed. self._before_file.close() class CompressedBufferedReader(CompressedMixin, io.BufferedReader): pass class CompressedBufferedWriter(CompressedMixin, io.BufferedWriter): pass class IterableStringReaderIO(io.StringIO): def __init__(self, iterable, newline): self._iterable = iterable super(IterableStringReaderIO, self).__init__(''.join(iterable), newline=newline) class IterableStringWriterIO(IterableStringReaderIO): def close(self): if not self.closed: backup = self.tell() self.seek(0) for line in self: self._iterable.append(line) self.seek(backup) super(IterableStringWriterIO, self).close() scikit-bio-0.5.9/skbio/io/_iosources.py000066400000000000000000000152211446255456000200400ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import gzip import bz2 import tempfile import itertools import requests from skbio.io import IOSourceError from ._fileobject import (IterableStringWriterIO, IterableStringReaderIO, WrappedBufferedRandom) # NamedTemporaryFile isn't an actual file class, it is a function which # returns _TemporaryFileWrapper around a normal file object. Instead of # relying on this implementation, we take whatever the class of the result of # NamedTemporaryFile is. with tempfile.NamedTemporaryFile() as fh: _WrappedTemporaryFile = type(fh) def get_io_sources(): return ( # The order of these source is significant as they will short-circuit HTTPSource, FilePathSource, BytesIOSource, BufferedIOSource, TextIOSource, WrappedTemporaryFileSource, IterableSource ) def _compressors(): return ( GzipCompressor, BZ2Compressor ) def get_compression_handler(name): compressors = {c.name: c for c in _compressors()} compressors['auto'] = AutoCompressor return compressors.get(name, False) class IOSource: closeable = True def __init__(self, file, options): self.file = file self.options = options def can_read(self): return False def can_write(self): return False def get_reader(self): raise NotImplementedError() def get_writer(self): raise NotImplementedError() class Compressor(IOSource): streamable = True name = '' def can_write(self): return True class FilePathSource(IOSource): def can_read(self): return isinstance(self.file, str) def can_write(self): return self.can_read() def get_reader(self): return io.open(self.file, mode='rb') def get_writer(self): return io.open(self.file, mode='wb') class HTTPSource(IOSource): def can_read(self): return ( isinstance(self.file, str) and requests.compat.urlparse(self.file).scheme in {'http', 'https'}) def get_reader(self): req = requests.get(self.file) # if the response is not 200, an exception will be raised req.raise_for_status() return io.BufferedReader(io.BytesIO(req.content)) class BytesIOSource(IOSource): closeable = False def can_read(self): return isinstance(self.file, io.BytesIO) def can_write(self): return self.can_read() def get_reader(self): return WrappedBufferedRandom(self.file) def get_writer(self): return self.get_reader() class BufferedIOSource(IOSource): closeable = False def can_read(self): # `peek` is part of the API we want to guarantee, so we can't just look # for io.BufferedIOBase. Despite the fact that the C implementation of # io.BufferedRandom inherits io.BufferedReader/Writer it is not # reflected in an isinstance check, so we need to check for it manually return isinstance(self.file, (io.BufferedReader, io.BufferedRandom)) def can_write(self): return isinstance(self.file, (io.BufferedWriter, io.BufferedRandom)) def get_reader(self): return self.file def get_writer(self): return self.file class TextIOSource(IOSource): closeable = False def can_read(self): return isinstance(self.file, io.TextIOBase) and self.file.readable() def can_write(self): return isinstance(self.file, io.TextIOBase) and self.file.writable() def get_reader(self): return self.file def get_writer(self): return self.file class WrappedTemporaryFileSource(IOSource): closeable = False def can_read(self): return (isinstance(self.file, _WrappedTemporaryFile) and self.file.readable()) def can_write(self): return (isinstance(self.file, _WrappedTemporaryFile) and self.file.writable()) def get_reader(self): # _TemporaryFileWrapper has a file attribute which is an actual fileobj return self.file.file def get_writer(self): return self.file.file class IterableSource(IOSource): def can_read(self): if hasattr(self.file, '__iter__'): iterator = iter(self.file) head = next(iterator, None) if head is None: self.repaired = [] return True if isinstance(head, str): self.repaired = itertools.chain([head], iterator) return True else: # We may have mangled a generator at this point, so just abort raise IOSourceError( "Could not open source: %r (mode: %r)" % (self.file, self.options['mode'])) return False def can_write(self): return hasattr(self.file, 'append') and hasattr(self.file, '__iter__') def get_reader(self): return IterableStringReaderIO(self.repaired, newline=self.options['newline']) def get_writer(self): return IterableStringWriterIO(self.file, newline=self.options['newline']) class GzipCompressor(Compressor): name = 'gzip' streamable = True def can_read(self): return self.file.peek(2)[:2] == b'\x1f\x8b' def get_reader(self): return gzip.GzipFile(fileobj=self.file) def get_writer(self): return gzip.GzipFile(fileobj=self.file, mode='wb', compresslevel=self.options['compresslevel']) class BZ2Compressor(Compressor): name = 'bz2' streamable = False def can_read(self): return self.file.peek(3)[:3] == b'BZh' def get_reader(self): return bz2.BZ2File(self.file, mode='rb') def get_writer(self): return bz2.BZ2File(self.file, mode='wb', compresslevel=self.options['compresslevel']) class AutoCompressor(Compressor): streamable = True # We can' write so it doesn't matter name = 'auto' def get_reader(self): for compression_handler in _compressors(): compressor = compression_handler(self.file, self.options) if compressor.can_read(): return compressor.get_reader() return self.file def get_writer(self): return self.file scikit-bio-0.5.9/skbio/io/_warning.py000066400000000000000000000011321446255456000174660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- class FormatIdentificationWarning(Warning): """Warn when the sniffer of a format cannot confirm the format.""" pass class ArgumentOverrideWarning(Warning): """Warn when a user provided kwarg differs from a guessed kwarg.""" pass scikit-bio-0.5.9/skbio/io/format/000077500000000000000000000000001446255456000166035ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/format/__init__.py000066400000000000000000000005411446255456000207140ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/io/format/_base.py000066400000000000000000000164731446255456000202410ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re import warnings import numpy as np from skbio.util import cardinal_to_ordinal _whitespace_regex = re.compile(r'\s') _newline_regex = re.compile(r'\n') def _decode_qual_to_phred(qual_str, variant=None, phred_offset=None): phred_offset, phred_range = _get_phred_offset_and_range( variant, phred_offset, ["Must provide either `variant` or `phred_offset` in order to decode " "quality scores.", "Decoding Solexa quality scores is not currently supported, " "as quality scores are always stored as Phred scores in " "scikit-bio. Please see the following scikit-bio issue to " "track progress on this:\n\t" "https://github.com/biocore/scikit-bio/issues/719"]) qual = np.frombuffer(qual_str.encode('ascii'), dtype=np.uint8) - phred_offset if np.any((qual > phred_range[1]) | (qual < phred_range[0])): raise ValueError("Decoded Phred score is out of range [%d, %d]." % (phred_range[0], phred_range[1])) return qual def _encode_phred_to_qual(phred, variant=None, phred_offset=None): phred_offset, phred_range = _get_phred_offset_and_range( variant, phred_offset, ["Must provide either `variant` or `phred_offset` in order to encode " "Phred scores.", "Encoding Solexa quality scores is not currently supported. " "Please see the following scikit-bio issue to track progress " "on this:\n\t" "https://github.com/biocore/scikit-bio/issues/719"]) qual_chars = [] for score in phred: if score < phred_range[0]: raise ValueError("Phred score %d is out of range [%d, %d]." % (score, phred_range[0], phred_range[1])) if score > phred_range[1]: warnings.warn( "Phred score %d is out of targeted range [%d, %d]. Converting " "to %d." % (score, phred_range[0], phred_range[1], phred_range[1]), UserWarning) score = phred_range[1] qual_chars.append(chr(score + phred_offset)) return ''.join(qual_chars) def _get_phred_offset_and_range(variant, phred_offset, errors): if variant is None and phred_offset is None: raise ValueError(errors[0]) if variant is not None and phred_offset is not None: raise ValueError( "Cannot provide both `variant` and `phred_offset`.") if variant is not None: if variant == 'sanger': phred_offset = 33 phred_range = (0, 93) elif variant == 'illumina1.3': phred_offset = 64 phred_range = (0, 62) elif variant == 'illumina1.8': phred_offset = 33 phred_range = (0, 62) elif variant == 'solexa': phred_offset = 64 phred_range = (-5, 62) raise ValueError(errors[1]) else: raise ValueError("Unrecognized variant %r." % variant) else: if not (33 <= phred_offset <= 126): raise ValueError( "`phred_offset` %d is out of printable ASCII character range." % phred_offset) phred_range = (0, 126 - phred_offset) return phred_offset, phred_range def _get_nth_sequence(generator, seq_num): # i is set to None so that an empty generator will not result in an # undefined variable when compared to seq_num. i = None if seq_num is None or seq_num < 1: raise ValueError('Invalid sequence number (`seq_num`=%s). `seq_num`' ' must be between 1 and the number of sequences in' ' the file.' % str(seq_num)) try: for i, seq in zip(range(1, seq_num + 1), generator): pass finally: generator.close() if i == seq_num: return seq raise ValueError('Reached end of file before finding the %s sequence.' % cardinal_to_ordinal(seq_num)) def _parse_fasta_like_header(line): id_ = '' desc = '' header = line[1:].rstrip() if header: if header[0].isspace(): # no id desc = header.lstrip() else: header_tokens = header.split(None, 1) if len(header_tokens) == 1: # no description id_ = header_tokens[0] else: id_, desc = header_tokens return id_, desc def _format_fasta_like_records(generator, id_whitespace_replacement, description_newline_replacement, require_qual, lowercase=None): if ((id_whitespace_replacement is not None and '\n' in id_whitespace_replacement) or (description_newline_replacement is not None and '\n' in description_newline_replacement)): raise ValueError( "Newline character (\\n) cannot be used to replace whitespace in " "sequence IDs, nor to replace newlines in sequence descriptions.") for idx, seq in enumerate(generator): if len(seq) < 1: raise ValueError( "%s sequence does not contain any characters (i.e., it is an " "empty/blank sequence). Writing empty sequences is not " "supported." % cardinal_to_ordinal(idx + 1)) if 'id' in seq.metadata: id_ = '%s' % seq.metadata['id'] else: id_ = '' if id_whitespace_replacement is not None: id_ = _whitespace_regex.sub(id_whitespace_replacement, id_) if 'description' in seq.metadata: desc = '%s' % seq.metadata['description'] else: desc = '' if description_newline_replacement is not None: desc = _newline_regex.sub(description_newline_replacement, desc) if desc: header = '%s %s' % (id_, desc) else: header = id_ if require_qual and 'quality' not in seq.positional_metadata: raise ValueError( "Cannot write %s sequence because it does not have quality " "scores associated with it." % cardinal_to_ordinal(idx + 1)) qual = None if 'quality' in seq.positional_metadata: qual = seq.positional_metadata['quality'].values if lowercase is not None: seq_str = seq.lowercase(lowercase) else: seq_str = str(seq) yield header, "%s" % seq_str, qual def _line_generator(fh, skip_blanks=False, strip=True): for line in fh: if strip: line = line.strip() skip = False if skip_blanks: skip = line.isspace() or not line if not skip: yield line def _too_many_blanks(fh, max_blanks): count = 0 too_many = False for line in _line_generator(fh, skip_blanks=False): if line: break else: count += 1 if count > max_blanks: too_many = True break fh.seek(0) return too_many scikit-bio-0.5.9/skbio/io/format/_blast.py000066400000000000000000000046121446255456000204240ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import functools import contextlib import pandas as pd _possible_columns = {'qseqid': str, 'qgi': float, 'qacc': str, 'qaccver': str, 'qlen': float, 'sseqid': str, 'sallseqid': str, 'sgi': float, 'sallgi': float, 'sacc': str, 'saccver': str, 'sallacc': str, 'slen': float, 'qstart': float, 'qend': float, 'sstart': float, 'send': float, 'qseq': str, 'sseq': str, 'evalue': float, 'bitscore': float, 'score': float, 'length': float, 'pident': float, 'nident': float, 'mismatch': float, 'positive': float, 'gapopen': float, 'gaps': float, 'ppos': float, 'frames': str, 'qframe': float, 'sframe': float, 'btop': float, 'staxids': str, 'sscinames': str, 'scomnames': str, 'sblastnames': str, 'sskingdoms': str, 'stitle': str, 'salltitles': str, 'sstrand': str, 'qcovs': float, 'qcovhsp': float} def _parse_blast_data(fh, columns, error, error_message, comment=None, skiprows=None): read_csv = functools.partial(pd.read_csv, na_values='N/A', sep='\t', header=None, keep_default_na=False, comment=comment, skiprows=skiprows) # HACK for https://github.com/pandas-dev/pandas/issues/14418 # this avoids closing the `fh`, whose lifetime isn't the responsibility # of this parser with _noop_close(fh) as fh: lineone = read_csv(fh, nrows=1) if len(lineone.columns) != len(columns): raise error(error_message % (len(columns), len(lineone.columns))) fh.seek(0) return read_csv(fh, names=columns, dtype=_possible_columns) # HACK for https://github.com/pandas-dev/pandas/issues/14418 @contextlib.contextmanager def _noop_close(fh): backup = fh.close fh.close = lambda: None try: yield fh finally: fh.close = backup scikit-bio-0.5.9/skbio/io/format/_sequence_feature_vocabulary.py000066400000000000000000000247161446255456000251000ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re from skbio.metadata import IntervalMetadata from skbio.io.format._base import _line_generator from skbio.io import FileFormatError def _vocabulary_change(format='insdc', read_in=True): '''Return a dict that converts between memory and output vocabulary.''' convert = {'phase': {'insdc': 'codon_start'}, 'source': {'insdc': 'inference'}, 'db_xref': {'gff3': 'Dbxref'}, 'note': {'gff3': 'Note'}} if read_in: return {v[format]: k for k, v in convert.items() if format in v} else: return {k: v[format] for k, v in convert.items() if format in v} def _vocabulary_skip(format='insdc'): '''Return a list of vocabularies that should be skipped when auto output to disk for the specified format. ''' skip = {'type': ('insdc', 'gff3'), 'ID': ('insdc'), 'translation': ('gff3'), 'strand': ('insdc')} return [k for k, v in skip.items() if format in v] def _yield_section(is_another_section, **kwargs): '''Returns function that returns successive sections from file. Parameters ---------- is_another_section : callable It takes a string as input and return a boolean indicating a new section starts. kwargs : dict, optional Keyword arguments will be passed to `_line_generator`. Returns ------- function A function accept a list of lines as input and return a generator to yield section one by one. ''' def parser(lines): curr = [] for line in _line_generator(lines, **kwargs): # if we find another, return the previous section if is_another_section(line): if curr: yield curr curr = [] curr.append(line) # don't forget to return the last section in the file if curr: yield curr return parser def _parse_section_default( lines, label_delimiter=None, join_delimiter=' ', return_label=False): '''Parse sections in default way. Do 2 things: 1. split first line with label_delimiter for label 2. join all the lines into one str with join_delimiter. ''' data = [] label = None line = lines[0] items = line.split(label_delimiter, 1) if len(items) == 2: label, section = items else: label = items[0] section = "" data.append(section) data.extend(lines[1:]) data = join_delimiter.join(i.strip() for i in data) if return_label: return label, data else: return data def _serialize_section_default(header, obj, indent=12): return '{header:<{indent}}{obj}\n'.format( header=header, obj=obj, indent=indent) def _parse_feature_table(lines, length): '''parse DDBJ/ENA/GenBank Feature Table.''' imd = IntervalMetadata(length) # skip the 1st FEATURES line if lines[0].startswith('FEATURES'): lines = lines[1:] # magic number 21: the lines following header of each feature # are indented with 21 spaces. feature_indent = ' ' * 21 section_splitter = _yield_section( lambda x: not x.startswith(feature_indent), skip_blanks=True, strip=False) for section in section_splitter(lines): _parse_single_feature(section, imd) return imd def _parse_single_feature(lines, imd): '''Parse a feature. Parse a feature and add it to ``IntervalMetadata`` object. Parameters ---------- imd : IntervalMetadata ''' voca_change = _vocabulary_change('insdc') # each component of a feature starts with '/', except the 1st # component of location. section_splitter = _yield_section( lambda x: x.startswith('/'), strip=True) section_iter = section_splitter(lines) # 1st section is location section = next(section_iter) feature_type, feature_loc = _parse_section_default( section, join_delimiter='', return_label=True) metadata = {'type': feature_type, '__location': feature_loc} intvl = imd.add(*_parse_loc_str(feature_loc)) for section in section_iter: # following sections are Qualifiers k, v = _parse_section_default( section, label_delimiter='=', join_delimiter=' ', return_label=True) # 1st char is '/' k = k[1:] if k in voca_change: k = voca_change[k] if k == 'phase': v = int(v) - 1 # some Qualifiers can appear multiple times if k in metadata: if not isinstance(metadata[k], list): metadata[k] = [metadata[k]] metadata[k].append(v) else: metadata[k] = v intvl.metadata.update(metadata) def _parse_loc_str(loc_str): '''Parse location string. .. warning: This converts coordinates to 0-based from 1-based GenBank coordinate system. The location descriptor can be one of the following [1]_: (a) a single base number. e.g. 467 (b) a site between two indicated adjoining bases. e.g. 123^124 (c) a single base chosen from within a specified range of bases (not allowed for new entries). e.g. 102.110 (d) the base numbers delimiting a sequence span. e.g.340..565 (e) a remote entry identifier followed by a local location descriptor (i.e., a-d). e.g. J00194.1:100..202 Notes ----- This does not fully handle (e) case. It will discard the remote entry part and only keep the local part. When it parses locations across strand (e.g. "complement(123..145),200..209"), it will record all the span parts but will record strand as negative. References ---------- .. [1] http://www.insdc.org/files/feature_table.html#3.4 ''' # define the tokens operators = ['join', 'complement', 'order'] LPAREN = r'(?P\()' RPAREN = r'(?P\))' COMMA = r'(?P,)' WS = r'(?P\s+)' a = r'(?P\d+)' b = r'(?P\d+\^\d+)' c = r'(?P\d+\.\d+)' d = r'(?P?\d+)' e_left = r'(?P?\d+)' e_right = r'(?P?[a-zA-Z_0-9\.]+:\d+)' illegal = r'(?P.+)' # The order of tokens in the master regular expression also # matters. When matching, re tries to match pattens in the order # specified. Thus, if a pattern happens to be a substring of a # longer pattern, you need to make sure the longer pattern goes # first. master_pat = re.compile('|'.join( operators + [WS, LPAREN, RPAREN, COMMA, b, c, d, e_left, e_right, a, illegal])) scanner = master_pat.scanner(loc_str) bounds = [] fuzzy = [] metadata = {'strand': '+'} for m in iter(scanner.match, None): p, v = m.lastgroup, m.group() if v == 'complement': metadata['strand'] = '-' elif p == 'A': start = int(v) bounds.append((start-1, start)) fuzzy.append((False, False)) elif p == 'B': start, end = v.split('^') start = int(start) bounds.append((start-1, start)) fuzzy.append((False, False)) elif p == 'C' or p == 'D': if p == 'C': start, end = v.split('.') else: start, end = v.split('..') fuzzy_s = fuzzy_e = False if start.startswith('<'): start = start[1:] fuzzy_s = True if end.startswith('>'): end = end[1:] fuzzy_e = True bounds.append((int(start)-1, int(end))) fuzzy.append((fuzzy_s, fuzzy_e)) elif p == 'ILLEGAL': raise FileFormatError( 'Could not parse location string: "%s"' % loc_str) return bounds, fuzzy, metadata def _serialize_feature_table(intervals, indent=21): ''' Parameters ---------- intervals : list of ``Interval`` ''' for intvl in intervals: yield _serialize_single_feature(intvl, indent) def _serialize_single_feature(intvl, indent=21): ''' Parameters ---------- intvl : Interval ''' # there are 5 spaces before Feature Key starts. padding = ' ' * 5 qualifiers = [] md = intvl.metadata voca_skip = _vocabulary_skip('insdc') voca_change = _vocabulary_change('insdc', read_in=False) # sort it so the output order is deterministic for k in sorted(md): if k.startswith('__') or k in voca_skip: continue v = md[k] if k == 'phase': v = str(v + 1) if k in voca_change: k = voca_change[k] if isinstance(v, list): for vi in v: qualifiers.append(_serialize_qualifier(k, vi)) else: qualifiers.append(_serialize_qualifier(k, v)) if '__location' in md: loc = md['__location'] else: loc = _serialize_location(intvl) # the qualifiers start at column 22 qualifiers = [' ' * indent + i for i in qualifiers] return '{header:<{indent}}{loc}\n{qualifiers}\n'.format( header=padding + md['type'], loc=loc, indent=indent, qualifiers='\n'.join(qualifiers)) def _serialize_location(intvl): loc = [] for bound, fuzzy in zip(intvl.bounds, intvl.fuzzy): start, end = bound start += 1 if start == end: s = str(start) elif fuzzy[0] and fuzzy[1]: s = '<%d..>%d' % (start, end) elif fuzzy[0] and not fuzzy[1]: s = '<%d..%d' % (start, end) elif not fuzzy[0] and fuzzy[1]: s = '%d..>%d' % (start, end) else: s = '%d..%d' % (start, end) loc.append(s) if len(loc) > 1: loc_str = 'join({})'.format(','.join(loc)) else: loc_str = loc[0] if intvl.metadata.get('strand') == '-': loc_str = 'complement({})'.format(loc_str) return loc_str def _serialize_qualifier(key, value): '''Serialize a Qualifier in a feature. Parameters ---------- value : int, str ''' # if value is empty if not value: return '/%s' % key return '/{k}={v}'.format(k=key, v=value) scikit-bio-0.5.9/skbio/io/format/binary_dm.py000066400000000000000000000132431446255456000211240ustar00rootroot00000000000000""" Simple binary dissimilarity matrix format (:mod:`skbio.io.format.binary_dm`) ============================================================================ .. currentmodule:: skbio.io.format.binary_dm The Binary DisSimilarity Matrix format (``binary_dm``) encodes a binary representation for dissimilarity and distance matrices. The format is designed to facilitate rapid random access to individual rows or columns of a hollow matrix. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.stats.distance.DissimilarityMatrix` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.stats.distance.DistanceMatrix` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- The binary dissimilarity matrix and object identifiers are stored within an HDF5 [1]_ file. Both datatypes are represented by their own datasets. The `ids` dataset is of a variable length unicode type, while the `matrix` dataset are floating point. The shape of the `ids` is `(N,)`, and the shape of the `dissimilarities` is `(N, N)`. The diagonal of `matrix` are all zeros. The dissimilarity between `ids[i]` and `ids[j]` is interpreted to be the value at `matrix[i, j]`. `i` and `j` are integer indices. Required attributes: +-----------+---------------------+------------------------------+ |Attribute |Value |Description | | |type | | +===========+=====================+==============================+ |format |string |A string identifying the file | | | |as Binary DM format | +-----------+---------------------+------------------------------+ |version |string |The version of the current | | | |Binary DM format | +-----------+---------------------+------------------------------+ |matrix |float32 or float64 |A (N, N) dataset containing | | | |the values of the | | | |dissimilarity matrix | +-----------+---------------------+------------------------------+ |order |string |A (N,) dataset of the sample | | | |IDs, where N is the total | | | |number of IDs | +-----------+---------------------+------------------------------+ .. note:: This file format is most useful for storing large matrices that do not need to be represented in a human-readable format. This format is especially appropriate for facilitating random access to entries in the distance matrix, such as when calculating within and between distances for a subset of samples in a large matrix. References ---------- .. [1] http://www.hdfgroup.org/ """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import h5py from skbio.io import create_format from skbio.stats.distance import DissimilarityMatrix, DistanceMatrix binary_dm = create_format('binary_dm', encoding='binary') _vlen_dtype = h5py.special_dtype(vlen=str) @binary_dm.sniffer() def _binary_dm_sniffer(fh): try: f = h5py.File(fh, 'r') except OSError: return False, {} header = _get_header(f) if header is None: return False, {} ids = f.get('order') if ids is None: return False, {} mat = f.get('matrix') if mat is None: return False, {} n = len(ids) if mat.shape != (n, n): return False, {} return True, {} @binary_dm.reader(DissimilarityMatrix) def _binary_dm_to_dissimilarity(fh): return _h5py_mat_to_skbio_mat(fh) @binary_dm.reader(DistanceMatrix) def _binary_dm_to_distance(fh): return _h5py_mat_to_skbio_mat(fh) @binary_dm.writer(DissimilarityMatrix) def _dissimilarity_to_binary_dm(obj, fh): return _skbio_mat_to_h5py_mat(fh) @binary_dm.writer(DistanceMatrix) def _distance_to_binary_dm(obj, fh): return _skbio_mat_to_h5py_mat(fh) def _h5py_mat_to_skbio_mat(cls, fh): return cls(fh['matrix'], _parse_ids(fh['order'])) def _skbio_mat_to_h5py_mat(obj, fh): _set_header(fh) ids = fh.create_dataset('order', shape=(len(obj.ids), ), dtype=_vlen_dtype) ids[:] = obj.ids fh.create_dataset('matrix', data=obj.data) def _get_header(fh): format_ = fh.get('format') version = fh.get('version') if format is None or version is None: return None else: return {'format': format_[0], 'version': version[0]} def _parse_ids(ids): if isinstance(ids[0], bytes): return _bytes_decoder(ids) else: return _passthrough_decoder(ids) def _verify_dimensions(fh): if 'order' not in fh or 'matrix' not in fh: return False n = len(fh['order']) return fh['matrix'].shape == (n, n) def _bytes_decoder(x): return [i.decode('utf8') for i in x] def _passthrough_decoder(x): return x def _set_header(h5grp): """Set format spec header information""" h5grp['format'] = [b'BDSM', ] h5grp['version'] = [b'2020.06', ] scikit-bio-0.5.9/skbio/io/format/blast6.py000066400000000000000000000310171446255456000203520ustar00rootroot00000000000000""" BLAST+6 format (:mod:`skbio.io.format.blast6`) ============================================== .. currentmodule:: skbio.io.format.blast6 The BLAST+6 format (``blast+6``) stores the results of a BLAST [1]_ database search. The results are stored in a simple tabular format with no column headers. Values are separated by the tab character. An example BLAST+6-formatted file comparing two protein sequences, taken from [2]_ (tab characters represented by ````):: moaCgi|15800534|ref|NP_286546.1|100.00161001\ 16111613e-114330 moaCgi|170768970|ref|ZP_02903423.1|99.3816110\ 116111619e-114329 Format Support -------------- **Has Sniffer: No** **State: Experimental as of 0.4.1.** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |No |:mod:`pandas.DataFrame` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- BLAST+6 format is a tabular text-based format produced by both BLAST+ output format 6 (``-outfmt 6``) and legacy BLAST output format 8 (``-m 8``). It is tab-separated and has no column headers. With BLAST+, users can specify the columns that are present in their BLAST output file by specifying column names (e.g., ``-outfmt "6 qseqid sseqid bitscore qstart sstart"``), if the default columns output by BLAST are not desired. BLAST Column Types ^^^^^^^^^^^^^^^^^^ The following column types are output by BLAST and supported by scikit-bio. This information is taken from [3]_. +-----------+------------------------------------+-----+ |Name |Description |Type | +===========+====================================+=====+ |qseqid |Query Seq-id |str | +-----------+------------------------------------+-----+ |qgi |Query GI |int | +-----------+------------------------------------+-----+ |qacc |Query accesion |str | +-----------+------------------------------------+-----+ |qaccver |Query accesion.version |str | +-----------+------------------------------------+-----+ |qlen |Query sequence length |int | +-----------+------------------------------------+-----+ |sseqid |Subject Seq-id |str | +-----------+------------------------------------+-----+ |sallseqid |All subject Seq-id(s), separated by |str | | |a ';' | | +-----------+------------------------------------+-----+ |sgi |Subject GI |int | +-----------+------------------------------------+-----+ |sallgi |All subject GIs |int | +-----------+------------------------------------+-----+ |sacc |Subject accesion |str | +-----------+------------------------------------+-----+ |saccver |Subject accesion.version |str | +-----------+------------------------------------+-----+ |sallacc |All subject accesions |str | +-----------+------------------------------------+-----+ |slen |Subject sequence length |int | +-----------+------------------------------------+-----+ |qstart |Start of alignment in query |int | +-----------+------------------------------------+-----+ |qend |End of alignment in query |int | +-----------+------------------------------------+-----+ |sstart |Start of alignment in subject |int | +-----------+------------------------------------+-----+ |send |End of alignment in subject |int | +-----------+------------------------------------+-----+ |qseq |Aligned part of query sequence |str | +-----------+------------------------------------+-----+ |sseq |Aligned part of subject sequence |str | +-----------+------------------------------------+-----+ |evalue |Expect value |float| +-----------+------------------------------------+-----+ |bitscore |Bit score |float| +-----------+------------------------------------+-----+ |score |Raw score |int | +-----------+------------------------------------+-----+ |length |Alignment length |int | +-----------+------------------------------------+-----+ |pident |Percent of identical matches |float| +-----------+------------------------------------+-----+ |nident |Number of identical matches |int | +-----------+------------------------------------+-----+ |mismatch |Number of mismatches |int | +-----------+------------------------------------+-----+ |positive |Number of positive-scoring matches |int | +-----------+------------------------------------+-----+ |gapopen |Number of gap openings |int | +-----------+------------------------------------+-----+ |gaps |Total number of gaps |int | +-----------+------------------------------------+-----+ |ppos |Percentage of positive-scoring |float| | |matches | | +-----------+------------------------------------+-----+ |frames |Query and subject frames separated |str | | |by a '/' | | +-----------+------------------------------------+-----+ |qframe |Query frame |int | +-----------+------------------------------------+-----+ |sframe |Subject frame |int | +-----------+------------------------------------+-----+ |btop |Blast traceback operations (BTOP) |int | +-----------+------------------------------------+-----+ |staxids |Unique Subject Taxonomy ID(s), |str | | |separated by a ';' (in numerical | | | |order). | | +-----------+------------------------------------+-----+ |sscinames |Unique Subject Scientific Name(s), |str | | |separated by a ';' | | +-----------+------------------------------------+-----+ |scomnames |Unique Subject Common Name(s), |str | | |separated by a ';' | | +-----------+------------------------------------+-----+ |sblastnames|unique Subject Blast Name(s), |str | | |separated by a ';' (in alphabetical | | | |order) | | +-----------+------------------------------------+-----+ |sskingdoms |unique Subject Super Kingdom(s), |str | | |separated by a ';' (in alphabetical | | | |order) | | +-----------+------------------------------------+-----+ |stitle |Subject Title |str | +-----------+------------------------------------+-----+ |sstrand |Subject Strand |str | +-----------+------------------------------------+-----+ |salltitles |All Subject Title(s), separated by |str | | |a '<>' | | +-----------+------------------------------------+-----+ |qcovs |Query Coverage Per Subject |int | +-----------+------------------------------------+-----+ |qcovhsp |Query Coverage Per HSP |int | +-----------+------------------------------------+-----+ .. note:: When a BLAST+6-formatted file contains ``N/A`` values, scikit-bio will convert these values into ``np.nan``, matching pandas' convention for representing missing data. .. note:: scikit-bio stores columns of type ``int`` as type ``float`` in the returned ``pd.DataFrame``. This is necessary in order to allow ``N/A`` values in integer columns (this is currently a limitation of pandas). Format Parameters ----------------- The following format parameters are available in ``blast+6`` format: - ``default_columns``: ``False`` by default. If ``True``, will use the default columns output by BLAST, which are qseqid, sseqid, pident, length, mismatch, gapopen, qstart, qend, sstart, send, evalue, and bitscore. .. warning:: When reading legacy BLAST files, you must pass ``default_columns=True`` because legacy BLAST does not allow users to specify which columns are present in the output file. - ``columns``: ``None`` by default. If provided, must be a list of column names in the order they will appear in the file. .. note:: Either ``default_columns`` or ``columns`` must be provided, as ``blast+6`` does not contain column headers. Examples -------- Suppose we have a ``blast+6`` file with default columns: >>> from io import StringIO >>> import skbio.io >>> import pandas as pd >>> fs = '\\n'.join([ ... 'moaC\\tgi|15800534|ref|NP_286546.1|\\t100.00\\t161\\t0\\t0\\t1\\t161\ \\t1\\t161\\t3e-114\\t330', ... 'moaC\\tgi|170768970|ref|ZP_02903423.1|\\t99.38\\t161\\t1\\t0\\t1\\t\ 161\\t1\\t161\\t9e-114\\t329' ... ]) >>> fh = StringIO(fs) Read the file into a ``pd.DataFrame`` and specify that default columns should be used: >>> df = skbio.io.read(fh, format="blast+6", into=pd.DataFrame, ... default_columns=True) >>> df # doctest: +NORMALIZE_WHITESPACE qseqid sseqid pident length mismatch gapopen \\ 0 moaC gi|15800534|ref|NP_286546.1| 100.00 161.0 0.0 0.0 1 moaC gi|170768970|ref|ZP_02903423.1| 99.38 161.0 1.0 0.0 qstart qend sstart send evalue bitscore 0 1.0 161.0 1.0 161.0 3.000000e-114 330.0 1 1.0 161.0 1.0 161.0 9.000000e-114 329.0 Suppose we have a ``blast+6`` file with user-supplied (non-default) columns: >>> from io import StringIO >>> import skbio.io >>> import pandas as pd >>> fs = '\\n'.join([ ... 'moaC\\t100.00\\t0\\t161\\t0\\t161\\t330\\t1', ... 'moaC\\t99.38\\t1\\t161\\t0\\t161\\t329\\t1' ... ]) >>> fh = StringIO(fs) Read the file into a ``pd.DataFrame`` and specify which columns are present in the file: >>> df = skbio.io.read(fh, format="blast+6", into=pd.DataFrame, ... columns=['qseqid', 'pident', 'mismatch', 'length', ... 'gapopen', 'qend', 'bitscore', 'sstart']) >>> df # doctest: +NORMALIZE_WHITESPACE qseqid pident mismatch length gapopen qend bitscore sstart 0 moaC 100.00 0.0 161.0 0.0 161.0 330.0 1.0 1 moaC 99.38 1.0 161.0 0.0 161.0 329.0 1.0 References ---------- .. [1] Altschul, S.F., Gish, W., Miller, W., Myers, E.W. & Lipman, D.J. (1990) "Basic local alignment search tool." J. Mol. Biol. 215:403-410. .. [2] http://blastedbio.blogspot.com/2014/11/column-headers-in-blast-tabular-\ and-csv.html .. [3] http://www.ncbi.nlm.nih.gov/books/NBK279675/ """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import pandas as pd from skbio.io import create_format from skbio.io.format._blast import _parse_blast_data, _possible_columns blast6 = create_format('blast+6') _default_columns = ['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore'] @blast6.reader(pd.DataFrame, monkey_patch=False) def _blast6_to_data_frame(fh, columns=None, default_columns=False): if default_columns and columns is not None: raise ValueError("`columns` and `default_columns` cannot both be" " provided.") if not default_columns and columns is None: raise ValueError("Either `columns` or `default_columns` must be" " provided.") if default_columns: columns = _default_columns else: for column in columns: if column not in _possible_columns: raise ValueError("Unrecognized column (%r)." " Supported columns:\n%r" % (column, set(_possible_columns.keys()))) return _parse_blast_data(fh, columns, ValueError, "Specified number of columns (%r) does not equal" " number of columns in file (%r).") scikit-bio-0.5.9/skbio/io/format/blast7.py000066400000000000000000000354501446255456000203600ustar00rootroot00000000000000""" BLAST+7 format (:mod:`skbio.io.format.blast7`) ============================================== .. currentmodule:: skbio.io.format.blast7 The BLAST+7 format (``blast+7``) stores the results of a BLAST [1]_ database search. This format is produced by both BLAST+ output format 7 and legacy BLAST output format 9. The results are stored in a simple tabular format with headers. Values are separated by the tab character. An example BLAST+7-formatted file comparing two nucleotide sequences, taken from [2]_ (tab characters represented by ````): .. code-block:: none # BLASTN 2.2.18+ # Query: gi|1786181|gb|AE000111.1|AE000111 # Subject: ecoli # Fields: query acc., subject acc., evalue, q. start, q. end, s. st\ art, s. end # 5 hits found AE000111AE0001110.0110596110596 AE000111AE0001748e-305565567169286821 AE000111AE0003941e-2755875671135219 AE000111AE0004256e-265587567185528468 AE000111AE0001713e-245587567122142130 Format Support ============== **Has Sniffer: Yes** **State: Experimental as of 0.4.1.** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |No |:mod:`pandas.DataFrame` | +------+------+---------------------------------------------------------------+ Format Specification ==================== There are two BLAST+7 file formats supported by scikit-bio: BLAST+ output format 7 (``-outfmt 7``) and legacy BLAST output format 9 (``-m 9``). Both file formats are structurally similar, with minor differences. Example BLAST+ output format 7 file:: # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: q. start, q. end, s. start, s. end, identical, mismatches, sbjct\ frame, query acc.ver, subject acc.ver # 2 hits found 1 8 3 10 8 0 1 query1 subject2 2 5 2 15 8 0 2 query1 subject2 .. note:: Database searches without hits may occur in BLAST+ output format 7 files. scikit-bio ignores these "empty" records: .. code-block:: none # BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found Example legacy BLAST output format 9 file: .. code-block:: none # BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: AF178033 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap openings,q.\ start,q. end,s. start,s. end,e-value,bit score AF178033 EMORG:AF178033 100.00 811 0 0 1 811 1 811 0.0 1566.6 AF178033 EMORG:AF031394 99.63 811 3 0 1 811 99 909 0.0 1542.8 .. note:: scikit-bio requires fields to be consistent within a file. BLAST Column Types ------------------ The following column types are output by BLAST and supported by scikit-bio. For more information on these column types, see :mod:`skbio.io.format.blast6`. +-------------------+----------------------+ |Field Name |DataFrame Column Name | +===================+======================+ |query id |qseqid | +-------------------+----------------------+ |query gi |qgi | +-------------------+----------------------+ |query acc. |qacc | +-------------------+----------------------+ |query acc.ver |qaccver | +-------------------+----------------------+ |query length |qlen | +-------------------+----------------------+ |subject id |sseqid | +-------------------+----------------------+ |subject ids |sallseqid | +-------------------+----------------------+ |subject gi |sgi | +-------------------+----------------------+ |subject gis |sallgi | +-------------------+----------------------+ |subject acc. |sacc | +-------------------+----------------------+ |subject acc.ver |saccver | +-------------------+----------------------+ |subject accs |sallacc | +-------------------+----------------------+ |subject length |slen | +-------------------+----------------------+ |q\\. start |qstart | +-------------------+----------------------+ |q\\. end |qend | +-------------------+----------------------+ |s\\. start |sstart | +-------------------+----------------------+ |s\\. end |send | +-------------------+----------------------+ |query seq |qseq | +-------------------+----------------------+ |subject seq |sseq | +-------------------+----------------------+ |evalue |evalue | +-------------------+----------------------+ |bit score |bitscore | +-------------------+----------------------+ |score |score | +-------------------+----------------------+ |alignment length |length | +-------------------+----------------------+ |% identity |pident | +-------------------+----------------------+ |identical |nident | +-------------------+----------------------+ |mismatches |mismatch | +-------------------+----------------------+ |positives |positive | +-------------------+----------------------+ |gap opens |gapopen | +-------------------+----------------------+ |gaps |gaps | +-------------------+----------------------+ |% positives |ppos | +-------------------+----------------------+ |query/sbjct frames |frames | +-------------------+----------------------+ |query frame |qframe | +-------------------+----------------------+ |sbjct frame |sframe | +-------------------+----------------------+ |BTOP |btop | +-------------------+----------------------+ |subject tax ids |staxids | +-------------------+----------------------+ |subject sci names |sscinames | +-------------------+----------------------+ |subject com names |scomnames | +-------------------+----------------------+ |subject blast names|sblastnames | +-------------------+----------------------+ |subject super |sskingdoms | |kingdoms | | +-------------------+----------------------+ |subject title |stitle | +-------------------+----------------------+ |subject strand |sstrand | +-------------------+----------------------+ |subject titles |salltitles | +-------------------+----------------------+ |% query coverage |qcovs | |per subject | | +-------------------+----------------------+ |% query coverage |qcovhsp | |per hsp | | +-------------------+----------------------+ Examples ======== Suppose we have a BLAST+7 file: >>> from io import StringIO >>> import skbio.io >>> import pandas as pd >>> fs = '\\n'.join([ ... '# BLASTN 2.2.18+', ... '# Query: gi|1786181|gb|AE000111.1|AE000111', ... '# Database: ecoli', ... '# Fields: query acc., subject acc., evalue, q. start, q. end, s. st\ art, s. end', ... '# 5 hits found', ... 'AE000111\\tAE000111\\t0.0\\t1\\t10596\\t1\\t10596', ... 'AE000111\\tAE000174\\t8e-30\\t5565\\t5671\\t6928\\t6821', ... 'AE000111\\tAE000171\\t3e-24\\t5587\\t5671\\t2214\\t2130', ... 'AE000111\\tAE000425\\t6e-26\\t5587\\t5671\\t8552\\t8468' ... ]) >>> fh = StringIO(fs) Read the file into a ``pd.DataFrame``: >>> df = skbio.io.read(fh, into=pd.DataFrame) >>> df # doctest: +NORMALIZE_WHITESPACE qacc sacc evalue qstart qend sstart send 0 AE000111 AE000111 0.000000e+00 1.0 10596.0 1.0 10596.0 1 AE000111 AE000174 8.000000e-30 5565.0 5671.0 6928.0 6821.0 2 AE000111 AE000171 3.000000e-24 5587.0 5671.0 2214.0 2130.0 3 AE000111 AE000425 6.000000e-26 5587.0 5671.0 8552.0 8468.0 Suppose we have a legacy BLAST 9 file: >>> from io import StringIO >>> import skbio.io >>> import pandas as pd >>> fs = '\\n'.join([ ... '# BLASTN 2.2.3 [May-13-2002]', ... '# Database: other_vertebrate', ... '# Query: AF178033', ... '# Fields: ', ... 'Query id,Subject id,% identity,alignment length,mismatches,gap openin\ gs,q. start,q. end,s. start,s. end,e-value,bit score', ... 'AF178033\\tEMORG:AF178033\\t100.00\\t811\\t0\\t0\\t1\\t811\\t1\\t81\ 1\\t0.0\\t1566.6', ... 'AF178033\\tEMORG:AF178032\\t94.57\\t811\\t44\\t0\\t1\\t811\\t1\\t81\ 1\\t0.0\\t1217.7', ... 'AF178033\\tEMORG:AF178031\\t94.82\\t811\\t42\\t0\\t1\\t811\\t1\\t81\ 1\\t0.0\\t1233.5' ... ]) >>> fh = StringIO(fs) Read the file into a ``pd.DataFrame``: >>> df = skbio.io.read(fh, into=pd.DataFrame) >>> df[['qseqid', 'sseqid', 'pident']] # doctest: +NORMALIZE_WHITESPACE qseqid sseqid pident 0 AF178033 EMORG:AF178033 100.00 1 AF178033 EMORG:AF178032 94.57 2 AF178033 EMORG:AF178031 94.82 References ========== .. [1] Altschul, S.F., Gish, W., Miller, W., Myers, E.W. & Lipman, D.J. (1990) "Basic local alignment search tool." J. Mol. Biol. 215:403-410. .. [2] http://www.ncbi.nlm.nih.gov/books/NBK279682/ """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import pandas as pd from skbio.io import create_format, BLAST7FormatError from skbio.io.format._blast import _parse_blast_data blast7 = create_format('blast+7') column_converter = {'query id': 'qseqid', 'query gi': 'qgi', 'query acc.': 'qacc', 'query acc.ver': 'qaccver', 'query length': 'qlen', 'subject id': 'sseqid', 'subject ids': 'sallseqid', 'subject gi': 'sgi', 'subject gis': 'sallgi', 'subject acc.': 'sacc', 'subject acc.ver': 'saccver', 'subject accs.': 'sallacc', 'subject length': 'slen', 'q. start': 'qstart', 'q. end': 'qend', 's. start': 'sstart', 's. end': 'send', 'query seq': 'qseq', 'subject seq': 'sseq', 'evalue': 'evalue', 'bit score': 'bitscore', 'score': 'score', 'alignment length': 'length', '% identity': 'pident', 'identical': 'nident', 'mismatches': 'mismatch', 'positives': 'positive', 'gap opens': 'gapopen', 'gaps': 'gaps', '% positives': 'ppos', 'query/sbjct frames': 'frames', 'query frame': 'qframe', 'sbjct frame': 'sframe', 'BTOP': 'btop', 'subject tax ids': 'staxids', 'subject sci names': 'sscinames', 'subject com names': 'scomnames', 'subject blast names': 'sblastnames', 'subject super kingdoms': 'sskingdoms', 'subject title': 'stitle', 'subject titles': 'salltitles', 'subject strand': 'sstrand', '% query coverage per subject': 'qcovs', '% query coverage per hsp': 'qcovhsp', 'Query id': 'qseqid', 'Subject id': 'sseqid', 'gap openings': 'gapopen', 'e-value': 'evalue'} @blast7.sniffer() def _blast7_sniffer(fh): # Smells a BLAST+7 file if the following conditions are present # -First line contains "BLAST" # -Second line contains "Query" or "Database" # -Third line starts with "Subject" or "Query" or "Database" lines = [line for _, line in zip(range(3), fh)] if len(lines) < 3: return False, {} if not lines[0].startswith("# BLAST"): return False, {} if not (lines[1].startswith("# Query:") or lines[1].startswith("# Database:")): return False, {} if not (lines[2].startswith("# Subject:") or lines[2].startswith("# Query:") or lines[2].startswith("# Database:")): return False, {} return True, {} @blast7.reader(pd.DataFrame, monkey_patch=False) def _blast7_to_data_frame(fh): line_num = 0 columns = None skiprows = [] for line in fh: if line == "# Fields: \n": # Identifies Legacy BLAST 9 data line = next(fh) line_num += 1 if columns is None: columns = _parse_fields(line, legacy=True) skiprows.append(line_num) else: next_columns = _parse_fields(line, legacy=True) if columns != next_columns: raise BLAST7FormatError("Fields %r do not equal fields %r" % (columns, next_columns)) skiprows.append(line_num) elif line.startswith("# Fields: "): # Identifies BLAST+7 data if columns is None: columns = _parse_fields(line) else: # Affirms data types do not differ throught file next_columns = _parse_fields(line) if columns != next_columns: raise BLAST7FormatError("Fields %r do not equal fields %r" % (columns, next_columns)) line_num += 1 if columns is None: # Affirms file contains BLAST data raise BLAST7FormatError("File contains no BLAST data.") fh.seek(0) return _parse_blast_data(fh, columns, BLAST7FormatError, "Number of fields (%r) does not equal number" " of data columns (%r).", comment='#', skiprows=skiprows) def _parse_fields(line, legacy=False): """Removes '\n' from fields line and returns fields as a list (columns).""" line = line.rstrip('\n') if legacy: fields = line.split(',') else: line = line.split('# Fields: ')[1] fields = line.split(', ') columns = [] for field in fields: if field not in column_converter: raise BLAST7FormatError("Unrecognized field (%r)." " Supported fields: %r" % (field, set(column_converter.keys()))) columns.append(column_converter[field]) return columns scikit-bio-0.5.9/skbio/io/format/clustal.py000066400000000000000000000276041446255456000206350ustar00rootroot00000000000000r""" Clustal format (:mod:`skbio.io.format.clustal`) =============================================== .. currentmodule:: skbio.io.format.clustal Clustal format (``clustal``) stores multiple sequence alignments. This format was originally introduced in the Clustal package [1]_. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.alignment.TabularMSA` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- A clustal-formatted file is a plain text format. It can optionally have a header, which states the clustal version number. This is followed by the multiple sequence alignment, and optional information about the degree of conservation at each position in the alignment [2]_. Alignment Section ^^^^^^^^^^^^^^^^^ Each sequence in the alignment is divided into subsequences each at most 60 characters long. The sequence identifier for each sequence precedes each subsequence. Each subsequence can optionally be followed by the cumulative number of non-gap characters up to that point in the full sequence (not included in the examples below). A line containing conservation information about each position in the alignment can optionally follow all of the subsequences (not included in the examples below). .. note:: scikit-bio ignores conservation information when reading and does not support writing conservation information. .. note:: When reading a clustal-formatted file into an ``skbio.alignment.TabularMSA`` object, sequence identifiers/labels are stored as ``TabularMSA`` index labels (``index`` property). When writing an ``skbio.alignment.TabularMSA`` object as a clustal-formatted file, ``TabularMSA`` index labels will be converted to strings and written as sequence identifiers/labels. Format Parameters ----------------- The only supported format parameter is ``constructor``, which specifies the type of in-memory sequence object to read each aligned sequence into. This must be a subclass of ``GrammaredSequence`` (e.g., ``DNA``, ``RNA``, ``Protein``) and is a required format parameter. For example, if you know that the clustal file you're reading contains DNA sequences, you would pass ``constructor=DNA`` to the reader call. Examples -------- Assume we have a clustal-formatted file of RNA sequences: .. code-block:: none CLUSTAL W (1.82) multiple sequence alignment abc GCAUGCAUCUGCAUACGUACGUACGCAUGCAUCA def ---------------------------------- xyz ---------------------------------- abc GUCGAUACAUACGUACGUCGUACGUACGU-CGAC def ---------------CGCGAUGCAUGCAU-CGAU xyz -----------CAUGCAUCGUACGUACGCAUGAC We can use the following code to read the clustal file into a ``TabularMSA``: >>> from skbio import TabularMSA, RNA >>> clustal_f = ['CLUSTAL W (1.82) multiple sequence alignment\n', ... '\n', ... 'abc GCAUGCAUCUGCAUACGUACGUACGCAUGCA\n', ... 'def -------------------------------\n', ... 'xyz -------------------------------\n', ... '\n', ... 'abc GUCGAUACAUACGUACGUCGGUACGU-CGAC\n', ... 'def ---------------CGUGCAUGCAU-CGAU\n', ... 'xyz -----------CAUUCGUACGUACGCAUGAC\n'] >>> msa = TabularMSA.read(clustal_f, constructor=RNA) >>> msa TabularMSA[RNA] -------------------------------------------------------------- Stats: sequence count: 3 position count: 62 -------------------------------------------------------------- GCAUGCAUCUGCAUACGUACGUACGCAUGCAGUCGAUACAUACGUACGUCGGUACGU-CGAC ----------------------------------------------CGUGCAUGCAU-CGAU ------------------------------------------CAUUCGUACGUACGCAUGAC >>> msa.index Index(['abc', 'def', 'xyz'], dtype='object') We can use the following code to write a ``TabularMSA`` to a clustal-formatted file: >>> from io import StringIO >>> from skbio import DNA >>> seqs = [DNA('ACCGTTGTA-GTAGCT', metadata={'id': 'seq1'}), ... DNA('A--GTCGAA-GTACCT', metadata={'id': 'sequence-2'}), ... DNA('AGAGTTGAAGGTATCT', metadata={'id': '3'})] >>> msa = TabularMSA(seqs, minter='id') >>> msa TabularMSA[DNA] ---------------------- Stats: sequence count: 3 position count: 16 ---------------------- ACCGTTGTA-GTAGCT A--GTCGAA-GTACCT AGAGTTGAAGGTATCT >>> msa.index Index(['seq1', 'sequence-2', '3'], dtype='object') >>> fh = StringIO() >>> _ = msa.write(fh, format='clustal') >>> print(fh.getvalue()) # doctest: +NORMALIZE_WHITESPACE CLUSTAL seq1 ACCGTTGTA-GTAGCT sequence-2 A--GTCGAA-GTACCT 3 AGAGTTGAAGGTATCT References ---------- .. [1] http://www.sciencedirect.com/science/article/pii/0378111988903307 .. [2] http://web.mit.edu/meme_v4.9.0/doc/clustalw-format.html """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.io import create_format, ClustalFormatError from skbio.alignment import TabularMSA clustal = create_format('clustal') def _label_line_parser(record): """Returns dict mapping list of data to labels, plus list with field order. Field order contains labels in order encountered in file. NOTE: doesn't care if lines are out of order in different blocks. This should never happen anyway, but it's possible that this behavior should be changed to tighten up validation. """ labels = [] result = {} for line in record: split_line = line.strip().rsplit(None, 1) if len(split_line) == 2: key, val = split_line else: raise ClustalFormatError( "Failed to parse sequence identifier and subsequence from " "the following line: %r" % line) if key in result: result[key].append(val) else: result[key] = [val] labels.append(key) return result, labels def _is_clustal_seq_line(line): """Returns True if line starts with a non-blank character but not 'CLUSTAL' Useful for filtering other lines out of the file. """ return line and (not line[0].isspace()) and\ (not line.startswith('CLUSTAL')) and (not line.startswith('MUSCLE')) def _delete_trailing_number(line): """Deletes trailing number from a line. WARNING: does not preserve internal whitespace when a number is removed! (converts each whitespace run to a single space). Returns the original line if it didn't end in a number. """ pieces = line.split() try: int(pieces[-1]) return ' '.join(pieces[:-1]) except ValueError: # no trailing numbers return line def _check_length(data, labels, num_seqs_check=None): """ Checks the lengths of the clustal sequences to make sure that they are lining up right num_seqs_check: The number of sequences to check Return True if all of the subsequence lengths are equal or if data is empty Return False if one of the subsequence lengths differs """ if len(labels) == 0: return True num_subseqs = len(data[labels[0]]) if num_seqs_check is None: num_seqs_check = num_subseqs else: if num_seqs_check > num_subseqs: num_seqs_check = num_subseqs subseq_length = len(data[labels[0]][0]) end_lengths = set() # subsequence lengths at end of file for i in range(num_seqs_check): for label in labels: seq = data[label][i] if len(seq) > subseq_length: return False elif i+1 == num_subseqs: # Last subsequence end_lengths.add(len(seq)) elif len(seq) < subseq_length: return False # All trailing subsequences must be the same if len(end_lengths) > 1: return False return True @clustal.sniffer() def _clustal_sniffer(fh): # Strategy # The following conditions preclude a file from being clustal # * It is an empty file # * The whole sequences have differing lengths # * The sub-sequences have differing lengths # * One of the sequence ids is not immediately # followed by a subsequence empty = True if fh.read(7) != 'CLUSTAL': return False, {} fh.seek(0) try: records = map(_delete_trailing_number, filter(_is_clustal_seq_line, fh)) data, labels = _label_line_parser(records) if len(data) > 0: empty = False # Only check first 50 sequences aligned_correctly = _check_length(data, labels, 50) if not aligned_correctly: raise ClustalFormatError("Sequences not aligned properly") except ClustalFormatError: return False, {} return not empty, {} @clustal.writer(TabularMSA) def _tabular_msa_to_clustal(obj, fh): if not obj.index.is_unique: raise ClustalFormatError( "TabularMSA's index labels must be unique.") clen = 60 # Max length of clustal lines seqs = [str(s) for s in obj] names = [str(label) for label in obj.index] nameLen = max(map(len, names)) seqLen = max(map(len, seqs)) fh.write('CLUSTAL\n\n\n') for i in range(0, seqLen, clen): for label, seq in zip(names, seqs): name = ('{:<%d}' % (nameLen)).format(label) fh.write("%s\t%s\n" % (name, seq[i:i+clen])) fh.write("\n") @clustal.reader(TabularMSA) def _clustal_to_tabular_msa(fh, constructor=None): r"""yields labels and sequences from msa (multiple sequence alignment) Parameters ---------- fh : open file object An open Clustal file. Returns ------- skbio.TabularMSA MSA containing aligned sequences. Raises ------ skbio.util.exception.ClustalFormatError If the sequences in `fh` don't have the same sequence length or if the sequence ids don't properly match with the subsequences Notes ----- Skips any line that starts with a blank. ``_clustal_to_tabular_msa`` preserves the order of the sequences from the original file. However, it does use a dict as an intermediate, so two sequences can't have the same label. This is probably OK since Clustal will refuse to run on a FASTA file in which two sequences have the same label, but could potentially cause trouble with manually edited files (all the segments of the conflicting sequences would be interleaved, possibly in an unpredictable way). If the lines have trailing numbers (i.e. Clustal was run with `-LINENOS=ON`), silently deletes them. Does not check that the numbers actually correspond to the number of chars in the sequence printed so far. References ---------- .. [1] Thompson JD, Higgins DG, Gibson TJ, "CLUSTAL W: improving the sensitivity of progressive multiple sequence alignment through sequence weighting, position-specific gap penalties and weight matrix choice. Thompson", Nucleic Acids Res. 1994 Nov 11;22(22):4673-80. """ if constructor is None: raise ValueError("Must provide `constructor`.") records = map(_delete_trailing_number, filter(_is_clustal_seq_line, fh)) data, labels = _label_line_parser(records) aligned_correctly = _check_length(data, labels) if not aligned_correctly: raise ClustalFormatError("Sequences not aligned properly") seqs = [] for label in labels: seqs.append(constructor(''.join(data[label]))) return TabularMSA(seqs, index=labels) scikit-bio-0.5.9/skbio/io/format/embl.py000066400000000000000000001513061446255456000201020ustar00rootroot00000000000000""" EMBL format (:mod:`skbio.io.format.embl`) ========================================= .. currentmodule:: skbio.io.format.embl EMBL format stores sequence and its annotation together. The start of the annotation section is marked by a line beginning with the word "ID". The start of sequence section is marked by a line beginning with the word "SQ". The "//" (terminator) line also contains no data or comments and designates the end of an entry. More information on EMBL file format can be found here [1]_. The EMBL file may end with .embl or .txt extension. An example of EMBL file can be seen here [2]_. Feature Level Products ^^^^^^^^^^^^^^^^^^^^^^ As described in [3]_ *"Feature-level products contain nucleotide sequence and related annotations derived from submitted ENA assembled and annotated sequences. Data are distributed in flatfile format, similar to that of parent ENA records, with each flatfile representing a single feature"*. While only the sequence of the feature is included in such entries, features are derived from the parent entry, and can't be applied as interval metadata. For such reason, interval metatdata are ignored from Feature-level products, as they will be ignored by subsetting a generic Sequence object. Format Support -------------- **Has Sniffer: Yes** **NOTE: No protein support at the moment** Current protein support development is tracked in issue-1499 [4]_ +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.RNA` | +------+------+---------------------------------------------------------------+ |No |No |:mod:`skbio.sequence.Protein` | +------+------+---------------------------------------------------------------+ |Yes |Yes | generator of :mod:`skbio.sequence.Sequence` objects | +------+------+---------------------------------------------------------------+ Format Specification -------------------- **State: Experimental as of 0.5.1** Sections before ``FH (Feature Header)`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ All the sections before ``FH (Feature Header)`` will be read into the attribute of ``metadata``. The header and its content of a section are stored as key-value pairs in ``metadata``. For the ``RN (Reference Number)`` section, its value is stored as a list, as there are often multiple reference sections in one EMBL record. ``FT`` section ^^^^^^^^^^^^^^ See :ref:`Genbank FEATURES section` ``SQ`` section ^^^^^^^^^^^^^^ The sequence in the ``SQ`` section is always in lowercase for the EMBL files downloaded from ENA. For the RNA molecules, ``t`` (thymine), instead of ``u`` (uracil) is used in the sequence. All EMBL writers follow these conventions while writing EMBL files. Examples -------- Reading EMBL Files ^^^^^^^^^^^^^^^^^^ Suppose we have the following EMBL file example: >>> embl_str = ''' ... ID X56734; SV 1; linear; mRNA; STD; PLN; 1859 BP. ... XX ... AC X56734; S46826; ... XX ... DT 12-SEP-1991 (Rel. 29, Created) ... DT 25-NOV-2005 (Rel. 85, Last updated, Version 11) ... XX ... DE Trifolium repens mRNA for non-cyanogenic beta-glucosidase ... XX ... KW beta-glucosidase. ... XX ... OS Trifolium repens (white clover) ... OC Eukaryota; Viridiplantae; Streptophyta; Embryophyta; Tracheophyta; ... OC Spermatophyta; Magnoliophyta; eudicotyledons; Gunneridae; ... OC Pentapetalae; rosids; fabids; Fabales; Fabaceae; Papilionoideae; ... OC Trifolieae; Trifolium. ... XX ... RN [5] ... RP 1-1859 ... RX DOI; 10.1007/BF00039495. ... RX PUBMED; 1907511. ... RA Oxtoby E., Dunn M.A., Pancoro A., Hughes M.A.; ... RT "Nucleotide and derived amino acid sequence of the cyanogenic ... RT beta-glucosidase (linamarase) from white clover ... RT (Trifolium repens L.)"; ... RL Plant Mol. Biol. 17(2):209-219(1991). ... XX ... RN [6] ... RP 1-1859 ... RA Hughes M.A.; ... RT ; ... RL Submitted (19-NOV-1990) to the INSDC. ... RL Hughes M.A., University of Newcastle Upon Tyne, Medical School, ... RL Newcastle ... RL Upon Tyne, NE2 4HH, UK ... XX ... DR MD5; 1e51ca3a5450c43524b9185c236cc5cc. ... XX ... FH Key Location/Qualifiers ... FH ... FT source 1..1859 ... FT /organism="Trifolium repens" ... FT /mol_type="mRNA" ... FT /clone_lib="lambda gt10" ... FT /clone="TRE361" ... FT /tissue_type="leaves" ... FT /db_xref="taxon:3899" ... FT mRNA 1..1859 ... FT /experiment="experimental evidence, no additional ... FT details recorded" ... FT CDS 14..1495 ... FT /product="beta-glucosidase" ... FT /EC_number="3.2.1.21" ... FT /note="non-cyanogenic" ... FT /db_xref="GOA:P26204" ... FT /db_xref="InterPro:IPR001360" ... FT /db_xref="InterPro:IPR013781" ... FT /db_xref="InterPro:IPR017853" ... FT /db_xref="InterPro:IPR033132" ... FT /db_xref="UniProtKB/Swiss-Prot:P26204" ... FT /protein_id="CAA40058.1" ... FT /translation="MDFIVAIFALFVISSFTITSTNAVEASTLLDIGNLSRS ... FT SFPRGFIFGAGSSAYQFEGAVNEGGRGPSIWDTFTHKYPEKIRDGSNADITV ... FT DQYHRYKEDVGIMKDQNMDSYRFSISWPRILPKGKLSGGINHEGIKYYNNLI ... FT NELLANGIQPFVTLFHWDLPQVLEDEYGGFLNSGVINDFRDYTDLCFKEFGD ... FT RVRYWSTLNEPWVFSNSGYALGTNAPGRCSASNVAKPGDSGTGPYIVTHNQI ... FT LAHAEAVHVYKTKYQAYQKGKIGITLVSNWLMPLDDNSIPDIKAAERSLDFQ ... FT FGLFMEQLTTGDYSKSMRRIVKNRLPKFSKFESSLVNGSFDFIGINYYSSSY ... FT ISNAPSHGNAKPSYSTNPMTNISFEKHGIPLGPRAASIWIYVYPYMFIQEDF ... FT EIFCYILKINITILQFSITENGMNEFNDATLPVEEALLNTYRIDYYYRHLYY ... FT IRSAIRAGSNVKGFYAWSFLDCNEWFAGFTVRFGLNFVD" ... XX ... SQ Sequence 1859 BP; 609 A; 314 C; 355 G; 581 T; 0 other; ... aaacaaacca aatatggatt ttattgtagc catatttgct ctgtttgtta ttagctcatt ... cacaattact tccacaaatg cagttgaagc ttctactctt cttgacatag gtaacctgag ... tcggagcagt tttcctcgtg gcttcatctt tggtgctgga tcttcagcat accaatttga ... aggtgcagta aacgaaggcg gtagaggacc aagtatttgg gataccttca cccataaata ... tccagaaaaa ataagggatg gaagcaatgc agacatcacg gttgaccaat atcaccgcta ... caaggaagat gttgggatta tgaaggatca aaatatggat tcgtatagat tctcaatctc ... ttggccaaga atactcccaa agggaaagtt gagcggaggc ataaatcacg aaggaatcaa ... atattacaac aaccttatca acgaactatt ggctaacggt atacaaccat ttgtaactct ... ttttcattgg gatcttcccc aagtcttaga agatgagtat ggtggtttct taaactccgg ... tgtaataaat gattttcgag actatacgga tctttgcttc aaggaatttg gagatagagt ... gaggtattgg agtactctaa atgagccatg ggtgtttagc aattctggat atgcactagg ... aacaaatgca ccaggtcgat gttcggcctc caacgtggcc aagcctggtg attctggaac ... aggaccttat atagttacac acaatcaaat tcttgctcat gcagaagctg tacatgtgta ... taagactaaa taccaggcat atcaaaaggg aaagataggc ataacgttgg tatctaactg ... gttaatgcca cttgatgata atagcatacc agatataaag gctgccgaga gatcacttga ... cttccaattt ggattgttta tggaacaatt aacaacagga gattattcta agagcatgcg ... gcgtatagtt aaaaaccgat tacctaagtt ctcaaaattc gaatcaagcc tagtgaatgg ... ttcatttgat tttattggta taaactatta ctcttctagt tatattagca atgccccttc ... acatggcaat gccaaaccca gttactcaac aaatcctatg accaatattt catttgaaaa ... acatgggata cccttaggtc caagggctgc ttcaatttgg atatatgttt atccatatat ... gtttatccaa gaggacttcg agatcttttg ttacatatta aaaataaata taacaatcct ... gcaattttca atcactgaaa atggtatgaa tgaattcaac gatgcaacac ttccagtaga ... agaagctctt ttgaatactt acagaattga ttactattac cgtcacttat actacattcg ... ttctgcaatc agggctggct caaatgtgaa gggtttttac gcatggtcat ttttggactg ... taatgaatgg tttgcaggct ttactgttcg ttttggatta aactttgtag attagaaaga ... tggattaaaa aggtacccta agctttctgc ccaatggtac aagaactttc tcaaaagaaa ... ctagctagta ttattaaaag aactttgtag tagattacag tacatcgttt gaagttgagt ... tggtgcacct aattaaataa aagaggttac tcttaacata tttttaggcc attcgttgtg ... aagttgttag gctgttattt ctattatact atgttgtagt aataagtgca ttgttgtacc ... agaagctatg atcataacta taggttgatc cttcatgtat cagtttgatg ttgagaatac ... tttgaattaa aagtcttttt ttattttttt aaaaaaaaaa aaaaaaaaaa aaaaaaaaa ... // ... ''' Now we can read it as ``DNA`` object: >>> import io >>> from skbio import DNA, RNA, Sequence >>> embl = io.StringIO(embl_str) >>> dna_seq = DNA.read(embl) >>> dna_seq DNA ---------------------------------------------------------------------- Metadata: 'ACCESSION': 'X56734; S46826;' 'CROSS_REFERENCE': 'DATE': 'DBSOURCE': 'MD5; 1e51ca3a5450c43524b9185c236cc5cc.' 'DEFINITION': 'Trifolium repens mRNA for non-cyanogenic beta- glucosidase' 'KEYWORDS': 'beta-glucosidase.' 'LOCUS': 'REFERENCE': 'SOURCE': 'VERSION': 'X56734.1' Interval metadata: 3 interval features Stats: length: 1859 has gaps: False has degenerates: False has definites: True GC-content: 35.99% ---------------------------------------------------------------------- 0 AAACAAACCA AATATGGATT TTATTGTAGC CATATTTGCT CTGTTTGTTA TTAGCTCATT 60 CACAATTACT TCCACAAATG CAGTTGAAGC TTCTACTCTT CTTGACATAG GTAACCTGAG ... 1740 AGAAGCTATG ATCATAACTA TAGGTTGATC CTTCATGTAT CAGTTTGATG TTGAGAATAC 1800 TTTGAATTAA AAGTCTTTTT TTATTTTTTT AAAAAAAAAA AAAAAAAAAA AAAAAAAAA Since this is a mRNA molecule, we may want to read it as ``RNA``. As the EMBL file usually have ``t`` instead of ``u`` in the sequence, we can read it as ``RNA`` by converting ``t`` to ``u``: >>> embl = io.StringIO(embl_str) >>> rna_seq = RNA.read(embl) >>> rna_seq RNA ---------------------------------------------------------------------- Metadata: 'ACCESSION': 'X56734; S46826;' 'CROSS_REFERENCE': 'DATE': 'DBSOURCE': 'MD5; 1e51ca3a5450c43524b9185c236cc5cc.' 'DEFINITION': 'Trifolium repens mRNA for non-cyanogenic beta- glucosidase' 'KEYWORDS': 'beta-glucosidase.' 'LOCUS': 'REFERENCE': 'SOURCE': 'VERSION': 'X56734.1' Interval metadata: 3 interval features Stats: length: 1859 has gaps: False has degenerates: False has definites: True GC-content: 35.99% ---------------------------------------------------------------------- 0 AAACAAACCA AAUAUGGAUU UUAUUGUAGC CAUAUUUGCU CUGUUUGUUA UUAGCUCAUU 60 CACAAUUACU UCCACAAAUG CAGUUGAAGC UUCUACUCUU CUUGACAUAG GUAACCUGAG ... 1740 AGAAGCUAUG AUCAUAACUA UAGGUUGAUC CUUCAUGUAU CAGUUUGAUG UUGAGAAUAC 1800 UUUGAAUUAA AAGUCUUUUU UUAUUUUUUU AAAAAAAAAA AAAAAAAAAA AAAAAAAAA We can also ``trascribe`` a sequence and verify that it will be a ``RNA`` sequence >>> rna_seq == dna_seq.transcribe() True Reading EMBL Files using generators ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Soppose we have an EMBL file with multiple records: we can instantiate a generator object to deal with multiple records >>> import skbio >>> embl = io.StringIO(embl_str) >>> embl_gen = skbio.io.read(embl, format="embl") >>> dna_seq = next(embl_gen) For more informations, see :mod:`skbio.io` References ---------- .. [1] ftp://ftp.ebi.ac.uk/pub/databases/embl/release/doc/usrman.txt .. [2] http://www.ebi.ac.uk/ena/data/view/X56734&display=text .. [3] http://www.ebi.ac.uk/ena/browse/feature-level-products .. [4] https://github.com/biocore/scikit-bio/issues/1499 """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- # std modules import re import copy import textwrap from functools import partial # skbio modules from skbio.io import create_format, EMBLFormatError from skbio.io.format._base import (_line_generator, _get_nth_sequence) from skbio.io.format._sequence_feature_vocabulary import ( _yield_section, _parse_single_feature, _serialize_section_default, _serialize_single_feature) from skbio.metadata import IntervalMetadata from skbio.sequence import Sequence, DNA, RNA, Protein from skbio.util._misc import chunk_str # look at skbio.io.registry to have an idea on how to define this class embl = create_format('embl') # This list is ordered used to read and write embl file. By processing those # values one by one, I will write embl sections with the same order _HEADERS = [ 'LOCUS', 'ACCESSION', 'PARENT_ACCESSION', 'PROJECT_IDENTIFIER', 'DATE', 'DEFINITION', 'GENE_NAME', 'KEYWORDS', 'SOURCE', 'REFERENCE', 'DBSOURCE', 'COMMENT', 'FEATURES' ] # embl has a series of keys different from genbank; moreover keys are not so # easy to understand (eg. RA for AUTHORS). I want to use the same keys used by # genbank both to convert between formats and to use the same methods to get # info from Sequence and its derived objects Here is a dictionary of keys # conversion (EMBL->GB). All the unspecified keys will remain in embl format KEYS_TRANSLATOR = { # identification 'ID': 'LOCUS', 'AC': 'ACCESSION', # PA means PARENT ACCESSION (?) and applies to # feature-level-products entries 'PA': 'PARENT_ACCESSION', 'PR': 'PROJECT_IDENTIFIER', 'DT': 'DATE', 'DE': 'DEFINITION', 'GN': 'GENE_NAME', # uniprot specific 'KW': 'KEYWORDS', # Source (taxonomy and classification) 'OS': 'ORGANISM', 'OC': 'taxonomy', 'OG': 'organelle', # reference keys 'RA': 'AUTHORS', 'RP': 'REFERENCE', 'RC': 'REFERENCE_COMMENT', 'RX': 'CROSS_REFERENCE', 'RG': 'GROUP', 'RT': 'TITLE', 'RL': 'JOURNAL', # Cross references 'DR': 'DBSOURCE', 'CC': 'COMMENT', # features 'FH': 'FEATURES', 'FT': 'FEATURES', 'SQ': 'ORIGIN', } # the inverse of KEYS_TRANSLATOR, for semplicity REV_KEYS_TRANSLATOR = {v: k for k, v in KEYS_TRANSLATOR.items()} # the original genbank _yield_section divides entries in sections relying on # spaces (the same section has the same level of indentation). EMBL entries # have a key for each line, so to divide record in sections I need to define a # correspondance for each key to section, then I will divide a record in # sections using these section name. KEYS_2_SECTIONS = { # identification 'ID': 'LOCUS', 'AC': 'ACCESSION', # PA means PARENT ACCESSION (?) and applies to # feature-level-products entries 'PA': 'PARENT_ACCESSION', 'PR': 'PROJECT_IDENTIFIER', 'DT': 'DATE', 'DE': 'DEFINITION', 'GN': 'GENE_NAME', # uniprot specific 'KW': 'KEYWORDS', # Source (taxonomy and classification) 'OS': 'SOURCE', 'OC': 'SOURCE', 'OG': 'SOURCE', # reference keys 'RA': 'REFERENCE', 'RP': 'REFERENCE', 'RC': 'REFERENCE', 'RX': 'REFERENCE', 'RG': 'REFERENCE', 'RT': 'REFERENCE', 'RL': 'REFERENCE', # This shuold be Reference Number. However, to split # between references with _embl_yield_section I need to # change section after reading one reference. So a single # reference is completed when I found a new RN. The # reference number information will be the reference # position in the final REFERENCE list metadata 'RN': 'SPACER', # Cross references 'DR': 'DBSOURCE', 'CC': 'COMMENT', 'AH': 'ASSEMBLY', 'AS': 'ASSEMBLY', 'FH': 'FEATURES', 'FT': 'FEATURES', # sequence 'SQ': 'ORIGIN', ' ': 'ORIGIN', 'CO': 'CONSTRUCTED', # spacer (discarded) 'XX': 'SPACER' } # for convenience: I think such functions are more readadble while accessing # values in lambda functions def _get_embl_key(line): """Return first part of a string as a embl key (ie 'AC M14399;' -> 'AC')""" # embl keys have a fixed size of 2 chars return line[:2] def _get_embl_section(line): """Return the embl section from uniprot key(ie 'RA' -> 'REFERENCE')""" # get embl key key = _get_embl_key(line) # get embl section from key section = KEYS_2_SECTIONS[key] return section def _translate_key(key): """A method to translate a single key from EMBL to genbank. Returns key itself if no traslation is defined""" return KEYS_TRANSLATOR.get(key, key) # a method to translate keys from embl to genbank for a dict object. All keys # not defined in the original dict will remain the same def _translate_keys(data): """Translate a dictionary of uniprot key->value in a genbank like dictionary of key values. Keep old keys if no translation is defined""" # traslate keys and get a new_data object new_data = {_translate_key(k): v for k, v in data.items()} return new_data # define a default textwrap.Wrapper for embl def _get_embl_wrapper(embl_key, indent=5, subsequent_indent=None, width=80): """Returns a textwrap.TextWrapper for embl records (eg, write by providing embl key and a string. Wrap text to 80 column""" # define the string to prepen (eg "OC ") prepend = '{key:<{indent}}'.format(key=embl_key, indent=indent) # deal with 2° strings and more if subsequent_indent is None: subsequent_prepend = prepend else: subsequent_prepend = '{key:<{indent}}'.format( key=embl_key, indent=subsequent_indent) # define a text wrapper object wrapper = textwrap.TextWrapper( initial_indent=prepend, subsequent_indent=subsequent_prepend, width=width ) return wrapper def _serialize_list(embl_wrapper, data, sep="\n"): """Serialize a list of obj using a textwrap.TextWrapper instance. Returns one string of wrapped embl objects""" # the output array output = [] for line in data: output += embl_wrapper.wrap(line) # merge dates in one string. Add final newline output = sep.join(output) + "\n" # return comupted string return output # Method to determine if file is in EMBL format or not. A uniprot embl format # can't be parsed by this module (at the moment) @embl.sniffer() def _embl_sniffer(fh): try: line = next(_line_generator(fh, skip_blanks=True, strip=False)) except StopIteration: return False, {} try: _parse_id([line]) except EMBLFormatError: return False, {} return True, {} @embl.reader(None) def _embl_to_generator(fh, constructor=None, **kwargs): for record in _parse_embls(fh): yield _construct(record, constructor, **kwargs) # Method to read EMBL data as skbio.sequence.DNA @embl.reader(Sequence) def _embl_to_sequence(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_embls(fh), seq_num) return _construct(record, Sequence, **kwargs) # Method to read EMBL data as skbio.sequence.DNA @embl.reader(DNA) def _embl_to_dna(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_embls(fh), seq_num) return _construct(record, DNA, **kwargs) # Method to read EMBL data as skbio.sequence.DNA @embl.reader(RNA) def _embl_to_rna(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_embls(fh), seq_num) return _construct(record, RNA, **kwargs) # No protein support at the moment @embl.reader(Protein) def _embl_to_protein(fh, seq_num=1, **kwargs): # no protein support, at the moment raise EMBLFormatError("There's no protein support for EMBL record. " "Current status of EMBL protein support is " "described in issue-1499 (https://github.com/" "biocore/scikit-bio/issues/1499)") # Writer methods @embl.writer(None) def _generator_to_embl(obj, fh): for obj_i in obj: _serialize_single_embl(obj_i, fh) @embl.writer(Sequence) def _sequence_to_embl(obj, fh): _serialize_single_embl(obj, fh) @embl.writer(DNA) def _dna_to_embl(obj, fh): _serialize_single_embl(obj, fh) @embl.writer(RNA) def _rna_to_embl(obj, fh): _serialize_single_embl(obj, fh) @embl.writer(Protein) def _protein_to_embl(obj, fh): # no protein support, at the moment raise EMBLFormatError("There's no protein support for EMBL record. " "Current status of EMBL protein support is " "described in issue-1499 (https://github.com/" "biocore/scikit-bio/issues/1499)") def _construct(record, constructor=None, **kwargs): '''Construct the object of Sequence, DNA, RNA, or Protein.''' # sequence, metadata and interval metadata seq, md, imd = record if 'lowercase' not in kwargs: kwargs['lowercase'] = True if constructor is None: unit = md['LOCUS']['unit'] if unit == 'bp': # RNA mol type has T instead of U for genbank from from NCBI constructor = DNA elif unit == 'aa': # no protein support, at the moment # constructor = Protein raise EMBLFormatError("There's no protein support for EMBL record") if constructor == RNA: return DNA( seq, metadata=md, interval_metadata=imd, **kwargs).transcribe() else: return constructor( seq, metadata=md, interval_metadata=imd, **kwargs) # looks like the genbank _parse_genbank def _parse_embls(fh): """Chunck multiple EMBL records by '//', and returns a generator""" data_chunks = [] for line in _line_generator(fh, skip_blanks=True, strip=False): if line.startswith('//'): yield _parse_single_embl(data_chunks) data_chunks = [] else: data_chunks.append(line) def _parse_single_embl(chunks): metadata = {} interval_metadata = None sequence = '' # define a section splitter with _embl_yield_section function defined in # this module (return the embl section by embl key). returns generator for # each block with different line type section_splitter = _embl_yield_section( lambda line: _get_embl_section(line), skip_blanks=True, strip=False) # process each section, like genbank does. for section, section_name in section_splitter(chunks): # section is a list of records with the same session (eg RA, RP for # for a single reference). section_name is the name of the section # (eg REFERENCE for the section of the previous example) # search for a specific method in PARSER_TABLE using section_name or # set _embl_parse_section_default parser = _PARSER_TABLE.get( section_name, _embl_parse_section_default) if section_name == 'FEATURES': # This requires 'ID' line parsed before 'FEATURES', which should # be true and is implicitly checked by the sniffer. This is true # since the first section is parsed by the last else condition if "PARENT_ACCESSION" in metadata: # this is a feature-level-products entry and features are # relative to parent accession; in the same way a subset of a # Sequence object has no interval metadata, I will refuse to # process interval metadata here continue # partials add arguments to previous defined functions, in this # case length of Sequence object parser = partial( parser, length=metadata["LOCUS"]["size"]) elif section_name == "COMMENT": # mantain newlines in comments # partials add arguments to previous defined functions parser = partial( parser, join_delimiter="\n") # call function on section parsed = parser(section) # reference can appear multiple times if section_name == 'REFERENCE': # genbank data hasn't CROSS_REFERENCE section, To have a similar # metatadata object, I chose to remove CROSS_REFERENCE from # each single reference and put them in metadata. Since I could # have more references, I need a list of CROSS_REFERENCE, with # None values when CROSS_REFERENCE are not defined: there are cases # in which some references have a CROSS_REFERENCE and others not. # So each reference will have it's cross reference in the same # index position, defined or not cross_reference = parsed.pop("CROSS_REFERENCE", None) # fix REFERENCE metadata. Ask if is the first reference or not # I need a reference number as genbank, this could be reference # size if section_name in metadata: RN = len(metadata[section_name]) + 1 else: RN = 1 # fix reference fields. Get RN->REFERENCE value from dict positions = parsed.pop("REFERENCE", None) parsed["REFERENCE"] = str(RN) # append position to RN (eg "1 (bases 1 to 63)") if positions: parsed["REFERENCE"] += " %s" % (positions) # cross_reference will be a list of cross reference; Also # metadata[REFERENCE] is a list of references if section_name in metadata: # I've already seen a reference, append new one metadata[section_name].append(parsed) metadata["CROSS_REFERENCE"].append(cross_reference) else: # define a list for this first reference and its RX metadata[section_name] = [parsed] metadata["CROSS_REFERENCE"] = [cross_reference] elif section_name == 'ORIGIN': sequence = parsed elif section_name == 'FEATURES': interval_metadata = parsed elif section_name == 'DATE': # read data (list) metadata[section_name] = parsed # fix locus metadata using last date. Take only last date date = metadata[section_name][-1].split()[0] metadata["LOCUS"]["date"] = date # parse all the others sections (SOURCE, ...) else: metadata[section_name] = parsed # after metadata were read, add a VERSION section like genbank # eval if entry is a feature level product or not if "ACCESSION" in metadata: metadata["VERSION"] = "{accession}.{version}".format( accession=metadata["ACCESSION"].split(";")[0], version=metadata["LOCUS"]["version"]) elif "PARENT_ACCESSION" in metadata: # locus name is in the format # .::[:ordinal] # and ordinal could be present or not, depends on how many features # are found in such location. Such entry couldn't be found in others # database like NCBI (at the moment) so we will take the version # relying on parent accession (hoping that an update in the parent # accession will generate an update in all feature level products) metadata["VERSION"] = metadata["PARENT_ACCESSION"] # return a string, metatdata as a dictionary and IntervalMetadata object return sequence, metadata, interval_metadata def _write_serializer(fh, serializer, embl_key, data): """A simple method to write serializer to a file. Append 'XX'""" # call the serializer function out = serializer(embl_key, data) # test if 'out' is a iterator. # cf. Effective Python Item 17 if iter(out) is iter(out): for s in out: fh.write(s) else: fh.write(out) # add spacer between sections fh.write("XX\n") # main function for writer methods def _serialize_single_embl(obj, fh): '''Write a EMBL record. Always write it in ENA canonical way: 1. sequence in lowercase (uniprot are uppercase) 2. 'u' as 't' even in RNA molecules. Parameters ---------- obj : Sequence or its child class ''' # shortcut to deal with metadata md = obj.metadata # embl has a different magick number than embl serialize_default = partial( _serialize_section_default, indent=5) # Now cicle for GB like headers (sections) in _HEADERS. for header in _HEADERS: # Get appropriate serializer method or default one serializer = _SERIALIZER_TABLE.get( header, serialize_default) # headers needs to be converted into embl, or matained as they are # if no conversion could be defined. embl_key = REV_KEYS_TRANSLATOR.get(header, header) # this is true also for locus line if header in md: # deal with special source case, add cross references if needed if header == "REFERENCE": serializer = partial( serializer, cross_references=md.get("CROSS_REFERENCE")) elif header == "LOCUS": # pass also metadata (in case of entries from genbank) serializer = partial( serializer, metadata=md) # call the serializer function _write_serializer(fh, serializer, embl_key, md[header]) else: # header not in metadata. Could be date read from GB? if header == "DATE": # Have I date in locus metadata? if md["LOCUS"]["date"]: # call serializer on date. Date is a list of values _write_serializer( fh, serializer, embl_key, [md["LOCUS"]["date"]]) if header == 'FEATURES': if obj.has_interval_metadata(): # magic number 21: the amount of indentation before # feature table starts as defined by INSDC indent = 21 feature_key = "FH Key" fh.write('{header:<{indent}}Location/Qualifiers\n'.format( header=feature_key, indent=indent)) # add FH spacer fh.write("FH\n") for s in serializer(obj.interval_metadata._intervals, indent): fh.write(s) # add spacer between sections fh.write("XX\n") # write out the sequence # always write RNA seq as DNA if isinstance(obj, RNA): obj = obj.reverse_transcribe() # serialize sequence from a Sequence object for s in _serialize_sequence(obj): fh.write(s) # terminate a embl record with fh.write('//\n') def _parse_id(lines): """ From EMBL user manual (Release 130, November 2016) (ftp://ftp.ebi.ac.uk/pub/databases/embl/release/doc/usrman.txt) The ID (IDentification) line is always the first line of an entry. The format of the ID line is: ID <1>; SV <2>; <3>; <4>; <5>; <6>; <7> BP. The tokens represent: 1. Primary accession number 2. Sequence version number 3. Topology: 'circular' or 'linear' 4. Molecule type (see note 1 below) 5. Data class (see section 3.1 of EMBL user manual) 6. Taxonomic division (see section 3.2 of EMBL user manual) 7. Sequence length (see note 2 below) Note 1 - Molecule type: this represents the type of molecule as stored and can be any value from the list of current values for the mandatory mol_type source qualifier. This item should be the same as the value in the mol_type qualifier(s) in a given entry. Note 2 - Sequence length: The last item on the ID line is the length of the sequence (the total number of bases in the sequence). This number includes base positions reported as present but undetermined (coded as "N"). An example of a complete identification line is shown below: ID CD789012; SV 4; linear; genomic DNA; HTG; MAM; 500 BP. """ # get only the first line of EMBL record line = lines[0] # define a specific patter for EMBL pattern = re.compile(r'ID' r' +([^\s]+);' # ie: CD789012 r' +SV ([0-9]*);' # 4 r' +(\w+);' # linear r' +([^;]+);' # genomic DNA r' +(\w*);' # HTG r' +(\w+);' # MAM r' +(\d+)' # 500 r' +(\w+)\.$') # BP # search it matches = re.match(pattern, line) try: res = dict(zip( ['locus_name', 'version', 'shape', 'mol_type', 'class', 'division', 'size', 'unit'], matches.groups())) except AttributeError: raise EMBLFormatError( "Could not parse the ID line:\n%s" % line) # check for CON entries: if res['class'] == "CON": # entries like http://www.ebi.ac.uk/ena/data/view/LT357133 # doesn't have sequence, so can't be read by skbio.sequence raise EMBLFormatError( "There's no support for embl CON record: for more information " "see issue-1506 (https://github.com/biocore/scikit-bio/issues/" "1506)") # those values are integer res['size'] = int(res['size']) # version could be integer if res['version']: res['version'] = int(res['version']) # unit are in lower cases in others modules res['unit'] = res['unit'].lower() # initialize a date record (for gb compatibility) res['date'] = None # returning parsed attributes return res def _serialize_id(header, obj, metadata={}, indent=5): '''Serialize ID line. Parameters ---------- obj : dict ''' # get key->value pairs, or key->'' if values is None kwargs = {k: '' if v is None else v for k, v in obj.items()} # then unit is in upper cases kwargs["unit"] = kwargs["unit"].upper() # check for missing keys (eg from gb data). Keys in md are in uppercase for key in ["version", "class"]: if key not in kwargs: if key.upper() in metadata: kwargs[key] = metadata[key.upper()] else: kwargs[key] = "" # version from genbank could be "M14399.1 GI:145229". I need an integer version = kwargs["version"] # version could by empty, integer or text if version != '': try: int(kwargs["version"]) # could be a text like M14399.1 except ValueError: match = re.search(r"^\w+\.([0-9]+)", version) if match: kwargs["version"] = match.groups()[0] # return first line return ('{header:<{indent}}{locus_name}; SV {version}; {shape}; ' '{mol_type}; {class}; {division}; {size} {unit}.\n').format( header=header, indent=indent, **kwargs) # similar to skbio.io.format._sequence_feature_vocabulary.__yield_section # but applies to embl file format def _embl_yield_section(get_line_key, **kwargs): '''Returns function that returns successive sections from file. Parameters ---------- get_line_key : callable It takes a string as input and a key indicating the section (could be the embl key or embl KEYS_2_SECTIONS) kwargs : dict, optional Keyword arguments will be passed to `_line_generator`. Returns ------- function A function accept a list of lines as input and return a generator to yield section one by one. ''' def parser(lines): curr = [] curr_type = None for line in _line_generator(lines, **kwargs): # if we find another line, return the previous section line_type = get_line_key(line) # changed line type if line_type != curr_type: if curr: # returning block yield curr, curr_type # reset curr after yield curr = [] # reset curr_type in any cases curr_type = line_type # don't append record if line type is a spacer if 'SPACER' not in line_type: curr.append(line) # don't forget to return the last section in the file if curr: yield curr, curr_type return parser # replace skbio.io.format._sequence_feature_vocabulary._parse_section_default def _embl_parse_section_default( lines, label_delimiter=None, join_delimiter=' ', return_label=False): '''Parse sections in default way. Do 2 things: 1. split first line with label_delimiter for label 2. join all the lines into one str with join_delimiter. ''' data = [] label = None line = lines[0] # take the first line, divide the key from the text items = line.split(label_delimiter, 1) if len(items) == 2: label, section = items else: label = items[0] section = "" # append the text of the first element in a empty array data.append(section) # Then process all the elements with the same embl key. remove the key # and append all the text in the data array data.extend(line.split(label_delimiter, 1)[-1] for line in lines[1:]) # Now concatenate the text using join_delimiter. All content with the same # key will be placed in the same string. Strip final "\n data = join_delimiter.join(i.strip() for i in data) # finally return the merged text content, and the key if needed if return_label: return label, data else: return data # parse an embl reference record. def _parse_reference(lines): '''Parse single REFERENCE field. ''' # parsed reference will be placed here res = {} # define a section splitter with _embl_yield_section function defined in # this module section_splitter = _embl_yield_section(lambda line: _get_embl_key(line), skip_blanks=True, strip=False) # now itereta along sections (lines of the same type) for section, section_name in section_splitter(lines): # this function append all data in the same keywords. A list of lines # as input (see skbio.io.format._sequence_feature_vocabulary) label, data = _embl_parse_section_default( section, join_delimiter=' ', return_label=True) res[label] = data # now RX (CROSS_REFERENCE) is a joined string of multiple values. To get # back to a list of values you can use: re.compile("([^;\s]*); ([^\s]*)") # search for pubmed record, and add the PUBMED key if "RX" in res: match = re.search(r"PUBMED; (\d+)\.", res["RX"]) if match: # add pubmed notation res["PUBMED"] = match.groups()[0] # fix RP field like genbank (if exists), Ie: (bases 1 to 63) if "RP" in res: match = re.search(r"(\d+)-(\d+)", res["RP"]) if match: # fix rp fields res["RP"] = "(bases {start} to {stop})".format( start=match.groups()[0], stop=match.groups()[1]) # return translated keys (EMBL->GB) return _translate_keys(res) def _serialize_reference(header, obj, cross_references, indent=5): """Serialize a list of references""" reference = [] sort_order = ["RC", "RP", "RX", "RG", "RA", "RT", "RL"] # deal with RX pattern and RP pattern RX = re.compile(r"([^;\s]*); ([^\s]*)") RP = re.compile(r"bases (\d+) to (\d+)") # create a copy of obj, that can be changed. I need to delete values or # adding new ones obj = copy.deepcopy(obj) # obj is a list of references. Now is a copy of metadata[SOURCE] for i, data in enumerate(obj): # get the reference number (as the iteration number) embl_key = "RN" # get cross_references if cross_references: cross_reference = cross_references[i] # append cross reference [i] to data (obj[i]) (if they exists) if cross_reference: data["CROSS_REFERENCE"] = cross_reference # delete PUBMED key (already present in CROSS_REFERENCE) if "PUBMED" in data: del (data["PUBMED"]) else: # no cross reference, do I have PUBMED in data? if "PUBMED" in data: # add a fake CROSS_REFERENCE data["CROSS_REFERENCE"] = 'PUBMED; %s.' % data["PUBMED"] # get an embl wrapper wrapper = _get_embl_wrapper(embl_key, indent) # define wrapped string and add RN to embl data reference += wrapper.wrap("[{RN}]".format(RN=i+1)) # now process each record for references for embl_key in sort_order: # get internal key (genbank like key) key = _translate_key(embl_key) # have I this reference in my reference data? if key not in data: continue # if yes, define wrapper wrapper = _get_embl_wrapper(embl_key, indent) # data could have newlines records = data[key].split("\n") for record in records: # strip after newlines record = record.strip() # define wrapped string. beware RX if embl_key == "RX": for match in re.finditer(RX, record): source, link = match.groups() # join text cross_reference = "; ".join([source, link]) reference += wrapper.wrap(cross_reference) # RP case elif embl_key == "RP": match = re.search(RP, record) # if I have position, re-define RP key if match: record = "%s-%s" % match.groups() reference += wrapper.wrap(record) # if not, ignore RP key else: continue # all the other cases, go in wrapper as they are else: reference += wrapper.wrap(record) # add a spacer between references (but no at the final reference) # cause the caller will add spacer if (i+1) < len(obj): reference += ["XX"] # now define a string and add a final "\n" s = "\n".join(reference) + "\n" # and return it return s # parse an embl reference record. def _parse_source(lines): '''Parse single SOURCE field. ''' # parsed reference will be placed here res = {} # define a section splitter with _embl_yield_section function defined in # this module section_splitter = _embl_yield_section(lambda line: _get_embl_key(line), skip_blanks=True, strip=False) # now itereta along sections (lines of the same type) for section, section_name in section_splitter(lines): # this function append all data in the same keywords. A list of lines # as input (see skbio.io.format._sequence_feature_vocabulary) label, data = _embl_parse_section_default( section, join_delimiter=' ', return_label=True) res[label] = data # return translated keys return _translate_keys(res) def _serialize_source(header, obj, indent=5): '''Serialize SOURCE. Parameters ---------- header: section header obj : dict indent : indent length ''' source = [] # treat taxonomy and all others keys for key in ["ORGANISM", "taxonomy", "organelle"]: # get data to serielize data = obj.get(key) # if key is not defined (eg. organelle, continue) if data is None: continue # get embl key for my key (eg, taxonomy -> OC) embl_key = REV_KEYS_TRANSLATOR.get(key, key) # get an embl wrapper wrapper = _get_embl_wrapper(embl_key, indent) # define wrapped string source += wrapper.wrap(data) # now define a string and add a final "\n" s = "\n".join(source) + "\n" # and return it return s def _parse_sequence(lines): '''Parse the sequence section for sequence.''' # result array sequence = [] for line in lines: # ignore record like: # SQ Sequence 275 BP; 64 A; 73 C; 88 G; 50 T; 0 other; if line.startswith('SQ'): continue # remove the numbers inside strings. revome spaces around string items = [i for i in line.split() if not i.isdigit()] # append each sequence items to sequence list sequence += items return ''.join(sequence) def _serialize_sequence(obj, indent=5): '''Serialize seq to SQ. Parameters ---------- obj : DNA, RNA, Sequence Obj ''' # a flag to determine if I wrote header or not flag_header = False # magic numbers: there will be 60 letters (AA, bp) on each line chunk_size = 60 # letters (AA, bp) will be grouped by 10: each group is divided by # one space from each other frag_size = 10 # fasta sequence will have indent spaces on the left, chunk_size/frag_size # groups of frag_size letters separated by n-1 groups of single spaces, # then the sequence length aligned on the right to get a string of # line_size. Setting left and right padding for semplicity pad_right = 65 # there are also 5 columns for indentation pad_left = 10 # sequence number will be in the last 10 columns # get sequence as a string with lower letters (uniprot will be upper!) seq = str(obj).lower() # count bases in sequence. Frequencies returns a dictionary of occurences # of A,C,G,T. Sequences are stored always in capital letters freq = obj.frequencies() # get values instead of popping them: I can't assure that the letter T, # for example, is always present n_a = freq.get('A', 0) n_c = freq.get('C', 0) n_g = freq.get('G', 0) n_t = freq.get('T', 0) # this will be the count of all others letters (more than ACGT) n_others = len(obj) - (n_a + n_c + n_g + n_t) # define SQ like this: # SQ Sequence 275 BP; 63 A; 72 C; 88 G; 52 T; 0 other; SQ = "SQ Sequence {size} {unit}; {n_a} A; {n_c} C; {n_g} G; " +\ "{n_t} T; {n_others} other;\n" # TODO: deal with protein SQ: they have a sequence header like: # SQ SEQUENCE 256 AA; 29735 MW; B4840739BF7D4121 CRC64; # apply format SQ = SQ.format(size=len(obj), unit=obj.metadata["LOCUS"]["unit"].upper(), n_a=n_a, n_c=n_c, n_g=n_g, n_t=n_t, n_others=n_others) for i in range(0, len(seq), chunk_size): line = seq[i:i+chunk_size] # pad string left and right s = '{indent}{s:<{pad_right}}{pos:>{pad_left}}\n'.format( indent=" "*indent, s=chunk_str(line, frag_size, ' '), pad_left=pad_left, pos=i+len(line), pad_right=pad_right) if not flag_header: # First time here. Add SQ header to sequence s = SQ + s # When I added header, I need to turn off this flag flag_header = True yield s def _embl_parse_feature_table(lines, length): """Parse embl feature tables""" # define interval metadata imd = IntervalMetadata(length) # get only FT records, and remove key from line lines = [line[2:] for line in lines if line.startswith('FT')] # magic number 19: after key removal, the lines of each feature # are indented with 19 spaces. feature_indent = ' ' * 19 section_splitter = _yield_section( lambda x: not x.startswith(feature_indent), skip_blanks=True, strip=False) for section in section_splitter(lines): _parse_single_feature(section, imd) return imd def _serialize_feature_table(intervals, indent=21): ''' Parameters ---------- intervals : list of ``Interval`` ''' # define a embl wrapper object. I need to replace only the first two # characters from _serialize_single_feature output wrapper = _get_embl_wrapper("FT", indent=2, subsequent_indent=21) for intvl in intervals: tmp = _serialize_single_feature(intvl, indent) output = [] # I need to remove two spaces, cause I will add a FT key for line in tmp.split("\n"): output += wrapper.wrap(line[2:]) # re add newline between elements, and a final "\n" yield "\n".join(output) + "\n" def _parse_date(lines, label_delimiter=None, return_label=False): """Parse embl date records""" # take the first line, and derive a label label = lines[0].split(label_delimiter, 1)[0] # read all the others dates and append to data array data = [line.split(label_delimiter, 1)[-1] for line in lines] # strip returned data data = [i.strip() for i in data] # finally return data array, and the key if needed if return_label: return label, data else: return data def _serialize_date(embl_key, date_list, indent=5): '''Serialize date line. Parameters ---------- header : embl key id date_list : a list of dates ''' # get an embl wrapper wrapper = _get_embl_wrapper(embl_key, indent) # # serialize date and return them as a string return _serialize_list(wrapper, date_list) def _serialize_comment(embl_key, obj, indent=5): """Serialize comment (like Assembly)""" # obj is a string, Split it by newlines data = obj.split("\n") # get an embl wrapper wrapper = _get_embl_wrapper(embl_key, indent) # serialize data and return it return _serialize_list(wrapper, data) def _serialize_dbsource(embl_key, obj, indent=5): """Serialize DBSOURCE""" # data are stored like 'SILVA-LSU; LK021130. SILVA-SSU; LK021130. ... # I need to split string after final period (not AAT09660.1) # deal with re pattern. A pattern to find a period as end of sentence DR = re.compile(r"\.\s") # splitting by this pattern, I will have # ["SILVA-LSU; LK021130", "SILVA-SSU; LK021130", ...] # I need that each of them will be in a DR record. # get an embl wrapper wrapper = _get_embl_wrapper(embl_key, indent) # serialize data and return it. Split dbsource using re. Add a # final period between elements since I removed it by splitting return _serialize_list(wrapper, re.split(DR, obj), sep=".\n") def _parse_assembly(lines): """Parse embl assembly records""" output = [] # first line is header, skip it for line in lines[1:]: data = line.split() # data could have comp feature or not. First element in data is 'AS' if len(data) == 5: res = dict(zip( ['local_span', 'primary_identifier', 'primary_span', 'comp'], data[1:])) elif len(data) == 4: res = dict(zip( ['local_span', 'primary_identifier', 'primary_span', 'comp'], data[1:]+[''])) else: raise EMBLFormatError("Can't parse assembly line %s" % line) # append res to output output += [res] return output # Map a function to each section of the entry _PARSER_TABLE = { 'LOCUS': _parse_id, 'SOURCE': _parse_source, 'DATE': _parse_date, 'REFERENCE': _parse_reference, 'FEATURES': _embl_parse_feature_table, 'ORIGIN': _parse_sequence, 'ASSEMBLY': _parse_assembly, } # for writer functions _SERIALIZER_TABLE = { 'LOCUS': _serialize_id, 'SOURCE': _serialize_source, 'DATE': _serialize_date, 'REFERENCE': _serialize_reference, 'FEATURES': _serialize_feature_table, 'COMMENT': _serialize_comment, 'DBSOURCE': _serialize_dbsource, } scikit-bio-0.5.9/skbio/io/format/emptyfile.py000066400000000000000000000022071446255456000211540ustar00rootroot00000000000000r""" Empty Files (:mod:`skbio.io.format.emptyfile`) ============================================== .. currentmodule:: skbio.io.format.emptyfile This format exists to make debugging simpler, often an empty file is a mistake which can take an embarrasing amount of time to notice. This format has only a sniffer and no readers or writers, so error messages will indicate as such if an empty file is accidentally used as input. Format Support -------------- **Has Sniffer: Yes** Format Specification -------------------- An empty file consists of only whitespace characters. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.io import create_format emptyfile = create_format('') @emptyfile.sniffer() def _empty_file_sniffer(fh): for line in fh: if line.strip(): return False, {} return True, {} scikit-bio-0.5.9/skbio/io/format/fasta.py000066400000000000000000001054571446255456000202670ustar00rootroot00000000000000""" FASTA/QUAL format (:mod:`skbio.io.format.fasta`) ================================================ .. currentmodule:: skbio.io.format.fasta The FASTA file format (``fasta``) stores biological (i.e., nucleotide or protein) sequences in a simple plain text format that is both human-readable and easy to parse. The file format was first introduced and used in the FASTA software package [1]_. Additional descriptions of the file format can be found in [2]_ and [3]_. An example of a FASTA-formatted file containing two DNA sequences:: >seq1 db-accession-149855 CGATGTCGATCGATCGATCGATCAG >seq2 db-accession-34989 CATCGATCGATCGATGCATGCATGCATG The QUAL file format is an additional format related to FASTA. A FASTA file is sometimes accompanied by a QUAL file, particuarly when the FASTA file contains sequences generated on a high-throughput sequencing instrument. QUAL files store a Phred quality score (nonnegative integer) for each base in a sequence stored in FASTA format (see [4]_ for more details). scikit-bio supports reading and writing FASTA (and optionally QUAL) file formats. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |generator of :mod:`skbio.sequence.Sequence` objects | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.alignment.TabularMSA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.RNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.Protein` | +------+------+---------------------------------------------------------------+ .. note:: All readers and writers support an optional QUAL file via the ``qual`` parameter. If one is provided, quality scores will be read/written in addition to FASTA sequence data. Format Specification -------------------- The following sections define the FASTA and QUAL file formats in detail. FASTA Format ^^^^^^^^^^^^ A FASTA file contains one or more biological sequences. The sequences are stored sequentially, with a *record* for each sequence (also referred to as a *FASTA record*). Each *record* consists of a single-line *header* (sometimes referred to as a *defline*, *label*, *description*, or *comment*) followed by the sequence data, optionally split over multiple lines. .. note:: Blank or whitespace-only lines are only allowed at the beginning of the file, between FASTA records, or at the end of the file. A blank or whitespace-only line after the header line, within the sequence (for FASTA files), or within quality scores (for QUAL files) will raise an error. scikit-bio will ignore leading and trailing whitespace characters on each line while reading. .. note:: scikit-bio does not currently support legacy FASTA format (i.e., headers/comments denoted with a semicolon). The format supported by scikit-bio (described below in detail) most closely resembles the description given in NCBI's BLAST documentation [3]_. See [2]_ for more details on legacy FASTA format. If you would like legacy FASTA format support added to scikit-bio, please consider submitting a feature request on the `scikit-bio issue tracker `_ (pull requests are also welcome!). Sequence Header ~~~~~~~~~~~~~~~ Each sequence header consists of a single line beginning with a greater-than (``>``) symbol. Immediately following this is a sequence identifier (ID) and description separated by one or more whitespace characters. .. note:: When reading a FASTA-formatted file, the sequence ID and description are stored in the sequence `metadata` attribute, under the `'id'` and `'description'` keys, repectively. Both are optional. Each will be represented as the empty string (``''``) in `metadata` if it is not present in the header. When writing a FASTA-formatted file, sequence `metadata` identified by keys `'id'` and `'description'` will be converted to strings and written as the sequence identifier and description, respectively. Each will be written as the empty string if not present in sequence `metadata`. A sequence ID consists of a single *word*: all characters after the greater- than symbol and before the first whitespace character (if any) are taken as the sequence ID. Unique sequence IDs are not strictly enforced by the FASTA format itself. A single standardized ID format is similarly not enforced by the FASTA format, though it is often common to use a unique library accession number for a sequence ID (e.g., NCBI's FASTA defline format [5]_). If a description is present, it is taken as the remaining characters that follow the sequence ID and initial whitespace(s). The description is considered additional information about the sequence (e.g., comments about the source of the sequence or the molecule that it encodes). For example, consider the following header:: >seq1 db-accession-149855 ``seq1`` is the sequence ID and ``db-accession-149855`` is the sequence description. .. note:: scikit-bio's readers will remove all leading and trailing whitespace from the description. If a header line begins with whitespace following the ``>``, the ID is assumed to be missing and the remainder of the line is taken as the description. Sequence Data ~~~~~~~~~~~~~ Biological sequence data follows the header, and can be split over multiple lines. The sequence data (i.e., nucleotides or amino acids) are stored using the standard IUPAC lexicon (single-letter codes). .. note:: scikit-bio supports both upper and lower case characters. This functionality depends on the type of object the data is being read into. For ``Sequence`` objects, sciki-bio doesn't care about the case. Other sequence objects do, but all provide the `lowercase` parameter to control case functionality. Refer to each class's respective constructor documentation for details. Both ``-`` and ``.`` are supported as gap characters when reading into ``DNA``, ``RNA``, and ``Protein`` sequence objects. Validation is performed when reading into scikit-bio sequence objects that enforce an alphabet (e.g., ``DNA``, ``RNA``, ``Protein``). If any invalid characters are found while reading from the FASTA file, an exception is raised. QUAL Format ^^^^^^^^^^^ A QUAL file contains quality scores for one or more biological sequences stored in a corresponding FASTA file. QUAL format is very similar to FASTA format: it stores records sequentially, with each record beginning with a header line containing a sequence ID and description. The same rules apply to QUAL headers as FASTA headers (see the above sections for details). scikit-bio processes FASTA and QUAL headers in exactly the same way. Instead of storing biological sequence data in each record, a QUAL file stores a Phred quality score for each base in the corresponding sequence. Quality scores are represented as nonnegative integers separated by whitespace (typically a single space or newline), and can span multiple lines. .. note:: When reading a QUAL-formatted file, quality scores are stored in the sequence's `positional_metadata` attribute under the `'quality'` column. When writing a QUAL-formatted file, a sequence's `positional_metadata` `'quality'` column will be written as the quality scores. .. note:: When reading FASTA and QUAL files, scikit-bio requires records to be in the same order in both files (i.e., each FASTA and QUAL record must have the same ID and description after being parsed). In addition to having the same order, the number of FASTA records must match the number of QUAL records (i.e., missing or additonal records are not allowed). scikit-bio also requires that the number of quality scores match the number of bases in the corresponding sequence. When writing FASTA and QUAL files, scikit-bio will maintain the same ordering of records in both files (i.e., using the same ID and description in both records) to support future reading. Format Parameters ----------------- The following parameters are available to change how FASTA/QUAL files are read or written in scikit-bio. QUAL File Parameter (Readers and Writers) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``qual`` parameter is available to all FASTA format readers and writers. It can be any file-like type supported by scikit-bio's I/O registry (e.g., file handle, file path, etc.). If ``qual`` is provided when reading, quality scores will be included in each in-memory ``Sequence`` object, in addition to sequence data stored in the FASTA file. When writing, quality scores will be written in QUAL format in addition to the sequence data being written in FASTA format. Reader-specific Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ The available reader parameters differ depending on which reader is used. Generator and TabularMSA Reader Parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The ``constructor`` parameter can be used with the ``Sequence`` generator and ``TabularMSA`` FASTA readers. ``constructor`` specifies the type of in-memory sequence object to read each sequence into. For example, if you know that the FASTA file you're reading contains protein sequences, you would pass ``constructor=Protein`` to the reader call. When reading into a ``Sequence`` generator, ``constructor`` defaults to ``Sequence`` and must be a subclass of ``Sequence`` if supplied. When reading into a ``TabularMSA``, ``constructor`` is a required format parameter and must be a subclass of ``GrammaredSequence`` (e.g., ``DNA``, ``RNA``, ``Protein``). .. note:: The FASTA sniffer will not attempt to guess the ``constructor`` parameter. Sequence Reader Parameters ~~~~~~~~~~~~~~~~~~~~~~~~~~ The ``seq_num`` parameter can be used with the ``Sequence``, ``DNA``, ``RNA``, and ``Protein`` FASTA readers. ``seq_num`` specifies which sequence to read from the FASTA file (and optional QUAL file), and defaults to 1 (i.e., such that the first sequence is read). For example, to read the 50th sequence from a FASTA file, you would pass ``seq_num=50`` to the reader call. Writer-specific Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ The following parameters are available to all FASTA format writers: - ``id_whitespace_replacement``: string to replace **each** whitespace character in a sequence ID. This parameter is useful for cases where an in-memory sequence ID contains whitespace, which would result in an on-disk representation that would not be read back into memory as the same ID (since IDs in FASTA format cannot contain whitespace). Defaults to ``_``. If ``None``, no whitespace replacement is performed and IDs are written as they are stored in memory (this has the potential to create an invalid FASTA-formatted file; see note below). This parameter also applies to a QUAL file if one is provided. - ``description_newline_replacement``: string to replace **each** newline character in a sequence description. Since a FASTA header must be a single line, newlines are not allowed in sequence descriptions and must be replaced in order to write a valid FASTA file. Defaults to a single space. If ``None``, no newline replacement is performed and descriptions are written as they are stored in memory (this has the potential to create an invalid FASTA-formatted file; see note below). This parameter also applies to a QUAL file if one is provided. - ``max_width``: integer specifying the maximum line width (i.e., number of characters) for sequence data and/or quality scores. If a sequence or its quality scores are longer than ``max_width``, it will be split across multiple lines, each with a maximum width of ``max_width``. Note that there are some caveats when splitting quality scores. A single quality score will *never* be split across multiple lines, otherwise it would become two different quality scores when read again. Thus, splitting only occurs *between* quality scores. This makes it possible to have a single long quality score written on its own line that exceeds ``max_width``. For example, the quality score ``12345`` would not be split across multiple lines even if ``max_width=3``. Thus, a 5-character line would be written. Default behavior is to not split sequence data or quality scores across multiple lines. - ``lowercase``: String or boolean array. If a string, it is treated as a key into the positional metadata of the object. If a boolean array, it indicates characters to write in lowercase. Characters in the sequence corresponding to `True` values will be written in lowercase. The boolean array must be the same length as the sequence. .. note:: The FASTA format writers will have noticeably better runtime performance if ``id_whitespace_replacement`` and/or ``description_newline_replacement`` are set to ``None`` so that whitespace replacement is not performed during writing. However, this can potentially create invalid FASTA files, especially if there are newline characters in the IDs or descriptions. For IDs with whitespace, this can also affect how the IDs are read into memory in a subsequent read operation. For example, if an in-memory sequence ID is ``'seq 1'`` and ``id_whitespace_replacement=None``, reading the FASTA file back into memory would result in an ID of ``'seq'``, and ``'1'`` would be part of the sequence description. Examples -------- Reading and Writing FASTA Files ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Suppose we have the following FASTA file with five equal-length sequences (example modified from [6]_):: >seq1 Turkey AAGCTNGGGCATTTCAGGGTGAGCCCGGGCAATACAGGGTAT >seq2 Salmo gair AAGCCTTGGCAGTGCAGGGTGAGCCGTGG CCGGGCACGGTAT >seq3 H. Sapiens ACCGGTTGGCCGTTCAGGGTACAGGTTGGCCGTTCAGGGTAA >seq4 Chimp AAACCCTTGCCG TTACGCTTAAAC CGAGGCCGGGAC ACTCAT >seq5 Gorilla AAACCCTTGCCGGTACGCTTAAACCATTGCCGGTACGCTTAA .. note:: Original copyright notice for the above example file: *(c) Copyright 1986-2008 by The University of Washington. Written by Joseph Felsenstein. Permission is granted to copy this document provided that no fee is charged for it and that this copyright notice is not removed.* Note that the sequences are not required to be of equal length in order for the file to be a valid FASTA file (this depends on the object that you're reading the file into). Also note that some of the sequences occur on a single line, while others are split across multiple lines. Let's define this file in-memory as a ``StringIO``, though this could be a real file path, file handle, or anything that's supported by scikit-bio's I/O registry in practice: >>> fl = [">seq1 Turkey\\n", ... "AAGCTNGGGCATTTCAGGGTGAGCCCGGGCAATACAGGGTAT\\n", ... ">seq2 Salmo gair\\n", ... "AAGCCTTGGCAGTGCAGGGTGAGCCGTGG\\n", ... "CCGGGCACGGTAT\\n", ... ">seq3 H. Sapiens\\n", ... "ACCGGTTGGCCGTTCAGGGTACAGGTTGGCCGTTCAGGGTAA\\n", ... ">seq4 Chimp\\n", ... "AAACCCTTGCCG\\n", ... "TTACGCTTAAAC\\n", ... "CGAGGCCGGGAC\\n", ... "ACTCAT\\n", ... ">seq5 Gorilla\\n", ... "AAACCCTTGCCGGTACGCTTAAACCATTGCCGGTACGCTTAA\\n"] Since these sequences are of equal length (presumably because they've been aligned), let's read the FASTA file into a ``TabularMSA`` object: >>> from skbio import TabularMSA, DNA >>> msa = TabularMSA.read(fl, constructor=DNA) >>> msa TabularMSA[DNA] ------------------------------------------ Stats: sequence count: 5 position count: 42 ------------------------------------------ AAGCTNGGGCATTTCAGGGTGAGCCCGGGCAATACAGGGTAT AAGCCTTGGCAGTGCAGGGTGAGCCGTGGCCGGGCACGGTAT ACCGGTTGGCCGTTCAGGGTACAGGTTGGCCGTTCAGGGTAA AAACCCTTGCCGTTACGCTTAAACCGAGGCCGGGACACTCAT AAACCCTTGCCGGTACGCTTAAACCATTGCCGGTACGCTTAA Note that we didn't specify a file format in the ``read`` call. The FASTA sniffer detected the correct file format for us! To write the ``TabularMSA`` in FASTA format: >>> from io import StringIO >>> with StringIO() as fh: ... print(msa.write(fh).getvalue()) >seq1 Turkey AAGCTNGGGCATTTCAGGGTGAGCCCGGGCAATACAGGGTAT >seq2 Salmo gair AAGCCTTGGCAGTGCAGGGTGAGCCGTGGCCGGGCACGGTAT >seq3 H. Sapiens ACCGGTTGGCCGTTCAGGGTACAGGTTGGCCGTTCAGGGTAA >seq4 Chimp AAACCCTTGCCGTTACGCTTAAACCGAGGCCGGGACACTCAT >seq5 Gorilla AAACCCTTGCCGGTACGCTTAAACCATTGCCGGTACGCTTAA ``TabularMSA`` loads all of the sequences from the FASTA file into memory at once. If the FASTA file is large (which is often the case), this may be infeasible if you don't have enough memory. To work around this issue, you can stream the sequences using scikit-bio's generator-based FASTA reader and writer. The generator-based reader yields ``Sequence`` objects (or subclasses if ``constructor`` is supplied) one at a time, instead of loading all sequences into memory. For example, let's use the generator-based reader to process a single sequence at a time in a ``for`` loop: >>> import skbio.io >>> for seq in skbio.io.read(fl, format='fasta'): ... seq ... print('') Sequence ------------------------------------------------ Metadata: 'description': 'Turkey' 'id': 'seq1' Stats: length: 42 ------------------------------------------------ 0 AAGCTNGGGC ATTTCAGGGT GAGCCCGGGC AATACAGGGT AT Sequence ------------------------------------------------ Metadata: 'description': 'Salmo gair' 'id': 'seq2' Stats: length: 42 ------------------------------------------------ 0 AAGCCTTGGC AGTGCAGGGT GAGCCGTGGC CGGGCACGGT AT Sequence ------------------------------------------------ Metadata: 'description': 'H. Sapiens' 'id': 'seq3' Stats: length: 42 ------------------------------------------------ 0 ACCGGTTGGC CGTTCAGGGT ACAGGTTGGC CGTTCAGGGT AA Sequence ------------------------------------------------ Metadata: 'description': 'Chimp' 'id': 'seq4' Stats: length: 42 ------------------------------------------------ 0 AAACCCTTGC CGTTACGCTT AAACCGAGGC CGGGACACTC AT Sequence ------------------------------------------------ Metadata: 'description': 'Gorilla' 'id': 'seq5' Stats: length: 42 ------------------------------------------------ 0 AAACCCTTGC CGGTACGCTT AAACCATTGC CGGTACGCTT AA A single sequence can also be read into a ``Sequence`` (or subclass): >>> from skbio import Sequence >>> seq = Sequence.read(fl) >>> seq Sequence ------------------------------------------------ Metadata: 'description': 'Turkey' 'id': 'seq1' Stats: length: 42 ------------------------------------------------ 0 AAGCTNGGGC ATTTCAGGGT GAGCCCGGGC AATACAGGGT AT By default, the first sequence in the FASTA file is read. This can be controlled with ``seq_num``. For example, to read the fifth sequence: >>> seq = Sequence.read(fl, seq_num=5) >>> seq Sequence ------------------------------------------------ Metadata: 'description': 'Gorilla' 'id': 'seq5' Stats: length: 42 ------------------------------------------------ 0 AAACCCTTGC CGGTACGCTT AAACCATTGC CGGTACGCTT AA We can use the same API to read the fifth sequence into a ``DNA`` sequence: >>> dna_seq = DNA.read(fl, seq_num=5) >>> dna_seq DNA ------------------------------------------------ Metadata: 'description': 'Gorilla' 'id': 'seq5' Stats: length: 42 has gaps: False has degenerates: False has definites: True GC-content: 50.00% ------------------------------------------------ 0 AAACCCTTGC CGGTACGCTT AAACCATTGC CGGTACGCTT AA Individual sequence objects can also be written in FASTA format: >>> with StringIO() as fh: ... print(dna_seq.write(fh).getvalue()) >seq5 Gorilla AAACCCTTGCCGGTACGCTTAAACCATTGCCGGTACGCTTAA Reading and Writing FASTA/QUAL Files ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ In addition to reading and writing standalone FASTA files, scikit-bio supports reading and writing FASTA and QUAL files together. Suppose we have the following FASTA file:: >seq1 db-accession-149855 CGATGTC >seq2 db-accession-34989 CATCGTC Also suppose we have the following QUAL file:: >seq1 db-accession-149855 40 39 39 4 50 1 100 >seq2 db-accession-34989 3 3 10 42 80 80 79 >>> fasta_fl = [ ... ">seq1 db-accession-149855\\n", ... "CGATGTC\\n", ... ">seq2 db-accession-34989\\n", ... "CATCGTC\\n"] >>> qual_fl = [ ... ">seq1 db-accession-149855\\n", ... "40 39 39 4\\n", ... "50 1 100\\n", ... ">seq2 db-accession-34989\\n", ... "3 3 10 42 80 80 79\\n"] To read in a single ``Sequence`` at a time, we can use the generator-based reader as we did above, providing both FASTA and QUAL files: >>> for seq in skbio.io.read(fasta_fl, qual=qual_fl, format='fasta'): ... seq ... print('') Sequence ---------------------------------------- Metadata: 'description': 'db-accession-149855' 'id': 'seq1' Positional metadata: 'quality': Stats: length: 7 ---------------------------------------- 0 CGATGTC Sequence --------------------------------------- Metadata: 'description': 'db-accession-34989' 'id': 'seq2' Positional metadata: 'quality': Stats: length: 7 --------------------------------------- 0 CATCGTC Note that the sequence objects have quality scores stored as positional metadata since we provided a QUAL file. The other FASTA readers operate in a similar manner. Now let's load the sequences and their quality scores into a ``TabularMSA``: >>> msa = TabularMSA.read(fasta_fl, qual=qual_fl, constructor=DNA) >>> msa TabularMSA[DNA] --------------------- Stats: sequence count: 2 position count: 7 --------------------- CGATGTC CATCGTC To write the sequence data and quality scores in the ``TabularMSA`` to FASTA and QUAL files, respectively: >>> new_fasta_fh = StringIO() >>> new_qual_fh = StringIO() >>> _ = msa.write(new_fasta_fh, qual=new_qual_fh) >>> print(new_fasta_fh.getvalue()) >seq1 db-accession-149855 CGATGTC >seq2 db-accession-34989 CATCGTC >>> print(new_qual_fh.getvalue()) >seq1 db-accession-149855 40 39 39 4 50 1 100 >seq2 db-accession-34989 3 3 10 42 80 80 79 >>> new_fasta_fh.close() >>> new_qual_fh.close() References ---------- .. [1] Lipman, DJ; Pearson, WR (1985). "Rapid and sensitive protein similarity searches". Science 227 (4693): 1435-41. .. [2] http://en.wikipedia.org/wiki/FASTA_format .. [3] http://blast.ncbi.nlm.nih.gov/blastcgihelp.shtml .. [4] https://www.broadinstitute.org/crd/wiki/index.php/Qual .. [5] Madden T. The BLAST Sequence Analysis Tool. 2002 Oct 9 [Updated 2003 Aug 13]. In: McEntyre J, Ostell J, editors. The NCBI Handbook [Internet]. Bethesda (MD): National Center for Biotechnology Information (US); 2002-. Chapter 16. Available from: http://www.ncbi.nlm.nih.gov/books/NBK21097/ .. [6] http://evolution.genetics.washington.edu/phylip/doc/sequence.html """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import itertools import textwrap import numpy as np from skbio.io import create_format, FASTAFormatError, QUALFormatError from skbio.io.registry import FileSentinel from skbio.io.format._base import (_get_nth_sequence, _parse_fasta_like_header, _format_fasta_like_records, _line_generator, _too_many_blanks) from skbio.util._misc import chunk_str from skbio.alignment import TabularMSA from skbio.sequence import Sequence, DNA, RNA, Protein fasta = create_format('fasta') @fasta.sniffer() def _fasta_sniffer(fh): # Strategy: # Ignore up to 5 blank/whitespace-only lines at the beginning of the # file. Read up to 10 records. If at least one record is read (i.e. # the file isn't empty) and no errors are thrown during reading, assume # the file is in FASTA format. If a record appears to be QUAL, do *not* # identify the file as FASTA since we don't want to sniff QUAL files as # FASTA (technically they can be read as FASTA since the sequences may # not be validated but it probably isn't what the user wanted). Also, if # we add QUAL as its own file format in the future, we wouldn't want the # FASTA and QUAL sniffers to both positively identify a QUAL file. if _too_many_blanks(fh, 5): return False, {} num_records = 10 empty = True try: parser = _parse_fasta_raw(fh, _sniffer_data_parser, FASTAFormatError) for _ in zip(range(num_records), parser): empty = False except FASTAFormatError: return False, {} if empty: return False, {} else: return True, {} def _sniffer_data_parser(chunks): data = _parse_sequence_data(chunks) try: _parse_quality_scores(chunks) except QUALFormatError: return data else: # used for flow control within sniffer, user should never see this # message raise FASTAFormatError('Data appear to be quality scores.') @fasta.reader(None) def _fasta_to_generator(fh, qual=FileSentinel, constructor=Sequence, **kwargs): if qual is None: for seq, id_, desc in _parse_fasta_raw(fh, _parse_sequence_data, FASTAFormatError): yield constructor(seq, metadata={'id': id_, 'description': desc}, **kwargs) else: fasta_gen = _parse_fasta_raw(fh, _parse_sequence_data, FASTAFormatError) qual_gen = _parse_fasta_raw(qual, _parse_quality_scores, QUALFormatError) for fasta_rec, qual_rec in itertools.zip_longest(fasta_gen, qual_gen, fillvalue=None): if fasta_rec is None: raise FASTAFormatError( "QUAL file has more records than FASTA file.") if qual_rec is None: raise FASTAFormatError( "FASTA file has more records than QUAL file.") fasta_seq, fasta_id, fasta_desc = fasta_rec qual_scores, qual_id, qual_desc = qual_rec if fasta_id != qual_id: raise FASTAFormatError( "IDs do not match between FASTA and QUAL records: %r != %r" % (str(fasta_id), str(qual_id))) if fasta_desc != qual_desc: raise FASTAFormatError( "Descriptions do not match between FASTA and QUAL " "records: %r != %r" % (str(fasta_desc), str(qual_desc))) # sequence and quality scores lengths are checked in constructor yield constructor( fasta_seq, metadata={'id': fasta_id, 'description': fasta_desc}, positional_metadata={'quality': qual_scores}, **kwargs) @fasta.reader(Sequence) def _fasta_to_sequence(fh, qual=FileSentinel, seq_num=1, **kwargs): return _get_nth_sequence( _fasta_to_generator(fh, qual=qual, constructor=Sequence, **kwargs), seq_num) @fasta.reader(DNA) def _fasta_to_dna(fh, qual=FileSentinel, seq_num=1, **kwargs): return _get_nth_sequence( _fasta_to_generator(fh, qual=qual, constructor=DNA, **kwargs), seq_num) @fasta.reader(RNA) def _fasta_to_rna(fh, qual=FileSentinel, seq_num=1, **kwargs): return _get_nth_sequence( _fasta_to_generator(fh, qual=qual, constructor=RNA, **kwargs), seq_num) @fasta.reader(Protein) def _fasta_to_protein(fh, qual=FileSentinel, seq_num=1, **kwargs): return _get_nth_sequence( _fasta_to_generator(fh, qual=qual, constructor=Protein, **kwargs), seq_num) @fasta.reader(TabularMSA) def _fasta_to_tabular_msa(fh, qual=FileSentinel, constructor=None, **kwargs): if constructor is None: raise ValueError("Must provide `constructor`.") return TabularMSA( _fasta_to_generator(fh, qual=qual, constructor=constructor, **kwargs)) @fasta.writer(None) def _generator_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): if max_width is not None: if max_width < 1: raise ValueError( "Maximum line width must be greater than zero (max_width=%d)." % max_width) if qual is not None: # define text wrapper for splitting quality scores here for # efficiency. textwrap docs recommend reusing a TextWrapper # instance when it is used many times. configure text wrapper to # never break "words" (i.e., integer quality scores) across lines qual_wrapper = textwrap.TextWrapper( width=max_width, break_long_words=False, break_on_hyphens=False) formatted_records = _format_fasta_like_records( obj, id_whitespace_replacement, description_newline_replacement, qual is not None, lowercase) for header, seq_str, qual_scores in formatted_records: if max_width is not None: seq_str = chunk_str(seq_str, max_width, '\n') fh.write('>%s\n%s\n' % (header, seq_str)) if qual is not None: qual_str = ' '.join(np.asarray(qual_scores, dtype=str)) if max_width is not None: qual_str = qual_wrapper.fill(qual_str) qual.write('>%s\n%s\n' % (header, qual_str)) @fasta.writer(Sequence) def _sequence_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): _sequences_to_fasta([obj], fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase) @fasta.writer(DNA) def _dna_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): _sequences_to_fasta([obj], fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase) @fasta.writer(RNA) def _rna_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): _sequences_to_fasta([obj], fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase) @fasta.writer(Protein) def _protein_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): _sequences_to_fasta([obj], fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase) @fasta.writer(TabularMSA) def _tabular_msa_to_fasta(obj, fh, qual=FileSentinel, id_whitespace_replacement='_', description_newline_replacement=' ', max_width=None, lowercase=None): _sequences_to_fasta(obj, fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase) def _parse_fasta_raw(fh, data_parser, error_type): """Raw parser for FASTA or QUAL files. Returns raw values (seq/qual, id, description). It is the responsibility of the caller to construct the correct in-memory object to hold the data. """ # Skip any blank or whitespace-only lines at beginning of file try: seq_header = next(_line_generator(fh, skip_blanks=True)) except StopIteration: return # header check inlined here and below for performance if seq_header.startswith('>'): id_, desc = _parse_fasta_like_header(seq_header) else: raise error_type( "Found non-header line when attempting to read the 1st record:" "\n%s" % seq_header) data_chunks = [] prev = seq_header for line in _line_generator(fh, skip_blanks=False): if line.startswith('>'): # new header, so yield current record and reset state yield data_parser(data_chunks), id_, desc data_chunks = [] id_, desc = _parse_fasta_like_header(line) else: if line: # ensure no blank lines within a single record if not prev: raise error_type( "Found blank or whitespace-only line within record.") data_chunks.append(line) prev = line # yield last record in file yield data_parser(data_chunks), id_, desc def _parse_sequence_data(chunks): if not chunks: raise FASTAFormatError("Found header without sequence data.") return ''.join(chunks) def _parse_quality_scores(chunks): if not chunks: raise QUALFormatError("Found header without quality scores.") qual_str = ' '.join(chunks) try: quality = np.asarray(qual_str.split(), dtype=int) except ValueError: raise QUALFormatError( "Could not convert quality scores to integers:\n%s" % str(qual_str)) if (quality < 0).any(): raise QUALFormatError( "Encountered negative quality score(s). Quality scores must be " "greater than or equal to zero.") if (quality > 255).any(): raise QUALFormatError( "Encountered quality score(s) greater than 255. scikit-bio only " "supports quality scores in the range 0-255 (inclusive) when " "reading QUAL files.") return quality.astype(np.uint8, casting='unsafe', copy=False) def _sequences_to_fasta(obj, fh, qual, id_whitespace_replacement, description_newline_replacement, max_width, lowercase=None): def seq_gen(): yield from obj _generator_to_fasta( seq_gen(), fh, qual=qual, id_whitespace_replacement=id_whitespace_replacement, description_newline_replacement=description_newline_replacement, max_width=max_width, lowercase=lowercase) scikit-bio-0.5.9/skbio/io/format/fastq.py000066400000000000000000000531451446255456000203030ustar00rootroot00000000000000r""" FASTQ format (:mod:`skbio.io.format.fastq`) =========================================== .. currentmodule:: skbio.io.format.fastq The FASTQ file format (``fastq``) stores biological (e.g., nucleotide) sequences and their quality scores in a simple plain text format that is both human-readable and easy to parse. The file format was invented by Jim Mullikin at the Wellcome Trust Sanger Institute but wasn't given a formal definition, though it has informally become a standard file format for storing high-throughput sequence data. More information about the format and its variants can be found in [1]_ and [2]_. Conceptually, a FASTQ file is similar to paired FASTA and QUAL files in that it stores both biological sequences and their quality scores. FASTQ differs from FASTA/QUAL because the quality scores are stored in the same file as the biological sequence data. An example FASTQ-formatted file containing two DNA sequences and their quality scores: .. code-block:: none @seq1 description 1 AACACCAAACTTCTCCACCACGTGAGCTACAAAAG + ````Y^T]`]c^cabcacc`^Lb^ccYT\T\Y\WF @seq2 description 2 TATGTATATATAACATATACATATATACATACATA + ]KZ[PY]_[YY^```ac^\\`bT``c`\aT``bbb Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |generator of :mod:`skbio.sequence.Sequence` objects | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.alignment.TabularMSA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.RNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.Protein` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- A FASTQ file contains one or more biological sequences and their corresponding quality scores stored sequentially as *records*. Each *record* consists of four sections: 1. Sequence header line consisting of a sequence identifier (ID) and description (both optional) 2. Biological sequence data (typically stored using the standard IUPAC lexicon), optionally split over multiple lines 3. Quality header line separating sequence data from quality scores (optionally repeating the ID and description from the sequence header line) 4. Quality scores as printable ASCII characters, optionally split over multiple lines. Decoding of quality scores will depend on the specified FASTQ variant (see below for more details) For the complete FASTQ format specification, see [1]_. scikit-bio's FASTQ implementation follows the format specification described in this excellent publication, including validating the implementation against the FASTQ example files provided in the publication's supplementary data. .. note:: IDs and descriptions will be parsed from sequence header lines in exactly the same way as FASTA headers (:mod:`skbio.io.format.fasta`). IDs, descriptions, and quality scores are also stored on, and written from, sequence objects in the same way as with FASTA. .. note:: Blank or whitespace-only lines are only allowed at the beginning of the file, between FASTQ records, or at the end of the file. A blank or whitespace-only line after the header line, within the sequence, or within quality scores will raise an error. scikit-bio will ignore leading and trailing whitespace characters on each line while reading. .. note:: Validation may be performed depending on the type of object the data is being read into. This behavior matches that of FASTA files. .. note:: scikit-bio will write FASTQ files in a normalized format, with each record section on a single line. Thus, each record will be composed of *exactly* four lines. The quality header line won't have the sequence ID and description repeated. .. note:: `lowercase` functionality is supported the same as with FASTA. Quality Score Variants ^^^^^^^^^^^^^^^^^^^^^^ FASTQ associates quality scores with sequence data, with each quality score encoded as a single printable ASCII character. In scikit-bio, all quality scores are decoded as Phred quality scores. This is the most common quality score metric, though there are others (e.g., Solexa quality scores). Unfortunately, different sequencers have different ways of encoding quality scores as ASCII characters, notably Sanger and Illumina. Below is a table highlighting the different encoding variants supported by scikit-bio, as well as listing the equivalent variant names used in the Open Bioinformatics Foundation (OBF) [3]_ projects (e.g., Biopython, BioPerl, etc.). +-----------+---------+----+--------+-----------------------------------------+ | Variant | ASCII |Off\|Quality | Notes | | | Range |set |Range | | +===========+=========+====+========+=========================================+ |sanger |33 to 126|33 |0 to 93 |Equivalent to OBF's fastq-sanger. | +-----------+---------+----+--------+-----------------------------------------+ |illumina1.3|64 to 126|64 |0 to 62 |Equivalent to OBF's fastq-illumina. Use | | | | | |this if your data was generated using | | | | | |Illumina 1.3-1.7 software. | +-----------+---------+----+--------+-----------------------------------------+ |illumina1.8|33 to 95 |33 |0 to 62 |Equivalent to sanger but with 0 to 62 | | | | | |quality score range check. Use this if | | | | | |your data was generated using Illumina | | | | | |1.8 software or later. | +-----------+---------+----+--------+-----------------------------------------+ |solexa |59 to 126|64 |-5 to 62|Not currently implemented. | +-----------+---------+----+--------+-----------------------------------------+ .. note:: When writing, Phred quality scores will be truncated to the maximum value in the variant's range and a warning will be issued. This is consistent with the OBF projects. When reading, an error will be raised if a decoded quality score is outside the variant's range. Format Parameters ----------------- The following parameters are available to all FASTQ format readers and writers: - ``variant``: A string indicating the quality score variant used to decode/encode Phred quality scores. Must be one of ``sanger``, ``illumina1.3``, ``illumina1.8``, or ``solexa``. This parameter is preferred over ``phred_offset`` because additional quality score range checks and conversions can be performed. It is also more explicit. - ``phred_offset``: An integer indicating the ASCII code offset used to decode/encode Phred quality scores. Must be in the range ``[33, 126]``. All decoded scores will be assumed to be Phred scores (i.e., no additional conversions are performed). Prefer using ``variant`` over this parameter whenever possible. .. note:: You must provide ``variant`` or ``phred_offset`` when reading or writing a FASTQ file. ``variant`` and ``phred_offset`` cannot both be provided at the same time. The following additional parameters are the same as in FASTA format (:mod:`skbio.io.format.fasta`): - ``constructor``: see ``constructor`` parameter in FASTA format - ``seq_num``: see ``seq_num`` parameter in FASTA format - ``id_whitespace_replacement``: see ``id_whitespace_replacement`` parameter in FASTA format - ``description_newline_replacement``: see ``description_newline_replacement`` parameter in FASTA format - ``lowercase``: see ``lowercase`` parameter in FASTA format Examples -------- Suppose we have the following FASTQ file with two DNA sequences:: @seq1 description 1 AACACCAAACTTCTCCACC ACGTGAGCTACAAAAG +seq1 description 1 ''''Y^T]']C^CABCACC `^LB^CCYT\T\Y\WF @seq2 description 2 TATGTATATATAACATATACATATATACATACATA + ]KZ[PY]_[YY^'''AC^\\'BT''C'\AT''BBB Note that the first sequence and its quality scores are split across multiple lines, while the second sequence and its quality scores are each on a single line. Also note that the first sequence has a duplicate ID and description on the quality header line, while the second sequence does not. Let's define this file in-memory as a ``StringIO``, though this could be a real file path, file handle, or anything that's supported by scikit-bio's I/O registry in practice: >>> from io import StringIO >>> fs = '\n'.join([ ... r"@seq1 description 1", ... r"AACACCAAACTTCTCCACC", ... r"ACGTGAGCTACAAAAG", ... r"+seq1 description 1", ... r"''''Y^T]']C^CABCACC", ... r"'^LB^CCYT\T\Y\WF", ... r"@seq2 description 2", ... r"TATGTATATATAACATATACATATATACATACATA", ... r"+", ... r"]KZ[PY]_[YY^'''AC^\\'BT''C'\AT''BBB"]) >>> fh = StringIO(fs) To load the sequences into a ``TabularMSA``, we run: >>> from skbio import TabularMSA, DNA >>> msa = TabularMSA.read(fh, constructor=DNA, variant='sanger') >>> msa TabularMSA[DNA] ----------------------------------- Stats: sequence count: 2 position count: 35 ----------------------------------- AACACCAAACTTCTCCACCACGTGAGCTACAAAAG TATGTATATATAACATATACATATATACATACATA Note that quality scores are decoded from Sanger. To load the second sequence as ``DNA``: >>> fh = StringIO(fs) # reload the StringIO to read from the beginning again >>> seq = DNA.read(fh, variant='sanger', seq_num=2) >>> seq DNA ---------------------------------------- Metadata: 'description': 'description 2' 'id': 'seq2' Positional metadata: 'quality': Stats: length: 35 has gaps: False has degenerates: False has definites: True GC-content: 14.29% ---------------------------------------- 0 TATGTATATA TAACATATAC ATATATACAT ACATA To write our ``TabularMSA`` to a FASTQ file with quality scores encoded using the ``illumina1.3`` variant: >>> new_fh = StringIO() >>> print(msa.write(new_fh, format='fastq', variant='illumina1.3').getvalue()) @seq1 description 1 AACACCAAACTTCTCCACCACGTGAGCTACAAAAG + FFFFx}s|F|b}b`ab`bbF}ka}bbxs{s{x{ve @seq2 description 2 TATGTATATATAACATATACATATATACATACATA + |jyzox|~zxx}FFF`b}{{FasFFbF{`sFFaaa >>> new_fh.close() Note that the file has been written in normalized format: sequence and quality scores each only occur on a single line and the sequence header line is not repeated in the quality header line. Note also that the quality scores are different because they have been encoded using a different variant. References ---------- .. [1] Peter J. A. Cock, Christopher J. Fields, Naohisa Goto, Michael L. Heuer, and Peter M. Rice. The Sanger FASTQ file format for sequences with quality scores, and the Solexa/Illumina FASTQ variants. Nucl. Acids Res. (2010) 38 (6): 1767-1771. first published online December 16, 2009. doi:10.1093/nar/gkp1137 http://nar.oxfordjournals.org/content/38/6/1767 .. [2] http://en.wikipedia.org/wiki/FASTQ_format .. [3] http://www.open-bio.org/ """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re import numpy as np from skbio.io import create_format, FASTQFormatError from skbio.io.format._base import ( _decode_qual_to_phred, _encode_phred_to_qual, _get_nth_sequence, _parse_fasta_like_header, _format_fasta_like_records, _line_generator, _too_many_blanks) from skbio.alignment import TabularMSA from skbio.sequence import Sequence, DNA, RNA, Protein _whitespace_regex = re.compile(r'\s') fastq = create_format('fastq') @fastq.sniffer() def _fastq_sniffer(fh): # Strategy: # Ignore up to 5 blank/whitespace-only lines at the beginning of the # file. Read up to 10 records. If at least one record is read (i.e. the # file isn't empty) and the quality scores are in printable ASCII range, # assume the file is FASTQ. if _too_many_blanks(fh, 5): return False, {} try: not_empty = False for _, seq in zip(range(10), _fastq_to_generator(fh, phred_offset=33)): split_length = len((seq.metadata['id'] + seq.metadata['description']).split(':')) description = seq.metadata['description'].split(':') if split_length == 10 and description[1] in 'YN': return True, {'variant': 'illumina1.8'} not_empty = True return not_empty, {} except (FASTQFormatError, ValueError): return False, {} @fastq.reader(None) def _fastq_to_generator(fh, variant=None, phred_offset=None, constructor=Sequence, **kwargs): # Skip any blank or whitespace-only lines at beginning of file try: seq_header = next(_line_generator(fh, skip_blanks=True)) except StopIteration: return if not seq_header.startswith('@'): raise FASTQFormatError( "Expected sequence (@) header line at start of file: %r" % str(seq_header)) while seq_header is not None: id_, desc = _parse_fasta_like_header(seq_header) seq, qual_header = _parse_sequence_data(fh, seq_header) if qual_header != '+' and qual_header[1:] != seq_header[1:]: raise FASTQFormatError( "Sequence (@) and quality (+) header lines do not match: " "%r != %r" % (str(seq_header[1:]), str(qual_header[1:]))) phred_scores, seq_header = _parse_quality_scores(fh, len(seq), variant, phred_offset, qual_header) yield constructor(seq, metadata={'id': id_, 'description': desc}, positional_metadata={'quality': phred_scores}, **kwargs) @fastq.reader(Sequence) def _fastq_to_sequence(fh, variant=None, phred_offset=None, seq_num=1, **kwargs): return _get_nth_sequence( _fastq_to_generator(fh, variant=variant, phred_offset=phred_offset, constructor=Sequence, **kwargs), seq_num) @fastq.reader(DNA) def _fastq_to_dna(fh, variant=None, phred_offset=None, seq_num=1, **kwargs): return _get_nth_sequence( _fastq_to_generator(fh, variant=variant, phred_offset=phred_offset, constructor=DNA, **kwargs), seq_num) @fastq.reader(RNA) def _fastq_to_rna(fh, variant=None, phred_offset=None, seq_num=1, **kwargs): return _get_nth_sequence( _fastq_to_generator(fh, variant=variant, phred_offset=phred_offset, constructor=RNA, **kwargs), seq_num) @fastq.reader(Protein) def _fastq_to_protein(fh, variant=None, phred_offset=None, seq_num=1, **kwargs): return _get_nth_sequence( _fastq_to_generator(fh, variant=variant, phred_offset=phred_offset, constructor=Protein, **kwargs), seq_num) @fastq.reader(TabularMSA) def _fastq_to_tabular_msa(fh, variant=None, phred_offset=None, constructor=None, **kwargs): if constructor is None: raise ValueError("Must provide `constructor`.") return TabularMSA( _fastq_to_generator(fh, variant=variant, phred_offset=phred_offset, constructor=constructor, **kwargs)) @fastq.writer(None) def _generator_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): formatted_records = _format_fasta_like_records( obj, id_whitespace_replacement, description_newline_replacement, True, lowercase=lowercase) for header, seq_str, qual_scores in formatted_records: qual_str = _encode_phred_to_qual(qual_scores, variant=variant, phred_offset=phred_offset) fh.write('@') fh.write(header) fh.write('\n') fh.write(seq_str) fh.write('\n+\n') fh.write(qual_str) fh.write('\n') @fastq.writer(Sequence) def _sequence_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): _sequences_to_fastq([obj], fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=lowercase) @fastq.writer(DNA) def _dna_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): _sequences_to_fastq([obj], fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=lowercase) @fastq.writer(RNA) def _rna_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): _sequences_to_fastq([obj], fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=lowercase) @fastq.writer(Protein) def _protein_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): _sequences_to_fastq([obj], fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=lowercase) @fastq.writer(TabularMSA) def _tabular_msa_to_fastq(obj, fh, variant=None, phred_offset=None, id_whitespace_replacement='_', description_newline_replacement=' ', lowercase=None): _sequences_to_fastq(obj, fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=lowercase) def _blank_error(unique_text): error_string = ("Found blank or whitespace-only line {} in " "FASTQ file").format(unique_text) raise FASTQFormatError(error_string) def _parse_sequence_data(fh, prev): seq_chunks = [] for chunk in _line_generator(fh, skip_blanks=False): if chunk.startswith('+'): if not prev: _blank_error("before '+'") if not seq_chunks: raise FASTQFormatError( "Found FASTQ record without sequence data.") return ''.join(seq_chunks), chunk elif chunk.startswith('@'): raise FASTQFormatError( "Found FASTQ record that is missing a quality (+) header line " "after sequence data.") else: if not prev: _blank_error("after header or within sequence") if _whitespace_regex.search(chunk): raise FASTQFormatError( "Found whitespace in sequence data: %r" % str(chunk)) seq_chunks.append(chunk) prev = chunk raise FASTQFormatError( "Found incomplete/truncated FASTQ record at end of file.") def _parse_quality_scores(fh, seq_len, variant, phred_offset, prev): phred_scores = [] qual_len = 0 for chunk in _line_generator(fh, skip_blanks=False): if chunk: if chunk.startswith('@') and qual_len == seq_len: return np.hstack(phred_scores), chunk else: if not prev: _blank_error("after '+' or within quality scores") qual_len += len(chunk) if qual_len > seq_len: raise FASTQFormatError( "Found more quality score characters than sequence " "characters. Extra quality score characters: %r" % chunk[-(qual_len - seq_len):]) phred_scores.append( _decode_qual_to_phred(chunk, variant=variant, phred_offset=phred_offset)) prev = chunk if qual_len != seq_len: raise FASTQFormatError( "Found incomplete/truncated FASTQ record at end of file.") return np.hstack(phred_scores), None def _sequences_to_fastq(obj, fh, variant, phred_offset, id_whitespace_replacement, description_newline_replacement, lowercase=None): def seq_gen(): yield from obj _generator_to_fastq( seq_gen(), fh, variant=variant, phred_offset=phred_offset, id_whitespace_replacement=id_whitespace_replacement, description_newline_replacement=description_newline_replacement, lowercase=lowercase) scikit-bio-0.5.9/skbio/io/format/genbank.py000066400000000000000000000610141446255456000205640ustar00rootroot00000000000000""" GenBank format (:mod:`skbio.io.format.genbank`) =============================================== .. currentmodule:: skbio.io.format.genbank GenBank format (GenBank Flat File Format) stores sequence and its annotation together. The start of the annotation section is marked by a line beginning with the word "LOCUS". The start of sequence section is marked by a line beginning with the word "ORIGIN" and the end of the section is marked by a line with only "//". The GenBank file usually ends with .gb or sometimes .gbk. The GenBank format for protein has been renamed to GenPept. The GenBank (for nucleotide) and Genpept are essentially the same format. An example of a GenBank file can be seen here [1]_. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.RNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.Protein` | +------+------+---------------------------------------------------------------+ |Yes | Yes | generator of :mod:`skbio.sequence.Sequence` objects | +------+------+---------------------------------------------------------------+ Format Specification -------------------- **State: Experimental as of 0.4.1.** Sections before ``FEATURES`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ All the sections before ``FEATURES`` will be read into the attribute of ``metadata``. The header and its content of a section is stored as a pair of key and value in ``metadata``. For the ``REFERENCE`` section, its value is stored as a list, as there are often multiple reference sections in one GenBank record. .. _genbank_feature_section: ``FEATURES`` section ^^^^^^^^^^^^^^^^^^^^ The International Nucleotide Sequence Database Collaboration (INSDC [2]_) is a joint effort among the DDBJ, EMBL, and GenBank. These organisations all use the same "Feature Table" layout in their plain text flat file formats, which are documented in detail [3]_. The feature keys and their qualifiers are also described in this webpage [4]_. The ``FEATURES`` section will be stored in ``interval_metadata`` of ``Sequence`` or its sub-class. Each sub-section is stored as an ``Interval`` object in ``interval_metadata``. Each ``Interval`` object has ``metadata`` keeping the information of this feature in the sub-section. To normalize the vocabulary between multiple formats (currently only the INSDC Feature Table and GFF3) to store metadata of interval features, we rename some terms in some formats to the same common name when parsing them into memory, as described in this table: +-----------+-----------+-----------+---------+------------------------------+ |INSDC |GFF3 |Key stored |Value |Description | |feature |columns or | |type | | |table |attributes | |stored | | +===========+===========+===========+=========+==============================+ |inference |source |source |str |the algorithm or experiment | | |(column 2) | | |used to generate this feature | +-----------+-----------+-----------+---------+------------------------------+ |feature key|type |type |str |the type of the feature | | |(column 3) | | | | +-----------+-----------+-----------+---------+------------------------------+ |N/A |score |score |float |the score of the feature | | |(column 6) | | | | +-----------+-----------+-----------+---------+------------------------------+ |N/A |strand |strand |str |the strand of the feature. + | | |(column 7) | | |for positive strand, - for | | | | | |minus strand, and . for | | | | | |features that are not | | | | | |stranded. In addition, ? can | | | | | |be used for features whose | | | | | |strandedness is relevant, but | | | | | |unknown. | +-----------+-----------+-----------+---------+------------------------------+ |codon_start|phase |phase |int |the offset at which the first | | |(column 8) | | |complete codon of a coding | | | | | |feature can be found, relative| | | | | |to the first base of that | | | | | |feature. It is 0, 1, or 2 in | | | | | |GFF3 or 1, 2, or 3 in GenBank.| | | | | |The stored value is 0, 1, or | | | | | |2, following in GFF3 format. | +-----------+-----------+-----------+---------+------------------------------+ |db_xref |Dbxref |db_xref |list of |A database cross reference | | | | |str | | +-----------+-----------+-----------+---------+------------------------------+ |N/A |ID |ID |str |feature ID | +-----------+-----------+-----------+---------+------------------------------+ |note |Note |note |str |any comment or additional | | | | | |information | +-----------+-----------+-----------+---------+------------------------------+ |translation|N/A |translation|str |the protein sequence for CDS | | | | | |features | +-----------+-----------+-----------+---------+------------------------------+ ``Location`` string +++++++++++++++++++ There are 5 types of location descriptors defined in Feature Table. This explains how they will be parsed into the bounds of ``Interval`` object (note it converts the 1-based coordinate to 0-based): 1. a single base number. e.g. 67. This is parsed to ``(66, 67)``. 2. a site between two neighboring bases. e.g. 67^68. This is parsed to ``(66, 67)``. 3. a single base from inside a range. e.g. 67.89. This is parsed to ``(66, 89)``. 4. a pair of base numbers defining a sequence span. e.g. 67..89. This is parsed to ``(66, 89)``. 5. a remote sequence identifier followed by a location descriptor defined above. e.g. J00123.1:67..89. This will be discarded because it is not on the current sequence. When it is combined with local descriptor like J00123.1:67..89,200..209, the local part will be kept to be ``(199, 209)``. .. note:: The Location string is fully stored in ``Interval.metadata`` with key ``__location``. The key starting with ``__`` is "private" and should be modified with care. ``ORIGIN`` section ^^^^^^^^^^^^^^^^^^ The sequence in the ``ORIGIN`` section is always in lowercase for the GenBank files downloaded from NCBI. For the RNA molecules, ``t`` (thymine), instead of ``u`` (uracil) is used in the sequence. All GenBank writers follow these conventions while writing GenBank files. Format Parameters ----------------- Reader-specific Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``constructor`` parameter can be used with the ``Sequence`` generator to specify the in-memory type of each GenBank record that is parsed. ``constructor`` should be ``Sequence`` or a sub-class of ``Sequence``. It is also detected by the unit label on the LOCUS line. For example, if it is ``bp``, it will be read into ``DNA``; if it is ``aa``, it will be read into ``Protein``. Otherwise, it will be read into ``Sequence``. This default behavior is overridden by setting ``constructor``. ``lowercase`` is another parameter available for all GenBank readers. By default, it is set to ``True`` to read in the ``ORIGIN`` sequence as lowercase letters. This parameter is passed to ``Sequence`` or its sub-class constructor. ``seq_num`` is a parameter used with the ``Sequence``, ``DNA``, ``RNA``, and ``Protein`` GenBank readers. It specifies which GenBank record to read from a GenBank file with multiple records in it. Examples -------- Reading and Writing GenBank Files ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Suppose we have the following GenBank file example modified from [5]_: >>> gb_str = ''' ... LOCUS 3K1V_A 34 bp RNA linear SYN 10-OCT-2012 ... DEFINITION Chain A, Structure Of A Mutant Class-I Preq1. ... ACCESSION 3K1V_A ... VERSION 3K1V_A GI:260656459 ... KEYWORDS . ... SOURCE synthetic construct ... ORGANISM synthetic construct ... other sequences; artificial sequences. ... REFERENCE 1 (bases 1 to 34) ... AUTHORS Klein,D.J., Edwards,T.E. and Ferre-D'Amare,A.R. ... TITLE Cocrystal structure of a class I preQ1 riboswitch ... JOURNAL Nat. Struct. Mol. Biol. 16 (3), 343-344 (2009) ... PUBMED 19234468 ... COMMENT SEQRES. ... FEATURES Location/Qualifiers ... source 1..34 ... /organism="synthetic construct" ... /mol_type="other RNA" ... /db_xref="taxon:32630" ... misc_binding 1..30 ... /note="Preq1 riboswitch" ... /bound_moiety="preQ1" ... ORIGIN ... 1 agaggttcta gcacatccct ctataaaaaa ctaa ... // ... ''' Now we can read it as ``DNA`` object: >>> import io >>> from skbio import DNA, RNA, Sequence >>> gb = io.StringIO(gb_str) >>> dna_seq = DNA.read(gb) >>> dna_seq DNA ----------------------------------------------------------------- Metadata: 'ACCESSION': '3K1V_A' 'COMMENT': 'SEQRES.' 'DEFINITION': 'Chain A, Structure Of A Mutant Class-I Preq1.' 'KEYWORDS': '.' 'LOCUS': 'REFERENCE': 'SOURCE': 'VERSION': '3K1V_A GI:260656459' Interval metadata: 2 interval features Stats: length: 34 has gaps: False has degenerates: False has definites: True GC-content: 35.29% ----------------------------------------------------------------- 0 AGAGGTTCTA GCACATCCCT CTATAAAAAA CTAA Since this is a riboswitch molecule, we may want to read it as ``RNA``. As the GenBank file usually have ``t`` instead of ``u`` in the sequence, we can read it as ``RNA`` by converting ``t`` to ``u``: >>> gb = io.StringIO(gb_str) >>> rna_seq = RNA.read(gb) >>> rna_seq RNA ----------------------------------------------------------------- Metadata: 'ACCESSION': '3K1V_A' 'COMMENT': 'SEQRES.' 'DEFINITION': 'Chain A, Structure Of A Mutant Class-I Preq1.' 'KEYWORDS': '.' 'LOCUS': 'REFERENCE': 'SOURCE': 'VERSION': '3K1V_A GI:260656459' Interval metadata: 2 interval features Stats: length: 34 has gaps: False has degenerates: False has definites: True GC-content: 35.29% ----------------------------------------------------------------- 0 AGAGGUUCUA GCACAUCCCU CUAUAAAAAA CUAA >>> rna_seq == dna_seq.transcribe() True >>> with io.StringIO() as fh: ... print(dna_seq.write(fh, format='genbank').getvalue()) LOCUS 3K1V_A 34 bp RNA linear SYN 10-OCT-2012 DEFINITION Chain A, Structure Of A Mutant Class-I Preq1. ACCESSION 3K1V_A VERSION 3K1V_A GI:260656459 KEYWORDS . SOURCE synthetic construct ORGANISM synthetic construct other sequences; artificial sequences. REFERENCE 1 (bases 1 to 34) AUTHORS Klein,D.J., Edwards,T.E. and Ferre-D'Amare,A.R. TITLE Cocrystal structure of a class I preQ1 riboswitch JOURNAL Nat. Struct. Mol. Biol. 16 (3), 343-344 (2009) PUBMED 19234468 COMMENT SEQRES. FEATURES Location/Qualifiers source 1..34 /db_xref="taxon:32630" /mol_type="other RNA" /organism="synthetic construct" misc_binding 1..30 /bound_moiety="preQ1" /note="Preq1 riboswitch" ORIGIN 1 agaggttcta gcacatccct ctataaaaaa ctaa // References ---------- .. [1] http://www.ncbi.nlm.nih.gov/Sitemap/samplerecord.html .. [2] http://www.insdc.org/ .. [3] http://www.insdc.org/files/feature_table.html .. [4] http://www.ebi.ac.uk/ena/WebFeat/ .. [5] http://www.ncbi.nlm.nih.gov/nuccore/3K1V_A """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re from functools import partial from skbio.io import create_format, GenBankFormatError from skbio.io.format._base import ( _get_nth_sequence, _line_generator, _too_many_blanks) from skbio.util._misc import chunk_str from skbio.sequence import Sequence, DNA, RNA, Protein from skbio.io.format._sequence_feature_vocabulary import ( _yield_section, _parse_section_default, _serialize_section_default, _parse_feature_table, _serialize_feature_table) genbank = create_format('genbank') # This list is ordered # used to read and write genbank file. _HEADERS = ['LOCUS', 'DEFINITION', 'ACCESSION', 'VERSION', 'DBSOURCE', 'DBLINK', 'KEYWORDS', 'SOURCE', 'REFERENCE', 'COMMENT', 'FEATURES', 'ORIGIN'] @genbank.sniffer() def _genbank_sniffer(fh): # check the 1st real line is a valid LOCUS line if _too_many_blanks(fh, 5): return False, {} try: line = next(_line_generator(fh, skip_blanks=True, strip=False)) except StopIteration: return False, {} try: _parse_locus([line]) except GenBankFormatError: return False, {} return True, {} @genbank.reader(None) def _genbank_to_generator(fh, constructor=None, **kwargs): for record in _parse_genbanks(fh): yield _construct(record, constructor, **kwargs) @genbank.reader(Sequence) def _genbank_to_sequence(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_genbanks(fh), seq_num) return _construct(record, Sequence, **kwargs) @genbank.reader(DNA) def _genbank_to_dna(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_genbanks(fh), seq_num) return _construct(record, DNA, **kwargs) @genbank.reader(RNA) def _genbank_to_rna(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_genbanks(fh), seq_num) return _construct(record, RNA, **kwargs) @genbank.reader(Protein) def _genbank_to_protein(fh, seq_num=1, **kwargs): record = _get_nth_sequence(_parse_genbanks(fh), seq_num) return _construct(record, Protein, **kwargs) @genbank.writer(None) def _generator_to_genbank(obj, fh): for obj_i in obj: _serialize_single_genbank(obj_i, fh) @genbank.writer(Sequence) def _sequence_to_genbank(obj, fh): _serialize_single_genbank(obj, fh) @genbank.writer(DNA) def _dna_to_genbank(obj, fh): _serialize_single_genbank(obj, fh) @genbank.writer(RNA) def _rna_to_genbank(obj, fh): _serialize_single_genbank(obj, fh) @genbank.writer(Protein) def _protein_to_genbank(obj, fh): _serialize_single_genbank(obj, fh) def _construct(record, constructor=None, **kwargs): '''Construct the object of Sequence, DNA, RNA, or Protein. ''' seq, md, imd = record if 'lowercase' not in kwargs: kwargs['lowercase'] = True if constructor is None: unit = md['LOCUS']['unit'] if unit == 'bp': # RNA mol type has T instead of U for genbank from from NCBI constructor = DNA elif unit == 'aa': constructor = Protein if constructor == RNA: return DNA( seq, metadata=md, interval_metadata=imd, **kwargs).transcribe() else: return constructor( seq, metadata=md, interval_metadata=imd, **kwargs) def _parse_genbanks(fh): data_chunks = [] for line in _line_generator(fh, skip_blanks=True, strip=False): if line.startswith('//'): yield _parse_single_genbank(data_chunks) data_chunks = [] else: data_chunks.append(line) def _parse_single_genbank(chunks): metadata = {} interval_metadata = None sequence = '' # each section starts with a HEADER without indent. section_splitter = _yield_section( lambda x: not x[0].isspace(), strip=False) for section in section_splitter(chunks): header = section[0].split(None, 1)[0] parser = _PARSER_TABLE.get( header, _parse_section_default) if header == 'FEATURES': # This requires 'LOCUS' line parsed before 'FEATURES', which should # be true and is implicitly checked by the sniffer. parser = partial( parser, length=metadata['LOCUS']['size']) parsed = parser(section) # reference can appear multiple times if header == 'REFERENCE': if header in metadata: metadata[header].append(parsed) else: metadata[header] = [parsed] elif header == 'ORIGIN': sequence = parsed elif header == 'FEATURES': interval_metadata = parsed else: metadata[header] = parsed return sequence, metadata, interval_metadata def _serialize_single_genbank(obj, fh): '''Write a GenBank record. Always write it in NCBI canonical way: 1. sequence in lowercase 2. 'u' as 't' even in RNA molecules. Parameters ---------- obj : Sequence or its child class ''' # write out the headers md = obj.metadata for header in _HEADERS: serializer = _SERIALIZER_TABLE.get( header, _serialize_section_default) if header in md: out = serializer(header, md[header]) # test if 'out' is a iterator. # cf. Effective Python Item 17 if iter(out) is iter(out): for s in out: fh.write(s) else: fh.write(out) if header == 'FEATURES': if obj.has_interval_metadata(): # magic number 21: the amount of indentation before # feature table starts as defined by INSDC indent = 21 fh.write('{header:<{indent}}Location/Qualifiers\n'.format( header=header, indent=indent)) for s in serializer(obj.interval_metadata._intervals, indent): fh.write(s) # write out the sequence # always write RNA seq as DNA if isinstance(obj, RNA): obj = obj.reverse_transcribe() # always write in lowercase seq_str = str(obj).lower() for s in _serialize_origin(seq_str): fh.write(s) fh.write('//\n') def _parse_locus(lines): '''Parse the line LOCUS. Format: # Positions Contents # --------- -------- # 00:06 LOCUS # 06:12 spaces # 12:?? Locus name # ??:?? space # ??:29 Length of sequence, right-justified # 29:33 space, bp/aa/rc, space # 33:41 molecule type (can be blank): DNA, ssDNA, dsRNA, tRNA, etc. # 41:42 space # 42:51 Blank (implies linear), linear or circular # 51:52 space # 52:55 The division code (e.g. BCT, VRL, INV) # 55:62 space # 62:73 Date, in the form dd-MMM-yyyy (e.g., 15-MAR-1991) ''' line = lines[0] pattern = (r'LOCUS' r' +([^\s]+)' r' +([0-9]+)' r' +(bp|aa|rc)' r' +(.*DNA|.*RNA)?' r' +(linear|circular)?' r' +(?!.*DNA|.*RNA)([A-Z]{3})' r' +([0-9]{2}-[A-Z]{3}-[0-9]{4})') matches = re.match(pattern, line) try: res = dict(zip( ['locus_name', 'size', 'unit', 'mol_type', 'shape', 'division', 'date'], matches.groups())) except Exception: raise GenBankFormatError( "Could not parse the LOCUS line:\n%s" % line) res['size'] = int(res['size']) return res def _serialize_locus(header, obj, indent=12): '''Serialize LOCUS line. Parameters ---------- obj : dict ''' # use 'or' to convert None to '' kwargs = {k: v or '' for k, v in obj.items()} return ('{header:<{indent}}{locus_name} {size} {unit}' ' {mol_type} {shape} {division} {date}\n').format( header=header, indent=indent, **kwargs) def _parse_reference(lines): '''Parse single REFERENCE field. ''' res = {} # magic number 11: the non keyworded lines in REFERENCE # are at least indented with 11 spaces. feature_indent = ' ' * 11 section_splitter = _yield_section( lambda x: not x.startswith(feature_indent), skip_blanks=True, strip=False) for section in section_splitter(lines): label, data = _parse_section_default( section, join_delimiter=' ', return_label=True) res[label] = data return res def _serialize_reference(header, obj, indent=12): '''Serialize REFERENCE. Parameters ---------- obj : list ''' padding = ' ' sort_order = {'REFERENCE': 0, 'AUTHORS': 1, 'TITLE': 2, 'JOURNAL': 3, 'PUBMED': 4} for obj_i in obj: ref_i = [] for h in sorted(obj_i, key=lambda k: sort_order.get(k, 100)): if h == header: s = '{h:<{indent}}{ref}'.format( h=h, indent=indent, ref=obj_i[h]) else: s = '{h:<{indent}}{value}'.format( h=padding + h, indent=indent, value=obj_i[h]) ref_i.append(s) yield '%s\n' % '\n'.join(ref_i) def _parse_source(lines): '''Parse SOURCE field. ''' res = {} # magic number 11: the non keyworded lines in SOURCE # are at least indented with 11 spaces. feature_indent = ' ' * 11 section_splitter = _yield_section( lambda x: not x.startswith(feature_indent), skip_blanks=True, strip=False) # SOURCE line is not informative; skip it _, organism = list(section_splitter(lines)) res['ORGANISM'] = organism[0].split(None, 1)[1].strip() res['taxonomy'] = ' '.join([i.strip() for i in organism[1:]]) return res def _serialize_source(header, obj, indent=12): '''Serialize SOURCE. Parameters ---------- obj : dict ''' s = ('{header:<{indent}}{organism}\n' '{h:<{indent}}{organism}\n' '{space}{taxonomy}\n').format( header=header, indent=indent, h=' ORGANISM', organism=obj['ORGANISM'], space=' ' * 12, taxonomy=obj['taxonomy']) return s def _parse_origin(lines): '''Parse the ORIGIN section for sequence. ''' sequence = [] for line in lines: if line.startswith('ORIGIN'): continue # remove the number at the beg of each line items = line.split() sequence.append(''.join(items[1:])) return ''.join(sequence) def _serialize_origin(seq, indent=9): '''Serialize seq to ORIGIN. Parameters ---------- seq : str ''' n = 1 line_size = 60 frag_size = 10 for i in range(0, len(seq), line_size): line = seq[i:i+line_size] s = '{n:>{indent}} {s}\n'.format( n=n, indent=indent, s=chunk_str(line, frag_size, ' ')) if n == 1: s = 'ORIGIN\n' + s n = n + line_size yield s _PARSER_TABLE = { 'LOCUS': _parse_locus, 'SOURCE': _parse_source, 'REFERENCE': _parse_reference, 'FEATURES': _parse_feature_table, 'ORIGIN': _parse_origin} _SERIALIZER_TABLE = { 'LOCUS': _serialize_locus, 'SOURCE': _serialize_source, 'REFERENCE': _serialize_reference, 'FEATURES': _serialize_feature_table} scikit-bio-0.5.9/skbio/io/format/gff3.py000066400000000000000000000441551446255456000200130ustar00rootroot00000000000000'''GFF3 format (:mod:`skbio.io.format.gff3`) ========================================= .. currentmodule:: skbio.io.format.gff3 GFF3 (Generic Feature Format version 3) is a standard file format for describing features for biological sequences. It contains lines of text, each consisting of 9 tab-delimited columns [1]_. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.metadata.IntervalMetadata` | +------+------+---------------------------------------------------------------+ |Yes |Yes |generator of tuple (seq_id of str type, | | | |:mod:`skbio.metadata.IntervalMetadata`) | +------+------+---------------------------------------------------------------+ Format Specification -------------------- **State: Experimental as of 0.5.1.** The first line of the file is a comment that identifies the format and version. This is followed by a series of data lines. Each data line corresponds to an annotation and consists of 9 columns: SEQID, SOURCE, TYPE, START, END, SCORE, STRAND, PHASE, and ATTR. Column 9 (ATTR) is list of feature attributes in the format "tag=value". Multiple "tag=value" pairs are delimited by semicolons. Multiple values of the same tag are separated with the comma ",". The following tags have predefined meanings: ID, Name, Alias, Parent, Target, Gap, Derives_from, Note, Dbxref, Ontology_term, and Is_circular. The meaning and format of these columns and attributes are explained detail in the format specification [1]_. And they are read in as the vocabulary defined in GenBank parser (:mod:`skbio.io.format.genbank`). Format Parameters ----------------- Reader-specific Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ ``IntervalMetadata`` GFF3 reader requires 1 parameter: ``seq_id``. It reads the annotation with the specified sequence ID from the GFF3 file into an ``IntervalMetadata`` object. ``DNA`` and ``Sequence`` GFF3 readers require ``seq_num`` of int as parameter. It specifies which GFF3 record to read from a GFF3 file with annotations of multiple sequences in it. Writer-specific Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ ``skip_subregion`` is a boolean parameter used by all the GFF3 writers. It specifies whether you would like to write each non-contiguous sub-region for a feature annotation. For example, if there is interval feature for a gene with two exons in an ``IntervalMetadata`` object, it will write one line into the GFF3 file when ``skip_subregion`` is ``True`` and will write 3 lines (one for the gene and one for each exon, respectively) when ``skip_subregion`` is ``False``. Default is ``True``. In addition, ``IntervalMetadata`` GFF3 writer needs a parameter of ``seq_id``. It specify the sequence ID (column 1 in GFF3 file) that the annotation belong to. Examples -------- Let's create a file stream with following data in GFF3 format: >>> from skbio import Sequence, DNA >>> gff_str = """ ... ##gff-version 3 ... seq_1\\t.\\tgene\\t10\\t90\\t.\\t+\\t0\\tID=gen1 ... seq_1\\t.\\texon\\t10\\t30\\t.\\t+\\t.\\tParent=gen1 ... seq_1\\t.\\texon\\t50\\t90\\t.\\t+\\t.\\tParent=gen1 ... seq_2\\t.\\tgene\\t80\\t96\\t.\\t-\\t.\\tID=gen2 ... ##FASTA ... >seq_1 ... ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... >seq_2 ... ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... """ >>> import io >>> from skbio.metadata import IntervalMetadata >>> from skbio.io import read >>> gff = io.StringIO(gff_str) We can read it into ``IntervalMetadata``. Each line will be read into an interval feature in ``IntervalMetadata`` object: >>> im = read(gff, format='gff3', into=IntervalMetadata, ... seq_id='seq_1') >>> im # doctest: +SKIP 3 interval features ------------------- Interval(interval_metadata=<4604421736>, bounds=[(9, 90)], \ fuzzy=[(False, False)], metadata={'type': 'gene', \ 'phase': 0, 'strand': '+', 'source': '.', 'score': '.', 'ID': 'gen1'}) Interval(interval_metadata=<4604421736>, bounds=[(9, 30)], \ fuzzy=[(False, False)], metadata={'strand': '+', 'source': '.', \ 'type': 'exon', 'Parent': 'gen1', 'score': '.'}) Interval(interval_metadata=<4604421736>, bounds=[(49, 90)], \ fuzzy=[(False, False)], metadata={'strand': '+', 'source': '.', \ 'type': 'exon', 'Parent': 'gen1', 'score': '.'}) We can write the ``IntervalMetadata`` object back to GFF3 file: >>> with io.StringIO() as fh: # doctest: +NORMALIZE_WHITESPACE ... print(im.write(fh, format='gff3', seq_id='seq_1').getvalue()) ##gff-version 3 seq_1 . gene 10 90 . + 0 ID=gen1 seq_1 . exon 10 30 . + . Parent=gen1 seq_1 . exon 50 90 . + . Parent=gen1 If the GFF3 file does not have the sequence ID, it will return an empty object: >>> gff = io.StringIO(gff_str) >>> im = read(gff, format='gff3', into=IntervalMetadata, ... seq_id='foo') >>> im 0 interval features ------------------- We can also read the GFF3 file into a generator: >>> gff = io.StringIO(gff_str) >>> gen = read(gff, format='gff3') >>> for im in gen: # doctest: +SKIP ... print(im[0]) # the seq id ... print(im[1]) # the interval metadata on this seq seq_1 3 interval features ------------------- Interval(interval_metadata=<4603377592>, bounds=[(9, 90)], \ fuzzy=[(False, False)], metadata={'type': 'gene', 'ID': 'gen1', \ 'source': '.', 'score': '.', 'strand': '+', 'phase': 0}) Interval(interval_metadata=<4603377592>, bounds=[(9, 30)], \ fuzzy=[(False, False)], metadata={'strand': '+', 'type': 'exon', \ 'Parent': 'gen1', 'source': '.', 'score': '.'}) Interval(interval_metadata=<4603377592>, bounds=[(49, 90)], \ fuzzy=[(False, False)], metadata={'strand': '+', 'type': 'exon', \ 'Parent': 'gen1', 'source': '.', 'score': '.'}) seq_2 1 interval feature ------------------ Interval(interval_metadata=<4603378712>, bounds=[(79, 96)], \ fuzzy=[(False, False)], metadata={'strand': '-', 'type': 'gene', \ 'ID': 'gen2', 'source': '.', 'score': '.'}) For the GFF3 file with sequences, we can read it into ``Sequence`` or ``DNA``: >>> gff = io.StringIO(gff_str) >>> seq = read(gff, format='gff3', into=Sequence, seq_num=1) >>> seq Sequence -------------------------------------------------------------------- Metadata: 'description': '' 'id': 'seq_1' Interval metadata: 3 interval features Stats: length: 100 -------------------------------------------------------------------- 0 ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC 60 ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC >>> gff = io.StringIO(gff_str) >>> seq = read(gff, format='gff3', into=DNA, seq_num=2) >>> seq DNA -------------------------------------------------------------------- Metadata: 'description': '' 'id': 'seq_2' Interval metadata: 1 interval feature Stats: length: 120 has gaps: False has degenerates: False has definites: True GC-content: 50.00% -------------------------------------------------------------------- 0 ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC 60 ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC ATGCATGCAT GCATGCATGC References ---------- .. [1] https://github.com/The-Sequence-Ontology/\ Specifications/blob/master/gff3.md ''' # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re from collections.abc import Iterable from skbio.sequence import DNA, Sequence from skbio.io import create_format, GFF3FormatError from skbio.metadata import IntervalMetadata from skbio.io.format._base import ( _line_generator, _too_many_blanks, _get_nth_sequence) from skbio.io.format.fasta import _fasta_to_generator from skbio.io.format._sequence_feature_vocabulary import ( _vocabulary_change, _vocabulary_skip) from skbio.io import write gff3 = create_format('gff3') @gff3.sniffer() def _gff3_sniffer(fh): # check the 1st real line is a valid ID line if _too_many_blanks(fh, 5): return False, {} try: line = next(_line_generator(fh, skip_blanks=True, strip=False)) except StopIteration: return False, {} if re.match(r'##gff-version\s+3', line): return True, {} else: return False, {} @gff3.reader(None) def _gff3_to_generator(fh): '''Parse the GFF3 into the existing IntervalMetadata Parameters ---------- fh : file file handler Yields ------ tuple str of seq id, IntervalMetadata ''' id_lengths = {} for data_type, sid, data in _yield_record(fh): if data_type == 'length': # get length from sequence-region pragma. # the pragma lines are always before the real annotation lines. id_lengths[sid] = data elif data_type == 'data': length = id_lengths.get(sid) yield sid, _parse_record(data, length) @gff3.writer(None) def _generator_to_gff3(obj, fh, skip_subregion=True): '''Write list of IntervalMetadata into file. Parameters ---------- obj : Iterable of (seq_id, IntervalMetadata) fh : file handler skip_subregion : bool write a line for each sub-regions of an ``Interval`` if it is ``False`` ''' # write file header fh.write('##gff-version 3\n') for seq_id, obj_i in obj: _serialize_interval_metadata(obj_i, seq_id, fh, skip_subregion) @gff3.reader(Sequence) def _gff3_to_sequence(fh, seq_num=1): return _construct_seq(fh, Sequence, seq_num) @gff3.writer(Sequence) def _sequence_to_gff3(obj, fh, skip_subregion=True): # write file header fh.write('##gff-version 3\n') _serialize_seq(obj, fh, skip_subregion) @gff3.reader(DNA) def _gff3_to_dna(fh, seq_num=1): return _construct_seq(fh, DNA, seq_num) @gff3.writer(DNA) def _dna_to_gff3(obj, fh, skip_subregion=True): # write file header fh.write('##gff-version 3\n') _serialize_seq(obj, fh, skip_subregion) @gff3.reader(IntervalMetadata) def _gff3_to_interval_metadata(fh, seq_id): '''Read a GFF3 record into the specified interval metadata. Parameters ---------- fh : file handler seq_id : str sequence ID which the interval metadata is associated with ''' length = None for data_type, sid, data in _yield_record(fh): if seq_id == sid: if data_type == 'length': # get length from sequence-region pragma length = data elif data_type == 'data': return _parse_record(data, length) else: raise GFF3FormatError( 'Unknown section in the input GFF3 file: ' '%r %r %r' % (data_type, sid, data)) # return an empty instead of None return IntervalMetadata(None) @gff3.writer(IntervalMetadata) def _interval_metadata_to_gff3(obj, fh, seq_id, skip_subregion=True): '''Output ``IntervalMetadata`` object to GFF3 file. Parameters ---------- obj : IntervalMetadata fh : file object like seq_id : str ID for column 1 in the GFF3 file. skip_subregion : bool write a line for each sub-regions of an ``Interval`` if it is ``False`` ''' # write file header fh.write('##gff-version 3\n') _serialize_interval_metadata(obj, seq_id, fh, skip_subregion=True) def _construct_seq(fh, constructor=DNA, seq_num=1): lines = [] for i, (data_type, seq_id, l) in enumerate(_yield_record(fh), 1): if data_type == 'data' and seq_num == i: lines = l seq = _get_nth_sequence(_fasta_to_generator(fh, constructor=constructor), seq_num=seq_num) seq.interval_metadata = _parse_record(lines, len(seq)) return seq def _yield_record(fh): '''Yield (seq_id, lines) that belong to the same sequence.''' lines = [] current = False for line in _line_generator(fh, skip_blanks=True, strip=True): if line.startswith('##sequence-region'): _, seq_id, start, end = line.split() length = int(end) - int(start) + 1 yield 'length', seq_id, length if line.startswith('##FASTA'): # stop once reaching to sequence section break if not line.startswith('#'): try: seq_id, _ = line.split('\t', 1) except ValueError: raise GFF3FormatError( 'Wrong GFF3 format at line: %s' % line) if current == seq_id: lines.append(line) else: if current is not False: yield 'data', current, lines lines = [line] current = seq_id if current is False: # if the input file object is empty, it should return # an empty generator return yield else: yield 'data', current, lines def _parse_record(lines, length): '''Parse the lines into a IntervalMetadata object.''' interval_metadata = IntervalMetadata(length) for line in lines: columns = line.split('\t') # there should be 9 columns if len(columns) != 9: raise GFF3FormatError( 'do not have 9 columns in this line: "%s"' % line) # the 1st column is seq ID for every feature. don't store # this repetitive information metadata = {'source': columns[1], 'type': columns[2], 'score': columns[5], 'strand': columns[6]} phase = columns[7] # phase value can only be int or '.' try: metadata['phase'] = int(phase) except ValueError: if phase != '.': raise GFF3FormatError( 'unknown value for phase column: {!r}'.format(phase)) metadata.update(_parse_attr(columns[8])) start, end = columns[3:5] bounds = [(int(start)-1, int(end))] interval_metadata.add(bounds, metadata=metadata) return interval_metadata def _parse_attr(s): '''parse attribute column''' voca_change = _vocabulary_change('gff3') md = {} # in case the line ending with ';', strip it. s = s.rstrip(';') for attr in s.split(';'): k, v = attr.split('=') if k in voca_change: k = voca_change[k] md[k] = v return md def _serialize_interval_metadata(interval_metadata, seq_id, fh, skip_subregion=True): '''Serialize an IntervalMetadata to GFF3. Parameters ---------- interval_metadata : IntervalMetadata seq_id : str Seq id for the current annotation. It will be used as the 1st column in the GFF3. fh : file handler the file object to output skip_subregion : bool Whether to skip outputting each sub region as a line in GFF3. ''' column_keys = ['source', 'type', 'score', 'strand', 'phase'] voca_change = _vocabulary_change('gff3', False) voca_skip = _vocabulary_skip('gff3') voca_skip.extend(column_keys) # these characters have reserved meanings in column 9 and must be # escaped when used in other contexts escape = str.maketrans({';': '%3B', '=': '%3D', '&': '%26', ',': '%2C'}) for interval in interval_metadata._intervals: md = interval.metadata bd = interval.bounds start = str(bd[0][0] + 1) end = str(bd[-1][-1]) source, feat_type, score, strand, phase = [ str(md.get(i, '.')) for i in column_keys] columns = [seq_id, source, feat_type, start, end, score, strand, phase] # serialize the attributes in column 9 attr = [] # use sort to make the output order deterministic for k in sorted(md): if k in voca_skip: # skip the metadata that doesn't go to attribute column continue v = md[k] if k in voca_change: k = voca_change[k] if isinstance(v, Iterable) and not isinstance(v, str): # if there are multiple values for this attribute, # convert them to str and concat them with "," v = ','.join(str(i).translate(escape) for i in v) else: v = v.translate(escape) attr.append('%s=%s' % (k.translate(escape), v)) columns.append(';'.join(attr)) fh.write('\t'.join(columns)) fh.write('\n') # if there are multiple regions for this feature, # output each region as a standalone line in GFF3. if len(bd) > 1 and skip_subregion is False: for start, end in bd: # if this is a gene, then each sub region should be an exon if columns[2] == 'gene': columns[2] = 'exon' columns[3] = str(start + 1) columns[4] = str(end) try: parent = md['ID'] except KeyError: raise GFF3FormatError( 'You need provide ID info for ' 'the parent interval feature: %r' % interval) columns[8] = 'Parent=%s' % parent fh.write('\t'.join(columns)) fh.write('\n') def _serialize_seq(seq, fh, skip_subregion=True): '''Serialize a sequence to GFF3.''' _serialize_interval_metadata( seq.interval_metadata, seq.metadata['id'], fh, skip_subregion) fh.write('##FASTA\n') write(seq, into=fh, format='fasta') scikit-bio-0.5.9/skbio/io/format/lsmat.py000066400000000000000000000176301446255456000203040ustar00rootroot00000000000000""" Labeled square matrix format (:mod:`skbio.io.format.lsmat`) =========================================================== .. currentmodule:: skbio.io.format.lsmat The labeled square matrix file format (``lsmat``) stores numeric square matrix data relating a set of objects along each axis. The format also stores identifiers (i.e., unique labels) for the objects. The matrix data and identifiers are stored in delimited text format (e.g., TSV or CSV). This format supports storing a variety of data types including dissimilarity/distance matrices, similarity matrices and amino acid substitution matrices. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.stats.distance.DissimilarityMatrix` | +------+------+---------------------------------------------------------------+ |Yes |Yes |:mod:`skbio.stats.distance.DistanceMatrix` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- The labeled square matrix and object identifiers are stored as delimited text. The first line of the file is the header, which must start with the delimiter, followed by the IDs for all objects in the matrix. Each of the following lines must contain an object's ID, followed by a numeric (float or integer) vector relating the object to all other objects in the matrix. The order of objects is determined by the IDs in the header. For example, assume we have a 2x2 distance matrix with IDs ``'a'`` and ``'b'``. When serialized in this format, the distance matrix might look like:: ab a0.01.0 b1.00.0 where ```` is the delimiter between elements. Lines containing only whitespace may occur anywhere throughout the file and are ignored. Lines starting with ``#`` are treated as comments and are ignored. Comments may only occur *before* the header. IDs will have any leading/trailing whitespace removed when they are parsed. .. note:: This file format is most useful for storing small matrices, or when it is desirable to represent the matrix in a human-readable format, or easily import the file into another program that supports delimited text (e.g., a spreadsheet program). If efficiency is a concern, this format may not be the most appropriate choice. Format Parameters ----------------- The only supported format parameter is ``delimiter``, which defaults to the tab character (``'\\t'``). ``delimiter`` is used to separate elements in the file format. ``delimiter`` can be specified as a keyword argument when reading from or writing to a file. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import csv import numpy as np from skbio.stats.distance import DissimilarityMatrix, DistanceMatrix from skbio.io import create_format, LSMatFormatError lsmat = create_format('lsmat') @lsmat.sniffer() def _lsmat_sniffer(fh): header = _find_header(fh) if header is not None: try: dialect = csv.Sniffer().sniff(header) delimiter = dialect.delimiter ids = _parse_header(header, delimiter) first_id, _ = next(_parse_data(fh, delimiter), (None, None)) if first_id is not None and first_id == ids[0]: return True, {'delimiter': delimiter} except (csv.Error, LSMatFormatError): pass return False, {} @lsmat.reader(DissimilarityMatrix) def _lsmat_to_dissimilarity_matrix(fh, delimiter='\t'): return _lsmat_to_matrix(DissimilarityMatrix, fh, delimiter) @lsmat.reader(DistanceMatrix) def _lsmat_to_distance_matrix(fh, delimiter='\t'): return _lsmat_to_matrix(DistanceMatrix, fh, delimiter) @lsmat.writer(DissimilarityMatrix) def _dissimilarity_matrix_to_lsmat(obj, fh, delimiter='\t'): _matrix_to_lsmat(obj, fh, delimiter) @lsmat.writer(DistanceMatrix) def _distance_matrix_to_lsmat(obj, fh, delimiter='\t'): _matrix_to_lsmat(obj, fh, delimiter) def _lsmat_to_matrix(cls, fh, delimiter): # We aren't using np.loadtxt because it uses *way* too much memory # (e.g, a 2GB matrix eats up 10GB, which then isn't freed after parsing # has finished). See: # http://mail.scipy.org/pipermail/numpy-tickets/2012-August/006749.html # Strategy: # - find the header # - initialize an empty ndarray # - for each row of data in the input file: # - populate the corresponding row in the ndarray with floats header = _find_header(fh) if header is None: raise LSMatFormatError( "Could not find a header line containing IDs in the " "dissimilarity matrix file. Please verify that the file is " "not empty.") ids = _parse_header(header, delimiter) num_ids = len(ids) data = np.empty((num_ids, num_ids), dtype=np.float64) row_idx = -1 for row_idx, (row_id, row_data) in enumerate(_parse_data(fh, delimiter)): if row_idx >= num_ids: # We've hit a nonempty line after we already filled the data # matrix. Raise an error because we shouldn't ignore extra data. raise LSMatFormatError( "Encountered extra row(s) without corresponding IDs in " "the header.") num_vals = len(row_data) if num_vals != num_ids: raise LSMatFormatError( "There are %d value(s) in row %d, which is not equal to the " "number of ID(s) in the header (%d)." % (num_vals, row_idx + 1, num_ids)) expected_id = ids[row_idx] if row_id == expected_id: data[row_idx, :] = np.asarray(row_data, dtype=float) else: raise LSMatFormatError( "Encountered mismatched IDs while parsing the " "dissimilarity matrix file. Found %r but expected " "%r. Please ensure that the IDs match between the " "dissimilarity matrix header (first row) and the row " "labels (first column)." % (str(row_id), str(expected_id))) if row_idx != num_ids - 1: raise LSMatFormatError("Expected %d row(s) of data, but found %d." % (num_ids, row_idx + 1)) return cls(data, ids) def _find_header(fh): header = None for line in fh: stripped_line = line.strip() if stripped_line and not stripped_line.startswith('#'): # Don't strip the header because the first delimiter might be # whitespace (e.g., tab). header = line break return header def _parse_header(header, delimiter): tokens = header.rstrip().split(delimiter) if tokens[0]: raise LSMatFormatError( "Header must start with delimiter %r." % str(delimiter)) return [e.strip() for e in tokens[1:]] def _parse_data(fh, delimiter): for line in fh: stripped_line = line.strip() if not stripped_line: continue tokens = line.rstrip().split(delimiter) id_ = tokens[0].strip() yield id_, tokens[1:] def _matrix_to_lsmat(obj, fh, delimiter): delimiter = "%s" % delimiter ids = obj.ids fh.write(_format_ids(ids, delimiter)) fh.write('\n') for id_, vals in zip(ids, obj.data): fh.write("%s" % id_) fh.write(delimiter) fh.write(delimiter.join(np.asarray(vals, dtype=str))) fh.write('\n') def _format_ids(ids, delimiter): return delimiter.join([''] + list(ids)) scikit-bio-0.5.9/skbio/io/format/newick.py000066400000000000000000000500161446255456000204370ustar00rootroot00000000000000r""" Newick format (:mod:`skbio.io.format.newick`) ============================================= .. currentmodule:: skbio.io.format.newick Newick format (``newick``) stores spanning-trees with weighted edges and node names in a minimal file format [1]_. This is useful for representing phylogenetic trees and taxonomies. Newick was created as an informal specification on June 26, 1986 [2]_. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.tree.TreeNode` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- A Newick file represents a tree using the following grammar. See below for an explanation of the format in plain English. Formal Grammar ^^^^^^^^^^^^^^ .. code-block:: none NEWICK ==> NODE ; NODE ==> FORMATTING SUBTREE FORMATTING NODE_INFO FORMATTING SUBTREE ==> ( CHILDREN ) | null NODE_INFO ==> LABEL | LENGTH | LABEL FORMATTING LENGTH | null FORMATTING ==> [ COMMENT_CHARS ] | whitespace | null CHILDREN ==> NODE | CHILDREN , NODE LABEL ==> ' ALL_CHARS ' | SAFE_CHARS LENGTH ==> : FORMATTING NUMBER COMMENT_CHARS ==> any ALL_CHARS ==> any SAFE_CHARS ==> any except: ,;:()[] and whitespace NUMBER ==> a decimal or integer .. note:: The ``_`` character inside of SAFE_CHARS will be converted to a blank space in ``skbio.tree.TreeNode`` and vice versa. ``'`` is considered the escape character. To escape ``'`` use a preceding ``'``. The implementation of newick in scikit-bio allows nested comments. To escape ``[`` or ``]`` from within COMMENT_CHARS, use a preceding ``'``. Explanation ^^^^^^^^^^^ The Newick format defines a tree by creating a minimal representation of nodes and their relationships to each other. Basic Symbols ~~~~~~~~~~~~~ There are several symbols which define nodes, the first of which is the semi-colon (``;``). The semi-colon creates a root node to its left. Recall that there can only be one root in a tree. The next symbol is the comma (``,``), which creates a node to its right. However, these two alone are not enough. For example imagine the following string: ``, , , ;``. It is evident that there is a root, but the other 3 nodes, defined by commas, have no relationship. For this reason, it is not a valid Newick string to have more than one node at the root level. To provide these relationships, there is another structure: paired parenthesis (``( )``). These are inserted at the location of an existing node and give it the ability to have children. Placing ``( )`` in a node's location will create a child inside the parenthesis on the left-most inner edge. Application of Rules ~~~~~~~~~~~~~~~~~~~~ Adding a comma within the parenthesis will create two children: ``( , )`` (also known as a bifurcating node). Notice that only one comma is needed because the parenthesis have already created a child. Adding more commas will create more children who are siblings to each other. For example, writing ``( , , , )`` will create a multifurcating node with 4 child nodes who are siblings to each other. The notation for a root can be used to create a complete tree. The ``;`` will create a root node where parenthesis can be placed: ``( );``. Adding commas will create more children: ``( , );``. These rules can be applied recursively ad. infinitum: ``(( , ), ( , ));``. Adding Node Information ~~~~~~~~~~~~~~~~~~~~~~~ Information about a node can be added to improve the clarity and meaning of a tree. Each node may have a label and/or a length (to the parent). Newick always places the node information at the right-most edge of a node's position. Starting with labels, ``(( , ), ( , ));`` would become ``((D, E)B, (F, G)C)A;``. There is a named root ``A`` and the root's children (from left to right) are ``B`` and ``C``. ``B`` has the children ``D`` and ``E``, and ``C`` has the children ``F`` and ``G``. Length represents the distance (or weight of the edge) that connects a node to its parent. This must be a decimal or integer. As an example, suppose ``D`` is rather estranged from ``B``, and ``E`` is very close. That can be written as: ``((D:10, E:0.5)B, (F, G)C)A;``. Notice that the colon (``:``) separates the label from the length. If the length is provided but the label is omitted, a colon must still precede the length (``(:0.25,:0.5):0.0;``). Without this, the length would be interpreted as a label (which happens to be a number). .. note:: Internally scikit-bio will cast a length to ``float`` which technically means that even exponent strings (``1e-3``) are supported) Advanced Label and Length Rules ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ More characters can be used to create more descriptive labels. When creating a label there are some rules that must be considered due to limitations in the Newick format. The following characters are not allowed within a standard label: parenthesis, commas, square-brackets, colon, semi-colon, and whitespace. These characters are also disallowed from occurring within a length, which has a much stricter format: decimal or integer. Many of these characters are symbols which define the structure of a Newick tree and are thus disallowed for obvious reasons. The symbols not yet mentioned are square-brackets (``[ ]``) and whitespace (space, tab, and newline). What if these characters are needed within a label? In the simple case of spaces, an underscore (``_``) will be translated as a space on read and vice versa on write. What if a literal underscore or any of the others mentioned are needed? A label can be escaped (meaning that its contents are understood as regular text) using single-quotes (``'``). When a label is surrounded by single-quotes, any character is permissible. If a single-quote is needed inside of an escaped label or anywhere else, it can be escaped with another single-quote. For example, ``A_1`` is written ``'A_1'`` and ``'A'_1`` would be ``'''A''_1'``. Inline Comments ~~~~~~~~~~~~~~~ Square-brackets define a comment, which are the least commonly used part of the Newick format. Comments are not included in the generated objects and exist only as human readable text ignored by the parser. The implementation in scikit-bio allows for nested comments (``[comment [nested]]``). Unpaired square-brackets can be escaped with a single-quote preceding the bracket when inside an existing comment. (This is identical to escaping a single-quote). The single-quote has the highest operator precedence, so there is no need to worry about starting a comment from within a properly escaped label. Whitespace ~~~~~~~~~~ Whitespace is not allowed within any un-escaped label or in any length, but it is permitted anywhere else. Caveats ~~~~~~~ Newick cannot always provide a unique representation of any tree, in other words, the same tree can be written multiple ways. For example: ``(A, B);`` is isomorphic to ``(B, A);``. The implementation in scikit-bio maintains the given sibling order in its object representations. Newick has no representation of an unrooted tree. Some biological packages make the assumption that when a trifurcated root exists in an otherwise bifurcated tree that the tree must be unrooted. In scikit-bio, ``skbio.tree.TreeNode`` will always be rooted at the ``newick`` root (``;``). Format Parameters ----------------- The only supported format parameter is `convert_underscores`. This is `True` by default. When `False`, underscores found in unescaped labels will not be converted to spaces. This is useful when reading the output of an external program in which the underscores were not escaped. This parameter only affects `read` operations. It does not exist for `write` operations; they will always properly escape underscores. Examples -------- This is a simple Newick string. >>> from io import StringIO >>> from skbio import read >>> from skbio.tree import TreeNode >>> f = StringIO("((D, E)B, (F, G)C)A;") >>> tree = read(f, format="newick", into=TreeNode) >>> f.close() >>> print(tree.ascii_art()) /-D /B-------| | \-E -A-------| | /-F \C-------| \-G This is a complex Newick string. >>> f = StringIO("[example](a:0.1, 'b_b''':0.2, (c:0.3, d_d:0.4)e:0.5)f:0.0;") >>> tree = read(f, format="newick", into=TreeNode) >>> f.close() >>> print(tree.ascii_art()) /-a | -f-------|--b_b' | | /-c \e-------| \-d d Notice that the node originally labeled ``d_d`` became ``d d``. Additionally ``'b_b'''`` became ``b_b'``. Note that the underscore was preserved in `b_b'`. References ---------- .. [1] http://evolution.genetics.washington.edu/phylip/newick_doc.html .. [2] http://evolution.genetics.washington.edu/phylip/newicktree.html """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.io import create_format, NewickFormatError from skbio.tree import TreeNode newick = create_format('newick') @newick.sniffer() def _newick_sniffer(fh): # Strategy: # The following conditions preclude a file from being newick: # * It is an empty file. # * There is whitespace inside of a label (handled by tokenizer) # * : is followed by anything that is an operator # * ( is not preceded immediately by , or another ( # * The parens are unbalanced when ; is found. # If 100 tokens (or less if EOF occurs earlier) then it is probably # newick, or at least we can't prove it isn't. operators = set(",;:()") empty = True last_token = ',' indent = 0 try: # 100 tokens ought to be enough for anybody. for token, _ in zip(_tokenize_newick(fh), range(100)): if token not in operators: pass elif token == ',' and last_token != ':' and indent > 0: pass elif token == ':' and last_token != ':': pass elif token == ';' and last_token != ':' and indent == 0: pass elif token == ')' and last_token != ':': indent -= 1 elif token == '(' and (last_token == '(' or last_token == ','): indent += 1 else: raise NewickFormatError() last_token = token empty = False except NewickFormatError: return False, {} return not empty, {} @newick.reader(TreeNode) def _newick_to_tree_node(fh, convert_underscores=True): tree_stack = [] current_depth = 0 last_token = '' next_is_distance = False root = TreeNode() tree_stack.append((root, current_depth)) for token in _tokenize_newick(fh, convert_underscores=convert_underscores): # Check for a label if last_token not in '(,):': if not next_is_distance: tree_stack[-1][0].name = last_token if last_token else None else: next_is_distance = False # Check for a distance if token == ':': next_is_distance = True elif last_token == ':': try: tree_stack[-1][0].length = float(token) except ValueError: raise NewickFormatError("Could not read length as numeric type" ": %s." % token) elif token == '(': current_depth += 1 tree_stack.append((TreeNode(), current_depth)) elif token == ',': tree_stack.append((TreeNode(), current_depth)) elif token == ')': if len(tree_stack) < 2: raise NewickFormatError("Could not parse file as newick." " Parenthesis are unbalanced.") children = [] # Pop all nodes at this depth as they belong to the remaining # node on the top of the stack as children. while current_depth == tree_stack[-1][1]: node, _ = tree_stack.pop() children.insert(0, node) parent = tree_stack[-1][0] if parent.children: raise NewickFormatError("Could not parse file as newick." " Contains unnested children.") # This is much faster than TreeNode.extend for child in children: child.parent = parent parent.children = children current_depth -= 1 elif token == ';': if len(tree_stack) == 1: return root break last_token = token raise NewickFormatError("Could not parse file as newick." " `(Parenthesis)`, `'single-quotes'`," " `[comments]` may be unbalanced, or tree may be" " missing its root.") @newick.writer(TreeNode) def _tree_node_to_newick(obj, fh): operators = set(",:_;()[]") current_depth = 0 nodes_left = [(obj, 0)] while len(nodes_left) > 0: entry = nodes_left.pop() node, node_depth = entry if node.children and node_depth >= current_depth: fh.write('(') nodes_left.append(entry) nodes_left += ((child, node_depth + 1) for child in reversed(node.children)) current_depth = node_depth + 1 else: if node_depth < current_depth: fh.write(')') current_depth -= 1 # Note we don't check for None because there is no way to represent # an empty string as a label in Newick. Therefore, both None and '' # are considered to be the absence of a label. label = node._node_label() if label: escaped = "%s" % label.replace("'", "''") if any(t in operators for t in label): fh.write("'") fh.write(escaped) fh.write("'") else: fh.write(escaped.replace(" ", "_")) if node.length is not None: fh.write(':') fh.write("%s" % node.length) if nodes_left and nodes_left[-1][1] == current_depth: fh.write(',') fh.write(';\n') def _tokenize_newick(fh, convert_underscores=True): structure_tokens = set('(),;:') not_escaped = True label_start = False last_non_ws_char = '' last_char = '' comment_depth = 0 metadata_buffer = [] # Strategy: # We will iterate by character. # Comments in newick are defined as: # [This is a comment] # Nested comments are allowed. # # The following characters indicate structure: # ( ) , ; : # # Whitespace is never allowed in a newick label, so an exception will be # thrown. # # We use ' to indicate a literal string. It has the highest precedence of # any operator. for line in fh: for character in line: # We will start by handling the comment case. # This code branch will probably never execute in practice. # Using a comment_depth we can handle nested comments. # Additionally if we are inside an escaped literal string, then # we don't want to consider it a comment. if character == "[" and not_escaped: # Sometimes we might not want to nest a comment, so we will use # our escape character. This is not explicitly mentioned in # any format specification, but seems like what a reasonable # person might do. if last_non_ws_char != "'" or comment_depth == 0: # Once again, only advance our depth if [ has not been # escaped inside our comment. comment_depth += 1 if comment_depth > 0: # Same as above, but in reverse if character == "]" and last_non_ws_char != "'": comment_depth -= 1 last_non_ws_char = character continue # We are not in a comment block if we are below here. # If we are inside of an escaped string literal, then ( ) , ; are # meaningless to the structure. # Otherwise, we are ready to submit our metadata token. if not_escaped and character in structure_tokens: label_start = False metadata = ''.join(metadata_buffer) # If the following condition is True, then we must have just # closed a literal. We know this because last_non_ws_char is # either None or the last non-whitespace character. # last_non_ws_char is None when we have just escaped an escape # and at the first iteration. if last_non_ws_char == "'" or not convert_underscores: # Make no modifications. yield metadata elif metadata: # Underscores are considered to be spaces when not in an # escaped literal string. yield metadata.replace('_', ' ') # Clear our buffer for the next metadata token and yield our # current structure token. metadata_buffer = [] yield character # We will now handle escaped string literals. # They are inconvenient because any character inside of them is # valid, especially whitespace. # We also need to allow ' to be escaped by '. e.g. '' -> ' elif character == "'": not_escaped = not not_escaped label_start = True if last_non_ws_char == "'": # We are escaping our escape, so it should be added to our # metadata_buffer which will represent some future token. metadata_buffer.append(character) # We do not want a running chain of overcounts, so we need # to clear the last character and continue iteration from # the top. Without this, the following would happen: # ''' ' -> '' # What we want is: # ''' ' -> ' last_non_ws_char = '' last_char = '' continue elif not character.isspace() or not not_escaped: if label_start and last_char.isspace() and not_escaped: raise NewickFormatError("Newick files cannot have" " unescaped whitespace in their" " labels.") metadata_buffer.append(character) label_start = True # This is equivalent to an `else` however it prevents coverage from # mis-identifying the `continue` as uncalled because cpython will # optimize it to a jump that is slightly different from the normal # jump it would have done anyways. elif True: # Skip the last statement last_char = character continue last_char = character # This line is skipped in the following cases: # * comment_depth > 0, i.e. we are in a comment. # * We have just processed the sequence '' and we don't want # the sequence ''' to result in ''. # * We have encountered whitespace that is not properly escaped. last_non_ws_char = character scikit-bio-0.5.9/skbio/io/format/ordination.py000066400000000000000000000341251446255456000213300ustar00rootroot00000000000000r""" Ordination results format (:mod:`skbio.io.format.ordination`) ============================================================= .. currentmodule:: skbio.io.format.ordination The ordination results file format (``ordination``) stores the results of an ordination method in a human-readable, text-based format. The format supports storing the results of various ordination methods available in scikit-bio, including (but not necessarily limited to) PCoA, CA, RDA, and CCA. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.stats.ordination.OrdinationResults` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- The format is text-based, consisting of six attributes that describe the ordination results: - ``Eigvals``: 1-D - ``Proportion explained``: 1-D - ``Species``: 2-D - ``Site``: 2-D - ``Biplot``: 2-D - ``Site constraints``: 2-D The attributes in the file *must* be in this order. Each attribute is defined in its own section of the file, where sections are separated by a blank (or whitespace-only) line. Each attribute begins with a header line, which contains the attribute's name (as listed above), followed by a tab character, followed by one or more tab-separated dimensions (integers) that describe the shape of the attribute's data. The attribute's data follows its header line, and is stored in tab-separated format. ``Species``, ``Site``, and ``Site constraints`` store species and site IDs, respectively, as the first column, followed by the 2-D data array. An example of this file format might look like:: Eigvals4 0.360.180.070.08 Proportion explained4 0.460.230.100.10 Species94 Species00.110.28-0.20-0.00 Species10.140.300.39-0.14 Species2-1.010.09-0.19-0.10 Species3-1.030.100.220.22 Species41.050.53-0.430.22 Species50.990.570.67-0.38 Species60.25-0.17-0.200.43 Species70.14-0.85-0.010.05 Species80.41-0.700.21-0.69 Site104 Site00.71-3.080.21-1.24 Site10.58-3.00-0.942.69 Site20.76-3.152.13-3.11 Site31.111.07-1.870.66 Site4-0.97-0.06-0.69-0.61 Site51.040.45-0.630.28 Site6-0.95-0.080.13-0.42 Site70.94-0.100.52-0.00 Site8-1.140.490.471.17 Site91.031.032.74-1.28 Biplot33 -0.160.630.76 -0.990.06-0.04 0.18-0.970.03 Site constraints104 Site00.69-3.08-0.32-1.24 Site10.66-3.060.232.69 Site20.63-3.040.78-3.11 Site31.100.50-1.550.66 Site4-0.970.06-1.12-0.61 Site51.050.53-0.430.28 Site6-1.020.10-0.00-0.42 Site70.990.570.67-0.00 Site8-1.080.131.111.17 Site90.940.611.79-1.28 If a given result attribute is not present (e.g. ``Biplot``), it should still be defined and declare its dimensions as 0. For example:: Biplot00 All attributes are optional except for ``Eigvals``. Examples -------- Assume we have the following tab-delimited text file storing the ordination results in ``ordination`` format:: Eigvals4 0.360.180.070.08 Proportion explained4 0.460.230.100.10 Species94 Species00.110.28-0.20-0.00 Species10.140.300.39-0.14 Species2-1.010.09-0.19-0.10 Species3-1.030.100.220.22 Species41.050.53-0.430.22 Species50.990.570.67-0.38 Species60.25-0.17-0.200.43 Species70.14-0.85-0.010.05 Species80.41-0.700.21-0.69 Site104 Site00.71-3.080.21-1.24 Site10.58-3.00-0.942.69 Site20.76-3.152.13-3.11 Site31.111.07-1.870.66 Site4-0.97-0.06-0.69-0.61 Site51.040.45-0.630.28 Site6-0.95-0.080.13-0.42 Site70.94-0.100.52-0.00 Site8-1.140.490.471.17 Site91.031.032.74-1.28 Biplot00 Site constraints00 Load the ordination results from the file: >>> from io import StringIO >>> from skbio import OrdinationResults >>> or_f = StringIO( ... "Eigvals\t4\n" ... "0.36\t0.18\t0.07\t0.08\n" ... "\n" ... "Proportion explained\t4\n" ... "0.46\t0.23\t0.10\t0.10\n" ... "\n" ... "Species\t9\t4\n" ... "Species0\t0.11\t0.28\t-0.20\t-0.00\n" ... "Species1\t0.14\t0.30\t0.39\t-0.14\n" ... "Species2\t-1.01\t0.09\t-0.19\t-0.10\n" ... "Species3\t-1.03\t0.10\t0.22\t0.22\n" ... "Species4\t1.05\t0.53\t-0.43\t0.22\n" ... "Species5\t0.99\t0.57\t0.67\t-0.38\n" ... "Species6\t0.25\t-0.17\t-0.20\t0.43\n" ... "Species7\t0.14\t-0.85\t-0.01\t0.05\n" ... "Species8\t0.41\t-0.70\t0.21\t-0.69\n" ... "\n" ... "Site\t10\t4\n" ... "Site0\t0.71\t-3.08\t0.21\t-1.24\n" ... "Site1\t0.58\t-3.00\t-0.94\t2.69\n" ... "Site2\t0.76\t-3.15\t2.13\t-3.11\n" ... "Site3\t1.11\t1.07\t-1.87\t0.66\n" ... "Site4\t-0.97\t-0.06\t-0.69\t-0.61\n" ... "Site5\t1.04\t0.45\t-0.63\t0.28\n" ... "Site6\t-0.95\t-0.08\t0.13\t-0.42\n" ... "Site7\t0.94\t-0.10\t0.52\t-0.00\n" ... "Site8\t-1.14\t0.49\t0.47\t1.17\n" ... "Site9\t1.03\t1.03\t2.74\t-1.28\n" ... "\n" ... "Biplot\t0\t0\n" ... "\n" ... "Site constraints\t0\t0\n") >>> ord_res = OrdinationResults.read(or_f) """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd from skbio.stats.ordination import OrdinationResults from skbio.io import create_format, OrdinationFormatError ordination = create_format('ordination') @ordination.sniffer() def _ordination_sniffer(fh): # Smells an ordination file if *all* of the following lines are present # *from the beginning* of the file: # - eigvals header (minimally parsed) # - another line (contents ignored) # - a whitespace-only line # - proportion explained header (minimally parsed) try: _parse_header(fh, 'Eigvals', 1) next_line = next(fh, None) if next_line is not None: _check_empty_line(fh) _parse_header(fh, 'Proportion explained', 1) return True, {} except OrdinationFormatError: pass return False, {} @ordination.reader(OrdinationResults) def _ordination_to_ordination_results(fh): eigvals = _parse_vector_section(fh, 'Eigvals') if eigvals is None: raise OrdinationFormatError("At least one eigval must be present.") _check_empty_line(fh) prop_expl = _parse_vector_section(fh, 'Proportion explained') _check_length_against_eigvals(prop_expl, eigvals, 'proportion explained values') _check_empty_line(fh) species = _parse_array_section(fh, 'Species') _check_length_against_eigvals(species, eigvals, 'coordinates per species') _check_empty_line(fh) site = _parse_array_section(fh, 'Site') _check_length_against_eigvals(site, eigvals, 'coordinates per site') _check_empty_line(fh) # biplot does not have ids to parse (the other arrays do) biplot = _parse_array_section(fh, 'Biplot', has_ids=False) _check_empty_line(fh) cons = _parse_array_section(fh, 'Site constraints') if cons is not None and site is not None: if not np.array_equal(cons.index, site.index): raise OrdinationFormatError( "Site constraints ids and site ids must be equal: %s != %s" % (cons.index, site.index)) return OrdinationResults( short_method_name='', long_method_name='', eigvals=eigvals, features=species, samples=site, biplot_scores=biplot, sample_constraints=cons, proportion_explained=prop_expl) def _parse_header(fh, header_id, num_dimensions): line = next(fh, None) if line is None: raise OrdinationFormatError( "Reached end of file while looking for %s header." % header_id) header = line.strip().split('\t') # +1 for the header ID if len(header) != num_dimensions + 1 or header[0] != header_id: raise OrdinationFormatError("%s header not found." % header_id) return header def _check_empty_line(fh): """Check that the next line in `fh` is empty or whitespace-only.""" line = next(fh, None) if line is None: raise OrdinationFormatError( "Reached end of file while looking for blank line separating " "sections.") if line.strip(): raise OrdinationFormatError("Expected an empty line.") def _check_length_against_eigvals(data, eigvals, label): if data is not None: num_vals = data.shape[-1] num_eigvals = eigvals.shape[-1] if num_vals != num_eigvals: raise OrdinationFormatError( "There should be as many %s as eigvals: %d != %d" % (label, num_vals, num_eigvals)) def _parse_vector_section(fh, header_id): header = _parse_header(fh, header_id, 1) # Parse how many values we are waiting for num_vals = int(header[1]) if num_vals == 0: # The ordination method didn't generate the vector, so set it to None vals = None else: # Parse the line with the vector values line = next(fh, None) if line is None: raise OrdinationFormatError( "Reached end of file while looking for line containing values " "for %s section." % header_id) vals = pd.Series(np.asarray(line.strip().split('\t'), dtype=np.float64)) if len(vals) != num_vals: raise OrdinationFormatError( "Expected %d values in %s section, but found %d." % (num_vals, header_id, len(vals))) return vals def _parse_array_section(fh, header_id, has_ids=True): """Parse an array section of `fh` identified by `header_id`.""" # Parse the array header header = _parse_header(fh, header_id, 2) # Parse the dimensions of the array rows = int(header[1]) cols = int(header[2]) ids = None if rows == 0 and cols == 0: # The ordination method didn't generate the array data for 'header', so # set it to None data = None elif rows == 0 or cols == 0: # Both dimensions should be 0 or none of them are zero raise OrdinationFormatError("One dimension of %s is 0: %d x %d" % (header_id, rows, cols)) else: # Parse the data data = np.empty((rows, cols), dtype=np.float64) if has_ids: ids = [] for i in range(rows): # Parse the next row of data line = next(fh, None) if line is None: raise OrdinationFormatError( "Reached end of file while looking for row %d in %s " "section." % (i + 1, header_id)) vals = line.strip().split('\t') if has_ids: ids.append(vals[0]) vals = vals[1:] if len(vals) != cols: raise OrdinationFormatError( "Expected %d values, but found %d in row %d." % (cols, len(vals), i + 1)) data[i, :] = np.asarray(vals, dtype=np.float64) data = pd.DataFrame(data, index=ids) return data @ordination.writer(OrdinationResults) def _ordination_results_to_ordination(obj, fh): _write_vector_section(fh, 'Eigvals', obj.eigvals) _write_vector_section(fh, 'Proportion explained', obj.proportion_explained) _write_array_section(fh, 'Species', obj.features) _write_array_section(fh, 'Site', obj.samples) _write_array_section(fh, 'Biplot', obj.biplot_scores, has_ids=False) _write_array_section(fh, 'Site constraints', obj.sample_constraints, include_section_separator=False) def _write_vector_section(fh, header_id, vector): if vector is None: shape = 0 else: shape = vector.shape[0] fh.write("%s\t%d\n" % (header_id, shape)) if vector is not None: fh.write(_format_vector(vector.values)) fh.write("\n") def _write_array_section(fh, header_id, data, has_ids=True, include_section_separator=True): # write section header if data is None: shape = (0, 0) else: shape = data.shape fh.write("%s\t%d\t%d\n" % (header_id, shape[0], shape[1])) # write section data if data is not None: if not has_ids: for vals in data.values: fh.write(_format_vector(vals)) else: for id_, vals in zip(data.index, data.values): fh.write(_format_vector(vals, id_)) if include_section_separator: fh.write("\n") def _format_vector(vector, id_=None): formatted_vector = '\t'.join(np.asarray(vector, dtype=str)) if id_ is None: return "%s\n" % formatted_vector else: return "%s\t%s\n" % (id_, formatted_vector) scikit-bio-0.5.9/skbio/io/format/phylip.py000066400000000000000000000335241446255456000204710ustar00rootroot00000000000000""" PHYLIP multiple sequence alignment format (:mod:`skbio.io.format.phylip`) ========================================================================= .. currentmodule:: skbio.io.format.phylip The PHYLIP file format stores a multiple sequence alignment. The format was originally defined and used in Joe Felsenstein's PHYLIP package [1]_, and has since been supported by several other bioinformatics tools (e.g., RAxML [2]_). See [3]_ for the original format description, and [4]_ and [5]_ for additional descriptions. An example PHYLIP-formatted file taken from [3]_:: 5 42 Turkey AAGCTNGGGC ATTTCAGGGT GAGCCCGGGC AATACAGGGT AT Salmo gairAAGCCTTGGC AGTGCAGGGT GAGCCGTGGC CGGGCACGGT AT H. SapiensACCGGTTGGC CGTTCAGGGT ACAGGTTGGC CGTTCAGGGT AA Chimp AAACCCTTGC CGTTACGCTT AAACCGAGGC CGGGACACTC AT Gorilla AAACCCTTGC CGGTACGCTT AAACCATTGC CGGTACGCTT AA .. note:: Original copyright notice for the above PHYLIP file: *(c) Copyright 1986-2008 by The University of Washington. Written by Joseph Felsenstein. Permission is granted to copy this document provided that no fee is charged for it and that this copyright notice is not removed.* Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.alignment.TabularMSA` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- PHYLIP format is a plain text format containing exactly two sections: a header describing the dimensions of the alignment, followed by the multiple sequence alignment itself. The format described here is "strict" PHYLIP, as described in [4]_. Strict PHYLIP requires that each sequence identifier is exactly 10 characters long (padded with spaces as necessary). Other bioinformatics tools (e.g., RAxML) may relax this rule to allow for longer sequence identifiers. See the **Alignment Section** below for more details. The format described here is "sequential" format. The original PHYLIP format specification [3]_ describes both sequential and interleaved formats. .. note:: scikit-bio currently supports reading and writing strict, sequential PHYLIP-formatted files. Relaxed and/or interleaved PHYLIP formats are not supported. Header Section ^^^^^^^^^^^^^^ The header consists of a single line describing the dimensions of the alignment. It **must** be the first line in the file. The header consists of optional spaces, followed by two positive integers (``n`` and ``m``) separated by one or more spaces. The first integer (``n``) specifies the number of sequences (i.e., the number of rows) in the alignment. The second integer (``m``) specifies the length of the sequences (i.e., the number of columns) in the alignment. The smallest supported alignment dimensions are 1x1. .. note:: scikit-bio will write the PHYLIP format header *without* preceding spaces, and with only a single space between ``n`` and ``m``. PHYLIP format *does not* support blank line(s) between the header and the alignment. Alignment Section ^^^^^^^^^^^^^^^^^ The alignment section immediately follows the header. It consists of ``n`` lines (rows), one for each sequence in the alignment. Each row consists of a sequence identifier (ID) and characters in the sequence, in fixed width format. The sequence ID can be up to 10 characters long. IDs less than 10 characters must have spaces appended to them to reach the 10 character fixed width. Within an ID, all characters except newlines are supported, including spaces, underscores, and numbers. .. note:: When reading a PHYLIP-formatted file into an ``skbio.alignment.TabularMSA`` object, sequence identifiers/labels are stored as ``TabularMSA`` index labels (``index`` property). When writing an ``skbio.alignment.TabularMSA`` object as a PHYLIP-formatted file, ``TabularMSA`` index labels will be converted to strings and written as sequence identifiers/labels. scikit-bio supports the empty string (``''``) as a valid sequence ID. An empty ID will be padded with 10 spaces when writing. Sequence characters immediately follow the sequence ID. They *must* start at the 11th character in the line, as the first 10 characters are reserved for the sequence ID. While PHYLIP format does not explicitly restrict the set of supported characters that may be used to represent a sequence, the original format description [3]_ specifies the IUPAC nucleic acid lexicon for DNA or RNA sequences, and the IUPAC protein lexicon for protein sequences. The original PHYLIP specification uses ``-`` as a gap character, though older versions also supported ``.``. The sequence characters may contain optional spaces (e.g., to improve readability), and both upper and lower case characters are supported. .. note:: scikit-bio will read/write a PHYLIP-formatted file as long as the alignment's sequence characters are valid for the type of in-memory sequence object being read into or written from. This differs from the PHYLIP specification, which states that a PHYLIP-formatted file can only contain valid IUPAC characters. See the ``constructor`` format parameter below for details. Since scikit-bio supports both ``-`` and ``.`` as gap characters (e.g., in ``DNA``, ``RNA``, and ``Protein`` sequence objects), both are supported when reading/writing a PHYLIP-formatted file. When writing a PHYLIP-formatted file, scikit-bio will split up each sequence into chunks that are 10 characters long. Each chunk will be separated by a single space. The sequence will always appear on a single line (sequential format). It will *not* be wrapped across multiple lines. Sequences are chunked in this manner for improved readability, and because most example PHYLIP files are chunked in a similar way (e.g., see the example file above). Note that this chunking is not required when reading PHYLIP-formatted files, nor by the PHYLIP format specification itself. Format Parameters ----------------- The only supported format parameter is ``constructor``, which specifies the type of in-memory sequence object to read each aligned sequence into. This must be a subclass of ``GrammaredSequence`` (e.g., ``DNA``, ``RNA``, ``Protein``) and is a required format parameter. For example, if you know that the PHYLIP file you're reading contains DNA sequences, you would pass ``constructor=DNA`` to the reader call. Examples -------- Let's create a ``TabularMSA`` with three DNA sequences: >>> from skbio import TabularMSA, DNA >>> seqs = [DNA('ACCGTTGTA-GTAGCT', metadata={'id':'seq1'}), ... DNA('A--GTCGAA-GTACCT', metadata={'id':'sequence-2'}), ... DNA('AGAGTTGAAGGTATCT', metadata={'id':'3'})] >>> msa = TabularMSA(seqs, minter='id') >>> msa TabularMSA[DNA] ---------------------- Stats: sequence count: 3 position count: 16 ---------------------- ACCGTTGTA-GTAGCT A--GTCGAA-GTACCT AGAGTTGAAGGTATCT >>> msa.index Index(['seq1', 'sequence-2', '3'], dtype='object') Now let's write the ``TabularMSA`` to file in PHYLIP format and take a look at the output: >>> from io import StringIO >>> fh = StringIO() >>> print(msa.write(fh, format='phylip').getvalue()) 3 16 seq1 ACCGTTGTA- GTAGCT sequence-2A--GTCGAA- GTACCT 3 AGAGTTGAAG GTATCT >>> fh.close() Notice that the 16-character sequences were split into two chunks, and that each sequence appears on a single line (sequential format). Also note that each sequence ID is padded with spaces to 10 characters in order to produce a fixed width column. If the index labels in a ``TabularMSA`` surpass the 10-character limit, an error will be raised when writing: >>> msa.index = ['seq1', 'long-sequence-2', 'seq3'] >>> fh = StringIO() >>> msa.write(fh, format='phylip') Traceback (most recent call last): ... skbio.io._exception.PhylipFormatError: ``TabularMSA`` can only be written in \ PHYLIP format if all sequence index labels have 10 or fewer characters. Found \ sequence with index label 'long-sequence-2' that exceeds this limit. Use \ ``TabularMSA.reassign_index`` to assign shorter index labels. >>> fh.close() One way to work around this is to assign shorter index labels. The recommended way to do this is via ``TabularMSA.reassign_index``. For example, to reassign default integer index labels: >>> msa.reassign_index() >>> msa.index RangeIndex(start=0, stop=3, step=1) We can now write the ``TabularMSA`` in PHYLIP format: >>> fh = StringIO() >>> print(msa.write(fh, format='phylip').getvalue()) 3 16 0 ACCGTTGTA- GTAGCT 1 A--GTCGAA- GTACCT 2 AGAGTTGAAG GTATCT >>> fh.close() References ---------- .. [1] http://evolution.genetics.washington.edu/phylip.html .. [2] RAxML Version 8: A tool for Phylogenetic Analysis and Post-Analysis of Large Phylogenies". In Bioinformatics, 2014 .. [3] http://evolution.genetics.washington.edu/phylip/doc/sequence.html .. [4] http://www.phylo.org/tools/obsolete/phylip.html .. [5] http://www.bioperl.org/wiki/PHYLIP_multiple_alignment_format """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.alignment import TabularMSA from skbio.io import create_format, PhylipFormatError from skbio.util._misc import chunk_str phylip = create_format('phylip') @phylip.sniffer() def _phylip_sniffer(fh): # Strategy: # Read the header and a single sequence; verify that the sequence length # matches the header information. Do not verify that the total number of # lines matches the header information, since that would require reading # the whole file. try: header = next(_line_generator(fh)) _, seq_len = _validate_header(header) line = next(_line_generator(fh)) _validate_line(line, seq_len) except (StopIteration, PhylipFormatError): return False, {} return True, {} @phylip.reader(TabularMSA) def _phylip_to_tabular_msa(fh, constructor=None): if constructor is None: raise ValueError("Must provide `constructor`.") seqs = [] index = [] for seq, ID in _parse_phylip_raw(fh): seqs.append(constructor(seq)) index.append(ID) return TabularMSA(seqs, index=index) @phylip.writer(TabularMSA) def _tabular_msa_to_phylip(obj, fh): sequence_count = obj.shape.sequence if sequence_count < 1: raise PhylipFormatError( "TabularMSA can only be written in PHYLIP format if there is at " "least one sequence in the alignment.") sequence_length = obj.shape.position if sequence_length < 1: raise PhylipFormatError( "TabularMSA can only be written in PHYLIP format if there is at " "least one position in the alignment.") chunk_size = 10 labels = [str(label) for label in obj.index] for label in labels: if len(label) > chunk_size: raise PhylipFormatError( "``TabularMSA`` can only be written in PHYLIP format if all " "sequence index labels have %d or fewer characters. Found " "sequence with index label '%s' that exceeds this limit. Use " "``TabularMSA.reassign_index`` to assign shorter index labels." % (chunk_size, label)) fh.write('{0:d} {1:d}\n'.format(sequence_count, sequence_length)) fmt = '{0:%d}{1}\n' % chunk_size for label, seq in zip(labels, obj): chunked_seq = chunk_str(str(seq), chunk_size, ' ') fh.write(fmt.format(label, chunked_seq)) def _validate_header(header): header_vals = header.split() try: n_seqs, seq_len = [int(x) for x in header_vals] if n_seqs < 1 or seq_len < 1: raise PhylipFormatError( 'The number of sequences and the length must be positive.') except ValueError: raise PhylipFormatError( 'Found non-header line when attempting to read the 1st record ' '(header line should have two space-separated integers): ' '"%s"' % header) return n_seqs, seq_len def _validate_line(line, seq_len): if not line: raise PhylipFormatError("Empty lines are not allowed.") ID = line[:10].strip() seq = line[10:].replace(' ', '') if len(seq) != seq_len: raise PhylipFormatError( "The length of sequence %s is not %s as specified in the header." % (ID, seq_len)) return (seq, ID) def _parse_phylip_raw(fh): """Raw parser for PHYLIP files. Returns a list of raw (seq, id) values. It is the responsibility of the caller to construct the correct in-memory object to hold the data. """ # Note: this returns the full data instead of yielding each sequence, # because the header specifies the number of sequences, so the file cannot # be validated until it's read completely. # File should have a single header on the first line. try: header = next(_line_generator(fh)) except StopIteration: raise PhylipFormatError("This file is empty.") n_seqs, seq_len = _validate_header(header) # All following lines should be ID+sequence. No blank lines are allowed. data = [] for line in _line_generator(fh): data.append(_validate_line(line, seq_len)) if len(data) != n_seqs: raise PhylipFormatError( "The number of sequences is not %s " % n_seqs + "as specified in the header.") return data def _line_generator(fh): """Just remove linebreak characters and yield lines. """ for line in fh: yield line.rstrip('\n') scikit-bio-0.5.9/skbio/io/format/qseq.py000066400000000000000000000235561446255456000201410ustar00rootroot00000000000000r""" QSeq format (:mod:`skbio.io.format.qseq`) ========================================= .. currentmodule:: skbio.io.format.qseq The QSeq format (`qseq`) is a record-based, plain text output format produced by some DNA sequencers for storing biological sequence data, quality scores, per-sequence filtering information, and run-specific metadata. Format Support -------------- **Has Sniffer: Yes** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |No |generator of :mod:`skbio.sequence.Sequence` objects | +------+------+---------------------------------------------------------------+ |Yes |No |:mod:`skbio.sequence.Sequence` | +------+------+---------------------------------------------------------------+ |Yes |No |:mod:`skbio.sequence.DNA` | +------+------+---------------------------------------------------------------+ |Yes |No |:mod:`skbio.sequence.RNA` | +------+------+---------------------------------------------------------------+ |Yes |No |:mod:`skbio.sequence.Protein` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- A QSeq file is composed of single-line records, delimited by tabs. There are 11 fields in a record: - Machine name - Run number - Lane number (positive int) - Tile number (positive int) - X coordinate (integer) - Y coordinate (integer) - Index - Read number (1-3) - Sequence data (typically IUPAC characters) - Quality scores (quality scores encoded as printable ASCII) - Filter boolean (1 if sequence has passed CASAVA's filter, 0 otherwise) For more details please refer to the CASAVA documentation [1]_. .. note:: When a QSeq file is read into a scikit-bio object, the object's `metadata` attribute is automatically populated with data corresponding to the names above. .. note:: `lowercase` functionality is supported when reading QSeq files. Refer to specific object constructor documentation for details. .. note:: scikit-bio allows for the filter field to be ommitted, but it is not clear if this is part of the original format specification. Format Parameters ----------------- The following parameters are the same as in FASTQ format (:mod:`skbio.io.format.fastq`): - ``variant``: see ``variant`` parameter in FASTQ format - ``phred_offset``: see ``phred_offset`` parameter in FASTQ format The following additional parameters are the same as in FASTA format (:mod:`skbio.io.format.fasta`): - ``constructor``: see ``constructor`` parameter in FASTA format - ``seq_num``: see ``seq_num`` parameter in FASTA format Generators Only ^^^^^^^^^^^^^^^ - ``filter``: If `True`, excludes sequences that did not pass filtering (i.e., filter field is 0). Default is `True`. Examples -------- Suppose we have the following QSeq file:: illumina 1 3 34 -30 30 0 1 ACG....ACGTAC ruBBBBrBCEFGH 1 illumina 1 3 34 30 -30 0 1 CGGGCATTGCA CGGGCasdGCA 0 illumina 1 3 35 -30 30 0 2 ACGTA.AATAAAC geTaAafhwqAAf 1 illumina 1 3 35 30 -30 0 3 CATTTAGGA.TGCA tjflkAFnkKghvM 0 Let's define this file in-memory as a ``StringIO``, though this could be a real file path, file handle, or anything that's supported by scikit-bio's I/O registry in practice: >>> from io import StringIO >>> fs = '\n'.join([ ... 'illumina\t1\t3\t34\t-30\t30\t0\t1\tACG....ACGTAC\truBBBBrBCEFGH\t1', ... 'illumina\t1\t3\t34\t30\t-30\t0\t1\tCGGGCATTGCA\tCGGGCasdGCA\t0', ... 'illumina\t1\t3\t35\t-30\t30\t0\t2\tACGTA.AATAAAC\tgeTaAafhwqAAf\t1', ... 'illumina\t1\t3\t35\t30\t-30\t0\t3\tCATTTAGGA.TGCA\ttjflkAFnkKghvM\t0' ... ]) >>> fh = StringIO(fs) To iterate over the sequences using the generator reader, we run: >>> import skbio.io >>> for seq in skbio.io.read(fh, format='qseq', variant='illumina1.3'): ... seq ... print('') Sequence -------------------------------------- Metadata: 'id': 'illumina_1:3:34:-30:30#0/1' 'index': 0 'lane_number': 3 'machine_name': 'illumina' 'read_number': 1 'run_number': 1 'tile_number': 34 'x': -30 'y': 30 Positional metadata: 'quality': Stats: length: 13 -------------------------------------- 0 ACG....ACG TAC Sequence -------------------------------------- Metadata: 'id': 'illumina_1:3:35:-30:30#0/2' 'index': 0 'lane_number': 3 'machine_name': 'illumina' 'read_number': 2 'run_number': 1 'tile_number': 35 'x': -30 'y': 30 Positional metadata: 'quality': Stats: length: 13 -------------------------------------- 0 ACGTA.AATA AAC Note that only two sequences were loaded because the QSeq reader filters out sequences whose filter field is 0 (unless ``filter=False`` is supplied). References ---------- .. [1] http://biowulf.nih.gov/apps/CASAVA_UG_15011196B.pdf """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.io import create_format, QSeqFormatError from skbio.io.format._base import _decode_qual_to_phred, _get_nth_sequence from skbio.sequence import Sequence, DNA, RNA, Protein _default_phred_offset = None _default_variant = None _will_filter = True qseq = create_format('qseq') @qseq.sniffer() def _qseq_sniffer(fh): empty = True try: for _, line in zip(range(10), fh): _record_parser(line) empty = False return not empty, {} except QSeqFormatError: return False, {} @qseq.reader(None) def _qseq_to_generator(fh, constructor=Sequence, filter=_will_filter, phred_offset=_default_phred_offset, variant=_default_variant, **kwargs): for line in fh: (machine_name, run, lane, tile, x, y, index, read, seq, raw_qual, filtered) = _record_parser(line) if not filter or not filtered: phred = _decode_qual_to_phred(raw_qual, variant, phred_offset) seq_id = '%s_%s:%s:%s:%s:%s#%s/%s' % ( machine_name, run, lane, tile, x, y, index, read) yield constructor(seq, metadata={'id': seq_id, 'machine_name': machine_name, 'run_number': int(run), 'lane_number': int(lane), 'tile_number': int(tile), 'x': int(x), 'y': int(y), 'index': int(index), 'read_number': int(read)}, positional_metadata={'quality': phred}, **kwargs) @qseq.reader(Sequence) def _qseq_to_sequence(fh, seq_num=1, phred_offset=_default_phred_offset, variant=_default_variant, **kwargs): return _get_nth_sequence(_qseq_to_generator(fh, filter=False, phred_offset=phred_offset, variant=variant, constructor=Sequence, **kwargs), seq_num) @qseq.reader(DNA) def _qseq_to_dna(fh, seq_num=1, phred_offset=_default_phred_offset, variant=_default_variant, **kwargs): return _get_nth_sequence(_qseq_to_generator(fh, filter=False, phred_offset=phred_offset, variant=variant, constructor=DNA, **kwargs), seq_num) @qseq.reader(RNA) def _qseq_to_rna(fh, seq_num=1, phred_offset=_default_phred_offset, variant=_default_variant, **kwargs): return _get_nth_sequence(_qseq_to_generator(fh, filter=False, phred_offset=phred_offset, variant=variant, constructor=RNA, **kwargs), seq_num) @qseq.reader(Protein) def _qseq_to_protein(fh, seq_num=1, phred_offset=_default_phred_offset, variant=_default_variant, **kwargs): return _get_nth_sequence(_qseq_to_generator(fh, filter=False, phred_offset=phred_offset, variant=variant, constructor=Protein, **kwargs), seq_num) def _record_parser(line): fields = line.rstrip('\n') if fields: fields = fields.split('\t') else: raise QSeqFormatError('Found blank line.') f_len = len(fields) if not (10 <= f_len <= 11): raise QSeqFormatError('Expected 10 or 11 fields, found %d.' % f_len) # If the filter field was ommitted, assume that it passed filtering: if f_len == 10: fields.append('1') (machine, run, lane, tile, x, y, index, read, seq, raw_qaul, filter) = fields _test_fields([('filter', filter)], lambda x: x in '01', "0 or 1") _test_fields([('read', read)], lambda x: x in '123', "in the range [1, 3]") _test_fields([('x', x), ('y', y)], lambda x: int(x) is not None, "an integer") _test_fields([('lane', lane), ('tile', tile)], lambda x: int(x) >= 0, "a positive integer") return (machine, run, lane, tile, x, y, index, read, seq, raw_qaul, filter == '0') def _test_fields(iterkv, test, efrag): try: for k, v in iterkv: if not test(v): raise ValueError() except ValueError: raise QSeqFormatError('Field %r is not %s.' % (k, efrag)) scikit-bio-0.5.9/skbio/io/format/stockholm.py000066400000000000000000000715671446255456000212000ustar00rootroot00000000000000""" Stockholm format (:mod:`skbio.io.format.stockholm`) =================================================== .. currentmodule:: skbio.io.format.stockholm The Stockholm format is a multiple sequence alignment format (MSA) that optionally supports storing arbitrary alignment features (metadata). Features can be placed into four different categories: GF, GS, GR, and GC (described in more detail below). An example Stockholm file, taken from [1]_: .. code-block:: none # STOCKHOLM 1.0 #=GF ID UPSK #=GF SE Predicted; Infernal #=GF SS Published; PMID 9223489 #=GF RN [1] #=GF RM 9223489 #=GF RT The role of the pseudoknot at the 3' end of turnip yellow mosaic #=GF RT virus RNA in minus-strand synthesis by the viral RNA-dependent \ RNA #=GF RT polymerase. #=GF RA Deiman BA, Kortlever RM, Pleij CW; #=GF RL J Virol 1997;71:5990-5996. AF035635.1/619-641 UGAGUUCUCGAUCUCUAAAAUCG M24804.1/82-104 UGAGUUCUCUAUCUCUAAAAUCG J04373.1/6212-6234 UAAGUUCUCGAUCUUUAAAAUCG M24803.1/1-23 UAAGUUCUCGAUCUCUAAAAUCG #=GC SS_cons .AAA....<<<>>> // Format Support -------------- **Has Sniffer: Yes** **State: Experimental as of 0.4.2.** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |Yes |:mod:`skbio.alignment.TabularMSA` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- The Stockholm format consists of a header, a multiple sequence alignment, associated metadata (features), and a footer. Header ^^^^^^ The first line of a Stockholm file must be the following header: .. code-block:: none # STOCKHOLM 1.0 Multiple Sequence Alignment ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sequence lines consist of a sequence name, followed by whitespace, followed by the aligned sequence. For example:: seq1 ACG-T-GGT seq2 ACCGTTCG- Sequence names (``seq1``, ``seq2``) are stored in the ``TabularMSA`` ``index``. .. note:: scikit-bio currently supports reading Stockholm files where each sequence is contained on a single line. Interleaved/wrap-around Stockholm files are not supported. When writing, each sequence will be placed on its own line. .. warning:: Sequence names must be unique in the Stockholm file. Likewise, when writing from a ``TabularMSA``, ``index`` must be unique. Metadata ^^^^^^^^ Stockholm files support storing arbitrary metadata (features) about the MSA. All metadata described in the following sections are optional and may appear in any order. Metadata "mark-up" lines begin with either ``#=GF``, ``#=GS``, ``#=GR``, or ``#=GC``, and each line describes a single feature of the alignment. .. note:: Stockholm format supports generic features. [1]_ and [2]_ provide a list of common features output by Pfam/Rfam. scikit-bio does not require that these features are present. These features are processed in the same way as any arbitrary feature would be, as a simple key-value pair of strings. When writing, feature names, feature data, and sequence names are converted to type ``str``. .. note:: When writing a Stockholm file, scikit-bio will place the metadata in the format's recommended order: - GF: Above the alignment - GS: Above the alignment (after GF) - GR: Below corresponding sequence - GC: Below the alignment GF metadata +++++++++++ Data relating to the multiple sequence alignment as a whole, such as authors or number of sequences in the alignment. Starts with ``#=GF`` followed by a feature name and data relating to the feature. Typically comes first in a Stockholm file. For example (taken from [2]_): .. code-block:: none #=GF DE CBS domain Where ``DE`` is the feature name and ``CBS Domain`` is the feature data. GF metadata is stored in the ``TabularMSA`` ``metadata`` dictionary. .. note:: When reading, duplicate GF feature names will have their values concatenated in the order they appear in the file. Concatenation will also add a space between lines if one isn't already there in order to avoid joining words together. When writing, each GF feature will be placed on its own line, regardless of length. .. note:: Trees labelled with ``NH``/``TN`` are handled differently than other GF features. When reading a Stockholm file with these features, the reader follows the rules described in [2]_. Trees split over multiple lines will have their values concatenated. Unlike other GF features, trees will never have a space added when they are concatenated. A single tree without an identifier will be stored as:: metadata = { 'NH': 'tree in NHX format' } A single tree with an identifier will be stored as:: metadata = { 'NH': { 'tree-id': 'tree in NHX format' } } Multiple trees (which must have identifiers) will be stored as:: metadata = { 'NH': { 'tree-id-1': 'tree in NHX format', 'tree-id-2': 'tree in NHX format' } } .. note:: References labelled with ``RN``/``RM``/``RT``/``RA``/``RL``/``RC`` are handled differently than other GF features. When reading a Stockholm file with these features, the reader populates a list of dictionaries, where each dictionary represents a single reference. The list contains references in the order they appear in the file, regardless of the value provided for ``RN``. If a reference does not include all possible reference tags (e.g. ``RC`` is missing), the dictionary will only contain the reference tags present for that reference. When writing, the writer adds a reference number (``RN``) line before writing each reference, for example: .. code-block:: none #=GF RN [1] #=GF RA Kestrel Gorlick ... #=GF RN [2] ... References will be stored as:: metadata = { 'RN': [{ 'RM': 'reference medline', 'RT': 'reference title', 'RA': 'reference author', 'RL': 'reference location', 'RC': 'reference comment' }, { 'RM': 'reference medline', ... }] } GS metadata +++++++++++ Data relating to a specific sequence in the multiple sequence alignment. Starts with ``#=GS`` followed by the sequence name followed by a feature name and data relating to the feature. Typically comes after GF metadata in a Stockholm file. For example (taken from [2]_): .. code-block:: none #=GS O83071/259-312 AC O83071 Where ``O83071/259-312`` is the sequence name, ``AC`` is the feature name, and ``083071`` is the feature data. GS metadata is stored in the sequence-specific ``metadata`` dictionary. .. note:: When reading, duplicate GS feature names will have their values concatenated in the order they appear in the file. Concatenation will also add a space between lines if one isn't already there in order to avoid joining words together. When writing, each GS feature will be placed on its own line, regardless of length. GR metadata +++++++++++ Data relating to the columns of a specific sequence in a multiple sequence alignment. Starts with ``#=GR`` followed by the sequence name followed by a feature name and data relating to the feature, one character per column. Typically comes after the sequence line it relates to. For example (taken from [2]_): .. code-block:: none #=GR O31698/18-71 SS CCCHHHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEHHH Where ``O31698/18-71`` is the sequence name, ``SS`` is the feature name, and ``CCCHHHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEHHH`` is the feature data. GR metadata is stored in sequence-specific ``positional_metadata``. .. note:: Duplicate GR feature names attributed to a single sequence are disallowed. GC metadata +++++++++++ Data relating to the columns of the multiple sequence alignment as a whole. Starts with ``#=GC`` followed by a feature name and data relating to the feature, one character per column. Typically comes at the end of the multiple sequence alignment. For example (taken from [2]_): .. code-block:: none #=GC SS_cons CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEEEH Where ``SS_cons`` is the feature name and ``CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEEEH`` is the feature data. GC metadata is stored in ``TabularMSA`` ``positional_metadata``. .. note:: Duplicate GC feature names are disallowed. Footer ^^^^^^ The final line of a Stockholm file must be the following footer:: // .. note:: scikit-bio currently supports reading a Stockholm file containing a single MSA. If the file contains more than one MSA, only the first MSA will be read into a ``TabularMSA``. Format Parameters ----------------- The only supported format parameter is ``constructor``, which specifies the type of in-memory sequence object to read each aligned sequence into. This must be a subclass of ``GrammaredSequence`` (e.g., ``DNA``, ``RNA``, ``Protein``) and is a required format parameter. For example, if you know that the Stockholm file you're reading contains DNA sequences, you would pass ``constructor=DNA`` to the reader call. Examples -------- Suppose we have a Stockholm file containing an MSA of protein sequences (modified from [2]_): >>> import skbio.io >>> from io import StringIO >>> from skbio import Protein, TabularMSA >>> fs = '\\n'.join([ ... '# STOCKHOLM 1.0', ... '#=GF CC CBS domains are small intracellular modules mostly' ... ' found', ... '#=GF CC in 2 or four copies within a protein.', ... '#=GS O83071/192-246 AC O83071', ... '#=GS O31698/88-139 OS Bacillus subtilis', ... 'O83071/192-246 MTCRAQLIAVPRASSLAE..AIACAQKM....RVSRV', ... '#=GR O83071/192-246 SA 999887756453524252..55152525....36463', ... 'O83071/259-312 MQHVSAPVFVFECTRLAY..VQHKLRAH....SRAVA', ... 'O31698/18-71 MIEADKVAHVQVGNNLEH..ALLVLTKT....GYTAI', ... 'O31698/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFV', ... 'O31699/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFV', ... '#=GR O31699/88-139 AS ________________*____________________', ... '#=GR O31699/88-139 IN ____________1______________2_________', ... '#=GC SS_cons CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEE', ... '//' ... ]) >>> fh = StringIO(fs) >>> msa = TabularMSA.read(fh, constructor=Protein) >>> msa # doctest: +NORMALIZE_WHITESPACE TabularMSA[Protein] ---------------------------------------------------------------------- Metadata: 'CC': 'CBS domains are small intracellular modules mostly found in 2 or four copies within a protein.' Positional metadata: 'SS_cons': Stats: sequence count: 5 position count: 37 ---------------------------------------------------------------------- MTCRAQLIAVPRASSLAE..AIACAQKM....RVSRV MQHVSAPVFVFECTRLAY..VQHKLRAH....SRAVA MIEADKVAHVQVGNNLEH..ALLVLTKT....GYTAI EVMLTDIPRLHINDPIMK..GFGMVINN......GFV EVMLTDIPRLHINDPIMK..GFGMVINN......GFV The sequence names are stored in the ``index``: >>> msa.index Index(['O83071/192-246', 'O83071/259-312', 'O31698/18-71', 'O31698/88-139', 'O31699/88-139'], dtype='object') The ``TabularMSA`` has GF metadata stored in its ``metadata`` dictionary: >>> msa.metadata OrderedDict([('CC', 'CBS domains are small intracellular modules mostly found \ in 2 or four copies within a protein.')]) GC metadata is stored in the ``TabularMSA`` ``positional_metadata``: >>> msa.positional_metadata # doctest: +ELLIPSIS SS_cons 0 C 1 C 2 C 3 C 4 C 5 H 6 H 7 H 8 H 9 H ... GS metadata is stored in the sequence-specific ``metadata`` dictionary: >>> msa[0].metadata OrderedDict([('AC', 'O83071')]) GR metadata is stored in sequence-specific ``positional_metadata``: >>> msa[4].positional_metadata # doctest: +ELLIPSIS AS IN 0 _ _ 1 _ _ 2 _ _ 3 _ _ 4 _ _ 5 _ _ 6 _ _ 7 _ _ 8 _ _ 9 _ _ ... Let's write this ``TabularMSA`` in Stockholm format: >>> fh = StringIO() >>> _ = msa.write(fh, format='stockholm') >>> print(fh.getvalue()) # STOCKHOLM 1.0 #=GF CC CBS domains are small intracellular modules mostly found in 2 or four \ copies within a protein. #=GS O83071/192-246 AC O83071 #=GS O31698/88-139 OS Bacillus subtilis O83071/192-246 MTCRAQLIAVPRASSLAE..AIACAQKM....RVSRV #=GR O83071/192-246 SA 999887756453524252..55152525....36463 O83071/259-312 MQHVSAPVFVFECTRLAY..VQHKLRAH....SRAVA O31698/18-71 MIEADKVAHVQVGNNLEH..ALLVLTKT....GYTAI O31698/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFV O31699/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFV #=GR O31699/88-139 AS ________________*____________________ #=GR O31699/88-139 IN ____________1______________2_________ #=GC SS_cons CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEE // >>> fh.close() References ========== .. [1] https://en.wikipedia.org/wiki/Stockholm_format .. [2] http://sonnhammer.sbc.su.se/Stockholm.html """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from collections import OrderedDict from skbio.alignment import TabularMSA from skbio.sequence._grammared_sequence import GrammaredSequence from skbio.io import create_format, StockholmFormatError stockholm = create_format('stockholm') _REFERENCE_TAGS = frozenset({'RM', 'RT', 'RA', 'RL', 'RC'}) @stockholm.sniffer() def _stockholm_sniffer(fh): # Smells a Stockholm file if the following conditions are met: # - File isn't empty # - File contains correct header try: line = next(fh) except StopIteration: return False, {} if _is_header(line): return True, {} return False, {} @stockholm.reader(TabularMSA) def _stockholm_to_tabular_msa(fh, constructor=None): # Checks that user has passed required constructor parameter if constructor is None: raise ValueError("Must provide `constructor` parameter indicating the " "type of sequences in the alignment. `constructor` " "must be a subclass of `GrammaredSequence` " "(e.g., `DNA`, `RNA`, `Protein`).") # Checks that contructor parameter is supported elif not issubclass(constructor, GrammaredSequence): raise TypeError("`constructor` must be a subclass of " "`GrammaredSequence`.") # Checks that the file isn't empty try: line = next(fh) except StopIteration: raise StockholmFormatError("File is empty.") # Checks that the file follows basic format (includes the required header) if not _is_header(line): raise StockholmFormatError("File missing required Stockholm header " "line.") msa_data = _MSAData() for line in fh: if line.isspace(): continue line = line.rstrip('\n') if _is_sequence_line(line): seq_name, seq_data = _parse_sequence_line(line) msa_data.add_sequence(seq_name, seq_data) elif line.startswith("#=GF"): feature_name, feature_data = _parse_gf_line(line) msa_data.add_gf_metadata(feature_name, feature_data) elif line.startswith("#=GS"): seq_name, feature_name, feature_data = _parse_gs_line(line) msa_data.add_gs_metadata(seq_name, feature_name, feature_data) elif line.startswith("#=GR"): seq_name, feature_name, feature_data = _parse_gr_line(line) msa_data.add_gr_metadata(seq_name, feature_name, feature_data) elif line.startswith('#=GC'): feature_name, feature_data = _parse_gc_line(line) msa_data.add_gc_metadata(feature_name, feature_data) elif _is_footer(line): break else: raise StockholmFormatError("Unrecognized line: %r" % line) if not _is_footer(line): raise StockholmFormatError('Final line does not conform to Stockholm ' 'format. Must contain only "//".') return msa_data.build_tabular_msa(constructor) # For storing intermediate data used to construct a Sequence object. class _MSAData: def __init__(self): self._seqs = {} self._seq_order = [] self._metadata = OrderedDict() self._positional_metadata = OrderedDict() def add_sequence(self, seq_name, seq_data): if seq_name not in self._seqs: self._seqs[seq_name] = _SeqData(seq_name) self._seqs[seq_name].seq = seq_data self._seq_order.append(seq_name) def add_gf_metadata(self, feature_name, feature_data): # Handles first instance of labelled tree if feature_name == 'TN' and 'NH' not in self._metadata: self._metadata['NH'] = OrderedDict() self._metadata['NH'][feature_data] = '' # Handles second instance of labelled tree elif feature_name == 'TN' and 'NH' in self._metadata: if feature_data in self._metadata['NH']: raise StockholmFormatError("Tree name %r used multiple times " "in file." % feature_data) self._metadata['NH'][feature_data] = '' # Handles extra line(s) of an already created tree elif feature_name == 'NH' and feature_name in self._metadata: trees = self._metadata[feature_name] if isinstance(trees, OrderedDict): tree_id = next(reversed(trees)) self._metadata[feature_name][tree_id] = (trees[tree_id] + feature_data) else: self._metadata[feature_name] = (self._metadata[feature_name] + feature_data) elif feature_name == 'RN': if feature_name not in self._metadata: self._metadata[feature_name] = [OrderedDict()] else: self._metadata[feature_name].append(OrderedDict()) elif feature_name in _REFERENCE_TAGS: if 'RN' not in self._metadata: raise StockholmFormatError("Expected 'RN' tag to precede " "'%s' tag." % feature_name) reference_dict = self._metadata['RN'][-1] if feature_name not in reference_dict: reference_dict[feature_name] = feature_data else: padding = _get_padding(reference_dict[feature_name]) reference_dict[feature_name] += padding + feature_data elif feature_name in self._metadata: padding = _get_padding(self._metadata[feature_name][-1]) self._metadata[feature_name] = (self._metadata[feature_name] + padding + feature_data) else: self._metadata[feature_name] = feature_data def add_gc_metadata(self, feature_name, feature_data): if feature_name in self._positional_metadata: _raise_duplicate_error("Found duplicate GC label %r." % feature_name) self._positional_metadata[feature_name] = feature_data def add_gs_metadata(self, seq_name, feature_name, feature_data): if seq_name not in self._seqs: self._seqs[seq_name] = _SeqData(seq_name) self._seqs[seq_name].add_metadata_feature(feature_name, feature_data) def add_gr_metadata(self, seq_name, feature_name, feature_data): if seq_name not in self._seqs: self._seqs[seq_name] = _SeqData(seq_name) self._seqs[seq_name].add_positional_metadata_feature(feature_name, feature_data) def build_tabular_msa(self, constructor): if len(self._seqs) != len(self._seq_order): invalid_seq_names = set(self._seqs) - set(self._seq_order) raise StockholmFormatError('Found GS or GR metadata for ' 'nonexistent sequence(s): %r' % invalid_seq_names) seqs = [] for seq_name in self._seq_order: seqs.append(self._seqs[seq_name].build_sequence(constructor)) positional_metadata = self._positional_metadata if not positional_metadata: positional_metadata = None metadata = self._metadata if not metadata: metadata = None # Constructs TabularMSA return TabularMSA(seqs, metadata=metadata, positional_metadata=positional_metadata, index=self._seq_order) class _SeqData: def __init__(self, name): self.name = name self._seq = None self.metadata = None self.positional_metadata = None @property def seq(self): return self._seq @seq.setter def seq(self, seq): if self._seq is None: self._seq = seq else: _raise_duplicate_error("Found duplicate sequence name: %r" % self.name) def add_metadata_feature(self, feature_name, feature_data): if self.metadata is None: self.metadata = OrderedDict() if feature_name in self.metadata: padding = _get_padding(self.metadata[feature_name][-1]) self.metadata[feature_name] += padding + feature_data else: self.metadata[feature_name] = feature_data def add_positional_metadata_feature(self, feature_name, feature_data): if self.positional_metadata is None: self.positional_metadata = OrderedDict() if feature_name in self.positional_metadata: _raise_duplicate_error("Found duplicate GR label %r associated " "with sequence name %r" % (feature_name, self.name)) else: self.positional_metadata[feature_name] = feature_data def build_sequence(self, constructor): return constructor(self.seq, metadata=self.metadata, positional_metadata=(self.positional_metadata)) def _parse_gf_line(line): line = line.split(None, 2) _check_for_malformed_line(line, 3) return line[1:] def _parse_gs_line(line): line = line.split(None, 3) _check_for_malformed_line(line, 4) return line[1:] def _parse_gr_line(line): line = line.split(None, 3) _check_for_malformed_line(line, 4) seq_name = line[1] feature_name = line[2] feature_data = list(line[3]) return seq_name, feature_name, feature_data def _parse_gc_line(line): line = line.split(None, 2) _check_for_malformed_line(line, 3) feature_name = line[1] feature_data = list(line[2]) return feature_name, feature_data def _parse_sequence_line(line): line = line.split(None, 1) _check_for_malformed_line(line, 2) return line def _is_header(line): return line == '# STOCKHOLM 1.0\n' def _is_footer(line): return line.rstrip() == '//' def _is_sequence_line(line): return not (line.startswith("#") or _is_footer(line)) def _raise_duplicate_error(message): raise StockholmFormatError(message+' Note: If the file being used is in ' 'Stockholm interleaved format, this ' 'is not supported by the reader.') def _check_for_malformed_line(line, expected_len): if len(line) != expected_len: raise StockholmFormatError('Line contains %d item(s). It must ' 'contain exactly %d item(s).' % (len(line), expected_len)) @stockholm.writer(TabularMSA) def _tabular_msa_to_stockholm(obj, fh): if not obj.index.is_unique: raise StockholmFormatError("The TabularMSA's index labels must be" " unique.") # Writes header fh.write("# STOCKHOLM 1.0\n") # Writes GF data to file if obj.has_metadata(): for gf_feature, gf_feature_data in obj.metadata.items(): if gf_feature == 'NH' and isinstance(gf_feature_data, dict): for tree_id, tree in gf_feature_data.items(): fh.write("#=GF TN %s\n" % tree_id) fh.write("#=GF NH %s\n" % tree) elif gf_feature == 'RN': if not isinstance(gf_feature_data, list): raise StockholmFormatError( "Expected 'RN' to contain a list of reference " "dictionaries, got %r." % gf_feature_data) for ref_num, dictionary in enumerate(gf_feature_data, start=1): if not isinstance(dictionary, dict): raise StockholmFormatError( "Expected reference information to be stored as a " "dictionary, found reference %d stored as %r." % (ref_num, type(dictionary).__name__)) fh.write("#=GF RN [%d]\n" % ref_num) for feature in dictionary: if feature not in _REFERENCE_TAGS: formatted_reference_tags = ', '.join( [tag for tag in _REFERENCE_TAGS]) raise StockholmFormatError( "Invalid reference tag %r found in reference " "dictionary %d. Valid reference tags are: %s." % (feature, ref_num, formatted_reference_tags)) fh.write("#=GF %s %s\n" % (feature, dictionary[feature])) else: fh.write("#=GF %s %s\n" % (gf_feature, gf_feature_data)) unpadded_data = [] # Writes GS data to file, retrieves GR data, and retrieves sequence data for seq, seq_name in zip(obj, obj.index): seq_name = str(seq_name) if seq.has_metadata(): for gs_feature, gs_feature_data in seq.metadata.items(): fh.write("#=GS %s %s %s\n" % (seq_name, gs_feature, gs_feature_data)) unpadded_data.append((seq_name, str(seq))) if seq.has_positional_metadata(): df = _format_positional_metadata(seq.positional_metadata, 'Sequence-specific positional ' 'metadata (GR)') for gr_feature in df.columns: gr_feature_data = ''.join(df[gr_feature]) gr_string = "#=GR %s %s" % (seq_name, gr_feature) unpadded_data.append((gr_string, gr_feature_data)) # Retrieves GC data if obj.has_positional_metadata(): df = _format_positional_metadata(obj.positional_metadata, 'Multiple sequence alignment ' 'positional metadata (GC)') for gc_feature in df.columns: gc_feature_data = ''.join(df[gc_feature]) gc_string = "#=GC %s" % gc_feature unpadded_data.append((gc_string, gc_feature_data)) # Writes GR, GC, and raw data to file with padding _write_padded_data(unpadded_data, fh) # Writes footer fh.write("//\n") def _write_padded_data(data, fh): max_data_len = 0 for label, _ in data: if len(label) > max_data_len: max_data_len = len(label) fmt = '{0:%d} {1}\n' % max_data_len for label, value in data: fh.write(fmt.format(label, value)) def _format_positional_metadata(df, data_type): # Asserts positional metadata feature names are unique if not df.columns.is_unique: num_repeated_columns = len(df.columns) - len(set(df.columns)) raise StockholmFormatError('%s feature names must be unique. ' 'Found %d duplicate names.' % (data_type, num_repeated_columns)) str_df = df.astype(str) # Asserts positional metadata dataframe items are one character long for column in str_df.columns: if (str_df[column].str.len() != 1).any(): raise StockholmFormatError("%s must contain a single character for" " each position's value. Found value(s)" " in column %s of incorrect length." % (data_type, column)) return str_df def _get_padding(item): return '' if item[-1].isspace() else ' ' scikit-bio-0.5.9/skbio/io/format/taxdump.py000066400000000000000000000315771446255456000206540ustar00rootroot00000000000000""" Taxdump format (:mod:`skbio.io.format.taxdump`) =============================================== .. currentmodule:: skbio.io.format.taxdump The NCBI Taxonomy database dump (``taxdump``) format stores information of organism names, classifications and other properties. It is a tabular format with a delimiter: ```` between columns, and a line end ```` after all columns. The file name usually ends with .dmp. Format Support -------------- **Has Sniffer: No** +------+------+---------------------------------------------------------------+ |Reader|Writer| Object Class | +======+======+===============================================================+ |Yes |No |:mod:`pandas.DataFrame` | +------+------+---------------------------------------------------------------+ Format Specification -------------------- **State: Experimental as of 0.5.8.** The NCBI taxonomy database [1]_ [2]_ hosts organism names and classifications. It has a web portal [3]_ and an FTP download server [4]_. It is also accessible using E-utilities [5]_. The database is being updated daily, and an archive is generated every month. The data release has the file name ``taxdump``. It consists of multiple .dmp files. These files serve different purposes, but they follow a common format pattern: - It is a tabular format. - Column delimiter is ````. - Line end is ````. - The first column is a numeric identifier, which usually represent taxa (i.e., "TaxID"), but can also be genetic codes, citations or other entries. The two most important files of the data release are ``nodes.dmp`` and ``names.dmp``. They store the hierarchical structure of the classification system (i.e., taxonomy) and the names of organisms, respectively. They can be used to construct the taxonomy tree of organisms. The definition of columns of each .dmp file type are taken from [6]_ and [7]_. ``nodes.dmp`` ^^^^^^^^^^^^^ +----------------+-------------------------------------+ |Name |Description | +================+=====================================+ |tax_id |node id in GenBank taxonomy database | +----------------+-------------------------------------+ |parent tax_id |parent node id in GenBank taxonomy | | |database | +----------------+-------------------------------------+ |rank |rank of this node (superkingdom, | | |kingdom, ...) | +----------------+-------------------------------------+ |embl code |locus-name prefix; not unique | +----------------+-------------------------------------+ |division id |see division.dmp file | +----------------+-------------------------------------+ |inherited div |1 if node inherits division from | |flag (1 or 0) |parent | +----------------+-------------------------------------+ |genetic code id |see gencode.dmp file | +----------------+-------------------------------------+ |inherited GC |1 if node inherits genetic code from | |flag (1 or 0) |parent | +----------------+-------------------------------------+ |mitochondrial |see gencode.dmp file | |genetic code id | | +----------------+-------------------------------------+ |inherited MGC |1 if node inherits mitochondrial | |flag (1 or 0) |gencode from parent | +----------------+-------------------------------------+ |GenBank hidden |1 if name is suppressed in GenBank | |flag (1 or 0) |entry lineage | +----------------+-------------------------------------+ |hidden subtree |1 if this subtree has no sequence | |root flag |data yet | |(1 or 0) | | +----------------+-------------------------------------+ |comments |free-text comments and citations | +----------------+-------------------------------------+ Since 2018, NCBI releases "new taxonomy files" [8]_ (``new_taxdump``). The new ``nodes.dmp`` format is compatible with the classical format, plus five extra columns after all aforementioned columns. +----------------+-------------------------------------+ |Name |Description | +================+=====================================+ |plastid genetic |see gencode.dmp file | |code id | | +----------------+-------------------------------------+ |inherited PGC |1 if node inherits plastid gencode | |flag (1 or 0) |from parent | +----------------+-------------------------------------+ |specified\\_ |1 if species in the node's lineage | |species |has formal name | +----------------+-------------------------------------+ |hydrogenosome |see gencode.dmp file | |genetic code id | | +----------------+-------------------------------------+ |inherited HGC |1 if node inherits hydrogenosome | |flag (1 or 0) |gencode from parent | +----------------+-------------------------------------+ ``names.dmp`` ^^^^^^^^^^^^^ +----------------+-------------------------------------+ |Name |Description | +================+=====================================+ |tax_id |the id of node associated with this | | |name | +----------------+-------------------------------------+ |name_txt |name itself | +----------------+-------------------------------------+ |unique name |the unique variant of this name if | | |name not unique | +----------------+-------------------------------------+ |name class |(synonym, common name, ...) | +----------------+-------------------------------------+ ``division.dmp`` ^^^^^^^^^^^^^^^^ +----------------+-------------------------------------+ |Name |Description | +================+=====================================+ |division id |taxonomy database division id | +----------------+-------------------------------------+ |division cde |GenBank division code (three | | |characters) | +----------------+-------------------------------------+ |division name |e.g. BCT, PLN, VRT, MAM, PRI... | +----------------+-------------------------------------+ |comments | | +----------------+-------------------------------------+ ``gencode.dmp`` ^^^^^^^^^^^^^^^ +----------------+-------------------------------------+ |Name |Description | +================+=====================================+ |genetic code id |GenBank genetic code id | +----------------+-------------------------------------+ |abbreviation |genetic code name abbreviation | +----------------+-------------------------------------+ |name |genetic code name | +----------------+-------------------------------------+ |cde |translation table for this genetic | | |code | +----------------+-------------------------------------+ |starts |start codons for this genetic code | +----------------+-------------------------------------+ Other types of .dmp files are currently not supported by scikit-bio. However, the user may customize column definitions in using this utility. See below for details. Format Parameters ----------------- The following format parameters are available in ``taxdump`` format: - ``scheme``: The column definition scheme name of the input .dmp file. Available options are listed below. Alternatively, one can provide a custom scheme as defined in a name-to-data type dictionary. 1. ``nodes``: The classical ``nodes.dmp`` scheme. It is also compatible with new ``nodes.dmp`` format, in which case only the columns defined by the classical format will be read. 2. ``nodes_new``: The new ``nodes.dmp`` scheme. 3. ``nodes_slim``: Only the first three columns: tax_id, parent_tax_id and rank, which are the minimum required information for constructing the taxonomy tree. It can be applied to both classical and new ``nodes.dmp`` files. It can also handle custom files which only contains these three columns. 4. ``names``: The ``names.dmp`` scheme. 5. ``division``: The ``division.dmp`` scheme. 6. ``gencode``: The ``gencode.dmp`` scheme. .. note:: scikit-bio will read columns from leftmost till the number of columns defined in the scheme. Extra columns will be cropped. Examples -------- >>> from io import StringIO >>> import skbio.io >>> import pandas as pd >>> fs = '\\n'.join([ ... '1\\t|\\t1\\t|\\tno rank\\t|', ... '2\\t|\\t131567\\t|\\tsuperkingdom\\t|', ... '6\\t|\\t335928\\t|\\tgenus\\t|' ... ]) >>> fh = StringIO(fs) Read the file into a ``pd.DataFrame`` and specify that the "nodes_slim" scheme should be used: >>> df = skbio.io.read(fh, format="taxdump", into=pd.DataFrame, ... scheme="nodes_slim") >>> df # doctest: +NORMALIZE_WHITESPACE parent_tax_id rank tax_id 1 1 no rank 2 131567 superkingdom 6 335928 genus References ---------- .. [1] Federhen, S. (2012). The NCBI taxonomy database. Nucleic acids research, 40(D1), D136-D143. .. [2] Schoch, C. L., Ciufo, S., Domrachev, M., Hotton, C. L., Kannan, S., Khovanskaya, R., ... & Karsch-Mizrachi, I. (2020). NCBI Taxonomy: a comprehensive update on curation, resources and tools. Database, 2020. .. [3] https://www.ncbi.nlm.nih.gov/taxonomy .. [4] https://ftp.ncbi.nlm.nih.gov/pub/taxonomy/ .. [5] Kans, J. (2022). Entrez direct: E-utilities on the UNIX command line. In Entrez Programming Utilities Help [Internet]. National Center for Biotechnology Information (US). .. [6] https://ftp.ncbi.nlm.nih.gov/pub/taxonomy/taxdump_readme.txt .. [7] https://ftp.ncbi.nlm.nih.gov/pub/taxonomy/new_taxdump/taxdump_readme.txt .. [8] https://ncbiinsights.ncbi.nlm.nih.gov/2018/02/22/new-taxonomy-files- available-with-lineage-type-and-host-information/ """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import pandas as pd from skbio.io import create_format taxdump = create_format('taxdump') _taxdump_column_schemes = { 'nodes_slim': { 'tax_id': int, 'parent_tax_id': int, 'rank': str }, 'nodes': { 'tax_id': int, 'parent_tax_id': int, 'rank': str, 'embl_code': str, 'division_id': int, 'inherited_div_flag': bool, 'genetic_code_id': int, 'inherited_GC_flag': bool, 'mitochondrial_genetic_code_id': int, 'inherited_MGC_flag': bool, 'GenBank_hidden_flag': bool, 'hidden_subtree_root_flag': bool, 'comments': str }, 'names': { 'tax_id': int, 'name_txt': str, 'unique_name': str, 'name_class': str }, 'division': { 'division_id': int, 'division_cde': str, 'division_name': str, 'comments': str }, 'gencode': { 'genetic_code_id': int, 'abbreviation': str, 'name': str, 'cde': str, 'starts': str } } _taxdump_column_schemes['nodes_new'] = dict( _taxdump_column_schemes['nodes'], **{ 'plastid_genetic_code_id': bool, 'inherited_PGC_flag': bool, 'specified_species': bool, 'hydrogenosome_genetic_code_id': int, 'inherited_HGC_flag': bool }) @taxdump.reader(pd.DataFrame, monkey_patch=False) def _taxdump_to_data_frame(fh, scheme): '''Read a taxdump file into a data frame. Parameters ---------- fh : file handle Input taxdump file scheme : str Name of column scheme Returns ------- pd.DataFrame Parsed table ''' if isinstance(scheme, str): if scheme not in _taxdump_column_schemes: raise ValueError(f'Invalid taxdump column scheme: "{scheme}".') scheme = _taxdump_column_schemes[scheme] names = list(scheme.keys()) try: return pd.read_csv( fh, sep='\t\\|(?:\t|$)', engine='python', index_col=0, names=names, dtype=scheme, usecols=range(len(names))) except ValueError: raise ValueError('Invalid taxdump file format.') scikit-bio-0.5.9/skbio/io/format/tests/000077500000000000000000000000001446255456000177455ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/format/tests/__init__.py000066400000000000000000000005411446255456000220560ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/io/format/tests/data/000077500000000000000000000000001446255456000206565ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_custom_minimal000066400000000000000000000000111446255456000250640ustar00rootroot00000000000000subject2 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_custom_mixed_nans000066400000000000000000000000651446255456000255740ustar00rootroot00000000000000N/A PAAWWWWW 8 1 100.00 N/A 0 query1 N/A 8 1 N/A 8 0 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_custom_multi_line000066400000000000000000000001611446255456000256050ustar00rootroot00000000000000subject2 32 0 100 N/A subject2 query1 subject2 18 0 100 N/A subject2 query1 subject1 19 0 70 N/A subject1 query2 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_custom_single_line000066400000000000000000000000371446255456000257360ustar00rootroot00000000000000query1 PAAWWWWW 8 1 100.00 8 0 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_default_multi_line000066400000000000000000000002171446255456000257210ustar00rootroot00000000000000query1 subject2 100.00 8 0 0 1 8 3 10 9e-05 16.9 query1 subject2 75.00 8 2 0 1 8 2 9 0.060 11.5 query2 subject1 71.43 7 2 0 1 7 1 7 0.044 11.9 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_default_single_line000066400000000000000000000000571446255456000260520ustar00rootroot00000000000000query1 subject2 75.00 8 2 0 1 8 2 9 0.060 11.5 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_invalid_column_types000066400000000000000000000002151446255456000263010ustar00rootroot000000000000001.2523 subject2 abcd 8 0 0 1 8 3 10 9e-05 16.9 query1 subject2 75.00 8 2 0 r 8 2 9 0.060 11.5 query2 subject1 71.43 7 2 0 1 7 1 7 G24TL 11.9 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_invalid_number_of_columns000066400000000000000000000000441446255456000272740ustar00rootroot00000000000000query1 subject2 75.00 8 2 0 1 8 2 9 scikit-bio-0.5.9/skbio/io/format/tests/data/blast6_invalid_type_in_column000066400000000000000000000001371446255456000266070ustar00rootroot00000000000000query1 subject2 string 8 2 0 1 8 2 9 0.060 11.5 query1 subject2 75.00 8 2 0 1 8 2 9 0.060 11.5 scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_custom_minimal000066400000000000000000000001351446255456000250740ustar00rootroot00000000000000# BLAST 2.2.31+ # Query: query1 # Subject: subject1 # Fields: query id # 1 hits found query1 scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_custom_mixed_nans000066400000000000000000000006141446255456000255750ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: query gi, subject gi, query length, subject length, query frame, sbjct frame, query id, subject id # 1 hits found 0 N/A 8 13 1 1 N/A subject2 N/A 0 8 N/A 1 1 query1 N/A # BLASTP 2.2.31+ # Query: query2 # Subject: subject4 # 0 hits found # BLAST processed 2 queries scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_custom_multi_line000066400000000000000000000006321446255456000256110ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: q. start, q. end, s. start, s. end, identical, mismatches, sbjct frame, query acc.ver, subject acc.ver # 3 hits found 1 8 3 10 8 0 1 query1 subject2 2 5 2 15 8 0 2 query1 subject2 1 6 2 12 8 0 1 query1 subject2 # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject4 # 0 hits found scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_custom_single_line000066400000000000000000000005711446255456000257420ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: query id, % positives, % identity, alignment length, subject gi, bit score, q. end, query seq # 1 hits found query1 100.00 100.00 8 0 16.9 8 PAAWWWWW # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLAST processed 2 queries scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_default_multi_line000066400000000000000000000006501446255456000257230ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score # 3 hits found query1 subject2 70.00 5 0 0 7 60 3 100 9e-05 10.5 query1 subject2 30.00 8 0 0 6 15 1 100 0.053 12.0 query1 subject2 90.00 2 0 0 9 35 2 100 0.002 8.3 scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_default_single_line000066400000000000000000000005041446255456000260500ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score # 1 hits found query1 subject2 100.00 8 0 0 1 8 3 10 9e-05 16.9 scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_differing_fields000066400000000000000000000006371446255456000270540ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, subject id, q. start # 1 hits found query1 subject1 4 # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, subject id, score # 1 hits found query2 subject2 4 # BLAST processed 2 queries scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_for_sniffer000066400000000000000000000000711446255456000260630ustar00rootroot00000000000000# BLASTP 2.2.31+ asdf # Subject: subject1 # 0 hits found scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_for_sniffer_2000066400000000000000000000000651446255456000263070ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 asdf # 0 hits found scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_gibberish000066400000000000000000000002201446255456000255130ustar00rootroot00000000000000aphanbrnaweoowehapivaborebaweo;aweifh[fapofh29r-2u-23 adjapignqp9rghp4hq2hrq93phq9hqwhpehoweawe aidgpuhp0eh9q2yrq02r9q9euq9rhg93fhqefjwphwpahw] scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_no_data000066400000000000000000000006301446255456000251670ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject2 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject2 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject3 # 0 hits found scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_too_many_columns000066400000000000000000000006321446255456000271510ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, subject id # 1 hits found query1 subject1 subject2 query2 # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, subject id # 1 hits found query2 subject2 # BLAST processed 2 queries scikit-bio-0.5.9/skbio/io/format/tests/data/blast7_invalid_unrecognized_field000066400000000000000000000002631446255456000274230ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, sallid # 1 hits found query1 subject1 scikit-bio-0.5.9/skbio/io/format/tests/data/embl_constructed000066400000000000000000000021211446255456000241310ustar00rootroot00000000000000ID LT357133; SV 1; linear; genomic DNA; CON; INV; 140 BP. XX AC LT357133; XX PR Project:PRJEB12116; XX DT 18-SEP-2016 (Rel. 130, Created) DT 18-SEP-2016 (Rel. 130, Last updated, Version 1) XX DE Spodoptera frugiperda genome assembly, scaffold: C262451 XX KW . XX OS Spodoptera frugiperda (fall armyworm) OC Eukaryota; Metazoa; Ecdysozoa; Arthropoda; Hexapoda; Insecta; Pterygota; OC Neoptera; Endopterygota; Lepidoptera; Glossata; Ditrysia; Noctuoidea; OC Noctuidae; Amphipyrinae; Spodoptera. XX RN [1] RA Landry J.; RT ; RL Submitted (16-MAR-2016) to the INSDC. RL EMBL, Genemics Core Facility, Meyerhofstrasse 1,, 69117 Heidelberg, Germany XX DR MD5; 90c05497c7cde972dc52b8d06097f88c. DR ENA; FJUZ01000000; SET. DR ENA; FJUZ00000000; SET. DR BioSample; SAMEA3707213. XX FH Key Location/Qualifiers FH FT source 1..140 FT /organism="Spodoptera frugiperda" FT /mol_type="genomic DNA" FT /cell_line="SF21" FT /db_xref="taxon:7108" XX CO join(FJUZ01138823.1:1..140) // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_feature_level_record000066400000000000000000000075231446255456000257670ustar00rootroot00000000000000ID LK021130.1:74067..75610:rRNA; SV 1; linear; genomic DNA; STD; PRO; 1544 BP. XX PA LK021130.1 XX PR Project:PRJEB5701; XX DT 02-JUN-2014 (Rel. 121, Created) DT 04-FEB-2016 (Rel. 127, Last updated, Version 5) XX DE Vibrio anguillarum 16S rRNA XX KW . XX OS Vibrio anguillarum OC Bacteria; Proteobacteria; Gammaproteobacteria; Vibrionales; Vibrionaceae; OC Vibrio. XX RN [1] RA Holm K.; RT ; RL Submitted (26-MAR-2014) to the INSDC. RL Norstruct, Dept of Chemistry, University of Tromso, Science Park 3, NO-9037 RL Tromso, NORWAY. XX RN [2] RX DOI; 10.1186/s40793-015-0060-7. RX PUBMED; 26380645. RA Holm K.O., Nilsson K., Hjerde E., Willassen N.P., Milton D.L.; RT "Complete genome sequence of Vibrio anguillarum strain NB10, a virulent RT isolate from the Gulf of Bothnia"; RL Stand Genomic Sci. 10:60-60(2015). XX DR SILVA-LSU; LK021130. DR SILVA-SSU; LK021130. DR MD5; afd116bf2c1a13acbf40d63d82f0218c. DR BioSample; SAMEA3865288. XX FH Key Location/Qualifiers FH FT source 1..1544 FT /organism="Vibrio anguillarum" FT /chromosome="1" FT /host="Rainbow trout" FT /strain="NB10" FT /mol_type="genomic DNA" FT /country="Sweden:Baltic Sea, Norrbyn Umeaa" FT /isolation_source="clinical isolate, Rainbow trout" FT /serovar="O1" FT /db_xref="taxon:55601" FT rRNA LK021130.1:74067..75610 FT /gene="16S" FT /product="16S rRNA" FT /note="16S rRNA subunit (checked and believed to be FT right,based on 454- and PacBio-sequencing)" XX SQ Sequence 1544 BP; 386 A; 344 C; 493 G; 321 T; 0 other; aattgaagag tttgatcatg gctcagattg aacgctggcg gcaggcctaa cacatgcaag 60 tcgagcggca gcacagagga acttgttcct tgggtggcga gcggcggacg ggtgagtaat 120 gcctaggaaa ttgccctgat gtgggggata accattggaa acgatggcta ataccgcatg 180 atgcctacgg gccaaagagg gggaccttct ggcctctcgc gtcaggatat gcctaggtgg 240 gattagctag ttggtgaggt aatggctcac caaggcgacg atccctagct ggtctgagag 300 gatgatcagc cacactggaa ctgagacacg gtccagactc ctacgggagg cagcagtggg 360 gaatattgca caatgggcgc aagcctgatg cagccatgcc gcgtgtatga agaaggcctt 420 cgggttgtaa agtactttca gtcgtgagga aggtggtgtt gttaatagca gcatcatttg 480 acgttagcga cagaagaagc accggctaac tccgtgccag cagccgcggt aatacggagg 540 gtgcgagcgt taatcggaat tactgggcgt aaagcgcatg caggtggtgg attaagtcag 600 atgtgaaagc ccggggctca acctcggaac cgcatttgaa actggttcac tagagtactg 660 tagagggggg tagaatttca ggtgtagcgg tgaaatgcgt agagatctga aggaataccg 720 gtggcgaagg cggccccctg gacagatact gacactcaga tgcgaaagcg tggggagcaa 780 acaggattag ataccctggt agtccacgcc gtaaacgatg tctacttgga ggttgtggcc 840 ttgagccgtg gctttcggag ctaacgcgtt aagtagaccg cctggggagt acggtcgcaa 900 gattaaaact caaatgaatt gacgggggcc cgcacaagcg gtggagcatg tggtttaatt 960 cgatgcaacg cgaagaacct tacctactct tgacatccag agaagccagc ggagacgcag 1020 gtgtgccttc gggagctctg agacaggtgc tgcatggctg tcgtcagctc gtgttgtgaa 1080 atgttgggtt aagtcccgca acgagcgcaa cccttatcct tgtttgccag cgagtcatgt 1140 cgggaactcc agggagactg ccggtgataa accggaggaa ggtggggacg acgtcaagtc 1200 atcatggccc ttacgagtag ggctacacac gtgctacaat ggcgcataca gagggcagca 1260 agctagcgat agtgagcgaa tcccaaaaag tgcgtcgtag tccggattgg agtctgcaac 1320 tcgactccat gaagtcggaa tcgctagtaa tcgtagatca gaatgctacg gtgaatacgt 1380 tcccgggcct tgtacacacc gcccgtcaca ccatgggagt gggctgcaaa agaagtgggt 1440 agtttaacct ttcggggagg acgctcacca ctttgtggtt catgactggg gtgaagtcgt 1500 aacaaggtag cgctagggga acctggcgct ggatcacctc ctta 1544 //scikit-bio-0.5.9/skbio/io/format/tests/data/embl_feature_level_record_no_FT000066400000000000000000000061241446255456000270500ustar00rootroot00000000000000ID LK021130.1:74067..75610:rRNA; SV 1; linear; genomic DNA; STD; PRO; 1544 BP. XX PA LK021130.1 XX PR Project:PRJEB5701; XX DT 02-JUN-2014 (Rel. 121, Created) DT 04-FEB-2016 (Rel. 127, Last updated, Version 5) XX DE Vibrio anguillarum 16S rRNA XX KW . XX OS Vibrio anguillarum OC Bacteria; Proteobacteria; Gammaproteobacteria; Vibrionales; Vibrionaceae; OC Vibrio. XX RN [1] RA Holm K.; RT ; RL Submitted (26-MAR-2014) to the INSDC. Norstruct, Dept of Chemistry, RL University of Tromso, Science Park 3, NO-9037 Tromso, NORWAY. XX RN [2] RX DOI; 10.1186/s40793-015-0060-7. RX PUBMED; 26380645. RA Holm K.O., Nilsson K., Hjerde E., Willassen N.P., Milton D.L.; RT "Complete genome sequence of Vibrio anguillarum strain NB10, a virulent RT isolate from the Gulf of Bothnia"; RL Stand Genomic Sci. 10:60-60(2015). XX DR SILVA-LSU; LK021130. DR SILVA-SSU; LK021130. DR MD5; afd116bf2c1a13acbf40d63d82f0218c. DR BioSample; SAMEA3865288. XX SQ Sequence 1544 BP; 386 A; 344 C; 493 G; 321 T; 0 other; aattgaagag tttgatcatg gctcagattg aacgctggcg gcaggcctaa cacatgcaag 60 tcgagcggca gcacagagga acttgttcct tgggtggcga gcggcggacg ggtgagtaat 120 gcctaggaaa ttgccctgat gtgggggata accattggaa acgatggcta ataccgcatg 180 atgcctacgg gccaaagagg gggaccttct ggcctctcgc gtcaggatat gcctaggtgg 240 gattagctag ttggtgaggt aatggctcac caaggcgacg atccctagct ggtctgagag 300 gatgatcagc cacactggaa ctgagacacg gtccagactc ctacgggagg cagcagtggg 360 gaatattgca caatgggcgc aagcctgatg cagccatgcc gcgtgtatga agaaggcctt 420 cgggttgtaa agtactttca gtcgtgagga aggtggtgtt gttaatagca gcatcatttg 480 acgttagcga cagaagaagc accggctaac tccgtgccag cagccgcggt aatacggagg 540 gtgcgagcgt taatcggaat tactgggcgt aaagcgcatg caggtggtgg attaagtcag 600 atgtgaaagc ccggggctca acctcggaac cgcatttgaa actggttcac tagagtactg 660 tagagggggg tagaatttca ggtgtagcgg tgaaatgcgt agagatctga aggaataccg 720 gtggcgaagg cggccccctg gacagatact gacactcaga tgcgaaagcg tggggagcaa 780 acaggattag ataccctggt agtccacgcc gtaaacgatg tctacttgga ggttgtggcc 840 ttgagccgtg gctttcggag ctaacgcgtt aagtagaccg cctggggagt acggtcgcaa 900 gattaaaact caaatgaatt gacgggggcc cgcacaagcg gtggagcatg tggtttaatt 960 cgatgcaacg cgaagaacct tacctactct tgacatccag agaagccagc ggagacgcag 1020 gtgtgccttc gggagctctg agacaggtgc tgcatggctg tcgtcagctc gtgttgtgaa 1080 atgttgggtt aagtcccgca acgagcgcaa cccttatcct tgtttgccag cgagtcatgt 1140 cgggaactcc agggagactg ccggtgataa accggaggaa ggtggggacg acgtcaagtc 1200 atcatggccc ttacgagtag ggctacacac gtgctacaat ggcgcataca gagggcagca 1260 agctagcgat agtgagcgaa tcccaaaaag tgcgtcgtag tccggattgg agtctgcaac 1320 tcgactccat gaagtcggaa tcgctagtaa tcgtagatca gaatgctacg gtgaatacgt 1380 tcccgggcct tgtacacacc gcccgtcaca ccatgggagt gggctgcaaa agaagtgggt 1440 agtttaacct ttcggggagg acgctcacca ctttgtggtt catgactggg gtgaagtcgt 1500 aacaaggtag cgctagggga acctggcgct ggatcacctc ctta 1544 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_multi_records000066400000000000000000000151351446255456000244600ustar00rootroot00000000000000ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. XX AC M14399; XX DT 16-JUL-1988 (Rel. 16, Created) DT 02-SEP-1999 (Rel. 60, Last updated, Version 3) XX DE E.coli alkaline phosphatase signal mRNA, 5' end. XX KW alkaline phosphatase; signal peptide. XX OS Escherichia coli OC Bacteria; Proteobacteria; Gammaproteobacteria; Enterobacterales; OC Enterobacteriaceae; Escherichia. XX RN [1] RP 1-63 RX DOI; 10.1016/0378-1119(85)90319-1. RX PUBMED; 3912261. RA Gray G.L., Baldridge J.S., McKeown K.S., Heyneker H.L., Chang C.N.; RT "Periplasmic production of correctly processed human growth hormone in RT Escherichia coli: natural and bacterial signal sequences are RT interchangeable"; RL Gene 39(2-3):247-254(1985). XX DR MD5; c9b40131b8622946b5aafdf5473b3d43. XX FH Key Location/Qualifiers FH FT source 1..63 FT /db_xref="taxon:562" FT /mol_type="mRNA" FT /organism="Escherichia coli" FT CDS 1..>63 FT /db_xref="GOA:P00634" FT /db_xref="InterPro:IPR001952" FT /db_xref="InterPro:IPR017849" FT /db_xref="InterPro:IPR017850" FT /db_xref="InterPro:IPR018299" FT /db_xref="PDB:1AJA" FT /db_xref="PDB:1AJB" FT /db_xref="PDB:1AJC" FT /db_xref="PDB:1AJD" FT /db_xref="PDB:1ALH" FT /db_xref="PDB:1ALI" FT /db_xref="PDB:1ALJ" FT /db_xref="PDB:1ALK" FT /db_xref="PDB:1ANI" FT /db_xref="PDB:1ANJ" FT /db_xref="PDB:1B8J" FT /db_xref="PDB:1ED8" FT /db_xref="PDB:1ED9" FT /db_xref="PDB:1ELX" FT /db_xref="PDB:1ELY" FT /db_xref="PDB:1ELZ" FT /db_xref="PDB:1EW8" FT /db_xref="PDB:1EW9" FT /db_xref="PDB:1HJK" FT /db_xref="PDB:1HQA" FT /db_xref="PDB:1KH4" FT /db_xref="PDB:1KH5" FT /db_xref="PDB:1KH7" FT /db_xref="PDB:1KH9" FT /db_xref="PDB:1KHJ" FT /db_xref="PDB:1KHK" FT /db_xref="PDB:1KHL" FT /db_xref="PDB:1KHN" FT /db_xref="PDB:1URA" FT /db_xref="PDB:1URB" FT /db_xref="PDB:1Y6V" FT /db_xref="PDB:1Y7A" FT /db_xref="PDB:2ANH" FT /db_xref="PDB:2G9Y" FT /db_xref="PDB:2GA3" FT /db_xref="PDB:2MLX" FT /db_xref="PDB:2MLY" FT /db_xref="PDB:2MLZ" FT /db_xref="PDB:3BDF" FT /db_xref="PDB:3BDG" FT /db_xref="PDB:3BDH" FT /db_xref="PDB:3CMR" FT /db_xref="PDB:3DPC" FT /db_xref="PDB:3DYC" FT /db_xref="PDB:3TG0" FT /db_xref="PDB:4KM4" FT /db_xref="PDB:4YR1" FT /db_xref="PDB:5C66" FT /db_xref="PDB:5GAD" FT /db_xref="PDB:5GAF" FT /db_xref="PDB:5GAG" FT /db_xref="PDB:5GAH" FT /db_xref="PDB:5JTL" FT /db_xref="PDB:5JTM" FT /db_xref="PDB:5JTN" FT /db_xref="PDB:5JTO" FT /db_xref="PDB:5JTP" FT /db_xref="UniProtKB/Swiss-Prot:P00634" FT /note="alkaline phosphatase signal peptide" FT /codon_start=1 FT /protein_id="AAA23431.1" FT /transl_table=11 FT /translation="MKQSTIALAVLPLLFTPVTKA" XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 60 gcc 63 // ID KX454487; SV 1; linear; mRNA; STD; INV; 743 BP. XX AC KX454487; XX DT 02-FEB-2017 (Rel. 131, Created) DT 02-FEB-2017 (Rel. 131, Last updated, Version 1) XX DE Ruditapes philippinarum histone mRNA, complete cds. XX KW . XX OS Ruditapes philippinarum OC Eukaryota; Metazoa; Lophotrochozoa; Mollusca; Bivalvia; Heteroconchia; OC Euheterodonta; Veneroida; Veneroidea; Veneridae; Ruditapes. XX RN [1] RP 1-743 RA Yang D., Zhao J., Wang Q.; RT ; RL Submitted (27-JUN-2016) to the INSDC. Key Laboratory of Coastal Zone RL Environment Processes and Ecological Remediation, Yantai Institute of RL Coastal Zone Research (YIC), Chinese Academy of Sciences (CAS), 17 Chunhui RL Road, Laishan District, Yantai, Shandong 264003, China XX DR MD5; cbc730cf7a8d694b50fb7dd6b993ae0d. XX CC ##Assembly-Data-START## CC Sequencing Technology :: Sanger dideoxy sequencing CC ##Assembly-Data-END## XX FH Key Location/Qualifiers FH FT source 1..743 FT /db_xref="taxon:129788" FT /mol_type="mRNA" FT /organism="Ruditapes philippinarum" FT CDS 58..444 FT /codon_start=1 FT /product="histone" FT /protein_id="APY18893.1" FT /translation="MPGGKAGKDSGKAKAKAVSRSARAGLQFPVGRIHRHLKNRTTSHG FT RVGATAAVYSAAILEYLTAEVLELAGNASKDLKVKRITPRHLQLAIRGDEELDSLIKAT FT IAGGGVIPHIHKSLIGKKGGQQAK" XX SQ Sequence 743 BP; 241 A; 147 C; 145 G; 210 T; 0 other; tgtgcacagt ctacgcgtca tcttgaaaga aagaactaca ctactccaaa aataatcatg 60 cctggtggaa aagctggtaa agattccgga aaggccaagg ctaaggcagt gtcaaggtcc 120 gcaagagctg gcttacagtt tccagtcgga cgtattcaca ggcatttgaa gaacagaacc 180 actagccacg gtcgtgttgg agctacagca gccgtttaca gtgcagcaat ccttgaatac 240 ctgaccgccg aagtgcttga gttggctgga aacgcaagta aagatctcaa agtaaagaga 300 atcaccccac gtcacttgca gttggcaatc agaggagatg aagagttgga ttccctaatt 360 aaagccacaa tcgctggtgg tggtgttatt ccacatatcc acaagtcact tattggcaag 420 aagggaggtc agcaagccaa ataaattgga catactcatt catcagggaa caatgtgtag 480 tgaatgtgtt aaaaagaaca atctcattgt gtagctcttt agttttatat gaatgtgtta 540 acatggtcat tcacatcgta tgactcatag aatcatctgt gtatcatttc atcctctcat 600 tttatagctc ctcattttcc ttagactcat taaaattttt atctcggaaa aatgtttttt 660 ctacaatttt agcattcatt tatcttcatc ttgcttttat gtttaataaa acgaacttat 720 aataccaaaa aaaaaaaaaa aaa 743 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_single_record000066400000000000000000000100501446255456000244130ustar00rootroot00000000000000ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. XX AC M14399; XX DT 16-JUL-1988 (Rel. 16, Created) DT 02-SEP-1999 (Rel. 60, Last updated, Version 3) XX DE E.coli alkaline phosphatase signal mRNA, 5' end. XX KW alkaline phosphatase; signal peptide. XX OS Escherichia coli OC Bacteria; Proteobacteria; Gammaproteobacteria; Enterobacterales; OC Enterobacteriaceae; Escherichia. XX RN [1] RP 1-63 RX DOI; 10.1016/0378-1119(85)90319-1. RX PUBMED; 3912261. RA Gray G.L., Baldridge J.S., McKeown K.S., Heyneker H.L., Chang C.N.; RT "Periplasmic production of correctly processed human growth hormone in RT Escherichia coli: natural and bacterial signal sequences are RT interchangeable"; RL Gene 39(2-3):247-254(1985). XX DR MD5; c9b40131b8622946b5aafdf5473b3d43. XX FH Key Location/Qualifiers FH FT source 1..63 FT /db_xref="taxon:562" FT /mol_type="mRNA" FT /organism="Escherichia coli" FT CDS 1..>63 FT /db_xref="GOA:P00634" FT /db_xref="InterPro:IPR001952" FT /db_xref="InterPro:IPR017849" FT /db_xref="InterPro:IPR017850" FT /db_xref="InterPro:IPR018299" FT /db_xref="PDB:1AJA" FT /db_xref="PDB:1AJB" FT /db_xref="PDB:1AJC" FT /db_xref="PDB:1AJD" FT /db_xref="PDB:1ALH" FT /db_xref="PDB:1ALI" FT /db_xref="PDB:1ALJ" FT /db_xref="PDB:1ALK" FT /db_xref="PDB:1ANI" FT /db_xref="PDB:1ANJ" FT /db_xref="PDB:1B8J" FT /db_xref="PDB:1ED8" FT /db_xref="PDB:1ED9" FT /db_xref="PDB:1ELX" FT /db_xref="PDB:1ELY" FT /db_xref="PDB:1ELZ" FT /db_xref="PDB:1EW8" FT /db_xref="PDB:1EW9" FT /db_xref="PDB:1HJK" FT /db_xref="PDB:1HQA" FT /db_xref="PDB:1KH4" FT /db_xref="PDB:1KH5" FT /db_xref="PDB:1KH7" FT /db_xref="PDB:1KH9" FT /db_xref="PDB:1KHJ" FT /db_xref="PDB:1KHK" FT /db_xref="PDB:1KHL" FT /db_xref="PDB:1KHN" FT /db_xref="PDB:1URA" FT /db_xref="PDB:1URB" FT /db_xref="PDB:1Y6V" FT /db_xref="PDB:1Y7A" FT /db_xref="PDB:2ANH" FT /db_xref="PDB:2G9Y" FT /db_xref="PDB:2GA3" FT /db_xref="PDB:2MLX" FT /db_xref="PDB:2MLY" FT /db_xref="PDB:2MLZ" FT /db_xref="PDB:3BDF" FT /db_xref="PDB:3BDG" FT /db_xref="PDB:3BDH" FT /db_xref="PDB:3CMR" FT /db_xref="PDB:3DPC" FT /db_xref="PDB:3DYC" FT /db_xref="PDB:3TG0" FT /db_xref="PDB:4KM4" FT /db_xref="PDB:4YR1" FT /db_xref="PDB:5C66" FT /db_xref="PDB:5GAD" FT /db_xref="PDB:5GAF" FT /db_xref="PDB:5GAG" FT /db_xref="PDB:5GAH" FT /db_xref="PDB:5JTL" FT /db_xref="PDB:5JTM" FT /db_xref="PDB:5JTN" FT /db_xref="PDB:5JTO" FT /db_xref="PDB:5JTP" FT /db_xref="UniProtKB/Swiss-Prot:P00634" FT /note="alkaline phosphatase signal peptide" FT /codon_start=1 FT /protein_id="AAA23431.1" FT /transl_table=11 FT /translation="MKQSTIALAVLPLLFTPVTKA" XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 60 gcc 63 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_single_record_lower000066400000000000000000000004201446255456000256230ustar00rootroot00000000000000ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 60 gcc 63 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_single_record_simple000066400000000000000000000076661446255456000260070ustar00rootroot00000000000000ID M14399; SV 1; linear; mRNA; ; PRO; 63 BP. XX AC M14399; XX DT 02-SEP-1999 XX DE E.coli alkaline phosphatase signal mRNA, 5' end. XX KW alkaline phosphatase; signal peptide. XX OS Escherichia coli OC Bacteria; Proteobacteria; Gammaproteobacteria; Enterobacterales; OC Enterobacteriaceae; Escherichia. XX RN [1] RP 1-63 RX PUBMED; 3912261. RA Gray G.L., Baldridge J.S., McKeown K.S., Heyneker H.L., Chang C.N.; RT "Periplasmic production of correctly processed human growth hormone in RT Escherichia coli: natural and bacterial signal sequences are RT interchangeable"; RL Gene 39(2-3):247-254(1985). XX DR MD5; c9b40131b8622946b5aafdf5473b3d43. XX FH Key Location/Qualifiers FH FT source 1..63 FT /db_xref="taxon:562" FT /mol_type="mRNA" FT /organism="Escherichia coli" FT CDS 1..>63 FT /db_xref="GOA:P00634" FT /db_xref="InterPro:IPR001952" FT /db_xref="InterPro:IPR017849" FT /db_xref="InterPro:IPR017850" FT /db_xref="InterPro:IPR018299" FT /db_xref="PDB:1AJA" FT /db_xref="PDB:1AJB" FT /db_xref="PDB:1AJC" FT /db_xref="PDB:1AJD" FT /db_xref="PDB:1ALH" FT /db_xref="PDB:1ALI" FT /db_xref="PDB:1ALJ" FT /db_xref="PDB:1ALK" FT /db_xref="PDB:1ANI" FT /db_xref="PDB:1ANJ" FT /db_xref="PDB:1B8J" FT /db_xref="PDB:1ED8" FT /db_xref="PDB:1ED9" FT /db_xref="PDB:1ELX" FT /db_xref="PDB:1ELY" FT /db_xref="PDB:1ELZ" FT /db_xref="PDB:1EW8" FT /db_xref="PDB:1EW9" FT /db_xref="PDB:1HJK" FT /db_xref="PDB:1HQA" FT /db_xref="PDB:1KH4" FT /db_xref="PDB:1KH5" FT /db_xref="PDB:1KH7" FT /db_xref="PDB:1KH9" FT /db_xref="PDB:1KHJ" FT /db_xref="PDB:1KHK" FT /db_xref="PDB:1KHL" FT /db_xref="PDB:1KHN" FT /db_xref="PDB:1URA" FT /db_xref="PDB:1URB" FT /db_xref="PDB:1Y6V" FT /db_xref="PDB:1Y7A" FT /db_xref="PDB:2ANH" FT /db_xref="PDB:2G9Y" FT /db_xref="PDB:2GA3" FT /db_xref="PDB:2MLX" FT /db_xref="PDB:2MLY" FT /db_xref="PDB:2MLZ" FT /db_xref="PDB:3BDF" FT /db_xref="PDB:3BDG" FT /db_xref="PDB:3BDH" FT /db_xref="PDB:3CMR" FT /db_xref="PDB:3DPC" FT /db_xref="PDB:3DYC" FT /db_xref="PDB:3TG0" FT /db_xref="PDB:4KM4" FT /db_xref="PDB:4YR1" FT /db_xref="PDB:5C66" FT /db_xref="PDB:5GAD" FT /db_xref="PDB:5GAF" FT /db_xref="PDB:5GAG" FT /db_xref="PDB:5GAH" FT /db_xref="PDB:5JTL" FT /db_xref="PDB:5JTM" FT /db_xref="PDB:5JTN" FT /db_xref="PDB:5JTO" FT /db_xref="PDB:5JTP" FT /db_xref="UniProtKB/Swiss-Prot:P00634" FT /note="alkaline phosphatase signal peptide" FT /codon_start=1 FT /protein_id="AAA23431.1" FT /transl_table=11 FT /translation="MKQSTIALAVLPLLFTPVTKA" XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 60 gcc 63 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_single_record_upper000066400000000000000000000005301446255456000256300ustar00rootroot00000000000000ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; GTGAAACAAA GCACTATTGC ACTGGCTGTC TTACCGTTAC TGTTTACCCC TGTGACAAAA 60 GCC 63 63 // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_uniprot_record000066400000000000000000000044351446255456000246440ustar00rootroot00000000000000ID 001R_FRG3G Reviewed; 256 AA. AC Q6GZX4; DT 28-JUN-2011, integrated into UniProtKB/Swiss-Prot. DT 19-JUL-2004, sequence version 1. DT 17-FEB-2016, entry version 31. DE RecName: Full=Putative transcription factor 001R; GN ORFNames=FV3-001R; OS Frog virus 3 (isolate Goorha) (FV-3). OC Viruses; dsDNA viruses, no RNA stage; Iridoviridae; Ranavirus. OX NCBI_TaxID=654924; OH NCBI_TaxID=8295; Ambystoma (mole salamanders). OH NCBI_TaxID=30343; Hyla versicolor (chameleon treefrog). OH NCBI_TaxID=8404; Lithobates pipiens (Northern leopard frog) (Rana pipiens). OH NCBI_TaxID=8316; Notophthalmus viridescens (Eastern newt) (Triturus viridescens). OH NCBI_TaxID=45438; Rana sylvatica (Wood frog). RN [1] RP NUCLEOTIDE SEQUENCE [LARGE SCALE GENOMIC DNA]. RX PubMed=15165820; DOI=10.1016/j.virol.2004.02.019; RA Tan W.G., Barkman T.J., Gregory Chinchar V., Essani K.; RT "Comparative genomic analyses of frog virus 3, type species of the RT genus Ranavirus (family Iridoviridae)."; RL Virology 323:70-84(2004). CC -!- FUNCTION: Transcription activation. {ECO:0000305}. DR EMBL; AY548484; AAT09660.1; -; Genomic_DNA. DR RefSeq; YP_031579.1; NC_005946.1. DR ProteinModelPortal; Q6GZX4; -. DR SwissPalm; Q6GZX4; -. DR GeneID; 2947773; -. DR KEGG; vg:2947773; -. DR Proteomes; UP000008770; Genome. DR GO; GO:0006355; P:regulation of transcription, DNA-templated; IEA:UniProtKB-KW. DR GO; GO:0046782; P:regulation of viral transcription; IEA:InterPro. DR GO; GO:0006351; P:transcription, DNA-templated; IEA:UniProtKB-KW. DR InterPro; IPR007031; Poxvirus_VLTF3. DR Pfam; PF04947; Pox_VLTF3; 1. PE 4: Predicted; KW Activator; Complete proteome; Reference proteome; Transcription; KW Transcription regulation. FT CHAIN 1 256 Putative transcription factor 001R. FT /FTId=PRO_0000410512. FT COMPBIAS 14 17 Poly-Arg. SQ SEQUENCE 256 AA; 29735 MW; B4840739BF7D4121 CRC64; MAFSAEDVLK EYDRRRRMEA LLLSLYYPND RKLLDYKEWS PPRVQVECPK APVEWNNPPS EKGLIVGHFS GIKYKGEKAQ ASEVDVNKMC CWVSKFKDAM RRYQGIQTCK IPGKVLSDLD AKIKAYNLTV EGVEGFVRYS RVTKQHVAAF LKELRHSKQY ENVNLIHYIL TDKRVDIQHL EKDLVKDFKA LVESAHRMRQ GHMINVKYIL YQLLKKHGHG PDGPDILTVK TGSKGVLYDD SFRKIYTDLG WKFTPL // scikit-bio-0.5.9/skbio/io/format/tests/data/embl_w_beginning_whitespace000066400000000000000000000004221446255456000263000ustar00rootroot00000000000000 ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. XX SQ Sequence 63 BP; 17 A; 17 C; 12 G; 17 T; 0 other; gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 60 gcc 63 // scikit-bio-0.5.9/skbio/io/format/tests/data/empty000066400000000000000000000000001446255456000217250ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/format/tests/data/error_diff_ids.fastq000066400000000000000000000011401446255456000246720ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_124 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_double_qual.fastq000066400000000000000000000012351446255456000254240ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_double_seq.fastq000066400000000000000000000012351446255456000252520ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_long_qual.fastq000066400000000000000000000011411446255456000251050ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWYY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_no_qual.fastq000066400000000000000000000007421446255456000245700ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGC +SLXA-B3_649_FC8437_R1_1_1_850_123 @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_del.fastq000066400000000000000000000011401446255456000247110ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_escape.fastq000066400000000000000000000011401446255456000254050ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_null.fastq000066400000000000000000000011421446255456000251210ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_space.fastq000066400000000000000000000011411446255456000252410ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYY WWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_tab.fastq000066400000000000000000000011411446255456000247140ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYY YYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_unit_sep.fastq000066400000000000000000000011401446255456000257730ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_qual_vtab.fastq000066400000000000000000000011401446255456000251010ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYY YYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_short_qual.fastq000066400000000000000000000011371446255456000253120ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYS @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_spaces.fastq000066400000000000000000000011641446255456000244070ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAA TACCTTTGTA GAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYY YYYYYYYYYW YWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGA AAGAGAAATG AGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYY WYYYYWWYYY WYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTT GATCATGATG ATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYY YYYYWYYWYY SYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAA GTTTTTCTCA ACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYY YYYYYYYYYW WWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTT AATGGCATAC ACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYY YWYYYYWYWW UWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_tabs.fastq000066400000000000000000000011651446255456000240630ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAA TACCTTTGTA GAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYY YYYYYYYYYW YWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGA AAGAGAAATG AGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYY WYYYYWWYYY WYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTT GATCATGATG ATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYY YYYYWYYWYY SYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAA GTTTTTCTCA ACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYY YYYYYYYYYW WWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTT AATGGCATAC ACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYY YWYYYYWYWW UWWWQQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_at_plus.fastq000066400000000000000000000010441446255456000260100ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA scikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_at_qual.fastq000066400000000000000000000011061446255456000257660ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 scikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_at_seq.fastq000066400000000000000000000010121446255456000256100ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 scikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_in_plus.fastq000066400000000000000000000010621446255456000260120ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FCscikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_in_qual.fastq000066400000000000000000000011371446255456000257740ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGCATACACTCAA +SLXA-B3_649_FC8437_R1_1_1_183_714 YYYYYYYYYYWYYYYWYWWUWWWQ scikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_in_seq.fastq000066400000000000000000000010271446255456000256200ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_183_714 GTATTATTTAATGGscikit-bio-0.5.9/skbio/io/format/tests/data/error_trunc_in_title.fastq000066400000000000000000000010011446255456000261410ustar00rootroot00000000000000@SLXA-B3_649_FC8437_R1_1_1_610_79 GATGTGCAATACCTTTGTAGAGGAA +SLXA-B3_649_FC8437_R1_1_1_610_79 YYYYYYYYYYYYYYYYYYWYWYYSU @SLXA-B3_649_FC8437_R1_1_1_397_389 GGTTTGAGAAAGAGAAATGAGATAA +SLXA-B3_649_FC8437_R1_1_1_397_389 YYYYYYYYYWYYYYWWYYYWYWYWW @SLXA-B3_649_FC8437_R1_1_1_850_123 GAGGGTGTTGATCATGATGATGGCG +SLXA-B3_649_FC8437_R1_1_1_850_123 YYYYYYYYYYYYYWYYWYYSYYYSY @SLXA-B3_649_FC8437_R1_1_1_362_549 GGAAACAAAGTTTTTCTCAACATAG +SLXA-B3_649_FC8437_R1_1_1_362_549 YYYYYYYYYYYYYYYYYYWWWWYWY @SLXA-B3_649_FC8437_R1_1_1_scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_10_seqs000066400000000000000000000002561446255456000232350ustar00rootroot00000000000000>seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 A C GT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 AC G T scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_3_seqs_defaults000066400000000000000000000000771446255456000250470ustar00rootroot00000000000000>s_e_q_1 desc 1 UUUU >s_e_q_2 desc 2 CATC >s_e_q_3 desc 3 sits scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_3_seqs_non_defaults000066400000000000000000000001021446255456000257060ustar00rootroot00000000000000>s*e*q*1 desc+1 UUU U >s*e*q*2 desc+2 CAT C >s*e*q*3 desc+3 sit s scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_5_blanks_start_of_file000066400000000000000000000002261446255456000263550ustar00rootroot00000000000000 >seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_5_ws_lines_start_of_file000066400000000000000000000003151446255456000267250ustar00rootroot00000000000000 >seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_6_blanks_start_of_file000066400000000000000000000002271446255456000263570ustar00rootroot00000000000000 >seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_6_ws_lines_start_of_file000066400000000000000000000003311446255456000267240ustar00rootroot00000000000000 >seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_blank_lines_between_records000066400000000000000000000002351446255456000274720ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_blanks_end_of_file000066400000000000000000000002301446255456000255350ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_description_newline_replacement_empty_str000066400000000000000000000001131446255456000325030ustar00rootroot00000000000000>proteinseq detaileddescription with newlines pQqqqPPQQQ >foo AGGAGAATA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_description_newline_replacement_multi_char000066400000000000000000000001551446255456000326120ustar00rootroot00000000000000>proteinseq :-)detailed:-)description with new:-):-)lines:-):-):-) pQqqqPPQQQ >foo :-):-):-):-) AGGAGAATA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_description_newline_replacement_none000066400000000000000000000001271446255456000314210ustar00rootroot00000000000000>proteinseq detailed description with new lines pQqqqPPQQQ >foo AGGAGAATA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_id_whitespace_replacement_empty_str000066400000000000000000000000211446255456000312450ustar00rootroot00000000000000>seq2 A > a b UA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_id_whitespace_replacement_multi_char000066400000000000000000000000651446255456000313560ustar00rootroot00000000000000>>:o>:o>:o>:o>:oseq>:o>:o2>:o A >>:o>:o>:o>:o a b UA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_id_whitespace_replacement_none000066400000000000000000000000351446255456000301630ustar00rootroot00000000000000> seq 2 A > a b UA scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_after_10_seqs000066400000000000000000000002721446255456000261220ustar00rootroot00000000000000>seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 A C GT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 ACGT >seq1 desc1 AC G T >seq1 desc1 scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_blank_line_after_header000066400000000000000000000000641446255456000302540ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 AAAAA >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_blank_line_within_sequence000066400000000000000000000001001446255456000310240ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 AAA AA >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_blank_sequence000066400000000000000000000000561446255456000264450ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_legacy_format000066400000000000000000000000501446255456000262740ustar00rootroot00000000000000; legacy-seq-id legacy description ACGT scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_missing_header000066400000000000000000000000201446255456000264360ustar00rootroot00000000000000seq1 desc1 ACGT scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_missing_seq_data_first000066400000000000000000000000561446255456000302070ustar00rootroot00000000000000>seq1 desc1 >seq2 desc2 AAAAA >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_missing_seq_data_last000066400000000000000000000000571446255456000300240ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 AAAAA >seq3 desc3 scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_missing_seq_data_middle000066400000000000000000000000551446255456000303150ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_whitespace_line_after_header000066400000000000000000000000771446255456000313250ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 AAAAA >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_whitespace_only_line_within_sequence000066400000000000000000000001051446255456000331370ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 AAAAA AAAAA >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_invalid_whitespace_only_sequence000066400000000000000000000000711446255456000305500ustar00rootroot00000000000000>seq1 desc1 ACGT >seq2 desc2 >seq3 desc3 CCC scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_max_width_1000066400000000000000000000000401446255456000241550ustar00rootroot00000000000000>seq1 desc1 A C G T - a c g t . scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_max_width_5000066400000000000000000000002261446255456000241670ustar00rootroot00000000000000>seq1 desc1 ACGT- acgt. >_____seq__2_ A > desc3 AACGG uA > ACGTT GCAcc GG > ACGUU >proteinseq detailed description with new lines pQqqq PPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_mixed_qual_scores000066400000000000000000000000631446255456000254640ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >da,dadadada 10 hours AAAAT scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_multi_seq000066400000000000000000000002211446255456000237540ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_multi_seq_roundtrip000066400000000000000000000001621446255456000260660ustar00rootroot00000000000000>seq-a a's description ACATAGGTA >seq-b b's description TAGATAGATAGA >seq-c c's description CATCATCATCATCATCATCAT scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_prot_seqs_odd_labels000066400000000000000000000001201446255456000261370ustar00rootroot00000000000000> DEFQ fp > skbio S K B I scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_bio_seq_defaults000066400000000000000000000000221446255456000266220ustar00rootroot00000000000000>f_o_o b a r ACgt scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_bio_seq_non_defaults000066400000000000000000000000251446255456000274770ustar00rootroot00000000000000>f-o-o b_a_r A C g t scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_dna_seq_defaults000066400000000000000000000000221446255456000266130ustar00rootroot00000000000000>f_o_o b a r TAcg scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_dna_seq_non_defaults000066400000000000000000000000251446255456000274700ustar00rootroot00000000000000>f-o-o b_a_r T A c g scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_prot_seq_defaults000066400000000000000000000000211446255456000270340ustar00rootroot00000000000000>f_o_o b a r PqQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_prot_seq_non_defaults000066400000000000000000000000231446255456000277100ustar00rootroot00000000000000>f-o-o b_a_r P q Q scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_rna_seq_defaults000066400000000000000000000000221446255456000266310ustar00rootroot00000000000000>f_o_o b a r uaCG scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_rna_seq_non_defaults000066400000000000000000000000251446255456000275060ustar00rootroot00000000000000>f-o-o b_a_r u a C G scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_single_seq000066400000000000000000000000271446255456000241070ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_tabular_msa_different_type000066400000000000000000000001101446255456000273300ustar00rootroot00000000000000> aUG >rnaseq-1 rnaseq desc 1 AuC >rnaseq-2 rnaseq desc 2 AUg scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_ws_lines_between_records000066400000000000000000000004251446255456000270350ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fasta_ws_lines_end_of_file000066400000000000000000000003511446255456000261120ustar00rootroot00000000000000>seq1 desc1 ACGT-acgt. >_____seq__2_ A > desc3 AACGGuA > ACGTTGCAccGG > ACGUU >proteinseq detailed description with new lines pQqqqPPQQQ scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_5_blanks_start_of_file000066400000000000000000000001341446255456000263730ustar00rootroot00000000000000 @foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_5_ws_lines_start_of_file000066400000000000000000000002231446255456000267430ustar00rootroot00000000000000 @foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_blank_lines000066400000000000000000000001321446255456000242540ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_after_header000066400000000000000000000001301446255456000272570ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_after_plus000066400000000000000000000001301446255456000270120ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_after_seq000066400000000000000000000001301446255456000266170ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_in_seq_at_symbol000066400000000000000000000001311446255456000301760ustar00rootroot00000000000000@foo bar baz AACCGG + MNO @QR @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_within_qual000066400000000000000000000001311446255456000271730ustar00rootroot00000000000000@foo bar baz AACCGG + MNO PQR @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_blank_within_seq000066400000000000000000000001311446255456000270210ustar00rootroot00000000000000@foo bar baz AAC CGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_missing_header000066400000000000000000000000271446255456000264650ustar00rootroot00000000000000seq1 desc1 ACGT + 1234 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_missing_seq_data000066400000000000000000000001471446255456000270210ustar00rootroot00000000000000@seq-1 first sequence ACG T + [[[[ @seq-2 second sequence T GCAC + [[[[[ @seq-3 third sequence + [[[[[ scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_ws_line_after_header000066400000000000000000000001431446255456000276340ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_ws_line_after_plus000066400000000000000000000001431446255456000273670ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_ws_line_after_seq000066400000000000000000000001431446255456000271740ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_ws_line_within_qual000066400000000000000000000001441446255456000275500ustar00rootroot00000000000000@foo bar baz AACCGG + MNO PQR @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_invalid_ws_line_within_seq000066400000000000000000000001441446255456000273760ustar00rootroot00000000000000@foo bar baz AAC CGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_blank_between_records000066400000000000000000000001371446255456000275330ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_blank_end_of_file000066400000000000000000000001361446255456000266110ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_blank_start_of_file000066400000000000000000000001351446255456000271770ustar00rootroot00000000000000 @foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_seq_sanger000066400000000000000000000001271446255456000253400ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_whitespace_stripping000066400000000000000000000005131446255456000274430ustar00rootroot00000000000000 @foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_ws_lines_between_records000066400000000000000000000002371446255456000302700ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_ws_lines_end_of_file000066400000000000000000000002671446255456000273520ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_multi_ws_lines_start_of_file000066400000000000000000000002371446255456000277360ustar00rootroot00000000000000 @foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_single_seq_illumina1.3000066400000000000000000000000411446255456000262370ustar00rootroot00000000000000@ bar baz a C G T + a b c d scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_single_seq_illumina1.8000066400000000000000000000001661446255456000262540ustar00rootroot00000000000000@EAS139:136:FC706VJ:2:2104:15343:197393 1:Y:18:ATCACG CCGCCGGTCATCCAATTCATTGCGAAAGGT + n%OiP]XgBh]u:9jO|KN4Op~7Ry;-&. scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_whitespace_only_lines000066400000000000000000000001731446255456000263670ustar00rootroot00000000000000@foo bar baz AACCGG + 123456 @bar baz foo TTGGCC + 876543 @baz foo bar GATTTC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_wrapping_as_illumina_no_description000066400000000000000000000015651446255456000313110ustar00rootroot00000000000000@SRR014849.50939 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + Zb^Ld`N\[d`NaZ[aZc]UOKHDA[\YT[_W[aZ\aZ[Zd`SF_WeaUI[Y\[[\\\[\Z\aY`X[[aZ\aZ\d`OY[aY[[\[[e`WPJC^UZ[`X\[R]T_V_W[`[Ga\I`\H[[Q^TVa\Ia\Ic^LY\S @SRR014849.110027 CTTCAAATGATTCCGGGACTGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTTCGGTTCCAACTCGCCGTCCGAATAATCCGTTCAAAATCTTGGCCTGTCAAAACGACTTTACGACCAGAACGATCCG + \aYY_[FY\T`X^Vd`OY\[[^U_V[R^T[_ZDc^La\HYYO\S[c^Ld`Nc_QAZaZaYaY`XZZ\[aZZ[aZ[aZ[aZY`Z[`ZWeaVJ\[aZaY`X[PY\eaUG[\[[d`OXTUZ[Q\\`W\\\Y_W\ @SRR014849.203935 AACCCGTCCCATCAAAGATTTTGGTTGGAACCCGAAAGGGTTTTGAATTCAAACCCCTTTCGGTTCCAACTATTCAATTGTTTAACTTTTTTTAAATTGATGGTCTGTTGGACCATTTGTAATAATCCCCATCGGAATTTCTTT + `Z_ZDVT^YB[[Xd`PZ\d`RDaZaZ`ZaZ_ZDXd`Pd`Pd`RD[aZ`ZWd`Oc_RCd`P\aZ`ZaZaZY\YaZYaY`XYd`O`X[e`WPJEAc^LaZS[YYN[Z\Y`XWLT^U\b]JW[[RZ\SYc`RD[Z\WLXM`\HYa\I scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_wrapping_as_sanger_no_description000066400000000000000000000015651446255456000307560ustar00rootroot00000000000000@SRR014849.50939 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + ;C?-EA/=60,)%"<=:5<@85@7@8+8<<3;=4:DA3%<;=8-9.A=):B=* scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_wrapping_original_sanger_no_description000066400000000000000000000016021446255456000321470ustar00rootroot00000000000000@SRR014849.50939 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + ;C?-EA/=60,)%"<=:5< @85@7@8+8< <3;=4:DA3%<;=8-9.A=):B=* scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_writer_illumina1.3_defaults000066400000000000000000000001361446255456000273160ustar00rootroot00000000000000@f_o__o bar baz AaCcGg + PQRSTU @bar baz foo TtGgCc + WVUTSR @ba___z foo bar gAtTtC + TUVWXR scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_writer_sanger_defaults000066400000000000000000000001361446255456000265410ustar00rootroot00000000000000@f_o__o bar baz AaCcGg + 123456 @bar baz foo TtGgCc + 876543 @ba___z foo bar gAtTtC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/fastq_writer_sanger_non_defaults000066400000000000000000000001361446255456000274130ustar00rootroot00000000000000@f%o%%o bar^^baz AaCcGg + 123456 @bar baz foo TtGgCc + 876543 @ba%%%z foo bar gAtTtC + 567893 scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_5_blanks_start_of_file000066400000000000000000000001251446255456000266620ustar00rootroot00000000000000 LOCUS NC_000932 154478 bp DNA circular PLN 15-APR-2009 scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_6_blanks_start_of_file000066400000000000000000000001261446255456000266640ustar00rootroot00000000000000 LOCUS NC_000932 154478 bp DNA circular PLN 15-APR-2009 scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_missing_locus_name000066400000000000000000000001071446255456000261420ustar00rootroot00000000000000LOCUS 154478 bp DNA circular PLN 15-APR-2009 scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_multi_records000066400000000000000000000030761446255456000251470ustar00rootroot00000000000000LOCUS AAB29917 9 aa linear BCT 23-SEP-1994 DEFINITION L-carnitine amidase {N-terminal} ACCESSION AAB29917 VERSION AAB29917.1 GI:545426 DBSOURCE accession AAB29917.1 KEYWORDS . SOURCE Bacteria ORGANISM Bacteria Unclassified. REFERENCE 1 (residues 1 to 9) AUTHORS Joeres,U. and Kula,M.R. TITLE a microbial L-carnitine amidase JOURNAL AMB 40 (5), 606-610 (1994) PUBMED 7764422 REMARK from the original journal article. REFERENCE 1 (residues 1 to 9) AUTHORS Joeres,U. and Kula,M.R. TITLE a microbial L-carnitine amidase JOURNAL AMB 40 (5), 606-610 (1994) PUBMED 7764422 COMMENT Method: direct peptide sequencing. FEATURES Location/Qualifiers source 1..9 /organism="Bacteria" Protein 1..>9 /product="L-carnitine amidase" ORIGIN 1 gsreildfk // LOCUS HQ018078 9 bp DNA linear ENV 29-AUG-2010 DEFINITION Uncultured Xylanimonas sp.16S, partial ACCESSION HQ018078 VERSION HQ018078.1 GI:304421728 KEYWORDS ENV. SOURCE uncultured Xylanimonas sp. ORGANISM uncultured Xylanimonas sp. Bacteria; Actinobacteria; Micrococcales; Promicromonosporaceae; Xylanimonas; environmental samples. FEATURES Location/Qualifiers source 1..9 /country="Brazil: Parana, Paranavai" /environmental_sample rRNA complement(<2..>8) /product="16S ribosomal RNA" ORIGIN 1 catgcaggc // scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_single_record000066400000000000000000000020761446255456000251120ustar00rootroot00000000000000LOCUS ECOALKP 63 bp mRNA linear BCT 26-APR-1993 DEFINITION alkaline phosphatase signal mRNA, 5' end. ACCESSION M14399 VERSION M14399.1 KEYWORDS alkaline phosphatase; signal peptide. SOURCE Escherichia coli ORGANISM Escherichia coli Bacteria; Proteobacteria; Gammaproteobacteria; Enterobacteriales; Enterobacteriaceae; Escherichia. COMMENT Original source text: E.coli, cDNA to mRNA. FEATURES Location/Qualifiers source 1..63 /db_xref="taxon:562" /mol_type="mRNA" /organism="Escherichia coli" CDS 1..>63 /db_xref="taxon:562" /db_xref="taxon:561" /note="alkaline phosphatase signal peptide" /codon_start=1 /protein_id="AAA23431.1" /transl_table=11 /translation="MKQSTIALAVLPLLFTPVTKA" ORIGIN 1 gtgaaacaaa gcactattgc actggctgtc ttaccgttac tgtttacccc tgtgacaaaa 61 gcc // scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_single_record_lower000066400000000000000000000001321446255456000263110ustar00rootroot00000000000000LOCUS AAB29917 9 aa linear BCT 23-SEP-1994 ORIGIN 1 gsreildfk // scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_single_record_upper000066400000000000000000000001321446255456000263140ustar00rootroot00000000000000LOCUS AAB29917 9 aa linear BCT 23-SEP-1994 ORIGIN 1 GSREILDFK // scikit-bio-0.5.9/skbio/io/format/tests/data/genbank_w_beginning_whitespace000066400000000000000000000001221446255456000267630ustar00rootroot00000000000000 LOCUS NC_000932 154478 bp DNA circular PLN 15-APR-2009 scikit-bio-0.5.9/skbio/io/format/tests/data/gff3_bad_missing_directive000066400000000000000000000003161446255456000260230ustar00rootroot00000000000000##sequence-region ctg123 1 1497228 ctg123 . gene 1000 9000 . + . ID=gene00001;Name=EDEN ctg123 . TF_binding_site 1000 1012 . + . Parent=gene00001 ctg123 . mRNA 1050 9000 . + . ID=mRNA00001;Parent=gene00001 scikit-bio-0.5.9/skbio/io/format/tests/data/gff3_bad_wrong_columns000066400000000000000000000007131446255456000252110ustar00rootroot00000000000000##gff-version 3 ##sequence-region Chromosome 1 4641652 #!genome-build European Nucleotide Archive ASM584v2 #!genome-version ASM584v2 #!genome-date 2014-08 #!genome-build-accession GCA_000005845.2 #!genebuild-last-updated 2014-08 Chromosome chromosome 1 4641652 . . . ID=chromosome:Chromosome;Alias=U00096.3;Is_circular=true ### Chromosome biological_region 148 148 . + . external_name=Promoter thrLp (RegulonDB:ECK120010236);logic_name=regulondb_promoter scikit-bio-0.5.9/skbio/io/format/tests/data/gff3_dna000066400000000000000000000001521446255456000222460ustar00rootroot00000000000000##gff-version 3 NC_1 Prodigal_v2.60 gene 1 9 . + 0 ID=gene1;Name=FXR ##FASTA >NC_1 species X ATGCATGCATGC scikit-bio-0.5.9/skbio/io/format/tests/data/gff3_multi_record000066400000000000000000000015611446255456000242010ustar00rootroot00000000000000##gff-version 3 ##sequence-region Chromosome 1 4641652 #!genome-build European Nucleotide Archive ASM584v2 #!genome-version ASM584v2 #!genome-date 2014-08 #!genome-build-accession GCA_000005845.2 #!genebuild-last-updated 2014-08 Chromosome European Nucleotide Archive chromosome 1 4641652 . . . Alias=U00096.3;ID=chromosome:Chromosome;Is_circular=true ### Chromosome regulondb_feature biological_region 148 148 . + . external_name=Promoter thrLp (RegulonDB:ECK120010236);logic_name=regulondb_promoter gi|556503834|ref|NC_000913.3| Prodigal_v2.60 gene 337 2799 1.8 + 0 ID=1_1;gc_cont=0.427 gi|556503834|ref|NC_000913.3| Prodigal_v2.60 CDS 337 2799 333.8 + 0 ID=1_2;Parent=1_1;rbs_motif=GGAG/GAGG;rbs_spacer=5-10bp NC 7 Prodigal_v2.60 gene 1 100 1.8 + 0 ID=1_1;gene=FXR receptor NC 7 Prodigal_v2.60 exon 1 50 1.8 + 0 Parent=1_1 NC 7 Prodigal_v2.60 exon 56 100 1.8 + 0 Parent=1_1 scikit-bio-0.5.9/skbio/io/format/tests/data/gff3_single_record000066400000000000000000000007711446255456000243320ustar00rootroot00000000000000##gff-version 3 ##sequence-region Chromosome 1 4641652 #!genome-build European Nucleotide Archive ASM584v2 #!genome-version ASM584v2 #!genome-date 2014-08 #!genome-build-accession GCA_000005845.2 #!genebuild-last-updated 2014-08 Chromosome European Nucleotide Archive chromosome 1 4641652 . . . Alias=U00096.3;ID=chromosome:Chromosome;Is_circular=true ### Chromosome regulondb_feature biological_region 148 148 . + . external_name=Promoter thrLp (RegulonDB:ECK120010236);logic_name=regulondb_promoter scikit-bio-0.5.9/skbio/io/format/tests/data/illumina_full_range_as_illumina.fastq000066400000000000000000000006521446255456000303060ustar00rootroot00000000000000@FAKE0005 Original version has PHRED scores from 0 to 62 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @FAKE0006 Original version has PHRED scores from 62 to 0 inclusive (in that order) GCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@ scikit-bio-0.5.9/skbio/io/format/tests/data/illumina_full_range_as_sanger.fastq000066400000000000000000000006521446255456000277530ustar00rootroot00000000000000@FAKE0005 Original version has PHRED scores from 0 to 62 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ @FAKE0006 Original version has PHRED scores from 62 to 0 inclusive (in that order) GCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + _^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! scikit-bio-0.5.9/skbio/io/format/tests/data/illumina_full_range_original_illumina.fastq000066400000000000000000000006521446255456000315070ustar00rootroot00000000000000@FAKE0005 Original version has PHRED scores from 0 to 62 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @FAKE0006 Original version has PHRED scores from 62 to 0 inclusive (in that order) GCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@ scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_and_blast7_default000066400000000000000000000007711446255456000257450ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query2 # Subject: subject2 # Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score # 1 hits found query2 subject2 100.00 8 0 1 0 9 3 10 2e-05 9.8 # BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: query2 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap opens,q. start,q. end,s. start,s. end,evalue,bit score query2 subject1 70.00 9 1 0 1 8 4 9 0.025 11.7 scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_invalid_differing_fields000066400000000000000000000006241446255456000272110ustar00rootroot00000000000000# BLASTP 2.2.31+ # Query: query1 # Subject: subject1 # 0 hits found # BLASTP 2.2.31+ # Query: query1 # Subject: subject3 # 0 hits found # BLASTP 2.2.31+ # Query: query2 # Subject: subject1 # Fields: query id, subject id, q. start # 1 hits found query1 subject1 4 # BLASTP 2.2.3 [May-13-2002] # Database: other_vertebrate # Subject: subject1 # Fields: Query id,Subject id,subject ids query2 subject1 N/A scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_invalid_too_many_columns000066400000000000000000000004061446255456000273110ustar00rootroot00000000000000# BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: AF178033 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap openings,q. start,q. end,s. start,s. end,e-value,bit score query1 subject1 80.00 7 2 0 0 9 4 9 0.023 14.4 0.145 scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_mixed_nans000066400000000000000000000004501446255456000243420ustar00rootroot00000000000000# BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: query2 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap opens,q. start,q. end,s. start,s. end,evalue,bit score N/A subject1 N/A 7 1 0 N/A 8 4 10 N/A 15.5 query2 subject1 90.00 8 N/A 0 0 8 N/A 9 1e-05 N/A scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_multi_line000066400000000000000000000005311446255456000243560ustar00rootroot00000000000000# BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: query1 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap opens,q. start,q. end,s. start,s. end,evalue,bit score query1 subject1 90.00 7 1 0 0 8 4 10 1e-05 15.5 query1 subject1 70.00 8 0 1 0 9 5 7 0.231 7.8 query1 subject1 90.00 5 1 1 0 0 2 10 0.022 13.0 scikit-bio-0.5.9/skbio/io/format/tests/data/legacy9_single_line000066400000000000000000000003731446255456000245110ustar00rootroot00000000000000# BLASTN 2.2.3 [May-13-2002] # Database: other_vertebrate # Query: query1 # Fields: Query id,Subject id,% identity,alignment length,mismatches,gap opens,q. start,q. end,s. start,s. end,evalue,bit score query1 subject1 90.00 7 1 0 0 8 4 10 1e-05 15.5 scikit-bio-0.5.9/skbio/io/format/tests/data/longreads_as_illumina.fastq000066400000000000000000000203041446255456000262500ustar00rootroot00000000000000@FSRRS4401BE7HA [length=395] [gc=36.46] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=95] tcagTTAAGATGGGATAATATCCTCAGATTGCGTGATGAACTTTGTTCTGGTGGAGGAGAAGGAAGTGCATTCGACGTATGCCCGTTTGTCGATATTTGtatttaaagtaatccgtcacaaatcagtgacataaatattatttagatttcgggagcaactttatttattccacaagcaggtttaaattttaaatttaaattattgcagaagactttaaattaacctcgttgtcggagtcatttgttcggttattggtcgaaagtaaccncgggaagtgccgaaaactaacaaacaaaagaagatagtgaaattttaattaaaanaaatagccaaacgtaactaactaaaacggacccgtcgaggaactgccaacggacgacacagggagtagnnn + eeeccccccc`UUU^UWWeegffhhhhhhhhhhhhhhhhhhggghhhhhhhhhfgfeeeee\\\\ceeeeeeeeeeeeeec^^^YRPOSNVU\YTMMMSMRKKKRUUNNNNS[`aa```\bbeccccccccYUUUbceeee\[`a`\ZYRRRPPP[\\\XXZaWWXeeeeeeccacaccc\WWSSQRPMMKKKLKKKKKKKKPPRRMMLLLPVPPPKKKKKQQTTTPRPPQPMLLMKRRRPPKMKKRLLKKMKKLLKRTPPPQRMMLL@KKKKLLKLLLLXKKKKW\KKLKKKLKKKKLLLQUYXYTLMMPKKKKPPNNKKKK@KKPXPVLLKKKKLRMKLLKKPVKKKKLLLJPPPPRMOROOOOKKKOSSSOOORUZXUUUQMNNZV][Z@@@ @FSRRS4401BRRTC [length=145] [gc=38.62] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=74] tcagCCAGCAATTCCGACTTAATTGTTCTTCTTCCATCATTCATCTCGACTAACAGTTCTACGATTAATGAGTTTGGCtttaatttgttgttcattattgtcacaattacactactgagactgccaaggcacncagggataggnn + eeeeeeeeecccceeeefecccca`````\[SSSS__a\TTTYaaaaa__^WYW[^[WXWXW[WSSSQZ\\RKKKTPSKKKPPKKKMKKQPVVVTTTTPRKMMLLPPPTVTWMNNRSSWW][[ZZZZXXSSN@NSKKKTVWTT@@ @FSRRS4401B64ST [length=382] [gc=40.58] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=346] tcagTTTTCTTAAATTACTTGAATCTGTTGAAGTGGATGTCCACTTTTGTATGCCAAATATGCCCAGCGTATACGATCTTGGCCACATCTCCACATAATCATCAGTCGGATGCAAAAAGCGATTAAACTAAAAATGAATGCGTTTTTAGATGAGTAAATAGGTAATACTTTGTTTAAATAATAAATGTCACAAACAGAACGCGGATTACAGTACCTGAAAATAGTTGTACTGTATCTGTGCCGGCACTTCCTCGGCCCTGAGAAGTTGTCCCGTTGTTTCCATTCGCACCATCCAATGGCCAAAGTTTGCGAAGAATCTGTTCCGTTCCATTACCAATTGTTTTTCCATGctgagactgccaaggcacacaggggataggnn + hhhhbbbbh^^UUUhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhUUUUh`hhhhh^^^hhhhbbbhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhUURRRdhbdYYRRW\NLLLLKW\]]^^YQLNNNNV]bddhdhggghhhhhhhhhdZZXXPPPXXa^^^habghhhhhhggghhggghhhhhhhhhhhhhhhhhhaabbhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhfffhhhhhhhhhc^\\\chhhggghhhhhhhhhggghhhhhhhhhhggghggghhhhhhhhhhhhhhhhhhhhhh^]ZXXWW\\TLLLLM__`dfhhhhhhhhhgg^^^^dhhheeXXXZdhhaa@@ @FSRRS4401EJ0YH [length=381] [gc=48.29] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=343] tcagTTTTTGGAGAATTCCGTCAGGGACGGCATGGCATATTTGTGGGTTCGGCACGGCGTCCTGGCCAAGAAGAAGAAGACGAATTAGCCCGTTAATTTAATGACACCTTCCCCAATTTTGCAGCAATGATTGGTTCATTCTTGGCGGTGCGTTTTTGTGCTTCGTCGAATTGTTGGCCATTTTGGTCCACCGGCCATCATCTTTACGCTATCCGACTGATTGGAAATCACCGCCTAGCATTTTGCCGAAGATTGTTGCGTTGTACGGCCATGTGCTGATTGTTTACATTGGCATTCTTGGCAATTTGTCCTTGGTCGGCTTTGACGGCAAATTTGCGGTGTTAAGTctgagactgccaaggcacacagggggatagggnn + hhhh^^^^^hhhhhhhhhhhhhhggghhhhhhhhhhhhhggghhggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhggghhhhhggghhhhhhhhhhh````hh]]]]hhhhhhhhhhhhhhhhhhhhhhhhhhddhddZRRRRRcVhhhhhhhhhhhhhhhhhhhhhbb__gghhhhhhhhhhhhhhhhggghhhhhhhhhhhhhhhhhhhggghhhhhhhhhhhhhaaaahgbcbghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhggghhhggbbchhhhhhggghhbbbg\bbhhhhhhhhhfffhhhhhhgggggghhhhhhhhhhhhhhhggghhggd^^]]^dedd^NNNNNZYWOLL@@ @FSRRS4401BK0IB [length=507] [gc=49.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=208] tcagTTGACCGGCGTTGTGTAACAATAATTCATTATTCTGAGACGATGCCAATGTAATCGACGGTTTATGCCCAATTATTCCCATCTATGCTTAACTGATCAAATACTATTTGCATTACGTCACGAAATTGCGCGAACACCGCCGGCCGACAATAATTTATACCGGACATACCGGAGTTGATGGTAATCGGTAAAGAGTTTTATTTAATTATntattatcnctattaattattgttancaacaatgtgcacgctntgccgcccgccgccgccgtgtcggtaggaccccggacggacccggacccggttcgggtacccgttttcgggttcccggaaccgtttttcgggtacccggttttttcggggggccccccggtaaaaaaccggggaaccccctaaaacgggtaaacgtaccgtaagggaccccctaaacgggggccccgaaaaaccgggacccaaaccggggggaaacggttaaaggggggggaagtaggngnnnnnnnnnnnn + eee`__eeeeeeeeeeggaYYY_aeeeeffghghhhhhhhhhhhhhhhhhhhhhhheeeeeeeee^\a`_PPPWWOPP[[WWZ^``accb^^^cc````c`UUUc^ccc\\\\\``]^]][[[\[PPPWW[[^^^``^XTTT\`aaa__^\]]^__PPPSQYYcc`^^^ceeeeeeeeeeeeea````[[OOOOMQQ\NNNNWKLLPPPPPP@QRLLNQS@RVYUUUU[ZWQQNMMS@SUTQPPVVTTRMLMQR@QRPPQPPPQKKLKKQPP\\TLLLLLLKPQKKKKKKLKKKLPKKKKLKKPTTLLKKKKPRPPPMKKKKKKKKJJPPPMMPPMMPKKKKKKKKKJRKKKKKLLQQLLLLLNNLLLLTTNNIINLLQQLLIIKKKKIIKKKKKKMPMKIKKKKIIIKKKKKKKKKKKKKKKKKKKKKKKHKKLKKKKKKHKKKKKIINNMHKKKNNNKKKKKKKKKKKMHHRRLLLKKKKKKKKKKGOKKK@M@@@@@@@@@@@@ @FSRRS4401ARCCB [length=258] [gc=46.90] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=193] tcagTTATTGCAGTCGTTCCGCGCCATCGCCGGTAACCGTCCGCGTGTTATTCTGTGTATCGGCCAACCTTCGTATAACTTCGTATAATGTATGCTATACGAAGTTATTACGATCTATACCGGCGAAACTCAGCCGAAAGGTCTCGCGGTAGAGCCTATGAGCTGCCCGACCGATGCATTTAAATTTCCGGGGATCGtcgctgatctgagactgccaaaggcacactagggggataggnnnnnnnnnnnnnnnnnnnn + eee[WYY_ceeeeeeeffecb`````a__OOOOSU[ZUURQQRUUVUQQSRRSW[[\^^SSSTYY]`a```_[[\\a\YTTTYaac^^\acccceeebbbbbbbeebccceeeeeca``\\WWWWOOOS][[[XXUWWZWWX[WWX^aaaa`\^^^ccaaa__^^WWWWXLLLQRVVVPKKKKKKKKLLPPTQ[[OOPTW`_][[[[[SRQVVVPPKKKLLRV\\\VTKLLLLRSUUU@@@@@@@@@@@@@@@@@@@@ @FSRRS4401CM938 [length=453] [gc=44.15] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=418] tcagGTTTTAAATCGCTTTCCAAGGAATTTGAGTCTAAATCCGGTGGATCCCATCAGTACAAATGCGGCGACAAGGCCGTGAAAACACTGCTTAATTCTTTGCACTTTTTGGCCACCTTTTTGGAAATGTTGTTTTGTGTTCTCAAAATTTTCCATCTCAGAACAAACATTCCATCGGGCTGATGTTGTGGCTTTTGGCGCGCGAAGTGCTGCTACTGCGCGGCAAAATCAGTCGCCAGACCGGTTTTGTTGTGGACGACAAAGTGATCATGCCTGACTTGTACTTCTACCGCGATCCGCAAGCGCGAATTGGTCACATAGTTATAGAATTTTTGAGCCTTTTTCTTGACATAAAAAGTGTGGTTTTAAAAATTTCCTGGCAGGACCCACGCCAACGTTCAGGAATAATATCTTTTAAAAAGctgagactgccaaggcacacaggggataggn + hhhhhbb]]UUUhhhhbbbhhhhhhhhggghhhhhfUUUhhhhhhhhhhggghhhhhhhhbbbhhhhhhhhhhhhhhhhhh____hhhhhhhhhhhhhggghhhh^^^\ZhhddhYYNNNNNVTSSY^haaVQQSSdWddbdab\_______gghhhhhhhhhhaaahhhhhhhhhggghhhhhhhhhhhhhbbbbhhhhhhhhhhhhhhhhhhhhhhhhhhhhUUUUcdhhgda^^c_VVVVVQQQQcWXddhhhhhhhggghhhhhhhhggghhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhggghhhhhhhhhhhhhhh\\^\\hhhhh^^^\ZhURcccWQLLKKKRW\\YYLLLLKKLLLJJJRROUUZ_URWOOOWNYWWX[Yafhhhhhhhhhed[^eTTOOLLLLLTYZZZY]^_b[[VXXXdddddd____ddddd@ @FSRRS4401EQLIK [length=411] [gc=34.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=374] tcagTTTAATTTGGTGCTTCCTTTCAATTCCTTAGTTTAAACTTGGCACTGAAGTCTCGCATTTATAACTAGAGCCCGGATTTTAGAGGCTAAAAAGTTTTCCAGATTTCAAAATTTATTTCGAAACTATTTTTCTGATTGTGATGTGACGGATTTCTAAATTAAATCGAAATGATGTGTATTGAACTTAACAAGTGATTTTTATCAGATTTTGTCAATGAATAAATTTTAATTTAAATCTCTTTCTAACACTTTCATGATTAAAATCTAACAAAGCGCGACCAGTATGTGAGAAGAGCAAAAACAACAAAAAGTGCTAGCACTAAAGAAGGTTCGAACCCAACACATAACGTAAGAGTTACCGGGAAGAAAACCACTctgagactgccaaggcacacagggggataggnn + hhh^UUU^^ggghhhhhhhhhfffhhhhhhhhhhhfffggghhhhhhhhhhhhhhhhhhhhfffhhhhhhhhhhggghhh____hhhhdhdPPPPOOLLLLQQ^\WLLLYLLLLLLLKKKKRRLLLTYRKLLLLYPaadddghhhhhhhhhhha^^`PQQOOOMMMY^\OQSfhhhhhhhhhhhhhhhhhhdbbgga\NNLKKQP^^[TLOOQ\Ueaa^YX[\PPNSSSSNNLNNVV^^fdhddgh`bbhhhggghhhhhhhbbb`hhhgggggghhhhhhhhhhhhhhhhhhhhhhddPNNLLWQQZLLLLMVVV_dhhhhhh^^^hhhhhhhhhhhggghhhhhhhhhhhhhhhhhhhhXXSQQVVVTTTT`dZhdddddhhhhh^^XVTT]_\\YRKKKKKRRRRU@@ @FSRRS4401AOV6A [length=309] [gc=22.98] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=273] tcagTTTTCAAATTTTCCGAAATTTGCTGTTTGGTAGAAGGCAAATTATTTGATTGAATTTTGTATTTATTTAAAACAATTTATTTTAAAATAATAATTTTCCATTGACTTTTTACATTTAATTGATTTTATTATGCATTTTATATTTGTTTTCTAAATATTCGTTTGCAAACTCACGTTGAAATTGTATTAAACTCGAAATTAGAGTTTTTGAAATTAATTTTTATGTAGCATAATATTTTAAACATATTGGAATTTTATAAAACATTATATTTTTctgagactgccaaggcacacagggggataggn + hhhhbbbbhZZZbbbbhhh^^^ggghhhhggghhhhhhhhhhggghhhggghhhhhhh____hehbbbhb``ZZZZdc^a__cUUSSTTTT[[[fhh]]``hhhhhhhhZZZYYhhh^^^bbbhhhZZZZheehhhhhbbbahahddcbSSSS^Saaad^dhhhbgghhZZZghhhhhhggZZZgghhhhhZZZhhhhggghhhhhh]]^^]hddaffYYPPPPNSUeaeaa^\Z\`^XVVVPPPXYd```ccacVVVV\NPPPPQQc`__aUWZZZhWgghhhhhZZZZ^]hdbbbaNNNNNZVST\@ @FSRRS4401EG0ZW [length=424] [gc=23.82] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=389] tcagTTTTGATCTTTTAATAATGAATTTTAATGTGTTAAAATGATTGCATTGATGGCATAACCGCATTTAAATTAATTACATGAAGTGTAAGTATGAAATTTTCCTTTCCAAATTGCAAAAACTAAAATTTAAAATTTATCGTAAAAATTAACATATATTTTAAACGATTTTAAGAAACATTTGTAAATTATATTTTTGTGAAGCGTTCAAACAAAAATAAACAATAAAATATTTTTCTATTTAATAGCAAAACATTTGACGATGAAAAGGAAAATGCGGGTTTGAAAATGGGCTTTGCCATGCTATTTTCATAATAACATATTTTTATTATGAATAATAAATTTACATACAATATATACAGTCTTAAATTTATTCATAATATTTTTGAGAATctgagactgccaaggcacacaggggataggn + hh`XSSSTddhh\\\]hhhhhhhhhbbbbhhghhhbbZZZZhhhhhhhhhhhhhhhhhhhhhhhhheZZUUUcchhhhhhhhhhhhhhhhhhhddXSSSQQSS__UUUbb[[acc`\LLLLLQ[KKKKUTXNNOO\\\WbhhhZ]]\\ggZZhhhhhhbb__^^^hhh____hb^UUUghccbh^a^^bb[ddPPPPPaSaccbaZ\_aVVV]NNNNL\RQR^SQRKKKN\PKKKKLYSdZ^^dhhhhhbbbbh]ZZZhhhhhhh[[__^\NNNNV\`XXXWW[[SSTThdddhhhhhhhhhhhhh[XXXghhhhhhhhhhh^^^^^hhhhhhhhhhhb`bZTTTRXdhhhhhhhhhhhhhhhhggXXXgggh`\`ddee_\MMMMM`c___ccddddehhhZZZXVVeebbb_QSSSX^ecc@ scikit-bio-0.5.9/skbio/io/format/tests/data/longreads_as_sanger.fastq000066400000000000000000000203041446255456000257150ustar00rootroot00000000000000@FSRRS4401BE7HA [length=395] [gc=36.46] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=95] tcagTTAAGATGGGATAATATCCTCAGATTGCGTGATGAACTTTGTTCTGGTGGAGGAGAAGGAAGTGCATTCGACGTATGCCCGTTTGTCGATATTTGtatttaaagtaatccgtcacaaatcagtgacataaatattatttagatttcgggagcaactttatttattccacaagcaggtttaaattttaaatttaaattattgcagaagactttaaattaacctcgttgtcggagtcatttgttcggttattggtcgaaagtaaccncgggaagtgccgaaaactaacaaacaaaagaagatagtgaaattttaattaaaanaaatagccaaacgtaactaactaaaacggacccgtcgaggaactgccaacggacgacacagggagtagnnn + FFFDDDDDDDA666?688FFHGGIIIIIIIIIIIIIIIIIIHHHIIIIIIIIIGHGFFFFF====DFFFFFFFFFFFFFFD???:3104/76=:5...4.3,,,366////4<;!!! @FSRRS4401BRRTC [length=145] [gc=38.62] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=74] tcagCCAGCAATTCCGACTTAATTGTTCTTCTTCCATCATTCATCTCGACTAACAGTTCTACGATTAATGAGTTTGGCtttaatttgttgttcattattgtcacaattacactactgagactgccaaggcacncagggataggnn + FFFFFFFFFDDDDFFFFGFDDDDBAAAAA=<4444@@B=555:BBBBB@@?8:8<<;;;;9944/!/4,,,57855!! @FSRRS4401B64ST [length=382] [gc=40.58] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=346] tcagTTTTCTTAAATTACTTGAATCTGTTGAAGTGGATGTCCACTTTTGTATGCCAAATATGCCCAGCGTATACGATCTTGGCCACATCTCCACATAATCATCAGTCGGATGCAAAAAGCGATTAAACTAAAAATGAATGCGTTTTTAGATGAGTAAATAGGTAATACTTTGTTTAAATAATAAATGTCACAAACAGAACGCGGATTACAGTACCTGAAAATAGTTGTACTGTATCTGTGCCGGCACTTCCTCGGCCCTGAGAAGTTGTCCCGTTGTTTCCATTCGCACCATCCAATGGCCAAAGTTTGCGAAGAATCTGTTCCGTTCCATTACCAATTGTTTTTCCATGctgagactgccaaggcacacaggggataggnn + IIIICCCCI??666IIIIIIIIIIIIIIIIIIIIIIIIIIIIII6666IAIIIII???IIIICCCIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII66333EICE::338=/----,8=>>??:2-////7>CEEIEIHHHIIIIIIIIIE;;9911199B???IBCHIIIIIIHHHIIHHHIIIIIIIIIIIIIIIIIIBBCCIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIGGGIIIIIIIIID?===DIIIHHHIIIIIIIIIHHHIIIIIIIIIIHHHIHHHIIIIIIIIIIIIIIIIIIIIII?>;9988==5----.@@AEGIIIIIIIIIHH????EIIIFF999;EIIBB!! @FSRRS4401EJ0YH [length=381] [gc=48.29] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=343] tcagTTTTTGGAGAATTCCGTCAGGGACGGCATGGCATATTTGTGGGTTCGGCACGGCGTCCTGGCCAAGAAGAAGAAGACGAATTAGCCCGTTAATTTAATGACACCTTCCCCAATTTTGCAGCAATGATTGGTTCATTCTTGGCGGTGCGTTTTTGTGCTTCGTCGAATTGTTGGCCATTTTGGTCCACCGGCCATCATCTTTACGCTATCCGACTGATTGGAAATCACCGCCTAGCATTTTGCCGAAGATTGTTGCGTTGTACGGCCATGTGCTGATTGTTTACATTGGCATTCTTGGCAATTTGTCCTTGGTCGGCTTTGACGGCAAATTTGCGGTGTTAAGTctgagactgccaaggcacacagggggatagggnn + IIII?????IIIIIIIIIIIIIIHHHIIIIIIIIIIIIIHHHIIHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHIIIIIHHHIIIIIIIIIIIAAAAII>>>>IIIIIIIIIIIIIIIIIIIIIIIIIIEEIEE;33333D7IIIIIIIIIIIIIIIIIIIIICC@@HHIIIIIIIIIIIIIIIIHHHIIIIIIIIIIIIIIIIIIIHHHIIIIIIIIIIIIIBBBBIHCDCHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHIIIHHCCDIIIIIIHHHIICCCH=CCIIIIIIIIIGGGIIIIIIHHHHHHIIIIIIIIIIIIIIIHHHIIHHE??>>?EFEE?/////;:80--!! @FSRRS4401BK0IB [length=507] [gc=49.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=208] tcagTTGACCGGCGTTGTGTAACAATAATTCATTATTCTGAGACGATGCCAATGTAATCGACGGTTTATGCCCAATTATTCCCATCTATGCTTAACTGATCAAATACTATTTGCATTACGTCACGAAATTGCGCGAACACCGCCGGCCGACAATAATTTATACCGGACATACCGGAGTTGATGGTAATCGGTAAAGAGTTTTATTTAATTATntattatcnctattaattattgttancaacaatgtgcacgctntgccgcccgccgccgccgtgtcggtaggaccccggacggacccggacccggttcgggtacccgttttcgggttcccggaaccgtttttcgggtacccggttttttcggggggccccccggtaaaaaaccggggaaccccctaaaacgggtaaacgtaccgtaagggaccccctaaacgggggccccgaaaaaccgggacccaaaccggggggaaacggttaaaggggggggaagtaggngnnnnnnnnnnnn + FFFA@@FFFFFFFFFFHHB:::@BFFFFGGHIHIIIIIIIIIIIIIIIIIIIIIIIFFFFFFFFF?=BA@11188011<<88;?AABDDC???DDAAAADA666D?DDD=====AA>?>><<<=<11188<>?@@11142::DDA???DFFFFFFFFFFFFFBAAAA<<0000.22=////8,--111111!23--/24!37:6666<;822/..4!46521177553.-.23!231121112,,-,,211==5------,12,,,,,,-,,,-1,,,,-,,155--,,,,13111.,,,,,,,,++111..11..1,,,,,,,,,+3,,,,,--22-----//----55//**/--22--**,,,,**,,,,,,.1.,*,,,,***,,,,,,,,,,,,,,,,,,,,,,,),,-,,,,,,),,,,,**//.),,,///,,,,,,,,,,,.))33---,,,,,,,,,,(0,,,!.!!!!!!!!!!!! @FSRRS4401ARCCB [length=258] [gc=46.90] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=193] tcagTTATTGCAGTCGTTCCGCGCCATCGCCGGTAACCGTCCGCGTGTTATTCTGTGTATCGGCCAACCTTCGTATAACTTCGTATAATGTATGCTATACGAAGTTATTACGATCTATACCGGCGAAACTCAGCCGAAAGGTCTCGCGGTAGAGCCTATGAGCTGCCCGACCGATGCATTTAAATTTCCGGGGATCGtcgctgatctgagactgccaaaggcacactagggggataggnnnnnnnnnnnnnnnnnnnn + FFF<8::@DFFFFFFFGGFDCAAAAAB@@000046<;66322366762243348<<=??4445::>ABAAA@<<==B=:555:BBD??=BDDDDFFFCCCCCCCFFCDDDFFFFFDBAA==88880004><<<99688;889<889?BBBBA=???DDBBB@@??88889---237771,,,,,,,,--1152<<00158A@><<<<<43277711,,,--37===75,----34666!!!!!!!!!!!!!!!!!!!! @FSRRS4401CM938 [length=453] [gc=44.15] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=418] tcagGTTTTAAATCGCTTTCCAAGGAATTTGAGTCTAAATCCGGTGGATCCCATCAGTACAAATGCGGCGACAAGGCCGTGAAAACACTGCTTAATTCTTTGCACTTTTTGGCCACCTTTTTGGAAATGTTGTTTTGTGTTCTCAAAATTTTCCATCTCAGAACAAACATTCCATCGGGCTGATGTTGTGGCTTTTGGCGCGCGAAGTGCTGCTACTGCGCGGCAAAATCAGTCGCCAGACCGGTTTTGTTGTGGACGACAAAGTGATCATGCCTGACTTGTACTTCTACCGCGATCCGCAAGCGCGAATTGGTCACATAGTTATAGAATTTTTGAGCCTTTTTCTTGACATAAAAAGTGTGGTTTTAAAAATTTCCTGGCAGGACCCACGCCAACGTTCAGGAATAATATCTTTTAAAAAGctgagactgccaaggcacacaggggataggn + IIIIICC>>666IIIICCCIIIIIIIIHHHIIIIIG666IIIIIIIIIIHHHIIIIIIIICCCIIIIIIIIIIIIIIIIII@@@@IIIIIIIIIIIIIHHHIIII???=;IIEEI:://///7544:?IBB72244E8EECEBC=@@@@@@@HHIIIIIIIIIIBBBIIIIIIIIIHHHIIIIIIIIIIIIICCCCIIIIIIIIIIIIIIIIIIIIIIIIIIII6666DEIIHEB??D@777772222D89EEIIIIIIIHHHIIIIIIIIHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHIIIIIIIIIIIIIII==?==IIIII???=;I63DDD82--,,,38==::----,,---+++33066;@6380008/:889<:BGIIIIIIIIIFE?@C<<7999EEEEEE@@@@EEEEE! @FSRRS4401EQLIK [length=411] [gc=34.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=374] tcagTTTAATTTGGTGCTTCCTTTCAATTCCTTAGTTTAAACTTGGCACTGAAGTCTCGCATTTATAACTAGAGCCCGGATTTTAGAGGCTAAAAAGTTTTCCAGATTTCAAAATTTATTTCGAAACTATTTTTCTGATTGTGATGTGACGGATTTCTAAATTAAATCGAAATGATGTGTATTGAACTTAACAAGTGATTTTTATCAGATTTTGTCAATGAATAAATTTTAATTTAAATCTCTTTCTAACACTTTCATGATTAAAATCTAACAAAGCGCGACCAGTATGTGAGAAGAGCAAAAACAACAAAAAGTGCTAGCACTAAAGAAGGTTCGAACCCAACACATAACGTAAGAGTTACCGGGAAGAAAACCACTctgagactgccaaggcacacagggggataggnn + III?666??HHHIIIIIIIIIGGGIIIIIIIIIIIGGGHHHIIIIIIIIIIIIIIIIIIIIGGGIIIIIIIIIIHHHIII@@@@IIIIEIE111100----22?=8---:-------,,,,33---5:3,----:1BBEEEHIIIIIIIIIIIB??A122000...:?=024GIIIIIIIIIIIIIIIIIIECCHHB=//-,,21??<5-002=6FBB?:9<=11/4444//-//77??GEIEEHIACCIIIHHHIIIIIIICCCAIIIHHHHHHIIIIIIIIIIIIIIIIIIIIIIEE1//--822;----.777@EIIIIII???IIIIIIIIIIIHHHIIIIIIIIIIIIIIIIIIII994227775555AE;IEEEEEIIIII??9755>@==:3,,,,,33336!! @FSRRS4401AOV6A [length=309] [gc=22.98] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=273] tcagTTTTCAAATTTTCCGAAATTTGCTGTTTGGTAGAAGGCAAATTATTTGATTGAATTTTGTATTTATTTAAAACAATTTATTTTAAAATAATAATTTTCCATTGACTTTTTACATTTAATTGATTTTATTATGCATTTTATATTTGTTTTCTAAATATTCGTTTGCAAACTCACGTTGAAATTGTATTAAACTCGAAATTAGAGTTTTTGAAATTAATTTTTATGTAGCATAATATTTTAAACATATTGGAATTTTATAAAACATTATATTTTTctgagactgccaaggcacacagggggataggn + IIIICCCCI;;;CCCCIII???HHHIIIIHHHIIIIIIIIIIHHHIIIHHHIIIIIII@@@@IFICCCICAA;;;;ED?B@@D66445555<<>AAIIIIIIII;;;::III???CCCIII;;;;IFFIIIIICCCBIBIEEDC4444?4BBBE?EIIICHHII;;;HIIIIIIHH;;;HHIIIII;;;IIIIHHHIIIIII>>??>IEEBGG::1111/46FBFBB?=;=A?97771119:EAAADDBD7777=/111122DA@@B68;;;I8HHIIIII;;;;?>IECCCB/////;745=! @FSRRS4401EG0ZW [length=424] [gc=23.82] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=389] tcagTTTTGATCTTTTAATAATGAATTTTAATGTGTTAAAATGATTGCATTGATGGCATAACCGCATTTAAATTAATTACATGAAGTGTAAGTATGAAATTTTCCTTTCCAAATTGCAAAAACTAAAATTTAAAATTTATCGTAAAAATTAACATATATTTTAAACGATTTTAAGAAACATTTGTAAATTATATTTTTGTGAAGCGTTCAAACAAAAATAAACAATAAAATATTTTTCTATTTAATAGCAAAACATTTGACGATGAAAAGGAAAATGCGGGTTTGAAAATGGGCTTTGCCATGCTATTTTCATAATAACATATTTTTATTATGAATAATAAATTTACATACAATATATACAGTCTTAAATTTATTCATAATATTTTTGAGAATctgagactgccaaggcacacaggggataggn + IIA94445EEII===>IIIIIIIIICCCCIIHIIICC;;;;IIIIIIIIIIIIIIIIIIIIIIIIIF;;666DDIIIIIIIIIIIIIIIIIIIEE94442244@@666CC<>==HH;;IIIIIICC@@???III@@@@IC?666HIDDCI?B??CC////-=323?423,,,/=1,,,,-:4E;??EIIIIICCCCI>;;;IIIIIII<<@@?=////7=A99988<<4455IEEEIIIIIIIIIIIII<999HIIIIIIIIIII?????IIIIIIIIIIICAC;55539EIIIIIIIIIIIIIIIIHH999HHHIA=AEEFF@=.....AD@@@DDEEEEFIII;;;977FFCCC@24449?FDD! scikit-bio-0.5.9/skbio/io/format/tests/data/longreads_original_sanger.fastq000066400000000000000000000223721446255456000271250ustar00rootroot00000000000000@FSRRS4401BE7HA [length=395] [gc=36.46] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=95] tcagTTAAGATGGGATAATATCCTCAGATTGCGTGATGAACTTTGTTCTGGTGGAGGAGAAGGAAGTGCATTCGACGTAT GCCCGTTTGTCGATATTTGtatttaaagtaatccgtcacaaatcagtgacataaatattatttagatttcgggagcaact ttatttattccacaagcaggtttaaattttaaatttaaattattgcagaagactttaaattaacctcgttgtcggagtca tttgttcggttattggtcgaaagtaaccncgggaagtgccgaaaactaacaaacaaaagaagatagtgaaattttaatta aaanaaatagccaaacgtaactaactaaaacggacccgtcgaggaactgccaacggacgacacagggagtagnnn +FSRRS4401BE7HA [length=395] [gc=36.46] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=95] FFFDDDDDDDA666?688FFHGGIIIIIIIIIIIIIIIIIIHHHIIIIIIIIIGHGFFFFF====DFFFFFFFFFFFFFF D???:3104/76=:5...4.3,,,366////4<;!!! @FSRRS4401BRRTC [length=145] [gc=38.62] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=74] tcagCCAGCAATTCCGACTTAATTGTTCTTCTTCCATCATTCATCTCGACTAACAGTTCTACGATTAATGAGTTTGGCtt taatttgttgttcattattgtcacaattacactactgagactgccaaggcacncagggataggnn +FSRRS4401BRRTC [length=145] [gc=38.62] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=74] FFFFFFFFFDDDDFFFFGFDDDDBAAAAA=<4444@@B=555:BBBBB@@?8:8<<;;;;9944/!/4,,,57855!! @FSRRS4401B64ST [length=382] [gc=40.58] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=346] tcagTTTTCTTAAATTACTTGAATCTGTTGAAGTGGATGTCCACTTTTGTATGCCAAATATGCCCAGCGTATACGATCTT GGCCACATCTCCACATAATCATCAGTCGGATGCAAAAAGCGATTAAACTAAAAATGAATGCGTTTTTAGATGAGTAAATA GGTAATACTTTGTTTAAATAATAAATGTCACAAACAGAACGCGGATTACAGTACCTGAAAATAGTTGTACTGTATCTGTG CCGGCACTTCCTCGGCCCTGAGAAGTTGTCCCGTTGTTTCCATTCGCACCATCCAATGGCCAAAGTTTGCGAAGAATCTG TTCCGTTCCATTACCAATTGTTTTTCCATGctgagactgccaaggcacacaggggataggnn +FSRRS4401B64ST [length=382] [gc=40.58] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=346] IIIICCCCI??666IIIIIIIIIIIIIIIIIIIIIIIIIIIIII6666IAIIIII???IIIICCCIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII66333EICE::338=/----,8=>>??:2-////7>CEEIEIHHHII IIIIIIIE;;9911199B???IBCHIIIIIIHHHIIHHHIIIIIIIIIIIIIIIIIIBBCCIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIGGGIIIIIIIIID?===DIIIHHHIIIIIIIIIHHHIIIIIIIIIIHHHIHHHIIIIIIIIIIII IIIIIIIIII?>;9988==5----.@@AEGIIIIIIIIIHH????EIIIFF999;EIIBB!! @FSRRS4401EJ0YH [length=381] [gc=48.29] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=343] tcagTTTTTGGAGAATTCCGTCAGGGACGGCATGGCATATTTGTGGGTTCGGCACGGCGTCCTGGCCAAGAAGAAGAAGA CGAATTAGCCCGTTAATTTAATGACACCTTCCCCAATTTTGCAGCAATGATTGGTTCATTCTTGGCGGTGCGTTTTTGTG CTTCGTCGAATTGTTGGCCATTTTGGTCCACCGGCCATCATCTTTACGCTATCCGACTGATTGGAAATCACCGCCTAGCA TTTTGCCGAAGATTGTTGCGTTGTACGGCCATGTGCTGATTGTTTACATTGGCATTCTTGGCAATTTGTCCTTGGTCGGC TTTGACGGCAAATTTGCGGTGTTAAGTctgagactgccaaggcacacagggggatagggnn +FSRRS4401EJ0YH [length=381] [gc=48.29] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=343] IIII?????IIIIIIIIIIIIIIHHHIIIIIIIIIIIIIHHHIIHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIHHHIIIIIHHHIIIIIIIIIIIAAAAII>>>>IIIIIIIIIIIIIIIIIIIIIIIIIIEEIEE;33333D7I IIIIIIIIIIIIIIIIIIIICC@@HHIIIIIIIIIIIIIIIIHHHIIIIIIIIIIIIIIIIIIIHHHIIIIIIIIIIIII BBBBIHCDCHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHIIIHHCCDIIIIIIHHHIICCCH=CCIIIIIIIII GGGIIIIIIHHHHHHIIIIIIIIIIIIIIIHHHIIHHE??>>?EFEE?/////;:80--!! @FSRRS4401BK0IB [length=507] [gc=49.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=208] tcagTTGACCGGCGTTGTGTAACAATAATTCATTATTCTGAGACGATGCCAATGTAATCGACGGTTTATGCCCAATTATT CCCATCTATGCTTAACTGATCAAATACTATTTGCATTACGTCACGAAATTGCGCGAACACCGCCGGCCGACAATAATTTA TACCGGACATACCGGAGTTGATGGTAATCGGTAAAGAGTTTTATTTAATTATntattatcnctattaattattgttanca acaatgtgcacgctntgccgcccgccgccgccgtgtcggtaggaccccggacggacccggacccggttcgggtacccgtt ttcgggttcccggaaccgtttttcgggtacccggttttttcggggggccccccggtaaaaaaccggggaaccccctaaaa cgggtaaacgtaccgtaagggaccccctaaacgggggccccgaaaaaccgggacccaaaccggggggaaacggttaaagg ggggggaagtaggngnnnnnnnnnnnn +FSRRS4401BK0IB [length=507] [gc=49.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=208] FFFA@@FFFFFFFFFFHHB:::@BFFFFGGHIHIIIIIIIIIIIIIIIIIIIIIIIFFFFFFFFF?=BA@11188011<< 88;?AABDDC???DDAAAADA666D?DDD=====AA>?>><<<=<11188<>?@@1114 2::DDA???DFFFFFFFFFFFFFBAAAA<<0000.22=////8,--111111!23--/24!37:6666<;822/..4!46 521177553.-.23!231121112,,-,,211==5------,12,,,,,,-,,,-1,,,,-,,155--,,,,13111.,, ,,,,,,++111..11..1,,,,,,,,,+3,,,,,--22-----//----55//**/--22--**,,,,**,,,,,,.1., *,,,,***,,,,,,,,,,,,,,,,,,,,,,,),,-,,,,,,),,,,,**//.),,,///,,,,,,,,,,,.))33---,, ,,,,,,,,(0,,,!.!!!!!!!!!!!! @FSRRS4401ARCCB [length=258] [gc=46.90] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=193] tcagTTATTGCAGTCGTTCCGCGCCATCGCCGGTAACCGTCCGCGTGTTATTCTGTGTATCGGCCAACCTTCGTATAACT TCGTATAATGTATGCTATACGAAGTTATTACGATCTATACCGGCGAAACTCAGCCGAAAGGTCTCGCGGTAGAGCCTATG AGCTGCCCGACCGATGCATTTAAATTTCCGGGGATCGtcgctgatctgagactgccaaaggcacactagggggataggnn nnnnnnnnnnnnnnnnnn +FSRRS4401ARCCB [length=258] [gc=46.90] [flows=800] [phred_min=0] [phred_max=38] [trimmed_length=193] FFF<8::@DFFFFFFFGGFDCAAAAAB@@000046<;66322366762243348<<=??4445::>ABAAA@<<==B=:5 55:BBD??=BDDDDFFFCCCCCCCFFCDDDFFFFFDBAA==88880004><<<99688;889<889?BBBBA=???DDBB B@@??88889---237771,,,,,,,,--1152<<00158A@><<<<<43277711,,,--37===75,----34666!! !!!!!!!!!!!!!!!!!! @FSRRS4401CM938 [length=453] [gc=44.15] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=418] tcagGTTTTAAATCGCTTTCCAAGGAATTTGAGTCTAAATCCGGTGGATCCCATCAGTACAAATGCGGCGACAAGGCCGT GAAAACACTGCTTAATTCTTTGCACTTTTTGGCCACCTTTTTGGAAATGTTGTTTTGTGTTCTCAAAATTTTCCATCTCA GAACAAACATTCCATCGGGCTGATGTTGTGGCTTTTGGCGCGCGAAGTGCTGCTACTGCGCGGCAAAATCAGTCGCCAGA CCGGTTTTGTTGTGGACGACAAAGTGATCATGCCTGACTTGTACTTCTACCGCGATCCGCAAGCGCGAATTGGTCACATA GTTATAGAATTTTTGAGCCTTTTTCTTGACATAAAAAGTGTGGTTTTAAAAATTTCCTGGCAGGACCCACGCCAACGTTC AGGAATAATATCTTTTAAAAAGctgagactgccaaggcacacaggggataggn +FSRRS4401CM938 [length=453] [gc=44.15] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=418] IIIIICC>>666IIIICCCIIIIIIIIHHHIIIIIG666IIIIIIIIIIHHHIIIIIIIICCCIIIIIIIIIIIIIIIII I@@@@IIIIIIIIIIIIIHHHIIII???=;IIEEI:://///7544:?IBB72244E8EECEBC=@@@@@@@HHIIIIII IIIIBBBIIIIIIIIIHHHIIIIIIIIIIIIICCCCIIIIIIIIIIIIIIIIIIIIIIIIIIII6666DEIIHEB??D@7 77772222D89EEIIIIIIIHHHIIIIIIIIHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHIIIIII IIIIIIIII==?==IIIII???=;I63DDD82--,,,38==::----,,---+++33066;@6380008/:889<:BGII IIIIIIIFE?@C<<7999EEEEEE@@@@EEEEE! @FSRRS4401EQLIK [length=411] [gc=34.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=374] tcagTTTAATTTGGTGCTTCCTTTCAATTCCTTAGTTTAAACTTGGCACTGAAGTCTCGCATTTATAACTAGAGCCCGGA TTTTAGAGGCTAAAAAGTTTTCCAGATTTCAAAATTTATTTCGAAACTATTTTTCTGATTGTGATGTGACGGATTTCTAA ATTAAATCGAAATGATGTGTATTGAACTTAACAAGTGATTTTTATCAGATTTTGTCAATGAATAAATTTTAATTTAAATC TCTTTCTAACACTTTCATGATTAAAATCTAACAAAGCGCGACCAGTATGTGAGAAGAGCAAAAACAACAAAAAGTGCTAG CACTAAAGAAGGTTCGAACCCAACACATAACGTAAGAGTTACCGGGAAGAAAACCACTctgagactgccaaggcacacag ggggataggnn +FSRRS4401EQLIK [length=411] [gc=34.31] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=374] III?666??HHHIIIIIIIIIGGGIIIIIIIIIIIGGGHHHIIIIIIIIIIIIIIIIIIIIGGGIIIIIIIIIIHHHIII @@@@IIIIEIE111100----22?=8---:-------,,,,33---5:3,----:1BBEEEHIIIIIIIIIIIB??A122 000...:?=024GIIIIIIIIIIIIIIIIIIECCHHB=//-,,21??<5-002=6FBB?:9<=11/4444//-//77??G EIEEHIACCIIIHHHIIIIIIICCCAIIIHHHHHHIIIIIIIIIIIIIIIIIIIIIIEE1//--822;----.777@EII IIII???IIIIIIIIIIIHHHIIIIIIIIIIIIIIIIIIII994227775555AE;IEEEEEIIIII??9755>@==:3, ,,,,33336!! @FSRRS4401AOV6A [length=309] [gc=22.98] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=273] tcagTTTTCAAATTTTCCGAAATTTGCTGTTTGGTAGAAGGCAAATTATTTGATTGAATTTTGTATTTATTTAAAACAAT TTATTTTAAAATAATAATTTTCCATTGACTTTTTACATTTAATTGATTTTATTATGCATTTTATATTTGTTTTCTAAATA TTCGTTTGCAAACTCACGTTGAAATTGTATTAAACTCGAAATTAGAGTTTTTGAAATTAATTTTTATGTAGCATAATATT TTAAACATATTGGAATTTTATAAAACATTATATTTTTctgagactgccaaggcacacagggggataggn +FSRRS4401AOV6A [length=309] [gc=22.98] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=273] IIIICCCCI;;;CCCCIII???HHHIIIIHHHIIIIIIIIIIHHHIIIHHHIIIIIII@@@@IFICCCICAA;;;;ED?B @@D66445555<<>AAIIIIIIII;;;::III???CCCIII;;;;IFFIIIIICCCBIBIEEDC4444?4BBBE? EIIICHHII;;;HIIIIIIHH;;;HHIIIII;;;IIIIHHHIIIIII>>??>IEEBGG::1111/46FBFBB?=;=A?97 771119:EAAADDBD7777=/111122DA@@B68;;;I8HHIIIII;;;;?>IECCCB/////;745=! @FSRRS4401EG0ZW [length=424] [gc=23.82] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=389] tcagTTTTGATCTTTTAATAATGAATTTTAATGTGTTAAAATGATTGCATTGATGGCATAACCGCATTTAAATTAATTAC ATGAAGTGTAAGTATGAAATTTTCCTTTCCAAATTGCAAAAACTAAAATTTAAAATTTATCGTAAAAATTAACATATATT TTAAACGATTTTAAGAAACATTTGTAAATTATATTTTTGTGAAGCGTTCAAACAAAAATAAACAATAAAATATTTTTCTA TTTAATAGCAAAACATTTGACGATGAAAAGGAAAATGCGGGTTTGAAAATGGGCTTTGCCATGCTATTTTCATAATAACA TATTTTTATTATGAATAATAAATTTACATACAATATATACAGTCTTAAATTTATTCATAATATTTTTGAGAATctgagac tgccaaggcacacaggggataggn +FSRRS4401EG0ZW [length=424] [gc=23.82] [flows=800] [phred_min=0] [phred_max=40] [trimmed_length=389] IIA94445EEII===>IIIIIIIIICCCCIIHIIICC;;;;IIIIIIIIIIIIIIIIIIIIIIIIIF;;666DDIIIIII IIIIIIIIIIIIIEE94442244@@666CC<>==HH;;IIIIIICC @@???III@@@@IC?666HIDDCI?B??CC////-=323?423,,,/=1,,,,-:4E ;??EIIIIICCCCI>;;;IIIIIII<<@@?=////7=A99988<<4455IEEEIIIIIIIIIIIII<999HIIIIIIIII II?????IIIIIIIIIIICAC;55539EIIIIIIIIIIIIIIIIHH999HHHIA=AEEFF@=.....AD@@@DDEEEEFI II;;;977FFCCC@24449?FDD! scikit-bio-0.5.9/skbio/io/format/tests/data/misc_dna_as_illumina.fastq000066400000000000000000000013771446255456000260600ustar00rootroot00000000000000@FAKE0007 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0008 Original version has mixed case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) gTcatAGcgTcatAGcgTcatAGcgTcatAGcgTcatAGcg + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0009 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) tcagtcagtcagtcagtcagtcagtcagtcagtcagtcagt + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0010 Original version has mixed case ambiguous DNA and PHRED scores of 40, 30, 20, 10 (cycled) gatcrywsmkhbvdnGATCRYWSMKHBVDN + h^TJh^TJh^TJh^TJh^TJh^TJh^TJh^ scikit-bio-0.5.9/skbio/io/format/tests/data/misc_dna_as_sanger.fastq000066400000000000000000000013771446255456000255250ustar00rootroot00000000000000@FAKE0007 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0008 Original version has mixed case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) gTcatAGcgTcatAGcgTcatAGcgTcatAGcgTcatAGcg + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0009 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) tcagtcagtcagtcagtcagtcagtcagtcagtcagtcagt + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0010 Original version has mixed case ambiguous DNA and PHRED scores of 40, 30, 20, 10 (cycled) gatcrywsmkhbvdnGATCRYWSMKHBVDN + I?5+I?5+I?5+I?5+I?5+I?5+I?5+I? scikit-bio-0.5.9/skbio/io/format/tests/data/misc_dna_original_sanger.fastq000066400000000000000000000013771446255456000267260ustar00rootroot00000000000000@FAKE0007 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0008 Original version has mixed case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) gTcatAGcgTcatAGcgTcatAGcgTcatAGcgTcatAGcg + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0009 Original version has lower case unambiguous DNA with PHRED scores from 0 to 40 inclusive (in that order) tcagtcagtcagtcagtcagtcagtcagtcagtcagtcagt + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0010 Original version has mixed case ambiguous DNA and PHRED scores of 40, 30, 20, 10 (cycled) gatcrywsmkhbvdnGATCRYWSMKHBVDN + I?5+I?5+I?5+I?5+I?5+I?5+I?5+I? scikit-bio-0.5.9/skbio/io/format/tests/data/misc_rna_as_illumina.fastq000066400000000000000000000014061446255456000260670ustar00rootroot00000000000000@FAKE0011 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ACGUACGUACGUACGUACGUACGUACGUACGUACGUACGUA + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0012 Original version has mixed case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) gUcauAGcgUcauAGcgUcauAGcgUcauAGcgUcauAGcg + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0013 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ucagucagucagucagucagucagucagucagucagucagu + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh @FAKE0014 Original version has mixed case ambiguous RNA with PHRED scores from 35 to 40 inclusive (cycled) gaucrywsmkhbvdnGAUCRYWSMKHBVDN + cdefghcdefghcdefghcdefghcdefgh scikit-bio-0.5.9/skbio/io/format/tests/data/misc_rna_as_sanger.fastq000066400000000000000000000014061446255456000255340ustar00rootroot00000000000000@FAKE0011 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ACGUACGUACGUACGUACGUACGUACGUACGUACGUACGUA + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0012 Original version has mixed case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) gUcauAGcgUcauAGcgUcauAGcgUcauAGcgUcauAGcg + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0013 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ucagucagucagucagucagucagucagucagucagucagu + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0014 Original version has mixed case ambiguous RNA with PHRED scores from 35 to 40 inclusive (cycled) gaucrywsmkhbvdnGAUCRYWSMKHBVDN + DEFGHIDEFGHIDEFGHIDEFGHIDEFGHI scikit-bio-0.5.9/skbio/io/format/tests/data/misc_rna_original_sanger.fastq000066400000000000000000000014061446255456000267350ustar00rootroot00000000000000@FAKE0011 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ACGUACGUACGUACGUACGUACGUACGUACGUACGUACGUA + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0012 Original version has mixed case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) gUcauAGcgUcauAGcgUcauAGcgUcauAGcgUcauAGcg + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0013 Original version has lower case unambiguous RNA with PHRED scores from 0 to 40 inclusive (in that order) ucagucagucagucagucagucagucagucagucagucagu + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI @FAKE0014 Original version has mixed case ambiguous RNA with PHRED scores from 35 to 40 inclusive (cycled) gaucrywsmkhbvdnGAUCRYWSMKHBVDN + DEFGHIDEFGHIDEFGHIDEFGHIDEFGHI scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_L&L_CA_data_scores000066400000000000000000000005371446255456000263230ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 Species 3 2 Species1 0.408869425742 0.0695518116298 Species2 -0.1153860437 -0.299767683538 Species3 -0.309967102571 0.187391917117 Site 3 2 Site1 -0.848956053187 0.882764759014 Site2 -0.220458650578 -1.34482000302 Site3 1.66697179591 0.470324389808 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_PCoA_sample_data_3_scores000066400000000000000000000030601446255456000277420ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.15704469605 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error1000066400000000000000000000107311446255456000242430ustar00rootroot000000000000000.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error10000066400000000000000000000004621446255456000243230ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 Species 3 2 Species1 0.408869425742 0.0695518116298 Species2 -0.1153860437 -0.299767683538 Species3 -0.309967102571 0.187391917117 Site 3 2 Site1 -0.848956053187 Site2 -0.220458650578 Site3 1.66697179591 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error11000066400000000000000000000107421446255456000243260ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Bro2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error12000066400000000000000000000030411446255456000243210ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.15704469605 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error13000066400000000000000000000030411446255456000243220ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.15704469605 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error14000066400000000000000000000030601446255456000243240ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.15704469605 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 0 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error15000066400000000000000000000030071446255456000243260ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.15704469605 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 Biplot Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error16000066400000000000000000000107431446255456000243340ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 0 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error17000066400000000000000000000106631446255456000243360ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 -0.994016563505 0.0609533148724 0.184352565909 -0.974867543612 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error18000066400000000000000000000030421446255456000243300ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 8 0.267573832777 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error19000066400000000000000000000004601446255456000243320ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 Species 3 1 Species1 0.408869425742 Species2 -0.1153860437 Species3 -0.309967102571 Site 3 2 Site1 -0.848956053187 0.882764759014 Site2 -0.220458650578 -1.34482000302 Site3 1.66697179591 0.470324389808 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error2000066400000000000000000000107131446255456000242440ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error20000066400000000000000000000004621446255456000243240ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 Species 3 2 Species1 0.408869425742 0.0695518116298 Species2 -0.1153860437 -0.299767683538 Species3 -0.309967102571 0.187391917117 Site 3 1 Site1 -0.848956053187 Site2 -0.220458650578 Site3 1.66697179591 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error21000066400000000000000000000000121446255456000243140ustar00rootroot00000000000000Eigvals 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error22000066400000000000000000000000221446255456000243160ustar00rootroot00000000000000Eigvals 1 0.12345 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error23000066400000000000000000000000521446255456000243220ustar00rootroot00000000000000Eigvals 1 0.12345 Proportion explained 1 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error24000066400000000000000000000001131446255456000243210ustar00rootroot00000000000000Eigvals 1 0.12345 Proportion explained 1 0.6789 Species 2 1 foo 0.987654 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error3000066400000000000000000000107271446255456000242520ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error4000066400000000000000000000107311446255456000242460ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error5000066400000000000000000000107311446255456000242470ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error6000066400000000000000000000107161446255456000242530ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error7000066400000000000000000000001011446255456000242370ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error8000066400000000000000000000030421446255456000242470ustar00rootroot00000000000000Eigvals 9 0.512367260461 0.300719094427 0.267912066004 0.208988681078 0.19169895326 0.16054234528 0.15017695712 0.122457748167 0.0 Proportion explained 9 0.267573832777 0.139911863774 0.109140272454 0.100111048503 0.0838401161912 0.0784269939011 0.0639511763509 0.0 Species 0 0 Site 9 9 PC.636 -0.258465461183 0.173999546883 0.0382875792552 -0.19447750562 0.0831176020844 0.262430333201 -0.0231636392235 -0.0184794039581 0.0 PC.635 -0.271001135391 -0.0185951319063 -0.0864841926349 0.118064245315 -0.198808358437 -0.0211723599535 -0.191024027565 0.155646592377 0.0 PC.356 0.235077898175 0.0962519254489 -0.345792726714 -0.00320862577619 -0.0963777675519 0.0457025386953 0.185472813286 0.0404093971793 0.0 PC.481 0.0261407664325 -0.0111459676533 0.147660603015 0.29087660853 0.203945472801 0.0619712384758 0.101641328709 0.105690998719 0.0 PC.354 0.285007552283 -0.0192549888483 0.0623263375385 0.138126799852 -0.104798602423 0.0951720730628 -0.129636097542 -0.220687170372 0.0 PC.593 0.204636326241 -0.139361150932 0.291513819623 -0.181566786821 -0.159580132715 -0.0246412130162 0.0866252404441 0.0996221476871 0.0 PC.355 0.233482403212 0.225257974068 -0.0188623096268 -0.107729981831 0.177108999572 -0.192905835151 -0.149819471408 0.0383549037465 0.0 PC.607 -0.0949631911323 -0.420974802495 -0.154869454869 -0.0898427509281 0.152618194488 -0.0334232691501 -0.0251224777303 -0.0508988536409 0.0 PC.634 -0.359915158638 0.113822595435 0.0662203444138 0.0297579972788 -0.0572254078183 -0.193133506163 0.145026331031 -0.149658611738 0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_error9000066400000000000000000000004601446255456000242510ustar00rootroot00000000000000Eigvals 2 0.0961330159181 0.0409418140138 Proportion explained 0 Species 3 2 Species1 0.408869425742 Species2 -0.1153860437 Species3 -0.309967102571 Site 3 2 Site1 -0.848956053187 0.882764759014 Site2 -0.220458650578 -1.34482000302 Site3 1.66697179591 0.470324389808 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_example2_scores000066400000000000000000000065041446255456000261270ustar00rootroot00000000000000Eigvals 7 25.8979540892 14.9825779819 8.93784077262 6.13995623072 1.68070536498 0.57735026919 0.275983624351 Proportion explained 0 Species 6 7 Species0 1.38198713901 -1.71496426179 0.632272455288 0.00712898231575 0.120512431133 -0.0723104306179 -0.00815886062344 Species1 0.919178380672 -1.25430767906 -1.1787426896 -0.00712898231576 -0.120512431133 -0.0723104306179 0.00815886062344 Species2 3.39897234869 0.446168315515 0.406691610423 0.749336668014 0.0793892812781 7.37971401683e-17 0.0329418170936 Species3 2.52353261895 0.446932822723 -0.413412046583 -0.639449029945 -0.0640330006084 3.40602185392e-17 0.0335491330226 Species4 -0.53155341411 -1.34263985744 0.464155649196 -0.412041388665 0.198336195195 7.37971401683e-17 0.00604836743485 Species5 -0.288618167117 -0.571491852197 -0.406527290424 0.206020694333 -0.0991680975973 -1.13534061797e-17 -0.00302418371743 Site 10 7 Site0 -1.48848983495 2.12675623514 0.727805340002 -0.227234564008 -3.8413042049 -2.30487725273 0.260061682644 Site1 -1.5541678384 2.37027298265 0.475523558326 1.58712629997e-16 1.39853499536e-15 4.60975450547 -1.41948353841e-14 Site2 -1.51048450796 2.19216727329 0.00519576944216 0.227234564008 3.8413042049 -2.30487725273 -0.260061682644 Site3 -0.872786591764 -2.6271708553 2.68871897067 -1.97005774092 0.948287641474 -2.0356145959e-14 0.0289185344306 Site4 2.97228673755 0.322310666722 2.50294580667 3.50264153009 0.489477682536 -1.25529566747e-14 2.11938273809 Site5 -0.879968888341 -2.19620098193 0.710888524695 -0.656685913639 0.316095880491 -4.47835211098e-15 0.00963951147681 Site6 2.64194948913 0.390104638861 -0.086230363198 -0.211189359785 -0.298609965083 -3.88762243221e-15 -4.5952222736 Site7 -0.887151184918 -1.76523110855 -1.26694192128 0.656685913639 -0.316095880491 1.21458337555e-14 -0.00963951147698 Site8 2.47314610115 0.521252384288 -2.51313331808 -3.29145217031 -0.190867717454 1.65563320466e-14 2.4758395355 Site9 -0.894333481495 -1.33426123517 -3.24477236725 1.97005774092 -0.948287641474 3.0262803659e-14 -0.0289185344308 Biplot 4 3 0.422650019179 -0.559142585857 -0.713250678211 0.988495963777 0.150787422017 -0.0117848614073 -0.556516618887 0.817599992718 0.147714267459 -0.404079676685 -0.9058434809 -0.127150316558 Site constraints 10 7 Site0 -1.48131076339 2.07063239013 1.42061063192 -0.227234564008 -3.8413042049 -2.30487725273 0.260061682644 Site1 -1.51771406044 2.22973216369 0.402841555923 1.58712629997e-16 1.39853499536e-15 4.60975450547 -1.41948353841e-14 Site2 -1.55411735749 2.38883193726 -0.61492752007 0.227234564008 3.8413042049 -2.30487725273 -0.260061682644 Site3 -0.774350145471 -2.45801536594 2.77528052969 -1.97005774092 0.948287641474 -2.0356145959e-14 0.0289185344306 Site4 2.76860070338 0.0930230161545 2.00339886045 3.50264153009 0.489477682536 -1.25529566747e-14 2.11938273809 Site5 -0.847156739577 -2.13981581881 0.739742377702 -0.656685913639 0.316095880491 -4.47835211098e-15 0.00963951147681 Site6 2.69579410928 0.41122256329 -0.0321392915344 -0.211189359785 -0.298609965083 -3.88762243221e-15 -4.5952222736 Site7 -0.919963333683 -1.82161627167 -1.29579577429 0.656685913639 -0.316095880491 1.21458337555e-14 -0.00963951147698 Site8 2.62298751517 0.729422110426 -2.06767744352 -3.29145217031 -0.190867717454 1.65563320466e-14 2.4758395355 Site9 -0.992769927788 -1.50341672453 -3.33133392627 1.97005774092 -0.948287641474 3.0262803659e-14 -0.0289185344308 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_example3_scores000066400000000000000000000107431446255456000261300ustar00rootroot00000000000000Eigvals 9 0.366135830393 0.186887643052 0.0788466514249 0.082287840501 0.0351348475787 0.0233265839374 0.0099048981912 0.00122461669234 0.000417454724117 Proportion explained 0 Species 9 9 Species0 0.110350890177 0.282399990052 -0.203028976154 -0.00192462284409 -0.082232863384 0.0857314258364 -0.0122038907184 -0.0425198793666 0.00466719926338 Species1 0.141359038961 0.303495645402 0.395441211576 -0.14126625534 -0.0268859204718 0.143253061936 0.0430260301697 0.0476377655759 -0.00228172378295 Species2 -1.01552204222 0.0958317865043 -0.198262718034 -0.104801030067 0.130025239749 0.0244045261332 0.0464701211285 0.0269279200532 0.0350103177576 Species3 -1.03620650502 0.109624974112 0.220984718362 0.223640072997 -0.243745876054 -0.0259064859794 -0.0534088909011 -0.0315611195993 0.0256448427552 Species4 1.05371722248 0.537178749104 -0.438075060322 0.223480553581 -0.323948461806 0.124644870822 -0.119275907223 0.0416254660329 -0.0381955235096 Species5 0.998558655 0.573960582723 0.679918103399 -0.389963380717 0.299077945999 0.328451006171 0.21215881857 -0.0829871883001 -0.0439653996462 Species6 0.255245719879 -0.178168259149 -0.204127155429 0.433397565801 0.0707099230629 -0.18817306522 0.126908756045 0.0044937289123 -0.0122511718244 Species7 0.146555872394 -0.857362497037 -0.0152499051659 0.0527604990862 0.354475793915 -0.0416813697787 -0.199011239586 -0.00213723187073 -0.00782946141667 Species8 0.413705102117 -0.707948964322 0.21569736034 -0.690314241725 -0.148431001217 -0.334251868558 -0.00628707445028 -0.00364123416731 -0.0122722164511 Site 10 9 Site0 0.710587311248 -3.08166800613 0.219651379947 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.584771352278 -3.00669301091 -0.947448656768 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.762734278287 -3.15258603503 2.13924426714 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.11230735331 1.07150585141 -1.87527740873 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.979116769996 -0.0603144289026 -0.696277367656 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.04322560423 0.459426970165 -0.639802790578 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -0.954490118162 -0.0847021660539 0.132509124411 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.947268764751 -0.108370567311 0.526107182587 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.14808173207 0.490449274267 0.478353666755 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 1.03291557934 1.0350490304 2.74691777314 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 Biplot 3 3 -0.169746767979 0.63069090084 0.760769036049 -0.994016563505 0.0609533148724 -0.0449369418179 0.184352565909 -0.974867543612 0.0309865007541 Site constraints 10 9 Site0 0.692138797603 -3.08053663489 -0.328747278055 -1.24528801163 -1.07293546227 -0.506241907472 0.244126652455 -3.63164833508 1.16311896657 Site1 0.664559513865 -3.06214571808 0.230249303805 2.69965142856 2.13682885838 0.813520011254 0.471530333182 0.908423015086 -1.34724387844 Site2 0.636980230127 -3.04375480127 0.789245885666 -3.1162748358 -2.30660936925 -0.698929858809 -1.39062619586 4.84117591747 0.562102984837 Site3 1.10887578995 0.500396915484 -1.55606822404 0.666370241998 -1.10153224699 1.43517552491 -1.10619960297 0.0137029328454 -0.0371803939101 Site4 -0.970016224052 0.0654867737684 -1.1206070781 -0.612646703308 0.983006619615 0.315662442163 0.574110232297 0.328630035672 0.868027697443 Site5 1.05371722248 0.537178749104 -0.438075060322 0.287156643872 -0.573935423877 -1.44980634943 1.70166994063 0.306164261447 -0.442115969758 Site6 -1.02517479153 0.102268607388 -0.00261391438256 -0.42143341064 -0.111552348931 -0.394242454835 -0.673963982894 -0.379018566362 -1.7472502885 Site7 0.998558655 0.573960582723 0.679918103399 -0.00565282365567 1.26272400228 -1.06565692165 -1.46326596729 -0.154459216567 0.778139732463 Site8 -1.080333359 0.139050441007 1.11537924934 1.17015870919 -1.00599224074 0.0735071441404 0.0860462673715 0.0417647558417 0.935819560428 Site9 0.943400087524 0.610742416342 1.79791126712 -1.28083971649 0.363002636972 1.98647950015 1.05356145232 -0.24813142226 -0.463165215106 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_CCA_site000066400000000000000000000043651446255456000275130ustar00rootroot000000000000007.105873112480000087e-01 -3.081668006130000137e+00 2.196513799469999861e-01 -1.245288011630000025e+00 -1.072935462270000029e+00 -5.062419074720000411e-01 2.441266524550000094e-01 -3.631648335079999956e+00 1.163118966569999913e+00 5.847713522780000339e-01 -3.006693010909999852e+00 -9.474486567680000526e-01 2.699651428560000177e+00 2.136828858379999918e+00 8.135200112539999751e-01 4.715303331819999944e-01 9.084230150859999853e-01 -1.347243878440000042e+00 7.627342782870000226e-01 -3.152586035030000122e+00 2.139244267140000044e+00 -3.116274835800000087e+00 -2.306609369249999819e+00 -6.989298588090000486e-01 -1.390626195859999914e+00 4.841175917470000201e+00 5.621029848370000526e-01 1.112307353310000080e+00 1.071505851409999988e+00 -1.875277408729999928e+00 6.663702419979999902e-01 -1.101532246989999964e+00 1.435175524910000000e+00 -1.106199602970000084e+00 1.370293284539999927e-02 -3.718039391010000139e-02 -9.791167699959999471e-01 -6.031442890259999801e-02 -6.962773676560000125e-01 -6.126467033079999736e-01 9.830066196150000213e-01 3.156624421629999899e-01 5.741102322969999783e-01 3.286300356719999982e-01 8.680276974430000125e-01 1.043225604230000103e+00 4.594269701650000037e-01 -6.398027905780000468e-01 2.871566438720000169e-01 -5.739354238770000283e-01 -1.449806349429999974e+00 1.701669940629999989e+00 3.061642614469999857e-01 -4.421159697579999937e-01 -9.544901181620000230e-01 -8.470216605390000486e-02 1.325091244109999900e-01 -4.214334106400000057e-01 -1.115523489309999949e-01 -3.942424548349999780e-01 -6.739639828939999466e-01 -3.790185663619999867e-01 -1.747250288500000082e+00 9.472687647509999698e-01 -1.083705673110000045e-01 5.261071825869999552e-01 -5.652823655669999593e-03 1.262724002279999924e+00 -1.065656921650000033e+00 -1.463265967289999914e+00 -1.544592165670000128e-01 7.781397324629999446e-01 -1.148081732070000083e+00 4.904492742670000238e-01 4.783536667550000177e-01 1.170158709190000090e+00 -1.005992240739999932e+00 7.350714414039999367e-02 8.604626737149999316e-02 4.176475584170000199e-02 9.358195604279999635e-01 1.032915579340000001e+00 1.035049030399999959e+00 2.746917773139999852e+00 -1.280839716490000058e+00 3.630026369720000257e-01 1.986479500149999966e+00 1.053561452320000091e+00 -2.481314222600000119e-01 -4.631652151060000056e-01 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_CCA_site_constraints000066400000000000000000000043631446255456000321400ustar00rootroot000000000000006.921387976030000111e-01 -3.080536634890000069e+00 -3.287472780549999807e-01 -1.245288011630000025e+00 -1.072935462270000029e+00 -5.062419074720000411e-01 2.441266524550000094e-01 -3.631648335079999956e+00 1.163118966569999913e+00 6.645595138650000067e-01 -3.062145718080000023e+00 2.302493038049999996e-01 2.699651428560000177e+00 2.136828858379999918e+00 8.135200112539999751e-01 4.715303331819999944e-01 9.084230150859999853e-01 -1.347243878440000042e+00 6.369802301270000022e-01 -3.043754801269999977e+00 7.892458856659999578e-01 -3.116274835800000087e+00 -2.306609369249999819e+00 -6.989298588090000486e-01 -1.390626195859999914e+00 4.841175917470000201e+00 5.621029848370000526e-01 1.108875789949999913e+00 5.003969154840000044e-01 -1.556068224039999892e+00 6.663702419979999902e-01 -1.101532246989999964e+00 1.435175524910000000e+00 -1.106199602970000084e+00 1.370293284539999927e-02 -3.718039391010000139e-02 -9.700162240520000534e-01 6.548677376839999453e-02 -1.120607078099999931e+00 -6.126467033079999736e-01 9.830066196150000213e-01 3.156624421629999899e-01 5.741102322969999783e-01 3.286300356719999982e-01 8.680276974430000125e-01 1.053717222479999993e+00 5.371787491039999862e-01 -4.380750603219999983e-01 2.871566438720000169e-01 -5.739354238770000283e-01 -1.449806349429999974e+00 1.701669940629999989e+00 3.061642614469999857e-01 -4.421159697579999937e-01 -1.025174791530000018e+00 1.022686073880000046e-01 -2.613914382559999906e-03 -4.214334106400000057e-01 -1.115523489309999949e-01 -3.942424548349999780e-01 -6.739639828939999466e-01 -3.790185663619999867e-01 -1.747250288500000082e+00 9.985586549999999617e-01 5.739605827229999901e-01 6.799181033990000511e-01 -5.652823655669999593e-03 1.262724002279999924e+00 -1.065656921650000033e+00 -1.463265967289999914e+00 -1.544592165670000128e-01 7.781397324629999446e-01 -1.080333358999999938e+00 1.390504410070000085e-01 1.115379249340000101e+00 1.170158709190000090e+00 -1.005992240739999932e+00 7.350714414039999367e-02 8.604626737149999316e-02 4.176475584170000199e-02 9.358195604279999635e-01 9.434000875239999528e-01 6.107424163419999941e-01 1.797911267119999934e+00 -1.280839716490000058e+00 3.630026369720000257e-01 1.986479500149999966e+00 1.053561452320000091e+00 -2.481314222600000119e-01 -4.631652151060000056e-01 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_CCA_species000066400000000000000000000040211446255456000301670ustar00rootroot000000000000001.103508901770000050e-01 2.823999900520000050e-01 -2.030289761540000071e-01 -1.924622844089999901e-03 -8.223286338400000173e-02 8.573142583640000480e-02 -1.220389071839999943e-02 -4.251987936659999689e-02 4.667199263379999581e-03 1.413590389609999942e-01 3.034956454020000249e-01 3.954412115759999846e-01 -1.412662553400000076e-01 -2.688592047179999903e-02 1.432530619359999868e-01 4.302603016969999694e-02 4.763776557589999988e-02 -2.281723782949999797e-03 -1.015522042219999976e+00 9.583178650430000667e-02 -1.982627180340000017e-01 -1.048010300670000061e-01 1.300252397489999878e-01 2.440452613319999894e-02 4.647012112849999849e-02 2.692792005320000098e-02 3.501031775760000270e-02 -1.036206505020000002e+00 1.096249741120000065e-01 2.209847183620000100e-01 2.236400729970000056e-01 -2.437458760539999991e-01 -2.590648597939999853e-02 -5.340889090110000070e-02 -3.156111959929999711e-02 2.564484275520000078e-02 1.053717222479999993e+00 5.371787491039999862e-01 -4.380750603219999983e-01 2.234805535809999966e-01 -3.239484618060000098e-01 1.246448708220000007e-01 -1.192759072229999939e-01 4.162546603290000202e-02 -3.819552350960000314e-02 9.985586549999999617e-01 5.739605827229999901e-01 6.799181033990000511e-01 -3.899633807169999855e-01 2.990779459990000055e-01 3.284510061709999817e-01 2.121588185699999907e-01 -8.298718830010000380e-02 -4.396539964619999852e-02 2.552457198790000215e-01 -1.781682591490000023e-01 -2.041271554290000068e-01 4.333975658009999732e-01 7.070992306289999862e-02 -1.881730652199999909e-01 1.269087560449999874e-01 4.493728912300000086e-03 -1.225117182439999959e-02 1.465558723940000030e-01 -8.573624970369999598e-01 -1.524990516589999970e-02 5.276049908620000090e-02 3.544757939150000037e-01 -4.168136977870000315e-02 -1.990112395860000050e-01 -2.137231870730000108e-03 -7.829461416669999951e-03 4.137051021170000120e-01 -7.079489643220000517e-01 2.156973603400000050e-01 -6.903142417249999996e-01 -1.484310012170000082e-01 -3.342518685579999871e-01 -6.287074450280000053e-03 -3.641234167310000193e-03 -1.227221645110000009e-02 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_PCoA_site000066400000000000000000000040161446255456000277000ustar00rootroot00000000000000-2.584654611830000115e-01 1.739995468830000114e-01 3.828757925520000216e-02 -1.944775056199999907e-01 8.311760208439999964e-02 2.624303332010000100e-01 -2.316363922349999951e-02 -1.847940395810000053e-02 0.000000000000000000e+00 -2.710011353910000143e-01 -1.859513190630000118e-02 -8.648419263489999509e-02 1.180642453149999965e-01 -1.988083584370000101e-01 -2.117235995349999941e-02 -1.910240275650000041e-01 1.556465923769999871e-01 0.000000000000000000e+00 2.350778981749999941e-01 9.625192544890000257e-02 -3.457927267140000205e-01 -3.208625776189999966e-03 -9.637776755190000100e-02 4.570253869529999902e-02 1.854728132859999878e-01 4.040939717929999814e-02 0.000000000000000000e+00 2.614076643250000040e-02 -1.114596765330000058e-02 1.476606030150000026e-01 2.908766085300000248e-01 2.039454728010000051e-01 6.197123847580000150e-02 1.016413287090000006e-01 1.056909987190000066e-01 0.000000000000000000e+00 2.850075522830000097e-01 -1.925498884830000035e-02 6.232633753849999708e-02 1.381267998519999929e-01 -1.047986024230000007e-01 9.517207306279999723e-02 -1.296360975420000061e-01 -2.206871703720000022e-01 0.000000000000000000e+00 2.046363262410000050e-01 -1.393611509319999942e-01 2.915138196229999923e-01 -1.815667868209999980e-01 -1.595801327149999893e-01 -2.464121301619999829e-02 8.662524044409999902e-02 9.962214768709999613e-02 0.000000000000000000e+00 2.334824032120000059e-01 2.252579740679999942e-01 -1.886230962680000151e-02 -1.077299818309999935e-01 1.771089995719999921e-01 -1.929058351509999880e-01 -1.498194714080000045e-01 3.835490374650000339e-02 0.000000000000000000e+00 -9.496319113230000664e-02 -4.209748024950000223e-01 -1.548694548690000006e-01 -8.984275092809999863e-02 1.526181944879999863e-01 -3.342326915010000038e-02 -2.512247773030000172e-02 -5.089885364090000058e-02 0.000000000000000000e+00 -3.599151586379999990e-01 1.138225954350000069e-01 6.622034441379999470e-02 2.975799727879999829e-02 -5.722540781830000312e-02 -1.931335061630000127e-01 1.450263310309999887e-01 -1.496586117379999914e-01 0.000000000000000000e+00 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_RDA_site000066400000000000000000000033721446255456000275300ustar00rootroot00000000000000-1.488489834949999979e+00 2.126756235139999784e+00 7.278053400020000341e-01 -2.272345640079999896e-01 -3.841304204900000130e+00 -2.304877252729999881e+00 2.600616826439999807e-01 -1.554167838399999946e+00 2.370272982649999971e+00 4.755235583260000176e-01 1.587126299970000006e-16 1.398534995359999983e-15 4.609754505469999764e+00 -1.419483538409999981e-14 -1.510484507960000000e+00 2.192167273289999940e+00 5.195769442159999842e-03 2.272345640079999896e-01 3.841304204900000130e+00 -2.304877252729999881e+00 -2.600616826439999807e-01 -8.727865917639999749e-01 -2.627170855300000163e+00 2.688718970670000097e+00 -1.970057740919999967e+00 9.482876414740000204e-01 -2.035614595899999968e-14 2.891853443059999931e-02 2.972286737550000169e+00 3.223106667219999832e-01 2.502945806670000106e+00 3.502641530090000010e+00 4.894776825359999917e-01 -1.255295667470000031e-14 2.119382738090000107e+00 -8.799688883409999551e-01 -2.196200981930000129e+00 7.108885246949999681e-01 -6.566859136389999740e-01 3.160958804910000142e-01 -4.478352110979999834e-15 9.639511476809999382e-03 2.641949489129999940e+00 3.901046388609999971e-01 -8.623036319799999572e-02 -2.111893597850000026e-01 -2.986099650829999730e-01 -3.887622432210000342e-15 -4.595222273600000129e+00 -8.871511849180000464e-01 -1.765231108550000094e+00 -1.266941921279999939e+00 6.566859136389999740e-01 -3.160958804910000142e-01 1.214583375549999947e-14 -9.639511476980000548e-03 2.473146101150000220e+00 5.212523842880000258e-01 -2.513133318079999956e+00 -3.291452170309999925e+00 -1.908677174539999966e-01 1.655633204660000023e-14 2.475839535500000022e+00 -8.943334814950000267e-01 -1.334261235170000059e+00 -3.244772367249999956e+00 1.970057740919999967e+00 -9.482876414740000204e-01 3.026280365900000082e-14 -2.891853443079999905e-02 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_RDA_site_constraints000066400000000000000000000033731446255456000321600ustar00rootroot00000000000000-1.481310763390000007e+00 2.070632390130000111e+00 1.420610631920000033e+00 -2.272345640079999896e-01 -3.841304204900000130e+00 -2.304877252729999881e+00 2.600616826439999807e-01 -1.517714060439999901e+00 2.229732163690000046e+00 4.028415559230000276e-01 1.587126299970000006e-16 1.398534995359999983e-15 4.609754505469999764e+00 -1.419483538409999981e-14 -1.554117357490000018e+00 2.388831937259999982e+00 -6.149275200699999555e-01 2.272345640079999896e-01 3.841304204900000130e+00 -2.304877252729999881e+00 -2.600616826439999807e-01 -7.743501454710000065e-01 -2.458015365940000141e+00 2.775280529689999831e+00 -1.970057740919999967e+00 9.482876414740000204e-01 -2.035614595899999968e-14 2.891853443059999931e-02 2.768600703380000194e+00 9.302301615449999617e-02 2.003398860449999930e+00 3.502641530090000010e+00 4.894776825359999917e-01 -1.255295667470000031e-14 2.119382738090000107e+00 -8.471567395769999953e-01 -2.139815818809999826e+00 7.397423777020000202e-01 -6.566859136389999740e-01 3.160958804910000142e-01 -4.478352110979999834e-15 9.639511476809999382e-03 2.695794109279999962e+00 4.112225632900000094e-01 -3.213929153439999686e-02 -2.111893597850000026e-01 -2.986099650829999730e-01 -3.887622432210000342e-15 -4.595222273600000129e+00 -9.199633336829999841e-01 -1.821616271669999954e+00 -1.295795774289999924e+00 6.566859136389999740e-01 -3.160958804910000142e-01 1.214583375549999947e-14 -9.639511476980000548e-03 2.622987515170000172e+00 7.294221104260000255e-01 -2.067677443520000047e+00 -3.291452170309999925e+00 -1.908677174539999966e-01 1.655633204660000023e-14 2.475839535500000022e+00 -9.927699277879999951e-01 -1.503416724530000081e+00 -3.331333926270000134e+00 1.970057740919999967e+00 -9.482876414740000204e-01 3.026280365900000082e-14 -2.891853443079999905e-02 scikit-bio-0.5.9/skbio/io/format/tests/data/ordination_exp_Ordination_RDA_species000066400000000000000000000020561446255456000302150ustar00rootroot000000000000001.381987139010000032e+00 -1.714964261790000055e+00 6.322724552880000237e-01 7.128982315749999785e-03 1.205124311330000031e-01 -7.231043061790000392e-02 -8.158860623439999696e-03 9.191783806719999728e-01 -1.254307679060000069e+00 -1.178742689599999949e+00 -7.128982315759999598e-03 -1.205124311330000031e-01 -7.231043061790000392e-02 8.158860623439999696e-03 3.398972348690000089e+00 4.461683155150000246e-01 4.066916104230000051e-01 7.493366680140000069e-01 7.938928127809999347e-02 7.379714016829999409e-17 3.294181709360000099e-02 2.523532618950000028e+00 4.469328227230000006e-01 -4.134120465830000146e-01 -6.394490299449999693e-01 -6.403300060840000363e-02 3.406021853920000005e-17 3.354913302260000008e-02 -5.315534141100000110e-01 -1.342639857440000029e+00 4.641556491959999975e-01 -4.120413886650000079e-01 1.983361951950000091e-01 7.379714016829999409e-17 6.048367434850000432e-03 -2.886181671170000018e-01 -5.714918521970000498e-01 -4.065272904239999874e-01 2.060206943329999929e-01 -9.916809759729999785e-02 -1.135340617969999987e-17 -3.024183717430000123e-03 scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_dna_3_seqs000066400000000000000000000001201446255456000241760ustar00rootroot000000000000003 13 d1 ..ACC-GTTG G.. d2 TTACCGGT-G GCC d3 .-ACC-GTTG C-- scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_empty_line_after_header000066400000000000000000000001061446255456000305270ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_empty_line_before_header000066400000000000000000000001061446255456000306700ustar00rootroot00000000000000 2 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_empty_line_between_seqs000066400000000000000000000001061446255456000306020ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_header_too_long000066400000000000000000000001201446255456000270150ustar00rootroot000000000000002 20 extra_text foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_header_too_short000066400000000000000000000001041446255456000272170ustar00rootroot00000000000000 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_no_header000066400000000000000000000001001446255456000256070ustar00rootroot00000000000000foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_seq_too_long000066400000000000000000000001071446255456000263620ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.CGA bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_seq_too_short000066400000000000000000000001031446255456000265560ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_too_few_seqs000066400000000000000000000000451446255456000263700ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.C scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_too_many_seqs000066400000000000000000000001051446255456000265500ustar00rootroot000000000000001 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_zero_seq_len000066400000000000000000000000171446255456000263570ustar00rootroot000000000000001 0 scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_invalid_zero_seqs000066400000000000000000000000041446255456000257000ustar00rootroot000000000000000 1 scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_single_seq_long000066400000000000000000000000521446255456000253330ustar00rootroot000000000000001 24 foo ..ACC-GTTG G..AATGC.C ---- scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_single_seq_short000066400000000000000000000000201446255456000255260ustar00rootroot000000000000001 1 - scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_two_chunks000066400000000000000000000001051446255456000243460ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_variable_length_ids000066400000000000000000000001521446255456000261510ustar00rootroot000000000000006 6 .-ACGT a TGCA-. bb .ACGT- 1 TGCA-. abcdefghijAAAAAA ab def42ijGGGGGG scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_varied_whitespace_in_seqs000066400000000000000000000001211446255456000273670ustar00rootroot000000000000002 20 foo ..ACC -GTTG G..AA TGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_whitespace_in_header_1000066400000000000000000000001521446255456000265360ustar00rootroot00000000000000 2 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_whitespace_in_header_2000066400000000000000000000001261446255456000265400ustar00rootroot00000000000000 2 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/phylip_whitespace_in_header_3000066400000000000000000000001461446255456000265430ustar00rootroot000000000000002 20 foo ..ACC-GTTG G..AATGC.C bar TTACCGGT-G GCCTA-GCAT scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_filter000066400000000000000000000003311446255456000246220ustar00rootroot00000000000000sanger 1 3 34 -30 30 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 3 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_lane000066400000000000000000000003311446255456000242540ustar00rootroot00000000000000sanger 1 -3 34 12 -2 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_read000066400000000000000000000003311446255456000242500ustar00rootroot00000000000000sanger 1 3 34 -30 30 0 4 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_tile000066400000000000000000000003301446255456000242710ustar00rootroot00000000000000sanger 1 5 -4 12 -2 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_x000066400000000000000000000003521446255456000236070ustar00rootroot00000000000000sanger 1 3 34 if_you're_a_shepherd 42 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_invalid_y000066400000000000000000000003731446255456000236130ustar00rootroot00000000000000sanger 1 3 34 42 and_a_snake_is_killing_all_your_sheep 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_multi_seq_illumina1.3000066400000000000000000000003421446255456000257470ustar00rootroot00000000000000illumina 1 3 34 -30 30 0 1 ACG....ACGTAC ruBBBBrBCEFGH 1 illumina 1 3 34 30 -30 0 1 CGGGCATTGCA CGGGCasdGCA 0 illumina 1 3 35 -30 30 0 2 ACGTA.AATAAAC geTaAafhwqAAf 1 illumina 1 3 35 30 -30 0 3 CATTTAGGA.TGCA tjflkAFnkKghvM 0 scikit-bio-0.5.9/skbio/io/format/tests/data/qseq_single_seq_sanger000066400000000000000000000003311446255456000253170ustar00rootroot00000000000000sanger 1 3 34 -30 30 0 2 ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC ;;>@BCEFGHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_2_seqs_defaults000066400000000000000000000001051446255456000247020ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_defaults000066400000000000000000000001441446255456000247060ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_defaults_desc_mismatch000066400000000000000000000001311446255456000275650ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 42 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_defaults_extra000066400000000000000000000001741446255456000261140ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 42 >s_e_q_4 desc 4 42 42 42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_defaults_id_mismatch000066400000000000000000000001311446255456000272430ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_42 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_defaults_length_mismatch000066400000000000000000000001411446255456000301310ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_3_seqs_non_defaults000066400000000000000000000001511446255456000255560ustar00rootroot00000000000000>s*e*q*1 desc+1 1234 0 0 2 >s*e*q*2 desc+2 1 11 111 11112 >s*e*q*3 desc+3 12345 678909 999999 4242424242 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_5_blanks_start_of_file000066400000000000000000000003321446255456000262170ustar00rootroot00000000000000 >seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_5_ws_lines_start_of_file000066400000000000000000000004211446255456000265670ustar00rootroot00000000000000 >seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_6_blanks_start_of_file000066400000000000000000000003331446255456000262210ustar00rootroot00000000000000 >seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_6_ws_lines_start_of_file000066400000000000000000000004351446255456000265750ustar00rootroot00000000000000 >seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_blank_lines_between_records000066400000000000000000000003371446255456000273410ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_blanks_end_of_file000066400000000000000000000003341446255456000254060ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_description_newline_replacement_empty_str000066400000000000000000000001501446255456000323500ustar00rootroot00000000000000>proteinseq detaileddescription with newlines 42 42 255 255 42 42 42 42 42 43 >foo 0 1 2 3 4 5 6 7 8 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_description_newline_replacement_multi_char000066400000000000000000000002121446255456000324500ustar00rootroot00000000000000>proteinseq :-)detailed:-)description with new:-):-)lines:-):-):-) 42 42 255 255 42 42 42 42 42 43 >foo :-):-):-):-) 0 1 2 3 4 5 6 7 8 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_description_newline_replacement_none000066400000000000000000000001641446255456000312660ustar00rootroot00000000000000>proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 >foo 0 1 2 3 4 5 6 7 8 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_id_whitespace_replacement_empty_str000066400000000000000000000000261446255456000311160ustar00rootroot00000000000000>seq2 42 > a b 1000 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_id_whitespace_replacement_multi_char000066400000000000000000000000721446255456000312200ustar00rootroot00000000000000>>:o>:o>:o>:o>:oseq>:o>:o2>:o 42 >>:o>:o>:o>:o a b 1000 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_id_whitespace_replacement_none000066400000000000000000000000421446255456000300250ustar00rootroot00000000000000> seq 2 42 > a b 1000 1 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_blank_line_after_header000066400000000000000000000001451446255456000301200ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_blank_line_within_seq000066400000000000000000000001461446255456000276620ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_blank_sequence000066400000000000000000000001241446255456000263050ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_legacy_format000066400000000000000000000000571446255456000261470ustar00rootroot00000000000000; legacy-seq-id legacy description 40 30 20 10 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_missing_header000066400000000000000000000000231446255456000263050ustar00rootroot00000000000000seq1 desc1 1 2 3 4 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_missing_qual_scores_first000066400000000000000000000001341446255456000306070ustar00rootroot00000000000000>s_e_q_1 desc 1 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_missing_qual_scores_last000066400000000000000000000001251446255456000304230ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_missing_qual_scores_middle000066400000000000000000000001231446255456000307140ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_qual_scores_float000066400000000000000000000001461446255456000270370ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41.0 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_qual_scores_negative000066400000000000000000000001441446255456000275320ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_qual_scores_over_255000066400000000000000000000001441446255456000272760ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 256 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_qual_scores_string000066400000000000000000000001451446255456000272370ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1a -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_whitespace_line_in_seq000066400000000000000000000001611446255456000300300ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_whitespace_only_sequence000066400000000000000000000001371446255456000304170ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_invalid_ws_line_after_header000066400000000000000000000001601446255456000274570ustar00rootroot00000000000000>s_e_q_1 desc 1 1 2 3 4 >s_e_q_2 desc 2 42 41 39 40 >s_e_q_3 desc 3 100 0 1 -42 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_max_width_1000066400000000000000000000000501446255456000240220ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_max_width_5000066400000000000000000000003251446255456000240330ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_multi_seq000066400000000000000000000003251446255456000236250ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_multi_seq_roundtrip000066400000000000000000000002461446255456000257350ustar00rootroot00000000000000>seq-a a's description 0 1 2 3 4 5 6 7 8 >seq-b b's description 0 1 2 3 4 5 6 7 8 9 10 11 >seq-c c's description 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_prot_seqs_odd_labels000066400000000000000000000002031446255456000260050ustar00rootroot00000000000000> -0000000 0000 01 5 00044 -0 > skbio 1 2 33 123 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_bio_seq_non_defaults000066400000000000000000000000251446255456000273430ustar00rootroot00000000000000>f-o-o b_a_r 1 2 3 4 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_dna_seq_non_defaults000066400000000000000000000000251446255456000273340ustar00rootroot00000000000000>f-o-o b_a_r 0 1 2 3 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_nuc_seq_non_defaults000066400000000000000000000000271446255456000273610ustar00rootroot00000000000000>f-o-o b_a_r 0 1 2 3 4 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_prot_seq_non_defaults000066400000000000000000000000261446255456000275570ustar00rootroot00000000000000>f-o-o b_a_r 42 41 40 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_rna_seq_non_defaults000066400000000000000000000000251446255456000273520ustar00rootroot00000000000000>f-o-o b_a_r 2 3 4 5 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_single_seq000066400000000000000000000000501446255456000237470ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_tabular_msa_different_type000066400000000000000000000001251446255456000272020ustar00rootroot00000000000000> 20 20 21 >rnaseq-1 rnaseq desc 1 10 9 10 >rnaseq-2 rnaseq desc 2 9 99 99 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_ws_lines_between_records000066400000000000000000000005151446255456000267010ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/qual_ws_lines_end_of_file000066400000000000000000000004651446255456000257640ustar00rootroot00000000000000>seq1 desc1 10 20 30 10 0 0 0 255 1 255 >_____seq__2_ 42 > desc3 0 0 0 0 0 0 0 > 55 10 0 99 1 1 8 77 40 10 10 0 > 10 9 8 7 6 >proteinseq detailed description with new lines 42 42 255 255 42 42 42 42 42 43 scikit-bio-0.5.9/skbio/io/format/tests/data/sanger_full_range_as_illumina.fastq000066400000000000000000000010461446255456000277510ustar00rootroot00000000000000@FAKE0001 Original version has PHRED scores from 0 to 93 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC + @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @FAKE0002 Original version has PHRED scores from 93 to 0 inclusive (in that order) CATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@ scikit-bio-0.5.9/skbio/io/format/tests/data/sanger_full_range_as_sanger.fastq000066400000000000000000000010461446255456000274160ustar00rootroot00000000000000@FAKE0001 Original version has PHRED scores from 0 to 93 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @FAKE0002 Original version has PHRED scores from 93 to 0 inclusive (in that order) CATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! scikit-bio-0.5.9/skbio/io/format/tests/data/sanger_full_range_original_sanger.fastq000066400000000000000000000010461446255456000306170ustar00rootroot00000000000000@FAKE0001 Original version has PHRED scores from 0 to 93 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC + !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @FAKE0002 Original version has PHRED scores from 93 to 0 inclusive (in that order) CATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! scikit-bio-0.5.9/skbio/io/format/tests/data/solexa_full_range_original_solexa.fastq000066400000000000000000000007021446255456000306450ustar00rootroot00000000000000@FAKE0003 Original version has Solexa scores from -5 to 62 inclusive (in that order) ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT + ;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @FAKE0004 Original version has Solexa scores from 62 to -5 inclusive (in that order) TGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCA + ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<; scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_all_data_types000066400000000000000000000006241446255456000256530ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF NM Kestrel Gorlick #=GF DT February 11, 2016 #=GF FN Writer test file #=GS seq1 DT February 1, 2016 #=GS seq1 NM Unknown #=GS seq3 DT Unknown seq1 GAGGCCATGCCCAGGTGAAG seq2 ACCTGAGCCACAGTAGAAGT seq3 CCCTTCGCTGGAAATGTATG #=GR seq3 AS CCGAAAGTCGTTCGAAAATG #=GR seq3 SS GGCGAGTCGTTCGAGCTGGC #=GC AS_cons CGTTCGTTCTAACAATTCCA #=GC SS_cons GGCGCTACGACCTACGACCG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_blank_lines000066400000000000000000000000571446255456000251470ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AL ABCD #=GF NM 1234 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_data_only000066400000000000000000000001221446255456000246310ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 ACUCCGACAUGCUCC seq2 UAGUGCCGAACGCUG seq3 GUGUGGGCGUGAUUC // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_different_padding000066400000000000000000000002161446255456000263170ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RC A Runon #=GF RC Comment Without Whitespace #=GF RN [2] #=GF RC A Runon #=GF RC Comment With Whitespace //scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_differing_gc_data_length000066400000000000000000000001061446255456000276210ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 ACGCUUGCAA #=GC AT_cons UGCUUGGCGCAU // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_differing_gr_data_length000066400000000000000000000000761446255456000276460ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 AUCGCCUG #=GR seq1 AL UCGCUUG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_differing_seq_lengths000066400000000000000000000001061446255456000272120ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 AUCCGCUUAC seq2 UGCCUGGAGCG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_duplicate_gc000066400000000000000000000002641446255456000253110ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF ID RCR2 OSF22 TCCTCCCAGTGTCGCCCGGT OSF33 TTTTTTGGTCAAATTAAAGG #=GC SS_cons CAAGGGAAATACTACGGGAC #=GC SS_cons CGGGACTCGTGCGTTGTAGG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_duplicate_gr000066400000000000000000000003031446255456000253220ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF ID CBS #=GF AC PF00571 LFDR2 GGCCTCAGGACGAAGCACGG LFDR3 AATTGTGATCATCTTACAGG #=GR LFDR3 OS TTTTACCAATTGCTGACAGA #=GR LFDR3 OS CCTGGACATCCCCCGCACGG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_duplicate_sequence_names000066400000000000000000000002371446255456000277130ustar00rootroot00000000000000# STOCKHOLM 1.0 ASR132 GGCGUUCCGUUCAGUGCUGG RTF112 GGGCGGUGCUAUGAAAAUAC ASR132 GGCGUUCCGUUCAGUGCUGG TTL879 AGCUAUCUCCGGGCCCUUGG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_duplicate_tree_ids000066400000000000000000000001111446255456000265050ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF TN tree1 #=GF NH ABCD #=GF TN tree1 #=GF NH EFGH // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_extensive000066400000000000000000000012141446255456000246740ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF ID CBS #=GF AC PF00571 #=GF AU Bateman A #=GF SQ 67 #=GS O31698/88-139 OS Bacillus subtilis O83071/192-246 MTCRAQLIAVPRASSLAE..AIACAQKM....RVSRVPVYERS #=GR O83071/192-246 SA 999887756453524252..55152525....36463774777 O31698/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFVCVENDE #=GR O31698/88-139 SS CCCCCCCHHHHHHHHHHH..HEEEEEEE....EEEEEEEEEEH O31699/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFVCVENDE #=GR O31699/88-139 AS ________________*__________________________ #=GR O31699/88-139 IN ____________1______________2__________0____ #=GC SS_cons CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEEEH // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_extensive_mixed000066400000000000000000000012241446255456000260630ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GR O31699/88-139 AS ________________*__________________________ O83071/192-246 MTCRAQLIAVPRASSLAE..AIACAQKM....RVSRVPVYERS #=GF ID CBS #=GR O31698/88-139 SS CCCCCCCHHHHHHHHHHH..HEEEEEEE....EEEEEEEEEEH #=GF AC PF00571 O31698/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFVCVENDE #=GC SS_cons CCCCCHHHHHHHHHHHHH..EEEEEEEE....EEEEEEEEEEH #=GR O31699/88-139 IN ____________1______________2__________0____ #=GS O31698/88-139 OS Bacillus subtilis #=GR O83071/192-246 SA 999887756453524252..55152525....36463774777 O31699/88-139 EVMLTDIPRLHINDPIMK..GFGMVINN......GFVCVENDE #=GF AU Bateman A #=GF SQ 67 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_invalid_data_type000066400000000000000000000000551446255456000263440ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AL ABCD #=GZ NM 1234 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_invalid_nonexistent_gr000066400000000000000000000002671446255456000274450ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF ID ARD RL1255 AAGGGUUAUUUAUAUACUUU RL1332 UGCUAAGAGUGGGGAUGAUU RL1232 GCCACAACCGAUUAGAUAGA #=GR RL1355 AS ACUAUAUACAUAGCUAUAUU // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_invalid_nonexistent_gs000066400000000000000000000001561446255456000274430ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GS AC14 ID ARD2 AC12 AAGGGUUAUUUAUAUACUUU AC13 UGCUAAGAGUGGGGAUGAUU // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_malformed_data_line000066400000000000000000000000301446255456000266230ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_malformed_gc_line000066400000000000000000000000751446255456000263140ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 ATCCGCT #=GC AT_cons // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_malformed_gf_line000066400000000000000000000000331446255456000263110ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AL // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_malformed_gr_line000066400000000000000000000000661446255456000263330ustar00rootroot00000000000000# STOCKHOLM 1.0 seq1 ACGGTCG #=GR seq1 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_malformed_gs_line000066400000000000000000000000531446255456000263300ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GS seq1 AL seq1 ACCTG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_metadata_only000066400000000000000000000001061446255456000255020ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF NM Kestrel Gorlick #=GF DT February 5th, 2016 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_minimal000066400000000000000000000000601446255456000243060ustar00rootroot00000000000000# STOCKHOLM 1.0 0235244 TGTGTCGCAGTTGTCGTTTG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_missing_footer000066400000000000000000000001711446255456000257120ustar00rootroot00000000000000# STOCKHOLM 1.0 0232455 TTATCTTAGCCTCTCTAAGT 0234323 ATCCCACGGAAACAGATGGC 0235244 TGTGTCGCAGTTGTCGTTTG scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_missing_header000066400000000000000000000001541446255456000256450ustar00rootroot000000000000000232455 TTATCTTAGCCTCTCTAAGT 0234323 ATCCCACGGAAACAGATGGC 0235244 TGTGTCGCAGTTGTCGTTTG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_missing_reference_items000066400000000000000000000001021446255456000275450ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RT A Title #=GF RA The Author // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_missing_rn_tag000066400000000000000000000000551446255456000256670ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RL Flagstaff Arizona // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multi_line_tree_no_id000066400000000000000000000000551446255456000272140ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF NH ABCD #=GF NH EFGH // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multi_line_tree_with_id000066400000000000000000000000731446255456000275530ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF TN tree1 #=GF NH ABCD #=GF NH EFGH // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multiple_msa000066400000000000000000000007461446255456000253660ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AC G2134T23 #=GF ID ARD RTC2231 AAGGGUUAUUUAUAUACUUU RTF2124 UGCUAAGAGUGGGGAUGAUU RTH3322 GCCACAACCGAUUAGAUAGA RTB1512 UUAGAAACCGAUGGACCGAA #=GC AC_cons GGGACUGGACAUCUAUUCAG // # STOCKHOLM 1.0 #=GF AC G2134T23 #=GF ID ARD RTC2231 AAGGGUUAUUUAUAUACUUU RTF2124 UGCUAAGAGUGGGGAUGAUU RTH3322 GCCACAACCGAUUAGAUAGA RTB1512 UUAGAAACCGAUGGACCGAA #=GC AC_cons GGGACUGGACAUCUAUUCAG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multiple_multi_line_trees000066400000000000000000000001431446255456000301400ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF TN tree1 #=GF NH ABCD #=GF NH EFGH #=GF TN tree2 #=GF NH IJKL #=GF NH MNOP // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multiple_references000066400000000000000000000004771446255456000267300ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RM 123456789 #=GF RT Title 1 #=GF RA Author 1 #=GF RL Location 1 #=GF RC Comment 1 #=GF RN [2] #=GF RM 987654321 #=GF RT Title 2 #=GF RA Author 2 #=GF RL Location 2 #=GF RC Comment 2 #=GF RN [3] #=GF RM 132465879 #=GF RT Title 3 #=GF RA Author 3 #=GF RL Location 3 #=GF RC Comment 3 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_multiple_trees000066400000000000000000000001441446255456000257200ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF TN tree1 #=GF NH ABCD #=GF TN tree2 #=GF NH EFGH #=GF TN tree3 #=GF NH IJKL // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_no_data000066400000000000000000000000231446255456000242640ustar00rootroot00000000000000# STOCKHOLM 1.0 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_nonstring_labels000066400000000000000000000001561446255456000262310ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF 1.3 2857 #=GS 11214 8 123 11214 ACTG #=GR 11214 1.0 1234 #=GC 25 4321 // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_rna000066400000000000000000000003631446255456000234460ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AC G2134T23 #=GF ID ARD RTC2231 AAGGGUUAUUUAUAUACUUU RTF2124 UGCUAAGAGUGGGGAUGAUU RTH3322 GCCACAACCGAUUAGAUAGA RTB1512 UUAGAAACCGAUGGACCGAA #=GC AC_cons GGGACUGGACAUCUAUUCAG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_gf_no_whitespace000066400000000000000000000002341446255456000274100ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF CC CBS domains are small intracellular modules mostly found #=GF CC in 2 or four copies within a protein. GG1344 ACTGGTTCAATG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_gf_with_whitespace000066400000000000000000000002351446255456000277500ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF CC CBS domains are small intracellular modules mostly found #=GF CC in 2 or four copies within a protein. GG1344 ACTGGTTCAATG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_gs_no_whitespace000066400000000000000000000001271446255456000274260ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GS seq1 LN This is a runon #=GS seq1 LN GS line. seq1 ATCGTTCAGTG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_gs_with_whitespace000066400000000000000000000001301446255456000277570ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GS seq1 LN This is a runon #=GS seq1 LN GS line. seq1 ATCGTTCAGTG // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_references000066400000000000000000000002261446255456000262260ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RM 123456789 #=GF RT A Runon #=GF RT Title #=GF RA The Author #=GF RL A Location #=GF RC A Runon #=GF RC Comment // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_runon_references_mixed000066400000000000000000000002261446255456000274140ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RC A Runon #=GF RM 123456789 #=GF RT A Runon #=GF RA The Author #=GF RT Title #=GF RL A Location #=GF RC Comment // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_single_reference000066400000000000000000000001671446255456000261670ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF RN [1] #=GF RM 123456789 #=GF RT A Title #=GF RA The Author #=GF RL A Location #=GF RC Comment // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_single_tree_with_id000066400000000000000000000000561446255456000266740ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF TN tree1 #=GF NH ABCD // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_single_tree_without_id000066400000000000000000000000401446255456000274150ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF NH ABCD // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_two_of_each_metadata000066400000000000000000000003661446255456000270060ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF NM Kestrel Gorlick #=GF DT February 5th, 2016 #=GS seq1 AL ABCD #=GS seq1 NS 1234 seq1 ACTGACCATGTTCA #=GR seq1 SS CACTACTTGTGACG #=GR seq1 AS TCACATCGGCGATG #=GC SS_cons ______1____2__ #=GC AS_cons __1___1___3___ // scikit-bio-0.5.9/skbio/io/format/tests/data/stockholm_whitespace_only_lines000066400000000000000000000001121446255456000272450ustar00rootroot00000000000000# STOCKHOLM 1.0 #=GF AL ABCD #=GF NM 1234 // scikit-bio-0.5.9/skbio/io/format/tests/data/taxdump_names.dmp000066400000000000000000000022071446255456000242260ustar00rootroot000000000000001 | root | | scientific name | 2 | Bacteria | Bacteria | scientific name | 2 | eubacteria | | genbank common name | 543 | Enterobacteriaceae | | scientific name | 548 | Klebsiella aerogenes | | scientific name | 561 | Escherichia | | scientific name | 562 | "Bacillus coli" Migula 1895 | | authority | 562 | Escherichia coli | | scientific name | 562 | Escherichia/Shigella coli | | equivalent name | 570 | Donovania | | synonym | 570 | Klebsiella | | scientific name | 620 | Shigella | | scientific name | 622 | Shigella dysenteriae | | scientific name | 766 | Rickettsiales | | scientific name | 1224 | Proteobacteria | | scientific name | 1236 | Gammaproteobacteria | | scientific name | 28211 | Alphaproteobacteria | | scientific name | 91347 | Enterobacterales | | scientific name | 118884 | unclassified Gammaproteobacteria | | scientific name | 126792 | Plasmid pPY113 | | scientific name | 131567 | cellular organisms | | scientific name | 585056 | Escherichia coli UMN026 | | scientific name | 1038927 | Escherichia coli O104:H4 | | scientific name | 2580236 | synthetic Escherichia coli Syn61 | | scientific name | scikit-bio-0.5.9/skbio/io/format/tests/data/taxdump_nodes.dmp000066400000000000000000000023411446255456000242320ustar00rootroot000000000000001 | 1 | no rank | | 8 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | | 2 | 131567 | superkingdom | | 0 | 0 | 11 | 0 | 0 | 0 | 0 | 0 | | 543 | 91347 | family | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 548 | 570 | species | KA | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 561 | 543 | genus | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 562 | 561 | species | EC | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 570 | 543 | genus | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 620 | 543 | genus | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 622 | 620 | species | SD | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 766 | 28211 | order | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 1224 | 2 | phylum | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 1236 | 1224 | class | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 28211 | 1224 | class | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 91347 | 1236 | order | | 0 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | 118884 | 1236 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 126792 | 36549 | species | PP | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 131567 | 1 | no rank | | 8 | 1 | 1 | 1 | 0 | 1 | 1 | 0 | | 585056 | 562 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 1038927 | 562 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | | 2580236 | 488338 | species | SE | 7 | 1 | 11 | 1 | 0 | 1 | 0 | 0 | | scikit-bio-0.5.9/skbio/io/format/tests/data/tsv_10_fields000066400000000000000000000002401446255456000232370ustar00rootroot00000000000000buh na de nuh buh KRRGRHRGRBAWAOMPWAMPOWAMP na de nuh de 1 1 1 1 1 1 1 1 1 1 3 3 3 3 3 3 $ 3 3 3 4 4 4 4 4 4 4 % 4 4 4 4 4 4 4 4 4 4 % 4 5 5 5 5 5 5 5 wat 6 ^ scikit-bio-0.5.9/skbio/io/format/tests/data/tsv_8_fields000066400000000000000000000002051446255456000231670ustar00rootroot00000000000000buh na de nuh buh KRRGRHRGRBAWAOMPWAMPOWAMP na de 1 1 1 1 1 1 1 1 3 3 3 3 3 3 $ 3 4 4 4 4 4 4 4 % 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 wat scikit-bio-0.5.9/skbio/io/format/tests/data/whitespace_only000066400000000000000000000000571446255456000240000ustar00rootroot00000000000000 scikit-bio-0.5.9/skbio/io/format/tests/data/wrapping_as_illumina.fastq000066400000000000000000000017031446255456000261230ustar00rootroot00000000000000@SRR014849.50939 EIXKN4201BA2EC length=135 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + Zb^Ld`N\[d`NaZ[aZc]UOKHDA[\YT[_W[aZ\aZ[Zd`SF_WeaUI[Y\[[\\\[\Z\aY`X[[aZ\aZ\d`OY[aY[[\[[e`WPJC^UZ[`X\[R]T_V_W[`[Ga\I`\H[[Q^TVa\Ia\Ic^LY\S @SRR014849.110027 EIXKN4201APUB0 length=131 CTTCAAATGATTCCGGGACTGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTTCGGTTCCAACTCGCCGTCCGAATAATCCGTTCAAAATCTTGGCCTGTCAAAACGACTTTACGACCAGAACGATCCG + \aYY_[FY\T`X^Vd`OY\[[^U_V[R^T[_ZDc^La\HYYO\S[c^Ld`Nc_QAZaZaYaY`XZZ\[aZZ[aZ[aZ[aZY`Z[`ZWeaVJ\[aZaY`X[PY\eaUG[\[[d`OXTUZ[Q\\`W\\\Y_W\ @SRR014849.203935 EIXKN4201B4HU6 length=144 AACCCGTCCCATCAAAGATTTTGGTTGGAACCCGAAAGGGTTTTGAATTCAAACCCCTTTCGGTTCCAACTATTCAATTGTTTAACTTTTTTTAAATTGATGGTCTGTTGGACCATTTGTAATAATCCCCATCGGAATTTCTTT + `Z_ZDVT^YB[[Xd`PZ\d`RDaZaZ`ZaZ_ZDXd`Pd`Pd`RD[aZ`ZWd`Oc_RCd`P\aZ`ZaZaZY\YaZYaY`XYd`O`X[e`WPJEAc^LaZS[YYN[Z\Y`XWLT^U\b]JW[[RZ\SYc`RD[Z\WLXM`\HYa\I scikit-bio-0.5.9/skbio/io/format/tests/data/wrapping_as_sanger.fastq000066400000000000000000000017031446255456000255700ustar00rootroot00000000000000@SRR014849.50939 EIXKN4201BA2EC length=135 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + ;C?-EA/=60,)%"<=:5<@85@7@8+8<<3;=4:DA3%<;=8-9.A=):B=* scikit-bio-0.5.9/skbio/io/format/tests/data/wrapping_original_sanger.fastq000066400000000000000000000017171446255456000267760ustar00rootroot00000000000000@SRR014849.50939 EIXKN4201BA2EC length=135 GAAATTTCAGGGCCACCTTTTTTTTGATAGAATAATGGAGAAAATTAAAAGCTGTACATATACCAATGAACAATAAATCAATACATAAAAAAGGAGAAGTTGGAACCGAAAGGGTTTGAATTCAAACCCTTTCGG + ;C?-EA/=60,)%"<=:5< @85@7@8+8< <3;=4:DA3%<;=8-9.A=):B=* scikit-bio-0.5.9/skbio/io/format/tests/test_base.py000066400000000000000000000321761446255456000223010ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy.testing as npt import numpy as np from skbio import Sequence, DNA, RNA from skbio.io.format._base import (_decode_qual_to_phred, _encode_phred_to_qual, _get_nth_sequence, _parse_fasta_like_header, _format_fasta_like_records) class PhredDecoderTests(unittest.TestCase): def test_missing_variant_and_phred_offset(self): with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('abcd') self.assertIn('`variant`', str(cm.exception)) self.assertIn('`phred_offset`', str(cm.exception)) self.assertIn('decode', str(cm.exception)) def test_variant_and_phred_offset_provided(self): with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('abcd', variant='sanger', phred_offset=64) self.assertIn('both', str(cm.exception)) self.assertIn('`variant`', str(cm.exception)) self.assertIn('`phred_offset`', str(cm.exception)) def test_solexa_variant(self): with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('abcd', variant='solexa') self.assertIn('719', str(cm.exception)) def test_unrecognized_variant(self): with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('abcd', variant='illumina') self.assertIn('variant', str(cm.exception)) self.assertIn("'illumina'", str(cm.exception)) def test_empty_qual_str(self): npt.assert_equal(_decode_qual_to_phred('', variant='sanger'), np.array([], dtype=np.uint8)) def test_sanger_variant(self): # test entire range of possible ascii chars for sanger all_sanger_ascii = ('!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP' 'QRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~') obs = _decode_qual_to_phred(all_sanger_ascii, variant='sanger') npt.assert_equal(obs, np.arange(94)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('a b', variant='sanger') self.assertIn('[0, 93]', str(cm.exception)) def test_illumina13_variant(self): # test entire range of possible ascii chars for illumina1.3 all_illumina13_ascii = ('@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijk' 'lmnopqrstuvwxyz{|}~') obs = _decode_qual_to_phred(all_illumina13_ascii, variant='illumina1.3') npt.assert_equal(obs, np.arange(63)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('a!b', variant='illumina1.3') self.assertIn('[0, 62]', str(cm.exception)) def test_illumina18_variant(self): # test entire range of possible ascii chars for illumina1.8 all_illumina18_ascii = ('!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL' 'MNOPQRSTUVWXYZ[\\]^_') obs = _decode_qual_to_phred(all_illumina18_ascii, variant='illumina1.8') npt.assert_equal(obs, np.arange(63)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred('AaB', variant='illumina1.8') self.assertIn('[0, 62]', str(cm.exception)) def test_custom_phred_offset(self): ascii_chars = '*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\' obs = _decode_qual_to_phred(ascii_chars, phred_offset=42) npt.assert_equal(obs, np.arange(51)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred(ascii_chars, phred_offset=43) self.assertIn('[0, 83]', str(cm.exception)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred(ascii_chars, phred_offset=0) self.assertIn('`phred_offset`', str(cm.exception)) self.assertIn('printable', str(cm.exception)) with self.assertRaises(ValueError) as cm: _decode_qual_to_phred(ascii_chars, phred_offset=127) self.assertIn('`phred_offset`', str(cm.exception)) self.assertIn('printable', str(cm.exception)) class PhredEncoderTests(unittest.TestCase): def test_missing_variant_and_phred_offset(self): with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([1, 2, 3]) self.assertIn('`variant`', str(cm.exception)) self.assertIn('`phred_offset`', str(cm.exception)) self.assertIn('encode', str(cm.exception)) def test_variant_and_phred_offset_provided(self): with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([1, 2, 3], variant='sanger', phred_offset=64) self.assertIn('both', str(cm.exception)) self.assertIn('`variant`', str(cm.exception)) self.assertIn('`phred_offset`', str(cm.exception)) def test_solexa_variant(self): with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([1, 2, 3], variant='solexa') self.assertIn('719', str(cm.exception)) def test_unrecognized_variant(self): with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([1, 2, 3], variant='illumina') self.assertIn('variant', str(cm.exception)) self.assertIn("'illumina'", str(cm.exception)) def test_no_phred_scores(self): self.assertEqual(_encode_phred_to_qual([], variant='sanger'), '') def test_sanger_variant(self): # test entire range of possible ascii chars for sanger all_sanger_ascii = ('!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP' 'QRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~') obs = _encode_phred_to_qual(list(range(94)), variant='sanger') self.assertEqual(obs, all_sanger_ascii) with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([42, -1, 33], variant='sanger') self.assertIn('-1', str(cm.exception)) self.assertIn('[0, 93]', str(cm.exception)) obs = npt.assert_warns(UserWarning, _encode_phred_to_qual, [42, 94, 33], variant='sanger') self.assertEqual(obs, 'K~B') def test_illumina13_variant(self): # test entire range of possible ascii chars for illumina1.3 all_illumina13_ascii = ('@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijk' 'lmnopqrstuvwxyz{|}~') obs = _encode_phred_to_qual(list(range(63)), variant='illumina1.3') self.assertEqual(obs, all_illumina13_ascii) with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([42, -1, 33], variant='illumina1.3') self.assertIn('-1', str(cm.exception)) self.assertIn('[0, 62]', str(cm.exception)) obs = npt.assert_warns(UserWarning, _encode_phred_to_qual, [42, 63, 33], variant='illumina1.3') self.assertEqual(obs, 'j~a') def test_illumina18_variant(self): # test entire range of possible ascii chars for illumina1.8 all_illumina18_ascii = ('!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL' 'MNOPQRSTUVWXYZ[\\]^_') obs = _encode_phred_to_qual(list(range(63)), variant='illumina1.8') self.assertEqual(obs, all_illumina18_ascii) with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([42, -1, 33], variant='illumina1.8') self.assertIn('-1', str(cm.exception)) self.assertIn('[0, 62]', str(cm.exception)) obs = npt.assert_warns(UserWarning, _encode_phred_to_qual, [42, 63, 33], variant='illumina1.8') self.assertEqual(obs, 'K_B') def test_custom_phred_offset(self): ascii_chars = '*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\' obs = _encode_phred_to_qual(list(range(51)), phred_offset=42) self.assertEqual(obs, ascii_chars) with self.assertRaises(ValueError) as cm: _encode_phred_to_qual([42, -1, 33], phred_offset=42) self.assertIn('-1', str(cm.exception)) self.assertIn('[0, 84]', str(cm.exception)) obs = npt.assert_warns(UserWarning, _encode_phred_to_qual, [42, 255, 33], phred_offset=42) self.assertEqual(obs, 'T~K') class TestGetNthSequence(unittest.TestCase): def setUp(self): def generator(): for i in range(1, 6): yield 'goldilocks: ' + str(i) self.gen = generator() def test_seq_num_too_small(self): with self.assertRaises(ValueError) as cm: _get_nth_sequence(self.gen, 0) self.assertIn('between 1 and', str(cm.exception)) self.assertIn('0', str(cm.exception)) def test_seq_num_too_big(self): with self.assertRaises(ValueError) as cm: _get_nth_sequence(self.gen, 6) self.assertIn('end of file', str(cm.exception)) self.assertIn('6th', str(cm.exception)) def test_seq_num_just_right(self): value = _get_nth_sequence(self.gen, 3) self.assertEqual(value, 'goldilocks: 3') class TestParseFASTALikeHeader(unittest.TestCase): def test_no_id_or_description(self): obs = _parse_fasta_like_header('> \t\t \n') self.assertEqual(obs, ('', '')) def test_id_only(self): obs = _parse_fasta_like_header('>suht! \t\t \n') self.assertEqual(obs, ('suht!', '')) def test_description_only(self): obs = _parse_fasta_like_header('> suht! \t\t \n') self.assertEqual(obs, ('', 'suht!')) def test_id_and_description(self): obs = _parse_fasta_like_header('>!thus suht! \t\t \n') self.assertEqual(obs, ('!thus', 'suht!')) class TestFormatFASTALikeRecords(unittest.TestCase): def setUp(self): def generator(): yield Sequence('ACGT', metadata={'id': '', 'description': ''}, positional_metadata={'quality': range(4)}) yield RNA('GAU', metadata={'id': ' foo \t\t bar ', 'description': ''}) yield DNA('TAG', metadata={'id': '', 'description': 'foo\n\n bar\n'}) yield Sequence('A', metadata={'id': 'foo', 'description': 'bar baz'}, positional_metadata={'quality': [42]}) self.gen = generator() def test_no_replacement(self): exp = [ ('', 'ACGT', range(4)), (' foo \t\t bar ', 'GAU', None), (' foo\n\n bar\n', 'TAG', None), ('foo bar baz', 'A', [42]) ] obs = list(_format_fasta_like_records(self.gen, None, None, False)) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): npt.assert_equal(o, e) def test_empty_str_replacement(self): exp = [ ('', 'ACGT', range(4)), ('foobar', 'GAU', None), (' foo bar', 'TAG', None), ('foo bar baz', 'A', [42]) ] obs = list(_format_fasta_like_records(self.gen, '', '', False)) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): npt.assert_equal(o, e) def test_multi_char_replacement(self): exp = [ ('', 'ACGT', range(4)), ('-.--.-foo-.--.--.--.-bar-.-', 'GAU', None), (' foo_-__-_ bar_-_', 'TAG', None), ('foo bar baz', 'A', [42]) ] obs = list(_format_fasta_like_records(self.gen, '-.-', '_-_', False)) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): npt.assert_equal(o, e) def test_newline_character_in_id_whitespace_replacement(self): with self.assertRaisesRegex(ValueError, r'Newline character'): list(_format_fasta_like_records(self.gen, '-\n--', ' ', False)) def test_newline_character_in_description_newline_replacement(self): with self.assertRaisesRegex(ValueError, r'Newline character'): list(_format_fasta_like_records(self.gen, None, 'a\nb', False)) def test_empty_sequence(self): def blank_seq_gen(): yield from (DNA('A'), Sequence(''), RNA('GG')) with self.assertRaisesRegex(ValueError, r'2nd.*empty'): list(_format_fasta_like_records(blank_seq_gen(), None, None, False)) def test_missing_quality_scores(self): def missing_qual_gen(): yield from (RNA('A', positional_metadata={'quality': [42]}), Sequence('AG'), DNA('GG', positional_metadata={'quality': [41, 40]})) with self.assertRaisesRegex(ValueError, r'2nd sequence.*quality scores'): list(_format_fasta_like_records(missing_qual_gen(), '-', '-', True)) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_binary_dm.py000066400000000000000000000112471446255456000233270ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import tempfile import shutil import os import numpy as np import numpy.testing as npt import h5py from skbio import DistanceMatrix from skbio.io.format.binary_dm import (_h5py_mat_to_skbio_mat, _skbio_mat_to_h5py_mat, _get_header, _parse_ids, _verify_dimensions, _bytes_decoder, _passthrough_decoder, _set_header, _vlen_dtype, _binary_dm_sniffer) class BinaryMatrixTests(unittest.TestCase): def setUp(self): self.mat = np.array([[0, 0.1, 0.2], [0.1, 0, 0.3], [0.2, 0.3, 0]]) self.ids = ['a', 'b', 'c'] self.tempdir = tempfile.TemporaryDirectory() self.basic_fname = os.path.join(self.tempdir.name, 'basic') self.basic = h5py.File(self.basic_fname, 'a') ids = self.basic.create_dataset('order', shape=(3, ), dtype=_vlen_dtype) ids[:] = self.ids self.basic.create_dataset('matrix', data=self.mat) _set_header(self.basic) self.basic.close() self.badids_fname = os.path.join(self.tempdir.name, 'badids') self.badids = h5py.File(self.badids_fname, 'a') ids = self.badids.create_dataset('order', shape=(2, ), dtype=_vlen_dtype) ids[:] = ['a', 'b'] self.badids.create_dataset('matrix', data=self.mat) _set_header(self.badids) self.badids.close() self.noheader_fname = os.path.join(self.tempdir.name, 'noheader') self.noheader = h5py.File(self.noheader_fname, 'a') ids = self.noheader.create_dataset('order', shape=(3, ), dtype=_vlen_dtype) ids[:] = self.ids self.noheader.create_dataset('matrix', data=self.mat) def tearDown(self): shutil.rmtree(self.tempdir.name) def test_binary_dm_sniffer(self): self.assertEqual((True, {}), _binary_dm_sniffer(open(self.basic_fname, 'rb'))) self.assertEqual((False, {}), _binary_dm_sniffer(open(self.badids_fname, 'rb'))) self.assertEqual((False, {}), _binary_dm_sniffer(open(self.noheader_fname, 'rb'))) def test_h5py_mat_to_skbio_mat(self): exp = DistanceMatrix(self.mat, self.ids) obs = _h5py_mat_to_skbio_mat(DistanceMatrix, h5py.File(self.basic_fname, 'r')) self.assertEqual(obs, exp) def test_skbio_mat_to_h5py_mat(self): fh1 = h5py.File('f1', 'a', driver='core', backing_store=False) mat = DistanceMatrix(self.mat, self.ids) _skbio_mat_to_h5py_mat(mat, fh1) npt.assert_equal(np.asarray(fh1['order'][:], dtype=str), mat.ids) npt.assert_equal(fh1['matrix'], mat.data) def test_get_header(self): self.assertEqual(_get_header(h5py.File(self.basic_fname, 'r')), {'format': b'BDSM', 'version': b'2020.06'}) self.assertEqual(_get_header(h5py.File(self.noheader_fname, 'r')), None) def test_parse_ids(self): tests = [(['a', 'b', 'c'], ['a', 'b', 'c']), ([b'a', b'b', b'\xc3\xa9\xc3\xb8asd'], ['a', 'b', 'éøasd'])] for test, exp in tests: self.assertEqual(_parse_ids(test), exp) def test_verify_dimensions(self): self.assertTrue(_verify_dimensions(h5py.File(self.basic_fname, 'r'))) self.assertFalse(_verify_dimensions(h5py.File(self.badids_fname, 'r'))) def test_bytes_decoder(self): test = [b'', b'a', b'\xc3\xa9\xc3\xb8asd'] exp = ['', 'a', 'éøasd'] self.assertEqual(_bytes_decoder(test), exp) def test_passthrough_decoder(self): tests = [('', ''), ('a', 'a'), ('éøasd', 'éøasd')] for test, expected in tests: self.assertEqual(_passthrough_decoder(test), expected) def test_set_header(self): def mock(): obj = h5py.File('bung', 'a', driver='core', backing_store=False) return obj m = mock() _set_header(m) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_blast6.py000066400000000000000000000140431446255456000225530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import pandas as pd import numpy as np from skbio.util import get_data_path, assert_data_frame_almost_equal from skbio.io.format.blast6 import _blast6_to_data_frame class TestBlast6Reader(unittest.TestCase): def test_default_valid_single_line(self): fp = get_data_path('blast6_default_single_line') df = _blast6_to_data_frame(fp, default_columns=True) exp = pd.DataFrame([['query1', 'subject2', 75.0, 8.0, 2.0, 0.0, 1.0, 8.0, 2.0, 9.0, 0.06, 11.5]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_default_valid_multi_line(self): fp = get_data_path('blast6_default_multi_line') df = _blast6_to_data_frame(fp, default_columns=True) exp = pd.DataFrame([['query1', 'subject2', 100.00, 8.0, 0.0, 0.0, 1.0, 8.0, 3.0, 10.0, 9e-05, 16.9], ['query1', 'subject2', 75.00, 8.0, 2.0, 0.0, 1.0, 8.0, 2.0, 9.0, 0.060, 11.5], ['query2', 'subject1', 71.43, 7.0, 2.0, 0.0, 1.0, 7.0, 1.0, 7.0, 0.044, 11.9]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_single_line(self): fp = get_data_path('blast6_custom_single_line') df = _blast6_to_data_frame(fp, columns=['qacc', 'qseq', 'btop', 'sframe', 'ppos', 'positive', 'gaps']) exp = pd.DataFrame([['query1', 'PAAWWWWW', 8.0, 1.0, 100.00, 8.0, 0.0]], columns=['qacc', 'qseq', 'btop', 'sframe', 'ppos', 'positive', 'gaps']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_multi_line(self): fp = get_data_path('blast6_custom_multi_line') df = _blast6_to_data_frame(fp, columns=['sacc', 'score', 'gapopen', 'qcovs', 'sblastnames', 'sallacc', 'qaccver']) exp = pd.DataFrame([['subject2', 32.0, 0.0, 100.0, np.nan, 'subject2', 'query1'], ['subject2', 18.0, 0.0, 100.0, np.nan, 'subject2', 'query1'], ['subject1', 19.0, 0.0, 70.0, np.nan, 'subject1', 'query2']], columns=['sacc', 'score', 'gapopen', 'qcovs', 'sblastnames', 'sallacc', 'qaccver']) exp['sblastnames'] = exp['sblastnames'].astype(object) assert_data_frame_almost_equal(df, exp) def test_valid_nan_handling(self): fp = get_data_path('blast6_custom_mixed_nans') df = _blast6_to_data_frame(fp, columns=['qacc', 'qseq', 'btop', 'sframe', 'ppos', 'positive', 'gaps']) exp = pd.DataFrame([[np.nan, 'PAAWWWWW', 8.0, 1.0, 100.00, np.nan, 0.0], ['query1', np.nan, 8.0, 1.0, np.nan, 8.0, 0.0]], columns=['qacc', 'qseq', 'btop', 'sframe', 'ppos', 'positive', 'gaps']) assert_data_frame_almost_equal(df, exp) def test_valid_minimal(self): fp = get_data_path('blast6_custom_minimal') df = _blast6_to_data_frame(fp, columns=['sacc']) exp = pd.DataFrame([['subject2']], columns=['sacc']) assert_data_frame_almost_equal(df, exp) def test_custom_and_default_passed_error(self): fp = get_data_path('blast6_default_single_line') with self.assertRaisesRegex(ValueError, r"`columns` and `default_columns`"): _blast6_to_data_frame(fp, columns=['qseqid'], default_columns=True) def test_no_columns_passed_error(self): fp = get_data_path('blast6_default_single_line') with self.assertRaisesRegex(ValueError, r"Either `columns` or `default_columns`"): _blast6_to_data_frame(fp) def test_wrong_amount_of_columns_error(self): fp = get_data_path('blast6_invalid_number_of_columns') with self.assertRaisesRegex( ValueError, r"Specified number of columns \(12\).*\(10\)"): _blast6_to_data_frame(fp, default_columns=True) def test_different_data_in_same_column(self): fp = get_data_path('blast6_invalid_type_in_column') with self.assertRaises(ValueError): _blast6_to_data_frame(fp, default_columns=True) def test_wrong_column_name_error(self): fp = get_data_path('blast6_default_single_line') with self.assertRaisesRegex(ValueError, r"Unrecognized column.*'abcd'"): _blast6_to_data_frame(fp, columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'abcd', 'bitscore']) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_blast7.py000066400000000000000000000233601446255456000225560ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import pandas as pd import numpy as np from skbio.util import get_data_path, assert_data_frame_almost_equal from skbio.io import BLAST7FormatError from skbio.io.format.blast7 import _blast7_to_data_frame, _blast7_sniffer class TestBLAST7Sniffer(unittest.TestCase): def setUp(self): self.positives = [get_data_path(e) for e in [ 'blast7_default_single_line', 'blast7_default_multi_line', 'blast7_custom_minimal', 'blast7_custom_single_line', 'blast7_custom_multi_line', 'blast7_custom_mixed_nans', 'blast7_invalid_differing_fields', 'blast7_invalid_no_data', 'blast7_invalid_too_many_columns', 'legacy9_and_blast7_default', 'legacy9_invalid_too_many_columns', 'legacy9_mixed_nans', 'legacy9_multi_line', 'legacy9_single_line']] self.negatives = [get_data_path(e) for e in [ 'blast7_invalid_gibberish', 'blast7_invalid_for_sniffer', 'blast7_invalid_for_sniffer_2', 'empty']] def test_positives(self): for fp in self.positives: self.assertEqual(_blast7_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negatives: self.assertEqual(_blast7_sniffer(fp), (False, {})) class TestBlast7Reader(unittest.TestCase): def test_default_valid_single_line(self): fp = get_data_path('blast7_default_single_line') df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1', 'subject2', 100.00, 8.0, 0.0, 0.0, 1.0, 8.0, 3.0, 10.0, 9e-05, 16.9]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) fp = get_data_path('legacy9_single_line') df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1', 'subject1', 90.00, 7.0, 1.0, 0.0, 0.0, 8.0, 4.0, 10.0, 1e-05, 15.5]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_default_valid_multi_line(self): fp = get_data_path('blast7_default_multi_line') df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1', 'subject2', 70.00, 5.0, 0.0, 0.0, 7.0, 60.0, 3.0, 100.0, 9e-05, 10.5], ['query1', 'subject2', 30.00, 8.0, 0.0, 0.0, 6.0, 15.0, 1.0, 100.0, 0.053, 12.0], ['query1', 'subject2', 90.00, 2.0, 0.0, 0.0, 9.0, 35.0, 2.0, 100.0, 0.002, 8.3]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) fp = get_data_path('legacy9_multi_line') df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1', 'subject1', 90.00, 7.0, 1.0, 0.0, 0.0, 8.0, 4.0, 10.0, 1e-05, 15.5], ['query1', 'subject1', 70.00, 8.0, 0.0, 1.0, 0.0, 9.0, 5.0, 7.0, 0.231, 7.8], ['query1', 'subject1', 90.00, 5.0, 1.0, 1.0, 0.0, 0.0, 2.0, 10.0, 0.022, 13.0]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_default_valid_mixed_output(self): fp = get_data_path('legacy9_and_blast7_default') df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query2', 'subject2', 100.00, 8.0, 0.0, 1.0, 0.0, 9.0, 3.0, 10.0, 2e-05, 9.8], ['query2', 'subject1', 70.00, 9.0, 1.0, 0.0, 1.0, 8.0, 4.0, 9.0, 0.025, 11.7]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_minimal(self): fp = get_data_path("blast7_custom_minimal") df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1']], columns=['qseqid']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_single_line(self): fp = get_data_path("blast7_custom_single_line") df = _blast7_to_data_frame(fp) exp = pd.DataFrame([['query1', 100.00, 100.00, 8.0, 0.0, 16.9, 8.0, 'PAAWWWWW']], columns=['qseqid', 'ppos', 'pident', 'length', 'sgi', 'bitscore', 'qend', 'qseq']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_multi_line(self): fp = get_data_path("blast7_custom_multi_line") df = _blast7_to_data_frame(fp) exp = pd.DataFrame([[1.0, 8.0, 3.0, 10.0, 8.0, 0.0, 1.0, 'query1', 'subject2'], [2.0, 5.0, 2.0, 15.0, 8.0, 0.0, 2.0, 'query1', 'subject2'], [1.0, 6.0, 2.0, 12.0, 8.0, 0.0, 1.0, 'query1', 'subject2']], columns=['qstart', 'qend', 'sstart', 'send', 'nident', 'mismatch', 'sframe', 'qaccver', 'saccver']) assert_data_frame_almost_equal(df, exp) def test_custom_valid_mixed_nans(self): fp = get_data_path("blast7_custom_mixed_nans") df = _blast7_to_data_frame(fp) exp = pd.DataFrame([[0.0, np.nan, 8.0, 13.0, 1.0, 1.0, np.nan, 'subject2'], [np.nan, 0.0, 8.0, np.nan, 1.0, 1.0, 'query1', np.nan]], columns=['qgi', 'sgi', 'qlen', 'slen', 'qframe', 'sframe', 'qseqid', 'sseqid']) assert_data_frame_almost_equal(df, exp) def test_legacy9_valid_mixed_nans(self): fp = get_data_path("legacy9_mixed_nans") df = _blast7_to_data_frame(fp) exp = pd.DataFrame([[np.nan, 'subject1', np.nan, 7.0, 1.0, 0.0, np.nan, 8.0, 4.0, 10.0, np.nan, 15.5], ['query2', 'subject1', 90.00, 8.0, np.nan, 0.0, 0.0, 8.0, np.nan, 9.0, 1e-05, np.nan]], columns=['qseqid', 'sseqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore']) assert_data_frame_almost_equal(df, exp) def test_differing_fields_error(self): fp = get_data_path("blast7_invalid_differing_fields") with self.assertRaisesRegex( BLAST7FormatError, r"Fields \[.*'qseqid', .*'sseqid', .*'qstart'\]" r" do.*\[.*'qseqid', .*'sseqid', .*'score'\]"): _blast7_to_data_frame(fp) fp = get_data_path("legacy9_invalid_differing_fields") with self.assertRaisesRegex( BLAST7FormatError, r"Fields \[.*'qseqid', .*'sseqid', .*'qstart'\]" r" do.*\[.*'qseqid', .*'sseqid', " r".*'sallseqid'\]"): _blast7_to_data_frame(fp) def test_no_data_error(self): fp = get_data_path("blast7_invalid_gibberish") with self.assertRaisesRegex(BLAST7FormatError, r"File contains no"): _blast7_to_data_frame(fp) fp = get_data_path("blast7_invalid_no_data") with self.assertRaisesRegex(BLAST7FormatError, r"File contains no"): _blast7_to_data_frame(fp) fp = get_data_path("empty") with self.assertRaisesRegex(BLAST7FormatError, r"File contains no"): _blast7_to_data_frame(fp) def test_wrong_amount_of_columns_error(self): fp = get_data_path("blast7_invalid_too_many_columns") with self.assertRaisesRegex(BLAST7FormatError, r"Number of fields.*\(2\)"): _blast7_to_data_frame(fp) fp = get_data_path("legacy9_invalid_too_many_columns") with self.assertRaisesRegex(BLAST7FormatError, r"Number of fields.*\(12\)"): _blast7_to_data_frame(fp) def test_unrecognized_field_error(self): fp = get_data_path("blast7_invalid_unrecognized_field") with self.assertRaisesRegex(BLAST7FormatError, r"Unrecognized field \(.*'sallid'\)"): _blast7_to_data_frame(fp) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_clustal.py000066400000000000000000000267031446255456000230350ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import string from io import StringIO from unittest import TestCase, main from skbio import TabularMSA from skbio.sequence import GrammaredSequence from skbio.util import classproperty from skbio.util._decorator import overrides from skbio.io.format.clustal import ( _clustal_to_tabular_msa, _tabular_msa_to_clustal, _clustal_sniffer, _is_clustal_seq_line, _delete_trailing_number, _check_length, _label_line_parser) from skbio.io import ClustalFormatError class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set(string.ascii_letters) @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {} class ClustalHelperTests(TestCase): def test_label_line_parser(self): self.assertEqual(_label_line_parser(StringIO('abc\tucag')), ({"abc": ["ucag"]}, ['abc'])) with self.assertRaises(ClustalFormatError): _label_line_parser(StringIO('abctucag')) def test_is_clustal_seq_line(self): ic = _is_clustal_seq_line self.assertTrue(ic('abc')) self.assertTrue(ic('abc def')) self.assertFalse(ic('CLUSTAL')) self.assertFalse(ic('CLUSTAL W fsdhicjkjsdk')) self.assertFalse(ic(' * *')) self.assertFalse(ic(' abc def')) self.assertFalse(ic('MUSCLE (3.41) multiple sequence alignment')) def test_delete_trailing_number(self): dtn = _delete_trailing_number self.assertEqual(dtn('abc'), 'abc') self.assertEqual(dtn('a b c'), 'a b c') self.assertEqual(dtn('a \t b \t c'), 'a \t b \t c') self.assertEqual(dtn('a b 3'), 'a b') self.assertEqual(dtn('a b c \t 345'), 'a b c') def test_check_lengh(self): self.assertEqual(False, _check_length({'abc': ['adjfkadfjaksdlfadskfda'], 'xyz': ['adjfkadfjaksdlfadsk']}, ['abc', 'xyz'])), self.assertEqual(True, _check_length({'abc': ['adjfkadfjaksdlfadskfda'], 'xyz': ['adjfkadfjaksdlfadsksdf']}, ['abc', 'xyz'])) self.assertEqual(True, _check_length({'abc': ['adjfkadfjaksdlfadskfda', 'adjfkadfjaksdlfadskfda'], 'xyz': ['adjfkadfjaksdlfadsksdf', 'adjfkadfjaksdlfadsksdf']}, ['abc', 'xyz'])) self.assertEqual(False, _check_length({'abc': ['adjfkadfjaksdlfadskfd', 'adjfkadfjaksdlfadskfda'], 'xyz': ['adjfkadfjaksdlfadsksdf', 'adjfkadfjaksdlfadsksdf']}, ['abc', 'xyz'])) self.assertEqual(False, _check_length({'abc': ['adjfkadfjaksdlfadskfda', 'adjfkadfjaksdlfadskfda'], 'xyz': ['adjfkadfjaksdlfadsksdf', 'adjfkadfjaksdlfadsksd']}, ['abc', 'xyz'])) class ClustalIOTests(TestCase): def setUp(self): self.valid_clustal_out = [ StringIO('CLUSTAL\n\nabc\tucag'), StringIO('CLUSTAL\n\nabc\tuuu\ndef\tccc\n\n ***\n\ndef ggg\nab' 'c\taaa\n'), StringIO('\n'.join(['CLUSTAL\n', 'abc uca', 'def ggg ccc'])), StringIO('\n'.join(['CLUSTAL\n', 'abc uca ggg', 'def ggg ccc'])), StringIO("""CLUSTAL abc GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA def ------------------------------------------------------------ xyz ------------------------------------------------------------ """), StringIO("""CLUSTAL abc GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA def ------------------------------------------------------------ xyz ------------------------------------------------------------ abc GUCGAUACGUACGUCAGUCAGUACGUCAGCAUGCAUACGUACGUCGUACGUACGU-CGAC def -----------------------------------------CGCGAUGCAUGCAU-CGAU xyz -------------------------------------CAUGCAUCGUACGUACGCAUGAC """), StringIO("""CLUSTAL W (1.82) multiple sequence alignment abc GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA def ------------------------------------------------------------ xyz ------------------------------------------------------------ abc GUCGAUACGUACGUCAGUCAGUACGUCAGCAUGCAUACGUACGUCGUACGUACGU-CGAC def -----------------------------------------CGCGAUGCAUGCAU-CGAU xyz -------------------------------------CAUGCAUCGUACGUACGCAUGAC abc UGACUAGUCAGCUAGCAUCGAUCAGU def CGAUCAGUCAGUCGAU---------- xyz UGCUGCAUCA----------------"""), StringIO("""CLUSTAL W (1.74) multiple sequence alignment abc GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA 60 def ------------------------------------------------------------ xyz ------------------------------------------------------------ abc GUCGAUACGUACGUCAGUCAGUACGUCAGCAUGCAUACGUACGUCGUACGUACGU-CGAC 11 def -----------------------------------------CGCGAUGCAUGCAU-CGAU 18 xyz -------------------------------------CAUGCAUCGUACGUACGCAUGAC 23 : * * * * ** abc UGACUAGUCAGCUAGCAUCGAUCAGU 145 def CGAUCAGUCAGUCGAU---------- 34 xyz UGCUGCAUCA---------------- 33 * ***""") ] self.invalid_clustal_out = [ StringIO('\n'.join(['dshfjsdfhdfsj', 'hfsdjksdfhjsdf'])), StringIO('\n'.join(['hfsdjksdfhjsdf'])), StringIO('\n'.join(['dshfjsdfhdfsj', 'dshfjsdfhdfsj', 'hfsdjksdfhjsdf'])), StringIO('\n'.join(['dshfjsdfhdfsj', '\t', 'hfsdjksdfhjsdf'])), StringIO('\n'.join(['dshfj\tdfhdfsj', 'hfsdjksdfhjsdf'])), StringIO('\n'.join(['dshfjsdfhdfsj', 'hfsdjk\tdfhjsdf'])), StringIO("""CLUSTAL W (1.74) multiple sequence alignment adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA ------------------------------------------------------------ adk -----GGGGGGG------------------------------------------------ """), StringIO("""CLUSTAL W (1.74) multiple sequence alignment adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA adk -----GGGGGGG------------------------------------------------ adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA adk -----GGGGGGG--------------------------------------------- """), StringIO("""CLUSTAL W (1.74) multiple sequence alignment adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA adk -----GGGGGGG--------------------------------------------- adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCA adk -----GGGGGGG--------------------------------------------- """), StringIO("""CLUSTAL W (1.74) multiple sequence alignment adj GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA ------------------------------------------------------------ adk -----GGGGGGG------------------------------------------------ """), StringIO("""CLUSTAL W (1.74) multiple sequence alignment GCAUGCAUGCAUGAUCGUACGUCAGCAUGCUAGACUGCAUACGUACGUACGCAUGCAUCA ------------------------------------------------------------ ------------------------------------------------------------ GUCGAUACGUACGUCAGUCAGUACGUCAGCAUGCAUACGUACGUCGUACGUACGU-CGAC -----------------------------------------CGCGAUGCAUGCAU-CGAU ------------------------------------------------------------ : * * * * ** UGACUAGUCAGCUAGCAUCGAUCAGU 145 CGAUCAGUCAGUCGAU---------- 34 UGCUGCAUCA---------------- 33 * ***""")] def test_tabular_msa_to_clustal_with_empty_input(self): result = _clustal_to_tabular_msa(StringIO(), constructor=CustomSequence) self.assertEqual(dict(result), {}) def test_tabular_msa_to_clustal_with_bad_input(self): BAD = StringIO('\n'.join(['dshfjsdfhdfsj', 'hfsdjksdfhjsdf'])) with self.assertRaises(ClustalFormatError): dict(_clustal_to_tabular_msa(BAD, constructor=CustomSequence)) def test_valid_tabular_msa_to_clustal_and_clustal_to_tabular_msa(self): for valid_out in self.valid_clustal_out: result_before = _clustal_to_tabular_msa( valid_out, constructor=CustomSequence) with StringIO() as fh: _tabular_msa_to_clustal(result_before, fh) fh.seek(0) result_after = _clustal_to_tabular_msa( fh, constructor=CustomSequence) self.assertEqual(result_before, result_after) def test_invalid_tabular_msa_to_clustal_and_clustal_to_tabular_msa(self): for invalid_out in self.invalid_clustal_out: with self.assertRaises(ClustalFormatError): dict(_clustal_to_tabular_msa(invalid_out, constructor=CustomSequence)) def test_clustal_sniffer_valid_files(self): for valid_out in self.valid_clustal_out: self.assertEqual(_clustal_sniffer(valid_out), (True, {})) def test_clustal_sniffer_invalid_files(self): for invalid_out in self.invalid_clustal_out: self.assertEqual(_clustal_sniffer(invalid_out), (False, {})) # sniffer should return False on empty file (which isn't contained # in self.invalid_clustal_out since an empty file is a valid output) self.assertEqual(_clustal_sniffer(StringIO()), (False, {})) def test_no_constructor(self): with self.assertRaisesRegex(ValueError, r"`constructor`"): _clustal_to_tabular_msa(self.valid_clustal_out[0]) def test_duplicate_labels(self): msa = TabularMSA([CustomSequence('foo'), CustomSequence('bar')], index=['a', 'a']) with self.assertRaisesRegex(ClustalFormatError, r"index.*unique"): with StringIO() as fh: _tabular_msa_to_clustal(msa, fh) def test_invalid_lengths(self): fh = StringIO( "CLUSTAL\n" "\n\n" "abc GCAU\n" "def -----\n") with self.assertRaisesRegex(ClustalFormatError, r"not aligned"): _clustal_to_tabular_msa(fh, constructor=CustomSequence) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_embl.py000066400000000000000000001067151446255456000223070ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import skbio.io from skbio import DNA, RNA, Sequence, Protein from skbio.metadata import IntervalMetadata from skbio.util import get_data_path # Module specific execption and functions from skbio.io import EMBLFormatError from skbio.io.format.embl import ( _embl_sniffer, _parse_id, _parse_reference, _embl_to_generator, _get_embl_section, _embl_to_sequence, _embl_to_dna, _embl_to_rna, _embl_to_protein, _generator_to_embl, _sequence_to_embl, _protein_to_embl, _rna_to_embl, _dna_to_embl, _serialize_id, _parse_assembly, _embl_parse_section_default, _serialize_dbsource) class SnifferTests(TestCase): def setUp(self): self.positive_fps = list(map(get_data_path, [ 'embl_single_record', 'embl_multi_records'])) self.negative_fps = list(map(get_data_path, [ 'empty', 'whitespace_only', 'embl_uniprot_record', 'embl_w_beginning_whitespace'])) def test_positives(self): for fp in self.positive_fps: self.assertEqual(_embl_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negative_fps: self.assertEqual(_embl_sniffer(fp), (False, {})) # Boilerplate for EMBL IO tests # TODO: implements all setUp needed class EMBLIOTests(TestCase): def setUp(self): # to test ID line self.id = ( # This is a derived record (non-coding, rRNA and spacer records) # (feature level record: # http://www.ebi.ac.uk/ena/browse/feature-level-products # TODO: a Uniprot record? (['ID AB000684.1:1..275:rRNA; SV 1; linear; ' 'genomic DNA; STD; ENV; 275 BP.'], {'division': 'ENV', 'mol_type': 'genomic DNA', 'shape': 'linear', 'locus_name': 'AB000684.1:1..275:rRNA', 'unit': 'bp', 'size': 275, 'version': 1, 'class': 'STD', 'date': None}), # A standard record (['ID M14399; SV 1; linear; mRNA; STD; PRO; 63 BP.'], {'division': 'PRO', 'mol_type': 'mRNA', 'shape': 'linear', 'locus_name': 'M14399', 'unit': 'bp', 'size': 63, 'version': 1, 'class': 'STD', 'date': None})) # define a single DNA record (with no interval metadata) # M14399; SV 1; linear; mRNA; STD; PRO; 63 BP. self.single = ( 'gtgaaacaaagcactattgcactggctgtcttaccgttactgtttacccctgtgacaaaagcc', {'LOCUS': {'locus_name': 'M14399', 'class': 'STD', 'division': 'PRO', 'mol_type': 'mRNA', 'shape': 'linear', 'size': 63, 'unit': 'bp', 'version': 1, 'date': None}}, None, DNA) # define a single protein record (uniprot) self.protein = ( 'MAFSAEDVLKEYDRRRRMEALLLSLYYPNDRKLLDYKEWSPPRVQVECPKAPVEWNNPPSEKG' 'LIVGHFSGIKYKGEKAQASEVDVNKMCCWVSKFKDAMRRYQGIQTCKIPGKVLSDLDAKIKAY' 'NLTVEGVEGFVRYSRVTKQHVAAFLKELRHSKQYENVNLIHYILTDKRVDIQHLEKDLVKDFK' 'ALVESAHRMRQGHMINVKYILYQLLKKHGHGPDGPDILTVKTGSKGVLYDDSFRKIYTDLGWK' 'FTPL', {'LOCUS': {'locus_name': '001R_FRG3G', 'status': 'Reviewed', 'size': 256, 'unit': 'aa'}}, None, Protein) # define a single DNA record uppercase (filepath) self.single_upper_fp = get_data_path('embl_single_record_upper') # define a single RNA record lower self.single_lower_fp = get_data_path('embl_single_record_lower') # define a single RNA record file path self.single_rna_fp = get_data_path('embl_single_record') # define a http://www.ebi.ac.uk/ena/browse/feature-level-products self.feature_level_fp = get_data_path("embl_feature_level_record") # define a interval metadata (see skbio.metadata.IntervalMetadata) imd = IntervalMetadata(63) # then add interval object to interval metadata. Add source imd.add([(0, 63)], [(False, False)], {'db_xref': '"taxon:562"', 'mol_type': '"mRNA"', 'organism': '"Escherichia coli"', 'type': 'source', 'strand': '+', '__location': '1..63'}) imd.add([(0, 63)], # the second True is beacause exact location is not known [(False, True)], {'phase': 0, 'db_xref': ['"GOA:P00634"', '"InterPro:IPR001952"', '"InterPro:IPR017849"', '"InterPro:IPR017850"', '"InterPro:IPR018299"', '"PDB:1AJA"', '"PDB:1AJB"', '"PDB:1AJC"', '"PDB:1AJD"', '"PDB:1ALH"', '"PDB:1ALI"', '"PDB:1ALJ"', '"PDB:1ALK"', '"PDB:1ANI"', '"PDB:1ANJ"', '"PDB:1B8J"', '"PDB:1ED8"', '"PDB:1ED9"', '"PDB:1ELX"', '"PDB:1ELY"', '"PDB:1ELZ"', '"PDB:1EW8"', '"PDB:1EW9"', '"PDB:1HJK"', '"PDB:1HQA"', '"PDB:1KH4"', '"PDB:1KH5"', '"PDB:1KH7"', '"PDB:1KH9"', '"PDB:1KHJ"', '"PDB:1KHK"', '"PDB:1KHL"', '"PDB:1KHN"', '"PDB:1URA"', '"PDB:1URB"', '"PDB:1Y6V"', '"PDB:1Y7A"', '"PDB:2ANH"', '"PDB:2G9Y"', '"PDB:2GA3"', '"PDB:2MLX"', '"PDB:2MLY"', '"PDB:2MLZ"', '"PDB:3BDF"', '"PDB:3BDG"', '"PDB:3BDH"', '"PDB:3CMR"', '"PDB:3DPC"', '"PDB:3DYC"', '"PDB:3TG0"', '"PDB:4KM4"', '"PDB:4YR1"', '"PDB:5C66"', '"PDB:5GAD"', '"PDB:5GAF"', '"PDB:5GAG"', '"PDB:5GAH"', '"PDB:5JTL"', '"PDB:5JTM"', '"PDB:5JTN"', '"PDB:5JTO"', '"PDB:5JTP"', '"UniProtKB/Swiss-Prot:P00634"'], '__location': '1..>63', 'strand': '+', 'note': '"alkaline phosphatase signal peptide"', 'protein_id': '"AAA23431.1"', 'transl_table': '11', 'translation': '"MKQSTIALAVLPLLFTPVTKA"', 'type': 'CDS'}) self.single_rna = ( 'gugaaacaaagcacuauugcacuggcugucuuaccguuacuguuuaccccugugacaaaagcc', {'LOCUS': {'locus_name': 'M14399', 'class': 'STD', 'division': 'PRO', 'mol_type': 'mRNA', 'shape': 'linear', 'size': 63, 'unit': 'bp', 'version': 1, 'date': '02-SEP-1999'}, 'ACCESSION': 'M14399;', # accessions (could be more than one) 'VERSION': 'M14399.1', # a genbank like version 'DATE': ["16-JUL-1988 (Rel. 16, Created)", "02-SEP-1999 (Rel. 60, Last updated, Version 3)"], 'DBSOURCE': 'MD5; c9b40131b8622946b5aafdf5473b3d43.', 'DEFINITION': "E.coli alkaline phosphatase signal mRNA, 5' end.", 'KEYWORDS': "alkaline phosphatase; signal peptide.", 'SOURCE': {"ORGANISM": "Escherichia coli", 'taxonomy': "Bacteria; Proteobacteria; " "Gammaproteobacteria; Enterobacterales; " "Enterobacteriaceae; Escherichia."}, 'REFERENCE': [{'AUTHORS': 'Gray G.L., Baldridge J.S., ' 'McKeown K.S., Heyneker H.L., ' 'Chang C.N.;', 'JOURNAL': 'Gene 39(2-3):247-254(1985).', 'REFERENCE': '1 (bases 1 to 63)', 'TITLE': '"Periplasmic production of correctly ' 'processed human growth hormone in ' 'Escherichia coli: natural and bacterial ' 'signal sequences are ' 'interchangeable";', 'PUBMED': '3912261'}], 'CROSS_REFERENCE': ['DOI; 10.1016/0378-1119(85)' '90319-1. PUBMED; 3912261.']}, imd, RNA) # define a multi record. File path self.multi_fp = get_data_path('embl_multi_records') # define interval metadata (as single metadata) imd1 = imd # define interal metadata for multi 2 imd2 = IntervalMetadata(743) # then add interval object to interval metadata. Add source imd2.add([(0, 743)], [(False, False)], {'organism': '"Ruditapes philippinarum"', 'type': 'source', '__location': '1..743', 'strand': '+', 'mol_type': '"mRNA"', 'db_xref': '"taxon:129788"'}) imd2.add([(57, 444)], [(False, False)], {'translation': '"MPGGKAGKDSGKAKAKAVSRSARAGLQFPVGRIHRHLKNRT' 'TSHG RVGATAAVYSAAILEYLTAEVLELAGNASKDLKVKRI' 'TPRHLQLAIRGDEELDSLIKAT IAGGGVIPHIHKSLIGKKG' 'GQQAK"', 'type': 'CDS', '__location': '58..444', 'protein_id': '"APY18893.1"', 'strand': '+', 'phase': 0, 'product': '"histone"'}) # multi object self.multi = ( ('GTGAAACAAAGCACTATTGCACTGGCTGTCTTACCGTTACTGTTTACCCCTGTGACAAAAGCC', {'LOCUS': {'locus_name': 'M14399', 'class': 'STD', 'division': 'PRO', 'mol_type': 'mRNA', 'shape': 'linear', 'size': 63, 'unit': 'bp', 'version': 1, 'date': '02-SEP-1999'}, 'ACCESSION': 'M14399;', # accessions (could be more than one) 'VERSION': 'M14399.1', # a genbank like version 'DATE': ["16-JUL-1988 (Rel. 16, Created)", "02-SEP-1999 (Rel. 60, Last updated, Version 3)"], 'DBSOURCE': 'MD5; c9b40131b8622946b5aafdf5473b3d43.', 'DEFINITION': "E.coli alkaline phosphatase signal mRNA, 5' end.", 'KEYWORDS': "alkaline phosphatase; signal peptide.", 'SOURCE': {"ORGANISM": "Escherichia coli", 'taxonomy': "Bacteria; Proteobacteria; " "Gammaproteobacteria; Enterobacterales; " "Enterobacteriaceae; Escherichia."}, 'REFERENCE': [{'AUTHORS': 'Gray G.L., Baldridge J.S., ' 'McKeown K.S., Heyneker H.L., ' 'Chang C.N.;', 'JOURNAL': 'Gene 39(2-3):247-254(1985).', 'REFERENCE': '1 (bases 1 to 63)', 'TITLE': '"Periplasmic production of correctly ' 'processed human growth hormone in ' 'Escherichia coli: natural and ' 'bacterial signal sequences are ' 'interchangeable";', 'PUBMED': '3912261'}], 'CROSS_REFERENCE': ['DOI; 10.1016/0378-1119(85)' '90319-1. PUBMED; 3912261.']}, imd1, DNA), ('TGTGCACAGTCTACGCGTCATCTTGAAAGAAAGAACTACACTACTCCAAAAATAATCATGCC' 'TGGTGGAAAAGCTGGTAAAGATTCCGGAAAGGCCAAGGCTAAGGCAGTGTCAAGGTCCGCAA' 'GAGCTGGCTTACAGTTTCCAGTCGGACGTATTCACAGGCATTTGAAGAACAGAACCACTAGC' 'CACGGTCGTGTTGGAGCTACAGCAGCCGTTTACAGTGCAGCAATCCTTGAATACCTGACCGC' 'CGAAGTGCTTGAGTTGGCTGGAAACGCAAGTAAAGATCTCAAAGTAAAGAGAATCACCCCAC' 'GTCACTTGCAGTTGGCAATCAGAGGAGATGAAGAGTTGGATTCCCTAATTAAAGCCACAATC' 'GCTGGTGGTGGTGTTATTCCACATATCCACAAGTCACTTATTGGCAAGAAGGGAGGTCAGCA' 'AGCCAAATAAATTGGACATACTCATTCATCAGGGAACAATGTGTAGTGAATGTGTTAAAAAG' 'AACAATCTCATTGTGTAGCTCTTTAGTTTTATATGAATGTGTTAACATGGTCATTCACATCG' 'TATGACTCATAGAATCATCTGTGTATCATTTCATCCTCTCATTTTATAGCTCCTCATTTTCC' 'TTAGACTCATTAAAATTTTTATCTCGGAAAAATGTTTTTTCTACAATTTTAGCATTCATTTA' 'TCTTCATCTTGCTTTTATGTTTAATAAAACGAACTTATAATACCAAAAAAAAAAAAAAAAA', {'ACCESSION': 'KX454487;', 'VERSION': 'KX454487.1', 'COMMENT': '##Assembly-Data-START##\nSequencing Technology ' ':: Sanger dideoxy sequencing\n##Assembly-Data-END##', 'DATE': ['02-FEB-2017 (Rel. 131, Created)', '02-FEB-2017 (Rel. 131, Last updated, Version 1)'], 'DBSOURCE': 'MD5; cbc730cf7a8d694b50fb7dd6b993ae0d.', 'DEFINITION': 'Ruditapes philippinarum histone mRNA, ' 'complete cds.', 'KEYWORDS': '.', 'LOCUS': {'locus_name': 'KX454487', 'class': 'STD', 'division': 'INV', 'mol_type': 'mRNA', 'shape': 'linear', 'size': 743, 'unit': 'bp', 'version': 1, 'date': '02-FEB-2017'}, 'REFERENCE': [ {'AUTHORS': 'Yang D., Zhao J., Wang Q.;', 'JOURNAL': 'Submitted (27-JUN-2016) to the INSDC. Key ' 'Laboratory of Coastal Zone Environment Processes ' 'and Ecological Remediation, Yantai Institute ' 'of Coastal Zone Research (YIC), Chinese Academy ' 'of Sciences (CAS), 17 Chunhui Road, Laishan ' 'District, Yantai, Shandong 264003, China', 'REFERENCE': '1 (bases 1 to 743)', 'TITLE': ';'}], 'CROSS_REFERENCE': [None], 'SOURCE': { 'ORGANISM': 'Ruditapes philippinarum', 'taxonomy': 'Eukaryota; Metazoa; Lophotrochozoa; Mollusca; ' 'Bivalvia; Heteroconchia; Euheterodonta; ' 'Veneroida; Veneroidea; Veneridae; Ruditapes.'}}, imd2, DNA)) # define the feature level product obj self.feature_level = ( 'AAUUGAAGAGUUUGAUCAUGGCUCAGAUUGAACGCUGGCGGCAGGCCUAACACAUGCAAGUC' 'GAGCGGCAGCACAGAGGAACUUGUUCCUUGGGUGGCGAGCGGCGGACGGGUGAGUAAUGCCU' 'AGGAAAUUGCCCUGAUGUGGGGGAUAACCAUUGGAAACGAUGGCUAAUACCGCAUGAUGCCU' 'ACGGGCCAAAGAGGGGGACCUUCUGGCCUCUCGCGUCAGGAUAUGCCUAGGUGGGAUUAGCU' 'AGUUGGUGAGGUAAUGGCUCACCAAGGCGACGAUCCCUAGCUGGUCUGAGAGGAUGAUCAGC' 'CACACUGGAACUGAGACACGGUCCAGACUCCUACGGGAGGCAGCAGUGGGGAAUAUUGCACA' 'AUGGGCGCAAGCCUGAUGCAGCCAUGCCGCGUGUAUGAAGAAGGCCUUCGGGUUGUAAAGUA' 'CUUUCAGUCGUGAGGAAGGUGGUGUUGUUAAUAGCAGCAUCAUUUGACGUUAGCGACAGAAG' 'AAGCACCGGCUAACUCCGUGCCAGCAGCCGCGGUAAUACGGAGGGUGCGAGCGUUAAUCGGA' 'AUUACUGGGCGUAAAGCGCAUGCAGGUGGUGGAUUAAGUCAGAUGUGAAAGCCCGGGGCUCA' 'ACCUCGGAACCGCAUUUGAAACUGGUUCACUAGAGUACUGUAGAGGGGGGUAGAAUUUCAGG' 'UGUAGCGGUGAAAUGCGUAGAGAUCUGAAGGAAUACCGGUGGCGAAGGCGGCCCCCUGGACA' 'GAUACUGACACUCAGAUGCGAAAGCGUGGGGAGCAAACAGGAUUAGAUACCCUGGUAGUCCA' 'CGCCGUAAACGAUGUCUACUUGGAGGUUGUGGCCUUGAGCCGUGGCUUUCGGAGCUAACGCG' 'UUAAGUAGACCGCCUGGGGAGUACGGUCGCAAGAUUAAAACUCAAAUGAAUUGACGGGGGCC' 'CGCACAAGCGGUGGAGCAUGUGGUUUAAUUCGAUGCAACGCGAAGAACCUUACCUACUCUUG' 'ACAUCCAGAGAAGCCAGCGGAGACGCAGGUGUGCCUUCGGGAGCUCUGAGACAGGUGCUGCA' 'UGGCUGUCGUCAGCUCGUGUUGUGAAAUGUUGGGUUAAGUCCCGCAACGAGCGCAACCCUUA' 'UCCUUGUUUGCCAGCGAGUCAUGUCGGGAACUCCAGGGAGACUGCCGGUGAUAAACCGGAGG' 'AAGGUGGGGACGACGUCAAGUCAUCAUGGCCCUUACGAGUAGGGCUACACACGUGCUACAAU' 'GGCGCAUACAGAGGGCAGCAAGCUAGCGAUAGUGAGCGAAUCCCAAAAAGUGCGUCGUAGUC' 'CGGAUUGGAGUCUGCAACUCGACUCCAUGAAGUCGGAAUCGCUAGUAAUCGUAGAUCAGAAU' 'GCUACGGUGAAUACGUUCCCGGGCCUUGUACACACCGCCCGUCACACCAUGGGAGUGGGCUG' 'CAAAAGAAGUGGGUAGUUUAACCUUUCGGGGAGGACGCUCACCACUUUGUGGUUCAUGACUG' 'GGGUGAAGUCGUAACAAGGUAGCGCUAGGGGAACCUGGCGCUGGAUCACCUCCUUA', {'DATE': ['02-JUN-2014 (Rel. 121, Created)', '04-FEB-2016 (Rel. 127, Last updated, Version 5)'], 'DBSOURCE': 'SILVA-LSU; LK021130. SILVA-SSU; LK021130. MD5; ' 'afd116bf2c1a13acbf40d63d82f0218c. BioSample; ' 'SAMEA3865288.', 'DEFINITION': 'Vibrio anguillarum 16S rRNA', 'KEYWORDS': '.', 'LOCUS': {'locus_name': 'LK021130.1:74067..75610:rRNA', 'class': 'STD', 'division': 'PRO', 'mol_type': 'genomic DNA', 'shape': 'linear', 'size': 1544, 'unit': 'bp', 'version': 1, 'date': '04-FEB-2016'}, 'PARENT_ACCESSION': 'LK021130.1', 'VERSION': 'LK021130.1', 'PROJECT_IDENTIFIER': 'Project:PRJEB5701;', 'REFERENCE': [ {'AUTHORS': 'Holm K.;', 'JOURNAL': 'Submitted (26-MAR-2014) to the INSDC. ' 'Norstruct, Dept of Chemistry, University of ' 'Tromso, Science Park 3, NO-9037 Tromso, NORWAY.', 'TITLE': ';', 'REFERENCE': '1'}, {'AUTHORS': 'Holm K.O., Nilsson K., Hjerde E., Willassen ' 'N.P., Milton D.L.;', 'JOURNAL': 'Stand Genomic Sci. 10:60-60(2015).', 'TITLE': '"Complete genome sequence of Vibrio anguillarum ' 'strain NB10, a virulent isolate from the Gulf ' 'of Bothnia";', 'REFERENCE': '2', 'PUBMED': '26380645'}], 'CROSS_REFERENCE': [ None, 'DOI; 10.1186/s40793-015-0060-7. PUBMED; 26380645.'], 'SOURCE': { 'ORGANISM': 'Vibrio anguillarum', 'taxonomy': 'Bacteria; Proteobacteria; Gammaproteobacteria; ' 'Vibrionales; Vibrionaceae; Vibrio.'}}, None, RNA) # get the feature level file without FT self.feature_level_fp = get_data_path( "embl_feature_level_record_no_FT") # get a genbank file in order to to file conversion self.genbank_fp = get_data_path('genbank_single_record') # a embl constructed sequence file path self.embl_constructed_fp = get_data_path("embl_constructed") # a simple embl version to perform embl->gb->embl conversion self.single_rna_simple_fp = get_data_path( "embl_single_record_simple") class ReaderTests(EMBLIOTests): """Implements test for reading EMBL data""" def test_parse_id(self): """Parse ID record (first line of embl format)""" for serialized, parsed in self.id: self.assertEqual(_parse_id(serialized), parsed) def test_parse_id_invalid(self): lines = [ # uniprot line (should this module handle it?) ['ID 001R_FRG3G Reviewed; 256 AA.'], # missing unit ['ID M14399; SV 1; linear; mRNA; STD; PRO; 63'], # missing division ['ID M14399; SV 1; linear; mRNA; STD; 63 BP.']] for line in lines: with self.assertRaisesRegex(EMBLFormatError, r'Could not parse the ID line:.*'): _parse_id(line) # current status of protein support is described in issue-1499 # https://github.com/biocore/scikit-bio/issues/1499 def test_no_protein_support(self): """Testing no protein support for embl""" # TODO: add protein support # a fake protein line. handle = io.StringIO('ID M14399; SV 1; linear; mRNA; STD; ' 'PRO; 63 AA.\n//\n') with self.assertRaisesRegex(EMBLFormatError, r"There's no protein support for EMBL " "record"): # read a protein record Protein.read(handle) # return to 0 handle.seek(0) with self.assertRaisesRegex(EMBLFormatError, r"There's no protein support for EMBL " "record"): # read a generic record skbio.io.read(handle, format='embl') def test_parse_reference(self): lines = ''' RP 1-63 RX DOI; 10.1016/0378-1119(85)90319-1. RX PUBMED; 3912261. RA Gray G.L., Baldridge J.S., McKeown K.S., Heyneker H.L., Chang C.N.; RT "Periplasmic production of correctly processed human growth hormone in RT Escherichia coli: natural and bacterial signal sequences are RT interchangeable"; RL Gene 39(2-3):247-254(1985).'''.split('\n') # DNA, Sequence and RNA data contain newlines lines = [line+"\n" for line in lines if line != ''] exp = {'AUTHORS': 'Gray G.L., Baldridge J.S., ' 'McKeown K.S., Heyneker H.L., Chang C.N.;', 'JOURNAL': 'Gene 39(2-3):247-254(1985).', 'CROSS_REFERENCE': 'DOI; 10.1016/0378-1119(85)90319-1. ' 'PUBMED; 3912261.', 'REFERENCE': '(bases 1 to 63)', 'TITLE': '"Periplasmic production of correctly processed ' 'human growth hormone in Escherichia coli: ' 'natural and bacterial signal sequences are ' 'interchangeable";', 'PUBMED': '3912261' } # read reference obs = _parse_reference(lines) # See all differences self.maxDiff = None self.assertEqual(obs, exp) def test_parse_assembly(self): lines = """ AH LOCAL_SPAN PRIMARY_IDENTIFIER PRIMARY_SPAN COMP AS 1-426 AC004528.1 18665-19090 AS 427-526 AC001234.2 1-100 c AS 527-1000 TI55475028 not_available """.split('\n') # DNA, Sequence and RNA data contain newlines lines = [line+"\n" for line in lines if line != ''] exp = [ { 'local_span': '1-426', 'primary_identifier': 'AC004528.1', 'primary_span': '18665-19090', 'comp': '' }, { 'local_span': '427-526', 'primary_identifier': 'AC001234.2', 'primary_span': '1-100', 'comp': 'c' }, { 'local_span': '527-1000', 'primary_identifier': 'TI55475028', 'primary_span': 'not_available', 'comp': '' } ] # read reference obs = _parse_assembly(lines) # See all differences self.maxDiff = None self.assertEqual(obs, exp) def test_parse_bad_assembly(self): """test for a wrong assembly line""" lines = """ AH LOCAL_SPAN PRIMARY_IDENTIFIER PRIMARY_SPAN COMP AS 1-426 AC004528.1 """.split("\n") # DNA, Sequence and RNA data contain newlines lines = [line+"\n" for line in lines if line != ''] with self.assertRaisesRegex(EMBLFormatError, r"Can't parse assembly line"): # read a malformed assembly record _parse_assembly(lines) def test_embl_to_generator_single(self): # test single record and uppercase sequence for c in [Sequence, DNA]: obs = next(_embl_to_generator( self.single_upper_fp, constructor=c)) exp = c(self.single[0], metadata=self.single[1], positional_metadata=self.single[2], lowercase=True) self.assertEqual(exp, obs) def test_get_embl_section(self): """Verify to have a section for each embl ID""" with open(self.single_rna_fp) as fh: for line in fh: if line.startswith("//"): continue # test that this function doesn't raise exceptions try: _get_embl_section(line) except KeyError as err: raise EMBLFormatError("Key {0} isn't defined in embl." "KEYS_2_SECTIONS".format(err)) def test_embl_to_generator(self): for i, obs in enumerate(_embl_to_generator(self.multi_fp)): seq, md, imd, constructor = self.multi[i] exp = constructor(seq, metadata=md, lowercase=True, interval_metadata=imd) self.assertEqual(exp, obs) def test_embl_to_sequence(self): for i, exp in enumerate(self.multi): obs = _embl_to_sequence(self.multi_fp, seq_num=i+1) exp = Sequence(exp[0], metadata=exp[1], lowercase=True, interval_metadata=exp[2]) self.assertEqual(exp, obs) def test_embl_to_rna(self): seq, md, imd, constructor = self.single_rna obs = _embl_to_rna(self.single_rna_fp) exp = constructor(seq, metadata=md, lowercase=True, interval_metadata=imd) self.assertEqual(exp, obs) def test_embl_to_dna(self): i = 1 exp = self.multi[i] obs = _embl_to_dna(self.multi_fp, seq_num=i+1) exp = DNA(exp[0], metadata=exp[1], lowercase=True, interval_metadata=exp[2]) self.assertEqual(exp, obs) # current status of protein support is described in issue-1499 # https://github.com/biocore/scikit-bio/issues/1499 def test_embl_to_protein(self): # TODO: add protein support i = 0 # there is no support for protein at the moment # when protein support will be added, this code must work # exp = self.multi[i] # obs = _embl_to_protein(self.multi_fp, seq_num=i+1) # exp = Protein(exp[0], metadata=exp[1], # lowercase=True, interval_metadata=exp[2]) # self.assertEqual(exp, obs) with self.assertRaisesRegex(EMBLFormatError, r"There's no protein support for EMBL " "record"): # read a generic record _embl_to_protein(self.multi_fp, seq_num=i+1) # deal with feature-level-products: ignore feature table def test_feature_level_products(self): seq, md, imd, constructor = self.feature_level obs = _embl_to_rna(self.feature_level_fp) exp = constructor(seq, metadata=md, lowercase=True, interval_metadata=imd) self.assertEqual(obs, exp) # deal with constructed sequences: ignore interval metadata def test_constructed_sequences(self): with self.assertRaisesRegex( EMBLFormatError, r"There's no support for embl CON record"): _embl_to_dna(self.embl_constructed_fp) class WriterTests(EMBLIOTests): def test_serialize_id(self): for serialized, parsed in self.id: self.assertEqual( _serialize_id('ID', parsed), serialized[0] + '\n') def test_serialize_dbsource(self): """Serialize a complex dbsource entry""" # test with a complex uniprot dbsource exp = """DR EMBL; AY548484; AAT09660.1; -; Genomic_DNA. DR RefSeq; YP_031579.1; NC_005946.1. DR ProteinModelPortal; Q6GZX4; -. DR SwissPalm; Q6GZX4; -. DR GeneID; 2947773; -. DR KEGG; vg:2947773; -. DR Proteomes; UP000008770; Genome. """ # split by lines lines = [line+"\n" for line in exp.split("\n") if line != ''] # parse objects parsed = _embl_parse_section_default(lines) # now serialize them obs = _serialize_dbsource("DR", parsed) # test objects self.assertEqual(obs, exp) def test_generator_to_embl(self): seq, md, imd, constructor = self.single obj = constructor(seq, md, interval_metadata=imd, lowercase=True) with io.StringIO() as fh: _generator_to_embl([obj], fh) obs = fh.getvalue() with open(self.single_lower_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_sequence_to_embl(self): with io.StringIO() as fh: for i, (seq, md, imd, constructor) in enumerate(self.multi): obj = Sequence(seq, md, interval_metadata=imd) _sequence_to_embl(obj, fh) obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_dna_to_embl(self): with io.StringIO() as fh: for i, (seq, md, imd, constructor) in enumerate(self.multi): obj = constructor( seq, md, interval_metadata=imd, lowercase=True) _dna_to_embl(obj, fh) # read all records written obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) # TODO: add support for protein # current status of protein support is described in issue-1499 # https://github.com/biocore/scikit-bio/issues/1499 def test_protein_to_embl(self): seq, md, imd, constructor = self.protein obj = constructor(seq, md, interval_metadata=imd) with io.StringIO() as fh: self.assertRaisesRegex(EMBLFormatError, r"There's no protein support for EMBL " "record", _protein_to_embl, [obj], fh) def test_rna_to_embl(self): with io.StringIO() as fh: seq, md, imd, constructor = self.single_rna obj = constructor(seq, md, interval_metadata=imd, lowercase=True) _rna_to_embl(obj, fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_rna_to_embl_flp(self): """Test writing feature level products""" with io.StringIO() as fh: seq, md, imd, constructor = self.feature_level obj = constructor(seq, md, interval_metadata=imd, lowercase=True) _rna_to_embl(obj, fh) obs = fh.getvalue() with open(self.feature_level_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) class RoundtripTests(EMBLIOTests): def test_roundtrip_generator(self): with io.StringIO() as fh: _generator_to_embl(_embl_to_generator(self.multi_fp), fh) obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_rna(self): with io.StringIO() as fh: _rna_to_embl(_embl_to_rna(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_dna(self): with io.StringIO() as fh: _dna_to_embl(_embl_to_dna(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) # TODO: test_roundtrip_protein # current status of protein support is described in issue-1499 # https://github.com/biocore/scikit-bio/issues/1499 def test_roundtrip_sequence(self): with io.StringIO() as fh: _sequence_to_embl(_embl_to_sequence(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) class Convertertest(EMBLIOTests): def test_gb_to_embl(self): genbank = DNA.read(self.genbank_fp, format="genbank") with io.StringIO() as fh: DNA.write(genbank, format="embl", file=fh) # EMBL can't deal with genbank version (ie M14399.1 GI:145229) # read embl data and write to gb fh.seek(0) embl = DNA.read(fh, format="embl") with io.StringIO() as fh: DNA.write(embl, format="genbank", file=fh) # read gb data obs = fh.getvalue() with open(self.genbank_fp) as fh: exp = fh.read() self.assertEqual(exp, obs) def test_embl_to_gb(self): # EMBL records have more features than genbank, (ex more than one date, # embl class, DOI cross references) so I can't convert an embl to gb # and then to embl keeping all those data. But I can start from # genbank record # do embl file -> embl object -> gb file -> gb object -> # embl file. Ensure that first and last files are identical embl = DNA.read(self.single_rna_simple_fp, format="embl") # "write" genbank record in a embl file with io.StringIO() as fh: DNA.write(embl, format="genbank", file=fh) # read genbank file fh.seek(0) genbank = DNA.read(fh, format="genbank") # "write" genbank record in a embl file with io.StringIO() as fh: DNA.write(genbank, format="embl", file=fh) # read file object obs = fh.getvalue() # test objects with open(self.single_rna_simple_fp) as fh: exp = fh.read() self.assertEqual(exp, obs) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_emptyfile.py000066400000000000000000000021111446255456000233470ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import io from skbio.io.format.emptyfile import _empty_file_sniffer class TestEmptyFile(unittest.TestCase): def test_empty(self): res, kw = _empty_file_sniffer(io.StringIO()) self.assertTrue(res) self.assertEqual({}, kw) res, kw = _empty_file_sniffer(io.StringIO(" \n \t ")) self.assertTrue(res) self.assertEqual({}, kw) def test_not_empty(self): res, kw = _empty_file_sniffer(io.StringIO("a")) self.assertFalse(res) self.assertEqual({}, kw) res, kw = _empty_file_sniffer(io.StringIO(" \n \ta")) self.assertFalse(res) self.assertEqual({}, kw) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_fasta.py000066400000000000000000001350561446255456000224660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import copy import io import string from unittest import TestCase, main from functools import partial import numpy as np from skbio import Sequence, DNA, RNA, Protein, TabularMSA from skbio.io import FASTAFormatError, QUALFormatError from skbio.io.format.fasta import ( _fasta_sniffer, _fasta_to_generator, _fasta_to_sequence, _fasta_to_dna, _fasta_to_rna, _fasta_to_protein, _fasta_to_tabular_msa, _generator_to_fasta, _sequence_to_fasta, _dna_to_fasta, _rna_to_fasta, _protein_to_fasta, _tabular_msa_to_fasta) from skbio.sequence import GrammaredSequence from skbio.util import get_data_path from skbio.util import classproperty from skbio.util._decorator import overrides class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set(string.ascii_letters) @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {} class SnifferTests(TestCase): def setUp(self): self.positive_fps = list(map(get_data_path, [ 'fasta_5_blanks_start_of_file', 'fasta_5_ws_lines_start_of_file', 'fasta_blanks_end_of_file', 'fasta_ws_lines_end_of_file', 'fasta_blank_lines_between_records', 'fasta_3_seqs_defaults', 'fasta_max_width_1', 'fasta_single_bio_seq_non_defaults', 'fasta_single_prot_seq_non_defaults', 'fasta_3_seqs_non_defaults', 'fasta_max_width_5', 'fasta_single_dna_seq_defaults', 'fasta_single_rna_seq_defaults', 'fasta_description_newline_replacement_empty_str', 'fasta_multi_seq', 'fasta_single_dna_seq_non_defaults', 'fasta_single_rna_seq_non_defaults', 'fasta_description_newline_replacement_multi_char', 'fasta_prot_seqs_odd_labels', 'fasta_single_seq', 'fasta_id_whitespace_replacement_empty_str', 'fasta_tabular_msa_different_type', 'fasta_id_whitespace_replacement_multi_char', 'fasta_single_bio_seq_defaults', 'fasta_single_prot_seq_defaults', 'fasta_10_seqs', 'fasta_invalid_after_10_seqs', 'fasta_mixed_qual_scores', 'qual_3_seqs_non_defaults' ])) self.negative_fps = list(map(get_data_path, [ 'empty', 'whitespace_only', 'fasta_invalid_missing_header', 'fasta_invalid_blank_line_after_header', 'fasta_invalid_blank_sequence', 'fasta_invalid_blank_line_within_sequence', 'fasta_invalid_whitespace_only_line_within_sequence', 'fasta_invalid_whitespace_line_after_header', 'fasta_invalid_missing_seq_data_first', 'fasta_invalid_missing_seq_data_middle', 'fasta_invalid_missing_seq_data_last', 'fasta_invalid_legacy_format', 'fasta_invalid_whitespace_only_sequence', 'fasta_id_whitespace_replacement_none', 'fasta_description_newline_replacement_none', 'fasta_6_blanks_start_of_file', 'fasta_6_ws_lines_start_of_file', 'qual_2_seqs_defaults', 'qual_3_seqs_defaults', 'qual_3_seqs_defaults_desc_mismatch', 'qual_3_seqs_defaults_extra', 'qual_3_seqs_defaults_id_mismatch', 'qual_3_seqs_defaults_length_mismatch', 'qual_description_newline_replacement_empty_str', 'qual_description_newline_replacement_multi_char', 'qual_description_newline_replacement_none', 'qual_id_whitespace_replacement_empty_str', 'qual_id_whitespace_replacement_multi_char', 'qual_id_whitespace_replacement_none', 'qual_invalid_blank_line_within_seq', 'qual_invalid_legacy_format', 'qual_invalid_missing_header', 'qual_invalid_missing_qual_scores_first', 'qual_invalid_missing_qual_scores_last', 'qual_invalid_missing_qual_scores_middle', 'qual_invalid_whitespace_line_in_seq', 'qual_invalid_blank_line_after_header', 'qual_invalid_blank_sequence', 'qual_invalid_whitespace_only_sequence', 'qual_invalid_ws_line_after_header', 'qual_invalid_qual_scores_float', 'qual_invalid_qual_scores_string', 'qual_max_width_1', 'qual_max_width_5', 'qual_multi_seq', 'qual_multi_seq_roundtrip', 'qual_prot_seqs_odd_labels', 'qual_tabular_msa_different_type', 'qual_single_bio_seq_non_defaults', 'qual_single_dna_seq_non_defaults', 'qual_single_prot_seq_non_defaults', 'qual_single_rna_seq_non_defaults', 'qual_single_seq', 'qual_ws_lines_between_records', 'qual_blank_lines_between_records', 'qual_5_blanks_start_of_file', 'qual_5_ws_lines_start_of_file', 'qual_6_blanks_start_of_file', 'qual_6_ws_lines_start_of_file', 'qual_blanks_end_of_file', 'qual_ws_lines_end_of_file' ])) def test_positives(self): for fp in self.positive_fps: self.assertEqual(_fasta_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negative_fps: self.assertEqual(_fasta_sniffer(fp), (False, {})) class ReaderTests(TestCase): def setUp(self): # each structure stores the sequence generator results (expanded into a # list) that we expect to obtain from reading, matched with kwargs to # pass to the reader, and fasta and qual filepaths that should # deserialize into the expected generator results # empty file shouldn't yield sequences self.empty = ([], {}, list(map(get_data_path, ['empty', 'whitespace_only'])), list(map(get_data_path, ['empty', 'whitespace_only']))) # single sequence self.single = ( [Sequence( 'ACGT-acgt.', metadata={'id': 'seq1', 'description': 'desc1'}, positional_metadata={'quality': np.asarray([10, 20, 30, 10, 0, 0, 0, 255, 1, 255], dtype=np.uint8)})], {}, list(map(get_data_path, ['fasta_single_seq', 'fasta_max_width_1'])), list(map(get_data_path, ['qual_single_seq', 'qual_max_width_1'])) ) # multiple sequences self.multi = ( [Sequence( 'ACGT-acgt.', metadata={'id': 'seq1', 'description': 'desc1'}, positional_metadata={'quality': np.asarray([10, 20, 30, 10, 0, 0, 0, 255, 1, 255], dtype=np.uint8)}), Sequence('A', metadata={'id': '_____seq__2_', 'description': ''}, positional_metadata={'quality': np.asarray([42], dtype=np.uint8)}), Sequence( 'AACGGuA', metadata={'id': '', 'description': 'desc3'}, positional_metadata={'quality': np.asarray([0, 0, 0, 0, 0, 0, 0], dtype=np.uint8)}), Sequence( 'ACGTTGCAccGG', metadata={'id': '', 'description': ''}, positional_metadata={'quality': np.asarray([55, 10, 0, 99, 1, 1, 8, 77, 40, 10, 10, 0], dtype=np.uint8)}), Sequence('ACGUU', metadata={'id': '', 'description': ''}, positional_metadata={'quality': np.asarray([10, 9, 8, 7, 6], dtype=np.uint8)}), Sequence( 'pQqqqPPQQQ', metadata={'id': 'proteinseq', 'description': 'detailed description \t\twith new lines'}, positional_metadata={'quality': np.asarray([42, 42, 255, 255, 42, 42, 42, 42, 42, 43], dtype=np.uint8)})], {}, list(map(get_data_path, ['fasta_multi_seq', 'fasta_max_width_5', 'fasta_blank_lines_between_records', 'fasta_ws_lines_between_records', 'fasta_5_blanks_start_of_file', 'fasta_5_ws_lines_start_of_file', 'fasta_6_blanks_start_of_file', 'fasta_6_ws_lines_start_of_file', 'fasta_blanks_end_of_file', 'fasta_ws_lines_end_of_file'])), list(map(get_data_path, ['qual_multi_seq', 'qual_max_width_5', 'qual_blank_lines_between_records', 'qual_ws_lines_between_records', 'qual_5_blanks_start_of_file', 'qual_5_ws_lines_start_of_file', 'qual_6_blanks_start_of_file', 'qual_6_ws_lines_start_of_file', 'qual_blanks_end_of_file', 'qual_ws_lines_end_of_file'])) ) # test constructor parameter, as well as odd labels (label only # containing whitespace, label description preceded by multiple spaces, # no id) and leading/trailing whitespace on sequence data. for qual # files, in addition to the odd labels, test leading/trailing # whitespace on qual scores, as well as strange number formatting. # also test that fasta and qual headers do not need to match # exactly, only that they need to match exactly after parsing (e.g., # after stripping leading/trailing whitespace from descriptions) self.odd_labels_different_type = ( [Protein('DEFQfp', metadata={'id': '', 'description': ''}, positional_metadata={'quality': np.asarray([0, 0, 1, 5, 44, 0], dtype=np.uint8)}, validate=False), Protein( 'SKBI', metadata={'id': '', 'description': 'skbio'}, positional_metadata={'quality': np.asarray([1, 2, 33, 123], dtype=np.uint8)})], {'constructor': partial(Protein, validate=False)}, list(map(get_data_path, ['fasta_prot_seqs_odd_labels'])), list(map(get_data_path, ['qual_prot_seqs_odd_labels'])) ) # sequences that can be loaded into a TabularMSA self.tabular_msa_different_type = ( [RNA('aUG', metadata={'id': '', 'description': ''}, positional_metadata={'quality': np.asarray([20, 20, 21], dtype=np.uint8)}, lowercase='introns'), RNA('AuC', metadata={'id': 'rnaseq-1', 'description': 'rnaseq desc 1'}, positional_metadata={'quality': np.asarray([10, 9, 10], dtype=np.uint8)}, lowercase='introns'), RNA('AUg', metadata={'id': 'rnaseq-2', 'description': 'rnaseq desc 2'}, positional_metadata={'quality': np.asarray([9, 99, 99], dtype=np.uint8)}, lowercase='introns')], {'constructor': partial(RNA, lowercase='introns')}, list(map(get_data_path, ['fasta_tabular_msa_different_type'])), list(map(get_data_path, ['qual_tabular_msa_different_type'])) ) self.lowercase_seqs = ( [DNA('TAcg', metadata={'id': 'f-o-o', 'description': 'b_a_r'}, positional_metadata={'quality': np.asarray([0, 1, 2, 3], dtype=np.uint8)}, lowercase='introns')], {'constructor': DNA, 'lowercase': 'introns'}, list(map(get_data_path, ['fasta_single_dna_seq_non_defaults'])), list(map(get_data_path, ['qual_single_dna_seq_non_defaults'])) ) # store fasta filepath, kwargs, error type, and expected error message # for invalid input. # # note: there is some duplication in testing that fasta and qual # parsers raise expected errors. even though the parsers share the same # underlying logic, these tests are here as a safeguard in case the # code is refactored in the future such that fasta and qual have # different implementations (e.g., if qual is written in cython while # fasta remains in python) self.invalid_fps = list(map(lambda e: (get_data_path(e[0]), e[1], e[2], e[3]), [ # fasta and qual missing header ('fasta_invalid_missing_header', {}, FASTAFormatError, r'non-header.*1st'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_missing_header')}, QUALFormatError, r'non-header.*1st'), # fasta and qual with blank line within sequence ('fasta_invalid_blank_line_within_sequence', {}, FASTAFormatError, r'whitespace-only'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_blank_line_within_seq')}, QUALFormatError, r'whitespace-only'), # fasta and qual with blank after header ('fasta_invalid_blank_sequence', {}, FASTAFormatError, r'without sequence data'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_blank_sequence')}, QUALFormatError, r'without quality scores'), # fasta and qual with whitespace only sequence ('fasta_invalid_whitespace_only_sequence', {}, FASTAFormatError, r'without sequence data'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_whitespace_only_sequence')}, QUALFormatError, r'without quality scores'), # fasta and qual with blank line within sequence ('fasta_invalid_blank_line_after_header', {}, FASTAFormatError, r'whitespace-only'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_blank_line_after_header')}, QUALFormatError, r'whitespace-only'), # fasta and qual with whitespace-only line within sequence ('fasta_invalid_whitespace_only_line_within_sequence', {}, FASTAFormatError, r'whitespace-only'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_whitespace_line_in_seq')}, QUALFormatError, r'whitespace-only'), # fasta and qual with whitespace-only line after header ('fasta_invalid_whitespace_line_after_header', {}, FASTAFormatError, r'whitespace-only'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_ws_line_after_header')}, QUALFormatError, r'whitespace-only'), # fasta and qual missing record data (first record) ('fasta_invalid_missing_seq_data_first', {}, FASTAFormatError, r'without sequence data'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_missing_qual_scores_first')}, QUALFormatError, r'without quality scores'), # fasta and qual missing record data (middle record) ('fasta_invalid_missing_seq_data_middle', {}, FASTAFormatError, r'without sequence data'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_missing_qual_scores_middle')}, QUALFormatError, r'without quality scores'), # fasta and qual missing record data (last record) ('fasta_invalid_missing_seq_data_last', {}, FASTAFormatError, r'without sequence data'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_missing_qual_scores_last')}, QUALFormatError, r'without quality scores'), # fasta and qual in legacy format (;) ('fasta_invalid_legacy_format', {}, FASTAFormatError, r'non-header.*1st'), ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_legacy_format')}, QUALFormatError, r'non-header.*1st'), # qual file with an extra record ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_3_seqs_defaults_extra')}, FASTAFormatError, r'QUAL file has more'), # fasta file with an extra record ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_2_seqs_defaults')}, FASTAFormatError, r'FASTA file has more'), # id mismatch between fasta and qual ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_3_seqs_defaults_id_mismatch')}, FASTAFormatError, r'IDs do not match.*\'s_e_q_2\' != \'s_e_q_42\''), # description mismatch between fasta and qual ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_3_seqs_defaults_desc_mismatch')}, FASTAFormatError, r'Descriptions do not match.*\'desc 2\' != \'desc 42\''), # sequence and quality score length mismatch between fasta and qual ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_3_seqs_defaults_length_mismatch')}, ValueError, r'Number of positional metadata values \(3\) must match the ' r'positional metadata axis length \(4\)\.'), # invalid qual scores (string value can't be converted to integer) ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_qual_scores_string')}, QUALFormatError, r'quality scores to integers:\n100 0 1a -42'), # invalid qual scores (float value can't be converted to integer) ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_qual_scores_float')}, QUALFormatError, r'quality scores to integers:\n42 41.0 39 40'), # invalid qual scores (negative integer) ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_qual_scores_negative')}, QUALFormatError, r'Quality scores must be greater than or equal to zero\.'), # invalid qual scores (over 255) ('fasta_3_seqs_defaults', {'qual': get_data_path('qual_invalid_qual_scores_over_255')}, QUALFormatError, r'quality score\(s\) greater than 255'), # misc. invalid files used elsewhere in the tests ('fasta_invalid_after_10_seqs', {}, FASTAFormatError, r'without sequence data'), ('fasta_id_whitespace_replacement_none', {}, FASTAFormatError, r'whitespace-only'), ('fasta_description_newline_replacement_none', {}, FASTAFormatError, r'whitespace-only') ])) # extensive tests for fasta -> generator reader since it is used by all # other fasta -> object readers def test_fasta_to_generator_valid_files(self): test_cases = (self.empty, self.single, self.multi, self.odd_labels_different_type, self.tabular_msa_different_type, self.lowercase_seqs) # Strategy: # for each fasta file, read it without its corresponding qual file, # and ensure observed vs. expected match, ignoring quality scores in # expected. next, parse the current fasta file with each # corresponding quality file and ensure that observed vs. expected # match, this time taking quality scores into account. this # sufficiently exercises parsing a standalone fasta file and paired # fasta/qual files for exp, kwargs, fasta_fps, qual_fps in test_cases: for fasta_fp in fasta_fps: obs = list(_fasta_to_generator(fasta_fp, **kwargs)) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): e = copy.copy(e) del e.positional_metadata['quality'] self.assertEqual(o, e) for qual_fp in qual_fps: obs = list(_fasta_to_generator(fasta_fp, qual=qual_fp, **kwargs)) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): self.assertEqual(o, e) def test_fasta_to_generator_invalid_files(self): for fp, kwargs, error_type, error_msg_regex in self.invalid_fps: with self.assertRaisesRegex(error_type, error_msg_regex): list(_fasta_to_generator(fp, **kwargs)) # light testing of fasta -> object readers to ensure interface is present # and kwargs are passed through. extensive testing of underlying reader is # performed above def test_fasta_to_any_sequence(self): for constructor, reader_fn in ((Sequence, _fasta_to_sequence), (partial(DNA, validate=False, lowercase='introns'), partial(_fasta_to_dna, validate=False, lowercase='introns')), (partial(RNA, validate=False, lowercase='introns'), partial(_fasta_to_rna, validate=False, lowercase='introns')), (partial(Protein, lowercase='introns'), partial(_fasta_to_protein, validate=False, lowercase='introns'))): # empty file empty_fp = get_data_path('empty') with self.assertRaisesRegex(ValueError, r'1st sequence'): reader_fn(empty_fp) with self.assertRaisesRegex(ValueError, r'1st sequence'): reader_fn(empty_fp, qual=empty_fp) # the sequences in the following files don't necessarily make sense # for each of the sequence object types that they're read into # (e.g., reading a protein sequence into a dna sequence object). # however, for the purposes of testing the various # fasta -> sequence readers, this works out okay as it is valid to # construct a sequence object with invalid characters. we're # interested in testing the reading logic here, and don't care so # much about constructing semantically-meaningful/valid sequence # objects # file with only 1 seq, get first fasta_fps = list(map(get_data_path, ['fasta_single_seq', 'fasta_max_width_1'])) for fasta_fp in fasta_fps: exp = constructor( 'ACGT-acgt.', metadata={'id': 'seq1', 'description': 'desc1'}) obs = reader_fn(fasta_fp) self.assertEqual(obs, exp) exp.positional_metadata.insert( 0, 'quality', np.asarray([10, 20, 30, 10, 0, 0, 0, 255, 1, 255], dtype=np.uint8)) qual_fps = list(map(get_data_path, ['qual_single_seq', 'qual_max_width_1'])) for qual_fp in qual_fps: obs = reader_fn(fasta_fp, qual=qual_fp) self.assertEqual(obs, exp) # file with multiple seqs fasta_fps = list(map(get_data_path, ['fasta_multi_seq', 'fasta_max_width_5'])) qual_fps = list(map(get_data_path, ['qual_multi_seq', 'qual_max_width_5'])) for fasta_fp in fasta_fps: # get first exp = constructor( 'ACGT-acgt.', metadata={'id': 'seq1', 'description': 'desc1'}) obs = reader_fn(fasta_fp) self.assertEqual(obs, exp) exp.positional_metadata.insert( 0, 'quality', np.asarray([10, 20, 30, 10, 0, 0, 0, 255, 1, 255], dtype=np.uint8)) for qual_fp in qual_fps: obs = reader_fn(fasta_fp, qual=qual_fp) self.assertEqual(obs, exp) # get middle exp = constructor('ACGTTGCAccGG', metadata={'id': '', 'description': ''}) obs = reader_fn(fasta_fp, seq_num=4) self.assertEqual(obs, exp) exp.positional_metadata.insert( 0, 'quality', np.asarray([55, 10, 0, 99, 1, 1, 8, 77, 40, 10, 10, 0], dtype=np.uint8)) for qual_fp in qual_fps: obs = reader_fn(fasta_fp, seq_num=4, qual=qual_fp) self.assertEqual(obs, exp) # get last exp = constructor( 'pQqqqPPQQQ', metadata={'id': 'proteinseq', 'description': 'detailed description \t\twith new lines'}) obs = reader_fn(fasta_fp, seq_num=6) self.assertEqual(obs, exp) exp.positional_metadata.insert( 0, 'quality', np.asarray([42, 42, 255, 255, 42, 42, 42, 42, 42, 43], dtype=np.uint8)) for qual_fp in qual_fps: obs = reader_fn(fasta_fp, seq_num=6, qual=qual_fp) self.assertEqual(obs, exp) # seq_num too large with self.assertRaisesRegex(ValueError, r'8th sequence'): reader_fn(fasta_fp, seq_num=8) for qual_fp in qual_fps: with self.assertRaisesRegex(ValueError, r'8th sequence'): reader_fn(fasta_fp, seq_num=8, qual=qual_fp) # seq_num too small with self.assertRaisesRegex(ValueError, r'`seq_num`=0'): reader_fn(fasta_fp, seq_num=0) for qual_fp in qual_fps: with self.assertRaisesRegex(ValueError, r'`seq_num`=0'): reader_fn(fasta_fp, seq_num=0, qual=qual_fp) def test_fasta_to_tabular_msa(self): test_cases = (self.empty, self.single, self.tabular_msa_different_type, self.lowercase_seqs) # see comment in test_fasta_to_generator_valid_files (above) for # testing strategy for exp_list, kwargs, fasta_fps, qual_fps in test_cases: if 'constructor' not in kwargs: kwargs['constructor'] = CustomSequence exp_list = [CustomSequence(seq) for seq in exp_list] exp = TabularMSA(exp_list) for fasta_fp in fasta_fps: obs = _fasta_to_tabular_msa(fasta_fp, **kwargs) self.assertEqual(len(obs), len(exp)) for o, e in zip(obs, exp): e = copy.copy(e) del e.positional_metadata['quality'] self.assertEqual(o, e) for qual_fp in qual_fps: obs = _fasta_to_tabular_msa(fasta_fp, qual=qual_fp, **kwargs) self.assertEqual(obs, exp) def test_fasta_to_tabular_msa_no_constructor(self): with self.assertRaisesRegex(ValueError, r'`constructor`'): _fasta_to_tabular_msa(get_data_path('fasta_single_seq')) class WriterTests(TestCase): def setUp(self): self.bio_seq1 = DNA( 'ACGT-acgt.', metadata={'id': 'seq1', 'description': 'desc1'}, positional_metadata={'quality': [10, 20, 30, 10, 0, 0, 0, 255, 1, 255]}, lowercase='introns') self.bio_seq2 = DNA( 'A', metadata={'id': ' \n \nseq \t2 '}, positional_metadata={'quality': [42]}, lowercase='introns') self.bio_seq3 = RNA( 'AACGGuA', metadata={'description': 'desc3'}, positional_metadata={'quality': [0, 0, 0, 0, 0, 0, 0]}, lowercase='introns') self.dna_seq = DNA( 'ACGTTGCAccGG', positional_metadata={'quality': [55, 10, 0, 99, 1, 1, 8, 77, 40, 10, 10, 0]}, lowercase='introns') self.rna_seq = RNA('ACGUU', positional_metadata={'quality': [10, 9, 8, 7, 6]}, lowercase='introns') self.prot_seq = Protein( 'pQqqqPPQQQ', metadata={'id': 'proteinseq', 'description': "\ndetailed\ndescription \t\twith " " new\n\nlines\n\n\n"}, positional_metadata={'quality': [42, 42, 255, 255, 42, 42, 42, 42, 42, 43]}, lowercase='introns') seqs = [ CustomSequence( 'UUUU', metadata={'id': 's\te\tq\t1', 'description': 'desc\n1'}, positional_metadata={'quality': [1234, 0, 0, 2]}, lowercase='introns'), CustomSequence( 'CATC', metadata={'id': 's\te\tq\t2', 'description': 'desc\n2'}, positional_metadata={'quality': [1, 11, 111, 11112]}), CustomSequence( 'sits', metadata={'id': 's\te\tq\t3', 'description': 'desc\n3'}, positional_metadata={'quality': [12345, 678909, 999999, 4242424242]}) ] self.msa = TabularMSA(seqs) def empty_gen(): yield from () def single_seq_gen(): yield self.bio_seq1 # generate sequences with descriptions containing newlines (to test # description_newline_replacement) def newline_description_gen(): yield self.prot_seq yield DNA('AGGAGAATA', metadata={'id': 'foo', 'description': '\n\n\n\n'}, positional_metadata={'quality': range(9)}, lowercase='introns') # generate sequences with ids containing whitespace (to test # id_whitespace_replacement) def whitespace_id_gen(): yield self.bio_seq2 yield RNA('UA', metadata={'id': '\n\t \t', 'description': 'a\nb'}, positional_metadata={'quality': [1000, 1]}) # multiple sequences of mixed types, lengths, and metadata. lengths are # chosen to exercise various splitting cases when testing max_width, # including exercising the different splitting algorithms used for # sequence data vs. quality scores def multi_seq_gen(): yield from (self.bio_seq1, self.bio_seq2, self.bio_seq3, self.dna_seq, self.rna_seq, self.prot_seq) # can be serialized if no qual file is provided, else it should raise # an error because one seq has qual scores and the other doesn't def mixed_qual_score_gen(): yield self.bio_seq1 yield DNA('AAAAT', metadata={'id': 'da,dadadada', 'description': '10 hours'}, lowercase='introns') self.mixed_qual_score_gen = mixed_qual_score_gen() # store sequence generator to serialize, writer kwargs (if any), and # fasta and qual filepaths of expected results self.objs_fps = list(map(lambda e: (e[0], e[1], get_data_path(e[2]), get_data_path(e[3])), [ (empty_gen(), {}, 'empty', 'empty'), (single_seq_gen(), {'lowercase': 'introns'}, 'fasta_single_seq', 'qual_single_seq'), # no splitting of sequence or qual data across lines b/c max_width # is sufficiently large (single_seq_gen(), {'max_width': 32, 'lowercase': 'introns'}, 'fasta_single_seq', 'qual_single_seq'), # splitting algorithm for sequence and qual scores is different; # make sure individual qual scores aren't split across lines even # if they exceed max_width (single_seq_gen(), {'max_width': 1, 'lowercase': 'introns'}, 'fasta_max_width_1', 'qual_max_width_1'), (multi_seq_gen(), {'lowercase': 'introns'}, 'fasta_multi_seq', 'qual_multi_seq'), (multi_seq_gen(), {'max_width': 5, 'lowercase': 'introns'}, 'fasta_max_width_5', 'qual_max_width_5'), (newline_description_gen(), {'description_newline_replacement': ':-)', 'lowercase': 'introns'}, 'fasta_description_newline_replacement_multi_char', 'qual_description_newline_replacement_multi_char'), (newline_description_gen(), {'description_newline_replacement': '', 'lowercase': 'introns'}, 'fasta_description_newline_replacement_empty_str', 'qual_description_newline_replacement_empty_str',), (newline_description_gen(), {'description_newline_replacement': None, 'lowercase': 'introns'}, 'fasta_description_newline_replacement_none', 'qual_description_newline_replacement_none'), (whitespace_id_gen(), {'id_whitespace_replacement': '>:o'}, 'fasta_id_whitespace_replacement_multi_char', 'qual_id_whitespace_replacement_multi_char'), (whitespace_id_gen(), {'id_whitespace_replacement': ''}, 'fasta_id_whitespace_replacement_empty_str', 'qual_id_whitespace_replacement_empty_str'), (whitespace_id_gen(), {'id_whitespace_replacement': None}, 'fasta_id_whitespace_replacement_none', 'qual_id_whitespace_replacement_none'), ])) def blank_seq_gen(): yield from (self.bio_seq1, Sequence('')) # generators or parameter combos that cannot be written in fasta # format, paired with kwargs (if any), error type, and expected error # message regexp self.invalid_objs = [ (blank_seq_gen(), {}, ValueError, r'2nd.*empty'), (single_seq_gen(), {'max_width': 0}, ValueError, r'max_width=0'), (multi_seq_gen(), {'id_whitespace_replacement': '-\n_'}, ValueError, r'Newline character'), (multi_seq_gen(), {'description_newline_replacement': '-.-\n'}, ValueError, r'Newline character'), (mixed_qual_score_gen(), {'qual': io.StringIO()}, ValueError, r'2nd sequence.*does not have quality scores') ] # extensive tests for generator -> fasta writer since it is used by all # other object -> fasta writers def test_generator_to_fasta_no_qual(self): # test writing standalone fasta (i.e., without a qual file) for obj, kwargs, fp, _ in self.objs_fps: fh = io.StringIO() _generator_to_fasta(obj, fh, **kwargs) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_generator_to_fasta_mixed_qual_scores(self): # test writing some sequences with qual scores and some without is # possible if no qual output file is specified fh = io.StringIO() _generator_to_fasta(self.mixed_qual_score_gen, fh, lowercase='introns') obs = fh.getvalue() fh.close() with io.open(get_data_path('fasta_mixed_qual_scores')) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_generator_to_fasta_with_qual(self): # test writing fasta and qual files for obj, kwargs, fasta_fp, qual_fp in self.objs_fps: if qual_fp is not None: fasta_fh = io.StringIO() qual_fh = io.StringIO() _generator_to_fasta(obj, fasta_fh, qual=qual_fh, **kwargs) obs_fasta = fasta_fh.getvalue() obs_qual = qual_fh.getvalue() fasta_fh.close() qual_fh.close() with io.open(fasta_fp) as fh: exp_fasta = fh.read() with io.open(qual_fp) as fh: exp_qual = fh.read() self.assertEqual(obs_fasta, exp_fasta) self.assertEqual(obs_qual, exp_qual) def test_generator_to_fasta_invalid_input(self): for obj, kwargs, error_type, error_msg_regexp in self.invalid_objs: fh = io.StringIO() with self.assertRaisesRegex(error_type, error_msg_regexp): _generator_to_fasta(obj, fh, **kwargs) fh.close() # light testing of object -> fasta writers to ensure interface is present # and kwargs are passed through. extensive testing of underlying writer is # performed above def test_any_sequence_to_fasta(self): # store writer function, sequence object to write, expected # fasta filepath for default parameters, expected fasta filepath for # non-defaults, and expected qual filepath for non-defaults id_ = 'f o o' desc = 'b\na\nr' test_data = ( (partial(_sequence_to_fasta, lowercase='introns'), Sequence('ACgt', metadata={'id': id_, 'description': desc}, positional_metadata={'quality': range(1, 5)}, lowercase='introns'), ('fasta_single_bio_seq_defaults', 'fasta_single_bio_seq_non_defaults', 'qual_single_bio_seq_non_defaults')), (partial(_dna_to_fasta, lowercase='introns'), DNA('TAcg', metadata={'id': id_, 'description': desc}, positional_metadata={'quality': range(4)}, lowercase='introns'), ('fasta_single_dna_seq_defaults', 'fasta_single_dna_seq_non_defaults', 'qual_single_dna_seq_non_defaults')), (partial(_rna_to_fasta, lowercase='introns'), RNA('uaCG', metadata={'id': id_, 'description': desc}, positional_metadata={'quality': range(2, 6)}, lowercase='introns'), ('fasta_single_rna_seq_defaults', 'fasta_single_rna_seq_non_defaults', 'qual_single_rna_seq_non_defaults')), (partial(_protein_to_fasta, lowercase='introns'), Protein('PqQ', metadata={'id': id_, 'description': desc}, positional_metadata={'quality': [42, 41, 40]}, lowercase='introns'), ('fasta_single_prot_seq_defaults', 'fasta_single_prot_seq_non_defaults', 'qual_single_prot_seq_non_defaults'))) for fn, obj, fps in test_data: defaults_fp, non_defaults_fasta_fp, non_defaults_qual_fp = fps # test writing with default parameters fh = io.StringIO() fn(obj, fh) obs = fh.getvalue() fh.close() with io.open(get_data_path(defaults_fp)) as fh: exp = fh.read() self.assertEqual(obs, exp) # test writing with non-defaults fasta_fh = io.StringIO() qual_fh = io.StringIO() fn(obj, fasta_fh, id_whitespace_replacement='-', description_newline_replacement='_', max_width=1, qual=qual_fh) obs_fasta = fasta_fh.getvalue() obs_qual = qual_fh.getvalue() fasta_fh.close() qual_fh.close() with io.open(get_data_path(non_defaults_fasta_fp)) as fh: exp_fasta = fh.read() with io.open(get_data_path(non_defaults_qual_fp)) as fh: exp_qual = fh.read() self.assertEqual(obs_fasta, exp_fasta) self.assertEqual(obs_qual, exp_qual) def test_any_sequences_to_fasta(self): # test writing with default parameters fh = io.StringIO() _tabular_msa_to_fasta(self.msa, fh) obs = fh.getvalue() fh.close() with io.open(get_data_path('fasta_3_seqs_defaults')) as fh: exp = fh.read() self.assertEqual(obs, exp) # test writing with non-defaults fasta_fh = io.StringIO() qual_fh = io.StringIO() _tabular_msa_to_fasta(self.msa, fasta_fh, id_whitespace_replacement='*', description_newline_replacement='+', max_width=3, qual=qual_fh) obs_fasta = fasta_fh.getvalue() obs_qual = qual_fh.getvalue() fasta_fh.close() qual_fh.close() with io.open(get_data_path('fasta_3_seqs_non_defaults')) as fh: exp_fasta = fh.read() with io.open(get_data_path('qual_3_seqs_non_defaults')) as fh: exp_qual = fh.read() self.assertEqual(obs_fasta, exp_fasta) self.assertEqual(obs_qual, exp_qual) class RoundtripTests(TestCase): def test_roundtrip_generators(self): # test that fasta and qual files can be streamed into memory and back # out to disk using generator reader and writer fps = list(map(lambda e: list(map(get_data_path, e)), [('empty', 'empty'), ('fasta_multi_seq_roundtrip', 'qual_multi_seq_roundtrip')])) for fasta_fp, qual_fp in fps: with io.open(fasta_fp) as fh: exp_fasta = fh.read() with io.open(qual_fp) as fh: exp_qual = fh.read() fasta_fh = io.StringIO() qual_fh = io.StringIO() _generator_to_fasta(_fasta_to_generator(fasta_fp, qual=qual_fp), fasta_fh, qual=qual_fh) obs_fasta = fasta_fh.getvalue() obs_qual = qual_fh.getvalue() fasta_fh.close() qual_fh.close() self.assertEqual(obs_fasta, exp_fasta) self.assertEqual(obs_qual, exp_qual) def test_roundtrip_tabular_msa(self): fps = list(map(lambda e: list(map(get_data_path, e)), [('empty', 'empty'), ('fasta_tabular_msa_different_type', 'qual_tabular_msa_different_type')])) reader = partial(_fasta_to_tabular_msa, constructor=CustomSequence) writer = _tabular_msa_to_fasta for fasta_fp, qual_fp in fps: # read obj1 = reader(fasta_fp, qual=qual_fp) # write fasta_fh = io.StringIO() qual_fh = io.StringIO() writer(obj1, fasta_fh, qual=qual_fh) fasta_fh.seek(0) qual_fh.seek(0) # read obj2 = reader(fasta_fh, qual=qual_fh) fasta_fh.close() qual_fh.close() self.assertEqual(obj1, obj2) def test_roundtrip_biological_sequences(self): fps = list(map(lambda e: list(map(get_data_path, e)), [('fasta_multi_seq_roundtrip', 'qual_multi_seq_roundtrip'), ('fasta_tabular_msa_different_type', 'qual_tabular_msa_different_type')])) for reader, writer in ((_fasta_to_sequence, _sequence_to_fasta), (partial(_fasta_to_dna, validate=False), _dna_to_fasta), (partial(_fasta_to_rna, validate=False), _rna_to_fasta), (partial(_fasta_to_protein, validate=False), _protein_to_fasta)): for fasta_fp, qual_fp in fps: # read obj1 = reader(fasta_fp, qual=qual_fp) # write fasta_fh = io.StringIO() qual_fh = io.StringIO() writer(obj1, fasta_fh, qual=qual_fh) fasta_fh.seek(0) qual_fh.seek(0) # read obj2 = reader(fasta_fh, qual=qual_fh) fasta_fh.close() qual_fh.close() self.assertEqual(obj1, obj2) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_fastq.py000066400000000000000000000702101446255456000224740ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import string import unittest import warnings from functools import partial from skbio import read, write, Sequence, DNA, RNA, Protein, TabularMSA from skbio.io import FASTQFormatError from skbio.io.format.fastq import ( _fastq_sniffer, _fastq_to_generator, _fastq_to_tabular_msa, _generator_to_fastq, _tabular_msa_to_fastq) from skbio.sequence import GrammaredSequence from skbio.util import get_data_path from skbio.util import classproperty from skbio.util._decorator import overrides import numpy as np # Note: the example FASTQ files with file extension .fastq are taken from the # following open-access publication's supplementary data: # # P.J.A. Cock, C.J. Fields, N. Goto, M.L. Heuer and P.M. Rice (2009). The # Sanger FASTQ file format for sequences with quality scores, and the # Solexa/Illumina FASTQ variants. # # See licenses/fastq-example-files-readme.txt for the original README that # accompanied these files, which includes the terms of use and detailed # description of the files. # # The example files bearing the original filenames have not been modified from # their original form. def _drop_kwargs(kwargs, *args): for arg in args: if arg in kwargs: kwargs.pop(arg) class TestSniffer(unittest.TestCase): def setUp(self): self.positives = [get_data_path(e) for e in [ 'fastq_multi_seq_sanger', 'fastq_multi_blank_between_records', 'fastq_multi_ws_lines_between_records', 'fastq_multi_blank_end_of_file', 'fastq_multi_ws_lines_end_of_file', 'fastq_multi_whitespace_stripping', 'fastq_blank_lines', 'fastq_whitespace_only_lines', 'fastq_single_seq_illumina1.3', 'fastq_wrapping_as_illumina_no_description', 'fastq_wrapping_as_sanger_no_description', 'fastq_wrapping_original_sanger_no_description', 'fastq_writer_illumina1.3_defaults', 'fastq_writer_sanger_defaults', 'fastq_writer_sanger_non_defaults', 'fastq_5_blanks_start_of_file', 'fastq_5_ws_lines_start_of_file', 'illumina_full_range_as_illumina.fastq', 'illumina_full_range_as_sanger.fastq', 'illumina_full_range_original_illumina.fastq', 'longreads_as_illumina.fastq', 'longreads_as_sanger.fastq', 'longreads_original_sanger.fastq', 'misc_dna_as_illumina.fastq', 'misc_dna_as_sanger.fastq', 'misc_dna_original_sanger.fastq', 'misc_rna_as_illumina.fastq', 'misc_rna_as_sanger.fastq', 'misc_rna_original_sanger.fastq', 'sanger_full_range_as_illumina.fastq', 'sanger_full_range_as_sanger.fastq', 'sanger_full_range_original_sanger.fastq', 'solexa_full_range_original_solexa.fastq', 'wrapping_as_illumina.fastq', 'wrapping_as_sanger.fastq', 'wrapping_original_sanger.fastq' ]] self.negatives = [get_data_path(e) for e in [ 'empty', 'whitespace_only', 'fastq_multi_blank_start_of_file', 'fastq_multi_ws_lines_start_of_file', 'fastq_invalid_blank_after_header', 'fastq_invalid_blank_after_seq', 'fastq_invalid_blank_after_plus', 'fastq_invalid_blank_within_seq', 'fastq_invalid_blank_within_qual', 'fastq_invalid_ws_line_after_header', 'fastq_invalid_ws_line_after_seq', 'fastq_invalid_ws_line_after_plus', 'fastq_invalid_ws_line_within_seq', 'fastq_invalid_ws_line_within_qual', 'fastq_invalid_missing_header', 'fastq_invalid_missing_seq_data', 'error_diff_ids.fastq', 'error_double_qual.fastq', 'error_double_seq.fastq', 'error_long_qual.fastq', 'error_no_qual.fastq', 'error_qual_del.fastq', 'error_qual_escape.fastq', 'error_qual_null.fastq', 'error_qual_space.fastq', 'error_qual_tab.fastq', 'error_qual_unit_sep.fastq', 'error_qual_vtab.fastq', 'error_short_qual.fastq', 'error_spaces.fastq', 'error_tabs.fastq', 'error_trunc_at_seq.fastq', 'error_trunc_at_plus.fastq', 'error_trunc_at_qual.fastq', 'error_trunc_in_title.fastq', 'error_trunc_in_seq.fastq', 'error_trunc_in_plus.fastq', 'error_trunc_in_qual.fastq', ]] def test_positives(self): for fp in self.positives: self.assertEqual(_fastq_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negatives: self.assertEqual(_fastq_sniffer(fp), (False, {})) def test_illumina_sniffed(self): fp = get_data_path('fastq_single_seq_illumina1.8') self.assertEqual(_fastq_sniffer(fp), (True, {'variant': 'illumina1.8'})) class TestReaders(unittest.TestCase): def setUp(self): self.valid_configurations = [ ([get_data_path('empty'), get_data_path('whitespace_only')], [{}, {'variant': 'illumina1.8'}, {'phred_offset': 33, 'constructor': DNA}], []), ([get_data_path('fastq_single_seq_illumina1.3')], [ {'variant': 'illumina1.3'}, {'phred_offset': 64}, {'variant': 'illumina1.3', 'constructor': Protein}, ], [ ('', 'bar\t baz', 'aCGT', [33, 34, 35, 36]) ]), ([get_data_path('fastq_multi_seq_sanger'), get_data_path('fastq_whitespace_only_lines'), get_data_path('fastq_blank_lines'), get_data_path('fastq_multi_blank_between_records'), get_data_path('fastq_multi_ws_lines_between_records'), get_data_path('fastq_multi_blank_end_of_file'), get_data_path('fastq_multi_ws_lines_end_of_file'), get_data_path('fastq_multi_blank_start_of_file'), get_data_path('fastq_multi_ws_lines_start_of_file'), get_data_path('fastq_multi_whitespace_stripping')], [ {'variant': 'sanger'}, {'phred_offset': 33, 'seq_num': 2}, {'variant': 'sanger', 'constructor': partial(RNA, validate=False), 'seq_num': 3}, ], [ ('foo', 'bar baz', 'AACCGG', [16, 17, 18, 19, 20, 21]), ('bar', 'baz foo', 'TTGGCC', [23, 22, 21, 20, 19, 18]), ('baz', 'foo bar', 'GATTTC', [20, 21, 22, 23, 24, 18]) ]), ] self.invalid_files = [(get_data_path(e[0]), e[1], e[2]) for e in [ ('fastq_invalid_blank_after_header', FASTQFormatError, r'blank or whitespace-only line.*after header.*in FASTQ'), ('fastq_invalid_blank_after_seq', FASTQFormatError, r"blank or whitespace-only line.*before '\+' in FASTQ"), ('fastq_invalid_blank_after_plus', FASTQFormatError, r"blank or whitespace-only line.*after '\+'.*in FASTQ"), ('fastq_invalid_blank_within_seq', FASTQFormatError, r'blank or whitespace-only line.*within sequence.*FASTQ'), ('fastq_invalid_blank_within_qual', FASTQFormatError, r"blank or whitespace-only line.*within quality scores.*in " "FASTQ"), ('fastq_invalid_ws_line_after_header', FASTQFormatError, r'blank or whitespace-only line.*after header.*in FASTQ'), ('fastq_invalid_ws_line_after_seq', FASTQFormatError, r"blank or whitespace-only line.*before '\+' in FASTQ"), ('fastq_invalid_ws_line_after_plus', FASTQFormatError, r"blank or whitespace-only line.*after '\+'.*in FASTQ"), ('fastq_invalid_ws_line_within_seq', FASTQFormatError, r'blank or whitespace-only line.*within sequence.*FASTQ'), ('fastq_invalid_ws_line_within_qual', FASTQFormatError, r"blank or whitespace-only line.*within quality scores.*in " "FASTQ"), ('fastq_invalid_missing_header', FASTQFormatError, r"sequence.*header.*start of file: 'seq1 desc1'"), ('fastq_invalid_missing_seq_data', FASTQFormatError, r'without sequence data'), ('error_diff_ids.fastq', FASTQFormatError, r"header lines do not match: " "'SLXA-B3_649_FC8437_R1_1_1_850_123' != " "'SLXA-B3_649_FC8437_R1_1_1_850_124'"), ('error_double_qual.fastq', FASTQFormatError, r"Extra quality.*'\+SLXA-B3_649_FC8437_R1_1_1_850_123'"), ('error_double_seq.fastq', FASTQFormatError, r'FASTQ record that is missing a quality \(\+\) header line'), ('error_long_qual.fastq', FASTQFormatError, r"Extra quality.*'Y'"), ('error_no_qual.fastq', FASTQFormatError, r"blank or whitespace-only line.*after '\+'.*in FASTQ"), ('error_qual_del.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_escape.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_null.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_space.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_tab.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_unit_sep.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_qual_vtab.fastq', ValueError, r'Decoded Phred score.*out of range'), ('error_short_qual.fastq', FASTQFormatError, r"Extra quality.*'SLXA-B3_649_FC8437_R1_1_1_362_549'"), ('error_spaces.fastq', FASTQFormatError, r"whitespace.*sequence data: 'GATGTGCAA TACCTTTGTA GAGGAA'"), ('error_tabs.fastq', FASTQFormatError, r"whitespace.*sequence data: 'GATGTGCAA\\tTACCTTTGTA\\tGAGGAA'"), ('error_trunc_at_seq.fastq', FASTQFormatError, r'incomplete/truncated.*FASTQ'), ('error_trunc_at_plus.fastq', FASTQFormatError, r'incomplete/truncated.*FASTQ'), ('error_trunc_at_qual.fastq', FASTQFormatError, r'incomplete/truncated.*end of file'), ('error_trunc_in_title.fastq', FASTQFormatError, r'incomplete/truncated.*end of file'), ('error_trunc_in_seq.fastq', FASTQFormatError, r'incomplete/truncated.*end of file'), ('error_trunc_in_plus.fastq', FASTQFormatError, r"header lines do not match: " "'SLXA-B3_649_FC8437_R1_1_1_183_714' != 'SLXA-B3_649_FC'"), ('error_trunc_in_qual.fastq', FASTQFormatError, r'incomplete/truncated.*end of file') ]] def test_fastq_to_generator_valid_files(self): for valid_files, kwargs, components in self.valid_configurations: for valid in valid_files: for observed_kwargs in kwargs: _drop_kwargs(observed_kwargs, 'seq_num') constructor = observed_kwargs.get('constructor', Sequence) expected_kwargs = {} expected_kwargs['lowercase'] = 'introns' observed_kwargs['lowercase'] = 'introns' expected = [constructor(c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': np.array(c[3], dtype=np.uint8)}, **expected_kwargs) for c in components] observed = list(_fastq_to_generator(valid, **observed_kwargs)) self.assertEqual(len(expected), len(observed)) for o, e in zip(observed, expected): self.assertEqual(o, e) def test_fastq_to_generator_invalid_files_all_variants(self): # files that should be invalid for all variants, as well as custom # phred offsets for fp, error_type, error_msg_regex in self.invalid_files: for variant in 'sanger', 'illumina1.3', 'illumina1.8': with self.assertRaisesRegex(error_type, error_msg_regex): list(_fastq_to_generator(fp, variant=variant)) for offset in 33, 64, 40, 77: with self.assertRaisesRegex(error_type, error_msg_regex): list(_fastq_to_generator(fp, phred_offset=offset)) def test_fastq_to_generator_invalid_files_illumina(self): # files that should be invalid for illumina1.3 and illumina1.8 variants fps = [get_data_path(fp) for fp in ['sanger_full_range_original_sanger.fastq', 'solexa_full_range_original_solexa.fastq']] for fp in fps: with self.assertRaisesRegex(ValueError, r'out of range \[0, 62\]'): list(_fastq_to_generator(fp, variant='illumina1.3')) with self.assertRaisesRegex(ValueError, r'out of range \[0, 62\]'): list(_fastq_to_generator(fp, variant='illumina1.8')) def test_fastq_to_generator_solexa(self): # solexa support isn't implemented yet. should raise error even with # valid solexa file with self.assertRaisesRegex(ValueError, r'Solexa'): list(_fastq_to_generator( get_data_path('solexa_full_range_original_solexa.fastq'), variant='solexa')) def test_fastq_to_sequence(self): for constructor in [Sequence, DNA, RNA, Protein]: for valid_files, kwargs, components in self.valid_configurations: for valid in valid_files: # skip empty file case since we cannot read a specific # sequencefrom an empty file if len(components) == 0: continue for observed_kwargs in kwargs: expected_kwargs = {} # TODO: # some of the test files contain characters which are # invalid for RNA, so don't validate for now. Need to # fix this if constructor is RNA: observed_kwargs['validate'] = False expected_kwargs['validate'] = False _drop_kwargs(observed_kwargs, 'constructor') expected_kwargs['lowercase'] = 'introns' observed_kwargs['lowercase'] = 'introns' seq_num = observed_kwargs.get('seq_num', 1) c = components[seq_num - 1] expected = \ constructor( c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': np.array(c[3], dtype=np.uint8)}, **expected_kwargs) observed = read(valid, into=constructor, format='fastq', verify=False, **observed_kwargs) self.assertEqual(observed, expected) def test_fastq_to_tabular_msa(self): class CustomSequence(GrammaredSequence): @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set(string.ascii_letters) @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return {} for valid_files, kwargs, components in self.valid_configurations: for valid in valid_files: for observed_kwargs in kwargs: _drop_kwargs(observed_kwargs, 'seq_num') if 'constructor' not in observed_kwargs: observed_kwargs['constructor'] = CustomSequence constructor = observed_kwargs['constructor'] expected_kwargs = {} expected_kwargs['lowercase'] = 'introns' observed_kwargs['lowercase'] = 'introns' expected = TabularMSA( [constructor( c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': np.array(c[3], dtype=np.uint8)}, **expected_kwargs) for c in components]) observed = _fastq_to_tabular_msa(valid, **observed_kwargs) self.assertEqual(observed, expected) def test_fastq_to_tabular_msa_no_constructor(self): with self.assertRaisesRegex(ValueError, r'`constructor`'): _fastq_to_tabular_msa(get_data_path('fastq_multi_seq_sanger')) class TestWriters(unittest.TestCase): def setUp(self): self.valid_files = [ ([ ('f o o', 'bar\n\nbaz', 'AaCcGg', [16, 17, 18, 19, 20, 21]), ('bar', 'baz foo', 'TtGgCc', [23, 22, 21, 20, 19, 18]), ('ba\n\t\tz', 'foo bar', 'gAtTtC', [20, 21, 22, 23, 24, 18]) ], [ ({'variant': 'sanger'}, get_data_path('fastq_writer_sanger_defaults')), ({'phred_offset': 33}, get_data_path('fastq_writer_sanger_defaults')), ({'variant': 'illumina1.8'}, get_data_path('fastq_writer_sanger_defaults')), ({'variant': 'illumina1.3'}, get_data_path('fastq_writer_illumina1.3_defaults')), ({'variant': 'sanger', 'id_whitespace_replacement': '%', 'description_newline_replacement': '^'}, get_data_path('fastq_writer_sanger_non_defaults')) ]), ] def test_generator_to_fastq_kwargs_passed(self): for components, kwargs_expected_fp in self.valid_files: for kwargs, expected_fp in kwargs_expected_fp: def gen(): for c in components: yield Sequence( c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': c[3]}) fh = io.StringIO() _generator_to_fastq(gen(), fh, **kwargs) observed = fh.getvalue() fh.close() with io.open(expected_fp) as f: expected = f.read() self.assertEqual(observed, expected) def test_sequence_to_fastq_kwargs_passed(self): for constructor in [Sequence, DNA, RNA, Protein]: for components, kwargs_expected_fp in self.valid_files: for expected_kwargs, expected_fp in kwargs_expected_fp: observed_kwargs = {} # TODO: # some of the test files contain characters which are # invalid for RNA, so don't validate for now. Need to # fix this if constructor is RNA: observed_kwargs['validate'] = False expected_kwargs['lowercase'] = 'introns' observed_kwargs['lowercase'] = 'introns' fh = io.StringIO() for c in components: obj = constructor( c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': c[3]}, **observed_kwargs) write(obj, into=fh, format='fastq', **expected_kwargs) observed = fh.getvalue() fh.close() with io.open(expected_fp) as f: expected = f.read() self.assertEqual(observed, expected) def test_tabular_msa_to_fastq_kwargs_passed(self): for components, kwargs_expected_fp in self.valid_files: for kwargs, expected_fp in kwargs_expected_fp: obj = TabularMSA([ Protein(c[2], metadata={'id': c[0], 'description': c[1]}, positional_metadata={'quality': c[3]}, lowercase='introns') for c in components]) fh = io.StringIO() kwargs['lowercase'] = 'introns' _tabular_msa_to_fastq(obj, fh, **kwargs) observed = fh.getvalue() fh.close() with io.open(expected_fp) as f: expected = f.read() self.assertEqual(observed, expected) def test_generator_to_fastq_no_qual(self): def gen(): yield Sequence('ACGT', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': range(4)}) yield Sequence('ACG', metadata={'id': 'foo', 'description': 'bar'}) with self.assertRaisesRegex(ValueError, r'2nd.*quality scores'): _generator_to_fastq(gen(), io.StringIO(), variant='illumina1.8') class TestConversions(unittest.TestCase): def setUp(self): self.conversions = [ (get_data_path('empty'), get_data_path('empty'), [ ({'variant': 'sanger'}, {'phred_offset': 42}), ]), (get_data_path('longreads_original_sanger.fastq'), get_data_path('longreads_as_sanger.fastq'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('longreads_original_sanger.fastq'), get_data_path('longreads_as_illumina.fastq'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), (get_data_path('wrapping_original_sanger.fastq'), get_data_path('wrapping_as_sanger.fastq'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('wrapping_original_sanger.fastq'), get_data_path('wrapping_as_illumina.fastq'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), (get_data_path('sanger_full_range_original_sanger.fastq'), get_data_path('sanger_full_range_as_sanger.fastq'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('sanger_full_range_original_sanger.fastq'), get_data_path('sanger_full_range_as_illumina.fastq'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), (get_data_path('illumina_full_range_original_illumina.fastq'), get_data_path('illumina_full_range_as_illumina.fastq'), [ ({'variant': 'illumina1.3'}, {'variant': 'illumina1.3'}), ({'phred_offset': 64}, {'variant': 'illumina1.3'}), ({'variant': 'illumina1.3'}, {'phred_offset': 64}) ]), (get_data_path('illumina_full_range_original_illumina.fastq'), get_data_path('illumina_full_range_as_sanger.fastq'), [ ({'variant': 'illumina1.3'}, {'variant': 'sanger'}), ({'phred_offset': 64}, {'variant': 'sanger'}), ({'variant': 'illumina1.3'}, {'phred_offset': 33}) ]), (get_data_path('misc_dna_original_sanger.fastq'), get_data_path('misc_dna_as_sanger.fastq'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('misc_dna_original_sanger.fastq'), get_data_path('misc_dna_as_illumina.fastq'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), (get_data_path('misc_rna_original_sanger.fastq'), get_data_path('misc_rna_as_sanger.fastq'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('misc_rna_original_sanger.fastq'), get_data_path('misc_rna_as_illumina.fastq'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), (get_data_path('fastq_wrapping_original_sanger_no_description'), get_data_path('fastq_wrapping_as_sanger_no_description'), [ ({'variant': 'sanger'}, {'variant': 'sanger'}), ({'phred_offset': 33}, {'variant': 'sanger'}), ({'variant': 'sanger'}, {'phred_offset': 33}) ]), (get_data_path('fastq_wrapping_original_sanger_no_description'), get_data_path('fastq_wrapping_as_illumina_no_description'), [ ({'variant': 'sanger'}, {'variant': 'illumina1.3'}), ({'phred_offset': 33}, {'variant': 'illumina1.3'}), ({'variant': 'sanger'}, {'phred_offset': 64}) ]), ] def test_conversion(self): for from_fp, to_fp, kwargs in self.conversions: for from_kwargs, to_kwargs in kwargs: read_gen = _fastq_to_generator(from_fp, **from_kwargs) fh = io.StringIO() # will issue warning when truncating quality scores with warnings.catch_warnings(record=True): warnings.simplefilter("ignore") _generator_to_fastq(read_gen, fh, **to_kwargs) obs = fh.getvalue() fh.close() with io.open(to_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_genbank.py000066400000000000000000000363431446255456000227740ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main from skbio import Protein, DNA, RNA, Sequence from skbio.metadata import IntervalMetadata from skbio.util import get_data_path from skbio.io import GenBankFormatError from skbio.io.format.genbank import ( _genbank_sniffer, _genbank_to_generator, _genbank_to_sequence, _genbank_to_dna, _genbank_to_rna, _genbank_to_protein, _parse_locus, _parse_reference, _generator_to_genbank, _sequence_to_genbank, _protein_to_genbank, _rna_to_genbank, _dna_to_genbank, _serialize_locus) class SnifferTests(TestCase): def setUp(self): self.positive_fps = list(map(get_data_path, [ 'genbank_5_blanks_start_of_file', 'genbank_single_record_upper', 'genbank_single_record_lower', 'genbank_multi_records'])) self.negative_fps = list(map(get_data_path, [ 'empty', 'whitespace_only', 'genbank_6_blanks_start_of_file', 'genbank_w_beginning_whitespace', 'genbank_missing_locus_name'])) def test_positives(self): for fp in self.positive_fps: self.assertEqual(_genbank_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negative_fps: self.assertEqual(_genbank_sniffer(fp), (False, {})) class GenBankIOTests(TestCase): # parent class to set up test data for the child class def setUp(self): # test locus line self.locus = ( (['LOCUS NC_005816 9609 bp ' 'DNA circular CON 07-FEB-2015'], {'division': 'CON', 'mol_type': 'DNA', 'shape': 'circular', 'locus_name': 'NC_005816', 'date': '07-FEB-2015', 'unit': 'bp', 'size': 9609}), (['LOCUS SCU49845 5028 bp ' 'DNA PLN 21-JUN-1999'], {'division': 'PLN', 'mol_type': 'DNA', 'shape': None, 'locus_name': 'SCU49845', 'date': '21-JUN-1999', 'unit': 'bp', 'size': 5028}), (['LOCUS NP_001832 360 aa ' 'linear PRI 18-DEC-2001'], {'division': 'PRI', 'mol_type': None, 'shape': 'linear', 'locus_name': 'NP_001832', 'date': '18-DEC-2001', 'unit': 'aa', 'size': 360})) # test single record and read uppercase sequence self.single_upper_fp = get_data_path('genbank_single_record_upper') self.single_lower_fp = get_data_path('genbank_single_record_lower') self.single = ( 'GSREILDFK', {'LOCUS': {'date': '23-SEP-1994', 'division': 'BCT', 'locus_name': 'AAB29917', 'mol_type': None, 'shape': 'linear', 'size': 9, 'unit': 'aa'}}, None, Protein) self.single_rna_fp = get_data_path('genbank_single_record') imd = IntervalMetadata(63) imd.add([(0, 63)], [(False, False)], {'db_xref': '"taxon:562"', 'mol_type': '"mRNA"', 'organism': '"Escherichia coli"', 'type': 'source', 'strand': '+', '__location': '1..63'}) imd.add([(0, 63)], [(False, True)], {'phase': 0, 'db_xref': ['"taxon:562"', '"taxon:561"'], '__location': '1..>63', 'strand': '+', 'note': '"alkaline phosphatase signal peptide"', 'protein_id': '"AAA23431.1"', 'transl_table': '11', 'translation': '"MKQSTIALAVLPLLFTPVTKA"', 'type': 'CDS'}) self.single_rna = ( 'gugaaacaaagcacuauugcacuggcugucuuaccguuacuguuuaccccugugacaaaagcc', {'ACCESSION': 'M14399', 'COMMENT': 'Original source text: E.coli, cDNA to mRNA.', 'DEFINITION': "alkaline phosphatase signal mRNA, 5' end.", 'KEYWORDS': 'alkaline phosphatase; signal peptide.', 'LOCUS': {'date': '26-APR-1993', 'division': 'BCT', 'locus_name': 'ECOALKP', 'mol_type': 'mRNA', 'shape': 'linear', 'size': 63, 'unit': 'bp'}, 'SOURCE': {'ORGANISM': 'Escherichia coli', 'taxonomy': 'Bacteria; Proteobacteria; ' 'Gammaproteobacteria; Enterobacteriales; ' 'Enterobacteriaceae; Escherichia.'}, 'VERSION': 'M14399.1'}, imd, RNA) # test: # 1. multiple records in one file # 2. lowercase sequence # 3. DNA, RNA, Protein type # 4. variation of formats self.multi_fp = get_data_path('genbank_multi_records') imd_pro = IntervalMetadata(9) imd_pro.add([(0, 9)], [(False, False)], {'organism': '"Bacteria"', 'type': 'source', 'strand': '+', '__location': '1..9'},) imd_pro.add([(0, 9)], [(False, True)], {'__location': '1..>9', 'product': '"L-carnitine amidase"', 'strand': '+', 'type': 'Protein'}) imd_dna = IntervalMetadata(9) imd_dna.add([(0, 9)], [(False, False)], {'country': '"Brazil: Parana, Paranavai"', 'type': 'source', 'strand': '+', '__location': '1..9', 'environmental_sample': ''}) imd_dna.add([(1, 8)], [(True, True)], {'__location': 'complement(<2..>8)', 'product': '"16S ribosomal RNA"', 'strand': '-', 'type': 'rRNA'}) self.multi = ( ('gsreildfk', {'ACCESSION': 'AAB29917', 'COMMENT': 'Method: direct peptide sequencing.', 'DBSOURCE': 'accession AAB29917.1', 'DEFINITION': 'L-carnitine amidase {N-terminal}', 'KEYWORDS': '.', 'LOCUS': {'date': '23-SEP-1994', 'division': 'BCT', 'locus_name': 'AAB29917', 'mol_type': None, 'shape': 'linear', 'size': 9, 'unit': 'aa'}, 'REFERENCE': [{'AUTHORS': 'Joeres,U. and Kula,M.R.', 'JOURNAL': 'AMB 40 (5), 606-610 (1994)', 'PUBMED': '7764422', 'REFERENCE': '1 (residues 1 to 9)', 'REMARK': 'from the original journal article.', 'TITLE': 'a microbial L-carnitine amidase'}, {'AUTHORS': 'Joeres,U. and Kula,M.R.', 'JOURNAL': 'AMB 40 (5), 606-610 (1994)', 'PUBMED': '7764422', 'REFERENCE': '1 (residues 1 to 9)', 'TITLE': 'a microbial L-carnitine amidase'}], 'SOURCE': {'ORGANISM': 'Bacteria', 'taxonomy': 'Unclassified.'}, 'VERSION': 'AAB29917.1 GI:545426'}, imd_pro, Protein), ('catgcaggc', {'ACCESSION': 'HQ018078', 'DEFINITION': 'Uncultured Xylanimonas sp.16S, partial', 'KEYWORDS': 'ENV.', 'LOCUS': {'date': '29-AUG-2010', 'division': 'ENV', 'locus_name': 'HQ018078', 'mol_type': 'DNA', 'shape': 'linear', 'size': 9, 'unit': 'bp'}, 'SOURCE': {'ORGANISM': 'uncultured Xylanimonas sp.', 'taxonomy': 'Bacteria; Actinobacteria; ' 'Micrococcales; Promicromonosporaceae; ' 'Xylanimonas; environmental samples.'}, 'VERSION': 'HQ018078.1 GI:304421728'}, imd_dna, DNA)) class ReaderTests(GenBankIOTests): def test_parse_reference(self): lines = ''' REFERENCE 1 (bases 1 to 154478) AUTHORS Sato,S., Nakamura,Y., Kaneko,T., and Tabata,S. TITLE Complete structure of the chloroplast genome of Arabidopsis thaliana JOURNAL DNA Res. 6 (5), 283-290 (1999) PUBMED 10574454'''.split('\n') exp = {'AUTHORS': 'Sato,S., Nakamura,Y., Kaneko,T., and Tabata,S.', 'JOURNAL': 'DNA Res. 6 (5), 283-290 (1999)', 'PUBMED': '10574454', 'REFERENCE': '1 (bases 1 to 154478)', 'TITLE': ('Complete structure of the chloroplast genome of' ' Arabidopsis thaliana')} self.assertEqual(_parse_reference(lines), exp) def test_parse_locus(self): for serialized, parsed in self.locus: self.assertEqual(_parse_locus(serialized), parsed) def test_parse_locus_invalid(self): lines = [ # missing unit ['LOCUS NC_005816 9609 ' ' DNA circular CON 07-FEB-2015'], # missing division ['LOCUS SCU49845 5028 bp' ' DNA 21-JUN-1999'], # wrong date format ['LOCUS NP_001832 360 aa' ' linear PRI 2001-12-18']] for line in lines: with self.assertRaisesRegex(GenBankFormatError, r'Could not parse the LOCUS line:.*'): _parse_locus(line) def test_genbank_to_generator_single(self): # test single record and uppercase sequence for c in [Sequence, Protein]: obs = next(_genbank_to_generator( self.single_upper_fp, constructor=c)) exp = c(self.single[0], metadata=self.single[1], positional_metadata=self.single[2]) self.assertEqual(exp, obs) def test_genbank_to_generator(self): for i, obs in enumerate(_genbank_to_generator(self.multi_fp)): seq, md, imd, constructor = self.multi[i] exp = constructor(seq, metadata=md, lowercase=True, interval_metadata=imd) self.assertEqual(exp, obs) def test_genbank_to_sequence(self): for i, exp in enumerate(self.multi): obs = _genbank_to_sequence(self.multi_fp, seq_num=i+1) exp = Sequence(exp[0], metadata=exp[1], lowercase=True, interval_metadata=exp[2]) self.assertEqual(exp, obs) def test_genbank_to_rna(self): seq, md, imd, constructor = self.single_rna obs = _genbank_to_rna(self.single_rna_fp) exp = constructor(seq, metadata=md, lowercase=True, interval_metadata=imd) self.assertEqual(exp, obs) def test_genbank_to_dna(self): i = 1 exp = self.multi[i] obs = _genbank_to_dna(self.multi_fp, seq_num=i+1) exp = DNA(exp[0], metadata=exp[1], lowercase=True, interval_metadata=exp[2]) self.assertEqual(exp, obs) def test_genbank_to_protein(self): i = 0 exp = self.multi[i] obs = _genbank_to_protein(self.multi_fp, seq_num=i+1) exp = Protein(exp[0], metadata=exp[1], lowercase=True, interval_metadata=exp[2]) self.assertEqual(exp, obs) class WriterTests(GenBankIOTests): def test_serialize_locus(self): for serialized, parsed in self.locus: self.assertEqual( _serialize_locus('LOCUS', parsed), serialized[0] + '\n') def test_generator_to_genbank(self): seq, md, imd, constructor = self.single obj = constructor(seq, md, interval_metadata=imd) with io.StringIO() as fh: _generator_to_genbank([obj], fh) obs = fh.getvalue() with open(self.single_lower_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_sequence_to_genbank(self): with io.StringIO() as fh: for i, (seq, md, imd, constructor) in enumerate(self.multi): obj = Sequence(seq, md, interval_metadata=imd, lowercase=True) _sequence_to_genbank(obj, fh) obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_dna_protein_to_genbank(self): writers = [_protein_to_genbank, _dna_to_genbank] with io.StringIO() as fh: for i, (seq, md, imd, constructor) in enumerate(self.multi): obj = constructor( seq, md, interval_metadata=imd, lowercase=True) writers[i](obj, fh) obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_rna_to_genbank(self): with io.StringIO() as fh: seq, md, imd, constructor = self.single_rna obj = constructor(seq, md, interval_metadata=imd, lowercase=True) _rna_to_genbank(obj, fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) class RoundtripTests(GenBankIOTests): def test_roundtrip_generator(self): with io.StringIO() as fh: _generator_to_genbank(_genbank_to_generator(self.multi_fp), fh) obs = fh.getvalue() with open(self.multi_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_rna(self): with io.StringIO() as fh: _rna_to_genbank(_genbank_to_rna(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_dna(self): with io.StringIO() as fh: _dna_to_genbank(_genbank_to_dna(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_protein(self): with io.StringIO() as fh: _protein_to_genbank(_genbank_to_protein(self.single_lower_fp), fh) obs = fh.getvalue() with open(self.single_lower_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_roundtrip_sequence(self): with io.StringIO() as fh: _sequence_to_genbank(_genbank_to_sequence(self.single_rna_fp), fh) obs = fh.getvalue() with open(self.single_rna_fp) as fh: exp = fh.read() self.assertEqual(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_gff3.py000066400000000000000000000321361446255456000222100ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import io from skbio.util import get_data_path from skbio.metadata import IntervalMetadata from skbio import DNA, Sequence from skbio.io import GFF3FormatError from skbio.io.format.gff3 import (_yield_record, _parse_record, _parse_attr, _gff3_sniffer, _gff3_to_interval_metadata, _interval_metadata_to_gff3, _gff3_to_generator, _generator_to_gff3, _gff3_to_sequence, _sequence_to_gff3, _gff3_to_dna, _dna_to_gff3, _serialize_interval_metadata) class GFF3IOTests(TestCase): def setUp(self): self.multi_fp = get_data_path('gff3_multi_record') self.single_fp = get_data_path('gff3_single_record') intvls = [{'bounds': [(0, 4641652)], 'metadata': {'source': 'European Nucleotide Archive', 'type': 'chromosome', 'score': '.', 'strand': '.', 'ID': 'chromosome:Chromosome', 'Alias': 'U00096.3', 'Is_circular': 'true'}}, {'bounds': [(147, 148)], 'metadata': {'source': 'regulondb_feature', 'type': 'biological_region', 'score': '.', 'strand': '+', 'external_name': 'Promoter thrLp (RegulonDB:ECK120010236)', 'logic_name': 'regulondb_promoter'}}, {'bounds': [(336, 2799)], 'metadata': {'source': 'Prodigal_v2.60', 'type': 'gene', 'score': '1.8', 'strand': '+', 'phase': 0, 'ID': '1_1', 'gc_cont': '0.427'}}, {'bounds': [(336, 2799)], 'metadata': {'source': 'Prodigal_v2.60', 'type': 'CDS', 'score': '333.8', 'strand': '+', 'phase': 0, 'ID': '1_2', 'Parent': '1_1', 'rbs_motif': 'GGAG/GAGG', 'rbs_spacer': '5-10bp'}}, {'bounds': [(0, 50), (55, 100)], 'metadata': {'source': 'Prodigal_v2.60', 'type': 'gene', 'score': '1.8', 'strand': '+', 'phase': 0, 'ID': '1_1', 'gene': 'FXR receptor'}}] self.upper_bound = 4641652 self.imd1 = IntervalMetadata(self.upper_bound) self.imd1.add(**intvls[0]) self.imd1.add(**intvls[1]) self.imd2 = IntervalMetadata(None) self.imd2.add(**intvls[2]) self.imd2.add(**intvls[3]) self.imd3 = IntervalMetadata(None) self.imd3.add(**intvls[4]) self.seq_fp = get_data_path('gff3_dna') self.seq = Sequence('ATGCATGCATGC', metadata={'id': 'NC_1', 'description': 'species X'}) self.seq.interval_metadata.add( [(0, 9)], metadata={'source': 'Prodigal_v2.60', 'type': 'gene', 'score': '.', 'strand': '+', 'phase': 0, 'ID': 'gene1', 'Name': 'FXR'}) self.dna = DNA(self.seq) class SnifferTests(TestCase): def setUp(self): self.positive_fps = map(get_data_path, [ 'gff3_multi_record', 'gff3_single_record', 'gff3_dna']) self.negative_fps = map(get_data_path, [ 'empty', 'whitespace_only', 'gff3_bad_missing_directive']) def test_positive(self): for fp in self.positive_fps: self.assertEqual(_gff3_sniffer(fp), (True, {})) def test_negative(self): for fp in self.negative_fps: self.assertEqual(_gff3_sniffer(fp), (False, {})) class ReaderTests(GFF3IOTests): def test_parse_attr(self): s = 'Dbxref=GO:000152,GO:001234;Note=fooo' obs = _parse_attr(s) exp = {'db_xref': 'GO:000152,GO:001234', 'note': 'fooo'} self.assertEqual(exp, obs) def test_yield_record(self): obs = [('data', 'seqid1', ['seqid1\txxx', 'seqid1\tyyy']), ('data', 'seqid2', ['seqid2\tzzz'])] s = ('seqid1\txxx\n' 'seqid1\tyyy\n' 'seqid2\tzzz\n') fh = io.StringIO(s) for i, j in zip(_yield_record(fh), obs): self.assertEqual(i, j) def test_parse_record_raise(self): chars = 'abc?!' for char in chars: lines = [ 'ctg123\t.\tgene\t1000\t9000\t.\t+\t%s\tID=gene00001' % char] with self.assertRaisesRegex( GFF3FormatError, r"unknown value for phase column: '%s'" % char): _parse_record(lines, 10000) def test_yield_record_raise(self): s = '##gff-version 3\nseq_1 . gene 1 3 . + . ID=gene01\n' with io.StringIO(s) as fh: with self.assertRaises(GFF3FormatError): list(_yield_record(fh)) def test_gff3_to_interval_metadata(self): obs = _gff3_to_interval_metadata( self.single_fp, seq_id='Chromosome') self.assertEqual(obs, self.imd1) def test_gff3_to_interval_metadata_empty(self): exp = IntervalMetadata(None) obs = _gff3_to_interval_metadata( # the seq id does not exist self.single_fp, seq_id='foo') self.assertEqual(obs, exp) def test_gff3_to_interval_metadata_bad(self): with self.assertRaisesRegex(GFF3FormatError, r'do not have 9 columns in this line'): _gff3_to_interval_metadata( get_data_path('gff3_bad_wrong_columns'), seq_id='Chromosome') def test_gff3_to_generator(self): exps = [('Chromosome', self.imd1), ('gi|556503834|ref|NC_000913.3|', self.imd2)] obss = _gff3_to_generator(self.multi_fp) for obs, exp in zip(obss, exps): self.assertEqual(obs, exp) def test_gff3_to_generator_empty(self): empty_fps = map(get_data_path, ['empty', 'whitespace_only']) for empty_fp in empty_fps: obs = list(_gff3_to_generator(empty_fp)) self.assertEqual(obs, []) def test_gff3_to_sequence(self): obs = _gff3_to_sequence(self.seq_fp) self.assertEqual(obs, self.seq) def test_gff3_to_dna(self): obs = _gff3_to_dna(self.seq_fp) self.assertEqual(obs, self.dna) class WriterTests(GFF3IOTests): def test_interval_metadata_to_gff3(self): with io.StringIO() as fh: _interval_metadata_to_gff3(self.imd1, fh, seq_id='Chromosome') # only compare the uncommented lines because the comments are not # stored in IntervalMetadata obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] with open(self.single_fp) as f: exp = [i.rstrip() for i in f.readlines() if not i.startswith('#')] self.assertEqual(obs, exp) def test_interval_metadata_to_gff3_missing_field(self): exp = 'ctg123\t.\tgene\t1\t9\t.\t.\t.\tID=gene00001;Name=EDEN' imd = IntervalMetadata(9) imd.add([(0, 9)], metadata={ 'type': 'gene', 'ID': 'gene00001', 'Name': 'EDEN'}) with io.StringIO() as fh: _interval_metadata_to_gff3(imd, fh, seq_id='ctg123') # only compare the uncommented lines because the comments are not # stored in IntervalMetadata obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] self.assertEqual([exp], obs) def test_interval_metadata_to_gff3_escape(self): # test escape of reserved char in GFF3 exp = 'ctg123\t.\tgene\t1\t9\t.\t.\t.\tID=a%3B%3D%26%2Cb' imd = IntervalMetadata(9) imd.add([(0, 9)], metadata={ 'type': 'gene', 'ID': 'a;=&,b'}) with io.StringIO() as fh: _interval_metadata_to_gff3(imd, fh, seq_id='ctg123') # only compare the uncommented lines because the comments are not # stored in IntervalMetadata obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] self.assertEqual([exp], obs) def test_interval_metadata_to_gff3_multiple_values(self): # test multiple values of db_xref are correctly serialized exp = 'ctg123\t.\tgene\t1\t9\t.\t.\t.\tDbxref=GO:000152,GO:001234' imd = IntervalMetadata(9) imd.add([(0, 9)], metadata={ 'type': 'gene', 'db_xref': ['GO:000152', 'GO:001234']}) with io.StringIO() as fh: _interval_metadata_to_gff3(imd, fh, seq_id='ctg123') # only compare the uncommented lines because the comments are not # stored in IntervalMetadata obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] self.assertEqual([exp], obs) def test_interval_metadata_to_gff3_empty(self): imd = IntervalMetadata(None) with io.StringIO() as fh: _interval_metadata_to_gff3(imd, fh, seq_id='foo') obs = fh.getvalue() self.assertEqual(obs, '##gff-version 3\n') def test_interval_metadata_to_gff3_sub_region(self): seq_id = 'NC 7' with open(self.multi_fp) as f: exp = [i.strip() for i in f if i.startswith(seq_id)] with io.StringIO() as fh: _serialize_interval_metadata( self.imd3, seq_id=seq_id, fh=fh, skip_subregion=False) obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] self.assertEqual(exp, obs) with io.StringIO() as fh: _serialize_interval_metadata(self.imd3, seq_id=seq_id, fh=fh) obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] # all the rest lines except the 1st are sub-region lines, so only # compare the first line from exp self.assertEqual(exp[:1], obs) def test_sequence_to_gff3(self): with io.StringIO() as fh: _sequence_to_gff3(self.seq, fh) obs = fh.getvalue() with open(self.seq_fp) as fh: exp = fh.read() self.assertEqual(exp, obs) def test_dna_to_gff3(self): with io.StringIO() as fh: _dna_to_gff3(self.dna, fh) obs = fh.getvalue() with open(self.seq_fp) as fh: exp = fh.read() self.assertEqual(exp, obs) def test_raise_subregion(self): im = IntervalMetadata(None) im.add([(0, 3), (7, 9)], metadata={'type': 'gene'}) with io.StringIO() as fh: with self.assertRaises(GFF3FormatError): _serialize_interval_metadata( im, seq_id='a', fh=fh, skip_subregion=False) class RoundtripTests(GFF3IOTests): def test_roundtrip_interval_metadata(self): '''''' with io.StringIO() as fh: _interval_metadata_to_gff3( _gff3_to_interval_metadata( self.single_fp, seq_id='Chromosome'), fh, seq_id='Chromosome') obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] with open(self.single_fp) as f: exp = [i.rstrip() for i in f.readlines() if not i.startswith('#')] self.assertEqual(obs, exp) def test_roundtrip_interval_metadata_generator(self): with io.StringIO() as fh: _generator_to_gff3( _gff3_to_generator(self.multi_fp), fh, skip_subregion=False) obs = [i for i in fh.getvalue().splitlines() if not i.startswith('#')] with open(self.multi_fp) as f: exp = [i.rstrip() for i in f.readlines() if not i.startswith('#')] self.assertEqual(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_lsmat.py000066400000000000000000000232671446255456000225100ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main from skbio import DistanceMatrix from skbio.io import LSMatFormatError from skbio.io.format.lsmat import ( _lsmat_to_dissimilarity_matrix, _lsmat_to_distance_matrix, _dissimilarity_matrix_to_lsmat, _distance_matrix_to_lsmat, _lsmat_sniffer) from skbio.stats.distance import DissimilarityMatrix, DistanceMatrixError class LSMatTestData(TestCase): def setUp(self): self.lsmat_1x1_fh = io.StringIO(LSMat_1x1) self.lsmat_2x2_fh = io.StringIO(LSMat_2x2) self.lsmat_2x2_asym_fh = io.StringIO(LSMat_2x2_ASYM) self.lsmat_3x3_fh = io.StringIO(LSMat_3x3) self.lsmat_3x3_whitespace_fh = io.StringIO(LSMat_3x3_WHITESPACE) self.lsmat_3x3_csv_fh = io.StringIO(LSMat_3x3_CSV) self.valid_fhs = [ self.lsmat_1x1_fh, self.lsmat_2x2_fh, self.lsmat_2x2_asym_fh, self.lsmat_3x3_fh, self.lsmat_3x3_whitespace_fh ] self.empty_fh = io.StringIO() self.invalid_1_fh = io.StringIO(INVALID_1) self.invalid_2_fh = io.StringIO(INVALID_2) self.invalid_3_fh = io.StringIO(INVALID_3) self.invalid_4_fh = io.StringIO(INVALID_4) self.invalid_5_fh = io.StringIO(INVALID_5) self.invalid_6_fh = io.StringIO(INVALID_6) self.invalid_fhs = [ (self.empty_fh, r'empty'), (self.invalid_1_fh, r'1 value\(s\).*2.*\(2\)'), (self.invalid_2_fh, r"'b'.*'a'"), (self.invalid_3_fh, r'extra row\(s\)'), (self.invalid_4_fh, r'2 row\(s\).*found 1'), (self.invalid_5_fh, r'2 row\(s\).*found 0'), (self.invalid_6_fh, r"delimiter '\\t'") ] class DissimilarityAndDistanceMatrixReaderWriterTests(LSMatTestData): def setUp(self): super(DissimilarityAndDistanceMatrixReaderWriterTests, self).setUp() self.lsmat_1x1_data = [[0.0]] self.lsmat_2x2_data = [[0.0, 0.123], [0.123, 0.0]] self.lsmat_2x2_asym_data = [[0.0, 1.0], [-2.0, 0.0]] self.lsmat_3x3_data = [[0.0, 0.01, 4.2], [0.01, 0.0, 12.0], [4.2, 12.0, 0.0]] # We repeat the 3x3 example because there are two file format # representations of it, one that is messy and one that is not. Both # should be read into an equivalent object and written to an equivalent # format though, which is why we duplicate the 3x3 objects and strings. self.dissim_objs = [ DissimilarityMatrix(self.lsmat_1x1_data, ['a']), DissimilarityMatrix(self.lsmat_2x2_data, ['a', 'b']), DissimilarityMatrix(self.lsmat_2x2_asym_data, ['a', 'b']), DissimilarityMatrix(self.lsmat_3x3_data, ['a', 'b', 'c']), DissimilarityMatrix(self.lsmat_3x3_data, ['a', 'b', 'c']) ] self.dissim_strs = [LSMat_1x1, LSMat_2x2, LSMat_2x2_ASYM, LSMat_3x3, LSMat_3x3] self.dissim_fhs = [self.lsmat_1x1_fh, self.lsmat_2x2_fh, self.lsmat_2x2_asym_fh, self.lsmat_3x3_fh, self.lsmat_3x3_whitespace_fh] self.dist_objs = [ DistanceMatrix(self.lsmat_1x1_data, ['a']), DistanceMatrix(self.lsmat_2x2_data, ['a', 'b']), DistanceMatrix(self.lsmat_3x3_data, ['a', 'b', 'c']), DistanceMatrix(self.lsmat_3x3_data, ['a', 'b', 'c']) ] self.dist_strs = [LSMat_1x1, LSMat_2x2, LSMat_3x3, LSMat_3x3] self.dist_fhs = [self.lsmat_1x1_fh, self.lsmat_2x2_fh, self.lsmat_3x3_fh, self.lsmat_3x3_whitespace_fh] def test_read_valid_files(self): for fn, cls, objs, fhs in ((_lsmat_to_dissimilarity_matrix, DissimilarityMatrix, self.dissim_objs, self.dissim_fhs), (_lsmat_to_distance_matrix, DistanceMatrix, self.dist_objs, self.dist_fhs)): for fh, obj in zip(fhs, objs): fh.seek(0) obs = fn(fh) self.assertEqual(obs, obj) self.assertIsInstance(obs, cls) # Above files are TSV (default delimiter). Test that CSV works too. for fn, cls in ((_lsmat_to_dissimilarity_matrix, DissimilarityMatrix), (_lsmat_to_distance_matrix, DistanceMatrix)): exp = cls(self.lsmat_3x3_data, ['a', 'b', 'c']) self.lsmat_3x3_csv_fh.seek(0) obs = fn(self.lsmat_3x3_csv_fh, delimiter=',') self.assertEqual(obs, exp) self.assertIsInstance(obs, cls) def test_read_invalid_files(self): for fn in _lsmat_to_dissimilarity_matrix, _lsmat_to_distance_matrix: for invalid_fh, error_msg_regexp in self.invalid_fhs: with self.assertRaisesRegex(LSMatFormatError, error_msg_regexp): invalid_fh.seek(0) fn(invalid_fh) # Asymmetric data only raises an error for DistanceMatrix. with self.assertRaises(DistanceMatrixError): _lsmat_to_distance_matrix(self.lsmat_2x2_asym_fh) def test_write(self): for fn, objs, strs in ((_dissimilarity_matrix_to_lsmat, self.dissim_objs, self.dissim_strs), (_distance_matrix_to_lsmat, self.dist_objs, self.dist_strs)): for obj, str_ in zip(objs, strs): fh = io.StringIO() fn(obj, fh) obs = fh.getvalue() fh.close() self.assertEqual(obs, str_) # Test writing CSV (TSV is written above). for fn, cls in ((_dissimilarity_matrix_to_lsmat, DissimilarityMatrix), (_distance_matrix_to_lsmat, DistanceMatrix)): obj = cls(self.lsmat_3x3_data, ['a', 'b', 'c']) fh = io.StringIO() fn(obj, fh, delimiter=',') obs = fh.getvalue() fh.close() self.assertEqual(obs, LSMat_3x3_CSV) def test_roundtrip_read_write(self): for reader_fn, writer_fn, fhs in ((_lsmat_to_dissimilarity_matrix, _dissimilarity_matrix_to_lsmat, self.dissim_fhs), (_lsmat_to_distance_matrix, _distance_matrix_to_lsmat, self.dist_fhs)): for fh in fhs: # Read. fh.seek(0) lsmat1 = reader_fn(fh) # Write. out_fh = io.StringIO() writer_fn(lsmat1, out_fh) out_fh.seek(0) # Read. lsmat2 = reader_fn(out_fh) out_fh.close() self.assertEqual(lsmat1, lsmat2) class SnifferTests(LSMatTestData): def setUp(self): super(SnifferTests, self).setUp() def test_match_tsv(self): # Sniffer should match all valid files, and will match some invalid # ones too because it doesn't exhaustively check the entire file. fhs = self.valid_fhs + [self.invalid_1_fh, self.invalid_3_fh, self.invalid_4_fh] for fh in fhs: self.assertEqual(_lsmat_sniffer(fh), (True, {'delimiter': '\t'})) def test_match_csv(self): self.assertEqual(_lsmat_sniffer(self.lsmat_3x3_csv_fh), (True, {'delimiter': ','})) def test_no_match(self): for fh in (self.empty_fh, self.invalid_2_fh, self.invalid_5_fh, self.invalid_6_fh): self.assertEqual(_lsmat_sniffer(fh), (False, {})) LSMat_1x1 = "\ta\na\t0.0\n" LSMat_2x2 = "\ta\tb\na\t0.0\t0.123\nb\t0.123\t0.0\n" LSMat_2x2_ASYM = "\ta\tb\na\t0.0\t1.0\nb\t-2.0\t0.0\n" LSMat_3x3 = ("\ta\tb\tc\na\t0.0\t0.01\t4.2\nb\t0.01\t0.0\t12.0\nc\t4.2\t12.0\t" "0.0\n") # Extra whitespace-only lines throughout. Also has comments before the header. LSMat_3x3_WHITESPACE = '\n'.join(['# foo', ' \t \t ', ' #bar', '', '', '\ta\t b \tc', 'a \t0.0\t0.01\t4.2', ' \t', 'b\t0.01\t0.0\t12.0', '', '\t \t', '', 'c\t4.2\t12.0\t0.0', '', ' \t ', '\t\t\t', ' ']) # Same matrix as above, but delimited by commas instead of tabs. LSMat_3x3_CSV = ",a,b,c\na,0.0,0.01,4.2\nb,0.01,0.0,12.0\nc,4.2,12.0,0.0\n" # missing data INVALID_1 = '\ta\tb\na\t0\t1\nb\t1' # mismatched IDs INVALID_2 = '\ta\tb\nb\t0\t1\na\t1\t0' # extra data lines INVALID_3 = '\ta\tb\na\t0\t1\nb\t1\t0\n \nfoo\n\n\n' # missing data lines INVALID_4 = '\ta\tb\na\t0\t1\n \n' # no data lines INVALID_5 = '\ta\tb\n' # missing leading delimiter in header INVALID_6 = "a\tb\na\t0.0\t0.123\nb\t0.123\t0.0\n" if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_newick.py000066400000000000000000000304621446255456000226430ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import unittest from skbio import TreeNode from skbio.io import NewickFormatError from skbio.io.format.newick import ( _newick_to_tree_node, _tree_node_to_newick, _newick_sniffer) class TestNewick(unittest.TestCase): def _assert_node_equal(self, n1, n2): self.assertEqual(n1.name, n2.name) self.assertEqual(n1.length, n2.length) self.assertEqual(len(n1.children), len(n2.children)) def _assert_equal(self, n1, n2): def name(x): return (str(x.name), float(x.length) if x.length is not None else 0, len(x.children)) self._assert_node_equal(n1, n2) for c1, c2 in zip(sorted(n1.children, key=name), sorted(n2.children, key=name)): self.assertTrue(c1.parent is n1) self.assertTrue(c2.parent is n2) self._assert_equal(c1, c2) def _setup_tree(self, kwargs_list): trees = [] for kwargs in kwargs_list: trees.append(TreeNode(**kwargs)) trees[4].extend([trees[2], trees[3]]) trees[5].extend([trees[0], trees[1], trees[4]]) return trees[5] def _setup_linked_list(self, kwargs_list): last_node = None for idx, kwargs in enumerate(kwargs_list): new_node = TreeNode(**kwargs) if last_node is not None: new_node.append(last_node) last_node = new_node return last_node def _setup_balanced_binary(self, kwargs_list): trees = [] for kwargs in kwargs_list: trees.append(TreeNode(**kwargs)) trees[0].extend([trees[2], trees[3]]) trees[1].extend([trees[4], trees[5]]) trees[6].extend([trees[0], trees[1]]) return trees[6] def setUp(self): # Using the factory functions above, we will construct different tree # instances. Each tree is expected to serialize to the first newick # string in the list. Each string in the list is expected to # deserialize into an equivilent rotation of the constructed instance. tree_blank = (self._setup_tree([ {}, {}, {}, {}, {}, {} ]), [ "(,,(,));\n", "(,(,),);", "((,),,);", " ((,[ this is a comment ]) , , ) ; ", "((,[ i_can_do_this[0] or escape unmatched '[ ]),[more words],);", ]) tree_leaves_named = (self._setup_tree([ {'name': 'a_'}, {'name': 'b'}, {'name': 'c'}, {'name': 'd'}, {}, {} ]), [ "('a_',b,(c,d));\n", "(b,(c,d),'a_');", "(b\n,'a_'\n ,(d \t,c) ) ;", ]) tree_all_named = (self._setup_tree([ {'name': 'a'}, {'name': 'b'}, {'name': 'c'}, {'name': '[whaaat!\']'}, {'name': 'e'}, {'name': 'f'} ]), [ "(a,b,(c,'[whaaat!'']')e)f;\n", "(b,(c,'[whaaat!'']')e,a)f;", "(b,[comment] \na,('[whaaat!'']',c)e)f;", ]) tree_all_but_root_distances = (self._setup_tree([ {'length': 0.1}, {'length': 0.2}, {'length': 0.3}, {'length': 0.4}, {'length': 0.5}, {} ]), [ "(:0.1,:0.2,(:0.3,:0.4):0.5);\n", "(:0.2,(:0.3,:0.4):0.5,:0.1);", "(:0.2,:0.1,(:0.4,:0.3):0.5);", ]) tree_all_distances = (self._setup_tree([ {'length': 0.1}, {'length': 0.2}, {'length': 0.3}, {'length': 0.4}, {'length': 0.5}, {'length': 0.0} ]), [ "(:0.1,:0.2,(:0.3,:0.4):0.5):0.0;\n", "(:0.2,(:0.3,:0.4):0.5,:0.1):0.0;", "(:0.2,\n:0.1,(:0.4,\n:0.3):0.5)\n:0.0;", ]) tree_all_leaves_named_with_distances = (self._setup_tree([ {'name': 'a', 'length': 0.1}, {'name': 'b_a\'', 'length': 0.2}, {'name': 'c', 'length': 0.3}, {'name': 'de d', 'length': 0.4}, {'length': 0.5}, {'length': 0.0} ]), [ "(a:0.1,'b_a''':0.2,(c:0.3,de_d:0.4):0.5):0.0;\n", "('b_a''':0.2,(c:0.3,'de d':0.4):0.5,a:0.1):0.0;", "('b_a''':0.2,a:0.1,('de d'[why not]:0.4,c:0.3):0.5):0.0;", ]) tree_all_leaves_named_with_distances_no_root = (self._setup_tree([ {'name': 'a', 'length': 0.1}, {'name': 'b_a\'', 'length': 0.2}, {'name': 'c', 'length': 0.3}, {'name': 'de d', 'length': 0.4}, {'length': 0.5}, {} ]), [ "(a:0.1,'b_a''':0.2,(c:0.3,de__d:0.4):0.5);\n", "('b_a''':0.2\n[comment ahoy]\n,(c:0.3,'de d':0.4):0.5,a:0.1);", "('b_a''':0.2,a:0.1,(de__d:0.4,c:0.3):0.5);" ]) tree_all = (self._setup_tree([ {'name': 'a', 'length': 0.1}, {'name': 'b_a\'', 'length': 0.2}, {'name': 'c', 'length': 0.3}, {'name': 'de\' d', 'length': 0.4}, {'name': 'e', 'length': 0.5}, {'name': 'f', 'length': 0.0} ]), [ "(a:0.1,'b_a''':0.2,(c:0.3,de''_d:0.4)e:0.5)f:0.0;\n", "('b_a''':0.2,(c:0.3,de''_d:0.4)e:0.5,a:0.1)f:0.0;", "((de''_d:0.4, c:0.3)e:0.5, 'b_a''':0.2, a:0.1)f:0.0;" ]) balanced_blank = (self._setup_balanced_binary([ {}, {}, {}, {}, {}, {}, {} ]), [ "((,),(,));\n", ]) balanced_named = (self._setup_balanced_binary([ {'name': 'a'}, {'name': 'b'}, {'name': 'c'}, {'name': 'd'}, {'name': 'e'}, {'name': 'f'}, {'name': 'g'} ]), [ "((c,d)a,(e,f)b)g;\n", ]) balanced_distances = (self._setup_balanced_binary([ {'length': 1.0}, {'length': 2.0}, {'length': 3.0}, {'length': 4.0}, {'length': 5.0}, {'length': 6.0}, {'length': 0.0} ]), [ "((:3.0,:4.0):1.0,(:5.0,:6.0):2.0):0.0;\n", ]) blanaced_all = (self._setup_balanced_binary([ {'name': 'a', 'length': 1.0}, {'name': 'b', 'length': 2.0}, {'name': 'c', 'length': 3.0}, {'name': 'd', 'length': 4.0}, {'name': 'e', 'length': 5.0}, {'name': 'f:f\'f', 'length': 6.0}, {'name': 'g', 'length': 0.0} ]), [ "((c:3.0,d:4.0)a:1.0,(e:5.0,'f:f''f':6.0)b:2.0)g:0.0;\n", ]) linked_list_blank = (self._setup_linked_list([ {}, {}, {}, {}, {} ]), [ "(((())));\n", "[(((())));](((())));", "[[(((())));](((())));](((())));\t\t\n" ]) linked_list_named = (self._setup_linked_list([ {'name': 'aaa'}, {'name': 'b_a\''}, {'name': 'c'}, {'name': 'de d'}, {'name': 'e'}, ]), [ "((((aaa)'b_a''')c)de_d)e;\n" ]) inked_list_distances = (self._setup_linked_list([ {'length': 0.4}, {'length': 0.3}, {'length': 0.2}, {'length': 0.1}, {'length': 0.0}, ]), [ "((((:0.4):0.3):0.2):0.1):0.0;\n", "((((:0.4)[not a label]:0.3):0.2):0.1):0.0;\t\t\n" ]) linked_list_all = (self._setup_linked_list([ {'name': 'a', 'length': 0.4}, {'name': 'b_a\'', 'length': 0.3}, {'name': 'c', 'length': 0.2}, {'name': 'de d', 'length': 0.1}, {'name': 'eee', 'length': 0.0}, ]), [ "((((a:0.4)'b_a''':0.3)c:0.2)de_d:0.1)eee:0.0;\n" ]) single_empty = (TreeNode(), [";\n", "[comment about the root" " and its properties];"]) single_named = (TreeNode(name='athing'), ["athing;\n"]) single_distance = (TreeNode(length=200.0), [":200.0;\n"]) single_all = (TreeNode(name='[a]', length=200.0), ["'[a]':200.0;\n"]) self.trees_newick_lists = [ tree_blank, tree_leaves_named, tree_all_named, tree_all_but_root_distances, tree_all_distances, tree_all_leaves_named_with_distances, tree_all_leaves_named_with_distances_no_root, tree_all, balanced_blank, balanced_named, balanced_distances, blanaced_all, linked_list_blank, linked_list_named, inked_list_distances, linked_list_all, single_empty, single_named, single_distance, single_all ] # Invalid newick strings and list of error fragments that should be # a part of the error message when read. self.invalid_newicks = [ ("", ['root']), ("This is not a newick file.", ['whitespace', 'label']), ("((();", ['Parenthesis', 'unbalanced']), ("(,,,)(,);\n", ['unnested', 'children']), ("(()());", ['unnested', 'children']), ("(():,,)", ['length']), ("[][[]('comment is the gotcha':0.2,,);", ['unbalanced', 'root']), ("#SampleID\tHeaderA\tHeaderB\n0\t'yellow'\t0.45;", ['whitespace', 'label']), ("))();", ['Parenthesis', 'unbalanced']), ("((,,),((,,));", ['Parenthesis', 'unbalanced']), ("\n".join([",".join(str(i) for i in range(100)) for _ in range(100)]), ['whitespace', 'label']) ] def test_newick_to_tree_node_valid_files(self): for tree, newicks in self.trees_newick_lists: for newick in newicks: fh = io.StringIO(newick) read_tree = _newick_to_tree_node(fh) self._assert_equal(tree, read_tree) fh.close() def test_newick_to_tree_node_invalid_files(self): for invalid, error_fragments in self.invalid_newicks: fh = io.StringIO(invalid) with self.assertRaises(NewickFormatError) as cm: _newick_to_tree_node(fh) for frag in error_fragments: self.assertIn(frag, str(cm.exception)) fh.close() def test_tree_node_to_newick(self): for tree, newicks in self.trees_newick_lists: newick = newicks[0] fh = io.StringIO() _tree_node_to_newick(tree, fh) self.assertEqual(newick, fh.getvalue()) fh.close() def test_roundtrip(self): for tree, newicks in self.trees_newick_lists: newick = newicks[0] fh = io.StringIO(newick) tree = _newick_to_tree_node(fh) fh2 = io.StringIO() _tree_node_to_newick(tree, fh2) fh2.seek(0) tree2 = _newick_to_tree_node(fh2) self.assertEqual(newick, fh2.getvalue()) self._assert_equal(tree, tree2) fh.close() fh2.close() def test_newick_to_tree_node_convert_underscores(self): fh = io.StringIO('(_:0.1, _a, _b)__;') tree = _newick_to_tree_node(fh, convert_underscores=False) fh2 = io.StringIO() _tree_node_to_newick(tree, fh2) self.assertEqual(fh2.getvalue(), "('_':0.1,'_a','_b')'__';\n") fh2.close() fh.close() def test_newick_sniffer_valid_files(self): for _, newicks in self.trees_newick_lists: for newick in newicks: fh = io.StringIO(newick) self.assertEqual(_newick_sniffer(fh), (True, {})) fh.close() def test_newick_sniffer_invalid_files(self): for invalid, _ in self.invalid_newicks: fh = io.StringIO(invalid) self.assertEqual(_newick_sniffer(fh), (False, {})) fh.close() if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_ordination.py000066400000000000000000000267131446255456000235350ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import numpy as np import pandas as pd import numpy.testing as npt from skbio import OrdinationResults from skbio.io import OrdinationFormatError from skbio.io.format.ordination import ( _ordination_to_ordination_results, _ordination_results_to_ordination, _ordination_sniffer) from skbio.util import get_data_path, assert_ordination_results_equal class OrdinationTestData(TestCase): def setUp(self): self.valid_fps = map( get_data_path, ['ordination_L&L_CA_data_scores', 'ordination_example3_scores', 'ordination_PCoA_sample_data_3_scores', 'ordination_example2_scores']) # Store filepath, regex for matching the error message that should be # raised when reading the file, and whether the file should be matched # by the sniffer (True) or not (False). self.invalid_fps = map(lambda e: (get_data_path(e[0]), e[1], e[2]), [ ('empty', r'end of file.*Eigvals header', False), ('whitespace_only', r'Eigvals header not found', False), ('ordination_error1', r'Eigvals header not found', False), ('ordination_error2', r'Proportion explained header not found', False), ('ordination_error3', r'Species header not found', True), ('ordination_error4', r'Site header not found', True), ('ordination_error5', r'Biplot header not found', True), ('ordination_error6', r'Site constraints header not found', True), ('ordination_error7', r'empty line', False), ('ordination_error8', r'9.*Proportion explained.*8', True), ('ordination_error9', r'2 values.*1 in row 1', True), ('ordination_error10', r'2 values.*1 in row 1', True), ('ordination_error11', r'Site constraints ids and site ids', True), ('ordination_error12', r'9.*Eigvals.*8', True), ('ordination_error13', r'9.*Proportion explained.*8', True), ('ordination_error14', r'Site is 0: 9 x 0', True), ('ordination_error15', r'9 values.*8 in row 1', True), ('ordination_error16', r'Biplot is 0: 3 x 0', True), ('ordination_error17', r'3 values.*2 in row 1', True), ('ordination_error18', r'proportion explained.*eigvals: 8 != 9', True), ('ordination_error19', r'coordinates.*species.*eigvals: 1 != 2', True), ('ordination_error20', r'coordinates.*site.*eigvals: 1 != 2', True), ('ordination_error21', r'one eigval', False), ('ordination_error22', r'end of file.*blank line', False), ('ordination_error23', r'end of file.*Proportion explained section', True), ('ordination_error24', r'end of file.*row 2.*Species section', True) ]) class OrdinationResultsReaderWriterTests(OrdinationTestData): def setUp(self): super(OrdinationResultsReaderWriterTests, self).setUp() # define in-memory results, one for each of the valid files in # self.valid_fps # CA results axes_ids = ['CA1', 'CA2'] species_ids = ['Species1', 'Species2', 'Species3'] site_ids = ['Site1', 'Site2', 'Site3'] eigvals = pd.Series([0.0961330159181, 0.0409418140138], axes_ids) species = pd.DataFrame([[0.408869425742, 0.0695518116298], [-0.1153860437, -0.299767683538], [-0.309967102571, 0.187391917117]], index=species_ids, columns=axes_ids) site = pd.DataFrame([[-0.848956053187, 0.882764759014], [-0.220458650578, -1.34482000302], [1.66697179591, 0.470324389808]], index=site_ids, columns=axes_ids) biplot = None site_constraints = None prop_explained = None ca_scores = OrdinationResults( 'CA', 'Correspondence Analysis', eigvals=eigvals, features=species, samples=site, biplot_scores=biplot, sample_constraints=site_constraints, proportion_explained=prop_explained) # CCA results axes_ids = ['CCA%d' % i for i in range(1, 10)] species_ids = ['Species0', 'Species1', 'Species2', 'Species3', 'Species4', 'Species5', 'Species6', 'Species7', 'Species8'] site_ids = ['Site0', 'Site1', 'Site2', 'Site3', 'Site4', 'Site5', 'Site6', 'Site7', 'Site8', 'Site9'] eigvals = pd.Series([0.366135830393, 0.186887643052, 0.0788466514249, 0.082287840501, 0.0351348475787, 0.0233265839374, 0.0099048981912, 0.00122461669234, 0.000417454724117], axes_ids) species = pd.DataFrame(np.loadtxt( get_data_path('ordination_exp_Ordination_CCA_species')), index=species_ids, columns=axes_ids) site = pd.DataFrame( np.loadtxt(get_data_path('ordination_exp_Ordination_CCA_site')), index=site_ids, columns=axes_ids) biplot = pd.DataFrame( [[-0.169746767979, 0.63069090084, 0.760769036049], [-0.994016563505, 0.0609533148724, -0.0449369418179], [0.184352565909, -0.974867543612, 0.0309865007541]], columns=axes_ids[:3]) site_constraints = pd.DataFrame(np.loadtxt( get_data_path('ordination_exp_Ordination_CCA_site_constraints')), index=site_ids, columns=axes_ids) prop_explained = None cca_scores = OrdinationResults('CCA', 'Canonical Correspondence Analysis', eigvals=eigvals, features=species, samples=site, biplot_scores=biplot, sample_constraints=site_constraints, proportion_explained=prop_explained) # PCoA results axes_ids = ['PC%d' % i for i in range(1, 10)] species_ids = None site_ids = ['PC.636', 'PC.635', 'PC.356', 'PC.481', 'PC.354', 'PC.593', 'PC.355', 'PC.607', 'PC.634'] eigvals = pd.Series([0.512367260461, 0.300719094427, 0.267912066004, 0.208988681078, 0.19169895326, 0.16054234528, 0.15017695712, 0.122457748167, 0.0], axes_ids) species = None site = pd.DataFrame( np.loadtxt(get_data_path('ordination_exp_Ordination_PCoA_site')), index=site_ids, columns=axes_ids) biplot = None site_constraints = None prop_explained = pd.Series([0.267573832777, 0.15704469605, 0.139911863774, 0.109140272454, 0.100111048503, 0.0838401161912, 0.0784269939011, 0.0639511763509, 0.0], axes_ids) pcoa_scores = OrdinationResults('PCoA', 'Principal Coordinate Analysis', eigvals=eigvals, features=species, samples=site, biplot_scores=biplot, sample_constraints=site_constraints, proportion_explained=prop_explained) # RDA results axes_ids = ['RDA%d' % i for i in range(1, 8)] species_ids = ['Species0', 'Species1', 'Species2', 'Species3', 'Species4', 'Species5'] site_ids = ['Site0', 'Site1', 'Site2', 'Site3', 'Site4', 'Site5', 'Site6', 'Site7', 'Site8', 'Site9'] eigvals = pd.Series([25.8979540892, 14.9825779819, 8.93784077262, 6.13995623072, 1.68070536498, 0.57735026919, 0.275983624351], axes_ids) species = pd.DataFrame(np.loadtxt( get_data_path('ordination_exp_Ordination_RDA_species')), index=species_ids, columns=axes_ids) site = pd.DataFrame( np.loadtxt(get_data_path('ordination_exp_Ordination_RDA_site')), index=site_ids, columns=axes_ids) biplot = pd.DataFrame( [[0.422650019179, -0.559142585857, -0.713250678211], [0.988495963777, 0.150787422017, -0.0117848614073], [-0.556516618887, 0.817599992718, 0.147714267459], [-0.404079676685, -0.9058434809, -0.127150316558]], columns=axes_ids[:3]) site_constraints = pd.DataFrame(np.loadtxt( get_data_path('ordination_exp_Ordination_RDA_site_constraints')), index=site_ids, columns=axes_ids) prop_explained = None rda_scores = OrdinationResults( 'RDA', 'Redundancy Analysis', eigvals=eigvals, features=species, samples=site, biplot_scores=biplot, sample_constraints=site_constraints, proportion_explained=prop_explained) self.ordination_results_objs = [ca_scores, cca_scores, pcoa_scores, rda_scores] def test_read_valid_files(self): for fp, obj in zip(self.valid_fps, self.ordination_results_objs): obs = _ordination_to_ordination_results(fp) assert_ordination_results_equal( obs, obj, ignore_method_names=True, ignore_axis_labels=True) def test_read_invalid_files(self): for invalid_fp, error_msg_regexp, _ in self.invalid_fps: with self.assertRaisesRegex(OrdinationFormatError, error_msg_regexp): _ordination_to_ordination_results(invalid_fp) def test_write(self): for fp, obj in zip(self.valid_fps, self.ordination_results_objs): fh = io.StringIO() _ordination_results_to_ordination(obj, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() npt.assert_equal(obs, exp) def test_roundtrip_read_write(self): for fp in self.valid_fps: # Read. obj1 = _ordination_to_ordination_results(fp) # Write. fh = io.StringIO() _ordination_results_to_ordination(obj1, fh) fh.seek(0) # Read. obj2 = _ordination_to_ordination_results(fh) fh.close() assert_ordination_results_equal(obj1, obj2) class SnifferTests(OrdinationTestData): def setUp(self): super(SnifferTests, self).setUp() def test_matches_and_nonmatches(self): # Sniffer should match all valid files, and will match some invalid # ones too because it doesn't exhaustively check the entire file. for fp in self.valid_fps: self.assertEqual(_ordination_sniffer(fp), (True, {})) for fp, _, expected_sniffer_match in self.invalid_fps: self.assertEqual(_ordination_sniffer(fp), (expected_sniffer_match, {})) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_phylip.py000066400000000000000000000232321446255456000226650ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import unittest from skbio.io import PhylipFormatError from skbio.io.format.phylip import ( _tabular_msa_to_phylip, _phylip_to_tabular_msa, _phylip_sniffer) from skbio import TabularMSA, DNA, RNA from skbio.util import get_data_path class TestSniffer(unittest.TestCase): def setUp(self): self.positives = [get_data_path(e) for e in [ 'phylip_dna_3_seqs', 'phylip_single_seq_long', 'phylip_single_seq_short', 'phylip_two_chunks', 'phylip_variable_length_ids', 'phylip_varied_whitespace_in_seqs', 'phylip_whitespace_in_header_1', 'phylip_whitespace_in_header_2', 'phylip_whitespace_in_header_3', ]] # negative tests for sniffer don't include # phylip_invalid_empty_line_between_seqs, phylip_invalid_too_few_seqs, # phylip_invalid_too_many_seqs - because sniffer only reads first seq self.negatives = [get_data_path(e) for e in [ 'empty', 'whitespace_only', 'phylip_invalid_empty_line_after_header', 'phylip_invalid_empty_line_before_header', 'phylip_invalid_header_too_long', 'phylip_invalid_header_too_short', 'phylip_invalid_no_header', 'phylip_invalid_seq_too_long', 'phylip_invalid_seq_too_short', 'phylip_invalid_zero_seq_len', 'phylip_invalid_zero_seqs', ]] def test_positives(self): for fp in self.positives: self.assertEqual(_phylip_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negatives: self.assertEqual(_phylip_sniffer(fp), (False, {})) class TestReaders(unittest.TestCase): def setUp(self): self.valid_configurations = [ ([get_data_path('phylip_dna_3_seqs')], [('..ACC-GTTGG..', 'd1'), ('TTACCGGT-GGCC', 'd2'), ('.-ACC-GTTGC--', 'd3')] ), ([get_data_path('phylip_single_seq_long')], [('..ACC-GTTGG..AATGC.C----', 'foo')] ), ([get_data_path('phylip_single_seq_short')], [('-', '')] ), ([get_data_path('phylip_two_chunks'), get_data_path('phylip_varied_whitespace_in_seqs'), get_data_path('phylip_whitespace_in_header_1'), get_data_path('phylip_whitespace_in_header_2'), get_data_path('phylip_whitespace_in_header_3'), ], [('..ACC-GTTGG..AATGC.C', 'foo'), ('TTACCGGT-GGCCTA-GCAT', 'bar')] ), ([get_data_path('phylip_variable_length_ids')], [('.-ACGT', ''), ('TGCA-.', 'a'), ('.ACGT-', 'bb'), ('TGCA-.', '1'), ('AAAAAA', 'abcdefghij'), ('GGGGGG', 'ab def42ij')] ), ] self.positive_fps = list(map(get_data_path, [ 'phylip_dna_3_seqs', 'phylip_single_seq_long', 'phylip_single_seq_short', 'phylip_two_chunks', 'phylip_variable_length_ids', 'phylip_varied_whitespace_in_seqs', 'phylip_whitespace_in_header_1', 'phylip_whitespace_in_header_2', 'phylip_whitespace_in_header_3', ])) self.invalid_files = [(get_data_path(e[0]), e[1], e[2]) for e in [ ('empty', PhylipFormatError, r'This file is empty.'), ('whitespace_only', PhylipFormatError, r'Found non-header line .*: ""'), ('phylip_invalid_empty_line_after_header', PhylipFormatError, r'Empty lines are not allowed.'), ('phylip_invalid_empty_line_before_header', PhylipFormatError, r'Found non-header line .*: ""'), ('phylip_invalid_empty_line_between_seqs', PhylipFormatError, r'Empty lines are not allowed.'), ('phylip_invalid_header_too_long', PhylipFormatError, r'Found non-header line .*: "2 20 extra_text"'), ('phylip_invalid_header_too_short', PhylipFormatError, r'Found non-header line .*: " 20"'), ('phylip_invalid_no_header', PhylipFormatError, r'Found non-header line .*: "foo .*"'), ('phylip_invalid_seq_too_long', PhylipFormatError, r'The length of sequence foo is not 20 as specified .*.'), ('phylip_invalid_seq_too_short', PhylipFormatError, r'The length of sequence foo is not 20 as specified .*.'), ('phylip_invalid_too_few_seqs', PhylipFormatError, r'The number of sequences is not .* as specified .*.'), ('phylip_invalid_too_many_seqs', PhylipFormatError, r'The number of sequences is not .* as specified in the header.'), ('phylip_invalid_zero_seq_len', PhylipFormatError, r'The number of sequences and the length must be positive.'), ('phylip_invalid_zero_seqs', PhylipFormatError, r'The number of sequences and the length must be positive.'), ]] def test_phylip_to_tabular_msa_invalid_files(self): for fp, error_type, error_msg_regex in self.invalid_files: with self.assertRaisesRegex(error_type, error_msg_regex): _phylip_to_tabular_msa(fp, constructor=DNA) def test_phylip_to_tabular_msa_no_constructor(self): with self.assertRaisesRegex(ValueError, '`constructor`'): _phylip_to_tabular_msa(get_data_path('phylip_dna_3_seqs')) def test_phylip_to_tabular_msa_valid_files(self): for valid_files, components in self.valid_configurations: for valid in valid_files: observed = _phylip_to_tabular_msa(valid, constructor=DNA) expected_seqs = [] expected_index = [] for seq, ID in components: expected_seqs.append(DNA(seq)) expected_index.append(ID) expected = TabularMSA(expected_seqs, index=expected_index) self.assertEqual(observed, expected) class TestWriters(unittest.TestCase): def setUp(self): # ids all same length, seqs longer than 10 chars dna_3_seqs = TabularMSA([ DNA('..ACC-GTTGG..', metadata={'id': "d1"}), DNA('TTACCGGT-GGCC', metadata={'id': "d2"}), DNA('.-ACC-GTTGC--', metadata={'id': "d3"})], minter='id') # id lengths from 0 to 10, with mixes of numbers, characters, and # spaces. sequences are shorter than 10 chars variable_length_ids = TabularMSA([ DNA('.-ACGT', metadata={'id': ''}), DNA('TGCA-.', metadata={'id': 'a'}), DNA('.ACGT-', metadata={'id': 'bb'}), DNA('TGCA-.', metadata={'id': '1'}), DNA('AAAAAA', metadata={'id': 'abcdefghij'}), DNA('GGGGGG', metadata={'id': 'ab def42ij'})], minter='id') # sequences with 20 chars = exactly two chunks of size 10 two_chunks = TabularMSA([ DNA('..ACC-GTTGG..AATGC.C', metadata={'id': 'foo'}), DNA('TTACCGGT-GGCCTA-GCAT', metadata={'id': 'bar'})], minter='id') # single sequence with more than two chunks single_seq_long = TabularMSA([ DNA('..ACC-GTTGG..AATGC.C----', metadata={'id': 'foo'})], minter='id') # single sequence with only a single character (minimal writeable # alignment) single_seq_short = TabularMSA([DNA('-', metadata={'id': ''})], minter='id') # alignments that can be written in phylip format self.objs = [dna_3_seqs, variable_length_ids, two_chunks, single_seq_long, single_seq_short] self.fps = map(get_data_path, ['phylip_dna_3_seqs', 'phylip_variable_length_ids', 'phylip_two_chunks', 'phylip_single_seq_long', 'phylip_single_seq_short']) # alignments that cannot be written in phylip format, paired with their # expected error message regexps self.invalid_objs = [ # no seqs (TabularMSA([]), 'one sequence'), # no positions (TabularMSA([DNA('', metadata={'id': "d1"}), DNA('', metadata={'id': "d2"})]), 'one position'), # ids too long (TabularMSA([RNA('ACGU', metadata={'id': "foo"}), RNA('UGCA', metadata={'id': "alongsequenceid"})], minter='id'), '10.*alongsequenceid') ] def test_write(self): for fp, obj in zip(self.fps, self.objs): fh = io.StringIO() _tabular_msa_to_phylip(obj, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_write_invalid_alignment(self): for invalid_obj, error_msg_regexp in self.invalid_objs: fh = io.StringIO() with self.assertRaisesRegex(PhylipFormatError, error_msg_regexp): _tabular_msa_to_phylip(invalid_obj, fh) # ensure nothing was written to the file before the error was # thrown obs = fh.getvalue() fh.close() self.assertEqual(obs, '') if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_qseq.py000066400000000000000000000316051446255456000223340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio import Sequence, DNA, RNA, Protein from skbio import read from skbio.util import get_data_path from skbio.io import QSeqFormatError from skbio.io.format.qseq import _qseq_to_generator, _qseq_sniffer import numpy as np def _drop_kwargs(kwargs, *args): for arg in args: if arg in kwargs: kwargs.pop(arg) class TestQSeqBase(unittest.TestCase): def setUp(self): self.valid_files = [ (get_data_path('qseq_single_seq_sanger'), [ {'variant': 'sanger'}, {'phred_offset': 33}, ], [ {'id': 'sanger_1:3:34:-30:30#0/2', 'sequence': 'ACGTACGTACGTACGTACGTACGTACTTTTTTTTTTACGTACGTACG' 'TACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC', 'quality': [26, 26, 29, 31, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93], 'machine_name': 'sanger', 'run_number': 1, 'lane_number': 3, 'tile_number': 34, 'x': -30, 'y': 30, 'index': 0, 'read_number': 2} ]), (get_data_path('qseq_multi_seq_illumina1.3'), [ {'variant': 'illumina1.3'}, {'phred_offset': 64} ], [ {'id': 'illumina_1:3:34:-30:30#0/1', 'sequence': 'ACG....ACGTAC', 'quality': [50, 53, 2, 2, 2, 2, 50, 2, 3, 5, 6, 7, 8], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 34, 'x': -30, 'y': 30, 'index': 0, 'read_number': 1}, {'id': 'illumina_1:3:35:-30:30#0/2', 'sequence': 'ACGTA.AATAAAC', 'quality': [39, 37, 20, 33, 1, 33, 38, 40, 55, 49, 1, 1, 38], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 35, 'x': -30, 'y': 30, 'index': 0, 'read_number': 2} ]), (get_data_path('qseq_multi_seq_illumina1.3'), [ {'variant': 'illumina1.3', 'filter': False, 'seq_num': 1}, {'phred_offset': 64, 'filter': False, 'seq_num': 2}, {'variant': 'illumina1.3', 'filter': False, 'seq_num': 3, 'constructor': Protein}, {'phred_offset': 64, 'filter': False, 'seq_num': 4, 'constructor': DNA}, ], [ {'id': 'illumina_1:3:34:-30:30#0/1', 'sequence': 'ACG....ACGTAC', 'quality': [50, 53, 2, 2, 2, 2, 50, 2, 3, 5, 6, 7, 8], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 34, 'x': -30, 'y': 30, 'index': 0, 'read_number': 1}, {'id': 'illumina_1:3:34:30:-30#0/1', 'sequence': 'CGGGCATTGCA', 'quality': [3, 7, 7, 7, 3, 33, 51, 36, 7, 3, 1], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 34, 'x': 30, 'y': -30, 'index': 0, 'read_number': 1}, {'id': 'illumina_1:3:35:-30:30#0/2', 'sequence': 'ACGTA.AATAAAC', 'quality': [39, 37, 20, 33, 1, 33, 38, 40, 55, 49, 1, 1, 38], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 35, 'x': -30, 'y': 30, 'index': 0, 'read_number': 2}, {'id': 'illumina_1:3:35:30:-30#0/3', 'sequence': 'CATTTAGGA.TGCA', 'quality': [52, 42, 38, 44, 43, 1, 6, 46, 43, 11, 39, 40, 54, 13], 'machine_name': 'illumina', 'run_number': 1, 'lane_number': 3, 'tile_number': 35, 'x': 30, 'y': -30, 'index': 0, 'read_number': 3} ]) ] self.invalid_files = [ (get_data_path('whitespace_only'), [ {}, {'variant': 'sanger'} ], [ 'blank line', ], QSeqFormatError), (get_data_path('tsv_10_fields'), [ {}, {'variant': 'sanger'}, {'variant': 'solexa'} ], [ 'read', '[1, 3]' ], QSeqFormatError), (get_data_path('tsv_8_fields'), [ {}, {'variant': 'sanger'}, {'variant': 'solexa'} ], [ '8', '10 or 11' ], QSeqFormatError), (get_data_path('qseq_invalid_filter'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'filter', '0 or 1', ], QSeqFormatError), (get_data_path('qseq_invalid_read'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'read', '[1, 3]', ], QSeqFormatError), (get_data_path('qseq_invalid_x'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'x', 'integer', ], QSeqFormatError), (get_data_path('qseq_invalid_y'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'y', 'integer', ], QSeqFormatError), (get_data_path('qseq_invalid_lane'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'lane', 'positive integer', ], QSeqFormatError), (get_data_path('qseq_invalid_tile'), [ {}, {'phred_offset': 33}, {'variant': 'solexa'}, {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'tile', 'positive integer', ], QSeqFormatError) ] class TestQSeqToGenerator(TestQSeqBase): def setUp(self): super(TestQSeqToGenerator, self).setUp() self.valid_files += [ (get_data_path('empty'), [{}, {'variant': 'sanger'}], []) ] self.invalid_files += [ (get_data_path('qseq_single_seq_sanger'), [ {'variant': 'illumina1.3'}, {'variant': 'illumina1.8'} ], [ 'out of range', '[0, 62]' ], ValueError) ] def test_invalid_files(self): for invalid, kwargs, errors, etype in self.invalid_files: with self.assertRaises(etype) as cm: for kwarg in kwargs: _drop_kwargs(kwarg, 'seq_num') list(_qseq_to_generator(invalid, **kwarg)) for e in errors: self.assertIn(e, str(cm.exception)) def test_valid_files(self): for valid, kwargs, components in self.valid_files: for kwarg in kwargs: _drop_kwargs(kwarg, 'seq_num') constructor = kwarg.get('constructor', Sequence) expected = [ constructor( c['sequence'], metadata={'id': c['id'], 'machine_name': c['machine_name'], 'run_number': c['run_number'], 'lane_number': c['lane_number'], 'tile_number': c['tile_number'], 'x': c['x'], 'y': c['y'], 'index': c['index'], 'read_number': c['read_number']}, positional_metadata={ 'quality': np.array(c['quality'], dtype=np.uint8)}) for c in components] observed = list(_qseq_to_generator(valid, **kwarg)) self.assertEqual(len(expected), len(observed)) for o, e in zip(observed, expected): self.assertEqual(o, e) class TestQSeqToSequences(TestQSeqBase): def test_invalid_files(self): for constructor in [Sequence, DNA, RNA, Protein]: for invalid, kwargs, errors, etype in self.invalid_files: with self.assertRaises(etype) as cm: for kwarg in kwargs: _drop_kwargs(kwarg, 'constructor', 'filter') read(invalid, format='qseq', verify=False, into=constructor, **kwarg) for e in errors: self.assertIn(e, str(cm.exception)) def test_valid_files(self): for constructor in [Sequence, DNA, RNA, Protein]: for valid, kwargs, components in self.valid_files: for observed_kwargs in kwargs: expected_kwargs = {} # Currently not validating the alphabet for qseq # files that are read in for this test. if hasattr(constructor, 'alphabet'): observed_kwargs['validate'] = False expected_kwargs['validate'] = False _drop_kwargs(observed_kwargs, 'constructor', 'filter') seq_num = observed_kwargs.get('seq_num', 1) c = components[seq_num - 1] expected = constructor( c['sequence'], metadata={'id': c['id'], 'machine_name': c['machine_name'], 'run_number': c['run_number'], 'lane_number': c['lane_number'], 'tile_number': c['tile_number'], 'x': c['x'], 'y': c['y'], 'index': c['index'], 'read_number': c['read_number']}, positional_metadata={ 'quality': np.array(c['quality'], np.uint8)}, **expected_kwargs) observed = read(valid, into=constructor, format='qseq', verify=False, **observed_kwargs) self.assertEqual(observed, expected) class TestQSeqSniffer(TestQSeqBase): def setUp(self): super(TestQSeqSniffer, self).setUp() self.invalid_files += [ (get_data_path('empty'), None, None, None) ] def test_qseq_sniffer_valid_files(self): for valid, _, _ in self.valid_files: self.assertEqual(_qseq_sniffer(valid), (True, {})) def test_qseq_sniffer_invalid_files(self): for invalid, _, _, _ in self.invalid_files: self.assertEqual(_qseq_sniffer(invalid), (False, {})) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_sequence_feature_vocabulary.py000066400000000000000000000073231446255456000271350ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main from skbio.io.format._sequence_feature_vocabulary import ( _parse_loc_str, _parse_section_default, _serialize_location) from skbio.io import FileFormatError from skbio.metadata import IntervalMetadata class Tests(TestCase): def test_parse_section_default(self): lines = [ ['FOO blah blah', ' blah'], ['FOO=blah', ' blah'], ['FOO']] kwargs = [{'join_delimiter': '=', 'return_label': False}, {'label_delimiter': '=', 'join_delimiter': '', 'return_label': True}, {'label_delimiter': '=', 'join_delimiter': '=', 'return_label': True}] expects = ['blah blah=blah', ('FOO', 'blahblah'), ('FOO', '')] for i, j, k in zip(lines, kwargs, expects): self.assertEqual(k, _parse_section_default(i, **j)) def test_parse_loc_str(self): examples = [ '9', # a single base in the presented sequence '3..8', '<3..8', '3..>8', 'complement(3..>8)', 'complement(join(3..>5,<7..9))', 'join(J00194.1:1..9,3..8)', 'join(3..8,J00194.1:1..9)', '1.9', '1^2'] expects = [ ([(8, 9)], [(False, False)], {'strand': '+'}), ([(2, 8)], [(False, False)], {'strand': '+'}), ([(2, 8)], [(True, False)], {'strand': '+'}), ([(2, 8)], [(False, True)], {'strand': '+'}), ([(2, 8)], [(False, True)], {'strand': '-'}), ([(2, 5), (6, 9)], [(False, True), (True, False)], {'strand': '-'}), ([(2, 8)], [(False, False)], {'strand': '+'}), ([(2, 8)], [(False, False)], {'strand': '+'}), ([(0, 9)], [(False, False)], {'strand': '+'}), ([(0, 1)], [(False, False)], {'strand': '+'})] for example, expect in zip(examples, expects): parsed = _parse_loc_str(example) self.assertEqual(parsed, expect) def test_parse_loc_str_invalid(self): examples = [ 'abc', '3-8'] for example in examples: with self.assertRaisesRegex(FileFormatError, r'Could not parse location string: ' '"%s"' % example): _parse_loc_str(example) def test_serialize_location(self): imd = IntervalMetadata(9) i1 = imd.add([(0, 1)]) self.assertEqual(_serialize_location(i1), '1') i2 = imd.add([(0, 2)], [(True, True)]) self.assertEqual(_serialize_location(i2), '<1..>2') i3 = imd.add([(0, 2)], [(False, True)]) self.assertEqual(_serialize_location(i3), '1..>2') i4 = imd.add([(0, 2)], [(True, False)]) self.assertEqual(_serialize_location(i4), '<1..2') i5 = imd.add([(0, 2), (3, 9)], metadata={'strand': '-'}) self.assertEqual(_serialize_location(i5), 'complement(join(1..2,4..9))') i6 = imd.add([(0, 2), (3, 9)], [(True, False), (False, True)], metadata={'strand': '-'}) self.assertEqual(_serialize_location(i6), 'complement(join(<1..2,4..>9))') if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/io/format/tests/test_stockholm.py000066400000000000000000001217011446255456000233630ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import pandas as pd import io import unittest from collections import OrderedDict from skbio import TabularMSA, Protein, DNA, RNA from skbio.io import StockholmFormatError from skbio.io.format.stockholm import (_stockholm_to_tabular_msa, _tabular_msa_to_stockholm, _stockholm_sniffer) from skbio.util import get_data_path class TestStockholmSniffer(unittest.TestCase): def setUp(self): self.positives = [get_data_path(e) for e in [ 'stockholm_extensive', 'stockholm_minimal', 'stockholm_rna', 'stockholm_runon_gf_with_whitespace', 'stockholm_runon_gf_no_whitespace', 'stockholm_duplicate_sequence_names', 'stockholm_duplicate_gr', 'stockholm_duplicate_gc', 'stockholm_invalid_nonexistent_gr', 'stockholm_invalid_nonexistent_gs', 'stockholm_no_data', 'stockholm_blank_lines', 'stockholm_differing_gc_data_length', 'stockholm_differing_gr_data_length', 'stockholm_differing_seq_lengths', 'stockholm_duplicate_sequence_names', 'stockholm_duplicate_tree_ids', 'stockholm_extensive_mixed', 'stockholm_invalid_data_type', 'stockholm_malformed_gf_line', 'stockholm_malformed_gs_line', 'stockholm_malformed_gr_line', 'stockholm_malformed_gc_line', 'stockholm_malformed_data_line', 'stockholm_metadata_only', 'stockholm_multiple_msa', 'stockholm_multiple_trees', 'stockholm_runon_gs_with_whitespace', 'stockholm_runon_gs_no_whitespace', 'stockholm_single_tree_with_id', 'stockholm_single_tree_without_id', 'stockholm_whitespace_only_lines', 'stockholm_all_data_types', 'stockholm_two_of_each_metadata', 'stockholm_data_only', 'stockholm_nonstring_labels', 'stockholm_missing_reference_items', 'stockholm_multiple_references', 'stockholm_runon_references', 'stockholm_runon_references_mixed', 'stockholm_single_reference', 'stockholm_missing_reference_items', 'stockholm_missing_rn_tag', 'stockholm_different_padding', 'stockholm_multi_line_tree_no_id', 'stockholm_multi_line_tree_with_id', 'stockholm_multiple_multi_line_trees' ]] self.negatives = [get_data_path(e) for e in [ 'stockholm_missing_header', 'empty', 'whitespace_only' ]] def test_positives(self): for fp in self.positives: self.assertEqual(_stockholm_sniffer(fp), (True, {})) def test_negatives(self): for fp in self.negatives: self.assertEqual(_stockholm_sniffer(fp), (False, {})) class TestStockholmReader(unittest.TestCase): def test_stockholm_extensive(self): fp = get_data_path('stockholm_extensive') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) exp = TabularMSA([Protein('MTCRAQLIAVPRASSLAE..AIACAQKM....' 'RVSRVPVYERS', positional_metadata={'SA': list('9998877564' '53524252..' '55152525..' '..36463774' '777')}), Protein('EVMLTDIPRLHINDPIMK..GFGMVINN....' '..GFVCVENDE', metadata={'OS': 'Bacillus subtilis'}, positional_metadata={'SS': list('CCCCCCCHHHH' 'HHHHHHH..HE' 'EEEEEE....E' 'EEEEEE' 'EEEH')}), Protein('EVMLTDIPRLHINDPIMK..GFGMVINN...' '...GFVCVENDE', positional_metadata={'AS': list('___________' '_____*_____' '___________' '________' '__'), 'IN': list('___________' '_1_________' '_____2_____' '_____0_' '___')})], metadata={'ID': 'CBS', 'AC': 'PF00571', 'AU': 'Bateman A', 'SQ': '67'}, positional_metadata={'SS_cons': list('CCCCCHHHHHHHH' 'HHHHH..EEEEEE' 'EE....EEEEEEE' 'EEEH')}, index=['O83071/192-246', 'O31698/88-139', 'O31699/88-139']) self.assertEqual(msa, exp) def test_stockholm_extensive_mixed(self): fp = get_data_path('stockholm_extensive_mixed') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) exp = TabularMSA([Protein('MTCRAQLIAVPRASSLAE..AIACAQKM....' 'RVSRVPVYERS', positional_metadata={'SA': list('9998877564' '53524252..' '55152525..' '..36463774' '777')}), Protein('EVMLTDIPRLHINDPIMK..GFGMVINN....' '..GFVCVENDE', metadata={'OS': 'Bacillus subtilis'}, positional_metadata={'SS': list('CCCCCCCHHHH' 'HHHHHHH..HE' 'EEEEEE....E' 'EEEEEE' 'EEEH')}), Protein('EVMLTDIPRLHINDPIMK..GFGMVINN...' '...GFVCVENDE', positional_metadata={'AS': list('___________' '_____*_____' '___________' '________' '__'), 'IN': list('___________' '_1_________' '_____2_____' '_____0_' '___')})], metadata={'ID': 'CBS', 'AC': 'PF00571', 'AU': 'Bateman A', 'SQ': '67'}, positional_metadata={'SS_cons': list('CCCCCHHHHHHHH' 'HHHHH..EEEEEE' 'EE....EEEEEEE' 'EEEH')}, index=['O83071/192-246', 'O31698/88-139', 'O31699/88-139']) self.assertEqual(msa, exp) def test_stockholm_minimal(self): fp = get_data_path('stockholm_minimal') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([DNA('TGTGTCGCAGTTGTCGTTTG')], index=['0235244']) self.assertEqual(msa, exp) def test_stockholm_rna(self): fp = get_data_path('stockholm_rna') msa = _stockholm_to_tabular_msa(fp, constructor=RNA) exp = TabularMSA([RNA('AAGGGUUAUUUAUAUACUUU'), RNA('UGCUAAGAGUGGGGAUGAUU'), RNA('GCCACAACCGAUUAGAUAGA'), RNA('UUAGAAACCGAUGGACCGAA')], metadata={'AC': 'G2134T23', 'ID': 'ARD'}, positional_metadata=( {'AC_cons': list('GGGACUGGACAUCUAUUCAG')}), index=['RTC2231', 'RTF2124', 'RTH3322', 'RTB1512']) self.assertEqual(msa, exp) def test_stockholm_runon_gf(self): fp = get_data_path('stockholm_runon_gf_no_whitespace') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([DNA('ACTGGTTCAATG')], metadata={'CC': 'CBS domains are small intracellular' ' modules mostly found in 2 or four ' 'copies within a protein.'}, index=['GG1344']) self.assertEqual(msa, exp) fp = get_data_path('stockholm_runon_gf_with_whitespace') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) self.assertEqual(msa, exp) def test_stockholm_runon_gs(self): fp = get_data_path('stockholm_runon_gs_no_whitespace') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([DNA('ATCGTTCAGTG', metadata={'LN': 'This is a runon GS line.'})], index=['seq1']) self.assertEqual(msa, exp) fp = get_data_path('stockholm_runon_gs_with_whitespace') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) self.assertEqual(msa, exp) def test_stockholm_metadata_only(self): fp = get_data_path('stockholm_metadata_only') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NM': 'Kestrel Gorlick', 'DT': 'February 5th, 2016'}) self.assertEqual(msa, exp) def test_stockholm_no_data(self): fp = get_data_path('stockholm_no_data') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([]) self.assertEqual(msa, exp) def test_stockholm_with_blank_lines(self): fp = get_data_path('stockholm_blank_lines') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'AL': 'ABCD', 'NM': '1234'}) self.assertEqual(msa, exp) def test_stockholm_with_whitespace_only_lines(self): fp = get_data_path('stockholm_whitespace_only_lines') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'AL': 'ABCD', 'NM': '1234'}) self.assertEqual(msa, exp) def test_stockholm_single_tree_without_id(self): fp = get_data_path('stockholm_single_tree_without_id') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': 'ABCD'}) self.assertEqual(msa, exp) def test_stockholm_single_tree_with_id(self): fp = get_data_path('stockholm_single_tree_with_id') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': {'tree1': 'ABCD'}}) self.assertEqual(msa, exp) def test_stockholm_multiple_trees(self): fp = get_data_path('stockholm_multiple_trees') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': {'tree1': 'ABCD', 'tree2': 'EFGH', 'tree3': 'IJKL'}}) self.assertEqual(msa, exp) def test_stockhom_single_reference(self): fp = get_data_path('stockholm_single_reference') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RM', '123456789'), ('RT', 'A Title'), ('RA', 'The Author'), ('RL', 'A Location'), ('RC', 'Comment')])]}) self.assertEqual(msa, exp) def test_stockholm_multiple_references(self): fp = get_data_path('stockholm_multiple_references') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RM', '123456789'), ('RT', 'Title 1'), ('RA', 'Author 1'), ('RL', 'Location 1'), ('RC', 'Comment 1')]), OrderedDict([('RM', '987654321'), ('RT', 'Title 2'), ('RA', 'Author 2'), ('RL', 'Location 2'), ('RC', 'Comment 2')]), OrderedDict([('RM', '132465879'), ('RT', 'Title 3'), ('RA', 'Author 3'), ('RL', 'Location 3'), ('RC', 'Comment 3')])]}) self.assertEqual(msa, exp) def test_stockholm_runon_references(self): fp = get_data_path('stockholm_runon_references') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RM', '123456789'), ('RT', 'A Runon Title'), ('RA', 'The Author'), ('RL', 'A Location'), ('RC', 'A Runon Comment')])]}) self.assertEqual(msa, exp) def test_stockholm_mixed_runon_references(self): fp = get_data_path('stockholm_runon_references_mixed') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RC', 'A Runon Comment'), ('RM', '123456789'), ('RT', 'A Runon Title'), ('RA', 'The Author'), ('RL', 'A Location')])]}) self.assertEqual(msa, exp) def test_stockholm_to_msa_different_padding(self): fp = get_data_path('stockholm_different_padding') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RC', 'A Runon Comment Without ' 'Whitespace')]), OrderedDict([('RC', 'A Runon Comment With ' 'Whitespace')])]}) self.assertEqual(msa, exp) def test_stockholm_handles_missing_reference_items(self): fp = get_data_path('stockholm_missing_reference_items') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA( [], metadata={'RN': [OrderedDict([('RT', 'A Title'), ('RA', 'The Author')])]}) self.assertEqual(msa, exp) def test_stockholm_multi_line_tree_no_id(self): fp = get_data_path('stockholm_multi_line_tree_no_id') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': 'ABCDEFGH'}) self.assertEqual(msa, exp) def test_stockholm_multiple_multi_line_trees(self): fp = get_data_path('stockholm_multiple_multi_line_trees') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': {'tree1': 'ABCDEFGH', 'tree2': 'IJKLMNOP'}}) self.assertEqual(msa, exp) def test_stockholm_multi_line_tree_with_id(self): fp = get_data_path('stockholm_multi_line_tree_with_id') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) exp = TabularMSA([], metadata={'NH': {'tree1': 'ABCDEFGH'}}) self.assertEqual(msa, exp) def test_multiple_msa_file(self): fp = get_data_path('stockholm_multiple_msa') msa = _stockholm_to_tabular_msa(fp, constructor=RNA) exp = TabularMSA([RNA('AAGGGUUAUUUAUAUACUUU'), RNA('UGCUAAGAGUGGGGAUGAUU'), RNA('GCCACAACCGAUUAGAUAGA'), RNA('UUAGAAACCGAUGGACCGAA')], metadata={'AC': 'G2134T23', 'ID': 'ARD'}, positional_metadata=( {'AC_cons': list('GGGACUGGACAUCUAUUCAG')}), index=['RTC2231', 'RTF2124', 'RTH3322', 'RTB1512']) self.assertEqual(msa, exp) def test_stockholm_maintains_order(self): fp = get_data_path('stockholm_two_of_each_metadata') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) msa_order = list(msa.metadata.items()) exp_order = [('NM', 'Kestrel Gorlick'), ('DT', 'February 5th, 2016')] self.assertEqual(msa_order, exp_order) msa_order = list(msa[0].metadata.items()) exp_order = [('AL', 'ABCD'), ('NS', '1234')] self.assertEqual(msa_order, exp_order) msa_order = list(msa.positional_metadata.columns) exp_order = ['SS_cons', 'AS_cons'] self.assertEqual(msa_order, exp_order) msa_order = list(msa[0].positional_metadata.columns) exp_order = ['SS', 'AS'] self.assertEqual(msa_order, exp_order) def test_stockholm_duplicate_tree_id_error(self): fp = get_data_path('stockholm_duplicate_tree_ids') with self.assertRaisesRegex(StockholmFormatError, r'Tree.*tree1.*in file.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_stockholm_missing_reference_number_error(self): fp = get_data_path('stockholm_missing_rn_tag') with self.assertRaisesRegex(StockholmFormatError, r"Expected 'RN'.*'RL' tag."): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_nonexistent_gr_error(self): fp = get_data_path('stockholm_invalid_nonexistent_gr') with self.assertRaisesRegex(StockholmFormatError, r'GS or GR.*nonexistent ' 'sequence.*RL1355.'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_nonexistent_gs_error(self): fp = get_data_path('stockholm_invalid_nonexistent_gs') with self.assertRaisesRegex(StockholmFormatError, r'GS or GR.*nonexistent sequence.*AC14.'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_duplicate_sequence_names_error(self): fp = get_data_path('stockholm_duplicate_sequence_names') with self.assertRaisesRegex( StockholmFormatError, r'duplicate sequence name.*ASR132.*supported by the reader.'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_duplicate_gr_error(self): fp = get_data_path('stockholm_duplicate_gr') with self.assertRaisesRegex(StockholmFormatError, r'Found duplicate GR.*OS.*LFDR3.*supported' ' by the reader.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_duplicate_gc_error(self): fp = get_data_path('stockholm_duplicate_gc') with self.assertRaisesRegex(StockholmFormatError, r'Found duplicate GC.*SS_cons.*supported ' 'by the reader.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_empty_file_error(self): fp = get_data_path('empty') with self.assertRaisesRegex(StockholmFormatError, r'File is empty.'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_missing_header_error(self): fp = get_data_path('stockholm_missing_header') with self.assertRaisesRegex(StockholmFormatError, r'File missing.*header'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_missing_footer_error(self): fp = get_data_path('stockholm_missing_footer') with self.assertRaisesRegex(StockholmFormatError, r'Final line.*only "//".'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_data_type_error(self): fp = get_data_path('stockholm_invalid_data_type') with self.assertRaisesRegex(StockholmFormatError, r"Unrecognized.*'#=GZ"): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_malformed_gf_line_error(self): fp = get_data_path('stockholm_malformed_gf_line') with self.assertRaisesRegex(StockholmFormatError, r'Line contains 2.*must contain.*3.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_malformed_gs_line_error(self): fp = get_data_path('stockholm_malformed_gs_line') with self.assertRaisesRegex(StockholmFormatError, r'Line contains 3.*must contain.*4.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_malformed_gr_line_error(self): fp = get_data_path('stockholm_malformed_gr_line') with self.assertRaisesRegex(StockholmFormatError, r'Line contains 2.*must contain.*4.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_malformed_gc_line_error(self): fp = get_data_path('stockholm_malformed_gc_line') with self.assertRaisesRegex(StockholmFormatError, r'Line contains 2.*must contain.*3.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_malformed_data_line_error(self): fp = get_data_path('stockholm_malformed_data_line') with self.assertRaisesRegex(StockholmFormatError, r'Line contains 1.*must contain.*2.'): _stockholm_to_tabular_msa(fp, constructor=DNA) def test_differing_sequence_lengths_error(self): fp = get_data_path('stockholm_differing_seq_lengths') with self.assertRaisesRegex(ValueError, r'Each sequence.*11 != 10'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_differing_data_lengths_gr_error(self): fp = get_data_path('stockholm_differing_gr_data_length') with self.assertRaisesRegex(ValueError, r'Number.*7.*(8).'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_differing_data_lengths_gc_error(self): fp = get_data_path('stockholm_differing_gc_data_length') with self.assertRaisesRegex(ValueError, r'Number.*12.*(10).'): _stockholm_to_tabular_msa(fp, constructor=RNA) def test_no_constructor_error(self): fp = get_data_path('empty') with self.assertRaisesRegex(ValueError, r'Must provide.*parameter.'): _stockholm_to_tabular_msa(fp) def test_unsupported_constructor_error(self): fp = get_data_path('empty') with self.assertRaisesRegex(TypeError, r'`constructor`.*`GrammaredSequence`.'): _stockholm_to_tabular_msa(fp, constructor=TabularMSA) class TestStockholmWriter(unittest.TestCase): def test_msa_to_stockholm_extensive(self): fp = get_data_path('stockholm_all_data_types') msa = TabularMSA([DNA('GAGGCCATGCCCAGGTGAAG', metadata=OrderedDict([('DT', 'February 1, 2016'), ('NM', 'Unknown')])), DNA('ACCTGAGCCACAGTAGAAGT'), DNA('CCCTTCGCTGGAAATGTATG', metadata={'DT': 'Unknown'}, positional_metadata=OrderedDict([('AS', list('CCGAAAGT' 'CGTTCGA' 'AAATG')), ('SS', list('GGCGAGTC' 'GTTCGAGC' 'TGG' 'C'))]))], metadata=OrderedDict([('NM', 'Kestrel Gorlick'), ('DT', 'February 11, 2016'), ('FN', 'Writer test file')]), positional_metadata=OrderedDict([('AS_cons', list('CGTTCGTTCTAAC' 'AATTCCA')), ('SS_cons', list('GGCGCTACGACCT' 'ACGACCG'))]), index=['seq1', 'seq2', 'seq3']) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_minimal(self): fp = get_data_path('stockholm_minimal') msa = TabularMSA([DNA('TGTGTCGCAGTTGTCGTTTG')], index=['0235244']) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_single_tree(self): fp = get_data_path('stockholm_single_tree_without_id') msa = TabularMSA([], metadata=OrderedDict([('NH', 'ABCD')])) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_single_tree_as_dict(self): fp = get_data_path('stockholm_single_tree_with_id') msa = TabularMSA([], metadata={'NH': {'tree1': 'ABCD'}}) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_multiple_trees(self): fp = get_data_path('stockholm_multiple_trees') msa = TabularMSA([], metadata=OrderedDict([('NH', OrderedDict([('tree1', 'ABCD'), ('tree2', 'EFGH'), ('tree3', 'IJKL')]))])) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_single_reference(self): fp = get_data_path('stockholm_single_reference') msa = TabularMSA( [], metadata={'RN': [OrderedDict([('RM', '123456789'), ('RT', 'A Title'), ('RA', 'The Author'), ('RL', 'A Location'), ('RC', 'Comment')])]}) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_multiple_references(self): fp = get_data_path('stockholm_multiple_references') msa = TabularMSA( [], metadata={'RN': [OrderedDict([('RM', '123456789'), ('RT', 'Title 1'), ('RA', 'Author 1'), ('RL', 'Location 1'), ('RC', 'Comment 1')]), OrderedDict([('RM', '987654321'), ('RT', 'Title 2'), ('RA', 'Author 2'), ('RL', 'Location 2'), ('RC', 'Comment 2')]), OrderedDict([('RM', '132465879'), ('RT', 'Title 3'), ('RA', 'Author 3'), ('RL', 'Location 3'), ('RC', 'Comment 3')])]}) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_data_only(self): fp = get_data_path('stockholm_data_only') msa = TabularMSA([RNA('ACUCCGACAUGCUCC'), RNA('UAGUGCCGAACGCUG'), RNA('GUGUGGGCGUGAUUC')], index=['seq1', 'seq2', 'seq3']) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_nonstring_values(self): fp = get_data_path('stockholm_nonstring_labels') msa = TabularMSA([DNA('ACTG', metadata=OrderedDict([(8, 123)]), positional_metadata=OrderedDict([(1.0, [1, 2, 3, 4])]) )], metadata=OrderedDict([(1.3, 2857)]), positional_metadata=OrderedDict([(25, [4, 3, 2, 1])]), index=[11214]) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_msa_to_stockholm_empty(self): fp = get_data_path('stockholm_no_data') msa = TabularMSA([]) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_extensive(self): fp = get_data_path('stockholm_extensive') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_minimal(self): fp = get_data_path('stockholm_minimal') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_single_tree(self): fp = get_data_path('stockholm_single_tree_without_id') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_multiple_trees(self): fp = get_data_path('stockholm_multiple_trees') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_single_reference(self): fp = get_data_path('stockholm_single_reference') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_multiple_references(self): fp = get_data_path('stockholm_multiple_references') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_missing_references(self): fp = get_data_path('stockholm_missing_reference_items') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_data_only(self): fp = get_data_path('stockholm_data_only') msa = _stockholm_to_tabular_msa(fp, constructor=RNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_nonstring_index_values(self): fp = get_data_path('stockholm_nonstring_labels') msa = _stockholm_to_tabular_msa(fp, constructor=DNA) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_round_trip_empty(self): fp = get_data_path('stockholm_no_data') msa = _stockholm_to_tabular_msa(fp, constructor=Protein) fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) obs = fh.getvalue() fh.close() with io.open(fp) as fh: exp = fh.read() self.assertEqual(obs, exp) def test_unoriginal_index_error(self): msa = TabularMSA([DNA('ATCGCCAGCT'), DNA('TTGTGCTGGC')], index=['seq1', 'seq1']) with self.assertRaisesRegex(StockholmFormatError, r'index labels must be unique.'): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_unoriginal_gr_feature_names_error(self): pos_metadata_dataframe = pd.DataFrame( [ list('GAGCAAGCCACTAGA'), list('TCCTTGAACTACCCG'), list('TCAGCTCTGCAGCGT'), list('GTCAGGCGCTCGGTG') ], index=['AC', 'SS', 'AS', 'AC'] ).T msa = TabularMSA([DNA('CGTCAATCTCGAACT', positional_metadata=pos_metadata_dataframe)], index=['seq1']) with self.assertRaisesRegex(StockholmFormatError, r'Sequence-specific positional metadata.*' 'must be unique. Found 1 duplicate'): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_unoriginal_gc_feature_names_error(self): pos_metadata_dataframe = pd.DataFrame( [ list('GAGCAAGCCACTAGA'), list('TCCTTGAACTACCCG'), list('TCAGCTCTGCAGCGT'), list('GTCAGGCGCTCGGTG') ], index=['AC', 'SS', 'SS', 'AC'] ).T msa = TabularMSA([DNA('CCCCTGCTTTCGTAG')], positional_metadata=pos_metadata_dataframe) with self.assertRaisesRegex(StockholmFormatError, r'Multiple sequence alignment positional ' 'metadata.*must be unique. Found 2 ' 'duplicate'): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_gr_wrong_dataframe_item_length_error(self): seq1 = list('GAGCAAGCCACTAGA') seq1.append('GG') pos_metadata_dataframe = pd.DataFrame({'AC': seq1, 'SS': list('TCCTTGAACTACCCGA'), 'AS': list('TCAGCTCTGCAGCGTT')}) msa = TabularMSA([DNA('TCCTTGAACTACCCGA', positional_metadata=pos_metadata_dataframe)]) with self.assertRaisesRegex(StockholmFormatError, r'Sequence-specific positional metadata.*' r'must contain a single character.*Found ' r'value\(s\) in column AC'): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_gc_wrong_dataframe_item_length_error(self): seq1 = list('GAGCAAGCCACTAGA') seq1.append('GG') pos_metadata_dataframe = pd.DataFrame({'AC': seq1, 'SS': list('TCCTTGAACTACCCGA'), 'AS': list('TCAGCTCTGCAGCGTT')}) msa = TabularMSA([DNA('TCCTTGAACTACCCGA')], positional_metadata=pos_metadata_dataframe) message = (r'Multiple sequence alignment positional metadata.*must ' r'contain a single character.*Found value\(s\) in column ' 'AC') with self.assertRaisesRegex(StockholmFormatError, message): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_rn_not_list_of_refs_error(self): msa = TabularMSA([], metadata={'RN': '1'}) with self.assertRaisesRegex(StockholmFormatError, r"Expected 'RN'.*list of reference" ".*got '1'"): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_rn_data_not_in_dict_error(self): msa = TabularMSA([], metadata={'RN': [OrderedDict([('RL', 'Flagstaff')]), 'Incorrect Item']}) with self.assertRaisesRegex(StockholmFormatError, r"Expected reference information.*stored" " as a dictionary, found.*2 stored as " "'str'"): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) def test_invalid_reference_tag_error(self): msa = TabularMSA([], metadata={'RN': [OrderedDict([('RL', 'Flagstaff'), ('foo', 'bar')])]}) with self.assertRaisesRegex(StockholmFormatError, r"Invalid reference.*foo' found " "in.*1.*Valid reference tags are:"): fh = io.StringIO() _tabular_msa_to_stockholm(msa, fh) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/format/tests/test_taxdump.py000066400000000000000000000172471446255456000230530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from io import StringIO import pandas as pd import numpy as np from skbio.util import get_data_path, assert_data_frame_almost_equal from skbio.io.format.taxdump import _taxdump_to_data_frame class TestTaxdumpReader(unittest.TestCase): def test_nodes_default(self): # subset of a real NCBI taxonomy nodes.dmp file fp = get_data_path('taxdump_nodes.dmp') obs = _taxdump_to_data_frame(fp, scheme='nodes') exp = pd.DataFrame([ [1, 1, 'no rank', np.nan, 8, False, 1, False, 0, False, False, False, np.nan], [2, 131567, 'superkingdom', np.nan, 0, False, 11, False, 0, False, False, False, np.nan], [543, 91347, 'family', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [548, 570, 'species', 'KA', 0, True, 11, True, 0, True, True, False, np.nan], [561, 543, 'genus', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [562, 561, 'species', 'EC', 0, True, 11, True, 0, True, True, False, np.nan], [570, 543, 'genus', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [620, 543, 'genus', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [622, 620, 'species', 'SD', 0, True, 11, True, 0, True, True, False, np.nan], [766, 28211, 'order', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [1224, 2, 'phylum', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [1236, 1224, 'class', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [28211, 1224, 'class', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [91347, 1236, 'order', np.nan, 0, True, 11, True, 0, True, False, False, np.nan], [118884, 1236, 'no rank', np.nan, 0, True, 11, True, 0, True, True, False, np.nan], [126792, 36549, 'species', 'PP', 0, True, 11, True, 0, True, True, False, np.nan], [131567, 1, 'no rank', np.nan, 8, True, 1, True, 0, True, True, False, np.nan], [585056, 562, 'no rank', np.nan, 0, True, 11, True, 0, True, True, False, np.nan], [1038927, 562, 'no rank', np.nan, 0, True, 11, True, 0, True, True, False, np.nan], [2580236, 488338, 'species', 'SE', 7, True, 11, True, 0, True, False, False, np.nan]], columns=[ 'tax_id', 'parent_tax_id', 'rank', 'embl_code', 'division_id', 'inherited_div_flag', 'genetic_code_id', 'inherited_GC_flag', 'mitochondrial_genetic_code_id', 'inherited_MGC_flag', 'GenBank_hidden_flag', 'hidden_subtree_root_flag', 'comments']).set_index('tax_id') exp['comments'] = exp['comments'].astype('O') assert_data_frame_almost_equal(obs, exp) def test_names_default(self): # subset of a real NCBI taxonomy names.dmp file fp = get_data_path('taxdump_names.dmp') obs = _taxdump_to_data_frame(fp, scheme='names') exp = pd.DataFrame([ [1, 'root', np.nan, 'scientific name'], [2, 'Bacteria', 'Bacteria ', 'scientific name'], [2, 'eubacteria', np.nan, 'genbank common name'], [543, 'Enterobacteriaceae', np.nan, 'scientific name'], [548, 'Klebsiella aerogenes', np.nan, 'scientific name'], [561, 'Escherichia', np.nan, 'scientific name'], [562, '"Bacillus coli" Migula 1895', np.nan, 'authority'], [562, 'Escherichia coli', np.nan, 'scientific name'], [562, 'Escherichia/Shigella coli', np.nan, 'equivalent name'], [570, 'Donovania', np.nan, 'synonym'], [570, 'Klebsiella', np.nan, 'scientific name'], [620, 'Shigella', np.nan, 'scientific name'], [622, 'Shigella dysenteriae', np.nan, 'scientific name'], [766, 'Rickettsiales', np.nan, 'scientific name'], [1224, 'Proteobacteria', np.nan, 'scientific name'], [1236, 'Gammaproteobacteria', np.nan, 'scientific name'], [28211, 'Alphaproteobacteria', np.nan, 'scientific name'], [91347, 'Enterobacterales', np.nan, 'scientific name'], [118884, 'unclassified Gammaproteobacteria', np.nan, 'scientific name'], [126792, 'Plasmid pPY113', np.nan, 'scientific name'], [131567, 'cellular organisms', np.nan, 'scientific name'], [585056, 'Escherichia coli UMN026', np.nan, 'scientific name'], [1038927, 'Escherichia coli O104:H4', np.nan, 'scientific name'], [2580236, 'synthetic Escherichia coli Syn61', np.nan, 'scientific name']], columns=['tax_id', 'name_txt', 'unique_name', 'name_class']).set_index('tax_id') assert_data_frame_almost_equal(obs, exp) def test_nodes_slim(self): fp = get_data_path('taxdump_nodes.dmp') obs = _taxdump_to_data_frame(fp, scheme='nodes_slim') exp = pd.DataFrame([ [1, 1, 'no rank'], [2, 131567, 'superkingdom'], [543, 91347, 'family'], [548, 570, 'species'], [561, 543, 'genus'], [562, 561, 'species'], [570, 543, 'genus'], [620, 543, 'genus'], [622, 620, 'species'], [766, 28211, 'order'], [1224, 2, 'phylum'], [1236, 1224, 'class'], [28211, 1224, 'class'], [91347, 1236, 'order'], [118884, 1236, 'no rank'], [126792, 36549, 'species'], [131567, 1, 'no rank'], [585056, 562, 'no rank'], [1038927, 562, 'no rank'], [2580236, 488338, 'species']], columns=['tax_id', 'parent_tax_id', 'rank']).set_index('tax_id') assert_data_frame_almost_equal(obs, exp) def test_custom_scheme(self): fs = StringIO('\n'.join(map('\t|\t'.join, [ ('a', 'a'), ('b', 'a'), ('c', 'a') ]))) obs = _taxdump_to_data_frame(fs, scheme={'self': str, 'parent': str}) exp = pd.DataFrame([ ['a', 'a'], ['b', 'a'], ['c', 'a']], columns=['self', 'parent']).set_index('self') assert_data_frame_almost_equal(obs, exp) def test_invalid_scheme(self): fp = get_data_path('taxdump_names.dmp') with self.assertRaises(ValueError) as ctx: _taxdump_to_data_frame(fp, scheme='hello') self.assertEqual(str(ctx.exception), 'Invalid taxdump column scheme: "hello".') def test_invalid_id(self): fs = StringIO('\n'.join(map('\t|\t'.join, [ ('1', '2', 'family'), ('3', '4', 'genus'), ('x', '6', 'species'), # 'x' is not a number ]))) with self.assertRaises(ValueError) as ctx: _taxdump_to_data_frame(fs, scheme='nodes_slim') self.assertEqual(str(ctx.exception), 'Invalid taxdump file format.') if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/registry.py000066400000000000000000001242411446255456000175410ustar00rootroot00000000000000r""" I/O Registry (:mod:`skbio.io.registry`) ======================================= .. currentmodule:: skbio.io.registry Classes ------- .. autosummary:: :toctree: IORegistry Format Functions --------- .. autosummary:: :toctree: create_format Exceptions ---------- .. autosummary:: :toctree: DuplicateRegistrationError InvalidRegistrationError Creating a new format for scikit-bio ------------------------------------ scikit-bio makes it simple to add new file formats to its I/O registry. scikit-bio maintains a singleton of the :class:`IORegistry` class called `io_registry`. This is where all scikit-bio file formats are registered. One could also instantiate their own :class:`IORegistry`, but that is not the focus of this tutorial. The first step to creating a new format is to add a submodule in `skbio/io/format/` named after the file format you are implementing. For example, if the format you are implementing is called `myformat` then you would create a file called `skbio/io/format/myformat.py`. The next step is to import the :func:`create_format` factory from :mod:`skbio.io`. This will allow you to create a new :class:`Format` object that `io_registry` will know about. Ideally you should name the result of :func:`create_format` as your file name. For example: .. code-block:: python from skbio.io import create_format myformat = create_format('myformat') The `myformat` object is what we will use to register our new functionality. At this point you should evaulate whether your format is binary or text. If your format is binary, your :func:`create_format` call should look like this: .. code-block:: python myformat = create_format('myformat', encoding='binary') Alternatively if your format is text and has a specific encoding or newline handling you can also specify that: .. code-block:: python myformat = create_format('myformat', encoding='ascii', newline='\n') This will ensure that our registry will open files with a default encoding of `'ascii'` for `'myformat'` and expect all newlines to be `'\n'` characters. Having worked out these details, we are ready to register the actual functionality of our format (e.g., sniffer, readers, and writers). To create a sniffer simply decorate the following onto your sniffer function: .. code-block:: python @myformat.sniffer() def _myformat_sniffer(fh): # do something with `fh` to determine the membership of the file For futher details on sniffer functions see :func:`Format.sniffer`. Creating a reader is very similar, but has one difference: .. code-block:: python @myformat.reader(SomeSkbioClass) def _myformat_to_some_skbio_class(fh, kwarg1='default', extra=FileSentinel): # parse `fh` and return a SomeSkbioClass instance here # `extra` will also be an open filehandle if provided else None Here we bound a function to a specific class. We also demonstrated using our FileSentinel object to indicate to the registry that this reader can take auxilary files that should be handled in the same way as the primary file. For futher details on reader functions see :func:`Format.reader`. Creating a writer is about the same: .. code-block:: python @myformat.writer(SomeSkbioClass) def _some_skbio_class_to_myformat(obj, fh, kwarg1='whatever', extra=FileSentinel): # write the contents of `obj` into `fh` and whatever else into `extra` # do not return anything, it will be ignored This is exactly the same as the `reader` above just in reverse, we also receive the object we are writing as the first parameter instead of the file (which is the second one). For further details on writer functions see :func:`Format.writer`. .. note:: When raising errors in readers and writers, the error should be a subclass of ``FileFormatError`` specific to your new format. Once you are satisfied with the functionality, you will need to ensure that `skbio/io/__init__.py` contains an import of your new submodule so the decorators are executed. Add the function ``import_module('skbio.io.format.myformat')`` with your module name to the existing list. .. note:: Because scikit-bio handles all of the I/O boilerplate, you only need to unit-test the actual business logic of your `readers`, `writers`, and `sniffers`. Reserved Keyword Arguments -------------------------- The following keyword args may not be used when defining new `readers` or `writers` as they already have special meaning to the registry system: - `format` - `into` - `verify` - `mode` - `encoding` - `errors` - `newline` - `compression` - `compresslevel` The following are not yet used but should be avoided as well: - `auth` - `user` - `password` - `buffering` - `buffer_size` - `closefd` - `exclusive` - `append` """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from warnings import warn import types import traceback import itertools import inspect from functools import wraps from ._exception import DuplicateRegistrationError, InvalidRegistrationError from . import (UnrecognizedFormatError, ArgumentOverrideWarning, FormatIdentificationWarning) from .util import _resolve_file, open_file, open_files, _d as _open_kwargs from skbio.util._misc import make_sentinel, find_sentinels from skbio.util._decorator import stable, classonlymethod FileSentinel = make_sentinel("FileSentinel") class IORegistry: """Create a registry of formats and implementations which map to classes. """ @stable(as_of="0.4.0") def __init__(self): # This seperation of binary and text formats is useful because there # are many situations where we may have recieved a text-file. When this # happens, the binary data fundamentally does not exist. We could # assume encoding should be interpreted in reverse, however this misses # the bigger point: why would the user ever want text to be treated as # binary? They already went through the effort to hand us text. # Therefore, during format resolution, we should skip the binary # formats if they are irrelevant. (They are incompatible with such a # filehandle anyways.) self._binary_formats = {} self._text_formats = {} self._lookups = (self._binary_formats, self._text_formats) @stable(as_of="0.4.0") def create_format(self, *args, **kwargs): """A simple factory for creating new file formats. This will automatically register the format with this regsistry. All arguments are passed through to the Format constructor. Returns ------- Format A new format that is registered with the registry. """ format = Format(*args, **kwargs) self.add_format(format) return format @stable(as_of="0.4.0") def add_format(self, format_object): """Add a format to the registry. Parameters ---------- format_object : Format The format to add to the registry. """ # See comment in the constructor for an explanation for why this split # occurs. name = format_object.name if name in self._binary_formats or name in self._text_formats: raise DuplicateRegistrationError("A format already exists with" " that name: %s" % name) if format_object.is_binary_format: self._binary_formats[name] = format_object else: self._text_formats[name] = format_object @stable(as_of="0.4.0") def get_sniffer(self, format_name): """Locate the sniffer for a format. Parameters ---------- format_name : str The name of the format to lookup. Returns ------- function or None The sniffer associated with `format_name` """ for lookup in self._lookups: if format_name in lookup: return lookup[format_name].sniffer_function return None @stable(as_of="0.4.0") def get_reader(self, format_name, cls): """Locate the reader for a format and class. Parameters ---------- format_name : str The name of the format to lookup. cls : type or None The class which the reader will return an instance of. If `cls` is None, the reader will return a generator. Default is None. Returns ------- function or None The reader associated with `format_name` and `cls` """ return self._get_rw(format_name, cls, 'readers') @stable(as_of="0.4.0") def get_writer(self, format_name, cls): """Locate the writer for a format and class. Parameters ---------- format_name : str The name of the format to lookup. cls : type or None The class which the writer will expect an instance of. If `cls` is None, the writer will expect a generator. Default is None. Returns ------- function or None The writer associated with `format_name` and `cls` """ return self._get_rw(format_name, cls, 'writers') def _get_rw(self, format_name, cls, lookup_name): for lookup in self._lookups: if format_name in lookup: format_lookup = getattr(lookup[format_name], lookup_name) if cls in format_lookup: return format_lookup[cls] return None @stable(as_of="0.4.0") def list_read_formats(self, cls): """Return a list of available read formats for a given `cls` type. Parameters ---------- cls : type The class which will be used to determine what read formats exist for an instance of `cls`. Returns ------- list A list of available read formats for an instance of `cls`. List may be empty. """ return list(self._iter_rw_formats(cls, 'readers')) @stable(as_of="0.4.0") def list_write_formats(self, cls): """Return a list of available write formats for a given `cls` type. Parameters ---------- cls : type The class which will be used to determine what write formats exist for an instance of `cls`. Returns ------- list A list of available write formats for an instance of `cls`. List may be empty. """ return list(self._iter_rw_formats(cls, 'writers')) def _iter_rw_formats(self, cls, lookup_name): for lookup in self._lookups: for format in lookup.values(): if cls in getattr(format, lookup_name): yield format.name @stable(as_of="0.4.0") def sniff(self, file, **kwargs): """Detect the format of a given `file` and suggest kwargs for reading. Parameters ---------- file : openable (filepath, URL, filehandle, etc.) The file to sniff. Something that is understood by `skbio.io.open`. kwargs : dict, optional Keyword arguments will be passed to `skbio.io.open`. `newline` cannot be provided. Returns ------- (str, dict) The name of the format of the file and any suggested kwargs for use with the corresponding reader. Raises ------ UnrecognizedFormatError This occurs when the format is not 'claimed' by any registered sniffer or when the format is ambiguous and has been 'claimed' by more than one sniffer. TypeError If `newline` is provided in `kwargs`. """ if 'newline' in kwargs: raise TypeError( "Cannot provide `newline` keyword argument when sniffing.") # By resolving the input here, we have the oppurtunity to reuse the # file (which is potentially ephemeral). Each sniffer will also resolve # the file, but that call will short-circuit and won't claim # responsibility for closing the file. This means that the file # should only close after leaving this context. This is also the reason # that we have to use SaneTextIOWrapper because each sniffer will # wrap the file to produce an appropriate default encoding for their # format (if unspecified). This results in the SaneTextIOWrapper being # garbage collected (using io.TextIOBase results in close being called # on our buffer by the deconstructor which we wanted to share with the # next sniffer) with _resolve_file(file, mode='r', **kwargs) as (fh, _, is_binary_file): # tell may fail noisily if the user provided a TextIOBase or # BufferedReader which has already been iterated over (via next()). matches = [] backup = fh.tell() if is_binary_file and kwargs.get('encoding', 'binary') == 'binary': matches = self._find_matches(fh, self._binary_formats, **kwargs) if kwargs.get('encoding', None) != 'binary': # We can always turn a binary file into a text file, but the # reverse doesn't make sense. matches += self._find_matches(fh, self._text_formats, **kwargs) fh.seek(backup) elif not is_binary_file: raise ValueError("Cannot decode text source (%r) as binary." % file) # else we are a binary_file and our encoding did not exclude binary # so we have already handled that condition if len(matches) > 1: raise UnrecognizedFormatError("File format for %r is ambiguous," " may be one of: %r" % (file, [m for m, s in matches])) elif len(matches) == 0: raise UnrecognizedFormatError("Could not detect the format of %r" % file) return matches[0] def _find_matches(self, file, lookup, **kwargs): matches = [] for format in lookup.values(): if format.sniffer_function is not None: is_format, skwargs = format.sniffer_function(file, **kwargs) file.seek(0) if is_format: matches.append((format.name, skwargs)) return matches @stable(as_of="0.4.0") def read(self, file, format=None, into=None, verify=True, **kwargs): """Read `file` as `format` into an object. Parameters ---------- file : openable (filepath, URL, filehandle, etc.) The file to read. Something that is understood by `skbio.io.open`. format : str, optional The format of the file if known. If None, the format will be inferred from the file. into : type or None, optional The object which will be returned. If None, a generator will be returned. verify : bool, optional When True, will double check the `format` if provided. kwargs : dict, optional Keyword arguments will be passed to their respective handlers (`skbio.io.open` and the reader for `format`). `newline` cannot be provided. Returns ------- object or generator An instance of `into` if `into` is not None else generator Raises ------ ValueError Raised when `format` and `into` are both None. TypeError If `newline` is provided in `kwargs`. UnrecognizedFormatError Raised when a reader could not be found for a given `format` or the format could not be guessed. FormatIdentificationWarning Raised when `verify` is True and the sniffer of a `format` did not agree that `file` is a member of `format` ArgumentOverrideWarning Raised when `verify` is True and a user-supplied argument is overriding the suggestion provided by the sniffer of `format`. """ if 'newline' in kwargs: raise TypeError( "Cannot provide `newline` keyword argument when reading.") # Context managers do not compose well with generators. We have to # duplicate the logic so that the file will stay open while yielding. # Otherwise the context exits as soon as the generator is returned # (making any iteration fail as the file is closed from its # perspective). if into is None: if format is None: raise ValueError("`into` and `format` cannot both be None") gen = self._read_gen(file, format, into, verify, kwargs) # This is done so that any errors occur immediately instead of # on the first call from __iter__ # eta-reduction is possible, but we want to the type to be # GeneratorType try: return (x for x in itertools.chain([next(gen)], gen)) except StopIteration: # If the error was a StopIteration, then we want to return an # empty generator as `next(gen)` failed. # See #1313 for more info. return (x for x in []) else: return self._read_ret(file, format, into, verify, kwargs) def _read_ret(self, file, fmt, into, verify, kwargs): io_kwargs = self._find_io_kwargs(kwargs) with _resolve_file(file, **io_kwargs) as (file, _, _): reader, kwargs = self._init_reader(file, fmt, into, verify, kwargs, io_kwargs) return reader(file, **kwargs) def _read_gen(self, file, fmt, into, verify, kwargs): io_kwargs = self._find_io_kwargs(kwargs) # We needed to get the io_kwargs from kwargs for things like # _resolve_file and for verifying a format. # kwargs should still retain the contents of io_kwargs because the # actual reader will also need them. with _resolve_file(file, **io_kwargs) as (file, _, _): reader, kwargs = self._init_reader(file, fmt, into, verify, kwargs, io_kwargs) yield from reader(file, **kwargs) def _find_io_kwargs(self, kwargs): return {k: kwargs[k] for k in _open_kwargs if k in kwargs} def _init_reader(self, file, fmt, into, verify, kwargs, io_kwargs): skwargs = {} if fmt is None: fmt, skwargs = self.sniff(file, **io_kwargs) elif verify: sniffer = self.get_sniffer(fmt) if sniffer is not None: backup = file.tell() is_format, skwargs = sniffer(file, **io_kwargs) file.seek(backup) if not is_format: warn("%r does not look like a %s file" % (file, fmt), FormatIdentificationWarning) for key in skwargs: if key not in kwargs: kwargs[key] = skwargs[key] elif kwargs[key] != skwargs[key]: warn('Best guess was: %s=%r, continuing with user' ' supplied: %r' % (key, skwargs[key], kwargs[key]), ArgumentOverrideWarning) reader = self.get_reader(fmt, into) if reader is None: possible_intos = [r.__name__ for r in self._get_possible_readers(fmt)] message = '' if possible_intos: message = ("Possible values for `into` include: %s" % ', '.join(possible_intos)) into_message = '`into` also not provided.' if not into else '' raise UnrecognizedFormatError( "Cannot read %r from %r, no %s reader found. %s %s" % (fmt, file, into.__name__ if into else 'generator', into_message, message)) return reader, kwargs def _get_possible_readers(self, fmt): for lookup in self._lookups: if fmt in lookup: return list(lookup[fmt].readers) return [] @stable(as_of="0.4.0") def write(self, obj, format, into, **kwargs): """Write `obj` as `format` into a file. Parameters ---------- obj : object The object to write as `format` format : str The format to write `obj` as into : openable (filepath, URL, filehandle, etc.) What to write `obj` to. Something that is understood by `skbio.io.open`. kwargs : dict, optional Keyword arguments will be passed to their respective handlers (`skbio.io.open` and the writer for `format`) Returns ------- openable (filepath, URL, filehandle, etc.) Will pass back the user argument for `into` as a convenience. Raises ------ UnrecognizedFormatError Raised when a writer for writing `obj` as `format` could not be found. """ # The simplest functionality here. cls = None if not isinstance(obj, types.GeneratorType): cls = obj.__class__ writer = self.get_writer(format, cls) if writer is None: raise UnrecognizedFormatError( "Cannot write %r into %r, no %s writer found." % (format, into, obj.__class__.__name__)) writer(obj, into, **kwargs) return into @stable(as_of="0.4.0") def monkey_patch(self): """Monkey-patch `read` and `write` methods onto registered classes. Will modify classes which have been registered to a reader or writer to have `read` and `write` methods which will contain documentation specifying useable formats for that class. The actual functionality will be a pass-through to `skbio.io.read` and `skbio.io.write` respectively. """ reads = set() writes = set() for lookup in self._lookups: for format in lookup.values(): reads |= format.monkey_patched_readers writes |= format.monkey_patched_writers for cls in reads: self._apply_read(cls) for cls in writes: self._apply_write(cls) def _apply_read(registry, cls): """Add read method if any formats have a reader for `cls`.""" read_formats = registry.list_read_formats(cls) @classonlymethod def read(cls, file, format=None, **kwargs): return registry.read(file, into=cls, format=format, **kwargs) imports = registry._import_paths(read_formats) doc_list = registry._formats_for_docs(read_formats, imports) read.__func__.__doc__ = _read_docstring % { 'name': cls.__name__, 'list': doc_list, 'see': '\n'.join(imports) } cls.read = read def _apply_write(registry, cls): """Add write method if any formats have a writer for `cls`.""" write_formats = registry.list_write_formats(cls) if not hasattr(cls, 'default_write_format'): raise NotImplementedError( "Classes with registered writers must provide a " "`default_write_format`. Please add `default_write_format`" " to '%s'." % cls.__name__) def write(self, file, format=cls.default_write_format, **kwargs): return registry.write(self, into=file, format=format, **kwargs) imports = registry._import_paths(write_formats) doc_list = registry._formats_for_docs(write_formats, imports) write.__doc__ = _write_docstring % { 'name': cls.__name__, 'list': doc_list, 'see': '\n'.join(imports), 'default': cls.default_write_format } cls.write = write def _import_paths(self, formats): lines = [] for fmt in formats: lines.append("skbio.io.format." + fmt) return lines def _formats_for_docs(self, formats, imports): lines = [] for fmt, imp in zip(formats, imports): lines.append("- ``'%s'`` (:mod:`%s`)" % (fmt, imp)) return '\n'.join(lines) _read_docstring = """Create a new ``%(name)s`` instance from a file. This is a convenience method for :func:`skbio.io.registry.read`. For more information about the I/O system in scikit-bio, please see :mod:`skbio.io`. Supported file formats include: %(list)s Parameters ---------- file : openable (filepath, URL, filehandle, etc.) The location to read the given `format`. Something that is understood by :func:`skbio.io.util.open`. Filehandles are not automatically closed, it is the responsibility of the caller. format : str, optional The format must be a format name with a reader for ``%(name)s``. If a `format` is not provided or is None, it will attempt to guess the format. kwargs : dict, optional Keyword arguments passed to :func:`skbio.io.registry.read` and the file format reader for ``%(name)s``. Returns ------- %(name)s A new instance. See Also -------- write skbio.io.registry.read skbio.io.util.open %(see)s """ _write_docstring = """Write an instance of ``%(name)s`` to a file. This is a convenience method for :func:`skbio.io.registry.write`. For more information about the I/O system in scikit-bio, please see :mod:`skbio.io`. Supported file formats include: %(list)s Parameters ---------- file : openable (filepath, URL, filehandle, etc.) The location to write the given `format` into. Something that is understood by :func:`skbio.io.util.open`. Filehandles are not automatically closed, it is the responsibility of the caller. format : str The format must be a registered format name with a writer for ``%(name)s``. Default is `'%(default)s'`. kwargs : dict, optional Keyword arguments passed to :func:`skbio.io.registry.write` and the file format writer. See Also -------- read skbio.io.registry.write skbio.io.util.open %(see)s """ class Format: """Defines a format on which readers/writers/sniffer can be registered. Parameters ---------- name : str The name of this format. encoding : str, optional What the default encoding of this format is. If set to 'binary' then all registered handlers will receive an :class:`io.BufferedReader` or :class:`io.BufferedWriter` instead of an :class:`io.TextIOBase`. The user will also be unable to override the encoding in that case. newline : str, optional What the default newline handling of this format is. Default is to use universal newline handling. """ @property @stable(as_of="0.4.0") def name(self): """The name of this format.""" return self._name @property @stable(as_of="0.4.0") def is_binary_format(self): """Return True if this is a binary format.""" return self._encoding == 'binary' @property @stable(as_of="0.4.0") def sniffer_function(self): """The sniffer function associated with this format.""" return self._sniffer_function @property @stable(as_of="0.4.0") def readers(self): """Dictionary that maps classes to their readers for this format.""" return self._readers @property @stable(as_of="0.4.0") def writers(self): """Dictionary that maps classes to their writers for this format.""" return self._writers @property @stable(as_of="0.4.0") def monkey_patched_readers(self): """Set of classes bound to readers to monkey patch.""" return self._monkey_patch['read'] @property @stable(as_of="0.4.0") def monkey_patched_writers(self): """Set of classes bound to writers to monkey patch.""" return self._monkey_patch['write'] def __init__(self, name, encoding=None, newline=None): self._encoding = encoding self._newline = newline self._name = name self._sniffer_function = None self._readers = {} self._writers = {} self._monkey_patch = {'read': set(), 'write': set()} @stable(as_of="0.4.0") def sniffer(self, override=False): """Decorate a function to act as the sniffer for this format. The function should take one argument which will be an implementation of either :class:`io.TextIOBase` or :class:`io.BufferedReader` depending on if the format is text or binary, respectively. The sniffer will always receive a filehandle which is pointing to the beginning of the file. It must return a tuple of bool and a dict of suggested keyword arguments (if any) to pass to the reader. .. note:: Keyword arguments are not permitted in `sniffers`. `Sniffers` may not raise exceptions; if an exception is thrown by a `sniffer`, the user will be asked to report it on our `issue tracker `_. Parameters ---------- override : bool, optional If True, the existing sniffer will be overriden. Raises ------ DuplicateRegistrationError When `override` is False and a sniffer is already registered for this format. Examples -------- >>> from skbio.io.registry import Format >>> # If developing a new format for skbio, use the create_format() >>> # factory instead of this constructor. >>> myformat = Format('myformat') >>> @myformat.sniffer() ... def myformat_sniffer(fh): ... check = fh.read(8) == "myformat" ... if check: ... version = int(fh.read(1)) ... return True, {'version': version} ... return False, {} ... >>> myformat_sniffer(["myformat2\\n", "some content\\n"]) (True, {'version': 2}) >>> myformat_sniffer(["something else\\n"]) (False, {}) """ if not type(override) is bool: raise InvalidRegistrationError("`override` must be a bool not %r" % override) if not override and self._sniffer_function is not None: raise DuplicateRegistrationError("A sniffer is already registered" " to format: %s" % self._name) def decorator(sniffer): @wraps(sniffer) def wrapped_sniffer(file, encoding=self._encoding, errors='ignore', newline=self._newline, **kwargs): self._validate_encoding(encoding) if encoding == 'binary': # Errors is irrelevant so set to default to prevent raising # a usage exception in open. errors = _open_kwargs['errors'] with open_file(file, mode='r', encoding=encoding, newline=newline, errors=errors, **kwargs) as fh: try: # Some formats may have headers which indicate their # format sniffers should be able to rely on the # filehandle to point at the beginning of the file. fh.seek(0) return sniffer(fh) except UnicodeDecodeError: pass except Exception: warn("'%s' has encountered a problem.\nPlease" " send the following to our issue tracker at\n" "https://github.com/biocore/scikit-bio/issues\n\n" "%s" % (sniffer.__name__, traceback.format_exc()), FormatIdentificationWarning) return False, {} self._sniffer_function = wrapped_sniffer return wrapped_sniffer return decorator @stable(as_of="0.4.0") def reader(self, cls, monkey_patch=True, override=False): """Decorate a function to act as the reader for a class in this format. The function should take an argument which will be an implementation of either :class:`io.TextIOBase` or :class:`io.BufferedReader` depending on if the format is text or binary, respectively. Any kwargs given by the user which are not handled by :func:`skbio.io.util.open` will be passed into the function. Any kwarg with a default of `FileSentinel` will transform user input for that parameter into a filehandle or `None` if not provided. Parameters ---------- cls : type or None The class which the function will be registered to handle. If None, it is assumed that the function will produce a generator. monkey_patch : bool, optional Whether to allow an IORegistry to attach a `read` method to `cls` with this format listed as an option. override : bool, optional If True, any existing readers for `cls` in this format will be overriden. Raises ------ DuplicateRegistrationError When `override` is False and a reader is already registered to `cls` for this format. Examples -------- >>> from skbio.io.registry import Format, IORegistry >>> registry = IORegistry() >>> myformat = Format('myformat') >>> registry.add_format(myformat) >>> # If developing a new format for skbio, use the create_format() >>> # factory instead of the above. >>> class MyObject: ... def __init__(self, content): ... self.content = content ... >>> @myformat.reader(MyObject) ... def myformat_reader(fh): ... return MyObject(fh.readlines()[1:]) ... >>> registry.monkey_patch() # If developing skbio, this isn't needed >>> MyObject.read(["myformat2\\n", "some content here!\\n"], ... format='myformat').content ['some content here!\\n'] """ self._check_registration(cls) def decorator(reader_function): file_params = find_sentinels(reader_function, FileSentinel) # This split has to occur for the same reason as in IORegistry.read if cls is not None: @wraps(reader_function) def wrapped_reader(file, encoding=self._encoding, newline=self._newline, **kwargs): file_keys, files, io_kwargs = self._setup_locals( file_params, file, encoding, newline, kwargs) with open_files(files, mode='r', **io_kwargs) as fhs: # The primary file is at the end of fh because append # is cheaper than insert kwargs.update(zip(file_keys, fhs[:-1])) return reader_function(fhs[-1], **kwargs) else: @wraps(reader_function) def wrapped_reader(file, encoding=self._encoding, newline=self._newline, **kwargs): file_keys, files, io_kwargs = self._setup_locals( file_params, file, encoding, newline, kwargs) with open_files(files, mode='r', **io_kwargs) as fhs: kwargs.update(zip(file_keys, fhs[:-1])) yield from reader_function(fhs[-1], **kwargs) self._add_reader(cls, wrapped_reader, monkey_patch, override) return wrapped_reader return decorator @stable(as_of="0.4.0") def writer(self, cls, monkey_patch=True, override=False): """Decorate a function to act as the writer for a class in this format. The function should take an instance of `cls` as its first argument and the second argument is a filehandle which will be an implementation of either :class:`io.TextIOBase` or :class:`io.BufferedWriter` depending on if the format is text or binary, respectively. Any kwargs given by the user which are not handled by :func:`skbio.io.util.open` will be passed into the function. Any kwarg with a default of `FileSentinel` will transform user input for that parameter into a filehandle or `None` if not provided. Parameters ---------- cls : type or None The class which the function will be registered to handle. If None, it is assumed that the function will consume a generator. monkey_patch : bool, optional Whether to allow an IORegistry to attach a `write` method to `cls` with this format listed as an option. override : bool, optional If True, any existing writers for `cls` in this format will be overriden. Raises ------ DuplicateRegistrationError When `override` is False and a writer is already registered to `cls` for this format. Examples -------- >>> from skbio.io.registry import Format, IORegistry >>> registry = IORegistry() >>> myformat = Format('myformat') >>> registry.add_format(myformat) >>> # If developing a new format for skbio, use the create_format() >>> # factory instead of the above. >>> class MyObject: ... default_write_format = 'myformat' ... def __init__(self, content): ... self.content = content ... >>> @myformat.writer(MyObject) ... def myformat_reader(obj, fh): ... fh.write("myformat2\\n") ... for c in obj.content: ... fh.write(c) ... >>> registry.monkey_patch() # If developing skbio, this isn't needed >>> obj = MyObject(["some content here!\\n"]) >>> obj.write([], format='myformat') ['myformat2\\n', 'some content here!\\n'] """ self._check_registration(cls) def decorator(writer_function): file_params = find_sentinels(writer_function, FileSentinel) @wraps(writer_function) def wrapped_writer(obj, file, encoding=self._encoding, newline=self._newline, **kwargs): file_keys, files, io_kwargs = self._setup_locals( file_params, file, encoding, newline, kwargs) with open_files(files, mode='w', **io_kwargs) as fhs: kwargs.update(zip(file_keys, fhs[:-1])) writer_function(obj, fhs[-1], **kwargs) self._add_writer(cls, wrapped_writer, monkey_patch, override) return wrapped_writer return decorator def _check_registration(self, cls): if cls is not None and not inspect.isclass(cls): raise InvalidRegistrationError("`cls` must be a class or None, not" " %r" % cls) def _setup_locals(self, file_params, file, encoding, newline, kwargs): self._validate_encoding(encoding) io_kwargs = self._pop_io_kwargs(kwargs, encoding, newline) file_keys, files = self._setup_file_args(kwargs, file_params) files.append(file) return file_keys, files, io_kwargs def _validate_encoding(self, encoding): if encoding != self._encoding: if self._encoding == 'binary': raise ValueError("Encoding must be 'binary' for %r" % self.name) if encoding == 'binary': raise ValueError("Encoding must not be 'binary' for %r" % self.name) def _pop_io_kwargs(self, kwargs, encoding, newline): io_kwargs = dict(encoding=encoding, newline=newline) for key in _open_kwargs: if key in kwargs: io_kwargs[key] = kwargs.pop(key) return io_kwargs def _setup_file_args(self, kwargs, file_params): file_keys = [] files = [] for param in file_params: arg = kwargs.get(param, None) if arg is not None: file_keys.append(param) files.append(arg) else: # set to None to mask FileSentinel when user neglected argument kwargs[param] = None return file_keys, files def _add_writer(self, cls, writer, monkey_patch, override): if cls in self._writers and not override: raise DuplicateRegistrationError("There is already a writer" " registered to %s in format: %s" % (cls, self._name)) self._writers[cls] = writer if monkey_patch and cls is not None: self._monkey_patch['write'].add(cls) def _add_reader(self, cls, reader, monkey_patch, override): if cls in self._readers and not override: raise DuplicateRegistrationError("There is already a reader" " registered to %s in format: %s" % (cls, self._name)) self._readers[cls] = reader if monkey_patch and cls is not None: self._monkey_patch['read'].add(cls) io_registry = IORegistry() @wraps(IORegistry.sniff) def sniff(file, **kwargs): return io_registry.sniff(file, **kwargs) @wraps(IORegistry.read) def read(file, format=None, into=None, verify=True, **kwargs): return io_registry.read(file, format=format, into=into, verify=verify, **kwargs) @wraps(IORegistry.write) def write(obj, format, into, **kwargs): return io_registry.write(obj, format, into, **kwargs) @wraps(IORegistry.create_format) def create_format(*args, **kwargs): return io_registry.create_format(*args, **kwargs) scikit-bio-0.5.9/skbio/io/tests/000077500000000000000000000000001446255456000164555ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/tests/__init__.py000066400000000000000000000005411446255456000205660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/io/tests/data/000077500000000000000000000000001446255456000173665ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/io/tests/data/big5_file000066400000000000000000000000051446255456000211310ustar00rootroot00000000000000§A¦n scikit-bio-0.5.9/skbio/io/tests/data/big5_file.bz2000066400000000000000000000000561446255456000216330ustar00rootroot00000000000000BZh91AY&SY²â*¼E € 0ÍÁ¥âîH§ \EW€scikit-bio-0.5.9/skbio/io/tests/data/big5_file.gz000066400000000000000000000000431446255456000215520ustar00rootroot00000000000000‹à[Ubig5_file[î¸, &Óáscikit-bio-0.5.9/skbio/io/tests/data/example_file000066400000000000000000000000651446255456000217440ustar00rootroot00000000000000This is some content It occurs on more than one line scikit-bio-0.5.9/skbio/io/tests/data/example_file.bz2000066400000000000000000000001241446255456000224340ustar00rootroot00000000000000BZh91AY&SYý¯ÝlW€@ *gž TPÓL Sõ2S&ôÔŽƒ*#$jëê²ô6óèÉ6ðŒÙ O)/œéà»’)„‡í~ë`scikit-bio-0.5.9/skbio/io/tests/data/example_file.gz000066400000000000000000000001231446255456000223560ustar00rootroot00000000000000‹wTUexample_file ÉÈ,V¢âüÜT…äü¼’Ô¼.Ï…üääÒ¢b…ü<…Üü¢T…’ŒÄ< 'U!'3/• Šô5scikit-bio-0.5.9/skbio/io/tests/data/real_file000066400000000000000000000000121446255456000212240ustar00rootroot00000000000000a b c d e scikit-bio-0.5.9/skbio/io/tests/data/real_file_2000066400000000000000000000000271446255456000214530ustar00rootroot00000000000000! @ # $ % The realest. scikit-bio-0.5.9/skbio/io/tests/test_iosources.py000066400000000000000000000027141446255456000221050ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio.io._iosources import IOSource, Compressor class TestIOSource(unittest.TestCase): def setUp(self): self.file = 'somepath' self.options = {'a': 1, 'b': 2} self.source = IOSource(self.file, self.options) def test_attributes(self): self.assertEqual(self.source.file, self.file) self.assertEqual(self.source.options, self.options) def test_can_read(self): self.assertEqual(self.source.can_read(), False) def test_can_write(self): self.assertEqual(self.source.can_write(), False) def test_get_reader(self): with self.assertRaises(NotImplementedError): self.source.get_reader() def test_get_writer(self): with self.assertRaises(NotImplementedError): self.source.get_writer() class TestCompressor(TestIOSource): def setUp(self): super(TestCompressor, self).setUp() self.compressor = Compressor(self.file, self.options) def test_can_write(self): self.assertEqual(self.compressor.can_write(), True) if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/io/tests/test_registry.py000066400000000000000000001737301446255456000217510ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from io import StringIO import io import itertools import os import unittest import warnings import types from tempfile import mkstemp from skbio.io import (FormatIdentificationWarning, UnrecognizedFormatError, ArgumentOverrideWarning, io_registry, sniff, create_format) from skbio.io.registry import (IORegistry, FileSentinel, Format, DuplicateRegistrationError, InvalidRegistrationError) from skbio.util import get_data_path from skbio.util._exception import TestingUtilError from skbio import DNA, read, write class MockClass: def __init__(self, list_): self.list = list_ def __eq__(self, other): # They are only equal when the class is EXACTLY the same. We don't want # readers to return knockoff instances... return self.__class__ is other.__class__ and self.list == other.list def __repr__(self): return "%s(%s)" % (str(self.__class__.__name__), str(self.list)) class MockClassA(MockClass): pass class MockClassB(MockClass): pass class TestFormatAndIORegistry(unittest.TestCase): def test_add_duplicate_format(self): f = Format('Example') r = IORegistry() r.add_format(f) with self.assertRaises(DuplicateRegistrationError): r.add_format(Format('Example')) class RegistryTest(unittest.TestCase): def setUp(self): self.registry = IORegistry() self.fd1, self.fp1 = mkstemp() self.fd2, self.fp2 = mkstemp() def tearDown(self): os.remove(self.fp1) os.close(self.fd1) os.remove(self.fp2) os.close(self.fd2) class TestRegisterAndGetReader(RegistryTest): def test_get_reader_no_match(self): self.assertIs(None, self.registry.get_reader('not_a_format', MockClass)) def test_get_reader_when_only_writer_exists(self): format1 = self.registry.create_format('format1') @format1.writer(MockClass) def format_writer(fh): return self.assertEqual(None, self.registry.get_reader('format', MockClass)) def test_register_reader_on_many(self): format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3') format4 = self.registry.create_format('format4', encoding='binary') format5 = self.registry.create_format('format5', encoding='binary') @format1.reader(MockClassA) def format1_reader(fh): return @format1.reader(MockClassB) def format1_reader_b(fh): return @format2.reader(MockClassA) def format2_reader(fh): return @format3.reader(MockClassB) def format3_reader(fh): return @format4.reader(MockClassA) def format4_reader(fh): return @format4.reader(MockClassB) def format4_reader_b(fh): return @format5.reader(None) def format5_reader(fh): return self.assertIs(format1_reader, self.registry.get_reader('format1', MockClassA)) self.assertIs(format1_reader_b, self.registry.get_reader('format1', MockClassB)) self.assertIs(format2_reader, self.registry.get_reader('format2', MockClassA)) self.assertIs(None, self.registry.get_reader('format2', MockClassB)) self.assertIs(None, self.registry.get_reader('format3', MockClassA)) self.assertIs(format3_reader, self.registry.get_reader('format3', MockClassB)) self.assertIs(format4_reader, self.registry.get_reader('format4', MockClassA)) self.assertIs(format4_reader_b, self.registry.get_reader('format4', MockClassB)) self.assertIs(format5_reader, self.registry.get_reader('format5', None)) self.assertIs(None, self.registry.get_reader('format5', MockClassA)) self.assertIs(None, self.registry.get_reader('format5', MockClassB)) def test_register_reader_over_existing(self): format1 = self.registry.create_format('format1') with self.assertRaises(DuplicateRegistrationError) as cm: @format1.reader(MockClassA) def format1_reader(fh): return @format1.reader(MockClassA) def duplicate_format1_reader(fh): return self.assertTrue('format1' in str(cm.exception)) self.assertTrue('reader' in str(cm.exception)) self.assertTrue(MockClassA.__name__ in str(cm.exception)) def test_register_reader_over_existing_override(self): format1 = self.registry.create_format('format1') @format1.reader(MockClassA) def format1_reader(fh): return self.assertIs(format1_reader, self.registry.get_reader('format1', MockClassA)) @format1.reader(MockClassA, override=True) def duplicate_format1_reader(fh): return self.assertIs(duplicate_format1_reader, self.registry.get_reader('format1', MockClassA)) def test_mistype_reader_registration(self): format1 = self.registry.create_format('format1') with self.assertRaises(InvalidRegistrationError): @format1.reader def left_out_parens(fh): return class TestRegisterAndGetWriter(RegistryTest): def test_get_writer_no_match(self): self.assertEqual(None, self.registry.get_writer('not_a_format', MockClass)) def test_get_writer_when_only_reader_exists(self): format = self.registry.create_format('format') @format.reader(MockClass) def format_reader(fh): return self.assertEqual(None, self.registry.get_writer('format', MockClass)) def test_register_writer_on_many(self): format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3') format4 = self.registry.create_format('format4', encoding='binary') format5 = self.registry.create_format('format5', encoding='binary') @format1.writer(MockClassA) def format1_writer(obj, fh): return @format1.writer(MockClassB) def format1_writer_b(obj, fh): return @format2.writer(MockClassA) def format2_writer(obj, fh): return @format3.writer(MockClassB) def format3_writer(obj, fh): return @format4.writer(MockClassA) def format4_writer(fh): return @format4.writer(MockClassB) def format4_writer_b(fh): return @format5.writer(None) def format5_writer(fh): return self.assertEqual(format1_writer, self.registry.get_writer('format1', MockClassA)) self.assertEqual(format1_writer_b, self.registry.get_writer('format1', MockClassB)) self.assertEqual(format2_writer, self.registry.get_writer('format2', MockClassA)) self.assertEqual(None, self.registry.get_writer('format2', MockClassB)) self.assertEqual(None, self.registry.get_writer('format3', MockClassA)) self.assertEqual(format3_writer, self.registry.get_writer('format3', MockClassB)) self.assertIs(format4_writer, self.registry.get_writer('format4', MockClassA)) self.assertIs(format4_writer_b, self.registry.get_writer('format4', MockClassB)) self.assertIs(format5_writer, self.registry.get_writer('format5', None)) self.assertIs(None, self.registry.get_writer('format5', MockClassA)) self.assertIs(None, self.registry.get_writer('format5', MockClassB)) def test_register_writer_over_existing(self): format1 = self.registry.create_format('format1') with self.assertRaises(DuplicateRegistrationError) as cm: @format1.writer(MockClassA) def format1_writer(obj, fh): return @format1.writer(MockClassA) def duplicate_format1_writer(obj, fh): return self.assertTrue('format1' in str(cm.exception)) self.assertTrue('writer' in str(cm.exception)) self.assertTrue(MockClassA.__name__ in str(cm.exception)) def test_register_writer_over_existing_override(self): format1 = self.registry.create_format('format1') @format1.writer(MockClassA) def format1_writer(obj, fh): return self.assertIs(format1_writer, self.registry.get_writer('format1', MockClassA)) @format1.writer(MockClassA, override=True) def duplicate_format1_writer(obj, fh): return self.assertIs(duplicate_format1_writer, self.registry.get_writer('format1', MockClassA)) def test_mistype_writer_registration(self): format1 = self.registry.create_format('format1') with self.assertRaises(InvalidRegistrationError): @format1.writer def left_out_parens(fh): return class TestRegisterAndGetSniffer(RegistryTest): def test_get_sniffer_no_match(self): self.assertEqual(None, self.registry.get_sniffer('not_a_format')) def test_register_sniffer_on_many(self): format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3', encoding='binary') @format1.sniffer() def format1_sniffer(fh): return '1' in fh.readline(), {} @format2.sniffer() def format2_sniffer(fh): return '2' in fh.readline(), {} @format3.sniffer() def format3_sniffer(fh): return '3' in fh.readline(), {} self.assertEqual(format1_sniffer, self.registry.get_sniffer('format1')) self.assertEqual(format2_sniffer, self.registry.get_sniffer('format2')) self.assertEqual(format3_sniffer, self.registry.get_sniffer('format3')) def test_register_sniffer_over_existing(self): format1 = self.registry.create_format('format1') with self.assertRaises(DuplicateRegistrationError) as cm: @format1.sniffer() def format1_sniffer(fh): return False, {} @format1.sniffer() def duplicate_format1_sniffer(fh): return False, {} self.assertTrue('format1' in str(cm.exception)) def test_register_sniffer_over_existing_override(self): format1 = self.registry.create_format('format1') @format1.sniffer() def format1_sniffer(fh): return False, {} self.assertIs(self.registry.get_sniffer('format1'), format1_sniffer) @format1.sniffer(override=True) def duplicate_format1_sniffer(fh): return False, {} self.assertIs(self.registry.get_sniffer('format1'), duplicate_format1_sniffer) def test_sniffer_warns_on_exception(self): format = self.registry.create_format('format') @format.sniffer() def format_sniffer(fh): raise TestingUtilError("Sniffer will return False and warn.") fh = StringIO() sniffer = self.registry.get_sniffer('format') with warnings.catch_warnings(record=True): warnings.simplefilter("error") with self.assertRaises(FormatIdentificationWarning): sniffer(fh) with warnings.catch_warnings(record=True): warnings.simplefilter("ignore") result, kwargs = sniffer(fh) self.assertFalse(result) self.assertEqual({}, kwargs) fh.close() def test_mistype_sniffer_registration(self): format1 = self.registry.create_format('format1') with self.assertRaises(InvalidRegistrationError): @format1.sniffer def left_out_parens(fh): return class TestListReadFormats(RegistryTest): def test_no_read_formats(self): format1 = self.registry.create_format('format1') @format1.reader(MockClassA) def this_isnt_on_clsB(fh): return self.assertEqual([], self.registry.list_read_formats(MockClassB)) def test_one_read_format(self): format1 = self.registry.create_format('format1') @format1.reader(MockClass) def format1_cls(fh): return self.assertEqual(['format1'], self.registry.list_read_formats(MockClass)) def test_many_read_formats(self): format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3', encoding='binary') format4 = self.registry.create_format('format4') format5 = self.registry.create_format('format5', encoding='binary') @format1.reader(MockClassA) def format1_clsA(fh): return @format2.reader(MockClassA) def format2_clsA(fh): return @format3.reader(MockClassA) def format3_clsA(fh): return @format3.reader(MockClassB) def format3_clsB(fh): return @format4.reader(MockClassB) def format4_clsB(fh): return @format5.writer(MockClassA) def format5_clsA(fh): return formats = self.registry.list_read_formats(MockClassA) self.assertTrue('format1' in formats) self.assertTrue('format2' in formats) self.assertTrue('format3' in formats) self.assertTrue('format4' not in formats) self.assertTrue('format5' not in formats) class TestListWriteFormats(RegistryTest): def test_no_write_formats(self): format1 = self.registry.create_format('format1') @format1.writer(MockClassA) def this_isnt_on_clsB(fh): return self.assertEqual([], self.registry.list_write_formats(MockClassB)) def test_one_write_format(self): format1 = self.registry.create_format('format1') @format1.writer(MockClass) def format1_cls(fh): return self.assertEqual(['format1'], self.registry.list_write_formats(MockClass)) def test_many_write_formats(self): format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3', encoding='binary') format4 = self.registry.create_format('format4') format5 = self.registry.create_format('format5', encoding='binary') @format1.writer(MockClassA) def format1_clsA(fh): return @format2.writer(MockClassA) def format2_clsA(fh): return @format3.writer(MockClassA) def format3_clsA(fh): return @format3.writer(MockClassB) def format3_clsB(fh): return @format4.writer(MockClassB) def format4_clsB(fh): return @format5.reader(MockClassA) def format5_clsA(fh): return formats = self.registry.list_write_formats(MockClassA) self.assertTrue('format1' in formats) self.assertTrue('format2' in formats) self.assertTrue('format3' in formats) self.assertTrue('format4' not in formats) self.assertTrue('format5' not in formats) class TestSniff(RegistryTest): def setUp(self): super(TestSniff, self).setUp() format1 = self.registry.create_format('format1') format2 = self.registry.create_format('format2') format3 = self.registry.create_format('format3') format4 = self.registry.create_format('format4') # No sniffer for this format: self.registry.create_format('format5') @format1.sniffer() def format1_sniffer(fh): return '1' in fh.readline(), {} @format2.sniffer() def format2_sniffer(fh): return '2' in fh.readline(), {} @format3.sniffer() def format3_sniffer(fh): return '3' in fh.readline(), {} @format4.sniffer() def format4_sniffer(fh): return '4' in fh.readline(), {} @format3.reader(MockClass) def reader3(fh): return @format4.reader(MockClass) def reader4(fh): return def test_no_matches(self): fh = StringIO("no matches here") with self.assertRaises(UnrecognizedFormatError) as cm: self.registry.sniff(fh) self.assertTrue(str(fh) in str(cm.exception)) fh.close() def test_one_match(self): fh = StringIO("contains a 3") self.assertEqual('format3', self.registry.sniff(fh)[0]) def test_many_matches(self): fh = StringIO("1234 will match all") with self.assertRaises(UnrecognizedFormatError) as cm: self.registry.sniff(fh) self.assertTrue("format1" in str(cm.exception)) self.assertTrue("format2" in str(cm.exception)) self.assertTrue("format3" in str(cm.exception)) self.assertTrue("format4" in str(cm.exception)) fh.close() def test_that_encoding_is_used(self): formatx = self.registry.create_format('formatx') fp = get_data_path('big5_file') @formatx.sniffer() def sniffer(fh): self.assertEqual('big5', fh.encoding) return True, {} fmt, _ = self.registry.sniff(fp, encoding='big5') self.assertEqual(fmt, 'formatx') def test_passing_newline_raises_error(self): formatx = self.registry.create_format('formatx') fp = get_data_path('real_file') @formatx.sniffer() def sniffer(fh): return True, {} with self.assertRaisesRegex(TypeError, r'`newline`'): self.registry.sniff(fp, newline='\r') def test_non_default_encoding(self): big5_format = self.registry.create_format('big5_format', encoding='big5') @big5_format.sniffer() def sniffer(fh): self.assertEqual(self._expected_encoding, fh.encoding) return True, {} self._expected_encoding = 'big5' fmt, _ = self.registry.sniff(self.fp1) self.assertEqual(fmt, 'big5_format') self._expected_encoding = 'UTF-8' fmt, _ = self.registry.sniff(self.fp1, encoding='UTF-8') self.assertEqual(fmt, 'big5_format') def test_non_default_newline(self): formatx = self.registry.create_format('formatx', newline='\r') fp = get_data_path('real_file') @formatx.sniffer() def sniffer(fh): self.assertEqual(fh.readlines(), ['a\nb\nc\nd\ne\n']) return True, {} fmt, _ = self.registry.sniff(fp) self.assertEqual(fmt, 'formatx') def test_position_not_mutated_real_file(self): formatx = self.registry.create_format('formatx') @formatx.sniffer() def sniffer(fh): return True, {} with io.open(get_data_path('real_file')) as fh: fh.seek(2) self.registry.sniff(fh) self.assertEqual(fh.tell(), 2) self.assertEqual('b\n', fh.readline()) def test_position_not_mutated_fileish(self): formatx = self.registry.create_format('formatx') @formatx.sniffer() def sniffer(fh): return True, {} fh = StringIO('a\nb\nc\nd\n') fh.seek(2) self.registry.sniff(fh) self.assertEqual('b\n', fh.readline()) def test_sniff_with_errors_in_sniffer(self): formatx = self.registry.create_format('formatx', encoding='ascii') @formatx.sniffer() def sniffer(fh): raise Exception("OH NO!") fp = get_data_path('big5_file') with warnings.catch_warnings(record=True): warnings.simplefilter('error') with self.assertRaises(FormatIdentificationWarning): fmt, _ = self.registry.sniff(fp) def test_sniff_with_encoding_errors(self): formatx = self.registry.create_format('formatx', encoding='ascii') @formatx.sniffer() def sniffer(fh): fh.read() return True, {} fp = get_data_path('big5_file') with self.assertRaises(UnrecognizedFormatError): fmt, _ = self.registry.sniff(fp, errors='strict') # errors is set to ignore by default, so our sniffer will return # true even though read() didn't entirely work for ascii fmt, _ = self.registry.sniff(fp) self.assertEqual(fmt, 'formatx') def test_binary_sniffer(self): binf = self.registry.create_format('binf', encoding='binary') @binf.sniffer() def sniffer(fh): self.assertIsInstance(fh, (io.BufferedReader, io.BufferedRandom)) return True, {} fmt, _ = self.registry.sniff(self.fp1) self.assertEqual(fmt, 'binf') def test_text_sniffer(self): textf = self.registry.create_format('textf', encoding=None) @textf.sniffer() def sniffer(fh): self.assertIsInstance(fh, io.TextIOBase) return True, {} fmt, _ = self.registry.sniff(self.fp1) self.assertEqual(fmt, 'textf') def test_sniff_with_illegal_encoding(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.sniffer() def binf_sniffer(fh): return True, {} @textf.sniffer() def textf_sniffer(fh): return True, {} # Should skip binary sniffers fmt, _ = self.registry.sniff(self.fp1, encoding=None) self.assertEqual(fmt, 'textf') # Should skip text sniffers fmt, _ = self.registry.sniff(self.fp1, encoding='binary') self.assertEqual(fmt, 'binf') with self.assertRaises(ValueError): self.registry.sniff(['some content\n'], encoding='binary') with self.assertRaises(ValueError): binf_sniffer(self.fp1, encoding=None) with self.assertRaises(ValueError): textf_sniffer(self.fp1, encoding='binary') def test_binary_fall_through(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.sniffer() def binf_sniffer(fh): self._check_binf = True return False, {} @textf.sniffer() def textf_sniffer(fh): self._check_textf = True return True, {} self._check_binf = False self._check_textf = False fmt, _ = self.registry.sniff(self.fp1) self.assertEqual(fmt, 'textf') self.assertTrue(self._check_binf) self.assertTrue(self._check_textf) def test_sniff_gzip(self): expected = "This is some content\nIt occurs on more than one line\n" formata = self.registry.create_format('formata', encoding='binary') formatb = self.registry.create_format('formatb') formatc = self.registry.create_format('formatc') @formata.sniffer() def formata_sniffer(fh): self._check_f1 = True self.assertEqual(fh.read(), expected.encode('ascii')) return False, {} @formatb.sniffer() def formatb_sniffer(fh): self._check_f2 = True self.assertEqual(fh.read(), expected) return True, {} @formatc.sniffer() def formatc_sniffer(fh): self._check_f3 = True self.assertEqual(fh.read(), expected) return False, {} self._check_f1 = False self._check_f2 = False self._check_f3 = False self.registry.sniff(get_data_path('example_file.gz')) self.assertTrue(self._check_f1) self.assertTrue(self._check_f2) self.assertTrue(self._check_f3) def test_text_skip_binary(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.sniffer() def binf_sniffer(fh): self._check_binf = True return True, {} @textf.sniffer() def textf_sniffer(fh): self._check_textf = True return True, {} self._check_binf = False self._check_textf = False fmt, _ = self.registry.sniff(['text']) self.assertEqual(fmt, 'textf') self.assertFalse(self._check_binf) self.assertTrue(self._check_textf) self._check_binf = False self._check_textf = False fmt, _ = self.registry.sniff(self.fp1, encoding=None) self.assertEqual(fmt, 'textf') self.assertFalse(self._check_binf) self.assertTrue(self._check_textf) def test_text_skip_text(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.sniffer() def binf_sniffer(fh): self._check_binf = True return True, {} @textf.sniffer() def textf_sniffer(fh): self._check_textf = True return True, {} self._check_binf = False self._check_textf = False fmt, _ = self.registry.sniff(self.fp1, encoding='binary') self.assertEqual(fmt, 'binf') self.assertTrue(self._check_binf) self.assertFalse(self._check_textf) class TestRead(RegistryTest): def test_format_and_into_are_none(self): fh = StringIO() with self.assertRaises(ValueError): self.registry.read(fh) fh.close() def test_format_is_none(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh): self.assertIsInstance(fh, io.TextIOBase) return MockClass([int(x) for x in fh.read().split('\n')]) instance = self.registry.read(fh, into=MockClass) self.assertEqual(MockClass([1, 2, 3, 4]), instance) fh.close() def test_into_is_none_and_no_generator_reader(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.reader(MockClass) def reader(fh): self.assertIsInstance(fh, io.TextIOBase) return with self.assertRaisesRegex(UnrecognizedFormatError, r"Cannot read 'format1'.*Possible.*include" ": MockClass"): self.registry.read(fh, format='format1') def test_into_is_none(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.reader(None) def reader(fh): self.assertIsInstance(fh, io.TextIOBase) yield from [int(x) for x in fh.read().split('\n')] generator = self.registry.read(fh, format='format1') self.assertIsInstance(generator, types.GeneratorType) first_run = True for a, b in zip(generator, [1, 2, 3, 4]): if first_run: fh.seek(3) first_run = False self.assertEqual(a, b) self.assertEqual(3, fh.tell()) fh.close() def test_into_is_none_real_file(self): format1 = self.registry.create_format('format1') fp = self.fp1 with open(fp, 'w') as fh: fh.write('1\n2\n3\n4') self._test_fh = None @format1.reader(None) def reader(fh): self._test_fh = fh yield from [int(x) for x in fh.read().split('\n')] generator = self.registry.read(fp, format='format1') for a, b in itertools.zip_longest(generator, [1, 2, 3, 4]): self.assertEqual(a, b) self.assertTrue(self._test_fh.closed) def test_reader_does_not_exist(self): fh = StringIO() with self.assertRaises(UnrecognizedFormatError) as cm: self.registry.read(fh, format='not_a_format', into=MockClass) self.assertTrue(MockClass.__name__ in str(cm.exception)) self.assertTrue('not_a_format' in str(cm.exception)) with self.assertRaises(UnrecognizedFormatError) as cm: self.registry.read(fh, format='not_a_format2') self.assertTrue('generator' in str(cm.exception)) self.assertTrue('not_a_format2' in str(cm.exception)) def test_reader_exists_with_verify_true(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): self.was_verified = True return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh): return MockClass([int(x) for x in fh.read().split('\n')]) self.was_verified = False instance = self.registry.read(fh, format='format1', into=MockClass, verify=True) self.assertEqual(MockClass([1, 2, 3, 4]), instance) self.assertTrue(self.was_verified) # Remove if read-context management is support in the future. fh.seek(0) self.was_verified = False instance = self.registry.read(fh, format='format1', into=MockClass) self.assertEqual(MockClass([1, 2, 3, 4]), instance) self.assertTrue(self.was_verified) fh.close() def test_warning_raised(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): self.was_verified = True return False, {} @format1.reader(MockClass) def reader(fh): return MockClass([int(x) for x in fh.read().split('\n')]) with warnings.catch_warnings(record=True): warnings.simplefilter("error") with self.assertRaises(FormatIdentificationWarning): self.was_verified = False instance = self.registry.read(fh, format='format1', into=MockClass, verify=True) self.assertEqual(MockClass([1, 2, 3, 4]), instance) self.assertTrue(self.was_verified) with warnings.catch_warnings(record=True): warnings.simplefilter("error") with self.assertRaises(FormatIdentificationWarning): self.was_verified = False instance = self.registry.read(fh, format='format1', into=MockClass) self.assertEqual(MockClass([1, 2, 3, 4]), instance) self.assertTrue(self.was_verified) fh.close() def test_reader_exists_with_verify_false(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): self.was_verified = True return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh): return MockClass([int(x) for x in fh.read().split('\n')]) self.was_verified = False instance = self.registry.read(fh, format='format1', into=MockClass, verify=False) self.assertEqual(MockClass([1, 2, 3, 4]), instance) self.assertFalse(self.was_verified) fh.close() def test_reader_exists_real_file(self): format1 = self.registry.create_format('format1') fp = self.fp1 with open(fp, 'w') as fh: fh.write('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh): return MockClass([int(x) for x in fh.read().split('\n')]) instance = self.registry.read(fp, format='format1', into=MockClass) self.assertEqual(MockClass([1, 2, 3, 4]), instance) def test_read_kwargs_passed_generator(self): format1 = self.registry.create_format('format1') @format1.sniffer() def sniffer(fh): return True, {'arg1': 15, 'arg2': 'abc'} @format1.reader(None) def reader(fh, **kwargs): self.assertEqual(kwargs['arg1'], 15) self.assertEqual(kwargs['arg2'], 'abc') self.assertEqual(kwargs['arg3'], [1]) yield next(self.registry.read(StringIO(), format='format1', arg3=[1])) def test_read_kwargs_passed_and_override(self): format1 = self.registry.create_format('format1') @format1.sniffer() def sniffer(fh): return True, {'arg1': 15, 'arg2': 'abc', 'override': 30} @format1.reader(MockClass) def reader(fh, **kwargs): self.assertEqual(kwargs['arg1'], 15) self.assertEqual(kwargs['arg2'], 'abc') self.assertEqual(kwargs['arg3'], [1]) return self.registry.read(StringIO('notempty'), into=MockClass, arg3=[1]) with warnings.catch_warnings(record=True): warnings.simplefilter("error") # Should raise no warning and thus no error. self.registry.read(StringIO('notempty'), into=MockClass, arg3=[1], override=30) # Should raise a warning and thus an error. with self.assertRaises(ArgumentOverrideWarning): self.registry.read(StringIO('notempty'), into=MockClass, arg3=[1], override=100) def test_that_encoding_is_used(self): format1 = self.registry.create_format('format1') fp = get_data_path('big5_file') @format1.sniffer() def sniffer(fh): return '\u4f60' in fh.readline(), {} @format1.reader(MockClass) def reader(fh): self.assertEqual(self._expected_enc, fh.encoding) return MockClass(fh.readlines()) @format1.reader(None) def reader_gen(fh): self.assertEqual(self._expected_enc, fh.encoding) yield MockClass(fh.readlines()) self._expected_enc = 'big5' instance = self.registry.read(fp, into=MockClass, encoding='big5') self.assertEqual(MockClass(['\u4f60\u597d\n']), instance) self._expected_enc = 'big5' gen = self.registry.read(fp, format='format1', encoding='big5') self.assertEqual(MockClass(['\u4f60\u597d\n']), next(gen)) def test_non_default_encoding(self): format1 = self.registry.create_format('format1', encoding='big5') fp = get_data_path('big5_file') @format1.sniffer() def sniffer(fh): return True, {} @format1.reader(MockClass) def reader(fh): self.assertEqual(self._expected_enc, fh.encoding) return MockClass(fh.readlines()) @format1.reader(None) def reader_gen(fh): self.assertEqual(self._expected_enc, fh.encoding) yield MockClass(fh.readlines()) self._expected_enc = 'big5' instance = self.registry.read(fp, into=MockClass) self.assertEqual(MockClass(['\u4f60\u597d\n']), instance) gen = self.registry.read(fp, format='format1') self.assertEqual(MockClass(['\u4f60\u597d\n']), next(gen)) gen.close() self._expected_enc = 'utf8' with self.assertRaises(UnicodeDecodeError): self.registry.read(fp, into=MockClass, encoding='utf8') with self.assertRaises(UnicodeDecodeError): self.registry.read(fp, format='format1', encoding='utf8') def test_passing_newline_raises_error(self): formatx = self.registry.create_format('formatx') fp = get_data_path('real_file') @formatx.sniffer() def sniffer(fh): return True, {} @formatx.reader(MockClass) def reader(fh): return MockClass(fh.readlines()) @formatx.reader(None) def reader_gen(fh): yield MockClass(fh.readlines()) with self.assertRaisesRegex(TypeError, r'`newline`'): self.registry.read(fp, into=MockClass, newline='\r') with self.assertRaisesRegex(TypeError, r'`newline`'): self.registry.read(fp, format='formatx', newline='\r') def test_non_default_newline(self): formatx = self.registry.create_format('formatx', newline='\r') fp = get_data_path('real_file') @formatx.sniffer() def sniffer(fh): return True, {} @formatx.reader(MockClass) def reader(fh): return MockClass(fh.readlines()) @formatx.reader(None) def reader_gen(fh): yield MockClass(fh.readlines()) instance = self.registry.read(fp, into=MockClass) self.assertEqual(instance, MockClass(['a\nb\nc\nd\ne\n'])) gen = self.registry.read(fp, format='formatx') self.assertEqual(next(gen), MockClass(['a\nb\nc\nd\ne\n'])) gen.close() def test_file_sentinel_many(self): format1 = self.registry.create_format('format1') extra = get_data_path('real_file') extra_2 = get_data_path('real_file_2') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertEqual('a\nb\nc\nd\ne\n', extra.read()) self.assertEqual('!\n@\n#\n$\n%\nThe realest.\n', extra_2.read()) return MockClass([int(x) for x in fh.read().split('\n')]) instance = self.registry.read(fh, format='format1', into=MockClass, extra=extra, extra_2=extra_2) self.assertEqual(MockClass([1, 2, 3, 4]), instance) fh.close() def test_file_sentinel_converted_to_none(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) return MockClass([int(x) for x in fh.read().split('\n')]) instance = self.registry.read(fh, format='format1', into=MockClass) self.assertEqual(MockClass([1, 2, 3, 4]), instance) fh.close() def test_file_sentinel_pass_none(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(MockClass) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) return MockClass([int(x) for x in fh.read().split('\n')]) instance = self.registry.read(fh, format='format1', into=MockClass, extra=None) self.assertEqual(MockClass([1, 2, 3, 4]), instance) fh.close() def test_file_sentinel_generator_many(self): format1 = self.registry.create_format('format1') extra = get_data_path('real_file') extra_2 = get_data_path('real_file_2') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(None) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertEqual('a\nb\nc\nd\ne\n', extra.read()) self.assertEqual('!\n@\n#\n$\n%\nThe realest.\n', extra_2.read()) yield MockClass([int(x) for x in fh.read().split('\n')]) gen = self.registry.read(fh, format='format1', extra=extra, extra_2=extra_2) self.assertEqual(MockClass([1, 2, 3, 4]), next(gen)) fh.close() def test_file_sentinel_converted_to_none_generator(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(None) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) yield MockClass([int(x) for x in fh.read().split('\n')]) gen = self.registry.read(fh, format='format1') self.assertEqual(MockClass([1, 2, 3, 4]), next(gen)) fh.close() def test_file_sentinel_pass_none_generator(self): format1 = self.registry.create_format('format1') fh = StringIO('1\n2\n3\n4') @format1.sniffer() def sniffer(fh): return '1' in fh.readline(), {} @format1.reader(None) def reader(fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) yield MockClass([int(x) for x in fh.read().split('\n')]) gen = self.registry.read(fh, format='format1', extra=None) self.assertEqual(MockClass([1, 2, 3, 4]), next(gen)) fh.close() def test_read_with_illegal_encoding(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.sniffer() def binf_sniffer(fh): return True, {} @binf.reader(MockClass) def binf_reader(fh): return MockClass(['bin']) @binf.reader(None) def binf_reader_gen(fh): yield MockClass(['bin']) @textf.sniffer() def textf_sniffer(fh): return True, {} @textf.reader(MockClass) def textf_reader(fh): return MockClass(['text']) @textf.reader(None) def textf_reader_gen(fh): yield MockClass(['text']) # Should skip binary sniffers instance = self.registry.read(self.fp1, encoding=None, into=MockClass) self.assertEqual(instance, MockClass(['text'])) gen = self.registry.read(self.fp1, encoding=None, format='textf') self.assertEqual(next(gen), MockClass(['text'])) gen.close() # Should skip text sniffers instance = self.registry.read(self.fp1, encoding='binary', into=MockClass) self.assertEqual(instance, MockClass(['bin'])) gen = self.registry.read(self.fp1, encoding='binary', format='binf') self.assertEqual(next(gen), MockClass(['bin'])) gen.close() with self.assertRaises(ValueError): self.registry.read(['some content\n'], encoding='binary', into=MockClass) with self.assertRaises(ValueError): self.registry.read(['some content\n'], format='textf', encoding='binary', into=MockClass) with self.assertRaises(ValueError): self.registry.read(['some content\n'], format='textf', encoding='binary', verify=False, into=MockClass) with self.assertRaises(ValueError): self.registry.read(['some content\n'], format='textf', encoding='binary') with self.assertRaises(ValueError): self.registry.read(['some content\n'], format='textf', encoding='binary', verify=False) with self.assertRaises(ValueError): self.registry.read(self.fp1, format='binf', encoding=None, into=MockClass) with self.assertRaises(ValueError): self.registry.read(self.fp1, format='binf', encoding=None, verify=False, into=MockClass) with self.assertRaises(ValueError): self.registry.read(self.fp1, format='binf', encoding=None) with self.assertRaises(ValueError): self.registry.read(self.fp1, format='binf', encoding=None, verify=False) def test_read_with_binary_encoding(self): binf = self.registry.create_format('binf', encoding='binary') @binf.reader(MockClass) def reader1(fh): self.assertIsInstance(fh, (io.BufferedReader, io.BufferedRandom)) return MockClass(['woo']) @binf.reader(None) def reader2(fh): self.assertIsInstance(fh, (io.BufferedReader, io.BufferedRandom)) yield MockClass(['woo']) instance = self.registry.read(self.fp1, format='binf', verify=False, into=MockClass) self.assertEqual(MockClass(['woo']), instance) gen = self.registry.read(self.fp1, format='binf', verify=False, into=None) self.assertEqual(MockClass(['woo']), next(gen)) gen.close() def test_io_kwargs_passed(self): format1 = self.registry.create_format('format1') @format1.sniffer() def sniffer(fh): return True, {} @format1.reader(MockClass) def reader1(fh): self.assertEqual(fh.errors, 'replace') return MockClass(['woo']) @format1.reader(None) def reader1_gen(fh): self.assertEqual(fh.errors, 'replace') yield MockClass(['woo']) obj = self.registry.read(self.fp1, into=MockClass, errors='replace') self.assertEqual(obj, MockClass(['woo'])) gen = self.registry.read(self.fp1, format='format1', errors='replace') self.assertEqual(next(gen), MockClass(['woo'])) gen.close() def test_read_empty_file_gen_with_format(self): format1 = self.registry.create_format('format1') @format1.sniffer() def sniffer(fh): return True, {} @format1.reader(None) def reader1(fh): return yield with io.StringIO("") as fh: gen = self.registry.read(fh, format='format1') self.assertEqual(list(gen), []) class TestWrite(RegistryTest): def test_writer_does_not_exist(self): fh = StringIO() with self.assertRaises(UnrecognizedFormatError) as cm: self.registry.write({}, format='not_a_format', into=fh) self.assertTrue('not_a_format' in str(cm.exception)) self.assertTrue(str(fh) in str(cm.exception)) fh.close() def test_writer_exists(self): format1 = self.registry.create_format('format1') obj = MockClass(['1', '2', '3', '4']) fh = StringIO() @format1.writer(MockClass) def writer(obj, fh): self.assertIsInstance(fh, io.TextIOBase) fh.write('\n'.join(obj.list)) self.registry.write(obj, format='format1', into=fh) fh.seek(0) self.assertEqual("1\n2\n3\n4", fh.read()) fh.close() def test_writer_exists_real_file(self): format1 = self.registry.create_format('format1') obj = MockClass(['1', '2', '3', '4']) fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): self.assertIsInstance(fh, io.TextIOBase) fh.write('\n'.join(obj.list)) self.registry.write(obj, format='format1', into=fp) with io.open(fp) as fh: self.assertEqual("1\n2\n3\n4", fh.read()) def test_writer_passed_kwargs(self): format1 = self.registry.create_format('format1') @format1.reader(None) def reader(fh): yield @format1.writer(None) def writer(obj, fh, **kwargs): self.assertEqual(kwargs['passed'], True) generator = self.registry.get_reader('format1', None)([]) self.registry.write(generator, format='format1', into=StringIO(), passed=True) def test_that_encoding_is_used(self): format1 = self.registry.create_format('format1') obj = MockClass(['\u4f60\u597d\n']) # Ni Hau fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): fh.write(''.join(obj.list)) self.assertEqual(self._expected_encoding, fh.encoding) self._expected_encoding = 'big5' self.registry.write(obj, format='format1', into=fp, encoding='big5') with io.open(fp, mode='rb') as fh: # This would have been b'\xe4\xbd\xa0\xe5\xa5\xbd\n' in utf8 self.assertEqual(b'\xa7A\xa6n\n', fh.read()) def test_non_default_encoding(self): format1 = self.registry.create_format('format1', encoding='big5') obj = MockClass(['\u4f60\u597d\n']) # Ni Hau fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): fh.write(''.join(obj.list)) self.assertEqual(self._expected_encoding, fh.encoding) self._expected_encoding = 'big5' self.registry.write(obj, format='format1', into=fp) with io.open(fp, mode='rb') as fh: self.assertEqual(b'\xa7A\xa6n\n', fh.read()) self._expected_encoding = 'utf8' self.registry.write(obj, format='format1', into=fp, encoding='utf8') with io.open(fp, mode='rb') as fh: self.assertEqual(b'\xe4\xbd\xa0\xe5\xa5\xbd\n', fh.read()) def test_that_newline_is_used(self): format1 = self.registry.create_format('format1') obj = MockClass(['a\n', 'b\n', 'c\n']) fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): fh.write(''.join(obj.list)) self.registry.write(obj, format='format1', into=fp, newline='\r') with io.open(fp, mode='rb') as fh: self.assertEqual(b'a\rb\rc\r', fh.read()) def test_non_default_newline(self): format1 = self.registry.create_format('format1', newline='\r') obj = MockClass(['a\n', 'b\n', 'c\n']) fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): fh.write(''.join(obj.list)) self.registry.write(obj, format='format1', into=fp) with io.open(fp, mode='rb') as fh: self.assertEqual(b'a\rb\rc\r', fh.read()) self.registry.write(obj, format='format1', into=fp, newline='\n') with io.open(fp, mode='rb') as fh: self.assertEqual(b'a\nb\nc\n', fh.read()) def test_file_sentinel_many(self): format1 = self.registry.create_format('format1') fh = StringIO() @format1.writer(MockClass) def writer(obj, fh, extra=FileSentinel, other=2, extra_2=FileSentinel): extra.write('oh yeah...') extra_2.write('oh no...') self.registry.write(MockClass([]), format='format1', into=fh, extra=self.fp1, extra_2=self.fp2) with open(self.fp1) as f1: self.assertEqual('oh yeah...', f1.read()) with open(self.fp2) as f2: self.assertEqual('oh no...', f2.read()) fh.close() def test_file_sentinel_converted_to_none(self): format1 = self.registry.create_format('format1') fh = StringIO() @format1.writer(MockClass) def writer(obj, fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) self.registry.write(MockClass([]), format='format1', into=fh) fh.close() def test_file_sentinel_pass_none(self): format1 = self.registry.create_format('format1') fh = StringIO() @format1.writer(MockClass) def writer(obj, fh, extra=FileSentinel, other=2, extra_2=FileSentinel): self.assertIsNone(extra) self.assertIsNone(extra_2) self.registry.write(MockClass([]), format='format1', into=fh, extra=None) fh.close() def test_write_with_illegal_encoding(self): binf = self.registry.create_format('binf', encoding='binary') textf = self.registry.create_format('textf', encoding=None) @binf.writer(MockClass) def writer(obj, fh): pass @textf.writer(MockClass) def writer2(obj, fh): pass with self.assertRaises(ValueError): self.registry.write(MockClass([]), into=self.fp1, format='binf', encoding=None) with self.assertRaises(ValueError): self.registry.write(MockClass([]), into=self.fp1, format='textf', encoding='binary') def test_write_binary_format(self): format1 = self.registry.create_format('format1', encoding='binary') obj = MockClass([b'a\n', b'b\n', b'c\n']) fp = self.fp1 @format1.writer(MockClass) def writer(obj, fh): self.assertIsInstance(fh, (io.BufferedWriter, io.BufferedRandom)) fh.write(b''.join(obj.list)) self.registry.write(obj, format='format1', into=fp) with io.open(fp, mode='rb') as fh: self.assertEqual(b'a\nb\nc\n', fh.read()) def test_io_kwargs_passed(self): format1 = self.registry.create_format('format1', encoding='ascii') obj = MockClass(['a\n', 'b\n', 'c\n']) fp = self.fp1 f = io.BytesIO() @format1.writer(MockClass) def writer(obj, fh): iterator = iter(obj.list) fh.write(next(iterator)) fh.flush() # Flush should be a noop for bz2 for line in iterator: fh.write(line) self.registry.write(obj, format='format1', into=fp, compression='bz2') self.registry.write(obj, format='format1', into=f, compression='bz2') expected = ( b'BZh91AY&SY\x03\x89\x0c\xa6\x00\x00\x01\xc1\x00\x00\x108\x00 \x00' b'!\x9ah3M\x1c\xb7\x8b\xb9"\x9c(H\x01\xc4\x86S\x00') with io.open(fp, mode='rb') as fh: self.assertEqual(expected, fh.read()) self.assertEqual(expected, f.getvalue()) class TestMonkeyPatch(RegistryTest): def setUp(self): super(TestMonkeyPatch, self).setUp() class UnassumingClass: pass class ClassWithDefault: default_write_format = 'favfmt' class NoMonkeySee: pass self.unassuming_class = UnassumingClass self.class_with_default = ClassWithDefault self.no_monkey_see = NoMonkeySee def test_no_readers_writers(self): self.registry.monkey_patch() self.assertFalse(hasattr(self.unassuming_class, 'read')) self.assertFalse(hasattr(self.unassuming_class, 'write')) self.assertFalse(hasattr(self.class_with_default, 'read')) self.assertFalse(hasattr(self.class_with_default, 'write')) def test_readers_only(self): favfmt = self.registry.create_format('favfmt') favfmt2 = self.registry.create_format('favfmt2') @favfmt.reader(self.unassuming_class) def fvfmt_to_unasumming_class(fh): return @favfmt.reader(None) def fvfmt_to_gen(fh): yield @favfmt2.reader(self.unassuming_class) def fvfmt2_to_unasumming_class(fh): return self.registry.monkey_patch() self.assertTrue(hasattr(self.unassuming_class, 'read')) self.assertFalse(hasattr(self.unassuming_class, 'write')) self.assertFalse(hasattr(self.class_with_default, 'read')) self.assertFalse(hasattr(self.class_with_default, 'write')) self.assertIn('favfmt', self.unassuming_class.read.__doc__) self.assertIn('favfmt2', self.unassuming_class.read.__doc__) def test_writers_only(self): favfmt = self.registry.create_format('favfmt') favfmt2 = self.registry.create_format('favfmt2') @favfmt.writer(self.class_with_default) def favfmt_writer(fh): pass @favfmt.writer(None) def gen_to_favfmt(fh): pass @favfmt2.writer(self.class_with_default) def favfmt2_writer(fh): pass self.registry.monkey_patch() self.assertFalse(hasattr(self.unassuming_class, 'read')) self.assertFalse(hasattr(self.unassuming_class, 'write')) self.assertFalse(hasattr(self.class_with_default, 'read')) self.assertTrue(hasattr(self.class_with_default, 'write')) self.assertIn('favfmt', self.class_with_default.write.__doc__) self.assertIn('favfmt2', self.class_with_default.write.__doc__) def test_writers_no_default_format(self): favfmt = self.registry.create_format('favfmt') favfmt2 = self.registry.create_format('favfmt2') @favfmt.writer(self.unassuming_class) def favfmt_writer(fh): pass @favfmt.writer(None) def gen_to_favfmt(fh): pass @favfmt2.writer(self.unassuming_class) def favfmt2_writer(fh): pass with self.assertRaises(NotImplementedError) as cm: self.registry.monkey_patch() self.assertIn('default_write_format', str(cm.exception)) def test_readers_writers(self): favfmt = self.registry.create_format('favfmt') favfmt2 = self.registry.create_format('favfmt2') @favfmt.reader(self.unassuming_class) def fvfmt_to_unasumming_class(fh): return @favfmt.reader(self.class_with_default) def fvfmt_to_class_w_default(fh): return @favfmt.reader(None) def fvfmt_to_gen(fh): yield @favfmt2.reader(self.unassuming_class) def fvfmt2_to_unasumming_class(fh): return @favfmt2.reader(self.class_with_default) def fvfmt2_to_class_w_default(fh): return @favfmt.writer(self.class_with_default) def favfmt_writer(fh): pass @favfmt.writer(None) def gen_to_favfmt(fh): pass @favfmt2.writer(self.class_with_default) def favfmt2_writer(fh): pass @favfmt2.reader(self.no_monkey_see, monkey_patch=True) def favfmt2_to_monkey(fh): pass @favfmt2.writer(self.no_monkey_see, monkey_patch=False) def monkey_to_favfmt2(fh): pass self.registry.monkey_patch() self.assertTrue(hasattr(self.unassuming_class, 'read')) self.assertFalse(hasattr(self.unassuming_class, 'write')) self.assertTrue(hasattr(self.class_with_default, 'read')) self.assertTrue(hasattr(self.class_with_default, 'write')) self.assertTrue(hasattr(self.no_monkey_see, 'read')) self.assertFalse(hasattr(self.no_monkey_see, 'write')) self.assertIn('favfmt', self.unassuming_class.read.__doc__) self.assertIn('favfmt2', self.unassuming_class.read.__doc__) self.assertIn('favfmt', self.class_with_default.read.__doc__) self.assertIn('favfmt2', self.class_with_default.read.__doc__) self.assertIn('favfmt', self.class_with_default.write.__doc__) self.assertIn('favfmt2', self.class_with_default.write.__doc__) self.assertIn('favfmt2', self.no_monkey_see.read.__doc__) def test_read_kwargs_passed(self): favfmt = self.registry.create_format('favfmt') self.was_called = False @favfmt.sniffer() def fvfmt_sniffer(fh): return True, {} @favfmt.reader(self.class_with_default) def fvfmt_to_class_w_default(fh, **kwargs): self.assertEqual('a', kwargs['a']) self.assertEqual(123, kwargs['b']) self.was_called = True self.registry.monkey_patch() fh = StringIO('notempty') self.class_with_default.read(fh, a='a', b=123) self.assertTrue(self.was_called) fh.close() def test_write_kwargs_passed(self): favfmt = self.registry.create_format('favfmt') self.was_called = False @favfmt.writer(self.class_with_default) def favfmt_writer(obj, fh, **kwargs): self.assertEqual('a', kwargs['a']) self.assertEqual(123, kwargs['b']) self.was_called = True self.registry.monkey_patch() fh = StringIO() self.class_with_default().write(fh, a='a', b=123) self.assertTrue(self.was_called) fh.close() class TestModuleFunctions(unittest.TestCase): def test_sniff_matches(self): exp = io_registry.sniff(['(a, b);']) result = sniff(['(a, b);']) self.assertEqual(exp, result) self.assertEqual('newick', exp[0]) self.assertEqual({}, exp[1]) def test_read_matches(self): input = ['>\n', 'ACGT\n'] exp = io_registry.read(input, into=DNA) result = read(input, into=DNA) self.assertEqual(exp, result) self.assertEqual(exp, DNA('ACGT', metadata={'id': '', 'description': ''})) def test_write_matches(self): input = DNA('ACGT') exp = io_registry.write(input, format='fasta', into=[]) result = write(input, format='fasta', into=[]) self.assertEqual(exp, result) self.assertEqual(exp, ['>\n', 'ACGT\n']) def test_create_format_matches(self): with self.assertRaises(DuplicateRegistrationError): io_registry.create_format('fasta') with self.assertRaises(DuplicateRegistrationError): create_format('fasta') if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/tests/test_util.py000066400000000000000000000551311446255456000210500ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import tempfile import shutil import io import os.path try: import httpretty has_httpretty = True except ImportError: has_httpretty = False import skbio.io from skbio.io.registry import open_file from skbio.util import get_data_path class TestOpen(unittest.TestCase): def test_open_invalid_mode(self): with self.assertRaises(ValueError): skbio.io.open([], mode='a') def test_open_invalid_source(self): with self.assertRaises(skbio.io.IOSourceError): skbio.io.open(42) def test_open_invalid_source_compression(self): with self.assertRaises(ValueError): skbio.io.open(['foo'], compression='gzip') def test_open_invalid_source_encoding(self): with self.assertRaises(ValueError): skbio.io.open(['foo'], encoding='binary') with self.assertRaises(ValueError): skbio.io.open(['foo'], encoding='binary', newline='\r') def test_open_invalid_compression(self): with self.assertRaises(ValueError): skbio.io.open(io.BytesIO(), compression='foo') class ReadableBinarySourceTests: def check_closed(self, file, expected): if hasattr(file, 'closed'): self.assertEqual(file.closed, expected) def check_open_state_contents(self, file, contents, is_binary, **kwargs): result = skbio.io.open(file, **kwargs) if is_binary: self.assertIsInstance(result, (io.BufferedReader, io.BufferedRandom)) else: self.assertIsInstance(result, io.TextIOBase) self.assertTrue(result.readable()) self.assertEqual(result.read(), contents) self.assertFalse(result.closed) result.close() self.assertTrue(result.closed) self.check_closed(file, True) def check_open_file_state_contents(self, file, contents, is_binary, **kwargs): with open_file(file, **kwargs) as f: if is_binary: self.assertIsInstance(f, (io.BufferedReader, io.BufferedRandom)) else: self.assertIsInstance(f, io.TextIOBase) self.assertTrue(f.readable()) self.assertEqual(f.read(), contents) self.assertEqual(f.closed, self.expected_close) f.close() self.assertTrue(f.closed) self.check_closed(file, True) def check_open_buffer_close_behaviour(self, file, **kwargs): if hasattr(file, 'close'): wrapped = skbio.io.open(file, **kwargs) file.close() self.assertTrue(wrapped.closed) def check_open_file_buffer_close_behaviour(self, file, **kwargs): if hasattr(file, 'close'): with open_file(file, **kwargs) as wrapped: file.close() self.assertTrue(wrapped.closed) def check_open_gc_behaviour(self, file, **kwargs): def mangle(file): result = skbio.io.open(file, **kwargs) self.assertIsInstance(result, io.TextIOBase) f = skbio.io.open(file, encoding='binary') mangle(f) self.assertFalse(f.closed) f.close() def check_open_file_gc_behaviour(self, file, **kwargs): def mangle(file): with open_file(file, **kwargs) as result: self.assertIsInstance(result, io.TextIOBase) with open_file(file, encoding='binary') as f: mangle(f) self.assertFalse(f.closed) def test_open_gc_binary(self): self.check_open_gc_behaviour(self.read_file) def test_open_gc_encoding(self): self.check_open_gc_behaviour(self.encoded_file) def test_open_gc_compression(self): self.check_open_gc_behaviour(self.gzip_file) self.check_open_gc_behaviour(self.bz2_file) def test_open_gc_compression_encoding(self): self.check_open_gc_behaviour(self.gzip_encoded_file) self.check_open_gc_behaviour(self.bz2_encoded_file) def test_open_file_gc_binary(self): self.check_open_file_gc_behaviour(self.read_file) def test_open_file_gc_encoding(self): self.check_open_file_gc_behaviour(self.encoded_file) def test_open_file_gc_compression(self): self.check_open_file_gc_behaviour(self.gzip_file) self.check_open_file_gc_behaviour(self.bz2_file) def test_open_file_gc_compression_encoding(self): self.check_open_file_gc_behaviour(self.gzip_encoded_file) self.check_open_file_gc_behaviour(self.bz2_encoded_file) def test_open_underclose_binary(self): self.check_open_buffer_close_behaviour(self.read_file) def test_open_underclose_encoding(self): self.check_open_buffer_close_behaviour(self.encoded_file) def test_open_underclose_compression(self): self.check_open_buffer_close_behaviour(self.gzip_file) self.check_open_buffer_close_behaviour(self.bz2_file) def test_open_underclose_compression_encoding(self): self.check_open_buffer_close_behaviour(self.gzip_encoded_file) self.check_open_buffer_close_behaviour(self.bz2_encoded_file) def test_open_file_underclose_binary(self): self.check_open_file_buffer_close_behaviour(self.read_file) def test_open_file_underclose_encoding(self): self.check_open_file_buffer_close_behaviour(self.encoded_file) def test_open_file_underclose_compression(self): self.check_open_file_buffer_close_behaviour(self.gzip_file) self.check_open_file_buffer_close_behaviour(self.bz2_file) def test_open_file_underclose_compression_encoding(self): self.check_open_file_buffer_close_behaviour(self.gzip_encoded_file) self.check_open_file_buffer_close_behaviour(self.bz2_encoded_file) def test_open_binary(self): self.check_open_state_contents(self.read_file, self.binary_contents, True, mode='r', encoding='binary') def test_open_binary_compression_none(self): self.check_open_state_contents(self.read_file, self.binary_contents, True, mode='r', encoding='binary', compression=None) def test_open_encoding(self): self.check_open_state_contents(self.encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) def test_open_auto_compression_binary(self): self.check_open_state_contents(self.gzip_file, self.binary_contents, True, mode='r', encoding='binary', compression='auto') self.check_open_state_contents(self.bz2_file, self.binary_contents, True, mode='r', encoding='binary', compression='auto') def test_open_gzip_compression_binary(self): self.check_open_state_contents(self.gzip_file, self.binary_contents, True, mode='r', encoding='binary', compression='gzip') def test_open_bz2_compression_binary(self): self.check_open_state_contents(self.bz2_file, self.binary_contents, True, mode='r', encoding='binary', compression='bz2') def test_open_default_compression_encoding(self): self.check_open_state_contents(self.gzip_encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) self.check_open_state_contents(self.bz2_encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) def test_open_file_binary(self): self.check_open_file_state_contents(self.read_file, self.binary_contents, True, mode='r', encoding='binary') def test_open_file_binary_compression_none(self): self.check_open_file_state_contents(self.read_file, self.binary_contents, True, mode='r', encoding='binary', compression=None) def test_open_file_encoding(self): self.check_open_file_state_contents(self.encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) def test_open_file_auto_compression_binary(self): self.check_open_file_state_contents(self.gzip_file, self.binary_contents, True, mode='r', encoding='binary', compression='auto') self.check_open_file_state_contents(self.bz2_file, self.binary_contents, True, mode='r', encoding='binary', compression='auto') def test_open_file_gzip_compression_binary(self): self.check_open_file_state_contents(self.gzip_file, self.binary_contents, True, mode='r', encoding='binary', compression='gzip') def test_open_file_bz2_compression_binary(self): self.check_open_file_state_contents(self.bz2_file, self.binary_contents, True, mode='r', encoding='binary', compression='bz2') def test_open_file_default_compression_encoding(self): self.check_open_file_state_contents(self.gzip_encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) self.check_open_file_state_contents(self.bz2_encoded_file, self.decoded_contents, False, mode='r', encoding=self.encoding) class ReadableSourceTest(unittest.TestCase): def setUp(self): self.read_file = self.get_fileobj(get_data_path("example_file")) self.gzip_file = \ self.get_fileobj(get_data_path("example_file.gz")) self.bz2_file = \ self.get_fileobj(get_data_path("example_file.bz2")) self.encoded_file = self.get_fileobj(get_data_path("big5_file")) self.gzip_encoded_file = \ self.get_fileobj(get_data_path("big5_file.gz")) self.bz2_encoded_file = \ self.get_fileobj(get_data_path("big5_file.bz2")) self.binary_contents = (b"This is some content\n" b"It occurs on more than one line\n") self.decoded_contents = '\u4f60\u597d\n' # Ni Hau self.compression = 'gzip' self.encoding = "big5" def tearDown(self): self.safe_close(self.read_file) self.safe_close(self.gzip_file) self.safe_close(self.bz2_file) self.safe_close(self.encoded_file) self.safe_close(self.gzip_encoded_file) self.safe_close(self.bz2_encoded_file) def safe_close(self, f): if hasattr(f, 'close'): f.close() class WritableBinarySourceTests: def check_closed(self, file, expected): if hasattr(file, 'closed'): self.assertEqual(file.closed, expected) def check_open_state_contents(self, file, contents, is_binary, **kwargs): result = skbio.io.open(file, mode='w', **kwargs) if is_binary: self.assertIsInstance(result, (io.BufferedWriter, io.BufferedRandom)) else: self.assertIsInstance(result, io.TextIOBase) self.assertTrue(result.writable()) result.write(contents) self.assertFalse(result.closed) if self.expected_close: result.close() self.assertTrue(result.closed) self.check_closed(file, True) def compare_gzip_file_contents(self, a, b): # The first 10 bytes of a gzip header include a timestamp. The header # can be followed by other "volatile" metadata, so only compare gzip # footers (last 8 bytes) which contain a CRC-32 checksum and the length # of the uncompressed data. self.assertEqual(a[-8:], b[-8:]) def test_open_binary(self): self.check_open_state_contents(self.binary_file, self.binary_contents, True, encoding='binary', compression=None) self.assertEqual(self.get_contents(self.binary_file), self.binary_contents) def test_open_gzip(self): self.check_open_state_contents(self.gzip_file, self.text_contents, False, compression='gzip') self.compare_gzip_file_contents(self.get_contents(self.gzip_file), self.gzip_contents) def test_open_bz2(self): self.check_open_state_contents(self.bz2_file, self.text_contents, False, compression='bz2') self.assertEqual(self.get_contents(self.bz2_file), self.bz2_contents) def test_open_encoding(self): self.check_open_state_contents(self.big5_file, self.decoded_contents, False, encoding='big5') self.assertEqual(self.get_contents(self.big5_file), self.encoded_contents) def test_open_gzip_encoding(self): self.check_open_state_contents(self.gzip_encoded_file, self.decoded_contents, False, compression='gzip', encoding='big5') self.compare_gzip_file_contents( self.get_contents(self.gzip_encoded_file), self.gzip_encoded_contents) def test_open_bz2_encoding(self): self.check_open_state_contents(self.bz2_encoded_file, self.decoded_contents, False, compression='bz2', encoding='big5') self.assertEqual(self.get_contents(self.bz2_encoded_file), self.bz2_encoded_contents) class WritableSourceTest(unittest.TestCase): def setUp(self): self._dir = tempfile.mkdtemp() with io.open(get_data_path('example_file'), mode='rb') as f: self.binary_contents = f.read() self.binary_file = self._make_file('example_file') with io.open(get_data_path('big5_file'), mode='rb') as f: self.encoded_contents = f.read() self.big5_file = self._make_file('big5_file') with io.open(get_data_path('example_file.gz'), mode='rb') as f: self.gzip_contents = f.read() self.gzip_file = self._make_file('example_file.gz') with io.open(get_data_path('example_file.bz2'), mode='rb') as f: self.bz2_contents = f.read() self.bz2_file = self._make_file('example_file.bz2') with io.open(get_data_path('big5_file.gz'), mode='rb') as f: self.gzip_encoded_contents = f.read() self.gzip_encoded_file = self._make_file('big5_file.gz') with io.open(get_data_path('big5_file.bz2'), mode='rb') as f: self.bz2_encoded_contents = f.read() self.bz2_encoded_file = self._make_file('big5_file.bz2') self.decoded_contents = self.encoded_contents.decode('big5') self.text_contents = self.binary_contents.decode('utf8') def tearDown(self): shutil.rmtree(self._dir) self.safe_close(self.binary_file) self.safe_close(self.gzip_file) self.safe_close(self.bz2_file) self.safe_close(self.big5_file) self.safe_close(self.gzip_encoded_file) self.safe_close(self.bz2_encoded_file) def safe_close(self, f): if hasattr(f, 'close'): f.close() def _make_file(self, name): return self.get_fileobj(os.path.join(self._dir, name)) class TestReadFilepath(ReadableBinarySourceTests, ReadableSourceTest): expected_close = True def get_fileobj(self, path): return path class TestWriteFilepath(WritableBinarySourceTests, WritableSourceTest): expected_close = True def get_fileobj(self, path): return path def get_contents(self, file): with io.open(file, mode='rb') as f: return f.read() @unittest.skipIf(not has_httpretty, "HTTPretty not available to mock tests.") class TestReadURL(ReadableBinarySourceTests, ReadableSourceTest): expected_close = True def setUp(self): super(TestReadURL, self).setUp() httpretty.enable() for file in (get_data_path('example_file'), get_data_path('big5_file'), get_data_path('example_file.gz'), get_data_path('example_file.bz2'), get_data_path('big5_file.gz'), get_data_path('big5_file.bz2')): with io.open(file, mode='rb') as f: httpretty.register_uri(httpretty.GET, self.get_fileobj(file), body=f.read(), content_type="application/octet-stream") def tearDown(self): super(TestReadURL, self).setUp() httpretty.disable() def get_fileobj(self, path): return "http://example.com/" + os.path.split(path)[1] class TestReadBytesIO(ReadableBinarySourceTests, ReadableSourceTest): expected_close = False def get_fileobj(self, path): with io.open(path, mode='rb') as f: return io.BytesIO(f.read()) class TestWriteBytesIO(WritableBinarySourceTests, WritableSourceTest): expected_close = False def get_fileobj(self, path): return io.BytesIO() def get_contents(self, file): return file.getvalue() def test_open_gzip(self): self.check_open_state_contents(self.gzip_file, self.text_contents, False, compression='gzip') self.compare_gzip_file_contents(self.get_contents(self.gzip_file), self.gzip_contents) def test_open_gzip_encoding(self): self.check_open_state_contents(self.gzip_encoded_file, self.decoded_contents, False, compression='gzip', encoding='big5') self.compare_gzip_file_contents( self.get_contents(self.gzip_encoded_file), self.gzip_encoded_contents) class TestReadBufferedReader(ReadableBinarySourceTests, ReadableSourceTest): expected_close = False def get_fileobj(self, path): return io.open(path, mode='rb') class TestWriteBufferedReader(WritableBinarySourceTests, WritableSourceTest): expected_close = False def get_fileobj(self, path): return io.open(path, mode='w+b') def get_contents(self, file): file.close() with io.open(file.name, mode='rb') as f: return f.read() class TestReadNamedTemporaryFile(ReadableBinarySourceTests, ReadableSourceTest): expected_close = False def get_fileobj(self, path): fileobj = tempfile.NamedTemporaryFile() with io.open(path, mode='rb') as fh: fileobj.write(fh.read()) fileobj.flush() fileobj.seek(0) return fileobj class TestWriteNamedTemporaryFile(WritableBinarySourceTests, WritableSourceTest): expected_close = False def get_fileobj(self, path): return tempfile.NamedTemporaryFile() def get_contents(self, file): file.flush() file.seek(0) contents = file.read() file.close() return contents class TestReadTemporaryFile(ReadableBinarySourceTests, ReadableSourceTest): expected_close = False def get_fileobj(self, path): fileobj = tempfile.TemporaryFile() with io.open(path, mode='rb') as fh: fileobj.write(fh.read()) fileobj.flush() fileobj.seek(0) return fileobj class TestWriteTemporaryFile(WritableBinarySourceTests, WritableSourceTest): expected_close = False def get_fileobj(self, path): return tempfile.TemporaryFile() def get_contents(self, file): file.flush() file.seek(0) contents = file.read() file.close() return contents class TestIterableReaderWriter(unittest.TestCase): def test_open(self): def gen(): yield from ('a', 'b', 'c') list_ = list(gen()) for input_ in gen(), list_: with skbio.io.open(input_) as result: self.assertIsInstance(result, io.TextIOBase) self.assertEqual(result.read(), 'abc') def test_open_with_newline(self): lines = ['a\r', 'b\r', 'c\r'] with skbio.io.open(lines, newline='\r') as result: self.assertIsInstance(result, io.TextIOBase) self.assertEqual(result.readlines(), lines) def test_open_invalid_iterable(self): with self.assertRaises(skbio.io.IOSourceError): skbio.io.open([1, 2, 3]) def test_open_empty_iterable(self): with skbio.io.open([]) as result: self.assertIsInstance(result, io.TextIOBase) self.assertEqual(result.read(), '') def test_open_write_mode(self): lines = [] with skbio.io.open(lines, mode='w') as fh: fh.write('abc') self.assertEqual(lines, ['abc']) lines = [] with skbio.io.open(lines, mode='w', newline='\r') as fh: fh.write('ab\nc\n') self.assertEqual(lines, ['ab\r', 'c\r']) self.assertTrue(fh.closed) fh.close() self.assertTrue(fh.closed) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/io/util.py000066400000000000000000000255411446255456000166510ustar00rootroot00000000000000r""" I/O utils (:mod:`skbio.io.util`) ================================ .. currentmodule:: skbio.io.util This module provides utility functions to deal with files and I/O in general. Functions --------- .. autosummary:: :toctree: generated/ open open_file open_files """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from contextlib import contextmanager, ExitStack from skbio.io import IOSourceError from skbio.io._iosources import get_io_sources, get_compression_handler from skbio.io._fileobject import ( is_binary_file, SaneTextIOWrapper, CompressedBufferedReader, CompressedBufferedWriter) from skbio.util._decorator import stable _d = dict(mode='r', encoding=None, errors=None, newline=None, compression='auto', compresslevel=9) def _resolve(file, mode=_d['mode'], encoding=_d['encoding'], errors=_d['errors'], newline=_d['newline'], compression=_d['compression'], compresslevel=_d['compresslevel']): arguments = locals().copy() if mode not in {'r', 'w'}: raise ValueError("Unsupported mode: %r, use 'r' or 'w'" % mode) newfile = None source = None for source_handler in get_io_sources(): source = source_handler(file, arguments) if mode == 'r' and source.can_read(): newfile = source.get_reader() break elif mode == 'w' and source.can_write(): newfile = source.get_writer() break if newfile is None: raise IOSourceError( "Could not open source: %r (mode: %r)" % (file, mode)) return newfile, source, is_binary_file(newfile) @stable(as_of="0.4.0") def open(file, mode=_d['mode'], encoding=_d['encoding'], errors=_d['errors'], newline=_d['newline'], compression=_d['compression'], compresslevel=_d['compresslevel']): r"""Convert input into a filehandle. Supported inputs: +--------------------------------------+--------+---------+-----------+ | type | can \ | can \ | source \ | | | read | write | type | +======================================+========+=========+===========+ | file path | True | True | Binary | +--------------------------------------+--------+---------+-----------+ | URL | True | False | Binary | +--------------------------------------+--------+---------+-----------+ | ``["lines list\n"]`` | True | True | Text | +--------------------------------------+--------+---------+-----------+ | :class:`io.StringIO` | True | True | Text | +--------------------------------------+--------+---------+-----------+ | :class:`io.BytesIO` | True | True | Binary | +--------------------------------------+--------+---------+-----------+ | :class:`io.TextIOWrapper` | True | True | Text | +--------------------------------------+--------+---------+-----------+ | :class:`io.BufferedReader` | True | False | Binary | +--------------------------------------+--------+---------+-----------+ | :class:`io.BufferedWriter` | False | True | Binary | +--------------------------------------+--------+---------+-----------+ | :class:`io.BufferedRandom` | True | True | Binary | +--------------------------------------+--------+---------+-----------+ | :func:`tempfile.TemporaryFile` | True | True | Binary | +--------------------------------------+--------+---------+-----------+ | :func:`tempfile.NamedTemporaryFile` | True | True | Binary | +--------------------------------------+--------+---------+-----------+ .. note:: When reading a list of unicode (str) lines, the input for `newline` is used to determine the number of lines in the resulting file handle, not the number of elements in the list. This is to allow composition with ``file.readlines()``. Parameters ---------- file : filepath, url, filehandle, list The input to convert to a filehandle. mode : {'r', 'w'}, optional Whether to return a readable or writable file. Conversely, this does not imply that the returned file will be unwritable or unreadable. To get a binary filehandle set `encoding` to binary. encoding : str, optional The encoding scheme to use for the file. If set to 'binary', no bytes will be translated. Otherwise this matches the behavior of :func:`io.open`. errors : str, optional Specifies how encoding and decoding errors are to be handled. This has no effect when `encoding` is binary (as there can be no errors). Otherwise this matches the behavior of :func:`io.open`. newline : {None, "", '\\n', '\\r\\n', '\\r'}, optional Matches the behavior of :func:`io.open`. compression : {'auto', 'gzip', 'bz2', None}, optional Will compress or decompress `file` depending on `mode`. If 'auto' then determining the compression of the file will be attempted and the result will be transparently decompressed. 'auto' will do nothing when writing. Other legal values will use their respective compression schemes. `compression` cannot be used with a text source. compresslevel : int (0-9 inclusive), optional The level of compression to use, will be passed to the appropriate compression handler. This is only used when writing. Returns ------- filehandle : io.TextIOBase or io.BufferedReader/Writer When `encoding='binary'` an :class:`io.BufferedReader` or :class:`io.BufferedWriter` will be returned depending on `mode`. Otherwise an implementation of :class:`io.TextIOBase` will be returned. .. note:: Any underlying resources needed to create `filehandle` are managed transparently. If `file` was closeable, garbage collection of `filehandle` will not close `file`. Calling `close` on `filehandle` will close `file`. Conversely calling `close` on `file` will cause `filehandle` to reflect a closed state. **This does not mean that a `flush` has occured for `filehandle`, there may still have been data in its buffer! Additionally, resources may not have been cleaned up properly, so ALWAYS call `close` on `filehandle` and NOT on `file`.** """ arguments = locals().copy() del arguments['file'] file, _, is_binary_file = _resolve(file, **arguments) return _munge_file(file, is_binary_file, arguments) def _munge_file(file, is_binary_file, arguments): mode = arguments.get('mode', _d['mode']) encoding = arguments.get('encoding', _d['encoding']) errors = arguments.get('errors', _d['errors']) newline = arguments.get('newline', _d['newline']) compression = arguments.get('compression', _d['compression']) is_output_binary = encoding == 'binary' newfile = file compression_handler = get_compression_handler(compression) if is_output_binary and newline is not _d['newline']: raise ValueError("Cannot use `newline` with binary encoding.") if compression is not None and not compression_handler: raise ValueError("Unsupported compression: %r" % compression) if is_binary_file: if compression: c = compression_handler(newfile, arguments) if mode == 'w': newfile = CompressedBufferedWriter(file, c.get_writer(), streamable=c.streamable) else: newfile = CompressedBufferedReader(file, c.get_reader()) if not is_output_binary: newfile = SaneTextIOWrapper(newfile, encoding=encoding, errors=errors, newline=newline) else: if compression is not None and compression != 'auto': raise ValueError("Cannot use compression with that source.") if is_output_binary: raise ValueError("Source is not a binary source") return newfile @contextmanager def _resolve_file(file, **kwargs): file, source, is_binary_file = _resolve(file, **kwargs) try: yield file, source, is_binary_file finally: if source.closeable: file.close() @contextmanager @stable(as_of="0.4.0") def open_file(file, **kwargs): r"""Context manager for :func:`skbio.io.util.open`. The signature matches :func:`open`. This context manager will not close filehandles that it did not create itself. Examples -------- Here our input isn't a filehandle and so `f` will get closed. >>> with open_file(['a\n']) as f: ... f.read() ... 'a\n' >>> f.closed True Here we provide an open file and so `f` will not get closed and neither will `file`. >>> file = io.BytesIO(b'BZh91AY&SY\x03\x89\x0c\xa6\x00\x00\x01\xc1\x00\x00' ... b'\x108\x00 \x00!\x9ah3M\x1c\xb7\x8b\xb9"\x9c(H\x01' ... b'\xc4\x86S\x00') >>> with open_file(file) as f: ... f.read() ... 'a\nb\nc\n' >>> f.closed False >>> file.closed False """ with _resolve_file(file, **kwargs) as (file, source, is_binary_file): newfile = _munge_file(file, is_binary_file, source.options) try: yield newfile finally: # As soon as we leave the above context manager file will be closed # It is important to realize that because we are closing an inner # buffer, the outer buffer will reflect that state, but it won't # get flushed as the inner buffer is oblivious to the outer # buffer's existence. if not newfile.closed: newfile.flush() _flush_compressor(newfile) def _flush_compressor(file): if isinstance(file, io.TextIOBase) and hasattr(file, 'buffer'): file = file.buffer if isinstance(file, CompressedBufferedWriter) and not file.streamable: # Some formats like BZ2 compress the entire file, and so they will # only flush once they have been closed. These kinds of files do not # close their underlying buffer, but only testing can prove that... file.raw.close() @contextmanager @stable(as_of="0.4.0") def open_files(files, **kwargs): """A plural form of :func:`open_file`.""" with ExitStack() as stack: yield [stack.enter_context(open_file(f, **kwargs)) for f in files] scikit-bio-0.5.9/skbio/metadata/000077500000000000000000000000001446255456000164645ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/metadata/__init__.py000066400000000000000000000013201446255456000205710ustar00rootroot00000000000000r""" Metadata (:mod:`skbio.metadata`) ================================ .. currentmodule:: skbio.metadata This module provides classes for storing and working with metadata. Classes ------- .. autosummary:: :toctree: generated/ Interval IntervalMetadata """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._interval import Interval, IntervalMetadata __all__ = ['Interval', 'IntervalMetadata'] scikit-bio-0.5.9/skbio/metadata/_intersection.c000066400000000000000000022263721446255456000215130ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [], "name": "skbio.metadata._intersection", "sources": [ "skbio/metadata/_intersection.pyx" ] }, "module_name": "skbio.metadata._intersection" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__metadata___intersection #define __PYX_HAVE_API__skbio__metadata___intersection /* Early includes */ #include "stdlib.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "stringsource", "skbio/metadata/_intersection.pyx", }; /*--- Type declarations ---*/ struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right; /* "skbio/metadata/_intersection.pyx":263 * * * cpdef left(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a start > than `position` */ struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left { int __pyx_n; int n; int max_dist; }; /* "skbio/metadata/_intersection.pyx":278 * return r[:n] * * cpdef right(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a end < than position */ struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right { int __pyx_n; int n; int max_dist; }; /* "skbio/metadata/_intersection.pyx":66 * cdef float nlog = -1.0 / log(0.5) * * cdef class IntervalNode: # <<<<<<<<<<<<<< * """ * A single node of an `IntervalTree`. */ struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode { PyObject_HEAD struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *__pyx_vtab; float priority; PyObject *interval; int start; int end; int minend; int maxend; int minstart; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *cleft; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *cright; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *croot; }; /* "skbio/metadata/_intersection.pyx":305 * ## ---- Wrappers that retain the old interface ------------------------------- * * cdef class IntervalObj: # <<<<<<<<<<<<<< * """ * Basic feature, with required integer start and end properties. */ struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj { PyObject_HEAD int start; int end; PyObject *value; PyObject *chrom; PyObject *strand; }; /* "skbio/metadata/_intersection.pyx":357 * return self == other or self > other * * cdef class IntervalTree: # <<<<<<<<<<<<<< * """ * Data structure for performing window intersect queries on a set of */ struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree { PyObject_HEAD struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *root; }; /* "skbio/metadata/_intersection.pyx":66 * cdef float nlog = -1.0 / log(0.5) * * cdef class IntervalNode: # <<<<<<<<<<<<<< * """ * A single node of an `IntervalTree`. */ struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*insert)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *, int __pyx_skip_dispatch); struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*rotate_right)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *); struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*rotate_left)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *); void (*set_ends)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *); void (*_intersect)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *); void (*update)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *, PyObject *, int __pyx_skip_dispatch); void (*_seek_left)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, PyObject *, int, int); void (*_seek_right)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, PyObject *, int, int); PyObject *(*left)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left *__pyx_optional_args); PyObject *(*right)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right *__pyx_optional_args); void (*_traverse)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *); }; static struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *__pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode; static CYTHON_INLINE void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *); /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* SliceTupleAndList.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); #else #define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #endif /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyIntCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* GetNameInClass.proto */ #define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto*/ static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto*/ static CYTHON_INLINE void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__intersect(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_results); /* proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_position, PyObject *__pyx_v_results, int __pyx_v_n, int __pyx_v_max_dist); /* proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_position, PyObject *__pyx_v_results, int __pyx_v_n, int __pyx_v_max_dist); /* proto*/ static PyObject *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left *__pyx_optional_args); /* proto*/ static PyObject *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right *__pyx_optional_args); /* proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_func); /* proto*/ /* Module declarations from 'skbio.metadata._intersection' */ static PyTypeObject *__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode = 0; static PyTypeObject *__pyx_ptype_5skbio_8metadata_13_intersection_IntervalObj = 0; static PyTypeObject *__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree = 0; static float __pyx_v_5skbio_8metadata_13_intersection_nlog; static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_5skbio_8metadata_13_intersection_EmptyNode = 0; static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imax2(int, int); /*proto*/ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imax3(int, int, int); /*proto*/ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imin3(int, int, int); /*proto*/ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imin2(int, int); /*proto*/ static PyObject *__pyx_f_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj__set_state(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *, PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "skbio.metadata._intersection" extern int __pyx_module_is_main_skbio__metadata___intersection; int __pyx_module_is_main_skbio__metadata___intersection = 0; /* Implementation of 'skbio.metadata._intersection' */ static PyObject *__pyx_builtin_TypeError; static const char __pyx_k_n[] = "n"; static const char __pyx_k__3[] = ")"; static const char __pyx_k__4[] = "-"; static const char __pyx_k_add[] = "add"; static const char __pyx_k_end[] = "end"; static const char __pyx_k_key[] = "key"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_find[] = "find"; static const char __pyx_k_left[] = "left"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_sort[] = "sort"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_chrom[] = "chrom"; static const char __pyx_k_right[] = "right"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_value[] = "value"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_insert[] = "insert"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_strand[] = "strand"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_reverse[] = "reverse"; static const char __pyx_k_value_2[] = ", value="; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_interval[] = "interval"; static const char __pyx_k_max_dist[] = "max_dist"; static const char __pyx_k_operator[] = "operator"; static const char __pyx_k_position[] = "position"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_traverse[] = "traverse"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_intersect[] = "intersect"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_attrgetter[] = "attrgetter"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_Intersecter[] = "Intersecter"; static const char __pyx_k_IntervalObj[] = "IntervalObj"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_new_feature[] = "new_feature"; static const char __pyx_k_old_feature[] = "old_feature"; static const char __pyx_k_IntervalNode[] = "IntervalNode"; static const char __pyx_k_IntervalTree[] = "IntervalTree"; static const char __pyx_k_add_interval[] = "add_interval"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_num_intervals[] = "num_intervals"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_IntervalObj_d_d[] = "IntervalObj(%d, %d"; static const char __pyx_k_insert_interval[] = "insert_interval"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_IntervalNode_i_i[] = "IntervalNode(%i, %i)"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_pyx_unpickle_IntervalObj[] = "__pyx_unpickle_IntervalObj"; static const char __pyx_k_start_must_be_less_than_end[] = "start must be less than end"; static const char __pyx_k_skbio_metadata__intersection[] = "skbio.metadata._intersection"; static const char __pyx_k_Data_structure_for_performing_i[] = "\nData structure for performing intersect queries on a set of intervals which\npreserves all information about the intervals (unlike bitset projection methods).\n\n:Authors: James Taylor (james@jamestaylor.org),\n Ian Schenk (ian.schenck@gmail.com),\n Brent Pedersen (bpederse@gmail.com)\n"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; static PyObject *__pyx_n_s_Intersecter; static PyObject *__pyx_n_s_IntervalNode; static PyObject *__pyx_kp_s_IntervalNode_i_i; static PyObject *__pyx_n_s_IntervalObj; static PyObject *__pyx_kp_s_IntervalObj_d_d; static PyObject *__pyx_n_s_IntervalTree; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_kp_s__3; static PyObject *__pyx_kp_s__4; static PyObject *__pyx_n_s_add; static PyObject *__pyx_n_s_add_interval; static PyObject *__pyx_n_s_attrgetter; static PyObject *__pyx_n_s_chrom; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_end; static PyObject *__pyx_n_s_find; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_insert; static PyObject *__pyx_n_s_insert_interval; static PyObject *__pyx_n_s_intersect; static PyObject *__pyx_n_s_interval; static PyObject *__pyx_n_s_key; static PyObject *__pyx_n_s_left; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_max_dist; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_new; static PyObject *__pyx_n_s_new_feature; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_num_intervals; static PyObject *__pyx_n_s_old_feature; static PyObject *__pyx_n_s_operator; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_position; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_IntervalObj; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_reverse; static PyObject *__pyx_n_s_right; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_skbio_metadata__intersection; static PyObject *__pyx_n_s_sort; static PyObject *__pyx_n_s_start; static PyObject *__pyx_kp_s_start_must_be_less_than_end; static PyObject *__pyx_n_s_strand; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_traverse; static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_value; static PyObject *__pyx_kp_s_value_2; static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9left_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10right_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9root_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode___repr__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_2__cinit__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_4insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_6intersect(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, CYTHON_UNUSED PyObject *__pyx_v_sort); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_v_n, int __pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_12right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_v_n, int __pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_14traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_func); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj___init__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_value, PyObject *__pyx_v_chrom, PyObject *__pyx_v_strand); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_2__repr__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_4__richcmp__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6__reduce_cython__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_8__setstate_cython__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree___cinit__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_2insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_4update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_start, PyObject *__pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_6find(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_start, PyObject *__pyx_v_end); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_8before(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_10after(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_12insert_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_14before_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_16after_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_18upstream_of_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_20downstream_of_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_22traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_fn); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalNode(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalObj(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalTree(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; static PyObject *__pyx_int_3; static PyObject *__pyx_int_4; static PyObject *__pyx_int_5; static PyObject *__pyx_int_2500; static PyObject *__pyx_int_18516155; static PyObject *__pyx_int_85614314; static PyObject *__pyx_int_183079363; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_codeobj__10; /* Late includes */ /* "skbio/metadata/_intersection.pyx":38 * int iabs(int) * * cdef inline int imax2(int a, int b): # <<<<<<<<<<<<<< * if b > a: return b * return a */ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imax2(int __pyx_v_a, int __pyx_v_b) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("imax2", 0); /* "skbio/metadata/_intersection.pyx":39 * * cdef inline int imax2(int a, int b): * if b > a: return b # <<<<<<<<<<<<<< * return a * */ __pyx_t_1 = ((__pyx_v_b > __pyx_v_a) != 0); if (__pyx_t_1) { __pyx_r = __pyx_v_b; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":40 * cdef inline int imax2(int a, int b): * if b > a: return b * return a # <<<<<<<<<<<<<< * * cdef inline int imax3(int a, int b, int c): */ __pyx_r = __pyx_v_a; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":38 * int iabs(int) * * cdef inline int imax2(int a, int b): # <<<<<<<<<<<<<< * if b > a: return b * return a */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":42 * return a * * cdef inline int imax3(int a, int b, int c): # <<<<<<<<<<<<<< * if b > a: * if c > b: */ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imax3(int __pyx_v_a, int __pyx_v_b, int __pyx_v_c) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("imax3", 0); /* "skbio/metadata/_intersection.pyx":43 * * cdef inline int imax3(int a, int b, int c): * if b > a: # <<<<<<<<<<<<<< * if c > b: * return c */ __pyx_t_1 = ((__pyx_v_b > __pyx_v_a) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":44 * cdef inline int imax3(int a, int b, int c): * if b > a: * if c > b: # <<<<<<<<<<<<<< * return c * return b */ __pyx_t_1 = ((__pyx_v_c > __pyx_v_b) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":45 * if b > a: * if c > b: * return c # <<<<<<<<<<<<<< * return b * if a > c: */ __pyx_r = __pyx_v_c; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":44 * cdef inline int imax3(int a, int b, int c): * if b > a: * if c > b: # <<<<<<<<<<<<<< * return c * return b */ } /* "skbio/metadata/_intersection.pyx":46 * if c > b: * return c * return b # <<<<<<<<<<<<<< * if a > c: * return a */ __pyx_r = __pyx_v_b; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":43 * * cdef inline int imax3(int a, int b, int c): * if b > a: # <<<<<<<<<<<<<< * if c > b: * return c */ } /* "skbio/metadata/_intersection.pyx":47 * return c * return b * if a > c: # <<<<<<<<<<<<<< * return a * return c */ __pyx_t_1 = ((__pyx_v_a > __pyx_v_c) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":48 * return b * if a > c: * return a # <<<<<<<<<<<<<< * return c * */ __pyx_r = __pyx_v_a; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":47 * return c * return b * if a > c: # <<<<<<<<<<<<<< * return a * return c */ } /* "skbio/metadata/_intersection.pyx":49 * if a > c: * return a * return c # <<<<<<<<<<<<<< * * cdef inline int imin3(int a, int b, int c): */ __pyx_r = __pyx_v_c; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":42 * return a * * cdef inline int imax3(int a, int b, int c): # <<<<<<<<<<<<<< * if b > a: * if c > b: */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":51 * return c * * cdef inline int imin3(int a, int b, int c): # <<<<<<<<<<<<<< * if b < a: * if c < b: */ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imin3(int __pyx_v_a, int __pyx_v_b, int __pyx_v_c) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("imin3", 0); /* "skbio/metadata/_intersection.pyx":52 * * cdef inline int imin3(int a, int b, int c): * if b < a: # <<<<<<<<<<<<<< * if c < b: * return c */ __pyx_t_1 = ((__pyx_v_b < __pyx_v_a) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":53 * cdef inline int imin3(int a, int b, int c): * if b < a: * if c < b: # <<<<<<<<<<<<<< * return c * return b */ __pyx_t_1 = ((__pyx_v_c < __pyx_v_b) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":54 * if b < a: * if c < b: * return c # <<<<<<<<<<<<<< * return b * if a < c: */ __pyx_r = __pyx_v_c; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":53 * cdef inline int imin3(int a, int b, int c): * if b < a: * if c < b: # <<<<<<<<<<<<<< * return c * return b */ } /* "skbio/metadata/_intersection.pyx":55 * if c < b: * return c * return b # <<<<<<<<<<<<<< * if a < c: * return a */ __pyx_r = __pyx_v_b; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":52 * * cdef inline int imin3(int a, int b, int c): * if b < a: # <<<<<<<<<<<<<< * if c < b: * return c */ } /* "skbio/metadata/_intersection.pyx":56 * return c * return b * if a < c: # <<<<<<<<<<<<<< * return a * return c */ __pyx_t_1 = ((__pyx_v_a < __pyx_v_c) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":57 * return b * if a < c: * return a # <<<<<<<<<<<<<< * return c * */ __pyx_r = __pyx_v_a; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":56 * return c * return b * if a < c: # <<<<<<<<<<<<<< * return a * return c */ } /* "skbio/metadata/_intersection.pyx":58 * if a < c: * return a * return c # <<<<<<<<<<<<<< * * cdef inline int imin2(int a, int b): */ __pyx_r = __pyx_v_c; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":51 * return c * * cdef inline int imin3(int a, int b, int c): # <<<<<<<<<<<<<< * if b < a: * if c < b: */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":60 * return c * * cdef inline int imin2(int a, int b): # <<<<<<<<<<<<<< * if b < a: return b * return a */ static CYTHON_INLINE int __pyx_f_5skbio_8metadata_13_intersection_imin2(int __pyx_v_a, int __pyx_v_b) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("imin2", 0); /* "skbio/metadata/_intersection.pyx":61 * * cdef inline int imin2(int a, int b): * if b < a: return b # <<<<<<<<<<<<<< * return a * */ __pyx_t_1 = ((__pyx_v_b < __pyx_v_a) != 0); if (__pyx_t_1) { __pyx_r = __pyx_v_b; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":62 * cdef inline int imin2(int a, int b): * if b < a: return b * return a # <<<<<<<<<<<<<< * * cdef float nlog = -1.0 / log(0.5) */ __pyx_r = __pyx_v_a; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":60 * return c * * cdef inline int imin2(int a, int b): # <<<<<<<<<<<<<< * if b < a: return b * return a */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":80 * * property left_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.cleft if self.cleft is not EmptyNode else None * property right_node: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9left_node_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9left_node_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9left_node___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9left_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/metadata/_intersection.pyx":81 * property left_node: * def __get__(self): * return self.cleft if self.cleft is not EmptyNode else None # <<<<<<<<<<<<<< * property right_node: * def __get__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); if ((__pyx_t_2 != 0)) { __Pyx_INCREF(((PyObject *)__pyx_v_self->cleft)); __pyx_t_1 = ((PyObject *)__pyx_v_self->cleft); } else { __Pyx_INCREF(Py_None); __pyx_t_1 = Py_None; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":80 * * property left_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.cleft if self.cleft is not EmptyNode else None * property right_node: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":83 * return self.cleft if self.cleft is not EmptyNode else None * property right_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.cright if self.cright is not EmptyNode else None * property root_node: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_10right_node_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_10right_node_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10right_node___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10right_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/metadata/_intersection.pyx":84 * property right_node: * def __get__(self): * return self.cright if self.cright is not EmptyNode else None # <<<<<<<<<<<<<< * property root_node: * def __get__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); if ((__pyx_t_2 != 0)) { __Pyx_INCREF(((PyObject *)__pyx_v_self->cright)); __pyx_t_1 = ((PyObject *)__pyx_v_self->cright); } else { __Pyx_INCREF(Py_None); __pyx_t_1 = Py_None; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":83 * return self.cleft if self.cleft is not EmptyNode else None * property right_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.cright if self.cright is not EmptyNode else None * property root_node: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":86 * return self.cright if self.cright is not EmptyNode else None * property root_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.croot if self.croot is not EmptyNode else None * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9root_node_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9root_node_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9root_node___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_9root_node___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; __Pyx_RefNannySetupContext("__get__", 0); /* "skbio/metadata/_intersection.pyx":87 * property root_node: * def __get__(self): * return self.croot if self.croot is not EmptyNode else None # <<<<<<<<<<<<<< * * def __repr__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = (__pyx_v_self->croot != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); if ((__pyx_t_2 != 0)) { __Pyx_INCREF(((PyObject *)__pyx_v_self->croot)); __pyx_t_1 = ((PyObject *)__pyx_v_self->croot); } else { __Pyx_INCREF(Py_None); __pyx_t_1 = Py_None; } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":86 * return self.cright if self.cright is not EmptyNode else None * property root_node: * def __get__(self): # <<<<<<<<<<<<<< * return self.croot if self.croot is not EmptyNode else None * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":89 * return self.croot if self.croot is not EmptyNode else None * * def __repr__(self): # <<<<<<<<<<<<<< * return "IntervalNode(%i, %i)" % (self.start, self.end) * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_1__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_1__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode___repr__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode___repr__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "skbio/metadata/_intersection.pyx":90 * * def __repr__(self): * return "IntervalNode(%i, %i)" % (self.start, self.end) # <<<<<<<<<<<<<< * * def __cinit__(IntervalNode self, int start, int end, object interval): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_IntervalNode_i_i, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":89 * return self.croot if self.croot is not EmptyNode else None * * def __repr__(self): # <<<<<<<<<<<<<< * return "IntervalNode(%i, %i)" % (self.start, self.end) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":92 * return "IntervalNode(%i, %i)" % (self.start, self.end) * * def __cinit__(IntervalNode self, int start, int end, object interval): # <<<<<<<<<<<<<< * # Python lacks the binomial distribution, so we convert a * # uniform into a binomial because it naturally scales with */ /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; PyObject *__pyx_v_interval = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_interval,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 1); __PYX_ERR(1, 92, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, 2); __PYX_ERR(1, 92, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 92, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 92, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 92, __pyx_L3_error) __pyx_v_interval = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 92, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_2__cinit__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_interval); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_2__cinit__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval) { int __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; double __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "skbio/metadata/_intersection.pyx":97 * # tree size. Also, python's uniform is perfect since the * # upper limit is not inclusive, which gives us undefined here. * self.priority = ceil(nlog * log(-1.0/(1.0 * rand()/RAND_MAX - 1))) # <<<<<<<<<<<<<< * self.start = start * self.end = end */ __pyx_t_1 = (1.0 * rand()); if (unlikely(RAND_MAX == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(1, 97, __pyx_L1_error) } __pyx_t_2 = ((__pyx_t_1 / RAND_MAX) - 1.0); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(1, 97, __pyx_L1_error) } __pyx_v_self->priority = ceil((__pyx_v_5skbio_8metadata_13_intersection_nlog * log((-1.0 / __pyx_t_2)))); /* "skbio/metadata/_intersection.pyx":98 * # upper limit is not inclusive, which gives us undefined here. * self.priority = ceil(nlog * log(-1.0/(1.0 * rand()/RAND_MAX - 1))) * self.start = start # <<<<<<<<<<<<<< * self.end = end * self.interval = interval */ __pyx_v_self->start = __pyx_v_start; /* "skbio/metadata/_intersection.pyx":99 * self.priority = ceil(nlog * log(-1.0/(1.0 * rand()/RAND_MAX - 1))) * self.start = start * self.end = end # <<<<<<<<<<<<<< * self.interval = interval * self.maxend = end */ __pyx_v_self->end = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":100 * self.start = start * self.end = end * self.interval = interval # <<<<<<<<<<<<<< * self.maxend = end * self.minstart = start */ __Pyx_INCREF(__pyx_v_interval); __Pyx_GIVEREF(__pyx_v_interval); __Pyx_GOTREF(__pyx_v_self->interval); __Pyx_DECREF(__pyx_v_self->interval); __pyx_v_self->interval = __pyx_v_interval; /* "skbio/metadata/_intersection.pyx":101 * self.end = end * self.interval = interval * self.maxend = end # <<<<<<<<<<<<<< * self.minstart = start * self.minend = end */ __pyx_v_self->maxend = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":102 * self.interval = interval * self.maxend = end * self.minstart = start # <<<<<<<<<<<<<< * self.minend = end * self.cleft = EmptyNode */ __pyx_v_self->minstart = __pyx_v_start; /* "skbio/metadata/_intersection.pyx":103 * self.maxend = end * self.minstart = start * self.minend = end # <<<<<<<<<<<<<< * self.cleft = EmptyNode * self.cright = EmptyNode */ __pyx_v_self->minend = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":104 * self.minstart = start * self.minend = end * self.cleft = EmptyNode # <<<<<<<<<<<<<< * self.cright = EmptyNode * self.croot = EmptyNode */ __Pyx_INCREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GIVEREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GOTREF(__pyx_v_self->cleft); __Pyx_DECREF(((PyObject *)__pyx_v_self->cleft)); __pyx_v_self->cleft = __pyx_v_5skbio_8metadata_13_intersection_EmptyNode; /* "skbio/metadata/_intersection.pyx":105 * self.minend = end * self.cleft = EmptyNode * self.cright = EmptyNode # <<<<<<<<<<<<<< * self.croot = EmptyNode * */ __Pyx_INCREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GIVEREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GOTREF(__pyx_v_self->cright); __Pyx_DECREF(((PyObject *)__pyx_v_self->cright)); __pyx_v_self->cright = __pyx_v_5skbio_8metadata_13_intersection_EmptyNode; /* "skbio/metadata/_intersection.pyx":106 * self.cleft = EmptyNode * self.cright = EmptyNode * self.croot = EmptyNode # <<<<<<<<<<<<<< * * cpdef IntervalNode insert(IntervalNode self, int start, int end, object interval): */ __Pyx_INCREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GIVEREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_GOTREF(__pyx_v_self->croot); __Pyx_DECREF(((PyObject *)__pyx_v_self->croot)); __pyx_v_self->croot = __pyx_v_5skbio_8metadata_13_intersection_EmptyNode; /* "skbio/metadata/_intersection.pyx":92 * return "IntervalNode(%i, %i)" % (self.start, self.end) * * def __cinit__(IntervalNode self, int start, int end, object interval): # <<<<<<<<<<<<<< * # Python lacks the binomial distribution, so we convert a * # uniform into a binomial because it naturally scales with */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":108 * self.croot = EmptyNode * * cpdef IntervalNode insert(IntervalNode self, int start, int end, object interval): # <<<<<<<<<<<<<< * """ * Insert a new IntervalNode into the tree of which this node is */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5insert(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval, int __pyx_skip_dispatch) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_croot = 0; int __pyx_v_decision_endpoint; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("insert", 0); /* Check if called by wrapper */ if (unlikely(__pyx_skip_dispatch)) ; /* Check if overridden in Python */ else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_insert); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5insert)) { __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_3, __pyx_t_4, __pyx_v_interval}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_t_3, __pyx_t_4, __pyx_v_interval}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_v_interval); __Pyx_GIVEREF(__pyx_v_interval); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_v_interval); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode))))) __PYX_ERR(1, 108, __pyx_L1_error) __pyx_r = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "skbio/metadata/_intersection.pyx":114 * may or may not be this node!) * """ * cdef IntervalNode croot = self # <<<<<<<<<<<<<< * # If starts are the same, decide which to add interval to based on * # end, thus maintaining sortedness relative to start/end */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_v_croot = __pyx_v_self; /* "skbio/metadata/_intersection.pyx":117 * # If starts are the same, decide which to add interval to based on * # end, thus maintaining sortedness relative to start/end * cdef int decision_endpoint = start # <<<<<<<<<<<<<< * if start == self.start: * decision_endpoint = end */ __pyx_v_decision_endpoint = __pyx_v_start; /* "skbio/metadata/_intersection.pyx":118 * # end, thus maintaining sortedness relative to start/end * cdef int decision_endpoint = start * if start == self.start: # <<<<<<<<<<<<<< * decision_endpoint = end * */ __pyx_t_9 = ((__pyx_v_start == __pyx_v_self->start) != 0); if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":119 * cdef int decision_endpoint = start * if start == self.start: * decision_endpoint = end # <<<<<<<<<<<<<< * * if decision_endpoint > self.start: */ __pyx_v_decision_endpoint = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":118 * # end, thus maintaining sortedness relative to start/end * cdef int decision_endpoint = start * if start == self.start: # <<<<<<<<<<<<<< * decision_endpoint = end * */ } /* "skbio/metadata/_intersection.pyx":121 * decision_endpoint = end * * if decision_endpoint > self.start: # <<<<<<<<<<<<<< * # insert to cright tree * if self.cright is not EmptyNode: */ __pyx_t_9 = ((__pyx_v_decision_endpoint > __pyx_v_self->start) != 0); if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":123 * if decision_endpoint > self.start: * # insert to cright tree * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright = self.cright.insert( start, end, interval ) * else: */ __pyx_t_9 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_10 = (__pyx_t_9 != 0); if (__pyx_t_10) { /* "skbio/metadata/_intersection.pyx":124 * # insert to cright tree * if self.cright is not EmptyNode: * self.cright = self.cright.insert( start, end, interval ) # <<<<<<<<<<<<<< * else: * self.cright = IntervalNode( start, end, interval ) */ __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->insert(__pyx_v_self->cright, __pyx_v_start, __pyx_v_end, __pyx_v_interval, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->cright); __Pyx_DECREF(((PyObject *)__pyx_v_self->cright)); __pyx_v_self->cright = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":123 * if decision_endpoint > self.start: * # insert to cright tree * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright = self.cright.insert( start, end, interval ) * else: */ goto __pyx_L5; } /* "skbio/metadata/_intersection.pyx":126 * self.cright = self.cright.insert( start, end, interval ) * else: * self.cright = IntervalNode( start, end, interval ) # <<<<<<<<<<<<<< * # rebalance tree * if self.priority < self.cright.priority: */ /*else*/ { __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_end); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); __Pyx_INCREF(__pyx_v_interval); __Pyx_GIVEREF(__pyx_v_interval); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_interval); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode), __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->cright); __Pyx_DECREF(((PyObject *)__pyx_v_self->cright)); __pyx_v_self->cright = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_2); __pyx_t_2 = 0; } __pyx_L5:; /* "skbio/metadata/_intersection.pyx":128 * self.cright = IntervalNode( start, end, interval ) * # rebalance tree * if self.priority < self.cright.priority: # <<<<<<<<<<<<<< * croot = self.rotate_left() * else: */ __pyx_t_10 = ((__pyx_v_self->priority < __pyx_v_self->cright->priority) != 0); if (__pyx_t_10) { /* "skbio/metadata/_intersection.pyx":129 * # rebalance tree * if self.priority < self.cright.priority: * croot = self.rotate_left() # <<<<<<<<<<<<<< * else: * # insert to cleft tree */ __pyx_t_2 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->rotate_left(__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 129, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_croot, ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_2)); __pyx_t_2 = 0; /* "skbio/metadata/_intersection.pyx":128 * self.cright = IntervalNode( start, end, interval ) * # rebalance tree * if self.priority < self.cright.priority: # <<<<<<<<<<<<<< * croot = self.rotate_left() * else: */ } /* "skbio/metadata/_intersection.pyx":121 * decision_endpoint = end * * if decision_endpoint > self.start: # <<<<<<<<<<<<<< * # insert to cright tree * if self.cright is not EmptyNode: */ goto __pyx_L4; } /* "skbio/metadata/_intersection.pyx":132 * else: * # insert to cleft tree * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft = self.cleft.insert( start, end, interval) * else: */ /*else*/ { __pyx_t_10 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":133 * # insert to cleft tree * if self.cleft is not EmptyNode: * self.cleft = self.cleft.insert( start, end, interval) # <<<<<<<<<<<<<< * else: * self.cleft = IntervalNode( start, end, interval) */ __pyx_t_2 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->insert(__pyx_v_self->cleft, __pyx_v_start, __pyx_v_end, __pyx_v_interval, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->cleft); __Pyx_DECREF(((PyObject *)__pyx_v_self->cleft)); __pyx_v_self->cleft = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_2); __pyx_t_2 = 0; /* "skbio/metadata/_intersection.pyx":132 * else: * # insert to cleft tree * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft = self.cleft.insert( start, end, interval) * else: */ goto __pyx_L7; } /* "skbio/metadata/_intersection.pyx":135 * self.cleft = self.cleft.insert( start, end, interval) * else: * self.cleft = IntervalNode( start, end, interval) # <<<<<<<<<<<<<< * # rebalance tree * if self.priority < self.cleft.priority: */ /*else*/ { __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_end); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __Pyx_INCREF(__pyx_v_interval); __Pyx_GIVEREF(__pyx_v_interval); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_interval); __pyx_t_2 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode), __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __Pyx_GOTREF(__pyx_v_self->cleft); __Pyx_DECREF(((PyObject *)__pyx_v_self->cleft)); __pyx_v_self->cleft = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_5); __pyx_t_5 = 0; } __pyx_L7:; /* "skbio/metadata/_intersection.pyx":137 * self.cleft = IntervalNode( start, end, interval) * # rebalance tree * if self.priority < self.cleft.priority: # <<<<<<<<<<<<<< * croot = self.rotate_right() * */ __pyx_t_9 = ((__pyx_v_self->priority < __pyx_v_self->cleft->priority) != 0); if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":138 * # rebalance tree * if self.priority < self.cleft.priority: * croot = self.rotate_right() # <<<<<<<<<<<<<< * * croot.set_ends() */ __pyx_t_5 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->rotate_right(__pyx_v_self)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_croot, ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_5)); __pyx_t_5 = 0; /* "skbio/metadata/_intersection.pyx":137 * self.cleft = IntervalNode( start, end, interval) * # rebalance tree * if self.priority < self.cleft.priority: # <<<<<<<<<<<<<< * croot = self.rotate_right() * */ } } __pyx_L4:; /* "skbio/metadata/_intersection.pyx":140 * croot = self.rotate_right() * * croot.set_ends() # <<<<<<<<<<<<<< * self.cleft.croot = croot * self.cright.croot = croot */ __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(__pyx_v_croot); /* "skbio/metadata/_intersection.pyx":141 * * croot.set_ends() * self.cleft.croot = croot # <<<<<<<<<<<<<< * self.cright.croot = croot * return croot */ __Pyx_INCREF(((PyObject *)__pyx_v_croot)); __Pyx_GIVEREF(((PyObject *)__pyx_v_croot)); __Pyx_GOTREF(__pyx_v_self->cleft->croot); __Pyx_DECREF(((PyObject *)__pyx_v_self->cleft->croot)); __pyx_v_self->cleft->croot = __pyx_v_croot; /* "skbio/metadata/_intersection.pyx":142 * croot.set_ends() * self.cleft.croot = croot * self.cright.croot = croot # <<<<<<<<<<<<<< * return croot * */ __Pyx_INCREF(((PyObject *)__pyx_v_croot)); __Pyx_GIVEREF(((PyObject *)__pyx_v_croot)); __Pyx_GOTREF(__pyx_v_self->cright->croot); __Pyx_DECREF(((PyObject *)__pyx_v_self->cright->croot)); __pyx_v_self->cright->croot = __pyx_v_croot; /* "skbio/metadata/_intersection.pyx":143 * self.cleft.croot = croot * self.cright.croot = croot * return croot # <<<<<<<<<<<<<< * * cdef IntervalNode rotate_right(IntervalNode self): */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_croot)); __pyx_r = __pyx_v_croot; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":108 * self.croot = EmptyNode * * cpdef IntervalNode insert(IntervalNode self, int start, int end, object interval): # <<<<<<<<<<<<<< * """ * Insert a new IntervalNode into the tree of which this node is */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.insert", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_croot); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5insert(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_4insert[] = "\n Insert a new IntervalNode into the tree of which this node is\n currently the root. The return value is the new root of the tree (which\n may or may not be this node!)\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5insert(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; PyObject *__pyx_v_interval = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("insert (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_interval,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("insert", 1, 3, 3, 1); __PYX_ERR(1, 108, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("insert", 1, 3, 3, 2); __PYX_ERR(1, 108, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "insert") < 0)) __PYX_ERR(1, 108, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 108, __pyx_L3_error) __pyx_v_interval = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("insert", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 108, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.insert", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_4insert(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_interval); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_4insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_interval) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("insert", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_insert(__pyx_v_self, __pyx_v_start, __pyx_v_end, __pyx_v_interval, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.insert", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":145 * return croot * * cdef IntervalNode rotate_right(IntervalNode self): # <<<<<<<<<<<<<< * cdef IntervalNode croot = self.cleft * self.cleft = self.cleft.cright */ static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_croot = 0; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("rotate_right", 0); /* "skbio/metadata/_intersection.pyx":146 * * cdef IntervalNode rotate_right(IntervalNode self): * cdef IntervalNode croot = self.cleft # <<<<<<<<<<<<<< * self.cleft = self.cleft.cright * croot.cright = self */ __pyx_t_1 = ((PyObject *)__pyx_v_self->cleft); __Pyx_INCREF(__pyx_t_1); __pyx_v_croot = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":147 * cdef IntervalNode rotate_right(IntervalNode self): * cdef IntervalNode croot = self.cleft * self.cleft = self.cleft.cright # <<<<<<<<<<<<<< * croot.cright = self * self.set_ends() */ __pyx_t_1 = ((PyObject *)__pyx_v_self->cleft->cright); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->cleft); __Pyx_DECREF(((PyObject *)__pyx_v_self->cleft)); __pyx_v_self->cleft = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":148 * cdef IntervalNode croot = self.cleft * self.cleft = self.cleft.cright * croot.cright = self # <<<<<<<<<<<<<< * self.set_ends() * return croot */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_croot->cright); __Pyx_DECREF(((PyObject *)__pyx_v_croot->cright)); __pyx_v_croot->cright = __pyx_v_self; /* "skbio/metadata/_intersection.pyx":149 * self.cleft = self.cleft.cright * croot.cright = self * self.set_ends() # <<<<<<<<<<<<<< * return croot * */ __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(__pyx_v_self); /* "skbio/metadata/_intersection.pyx":150 * croot.cright = self * self.set_ends() * return croot # <<<<<<<<<<<<<< * * cdef IntervalNode rotate_left(IntervalNode self): */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_croot)); __pyx_r = __pyx_v_croot; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":145 * return croot * * cdef IntervalNode rotate_right(IntervalNode self): # <<<<<<<<<<<<<< * cdef IntervalNode croot = self.cleft * self.cleft = self.cleft.cright */ /* function exit code */ __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_croot); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":152 * return croot * * cdef IntervalNode rotate_left(IntervalNode self): # <<<<<<<<<<<<<< * cdef IntervalNode croot = self.cright * self.cright = self.cright.cleft */ static struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_croot = 0; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("rotate_left", 0); /* "skbio/metadata/_intersection.pyx":153 * * cdef IntervalNode rotate_left(IntervalNode self): * cdef IntervalNode croot = self.cright # <<<<<<<<<<<<<< * self.cright = self.cright.cleft * croot.cleft = self */ __pyx_t_1 = ((PyObject *)__pyx_v_self->cright); __Pyx_INCREF(__pyx_t_1); __pyx_v_croot = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":154 * cdef IntervalNode rotate_left(IntervalNode self): * cdef IntervalNode croot = self.cright * self.cright = self.cright.cleft # <<<<<<<<<<<<<< * croot.cleft = self * self.set_ends() */ __pyx_t_1 = ((PyObject *)__pyx_v_self->cright->cleft); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->cright); __Pyx_DECREF(((PyObject *)__pyx_v_self->cright)); __pyx_v_self->cright = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":155 * cdef IntervalNode croot = self.cright * self.cright = self.cright.cleft * croot.cleft = self # <<<<<<<<<<<<<< * self.set_ends() * return croot */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_croot->cleft); __Pyx_DECREF(((PyObject *)__pyx_v_croot->cleft)); __pyx_v_croot->cleft = __pyx_v_self; /* "skbio/metadata/_intersection.pyx":156 * self.cright = self.cright.cleft * croot.cleft = self * self.set_ends() # <<<<<<<<<<<<<< * return croot * */ __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(__pyx_v_self); /* "skbio/metadata/_intersection.pyx":157 * croot.cleft = self * self.set_ends() * return croot # <<<<<<<<<<<<<< * * cdef inline void set_ends(IntervalNode self): */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_croot)); __pyx_r = __pyx_v_croot; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":152 * return croot * * cdef IntervalNode rotate_left(IntervalNode self): # <<<<<<<<<<<<<< * cdef IntervalNode croot = self.cright * self.cright = self.cright.cleft */ /* function exit code */ __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_croot); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":159 * return croot * * cdef inline void set_ends(IntervalNode self): # <<<<<<<<<<<<<< * if self.cright is not EmptyNode and self.cleft is not EmptyNode: * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) */ static CYTHON_INLINE void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; __Pyx_RefNannySetupContext("set_ends", 0); /* "skbio/metadata/_intersection.pyx":160 * * cdef inline void set_ends(IntervalNode self): * if self.cright is not EmptyNode and self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) */ __pyx_t_2 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_3 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":161 * cdef inline void set_ends(IntervalNode self): * if self.cright is not EmptyNode and self.cleft is not EmptyNode: * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) # <<<<<<<<<<<<<< * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) */ __pyx_v_self->maxend = __pyx_f_5skbio_8metadata_13_intersection_imax3(__pyx_v_self->end, __pyx_v_self->cright->maxend, __pyx_v_self->cleft->maxend); /* "skbio/metadata/_intersection.pyx":162 * if self.cright is not EmptyNode and self.cleft is not EmptyNode: * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) # <<<<<<<<<<<<<< * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) * elif self.cright is not EmptyNode: */ __pyx_v_self->minend = __pyx_f_5skbio_8metadata_13_intersection_imin3(__pyx_v_self->end, __pyx_v_self->cright->minend, __pyx_v_self->cleft->minend); /* "skbio/metadata/_intersection.pyx":163 * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) # <<<<<<<<<<<<<< * elif self.cright is not EmptyNode: * self.maxend = imax2(self.end, self.cright.maxend) */ __pyx_v_self->minstart = __pyx_f_5skbio_8metadata_13_intersection_imin3(__pyx_v_self->start, __pyx_v_self->cright->minstart, __pyx_v_self->cleft->minstart); /* "skbio/metadata/_intersection.pyx":160 * * cdef inline void set_ends(IntervalNode self): * if self.cright is not EmptyNode and self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) */ goto __pyx_L3; } /* "skbio/metadata/_intersection.pyx":164 * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) * elif self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax2(self.end, self.cright.maxend) * self.minend = imin2(self.end, self.cright.minend) */ __pyx_t_1 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":165 * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) * elif self.cright is not EmptyNode: * self.maxend = imax2(self.end, self.cright.maxend) # <<<<<<<<<<<<<< * self.minend = imin2(self.end, self.cright.minend) * self.minstart = imin2(self.start, self.cright.minstart) */ __pyx_v_self->maxend = __pyx_f_5skbio_8metadata_13_intersection_imax2(__pyx_v_self->end, __pyx_v_self->cright->maxend); /* "skbio/metadata/_intersection.pyx":166 * elif self.cright is not EmptyNode: * self.maxend = imax2(self.end, self.cright.maxend) * self.minend = imin2(self.end, self.cright.minend) # <<<<<<<<<<<<<< * self.minstart = imin2(self.start, self.cright.minstart) * elif self.cleft is not EmptyNode: */ __pyx_v_self->minend = __pyx_f_5skbio_8metadata_13_intersection_imin2(__pyx_v_self->end, __pyx_v_self->cright->minend); /* "skbio/metadata/_intersection.pyx":167 * self.maxend = imax2(self.end, self.cright.maxend) * self.minend = imin2(self.end, self.cright.minend) * self.minstart = imin2(self.start, self.cright.minstart) # <<<<<<<<<<<<<< * elif self.cleft is not EmptyNode: * self.maxend = imax2(self.end, self.cleft.maxend) */ __pyx_v_self->minstart = __pyx_f_5skbio_8metadata_13_intersection_imin2(__pyx_v_self->start, __pyx_v_self->cright->minstart); /* "skbio/metadata/_intersection.pyx":164 * self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) * self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) * elif self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax2(self.end, self.cright.maxend) * self.minend = imin2(self.end, self.cright.minend) */ goto __pyx_L3; } /* "skbio/metadata/_intersection.pyx":168 * self.minend = imin2(self.end, self.cright.minend) * self.minstart = imin2(self.start, self.cright.minstart) * elif self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax2(self.end, self.cleft.maxend) * self.minend = imin2(self.end, self.cleft.minend) */ __pyx_t_2 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":169 * self.minstart = imin2(self.start, self.cright.minstart) * elif self.cleft is not EmptyNode: * self.maxend = imax2(self.end, self.cleft.maxend) # <<<<<<<<<<<<<< * self.minend = imin2(self.end, self.cleft.minend) * self.minstart = imin2(self.start, self.cleft.minstart) */ __pyx_v_self->maxend = __pyx_f_5skbio_8metadata_13_intersection_imax2(__pyx_v_self->end, __pyx_v_self->cleft->maxend); /* "skbio/metadata/_intersection.pyx":170 * elif self.cleft is not EmptyNode: * self.maxend = imax2(self.end, self.cleft.maxend) * self.minend = imin2(self.end, self.cleft.minend) # <<<<<<<<<<<<<< * self.minstart = imin2(self.start, self.cleft.minstart) * */ __pyx_v_self->minend = __pyx_f_5skbio_8metadata_13_intersection_imin2(__pyx_v_self->end, __pyx_v_self->cleft->minend); /* "skbio/metadata/_intersection.pyx":171 * self.maxend = imax2(self.end, self.cleft.maxend) * self.minend = imin2(self.end, self.cleft.minend) * self.minstart = imin2(self.start, self.cleft.minstart) # <<<<<<<<<<<<<< * * def intersect( self, int start, int end, sort=True ): */ __pyx_v_self->minstart = __pyx_f_5skbio_8metadata_13_intersection_imin2(__pyx_v_self->start, __pyx_v_self->cleft->minstart); /* "skbio/metadata/_intersection.pyx":168 * self.minend = imin2(self.end, self.cright.minend) * self.minstart = imin2(self.start, self.cright.minstart) * elif self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.maxend = imax2(self.end, self.cleft.maxend) * self.minend = imin2(self.end, self.cleft.minend) */ } __pyx_L3:; /* "skbio/metadata/_intersection.pyx":159 * return croot * * cdef inline void set_ends(IntervalNode self): # <<<<<<<<<<<<<< * if self.cright is not EmptyNode and self.cleft is not EmptyNode: * self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "skbio/metadata/_intersection.pyx":173 * self.minstart = imin2(self.start, self.cleft.minstart) * * def intersect( self, int start, int end, sort=True ): # <<<<<<<<<<<<<< * """ * given a start and a end, return a list of features */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_7intersect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_6intersect[] = "\n given a start and a end, return a list of features\n falling within that range\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_7intersect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; CYTHON_UNUSED PyObject *__pyx_v_sort = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("intersect (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_sort,0}; PyObject* values[3] = {0,0,0}; values[2] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 3, 1); __PYX_ERR(1, 173, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sort); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "intersect") < 0)) __PYX_ERR(1, 173, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 173, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 173, __pyx_L3_error) __pyx_v_sort = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 173, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_6intersect(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_sort); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_6intersect(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, CYTHON_UNUSED PyObject *__pyx_v_sort) { PyObject *__pyx_v_results = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("intersect", 0); /* "skbio/metadata/_intersection.pyx":178 * falling within that range * """ * cdef list results = [] # <<<<<<<<<<<<<< * self._intersect( start, end, results ) * return results */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_results = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":179 * """ * cdef list results = [] * self._intersect( start, end, results ) # <<<<<<<<<<<<<< * return results * */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->_intersect(__pyx_v_self, __pyx_v_start, __pyx_v_end, __pyx_v_results); /* "skbio/metadata/_intersection.pyx":180 * cdef list results = [] * self._intersect( start, end, results ) * return results # <<<<<<<<<<<<<< * * find = intersect */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":173 * self.minstart = imin2(self.start, self.cleft.minstart) * * def intersect( self, int start, int end, sort=True ): # <<<<<<<<<<<<<< * """ * given a start and a end, return a list of features */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_results); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":184 * find = intersect * * cdef void _intersect( IntervalNode self, int start, int end, list results): # <<<<<<<<<<<<<< * cdef int send, qend * */ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__intersect(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_results) { int __pyx_v_send; int __pyx_v_qend; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_intersect", 0); /* "skbio/metadata/_intersection.pyx":188 * * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend >= start: # <<<<<<<<<<<<<< * self.cleft._intersect( start, end, results ) * # This interval */ __pyx_t_2 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = ((__pyx_v_self->cleft->maxend >= __pyx_v_start) != 0); __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":189 * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend >= start: * self.cleft._intersect( start, end, results ) # <<<<<<<<<<<<<< * # This interval * if start == end: */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->_intersect(__pyx_v_self->cleft, __pyx_v_start, __pyx_v_end, __pyx_v_results); /* "skbio/metadata/_intersection.pyx":188 * * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend >= start: # <<<<<<<<<<<<<< * self.cleft._intersect( start, end, results ) * # This interval */ } /* "skbio/metadata/_intersection.pyx":191 * self.cleft._intersect( start, end, results ) * # This interval * if start == end: # <<<<<<<<<<<<<< * qend = end * else: */ __pyx_t_1 = ((__pyx_v_start == __pyx_v_end) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":192 * # This interval * if start == end: * qend = end # <<<<<<<<<<<<<< * else: * qend = end - 1 */ __pyx_v_qend = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":191 * self.cleft._intersect( start, end, results ) * # This interval * if start == end: # <<<<<<<<<<<<<< * qend = end * else: */ goto __pyx_L6; } /* "skbio/metadata/_intersection.pyx":194 * qend = end * else: * qend = end - 1 # <<<<<<<<<<<<<< * if self.end == self.start: * send = self.end */ /*else*/ { __pyx_v_qend = (__pyx_v_end - 1); } __pyx_L6:; /* "skbio/metadata/_intersection.pyx":195 * else: * qend = end - 1 * if self.end == self.start: # <<<<<<<<<<<<<< * send = self.end * else: */ __pyx_t_1 = ((__pyx_v_self->end == __pyx_v_self->start) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":196 * qend = end - 1 * if self.end == self.start: * send = self.end # <<<<<<<<<<<<<< * else: * send = self.end - 1 */ __pyx_t_4 = __pyx_v_self->end; __pyx_v_send = __pyx_t_4; /* "skbio/metadata/_intersection.pyx":195 * else: * qend = end - 1 * if self.end == self.start: # <<<<<<<<<<<<<< * send = self.end * else: */ goto __pyx_L7; } /* "skbio/metadata/_intersection.pyx":198 * send = self.end * else: * send = self.end - 1 # <<<<<<<<<<<<<< * if ( send >= start ) and ( self.start <= qend ): * results.append( self.interval ) */ /*else*/ { __pyx_v_send = (__pyx_v_self->end - 1); } __pyx_L7:; /* "skbio/metadata/_intersection.pyx":199 * else: * send = self.end - 1 * if ( send >= start ) and ( self.start <= qend ): # <<<<<<<<<<<<<< * results.append( self.interval ) * # Right subtree */ __pyx_t_3 = ((__pyx_v_send >= __pyx_v_start) != 0); if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L9_bool_binop_done; } __pyx_t_3 = ((__pyx_v_self->start <= __pyx_v_qend) != 0); __pyx_t_1 = __pyx_t_3; __pyx_L9_bool_binop_done:; if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":200 * send = self.end - 1 * if ( send >= start ) and ( self.start <= qend ): * results.append( self.interval ) # <<<<<<<<<<<<<< * # Right subtree * if self.cright is not EmptyNode and self.start <= qend: */ if (unlikely(__pyx_v_results == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(1, 200, __pyx_L1_error) } __pyx_t_5 = __pyx_v_self->interval; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_results, __pyx_t_5); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 200, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "skbio/metadata/_intersection.pyx":199 * else: * send = self.end - 1 * if ( send >= start ) and ( self.start <= qend ): # <<<<<<<<<<<<<< * results.append( self.interval ) * # Right subtree */ } /* "skbio/metadata/_intersection.pyx":202 * results.append( self.interval ) * # Right subtree * if self.cright is not EmptyNode and self.start <= qend: # <<<<<<<<<<<<<< * self.cright._intersect( start, end, results ) * */ __pyx_t_3 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L12_bool_binop_done; } __pyx_t_2 = ((__pyx_v_self->start <= __pyx_v_qend) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L12_bool_binop_done:; if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":203 * # Right subtree * if self.cright is not EmptyNode and self.start <= qend: * self.cright._intersect( start, end, results ) # <<<<<<<<<<<<<< * * cpdef void update(IntervalNode self, int start, int end, */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->_intersect(__pyx_v_self->cright, __pyx_v_start, __pyx_v_end, __pyx_v_results); /* "skbio/metadata/_intersection.pyx":202 * results.append( self.interval ) * # Right subtree * if self.cright is not EmptyNode and self.start <= qend: # <<<<<<<<<<<<<< * self.cright._intersect( start, end, results ) * */ } /* "skbio/metadata/_intersection.pyx":184 * find = intersect * * cdef void _intersect( IntervalNode self, int start, int end, list results): # <<<<<<<<<<<<<< * cdef int send, qend * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("skbio.metadata._intersection.IntervalNode._intersect", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "skbio/metadata/_intersection.pyx":205 * self.cright._intersect( start, end, results ) * * cpdef void update(IntervalNode self, int start, int end, # <<<<<<<<<<<<<< * object old_feature, object new_feature): * """ */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9update(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature, int __pyx_skip_dispatch) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update", 0); /* Check if called by wrapper */ if (unlikely(__pyx_skip_dispatch)) ; /* Check if overridden in Python */ else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_update); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9update)) { __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_6, __pyx_t_3, __pyx_t_4, __pyx_v_old_feature, __pyx_v_new_feature}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_6, __pyx_t_3, __pyx_t_4, __pyx_v_old_feature, __pyx_v_new_feature}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_8 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_v_old_feature); __Pyx_GIVEREF(__pyx_v_old_feature); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_v_old_feature); __Pyx_INCREF(__pyx_v_new_feature); __Pyx_GIVEREF(__pyx_v_new_feature); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_7, __pyx_v_new_feature); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "skbio/metadata/_intersection.pyx":213 * * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend > start: # <<<<<<<<<<<<<< * self.cleft.update( start, end, old_feature, new_feature ) * # This interval */ __pyx_t_10 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_11 = (__pyx_t_10 != 0); if (__pyx_t_11) { } else { __pyx_t_9 = __pyx_t_11; goto __pyx_L4_bool_binop_done; } __pyx_t_11 = ((__pyx_v_self->cleft->maxend > __pyx_v_start) != 0); __pyx_t_9 = __pyx_t_11; __pyx_L4_bool_binop_done:; if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":214 * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend > start: * self.cleft.update( start, end, old_feature, new_feature ) # <<<<<<<<<<<<<< * # This interval * if ( self.end > start ) and ( self.start < end ): */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->update(__pyx_v_self->cleft, __pyx_v_start, __pyx_v_end, __pyx_v_old_feature, __pyx_v_new_feature, 0); /* "skbio/metadata/_intersection.pyx":213 * * # Left subtree * if self.cleft is not EmptyNode and self.cleft.maxend > start: # <<<<<<<<<<<<<< * self.cleft.update( start, end, old_feature, new_feature ) * # This interval */ } /* "skbio/metadata/_intersection.pyx":216 * self.cleft.update( start, end, old_feature, new_feature ) * # This interval * if ( self.end > start ) and ( self.start < end ): # <<<<<<<<<<<<<< * if self.interval == old_feature: * self.interval = new_feature */ __pyx_t_11 = ((__pyx_v_self->end > __pyx_v_start) != 0); if (__pyx_t_11) { } else { __pyx_t_9 = __pyx_t_11; goto __pyx_L7_bool_binop_done; } __pyx_t_11 = ((__pyx_v_self->start < __pyx_v_end) != 0); __pyx_t_9 = __pyx_t_11; __pyx_L7_bool_binop_done:; if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":217 * # This interval * if ( self.end > start ) and ( self.start < end ): * if self.interval == old_feature: # <<<<<<<<<<<<<< * self.interval = new_feature * # Right subtree */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_self->interval, __pyx_v_old_feature, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 217, __pyx_L1_error) __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(1, 217, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":218 * if ( self.end > start ) and ( self.start < end ): * if self.interval == old_feature: * self.interval = new_feature # <<<<<<<<<<<<<< * # Right subtree * if self.cright is not EmptyNode and self.start < end: */ __Pyx_INCREF(__pyx_v_new_feature); __Pyx_GIVEREF(__pyx_v_new_feature); __Pyx_GOTREF(__pyx_v_self->interval); __Pyx_DECREF(__pyx_v_self->interval); __pyx_v_self->interval = __pyx_v_new_feature; /* "skbio/metadata/_intersection.pyx":217 * # This interval * if ( self.end > start ) and ( self.start < end ): * if self.interval == old_feature: # <<<<<<<<<<<<<< * self.interval = new_feature * # Right subtree */ } /* "skbio/metadata/_intersection.pyx":216 * self.cleft.update( start, end, old_feature, new_feature ) * # This interval * if ( self.end > start ) and ( self.start < end ): # <<<<<<<<<<<<<< * if self.interval == old_feature: * self.interval = new_feature */ } /* "skbio/metadata/_intersection.pyx":220 * self.interval = new_feature * # Right subtree * if self.cright is not EmptyNode and self.start < end: # <<<<<<<<<<<<<< * self.cright.update( start, end, old_feature, new_feature ) * */ __pyx_t_11 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_10 = (__pyx_t_11 != 0); if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L11_bool_binop_done; } __pyx_t_10 = ((__pyx_v_self->start < __pyx_v_end) != 0); __pyx_t_9 = __pyx_t_10; __pyx_L11_bool_binop_done:; if (__pyx_t_9) { /* "skbio/metadata/_intersection.pyx":221 * # Right subtree * if self.cright is not EmptyNode and self.start < end: * self.cright.update( start, end, old_feature, new_feature ) # <<<<<<<<<<<<<< * * cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->update(__pyx_v_self->cright, __pyx_v_start, __pyx_v_end, __pyx_v_old_feature, __pyx_v_new_feature, 0); /* "skbio/metadata/_intersection.pyx":220 * self.interval = new_feature * # Right subtree * if self.cright is not EmptyNode and self.start < end: # <<<<<<<<<<<<<< * self.cright.update( start, end, old_feature, new_feature ) * */ } /* "skbio/metadata/_intersection.pyx":205 * self.cright._intersect( start, end, results ) * * cpdef void update(IntervalNode self, int start, int end, # <<<<<<<<<<<<<< * object old_feature, object new_feature): * """ */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_WriteUnraisable("skbio.metadata._intersection.IntervalNode.update", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9update(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_8update[] = "\n given a start and end, replace all objects that\n match the old_feature with new_feature.\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9update(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; PyObject *__pyx_v_old_feature = 0; PyObject *__pyx_v_new_feature = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("update (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_old_feature,&__pyx_n_s_new_feature,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 1); __PYX_ERR(1, 205, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_old_feature)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 2); __PYX_ERR(1, 205, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_feature)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 3); __PYX_ERR(1, 205, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update") < 0)) __PYX_ERR(1, 205, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 205, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 205, __pyx_L3_error) __pyx_v_old_feature = values[2]; __pyx_v_new_feature = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 205, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8update(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_old_feature, __pyx_v_new_feature); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_void_to_None(__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_update(__pyx_v_self, __pyx_v_start, __pyx_v_end, __pyx_v_old_feature, __pyx_v_new_feature, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":223 * self.cright.update( start, end, old_feature, new_feature ) * * cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): # <<<<<<<<<<<<<< * # we know we can bail in these 2 cases. * if self.maxend + max_dist < position: */ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_position, PyObject *__pyx_v_results, int __pyx_v_n, int __pyx_v_max_dist) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_seek_left", 0); /* "skbio/metadata/_intersection.pyx":225 * cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): * # we know we can bail in these 2 cases. * if self.maxend + max_dist < position: # <<<<<<<<<<<<<< * return * if self.minstart > position: */ __pyx_t_1 = (((__pyx_v_self->maxend + __pyx_v_max_dist) < __pyx_v_position) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":226 * # we know we can bail in these 2 cases. * if self.maxend + max_dist < position: * return # <<<<<<<<<<<<<< * if self.minstart > position: * return */ goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":225 * cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): * # we know we can bail in these 2 cases. * if self.maxend + max_dist < position: # <<<<<<<<<<<<<< * return * if self.minstart > position: */ } /* "skbio/metadata/_intersection.pyx":227 * if self.maxend + max_dist < position: * return * if self.minstart > position: # <<<<<<<<<<<<<< * return * */ __pyx_t_1 = ((__pyx_v_self->minstart > __pyx_v_position) != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":228 * return * if self.minstart > position: * return # <<<<<<<<<<<<<< * * # the ordering of these 3 blocks makes it so the results are */ goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":227 * if self.maxend + max_dist < position: * return * if self.minstart > position: # <<<<<<<<<<<<<< * return * */ } /* "skbio/metadata/_intersection.pyx":232 * # the ordering of these 3 blocks makes it so the results are * # ordered nearest to farest from the query position * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright._seek_left(position, results, n, max_dist) * */ __pyx_t_1 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":233 * # ordered nearest to farest from the query position * if self.cright is not EmptyNode: * self.cright._seek_left(position, results, n, max_dist) # <<<<<<<<<<<<<< * * if -1 < position - self.end < max_dist: */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->_seek_left(__pyx_v_self->cright, __pyx_v_position, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":232 * # the ordering of these 3 blocks makes it so the results are * # ordered nearest to farest from the query position * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright._seek_left(position, results, n, max_dist) * */ } /* "skbio/metadata/_intersection.pyx":235 * self.cright._seek_left(position, results, n, max_dist) * * if -1 < position - self.end < max_dist: # <<<<<<<<<<<<<< * results.append(self.interval) * */ __pyx_t_3 = (__pyx_v_position - __pyx_v_self->end); __pyx_t_2 = (-1L < __pyx_t_3); if (__pyx_t_2) { __pyx_t_2 = (__pyx_t_3 < __pyx_v_max_dist); } __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":236 * * if -1 < position - self.end < max_dist: * results.append(self.interval) # <<<<<<<<<<<<<< * * # TODO: can these conditionals be more stringent? */ if (unlikely(__pyx_v_results == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(1, 236, __pyx_L1_error) } __pyx_t_4 = __pyx_v_self->interval; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_results, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 236, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/metadata/_intersection.pyx":235 * self.cright._seek_left(position, results, n, max_dist) * * if -1 < position - self.end < max_dist: # <<<<<<<<<<<<<< * results.append(self.interval) * */ } /* "skbio/metadata/_intersection.pyx":239 * * # TODO: can these conditionals be more stringent? * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft._seek_left(position, results, n, max_dist) * */ __pyx_t_1 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":240 * # TODO: can these conditionals be more stringent? * if self.cleft is not EmptyNode: * self.cleft._seek_left(position, results, n, max_dist) # <<<<<<<<<<<<<< * * */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->_seek_left(__pyx_v_self->cleft, __pyx_v_position, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":239 * * # TODO: can these conditionals be more stringent? * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft._seek_left(position, results, n, max_dist) * */ } /* "skbio/metadata/_intersection.pyx":223 * self.cright.update( start, end, old_feature, new_feature ) * * cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): # <<<<<<<<<<<<<< * # we know we can bail in these 2 cases. * if self.maxend + max_dist < position: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("skbio.metadata._intersection.IntervalNode._seek_left", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "skbio/metadata/_intersection.pyx":244 * * * cdef void _seek_right(IntervalNode self, int position, list results, int n, int max_dist): # <<<<<<<<<<<<<< * # we know we can bail in these 2 cases. * if self.maxend < position: return */ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, int __pyx_v_position, PyObject *__pyx_v_results, int __pyx_v_n, int __pyx_v_max_dist) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_seek_right", 0); /* "skbio/metadata/_intersection.pyx":246 * cdef void _seek_right(IntervalNode self, int position, list results, int n, int max_dist): * # we know we can bail in these 2 cases. * if self.maxend < position: return # <<<<<<<<<<<<<< * if self.minstart - max_dist > position: return * */ __pyx_t_1 = ((__pyx_v_self->maxend < __pyx_v_position) != 0); if (__pyx_t_1) { goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":247 * # we know we can bail in these 2 cases. * if self.maxend < position: return * if self.minstart - max_dist > position: return # <<<<<<<<<<<<<< * * #print "SEEK_RIGHT:",self, self.cleft, self.maxend, self.minstart, position */ __pyx_t_1 = (((__pyx_v_self->minstart - __pyx_v_max_dist) > __pyx_v_position) != 0); if (__pyx_t_1) { goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":253 * # the ordering of these 3 blocks makes it so the results are * # ordered nearest to farest from the query position * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft._seek_right(position, results, n, max_dist) * */ __pyx_t_1 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":254 * # ordered nearest to farest from the query position * if self.cleft is not EmptyNode: * self.cleft._seek_right(position, results, n, max_dist) # <<<<<<<<<<<<<< * * if -1 < self.start - position < max_dist: */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->_seek_right(__pyx_v_self->cleft, __pyx_v_position, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":253 * # the ordering of these 3 blocks makes it so the results are * # ordered nearest to farest from the query position * if self.cleft is not EmptyNode: # <<<<<<<<<<<<<< * self.cleft._seek_right(position, results, n, max_dist) * */ } /* "skbio/metadata/_intersection.pyx":256 * self.cleft._seek_right(position, results, n, max_dist) * * if -1 < self.start - position < max_dist: # <<<<<<<<<<<<<< * results.append(self.interval) * */ __pyx_t_3 = (__pyx_v_self->start - __pyx_v_position); __pyx_t_2 = (-1L < __pyx_t_3); if (__pyx_t_2) { __pyx_t_2 = (__pyx_t_3 < __pyx_v_max_dist); } __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "skbio/metadata/_intersection.pyx":257 * * if -1 < self.start - position < max_dist: * results.append(self.interval) # <<<<<<<<<<<<<< * * if self.cright is not EmptyNode: */ if (unlikely(__pyx_v_results == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); __PYX_ERR(1, 257, __pyx_L1_error) } __pyx_t_4 = __pyx_v_self->interval; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_results, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 257, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/metadata/_intersection.pyx":256 * self.cleft._seek_right(position, results, n, max_dist) * * if -1 < self.start - position < max_dist: # <<<<<<<<<<<<<< * results.append(self.interval) * */ } /* "skbio/metadata/_intersection.pyx":259 * results.append(self.interval) * * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright._seek_right(position, results, n, max_dist) * */ __pyx_t_1 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":260 * * if self.cright is not EmptyNode: * self.cright._seek_right(position, results, n, max_dist) # <<<<<<<<<<<<<< * * */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->_seek_right(__pyx_v_self->cright, __pyx_v_position, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":259 * results.append(self.interval) * * if self.cright is not EmptyNode: # <<<<<<<<<<<<<< * self.cright._seek_right(position, results, n, max_dist) * */ } /* "skbio/metadata/_intersection.pyx":244 * * * cdef void _seek_right(IntervalNode self, int position, list results, int n, int max_dist): # <<<<<<<<<<<<<< * # we know we can bail in these 2 cases. * if self.maxend < position: return */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("skbio.metadata._intersection.IntervalNode._seek_right", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "skbio/metadata/_intersection.pyx":263 * * * cpdef left(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a start > than `position` */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_11left(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left *__pyx_optional_args) { int __pyx_v_n = ((int)1); int __pyx_v_max_dist = ((int)0x9C4); PyObject *__pyx_v_results = 0; PyObject *__pyx_v_r = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("left", 0); if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_n = __pyx_optional_args->n; if (__pyx_optional_args->__pyx_n > 1) { __pyx_v_max_dist = __pyx_optional_args->max_dist; } } } /* Check if called by wrapper */ if (unlikely(__pyx_skip_dispatch)) ; /* Check if overridden in Python */ else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_left); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_11left)) { __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_max_dist); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_position, __pyx_t_3, __pyx_t_4}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_position, __pyx_t_3, __pyx_t_4}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_position); __Pyx_GIVEREF(__pyx_v_position); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_position); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "skbio/metadata/_intersection.pyx":270 * max_dist: the maximum distance to look before giving up. * """ * cdef list results = [] # <<<<<<<<<<<<<< * # use start - 1 becuase .left() assumes strictly left-of * self._seek_left( position - 1, results, n, max_dist ) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_results = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":272 * cdef list results = [] * # use start - 1 becuase .left() assumes strictly left-of * self._seek_left( position - 1, results, n, max_dist ) # <<<<<<<<<<<<<< * if len(results) == n: return results * r = results */ __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_position, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->_seek_left(__pyx_v_self, __pyx_t_7, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":273 * # use start - 1 becuase .left() assumes strictly left-of * self._seek_left( position - 1, results, n, max_dist ) * if len(results) == n: return results # <<<<<<<<<<<<<< * r = results * r.sort(key=operator.attrgetter('end'), reverse=True) */ __pyx_t_9 = PyList_GET_SIZE(__pyx_v_results); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 273, __pyx_L1_error) __pyx_t_10 = ((__pyx_t_9 == __pyx_v_n) != 0); if (__pyx_t_10) { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":274 * self._seek_left( position - 1, results, n, max_dist ) * if len(results) == n: return results * r = results # <<<<<<<<<<<<<< * r.sort(key=operator.attrgetter('end'), reverse=True) * return r[:n] */ __Pyx_INCREF(__pyx_v_results); __pyx_v_r = __pyx_v_results; /* "skbio/metadata/_intersection.pyx":275 * if len(results) == n: return results * r = results * r.sort(key=operator.attrgetter('end'), reverse=True) # <<<<<<<<<<<<<< * return r[:n] * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r, __pyx_n_s_sort); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_operator); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_attrgetter); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_n_s_end) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_n_s_end); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_key, __pyx_t_5) < 0) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_reverse, Py_True) < 0) __PYX_ERR(1, 275, __pyx_L1_error) __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "skbio/metadata/_intersection.pyx":276 * r = results * r.sort(key=operator.attrgetter('end'), reverse=True) * return r[:n] # <<<<<<<<<<<<<< * * cpdef right(self, position, int n=1, int max_dist=2500): */ __Pyx_XDECREF(__pyx_r); __pyx_t_5 = __Pyx_PyList_GetSlice(__pyx_v_r, 0, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":263 * * * cpdef left(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a start > than `position` */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.left", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_results); __Pyx_XDECREF(__pyx_v_r); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_11left(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_10left[] = "\n find n features with a start > than `position`\n f: a Interval object (or anything with an `end` attribute)\n n: the number of features to return\n max_dist: the maximum distance to look before giving up.\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_11left(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_position = 0; int __pyx_v_n; int __pyx_v_max_dist; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("left (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_position,&__pyx_n_s_n,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_position)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "left") < 0)) __PYX_ERR(1, 263, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_position = values[0]; if (values[1]) { __pyx_v_n = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 263, __pyx_L3_error) } else { __pyx_v_n = ((int)1); } if (values[2]) { __pyx_v_max_dist = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_max_dist == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 263, __pyx_L3_error) } else { __pyx_v_max_dist = ((int)0x9C4); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("left", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 263, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.left", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10left(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_position, __pyx_v_n, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_10left(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_v_n, int __pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("left", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 2; __pyx_t_2.n = __pyx_v_n; __pyx_t_2.max_dist = __pyx_v_max_dist; __pyx_t_1 = __pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode->left(__pyx_v_self, __pyx_v_position, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.left", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":278 * return r[:n] * * cpdef right(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a end < than position */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_13right(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right *__pyx_optional_args) { int __pyx_v_n = ((int)1); int __pyx_v_max_dist = ((int)0x9C4); PyObject *__pyx_v_results = 0; PyObject *__pyx_v_r = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("right", 0); if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_n = __pyx_optional_args->n; if (__pyx_optional_args->__pyx_n > 1) { __pyx_v_max_dist = __pyx_optional_args->max_dist; } } } /* Check if called by wrapper */ if (unlikely(__pyx_skip_dispatch)) ; /* Check if overridden in Python */ else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_right); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_13right)) { __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_max_dist); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = __pyx_t_1; __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_position, __pyx_t_3, __pyx_t_4}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_v_position, __pyx_t_3, __pyx_t_4}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_position); __Pyx_GIVEREF(__pyx_v_position); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_position); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "skbio/metadata/_intersection.pyx":285 * max_dist: the maximum distance to look before giving up. * """ * cdef list results = [] # <<<<<<<<<<<<<< * # use end + 1 becuase .right() assumes strictly right-of * self._seek_right(position + 1, results, n, max_dist) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 285, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_results = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":287 * cdef list results = [] * # use end + 1 becuase .right() assumes strictly right-of * self._seek_right(position + 1, results, n, max_dist) # <<<<<<<<<<<<<< * if len(results) == n: return results * r = results */ __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_v_position, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->_seek_right(__pyx_v_self, __pyx_t_7, __pyx_v_results, __pyx_v_n, __pyx_v_max_dist); /* "skbio/metadata/_intersection.pyx":288 * # use end + 1 becuase .right() assumes strictly right-of * self._seek_right(position + 1, results, n, max_dist) * if len(results) == n: return results # <<<<<<<<<<<<<< * r = results * r.sort(key=operator.attrgetter('start')) */ __pyx_t_9 = PyList_GET_SIZE(__pyx_v_results); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 288, __pyx_L1_error) __pyx_t_10 = ((__pyx_t_9 == __pyx_v_n) != 0); if (__pyx_t_10) { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":289 * self._seek_right(position + 1, results, n, max_dist) * if len(results) == n: return results * r = results # <<<<<<<<<<<<<< * r.sort(key=operator.attrgetter('start')) * return r[:n] */ __Pyx_INCREF(__pyx_v_results); __pyx_v_r = __pyx_v_results; /* "skbio/metadata/_intersection.pyx":290 * if len(results) == n: return results * r = results * r.sort(key=operator.attrgetter('start')) # <<<<<<<<<<<<<< * return r[:n] * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r, __pyx_n_s_sort); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_operator); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_attrgetter); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_5 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_8, __pyx_n_s_start) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_n_s_start); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_key, __pyx_t_5) < 0) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "skbio/metadata/_intersection.pyx":291 * r = results * r.sort(key=operator.attrgetter('start')) * return r[:n] # <<<<<<<<<<<<<< * * def traverse(self, func): */ __Pyx_XDECREF(__pyx_r); __pyx_t_5 = __Pyx_PyList_GetSlice(__pyx_v_r, 0, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":278 * return r[:n] * * cpdef right(self, position, int n=1, int max_dist=2500): # <<<<<<<<<<<<<< * """ * find n features with a end < than position */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.right", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_results); __Pyx_XDECREF(__pyx_v_r); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_13right(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_12right[] = "\n find n features with a end < than position\n f: a Interval object (or anything with a `start` attribute)\n n: the number of features to return\n max_dist: the maximum distance to look before giving up.\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_13right(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_position = 0; int __pyx_v_n; int __pyx_v_max_dist; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("right (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_position,&__pyx_n_s_n,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_position)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "right") < 0)) __PYX_ERR(1, 278, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_position = values[0]; if (values[1]) { __pyx_v_n = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 278, __pyx_L3_error) } else { __pyx_v_n = ((int)1); } if (values[2]) { __pyx_v_max_dist = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_max_dist == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 278, __pyx_L3_error) } else { __pyx_v_max_dist = ((int)0x9C4); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("right", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 278, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.right", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_12right(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), __pyx_v_position, __pyx_v_n, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_12right(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_position, int __pyx_v_n, int __pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("right", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 2; __pyx_t_2.n = __pyx_v_n; __pyx_t_2.max_dist = __pyx_v_max_dist; __pyx_t_1 = __pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode->right(__pyx_v_self, __pyx_v_position, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.right", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":293 * return r[:n] * * def traverse(self, func): # <<<<<<<<<<<<<< * self._traverse(func) * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_15traverse(PyObject *__pyx_v_self, PyObject *__pyx_v_func); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_15traverse(PyObject *__pyx_v_self, PyObject *__pyx_v_func) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("traverse (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_14traverse(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), ((PyObject *)__pyx_v_func)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_14traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_func) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("traverse", 0); /* "skbio/metadata/_intersection.pyx":294 * * def traverse(self, func): * self._traverse(func) # <<<<<<<<<<<<<< * * cdef void _traverse(IntervalNode self, object func): */ ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->__pyx_vtab)->_traverse(__pyx_v_self, __pyx_v_func); /* "skbio/metadata/_intersection.pyx":293 * return r[:n] * * def traverse(self, func): # <<<<<<<<<<<<<< * self._traverse(func) * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":296 * self._traverse(func) * * cdef void _traverse(IntervalNode self, object func): # <<<<<<<<<<<<<< * if self.cleft is not EmptyNode: self.cleft._traverse(func) * func(self) */ static void __pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_func) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_traverse", 0); /* "skbio/metadata/_intersection.pyx":297 * * cdef void _traverse(IntervalNode self, object func): * if self.cleft is not EmptyNode: self.cleft._traverse(func) # <<<<<<<<<<<<<< * func(self) * if self.cright is not EmptyNode: self.cright._traverse(func) */ __pyx_t_1 = (__pyx_v_self->cleft != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cleft->__pyx_vtab)->_traverse(__pyx_v_self->cleft, __pyx_v_func); } /* "skbio/metadata/_intersection.pyx":298 * cdef void _traverse(IntervalNode self, object func): * if self.cleft is not EmptyNode: self.cleft._traverse(func) * func(self) # <<<<<<<<<<<<<< * if self.cright is not EmptyNode: self.cright._traverse(func) * */ __Pyx_INCREF(__pyx_v_func); __pyx_t_4 = __pyx_v_func; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "skbio/metadata/_intersection.pyx":299 * if self.cleft is not EmptyNode: self.cleft._traverse(func) * func(self) * if self.cright is not EmptyNode: self.cright._traverse(func) # <<<<<<<<<<<<<< * * cdef IntervalNode EmptyNode = IntervalNode( 0, 0, IntervalObj(0, 0)) */ __pyx_t_2 = (__pyx_v_self->cright != __pyx_v_5skbio_8metadata_13_intersection_EmptyNode); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->cright->__pyx_vtab)->_traverse(__pyx_v_self->cright, __pyx_v_func); } /* "skbio/metadata/_intersection.pyx":296 * self._traverse(func) * * cdef void _traverse(IntervalNode self, object func): # <<<<<<<<<<<<<< * if self.cleft is not EmptyNode: self.cleft._traverse(func) * func(self) */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("skbio.metadata._intersection.IntervalNode._traverse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "skbio/metadata/_intersection.pyx":74 * """ * cdef float priority * cdef public object interval # <<<<<<<<<<<<<< * cdef public int start, end * cdef int minend, maxend, minstart */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->interval); __pyx_r = __pyx_v_self->interval; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->interval); __Pyx_DECREF(__pyx_v_self->interval); __pyx_v_self->interval = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_4__del__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_8interval_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->interval); __Pyx_DECREF(__pyx_v_self->interval); __pyx_v_self->interval = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":75 * cdef float priority * cdef public object interval * cdef public int start, end # <<<<<<<<<<<<<< * cdef int minend, maxend, minstart * cdef IntervalNode cleft, cright, croot */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.start.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_5start_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 75, __pyx_L1_error) __pyx_v_self->start = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.start.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 75, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.end.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_3end_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 75, __pyx_L1_error) __pyx_v_self->end = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.end.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_16__reduce_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_18__setstate_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalNode_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalNode.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":322 * cdef public object value, chrom, strand * * def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): # <<<<<<<<<<<<<< * assert start <= end, "start must be less than end" * self.start = start */ /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; PyObject *__pyx_v_value = 0; PyObject *__pyx_v_chrom = 0; PyObject *__pyx_v_strand = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_value,&__pyx_n_s_chrom,&__pyx_n_s_strand,0}; PyObject* values[5] = {0,0,0,0,0}; values[2] = ((PyObject *)Py_None); values[3] = ((PyObject *)Py_None); values[4] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); __PYX_ERR(1, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_chrom); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_strand); if (value) { values[4] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 322, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 322, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 322, __pyx_L3_error) __pyx_v_value = values[2]; __pyx_v_chrom = values[3]; __pyx_v_strand = values[4]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 322, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj___init__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_value, __pyx_v_chrom, __pyx_v_strand); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj___init__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_value, PyObject *__pyx_v_chrom, PyObject *__pyx_v_strand) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "skbio/metadata/_intersection.pyx":323 * * def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): * assert start <= end, "start must be less than end" # <<<<<<<<<<<<<< * self.start = start * self.end = end */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_start <= __pyx_v_end) != 0))) { PyErr_SetObject(PyExc_AssertionError, __pyx_kp_s_start_must_be_less_than_end); __PYX_ERR(1, 323, __pyx_L1_error) } } #endif /* "skbio/metadata/_intersection.pyx":324 * def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): * assert start <= end, "start must be less than end" * self.start = start # <<<<<<<<<<<<<< * self.end = end * self.value = value */ __pyx_v_self->start = __pyx_v_start; /* "skbio/metadata/_intersection.pyx":325 * assert start <= end, "start must be less than end" * self.start = start * self.end = end # <<<<<<<<<<<<<< * self.value = value * self.chrom = chrom */ __pyx_v_self->end = __pyx_v_end; /* "skbio/metadata/_intersection.pyx":326 * self.start = start * self.end = end * self.value = value # <<<<<<<<<<<<<< * self.chrom = chrom * self.strand = strand */ __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->value); __Pyx_DECREF(__pyx_v_self->value); __pyx_v_self->value = __pyx_v_value; /* "skbio/metadata/_intersection.pyx":327 * self.end = end * self.value = value * self.chrom = chrom # <<<<<<<<<<<<<< * self.strand = strand * */ __Pyx_INCREF(__pyx_v_chrom); __Pyx_GIVEREF(__pyx_v_chrom); __Pyx_GOTREF(__pyx_v_self->chrom); __Pyx_DECREF(__pyx_v_self->chrom); __pyx_v_self->chrom = __pyx_v_chrom; /* "skbio/metadata/_intersection.pyx":328 * self.value = value * self.chrom = chrom * self.strand = strand # <<<<<<<<<<<<<< * * def __repr__(self): */ __Pyx_INCREF(__pyx_v_strand); __Pyx_GIVEREF(__pyx_v_strand); __Pyx_GOTREF(__pyx_v_self->strand); __Pyx_DECREF(__pyx_v_self->strand); __pyx_v_self->strand = __pyx_v_strand; /* "skbio/metadata/_intersection.pyx":322 * cdef public object value, chrom, strand * * def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): # <<<<<<<<<<<<<< * assert start <= end, "start must be less than end" * self.start = start */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":330 * self.strand = strand * * def __repr__(self): # <<<<<<<<<<<<<< * fstr = "IntervalObj(%d, %d" % (self.start, self.end) * if not self.value is None: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_2__repr__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_2__repr__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_v_fstr = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "skbio/metadata/_intersection.pyx":331 * * def __repr__(self): * fstr = "IntervalObj(%d, %d" % (self.start, self.end) # <<<<<<<<<<<<<< * if not self.value is None: * fstr += ", value=" + str(self.value) */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_IntervalObj_d_d, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 331, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_fstr = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/metadata/_intersection.pyx":332 * def __repr__(self): * fstr = "IntervalObj(%d, %d" % (self.start, self.end) * if not self.value is None: # <<<<<<<<<<<<<< * fstr += ", value=" + str(self.value) * fstr += ")" */ __pyx_t_4 = (__pyx_v_self->value != Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "skbio/metadata/_intersection.pyx":333 * fstr = "IntervalObj(%d, %d" % (self.start, self.end) * if not self.value is None: * fstr += ", value=" + str(self.value) # <<<<<<<<<<<<<< * fstr += ")" * return fstr */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_self->value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Add(__pyx_kp_s_value_2, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_fstr, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_fstr, __pyx_t_2); __pyx_t_2 = 0; /* "skbio/metadata/_intersection.pyx":332 * def __repr__(self): * fstr = "IntervalObj(%d, %d" % (self.start, self.end) * if not self.value is None: # <<<<<<<<<<<<<< * fstr += ", value=" + str(self.value) * fstr += ")" */ } /* "skbio/metadata/_intersection.pyx":334 * if not self.value is None: * fstr += ", value=" + str(self.value) * fstr += ")" # <<<<<<<<<<<<<< * return fstr * */ __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_fstr, __pyx_kp_s__3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_fstr, __pyx_t_2); __pyx_t_2 = 0; /* "skbio/metadata/_intersection.pyx":335 * fstr += ", value=" + str(self.value) * fstr += ")" * return fstr # <<<<<<<<<<<<<< * * def __richcmp__(self, other, op): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_fstr); __pyx_r = __pyx_v_fstr; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":330 * self.strand = strand * * def __repr__(self): # <<<<<<<<<<<<<< * fstr = "IntervalObj(%d, %d" % (self.start, self.end) * if not self.value is None: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_fstr); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":337 * return fstr * * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< * if op == 0: * # < */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op) { PyObject *__pyx_v_op = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__richcmp__ (wrapper)", 0); __pyx_v_op = __Pyx_PyInt_From_int(__pyx_arg_op); if (unlikely(!__pyx_v_op)) __PYX_ERR(1, 337, __pyx_L3_error) __Pyx_GOTREF(__pyx_v_op); goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_4__richcmp__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_op)); /* function exit code */ __Pyx_XDECREF(__pyx_v_op); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_4__richcmp__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__richcmp__", 0); /* "skbio/metadata/_intersection.pyx":338 * * def __richcmp__(self, other, op): * if op == 0: # <<<<<<<<<<<<<< * # < * return self.start < other.start or self.end < other.end */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":340 * if op == 0: * # < * return self.start < other.start or self.end < other.end # <<<<<<<<<<<<<< * elif op == 1: * # <= */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 340, __pyx_L1_error) if (!__pyx_t_2) { __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __Pyx_INCREF(__pyx_t_5); __pyx_t_1 = __pyx_t_5; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 340, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L4_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":338 * * def __richcmp__(self, other, op): * if op == 0: # <<<<<<<<<<<<<< * # < * return self.start < other.start or self.end < other.end */ } /* "skbio/metadata/_intersection.pyx":341 * # < * return self.start < other.start or self.end < other.end * elif op == 1: # <<<<<<<<<<<<<< * # <= * return self == other or self < other */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 341, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":343 * elif op == 1: * # <= * return self == other or self < other # <<<<<<<<<<<<<< * elif op == 2: * # == */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyObject_RichCompare(((PyObject *)__pyx_v_self), __pyx_v_other, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 343, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 343, __pyx_L1_error) if (!__pyx_t_2) { __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = PyObject_RichCompare(((PyObject *)__pyx_v_self), __pyx_v_other, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 343, __pyx_L1_error) __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L6_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":341 * # < * return self.start < other.start or self.end < other.end * elif op == 1: # <<<<<<<<<<<<<< * # <= * return self == other or self < other */ } /* "skbio/metadata/_intersection.pyx":344 * # <= * return self == other or self < other * elif op == 2: # <<<<<<<<<<<<<< * # == * return self.start == other.start and self.end == other.end */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 344, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":346 * elif op == 2: * # == * return self.start == other.start and self.end == other.end # <<<<<<<<<<<<<< * elif op == 3: * # != */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 346, __pyx_L1_error) if (__pyx_t_2) { __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __Pyx_INCREF(__pyx_t_5); __pyx_t_1 = __pyx_t_5; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L8_bool_binop_done; } __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L8_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":344 * # <= * return self == other or self < other * elif op == 2: # <<<<<<<<<<<<<< * # == * return self.start == other.start and self.end == other.end */ } /* "skbio/metadata/_intersection.pyx":347 * # == * return self.start == other.start and self.end == other.end * elif op == 3: # <<<<<<<<<<<<<< * # != * return self.start != other.start or self.end != other.end */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_3, 3, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 347, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":349 * elif op == 3: * # != * return self.start != other.start or self.end != other.end # <<<<<<<<<<<<<< * elif op == 4: * # > */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 349, __pyx_L1_error) if (!__pyx_t_2) { __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __Pyx_INCREF(__pyx_t_5); __pyx_t_1 = __pyx_t_5; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L10_bool_binop_done; } __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 349, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L10_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":347 * # == * return self.start == other.start and self.end == other.end * elif op == 3: # <<<<<<<<<<<<<< * # != * return self.start != other.start or self.end != other.end */ } /* "skbio/metadata/_intersection.pyx":350 * # != * return self.start != other.start or self.end != other.end * elif op == 4: # <<<<<<<<<<<<<< * # > * return self.start > other.start or self.end > other.end */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_4, 4, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":352 * elif op == 4: * # > * return self.start > other.start or self.end > other.end # <<<<<<<<<<<<<< * elif op == 5: * # >= */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 352, __pyx_L1_error) if (!__pyx_t_2) { __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __Pyx_INCREF(__pyx_t_5); __pyx_t_1 = __pyx_t_5; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L12_bool_binop_done; } __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 352, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L12_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":350 * # != * return self.start != other.start or self.end != other.end * elif op == 4: # <<<<<<<<<<<<<< * # > * return self.start > other.start or self.end > other.end */ } /* "skbio/metadata/_intersection.pyx":353 * # > * return self.start > other.start or self.end > other.end * elif op == 5: # <<<<<<<<<<<<<< * # >= * return self == other or self > other */ __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_op, __pyx_int_5, 5, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 353, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":355 * elif op == 5: * # >= * return self == other or self > other # <<<<<<<<<<<<<< * * cdef class IntervalTree: */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyObject_RichCompare(((PyObject *)__pyx_v_self), __pyx_v_other, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 355, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 355, __pyx_L1_error) if (!__pyx_t_2) { __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L14_bool_binop_done; } __pyx_t_3 = PyObject_RichCompare(((PyObject *)__pyx_v_self), __pyx_v_other, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L14_bool_binop_done:; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":353 * # > * return self.start > other.start or self.end > other.end * elif op == 5: # <<<<<<<<<<<<<< * # >= * return self == other or self > other */ } /* "skbio/metadata/_intersection.pyx":337 * return fstr * * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< * if op == 0: * # < */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":319 * * """ * cdef public int start, end # <<<<<<<<<<<<<< * cdef public object value, chrom, strand * */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.start.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5start_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 319, __pyx_L1_error) __pyx_v_self->start = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.start.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.end.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_3end_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 319, __pyx_L1_error) __pyx_v_self->end = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.end.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":320 * """ * cdef public int start, end * cdef public object value, chrom, strand # <<<<<<<<<<<<<< * * def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->value); __pyx_r = __pyx_v_self->value; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->value); __Pyx_DECREF(__pyx_v_self->value); __pyx_v_self->value = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_4__del__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5value_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->value); __Pyx_DECREF(__pyx_v_self->value); __pyx_v_self->value = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->chrom); __pyx_r = __pyx_v_self->chrom; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->chrom); __Pyx_DECREF(__pyx_v_self->chrom); __pyx_v_self->chrom = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_4__del__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->chrom); __Pyx_DECREF(__pyx_v_self->chrom); __pyx_v_self->chrom = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand___get__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand___get__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->strand); __pyx_r = __pyx_v_self->strand; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_2__set__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_2__set__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->strand); __Pyx_DECREF(__pyx_v_self->strand); __pyx_v_self->strand = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_4__del__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6strand_4__del__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->strand); __Pyx_DECREF(__pyx_v_self->strand); __pyx_v_self->strand = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6__reduce_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_6__reduce_cython__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.chrom, self.end, self.start, self.strand, self.value) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->end); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_self->chrom); __Pyx_GIVEREF(__pyx_v_self->chrom); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->chrom); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __Pyx_INCREF(__pyx_v_self->strand); __Pyx_GIVEREF(__pyx_v_self->strand); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_self->strand); __Pyx_INCREF(__pyx_v_self->value); __Pyx_GIVEREF(__pyx_v_self->value); PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_v_self->value); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_v_state = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.chrom, self.end, self.start, self.strand, self.value) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_3 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v__dict = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":7 * state = (self.chrom, self.end, self.start, self.strand, self.value) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_4 = (__pyx_v__dict != Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict); __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.chrom is not None or self.strand is not None or self.value is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.chrom, self.end, self.start, self.strand, self.value) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.chrom is not None or self.strand is not None or self.value is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, None), state */ /*else*/ { __pyx_t_4 = (__pyx_v_self->chrom != Py_None); __pyx_t_6 = (__pyx_t_4 != 0); if (!__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L4_bool_binop_done; } __pyx_t_6 = (__pyx_v_self->strand != Py_None); __pyx_t_4 = (__pyx_t_6 != 0); if (!__pyx_t_4) { } else { __pyx_t_5 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = (__pyx_v_self->value != Py_None); __pyx_t_6 = (__pyx_t_4 != 0); __pyx_t_5 = __pyx_t_6; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_5; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.chrom is not None or self.strand is not None or self.value is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, None), state * else: */ __pyx_t_5 = (__pyx_v_use_setstate != 0); if (__pyx_t_5) { /* "(tree fragment)":13 * use_setstate = self.chrom is not None or self.strand is not None or self.value is not None * if use_setstate: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle_IntervalObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_183079363); __Pyx_GIVEREF(__pyx_int_183079363); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_183079363); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.chrom is not None or self.strand is not None or self.value is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, None), state * else: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_IntervalObj__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle_IntervalObj); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_183079363); __Pyx_GIVEREF(__pyx_int_183079363); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_183079363); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_IntervalObj__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_8__setstate_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_11IntervalObj_8__setstate_cython__(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_IntervalObj__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_IntervalObj, (type(self), 0xae991c3, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_IntervalObj__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalObj.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":415 * cdef IntervalNode root * * def __cinit__( self ): # <<<<<<<<<<<<<< * root = None * */ /* Python wrapper */ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree___cinit__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree___cinit__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self) { CYTHON_UNUSED PyObject *__pyx_v_root = NULL; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__", 0); /* "skbio/metadata/_intersection.pyx":416 * * def __cinit__( self ): * root = None # <<<<<<<<<<<<<< * * # ---- Position based interfaces ----------------------------------------- */ __Pyx_INCREF(Py_None); __pyx_v_root = Py_None; /* "skbio/metadata/_intersection.pyx":415 * cdef IntervalNode root * * def __cinit__( self ): # <<<<<<<<<<<<<< * root = None * */ /* function exit code */ __pyx_r = 0; __Pyx_XDECREF(__pyx_v_root); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":420 * # ---- Position based interfaces ----------------------------------------- * * def insert( self, int start, int end, object value=None ): # <<<<<<<<<<<<<< * """ * Insert the interval [start,end) associated with value `value`. */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_3insert(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_2insert[] = "\n Insert the interval [start,end) associated with value `value`.\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_3insert(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_start; int __pyx_v_end; PyObject *__pyx_v_value = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("insert (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_value,0}; PyObject* values[3] = {0,0,0}; values[2] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("insert", 0, 2, 3, 1); __PYX_ERR(1, 420, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "insert") < 0)) __PYX_ERR(1, 420, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_start = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 420, __pyx_L3_error) __pyx_v_end = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_end == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 420, __pyx_L3_error) __pyx_v_value = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("insert", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 420, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.insert", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_2insert(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_value); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_2insert(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, int __pyx_v_start, int __pyx_v_end, PyObject *__pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("insert", 0); /* "skbio/metadata/_intersection.pyx":424 * Insert the interval [start,end) associated with value `value`. * """ * if self.root is None: # <<<<<<<<<<<<<< * self.root = IntervalNode( start, end, value ) * else: */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":425 * """ * if self.root is None: * self.root = IntervalNode( start, end, value ) # <<<<<<<<<<<<<< * else: * self.root = self.root.insert( start, end, value ) */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_value); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->root); __Pyx_DECREF(((PyObject *)__pyx_v_self->root)); __pyx_v_self->root = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_4); __pyx_t_4 = 0; /* "skbio/metadata/_intersection.pyx":424 * Insert the interval [start,end) associated with value `value`. * """ * if self.root is None: # <<<<<<<<<<<<<< * self.root = IntervalNode( start, end, value ) * else: */ goto __pyx_L3; } /* "skbio/metadata/_intersection.pyx":427 * self.root = IntervalNode( start, end, value ) * else: * self.root = self.root.insert( start, end, value ) # <<<<<<<<<<<<<< * * add = insert */ /*else*/ { __pyx_t_4 = ((PyObject *)((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->insert(__pyx_v_self->root, __pyx_v_start, __pyx_v_end, __pyx_v_value, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_GOTREF(__pyx_v_self->root); __Pyx_DECREF(((PyObject *)__pyx_v_self->root)); __pyx_v_self->root = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; /* "skbio/metadata/_intersection.pyx":420 * # ---- Position based interfaces ----------------------------------------- * * def insert( self, int start, int end, object value=None ): # <<<<<<<<<<<<<< * """ * Insert the interval [start,end) associated with value `value`. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.insert", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":432 * * * def update( self, start, end, old_feature, new_feature): # <<<<<<<<<<<<<< * """ * Given an interval [start, end), replace all objects that */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_5update(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_4update[] = "\n Given an interval [start, end), replace all objects that\n match the `old_feature` with `new_feature`.\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_5update(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_start = 0; PyObject *__pyx_v_end = 0; PyObject *__pyx_v_old_feature = 0; PyObject *__pyx_v_new_feature = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("update (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,&__pyx_n_s_old_feature,&__pyx_n_s_new_feature,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 1); __PYX_ERR(1, 432, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_old_feature)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 2); __PYX_ERR(1, 432, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_feature)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, 3); __PYX_ERR(1, 432, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "update") < 0)) __PYX_ERR(1, 432, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_start = values[0]; __pyx_v_end = values[1]; __pyx_v_old_feature = values[2]; __pyx_v_new_feature = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("update", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 432, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_4update(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_start, __pyx_v_end, __pyx_v_old_feature, __pyx_v_new_feature); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_4update(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_start, PyObject *__pyx_v_end, PyObject *__pyx_v_old_feature, PyObject *__pyx_v_new_feature) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update", 0); /* "skbio/metadata/_intersection.pyx":437 * match the `old_feature` with `new_feature`. * """ * if self.root is not None: # <<<<<<<<<<<<<< * self.root.update(start, end, old_feature, new_feature) * */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":438 * """ * if self.root is not None: * self.root.update(start, end, old_feature, new_feature) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_start); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 438, __pyx_L1_error) __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_end); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 438, __pyx_L1_error) ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->update(__pyx_v_self->root, __pyx_t_3, __pyx_t_4, __pyx_v_old_feature, __pyx_v_new_feature, 0); /* "skbio/metadata/_intersection.pyx":437 * match the `old_feature` with `new_feature`. * """ * if self.root is not None: # <<<<<<<<<<<<<< * self.root.update(start, end, old_feature, new_feature) * */ } /* "skbio/metadata/_intersection.pyx":432 * * * def update( self, start, end, old_feature, new_feature): # <<<<<<<<<<<<<< * """ * Given an interval [start, end), replace all objects that */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.update", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":441 * * * def find( self, start, end ): # <<<<<<<<<<<<<< * """ * Return a sorted list of all intervals overlapping [start,end). */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_7find(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_6find[] = "\n Return a sorted list of all intervals overlapping [start,end).\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_7find(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_start = 0; PyObject *__pyx_v_end = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("find (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_end,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_end)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("find", 1, 2, 2, 1); __PYX_ERR(1, 441, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "find") < 0)) __PYX_ERR(1, 441, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_start = values[0]; __pyx_v_end = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("find", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 441, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.find", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_6find(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_start, __pyx_v_end); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_6find(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_start, PyObject *__pyx_v_end) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("find", 0); /* "skbio/metadata/_intersection.pyx":445 * Return a sorted list of all intervals overlapping [start,end). * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.find( start, end ) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":446 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * return self.root.find( start, end ) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":445 * Return a sorted list of all intervals overlapping [start,end). * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.find( start, end ) */ } /* "skbio/metadata/_intersection.pyx":447 * if self.root is None: * return [] * return self.root.find( start, end ) # <<<<<<<<<<<<<< * * def before( self, position, num_intervals=1, max_dist=2500 ): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->root), __pyx_n_s_find); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_start, __pyx_v_end}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_start, __pyx_v_end}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_v_start); __Pyx_GIVEREF(__pyx_v_start); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_start); __Pyx_INCREF(__pyx_v_end); __Pyx_GIVEREF(__pyx_v_end); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_end); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":441 * * * def find( self, start, end ): # <<<<<<<<<<<<<< * """ * Return a sorted list of all intervals overlapping [start,end). */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.find", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":449 * return self.root.find( start, end ) * * def before( self, position, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie before `position` and are no */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_9before(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_8before[] = "\n Find `num_intervals` intervals that lie before `position` and are no\n further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_9before(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_position = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("before (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_position,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_position)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "before") < 0)) __PYX_ERR(1, 449, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_position = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("before", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 449, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.before", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_8before(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_position, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_8before(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("before", 0); /* "skbio/metadata/_intersection.pyx":454 * further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.left( position, num_intervals, max_dist ) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":455 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * return self.root.left( position, num_intervals, max_dist ) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":454 * further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.left( position, num_intervals, max_dist ) */ } /* "skbio/metadata/_intersection.pyx":456 * if self.root is None: * return [] * return self.root.left( position, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * def after( self, position, num_intervals=1, max_dist=2500 ): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 456, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 456, __pyx_L1_error) __pyx_t_6.__pyx_n = 2; __pyx_t_6.n = __pyx_t_4; __pyx_t_6.max_dist = __pyx_t_5; __pyx_t_3 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->left(__pyx_v_self->root, __pyx_v_position, 0, &__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":449 * return self.root.find( start, end ) * * def before( self, position, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie before `position` and are no */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.before", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":458 * return self.root.left( position, num_intervals, max_dist ) * * def after( self, position, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie after `position` and are no */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_11after(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_10after[] = "\n Find `num_intervals` intervals that lie after `position` and are no\n further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_11after(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_position = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("after (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_position,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_position)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "after") < 0)) __PYX_ERR(1, 458, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_position = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("after", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 458, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.after", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_10after(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_position, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_10after(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_position, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("after", 0); /* "skbio/metadata/_intersection.pyx":463 * further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.right( position, num_intervals, max_dist ) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":464 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * return self.root.right( position, num_intervals, max_dist ) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":463 * further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.right( position, num_intervals, max_dist ) */ } /* "skbio/metadata/_intersection.pyx":465 * if self.root is None: * return [] * return self.root.right( position, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * # ---- Interval-like object based interfaces ----------------------------- */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 465, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 465, __pyx_L1_error) __pyx_t_6.__pyx_n = 2; __pyx_t_6.n = __pyx_t_4; __pyx_t_6.max_dist = __pyx_t_5; __pyx_t_3 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->right(__pyx_v_self->root, __pyx_v_position, 0, &__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":458 * return self.root.left( position, num_intervals, max_dist ) * * def after( self, position, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie after `position` and are no */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.after", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":469 * # ---- Interval-like object based interfaces ----------------------------- * * def insert_interval( self, interval ): # <<<<<<<<<<<<<< * """ * Insert an "interval" like object (one with at least start and end */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_13insert_interval(PyObject *__pyx_v_self, PyObject *__pyx_v_interval); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_12insert_interval[] = "\n Insert an \"interval\" like object (one with at least start and end\n attributes)\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_13insert_interval(PyObject *__pyx_v_self, PyObject *__pyx_v_interval) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("insert_interval (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_12insert_interval(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), ((PyObject *)__pyx_v_interval)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_12insert_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("insert_interval", 0); /* "skbio/metadata/_intersection.pyx":474 * attributes) * """ * self.insert( interval.start, interval.end, interval ) # <<<<<<<<<<<<<< * * add_interval = insert_interval */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_insert); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_v_interval}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_v_interval}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_v_interval); __Pyx_GIVEREF(__pyx_v_interval); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_v_interval); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":469 * # ---- Interval-like object based interfaces ----------------------------- * * def insert_interval( self, interval ): # <<<<<<<<<<<<<< * """ * Insert an "interval" like object (one with at least start and end */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.insert_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":478 * add_interval = insert_interval * * def before_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely before `interval` */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_15before_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_14before_interval[] = "\n Find `num_intervals` intervals that lie completely before `interval`\n and are no further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_15before_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_interval = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("before_interval (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_interval,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "before_interval") < 0)) __PYX_ERR(1, 478, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_interval = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("before_interval", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 478, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.before_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_14before_interval(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_interval, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_14before_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("before_interval", 0); /* "skbio/metadata/_intersection.pyx":483 * and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.left( interval.start, num_intervals, max_dist ) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":484 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * return self.root.left( interval.start, num_intervals, max_dist ) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":483 * and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.left( interval.start, num_intervals, max_dist ) */ } /* "skbio/metadata/_intersection.pyx":485 * if self.root is None: * return [] * return self.root.left( interval.start, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * def after_interval( self, interval, num_intervals=1, max_dist=2500 ): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 485, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 485, __pyx_L1_error) __pyx_t_7.__pyx_n = 2; __pyx_t_7.n = __pyx_t_4; __pyx_t_7.max_dist = __pyx_t_5; __pyx_t_6 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->left(__pyx_v_self->root, __pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":478 * add_interval = insert_interval * * def before_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely before `interval` */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.before_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":487 * return self.root.left( interval.start, num_intervals, max_dist ) * * def after_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely after `interval` and */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_17after_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_16after_interval[] = "\n Find `num_intervals` intervals that lie completely after `interval` and\n are no further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_17after_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_interval = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("after_interval (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_interval,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "after_interval") < 0)) __PYX_ERR(1, 487, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_interval = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("after_interval", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 487, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.after_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_16after_interval(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_interval, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_16after_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("after_interval", 0); /* "skbio/metadata/_intersection.pyx":492 * are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.right( interval.end, num_intervals, max_dist ) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":493 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * return self.root.right( interval.end, num_intervals, max_dist ) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":492 * are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * return self.root.right( interval.end, num_intervals, max_dist ) */ } /* "skbio/metadata/_intersection.pyx":494 * if self.root is None: * return [] * return self.root.right( interval.end, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * def upstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_end); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 494, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 494, __pyx_L1_error) __pyx_t_7.__pyx_n = 2; __pyx_t_7.n = __pyx_t_4; __pyx_t_7.max_dist = __pyx_t_5; __pyx_t_6 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->right(__pyx_v_self->root, __pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":487 * return self.root.left( interval.start, num_intervals, max_dist ) * * def after_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely after `interval` and */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.after_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":496 * return self.root.right( interval.end, num_intervals, max_dist ) * * def upstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely upstream of */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_19upstream_of_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_18upstream_of_interval[] = "\n Find `num_intervals` intervals that lie completely upstream of\n `interval` and are no further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_19upstream_of_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_interval = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("upstream_of_interval (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_interval,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "upstream_of_interval") < 0)) __PYX_ERR(1, 496, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_interval = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("upstream_of_interval", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 496, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.upstream_of_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_18upstream_of_interval(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_interval, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_18upstream_of_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right __pyx_t_7; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("upstream_of_interval", 0); /* "skbio/metadata/_intersection.pyx":501 * `interval` and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * if interval.strand == -1 or interval.strand == "-": */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":502 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * if interval.strand == -1 or interval.strand == "-": * return self.root.right( interval.end, num_intervals, max_dist ) */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":501 * `interval` and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * if interval.strand == -1 or interval.strand == "-": */ } /* "skbio/metadata/_intersection.pyx":503 * if self.root is None: * return [] * if interval.strand == -1 or interval.strand == "-": # <<<<<<<<<<<<<< * return self.root.right( interval.end, num_intervals, max_dist ) * else: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_strand); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L5_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_strand); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_kp_s__4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L5_bool_binop_done:; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":504 * return [] * if interval.strand == -1 or interval.strand == "-": * return self.root.right( interval.end, num_intervals, max_dist ) # <<<<<<<<<<<<<< * else: * return self.root.left( interval.start, num_intervals, max_dist ) */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_end); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 504, __pyx_L1_error) __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 504, __pyx_L1_error) __pyx_t_7.__pyx_n = 2; __pyx_t_7.n = __pyx_t_5; __pyx_t_7.max_dist = __pyx_t_6; __pyx_t_3 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->right(__pyx_v_self->root, __pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":503 * if self.root is None: * return [] * if interval.strand == -1 or interval.strand == "-": # <<<<<<<<<<<<<< * return self.root.right( interval.end, num_intervals, max_dist ) * else: */ } /* "skbio/metadata/_intersection.pyx":506 * return self.root.right( interval.end, num_intervals, max_dist ) * else: * return self.root.left( interval.start, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * def downstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 506, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 506, __pyx_L1_error) __pyx_t_8.__pyx_n = 2; __pyx_t_8.n = __pyx_t_6; __pyx_t_8.max_dist = __pyx_t_5; __pyx_t_4 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->left(__pyx_v_self->root, __pyx_t_3, 0, &__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":496 * return self.root.right( interval.end, num_intervals, max_dist ) * * def upstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely upstream of */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.upstream_of_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":508 * return self.root.left( interval.start, num_intervals, max_dist ) * * def downstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely downstream of */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_21downstream_of_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_20downstream_of_interval[] = "\n Find `num_intervals` intervals that lie completely downstream of\n `interval` and are no further than `max_dist` positions away\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_21downstream_of_interval(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_interval = 0; PyObject *__pyx_v_num_intervals = 0; PyObject *__pyx_v_max_dist = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("downstream_of_interval (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_interval,&__pyx_n_s_num_intervals,&__pyx_n_s_max_dist,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_int_1); values[2] = ((PyObject *)__pyx_int_2500); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_interval)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_intervals); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_dist); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "downstream_of_interval") < 0)) __PYX_ERR(1, 508, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_interval = values[0]; __pyx_v_num_intervals = values[1]; __pyx_v_max_dist = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("downstream_of_interval", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 508, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.downstream_of_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_20downstream_of_interval(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), __pyx_v_interval, __pyx_v_num_intervals, __pyx_v_max_dist); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_20downstream_of_interval(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_interval, PyObject *__pyx_v_num_intervals, PyObject *__pyx_v_max_dist) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left __pyx_t_7; struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("downstream_of_interval", 0); /* "skbio/metadata/_intersection.pyx":513 * `interval` and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * if interval.strand == -1 or interval.strand == "-": */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":514 * """ * if self.root is None: * return [] # <<<<<<<<<<<<<< * if interval.strand == -1 or interval.strand == "-": * return self.root.left( interval.start, num_intervals, max_dist ) */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":513 * `interval` and are no further than `max_dist` positions away * """ * if self.root is None: # <<<<<<<<<<<<<< * return [] * if interval.strand == -1 or interval.strand == "-": */ } /* "skbio/metadata/_intersection.pyx":515 * if self.root is None: * return [] * if interval.strand == -1 or interval.strand == "-": # <<<<<<<<<<<<<< * return self.root.left( interval.start, num_intervals, max_dist ) * else: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_strand); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 515, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L5_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_strand); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_kp_s__4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 515, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L5_bool_binop_done:; if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":516 * return [] * if interval.strand == -1 or interval.strand == "-": * return self.root.left( interval.start, num_intervals, max_dist ) # <<<<<<<<<<<<<< * else: * return self.root.right( interval.end, num_intervals, max_dist ) */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_start); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 516, __pyx_L1_error) __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 516, __pyx_L1_error) __pyx_t_7.__pyx_n = 2; __pyx_t_7.n = __pyx_t_5; __pyx_t_7.max_dist = __pyx_t_6; __pyx_t_3 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->left(__pyx_v_self->root, __pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":515 * if self.root is None: * return [] * if interval.strand == -1 or interval.strand == "-": # <<<<<<<<<<<<<< * return self.root.left( interval.start, num_intervals, max_dist ) * else: */ } /* "skbio/metadata/_intersection.pyx":518 * return self.root.left( interval.start, num_intervals, max_dist ) * else: * return self.root.right( interval.end, num_intervals, max_dist ) # <<<<<<<<<<<<<< * * def traverse(self, fn): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_interval, __pyx_n_s_end); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_num_intervals); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 518, __pyx_L1_error) __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_max_dist); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 518, __pyx_L1_error) __pyx_t_8.__pyx_n = 2; __pyx_t_8.n = __pyx_t_6; __pyx_t_8.max_dist = __pyx_t_5; __pyx_t_4 = ((struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_v_self->root->__pyx_vtab)->right(__pyx_v_self->root, __pyx_t_3, 0, &__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "skbio/metadata/_intersection.pyx":508 * return self.root.left( interval.start, num_intervals, max_dist ) * * def downstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): # <<<<<<<<<<<<<< * """ * Find `num_intervals` intervals that lie completely downstream of */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.downstream_of_interval", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/metadata/_intersection.pyx":520 * return self.root.right( interval.end, num_intervals, max_dist ) * * def traverse(self, fn): # <<<<<<<<<<<<<< * """ * call fn for each element in the tree */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_23traverse(PyObject *__pyx_v_self, PyObject *__pyx_v_fn); /*proto*/ static char __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_22traverse[] = "\n call fn for each element in the tree\n "; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_23traverse(PyObject *__pyx_v_self, PyObject *__pyx_v_fn) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("traverse (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_22traverse(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), ((PyObject *)__pyx_v_fn)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_22traverse(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, PyObject *__pyx_v_fn) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("traverse", 0); /* "skbio/metadata/_intersection.pyx":524 * call fn for each element in the tree * """ * if self.root is None: # <<<<<<<<<<<<<< * return None * return self.root.traverse(fn) */ __pyx_t_1 = (((PyObject *)__pyx_v_self->root) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "skbio/metadata/_intersection.pyx":525 * """ * if self.root is None: * return None # <<<<<<<<<<<<<< * return self.root.traverse(fn) * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":524 * call fn for each element in the tree * """ * if self.root is None: # <<<<<<<<<<<<<< * return None * return self.root.traverse(fn) */ } /* "skbio/metadata/_intersection.pyx":526 * if self.root is None: * return None * return self.root.traverse(fn) # <<<<<<<<<<<<<< * * # For backward compatibility */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->root), __pyx_n_s_traverse); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_fn) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_fn); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "skbio/metadata/_intersection.pyx":520 * return self.root.right( interval.end, num_intervals, max_dist ) * * def traverse(self, fn): # <<<<<<<<<<<<<< * """ * call fn for each element in the tree */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.traverse", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_25__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_24__reduce_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_27__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_26__setstate_cython__(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection_12IntervalTree_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("skbio.metadata._intersection.IntervalTree.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_IntervalObj(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_1__pyx_unpickle_IntervalObj(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_5skbio_8metadata_13_intersection_1__pyx_unpickle_IntervalObj = {"__pyx_unpickle_IntervalObj", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_1__pyx_unpickle_IntervalObj, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_5skbio_8metadata_13_intersection_1__pyx_unpickle_IntervalObj(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_IntervalObj (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_IntervalObj", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_IntervalObj", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_IntervalObj") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_IntervalObj", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.metadata._intersection.__pyx_unpickle_IntervalObj", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_IntervalObj", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xae991c3, 0x11a88bb, 0x51a5eea): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0xae991c3, 0x11a88bb, 0x51a5eea): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) * __pyx_result = IntervalObj.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0xae991c3, 0x11a88bb, 0x51a5eea): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = IntervalObj.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xae991c3, 0x11a88bb, 0x51a5eea): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) * __pyx_result = IntervalObj.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalObj), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) * __pyx_result = IntervalObj.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = IntervalObj.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 9, __pyx_L1_error) __pyx_t_4 = __pyx_f_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj__set_state(((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xae991c3, 0x11a88bb, 0x51a5eea) = (chrom, end, start, strand, value))" % __pyx_checksum) * __pyx_result = IntervalObj.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_IntervalObj(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("skbio.metadata._intersection.__pyx_unpickle_IntervalObj", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_5skbio_8metadata_13_intersection___pyx_unpickle_IntervalObj__set_state(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_IntervalObj__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] # <<<<<<<<<<<<<< * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[5]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->chrom); __Pyx_DECREF(__pyx_v___pyx_result->chrom); __pyx_v___pyx_result->chrom = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->end = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->start = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->strand); __Pyx_DECREF(__pyx_v___pyx_result->strand); __pyx_v___pyx_result->strand = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->value); __Pyx_DECREF(__pyx_v___pyx_result->value); __pyx_v___pyx_result->value = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[5]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 13, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 5) != 0); if (__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_3 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "(tree fragment)":14 * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[5]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 14, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[5]) */ } /* "(tree fragment)":11 * __pyx_unpickle_IntervalObj__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_IntervalObj__set_state(IntervalObj __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.chrom = __pyx_state[0]; __pyx_result.end = __pyx_state[1]; __pyx_result.start = __pyx_state[2]; __pyx_result.strand = __pyx_state[3]; __pyx_result.value = __pyx_state[4] * if len(__pyx_state) > 5 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("skbio.metadata._intersection.__pyx_unpickle_IntervalObj__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_5skbio_8metadata_13_intersection_IntervalNode __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode; static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalNode(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)o); p->__pyx_vtab = __pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode; p->interval = Py_None; Py_INCREF(Py_None); p->cleft = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); p->cright = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); p->croot = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalNode(PyObject *o) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->interval); Py_CLEAR(p->cleft); Py_CLEAR(p->cright); Py_CLEAR(p->croot); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalNode(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)o; if (p->interval) { e = (*v)(p->interval, a); if (e) return e; } if (p->cleft) { e = (*v)(((PyObject *)p->cleft), a); if (e) return e; } if (p->cright) { e = (*v)(((PyObject *)p->cright), a); if (e) return e; } if (p->croot) { e = (*v)(((PyObject *)p->croot), a); if (e) return e; } return 0; } static int __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalNode(PyObject *o) { PyObject* tmp; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)o; tmp = ((PyObject*)p->interval); p->interval = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->cleft); p->cleft = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->cright); p->cright = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->croot); p->croot = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_left_node(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9left_node_1__get__(o); } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_right_node(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_10right_node_1__get__(o); } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_root_node(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9root_node_1__get__(o); } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_interval(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_interval(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_3__set__(o, v); } else { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_8interval_5__del__(o); } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_start(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_start(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5start_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_end(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_end(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_3end_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_5skbio_8metadata_13_intersection_IntervalNode[] = { {"insert", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_5insert, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_4insert}, {"intersect", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_7intersect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_6intersect}, {"update", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_9update, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_8update}, {"left", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_11left, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_10left}, {"right", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_13right, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalNode_12right}, {"traverse", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_15traverse, METH_O, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_17__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_19__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_5skbio_8metadata_13_intersection_IntervalNode[] = { {(char *)"left_node", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_left_node, 0, (char *)0, 0}, {(char *)"right_node", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_right_node, 0, (char *)0, 0}, {(char *)"root_node", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_root_node, 0, (char *)0, 0}, {(char *)"interval", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_interval, __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_interval, (char *)0, 0}, {(char *)"start", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_start, __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_start, (char *)0, 0}, {(char *)"end", __pyx_getprop_5skbio_8metadata_13_intersection_12IntervalNode_end, __pyx_setprop_5skbio_8metadata_13_intersection_12IntervalNode_end, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_5skbio_8metadata_13_intersection_IntervalNode = { PyVarObject_HEAD_INIT(0, 0) "skbio.metadata._intersection.IntervalNode", /*tp_name*/ sizeof(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalNode, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_pw_5skbio_8metadata_13_intersection_12IntervalNode_1__repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n A single node of an `IntervalTree`.\n\n NOTE: Unless you really know what you are doing, you probably should us\n `IntervalTree` rather than using this directly.\n ", /*tp_doc*/ __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalNode, /*tp_traverse*/ __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalNode, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_5skbio_8metadata_13_intersection_IntervalNode, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_5skbio_8metadata_13_intersection_IntervalNode, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_5skbio_8metadata_13_intersection_IntervalNode, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalObj(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)o); p->value = Py_None; Py_INCREF(Py_None); p->chrom = Py_None; Py_INCREF(Py_None); p->strand = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalObj(PyObject *o) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->value); Py_CLEAR(p->chrom); Py_CLEAR(p->strand); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalObj(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)o; if (p->value) { e = (*v)(p->value, a); if (e) return e; } if (p->chrom) { e = (*v)(p->chrom, a); if (e) return e; } if (p->strand) { e = (*v)(p->strand, a); if (e) return e; } return 0; } static int __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalObj(PyObject *o) { PyObject* tmp; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj *)o; tmp = ((PyObject*)p->value); p->value = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->chrom); p->chrom = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->strand); p->strand = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_start(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_start(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5start_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_end(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_end(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3end_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_value(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_value(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_3__set__(o, v); } else { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5value_5__del__(o); } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_chrom(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_chrom(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_3__set__(o, v); } else { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5chrom_5__del__(o); } } static PyObject *__pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_strand(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_1__get__(o); } static int __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_strand(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_3__set__(o, v); } else { return __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_6strand_5__del__(o); } } static PyMethodDef __pyx_methods_5skbio_8metadata_13_intersection_IntervalObj[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_7__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_9__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_5skbio_8metadata_13_intersection_IntervalObj[] = { {(char *)"start", __pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_start, __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_start, (char *)0, 0}, {(char *)"end", __pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_end, __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_end, (char *)0, 0}, {(char *)"value", __pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_value, __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_value, (char *)0, 0}, {(char *)"chrom", __pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_chrom, __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_chrom, (char *)0, 0}, {(char *)"strand", __pyx_getprop_5skbio_8metadata_13_intersection_11IntervalObj_strand, __pyx_setprop_5skbio_8metadata_13_intersection_11IntervalObj_strand, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_5skbio_8metadata_13_intersection_IntervalObj = { PyVarObject_HEAD_INIT(0, 0) "skbio.metadata._intersection.IntervalObj", /*tp_name*/ sizeof(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalObj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalObj, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_3__repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n Basic feature, with required integer start and end properties.\n Also accepts optional strand as +1 or -1 (used for up/downstream queries),\n a name, and any arbitrary data is sent in on the info keyword argument\n\n >>> from skbio.metadata._intersection import IntervalObj\n\n >>> f1 = IntervalObj(23, 36)\n >>> f2 = IntervalObj(34, 48, value={'chr':12, 'anno':'transposon'})\n >>> f2 # doctest: +SKIP\n IntervalObj(34, 48, value={'anno': 'transposon', 'chr': 12})\n\n ", /*tp_doc*/ __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalObj, /*tp_traverse*/ __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalObj, /*tp_clear*/ __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_5__richcmp__, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_5skbio_8metadata_13_intersection_IntervalObj, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_5skbio_8metadata_13_intersection_IntervalObj, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_5skbio_8metadata_13_intersection_11IntervalObj_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_5skbio_8metadata_13_intersection_IntervalObj, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_5skbio_8metadata_13_intersection_IntervalTree(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)o); p->root = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalTree(PyObject *o) { struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->root); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalTree(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)o; if (p->root) { e = (*v)(((PyObject *)p->root), a); if (e) return e; } return 0; } static int __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalTree(PyObject *o) { PyObject* tmp; struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *p = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree *)o; tmp = ((PyObject*)p->root); p->root = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_5skbio_8metadata_13_intersection_IntervalTree[] = { {"insert", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_3insert, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_2insert}, {"update", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_5update, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_4update}, {"find", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_7find, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_6find}, {"before", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_9before, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_8before}, {"after", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_11after, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_10after}, {"insert_interval", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_13insert_interval, METH_O, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_12insert_interval}, {"before_interval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_15before_interval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_14before_interval}, {"after_interval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_17after_interval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_16after_interval}, {"upstream_of_interval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_19upstream_of_interval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_18upstream_of_interval}, {"downstream_of_interval", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_21downstream_of_interval, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_20downstream_of_interval}, {"traverse", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_23traverse, METH_O, __pyx_doc_5skbio_8metadata_13_intersection_12IntervalTree_22traverse}, {"__reduce_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_25__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_5skbio_8metadata_13_intersection_12IntervalTree_27__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_5skbio_8metadata_13_intersection_IntervalTree = { PyVarObject_HEAD_INIT(0, 0) "skbio.metadata._intersection.IntervalTree", /*tp_name*/ sizeof(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalTree), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_5skbio_8metadata_13_intersection_IntervalTree, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n Data structure for performing window intersect queries on a set of\n of possibly overlapping 1d intervals.\n\n Usage\n =====\n\n Create an empty IntervalTree\n\n >>> from skbio.metadata._intersection import IntervalObj, IntervalTree\n >>> intersecter = IntervalTree()\n\n An interval is a start and end position and a value (possibly None).\n You can add any object as an interval:\n\n >>> intersecter.insert( 0, 10, \"food\" )\n >>> intersecter.insert( 3, 7, dict(foo='bar') )\n\n >>> intersecter.find( 2, 5 )\n ['food', {'foo': 'bar'}]\n\n If the object has start and end attributes (like the Interval class) there\n is are some shortcuts:\n\n >>> intersecter = IntervalTree()\n >>> intersecter.insert_interval( IntervalObj( 0, 10 ) )\n >>> intersecter.insert_interval( IntervalObj( 3, 7 ) )\n >>> intersecter.insert_interval( IntervalObj( 3, 40 ) )\n >>> intersecter.insert_interval( IntervalObj( 13, 50 ) )\n\n >>> intersecter.find( 30, 50 )\n [IntervalObj(3, 40), IntervalObj(13, 50)]\n >>> intersecter.find( 100, 200 )\n []\n\n Before/after for intervals\n\n >>> intersecter.before_interval( IntervalObj( 10, 20 ) )\n [IntervalObj(3, 7)]\n >>> intersecter.before_interval( IntervalObj( 5, 20 ) )\n []\n\n Upstream/downstream\n\n >>> intersecter.upstream_of_interval(IntervalObj(11, 12))\n [IntervalObj(0, 10)]\n >>> intersecter.upstream_of_interval(IntervalObj(11, 12, strand=\"-\"))\n [IntervalObj(13, 50)]\n\n >>> intersecter.upstream_of_interval(IntervalObj(1, 2, strand=\"-\"), num_intervals=3)\n [IntervalObj(3, 7), IntervalObj(3, 40), IntervalObj(13, 50)]\n\n\n ", /*tp_doc*/ __pyx_tp_traverse_5skbio_8metadata_13_intersection_IntervalTree, /*tp_traverse*/ __pyx_tp_clear_5skbio_8metadata_13_intersection_IntervalTree, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_5skbio_8metadata_13_intersection_IntervalTree, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_5skbio_8metadata_13_intersection_IntervalTree, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__intersection(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__intersection}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_intersection", __pyx_k_Data_structure_for_performing_i, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, {&__pyx_n_s_Intersecter, __pyx_k_Intersecter, sizeof(__pyx_k_Intersecter), 0, 0, 1, 1}, {&__pyx_n_s_IntervalNode, __pyx_k_IntervalNode, sizeof(__pyx_k_IntervalNode), 0, 0, 1, 1}, {&__pyx_kp_s_IntervalNode_i_i, __pyx_k_IntervalNode_i_i, sizeof(__pyx_k_IntervalNode_i_i), 0, 0, 1, 0}, {&__pyx_n_s_IntervalObj, __pyx_k_IntervalObj, sizeof(__pyx_k_IntervalObj), 0, 0, 1, 1}, {&__pyx_kp_s_IntervalObj_d_d, __pyx_k_IntervalObj_d_d, sizeof(__pyx_k_IntervalObj_d_d), 0, 0, 1, 0}, {&__pyx_n_s_IntervalTree, __pyx_k_IntervalTree, sizeof(__pyx_k_IntervalTree), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0}, {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, {&__pyx_n_s_add_interval, __pyx_k_add_interval, sizeof(__pyx_k_add_interval), 0, 0, 1, 1}, {&__pyx_n_s_attrgetter, __pyx_k_attrgetter, sizeof(__pyx_k_attrgetter), 0, 0, 1, 1}, {&__pyx_n_s_chrom, __pyx_k_chrom, sizeof(__pyx_k_chrom), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1}, {&__pyx_n_s_find, __pyx_k_find, sizeof(__pyx_k_find), 0, 0, 1, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_insert, __pyx_k_insert, sizeof(__pyx_k_insert), 0, 0, 1, 1}, {&__pyx_n_s_insert_interval, __pyx_k_insert_interval, sizeof(__pyx_k_insert_interval), 0, 0, 1, 1}, {&__pyx_n_s_intersect, __pyx_k_intersect, sizeof(__pyx_k_intersect), 0, 0, 1, 1}, {&__pyx_n_s_interval, __pyx_k_interval, sizeof(__pyx_k_interval), 0, 0, 1, 1}, {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, {&__pyx_n_s_left, __pyx_k_left, sizeof(__pyx_k_left), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_max_dist, __pyx_k_max_dist, sizeof(__pyx_k_max_dist), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_n_s_new_feature, __pyx_k_new_feature, sizeof(__pyx_k_new_feature), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_num_intervals, __pyx_k_num_intervals, sizeof(__pyx_k_num_intervals), 0, 0, 1, 1}, {&__pyx_n_s_old_feature, __pyx_k_old_feature, sizeof(__pyx_k_old_feature), 0, 0, 1, 1}, {&__pyx_n_s_operator, __pyx_k_operator, sizeof(__pyx_k_operator), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_position, __pyx_k_position, sizeof(__pyx_k_position), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_IntervalObj, __pyx_k_pyx_unpickle_IntervalObj, sizeof(__pyx_k_pyx_unpickle_IntervalObj), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_reverse, __pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 0, 1, 1}, {&__pyx_n_s_right, __pyx_k_right, sizeof(__pyx_k_right), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_skbio_metadata__intersection, __pyx_k_skbio_metadata__intersection, sizeof(__pyx_k_skbio_metadata__intersection), 0, 0, 1, 1}, {&__pyx_n_s_sort, __pyx_k_sort, sizeof(__pyx_k_sort), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_kp_s_start_must_be_less_than_end, __pyx_k_start_must_be_less_than_end, sizeof(__pyx_k_start_must_be_less_than_end), 0, 0, 1, 0}, {&__pyx_n_s_strand, __pyx_k_strand, sizeof(__pyx_k_strand), 0, 0, 1, 1}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_traverse, __pyx_k_traverse, sizeof(__pyx_k_traverse), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_kp_s_value_2, __pyx_k_value_2, sizeof(__pyx_k_value_2), 0, 0, 1, 0}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); __pyx_tuple__7 = PyTuple_Pack(3, __pyx_int_183079363, __pyx_int_18516155, __pyx_int_85614314); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "skbio/metadata/_intersection.pyx":301 * if self.cright is not EmptyNode: self.cright._traverse(func) * * cdef IntervalNode EmptyNode = IntervalNode( 0, 0, IntervalObj(0, 0)) # <<<<<<<<<<<<<< * * ## ---- Wrappers that retain the old interface ------------------------------- */ __pyx_tuple__8 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "(tree fragment)":1 * def __pyx_unpickle_IntervalObj(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__9 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_IntervalObj, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_2500 = PyInt_FromLong(2500); if (unlikely(!__pyx_int_2500)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_18516155 = PyInt_FromLong(18516155L); if (unlikely(!__pyx_int_18516155)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_85614314 = PyInt_FromLong(85614314L); if (unlikely(!__pyx_int_85614314)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_183079363 = PyInt_FromLong(183079363L); if (unlikely(!__pyx_int_183079363)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(1, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __pyx_v_5skbio_8metadata_13_intersection_EmptyNode = ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)Py_None); Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode = &__pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.insert = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *, int __pyx_skip_dispatch))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_insert; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.rotate_right = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_right; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.rotate_left = (struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *(*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_rotate_left; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.set_ends = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_set_ends; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode._intersect = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__intersect; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.update = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, int, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_update; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode._seek_left = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, PyObject *, int, int))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_left; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode._seek_right = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, int, PyObject *, int, int))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__seek_right; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.left = (PyObject *(*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_left *__pyx_optional_args))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_left; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode.right = (PyObject *(*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_5skbio_8metadata_13_intersection_12IntervalNode_right *__pyx_optional_args))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode_right; __pyx_vtable_5skbio_8metadata_13_intersection_IntervalNode._traverse = (void (*)(struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *, PyObject *))__pyx_f_5skbio_8metadata_13_intersection_12IntervalNode__traverse; if (PyType_Ready(&__pyx_type_5skbio_8metadata_13_intersection_IntervalNode) < 0) __PYX_ERR(1, 66, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_5skbio_8metadata_13_intersection_IntervalNode.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5skbio_8metadata_13_intersection_IntervalNode.tp_dictoffset && __pyx_type_5skbio_8metadata_13_intersection_IntervalNode.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_5skbio_8metadata_13_intersection_IntervalNode.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_5skbio_8metadata_13_intersection_IntervalNode.tp_dict, __pyx_vtabptr_5skbio_8metadata_13_intersection_IntervalNode) < 0) __PYX_ERR(1, 66, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_IntervalNode, (PyObject *)&__pyx_type_5skbio_8metadata_13_intersection_IntervalNode) < 0) __PYX_ERR(1, 66, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5skbio_8metadata_13_intersection_IntervalNode) < 0) __PYX_ERR(1, 66, __pyx_L1_error) __pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode = &__pyx_type_5skbio_8metadata_13_intersection_IntervalNode; if (PyType_Ready(&__pyx_type_5skbio_8metadata_13_intersection_IntervalObj) < 0) __PYX_ERR(1, 305, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_5skbio_8metadata_13_intersection_IntervalObj.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5skbio_8metadata_13_intersection_IntervalObj.tp_dictoffset && __pyx_type_5skbio_8metadata_13_intersection_IntervalObj.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_5skbio_8metadata_13_intersection_IntervalObj.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_IntervalObj, (PyObject *)&__pyx_type_5skbio_8metadata_13_intersection_IntervalObj) < 0) __PYX_ERR(1, 305, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5skbio_8metadata_13_intersection_IntervalObj) < 0) __PYX_ERR(1, 305, __pyx_L1_error) __pyx_ptype_5skbio_8metadata_13_intersection_IntervalObj = &__pyx_type_5skbio_8metadata_13_intersection_IntervalObj; if (PyType_Ready(&__pyx_type_5skbio_8metadata_13_intersection_IntervalTree) < 0) __PYX_ERR(1, 357, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_5skbio_8metadata_13_intersection_IntervalTree.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_5skbio_8metadata_13_intersection_IntervalTree.tp_dictoffset && __pyx_type_5skbio_8metadata_13_intersection_IntervalTree.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_5skbio_8metadata_13_intersection_IntervalTree.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_IntervalTree, (PyObject *)&__pyx_type_5skbio_8metadata_13_intersection_IntervalTree) < 0) __PYX_ERR(1, 357, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_5skbio_8metadata_13_intersection_IntervalTree) < 0) __PYX_ERR(1, 357, __pyx_L1_error) __pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree = &__pyx_type_5skbio_8metadata_13_intersection_IntervalTree; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_intersection(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_intersection(void) #else __Pyx_PyMODINIT_FUNC PyInit__intersection(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__intersection(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__intersection(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; float __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_intersection' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__intersection(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_intersection", __pyx_methods, __pyx_k_Data_structure_for_performing_i, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(1, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__metadata___intersection) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.metadata._intersection")) { if (unlikely(PyDict_SetItemString(modules, "skbio.metadata._intersection", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(1, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error) #endif /* "skbio/metadata/_intersection.pyx":28 * #cython: cdivision=True * * import operator # <<<<<<<<<<<<<< * * cdef extern from "stdlib.h": */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_operator, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_operator, __pyx_t_1) < 0) __PYX_ERR(1, 28, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":64 * return a * * cdef float nlog = -1.0 / log(0.5) # <<<<<<<<<<<<<< * * cdef class IntervalNode: */ __pyx_t_2 = log(0.5); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(1, 64, __pyx_L1_error) } __pyx_v_5skbio_8metadata_13_intersection_nlog = (-1.0 / __pyx_t_2); /* "skbio/metadata/_intersection.pyx":182 * return results * * find = intersect # <<<<<<<<<<<<<< * * cdef void _intersect( IntervalNode self, int start, int end, list results): */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode, __pyx_n_s_intersect); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode->tp_dict, __pyx_n_s_find, __pyx_t_1) < 0) __PYX_ERR(1, 182, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode); /* "skbio/metadata/_intersection.pyx":301 * if self.cright is not EmptyNode: self.cright._traverse(func) * * cdef IntervalNode EmptyNode = IntervalNode( 0, 0, IntervalObj(0, 0)) # <<<<<<<<<<<<<< * * ## ---- Wrappers that retain the old interface ------------------------------- */ __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalObj), __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_0); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalNode), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XGOTREF(((PyObject *)__pyx_v_5skbio_8metadata_13_intersection_EmptyNode)); __Pyx_DECREF_SET(__pyx_v_5skbio_8metadata_13_intersection_EmptyNode, ((struct __pyx_obj_5skbio_8metadata_13_intersection_IntervalNode *)__pyx_t_1)); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":429 * self.root = self.root.insert( start, end, value ) * * add = insert # <<<<<<<<<<<<<< * * */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree, __pyx_n_s_insert); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree->tp_dict, __pyx_n_s_add, __pyx_t_1) < 0) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree); /* "skbio/metadata/_intersection.pyx":476 * self.insert( interval.start, interval.end, interval ) * * add_interval = insert_interval # <<<<<<<<<<<<<< * * def before_interval( self, interval, num_intervals=1, max_dist=2500 ): */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree, __pyx_n_s_insert_interval); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree->tp_dict, __pyx_n_s_add_interval, __pyx_t_1) < 0) __PYX_ERR(1, 476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree); /* "skbio/metadata/_intersection.pyx":529 * * # For backward compatibility * Intersecter = IntervalTree # <<<<<<<<<<<<<< */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_Intersecter, ((PyObject *)__pyx_ptype_5skbio_8metadata_13_intersection_IntervalTree)) < 0) __PYX_ERR(1, 529, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_IntervalObj(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_5skbio_8metadata_13_intersection_1__pyx_unpickle_IntervalObj, NULL, __pyx_n_s_skbio_metadata__intersection); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_IntervalObj, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/metadata/_intersection.pyx":1 * # ----------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # This code is taken from bx-python project and added with a new function * # `update` from line 195 to 211. The license for this code is included in */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.metadata._intersection", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.metadata._intersection"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a - b); if (likely((x^a) >= 0 || (x^~b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_subtract(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); } } x = a - b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla - llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("subtract", return NULL) result = ((double)a) - (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* SliceTupleAndList */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) { Py_ssize_t start = *_start, stop = *_stop, length = *_length; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; else if (stop > length) stop = length; *_length = stop - start; *_start = start; *_stop = stop; } static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { PyObject *v; Py_ssize_t i; for (i = 0; i < length; i++) { v = dest[i] = src[i]; Py_INCREF(v); } } static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { PyObject* dest; Py_ssize_t length = PyList_GET_SIZE(src); __Pyx_crop_slice(&start, &stop, &length); if (unlikely(length <= 0)) return PyList_New(0); dest = PyList_New(length); if (unlikely(!dest)) return NULL; __Pyx_copy_object_array( ((PyListObject*)src)->ob_item + start, ((PyListObject*)dest)->ob_item, length); return dest; } static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { PyObject* dest; Py_ssize_t length = PyTuple_GET_SIZE(src); __Pyx_crop_slice(&start, &stop, &length); if (unlikely(length <= 0)) return PyTuple_New(0); dest = PyTuple_New(length); if (unlikely(!dest)) return NULL; __Pyx_copy_object_array( ((PyTupleObject*)src)->ob_item + start, ((PyTupleObject*)dest)->ob_item, length); return dest; } #endif /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a + b); if (likely((x^a) >= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyIntCompare */ static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { if (op1 == op2) { Py_RETURN_TRUE; } #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long a = PyInt_AS_LONG(op1); if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { int unequal; unsigned long uintval; Py_ssize_t size = Py_SIZE(op1); const digit* digits = ((PyLongObject*)op1)->ob_digit; if (intval == 0) { if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } else if (intval < 0) { if (size >= 0) Py_RETURN_FALSE; intval = -intval; size = -size; } else { if (size <= 0) Py_RETURN_FALSE; } uintval = (unsigned long) intval; #if PyLong_SHIFT * 4 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 4)) { unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 3 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 3)) { unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 2 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 2)) { unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif #if PyLong_SHIFT * 1 < SIZEOF_LONG*8 if (uintval >> (PyLong_SHIFT * 1)) { unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); } else #endif unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; } return ( PyObject_RichCompare(op1, op2, Py_EQ)); } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* GetNameInClass */ static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) { PyObject *result; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); __Pyx_GetModuleGlobalNameUncached(result, name); return result; } static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { PyObject *result; result = __Pyx_PyObject_GetAttrStr(nmspace, name); if (!result) { result = __Pyx_GetGlobalNameAfterAttributeLookup(name); } return result; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/metadata/_intersection.pyx000066400000000000000000000443521446255456000221030ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # This code is taken from bx-python project and added with a new function # `update` from line 195 to 211. The license for this code is included in # licenses/bx_python.txt. # ----------------------------------------------------------------------------- """ Data structure for performing intersect queries on a set of intervals which preserves all information about the intervals (unlike bitset projection methods). :Authors: James Taylor (james@jamestaylor.org), Ian Schenk (ian.schenck@gmail.com), Brent Pedersen (bpederse@gmail.com) """ # Historical note: # This module original contained an implementation based on sorted endpoints # and a binary search, using an idea from Scott Schwartz and Piotr Berman. # Later an interval tree implementation was implemented by Ian for Galaxy's # join tool (see `bx.intervals.operations.quicksect.py`). This was then # converted to Cython by Brent, who also added support for # upstream/downstream/neighbor queries. This was modified by James to # handle half-open intervals strictly, to maintain sort order, and to # implement the same interface as the original Intersecter. #cython: cdivision=True import operator cdef extern from "stdlib.h": int ceil(float f) float log(float f) int RAND_MAX int rand() int strlen(char *) int iabs(int) cdef inline int imax2(int a, int b): if b > a: return b return a cdef inline int imax3(int a, int b, int c): if b > a: if c > b: return c return b if a > c: return a return c cdef inline int imin3(int a, int b, int c): if b < a: if c < b: return c return b if a < c: return a return c cdef inline int imin2(int a, int b): if b < a: return b return a cdef float nlog = -1.0 / log(0.5) cdef class IntervalNode: """ A single node of an `IntervalTree`. NOTE: Unless you really know what you are doing, you probably should us `IntervalTree` rather than using this directly. """ cdef float priority cdef public object interval cdef public int start, end cdef int minend, maxend, minstart cdef IntervalNode cleft, cright, croot property left_node: def __get__(self): return self.cleft if self.cleft is not EmptyNode else None property right_node: def __get__(self): return self.cright if self.cright is not EmptyNode else None property root_node: def __get__(self): return self.croot if self.croot is not EmptyNode else None def __repr__(self): return "IntervalNode(%i, %i)" % (self.start, self.end) def __cinit__(IntervalNode self, int start, int end, object interval): # Python lacks the binomial distribution, so we convert a # uniform into a binomial because it naturally scales with # tree size. Also, python's uniform is perfect since the # upper limit is not inclusive, which gives us undefined here. self.priority = ceil(nlog * log(-1.0/(1.0 * rand()/RAND_MAX - 1))) self.start = start self.end = end self.interval = interval self.maxend = end self.minstart = start self.minend = end self.cleft = EmptyNode self.cright = EmptyNode self.croot = EmptyNode cpdef IntervalNode insert(IntervalNode self, int start, int end, object interval): """ Insert a new IntervalNode into the tree of which this node is currently the root. The return value is the new root of the tree (which may or may not be this node!) """ cdef IntervalNode croot = self # If starts are the same, decide which to add interval to based on # end, thus maintaining sortedness relative to start/end cdef int decision_endpoint = start if start == self.start: decision_endpoint = end if decision_endpoint > self.start: # insert to cright tree if self.cright is not EmptyNode: self.cright = self.cright.insert( start, end, interval ) else: self.cright = IntervalNode( start, end, interval ) # rebalance tree if self.priority < self.cright.priority: croot = self.rotate_left() else: # insert to cleft tree if self.cleft is not EmptyNode: self.cleft = self.cleft.insert( start, end, interval) else: self.cleft = IntervalNode( start, end, interval) # rebalance tree if self.priority < self.cleft.priority: croot = self.rotate_right() croot.set_ends() self.cleft.croot = croot self.cright.croot = croot return croot cdef IntervalNode rotate_right(IntervalNode self): cdef IntervalNode croot = self.cleft self.cleft = self.cleft.cright croot.cright = self self.set_ends() return croot cdef IntervalNode rotate_left(IntervalNode self): cdef IntervalNode croot = self.cright self.cright = self.cright.cleft croot.cleft = self self.set_ends() return croot cdef inline void set_ends(IntervalNode self): if self.cright is not EmptyNode and self.cleft is not EmptyNode: self.maxend = imax3(self.end, self.cright.maxend, self.cleft.maxend) self.minend = imin3(self.end, self.cright.minend, self.cleft.minend) self.minstart = imin3(self.start, self.cright.minstart, self.cleft.minstart) elif self.cright is not EmptyNode: self.maxend = imax2(self.end, self.cright.maxend) self.minend = imin2(self.end, self.cright.minend) self.minstart = imin2(self.start, self.cright.minstart) elif self.cleft is not EmptyNode: self.maxend = imax2(self.end, self.cleft.maxend) self.minend = imin2(self.end, self.cleft.minend) self.minstart = imin2(self.start, self.cleft.minstart) def intersect( self, int start, int end, sort=True ): """ given a start and a end, return a list of features falling within that range """ cdef list results = [] self._intersect( start, end, results ) return results find = intersect cdef void _intersect( IntervalNode self, int start, int end, list results): cdef int send, qend # Left subtree if self.cleft is not EmptyNode and self.cleft.maxend >= start: self.cleft._intersect( start, end, results ) # This interval if start == end: qend = end else: qend = end - 1 if self.end == self.start: send = self.end else: send = self.end - 1 if ( send >= start ) and ( self.start <= qend ): results.append( self.interval ) # Right subtree if self.cright is not EmptyNode and self.start <= qend: self.cright._intersect( start, end, results ) cpdef void update(IntervalNode self, int start, int end, object old_feature, object new_feature): """ given a start and end, replace all objects that match the old_feature with new_feature. """ # Left subtree if self.cleft is not EmptyNode and self.cleft.maxend > start: self.cleft.update( start, end, old_feature, new_feature ) # This interval if ( self.end > start ) and ( self.start < end ): if self.interval == old_feature: self.interval = new_feature # Right subtree if self.cright is not EmptyNode and self.start < end: self.cright.update( start, end, old_feature, new_feature ) cdef void _seek_left(IntervalNode self, int position, list results, int n, int max_dist): # we know we can bail in these 2 cases. if self.maxend + max_dist < position: return if self.minstart > position: return # the ordering of these 3 blocks makes it so the results are # ordered nearest to farest from the query position if self.cright is not EmptyNode: self.cright._seek_left(position, results, n, max_dist) if -1 < position - self.end < max_dist: results.append(self.interval) # TODO: can these conditionals be more stringent? if self.cleft is not EmptyNode: self.cleft._seek_left(position, results, n, max_dist) cdef void _seek_right(IntervalNode self, int position, list results, int n, int max_dist): # we know we can bail in these 2 cases. if self.maxend < position: return if self.minstart - max_dist > position: return #print "SEEK_RIGHT:",self, self.cleft, self.maxend, self.minstart, position # the ordering of these 3 blocks makes it so the results are # ordered nearest to farest from the query position if self.cleft is not EmptyNode: self.cleft._seek_right(position, results, n, max_dist) if -1 < self.start - position < max_dist: results.append(self.interval) if self.cright is not EmptyNode: self.cright._seek_right(position, results, n, max_dist) cpdef left(self, position, int n=1, int max_dist=2500): """ find n features with a start > than `position` f: a Interval object (or anything with an `end` attribute) n: the number of features to return max_dist: the maximum distance to look before giving up. """ cdef list results = [] # use start - 1 becuase .left() assumes strictly left-of self._seek_left( position - 1, results, n, max_dist ) if len(results) == n: return results r = results r.sort(key=operator.attrgetter('end'), reverse=True) return r[:n] cpdef right(self, position, int n=1, int max_dist=2500): """ find n features with a end < than position f: a Interval object (or anything with a `start` attribute) n: the number of features to return max_dist: the maximum distance to look before giving up. """ cdef list results = [] # use end + 1 becuase .right() assumes strictly right-of self._seek_right(position + 1, results, n, max_dist) if len(results) == n: return results r = results r.sort(key=operator.attrgetter('start')) return r[:n] def traverse(self, func): self._traverse(func) cdef void _traverse(IntervalNode self, object func): if self.cleft is not EmptyNode: self.cleft._traverse(func) func(self) if self.cright is not EmptyNode: self.cright._traverse(func) cdef IntervalNode EmptyNode = IntervalNode( 0, 0, IntervalObj(0, 0)) ## ---- Wrappers that retain the old interface ------------------------------- cdef class IntervalObj: """ Basic feature, with required integer start and end properties. Also accepts optional strand as +1 or -1 (used for up/downstream queries), a name, and any arbitrary data is sent in on the info keyword argument >>> from skbio.metadata._intersection import IntervalObj >>> f1 = IntervalObj(23, 36) >>> f2 = IntervalObj(34, 48, value={'chr':12, 'anno':'transposon'}) >>> f2 # doctest: +SKIP IntervalObj(34, 48, value={'anno': 'transposon', 'chr': 12}) """ cdef public int start, end cdef public object value, chrom, strand def __init__(self, int start, int end, object value=None, object chrom=None, object strand=None ): assert start <= end, "start must be less than end" self.start = start self.end = end self.value = value self.chrom = chrom self.strand = strand def __repr__(self): fstr = "IntervalObj(%d, %d" % (self.start, self.end) if not self.value is None: fstr += ", value=" + str(self.value) fstr += ")" return fstr def __richcmp__(self, other, op): if op == 0: # < return self.start < other.start or self.end < other.end elif op == 1: # <= return self == other or self < other elif op == 2: # == return self.start == other.start and self.end == other.end elif op == 3: # != return self.start != other.start or self.end != other.end elif op == 4: # > return self.start > other.start or self.end > other.end elif op == 5: # >= return self == other or self > other cdef class IntervalTree: """ Data structure for performing window intersect queries on a set of of possibly overlapping 1d intervals. Usage ===== Create an empty IntervalTree >>> from skbio.metadata._intersection import IntervalObj, IntervalTree >>> intersecter = IntervalTree() An interval is a start and end position and a value (possibly None). You can add any object as an interval: >>> intersecter.insert( 0, 10, "food" ) >>> intersecter.insert( 3, 7, dict(foo='bar') ) >>> intersecter.find( 2, 5 ) ['food', {'foo': 'bar'}] If the object has start and end attributes (like the Interval class) there is are some shortcuts: >>> intersecter = IntervalTree() >>> intersecter.insert_interval( IntervalObj( 0, 10 ) ) >>> intersecter.insert_interval( IntervalObj( 3, 7 ) ) >>> intersecter.insert_interval( IntervalObj( 3, 40 ) ) >>> intersecter.insert_interval( IntervalObj( 13, 50 ) ) >>> intersecter.find( 30, 50 ) [IntervalObj(3, 40), IntervalObj(13, 50)] >>> intersecter.find( 100, 200 ) [] Before/after for intervals >>> intersecter.before_interval( IntervalObj( 10, 20 ) ) [IntervalObj(3, 7)] >>> intersecter.before_interval( IntervalObj( 5, 20 ) ) [] Upstream/downstream >>> intersecter.upstream_of_interval(IntervalObj(11, 12)) [IntervalObj(0, 10)] >>> intersecter.upstream_of_interval(IntervalObj(11, 12, strand="-")) [IntervalObj(13, 50)] >>> intersecter.upstream_of_interval(IntervalObj(1, 2, strand="-"), num_intervals=3) [IntervalObj(3, 7), IntervalObj(3, 40), IntervalObj(13, 50)] """ cdef IntervalNode root def __cinit__( self ): root = None # ---- Position based interfaces ----------------------------------------- def insert( self, int start, int end, object value=None ): """ Insert the interval [start,end) associated with value `value`. """ if self.root is None: self.root = IntervalNode( start, end, value ) else: self.root = self.root.insert( start, end, value ) add = insert def update( self, start, end, old_feature, new_feature): """ Given an interval [start, end), replace all objects that match the `old_feature` with `new_feature`. """ if self.root is not None: self.root.update(start, end, old_feature, new_feature) def find( self, start, end ): """ Return a sorted list of all intervals overlapping [start,end). """ if self.root is None: return [] return self.root.find( start, end ) def before( self, position, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie before `position` and are no further than `max_dist` positions away """ if self.root is None: return [] return self.root.left( position, num_intervals, max_dist ) def after( self, position, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie after `position` and are no further than `max_dist` positions away """ if self.root is None: return [] return self.root.right( position, num_intervals, max_dist ) # ---- Interval-like object based interfaces ----------------------------- def insert_interval( self, interval ): """ Insert an "interval" like object (one with at least start and end attributes) """ self.insert( interval.start, interval.end, interval ) add_interval = insert_interval def before_interval( self, interval, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie completely before `interval` and are no further than `max_dist` positions away """ if self.root is None: return [] return self.root.left( interval.start, num_intervals, max_dist ) def after_interval( self, interval, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie completely after `interval` and are no further than `max_dist` positions away """ if self.root is None: return [] return self.root.right( interval.end, num_intervals, max_dist ) def upstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie completely upstream of `interval` and are no further than `max_dist` positions away """ if self.root is None: return [] if interval.strand == -1 or interval.strand == "-": return self.root.right( interval.end, num_intervals, max_dist ) else: return self.root.left( interval.start, num_intervals, max_dist ) def downstream_of_interval( self, interval, num_intervals=1, max_dist=2500 ): """ Find `num_intervals` intervals that lie completely downstream of `interval` and are no further than `max_dist` positions away """ if self.root is None: return [] if interval.strand == -1 or interval.strand == "-": return self.root.left( interval.start, num_intervals, max_dist ) else: return self.root.right( interval.end, num_intervals, max_dist ) def traverse(self, fn): """ call fn for each element in the tree """ if self.root is None: return None return self.root.traverse(fn) # For backward compatibility Intersecter = IntervalTree scikit-bio-0.5.9/skbio/metadata/_interval.py000066400000000000000000001066311446255456000210300ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import operator import copy import functools from ._intersection import IntervalTree from skbio.util._decorator import experimental, classonlymethod class Interval: """Stores the bounds and metadata of an interval feature. This class stores an interval feature. An interval feature is defined as a sub-region of a biological sequence or sequence alignment that is a functional entity, e.g., a gene, a riboswitch, an exon, etc. It can span a single contiguous region or multiple non-contiguous regions (e.g. multiple exons in a transcript, or multiple genes in an operon). Parameters ---------- interval_metadata : object A reference to the ``IntervalMetadata`` object that this ``Interval`` object is associated to. bounds : iterable of tuple of int Tuples representing start and end coordinates. It is *zero-based* numbering. It is always inclusive on start bound and exclusive on end bound. fuzzy : iterable of tuple of bool, optional Tuples representing the fuzziness of each bound coordinates. If this isn't specified, then the fuzziness of all bound coordinates are ``False``. If any of the coordinate fuzziness is ``True``, it indicates that the exact bound point of a interval feature is unknown. The bound may begin or end at some points outside the specified coordinates. This accommodates the location format [1]_ of INSDC. metadata : dict, optional Dictionary of attributes storing information of the feature such as "strand", "gene_name", or "product". See Also -------- skbio.metadata.IntervalMetadata Notes ----- While the construction of an ``Interval`` object automatically add itself to its associated ``IntervalMetadata`` object, ``IntervalMetadata.add`` is the typical/easier way to create and add it to ``IntervalMetadata``. References ---------- .. [1] ftp://ftp.ebi.ac.uk/pub/databases/embl/doc/FT_current.html#3.4.3 Examples -------- Hypothetically, let's say we have a gene called "genA" with 10 nt as shown in the following diagram. The second row represents the two exons (indicated by "=") on this gene: :: TGGATTCTGC -====--==- 0123456789 We can create an ``Interval`` object to represent the exons of the gene: >>> from skbio.metadata import Interval, IntervalMetadata >>> interval_metadata = IntervalMetadata(10) Remember the coordinates are inclusive in lower bound and exclusive on upper bound: >>> gene = Interval(interval_metadata, ... bounds=[(1, 5), (7, 9)], ... metadata={'name': 'genA'}) >>> gene # doctest: +ELLIPSIS Interval(interval_metadata=..., bounds=[(1, 5), (7, 9)], \ fuzzy=[(False, False), (False, False)], metadata={'name': 'genA'}) """ def __init__(self, interval_metadata, bounds, fuzzy=None, metadata=None): if not isinstance(interval_metadata, IntervalMetadata): raise TypeError('You need to provide an IntervalMetadata' 'object, not %r' % interval_metadata) # Intervals self._interval_metadata = interval_metadata self._bounds_fuzzy_setter(bounds, fuzzy) # Metadata if metadata is None: metadata = {} self.metadata = metadata # add this interval feature to the associated IntervalMetadata self._add() def _add(self): """Add the current ``Interval`` to the IntervalMetadata object.""" for bound in self.bounds: start, end = bound self._interval_metadata._interval_tree.add(start, end, self) self._interval_metadata._intervals.append(self) @experimental(as_of='0.5.1') def __eq__(self, other): '''Test if this ``Interval`` object is equal to another. The equality is performed by checking if the ``metadata``, ``bounds`` and ``fuzzy`` are equal. Since the ``bounds`` and the ``fuzzy`` are sorted, the permutations of them during the ``Interval`` construction or assignment won't matter. Parameters ---------- other : Interval Interval to test for equality against. Returns ------- bool Indicates if the two objects are equal. ''' return ((self.metadata == other.metadata) and (self.bounds == other.bounds) and (self.fuzzy == other.fuzzy)) @experimental(as_of='0.5.1') def __ne__(self, other): '''Test if this ``Interval`` object is not equal to another. Parameters ---------- other : Interval Interval to test for inequality against. Returns ------- bool Indicates if the two objects are not equal. ''' return not (self == other) @experimental(as_of='0.5.1') def __repr__(self): '''Return a string representation of this ``Interval`` object. Returns ------- str String representation of this ``Interval`` object. ''' if self.dropped: s = ('{}(dropped=True, bounds={!r}, ' 'fuzzy={!r}, metadata={!r})') return s.format(self.__class__.__name__, self.bounds, self.fuzzy, self.metadata) else: s = ('{}(interval_metadata=<{!r}>, bounds={!r}, ' 'fuzzy={!r}, metadata={!r})') return s.format(self.__class__.__name__, id(self._interval_metadata), self.bounds, self.fuzzy, self.metadata) @experimental(as_of='0.5.1') def drop(self): '''Drop this ``Interval`` object from interval metadata it links to. If the ``Interval`` object is dropped, you can still get values of ``bounds``, ``fuzzy``, and ``metadata`` attributes, but you can not change their values with the setters. See Also -------- skbio.metadata.IntervalMetadata.drop ''' if not self.dropped: self._interval_metadata.drop([self]) def _bounds_fuzzy_setter(self, bounds=None, fuzzy=None): if self.dropped: raise RuntimeError('Cannot change `bounds` or `fuzzy` ' 'on a dropped Interval object.') # Casts to `list`, validation, sorting, and setting of `bounds` # and `fuzzy` happen here. if bounds is not None: # check iterability try: # check iterability bounds = list(bounds) except TypeError: raise TypeError('Cannot give an non-iterable (%r) ' 'to `bounds`.' % bounds) # check it is not empty if not bounds: raise ValueError('Cannot give empty `bounds`.') # check each contiguous span is in right format for bound in bounds: _assert_valid_bound(bound) spans = len(bounds) else: spans = len(self.bounds) if fuzzy is not None: try: fuzzy = list(fuzzy) except TypeError: raise TypeError( 'Cannot give a non-iterable (%r) ' 'to `fuzzy`.' % fuzzy) if len(fuzzy) != spans: raise ValueError( 'The length of fuzzy must ' 'be equal to the length of bounds.') for fuzzy_i in fuzzy: _assert_valid_fuzzy(fuzzy_i) if bounds is None: # `bounds` and `fuzzy` cannot both be omitted. if fuzzy is None: raise ValueError('Cannot give `None` to both `bounds` ' 'and `fuzzy`.') # If only `fuzzy` is provided, set `self.fuzzy` and don't # change `self.bounds`. else: self._fuzzy = fuzzy else: # If only `bounds` is provided, reset `self.fuzzy` to # all `False`. if fuzzy is None: bounds.sort() self._check_bounds(bounds) self._bounds = bounds # reset all the fuzzy to False!! del self.fuzzy # If both `bounds` and `fuzzy` are provided, set # `self.bounds` and `self.fuzzy`. else: bounds, fuzzy = [ list(e) for e in zip(*sorted(zip(bounds, fuzzy)))] self._check_bounds(bounds) self._bounds = bounds self._fuzzy = fuzzy self._interval_metadata._is_stale_tree = True def _check_bounds(self, bounds): '''input `bounds` must be sorted.''' upper_bound = self._interval_metadata.upper_bound lower_bound = self._interval_metadata.lower_bound if upper_bound is not None and bounds[-1][-1] > upper_bound: raise ValueError('Cannot set `bounds` (%r) with coordinate ' 'larger than upper bound (%r)' % (bounds, upper_bound)) if bounds[0][0] < lower_bound: raise ValueError('Cannot set `bounds` (%r) with coordinate ' 'smaller than lower bound (%r).' % (bounds, lower_bound)) @property @experimental(as_of='0.5.1') def fuzzy(self): '''The openness of each coordinate. This indicates that the exact bound of a interval feature is unknown. The bound may begin or end at some points outside the specified coordinates. This accommodates the bound format [1]_ of INSDC. References ---------- .. [1] ftp://ftp.ebi.ac.uk/pub/databases/embl/doc/FT_current.html#3.4.3 ''' return self._fuzzy @fuzzy.setter @experimental(as_of='0.5.1') def fuzzy(self, value): '''Set ``fuzzy``. The ``value`` should an iterable matching ``self.bounds``. ''' self._bounds_fuzzy_setter(fuzzy=value) @fuzzy.deleter @experimental(as_of='0.5.1') def fuzzy(self): '''Delete ``fuzzy``. This set all fuzzy to be ``False``. ''' if self.dropped: raise RuntimeError('Cannot change fuzzy on dropped ' 'Interval object.') self._fuzzy = [(False, False)] * len(self.bounds) @property @experimental(as_of='0.5.1') def bounds(self): '''The coordinates of the interval feature. It should be a list of tuples of int pair. Each tuple stores the start and end coordinates of a span of the interval feature. The coordinates are *zero-based*. They are inclusive on the start and exclusive on the end. ''' return self._bounds @bounds.setter @experimental(as_of='0.5.1') def bounds(self, value): '''Set ``bounds``. WARNING: setting ``bounds`` will reset ``fuzzy`` value to ``False``. This is not totally surprising because it is justifiable your old ``fuzzy`` don't fit the new bounds. ''' self._bounds_fuzzy_setter(bounds=value) @property @experimental(as_of='0.5.1') def metadata(self): '''The metadata of the interval feature. It stores the metadata (eg. gene name, function, ID, etc.) of the interval feature as a ``dict``. ''' return self._metadata @metadata.setter @experimental(as_of='0.5.1') def metadata(self, value): if self.dropped: raise RuntimeError('Cannot change metadata on dropped ' 'Interval object.') if not isinstance(value, dict): raise TypeError("metadata must be a dict, not %r" % value) self._metadata = value @metadata.deleter @experimental(as_of='0.5.1') def metadata(self): '''Delete metadata. This sets metadata to be empty dict. ''' if self.dropped: raise RuntimeError('Cannot change metadata to dropped ' 'Interval object.') self._metadata = {} @property @experimental(as_of='0.5.1') def dropped(self): '''Boolean value indicating if the ``Interval`` object is dropped. If it is dropped, it means it is not associated with IntervalMetadata object any more. Notes ----- This property is not writable. See Also -------- skbio.metadata.Interval.drop skbio.metadata.IntervalMetadata.drop ''' return self._interval_metadata is None class IntervalMetadata(): """Stores the interval features. ``IntervalMetadata`` object allows storage, modification, and querying of interval features covering a region of a single coordinate system. For instance, this can be used to store functional annotations about genes across a genome. This object is also applied to the sequence alignment. This object is typically coupled with another object, such as a ``Sequence`` object (or its child class), or a ``TabularMSA`` object. Parameters ---------- upper_bound : int or None Defines the exclusive upper bound of the interval features. No coordinate can be greater than it. ``None`` means that the coordinate space is unbounded. copy_from : IntervalMetadata or None, optional Create a new object from the input ``IntervalMetadata`` object by shallow copying if it is not ``None``. The upper bound of the new object will be updated with the ``upper_bound`` parameter specified. Notes ----- This class stores coordinates of all feature bounds into a interval tree. It allows the speed up of query-by-bound. The building of interval tree is deferred until necessary to save computation. It is updated from all coordinates only when you need to fetch info from the interval tree. When you add a method into this class and if you method need to fetch info from ``IntervalMetadata._interval_tree``, you should decorate it with ``_rebuild_tree``. This decorator will check if the current interval tree is stale and will update it if so. Additionally, if your method add, delete, or changes the coordinates of any interval features, you should set ``self._is_stale_tree`` to ``True`` at the end of your method to indicate the interval tree becomes stale. See Also -------- skbio.metadata.Interval Examples -------- Let's say we have a sequence of length 10 and want to add annotation to it. Create an ``IntervalMetadata`` object: >>> from skbio.metadata import Interval, IntervalMetadata >>> im = IntervalMetadata(10) Let's add annotations of 3 genes: >>> im.add(bounds=[(3, 9)], ... metadata={'gene': 'sagB'}) # doctest: +ELLIPSIS Interval(interval_metadata=..., bounds=[(3, 9)], \ fuzzy=[(False, False)], metadata={'gene': 'sagB'}) >>> im.add(bounds=[(3, 7)], ... metadata={'gene': 'sagC'}) # doctest: +ELLIPSIS Interval(interval_metadata=..., bounds=[(3, 7)], \ fuzzy=[(False, False)], metadata={'gene': 'sagC'}) >>> im.add(bounds=[(1, 2), (4, 7)], ... metadata={'gene': 'sagA'}) # doctest: +ELLIPSIS Interval(interval_metadata=..., bounds=[(1, 2), (4, 7)], \ fuzzy=[(False, False), (False, False)], metadata={'gene': 'sagA'}) Show the object representation: >>> im # doctest: +ELLIPSIS 3 interval features ------------------- Interval(interval_metadata=..., bounds=[(3, 9)], \ fuzzy=[(False, False)], metadata={'gene': 'sagB'}) Interval(interval_metadata=..., bounds=[(3, 7)], \ fuzzy=[(False, False)], metadata={'gene': 'sagC'}) Interval(interval_metadata=..., bounds=[(1, 2), (4, 7)], \ fuzzy=[(False, False), (False, False)], metadata={'gene': 'sagA'}) We can sort the genes by their bounds: >>> im.sort() >>> im # doctest: +ELLIPSIS 3 interval features ------------------- Interval(interval_metadata=..., bounds=[(1, 2), (4, 7)], \ fuzzy=[(False, False), (False, False)], metadata={'gene': 'sagA'}) Interval(interval_metadata=..., bounds=[(3, 7)], \ fuzzy=[(False, False)], metadata={'gene': 'sagC'}) Interval(interval_metadata=..., bounds=[(3, 9)], \ fuzzy=[(False, False)], metadata={'gene': 'sagB'}) Query the genes by bound and/or metadata: >>> intvls = im.query([(1, 2)], metadata={'gene': 'foo'}) >>> list(intvls) [] >>> intvls = im.query([(7, 9)]) >>> list(intvls) # doctest: +ELLIPSIS [Interval(interval_metadata=..., bounds=[(3, 9)], \ fuzzy=[(False, False)], metadata={'gene': 'sagB'})] >>> intvls = im.query(metadata={'gene': 'sagA'}) >>> intvls = list(intvls) >>> intvls # doctest: +ELLIPSIS [Interval(interval_metadata=..., bounds=[(1, 2), (4, 7)], \ fuzzy=[(False, False), (False, False)], metadata={'gene': 'sagA'})] Drop the gene(s) we get from query: >>> im.drop(intvls) >>> im.sort() >>> im # doctest: +ELLIPSIS 2 interval features ------------------- Interval(interval_metadata=..., bounds=[(3, 7)], \ fuzzy=[(False, False)], metadata={'gene': 'sagC'}) Interval(interval_metadata=..., bounds=[(3, 9)], \ fuzzy=[(False, False)], metadata={'gene': 'sagB'}) """ default_write_format = 'gff3' def __init__(self, upper_bound, copy_from=None): self._upper_bound = upper_bound if self.upper_bound is not None: if self.upper_bound < self.lower_bound: raise ValueError('Cannot set `upper_bound` (%r) ' 'smaller than `lower_bound` (%r)' % (self.upper_bound, self.lower_bound)) # List of Interval objects. self._intervals = [] # IntervalTree object to allow faster querying of interval objects. self._interval_tree = IntervalTree() # Indicates if the IntervalTree needs to be rebuilt. self._is_stale_tree = False if copy_from is not None: for interval in copy_from._intervals: bounds_cp = interval.bounds[:] fuzzy_cp = interval.fuzzy[:] metadata_cp = copy.copy(interval.metadata) self.add(bounds_cp, fuzzy=fuzzy_cp, metadata=metadata_cp) @property @experimental(as_of='0.5.1') def upper_bound(self): '''The exclusive upper bound of interval features.''' return self._upper_bound @property @experimental(as_of='0.5.1') def lower_bound(self): '''The inclusive lower bound of interval features.''' return 0 @property @experimental(as_of='0.5.1') def num_interval_features(self): '''The total number of interval features.''' return len(self._intervals) def _rebuild_tree(method): """Rebuild the IntervalTree.""" @functools.wraps(method) def inner(self, *args, **kwargs): if self._is_stale_tree is False: return method(self, *args, **kwargs) self._interval_tree = IntervalTree() for f in self._intervals: for start, end in f.bounds: self._interval_tree.add(start, end, f) self._is_stale_tree = False return method(self, *args, **kwargs) return inner def _reverse(self): """Reverse ``IntervalMetadata`` object. This operation reverses all of the interval coordinates. For instance, this can be used to compare coordinates in the forward strand to coordinates in the reversal strand. """ for f in self._intervals: try: intvls = [(self.upper_bound - x[1], self.upper_bound - x[0]) for x in reversed(f.bounds)] except TypeError: raise TypeError('You cannot reverse the coordinates ' 'when the upper bound is `None`') f.bounds = intvls # DON'T forget this!!! self._is_stale_tree = True @classonlymethod @experimental(as_of="0.5.1") def concat(cls, interval_metadata): '''Concatenate an iterable of ``IntervalMetadata`` objects. It concatenates the multiple ``IntervalMetadata`` objects into one coordinate space. The order of the objects in the input iterable matters. The coordinate of the second ``InterableMetadata`` will be shifted up with the length of the first ``IntervalMetadata`` object. This function is useful when you concatenate multiple sequences. Parameters ---------- interval_metadata : Iterable (IntervalMetadata) The interval metadata to concatenate. Returns ------- IntervalMetadata Concatenated interval metadata. Examples -------- >>> from skbio.metadata import IntervalMetadata Create two ``IntervalMetadata`` objects: >>> im1 = IntervalMetadata(3) >>> _ = im1.add([(0, 2)], [(True, False)], {'gene': 'sagA'}) >>> im2 = IntervalMetadata(4) >>> _ = im2.add([(1, 4)], [(True, True)], {'gene': 'sagB'}) Concatenate them into a single coordinate space. The second ``IntervalMetadata``'s interval features are all shifted up. The resulting ``IntervalMetadata``'s upper bound is the sum of upper bounds of concatenated objects: >>> im = IntervalMetadata.concat([im1, im2]) >>> im # doctest: +ELLIPSIS 2 interval features ------------------- Interval(interval_metadata=<...>, bounds=[(0, 2)], \ fuzzy=[(True, False)], metadata={'gene': 'sagA'}) Interval(interval_metadata=<...>, bounds=[(4, 7)], \ fuzzy=[(True, True)], metadata={'gene': 'sagB'}) >>> im.upper_bound 7 ''' interval_metadata = list(interval_metadata) if len(interval_metadata) == 0: return cls(0) upper_bound = 0 for im in interval_metadata: try: upper_bound += im.upper_bound except TypeError: raise TypeError('You cannot concat the interval metadata ' 'because its upper bound is `None`:\n%r' % im) new = cls(upper_bound) length = 0 for i, im in enumerate(interval_metadata): for intvl in im._intervals: bounds = intvl.bounds fuzzy = intvl.fuzzy if i != 0: bounds = [(start + length, end + length) for start, end in bounds] new.add(bounds, fuzzy, intvl.metadata) length += im.upper_bound return new @experimental(as_of='0.5.1') def merge(self, other): '''Merge the interval features of another ``IntervalMetadata`` object. It adds all the interval features of the other object into ``self``. Note this will not check if there are any duplicates of interval features after merge. Notes ----- It will raise error if you merge an unbounded ``IntervalMetadata`` object to the current object if it is bounded. This avoids partially updating the current object if the merge fails in the middle of the process due to the possibility that some interval features to be merged may live outside the current defined upper bound. Parameters ---------- other : ``IntervalMetadata`` The other ``IntervalMetadata`` to be merged. ''' if self.upper_bound is not None: if other.upper_bound is None: raise ValueError( 'Cannot merge an unbound IntervalMetadata object ' 'to a bounded one') elif self.upper_bound != other.upper_bound: raise ValueError( 'The upper bounds of the two IntervalMetadata objects ' 'are not equal (%r != %r)' % ( self.upper_bound, other.upper_bound)) if self.lower_bound != other.lower_bound: raise ValueError( 'The lower bounds of the two IntervalMetadata objects ' 'are not equal (%d != %d)' % ( self.lower_bound, other.lower_bound)) for intvl in other._intervals: self.add(intvl.bounds, intvl.fuzzy, intvl.metadata) @experimental(as_of='0.5.1') def sort(self, ascending=True): '''Sort interval features by their coordinates. It sorts by the start coordinate first. If they are the same between two interval features, they will be sorted by comparing their end coordinates. For example, an interval feature with [(1, 2), (4, 7)] will be sorted in front of another one with [(1, 2), (3, 8)]. Parameters ---------- ascending : bool, optional sort in ascending or descending coordinates. ''' self._intervals.sort( key=lambda i: [i.bounds[0][0], i.bounds[-1][1]], reverse=not ascending) @experimental(as_of='0.5.1') def add(self, bounds, fuzzy=None, metadata=None): """Create and add an ``Interval`` to this ``IntervalMetadata``. This method creates an ``Interval`` object and inserts it into the ``IntervalMetadata`` object. Parameters ---------- bounds : iterable of tuple of ints Tuples representing start and end coordinates. It is *zero-based* numbering. It is always inclusive on start bound and exclusive on end bound. fuzzy : iterable of tuple of bool, optional Tuples representing the fuzziness of each bound coordinates. metadata : dict, optional A dictionary of key-value pairs associated with the ``Interval`` object. Returns ------- Interval The ``Interval`` object added. See Also -------- skbio.metadata.Interval """ # Add an interval to the tree. Note that the add functionality is # built within the Interval constructor. return Interval(interval_metadata=self, bounds=bounds, fuzzy=fuzzy, metadata=metadata) @_rebuild_tree def _query_interval(self, bound): """Yield ``Interval`` objects that overlap with the bound.""" _assert_valid_bound(bound) start, end = bound intvls = self._interval_tree.find(start, end) # if a ``Interval`` has many non-contiguous spans and # multiple of them overlap with the bound, then # this ``Interval`` object will be returned # multiple times. So we need to remove duplicates. seen = set() for intvl in intvls: if id(intvl) not in seen: seen.add(id(intvl)) yield intvl def _query_attribute(self, metadata, intervals=None): """Yield ``Interval`` objects based on query attributes. Parameters ---------- metadata : dict or ``None`` If it is ``None``, return empty iterator; if it is ``{}``, return an interator of all the ``Interval`` objects. intervals : an iterable of ``Interval`` objects """ if metadata is None: return if intervals is None: intervals = self._intervals for intvl in intervals: for (key, value) in metadata.items(): if (key not in intvl.metadata or intvl.metadata[key] != value): break else: yield intvl @experimental(as_of='0.5.1') @_rebuild_tree def query(self, bounds=None, metadata=None): """Yield ``Interval`` object with the bounds and attributes. The ``Interval`` objects must meet both requirements: 1) overlap with any of the spans specified by ``bounds``; 2) satisfy ``metadata`` specification. For instance, you can identify all the recA genes that overlap with (10, 100) or (900, 1000) with this code ``interval_metadata.query([(10, 100), (900, 1000)], {'gene': 'recA'})``. Parameters ---------- bounds : iterable of tuples of int pair, optional Specifies bounds to look for the ``Interval`` objects. An satisfying interval feature only need to overlap with one bound. Default (``None``) means all ``Intervals`` meet this requirement. metadata : dict, optional A dictionary of key word attributes associated with the ``Interval`` object. It specifies what metadata keywords and values to look for. Default (``None``) means all ``Intervals`` meet this requirement. Yields ------ Interval ``Interval`` object satisfying the search criteria. """ if bounds is None and metadata is None: metadata = {} if bounds is None: for intvl in self._query_attribute(metadata): yield intvl else: for loc in bounds: intvls = self._query_interval(loc) if metadata is None: metadata = {} for intvl in self._query_attribute(metadata, intvls): yield intvl @experimental(as_of='0.5.1') def drop(self, intervals, negate=False): """Drops Interval objects. The given ``Interval`` objects will be removed and their associated ``IntervalMetadata`` will be set to ``None``. Parameters ---------- intervals : iterable of ``Interval`` ``Interval`` objects to drop from this object. negate : bool Negate the drop operation, i.e. keeping the specified intervals instead of dropping them. """ to_delete = {id(f) for f in intervals} new_intvls = [] # iterate through queries and drop them for intvl in self._intervals: drop = id(intvl) in to_delete if negate is True: drop = not drop if drop: intvl._interval_metadata = None else: new_intvls.append(intvl) self._intervals = new_intvls self._is_stale_tree = True @experimental(as_of='0.5.1') def __eq__(self, other): '''Test if this object is equal to another. It checks if the coordinate spaces are the same between the two objects. If so, then check if all the interval features are equal between the two objects after sorting them by bounds. Parameters ---------- other : IntervalMetadata Interval metadata to test for equality against. Returns ------- bool Indicates if the two objects are equal. ''' if self.upper_bound != other.upper_bound or \ self.lower_bound != other.lower_bound: return False else: self_intervals = sorted(self._intervals, key=operator.attrgetter('bounds')) other_intervals = sorted(other._intervals, key=operator.attrgetter('bounds')) return self_intervals == other_intervals @experimental(as_of='0.5.1') def __ne__(self, other): '''Test if this object is not equal to another. Parameters ---------- other : IntervalMetadata Interval metadata to test for inequality against. Returns ------- bool Indicates if the two objects are not equal. See Also -------- skbio.metadata.IntervalMetadata.__eq__ ''' return not (self == other) @experimental(as_of='0.5.1') def __repr__(self): '''Return a string representation of this object. Returns ------- str String representation of this ``IntervalMetadata`` object. ''' n = self.num_interval_features l1 = '{} interval feature'.format(n) if n != 1: l1 += 's' l2 = '-' * len(l1) if n <= 5: items = [repr(i) for i in self._intervals] else: # intentionally overwrite items[2] to make code cleaner items = [repr(self._intervals[i]) for i in [0, 1, 2, n-2, n-1]] items[2] = '...' return '\n'.join([l1, l2] + items) @experimental(as_of='0.5.1') def __copy__(self): '''Return a shallow copy. Notes ----- The ``IntervalMetadata`` copy will have copies of the ``Interval`` objects present in this object. The ``metadata`` dictionary of each ``Interval`` object will be a shallow copy. See Also -------- __deepcopy__ ''' return self._copy(False, {}) @experimental(as_of='0.5.1') def __deepcopy__(self, memo): '''Return a deep copy. Notes ----- The ``IntervalMetadata`` copy will have copies of the ``Interval`` objects present in this object. The ``metadata`` dictionary of each ``Interval`` object will be a deep copy. See Also -------- __copy__ ''' return self._copy(True, memo) def _copy(self, deep, memo): cp = IntervalMetadata(self.upper_bound) for interval in self._intervals: # Only need to shallow-copy `bounds` and `fuzzy` # because their elements are immutable. bounds_cp = interval.bounds[:] fuzzy_cp = interval.fuzzy[:] if deep: metadata_cp = copy.deepcopy(interval.metadata, memo) else: metadata_cp = copy.copy(interval.metadata) cp.add(bounds_cp, fuzzy=fuzzy_cp, metadata=metadata_cp) return cp def _assert_valid_bound(bound): if isinstance(bound, tuple): try: start, end = bound except ValueError: raise ValueError("A `bound` must be a tuple of exactly " "two coordinates, not {!r}".format(bound)) if not (isinstance(start, int) and isinstance(end, int)) or start > end: raise ValueError('`start` (%r) cannot be a larger int ' 'than `end` (%r).' % (start, end)) else: raise TypeError("Each `bound` must be a tuple, not {!r}".format( bound)) def _assert_valid_fuzzy(fuzzy): if isinstance(fuzzy, tuple): try: start, end = fuzzy except ValueError: raise ValueError("A `fuzzy` must be a tuple of exactly " "two, not {!r}".format(fuzzy)) if not (isinstance(start, bool) and isinstance(end, bool)): raise TypeError('A `fuzzy` must be a tuple of two booleans') else: raise TypeError("Each `fuzzy` must be a tuple, not {!r}".format( fuzzy)) scikit-bio-0.5.9/skbio/metadata/_mixin.py000066400000000000000000000441531446255456000203300ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import abc import copy import pandas as pd from skbio.util._decorator import stable, experimental from skbio.metadata import IntervalMetadata class MetadataMixin(metaclass=abc.ABCMeta): @property @stable(as_of="0.4.0") def metadata(self): """``dict`` containing metadata which applies to the entire object. Notes ----- This property can be set and deleted. When setting new metadata a shallow copy of the dictionary is made. Examples -------- .. note:: scikit-bio objects with metadata share a common interface for accessing and manipulating their metadata. The following examples use scikit-bio's ``Sequence`` class to demonstrate metadata behavior. These examples apply to all other scikit-bio objects storing metadata. Create a sequence with metadata: >>> from pprint import pprint >>> from skbio import Sequence >>> seq = Sequence('ACGT', metadata={'description': 'seq description', ... 'id': 'seq-id'}) Retrieve metadata: >>> pprint(seq.metadata) # using pprint to display dict in sorted order {'description': 'seq description', 'id': 'seq-id'} Update metadata: >>> seq.metadata['id'] = 'new-id' >>> seq.metadata['pubmed'] = 12345 >>> pprint(seq.metadata) {'description': 'seq description', 'id': 'new-id', 'pubmed': 12345} Set metadata: >>> seq.metadata = {'abc': 123} >>> seq.metadata {'abc': 123} Delete metadata: >>> seq.has_metadata() True >>> del seq.metadata >>> seq.metadata {} >>> seq.has_metadata() False """ if self._metadata is None: # Not using setter to avoid copy. self._metadata = {} return self._metadata @metadata.setter def metadata(self, metadata): if not isinstance(metadata, dict): raise TypeError("metadata must be a dict, not type %r" % type(metadata).__name__) # Shallow copy. self._metadata = metadata.copy() @metadata.deleter def metadata(self): self._metadata = None @abc.abstractmethod def __init__(self, metadata=None): raise NotImplementedError def _init_(self, metadata=None): if metadata is None: # Could use deleter but this is less overhead and needs to be fast. self._metadata = None else: # Use setter for validation and copy. self.metadata = metadata @abc.abstractmethod def __eq__(self, other): raise NotImplementedError def _eq_(self, other): # We're not simply comparing self.metadata to other.metadata in order # to avoid creating "empty" metadata representations on the objects if # they don't have metadata. if self.has_metadata() and other.has_metadata(): return self.metadata == other.metadata elif not (self.has_metadata() or other.has_metadata()): # Both don't have metadata. return True else: # One has metadata while the other does not. return False @abc.abstractmethod def __ne__(self, other): raise NotImplementedError def _ne_(self, other): return not (self == other) @abc.abstractmethod def __copy__(self): raise NotImplementedError def _copy_(self): if self.has_metadata(): return self.metadata.copy() else: return None @abc.abstractmethod def __deepcopy__(self, memo): raise NotImplementedError def _deepcopy_(self, memo): if self.has_metadata(): return copy.deepcopy(self.metadata, memo) else: return None @stable(as_of="0.4.0") def has_metadata(self): """Determine if the object has metadata. An object has metadata if its ``metadata`` dictionary is not empty (i.e., has at least one key-value pair). Returns ------- bool Indicates whether the object has metadata. Examples -------- .. note:: scikit-bio objects with metadata share a common interface for accessing and manipulating their metadata. The following examples use scikit-bio's ``Sequence`` class to demonstrate metadata behavior. These examples apply to all other scikit-bio objects storing metadata. >>> from skbio import Sequence >>> seq = Sequence('ACGT') >>> seq.has_metadata() False >>> seq = Sequence('ACGT', metadata={}) >>> seq.has_metadata() False >>> seq = Sequence('ACGT', metadata={'id': 'seq-id'}) >>> seq.has_metadata() True """ return self._metadata is not None and bool(self.metadata) class PositionalMetadataMixin(metaclass=abc.ABCMeta): @abc.abstractmethod def _positional_metadata_axis_len_(self): """Return length of axis that positional metadata applies to. Returns ------- int Positional metadata axis length. """ raise NotImplementedError @property @stable(as_of="0.4.0") def positional_metadata(self): """``pd.DataFrame`` containing metadata along an axis. Notes ----- This property can be set and deleted. When setting new positional metadata, a shallow copy is made and the ``pd.DataFrame`` index is set to ``pd.RangeIndex(start=0, stop=axis_len, step=1)``. Examples -------- .. note:: scikit-bio objects with positional metadata share a common interface for accessing and manipulating their positional metadata. The following examples use scikit-bio's ``DNA`` class to demonstrate positional metadata behavior. These examples apply to all other scikit-bio objects storing positional metadata. Create a DNA sequence with positional metadata: >>> from skbio import DNA >>> seq = DNA( ... 'ACGT', ... positional_metadata={'exons': [True, True, False, True], ... 'quality': [3, 3, 20, 11]}) >>> seq DNA ----------------------------- Positional metadata: 'exons': 'quality': Stats: length: 4 has gaps: False has degenerates: False has definites: True GC-content: 50.00% ----------------------------- 0 ACGT Retrieve positional metadata: >>> seq.positional_metadata exons quality 0 True 3 1 True 3 2 False 20 3 True 11 Update positional metadata: >>> seq.positional_metadata['gaps'] = seq.gaps() >>> seq.positional_metadata exons quality gaps 0 True 3 False 1 True 3 False 2 False 20 False 3 True 11 False Set positional metadata: >>> seq.positional_metadata = {'degenerates': seq.degenerates()} >>> seq.positional_metadata # doctest: +NORMALIZE_WHITESPACE degenerates 0 False 1 False 2 False 3 False Delete positional metadata: >>> seq.has_positional_metadata() True >>> del seq.positional_metadata >>> seq.positional_metadata Empty DataFrame Columns: [] Index: [0, 1, 2, 3] >>> seq.has_positional_metadata() False """ if self._positional_metadata is None: # Not using setter to avoid copy. self._positional_metadata = pd.DataFrame( index=self._get_positional_metadata_index()) return self._positional_metadata @positional_metadata.setter def positional_metadata(self, positional_metadata): try: # Pass copy=True to copy underlying data buffer. positional_metadata = pd.DataFrame(positional_metadata, copy=True) # Different versions of pandas will raise different error types. We # don't really care what the type of the error is, just its message, so # a blanket Exception will do. except Exception as e: raise TypeError( "Invalid positional metadata. Must be consumable by " "`pd.DataFrame` constructor. Original pandas error message: " "\"%s\"" % e) num_rows = len(positional_metadata.index) axis_len = self._positional_metadata_axis_len_() if num_rows != axis_len: raise ValueError( "Number of positional metadata values (%d) must match the " "positional metadata axis length (%d)." % (num_rows, axis_len)) positional_metadata.index = self._get_positional_metadata_index() self._positional_metadata = positional_metadata @positional_metadata.deleter def positional_metadata(self): self._positional_metadata = None def _get_positional_metadata_index(self): """Create a memory-efficient integer index for positional metadata.""" return pd.RangeIndex(start=0, stop=self._positional_metadata_axis_len_(), step=1) @abc.abstractmethod def __init__(self, positional_metadata=None): raise NotImplementedError def _init_(self, positional_metadata=None): if positional_metadata is None: # Could use deleter but this is less overhead and needs to be fast. self._positional_metadata = None else: # Use setter for validation and copy. self.positional_metadata = positional_metadata @abc.abstractmethod def __eq__(self, other): raise NotImplementedError def _eq_(self, other): # We're not simply comparing self.positional_metadata to # other.positional_metadata in order to avoid creating "empty" # positional metadata representations on the objects if they don't have # positional metadata. if self.has_positional_metadata() and other.has_positional_metadata(): return self.positional_metadata.equals(other.positional_metadata) elif not (self.has_positional_metadata() or other.has_positional_metadata()): # Both don't have positional metadata. return (self._positional_metadata_axis_len_() == other._positional_metadata_axis_len_()) else: # One has positional metadata while the other does not. return False @abc.abstractmethod def __ne__(self, other): raise NotImplementedError def _ne_(self, other): return not (self == other) @abc.abstractmethod def __copy__(self): raise NotImplementedError def _copy_(self): if self.has_positional_metadata(): # deep=True makes a shallow copy of the underlying data buffer. return self.positional_metadata.copy(deep=True) else: return None @abc.abstractmethod def __deepcopy__(self, memo): raise NotImplementedError def _deepcopy_(self, memo): if self.has_positional_metadata(): # `copy.deepcopy` no longer recursively copies contents of the # DataFrame, so we must handle the deep copy ourselves. # Reference: https://github.com/pandas-dev/pandas/issues/17406 df = self.positional_metadata data_cp = copy.deepcopy(df.values.tolist(), memo) return pd.DataFrame(data_cp, index=df.index.copy(deep=True), columns=df.columns.copy(deep=True), copy=False) else: return None @stable(as_of="0.4.0") def has_positional_metadata(self): """Determine if the object has positional metadata. An object has positional metadata if its ``positional_metadata`` ``pd.DataFrame`` has at least one column. Returns ------- bool Indicates whether the object has positional metadata. Examples -------- .. note:: scikit-bio objects with positional metadata share a common interface for accessing and manipulating their positional metadata. The following examples use scikit-bio's ``DNA`` class to demonstrate positional metadata behavior. These examples apply to all other scikit-bio objects storing positional metadata. >>> import pandas as pd >>> from skbio import DNA >>> seq = DNA('ACGT') >>> seq.has_positional_metadata() False >>> seq = DNA('ACGT', positional_metadata=pd.DataFrame(index=range(4))) >>> seq.has_positional_metadata() False >>> seq = DNA('ACGT', positional_metadata={'quality': range(4)}) >>> seq.has_positional_metadata() True """ return (self._positional_metadata is not None and len(self.positional_metadata.columns) > 0) class IntervalMetadataMixin(metaclass=abc.ABCMeta): @abc.abstractmethod def _interval_metadata_axis_len_(self): '''Return length of axis that interval metadata applies to. Returns ------- int Interval metadata axis length. ''' raise NotImplementedError @abc.abstractmethod def __init__(self, interval_metadata=None): raise NotImplementedError def _init_(self, interval_metadata=None): if interval_metadata is None: # Could use deleter but this is less overhead and needs to be fast. self._interval_metadata = None else: # Use setter for validation and copy. self.interval_metadata = interval_metadata @property @experimental(as_of="0.5.1") def interval_metadata(self): '''``IntervalMetadata`` object containing info about interval features. Notes ----- This property can be set and deleted. When setting new interval metadata, a shallow copy of the ``IntervalMetadata`` object is made. ''' if self._interval_metadata is None: # Not using setter to avoid copy. self._interval_metadata = IntervalMetadata( self._interval_metadata_axis_len_()) return self._interval_metadata @interval_metadata.setter def interval_metadata(self, interval_metadata): if isinstance(interval_metadata, IntervalMetadata): upper_bound = interval_metadata.upper_bound lower_bound = interval_metadata.lower_bound axis_len = self._interval_metadata_axis_len_() if lower_bound != 0: raise ValueError( 'The lower bound for the interval features (%d) ' 'must be zero.' % lower_bound) if upper_bound is not None and upper_bound != axis_len: raise ValueError( 'The upper bound for the interval features (%d) ' 'must match the interval metadata axis length (%d)' % (upper_bound, axis_len)) # copy all the data to the mixin self._interval_metadata = IntervalMetadata( axis_len, copy_from=interval_metadata) else: raise TypeError('You must provide `IntervalMetadata` object, ' 'not type %s.' % type(interval_metadata).__name__) @interval_metadata.deleter def interval_metadata(self): self._interval_metadata = None @experimental(as_of="0.5.1") def has_interval_metadata(self): """Determine if the object has interval metadata. An object has interval metadata if its ``interval_metadata`` has at least one ```Interval`` objects. Returns ------- bool Indicates whether the object has interval metadata. """ return (self._interval_metadata is not None and self.interval_metadata.num_interval_features > 0) @abc.abstractmethod def __eq__(self, other): raise NotImplementedError def _eq_(self, other): # We're not simply comparing self.interval_metadata to # other.interval_metadata in order to avoid creating "empty" # interval metadata representations on the objects if they don't have # interval metadata. if self.has_interval_metadata() and other.has_interval_metadata(): return self.interval_metadata == other.interval_metadata elif not (self.has_interval_metadata() or other.has_interval_metadata()): # Both don't have interval metadata. return (self._interval_metadata_axis_len_() == other._interval_metadata_axis_len_()) else: # One has interval metadata while the other does not. return False @abc.abstractmethod def __ne__(self, other): raise NotImplementedError def _ne_(self, other): return not (self == other) @abc.abstractmethod def __copy__(self): raise NotImplementedError def _copy_(self): if self.has_interval_metadata(): return copy.copy(self.interval_metadata) else: return None @abc.abstractmethod def __deepcopy__(self, memo): raise NotImplementedError def _deepcopy_(self, memo): if self.has_interval_metadata(): return copy.deepcopy(self.interval_metadata, memo) else: return None scikit-bio-0.5.9/skbio/metadata/_repr.py000066400000000000000000000150221446255456000201450ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import itertools import numbers import textwrap from abc import ABCMeta, abstractmethod from skbio._base import ElasticLines class _MetadataReprBuilder(metaclass=ABCMeta): """An ABC for building a repr from an object containing metadata. This abstract base class constructs a repr string for an object which contains metadata, positional metadata and/or interval metadata. Parameters ---------- obj : Type varies depending on subclass Object to build repr for. width : int Maximum width of the repr. indent : int Number of spaces to use for indented lines. """ def __init__(self, obj, width, indent): self._obj = obj self._width = width self._indent = ' ' * indent @abstractmethod def _process_header(self): """Used by `build` Template Method to build header for the repr""" raise NotImplementedError @abstractmethod def _process_data(self): """Used by `build` Template Method to build data lines for the repr""" raise NotImplementedError def build(self): """Template method for building the repr""" self._lines = ElasticLines() self._process_header() self._process_metadata() self._process_positional_metadata() self._process_interval_metadata() self._process_stats() self._process_data() return self._lines.to_str() def _process_metadata(self): if self._obj.has_metadata(): self._lines.add_line('Metadata:') # Python 3 doesn't allow sorting of mixed types so we can't just # use sorted() on the metadata keys. Sort first by type then sort # by value within each type. for key in self._sorted_keys_grouped_by_type(self._obj.metadata): value = self._obj.metadata[key] self._lines.add_lines( self._format_metadata_key_value(key, value)) def _sorted_keys_grouped_by_type(self, dict_): """Group keys within a dict by their type and sort within type.""" type_sorted = sorted(dict_, key=self._type_sort_key) type_and_value_sorted = [] for _, group in itertools.groupby(type_sorted, self._type_sort_key): type_and_value_sorted.extend(sorted(group)) return type_and_value_sorted def _type_sort_key(self, key): return repr(type(key)) def _format_metadata_key_value(self, key, value): """Format metadata key:value, wrapping across lines if necessary.""" key_fmt = self._format_key(key) supported_type = True if isinstance(value, str): # extra indent of 1 so that wrapped text lines up: # # 'foo': 'abc def ghi # jkl mno' value_repr = repr(value) extra_indent = 1 elif isinstance(value, bytes): # extra indent of 2 so that wrapped text lines up: # # 'foo': b'abc def ghi # jkl mno' value_repr = repr(value) extra_indent = 2 # handles any number, this includes bool elif value is None or isinstance(value, numbers.Number): value_repr = repr(value) extra_indent = 0 else: supported_type = False if not supported_type or len(value_repr) > 140: value_repr = str(type(value)) # extra indent of 1 so that wrapped text lines up past the bracket: # # 'foo': extra_indent = 1 return self._wrap_text_with_indent(value_repr, key_fmt, extra_indent) def _process_positional_metadata(self): if self._obj.has_positional_metadata(): self._lines.add_line('Positional metadata:') for key in self._obj.positional_metadata.columns.values.tolist(): dtype = self._obj.positional_metadata[key].dtype self._lines.add_lines( self._format_positional_metadata_column(key, dtype)) def _format_positional_metadata_column(self, key, dtype): key_fmt = self._format_key(key) dtype_fmt = '' % str(dtype) return self._wrap_text_with_indent(dtype_fmt, key_fmt, 1) def _process_interval_metadata(self): # TODO: this hasattr check can be removed once all the relevant # classes have interval_metadata added to it. if (hasattr(self._obj, "has_interval_metadata") and self._obj.has_interval_metadata()): self._lines.add_line('Interval metadata:') n = self._obj.interval_metadata.num_interval_features line = self._indent + '%d interval feature' % n if n > 1: line += 's' self._lines.add_line(line) def _format_key(self, key): """Format metadata key. Includes initial indent and trailing colon and space: 'foo': """ key_fmt = self._indent + repr(key) supported_types = (str, bytes, numbers.Number, type(None)) if len(key_fmt) > (self._width / 2) or not isinstance(key, supported_types): key_fmt = self._indent + str(type(key)) return '%s: ' % key_fmt def _wrap_text_with_indent(self, text, initial_text, extra_indent): """Wrap text across lines with an initial indentation. For example: 'foo': 'abc def ghi jkl mno pqr' 'foo': is `initial_text`. `extra_indent` is 1. Wrapped lines are indented such that they line up with the start of the previous line of wrapped text. """ return textwrap.wrap( text, width=self._width, expand_tabs=False, initial_indent=initial_text, subsequent_indent=' ' * (len(initial_text) + extra_indent)) def _process_stats(self): self._lines.add_line('Stats:') for label, value in self._obj._repr_stats(): self._lines.add_line('%s%s: %s' % (self._indent, label, value)) self._lines.add_separator() scikit-bio-0.5.9/skbio/metadata/_testing.py000066400000000000000000001500121446255456000206510ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import copy import pandas as pd import numpy as np import numpy.testing as npt from skbio.util._testing import assert_data_frame_almost_equal from skbio.metadata import IntervalMetadata class MetadataMixinTests: def test_constructor_invalid_type(self): for md in (0, 'a', ('f', 'o', 'o'), np.array([]), pd.DataFrame()): with self.assertRaisesRegex(TypeError, 'metadata must be a dict'): self._metadata_constructor_(metadata=md) def test_constructor_no_metadata(self): for md in None, {}: obj = self._metadata_constructor_(metadata=md) self.assertFalse(obj.has_metadata()) self.assertEqual(obj.metadata, {}) def test_constructor_with_metadata(self): obj = self._metadata_constructor_(metadata={'foo': 'bar'}) self.assertEqual(obj.metadata, {'foo': 'bar'}) obj = self._metadata_constructor_( metadata={'': '', 123: {'a': 'b', 'c': 'd'}}) self.assertEqual(obj.metadata, {'': '', 123: {'a': 'b', 'c': 'd'}}) def test_constructor_handles_missing_metadata_efficiently(self): self.assertIsNone(self._metadata_constructor_()._metadata) self.assertIsNone(self._metadata_constructor_(metadata=None)._metadata) def test_constructor_makes_shallow_copy_of_metadata(self): md = {'foo': 'bar', 42: []} obj = self._metadata_constructor_(metadata=md) self.assertEqual(obj.metadata, md) self.assertIsNot(obj.metadata, md) md['foo'] = 'baz' self.assertEqual(obj.metadata, {'foo': 'bar', 42: []}) md[42].append(True) self.assertEqual(obj.metadata, {'foo': 'bar', 42: [True]}) def test_eq(self): self.assertReallyEqual( self._metadata_constructor_(metadata={'foo': 42}), self._metadata_constructor_(metadata={'foo': 42})) self.assertReallyEqual( self._metadata_constructor_(metadata={'foo': 42, 123: {}}), self._metadata_constructor_(metadata={'foo': 42, 123: {}})) def test_eq_missing_metadata(self): self.assertReallyEqual(self._metadata_constructor_(), self._metadata_constructor_()) self.assertReallyEqual(self._metadata_constructor_(), self._metadata_constructor_(metadata={})) self.assertReallyEqual(self._metadata_constructor_(metadata={}), self._metadata_constructor_(metadata={})) def test_eq_handles_missing_metadata_efficiently(self): obj1 = self._metadata_constructor_() obj2 = self._metadata_constructor_() self.assertReallyEqual(obj1, obj2) self.assertIsNone(obj1._metadata) self.assertIsNone(obj2._metadata) def test_ne(self): # Both have metadata. obj1 = self._metadata_constructor_(metadata={'id': 'foo'}) obj2 = self._metadata_constructor_(metadata={'id': 'bar'}) self.assertReallyNotEqual(obj1, obj2) # One has metadata. obj1 = self._metadata_constructor_(metadata={'id': 'foo'}) obj2 = self._metadata_constructor_() self.assertReallyNotEqual(obj1, obj2) def test_copy_metadata_none(self): obj = self._metadata_constructor_() obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._metadata) self.assertIsNone(obj_copy._metadata) def test_copy_metadata_empty(self): obj = self._metadata_constructor_(metadata={}) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertEqual(obj._metadata, {}) self.assertIsNone(obj_copy._metadata) def test_copy_with_metadata(self): obj = self._metadata_constructor_(metadata={'foo': [1]}) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj._metadata, obj_copy._metadata) self.assertIs(obj._metadata['foo'], obj_copy._metadata['foo']) obj_copy.metadata['foo'].append(2) obj_copy.metadata['foo2'] = 42 self.assertEqual(obj_copy.metadata, {'foo': [1, 2], 'foo2': 42}) self.assertEqual(obj.metadata, {'foo': [1, 2]}) def test_deepcopy_metadata_none(self): obj = self._metadata_constructor_() obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._metadata) self.assertIsNone(obj_copy._metadata) def test_deepcopy_metadata_empty(self): obj = self._metadata_constructor_(metadata={}) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertEqual(obj._metadata, {}) self.assertIsNone(obj_copy._metadata) def test_deepcopy_with_metadata(self): obj = self._metadata_constructor_(metadata={'foo': [1]}) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj._metadata, obj_copy._metadata) self.assertIsNot(obj._metadata['foo'], obj_copy._metadata['foo']) obj_copy.metadata['foo'].append(2) obj_copy.metadata['foo2'] = 42 self.assertEqual(obj_copy.metadata, {'foo': [1, 2], 'foo2': 42}) self.assertEqual(obj.metadata, {'foo': [1]}) def test_deepcopy_memo_is_respected(self): # Basic test to ensure deepcopy's memo is passed through to recursive # deepcopy calls. obj = self._metadata_constructor_(metadata={'foo': 'bar'}) memo = {} copy.deepcopy(obj, memo) self.assertGreater(len(memo), 2) def test_metadata_getter(self): obj = self._metadata_constructor_( metadata={42: 'foo', ('hello', 'world'): 43}) self.assertIsInstance(obj.metadata, dict) self.assertEqual(obj.metadata, {42: 'foo', ('hello', 'world'): 43}) obj.metadata[42] = 'bar' self.assertEqual(obj.metadata, {42: 'bar', ('hello', 'world'): 43}) def test_metadata_getter_no_metadata(self): obj = self._metadata_constructor_() self.assertIsNone(obj._metadata) self.assertIsInstance(obj.metadata, dict) self.assertEqual(obj.metadata, {}) self.assertIsNotNone(obj._metadata) def test_metadata_setter(self): obj = self._metadata_constructor_() self.assertFalse(obj.has_metadata()) obj.metadata = {'hello': 'world'} self.assertTrue(obj.has_metadata()) self.assertEqual(obj.metadata, {'hello': 'world'}) obj.metadata = {} self.assertFalse(obj.has_metadata()) self.assertEqual(obj.metadata, {}) def test_metadata_setter_makes_shallow_copy(self): obj = self._metadata_constructor_() md = {'foo': 'bar', 42: []} obj.metadata = md self.assertEqual(obj.metadata, md) self.assertIsNot(obj.metadata, md) md['foo'] = 'baz' self.assertEqual(obj.metadata, {'foo': 'bar', 42: []}) md[42].append(True) self.assertEqual(obj.metadata, {'foo': 'bar', 42: [True]}) def test_metadata_setter_invalid_type(self): obj = self._metadata_constructor_(metadata={123: 456}) for md in (None, 0, 'a', ('f', 'o', 'o'), np.array([]), pd.DataFrame()): with self.assertRaisesRegex(TypeError, 'metadata must be a dict'): obj.metadata = md self.assertEqual(obj.metadata, {123: 456}) def test_metadata_deleter(self): obj = self._metadata_constructor_(metadata={'foo': 'bar'}) self.assertEqual(obj.metadata, {'foo': 'bar'}) del obj.metadata self.assertIsNone(obj._metadata) self.assertFalse(obj.has_metadata()) # Delete again. del obj.metadata self.assertIsNone(obj._metadata) self.assertFalse(obj.has_metadata()) obj = self._metadata_constructor_() self.assertIsNone(obj._metadata) self.assertFalse(obj.has_metadata()) del obj.metadata self.assertIsNone(obj._metadata) self.assertFalse(obj.has_metadata()) def test_has_metadata(self): obj = self._metadata_constructor_() self.assertFalse(obj.has_metadata()) # Handles metadata efficiently. self.assertIsNone(obj._metadata) self.assertFalse( self._metadata_constructor_(metadata={}).has_metadata()) self.assertTrue( self._metadata_constructor_(metadata={'': ''}).has_metadata()) self.assertTrue( self._metadata_constructor_( metadata={'foo': 42}).has_metadata()) class PositionalMetadataMixinTests: def test_constructor_invalid_positional_metadata_type(self): with self.assertRaisesRegex(TypeError, 'Invalid positional metadata. Must be ' 'consumable by `pd.DataFrame` constructor.' ' Original pandas error message: '): self._positional_metadata_constructor_(0, positional_metadata=2) def test_constructor_positional_metadata_len_mismatch(self): # Zero elements. with self.assertRaisesRegex(ValueError, r'\(0\).*\(4\)'): self._positional_metadata_constructor_(4, positional_metadata=[]) # Not enough elements. with self.assertRaisesRegex(ValueError, r'\(3\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=[2, 3, 4]) # Too many elements. with self.assertRaisesRegex(ValueError, r'\(5\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=[2, 3, 4, 5, 6]) # Series not enough rows. with self.assertRaisesRegex(ValueError, r'\(3\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=pd.Series(range(3))) # Series too many rows. with self.assertRaisesRegex(ValueError, r'\(5\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=pd.Series(range(5))) # DataFrame not enough rows. with self.assertRaisesRegex(ValueError, r'\(3\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=pd.DataFrame({'quality': range(3)})) # DataFrame too many rows. with self.assertRaisesRegex(ValueError, r'\(5\).*\(4\)'): self._positional_metadata_constructor_( 4, positional_metadata=pd.DataFrame({'quality': range(5)})) # Empty DataFrame wrong size. with self.assertRaisesRegex(ValueError, r'\(2\).*\(3\)'): self._positional_metadata_constructor_( 3, positional_metadata=pd.DataFrame(index=range(2))) def test_constructor_no_positional_metadata(self): # Length zero with missing/empty positional metadata. for empty in None, {}, pd.DataFrame(): obj = self._positional_metadata_constructor_( 0, positional_metadata=empty) self.assertFalse(obj.has_positional_metadata()) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame(index=range(0))) # Nonzero length with missing positional metadata. obj = self._positional_metadata_constructor_( 3, positional_metadata=None) self.assertFalse(obj.has_positional_metadata()) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame(index=range(3))) def test_constructor_with_positional_metadata_len_zero(self): for data in [], (), np.array([]): obj = self._positional_metadata_constructor_( 0, positional_metadata={'foo': data}) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': data}, index=range(0))) def test_constructor_with_positional_metadata_len_one(self): for data in [2], (2, ), np.array([2]): obj = self._positional_metadata_constructor_( 1, positional_metadata={'foo': data}) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': data}, index=range(1))) def test_constructor_with_positional_metadata_len_greater_than_one(self): for data in ([0, 42, 42, 1, 0, 8, 100, 0, 0], (0, 42, 42, 1, 0, 8, 100, 0, 0), np.array([0, 42, 42, 1, 0, 8, 100, 0, 0])): obj = self._positional_metadata_constructor_( 9, positional_metadata={'foo': data}) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': data}, index=range(9))) def test_constructor_with_positional_metadata_multiple_columns(self): obj = self._positional_metadata_constructor_( 5, positional_metadata={'foo': np.arange(5), 'bar': np.arange(5)[::-1]}) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=range(5))) def test_constructor_with_positional_metadata_custom_index(self): df = pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=['a', 'b', 'c', 'd', 'e']) obj = self._positional_metadata_constructor_( 5, positional_metadata=df) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=range(5))) def test_constructor_with_positional_metadata_int64_index(self): # Test that memory-inefficient index is converted to memory-efficient # index. df = pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=np.arange(5)) self.assertEqual(df.index.dtype, np.int64) obj = self._positional_metadata_constructor_( 5, positional_metadata=df) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=range(5))) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) def test_constructor_handles_missing_positional_metadata_efficiently(self): obj = self._positional_metadata_constructor_(4) self.assertIsNone(obj._positional_metadata) obj = self._positional_metadata_constructor_( 4, positional_metadata=None) self.assertIsNone(obj._positional_metadata) def test_constructor_makes_shallow_copy_of_positional_metadata(self): df = pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=['a', 'b', 'c']) obj = self._positional_metadata_constructor_( 3, positional_metadata=df) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) self.assertIsNot(obj.positional_metadata, df) # Original df is not mutated. orig_df = pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=['a', 'b', 'c']) assert_data_frame_almost_equal(df, orig_df) # Change values of column (using same dtype). df['foo'] = [42, 42, 42] assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) # Change single value of underlying data. df.values[0][0] = 10 assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) # Mutate list (not a deep copy). df['bar'][0].append(42) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[42], [], []]}, index=range(3))) def test_eq_basic(self): obj1 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) obj2 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) self.assertReallyEqual(obj1, obj2) def test_eq_from_different_source(self): obj1 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': np.array([1, 2, 3])}) obj2 = self._positional_metadata_constructor_( 3, positional_metadata=pd.DataFrame({'foo': [1, 2, 3]}, index=['foo', 'bar', 'baz'])) self.assertReallyEqual(obj1, obj2) def test_eq_missing_positional_metadata(self): for empty in None, {}, pd.DataFrame(), pd.DataFrame(index=[]): obj = self._positional_metadata_constructor_( 0, positional_metadata=empty) self.assertReallyEqual( obj, self._positional_metadata_constructor_(0)) self.assertReallyEqual( obj, self._positional_metadata_constructor_( 0, positional_metadata=empty)) for empty in None, pd.DataFrame(index=['a', 'b']): obj = self._positional_metadata_constructor_( 2, positional_metadata=empty) self.assertReallyEqual( obj, self._positional_metadata_constructor_(2)) self.assertReallyEqual( obj, self._positional_metadata_constructor_( 2, positional_metadata=empty)) def test_eq_handles_missing_positional_metadata_efficiently(self): obj1 = self._positional_metadata_constructor_(1) obj2 = self._positional_metadata_constructor_(1) self.assertReallyEqual(obj1, obj2) self.assertIsNone(obj1._positional_metadata) self.assertIsNone(obj2._positional_metadata) def test_ne_len_zero(self): # Both have positional metadata. obj1 = self._positional_metadata_constructor_( 0, positional_metadata={'foo': []}) obj2 = self._positional_metadata_constructor_( 0, positional_metadata={'foo': [], 'bar': []}) self.assertReallyNotEqual(obj1, obj2) # One has positional metadata. obj1 = self._positional_metadata_constructor_( 0, positional_metadata={'foo': []}) obj2 = self._positional_metadata_constructor_(0) self.assertReallyNotEqual(obj1, obj2) def test_ne_len_greater_than_zero(self): # Both have positional metadata. obj1 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) obj2 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 2]}) self.assertReallyNotEqual(obj1, obj2) # One has positional metadata. obj1 = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) obj2 = self._positional_metadata_constructor_(3) self.assertReallyNotEqual(obj1, obj2) def test_ne_len_mismatch(self): obj1 = self._positional_metadata_constructor_( 3, positional_metadata=pd.DataFrame(index=range(3))) obj2 = self._positional_metadata_constructor_( 2, positional_metadata=pd.DataFrame(index=range(2))) self.assertReallyNotEqual(obj1, obj2) def test_copy_positional_metadata_none(self): obj = self._positional_metadata_constructor_(3) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._positional_metadata) self.assertIsNone(obj_copy._positional_metadata) def test_copy_positional_metadata_empty(self): obj = self._positional_metadata_constructor_( 3, positional_metadata=pd.DataFrame(index=range(3))) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) assert_data_frame_almost_equal(obj._positional_metadata, pd.DataFrame(index=range(3))) self.assertIsNone(obj_copy._positional_metadata) def test_copy_with_positional_metadata(self): obj = self._positional_metadata_constructor_( 4, positional_metadata={'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]}) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj._positional_metadata, obj_copy._positional_metadata) self.assertIsNot(obj._positional_metadata.values, obj_copy._positional_metadata.values) self.assertIs(obj._positional_metadata.loc[0, 'bar'], obj_copy._positional_metadata.loc[0, 'bar']) obj_copy.positional_metadata.loc[0, 'bar'].append(1) obj_copy.positional_metadata.loc[0, 'baz'] = 43 assert_data_frame_almost_equal( obj_copy.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [43, 42, 42, 42]})) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [42, 42, 42, 42]})) def test_copy_preserves_range_index(self): for pm in None, {'foo': ['a', 'b', 'c']}: obj = self._positional_metadata_constructor_( 3, positional_metadata=pm) obj_copy = copy.copy(obj) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) self.assertIsInstance(obj_copy.positional_metadata.index, pd.RangeIndex) def test_deepcopy_positional_metadata_none(self): obj = self._positional_metadata_constructor_(3) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._positional_metadata) self.assertIsNone(obj_copy._positional_metadata) def test_deepcopy_positional_metadata_empty(self): obj = self._positional_metadata_constructor_( 3, positional_metadata=pd.DataFrame(index=range(3))) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) assert_data_frame_almost_equal(obj._positional_metadata, pd.DataFrame(index=range(3))) self.assertIsNone(obj_copy._positional_metadata) def test_deepcopy_with_positional_metadata(self): obj = self._positional_metadata_constructor_( 4, positional_metadata={'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]}) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj._positional_metadata, obj_copy._positional_metadata) self.assertIsNot(obj._positional_metadata.values, obj_copy._positional_metadata.values) self.assertIsNot(obj._positional_metadata.loc[0, 'bar'], obj_copy._positional_metadata.loc[0, 'bar']) obj_copy.positional_metadata.loc[0, 'bar'].append(1) obj_copy.positional_metadata.loc[0, 'baz'] = 43 assert_data_frame_almost_equal( obj_copy.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [43, 42, 42, 42]})) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]})) def test_deepcopy_preserves_range_index(self): for pm in None, {'foo': ['a', 'b', 'c']}: obj = self._positional_metadata_constructor_( 3, positional_metadata=pm) obj_copy = copy.deepcopy(obj) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) self.assertIsInstance(obj_copy.positional_metadata.index, pd.RangeIndex) def test_deepcopy_memo_is_respected(self): # Basic test to ensure deepcopy's memo is passed through to recursive # deepcopy calls. obj = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) memo = {} copy.deepcopy(obj, memo) self.assertGreater(len(memo), 2) def test_positional_metadata_getter(self): obj = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [22, 22, 0]}) self.assertIsInstance(obj.positional_metadata, pd.DataFrame) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0]})) # Update existing column. obj.positional_metadata['foo'] = [42, 42, 43] assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [42, 42, 43]})) # Add new column. obj.positional_metadata['foo2'] = [True, False, True] assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [42, 42, 43], 'foo2': [True, False, True]})) def test_positional_metadata_getter_no_positional_metadata(self): obj = self._positional_metadata_constructor_(4) self.assertIsNone(obj._positional_metadata) self.assertIsInstance(obj.positional_metadata, pd.DataFrame) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame(index=range(4))) self.assertIsNotNone(obj._positional_metadata) def test_positional_metadata_getter_set_column_series(self): length = 8 obj = self._positional_metadata_constructor_( length, positional_metadata={'foo': range(length)}) obj.positional_metadata['bar'] = pd.Series(range(length-3)) # pandas.Series will be padded with NaN if too short. npt.assert_equal(obj.positional_metadata['bar'], np.array(list(range(length-3)) + [np.nan]*3)) obj.positional_metadata['baz'] = pd.Series(range(length+3)) # pandas.Series will be truncated if too long. npt.assert_equal(obj.positional_metadata['baz'], np.array(range(length))) def test_positional_metadata_getter_set_column_array(self): length = 8 obj = self._positional_metadata_constructor_( length, positional_metadata={'foo': range(length)}) # array-like objects will fail if wrong size. for array_like in (np.array(range(length-1)), range(length-1), np.array(range(length+1)), range(length+1)): with self.assertRaisesRegex(ValueError, r'Length of values \(' + str(len(array_like)) + r'\) does not match length' r' of index \(8\)'): obj.positional_metadata['bar'] = array_like def test_positional_metadata_setter_pandas_consumable(self): obj = self._positional_metadata_constructor_(3) self.assertFalse(obj.has_positional_metadata()) obj.positional_metadata = {'foo': [3, 2, 1]} self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [3, 2, 1]})) obj.positional_metadata = pd.DataFrame(index=np.arange(3)) self.assertFalse(obj.has_positional_metadata()) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame(index=range(3))) def test_positional_metadata_setter_data_frame(self): obj = self._positional_metadata_constructor_(3) self.assertFalse(obj.has_positional_metadata()) obj.positional_metadata = pd.DataFrame({'foo': [3, 2, 1]}, index=['a', 'b', 'c']) self.assertTrue(obj.has_positional_metadata()) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [3, 2, 1]})) obj.positional_metadata = pd.DataFrame(index=np.arange(3)) self.assertFalse(obj.has_positional_metadata()) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame(index=range(3))) def test_positional_metadata_setter_none(self): obj = self._positional_metadata_constructor_( 0, positional_metadata={'foo': []}) self.assertTrue(obj.has_positional_metadata()) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': []})) # `None` behavior differs from constructor. obj.positional_metadata = None self.assertFalse(obj.has_positional_metadata()) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame(index=range(0))) def test_positional_metadata_setter_int64_index(self): # Test that memory-inefficient index is converted to memory-efficient # index. obj = self._positional_metadata_constructor_(5) df = pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=np.arange(5)) self.assertEqual(df.index.dtype, np.int64) obj.positional_metadata = df assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': np.arange(5), 'bar': np.arange(5)[::-1]}, index=range(5))) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) def test_positional_metadata_setter_makes_shallow_copy(self): obj = self._positional_metadata_constructor_(3) df = pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=['a', 'b', 'c']) obj.positional_metadata = df assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) self.assertIsNot(obj.positional_metadata, df) # Original df is not mutated. orig_df = pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=['a', 'b', 'c']) assert_data_frame_almost_equal(df, orig_df) # Change values of column (using same dtype). df['foo'] = [42, 42, 42] assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) # Change single value of underlying data. df.values[0][0] = 10 assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[], [], []]}, index=range(3))) # Mutate list (not a deep copy). df['bar'][0].append(42) assert_data_frame_almost_equal( obj.positional_metadata, pd.DataFrame({'foo': [22, 22, 0], 'bar': [[42], [], []]}, index=range(3))) def test_positional_metadata_setter_invalid_type(self): obj = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 42]}) with self.assertRaisesRegex(TypeError, 'Invalid positional metadata. Must be ' 'consumable by `pd.DataFrame` constructor.' ' Original pandas error message: '): obj.positional_metadata = 2 assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [1, 2, 42]})) def test_positional_metadata_setter_len_mismatch(self): obj = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 42]}) # `None` behavior differs from constructor. with self.assertRaisesRegex(ValueError, r'\(0\).*\(3\)'): obj.positional_metadata = None assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [1, 2, 42]})) with self.assertRaisesRegex(ValueError, r'\(4\).*\(3\)'): obj.positional_metadata = [1, 2, 3, 4] assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [1, 2, 42]})) def test_positional_metadata_deleter(self): obj = self._positional_metadata_constructor_( 3, positional_metadata={'foo': [1, 2, 3]}) self.assertIsInstance(obj.positional_metadata.index, pd.RangeIndex) assert_data_frame_almost_equal(obj.positional_metadata, pd.DataFrame({'foo': [1, 2, 3]})) del obj.positional_metadata self.assertIsNone(obj._positional_metadata) self.assertFalse(obj.has_positional_metadata()) # Delete again. del obj.positional_metadata self.assertIsNone(obj._positional_metadata) self.assertFalse(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_(3) self.assertIsNone(obj._positional_metadata) self.assertFalse(obj.has_positional_metadata()) del obj.positional_metadata self.assertIsNone(obj._positional_metadata) self.assertFalse(obj.has_positional_metadata()) def test_has_positional_metadata(self): obj = self._positional_metadata_constructor_(4) self.assertFalse(obj.has_positional_metadata()) self.assertIsNone(obj._positional_metadata) obj = self._positional_metadata_constructor_(0, positional_metadata={}) self.assertFalse(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_( 4, positional_metadata=pd.DataFrame(index=np.arange(4))) self.assertFalse(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_( 4, positional_metadata=pd.DataFrame(index=['a', 'b', 'c', 'd'])) self.assertFalse(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_( 0, positional_metadata={'foo': []}) self.assertTrue(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_( 4, positional_metadata={'foo': [1, 2, 3, 4]}) self.assertTrue(obj.has_positional_metadata()) obj = self._positional_metadata_constructor_( 2, positional_metadata={'foo': [1, 2], 'bar': ['abc', 'def']}) self.assertTrue(obj.has_positional_metadata()) class IntervalMetadataMixinTests: def _set_up(self): self.upper_bound = 9 self.im = IntervalMetadata(self.upper_bound) self.intvls = [ {'bounds': [(0, 1), (2, 9)], 'metadata': {'gene': 'sagA'}}, {'bounds': [(0, 1)], 'metadata': {'gene': ['a'], 'product': 'foo'}}] def test_constructor_invalid(self): with self.assertRaisesRegex(TypeError, 'You must provide `IntervalMetadata` ' 'object.'): self._interval_metadata_constructor_(0, '') def test_constructor_empty_interval_metadata_upper_bound_is_none(self): im = IntervalMetadata(None) for i in [0, 1, 3, 100]: x = self._interval_metadata_constructor_(i, im) # the upper bound is reset to seq/axis length self.assertEqual(x.interval_metadata.upper_bound, i) self.assertEqual(x.interval_metadata._intervals, im._intervals) # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_constructor_interval_metadata_upper_bound_is_none(self): im = IntervalMetadata(None) # populate im im.add(**self.intvls[0]) im.add(**self.intvls[1]) for i in [1000, 100]: x = self._interval_metadata_constructor_(i, im) # the upper bound is reset to seq/axis length self.assertEqual(x.interval_metadata.upper_bound, i) self.assertEqual(x.interval_metadata._intervals, im._intervals) # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_constructor_interval_bounds_larger_than_len(self): im = IntervalMetadata(None) # populate im im.add(**self.intvls[0]) im.add(**self.intvls[1]) for i in [0, 1, 3]: # error to reset upper bound to a smaller value than seq/axis len with self.assertRaisesRegex( ValueError, r'larger than upper bound \(%r\)' % i): self._interval_metadata_constructor_(i, im) # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_constructor_interval_metadata_len_mismatch(self): for i in [0, 1, 3, 100]: with self.assertRaisesRegex( ValueError, r'\(%d\).*\(%d\)' % (self.upper_bound, i)): self._interval_metadata_constructor_(i, self.im) def test_constructor_interval_metadata_len(self): for n in 1, 2, 3: im = IntervalMetadata(n) im.add([(0, 1)], metadata={'a': 'b'}) obj = self._interval_metadata_constructor_(n, im) self.assertTrue(obj.has_interval_metadata()) self.assertIsInstance(obj.interval_metadata, IntervalMetadata) def test_constructor_interval_metadata_len_0(self): im = IntervalMetadata(0) obj = self._interval_metadata_constructor_(0, im) self.assertFalse(obj.has_interval_metadata()) def test_constructor_no_interval_metadata(self): for i, im in [(0, None), (self.upper_bound, self.im)]: obj = self._interval_metadata_constructor_(i, im) self.assertFalse(obj.has_interval_metadata()) self.assertIsInstance(obj.interval_metadata, IntervalMetadata) def test_constructor_handles_missing_interval_metadata_efficiently(self): obj = self._interval_metadata_constructor_(self.upper_bound) self.assertIsNone(obj._interval_metadata) obj = self._interval_metadata_constructor_( self.upper_bound, interval_metadata=None) self.assertIsNone(obj._interval_metadata) def test_constructor_makes_shallow_copy_of_interval_metadata(self): intvl = self.im.add(**self.intvls[1]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) self.assertEqual(obj.interval_metadata, self.im) self.assertIsNot(obj.interval_metadata, self.im) # Changing mutable value of metadata of the old interval # also changes obj. intvl.metadata['gene'].append('b') self.assertEqual(obj.interval_metadata, self.im) # Changing old interval doesn't change obj intvl.bounds = [(3, 6)] self.assertNotEqual(obj.interval_metadata, self.im) def test_eq_basic(self): im1 = IntervalMetadata(self.upper_bound) im1.add(**self.intvls[0]) obj1 = self._interval_metadata_constructor_(self.upper_bound, im1) im2 = IntervalMetadata(self.upper_bound) im2.add(**self.intvls[0]) obj2 = self._interval_metadata_constructor_(self.upper_bound, im2) self.assertReallyEqual(obj1, obj2) def test_eq_populated_differently(self): im1 = IntervalMetadata(self.upper_bound) im1.add(**self.intvls[0]) obj1 = self._interval_metadata_constructor_(self.upper_bound, im1) obj2 = self._interval_metadata_constructor_(self.upper_bound) obj2.interval_metadata.add(**self.intvls[0]) self.assertReallyEqual(obj1, obj2) def test_eq_handles_missing_positional_metadata_efficiently(self): obj1 = self._interval_metadata_constructor_(self.upper_bound) obj2 = self._interval_metadata_constructor_(self.upper_bound) self.assertReallyEqual(obj1, obj2) self.assertIsNone(obj1._interval_metadata) self.assertIsNone(obj2._interval_metadata) def test_ne_diff_len(self): obj1 = self._interval_metadata_constructor_(0) obj2 = self._interval_metadata_constructor_(self.upper_bound) self.assertReallyNotEqual(obj1, obj2) def test_ne_only_one_is_empty(self): im1 = IntervalMetadata(self.upper_bound) im1.add(**self.intvls[0]) obj1 = self._interval_metadata_constructor_(self.upper_bound, im1) obj2 = self._interval_metadata_constructor_(self.upper_bound) self.assertReallyNotEqual(obj1, obj2) def test_ne(self): im1 = IntervalMetadata(self.upper_bound) im1.add(**self.intvls[0]) obj1 = self._interval_metadata_constructor_(self.upper_bound, im1) im2 = IntervalMetadata(self.upper_bound) im2.add(**self.intvls[1]) obj2 = self._interval_metadata_constructor_(self.upper_bound, im2) self.assertReallyNotEqual(obj1, obj2) def test_copy_interval_metadata_empty(self): obj = self._interval_metadata_constructor_(self.upper_bound, self.im) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj_copy._interval_metadata) self.assertEqual(obj._interval_metadata, self.im) def test_copy_interval_metadata_none(self): obj = self._interval_metadata_constructor_(self.upper_bound) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._interval_metadata) self.assertIsNone(obj_copy._interval_metadata) def test_copy_interval_metadata(self): self.im.add(**self.intvls[1]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) obj_copy = copy.copy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj.interval_metadata, obj_copy.interval_metadata) self.assertIsNot(obj.interval_metadata._intervals, obj_copy.interval_metadata._intervals) for i, j in zip(obj.interval_metadata._intervals, obj_copy.interval_metadata._intervals): self.assertIsNot(i, j) self.assertIsNot(i.metadata, j.metadata) for k in i.metadata: self.assertIs(i.metadata[k], j.metadata[k]) def test_deepcopy_interval_metadata(self): self.im.add(**self.intvls[1]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNot(obj.interval_metadata, obj_copy.interval_metadata) self.assertIsNot(obj.interval_metadata._intervals, obj_copy.interval_metadata._intervals) for i, j in zip(obj.interval_metadata._intervals, obj_copy.interval_metadata._intervals): self.assertIsNot(i, j) self.assertIsNot(i.metadata, j.metadata) self.assertIsNot(i.metadata['gene'], j.metadata['gene']) self.assertIs(i.metadata['product'], j.metadata['product']) def test_deepcopy_interval_metadata_empty(self): obj = self._interval_metadata_constructor_(self.upper_bound, self.im) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj_copy._interval_metadata) self.assertEqual(obj._interval_metadata, self.im) def test_deepcopy_interval_metadata_none(self): obj = self._interval_metadata_constructor_(self.upper_bound, None) obj_copy = copy.deepcopy(obj) self.assertEqual(obj, obj_copy) self.assertIsNot(obj, obj_copy) self.assertIsNone(obj._interval_metadata) self.assertIsNone(obj_copy._interval_metadata) def test_deepcopy_memo_is_respected(self): # Basic test to ensure deepcopy's memo is passed through to recursive # deepcopy calls. obj = self._interval_metadata_constructor_(self.upper_bound, self.im) memo = {} copy.deepcopy(obj, memo) self.assertGreater(len(memo), 1) def test_interval_metadata_getter(self): self.im.add(**self.intvls[0]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) self.assertIsInstance(obj.interval_metadata, IntervalMetadata) self.assertEqual(self.im, obj.interval_metadata) # Update existing metadata. obj.interval_metadata._intervals[0].metadata['gene'] = 'sagB' self.assertNotEqual(obj.interval_metadata, self.im) self.im._intervals[0].metadata['gene'] = 'sagB' self.assertEqual(obj.interval_metadata, self.im) # Add new interval feature. obj.interval_metadata.add(**self.intvls[1]) self.im.add(**self.intvls[1]) self.assertEqual(obj.interval_metadata, self.im) def test_interval_metadata_getter_no_interval_metadata(self): obj = self._interval_metadata_constructor_(self.upper_bound) self.assertIsNone(obj._interval_metadata) self.assertIsInstance(obj.interval_metadata, IntervalMetadata) self.assertEqual(obj.interval_metadata, self.im) self.assertIsNotNone(obj._interval_metadata) def test_interval_metadata_setter(self): obj = self._interval_metadata_constructor_(self.upper_bound) self.assertFalse(obj.has_interval_metadata()) obj.interval_metadata = self.im self.assertFalse(obj.has_interval_metadata()) self.assertEqual(obj.interval_metadata, self.im) self.im.add(**self.intvls[1]) obj.interval_metadata = self.im self.assertTrue(obj.has_interval_metadata()) self.assertEqual(obj.interval_metadata, self.im) def test_interval_metadata_setter_makes_copy(self): intvl = self.im.add(**self.intvls[1]) obj = self._interval_metadata_constructor_(self.upper_bound) obj.interval_metadata = self.im self.assertEqual(obj.interval_metadata, self.im) self.assertIsNot(obj.interval_metadata, self.im) # Changing mutable value of metadata of the old interval # also changes obj. intvl.metadata['gene'].append('b') self.assertEqual(obj.interval_metadata, self.im) # Changing old interval doesn't change obj intvl.bounds = [(3, 6)] self.assertNotEqual(obj.interval_metadata, self.im) def test_interval_metadata_setter_len_mismatch(self): self.im.add(**self.intvls[1]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) for i in 0, 1, 3, 100: with self.assertRaisesRegex( ValueError, r'\(%d\).*\(%d\)' % (i, self.upper_bound)): obj.interval_metadata = IntervalMetadata(i) self.assertEqual(obj.interval_metadata, self.im) def test_interval_metadata_setter_invalid_type(self): self.im.add(**self.intvls[0]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) for i in [2, None, '', {}, []]: with self.assertRaisesRegex( TypeError, 'You must provide `IntervalMetadata` object'): obj.interval_metadata = i self.assertEqual(self.im, obj.interval_metadata) def test_interval_metadata_setter_empty_upper_bound_is_none(self): im = IntervalMetadata(None) for i in [0, 1, 3, 100]: x = self._interval_metadata_constructor_(i) x.interval_metadata = im self.assertFalse(x.has_interval_metadata()) # the upper bound is reset to seq/axis length self.assertEqual(x.interval_metadata.upper_bound, i) # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_interval_metadata_setter_upper_bound_is_none(self): im = IntervalMetadata(None) # populate im im.add(**self.intvls[0]) im.add(**self.intvls[1]) for i in [1000, 100]: x = self._interval_metadata_constructor_(i) x.interval_metadata = im # the upper bound is reset to seq/axis length self.assertEqual(x.interval_metadata.upper_bound, i) self.assertEqual(x.interval_metadata._intervals, im._intervals) # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_interval_metadata_setter_interval_bounds_larger_than_len(self): im = IntervalMetadata(None) # populate im im.add(**self.intvls[0]) im.add(**self.intvls[1]) for i in [0, 1, 3]: # error to reset upper bound to a smaller value than seq/axis len with self.assertRaisesRegex( ValueError, r'larger than upper bound \(%r\)' % i): x = self._interval_metadata_constructor_(i) x.interval_metadata = im # original interval metadata upper bound is not changed self.assertIsNone(im.upper_bound) def test_interval_metadata_deleter_empty(self): obj = self._interval_metadata_constructor_(self.upper_bound, self.im) del obj.interval_metadata self.assertIsNone(obj._interval_metadata) self.assertFalse(obj.has_interval_metadata()) # Delete again. test idempotent del obj.interval_metadata self.assertIsNone(obj._interval_metadata) self.assertFalse(obj.has_interval_metadata()) def test_interval_metadata_deleter(self): self.im.add(**self.intvls[0]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) del obj.interval_metadata self.assertIsNone(obj._interval_metadata) self.assertFalse(obj.has_interval_metadata()) def test_has_interval_metadata(self): obj = self._interval_metadata_constructor_(self.upper_bound) self.assertFalse(obj.has_interval_metadata()) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) self.assertFalse(obj.has_interval_metadata()) self.im.add([(0, 1)]) obj = self._interval_metadata_constructor_(self.upper_bound, self.im) self.assertTrue(obj.has_interval_metadata()) scikit-bio-0.5.9/skbio/metadata/tests/000077500000000000000000000000001446255456000176265ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/metadata/tests/__init__.py000066400000000000000000000005411446255456000217370ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/metadata/tests/test_intersection.py000066400000000000000000000177741446255456000237650ustar00rootroot00000000000000# checklist.py:CopyrightHeadersValidator IGNORE # ---------------------------------------------------------------------------- # This code is taken from bx-python project and added with a test for a new # function `update` from line 195 to 211. The license for this code is # included in licenses/bx_python.txt. # ---------------------------------------------------------------------------- import sys import unittest import random from skbio.metadata._intersection import IntervalObj from skbio.metadata._intersection import IntervalNode from skbio.metadata._intersection import IntervalTree # Note: More bounds checking on input parameters are performed # within test_interval.py class NeighborTestCase(unittest.TestCase): def setUp(self): iv = IntervalNode(50, 59, IntervalObj(50, 59)) for i in range(0, 110, 10): if i == 50: continue f = IntervalObj(i, i + 9) iv = iv.insert(f.start, f.end, f) self.intervals = iv def test_left(self): iv = self.intervals self.assertEqual(str(iv.left(60, n=2)), str([IntervalObj(50, 59), IntervalObj(40, 49)])) for i in range(10, 100, 10): r = iv.left(i, max_dist=10, n=1) self.assertEqual(r[0].end, i - 1) def test_toomany(self): iv = self.intervals self.assertEqual(len(iv.left(60, n=200)), 6) def test_right(self): iv = self.intervals self.assertEqual(str(iv.left(60, n=2)), str([IntervalObj(50, 59), IntervalObj(40, 49)])) def get_right_start(b10): r = iv.right(b10+1, n=1) assert len(r) == 1 return r[0].start for i in range(10, 100, 10): self.assertEqual(get_right_start(i), i + 10) for i in range(0, 100, 10): r = iv.right(i-1, max_dist=10, n=1) self.assertEqual(r[0].start, i) class UpDownStreamTestCase(unittest.TestCase): def setUp(self): iv = IntervalTree() iv.add_interval(IntervalObj(50, 59)) for i in range(0, 110, 10): if i == 50: continue f = IntervalObj(i, i + 9) iv.add_interval(f) self.intervals = iv def test_upstream(self): iv = self.intervals upstreams = iv.upstream_of_interval(IntervalObj(59, 60), num_intervals=200) for u in upstreams: self.assertTrue(u.end < 59) upstreams = iv.upstream_of_interval(IntervalObj(60, 70, strand=-1), num_intervals=200) for u in upstreams: self.assertTrue(u.start > 70) upstreams = iv.upstream_of_interval(IntervalObj(58, 58, strand=-1), num_intervals=200) for u in upstreams: self.assertTrue(u.start > 59) def test_downstream(self): iv = self.intervals downstreams = iv.downstream_of_interval(IntervalObj(59, 60), num_intervals=200) for d in downstreams: self.assertTrue(d.start > 60) downstreams = iv.downstream_of_interval(IntervalObj(59, 60, strand=-1), num_intervals=200) for d in downstreams: self.assertTrue(d.start < 59) def test_n(self): iv = self.intervals for i in range(0, 90, 10): r = iv.after(i, max_dist=20, num_intervals=2) self.assertEqual(r[0].start, i + 10) self.assertEqual(r[1].start, i + 20) r = iv.after_interval(IntervalObj(i, i), max_dist=20, num_intervals=2) self.assertEqual(r[0].start, i + 10) self.assertEqual(r[1].start, i + 20) class LotsaTestCase(unittest.TestCase): """ put lotsa data in the tree and make sure it works""" def setUp(self): iv = IntervalNode(1, 2, IntervalObj(1, 2)) self.max = 1000000 for i in range(0, self.max, 10): f = IntervalObj(i, i) iv = iv.insert(f.start, f.end, f) for i in range(600): iv = iv.insert(0, 1, IntervalObj(0, 1)) self.intervals = iv def test_count(self): iv = self.intervals r = iv.right(1, n=33) self.assertEqual(len(r), 33) left = iv.left(1, n=33) self.assertEqual(len(left), 1) u = iv.right(1, n=9999) self.assertEqual(len(u), 250) # now increase max_dist u = iv.right(1, n=9999, max_dist=99999) self.assertEqual(len(u), 9999) def test_max_dist(self): iv = self.intervals r = iv.right(1, max_dist=0, n=10) self.assertEqual(len(r), 0) for n, d in enumerate(range(10, 1000, 10)): r = iv.right(1, max_dist=d, n=10000) self.assertEqual(len(r), n + 1) def test_find(self): iv = self.intervals path = sys.path[:] sys.path = sys.path[2:] sys.path = path for t in range(25): start = random.randint(0, self.max - 10000) end = start + random.randint(100, 10000) results = iv.find(start, end) for feat in results: self.assertTrue( (feat.end >= start and feat.end <= end) or (feat.start <= end and feat.start >= start)) class IntervalTreeTest(unittest.TestCase): def setUp(self): iv = IntervalTree() n = 0 for i in range(1, 1000, 80): iv.insert(i, i + 10, dict(value=i*i)) # add is synonym for insert. iv.add(i + 20, i + 30, dict(astr=str(i*i))) # or insert/add an interval object with start, end attrs. iv.insert_interval(IntervalObj(i + 40, i + 50, value=dict(astr=str(i*i)))) iv.add_interval(IntervalObj(i + 60, i + 70, value=dict(astr=str(i*i)))) n += 4 self.intervals = self.iv = iv self.nintervals = n def test_find(self): r = self.iv.find(100, 200) self.assertEqual(len(r), 5) def test_edge_cases(self): iv = IntervalTree() iv.insert(1, 1, 'foo') iv.insert(3, 7, 'spam') iv.insert(8, 8, 'abc') self.assertEqual(iv.find(0, 1), []) self.assertEqual(iv.find(1, 1), ['foo']) self.assertEqual(iv.find(1, 2), ['foo']) self.assertEqual(iv.find(2, 3), []) self.assertEqual(iv.find(3, 3), ['spam']) self.assertEqual(iv.find(3, 4), ['spam']) self.assertEqual(iv.find(6, 7), ['spam']) self.assertEqual(iv.find(7, 7), []) self.assertEqual(iv.find(0, 8), ['foo', 'spam']) self.assertEqual(iv.find(8, 8), ['abc']) self.assertEqual(iv.find(8, 9), ['abc']) self.assertEqual(iv.find(9, 9), []) self.assertEqual(iv.find(0, 10), ['foo', 'spam', 'abc']) self.assertEqual(iv.find(6, 10), ['spam', 'abc']) self.assertEqual(iv.find(7, 9), ['abc']) def test_traverse(self): a = [] fn = a.append self.iv.traverse(fn) self.assertEqual(len(a), self.nintervals) def test_empty(self): iv = IntervalTree() self.assertEqual([], iv.find(100, 300)) self.assertEqual([], iv.after(100)) self.assertEqual([], iv.before(100)) self.assertEqual([], iv.after_interval(100)) self.assertEqual([], iv.before_interval(100)) self.assertEqual([], iv.upstream_of_interval(100)) self.assertEqual([], iv.downstream_of_interval(100)) self.assertEqual(None, iv.traverse(lambda x: x.append(1))) def test_public_interval(self): self.iv.traverse(lambda ival: self.assertTrue(ival.interval)) def test_update(self): i = 1 self.iv.update(i, i + 10, dict(value=i*i), dict(value=-1)) self.assertEqual([dict(value=-1)], self.iv.find(i, i+10)) if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/metadata/tests/test_interval.py000066400000000000000000000772251446255456000231000ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from copy import deepcopy, copy from skbio.metadata._interval import (_assert_valid_bound, _assert_valid_fuzzy) from skbio.metadata import Interval from skbio.metadata import IntervalMetadata from skbio.metadata._intersection import IntervalTree from skbio.util._testing import ReallyEqualMixin class TestInterval(unittest.TestCase, ReallyEqualMixin): def setUp(self): self.upper_bound = 100 self.im = IntervalMetadata(self.upper_bound) def test_init_default(self): f = Interval(self.im, bounds=[(0, 2), (4, self.upper_bound)]) self.assertTrue(f._interval_metadata is not None) self.assertListEqual(f.bounds, [(0, 2), (4, self.upper_bound)]) self.assertListEqual(f.fuzzy, [(False, False), (False, False)]) self.assertDictEqual(f.metadata, {}) def test_init(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) self.assertTrue(f._interval_metadata is not None) self.assertListEqual(f.bounds, [(1, 2), (4, 7)]) self.assertListEqual(f.fuzzy, [(True, False), (False, False)]) self.assertDictEqual(f.metadata, {'name': 'sagA', 'function': 'transport'}) def test_init_iterables(self): f = Interval(interval_metadata=self.im, bounds=((1, 2), (4, 7)), fuzzy=((True, False), (False, False)), metadata={'name': 'sagA', 'function': 'transport'}) self.assertTrue(f._interval_metadata is not None) self.assertListEqual(f.bounds, [(1, 2), (4, 7)]) self.assertListEqual(f.fuzzy, [(True, False), (False, False)]) self.assertDictEqual(f.metadata, {'name': 'sagA', 'function': 'transport'}) def test_init_generator(self): def gen(): for x in [(1, 2), (4, 7)]: yield x f = Interval(interval_metadata=self.im, bounds=gen(), fuzzy=((True, False), (False, False)), metadata={'name': 'sagA', 'function': 'transport'}) self.assertTrue(f._interval_metadata is not None) self.assertListEqual(f.bounds, [(1, 2), (4, 7)]) self.assertListEqual(f.fuzzy, [(True, False), (False, False)]) self.assertDictEqual(f.metadata, {'name': 'sagA', 'function': 'transport'}) def test_init_bounds_scrambled(self): f = Interval(interval_metadata=self.im, bounds=[(4, 7), (1, 2)], fuzzy=[(True, False), (False, True)], metadata={'name': 'sagA', 'function': 'transport'}) self.assertTrue(f._interval_metadata is not None) self.assertListEqual(f.bounds, [(1, 2), (4, 7)]) self.assertListEqual(f.fuzzy, [(False, True), (True, False)]) self.assertDictEqual(f.metadata, {'name': 'sagA', 'function': 'transport'}) def test_init_no_interval_metadata(self): with self.assertRaises(TypeError): Interval(interval_metadata=None, bounds=[(4, 7)], metadata={'name': 'sagA', 'function': 'transport'}) def test_init_empty_metadata(self): for i in 0, 1: # test that no exception is raised Interval(interval_metadata=self.im, bounds=[(i, i)]) def test_init_out_of_bounds(self): with self.assertRaises(ValueError): Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 101)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) with self.assertRaises(ValueError): Interval(interval_metadata=self.im, bounds=[(-1, 2), (4, 6)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) def test_init_bad_bounds(self): with self.assertRaises(TypeError): Interval(interval_metadata=self.im, bounds=[1, (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) def test_init_bad_fuzzy(self): with self.assertRaises(ValueError): Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(False, False)], metadata={'name': 'sagA', 'function': 'transport'}) def test_repr(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2)], metadata={'name': 'sagA'}) exp = (r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(1, 2\)\]," r" fuzzy=\[\(False, False\)\], metadata={'name': 'sagA'}\)") obs = repr(f) self.assertRegex(obs, exp) # test for dropped f.drop() exp = (r"Interval\(dropped=True, bounds=\[\(1, 2\)\]," r" fuzzy=\[\(False, False\)\], metadata={'name': 'sagA'}\)") obs = repr(f) self.assertRegex(obs, exp) def test_drop(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2)], metadata={'name': 'sagA'}) f.drop() self.assertTrue(f._interval_metadata is None) self.assertTrue(f.dropped) self.assertTrue(f.bounds, [(1, 2)]) self.assertTrue(f.metadata, {'name': 'sagA'}) # test the idempotence f.drop() self.assertTrue(f._interval_metadata is None) self.assertTrue(f.dropped) self.assertTrue(f.bounds, [(1, 2)]) self.assertTrue(f.metadata, {'name': 'sagA'}) def test_eq(self): f0 = Interval(interval_metadata=self.im, bounds=[(4, 7), (1, 2)], fuzzy=[(False, False), (True, False)], metadata={'name': 'sagA', 'function': 'transport'}) f1 = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f2 = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f3 = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, True), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f4 = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 8)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f5 = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagB', 'function': 'transport'}) # scramble bounds/fuzzy self.assertReallyEqual(f0, f1) self.assertReallyEqual(f2, f1) # diff fuzzy self.assertReallyNotEqual(f1, f3) # diff bounds self.assertReallyNotEqual(f1, f4) # diff metadata self.assertReallyNotEqual(f1, f5) def test_get_bounds(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) self.assertEqual(f.bounds, [(1, 2), (4, 7)]) self.assertEqual(self.im._is_stale_tree, True) def test_set_bounds(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f.bounds = [(4, 7), (1, 3)] self.assertEqual(f.bounds, [(1, 3), (4, 7)]) self.assertEqual(f.fuzzy, [(False, False), (False, False)]) self.assertEqual(self.im._is_stale_tree, True) def test_set_bounds_bad(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) for value in [1, 's']: with self.assertRaises(TypeError): f.bounds = value for value in [[(-1, 2)], # start < lower_bound [(1, 101)], # end > upper_bound [(3, 1)], # start < end [('s', 1)], (), None]: # invalid values with self.assertRaises(ValueError): f.bounds = value def test_get_fuzzy(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) self.assertEqual(f.fuzzy, [(True, False), (False, False)]) def test_set_fuzzy(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f.fuzzy = [(False, False), (False, False)] self.assertEqual(f.fuzzy, [(False, False), (False, False)]) def test_set_fuzzy_bad(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) for value in [[(False, False)], (), None]: with self.assertRaises(ValueError): f.fuzzy = value for value in [1, True]: with self.assertRaises(TypeError): f.fuzzy = value def test_delete_fuzzy(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) del f.fuzzy self.assertEqual(f.fuzzy, [(False, False), (False, False)]) # delete again del f.fuzzy self.assertEqual(f.fuzzy, [(False, False), (False, False)]) def test_get_metadata(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f.metadata['name'] = 'sagB' self.assertEqual(f.metadata, {'name': 'sagB', 'function': 'transport'}) def test_set_metadata(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) f.metadata = {'name': 'sagB', 'function': 'transport'} self.assertDictEqual(f.metadata, {'name': 'sagB', 'function': 'transport'}) f.metadata = {} self.assertDictEqual(f.metadata, {}) def test_set_metadata_bad(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) for value in [1, '', None]: with self.assertRaises(TypeError): f.metadata = value def test_delete_metadata(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2), (4, 7)], fuzzy=[(True, False), (False, False)], metadata={'name': 'sagA', 'function': 'transport'}) del f.metadata self.assertEqual(f.metadata, {}) def test_set_delete_on_dropped(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2)], fuzzy=[(True, False)], metadata={'name': 'sagA'}) f.drop() with self.assertRaises(RuntimeError): f.fuzzy = None with self.assertRaises(RuntimeError): f.bounds = [(1, 2)] with self.assertRaises(RuntimeError): f.metadata = {} with self.assertRaises(RuntimeError): del f.fuzzy with self.assertRaises(RuntimeError): del f.metadata def test_get_on_dropped(self): f = Interval(interval_metadata=self.im, bounds=[(1, 2)], fuzzy=[(True, False)], metadata={'name': 'sagA'}) f.drop() self.assertEqual(f.fuzzy, [(True, False)]) self.assertEqual(f.bounds, [(1, 2)]) self.assertEqual(f.metadata, {'name': 'sagA'}) class TestIntervalUtil(unittest.TestCase): def test_assert_valid_bound(self): intvls = [(1, 2), (-1, 2)] for intvl in intvls: try: _assert_valid_bound(intvl) except TypeError: self.assertTrue(False) def test_assert_valid_bound_wrong_type(self): intvls = [[1, 2], 1, [1, 2, 3]] for intvl in intvls: with self.assertRaises(TypeError): _assert_valid_bound(intvl) def test_assert_valid_bound_wrong_value(self): intvls = [(1, 2, 3), (2, 1), (True, 0), ('s', 'r')] for intvl in intvls: with self.assertRaises(ValueError): _assert_valid_bound(intvl) def test_assert_valid_fuzzy(self): fuzzy = [(True, False), (True, True)] for fuzzy in fuzzy: try: _assert_valid_fuzzy(fuzzy) except Exception: self.assertTrue(False) def test_assert_valid_fuzzy_wrong_value(self): fuzzy = [(True, False, True), ()] for fuzzy in fuzzy: with self.assertRaises(ValueError): _assert_valid_fuzzy(fuzzy) def test_assert_valid_fuzzy_wrong_type(self): fuzzy = [[True, False], 's', 1, (0, 1), ('s', '')] for fuzzy in fuzzy: with self.assertRaises(TypeError): _assert_valid_fuzzy(fuzzy) class TestIntervalMetadata(unittest.TestCase, ReallyEqualMixin): def setUp(self): self.upper_bound = 10 self.im_empty = IntervalMetadata(self.upper_bound) self.im_1 = IntervalMetadata(self.upper_bound) self.im_1_1 = Interval( interval_metadata=self.im_1, bounds=[(1, 2), (4, self.upper_bound)], metadata={'gene': 'sagA', 'bound': 0}) self.im_2 = IntervalMetadata(self.upper_bound) self.im_2_1 = Interval( interval_metadata=self.im_2, bounds=[(1, 2), (4, self.upper_bound)], metadata={'gene': 'sagA', 'bound': 0}) self.im_2_2 = Interval( interval_metadata=self.im_2, bounds=[(3, 5)], metadata={'gene': 'sagB', 'bound': 0, 'spam': [0]}) def test_copy_empty(self): obs = copy(self.im_empty) self.assertEqual(obs, self.im_empty) self.assertIsNot(obs._intervals, self.im_empty._intervals) self.assertIsNot(obs._interval_tree, self.im_empty._interval_tree) def test_copy(self): obs = copy(self.im_2) self.assertEqual(obs, self.im_2) self.assertIsNot(obs._intervals, self.im_2._intervals) self.assertIsNot(obs._interval_tree, self.im_2._interval_tree) for i in range(self.im_2.num_interval_features): i1, i2 = obs._intervals[i], self.im_2._intervals[i] self.assertIsNot(i1, i2) self.assertIsNot(i1.bounds, i2.bounds) self.assertIsNot(i1.fuzzy, i2.fuzzy) self.assertIsNot(i1._interval_metadata, i2._interval_metadata) self.assertIsNot(i1.metadata, i2.metadata) for k in i1.metadata: self.assertIs(i1.metadata[k], i2.metadata[k]) def test_deepcopy(self): obs = deepcopy(self.im_2) self.assertEqual(obs, self.im_2) self.assertIsNot(obs._intervals, self.im_2._intervals) self.assertIsNot(obs._interval_tree, self.im_2._interval_tree) for i in range(self.im_2.num_interval_features): i1, i2 = obs._intervals[i], self.im_2._intervals[i] self.assertIsNot(i1, i2) self.assertIsNot(i1.bounds, i2.bounds) self.assertIsNot(i1.fuzzy, i2.fuzzy) self.assertIsNot(i1.metadata, i2.metadata) i2.metadata['spam'].append(1) self.assertEqual(i2.metadata, {'gene': 'sagB', 'bound': 0, 'spam': [0, 1]}) self.assertEqual(i1.metadata, {'gene': 'sagB', 'bound': 0, 'spam': [0]}) def test_deepcopy_memo_is_respected(self): memo = {} deepcopy(self.im_1, memo) self.assertGreater(len(memo), 2) def test_init(self): self.assertFalse(self.im_empty._is_stale_tree) self.assertEqual(self.im_empty._intervals, []) def test_init_upper_bound_lt_lower_bound(self): # test that no exception is raised IntervalMetadata(0) with self.assertRaises(ValueError): IntervalMetadata(-1) def test_upper_bound_is_none(self): im = IntervalMetadata(None) # should not raise error im.add([(0, 1000000000)]) self.assertIsNone(im.upper_bound) with self.assertRaisesRegex( TypeError, r'upper bound is `None`'): im._reverse() with self.assertRaisesRegex( TypeError, r'upper bound is `None`'): IntervalMetadata.concat([self.im_1, im]) def test_init_copy_from(self): for i in [None, 99, 999]: obs = IntervalMetadata(i, self.im_1) exp = IntervalMetadata(i) exp.add(bounds=[(1, 2), (4, self.upper_bound)], metadata={'gene': 'sagA', 'bound': 0}) self.assertEqual(obs, exp) def test_init_copy_from_empty(self): for i in [None, 0, 9, 99, 999]: obs = IntervalMetadata(i, self.im_empty) exp = IntervalMetadata(i) self.assertEqual(obs, exp) # test it is shallow copy self.assertIsNot(obs._intervals, self.im_empty._intervals) self.assertIsNot(obs._interval_tree, self.im_empty._interval_tree) def test_init_copy_from_shallow_copy(self): obs = IntervalMetadata(self.upper_bound, self.im_2) self.assertEqual(self.im_2, obs) # test it is shallow copy self.assertIsNot(obs._intervals, self.im_2._intervals) self.assertIsNot(obs._interval_tree, self.im_2._interval_tree) for i in range(self.im_2.num_interval_features): i1, i2 = obs._intervals[i], self.im_2._intervals[i] self.assertIsNot(i1, i2) self.assertIsNot(i1.bounds, i2.bounds) self.assertIsNot(i1.fuzzy, i2.fuzzy) self.assertIsNot(i1._interval_metadata, i2._interval_metadata) self.assertIsNot(i1.metadata, i2.metadata) for k in i1.metadata: self.assertIs(i1.metadata[k], i2.metadata[k]) def test_init_copy_from_error(self): i = self.upper_bound - 1 with self.assertRaisesRegex( ValueError, r'larger than upper bound \(%r\)' % i): IntervalMetadata(i, self.im_2) def test_num_interval_features(self): self.assertEqual(self.im_empty.num_interval_features, 0) self.assertEqual(self.im_1.num_interval_features, 1) self.assertEqual(self.im_2.num_interval_features, 2) def test_duplicate(self): '''Test query and drop methods on duplicate Intervals.''' intvl_1 = self.im_empty.add([(1, 2)]) intvl_2 = self.im_empty.add([(1, 2)]) self.assertEqual(len(list(self.im_empty.query([(1, 2)]))), 2) self.im_empty.drop([intvl_1]) self.assertEqual(len(self.im_empty._intervals), 1) self.assertTrue(self.im_empty._intervals[0] is intvl_2) def test_duplicate_bounds(self): intvl = self.im_empty.add([(1, 2), (1, 2)]) intvls = list(self.im_empty.query([(1, 2)])) self.assertEqual(len(intvls), 1) self.assertTrue(intvl is intvls[0]) def test_concat_empty(self): for i in 0, 1, 2: obs = IntervalMetadata.concat([self.im_empty] * i) exp = IntervalMetadata(self.upper_bound * i) self.assertEqual(obs, exp) obs = IntervalMetadata.concat([]) self.assertEqual(obs, IntervalMetadata(0)) def test_concat(self): im1 = IntervalMetadata(3) im2 = IntervalMetadata(4) im3 = IntervalMetadata(5) im1.add([(0, 2)], [(True, True)]) im2.add([(0, 3)], [(True, False)], {'gene': 'sagA'}) im2.add([(2, 4)], metadata={'gene': 'sagB'}) im3.add([(1, 5)], [(False, True)], {'gene': 'sagC'}) obs = IntervalMetadata.concat([im1, im2, im3]) exp = IntervalMetadata(12) exp.add(bounds=[(0, 2)], fuzzy=[(True, True)]) exp.add(bounds=[(3, 6)], fuzzy=[(True, False)], metadata={'gene': 'sagA'}) exp.add(bounds=[(5, 7)], metadata={'gene': 'sagB'}) exp.add(bounds=[(8, 12)], fuzzy=[(False, True)], metadata={'gene': 'sagC'}) self.assertEqual(obs, exp) def test_merge(self): # empty + empty im = IntervalMetadata(self.upper_bound) self.im_empty.merge(im) self.assertEqual(self.im_empty, im) # empty + non-empty self.im_empty.merge(self.im_1) self.assertEqual(self.im_empty, self.im_1) # non-empty + non-empty self.im_empty.merge(self.im_2) self.im_2.merge(self.im_1) self.assertEqual(self.im_empty, self.im_2) def test_merge_unequal_upper_bounds(self): n = 3 im1 = IntervalMetadata(n) for im in [self.im_empty, self.im_1]: with self.assertRaisesRegex( ValueError, r'not equal \(%d != %d\)' % (self.upper_bound, n)): im.merge(im1) def test_merge_to_unbounded(self): for im in [self.im_empty, self.im_1, IntervalMetadata(None)]: obs = IntervalMetadata(None) obs.merge(im) self.assertIsNone(obs.upper_bound) self.assertEqual(obs._intervals, im._intervals) def test_merge_unbounded_to_bounded(self): im = IntervalMetadata(None) with self.assertRaisesRegex( ValueError, r'Cannot merge an unbound IntervalMetadata object ' 'to a bounded one'): self.im_1.merge(im) # original im is not changed self.assertIsNone(im.upper_bound) self.assertEqual(im._intervals, []) def test_sort(self): interval = Interval( self.im_2, [(1, 2), (3, 8)], metadata={'gene': 'sagA', 'bound': 0}) im = deepcopy(self.im_2) self.im_2.sort(False) # check sorting does not have other side effects self.assertEqual(im, self.im_2) self.assertEqual(self.im_2._intervals, [self.im_2_2, self.im_2_1, interval]) self.im_2.sort() self.assertEqual(im, self.im_2) self.assertEqual(self.im_2._intervals, [interval, self.im_2_1, self.im_2_2]) self.im_empty.sort() self.assertEqual(self.im_empty, IntervalMetadata(self.upper_bound)) def test_add_eq_upper_bound(self): self.im_empty.add(bounds=[(1, 2), (4, self.upper_bound)], metadata={'gene': 'sagA', 'bound': 0}) self.assertTrue(self.im_empty._is_stale_tree) interval = self.im_empty._intervals[0] self.assertEqual(interval.bounds, [(1, 2), (4, self.upper_bound)]) self.assertEqual(interval.metadata, {'gene': 'sagA', 'bound': 0}) self.assertTrue(isinstance(self.im_empty._interval_tree, IntervalTree)) def test_add_gt_upper_bound(self): with self.assertRaises(ValueError): self.im_empty.add(bounds=[(1, 2), (4, self.upper_bound+1)], metadata={'gene': 'sagA', 'bound': 0}) def test_add_eq_start_end_bound(self): for i in 0, 1, self.upper_bound: # test that no exception is raised self.im_empty.add(bounds=[(i, i)], metadata={'gene': 'sagA', 'bound': 0}) def test_query_attribute(self): intervals = self.im_2._query_attribute({}) for i, j in zip(intervals, self.im_2._intervals): self.assertEqual(i, j) intervals = list(self.im_2._query_attribute(None)) self.assertEqual(len(intervals), 0) for i in self.im_2._intervals: intervals = list(self.im_2._query_attribute(i.metadata)) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0], i) def test_query_interval(self): intervals = list(self.im_2._query_interval((1, 2))) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0], self.im_2_1) intervals = list(self.im_2._query_interval((3, 4))) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0], self.im_2_2) intervals = {repr(i) for i in self.im_2._query_interval((1, 7))} self.assertEqual(len(intervals), 2) self.assertSetEqual(intervals, {repr(i) for i in self.im_2._intervals}) def test_query_interval_upper_bound(self): intervals = list(self.im_2._query_interval((self.upper_bound-1, self.upper_bound))) self.assertEqual(intervals, [self.im_2_1]) def test_query(self): intervals = list(self.im_2.query(bounds=[(1, 5)], metadata={'gene': 'sagA'})) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0], self.im_2_1) def test_query_empty(self): intervals = list(self.im_1.query()) self.assertEqual(len(intervals), 1) def test_query_no_hits(self): intervals = list(self.im_2.query(bounds=[(self.upper_bound, 200)])) self.assertEqual(len(intervals), 0) intervals = list(self.im_2.query(metadata={'gene': 'sagC'})) self.assertEqual(len(intervals), 0) intervals = list(self.im_2.query(bounds=[(1, 2)], metadata={'gene': 'sagC'})) self.assertEqual(len(intervals), 0) def test_query_interval_only(self): for loc in [[(1, 7)], [(1, 2), (3, 4)]]: intervals = list(self.im_2.query(bounds=loc)) self.assertEqual(len(intervals), 2) self.assertEqual(intervals[0], self.im_2_1) self.assertEqual(intervals[1], self.im_2_2) def test_query_metadata_only(self): intervals = list(self.im_2.query(metadata={'gene': 'sagB'})) self.assertEqual(len(intervals), 1) self.assertEqual(intervals[0], self.im_2_2) intervals = list(self.im_2.query(metadata={'bound': 0})) self.assertEqual(len(intervals), 2) self.assertEqual(intervals[0], self.im_2_1) self.assertEqual(intervals[1], self.im_2_2) def test_drop(self): intvl = self.im_2._intervals[0] self.im_2.drop([intvl]) self.assertEqual(len(self.im_2._intervals), 1) self.assertEqual(self.im_2._intervals[0], self.im_2_2) # test the intvl was set to dropped self.assertTrue(intvl.dropped) def test_drop_all(self): self.im_2.drop(self.im_2._intervals) self.assertEqual(self.im_2, self.im_empty) def test_drop_negate(self): intvl = self.im_2._intervals[0] self.im_2.drop([intvl], negate=True) self.assertEqual(len(self.im_2._intervals), 1) self.assertEqual(self.im_2._intervals[0], intvl) # test the dropped intvl was set to dropped self.assertTrue(self.im_2_2.dropped) def test_reverse(self): self.im_2._reverse() Interval( interval_metadata=self.im_empty, bounds=[(0, 6), (8, 9)], metadata={'gene': 'sagA', 'bound': 0}) Interval( interval_metadata=self.im_empty, bounds=[(5, 7)], metadata={'gene': 'sagB', 'bound': 0, 'spam': [0]}) self.assertEqual(self.im_2, self.im_empty) def test_eq_ne(self): im1 = IntervalMetadata(10) im1.add(metadata={'gene': 'sagA', 'bound': '0'}, bounds=[(0, 2), (4, 7)]) im1.add(metadata={'gene': 'sagB', 'bound': '3'}, bounds=[(3, 5)]) # The ordering shouldn't matter im2 = IntervalMetadata(10) im2.add(metadata={'gene': 'sagB', 'bound': '3'}, bounds=[(3, 5)]) im2.add(metadata={'gene': 'sagA', 'bound': '0'}, bounds=[(0, 2), (4, 7)]) im3 = IntervalMetadata(10) im3.add(metadata={'gene': 'sagA', 'bound': '3'}, bounds=[(0, 2), (4, 7)]) im3.add(metadata={'gene': 'sagB', 'bound': '3'}, bounds=[(3, 5)]) self.assertReallyEqual(im1, im2) self.assertReallyNotEqual(im1, im3) def test_ne_diff_bounds(self): im1 = IntervalMetadata(10) im2 = IntervalMetadata(9) intvl = {'bounds': [(0, 1)], 'metadata': {'spam': 'foo'}} im1.add(**intvl) im2.add(**intvl) self.assertReallyNotEqual(im1, im2) def test_repr(self): exp = '''0 interval features -------------------''' self.assertEqual(repr(self.im_empty), exp) self.im_empty.add([(1, 2)], metadata={'gene': 'sagA'}) exp = ("1 interval feature\n" "------------------\n" r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(1, 2\)\], " r"fuzzy=\[\(False, False\)\], metadata={'gene': 'sagA'}\)") self.assertRegex(repr(self.im_empty), exp) self.im_empty.add([(3, 4)], metadata={'gene': 'sagB'}) self.im_empty.add([(3, 4)], metadata={'gene': 'sagC'}) self.im_empty.add([(3, 4)], metadata={'gene': 'sagD'}) self.im_empty.add([(3, 4)], metadata={'gene': 'sagE'}) self.im_empty.add([(3, 4)], metadata={'gene': 'sagF'}) exp = ("6 interval features\n" "-------------------\n" r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(1, 2\)\], " r"fuzzy=\[\(False, False\)\], metadata={'gene': 'sagA'}\)\n" r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(3, 4\)\], " r"fuzzy=\[\(False, False\)\], metadata={'gene': 'sagB'}\)\n" r"...\n" r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(3, 4\)\], " r"fuzzy=\[\(False, False\)\], metadata={'gene': 'sagE'}\)\n" r"Interval\(interval_metadata=<[0-9]+>, bounds=\[\(3, 4\)\], " r"fuzzy=\[\(False, False\)\], metadata={'gene': 'sagF'}\)") self.assertRegex(repr(self.im_empty), exp) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/metadata/tests/test_mixin.py000066400000000000000000000106461446255456000223720ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio.metadata._mixin import (MetadataMixin, PositionalMetadataMixin, IntervalMetadataMixin) from skbio.util._decorator import overrides from skbio.util._testing import ReallyEqualMixin from skbio.metadata._testing import (MetadataMixinTests, PositionalMetadataMixinTests, IntervalMetadataMixinTests) class TestMetadataMixin(unittest.TestCase, ReallyEqualMixin, MetadataMixinTests): def setUp(self): class ExampleMetadataMixin(MetadataMixin): def __init__(self, metadata=None): MetadataMixin._init_(self, metadata=metadata) def __eq__(self, other): return MetadataMixin._eq_(self, other) def __ne__(self, other): return MetadataMixin._ne_(self, other) def __copy__(self): copy = self.__class__(metadata=None) copy._metadata = MetadataMixin._copy_(self) return copy def __deepcopy__(self, memo): copy = self.__class__(metadata=None) copy._metadata = MetadataMixin._deepcopy_(self, memo) return copy self._metadata_constructor_ = ExampleMetadataMixin class TestPositionalMetadataMixin(unittest.TestCase, ReallyEqualMixin, PositionalMetadataMixinTests): def setUp(self): class ExamplePositionalMetadataMixin(PositionalMetadataMixin): @overrides(PositionalMetadataMixin) def _positional_metadata_axis_len_(self): return self._axis_len def __init__(self, axis_len, positional_metadata=None): self._axis_len = axis_len PositionalMetadataMixin._init_( self, positional_metadata=positional_metadata) def __eq__(self, other): return PositionalMetadataMixin._eq_(self, other) def __ne__(self, other): return PositionalMetadataMixin._ne_(self, other) def __copy__(self): copy = self.__class__(self._axis_len, positional_metadata=None) copy._positional_metadata = \ PositionalMetadataMixin._copy_(self) return copy def __deepcopy__(self, memo): copy = self.__class__(self._axis_len, positional_metadata=None) copy._positional_metadata = \ PositionalMetadataMixin._deepcopy_(self, memo) return copy self._positional_metadata_constructor_ = ExamplePositionalMetadataMixin class TestIntervalMetadataMixin(unittest.TestCase, ReallyEqualMixin, IntervalMetadataMixinTests): def setUp(self): super()._set_up() class ExampleIntervalMetadataMixin(IntervalMetadataMixin): @overrides(IntervalMetadataMixin) def _interval_metadata_axis_len_(self): return self._axis_len def __init__(self, axis_len, interval_metadata=None): self._axis_len = axis_len IntervalMetadataMixin._init_( self, interval_metadata=interval_metadata) def __eq__(self, other): return IntervalMetadataMixin._eq_(self, other) def __ne__(self, other): return IntervalMetadataMixin._ne_(self, other) def __copy__(self): copy = self.__class__(self._axis_len, interval_metadata=None) copy._interval_metadata = IntervalMetadataMixin._copy_(self) return copy def __deepcopy__(self, memo): copy = self.__class__(self._axis_len, interval_metadata=None) copy._interval_metadata = IntervalMetadataMixin._deepcopy_( self, memo) return copy self._interval_metadata_constructor_ = ExampleIntervalMetadataMixin if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/sequence/000077500000000000000000000000001446255456000165145ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/sequence/__init__.py000066400000000000000000000167671446255456000206460ustar00rootroot00000000000000r""" Sequences (:mod:`skbio.sequence`) ================================= .. currentmodule:: skbio.sequence This module provides classes for storing and working with sequences, including generic/nonbiological sequences which have no alphabet restrictions (``Sequence``) and sequences based on IUPAC-defined alphabets (``DNA``, ``RNA``, ``Protein``). Common operations are defined as methods, for example computing the reverse complement of a DNA sequence, or searching for N-glycosylation motifs in protein sequences. Class attributes provide valid character sets, complement maps for different sequence types, and degenerate character definitions. Additionally this module defines the ``GeneticCode`` class, which represents an immutable object that translates DNA or RNA sequences into protein sequences. The primary information stored for each different type of sequence object is the underlying sequence data itself. This is stored as an immutable numpy array. Additionally, each type of sequence may include optional metadata and positional metadata. Note that metadata and positional metadata are mutable. Classes ------- .. autosummary:: :toctree: generated/ Sequence GrammaredSequence DNA RNA Protein GeneticCode Subpackages ----------- .. autosummary:: :toctree: generated/ distance Examples -------- New sequences are created with optional metadata and positional metadata. Metadata is stored as a Python ``dict``, while positional metadata is stored as a pandas ``DataFrame``. >>> from skbio import DNA, RNA >>> d = DNA('ACCGGGTA', metadata={'id':"my-sequence", 'description':"GFP"}, ... positional_metadata={'quality':[22, 25, 22, 18, 23, 25, 25, 25]}) >>> d DNA ----------------------------- Metadata: 'description': 'GFP' 'id': 'my-sequence' Positional metadata: 'quality': Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 62.50% ----------------------------- 0 ACCGGGTA New sequences can also be created from existing sequences, for example as their reverse complement or degapped (i.e., unaligned) version. >>> d1 = DNA('.ACC--GGG-TA...', metadata={'id':'my-sequence'}) >>> d2 = d1.degap() >>> d2 DNA -------------------------- Metadata: 'id': 'my-sequence' Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 62.50% -------------------------- 0 ACCGGGTA >>> d3 = d2.reverse_complement() >>> d3 DNA -------------------------- Metadata: 'id': 'my-sequence' Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 62.50% -------------------------- 0 TACCCGGT It's also straightforward to compute distances between sequences (optionally using user-defined distance metrics, the default is Hamming distance which requires that the sequences being compared are the same length) for use in sequence clustering, phylogenetic reconstruction, etc. >>> r1 = RNA('GACCCGCUUU') >>> r2 = RNA('GCCCCCCUUU') >>> r1.distance(r2) 0.2 Similarly, you can calculate the percent (dis)similarity between a pair of aligned sequences. >>> r3 = RNA('ACCGUUAGUC') >>> r4 = RNA('ACGGGU--UC') >>> r3.match_frequency(r4, relative=True) 0.6 >>> r3.mismatch_frequency(r4, relative=True) 0.4 Sequences can be searched for known motif types. This returns the slices that describe the matches. >>> r5 = RNA('AGG-GGACUGAA') >>> for motif in r5.find_motifs('purine-run', min_length=2): ... motif slice(0, 3, None) slice(4, 7, None) slice(9, 12, None) Those slices can be used to extract the relevant subsequences. >>> for motif in r5.find_motifs('purine-run', min_length=2): ... r5[motif] ... print('') RNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 66.67% -------------------------- 0 AGG RNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 66.67% -------------------------- 0 GGA RNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 GAA And gaps or other features can be ignored while searching, as these may disrupt otherwise meaningful motifs. >>> for motif in r5.find_motifs('purine-run', min_length=2, ignore=r5.gaps()): ... r5[motif] ... print('') RNA -------------------------- Stats: length: 7 has gaps: True has degenerates: False has definites: True GC-content: 66.67% -------------------------- 0 AGG-GGA RNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 GAA In the above example, removing gaps from the resulting motif matches is easily achieved, as the sliced matches themselves are sequences of the same type as the input. >>> for motif in r5.find_motifs('purine-run', min_length=2, ignore=r5.gaps()): ... r5[motif].degap() ... print('') RNA -------------------------- Stats: length: 6 has gaps: False has degenerates: False has definites: True GC-content: 66.67% -------------------------- 0 AGGGGA RNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 GAA Sequences can similarly be searched for arbitrary patterns using regular expressions. >>> for match in r5.find_with_regex('(G+AC[UT])'): ... match slice(4, 9, None) DNA can be transcribed to RNA: >>> dna = DNA('ATGTGTATTTGA') >>> rna = dna.transcribe() >>> rna RNA -------------------------- Stats: length: 12 has gaps: False has degenerates: False has definites: True GC-content: 25.00% -------------------------- 0 AUGUGUAUUU GA Both DNA and RNA can be translated into a protein sequence. For example, let's translate our DNA and RNA sequences using NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> protein_from_dna = dna.translate() >>> protein_from_dna Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MCI* >>> protein_from_rna = rna.translate() >>> protein_from_rna Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MCI* The two translations are equivalent: >>> protein_from_dna == protein_from_rna True Class-level methods contain information about the molecule types. >>> sorted(DNA.degenerate_map['B']) ['C', 'G', 'T'] >>> sorted(RNA.degenerate_map['B']) ['C', 'G', 'U'] """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._sequence import Sequence from ._protein import Protein from ._dna import DNA from ._rna import RNA from ._genetic_code import GeneticCode from ._grammared_sequence import GrammaredSequence __all__ = ['Sequence', 'Protein', 'DNA', 'RNA', 'GeneticCode', 'GrammaredSequence'] scikit-bio-0.5.9/skbio/sequence/_dna.py000066400000000000000000000307001446255456000177670ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import skbio from skbio.util._decorator import classproperty, overrides from skbio.util._decorator import stable from ._nucleotide_mixin import NucleotideMixin, _motifs as _parent_motifs from ._grammared_sequence import GrammaredSequence, DisableSubclassingMeta class DNA(GrammaredSequence, NucleotideMixin, metaclass=DisableSubclassingMeta): r"""Store DNA sequence data and optional associated metadata. Only characters in the IUPAC DNA character set [1]_ are supported. Parameters ---------- sequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Characters representing the DNA sequence itself. metadata : dict, optional Arbitrary metadata which applies to the entire sequence. positional_metadata : Pandas DataFrame consumable, optional Arbitrary per-character metadata. For example, quality data from sequencing reads. Must be able to be passed directly to the Pandas DataFrame constructor. interval_metadata : IntervalMetadata Arbitrary interval metadata which applies to intervals within a sequence to store interval features (such as genes on the DNA sequence). lowercase : bool or str, optional If ``True``, lowercase sequence characters will be converted to uppercase characters in order to be valid IUPAC DNA characters. If ``False``, no characters will be converted. If a str, it will be treated as a key into the positional metadata of the object. All lowercase characters will be converted to uppercase, and a ``True`` value will be stored in a boolean array in the positional metadata under the key. validate : bool, optional If ``True``, validation will be performed to ensure that all sequence characters are in the IUPAC DNA character set. If ``False``, validation will not be performed. Turning off validation will improve runtime performance. If invalid characters are present, however, there is **no guarantee that operations performed on the resulting object will work or behave as expected.** Only turn off validation if you are certain that the sequence characters are valid. To store sequence data that is not IUPAC-compliant, use ``Sequence``. See Also -------- RNA GrammaredSequence Notes ----- Subclassing is disabled for DNA, because subclassing makes it possible to change the alphabet, and certain methods rely on the IUPAC alphabet. If a custom sequence alphabet is needed, inherit directly from ``GrammaredSequence``. References ---------- .. [1] Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden Examples -------- >>> from skbio import DNA >>> DNA('ACCGAAT') DNA -------------------------- Stats: length: 7 has gaps: False has degenerates: False has definites: True GC-content: 42.86% -------------------------- 0 ACCGAAT Convert lowercase characters to uppercase: >>> DNA('AcCGaaT', lowercase=True) DNA -------------------------- Stats: length: 7 has gaps: False has degenerates: False has definites: True GC-content: 42.86% -------------------------- 0 ACCGAAT """ @classproperty @overrides(NucleotideMixin) def complement_map(cls): comp_map = { 'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'Y': 'R', 'R': 'Y', 'S': 'S', 'W': 'W', 'K': 'M', 'M': 'K', 'B': 'V', 'D': 'H', 'H': 'D', 'V': 'B', 'N': 'N' } comp_map.update({c: c for c in cls.gap_chars}) return comp_map @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set("ACGT") @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return { "R": set("AG"), "Y": set("CT"), "M": set("AC"), "K": set("TG"), "W": set("AT"), "S": set("GC"), "B": set("CGT"), "D": set("AGT"), "H": set("ACT"), "V": set("ACG"), "N": set("ACGT") } @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @property def _motifs(self): return _motifs @stable(as_of="0.4.0") def transcribe(self): """Transcribe DNA into RNA. DNA sequence is assumed to be the coding strand. Thymine (T) is replaced with uracil (U) in the transcribed sequence. Returns ------- RNA Transcribed sequence. See Also -------- translate translate_six_frames Notes ----- DNA sequence's metadata, positional, and interval metadata are included in the transcribed RNA sequence. Examples -------- Transcribe DNA into RNA: >>> from skbio import DNA >>> dna = DNA('TAACGTTA') >>> dna DNA -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 25.00% -------------------------- 0 TAACGTTA >>> dna.transcribe() RNA -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 25.00% -------------------------- 0 UAACGUUA """ seq = self._string.replace(b'T', b'U') metadata = None if self.has_metadata(): metadata = self.metadata positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata interval_metadata = None if self.has_interval_metadata(): interval_metadata = self.interval_metadata # turn off validation because `seq` is guaranteed to be valid return skbio.RNA(seq, metadata=metadata, positional_metadata=positional_metadata, interval_metadata=interval_metadata, validate=False) @stable(as_of="0.4.0") def translate(self, *args, **kwargs): """Translate DNA sequence into protein sequence. DNA sequence is assumed to be the coding strand. DNA sequence is first transcribed into RNA and then translated into protein. Parameters ---------- args : tuple Positional arguments accepted by ``RNA.translate``. kwargs : dict Keyword arguments accepted by ``RNA.translate``. Returns ------- Protein Translated sequence. See Also -------- RNA.reverse_transcribe RNA.translate translate_six_frames transcribe Notes ----- DNA sequence's metadata are included in the translated protein sequence. Positional metadata are not included. Examples -------- Translate DNA into protein using NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import DNA >>> dna = DNA('ATGCCACTTTAA') >>> dna.translate() Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* Translate the same DNA sequence using a different NCBI genetic code (table ID 3, the yeast mitochondrial code) and specify that translation must terminate at the first stop codon: >>> dna.translate(3, stop='require') Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 MPT """ return self.transcribe().translate(*args, **kwargs) @stable(as_of="0.4.0") def translate_six_frames(self, *args, **kwargs): """Translate DNA into protein using six possible reading frames. DNA sequence is assumed to be the coding strand. DNA sequence is first transcribed into RNA and then translated into protein. The six possible reading frames are: * 1 (forward) * 2 (forward) * 3 (forward) * -1 (reverse) * -2 (reverse) * -3 (reverse) Translated sequences are yielded in this order. Parameters ---------- args : tuple Positional arguments accepted by ``RNA.translate_six_frames``. kwargs : dict Keyword arguments accepted by ``RNA.translate_six_frames``. Yields ------ Protein Translated sequence in the current reading frame. See Also -------- RNA.translate_six_frames translate transcribe Notes ----- This method is faster than (and equivalent to) performing six independent translations using, for example: ``(seq.translate(reading_frame=rf) for rf in GeneticCode.reading_frames)`` DNA sequence's metadata are included in each translated protein sequence. Positional metadata are not included. Examples -------- Translate DNA into protein using the six possible reading frames and NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import DNA >>> dna = DNA('ATGCCACTTTAA') >>> for protein in dna.translate_six_frames(): ... protein ... print('') Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 CHF Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 ATL Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 LKWH Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 *SG Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 KVA """ return self.transcribe().translate_six_frames(*args, **kwargs) @overrides(GrammaredSequence) def _repr_stats(self): """Define custom statistics to display in the sequence's repr.""" stats = super(DNA, self)._repr_stats() stats.append(('GC-content', '{:.2%}'.format(self.gc_content()))) return stats _motifs = _parent_motifs.copy() # Leave this at the bottom _motifs.interpolate(DNA, "find_motifs") scikit-bio-0.5.9/skbio/sequence/_genetic_code.py000066400000000000000000000745301446255456000216460ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.util._decorator import classproperty, stable, classonlymethod from skbio._base import SkbioObject from skbio.sequence import Protein, RNA from skbio._base import ElasticLines class GeneticCode(SkbioObject): """Genetic code for translating codons to amino acids. Parameters ---------- amino_acids : consumable by ``skbio.Protein`` constructor 64-character vector containing IUPAC amino acid characters. The order of the amino acids should correspond to NCBI's codon order (see *Notes* section below). `amino_acids` is the "AAs" field in NCBI's genetic code format [1]_. starts : consumable by ``skbio.Protein`` constructor 64-character vector containing only M and - characters, with start codons indicated by M. The order of the amino acids should correspond to NCBI's codon order (see *Notes* section below). `starts` is the "Starts" field in NCBI's genetic code format [1]_. name : str, optional Genetic code name. This is simply metadata and does not affect the functionality of the genetic code itself. See Also -------- RNA.translate DNA.translate GeneticCode.from_ncbi Notes ----- The genetic codes available via ``GeneticCode.from_ncbi`` and used throughout the examples are defined in [1]_. The genetic code strings defined there are directly compatible with the ``GeneticCode`` constructor. The order of `amino_acids` and `starts` should correspond to NCBI's codon order, defined in [1]_:: UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGG UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG Note that scikit-bio displays this ordering using the IUPAC RNA alphabet, while NCBI displays this same ordering using the IUPAC DNA alphabet (for historical purposes). References ---------- .. [1] http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi Examples -------- Get NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import GeneticCode >>> GeneticCode.from_ncbi() GeneticCode (Standard) ------------------------------------------------------------------------- AAs = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG Starts = ---M---------------M---------------M---------------------------- Base1 = UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG Base2 = UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGG Base3 = UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG Get a different NCBI genetic code (25): >>> GeneticCode.from_ncbi(25) GeneticCode (Candidate Division SR1 and Gracilibacteria) ------------------------------------------------------------------------- AAs = FFLLSSSSYY**CCGWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG Starts = ---M-------------------------------M---------------M------------ Base1 = UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG Base2 = UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGG Base3 = UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG Define a custom genetic code: >>> GeneticCode('M' * 64, '-' * 64) GeneticCode ------------------------------------------------------------------------- AAs = MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM Starts = ---------------------------------------------------------------- Base1 = UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG Base2 = UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGG Base3 = UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG Translate an RNA sequence to protein using NCBI's standard genetic code: >>> from skbio import RNA >>> rna = RNA('AUGCCACUUUAA') >>> GeneticCode.from_ncbi().translate(rna) Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* """ _num_codons = 64 _radix_multiplier = np.asarray([16, 4, 1], dtype=np.uint8) _start_stop_options = ['ignore', 'optional', 'require'] __offset_table = None @classproperty def _offset_table(cls): if cls.__offset_table is None: # create lookup table that is filled with 255 everywhere except for # indices corresponding to U, C, A, and G. 255 was chosen to # represent invalid character offsets because it will create an # invalid (out of bounds) index into `amino_acids` which should # error noisily. this is important in case the valid definite # IUPAC RNA characters change in the future and the assumptions # currently made by the code become invalid table = np.empty(ord(b'U') + 1, dtype=np.uint8) table.fill(255) table[ord(b'U')] = 0 table[ord(b'C')] = 1 table[ord(b'A')] = 2 table[ord(b'G')] = 3 cls.__offset_table = table return cls.__offset_table @classonlymethod @stable(as_of="0.4.0") def from_ncbi(cls, table_id=1): """Return NCBI genetic code specified by table ID. Parameters ---------- table_id : int, optional Table ID of the NCBI genetic code to return. Returns ------- GeneticCode NCBI genetic code specified by `table_id`. Notes ----- The table IDs and genetic codes available in this method and used throughout the examples are defined in [1]_. References ---------- .. [1] http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi Examples -------- Get the NCBI thraustochytrium mitochondrial genetic code (23): >>> tmgc = GeneticCode.from_ncbi(23) >>> tmgc.name 'Thraustochytrium Mitochondrial' """ if table_id not in _ncbi_genetic_codes: raise ValueError( "`table_id` must be one of %r, not %r" % (sorted(_ncbi_genetic_codes), table_id)) return _ncbi_genetic_codes[table_id] @classproperty @stable(as_of="0.4.0") def reading_frames(cls): """Six possible reading frames. Reading frames are ordered: * 1 (forward) * 2 (forward) * 3 (forward) * -1 (reverse) * -2 (reverse) * -3 (reverse) This property can be passed into ``GeneticCode.translate(reading_frame)``. Returns ------- list (int) Six possible reading frames. """ return [1, 2, 3, -1, -2, -3] @property @stable(as_of="0.4.0") def name(self): """Genetic code name. This is simply metadata and does not affect the functionality of the genetic code itself. Returns ------- str Genetic code name. """ return self._name @stable(as_of="0.4.0") def __init__(self, amino_acids, starts, name=''): self._set_amino_acids(amino_acids) self._set_starts(starts) self._name = name def _set_amino_acids(self, amino_acids): amino_acids = Protein(amino_acids) if len(amino_acids) != self._num_codons: raise ValueError("`amino_acids` must be length %d, not %d" % (self._num_codons, len(amino_acids))) indices = (amino_acids.values == b'M').nonzero()[0] if indices.size < 1: raise ValueError("`amino_acids` must contain at least one M " "(methionine) character") self._amino_acids = amino_acids self._m_character_codon = self._index_to_codon(indices[0]) def _set_starts(self, starts): starts = Protein(starts) if len(starts) != self._num_codons: raise ValueError("`starts` must be length %d, not %d" % (self._num_codons, len(starts))) if ((starts.values == b'M').sum() + (starts.values == b'-').sum() != len(starts)): # to prevent the user from accidentally swapping `starts` and # `amino_acids` and getting a translation back raise ValueError("`starts` may only contain M and - characters") self._starts = starts indices = (self._starts.values == b'M').nonzero()[0] codons = np.empty((indices.size, 3), dtype=np.uint8) for i, index in enumerate(indices): codons[i] = self._index_to_codon(index) self._start_codons = codons def _index_to_codon(self, index): """Convert AA index (0-63) to codon encoded in offsets (0-3).""" codon = np.empty(3, dtype=np.uint8) for i, multiplier in enumerate(self._radix_multiplier): offset, index = divmod(index, multiplier) codon[i] = offset return codon @stable(as_of="0.4.0") def __str__(self): """Return string representation of the genetic code. Returns ------- str Genetic code in NCBI genetic code format. Notes ----- Representation uses NCBI genetic code format defined in [1]_. References ---------- .. [1] http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi """ return self._build_repr(include_name=False) @stable(as_of="0.4.0") def __repr__(self): """Return string representation of the genetic code. Returns ------- str Genetic code in NCBI genetic code format. Notes ----- Representation uses NCBI genetic code format defined in [1]_ preceded by a header. If the genetic code has a name, it will be included in the header. References ---------- .. [1] http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi """ return self._build_repr(include_name=True) def _build_repr(self, include_name): lines = ElasticLines() if include_name: name_line = self.__class__.__name__ if len(self.name) > 0: name_line += ' (%s)' % self.name lines.add_line(name_line) lines.add_separator() lines.add_line(' AAs = %s' % str(self._amino_acids)) lines.add_line('Starts = %s' % str(self._starts)) base1 = 'U' * 16 + 'C' * 16 + 'A' * 16 + 'G' * 16 lines.add_line('Base1 = %s' % base1) base2 = ('U' * 4 + 'C' * 4 + 'A' * 4 + 'G' * 4) * 4 lines.add_line('Base2 = %s' % base2) base3 = 'UCAG' * 16 lines.add_line('Base3 = %s' % base3) return lines.to_str() @stable(as_of="0.4.0") def __eq__(self, other): """Determine if the genetic code is equal to another. Genetic codes are equal if they are *exactly* the same type and defined by the same `amino_acids` and `starts`. A genetic code's name (accessed via ``name`` property) does not affect equality. Parameters ---------- other : GeneticCode Genetic code to test for equality against. Returns ------- bool Indicates whether the genetic code is equal to `other`. Examples -------- NCBI genetic codes 1 and 2 are not equal: >>> GeneticCode.from_ncbi(1) == GeneticCode.from_ncbi(2) False Define a custom genetic code: >>> gc = GeneticCode('M' * 64, '-' * 64) Define a second genetic code with the same `amino_acids` and `starts`. Note that the presence of a name does not make the genetic codes unequal: >>> named_gc = GeneticCode('M' * 64, '-' * 64, name='example name') >>> gc == named_gc True """ if self.__class__ != other.__class__: return False # convert Protein to str so that metadata is ignored in comparison. we # only care about the sequence data defining the genetic code if str(self._amino_acids) != str(other._amino_acids): return False if str(self._starts) != str(other._starts): return False return True @stable(as_of="0.4.0") def __ne__(self, other): """Determine if the genetic code is not equal to another. Genetic codes are not equal if their type, `amino_acids`, or `starts` differ. A genetic code's name (accessed via ``name`` property) does not affect equality. Parameters ---------- other : GeneticCode Genetic code to test for inequality against. Returns ------- bool Indicates whether the genetic code is not equal to `other`. """ return not (self == other) @stable(as_of="0.4.0") def translate(self, sequence, reading_frame=1, start='ignore', stop='ignore'): """Translate RNA sequence into protein sequence. Parameters ---------- sequence : RNA RNA sequence to translate. reading_frame : {1, 2, 3, -1, -2, -3} Reading frame to use in translation. 1, 2, and 3 are forward frames and -1, -2, and -3 are reverse frames. If reverse (negative), will reverse complement the sequence before translation. start : {'ignore', 'require', 'optional'} How to handle start codons: * "ignore": translation will start from the beginning of the reading frame, regardless of the presence of a start codon. * "require": translation will start at the first start codon in the reading frame, ignoring all prior positions. The first amino acid in the translated sequence will *always* be methionine (M character), even if an alternative start codon was used in translation. This behavior most closely matches the underlying biology since fMet doesn't have a corresponding IUPAC character. If a start codon does not exist, a ``ValueError`` is raised. * "optional": if a start codon exists in the reading frame, matches the behavior of "require". If a start codon does not exist, matches the behavior of "ignore". stop : {'ignore', 'require', 'optional'} How to handle stop codons: * "ignore": translation will ignore the presence of stop codons and translate to the end of the reading frame. * "require": translation will terminate at the first stop codon. The stop codon will not be included in the translated sequence. If a stop codon does not exist, a ``ValueError`` is raised. * "optional": if a stop codon exists in the reading frame, matches the behavior of "require". If a stop codon does not exist, matches the behavior of "ignore". Returns ------- Protein Translated sequence. See Also -------- translate_six_frames Notes ----- Input RNA sequence metadata are included in the translated protein sequence. Positional metadata are not included. Examples -------- Translate RNA into protein using NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import RNA, GeneticCode >>> rna = RNA('AGUAUUCUGCCACUGUAAGAA') >>> sgc = GeneticCode.from_ncbi() >>> sgc.translate(rna) Protein -------------------------- Stats: length: 7 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 SILPL*E In this command, we used the default ``start`` behavior, which starts translation at the beginning of the reading frame, regardless of the presence of a start codon. If we specify "require", translation will start at the first start codon in the reading frame (in this example, CUG), ignoring all prior positions: >>> sgc.translate(rna, start='require') Protein -------------------------- Stats: length: 5 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL*E Note that the codon coding for L (CUG) is an alternative start codon in this genetic code. Since we specified "require" mode, methionine (M) was used in place of the alternative start codon (L). This behavior most closely matches the underlying biology since fMet doesn't have a corresponding IUPAC character. Translate the same RNA sequence, also specifying that translation terminate at the first stop codon in the reading frame: >>> sgc.translate(rna, start='require', stop='require') Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 MPL Passing "require" to both ``start`` and ``stop`` trims the translation to the CDS (and in fact requires that one is present in the reading frame). Changing the reading frame to 2 causes an exception to be raised because a start codon doesn't exist in the reading frame: >>> sgc.translate(rna, start='require', stop='require', ... reading_frame=2) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: ... """ self._validate_translate_inputs(sequence, reading_frame, start, stop) offset = abs(reading_frame) - 1 if reading_frame < 0: sequence = sequence.reverse_complement() # Translation strategy: # # 1. Obtain view of underlying sequence bytes from the beginning of # the reading frame. # 2. Convert bytes to offsets (0-3, base 4 since there are only 4 # characters allowed: UCAG). # 3. Reshape byte vector into (N, 3), where N is the number of codons # in the reading frame. Each row represents a codon in the # sequence. # 4. (Optional) Find start codon in the reading frame and trim to # this position. Replace start codon with M codon. # 5. Convert each codon (encoded as offsets) into an index # corresponding to an amino acid (0-63). # 6. Obtain translated sequence by indexing into the amino acids # vector (`amino_acids`) using the indices defined in step 5. # 7. (Optional) Find first stop codon and trim to this position. data = sequence.values[offset:].view(np.uint8) # since advanced indexing is used with an integer ndarray, a copy is # always returned. thus, the in-place modification made below # (replacing the start codon) is safe. data = self._offset_table[data] data = data[:data.size // 3 * 3].reshape((-1, 3)) if start in {'require', 'optional'}: start_codon_index = data.shape[0] for start_codon in self._start_codons: indices = np.all(data == start_codon, axis=1).nonzero()[0] if indices.size > 0: first_index = indices[0] if first_index < start_codon_index: start_codon_index = first_index if start_codon_index != data.shape[0]: data = data[start_codon_index:] data[0] = self._m_character_codon elif start == 'require': self._raise_require_error('start', reading_frame) indices = (data * self._radix_multiplier).sum(axis=1) translated = self._amino_acids.values[indices] if stop in {'require', 'optional'}: stop_codon_indices = (translated == b'*').nonzero()[0] if stop_codon_indices.size > 0: translated = translated[:stop_codon_indices[0]] elif stop == 'require': self._raise_require_error('stop', reading_frame) metadata = None if sequence.has_metadata(): metadata = sequence.metadata # turn off validation because `translated` is guaranteed to be valid return Protein(translated, metadata=metadata, validate=False) def _validate_translate_inputs(self, sequence, reading_frame, start, stop): if not isinstance(sequence, RNA): raise TypeError("Sequence to translate must be RNA, not %s" % type(sequence).__name__) if reading_frame not in self.reading_frames: raise ValueError("`reading_frame` must be one of %r, not %r" % (self.reading_frames, reading_frame)) for name, value in ('start', start), ('stop', stop): if value not in self._start_stop_options: raise ValueError("`%s` must be one of %r, not %r" % (name, self._start_stop_options, value)) if sequence.has_gaps(): raise ValueError("scikit-bio does not support translation of " "gapped sequences.") if sequence.has_degenerates(): raise NotImplementedError("scikit-bio does not currently support " "translation of degenerate sequences." "`RNA.expand_degenerates` can be used " "to obtain all definite versions " "of a degenerate sequence.") def _raise_require_error(self, name, reading_frame): raise ValueError( "Sequence does not contain a %s codon in the " "current reading frame (`reading_frame=%d`). Presence " "of a %s codon is required with `%s='require'`" % (name, reading_frame, name, name)) @stable(as_of="0.4.0") def translate_six_frames(self, sequence, start='ignore', stop='ignore'): """Translate RNA into protein using six possible reading frames. The six possible reading frames are: * 1 (forward) * 2 (forward) * 3 (forward) * -1 (reverse) * -2 (reverse) * -3 (reverse) Translated sequences are yielded in this order. Parameters ---------- sequence : RNA RNA sequence to translate. start : {'ignore', 'require', 'optional'} How to handle start codons. See ``GeneticCode.translate`` for details. stop : {'ignore', 'require', 'optional'} How to handle stop codons. See ``GeneticCode.translate`` for details. Yields ------ Protein Translated sequence in the current reading frame. See Also -------- translate Notes ----- This method is faster than (and equivalent to) performing six independent translations using, for example: ``(gc.translate(seq, reading_frame=rf) for rf in GeneticCode.reading_frames)`` Input RNA sequence metadata are included in each translated protein sequence. Positional metadata are not included. Examples -------- Translate RNA into protein using the six possible reading frames and NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import RNA, GeneticCode >>> rna = RNA('AUGCCACUUUAA') >>> sgc = GeneticCode.from_ncbi() >>> for protein in sgc.translate_six_frames(rna): ... protein ... print('') Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 CHF Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 ATL Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 LKWH Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 *SG Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 KVA """ rc = sequence.reverse_complement() for reading_frame in range(1, 4): yield self.translate(sequence, reading_frame=reading_frame, start=start, stop=stop) for reading_frame in range(1, 4): yield self.translate(rc, reading_frame=reading_frame, start=start, stop=stop) # defined at http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi _ncbi_genetic_codes = { 1: GeneticCode( 'FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '---M---------------M---------------M----------------------------', 'Standard'), 2: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSS**VVVVAAAADDEEGGGG', '--------------------------------MMMM---------------M------------', 'Vertebrate Mitochondrial'), 3: GeneticCode( 'FFLLSSSSYY**CCWWTTTTPPPPHHQQRRRRIIMMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '----------------------------------MM----------------------------', 'Yeast Mitochondrial'), 4: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '--MM---------------M------------MMMM---------------M------------', 'Mold, Protozoan, and Coelenterate Mitochondrial, and ' 'Mycoplasma/Spiroplasma'), 5: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSSSSVVVVAAAADDEEGGGG', '---M----------------------------MMMM---------------M------------', 'Invertebrate Mitochondrial'), 6: GeneticCode( 'FFLLSSSSYYQQCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '-----------------------------------M----------------------------', 'Ciliate, Dasycladacean and Hexamita Nuclear'), 9: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNNKSSSSVVVVAAAADDEEGGGG', '-----------------------------------M---------------M------------', 'Echinoderm and Flatworm Mitochondrial'), 10: GeneticCode( 'FFLLSSSSYY**CCCWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '-----------------------------------M----------------------------', 'Euplotid Nuclear'), 11: GeneticCode( 'FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '---M---------------M------------MMMM---------------M------------', 'Bacterial, Archaeal and Plant Plastid'), 12: GeneticCode( 'FFLLSSSSYY**CC*WLLLSPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '-------------------M---------------M----------------------------', 'Alternative Yeast Nuclear'), 13: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSSGGVVVVAAAADDEEGGGG', '---M------------------------------MM---------------M------------', 'Ascidian Mitochondrial'), 14: GeneticCode( 'FFLLSSSSYYY*CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNNKSSSSVVVVAAAADDEEGGGG', '-----------------------------------M----------------------------', 'Alternative Flatworm Mitochondrial'), 16: GeneticCode( 'FFLLSSSSYY*LCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '-----------------------------------M----------------------------', 'Chlorophycean Mitochondrial'), 21: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNNKSSSSVVVVAAAADDEEGGGG', '-----------------------------------M---------------M------------', 'Trematode Mitochondrial'), 22: GeneticCode( 'FFLLSS*SYY*LCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '-----------------------------------M----------------------------', 'Scenedesmus obliquus Mitochondrial'), 23: GeneticCode( 'FF*LSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '--------------------------------M--M---------------M------------', 'Thraustochytrium Mitochondrial'), 24: GeneticCode( 'FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSSKVVVVAAAADDEEGGGG', '---M---------------M---------------M---------------M------------', 'Pterobranchia Mitochondrial'), 25: GeneticCode( 'FFLLSSSSYY**CCGWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG', '---M-------------------------------M---------------M------------', 'Candidate Division SR1 and Gracilibacteria') } scikit-bio-0.5.9/skbio/sequence/_grammared_sequence.py000066400000000000000000000576471446255456000230770ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from abc import ABCMeta, abstractproperty from itertools import product import re import numpy as np from skbio.util._decorator import (classproperty, overrides, stable, deprecated, experimental) from skbio.util._misc import MiniRegistry from ._sequence import Sequence class GrammaredSequenceMeta(ABCMeta, type): def __new__(mcs, name, bases, dct): cls = super(GrammaredSequenceMeta, mcs).__new__(mcs, name, bases, dct) concrete_gap_chars = \ type(cls.gap_chars) is not abstractproperty concrete_degenerate_map = \ type(cls.degenerate_map) is not abstractproperty concrete_definite_chars = \ type(cls.definite_chars) is not abstractproperty concrete_default_gap_char = \ type(cls.default_gap_char) is not abstractproperty # degenerate_chars is not abstract but it depends on degenerate_map # which is abstract. concrete_degenerate_chars = concrete_degenerate_map # Only perform metaclass checks if none of the attributes on the class # are abstract. # TODO: Rather than hard-coding a list of attributes to check, we can # probably check all the attributes on the class and make sure none of # them are abstract. if (concrete_gap_chars and concrete_degenerate_map and concrete_definite_chars and concrete_default_gap_char and concrete_degenerate_chars): if cls.default_gap_char not in cls.gap_chars: raise TypeError( "default_gap_char must be in gap_chars for class %s" % name) if len(cls.gap_chars & cls.degenerate_chars) > 0: raise TypeError( "gap_chars and degenerate_chars must not share any " "characters for class %s" % name) for key in cls.degenerate_map.keys(): for definite_char in cls.degenerate_map[key]: if definite_char not in cls.definite_chars: raise TypeError( "degenerate_map must expand only to " "characters included in definite_chars " "for class %s" % name) if len(cls.degenerate_chars & cls.definite_chars) > 0: raise TypeError( "degenerate_chars and definite_chars must not " "share any characters for class %s" % name) if len(cls.gap_chars & cls.definite_chars) > 0: raise TypeError( "gap_chars and definite_chars must not share any " "characters for class %s" % name) return cls # Adapted from http://stackoverflow.com/a/16056691/943814 # Note that inheriting from GrammaredSequenceMeta, rather than something # more general, is intentional. Multiple inheritance with metaclasses can be # tricky and is not handled automatically in Python. Since this class needs to # inherit both from ABCMeta and GrammaredSequenceMeta, the only way we could # find to make this work was to have GrammaredSequenceMeta inherit from ABCMeta # and then inherit from GrammaredSequenceMeta here. class DisableSubclassingMeta(GrammaredSequenceMeta): def __new__(mcs, name, bases, dct): for b in bases: if isinstance(b, DisableSubclassingMeta): raise TypeError("Subclassing disabled for class %s. To create" " a custom sequence class, inherit directly" " from skbio.sequence.%s" % (b.__name__, GrammaredSequence.__name__)) return super(DisableSubclassingMeta, mcs).__new__(mcs, name, bases, dict(dct)) class GrammaredSequence(Sequence, metaclass=GrammaredSequenceMeta): """Store sequence data conforming to a character set. This is an abstract base class (ABC) that cannot be instantiated. This class is intended to be inherited from to create grammared sequences with custom alphabets. Raises ------ ValueError If sequence characters are not in the character set [1]_. See Also -------- DNA RNA Protein References ---------- .. [1] Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden Examples -------- Note in the example below that properties either need to be static or use skbio's `classproperty` decorator. >>> from skbio.sequence import GrammaredSequence >>> from skbio.util import classproperty >>> class CustomSequence(GrammaredSequence): ... @classproperty ... def degenerate_map(cls): ... return {"X": set("AB")} ... ... @classproperty ... def definite_chars(cls): ... return set("ABC") ... ... ... @classproperty ... def default_gap_char(cls): ... return '-' ... ... @classproperty ... def gap_chars(cls): ... return set('-.') >>> seq = CustomSequence('ABABACAC') >>> seq CustomSequence -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True -------------------------- 0 ABABACAC >>> seq = CustomSequence('XXXXXX') >>> seq CustomSequence ------------------------- Stats: length: 6 has gaps: False has degenerates: True has definites: False ------------------------- 0 XXXXXX """ __validation_mask = None __degenerate_codes = None __definite_char_codes = None __gap_codes = None @classproperty def _validation_mask(cls): # TODO These masks could be defined (as literals) on each concrete # object. For now, memoize! if cls.__validation_mask is None: as_bytes = ''.join(cls.alphabet).encode('ascii') cls.__validation_mask = np.invert(np.bincount( np.frombuffer(as_bytes, dtype=np.uint8), minlength=cls._number_of_extended_ascii_codes).astype(bool)) return cls.__validation_mask @classproperty def _degenerate_codes(cls): if cls.__degenerate_codes is None: degens = cls.degenerate_chars cls.__degenerate_codes = np.asarray([ord(d) for d in degens]) return cls.__degenerate_codes @classproperty def _definite_char_codes(cls): if cls.__definite_char_codes is None: definite_chars = cls.definite_chars cls.__definite_char_codes = np.asarray( [ord(d) for d in definite_chars]) return cls.__definite_char_codes @classproperty def _gap_codes(cls): if cls.__gap_codes is None: gaps = cls.gap_chars cls.__gap_codes = np.asarray([ord(g) for g in gaps]) return cls.__gap_codes @classproperty @stable(as_of='0.4.0') def alphabet(cls): """Return valid characters. This includes gap, definite, and degenerate characters. Returns ------- set Valid characters. """ return cls.degenerate_chars | cls.definite_chars | cls.gap_chars @abstractproperty @classproperty @stable(as_of='0.4.0') def gap_chars(cls): """Return characters defined as gaps. Returns ------- set Characters defined as gaps. """ raise NotImplementedError @abstractproperty @classproperty @experimental(as_of='0.4.1') def default_gap_char(cls): """Gap character to use when constructing a new gapped sequence. This character is used when it is necessary to represent gap characters in a new sequence. For example, a majority consensus sequence will use this character to represent gaps. Returns ------- str Default gap character. """ raise NotImplementedError @classproperty @stable(as_of='0.4.0') def degenerate_chars(cls): """Return degenerate characters. Returns ------- set Degenerate characters. """ return set(cls.degenerate_map) @classproperty @deprecated(as_of='0.5.0', until='0.6.0', reason='Renamed to definite_chars') def nondegenerate_chars(cls): """Return non-degenerate characters. Returns ------- set Non-degenerate characters. """ return cls.definite_chars @abstractproperty @classproperty @stable(as_of='0.5.0') def definite_chars(cls): """Return definite characters. Returns ------- set Definite characters. """ raise NotImplementedError @abstractproperty @classproperty @stable(as_of='0.4.0') def degenerate_map(cls): """Return mapping of degenerate to definite characters. Returns ------- dict (set) Mapping of each degenerate character to the set of definite characters it represents. """ raise NotImplementedError @property def _motifs(self): return _motifs @overrides(Sequence) def __init__(self, sequence, metadata=None, positional_metadata=None, interval_metadata=None, lowercase=False, validate=True): super(GrammaredSequence, self).__init__( sequence, metadata, positional_metadata, interval_metadata, lowercase) if validate: self._validate() def _validate(self): # This is the fastest way that we have found to identify the # presence or absence of certain characters (numbers). # It works by multiplying a mask where the numbers which are # permitted have a zero at their index, and all others have a one. # The result is a vector which will propogate counts of invalid # numbers and remove counts of valid numbers, so that we need only # see if the array is empty to determine validity. invalid_characters = np.bincount( self._bytes, minlength=self._number_of_extended_ascii_codes ) * self._validation_mask if np.any(invalid_characters): bad = list(np.where( invalid_characters > 0)[0].astype(np.uint8).view('|S1')) raise ValueError( "Invalid character%s in sequence: %r. \n" "Valid characters: %r\n" "Note: Use `lowercase` if your sequence contains lowercase " "characters not in the sequence's alphabet." % ('s' if len(bad) > 1 else '', [str(b.tobytes().decode("ascii")) for b in bad] if len(bad) > 1 else bad[0], list(self.alphabet))) @stable(as_of='0.4.0') def gaps(self): """Find positions containing gaps in the biological sequence. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` indicates a gap character is present at that position in the biological sequence. See Also -------- has_gaps Examples -------- >>> from skbio import DNA >>> s = DNA('AC-G-') >>> s.gaps() array([False, False, True, False, True], dtype=bool) """ return np.in1d(self._bytes, self._gap_codes) @stable(as_of='0.4.0') def has_gaps(self): """Determine if the sequence contains one or more gap characters. Returns ------- bool Indicates whether there are one or more occurrences of gap characters in the biological sequence. Examples -------- >>> from skbio import DNA >>> s = DNA('ACACGACGTT') >>> s.has_gaps() False >>> t = DNA('A.CAC--GACGTT') >>> t.has_gaps() True """ # TODO use count, there aren't that many gap chars # TODO: cache results return bool(self.gaps().any()) @stable(as_of='0.4.0') def degenerates(self): """Find positions containing degenerate characters in the sequence. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` indicates a degenerate character is present at that position in the biological sequence. See Also -------- has_degenerates definites has_definites Examples -------- >>> from skbio import DNA >>> s = DNA('ACWGN') >>> s.degenerates() array([False, False, True, False, True], dtype=bool) """ return np.in1d(self._bytes, self._degenerate_codes) @stable(as_of='0.4.0') def has_degenerates(self): """Determine if sequence contains one or more degenerate characters. Returns ------- bool Indicates whether there are one or more occurrences of degenerate characters in the biological sequence. See Also -------- degenerates definites has_definites Examples -------- >>> from skbio import DNA >>> s = DNA('ACAC-GACGTT') >>> s.has_degenerates() False >>> t = DNA('ANCACWWGACGTT') >>> t.has_degenerates() True """ # TODO use bincount! # TODO: cache results return bool(self.degenerates().any()) @stable(as_of='0.5.0') def definites(self): """Find positions containing definite characters in the sequence. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` indicates a definite character is present at that position in the biological sequence. See Also -------- has_definites degenerates Examples -------- >>> from skbio import DNA >>> s = DNA('ACWGN') >>> s.definites() array([ True, True, False, True, False], dtype=bool) """ return np.in1d(self._bytes, self._definite_char_codes) @deprecated(as_of='0.5.0', until='0.6.0', reason='Renamed to definites') def nondegenerates(self): """Find positions containing non-degenerate characters in the sequence. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` indicates a non-degenerate character is present at that position in the biological sequence. See Also -------- has_definites degenerates Examples -------- >>> from skbio import DNA >>> s = DNA('ACWGN') >>> s.nondegenerates() array([ True, True, False, True, False], dtype=bool) """ return self.definites() @stable(as_of='0.5.0') def has_definites(self): """Determine if sequence contains one or more definite characters Returns ------- bool Indicates whether there are one or more occurrences of definite characters in the biological sequence. See Also -------- definites degenerates has_degenerates Examples -------- >>> from skbio import DNA >>> s = DNA('NWNNNNNN') >>> s.has_definites() False >>> t = DNA('ANCACWWGACGTT') >>> t.has_definites() True """ # TODO: cache results return bool(self.definites().any()) @deprecated(as_of='0.5.0', until='0.6.0', reason='Renamed to has_definites') def has_nondegenerates(self): """Determine if sequence contains one or more non-degenerate characters Returns ------- bool Indicates whether there are one or more occurrences of non-degenerate characters in the biological sequence. See Also -------- definites degenerates has_degenerates Examples -------- >>> from skbio import DNA >>> s = DNA('NWNNNNNN') >>> s.has_nondegenerates() False >>> t = DNA('ANCACWWGACGTT') >>> t.has_nondegenerates() True """ # TODO: cache results return self.has_definites() @stable(as_of='0.4.0') def degap(self): """Return a new sequence with gap characters removed. Returns ------- GrammaredSequence A new sequence with all gap characters removed. See Also -------- gap_chars Notes ----- The type and metadata of the result will be the same as the biological sequence. If positional metadata is present, it will be filtered in the same manner as the sequence characters and included in the resulting degapped sequence. Examples -------- >>> from skbio import DNA >>> s = DNA('GGTC-C--ATT-C.', ... positional_metadata={'quality':range(14)}) >>> s.degap() DNA ----------------------------- Positional metadata: 'quality': Stats: length: 9 has gaps: False has degenerates: False has definites: True GC-content: 55.56% ----------------------------- 0 GGTCCATTC """ return self[np.invert(self.gaps())] @stable(as_of='0.4.0') def expand_degenerates(self): """Yield all possible definite versions of the sequence. Yields ------ GrammaredSequence Definite version of the sequence. See Also -------- degenerate_map Notes ----- There is no guaranteed ordering to the definite sequences that are yielded. Each definite sequence will have the same type, metadata, and positional metadata as the biological sequence. Examples -------- >>> from skbio import DNA >>> seq = DNA('TRG') >>> seq_generator = seq.expand_degenerates() >>> for s in sorted(seq_generator, key=str): ... s ... print('') DNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 33.33% -------------------------- 0 TAG DNA -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True GC-content: 66.67% -------------------------- 0 TGG """ degen_chars = self.degenerate_map nonexpansion_chars = self.definite_chars.union(self.gap_chars) expansions = [] for char in self: char = str(char) if char in nonexpansion_chars: expansions.append(char) else: expansions.append(degen_chars[char]) metadata = None if self.has_metadata(): metadata = self.metadata positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata for definite_seq in product(*expansions): yield self._constructor( sequence=''.join(definite_seq), metadata=metadata, positional_metadata=positional_metadata, interval_metadata=self.interval_metadata) @stable(as_of='0.4.1') def to_regex(self, within_capture=False): """Return regular expression object that accounts for degenerate chars. Parameters ---------- within_capture : bool If ``True``, format the regex pattern for the sequence into a single capture group. If ``False``, compile the regex pattern as-is with no capture groups. Returns ------- regex Pre-compiled regular expression object (as from ``re.compile``) that matches all definite versions of this sequence, and nothing else. Examples -------- >>> from skbio import DNA >>> seq = DNA('TRG') >>> regex = seq.to_regex() >>> regex.match('TAG').string 'TAG' >>> regex.match('TGG').string 'TGG' >>> regex.match('TCG') is None True >>> regex = seq.to_regex(within_capture=True) >>> regex.match('TAG').groups(0) ('TAG',) """ regex_parts = [] for base in str(self): if base in self.degenerate_chars: regex_parts.append('[{0}]'.format( ''.join(self.degenerate_map[base]))) else: regex_parts.append(base) regex_string = ''.join(regex_parts) if within_capture: regex_string = '({})'.format(regex_string) return re.compile(regex_string) @stable(as_of='0.4.0') def find_motifs(self, motif_type, min_length=1, ignore=None): """Search the biological sequence for motifs. Options for `motif_type`: Parameters ---------- motif_type : str Type of motif to find. min_length : int, optional Only motifs at least as long as `min_length` will be returned. ignore : 1D array_like (bool), optional Boolean vector indicating positions to ignore when matching. Yields ------ slice Location of the motif in the biological sequence. Raises ------ ValueError If an unknown `motif_type` is specified. Examples -------- >>> from skbio import DNA >>> s = DNA('ACGGGGAGGCGGAG') >>> for motif_slice in s.find_motifs('purine-run', min_length=2): ... motif_slice ... str(s[motif_slice]) slice(2, 9, None) 'GGGGAGG' slice(10, 14, None) 'GGAG' Gap characters can disrupt motifs: >>> s = DNA('GG-GG') >>> for motif_slice in s.find_motifs('purine-run'): ... motif_slice slice(0, 2, None) slice(3, 5, None) Gaps can be ignored by passing the gap boolean vector to `ignore`: >>> s = DNA('GG-GG') >>> for motif_slice in s.find_motifs('purine-run', ignore=s.gaps()): ... motif_slice slice(0, 5, None) """ if motif_type not in self._motifs: raise ValueError("Not a known motif (%r) for this sequence (%s)." % (motif_type, self.__class__.__name__)) return self._motifs[motif_type](self, min_length, ignore) @overrides(Sequence) def _constructor(self, **kwargs): return self.__class__(validate=False, lowercase=False, **kwargs) @overrides(Sequence) def _repr_stats(self): """Define custom statistics to display in the sequence's repr.""" stats = super(GrammaredSequence, self)._repr_stats() stats.append(('has gaps', '%r' % self.has_gaps())) stats.append(('has degenerates', '%r' % self.has_degenerates())) stats.append(('has definites', '%r' % self.has_definites())) return stats _motifs = MiniRegistry() # Leave this at the bottom _motifs.interpolate(GrammaredSequence, "find_motifs") scikit-bio-0.5.9/skbio/sequence/_nucleotide_mixin.py000066400000000000000000000257531446255456000226000ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from abc import ABCMeta, abstractproperty import numpy as np from skbio.util._decorator import classproperty, stable from ._grammared_sequence import _motifs as parent_motifs class NucleotideMixin(metaclass=ABCMeta): """Mixin for adding funtionality for working with sequences of nucleotides. This is an abstract base class (ABC) that cannot be instantiated. See Also -------- DNA RNA """ __complement_lookup = None __gc_codes = None @classproperty def _complement_lookup(cls): if cls.__complement_lookup is not None: return cls.__complement_lookup lookup = np.zeros(cls._number_of_extended_ascii_codes, dtype=np.uint8) for key, value in cls.complement_map.items(): lookup[ord(key)] = ord(value) cls.__complement_lookup = lookup return lookup @classproperty def _gc_codes(cls): if cls.__gc_codes is None: gc_iupac_chars = 'GCS' cls.__gc_codes = np.asarray([ord(g) for g in gc_iupac_chars]) return cls.__gc_codes @property def _motifs(self): return _motifs @abstractproperty @classproperty @stable(as_of='0.4.0') def complement_map(cls): """Return mapping of nucleotide characters to their complements. Returns ------- dict Mapping of each character to its complement. Notes ----- Complements cannot be defined for a generic nucleotide sequence because the complement of ``A`` is ambiguous. Thanks, nature... """ raise NotImplementedError @stable(as_of='0.4.0') def complement(self, reverse=False): """Return the complement of the nucleotide sequence. Parameters ---------- reverse : bool, optional If ``True``, return the reverse complement. If positional and/or interval metadata are present, they will be reversed. Returns ------- NucleotideMixin The (reverse) complement of the nucleotide sequence. The type and metadata of the result will be the same as the nucleotide sequence. If `reverse` is ``True``, positional or interval metadata will be reversed if it is present. See Also -------- reverse_complement complement_map Examples -------- >>> from skbio import DNA >>> seq = DNA('TTCATT', positional_metadata={'quality':range(6)}) >>> seq DNA ----------------------------- Positional metadata: 'quality': Stats: length: 6 has gaps: False has degenerates: False has definites: True GC-content: 16.67% ----------------------------- 0 TTCATT >>> seq.complement() DNA ----------------------------- Positional metadata: 'quality': Stats: length: 6 has gaps: False has degenerates: False has definites: True GC-content: 16.67% ----------------------------- 0 AAGTAA >>> rc = seq.complement(reverse=True) >>> rc DNA ----------------------------- Positional metadata: 'quality': Stats: length: 6 has gaps: False has degenerates: False has definites: True GC-content: 16.67% ----------------------------- 0 AATGAA >>> rc.positional_metadata['quality'].values array([5, 4, 3, 2, 1, 0]) """ result = self._complement_lookup[self._bytes] metadata = None if self.has_metadata(): metadata = self.metadata positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata complement = self._constructor( sequence=result, metadata=metadata, positional_metadata=positional_metadata) if reverse: # this has to be before the interval metadata code, # because __gititem__ drops interval_metadata. complement = complement[::-1] if self.has_interval_metadata(): complement.interval_metadata = self.interval_metadata if reverse: # TODO: this can be revised to match # positional_metadata when __getitem__ # supports interval_metadata complement.interval_metadata._reverse() return complement @stable(as_of='0.4.0') def reverse_complement(self): """Return the reverse complement of the nucleotide sequence. Returns ------- NucleotideMixin The reverse complement of the nucleotide sequence. The type and metadata of the result will be the same as the nucleotide sequence. If positional metadata is present, it will be reversed. See Also -------- complement is_reverse_complement Notes ----- This method is equivalent to ``self.complement(reverse=True)``. Examples -------- >>> from skbio import DNA >>> seq = DNA('TTCATT', ... positional_metadata={'quality':range(6)}) >>> seq = seq.reverse_complement() >>> seq DNA ----------------------------- Positional metadata: 'quality': Stats: length: 6 has gaps: False has degenerates: False has definites: True GC-content: 16.67% ----------------------------- 0 AATGAA >>> seq.positional_metadata['quality'].values array([5, 4, 3, 2, 1, 0]) """ return self.complement(reverse=True) @stable(as_of='0.4.0') def is_reverse_complement(self, other): r"""Determine if a sequence is the reverse complement of this sequence. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compare to. Returns ------- bool ``True`` if `other` is the reverse complement of the nucleotide sequence. Raises ------ TypeError If `other` is a ``Sequence`` object with a different type than the nucleotide sequence. See Also -------- reverse_complement Examples -------- >>> from skbio import DNA >>> DNA('TTCATT').is_reverse_complement('AATGAA') True >>> DNA('TTCATT').is_reverse_complement('AATGTT') False >>> DNA('ACGT').is_reverse_complement('ACGT') True """ other = self._munge_to_sequence(other, 'is_reverse_complement') # avoid computing the reverse complement if possible if len(self) != len(other): return False else: # we reverse complement ourselves because `other` is a `Sequence` # object at this point and we only care about comparing the # underlying sequence data return self.reverse_complement()._string == other._string @stable(as_of='0.4.0') def gc_content(self): """Calculate the relative frequency of G's and C's in the sequence. This includes G, C, and S characters. This is equivalent to calling ``gc_frequency(relative=True)``. Note that the sequence will be degapped before the operation, so gap characters will not be included when calculating the length of the sequence. Returns ------- float Relative frequency of G's and C's in the sequence. See Also -------- gc_frequency Examples -------- >>> from skbio import DNA >>> DNA('ACGT').gc_content() 0.5 >>> DNA('ACGTACGT').gc_content() 0.5 >>> DNA('ACTTAGTT').gc_content() 0.25 >>> DNA('ACGT--..').gc_content() 0.5 >>> DNA('--..').gc_content() 0 `S` means `G` or `C`, so it counts: >>> DNA('ASST').gc_content() 0.5 Other degenerates don't count: >>> DNA('RYKMBDHVN').gc_content() 0.0 """ return self.gc_frequency(relative=True) @stable(as_of='0.4.0') def gc_frequency(self, relative=False): """Calculate frequency of G's and C's in the sequence. This calculates the minimum GC frequency, which corresponds to IUPAC characters G, C, and S (which stands for G or C). Parameters ---------- relative : bool, optional If False return the frequency of G, C, and S characters (ie the count). If True return the relative frequency, ie the proportion of G, C, and S characters in the sequence. In this case the sequence will also be degapped before the operation, so gap characters will not be included when calculating the length of the sequence. Returns ------- int or float Either frequency (count) or relative frequency (proportion), depending on `relative`. See Also -------- gc_content Examples -------- >>> from skbio import DNA >>> DNA('ACGT').gc_frequency() 2 >>> DNA('ACGT').gc_frequency(relative=True) 0.5 >>> DNA('ACGT--..').gc_frequency(relative=True) 0.5 >>> DNA('--..').gc_frequency(relative=True) 0 `S` means `G` or `C`, so it counts: >>> DNA('ASST').gc_frequency() 2 Other degenerates don't count: >>> DNA('RYKMBDHVN').gc_frequency() 0 """ counts = np.bincount(self._bytes, minlength=self._number_of_extended_ascii_codes) gc = counts[self._gc_codes].sum() if relative: seq = self.degap() if len(seq) != 0: gc /= len(seq) return gc _motifs = parent_motifs.copy() @_motifs("purine-run") def _motif_purine_run(sequence, min_length, ignore): """Identifies purine runs""" return sequence.find_with_regex("([AGR]{%d,})" % min_length, ignore=ignore) @_motifs("pyrimidine-run") def _motif_pyrimidine_run(sequence, min_length, ignore): """Identifies pyrimidine runs""" return sequence.find_with_regex("([CTUY]{%d,})" % min_length, ignore=ignore) scikit-bio-0.5.9/skbio/sequence/_protein.py000066400000000000000000000155301446255456000207110ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.util._decorator import classproperty, overrides from skbio.util._decorator import stable from ._grammared_sequence import (GrammaredSequence, DisableSubclassingMeta, _motifs as parent_motifs) class Protein(GrammaredSequence, metaclass=DisableSubclassingMeta): r"""Store protein sequence data and optional associated metadata. Only characters in the IUPAC protein character set [1]_ are supported. Parameters ---------- sequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Characters representing the protein sequence itself. metadata : dict, optional Arbitrary metadata which applies to the entire sequence. positional_metadata : Pandas DataFrame consumable, optional Arbitrary per-character metadata. For example, quality data from sequencing reads. Must be able to be passed directly to the Pandas DataFrame constructor. interval_metadata : IntervalMetadata Arbitrary interval metadata which applies to intervals within a sequence to store interval features (such as protein domains). lowercase : bool or str, optional If ``True``, lowercase sequence characters will be converted to uppercase characters in order to be valid IUPAC Protein characters. If ``False``, no characters will be converted. If a str, it will be treated as a key into the positional metadata of the object. All lowercase characters will be converted to uppercase, and a ``True`` value will be stored in a boolean array in the positional metadata under the key. validate : bool, optional If ``True``, validation will be performed to ensure that all sequence characters are in the IUPAC protein character set. If ``False``, validation will not be performed. Turning off validation will improve runtime performance. If invalid characters are present, however, there is **no guarantee that operations performed on the resulting object will work or behave as expected.** Only turn off validation if you are certain that the sequence characters are valid. To store sequence data that is not IUPAC-compliant, use ``Sequence``. See Also -------- GrammaredSequence Notes ----- Subclassing is disabled for Protein, because subclassing makes it possible to change the alphabet, and certain methods rely on the IUPAC alphabet. If a custom sequence alphabet is needed, inherit directly from ``GrammaredSequence``. References ---------- .. [1] Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden Examples -------- >>> from skbio import Protein >>> Protein('PAW') Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 PAW Convert lowercase characters to uppercase: >>> Protein('paW', lowercase=True) Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 PAW """ __stop_codes = None @classproperty def _stop_codes(cls): if cls.__stop_codes is None: stops = cls.stop_chars cls.__stop_codes = np.asarray([ord(s) for s in stops]) return cls.__stop_codes @classproperty @overrides(GrammaredSequence) def alphabet(cls): return super(Protein, cls).alphabet | cls.stop_chars @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set("ACDEFGHIKLMNOPQRSTUVWY") @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return { "B": set("DN"), "Z": set("EQ"), "J": set("IL"), "X": set("ACDEFGHIKLMNOPQRSTUVWY") } @classproperty @stable(as_of="0.4.0") def stop_chars(cls): """Return characters representing translation stop codons. Returns ------- set Characters representing translation stop codons. """ return set('*') @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @property def _motifs(self): return _motifs @stable(as_of="0.4.0") def stops(self): """Find positions containing stop characters in the protein sequence. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` indicates a stop character is present at that position in the protein sequence. See Also -------- has_stops Examples -------- >>> from skbio import Protein >>> s = Protein('PAW') >>> s.stops() array([False, False, False], dtype=bool) >>> s = Protein('PAW*E*') >>> s.stops() array([False, False, False, True, False, True], dtype=bool) """ return np.in1d(self._bytes, self._stop_codes) @stable(as_of="0.4.0") def has_stops(self): """Determine if the sequence contains one or more stop characters. Returns ------- bool Indicates whether there are one or more occurrences of stop characters in the protein sequence. Examples -------- >>> from skbio import Protein >>> s = Protein('PAW') >>> s.has_stops() False >>> s = Protein('PAW*E*') >>> s.has_stops() True """ return bool(self.stops().any()) @overrides(GrammaredSequence) def _repr_stats(self): """Define custom statistics to display in the sequence's repr.""" stats = super(Protein, self)._repr_stats() stats.append(('has stops', '%r' % self.has_stops())) return stats _motifs = parent_motifs.copy() @_motifs("N-glycosylation") def _motif_nitro_glycosylation(sequence, min_length, ignore): """Identifies N-glycosylation runs""" return sequence.find_with_regex("(N[^PX][ST][^PX])", ignore=ignore) # Leave this at the bottom _motifs.interpolate(Protein, "find_motifs") scikit-bio-0.5.9/skbio/sequence/_repr.py000066400000000000000000000101411446255456000201720ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import math from skbio.util._misc import chunk_str from skbio.metadata._repr import _MetadataReprBuilder class _SequenceReprBuilder(_MetadataReprBuilder): """Build a ``Sequence`` repr. Parameters ---------- seq : Sequence Sequence to repr. width : int Maximum width of the repr. indent : int Number of spaces to use for indented lines. chunk_size: int Number of characters in each chunk of a sequence. """ def __init__(self, seq, width, indent, chunk_size): super(_SequenceReprBuilder, self).__init__(seq, width, indent) self._chunk_size = chunk_size def _process_header(self): cls_name = self._obj.__class__.__name__ self._lines.add_line(cls_name) self._lines.add_separator() def _process_data(self): num_lines, num_chars, column_width = self._find_optimal_seq_chunking() # display entire sequence if we can, else display the first two and # last two lines separated by ellipsis if num_lines <= 5: self._lines.add_lines(self._format_chunked_seq( range(num_lines), num_chars, column_width)) else: self._lines.add_lines(self._format_chunked_seq( range(2), num_chars, column_width)) self._lines.add_line('...') self._lines.add_lines(self._format_chunked_seq( range(num_lines - 2, num_lines), num_chars, column_width)) def _find_optimal_seq_chunking(self): """Find the optimal number of sequence chunks to fit on a single line. Returns the number of lines the sequence will occupy, the number of sequence characters displayed on each line, and the column width necessary to display position info using the optimal number of sequence chunks. """ # strategy: use an iterative approach to find the optimal number of # sequence chunks per line. start with a single chunk and increase # until the max line width is exceeded. when this happens, the previous # number of chunks is optimal num_lines = 0 num_chars = 0 column_width = 0 num_chunks = 1 not_exceeded = True while not_exceeded: line_len, new_chunk_info = self._compute_chunked_seq_line_len( num_chunks) not_exceeded = line_len <= self._width if not_exceeded: num_lines, num_chars, column_width = new_chunk_info num_chunks += 1 return num_lines, num_chars, column_width def _compute_chunked_seq_line_len(self, num_chunks): """Compute line length based on a number of chunks.""" num_chars = num_chunks * self._chunk_size # ceil to account for partial line num_lines = int(math.ceil(len(self._obj) / num_chars)) # position column width is fixed width, based on the number of # characters necessary to display the position of the final line (all # previous positions will be left justified using this width) column_width = len('%d ' % ((num_lines - 1) * num_chars)) # column width + number of sequence characters + spaces between chunks line_len = column_width + num_chars + (num_chunks - 1) return line_len, (num_lines, num_chars, column_width) def _format_chunked_seq(self, line_idxs, num_chars, column_width): """Format specified lines of chunked sequence data.""" lines = [] for line_idx in line_idxs: seq_idx = line_idx * num_chars chars = str(self._obj[seq_idx:seq_idx+num_chars]) chunked_chars = chunk_str(chars, self._chunk_size, ' ') lines.append(('%d' % seq_idx).ljust(column_width) + chunked_chars) return lines scikit-bio-0.5.9/skbio/sequence/_rna.py000066400000000000000000000316571446255456000200210ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import skbio from skbio.util._decorator import classproperty, overrides from skbio.util._decorator import stable from ._nucleotide_mixin import NucleotideMixin, _motifs as _parent_motifs from ._grammared_sequence import GrammaredSequence, DisableSubclassingMeta class RNA(GrammaredSequence, NucleotideMixin, metaclass=DisableSubclassingMeta): r"""Store RNA sequence data and optional associated metadata. Only characters in the IUPAC RNA character set [1]_ are supported. Parameters ---------- sequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Characters representing the RNA sequence itself. metadata : dict, optional Arbitrary metadata which applies to the entire sequence. positional_metadata : Pandas DataFrame consumable, optional Arbitrary per-character metadata. For example, quality data from sequencing reads. Must be able to be passed directly to the Pandas DataFrame constructor. interval_metadata : IntervalMetadata Arbitrary metadata which applies to intervals within a sequence to store interval features (such as exons or introns on the sequence). lowercase : bool or str, optional If ``True``, lowercase sequence characters will be converted to uppercase characters in order to be valid IUPAC RNA characters. If ``False``, no characters will be converted. If a str, it will be treated as a key into the positional metadata of the object. All lowercase characters will be converted to uppercase, and a ``True`` value will be stored in a boolean array in the positional metadata under the key. validate : bool, optional If ``True``, validation will be performed to ensure that all sequence characters are in the IUPAC RNA character set. If ``False``, validation will not be performed. Turning off validation will improve runtime performance. If invalid characters are present, however, there is **no guarantee that operations performed on the resulting object will work or behave as expected.** Only turn off validation if you are certain that the sequence characters are valid. To store sequence data that is not IUPAC-compliant, use ``Sequence``. See Also -------- DNA GrammaredSequence Notes ----- Subclassing is disabled for RNA, because subclassing makes it possible to change the alphabet, and certain methods rely on the IUPAC alphabet. If a custom sequence alphabet is needed, inherit directly from ``GrammaredSequence``. References ---------- .. [1] Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden Examples -------- >>> from skbio import RNA >>> RNA('ACCGAAU') RNA -------------------------- Stats: length: 7 has gaps: False has degenerates: False has definites: True GC-content: 42.86% -------------------------- 0 ACCGAAU Convert lowercase characters to uppercase: >>> RNA('AcCGaaU', lowercase=True) RNA -------------------------- Stats: length: 7 has gaps: False has degenerates: False has definites: True GC-content: 42.86% -------------------------- 0 ACCGAAU """ @classproperty @overrides(NucleotideMixin) def complement_map(cls): comp_map = { 'A': 'U', 'U': 'A', 'G': 'C', 'C': 'G', 'Y': 'R', 'R': 'Y', 'S': 'S', 'W': 'W', 'K': 'M', 'M': 'K', 'B': 'V', 'D': 'H', 'H': 'D', 'V': 'B', 'N': 'N' } comp_map.update({c: c for c in cls.gap_chars}) return comp_map @classproperty @overrides(GrammaredSequence) def definite_chars(cls): return set("ACGU") @classproperty @overrides(GrammaredSequence) def degenerate_map(cls): return { "R": set("AG"), "Y": set("CU"), "M": set("AC"), "K": set("UG"), "W": set("AU"), "S": set("GC"), "B": set("CGU"), "D": set("AGU"), "H": set("ACU"), "V": set("ACG"), "N": set("ACGU") } @classproperty @overrides(GrammaredSequence) def default_gap_char(cls): return '-' @classproperty @overrides(GrammaredSequence) def gap_chars(cls): return set('-.') @property def _motifs(self): return _motifs @stable(as_of="0.4.1") def reverse_transcribe(self): """Reverse transcribe RNA into DNA. It returns the coding DNA strand of the RNA sequence, i.e. uracil (U) is replaced with thymine (T) in the reverse transcribed sequence. Returns ------- DNA Reverse transcribed sequence. See Also -------- DNA.transcribe translate translate_six_frames Notes ----- RNA sequence's metadata and positional metadata are included in the transcribed DNA sequence. Examples -------- Reverse transcribe RNA into DNA: >>> from skbio import RNA >>> rna = RNA('UAACGUUA') >>> rna RNA -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 25.00% -------------------------- 0 UAACGUUA >>> rna.reverse_transcribe() DNA -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 25.00% -------------------------- 0 TAACGTTA """ seq = self._string.replace(b'U', b'T') metadata = None if self.has_metadata(): metadata = self.metadata positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata interval_metadata = None if self.has_interval_metadata(): interval_metadata = self.interval_metadata # turn off validation because `seq` is guaranteed to be valid return skbio.DNA(seq, metadata=metadata, positional_metadata=positional_metadata, interval_metadata=interval_metadata, validate=False) @stable(as_of="0.4.0") def translate(self, genetic_code=1, *args, **kwargs): """Translate RNA sequence into protein sequence. Parameters ---------- genetic_code : int, GeneticCode, optional Genetic code to use in translation. If ``int``, used as a table ID to look up the corresponding NCBI genetic code. args : tuple Positional arguments accepted by ``GeneticCode.translate``. kwargs : dict Keyword arguments accepted by ``GeneticCode.translate``. Returns ------- Protein Translated sequence. See Also -------- GeneticCode.translate GeneticCode.from_ncbi translate_six_frames Notes ----- RNA sequence's metadata are included in the translated protein sequence. Positional metadata are not included. Examples -------- Translate RNA into protein using NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import RNA >>> rna = RNA('AUGCCACUUUAA') >>> rna.translate() Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* Translate the same RNA sequence using a different NCBI genetic code (table ID 3, the yeast mitochondrial code) and specify that translation must terminate at the first stop codon: >>> rna.translate(3, stop='require') Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 MPT """ if not isinstance(genetic_code, skbio.GeneticCode): genetic_code = skbio.GeneticCode.from_ncbi(genetic_code) return genetic_code.translate(self, *args, **kwargs) @stable(as_of="0.4.0") def translate_six_frames(self, genetic_code=1, *args, **kwargs): """Translate RNA into protein using six possible reading frames. The six possible reading frames are: * 1 (forward) * 2 (forward) * 3 (forward) * -1 (reverse) * -2 (reverse) * -3 (reverse) Translated sequences are yielded in this order. Parameters ---------- genetic_code : int, GeneticCode, optional Genetic code to use in translation. If ``int``, used as a table ID to look up the corresponding NCBI genetic code. args : tuple Positional arguments accepted by ``GeneticCode.translate_six_frames``. kwargs : dict Keyword arguments accepted by ``GeneticCode.translate_six_frames``. Yields ------ Protein Translated sequence in the current reading frame. See Also -------- GeneticCode.translate_six_frames GeneticCode.from_ncbi translate Notes ----- This method is faster than (and equivalent to) performing six independent translations using, for example: ``(seq.translate(reading_frame=rf) for rf in GeneticCode.reading_frames)`` RNA sequence's metadata are included in each translated protein sequence. Positional metadata are not included. Examples -------- Translate RNA into protein using the six possible reading frames and NCBI's standard genetic code (table ID 1, the default genetic code in scikit-bio): >>> from skbio import RNA >>> rna = RNA('AUGCCACUUUAA') >>> for protein in rna.translate_six_frames(): ... protein ... print('') Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 MPL* Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 CHF Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 ATL Protein -------------------------- Stats: length: 4 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 LKWH Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: True -------------------------- 0 *SG Protein -------------------------- Stats: length: 3 has gaps: False has degenerates: False has definites: True has stops: False -------------------------- 0 KVA """ if not isinstance(genetic_code, skbio.GeneticCode): genetic_code = skbio.GeneticCode.from_ncbi(genetic_code) return genetic_code.translate_six_frames(self, *args, **kwargs) @overrides(GrammaredSequence) def _repr_stats(self): """Define custom statistics to display in the sequence's repr.""" stats = super(RNA, self)._repr_stats() stats.append(('GC-content', '{:.2%}'.format(self.gc_content()))) return stats _motifs = _parent_motifs.copy() # Leave this at the bottom _motifs.interpolate(RNA, "find_motifs") scikit-bio-0.5.9/skbio/sequence/_sequence.py000066400000000000000000002175331446255456000210500ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import re import collections import numbers from contextlib import contextmanager import numpy as np import pandas as pd import skbio.sequence.distance from skbio._base import SkbioObject from skbio.metadata._mixin import (MetadataMixin, PositionalMetadataMixin, IntervalMetadataMixin) from skbio.metadata import IntervalMetadata from skbio.sequence._repr import _SequenceReprBuilder from skbio.util._decorator import (stable, experimental, classonlymethod, overrides) class Sequence(MetadataMixin, PositionalMetadataMixin, IntervalMetadataMixin, collections.abc.Sequence, SkbioObject): """Store generic sequence data and optional associated metadata. ``Sequence`` objects do not enforce an alphabet or grammar and are thus the most generic objects for storing sequence data. ``Sequence`` objects do not necessarily represent biological sequences. For example, ``Sequence`` can be used to represent a position in a multiple sequence alignment. Subclasses ``DNA``, ``RNA``, and ``Protein`` enforce the IUPAC character set [1]_ for, and provide operations specific to, each respective molecule type. ``Sequence`` objects consist of the underlying sequence data, as well as optional metadata and positional metadata. The underlying sequence is immutable, while the metdata and positional metadata are mutable. Parameters ---------- sequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\\|S1') Characters representing the sequence itself. metadata : dict, optional Arbitrary metadata which applies to the entire sequence. A shallow copy of the ``dict`` will be made (see Examples section below for details). positional_metadata : pd.DataFrame consumable, optional Arbitrary per-character metadata (e.g., sequence read quality scores). Must be able to be passed directly to ``pd.DataFrame`` constructor. Each column of metadata must be the same length as `sequence`. A shallow copy of the positional metadata will be made if necessary (see Examples section below for details). interval_metadata : IntervalMetadata Arbitrary metadata which applies to intervals within a sequence to store interval features (such as genes, ncRNA on the sequence). lowercase : bool or str, optional If ``True``, lowercase sequence characters will be converted to uppercase characters. If ``False``, no characters will be converted. If a str, it will be treated as a key into the positional metadata of the object. All lowercase characters will be converted to uppercase, and a ``True`` value will be stored in a boolean array in the positional metadata under the key. See Also -------- DNA RNA Protein References ---------- .. [1] Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden Examples -------- >>> from pprint import pprint >>> from skbio import Sequence >>> from skbio.metadata import IntervalMetadata **Creating sequences:** Create a sequence without any metadata: >>> seq = Sequence('GGUCGUGAAGGA') >>> seq Sequence --------------- Stats: length: 12 --------------- 0 GGUCGUGAAG GA Create a sequence with metadata and positional metadata: >>> metadata = {'authors': ['Alice'], 'desc':'seq desc', 'id':'seq-id'} >>> positional_metadata = {'exons': [True, True, False, True], ... 'quality': [3, 3, 4, 10]} >>> interval_metadata = IntervalMetadata(4) >>> interval = interval_metadata.add([(1, 3)], metadata={'gene': 'sagA'}) >>> seq = Sequence('ACGT', metadata=metadata, ... positional_metadata=positional_metadata, ... interval_metadata=interval_metadata) >>> seq Sequence ----------------------------- Metadata: 'authors': 'desc': 'seq desc' 'id': 'seq-id' Positional metadata: 'exons': 'quality': Interval metadata: 1 interval feature Stats: length: 4 ----------------------------- 0 ACGT **Retrieving underlying sequence data:** Retrieve underlying sequence: >>> seq.values # doctest: +NORMALIZE_WHITESPACE array([b'A', b'C', b'G', b'T'], dtype='|S1') Underlying sequence immutable: >>> values = np.array([b'T', b'C', b'G', b'A'], dtype='|S1') >>> seq.values = values # doctest: +SKIP Traceback (most recent call last): ... AttributeError: can't set attribute >>> seq.values[0] = b'T' Traceback (most recent call last): ... ValueError: assignment destination is read-only **Retrieving sequence metadata:** Retrieve metadata: >>> pprint(seq.metadata) # using pprint to display dict in sorted order {'authors': ['Alice'], 'desc': 'seq desc', 'id': 'seq-id'} Retrieve positional metadata: >>> seq.positional_metadata exons quality 0 True 3 1 True 3 2 False 4 3 True 10 Retrieve interval metadata: >>> seq.interval_metadata # doctest: +ELLIPSIS 1 interval feature ------------------ Interval(interval_metadata=<...>, bounds=[(1, 3)], \ fuzzy=[(False, False)], metadata={'gene': 'sagA'}) **Updating sequence metadata:** .. warning:: Be aware that a shallow copy of ``metadata`` and ``positional_metadata`` is made for performance. Since a deep copy is not made, changes made to mutable Python objects stored as metadata may affect the metadata of other ``Sequence`` objects or anything else that shares a reference to the object. The following examples illustrate this behavior. First, let's create a sequence and update its metadata: >>> metadata = {'id':'seq-id', 'desc':'seq desc', 'authors': ['Alice']} >>> seq = Sequence('ACGT', metadata=metadata) >>> seq.metadata['id'] = 'new-id' >>> seq.metadata['pubmed'] = 12345 >>> pprint(seq.metadata) {'authors': ['Alice'], 'desc': 'seq desc', 'id': 'new-id', 'pubmed': 12345} Note that the original metadata dictionary (stored in variable ``metadata``) hasn't changed because a shallow copy was made: >>> pprint(metadata) {'authors': ['Alice'], 'desc': 'seq desc', 'id': 'seq-id'} >>> seq.metadata == metadata False Note however that since only a *shallow* copy was made, updates to mutable objects will also change the original metadata dictionary: >>> seq.metadata['authors'].append('Bob') >>> seq.metadata['authors'] ['Alice', 'Bob'] >>> metadata['authors'] ['Alice', 'Bob'] This behavior can also occur when manipulating a sequence that has been derived from another sequence: >>> subseq = seq[1:3] >>> subseq Sequence ----------------------------- Metadata: 'authors': 'desc': 'seq desc' 'id': 'new-id' 'pubmed': 12345 Stats: length: 2 ----------------------------- 0 CG >>> pprint(subseq.metadata) {'authors': ['Alice', 'Bob'], 'desc': 'seq desc', 'id': 'new-id', 'pubmed': 12345} The subsequence has inherited the metadata of its parent sequence. If we update the subsequence's author list, we see the changes propagated in the parent sequence and original metadata dictionary: >>> subseq.metadata['authors'].append('Carol') >>> subseq.metadata['authors'] ['Alice', 'Bob', 'Carol'] >>> seq.metadata['authors'] ['Alice', 'Bob', 'Carol'] >>> metadata['authors'] ['Alice', 'Bob', 'Carol'] The behavior for updating positional metadata is similar. Let's create a new sequence with positional metadata that is already stored in a ``pd.DataFrame``: >>> positional_metadata = pd.DataFrame( ... {'list': [[], [], [], []], 'quality': [3, 3, 4, 10]}) >>> seq = Sequence('ACGT', positional_metadata=positional_metadata) >>> seq Sequence ----------------------------- Positional metadata: 'list': 'quality': Stats: length: 4 ----------------------------- 0 ACGT >>> seq.positional_metadata list quality 0 [] 3 1 [] 3 2 [] 4 3 [] 10 Now let's update the sequence's positional metadata by adding a new column and changing a value in another column: >>> seq.positional_metadata['gaps'] = [False, False, False, False] >>> seq.positional_metadata.loc[0, 'quality'] = 999 >>> seq.positional_metadata list quality gaps 0 [] 999 False 1 [] 3 False 2 [] 4 False 3 [] 10 False Note that the original positional metadata (stored in variable ``positional_metadata``) hasn't changed because a shallow copy was made: >>> positional_metadata list quality 0 [] 3 1 [] 3 2 [] 4 3 [] 10 >>> seq.positional_metadata.equals(positional_metadata) False Next let's create a sequence that has been derived from another sequence: >>> subseq = seq[1:3] >>> subseq Sequence ----------------------------- Positional metadata: 'list': 'quality': 'gaps': Stats: length: 2 ----------------------------- 0 CG >>> subseq.positional_metadata list quality gaps 0 [] 3 False 1 [] 4 False As described above for metadata, since only a *shallow* copy was made of the positional metadata, updates to mutable objects will also change the parent sequence's positional metadata and the original positional metadata ``pd.DataFrame``: >>> subseq.positional_metadata.loc[0, 'list'].append('item') >>> subseq.positional_metadata list quality gaps 0 [item] 3 False 1 [] 4 False >>> seq.positional_metadata list quality gaps 0 [] 999 False 1 [item] 3 False 2 [] 4 False 3 [] 10 False >>> positional_metadata list quality 0 [] 3 1 [item] 3 2 [] 4 3 [] 10 You can also update the interval metadata. Let's re-create a ``Sequence`` object with interval metadata at first: >>> seq = Sequence('ACGT') >>> interval = seq.interval_metadata.add( ... [(1, 3)], metadata={'gene': 'foo'}) You can update directly on the ``Interval`` object: >>> interval # doctest: +ELLIPSIS Interval(interval_metadata=<...>, bounds=[(1, 3)], \ fuzzy=[(False, False)], metadata={'gene': 'foo'}) >>> interval.bounds = [(0, 2)] >>> interval # doctest: +ELLIPSIS Interval(interval_metadata=<...>, bounds=[(0, 2)], \ fuzzy=[(False, False)], metadata={'gene': 'foo'}) You can also query and obtain the interval features you are interested and then modify them: >>> intervals = list(seq.interval_metadata.query(metadata={'gene': 'foo'})) >>> intervals[0].fuzzy = [(True, False)] >>> print(intervals[0]) # doctest: +ELLIPSIS Interval(interval_metadata=<...>, bounds=[(0, 2)], \ fuzzy=[(True, False)], metadata={'gene': 'foo'}) """ _number_of_extended_ascii_codes = 256 # ASCII is built such that the difference between uppercase and lowercase # is the 6th bit. _ascii_invert_case_bit_offset = 32 _ascii_lowercase_boundary = 90 default_write_format = 'fasta' __hash__ = None @property @stable(as_of="0.4.0") def values(self): r"""Array containing underlying sequence characters. Notes ----- This property is not writeable. Examples -------- >>> from skbio import Sequence >>> s = Sequence('AACGA') >>> s.values # doctest: +NORMALIZE_WHITESPACE array([b'A', b'A', b'C', b'G', b'A'], dtype='|S1') """ return self._bytes.view('|S1') @property def __array_interface__(self): r"""Array interface for compatibility with numpy. This property allows a ``Sequence`` object to share its underlying data buffer (``Sequence.values``) with numpy. See [1]_ for more details. References ---------- .. [1] http://docs.scipy.org/doc/numpy/reference/arrays.interface.html Examples -------- >>> import numpy as np >>> from skbio import Sequence >>> seq = Sequence('ABC123') >>> np.asarray(seq) # doctest: +NORMALIZE_WHITESPACE array([b'A', b'B', b'C', b'1', b'2', b'3'], dtype='|S1') """ return self.values.__array_interface__ @property @experimental(as_of="0.4.1") def observed_chars(self): r"""Set of observed characters in the sequence. Notes ----- This property is not writeable. Examples -------- >>> from skbio import Sequence >>> s = Sequence('AACGAC') >>> s.observed_chars == {'G', 'A', 'C'} True """ return set(str(self)) @property def _string(self): return self._bytes.tobytes() @classonlymethod @experimental(as_of="0.4.1") def concat(cls, sequences, how='strict'): r"""Concatenate an iterable of ``Sequence`` objects. Parameters ---------- sequences : iterable (Sequence) An iterable of ``Sequence`` objects or appropriate subclasses. how : {'strict', 'inner', 'outer'}, optional How to intersect the `positional_metadata` of the sequences. If 'strict': the `positional_metadata` must have the exact same columns; 'inner': an inner-join of the columns (only the shared set of columns are used); 'outer': an outer-join of the columns (all columns are used: missing values will be padded with NaN). Returns ------- Sequence The returned sequence will be an instance of the class which called this class-method. Raises ------ ValueError If `how` is not one of: 'strict', 'inner', or 'outer'. ValueError If `how` is 'strict' and the `positional_metadata` of each sequence does not have the same columns. TypeError If the sequences cannot be cast as the calling class. Notes ----- The sequence-wide metadata (``Sequence.metadata``) is not retained during concatenation. Sequence objects can be cast to a different type only when the new type is an ancestor or child of the original type. Casting between sibling types is not allowed, e.g. ``DNA`` -> ``RNA`` is not allowed, but ``DNA`` -> ``Sequence`` or ``Sequence`` -> ``DNA`` would be. Examples -------- Concatenate two DNA sequences into a new DNA object: >>> from skbio import DNA, Sequence >>> s1 = DNA("ACGT") >>> s2 = DNA("GGAA") >>> DNA.concat([s1, s2]) DNA -------------------------- Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 50.00% -------------------------- 0 ACGTGGAA Concatenate DNA sequences into a Sequence object (type coercion): >>> Sequence.concat([s1, s2]) Sequence ------------- Stats: length: 8 ------------- 0 ACGTGGAA Positional metadata is conserved: >>> s1 = DNA('AcgT', lowercase='one') >>> s2 = DNA('GGaA', lowercase='one', ... positional_metadata={'two': [1, 2, 3, 4]}) >>> result = DNA.concat([s1, s2], how='outer') >>> result DNA --------------------------- Positional metadata: 'one': 'two': Stats: length: 8 has gaps: False has degenerates: False has definites: True GC-content: 50.00% --------------------------- 0 ACGTGGAA >>> result.positional_metadata one two 0 False NaN 1 True NaN 2 True NaN 3 False NaN 4 False 1.0 5 False 2.0 6 True 3.0 7 False 4.0 """ if how not in {'strict', 'inner', 'outer'}: raise ValueError("`how` must be 'strict', 'inner', or 'outer'.") seqs = list(sequences) if len(seqs) == 0: return cls("") for seq in seqs: seq._assert_can_cast_to(cls) if how == 'strict': how = 'inner' cols = set() for s in seqs: if s.has_positional_metadata(): cols.add(frozenset(s.positional_metadata)) else: cols.add(frozenset()) if len(cols) > 1: raise ValueError("The positional metadata of the sequences do" " not have matching columns. Consider setting" " how='inner' or how='outer'") seq_data = [] pm_data = [] for seq in seqs: seq_data.append(seq._bytes) pm_data.append(seq.positional_metadata) if not seq.has_positional_metadata(): del seq.positional_metadata pm = pd.concat(pm_data, join=how, ignore_index=True, sort=True) bytes_ = np.concatenate(seq_data) im = IntervalMetadata.concat(i.interval_metadata for i in seqs) return cls(bytes_, positional_metadata=pm, interval_metadata=im) @classmethod def _assert_can_cast_to(cls, target): if not (issubclass(cls, target) or issubclass(target, cls)): raise TypeError("Cannot cast %r as %r." % (cls.__name__, target.__name__)) @overrides(PositionalMetadataMixin) def _positional_metadata_axis_len_(self): return len(self) @overrides(IntervalMetadataMixin) def _interval_metadata_axis_len_(self): return len(self) @stable(as_of="0.4.0") def __init__(self, sequence, metadata=None, positional_metadata=None, interval_metadata=None, lowercase=False): if isinstance(sequence, np.ndarray): if sequence.dtype == np.uint8: self._set_bytes_contiguous(sequence) elif sequence.dtype == '|S1': sequence = sequence.view(np.uint8) # Guarantee the sequence is an array (might be scalar before # this). if sequence.shape == (): sequence = np.array([sequence], dtype=np.uint8) self._set_bytes_contiguous(sequence) else: raise TypeError( "Can only create sequence from numpy.ndarray of dtype " "np.uint8 or '|S1'. Invalid dtype: %s" % sequence.dtype) elif isinstance(sequence, Sequence): # Sequence casting is acceptable between direct # decendants/ancestors sequence._assert_can_cast_to(type(self)) if metadata is None and sequence.has_metadata(): metadata = sequence.metadata if (positional_metadata is None and sequence.has_positional_metadata()): positional_metadata = sequence.positional_metadata if (interval_metadata is None and sequence.has_interval_metadata()): interval_metadata = sequence.interval_metadata sequence = sequence._bytes self._owns_bytes = False self._set_bytes(sequence) else: # Encode as ascii to raise UnicodeEncodeError if necessary. if isinstance(sequence, str): sequence = sequence.encode("ascii") s = np.frombuffer(sequence, dtype=np.uint8) # There are two possibilities (to our knowledge) at this point: # Either the sequence we were given was something string-like, # (else it would not have made it past frombuffer), or it was a # numpy scalar, and so our length must be 1. if isinstance(sequence, np.generic) and len(s) != 1: raise TypeError("Can cannot create a sequence with %r" % type(sequence).__name__) sequence = s self._owns_bytes = False self._set_bytes(sequence) MetadataMixin._init_(self, metadata=metadata) PositionalMetadataMixin._init_( self, positional_metadata=positional_metadata) IntervalMetadataMixin._init_( self, interval_metadata=interval_metadata) if lowercase is False: pass elif lowercase is True or isinstance(lowercase, str): lowercase_mask = self._bytes > self._ascii_lowercase_boundary self._convert_to_uppercase(lowercase_mask) # If it isn't True, it must be a string_type if not (lowercase is True): self.positional_metadata[lowercase] = lowercase_mask else: raise TypeError("lowercase keyword argument expected a bool or " "string, but got %s" % type(lowercase)) def _set_bytes_contiguous(self, sequence): r"""Munge the sequence data into a numpy array of dtype uint8.""" if not sequence.flags['C_CONTIGUOUS']: # numpy doesn't support views of non-contiguous arrays. Since we're # making heavy use of views internally, and users may also supply # us with a view, make sure we *always* store a contiguous array to # avoid hard-to-track bugs. See # https://github.com/numpy/numpy/issues/5716 sequence = np.ascontiguousarray(sequence) self._owns_bytes = True else: self._owns_bytes = False self._set_bytes(sequence) def _set_bytes(self, sequence): sequence.flags.writeable = False self._bytes = sequence def _convert_to_uppercase(self, lowercase): if np.any(lowercase): with self._byte_ownership(): self._bytes[lowercase] ^= self._ascii_invert_case_bit_offset @stable(as_of="0.4.0") def __contains__(self, subsequence): r"""Determine if a subsequence is contained in this sequence. Parameters ---------- subsequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') The putative subsequence. Returns ------- bool Indicates whether `subsequence` is contained in this sequence. Raises ------ TypeError If `subsequence` is a ``Sequence`` object with a different type than this sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUCGUGAAGGA') >>> 'GGU' in s True >>> 'CCC' in s False """ return self._munge_to_bytestring(subsequence, "in") in self._string @stable(as_of="0.4.0") def __eq__(self, other): r"""Determine if this sequence is equal to another. Sequences are equal if they are *exactly* the same type and their sequence characters, metadata, and positional metadata are the same. Parameters ---------- other : Sequence Sequence to test for equality against. Returns ------- bool Indicates whether this sequence is equal to `other`. Examples -------- Define two ``Sequence`` objects that have the same underlying sequence of characters: >>> from skbio import Sequence >>> s = Sequence('ACGT') >>> t = Sequence('ACGT') The two sequences are considered equal because they are the same type, their underlying sequence of characters are the same, and their optional metadata attributes (``metadata`` and ``positional_metadata``) were not provided: >>> s == t True >>> t == s True Define another sequence object with a different sequence of characters than the previous two sequence objects: >>> u = Sequence('ACGA') >>> u == t False Define a sequence with the same sequence of characters as ``u`` but with different metadata, positional metadata, and interval metadata: >>> v = Sequence('ACGA', metadata={'id': 'abc'}, ... positional_metadata={'quality':[1, 5, 3, 3]}) >>> _ = v.interval_metadata.add([(0, 1)]) The two sequences are not considered equal because their metadata, positional metadata, and interval metadata do not match: >>> u == v False """ # checks ordered from least to most expensive if self.__class__ != other.__class__: return False if not MetadataMixin._eq_(self, other): return False if self._string != other._string: return False if not PositionalMetadataMixin._eq_(self, other): return False if not IntervalMetadataMixin._eq_(self, other): return False return True @stable(as_of="0.4.0") def __ne__(self, other): r"""Determine if this sequence is not equal to another. Sequences are not equal if they are not *exactly* the same type, or their sequence characters, metadata, or positional metadata differ. Parameters ---------- other : Sequence Sequence to test for inequality against. Returns ------- bool Indicates whether this sequence is not equal to `other`. Examples -------- >>> from skbio import Sequence >>> s = Sequence('ACGT') >>> t = Sequence('ACGT') >>> s != t False >>> u = Sequence('ACGA') >>> u != t True >>> v = Sequence('ACGA', metadata={'id': 'v'}) >>> u != v True """ return not (self == other) @stable(as_of="0.4.0") def __getitem__(self, indexable): r"""Slice this sequence. Notes ----- This drops the ``self.interval_metadata`` from the returned new ``Sequence`` object. Parameters ---------- indexable : int, slice, iterable (int and slice), 1D array_like (bool) The position(s) to return from this sequence. If `indexable` is an iterable of integers, these are assumed to be indices in the sequence to keep. If `indexable` is a 1D ``array_like`` of booleans, these are assumed to be the positions in the sequence to keep. Returns ------- Sequence New sequence containing the position(s) specified by `indexable` in this sequence. Positional metadata will be sliced in the same manner and included in the returned sequence. `metadata` is included in the returned sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUCGUGAAGGA') Obtain a single character from the sequence: >>> s[1] Sequence ------------- Stats: length: 1 ------------- 0 G Obtain a slice: >>> s[7:] Sequence ------------- Stats: length: 5 ------------- 0 AAGGA Obtain characters at the following indices: >>> s[[3, 4, 7, 0, 3]] Sequence ------------- Stats: length: 5 ------------- 0 CGAGC Obtain characters at positions evaluating to `True`: >>> s = Sequence('GGUCG') >>> index = [True, False, True, 'a' is 'a', False] >>> s[index] Sequence ------------- Stats: length: 3 ------------- 0 GUC """ if (not isinstance(indexable, np.ndarray) and ((not isinstance(indexable, str)) and hasattr(indexable, '__iter__'))): indexable_ = indexable indexable = np.asarray(indexable) if indexable.dtype == object: indexable = list(indexable_) # TODO: Don't blow out memory if len(indexable) == 0: # indexing with an empty list, so convert to ndarray and # fall through to ndarray slicing below indexable = np.asarray(indexable) else: seq = np.concatenate( list(_slices_from_iter(self._bytes, indexable))) index = _as_slice_if_single_index(indexable) positional_metadata = None if self.has_positional_metadata(): pos_md_slices = list(_slices_from_iter( self.positional_metadata, index)) positional_metadata = pd.concat(pos_md_slices, sort=True) metadata = None if self.has_metadata(): metadata = self.metadata return self._constructor( sequence=seq, metadata=metadata, positional_metadata=positional_metadata) elif (isinstance(indexable, str) or isinstance(indexable, bool)): raise IndexError("Cannot index with %s type: %r" % (type(indexable).__name__, indexable)) if (isinstance(indexable, np.ndarray) and indexable.dtype == bool and len(indexable) != len(self)): raise IndexError("An boolean vector index must be the same length" " as the sequence (%d, not %d)." % (len(self), len(indexable))) if isinstance(indexable, np.ndarray) and indexable.size == 0: # convert an empty ndarray to a supported dtype for slicing a numpy # array indexable = indexable.astype(int) seq = self._bytes[indexable] positional_metadata = self._slice_positional_metadata(indexable) metadata = None if self.has_metadata(): metadata = self.metadata return self._constructor( sequence=seq, metadata=metadata, positional_metadata=positional_metadata) def _slice_positional_metadata(self, indexable): if self.has_positional_metadata(): if _is_single_index(indexable): index = _single_index_to_slice(indexable) else: index = indexable return self.positional_metadata.iloc[index] else: return None @stable(as_of="0.4.0") def __len__(self): r"""Return the number of characters in this sequence. Returns ------- int The length of this sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> len(s) 4 """ return self._bytes.size @stable(as_of="0.4.0") def __bool__(self): r"""Returns truth value (truthiness) of sequence. Returns ------- bool True if length of sequence is greater than 0, else False. Examples -------- >>> from skbio import Sequence >>> bool(Sequence('')) False >>> bool(Sequence('ACGT')) True """ return len(self) > 0 @stable(as_of="0.4.0") def __iter__(self): r"""Iterate over positions in this sequence. Yields ------ Sequence Single character subsequence, one for each position in the sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> for c in s: ... str(c) 'G' 'G' 'U' 'C' """ for i in range(len(self)): yield self[i] @stable(as_of="0.4.0") def __reversed__(self): r"""Iterate over positions in this sequence in reverse order. Yields ------ Sequence Single character subsequence, one for each position in the sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> for c in reversed(s): ... str(c) 'C' 'U' 'G' 'G' """ return iter(self[::-1]) @stable(as_of="0.4.0") def __str__(self): r"""Return sequence characters as a string. Returns ------- str Sequence characters as a string. No metadata or positional metadata will be included. See Also -------- sequence Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUCGUAAAGGA', metadata={'id':'hello'}) >>> str(s) 'GGUCGUAAAGGA' """ return str(self._string.decode("ascii")) @stable(as_of="0.4.0") def __repr__(self): r"""Return a string representation of this sequence object. Representation includes: * sequence type * metadata keys and values: will display key/value if it is an understood type, otherwise just the type will be displayed. If it is an understood type whose representation is too long, just the type will be displayed * positional metadata: column names and column dtypes will be displayed in the order they appear in the positional metadata ``pd.DataFrame``. Column names (i.e., keys) follow the same display rules as metadata keys * interval metadata: the number of interval features will be displayed. * sequence stats (e.g., length) * up to five lines of chunked sequence data. Each line of chunked sequence data displays the current position in the sequence Returns ------- str String representation of this sequence object. Notes ----- Subclasses can override Sequence._repr_stats to provide custom statistics. Examples -------- Short sequence without metadata: >>> from skbio import Sequence >>> from skbio.metadata._interval import IntervalMetadata >>> Sequence('ACGTAATGGATACGTAATGCA') Sequence ------------------------- Stats: length: 21 ------------------------- 0 ACGTAATGGA TACGTAATGC A Longer sequence displays first two lines and last two lines: >>> Sequence('ACGT' * 100) Sequence --------------------------------------------------------------------- Stats: length: 400 --------------------------------------------------------------------- 0 ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT 60 ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT ... 300 ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT 360 ACGTACGTAC GTACGTACGT ACGTACGTAC GTACGTACGT Sequence with metadata, positional metadata, and interval metadata: >>> metadata = { ... 'id': 'seq-id', ... 'description': 'description of the sequence, wrapping across ' ... 'lines if it\'s too long', ... 'authors': ['Alice', 'Bob', 'Carol'], ... 'year': 2015, ... 'published': True ... } >>> positional_metadata = { ... 'exons': [True, True, False, True], ... 'quality': [3, 10, 11, 10] ... } >>> seq = Sequence('ACGT', metadata=metadata, ... positional_metadata=positional_metadata) >>> _ = seq.interval_metadata.add([(0, 2)], metadata={'gene': 'sagA'}) >>> seq Sequence ---------------------------------------------------------------------- Metadata: 'authors': 'description': "description of the sequence, wrapping across lines if it's too long" 'id': 'seq-id' 'published': True 'year': 2015 Positional metadata: 'exons': 'quality': Interval metadata: 1 interval feature Stats: length: 4 ---------------------------------------------------------------------- 0 ACGT """ return _SequenceReprBuilder( seq=self, width=71, # 79 for pep8, 8 space indent for docstrings indent=4, chunk_size=10).build() def _repr_stats(self): r"""Define statistics to display in the sequence's repr. Subclasses can override this method to provide type-specific statistics. This method computes a single statistic: length. Returns ------- list List of tuples where each tuple represents a statistic. Each tuple contains exactly two ``str`` elements: the statistic's name/label, and the str-formatted value of the statistic. Ordering of statistics (i.e., list order) determines display order in the sequence repr. """ return [('length', '%d' % len(self))] @stable(as_of="0.4.0") def __copy__(self): r"""Return a shallow copy of this sequence. See Also -------- copy Notes ----- This method is equivalent to ``seq.copy(deep=False)``. """ return self._copy(False, {}) @stable(as_of="0.4.0") def __deepcopy__(self, memo): r"""Return a deep copy of this sequence. See Also -------- copy Notes ----- This method is equivalent to ``seq.copy(deep=True)``. """ return self._copy(True, memo) def _copy(self, deep, memo): # strategy: copy the sequence without metadata first, then set metadata # attributes with copies. we take this approach instead of simply # passing the metadata through the Sequence constructor because we # don't want to copy twice (this could happen when deep=True, where we # deep copy here and then shallow copy in the Sequence constructor). we # also directly set the private metadata attributes instead of using # their public setters to avoid an unnecessary copy # we don't make a distinction between deep vs. shallow copy of bytes # because dtype=np.uint8. we only need to make the distinction when # dealing with object dtype bytes_ = np.copy(self._bytes) seq_copy = self._constructor(sequence=bytes_, metadata=None, positional_metadata=None, interval_metadata=None) if deep: seq_copy._metadata = MetadataMixin._deepcopy_(self, memo) seq_copy._positional_metadata = \ PositionalMetadataMixin._deepcopy_(self, memo) seq_copy._interval_metadata = IntervalMetadataMixin._deepcopy_( self, memo) else: seq_copy._metadata = MetadataMixin._copy_(self) seq_copy._positional_metadata = \ PositionalMetadataMixin._copy_(self) seq_copy._interval_metadata = IntervalMetadataMixin._copy_( self) return seq_copy @stable(as_of='0.4.0') def lowercase(self, lowercase): r"""Return a case-sensitive string representation of the sequence. Parameters ---------- lowercase: str or boolean vector If lowercase is a boolean vector, it is used to set sequence characters to lowercase in the output string. True values in the boolean vector correspond to lowercase characters. If lowercase is a str, it is treated like a key into the positional metadata, pointing to a column which must be a boolean vector. That boolean vector is then used as described previously. Returns ------- str String representation of sequence with specified characters set to lowercase. Examples -------- >>> from skbio import Sequence >>> s = Sequence('ACGT') >>> s.lowercase([True, True, False, False]) 'acGT' >>> s = Sequence('ACGT', ... positional_metadata={ ... 'exons': [True, False, False, True]}) >>> s.lowercase('exons') 'aCGt' Constructor automatically populates a column in positional metadata when the ``lowercase`` keyword argument is provided with a column name: >>> s = Sequence('ACgt', lowercase='introns') >>> s.lowercase('introns') 'ACgt' >>> s = Sequence('ACGT', lowercase='introns') >>> s.lowercase('introns') 'ACGT' """ index = self._munge_to_index_array(lowercase) outbytes = self._bytes.copy() outbytes[index] ^= self._ascii_invert_case_bit_offset return str(outbytes.tobytes().decode('ascii')) @stable(as_of="0.4.0") def count(self, subsequence, start=None, end=None): r"""Count occurrences of a subsequence in this sequence. Parameters ---------- subsequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Subsequence to count occurrences of. start : int, optional The position at which to start counting (inclusive). end : int, optional The position at which to stop counting (exclusive). Returns ------- int Number of occurrences of `subsequence` in this sequence. Raises ------ ValueError If `subsequence` is of length 0. TypeError If `subsequence` is a ``Sequence`` object with a different type than this sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUCG') >>> s.count('G') 3 >>> s.count('GG') 1 >>> s.count('T') 0 >>> s.count('G', 2, 5) 1 """ if len(subsequence) == 0: raise ValueError("`count` is not defined for empty subsequences.") return self._string.count( self._munge_to_bytestring(subsequence, "count"), start, end) @experimental(as_of="0.5.0") def replace(self, where, character): r"""Replace values in this sequence with a different character. Parameters ---------- where : 1D array_like (bool) or iterable (slices or ints) or str Indicates positions in the sequence to replace with `character`. Can be a boolean vector, an iterable of indices/slices, or a string that is a key in `positional_metadata` pointing to a boolean vector. character : str or bytes Character that will replace chosen items in this sequence. Returns ------- Sequence Copy of this sequence, with chosen items replaced with chosen character. All metadata is retained. Examples -------- Let's create and display a Sequence: >>> from skbio import Sequence >>> sequence = Sequence('GGTACCAACG') >>> str(sequence) 'GGTACCAACG' Let's call ``replace`` on the Sequence using a boolean vector for ``where`` and assign it to a new variable: >>> seq = sequence.replace([False, False, False, True, False, False, ... True, True, False, False], '-') Let's take a look at the new Sequence: >>> str(seq) 'GGT-CC--CG' Other types of input are accepted by the ``where`` parameter. Let's pass in a list of indices and slices that is equivalent to the boolean vector we used previously: >>> str(seq) == str(sequence.replace([3, slice(6, 8)], '-')) True ``where`` also accepts a boolean vector contained in ``Sequence.positional_metadata``: >>> sequence.positional_metadata = {'where': ... [False, False, False, True, False, ... False, True, True, False, False]} Let's pass in the key ``'where'`` and compare to ``seq``: >>> str(seq) == str(sequence.replace('where', '-')) True """ if type(character) is not bytes: character = character.encode('ascii') character = ord(character) index = self._munge_to_index_array(where) seq_bytes = self._bytes.copy() seq_bytes[index] = character metadata = None if self.has_metadata(): metadata = self.metadata positional_metadata = None if self.has_positional_metadata(): positional_metadata = self.positional_metadata interval_metadata = None if self.has_interval_metadata(): interval_metadata = self.interval_metadata # Use __class__ instead of _constructor so that validations are # performed for subclasses (the user could have introduced invalid # characters). return self.__class__(seq_bytes, metadata=metadata, positional_metadata=positional_metadata, interval_metadata=interval_metadata) @stable(as_of="0.4.0") def index(self, subsequence, start=None, end=None): r"""Find position where subsequence first occurs in the sequence. Parameters ---------- subsequence : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Subsequence to search for in this sequence. start : int, optional The position at which to start searching (inclusive). end : int, optional The position at which to stop searching (exclusive). Returns ------- int Position where `subsequence` first occurs in this sequence. Raises ------ ValueError If `subsequence` is not present in this sequence. TypeError If `subsequence` is a ``Sequence`` object with a different type than this sequence. Examples -------- >>> from skbio import Sequence >>> s = Sequence('ACACGACGTT-') >>> s.index('ACG') 2 """ try: return self._string.index( self._munge_to_bytestring(subsequence, "index"), start, end) except ValueError: raise ValueError( "%r is not present in %r." % (subsequence, self)) @experimental(as_of="0.4.0") def distance(self, other, metric=None): r"""Compute the distance to another sequence. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compute the distance to. If `other` is a ``Sequence`` object, it must be the same type as this sequence. Other input types will be converted into a ``Sequence`` object of the same type as this sequence. metric : function, optional Function used to compute the distance between this sequence and `other`. If ``None`` (the default), Hamming distance will be used (:func:`skbio.sequence.distance.hamming`). `metric` should take two ``skbio.Sequence`` objects and return a ``float``. The sequence objects passed to `metric` will be the same type as this sequence. See :mod:`skbio.sequence.distance` for other predefined metrics that can be supplied via `metric`. Returns ------- float Distance between this sequence and `other` as defined by `metric`. Raises ------ TypeError If `other` is a ``Sequence`` object with a different type than this sequence. See Also -------- skbio.sequence.distance fraction_diff fraction_same Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> t = Sequence('AGUC') Compute Hamming distance (the default metric): >>> s.distance(t) 0.25 Use a custom metric: >>> def custom_metric(s1, s2): return 0.42 >>> s.distance(t, custom_metric) 0.42 """ # TODO refactor this method to accept a name (string) of the distance # metric to apply and accept **kwargs other = self._munge_to_self_type(other, 'distance') if metric is None: metric = skbio.sequence.distance.hamming return float(metric(self, other)) @stable(as_of="0.4.0") def matches(self, other): r"""Find positions that match with another sequence. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compare to. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` at position ``i`` indicates a match between the sequences at their positions ``i``. Raises ------ ValueError If the sequences are not the same length. TypeError If `other` is a ``Sequence`` object with a different type than this sequence. See Also -------- mismatches Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> t = Sequence('GAUU') >>> s.matches(t) array([ True, False, True, False], dtype=bool) """ other = self._munge_to_sequence(other, 'matches/mismatches') if len(self) != len(other): raise ValueError("Match and mismatch vectors can only be " "generated from equal length sequences.") return self._bytes == other._bytes @stable(as_of="0.4.0") def mismatches(self, other): r"""Find positions that do not match with another sequence. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compare to. Returns ------- 1D np.ndarray (bool) Boolean vector where ``True`` at position ``i`` indicates a mismatch between the sequences at their positions ``i``. Raises ------ ValueError If the sequences are not the same length. TypeError If `other` is a ``Sequence`` object with a different type than this sequence. See Also -------- matches Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> t = Sequence('GAUU') >>> s.mismatches(t) array([False, True, False, True], dtype=bool) """ return np.invert(self.matches(other)) @stable(as_of="0.4.0") def match_frequency(self, other, relative=False): r"""Return count of positions that are the same between two sequences. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compare to. relative : bool, optional If ``True``, return the relative frequency of matches instead of the count. Returns ------- int or float Number of positions that are the same between the sequences. This will be an ``int`` if `relative` is ``False`` and a ``float`` if `relative` is ``True``. Raises ------ ValueError If the sequences are not the same length. TypeError If `other` is a ``Sequence`` object with a different type than this sequence. See Also -------- mismatch_frequency matches mismatches distance Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> t = Sequence('AGUC') >>> s.match_frequency(t) 3 >>> s.match_frequency(t, relative=True) 0.75 """ if relative: return float(self.matches(other).mean()) else: return int(self.matches(other).sum()) @stable(as_of="0.4.0") def mismatch_frequency(self, other, relative=False): r"""Return count of positions that differ between two sequences. Parameters ---------- other : str, Sequence, or 1D np.ndarray (np.uint8 or '\|S1') Sequence to compare to. relative : bool, optional If ``True``, return the relative frequency of mismatches instead of the count. Returns ------- int or float Number of positions that differ between the sequences. This will be an ``int`` if `relative` is ``False`` and a ``float`` if `relative` is ``True``. Raises ------ ValueError If the sequences are not the same length. TypeError If `other` is a ``Sequence`` object with a different type than this sequence. See Also -------- match_frequency matches mismatches distance Examples -------- >>> from skbio import Sequence >>> s = Sequence('GGUC') >>> t = Sequence('AGUC') >>> s.mismatch_frequency(t) 1 >>> s.mismatch_frequency(t, relative=True) 0.25 """ if relative: return float(self.mismatches(other).mean()) else: return int(self.mismatches(other).sum()) @experimental(as_of="0.4.1") def frequencies(self, chars=None, relative=False): r"""Compute frequencies of characters in the sequence. Parameters ---------- chars : str or set of str, optional Characters to compute the frequencies of. May be a ``str`` containing a single character or a ``set`` of single-character strings. If ``None``, frequencies will be computed for all characters present in the sequence. relative : bool, optional If ``True``, return the relative frequency of each character instead of its count. If `chars` is provided, relative frequencies will be computed with respect to the number of characters in the sequence, **not** the total count of characters observed in `chars`. Thus, the relative frequencies will not necessarily sum to 1.0 if `chars` is provided. Returns ------- dict Frequencies of characters in the sequence. Raises ------ TypeError If `chars` is not a ``str`` or ``set`` of ``str``. ValueError If `chars` is not a single-character ``str`` or a ``set`` of single-character strings. ValueError If `chars` contains characters outside the allowable range of characters in a ``Sequence`` object. See Also -------- kmer_frequencies iter_kmers Notes ----- If the sequence is empty (i.e., length zero), ``relative=True``, **and** `chars` is provided, the relative frequency of each specified character will be ``np.nan``. If `chars` is not provided, this method is equivalent to, but faster than, ``seq.kmer_frequencies(k=1)``. If `chars` is not provided, it is equivalent to, but faster than, passing ``chars=seq.observed_chars``. Examples -------- Compute character frequencies of a sequence: >>> from pprint import pprint >>> from skbio import Sequence >>> seq = Sequence('AGAAGACC') >>> freqs = seq.frequencies() >>> pprint(freqs) # using pprint to display dict in sorted order {'A': 4, 'C': 2, 'G': 2} Compute relative character frequencies: >>> freqs = seq.frequencies(relative=True) >>> pprint(freqs) {'A': 0.5, 'C': 0.25, 'G': 0.25} Compute relative frequencies of characters A, C, and T: >>> freqs = seq.frequencies(chars={'A', 'C', 'T'}, relative=True) >>> pprint(freqs) {'A': 0.5, 'C': 0.25, 'T': 0.0} Note that since character T is not in the sequence we receive a relative frequency of 0.0. The relative frequencies of A and C are relative to the number of characters in the sequence (8), **not** the number of A and C characters (4 + 2 = 6). """ freqs = np.bincount(self._bytes, minlength=self._number_of_extended_ascii_codes) if chars is not None: chars, indices = self._chars_to_indices(chars) else: indices, = np.nonzero(freqs) # Downcast from int64 to uint8 then convert to str. This is safe # because we are guaranteed to have indices in the range 0 to 255 # inclusive. chars = indices.astype(np.uint8).tobytes().decode('ascii') obs_counts = freqs[indices] if relative: obs_counts = obs_counts / len(self) # Use tolist() for minor performance gain. return dict(zip(chars, obs_counts.tolist())) def _chars_to_indices(self, chars): r"""Helper for Sequence.frequencies.""" if isinstance(chars, (str, bytes)): chars = set([chars]) elif not isinstance(chars, set): raise TypeError( "`chars` must be of type `set`, not %r" % type(chars).__name__) # Impose an (arbitrary) ordering to `chars` so that we can return # `indices` in that same order. chars = list(chars) indices = [] for char in chars: if not isinstance(char, (str, bytes)): raise TypeError( "Each element of `chars` must be string-like, not %r" % type(char).__name__) if len(char) != 1: raise ValueError( "Each element of `chars` must contain a single " "character (found %d characters)" % len(char)) index = ord(char) if index >= self._number_of_extended_ascii_codes: raise ValueError( "Character %r in `chars` is outside the range of " "allowable characters in a `Sequence` object." % char) indices.append(index) return chars, indices @stable(as_of="0.4.0") def iter_kmers(self, k, overlap=True): r"""Generate kmers of length `k` from this sequence. Parameters ---------- k : int The kmer length. overlap : bool, optional Defines whether the kmers should be overlapping or not. Yields ------ Sequence kmer of length `k` contained in this sequence. Raises ------ ValueError If `k` is less than 1. Examples -------- >>> from skbio import Sequence >>> s = Sequence('ACACGACGTT') >>> for kmer in s.iter_kmers(4, overlap=False): ... str(kmer) 'ACAC' 'GACG' >>> for kmer in s.iter_kmers(3, overlap=True): ... str(kmer) 'ACA' 'CAC' 'ACG' 'CGA' 'GAC' 'ACG' 'CGT' 'GTT' """ if k < 1: raise ValueError("k must be greater than 0.") if overlap: step = 1 count = len(self) - k + 1 else: step = k count = len(self) // k if len(self) == 0 or self.has_positional_metadata(): # Slower path when sequence is empty or positional metadata needs # to be sliced. for i in range(0, len(self) - k + 1, step): yield self[i:i+k] else: # Optimized path when positional metadata doesn't need slicing. kmers = np.lib.stride_tricks.as_strided( self._bytes, shape=(k, count), strides=(1, step)).T metadata = None if self.has_metadata(): metadata = self.metadata for s in kmers: yield self._constructor( sequence=s, metadata=metadata, positional_metadata=None) @stable(as_of="0.4.0") def kmer_frequencies(self, k, overlap=True, relative=False): r"""Return counts of words of length `k` from this sequence. Parameters ---------- k : int The word length. overlap : bool, optional Defines whether the kmers should be overlapping or not. relative : bool, optional If ``True``, return the relative frequency of each kmer instead of its count. Returns ------- dict Frequencies of words of length `k` contained in this sequence. Raises ------ ValueError If `k` is less than 1. Examples -------- >>> from pprint import pprint >>> from skbio import Sequence >>> s = Sequence('ACACATTTATTA') >>> freqs = s.kmer_frequencies(3, overlap=False) >>> pprint(freqs) # using pprint to display dict in sorted order {'ACA': 1, 'CAT': 1, 'TTA': 2} >>> freqs = s.kmer_frequencies(3, relative=True, overlap=False) >>> pprint(freqs) {'ACA': 0.25, 'CAT': 0.25, 'TTA': 0.5} """ kmers = self.iter_kmers(k, overlap=overlap) freqs = dict(collections.Counter((str(seq) for seq in kmers))) if relative: if overlap: num_kmers = len(self) - k + 1 else: num_kmers = len(self) // k relative_freqs = {} for kmer, count in freqs.items(): relative_freqs[kmer] = count / num_kmers freqs = relative_freqs return freqs @stable(as_of="0.4.0") def find_with_regex(self, regex, ignore=None): r"""Generate slices for patterns matched by a regular expression. Parameters ---------- regex : str or regular expression object String to be compiled into a regular expression, or a pre- compiled regular expression object (e.g., from calling ``re.compile``). ignore : 1D array_like (bool) or iterable (slices or ints), optional Indicate the positions to ignore when matching. Yields ------ slice Location where the regular expression matched. Examples -------- >>> from skbio import Sequence >>> s = Sequence('AATATACCGGTTATAA') >>> for match in s.find_with_regex('(TATA+)'): ... match ... str(s[match]) slice(2, 6, None) 'TATA' slice(11, 16, None) 'TATAA' """ if isinstance(regex, str): regex = re.compile(regex) lookup = np.arange(len(self)) if ignore is None: string = str(self) else: ignore = self._munge_to_index_array(ignore) lookup = np.delete(lookup, ignore) string = str(self[lookup]) for match in regex.finditer(string): # We start at 1 because we don't want the group that contains all # other groups. for g in range(1, len(match.groups())+1): yield slice(lookup[match.start(g)], lookup[match.end(g) - 1] + 1) @stable(as_of="0.4.0") def iter_contiguous(self, included, min_length=1, invert=False): r"""Yield contiguous subsequences based on `included`. Parameters ---------- included : 1D array_like (bool) or iterable (slices or ints) `included` is transformed into a flat boolean vector where each position will either be included or skipped. All contiguous included positions will be yielded as a single region. min_length : int, optional The minimum length of a subsequence for it to be yielded. Default is 1. invert : bool, optional Whether to invert `included` such that it describes what should be skipped instead of included. Default is False. Yields ------ Sequence Contiguous subsequence as indicated by `included`. Notes ----- If slices provide adjacent ranges, then they will be considered the same contiguous subsequence. Examples -------- Here we use `iter_contiguous` to find all of the contiguous ungapped sequences using a boolean vector derived from our DNA sequence. >>> from skbio import DNA >>> s = DNA('AAA--TT-CCCC-G-') >>> no_gaps = ~s.gaps() >>> for ungapped_subsequence in s.iter_contiguous(no_gaps, ... min_length=2): ... print(ungapped_subsequence) AAA TT CCCC Note how the last potential subsequence was skipped because it would have been smaller than our `min_length` which was set to 2. We can also use `iter_contiguous` on a generator of slices as is produced by `find_motifs` (and `find_with_regex`). >>> from skbio import Protein >>> s = Protein('ACDFNASANFTACGNPNRTESL') >>> for subseq in s.iter_contiguous(s.find_motifs('N-glycosylation')): ... print(subseq) NASANFTA NRTE Note how the first subsequence contains two N-glycosylation sites. This happened because they were contiguous. """ idx = self._munge_to_index_array(included) if invert: idx = np.delete(np.arange(len(self)), idx) # Adapted from http://stackoverflow.com/a/7353335/579416 for contig in np.split(idx, np.where(np.diff(idx) != 1)[0] + 1): r = self[contig] if len(r) >= min_length: yield r def _constructor(self, **kwargs): return self.__class__(**kwargs) def _munge_to_index_array(self, sliceable): r"""Return index array from something isomorphic to a boolean vector. """ if isinstance(sliceable, str): if sliceable in self.positional_metadata: if self.positional_metadata[sliceable].dtype == bool: sliceable = self.positional_metadata[sliceable] else: raise TypeError("Column '%s' in positional metadata does " "not correspond to a boolean vector" % sliceable) else: raise ValueError("No positional metadata associated with key " "'%s'" % sliceable) if not hasattr(sliceable, 'dtype') or (hasattr(sliceable, 'dtype') and sliceable.dtype == 'object'): sliceable = tuple(sliceable) bool_mode = False int_mode = False for s in sliceable: if isinstance(s, (bool, np.bool_)): bool_mode = True elif isinstance(s, (slice, int, np.signedinteger)) or ( hasattr(s, 'dtype') and s.dtype != bool): int_mode = True else: raise TypeError("Invalid type in iterable: %s, must be one" " of {bool, int, slice, np.signedinteger}" % s.__class__.__name__) if bool_mode and int_mode: raise TypeError("Cannot provide iterable of both bool and" " int.") sliceable = np.r_[sliceable] if sliceable.dtype == bool: if sliceable.size != len(self): raise ValueError("Boolean array (%d) does not match length of" " sequence (%d)." % (sliceable.size, len(self))) normalized, = np.where(sliceable) else: normalized = np.bincount(sliceable) if np.any(normalized > 1): raise ValueError("Overlapping index regions are not allowed.") normalized, = np.where(normalized) if np.any(normalized != sliceable): raise ValueError("Index regions are out of order.") return normalized def _munge_to_self_type(self, other, method): if isinstance(other, Sequence): if type(other) is not type(self): raise TypeError("Cannot use %s and %s together with `%s`" % (self.__class__.__name__, other.__class__.__name__, method)) else: return other return self.__class__(other) def _munge_to_sequence(self, other, method): if isinstance(other, Sequence): if type(other) is not type(self): raise TypeError("Cannot use %s and %s together with `%s`" % (self.__class__.__name__, other.__class__.__name__, method)) else: return other # We don't use self.__class__ or self._constructor here because we want # to construct the most general type of Sequence object in order to # avoid validation errors. return Sequence(other) def _munge_to_bytestring(self, other, method): if type(other) is bytes: return other elif isinstance(other, str): return other.encode('ascii') else: return self._munge_to_sequence(other, method)._string @contextmanager def _byte_ownership(self): if not self._owns_bytes: self._bytes = self._bytes.copy() self._owns_bytes = True self._bytes.flags.writeable = True yield self._bytes.flags.writeable = False def _single_index_to_slice(start_index): end_index = None if start_index == -1 else start_index+1 return slice(start_index, end_index) def _is_single_index(index): return (isinstance(index, numbers.Integral) and not isinstance(index, bool)) def _as_slice_if_single_index(indexable): if _is_single_index(indexable): return _single_index_to_slice(indexable) else: return indexable def _slices_from_iter(array, indexables): for i in indexables: if isinstance(i, slice): pass elif _is_single_index(i): i = _single_index_to_slice(i) else: raise IndexError("Cannot slice sequence from iterable " "containing %r." % i) yield array[i] scikit-bio-0.5.9/skbio/sequence/distance.py000066400000000000000000000121421446255456000206600ustar00rootroot00000000000000""" Sequence distance metrics (:mod:`skbio.sequence.distance`) ========================================================== .. currentmodule:: skbio.sequence.distance This module contains functions for computing distances between scikit-bio ``Sequence`` objects. These functions can be used directly or supplied to other parts of the scikit-bio API that accept a sequence distance metric as input, such as :meth:`skbio.sequence.Sequence.distance` and :meth:`skbio.stats.distance.DistanceMatrix.from_iterable`. Functions --------- .. autosummary:: :toctree: hamming kmer_distance """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import scipy.spatial.distance import skbio from skbio.util._decorator import experimental @experimental(as_of='0.4.2') def hamming(seq1, seq2): """Compute Hamming distance between two sequences. The Hamming distance between two equal-length sequences is the proportion of differing characters. Parameters ---------- seq1, seq2 : Sequence Sequences to compute Hamming distance between. Returns ------- float Hamming distance between `seq1` and `seq2`. Raises ------ TypeError If `seq1` and `seq2` are not ``Sequence`` instances. TypeError If `seq1` and `seq2` are not the same type. ValueError If `seq1` and `seq2` are not the same length. See Also -------- scipy.spatial.distance.hamming Notes ----- ``np.nan`` will be returned if the sequences do not contain any characters. This function does not make assumptions about the sequence alphabet in use. Each sequence object's underlying sequence of characters are used to compute Hamming distance. Characters that may be considered equivalent in certain contexts (e.g., `-` and `.` as gap characters) are treated as distinct characters when computing Hamming distance. Examples -------- >>> from skbio import Sequence >>> from skbio.sequence.distance import hamming >>> seq1 = Sequence('AGGGTA') >>> seq2 = Sequence('CGTTTA') >>> hamming(seq1, seq2) 0.5 """ _check_seqs(seq1, seq2) # Hamming requires equal length sequences. We are checking this here # because the error you would get otherwise is cryptic. if len(seq1) != len(seq2): raise ValueError( "Hamming distance can only be computed between sequences of equal " "length (%d != %d)" % (len(seq1), len(seq2))) # scipy throws a RuntimeWarning when computing Hamming distance on length 0 # input. if not seq1: distance = np.nan else: distance = scipy.spatial.distance.hamming(seq1.values, seq2.values) return float(distance) @experimental(as_of='0.5.0') def kmer_distance(seq1, seq2, k, overlap=True): """Compute the kmer distance between a pair of sequences The kmer distance between two sequences is the fraction of kmers that are unique to either sequence. Parameters ---------- seq1, seq2 : Sequence Sequences to compute kmer distance between. k : int The kmer length. overlap : bool, optional Defines whether the kmers should be overlapping or not. Returns ------- float kmer distance between `seq1` and `seq2`. Raises ------ ValueError If `k` is less than 1. TypeError If `seq1` and `seq2` are not ``Sequence`` instances. TypeError If `seq1` and `seq2` are not the same type. Notes ----- kmer counts are not incorporated in this distance metric. ``np.nan`` will be returned if there are no kmers defined for the sequences. Examples -------- >>> from skbio import Sequence >>> seq1 = Sequence('ATCGGCGAT') >>> seq2 = Sequence('GCAGATGTG') >>> kmer_distance(seq1, seq2, 3) # doctest: +ELLIPSIS 0.9230769230... """ _check_seqs(seq1, seq2) seq1_kmers = set(map(str, seq1.iter_kmers(k, overlap=overlap))) seq2_kmers = set(map(str, seq2.iter_kmers(k, overlap=overlap))) all_kmers = seq1_kmers | seq2_kmers if not all_kmers: return np.nan shared_kmers = seq1_kmers & seq2_kmers number_unique = len(all_kmers) - len(shared_kmers) fraction_unique = number_unique / len(all_kmers) return fraction_unique def _check_seqs(seq1, seq2): # Asserts both sequences are skbio.sequence objects for seq in seq1, seq2: if not isinstance(seq, skbio.Sequence): raise TypeError( "`seq1` and `seq2` must be Sequence instances, not %r" % type(seq).__name__) # Asserts sequences have the same type if type(seq1) is not type(seq2): raise TypeError( "Sequences must have matching type. Type %r does not match type %r" % (type(seq1).__name__, type(seq2).__name__)) scikit-bio-0.5.9/skbio/sequence/tests/000077500000000000000000000000001446255456000176565ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/sequence/tests/__init__.py000066400000000000000000000005411446255456000217670ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/sequence/tests/test_distance.py000066400000000000000000000160571446255456000230720ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import itertools import unittest import numpy as np import numpy.testing as npt from skbio import Sequence, DNA from skbio.sequence.distance import hamming, kmer_distance class TestHamming(unittest.TestCase): def test_non_sequence(self): seq1 = Sequence('abc') seq2 = 'abc' with self.assertRaisesRegex(TypeError, r'seq1.*seq2.*Sequence.*str'): hamming(seq1, seq2) with self.assertRaisesRegex(TypeError, r'seq1.*seq2.*Sequence.*str'): hamming(seq2, seq1) def test_type_mismatch(self): seq1 = Sequence('ABC') seq2 = DNA('ACG') with self.assertRaisesRegex(TypeError, r'Sequence.*does not match.*DNA'): hamming(seq1, seq2) def test_length_mismatch(self): seq1 = Sequence('ABC') seq2 = Sequence('ABCD') with self.assertRaisesRegex(ValueError, r'equal length.*3 != 4'): hamming(seq1, seq2) def test_return_type(self): seq1 = Sequence('ABC') seq2 = Sequence('ABC') distance = hamming(seq1, seq2) self.assertIsInstance(distance, float) self.assertEqual(distance, 0.0) def test_minimum_distance(self): seq1 = Sequence('ABC') seq2 = Sequence('ABC') distance = hamming(seq1, seq2) self.assertEqual(distance, 0.0) def test_mid_range_distance(self): seq1 = Sequence("abcdefgh") seq2 = Sequence("1b23ef45") distance = hamming(seq1, seq2) self.assertEqual(distance, 5.0/8.0) def test_maximum_distance(self): seq1 = Sequence('ABC') seq2 = Sequence('CAB') distance = hamming(seq1, seq2) self.assertEqual(distance, 1.0) def test_empty_sequences(self): seq1 = Sequence('') seq2 = Sequence('') distance = hamming(seq1, seq2) npt.assert_equal(distance, np.nan) def test_single_character_sequences(self): seq1 = Sequence('a') seq2 = Sequence('b') self.assertEqual(hamming(seq1, seq1), 0.0) self.assertEqual(hamming(seq1, seq2), 1.0) def test_sequence_subclass(self): seq1 = DNA('ACG-T') seq2 = DNA('ACCTT') distance = hamming(seq1, seq2) self.assertEqual(distance, 2.0/5.0) def test_sequences_with_metadata(self): # test for #1254 seqs1 = [ Sequence("ACGT"), Sequence("ACGT", metadata={'id': 'abc'}), Sequence("ACGT", positional_metadata={'qual': range(4)}) ] seqs2 = [ Sequence("AAAA"), Sequence("AAAA", metadata={'id': 'def'}), Sequence("AAAA", positional_metadata={'qual': range(4, 8)}) ] for seqs in seqs1, seqs2: for seq1, seq2 in itertools.product(seqs, repeat=2): distance = hamming(seq1, seq2) self.assertEqual(distance, 0.0) for seq1, seq2 in itertools.product(seqs1, seqs2): distance = hamming(seq1, seq2) self.assertEqual(distance, 0.75) class TestKmerDistance(unittest.TestCase): def test_default_kwargs(self): seq1 = Sequence('AACCTAGCAATGGAT') seq2 = Sequence('CAGGCAGTTCTCACC') obs = kmer_distance(seq1, seq2, 3) exp = 0.9130434782608695 self.assertAlmostEqual(obs, exp) def test_nondefault_k(self): seq1 = Sequence('GCTTATGGAGAGAGA') seq2 = Sequence('CTCGAACTCCAGCCA') obs = kmer_distance(seq1, seq2, 2) exp = 0.7333333333333333 self.assertAlmostEqual(obs, exp) seq1 = Sequence('EADDECAEECDEACD') seq2 = Sequence('DCBCBADADABCCDA') obs = kmer_distance(seq1, seq2, 1) exp = 0.4 self.assertAlmostEqual(obs, exp) def test_overlap_false(self): seq1 = Sequence('CGTTATGTCTGTGAT') seq2 = Sequence('CTGAATCGGTAGTGT') obs = kmer_distance(seq1, seq2, 3, overlap=False) exp = 0.8888888888888888 self.assertAlmostEqual(obs, exp) def test_entirely_different_sequences(self): seq1 = Sequence('CCGTGGTCGTATAAG') seq2 = Sequence('CGCCTTCCACATCAG') obs = kmer_distance(seq1, seq2, 3) exp = 1.0 self.assertEqual(obs, exp) def test_same_sequence(self): seq1 = Sequence('CTGCGACAGTTGGTA') seq2 = Sequence('CTGCGACAGTTGGTA') obs = kmer_distance(seq1, seq2, 3) exp = 0.0 self.assertEqual(obs, exp) def test_differing_length_seqs(self): seq1 = Sequence('AGAAATCTGAGCAAGGATCA') seq2 = Sequence('TTAGTGCGTAATCCG') obs = kmer_distance(seq1, seq2, 3) exp = 0.9285714285714286 self.assertAlmostEqual(obs, exp) def test_with_sequence_subclass(self): seq1 = DNA('GATGGTACTGTAGGT') seq2 = DNA('AGGGTGAAGGTATCA') obs = kmer_distance(seq1, seq2, 3) exp = 0.8421052631578947 self.assertAlmostEqual(obs, exp) def test_with_metadata_sanity(self): seq1 = Sequence('AACCTAGCAATGGAT', metadata={'Name': 'Kestrel Gorlick'}, positional_metadata={'seq': list('ACTCAAGCTACGAAG')}) seq2 = Sequence('CAGGCAGTTCTCACC') obs = kmer_distance(seq1, seq2, 3) exp = 0.9130434782608695 self.assertAlmostEqual(obs, exp) def test_return_type(self): seq1 = Sequence('ATCG') seq2 = Sequence('ATCG') obs = kmer_distance(seq1, seq2, 3) self.assertIsInstance(obs, float) self.assertEqual(obs, 0.0) def test_empty_sequences(self): seq1 = Sequence('') seq2 = Sequence('') obs = kmer_distance(seq1, seq2, 3) npt.assert_equal(obs, np.nan) def test_one_empty_sequence(self): seq1 = Sequence('') seq2 = Sequence('CGGGCAGCTCCTACCTGCTA') obs = kmer_distance(seq1, seq2, 3) exp = 1.0 self.assertAlmostEqual(obs, exp) def test_no_kmers_found(self): seq1 = Sequence('ATCG') seq2 = Sequence('ACGT') obs = kmer_distance(seq1, seq2, 5) npt.assert_equal(obs, np.nan) def test_k_less_than_one_error(self): seq1 = Sequence('ATCG') seq2 = Sequence('ACTG') with self.assertRaisesRegex(ValueError, r'k must be greater than 0.'): kmer_distance(seq1, seq2, 0) def test_type_mismatch_error(self): seq1 = Sequence('ABC') seq2 = DNA('ATC') with self.assertRaisesRegex(TypeError, r"Type 'Sequence'.*type 'DNA'"): kmer_distance(seq1, seq2, 3) def test_non_sequence_error(self): seq1 = Sequence('ATCG') seq2 = 'ATCG' with self.assertRaisesRegex(TypeError, r"not 'str'"): kmer_distance(seq1, seq2, 3) if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_dna.py000066400000000000000000000037031446255456000220340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio import DNA, RNA from skbio.metadata import IntervalMetadata # tests specific to DNA go here. tests for functionality shared by DNA and RNA # go in test_nucleotide_sequences.py class TestDNA(unittest.TestCase): def test_transcribe(self): # without changes self.assertEqual(DNA('').transcribe(), RNA('')) self.assertEqual(DNA('A').transcribe(), RNA('A')) self.assertEqual(DNA('.ACGW-').transcribe(), RNA('.ACGW-')) # with changes self.assertEqual(DNA('T').transcribe(), RNA('U')) self.assertEqual(DNA('TT').transcribe(), RNA('UU')) self.assertEqual(DNA('ATCTG').transcribe(), RNA('AUCUG')) self.assertEqual(DNA('TTTG').transcribe(), RNA('UUUG')) def test_transcribe_preserves_all_metadata(self): im = IntervalMetadata(4) im.add([(0, 2)], metadata={'gene': 'p53'}) exp = RNA('AGUU', metadata={'foo': 'bar'}, positional_metadata={'foo': range(4)}, interval_metadata=im) seq = DNA('AGTT', metadata={'foo': 'bar'}, positional_metadata={'foo': range(4)}, interval_metadata=im) self.assertEqual(seq.transcribe(), exp) def test_transcribe_does_not_modify_input(self): seq = DNA('ATAT') self.assertEqual(seq.transcribe(), RNA('AUAU')) self.assertEqual(seq, DNA('ATAT')) def test_cannot_subclass(self): with self.assertRaisesRegex(TypeError, r"Subclassing disabled"): class CustomSequence(DNA): pass if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_genetic_code.py000066400000000000000000000463221446255456000237060ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import itertools import unittest import numpy as np import numpy.testing as npt from skbio import Sequence, DNA, RNA, Protein, GeneticCode from skbio.sequence._genetic_code import _ncbi_genetic_codes class TestGeneticCode(unittest.TestCase): def setUp(self): self.sgc = GeneticCode.from_ncbi(1) def test_from_ncbi_valid_table_ids(self): # spot check a few tables self.assertEqual(GeneticCode.from_ncbi().name, 'Standard') self.assertEqual(GeneticCode.from_ncbi(2).name, 'Vertebrate Mitochondrial') self.assertEqual(GeneticCode.from_ncbi(12).name, 'Alternative Yeast Nuclear') self.assertEqual(GeneticCode.from_ncbi(25).name, 'Candidate Division SR1 and Gracilibacteria') def test_from_ncbi_invalid_input(self): with self.assertRaisesRegex(ValueError, r'table_id.*7'): GeneticCode.from_ncbi(7) with self.assertRaisesRegex(ValueError, r'table_id.*42'): GeneticCode.from_ncbi(42) def test_reading_frames(self): exp = [1, 2, 3, -1, -2, -3] self.assertEqual(GeneticCode.reading_frames, exp) self.assertEqual(self.sgc.reading_frames, exp) GeneticCode.reading_frames.append(42) self.assertEqual(GeneticCode.reading_frames, exp) self.assertEqual(self.sgc.reading_frames, exp) with self.assertRaises(AttributeError): self.sgc.reading_frames = [1, 2, 42] def test_name(self): self.assertEqual(self.sgc.name, 'Standard') self.assertEqual(GeneticCode('M' * 64, '-' * 64).name, '') self.assertEqual(GeneticCode('M' * 64, '-' * 64, 'foo').name, 'foo') with self.assertRaises(AttributeError): self.sgc.name = 'foo' def test_init_varied_equivalent_input(self): for args in (('M' * 64, '-' * 64), (Protein('M' * 64), Protein('-' * 64)), (Sequence('M' * 64), Sequence('-' * 64))): gc = GeneticCode(*args) self.assertEqual(gc.name, '') self.assertEqual(gc._amino_acids, Protein('M' * 64)) self.assertEqual(gc._starts, Protein('-' * 64)) npt.assert_array_equal(gc._m_character_codon, np.asarray([0, 0, 0], dtype=np.uint8)) self.assertEqual(len(gc._start_codons), 0) def test_init_invalid_input(self): # `amino_acids` invalid protein with self.assertRaisesRegex(ValueError, r'Invalid character.*&'): GeneticCode('&' * 64, '-' * 64) # wrong number of amino acids with self.assertRaisesRegex(ValueError, r'amino_acids.*64.*42'): GeneticCode('M' * 42, '-' * 64) # `amino_acids` missing M with self.assertRaisesRegex(ValueError, r'amino_acids.*M.*character'): GeneticCode('A' * 64, '-' * 64) # `starts` invalid protein with self.assertRaisesRegex(ValueError, r'Invalid character.*&'): GeneticCode('M' * 64, '&' * 64) # wrong number of starts with self.assertRaisesRegex(ValueError, r'starts.*64.*42'): GeneticCode('M' * 64, '-' * 42) # invalid characters in `starts` with self.assertRaisesRegex(ValueError, r'starts.*M and - characters'): GeneticCode('M' * 64, '-M' * 30 + '*AQR') def test_str(self): # predefined exp = ( ' AAs = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAA' 'DDEEGGGG\n' 'Starts = ---M---------------M---------------M--------------------' '--------\n' 'Base1 = UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGG' 'GGGGGGGG\n' 'Base2 = UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCC' 'AAAAGGGG\n' 'Base3 = UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG' 'UCAGUCAG' ) self.assertEqual(str(self.sgc), exp) # custom, no name obs = str(GeneticCode('M' * 64, '-' * 64)) self.assertIn('M' * 64, obs) self.assertIn('-' * 64, obs) def test_repr(self): # predefined exp = ( 'GeneticCode (Standard)\n' '-----------------------------------------------------------------' '--------\n' ' AAs = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAA' 'DDEEGGGG\n' 'Starts = ---M---------------M---------------M--------------------' '--------\n' 'Base1 = UUUUUUUUUUUUUUUUCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGG' 'GGGGGGGG\n' 'Base2 = UUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCCAAAAGGGGUUUUCCCC' 'AAAAGGGG\n' 'Base3 = UCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAGUCAG' 'UCAGUCAG' ) self.assertEqual(repr(self.sgc), exp) # custom, no name obs = repr(GeneticCode('M' * 64, '-' * 64)) self.assertTrue(obs.startswith('GeneticCode\n')) self.assertIn('M' * 64, obs) self.assertIn('-' * 64, obs) def test_eq(self): amino_acids = 'AMPM' * 16 starts = '--M-' * 16 equal_gcs = [ GeneticCode(amino_acids, starts), # name should be ignored GeneticCode(amino_acids, starts, 'foo'), # metadata/positional metadata should be ignored if Sequence # subclass is provided GeneticCode( Protein(amino_acids, metadata={'foo': 'bar'}), Protein(starts, positional_metadata={'foo': range(64)})) ] # every gc should be equal to itself for gc in equal_gcs: self.assertTrue(gc == gc) self.assertFalse(gc != gc) # every pair of gcs should be equal. use permutations instead of # combinations to test that comparing gc1 to gc2 and gc2 to gc1 are # both equal for gc1, gc2 in itertools.permutations(equal_gcs, 2): self.assertTrue(gc1 == gc2) self.assertFalse(gc1 != gc2) def test_ne(self): class GeneticCodeSubclass(GeneticCode): pass amino_acids = 'AMPM' * 16 starts = '--M-' * 16 unequal_gcs = [ GeneticCode(amino_acids, starts), # type must match GeneticCodeSubclass(amino_acids, starts), # completely different type 'foo' ] # none of the NCBI genetic codes should be equal to each other unequal_gcs.extend(_ncbi_genetic_codes.values()) for gc in unequal_gcs: self.assertTrue(gc == gc) self.assertFalse(gc != gc) for gc1, gc2 in itertools.permutations(unequal_gcs, 2): self.assertTrue(gc1 != gc2) self.assertFalse(gc1 == gc2) def test_translate_preserves_metadata(self): obs = self.sgc.translate( RNA('AUG', metadata={'foo': 'bar', 'baz': 42}, positional_metadata={'foo': range(3)})) # metadata retained, positional metadata dropped self.assertEqual(obs, Protein('M', metadata={'foo': 'bar', 'baz': 42})) def test_translate_default_behavior(self): # empty translation exp = Protein('') for seq in RNA(''), RNA('A'), RNA('AU'): obs = self.sgc.translate(seq) self.assertEqual(obs, exp) # no start or stop codons obs = self.sgc.translate(RNA('CCU')) self.assertEqual(obs, Protein('P')) # multiple alternative start codons, no stop codons, length is multiple # of 3 obs = self.sgc.translate(RNA('CAUUUGCUGAAA')) self.assertEqual(obs, Protein('HLLK')) # multiple stop codons, length isn't multiple of 3 obs = self.sgc.translate(RNA('UUUUUUUAAAGUUAAGGGAU')) self.assertEqual(obs, Protein('FF*S*G')) def test_translate_reading_frame_empty_translation(self): exp = Protein('') for seq in RNA(''), RNA('A'), RNA('AU'): for reading_frame in GeneticCode.reading_frames: obs = self.sgc.translate(seq, reading_frame=reading_frame) self.assertEqual(obs, exp) # reading frames that yield a partial codon for reading_frame in 2, 3, -2, -3: obs = self.sgc.translate(RNA('AUG'), reading_frame=reading_frame) self.assertEqual(obs, exp) def test_translate_reading_frame_non_empty_translation(self): seq = RNA('AUGGUGGAA') # rc = UUCCACCAU for reading_frame, exp_str in ((1, 'MVE'), (2, 'WW'), (3, 'GG'), (-1, 'FHH'), (-2, 'ST'), (-3, 'PP')): exp = Protein(exp_str) obs = self.sgc.translate(seq, reading_frame=reading_frame) self.assertEqual(obs, exp) def test_translate_start_empty_translation(self): exp = Protein('') for seq in RNA(''), RNA('A'), RNA('AU'): for start in {'optional', 'ignore'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*start=\'require\''): self.sgc.translate(seq, start='require') def test_translate_start_with_start_codon(self): # trim before start codon, replace with M. ensure alternative start # codons following the start codon aren't replaced with M. ensure # default behavior for handling stop codons is retained seq = RNA('CAUUUGCUGAAAUGA') exp = Protein('MLK*') for start in {'require', 'optional'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) # ignore start codon replacement and trimming; just translate exp = Protein('HLLK*') obs = self.sgc.translate(seq, start='ignore') self.assertEqual(obs, exp) # just a start codon, no replacement necessary seq = RNA('AUG') exp = Protein('M') for start in {'require', 'optional', 'ignore'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) # single alternative start codon seq = RNA('CUG') exp = Protein('M') for start in {'require', 'optional'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) exp = Protein('L') obs = self.sgc.translate(seq, start='ignore') self.assertEqual(obs, exp) def test_translate_start_no_start_codon(self): seq = RNA('CAACAACAGCAA') exp = Protein('QQQQ') for start in {'ignore', 'optional'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*start=\'require\''): self.sgc.translate(seq, start='require') # non-start codon that translates to an AA that start codons also map # to. should catch bug if code attempts to search and trim *after* # translation -- this must happen *before* translation seq = RNA('UUACAA') exp = Protein('LQ') for start in {'ignore', 'optional'}: obs = self.sgc.translate(seq, start=start) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*start=\'require\''): self.sgc.translate(seq, start='require') def test_translate_start_no_accidental_mutation(self): # `start` mutates a vector in-place that is derived from # GeneticCode._offset_table. the current code doesn't perform an # explicit copy because numpy's advanced indexing is used, which always # returns a copy. test this assumption here in case that behavior # changes in the future offset_table = self.sgc._offset_table.copy() seq = RNA('CAUUUGCUGAAAUGA') obs = self.sgc.translate(seq, start='require') self.assertEqual(obs, Protein('MLK*')) npt.assert_array_equal(self.sgc._offset_table, offset_table) def test_translate_stop_empty_translation(self): exp = Protein('') for seq in RNA(''), RNA('A'), RNA('AU'): for stop in {'optional', 'ignore'}: obs = self.sgc.translate(seq, stop=stop) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*stop=\'require\''): self.sgc.translate(seq, stop='require') def test_translate_stop_with_stop_codon(self): # multiple stop codons with trailing codons seq = RNA('UGGACUUGAUAUCGUUAGGAU') exp = Protein('WT') for stop in {'require', 'optional'}: obs = self.sgc.translate(seq, stop=stop) self.assertEqual(obs, exp) # ignore stop codon trimming; just translate exp = Protein('WT*YR*D') obs = self.sgc.translate(seq, stop='ignore') self.assertEqual(obs, exp) # ends with single stop codon seq = RNA('UGUCUGUAA') exp = Protein('CL') for stop in {'require', 'optional'}: obs = self.sgc.translate(seq, stop=stop) self.assertEqual(obs, exp) exp = Protein('CL*') obs = self.sgc.translate(seq, stop='ignore') self.assertEqual(obs, exp) # just a stop codon seq = RNA('UAG') exp = Protein('') for stop in {'require', 'optional'}: obs = self.sgc.translate(seq, stop=stop) self.assertEqual(obs, exp) exp = Protein('*') obs = self.sgc.translate(seq, stop='ignore') self.assertEqual(obs, exp) def test_translate_stop_no_stop_codon(self): seq = RNA('GAAUCU') exp = Protein('ES') for stop in {'ignore', 'optional'}: obs = self.sgc.translate(seq, stop=stop) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*stop=\'require\''): self.sgc.translate(seq, stop='require') def test_translate_trim_to_cds(self): seq = RNA('UAAUUGCCUCAUUAAUAACAAUGA') # find first start codon, trim all before it, convert alternative start # codon to M, finally trim to first stop codon following the start # codon exp = Protein('MPH') for param in {'require', 'optional'}: obs = self.sgc.translate(seq, start=param, stop=param) self.assertEqual(obs, exp) exp = Protein('*LPH**Q*') obs = self.sgc.translate(seq, start='ignore', stop='ignore') self.assertEqual(obs, exp) # alternative reading frame disrupts cds: # AAUUGCCUCAUUAAUAACAAUGA # NCLINNN with self.assertRaisesRegex(ValueError, r'reading_frame=2.*start=\'require\''): self.sgc.translate(seq, reading_frame=2, start='require') with self.assertRaisesRegex(ValueError, r'reading_frame=2.*stop=\'require\''): self.sgc.translate(seq, reading_frame=2, stop='require') exp = Protein('NCLINNN') for param in {'ignore', 'optional'}: obs = self.sgc.translate(seq, reading_frame=2, start=param, stop=param) self.assertEqual(obs, exp) def test_translate_invalid_input(self): # invalid sequence type with self.assertRaisesRegex(TypeError, r'RNA.*DNA'): self.sgc.translate(DNA('ACG')) with self.assertRaisesRegex(TypeError, r'RNA.*str'): self.sgc.translate('ACG') # invalid reading frame with self.assertRaisesRegex(ValueError, r'\[1, 2, 3, -1, -2, -3\].*0'): self.sgc.translate(RNA('AUG'), reading_frame=0) # invalid start with self.assertRaisesRegex(ValueError, r'start.*foo'): self.sgc.translate(RNA('AUG'), start='foo') # invalid stop with self.assertRaisesRegex(ValueError, r'stop.*foo'): self.sgc.translate(RNA('AUG'), stop='foo') # gapped sequence with self.assertRaisesRegex(ValueError, r'gapped'): self.sgc.translate(RNA('UU-G')) # degenerate sequence with self.assertRaisesRegex(NotImplementedError, r'degenerate'): self.sgc.translate(RNA('RUG')) def test_translate_varied_genetic_codes(self): # spot check using a few NCBI and custom genetic codes to translate seq = RNA('AAUGAUGUGACUAUCAGAAGG') # table_id=2 exp = Protein('NDVTI**') obs = GeneticCode.from_ncbi(2).translate(seq) self.assertEqual(obs, exp) exp = Protein('MTI') obs = GeneticCode.from_ncbi(2).translate(seq, start='require', stop='require') self.assertEqual(obs, exp) # table_id=22 exp = Protein('NDVTIRR') obs = GeneticCode.from_ncbi(22).translate(seq) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*start=\'require\''): GeneticCode.from_ncbi(22).translate(seq, start='require', stop='require') # custom, no start codons gc = GeneticCode('MWN*' * 16, '-' * 64) exp = Protein('MM*MWN*') obs = gc.translate(seq) self.assertEqual(obs, exp) with self.assertRaisesRegex(ValueError, r'reading_frame=1.*start=\'require\''): gc.translate(seq, start='require', stop='require') def test_translate_six_frames(self): seq = RNA('AUGCUAACAUAAA') # rc = UUUAUGUUAGCAU # test default behavior exp = [Protein('MLT*'), Protein('C*HK'), Protein('ANI'), Protein('FMLA'), Protein('LC*H'), Protein('YVS')] obs = list(self.sgc.translate_six_frames(seq)) self.assertEqual(obs, exp) # test that start/stop are respected exp = [Protein('MLT'), Protein('C'), Protein('ANI'), Protein('MLA'), Protein('LC'), Protein('YVS')] obs = list(self.sgc.translate_six_frames(seq, start='optional', stop='optional')) self.assertEqual(obs, exp) def test_translate_six_frames_preserves_metadata(self): seq = RNA('AUG', metadata={'foo': 'bar', 'baz': 42}, positional_metadata={'foo': range(3)}) obs = list(self.sgc.translate_six_frames(seq))[:2] # metadata retained, positional metadata dropped self.assertEqual( obs, [Protein('M', metadata={'foo': 'bar', 'baz': 42}), Protein('', metadata={'foo': 'bar', 'baz': 42})]) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_grammared_sequence.py000066400000000000000000000647031446255456000251300ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas as pd from skbio.sequence import GrammaredSequence from skbio.util import classproperty from skbio.util import assert_data_frame_almost_equal from skbio.metadata import IntervalMetadata class ExampleGrammaredSequence(GrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("AB"), "Y": set("BC"), "Z": set("AC")} @classproperty def definite_chars(cls): return set("ABC") @classproperty def default_gap_char(cls): return '-' @classproperty def gap_chars(cls): return set('-.') class ExampleMotifsTester(ExampleGrammaredSequence): @property def _motifs(self): # These aren't really motifs, just a way to excercise the code paths return { "name1": lambda x, _, __: str(x), "name2": lambda x, _, __: len(x) } class TestGrammaredSequence(TestCase): def test_default_gap_must_be_in_gap_chars(self): with self.assertRaisesRegex( TypeError, r"default_gap_char must be in gap_chars for class " "GrammaredSequenceInvalidDefaultGap"): class GrammaredSequenceInvalidDefaultGap(ExampleGrammaredSequence): @classproperty def default_gap_char(cls): return '*' def test_degenerates_must_expand_to_valid_definites(self): with self.assertRaisesRegex( TypeError, r"degenerate_map must expand only to characters included in " "definite_chars for class " "GrammaredSequenceInvalidDefaultGap"): class GrammaredSequenceInvalidDefaultGap(ExampleGrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("B")} @classproperty def definite_chars(cls): return set("A") def test_gap_chars_and_degenerates_share(self): with self.assertRaisesRegex( TypeError, r"gap_chars and degenerate_chars must not share any characters" " for class GrammaredSequenceGapInDegenerateMap"): class GrammaredSequenceGapInDegenerateMap( ExampleGrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("AB")} @classproperty def definite_chars(cls): return set("ABC") @classproperty def gap_chars(cls): return set(".-X") def test_gap_chars_and_definites_share(self): with self.assertRaisesRegex( TypeError, (r"gap_chars and definite_chars must not share any characters " "for class GrammaredSequenceGapInDefiniteMap")): class GrammaredSequenceGapInDefiniteMap( ExampleGrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("AB")} @classproperty def definite_chars(cls): return set("ABC") @classproperty def gap_chars(cls): return set(".-A") def test_degenerates_and_definites_share(self): with self.assertRaisesRegex( TypeError, (r"degenerate_chars and definite_chars must not share any " "characters for class GrammaredSequenceInvalid")): class GrammaredSequenceInvalid(ExampleGrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("AB")} @classproperty def definite_chars(cls): return set("ABCX") def test_instantiation_with_no_implementation(self): class GrammaredSequenceSubclassNoImplementation(GrammaredSequence): pass with self.assertRaises(TypeError) as cm: GrammaredSequenceSubclassNoImplementation() self.assertIn("abstract class", str(cm.exception)) self.assertIn("definite_chars", str(cm.exception)) self.assertIn("degenerate_map", str(cm.exception)) def test_init_default_parameters(self): seq = ExampleGrammaredSequence('.-ABCXYZ') npt.assert_equal(seq.values, np.array('.-ABCXYZ', dtype='c')) self.assertEqual(seq.metadata, {}) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame(index=range(8))) self.assertEqual(seq.interval_metadata, IntervalMetadata(8)) def test_init_nondefault_parameters(self): im = IntervalMetadata(8) im.add([(1, 8)], metadata={'gene': 'p53'}) seq = ExampleGrammaredSequence( '.-ABCXYZ', metadata={'id': 'foo'}, positional_metadata={'quality': range(8)}, interval_metadata=im) npt.assert_equal(seq.values, np.array('.-ABCXYZ', dtype='c')) self.assertEqual(seq.metadata, {'id': 'foo'}) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame({'quality': range(8)})) self.assertEqual(seq.interval_metadata, im) def test_init_valid_empty_sequence(self): # just make sure we can instantiate an empty sequence regardless of # `validate` and `lowercase` parameters. more extensive tests # are performed in Sequence base class unit tests for validate in (True, False): for lowercase in (True, False): seq = ExampleGrammaredSequence( '', validate=validate, lowercase=lowercase) self.assertEqual(seq, ExampleGrammaredSequence('')) def test_init_valid_single_character_sequence(self): for validate in (True, False): for lowercase in (True, False): seq = ExampleGrammaredSequence( 'C', validate=validate, lowercase=lowercase) self.assertEqual(seq, ExampleGrammaredSequence('C')) def test_init_valid_multiple_character_sequence(self): for validate in (True, False): for lowercase in (True, False): seq = ExampleGrammaredSequence( 'BAACB.XYY-AZ', validate=validate, lowercase=lowercase) self.assertEqual(seq, ExampleGrammaredSequence('BAACB.XYY-AZ')) def test_init_validate_parameter_single_character(self): seq = 'w' with self.assertRaisesRegex(ValueError, r"character.*'w'"): ExampleGrammaredSequence(seq) # test that we can instantiate an invalid sequence. we don't guarantee # anything working beyond instantiation ExampleGrammaredSequence(seq, validate=False) def test_init_validate_parameter_multiple_characters(self): # mix of valid and invalid characters with repeats and lowercased # alphabet characters seq = 'CBCBBbawCbbwBXYZ-.x' with self.assertRaisesRegex(ValueError, r"\['a', 'b', 'w', 'x'\]"): ExampleGrammaredSequence(seq) ExampleGrammaredSequence(seq, validate=False) def test_init_lowercase_all_lowercase(self): s = 'cbcbbbazcbbzbxyz-.x' with self.assertRaisesRegex(ValueError, r"\['a', 'b', 'c', 'x', 'y', 'z'\]"): ExampleGrammaredSequence(s) seq = ExampleGrammaredSequence(s, lowercase=True) self.assertEqual(seq, ExampleGrammaredSequence('CBCBBBAZCBBZBXYZ-.X')) def test_init_lowercase_mixed_case(self): s = 'CBCBBbazCbbzBXYZ-.x' with self.assertRaisesRegex(ValueError, r"\['a', 'b', 'x', 'z'\]"): ExampleGrammaredSequence(s) seq = ExampleGrammaredSequence(s, lowercase=True) self.assertEqual(seq, ExampleGrammaredSequence('CBCBBBAZCBBZBXYZ-.X')) def test_init_lowercase_no_validation(self): s = 'car' with self.assertRaisesRegex(ValueError, r"\['a', 'c', 'r'\]"): ExampleGrammaredSequence(s) with self.assertRaisesRegex(ValueError, r"character.*'R'"): ExampleGrammaredSequence(s, lowercase=True) ExampleGrammaredSequence(s, lowercase=True, validate=False) def test_init_lowercase_byte_ownership(self): bytes = np.array([97, 98, 97], dtype=np.uint8) with self.assertRaisesRegex(ValueError, r"\['a', 'b'\]"): ExampleGrammaredSequence(bytes) seq = ExampleGrammaredSequence(bytes, lowercase=True) self.assertEqual(seq, ExampleGrammaredSequence('ABA')) # should not share the same memory self.assertIsNot(seq._bytes, bytes) # we should have copied `bytes` before modifying in place to convert to # upper. make sure `bytes` hasn't been mutated npt.assert_equal(bytes, np.array([97, 98, 97], dtype=np.uint8)) def test_init_lowercase_invalid_keys(self): for invalid_key in ((), [], 2): invalid_type = type(invalid_key) with self.assertRaisesRegex(TypeError, r"lowercase keyword argument expected " "a bool or string, but got %s" % invalid_type): ExampleGrammaredSequence('ACGTacgt', lowercase=invalid_key) def test_degenerate_chars(self): expected = set("XYZ") self.assertIs(type(ExampleGrammaredSequence.degenerate_chars), set) self.assertEqual(ExampleGrammaredSequence.degenerate_chars, expected) ExampleGrammaredSequence.degenerate_chars.add("W") self.assertEqual(ExampleGrammaredSequence.degenerate_chars, expected) self.assertEqual(ExampleGrammaredSequence('').degenerate_chars, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').degenerate_chars = set("BAR") # TODO: duplicate of test_definite_chars, remove when nondegenerate_chars, # is removed def test_nondegenerate_chars(self): expected = set("ABC") self.assertEqual(ExampleGrammaredSequence.nondegenerate_chars, expected) ExampleGrammaredSequence.degenerate_chars.add("D") self.assertEqual(ExampleGrammaredSequence.nondegenerate_chars, expected) self.assertEqual(ExampleGrammaredSequence('').nondegenerate_chars, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').nondegenerate_chars = set("BAR") def test_definite_chars(self): expected = set("ABC") self.assertEqual(ExampleGrammaredSequence.definite_chars, expected) ExampleGrammaredSequence.degenerate_chars.add("D") self.assertEqual(ExampleGrammaredSequence.definite_chars, expected) self.assertEqual(ExampleGrammaredSequence('').definite_chars, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').definite_chars = set("BAR") def test_gap_chars(self): expected = set(".-") self.assertIs(type(ExampleGrammaredSequence.gap_chars), set) self.assertEqual(ExampleGrammaredSequence.gap_chars, expected) ExampleGrammaredSequence.gap_chars.add("_") self.assertEqual(ExampleGrammaredSequence.gap_chars, expected) self.assertEqual(ExampleGrammaredSequence('').gap_chars, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').gap_chars = set("_ =") def test_default_gap_char(self): self.assertIs(type(ExampleGrammaredSequence.default_gap_char), str) self.assertEqual(ExampleGrammaredSequence.default_gap_char, '-') self.assertEqual(ExampleGrammaredSequence('').default_gap_char, '-') with self.assertRaises(AttributeError): ExampleGrammaredSequence('').default_gap_char = '.' def test_alphabet(self): expected = set("ABC.-XYZ") self.assertIs(type(ExampleGrammaredSequence.alphabet), set) self.assertEqual(ExampleGrammaredSequence.alphabet, expected) ExampleGrammaredSequence.alphabet.add("DEF") self.assertEqual(ExampleGrammaredSequence.alphabet, expected) self.assertEqual(ExampleGrammaredSequence('').alphabet, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').alphabet = set("ABCDEFG.-WXYZ") def test_degenerate_map(self): expected = {"X": set("AB"), "Y": set("BC"), "Z": set("AC")} self.assertEqual(ExampleGrammaredSequence.degenerate_map, expected) ExampleGrammaredSequence.degenerate_map['W'] = set("ABC") ExampleGrammaredSequence.degenerate_map['X'] = set("CA") self.assertEqual(ExampleGrammaredSequence.degenerate_map, expected) self.assertEqual(ExampleGrammaredSequence('').degenerate_map, expected) with self.assertRaises(AttributeError): ExampleGrammaredSequence('').degenerate_map = {'W': "ABC"} def test_gaps(self): self.assertIs(type(ExampleGrammaredSequence("").gaps()), np.ndarray) self.assertIs(ExampleGrammaredSequence("").gaps().dtype, np.dtype('bool')) npt.assert_equal(ExampleGrammaredSequence("ABCXBZYABC").gaps(), np.zeros(10).astype(bool)) npt.assert_equal(ExampleGrammaredSequence(".-.-.").gaps(), np.ones(5).astype(bool)) npt.assert_equal(ExampleGrammaredSequence("A.B-C.X-Y.").gaps(), np.array([0, 1] * 5, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("AB.AC.XY-").gaps(), np.array([0, 0, 1] * 3, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("A.BC.-").gaps(), np.array([0, 1, 0, 0, 1, 1], dtype=bool)) def test_has_gaps(self): self.assertIs(type(ExampleGrammaredSequence("").has_gaps()), bool) self.assertIs(type(ExampleGrammaredSequence("-").has_gaps()), bool) self.assertFalse(ExampleGrammaredSequence("").has_gaps()) self.assertFalse(ExampleGrammaredSequence("ABCXYZ").has_gaps()) self.assertTrue(ExampleGrammaredSequence("-").has_gaps()) self.assertTrue(ExampleGrammaredSequence("ABCXYZ-").has_gaps()) def test_degenerates(self): self.assertIs(type(ExampleGrammaredSequence("").degenerates()), np.ndarray) self.assertIs(ExampleGrammaredSequence("").degenerates().dtype, np.dtype('bool')) npt.assert_equal(ExampleGrammaredSequence("ABCBC-.AB.").degenerates(), np.zeros(10).astype(bool)) npt.assert_equal(ExampleGrammaredSequence("ZYZYZ").degenerates(), np.ones(5).astype(bool)) npt.assert_equal(ExampleGrammaredSequence("AX.Y-ZBXCZ").degenerates(), np.array([0, 1] * 5, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("ABXACY.-Z").degenerates(), np.array([0, 0, 1] * 3, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("AZBCXY").degenerates(), np.array([0, 1, 0, 0, 1, 1], dtype=bool)) def test_has_degenerates(self): self.assertIs(type(ExampleGrammaredSequence("").has_degenerates()), bool) self.assertIs(type(ExampleGrammaredSequence("X").has_degenerates()), bool) self.assertFalse(ExampleGrammaredSequence("").has_degenerates()) self.assertFalse(ExampleGrammaredSequence("A-.BC").has_degenerates()) self.assertTrue(ExampleGrammaredSequence("Z").has_degenerates()) self.assertTrue(ExampleGrammaredSequence("ABC.XYZ-").has_degenerates()) # TODO: duplicate of test_definites; remove when nondegenerates is removed def test_nondegenerates(self): self.assertIs(type(ExampleGrammaredSequence("").nondegenerates()), np.ndarray) self.assertIs(ExampleGrammaredSequence("").nondegenerates().dtype, np.dtype('bool')) npt.assert_equal( ExampleGrammaredSequence("XYZYZ-.XY.").nondegenerates(), np.zeros(10).astype(bool)) npt.assert_equal(ExampleGrammaredSequence("ABABA").nondegenerates(), np.ones(5).astype(bool)) npt.assert_equal( ExampleGrammaredSequence("XA.B-AZCXA").nondegenerates(), np.array([0, 1] * 5, dtype=bool)) npt.assert_equal( ExampleGrammaredSequence("XXAZZB.-C").nondegenerates(), np.array([0, 0, 1] * 3, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("YB.-AC").nondegenerates(), np.array([0, 1, 0, 0, 1, 1], dtype=bool)) def test_definites(self): self.assertIs(type(ExampleGrammaredSequence("").definites()), np.ndarray) self.assertIs(ExampleGrammaredSequence("").definites().dtype, np.dtype('bool')) npt.assert_equal( ExampleGrammaredSequence("XYZYZ-.XY.").definites(), np.zeros(10).astype(bool)) npt.assert_equal(ExampleGrammaredSequence("ABABA").definites(), np.ones(5).astype(bool)) npt.assert_equal( ExampleGrammaredSequence("XA.B-AZCXA").definites(), np.array([0, 1] * 5, dtype=bool)) npt.assert_equal( ExampleGrammaredSequence("XXAZZB.-C").definites(), np.array([0, 0, 1] * 3, dtype=bool)) npt.assert_equal(ExampleGrammaredSequence("YB.-AC").definites(), np.array([0, 1, 0, 0, 1, 1], dtype=bool)) # TODO: duplicate of test_has_definites; remove when has_nondegenerates is # removed. def test_has_nondegenerates(self): self.assertIs(type(ExampleGrammaredSequence("").has_nondegenerates()), bool) self.assertIs(type(ExampleGrammaredSequence("A").has_nondegenerates()), bool) self.assertFalse(ExampleGrammaredSequence("").has_nondegenerates()) self.assertFalse( ExampleGrammaredSequence("X-.YZ").has_nondegenerates()) self.assertTrue(ExampleGrammaredSequence("C").has_nondegenerates()) self.assertTrue( ExampleGrammaredSequence(".XYZ-ABC").has_nondegenerates()) def test_has_definites(self): self.assertIs(type(ExampleGrammaredSequence("").has_definites()), bool) self.assertIs(type(ExampleGrammaredSequence("A").has_definites()), bool) self.assertFalse(ExampleGrammaredSequence("").has_definites()) self.assertFalse( ExampleGrammaredSequence("X-.YZ").has_definites()) self.assertTrue(ExampleGrammaredSequence("C").has_definites()) self.assertTrue( ExampleGrammaredSequence(".XYZ-ABC").has_definites()) def test_degap(self): kw = { 'metadata': { 'id': 'some_id', 'description': 'some description', }, } self.assertEqual( ExampleGrammaredSequence( "", positional_metadata={'qual': []}, **kw).degap(), ExampleGrammaredSequence( "", positional_metadata={'qual': []}, **kw)) self.assertEqual( ExampleGrammaredSequence( "ABCXYZ", positional_metadata={'qual': np.arange(6)}, **kw).degap(), ExampleGrammaredSequence( "ABCXYZ", positional_metadata={'qual': np.arange(6)}, **kw)) self.assertEqual( ExampleGrammaredSequence( "ABC-XYZ", positional_metadata={'qual': np.arange(7)}, **kw).degap(), ExampleGrammaredSequence( "ABCXYZ", positional_metadata={'qual': [0, 1, 2, 4, 5, 6]}, **kw)) self.assertEqual( ExampleGrammaredSequence( ".-ABC-XYZ.", positional_metadata={'qual': np.arange(10)}, **kw).degap(), ExampleGrammaredSequence( "ABCXYZ", positional_metadata={'qual': [2, 3, 4, 6, 7, 8]}, **kw)) self.assertEqual( ExampleGrammaredSequence( "---.-.-.-.-.", positional_metadata={'quality': np.arange(12)}, **kw).degap(), ExampleGrammaredSequence( "", positional_metadata={'quality': np.array([], dtype=np.int64)}, **kw)) def test_expand_degenerates_no_degens(self): seq = ExampleGrammaredSequence("ABCABCABC") self.assertEqual(list(seq.expand_degenerates()), [seq]) def test_expand_degenerates_all_degens(self): exp = [ ExampleGrammaredSequence('ABA'), ExampleGrammaredSequence('ABC'), ExampleGrammaredSequence('ACA'), ExampleGrammaredSequence('ACC'), ExampleGrammaredSequence('BBA'), ExampleGrammaredSequence('BBC'), ExampleGrammaredSequence('BCA'), ExampleGrammaredSequence('BCC') ] # Sort based on sequence string, as order is not guaranteed. obs = sorted(ExampleGrammaredSequence('XYZ').expand_degenerates(), key=str) self.assertEqual(obs, exp) def test_expand_degenerates_with_metadata(self): kw = { "metadata": { "id": "some_id", "description": "some description" }, "positional_metadata": { "quality": np.arange(3), }, } exp = [ExampleGrammaredSequence('ABA', **kw), ExampleGrammaredSequence('ABC', **kw), ExampleGrammaredSequence('BBA', **kw), ExampleGrammaredSequence('BBC', **kw)] obs = sorted( ExampleGrammaredSequence('XBZ', **kw).expand_degenerates(), key=str) self.assertEqual(obs, exp) def test_to_regex_no_degens(self): seq = ExampleGrammaredSequence('ABC') regex = seq.to_regex() self.assertEqual(regex.pattern, str(seq)) def test_to_regex_with_degens(self): seq = ExampleGrammaredSequence('AYZ') regex = seq.to_regex() self.assertFalse(any(regex.match(s) is None for s in 'ABA ABC ACA ACC'.split())) self.assertTrue(all(regex.match(s) is None for s in 'CBA BBA ABB AAA'.split())) def test_to_regex_within_capture(self): seq = ExampleGrammaredSequence('XYC') regex = seq.to_regex(within_capture=True) for ref in 'ABA BBB CCA'.split(): self.assertFalse(any(len(match.groups()) == 1 for match in regex.finditer(ref))) for ref in 'ABC BBC ACC'.split(): self.assertTrue(all(len(match.groups()) == 1 for match in regex.finditer(ref))) def test_find_motifs_no_motif(self): seq = ExampleMotifsTester("ABCABCABC") with self.assertRaises(ValueError) as cm: seq.find_motifs("doesn't-exist") self.assertIn("doesn't-exist", str(cm.exception)) seq = ExampleGrammaredSequence("ABCABCABC") with self.assertRaises(ValueError) as cm: seq.find_motifs("doesn't-exist") self.assertIn("doesn't-exist", str(cm.exception)) def test_find_motifs(self): seq = ExampleMotifsTester("ABC") self.assertEqual(seq.find_motifs("name1"), "ABC") self.assertEqual(seq.find_motifs("name2"), 3) def test_repr(self): # basic sanity checks for custom repr stats. more extensive testing is # performed on Sequence.__repr__ # minimal obs = repr(ExampleGrammaredSequence('')) self.assertEqual(obs.count('\n'), 7) self.assertTrue(obs.startswith('ExampleGrammaredSequence')) self.assertIn('length: 0', obs) self.assertIn('has gaps: False', obs) self.assertIn('has degenerates: False', obs) self.assertIn('has definites: False', obs) self.assertTrue(obs.endswith('-')) # no metadata, mix of gaps, degenerates, and definites obs = repr(ExampleGrammaredSequence('AY-B')) self.assertEqual(obs.count('\n'), 8) self.assertTrue(obs.startswith('ExampleGrammaredSequence')) self.assertIn('length: 4', obs) self.assertIn('has gaps: True', obs) self.assertIn('has degenerates: True', obs) self.assertIn('has definites: True', obs) self.assertTrue(obs.endswith('0 AY-B')) # metadata and positional metadata of mixed types obs = repr( ExampleGrammaredSequence( 'ABCA', metadata={'foo': 42, b'bar': 33.33, None: True, False: {}, (1, 2): 3, 'acb' * 100: "'"}, positional_metadata={'foo': range(4), 42: ['a', 'b', [], 'c']})) self.assertEqual(obs.count('\n'), 18) self.assertTrue(obs.startswith('ExampleGrammaredSequence')) self.assertIn('None: True', obs) self.assertIn('\'foo\': 42', obs) self.assertIn('42: ', obs) self.assertIn('\'foo\': ', obs) self.assertIn('length: 4', obs) self.assertIn('has gaps: False', obs) self.assertIn('has degenerates: False', obs) self.assertIn('has definites: True', obs) self.assertTrue(obs.endswith('0 ABCA')) # sequence spanning > 5 lines obs = repr(ExampleGrammaredSequence('A' * 301)) self.assertEqual(obs.count('\n'), 12) self.assertTrue(obs.startswith('ExampleGrammaredSequence')) self.assertIn('length: 301', obs) self.assertIn('has gaps: False', obs) self.assertIn('has degenerates: False', obs) self.assertIn('has definites: True', obs) self.assertIn('...', obs) self.assertTrue(obs.endswith('300 A')) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/sequence/tests/test_nucleotide_sequences.py000066400000000000000000000513771446255456000255120ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy as np from skbio import DNA, RNA, Protein, GeneticCode from skbio.sequence._nucleotide_mixin import NucleotideMixin from skbio.sequence import GrammaredSequence from skbio.util import classproperty from skbio.metadata import IntervalMetadata # This file contains tests for functionality of sequence types which implement # NucleotideMixin. Currently this means DNA and RNA. These types are so # similar that the testing logic can be shared and parameterized across # different test data. class TestNucleotideSequence(unittest.TestCase): def setUp(self): self.sequence_kinds = frozenset([ str, lambda s: np.frombuffer(s.encode('ascii'), dtype='|S1'), lambda s: np.frombuffer(s.encode('ascii'), dtype=np.uint8)]) dna_str = 'ACGTMRWSYKVHDBN.-' dna_comp_str = 'TGCAKYWSRMBDHVN.-' dna_rev_comp_str = '-.NVHDBMRSWYKACGT' rna_str = 'ACGUMRWSYKVHDBN.-' rna_comp_str = 'UGCAKYWSRMBDHVN.-' rna_rev_comp_str = '-.NVHDBMRSWYKACGU' qual = tuple(range(len(dna_str))) self.dna = (DNA, dna_str) self.rna = (RNA, rna_str) dna_comp = self.dna + (dna_comp_str,) rna_comp = self.rna + (rna_comp_str,) dna_comp_qual = dna_comp + (qual,) rna_comp_qual = rna_comp + (qual,) self.all_combos_comp_qual = (dna_comp_qual, rna_comp_qual) dna_rev_comp = self.dna + (dna_rev_comp_str,) rna_rev_comp = self.rna + (rna_rev_comp_str,) self.all_combos_rev_comp = (dna_rev_comp, rna_rev_comp) dna_rev_comp_qual = dna_rev_comp + (qual,) rna_rev_comp_qual = rna_rev_comp + (qual,) self.all_combos_rev_comp_qual = \ (dna_rev_comp_qual, rna_rev_comp_qual) def test_instantiation_with_no_implementation(self): class NucleotideSequenceSubclassNoImplementation(NucleotideMixin): pass with self.assertRaises(TypeError) as cm: NucleotideSequenceSubclassNoImplementation() self.assertIn("abstract class", str(cm.exception)) self.assertIn("complement_map", str(cm.exception)) # TODO: remove when nondegenerate_chars is removed def test_nondegenerate_chars(self): dna = (DNA, "ACGT") rna = (RNA, "ACGU") for constructor, nondegenerate in (dna, rna): exp = set(nondegenerate) self.assertEqual(constructor('').nondegenerate_chars, exp) self.assertEqual(constructor.nondegenerate_chars, exp) def test_definite_chars(self): dna = (DNA, "ACGT") rna = (RNA, "ACGU") for constructor, definite_char in (dna, rna): exp = set(definite_char) self.assertEqual(constructor('').definite_chars, exp) self.assertEqual(constructor.definite_chars, exp) def test_degenerate_map(self): dna_exp = (DNA, { 'B': set(['C', 'T', 'G']), 'D': set(['A', 'T', 'G']), 'H': set(['A', 'C', 'T']), 'K': set(['T', 'G']), 'M': set(['A', 'C']), 'N': set(['A', 'C', 'T', 'G']), 'S': set(['C', 'G']), 'R': set(['A', 'G']), 'W': set(['A', 'T']), 'V': set(['A', 'C', 'G']), 'Y': set(['C', 'T']) }) rna_exp = (RNA, { 'B': set(['C', 'U', 'G']), 'D': set(['A', 'U', 'G']), 'H': set(['A', 'C', 'U']), 'K': set(['U', 'G']), 'M': set(['A', 'C']), 'N': set(['A', 'C', 'U', 'G']), 'S': set(['C', 'G']), 'R': set(['A', 'G']), 'W': set(['A', 'U']), 'V': set(['A', 'C', 'G']), 'Y': set(['C', 'U']) }) for constructor, degenerate in (dna_exp, rna_exp): self.assertEqual(constructor('').degenerate_map, degenerate) self.assertEqual(constructor.degenerate_map, degenerate) def test_complement_map(self): dna_exp = (DNA, { '-': '-', '.': '.', 'A': 'T', 'C': 'G', 'B': 'V', 'D': 'H', 'G': 'C', 'H': 'D', 'K': 'M', 'M': 'K', 'N': 'N', 'S': 'S', 'R': 'Y', 'T': 'A', 'W': 'W', 'V': 'B', 'Y': 'R' }) rna_exp = (RNA, { '-': '-', '.': '.', 'A': 'U', 'C': 'G', 'B': 'V', 'D': 'H', 'G': 'C', 'H': 'D', 'K': 'M', 'M': 'K', 'N': 'N', 'S': 'S', 'R': 'Y', 'U': 'A', 'W': 'W', 'V': 'B', 'Y': 'R' }) for constructor, comp_map in (dna_exp, rna_exp): self.assertEqual(constructor('').complement_map, comp_map) self.assertEqual(constructor.complement_map, comp_map) # immutable constructor.complement_map['A'] = 'X' constructor.complement_map['C'] = 'W' self.assertEqual(constructor.complement_map, comp_map) with self.assertRaises(AttributeError): constructor('').complement_map = {'W': 'X'} def test_translate_ncbi_table_id(self): for seq in RNA('AAAUUUAUGCAU'), DNA('AAATTTATGCAT'): # default obs = seq.translate() self.assertEqual(obs, Protein('KFMH')) obs = seq.translate(9) self.assertEqual(obs, Protein('NFMH')) def test_translate_genetic_code_object(self): gc = GeneticCode('M' * 64, '-' * 64) for seq in RNA('AAAUUUAUGCAU'), DNA('AAATTTATGCAT'): obs = seq.translate(gc) self.assertEqual(obs, Protein('MMMM')) def test_translate_passes_parameters_through(self): exp = Protein('MW') for seq in RNA('UAAAUUGUGGUAA'), DNA('TAAATTGTGGTAA'): # mix of args and kwargs obs = seq.translate(13, reading_frame=2, start='require', stop='require') self.assertEqual(obs, exp) # kwargs only obs = seq.translate(genetic_code=13, reading_frame=2, start='require', stop='require') self.assertEqual(obs, exp) # args only obs = seq.translate(13, 2, 'require', 'require') self.assertEqual(obs, exp) def test_translate_preserves_metadata(self): metadata = {'foo': 'bar', 'baz': 42} positional_metadata = {'foo': range(3)} for seq in (RNA('AUG', metadata=metadata, positional_metadata=positional_metadata), DNA('ATG', metadata=metadata, positional_metadata=positional_metadata)): obs = seq.translate() # metadata retained, positional metadata dropped self.assertEqual(obs, Protein('M', metadata={'foo': 'bar', 'baz': 42})) def test_translate_invalid_id(self): for seq in RNA('AUG'), DNA('ATG'): with self.assertRaisesRegex(ValueError, r'table_id.*42'): seq.translate(42) def test_translate_six_frames_ncbi_table_id(self): # rc = CAAUUU for seq in RNA('AAAUUG'), DNA('AAATTG'): # default obs = list(seq.translate_six_frames()) self.assertEqual(obs, [Protein('KL'), Protein('N'), Protein('I'), Protein('QF'), Protein('N'), Protein('I')]) obs = list(seq.translate_six_frames(9)) self.assertEqual(obs, [Protein('NL'), Protein('N'), Protein('I'), Protein('QF'), Protein('N'), Protein('I')]) def test_translate_six_frames_genetic_code_object(self): gc = GeneticCode('M' * 64, '-' * 64) for seq in RNA('AAAUUG'), DNA('AAATTG'): obs = list(seq.translate_six_frames(gc)) self.assertEqual(obs, [Protein('MM'), Protein('M'), Protein('M'), Protein('MM'), Protein('M'), Protein('M')]) def test_translate_six_frames_passes_parameters_through(self): for seq in RNA('UUUAUGUGGUGA'), DNA('TTTATGTGGTGA'): # mix of args and kwargs obs = next(seq.translate_six_frames(11, start='require', stop='require')) self.assertEqual(obs, Protein('MW')) # kwargs only obs = next(seq.translate_six_frames(genetic_code=11, start='require', stop='require')) self.assertEqual(obs, Protein('MW')) # args only obs = next(seq.translate_six_frames(11, 'require', 'require')) self.assertEqual(obs, Protein('MW')) def test_translate_six_frames_preserves_metadata(self): metadata = {'foo': 'bar', 'baz': 42} positional_metadata = {'foo': range(3)} for seq in (RNA('AUG', metadata=metadata, positional_metadata=positional_metadata), DNA('ATG', metadata=metadata, positional_metadata=positional_metadata)): obs = list(seq.translate_six_frames())[:2] # metadata retained, positional metadata dropped self.assertEqual( obs, [Protein('M', metadata={'foo': 'bar', 'baz': 42}), Protein('', metadata={'foo': 'bar', 'baz': 42})]) def test_translate_six_frames_invalid_id(self): for seq in RNA('AUG'), DNA('ATG'): with self.assertRaisesRegex(ValueError, r'table_id.*42'): seq.translate_six_frames(42) def test_repr(self): # basic sanity checks for custom repr stats. more extensive testing is # performed on Sequence.__repr__ for seq in DNA(''), RNA(''): obs = repr(seq) # obtained from super() self.assertIn('has gaps: False', obs) # custom to Protein self.assertIn('GC-content: 0.00%', obs) for seq in DNA('ACGT'), RNA('ACGU'): obs = repr(seq) self.assertIn('has gaps: False', obs) self.assertIn('GC-content: 50.00%', obs) for seq in DNA('CST'), RNA('CSU'): obs = repr(seq) self.assertIn('has gaps: False', obs) self.assertIn('GC-content: 66.67%', obs) for seq in DNA('GCSSCG'), RNA('GCSSCG'): obs = repr(seq) self.assertIn('has gaps: False', obs) self.assertIn('GC-content: 100.00%', obs) for seq in DNA('-GCSSCG.'), RNA('-GCSSCG.'): obs = repr(seq) self.assertIn('has gaps: True', obs) self.assertIn('GC-content: 100.00%', obs) def test_complement_without_reverse_empty(self): for constructor in (DNA, RNA): # without optional attributes comp = constructor('').complement() self.assertEqual(comp, constructor('')) # with optional attributes comp = constructor( '', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': []}, interval_metadata=IntervalMetadata(0)).complement() self.assertEqual( comp, constructor( '', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': []})) def test_complement_without_reverse_non_empty(self): for (constructor, seq_str, comp_str, qual) in self.all_combos_comp_qual: comp = constructor(seq_str).complement() self.assertEqual(comp, constructor(comp_str)) im = IntervalMetadata(len(seq_str)) im.add([(0, 1)], metadata={'gene': 'p53'}) comp = constructor( seq_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': qual}, interval_metadata=im).complement() self.assertEqual( comp, constructor( comp_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': qual}, interval_metadata=im)) def test_complement_with_reverse_empty(self): for constructor in (DNA, RNA): rc = constructor('').complement(reverse=True) self.assertEqual(rc, constructor('')) rc = constructor( '', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': []}, interval_metadata=IntervalMetadata(0)).complement(reverse=True) self.assertEqual( rc, constructor( '', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': []})) def test_complement_with_reverse_non_empty(self): for (constructor, seq_str, rev_comp_str, qual) in self.all_combos_rev_comp_qual: rc = constructor(seq_str).complement(reverse=True) self.assertEqual(rc, constructor(rev_comp_str)) length = len(seq_str) im = IntervalMetadata(length) im.add([(0, 1)], metadata={'gene': 'p53'}) im_rc = IntervalMetadata(length) im_rc.add([(length-1, length)], metadata={'gene': 'p53'}) original = constructor( seq_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={ 'quality': qual}, interval_metadata=im) rc = original.complement(reverse=True) self.assertEqual( rc, constructor( rev_comp_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': list(qual)[::-1]}, interval_metadata=im_rc)) # assert the original object is not changed self.assertIsNot(original.interval_metadata, im) self.assertEqual(original.interval_metadata, im) def test_reverse_complement(self): # light tests because this just calls # NucleotideSequence.complement(reverse=True), which is tested more # extensively for (constructor, seq_str, rev_comp_str, qual) in self.all_combos_rev_comp_qual: rc = constructor( seq_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': qual}).reverse_complement() self.assertEqual( rc, constructor( rev_comp_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': list(qual)[::-1]})) def test_is_reverse_complement_varied_types(self): tested = 0 for constructor, seq_str, rev_comp_str in self.all_combos_rev_comp: seq_kinds = self.sequence_kinds.union(frozenset([constructor])) for sequence in seq_kinds: tested += 1 seq1 = constructor(seq_str) seq2 = sequence(rev_comp_str) self.assertTrue(seq1.is_reverse_complement(seq2)) self.assertEqual(tested, 8) def test_is_reverse_complement_empty(self): for constructor in (DNA, RNA): seq1 = constructor('') self.assertTrue(seq1.is_reverse_complement(seq1)) # optional attributes are ignored, only the sequence is compared seq2 = constructor( '', metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': np.array([], dtype=np.int64)}) self.assertTrue(seq2.is_reverse_complement(seq2)) self.assertTrue(seq1.is_reverse_complement(seq2)) self.assertTrue(seq2.is_reverse_complement(seq1)) def test_is_reverse_complement_metadata_ignored(self): for (constructor, seq_str, rev_comp_str, qual) in self.all_combos_rev_comp_qual: seq1 = constructor(seq_str) seq2 = constructor( rev_comp_str, metadata={'id': 'foo', 'description': 'bar'}, positional_metadata={'quality': qual}) self.assertFalse(seq1.is_reverse_complement(seq1)) self.assertFalse(seq2.is_reverse_complement(seq2)) self.assertTrue(seq1.is_reverse_complement(seq2)) self.assertTrue(seq2.is_reverse_complement(seq1)) def test_is_reverse_complement_non_reverse_complements(self): for constructor in (DNA, RNA): # same length seq1 = constructor('ACAG') seq2 = constructor('AAAA') self.assertFalse(seq1.is_reverse_complement(seq1)) self.assertFalse(seq2.is_reverse_complement(seq2)) self.assertFalse(seq1.is_reverse_complement(seq2)) self.assertFalse(seq2.is_reverse_complement(seq1)) # different length seq1 = constructor('ACAG') seq2 = constructor('AAAAA') self.assertFalse(seq1.is_reverse_complement(seq1)) self.assertFalse(seq2.is_reverse_complement(seq2)) self.assertFalse(seq1.is_reverse_complement(seq2)) self.assertFalse(seq2.is_reverse_complement(seq1)) def test_is_reverse_complement_type_mismatch(self): for Class in (DNA, RNA): class DifferentSequenceClass(GrammaredSequence): @classproperty def degenerate_map(cls): return {"X": set("AB")} @classproperty def definite_chars(cls): return set("ABC") @classproperty def default_gap_char(cls): return '-' @classproperty def gap_chars(cls): return set('-.') seq1 = Class('ABC') seq2 = DifferentSequenceClass('ABC') with self.assertRaisesRegex(TypeError, r"Cannot use.*and " "DifferentSequenceClass together"): seq1.is_reverse_complement(seq2) def test_motif_purine_run(self): dna = (DNA, "AARC--TCRG", "AA-RC--TCR-G") rna = (RNA, "AARC--UCRG", "AA-RC--UCR-G") all_sets = (dna, rna) for constructor, run1, run2 in all_sets: seq = constructor("") self.assertEqual(list(seq.find_motifs("purine-run")), []) seq = constructor(run1) self.assertEqual(list(seq.find_motifs("purine-run")), [slice(0, 3), slice(8, 10)]) seq = constructor(run2) self.assertEqual(list(seq.find_motifs("purine-run", min_length=3, ignore=seq.gaps())), [slice(0, 4)]) def test_motif_pyrimidine_run(self): dna = (DNA, "AARC--TCRA", "AA-RC--TCR-A") rna = (RNA, "AARC--UCRG", "AA-RC--UCR-G") all_sets = (dna, rna) for constructor, run1, run2 in all_sets: seq = constructor("") self.assertEqual(list(seq.find_motifs("pyrimidine-run")), []) seq = constructor(run1) self.assertEqual(list(seq.find_motifs("pyrimidine-run")), [slice(3, 4), slice(6, 8)]) seq = constructor(run2) self.assertEqual(list(seq.find_motifs("pyrimidine-run", min_length=3, ignore=seq.gaps())), [slice(4, 9)]) def test_gc_frequency_and_gc_content(self): universal_sets = (('', 0, 0.0), ('ADDDH', 0, 0.0), ('ACGA', 2, 0.5), ('ACGS', 3, 0.75), ('AAAAAAAG', 1, 0.125), ('CCC', 3, 1.0), ('GGG', 3, 1.0), ('SSS', 3, 1.0), ('CGS', 3, 1.0), ('----....', 0, 0.0), ('G--..', 1, 1.0), ('ACGA', 2, 0.5)) dna = (DNA, universal_sets + (('ATMRWYKVHDBN.-', 0, 0.0),)) rna = (RNA, universal_sets + (('AUMRWYKVHDBN.-', 0, 0.0),)) for constructor, current_set in (dna, rna): for seq_str, count, ratio in current_set: seq = constructor(seq_str) self.assertEqual(count, seq.gc_frequency()) self.assertEqual(count, seq.gc_frequency(relative=False)) self.assertEqual(ratio, seq.gc_frequency(relative=True)) self.assertEqual(ratio, seq.gc_content()) if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_protein.py000066400000000000000000000114321446255456000227500ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy as np import numpy.testing as npt from skbio import Protein class TestProtein(unittest.TestCase): def test_alphabet(self): expected = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ-.*") self.assertIs(type(Protein.alphabet), set) self.assertEqual(Protein.alphabet, expected) Protein.alphabet.add("&") self.assertEqual(Protein.alphabet, expected) self.assertEqual(Protein('').alphabet, expected) with self.assertRaises(AttributeError): Protein('').alphabet = set("ABCD") # TODO: duplicate of test_definite_chars, remove when nondegenerate_chars, # is removed def test_nondegenerate_chars(self): exp = set("ACDEFGHIKLMNOPQRSTUVWY") self.assertEqual(Protein("").nondegenerate_chars, exp) self.assertEqual(Protein.nondegenerate_chars, exp) def test_definite_chars(self): exp = set("ACDEFGHIKLMNOPQRSTUVWY") self.assertEqual(Protein("").definite_chars, exp) self.assertEqual(Protein.definite_chars, exp) def test_degenerate_map(self): exp = { 'B': set(['D', 'N']), 'Z': set(['E', 'Q']), 'J': set(['I', 'L']), 'X': set(['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'Y']) } self.assertEqual(Protein("").degenerate_map, exp) self.assertEqual(Protein.degenerate_map, exp) def test_stop_chars(self): expected = set('*') self.assertIs(type(Protein.stop_chars), set) self.assertEqual(Protein.stop_chars, expected) Protein.stop_chars.add("JO") self.assertEqual(Protein.stop_chars, expected) self.assertEqual(Protein('').stop_chars, expected) with self.assertRaises(AttributeError): Protein('').stop_chars = set("^&") def test_stops(self): npt.assert_array_equal(Protein('').stops(), np.array([])) npt.assert_array_equal(Protein('P').stops(), np.array([False])) npt.assert_array_equal(Protein('PAW').stops(), np.array([False, False, False])) npt.assert_array_equal(Protein('PAW*').stops(), np.array([False, False, False, True])) npt.assert_array_equal(Protein('P*W*').stops(), np.array([False, True, False, True])) npt.assert_array_equal(Protein('****').stops(), np.array([True, True, True, True])) npt.assert_array_equal(Protein('XZB-.').stops(), np.array([False, False, False, False, False])) def test_has_stops(self): self.assertFalse(Protein('').has_stops()) self.assertFalse(Protein('P').has_stops()) self.assertFalse(Protein('PAW').has_stops()) self.assertTrue(Protein('PAW*').has_stops()) self.assertTrue(Protein('P*W*').has_stops()) self.assertTrue(Protein('****').has_stops()) self.assertFalse(Protein('XZB-.').has_stops()) def test_motif_n_glycosylation(self): seq = Protein("ACDFFACGNPSL") self.assertEqual(list(seq.find_motifs("N-glycosylation")), []) seq = Protein("ACDFNFTACGNPSL") self.assertEqual(list(seq.find_motifs("N-glycosylation")), [slice(4, 8)]) seq = Protein("AC-DFN-FTACGNPSL") self.assertEqual(list(seq.find_motifs("N-glycosylation", ignore=seq.gaps())), [slice(5, 10)]) def test_repr(self): # basic sanity checks for custom repr stats. more extensive testing is # performed on Sequence.__repr__ obs = repr(Protein('')) # obtained from super() self.assertIn('has gaps: False', obs) # custom to Protein self.assertIn('has stops: False', obs) obs = repr(Protein('PAW')) self.assertIn('has gaps: False', obs) self.assertIn('has stops: False', obs) obs = repr(Protein('PA*W-')) self.assertIn('has gaps: True', obs) self.assertIn('has stops: True', obs) obs = repr(Protein('*****')) self.assertIn('has gaps: False', obs) self.assertIn('has stops: True', obs) def test_cannot_subclass(self): with self.assertRaisesRegex(TypeError, r"Subclassing disabled"): class CustomSequence(Protein): pass if __name__ == "__main__": unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_rna.py000066400000000000000000000040431446255456000220500ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio import DNA, RNA from skbio.metadata import IntervalMetadata # tests specific to RNA go here. tests for functionality shared by DNA and RNA # go in test_nucleotide_sequences.py class TestRNA(unittest.TestCase): def test_reverse_transcribe(self): # without changes self.assertEqual(RNA('').reverse_transcribe(), DNA('')) self.assertEqual(RNA('A').reverse_transcribe(), DNA('A')) self.assertEqual(RNA('.ACGW-').reverse_transcribe(), DNA('.ACGW-')) # with changes self.assertEqual(DNA('T'), RNA('U').reverse_transcribe()) self.assertEqual(DNA('TT'), RNA('UU').reverse_transcribe()) self.assertEqual(DNA('ATCTG'), RNA('AUCUG').reverse_transcribe()) self.assertEqual(DNA('TTTG'), RNA('UUUG').reverse_transcribe()) def test_reverse_transcribe_preserves_all_metadata(self): im = IntervalMetadata(4) im.add([(0, 2)], metadata={'gene': 'p53'}) seq = RNA('AGUU', metadata={'foo': 'bar'}, positional_metadata={'foo': range(4)}, interval_metadata=im) exp = DNA('AGTT', metadata={'foo': 'bar'}, positional_metadata={'foo': range(4)}, interval_metadata=im) self.assertEqual(seq.reverse_transcribe(), exp) def test_reverse_transcribe_does_not_modify_input(self): seq = RNA('AUAU') self.assertEqual(seq.reverse_transcribe(), DNA('ATAT')) self.assertEqual(seq, RNA('AUAU')) def test_cannot_subclass(self): with self.assertRaisesRegex(TypeError, r"Subclassing disabled"): class CustomSequence(RNA): pass if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/sequence/tests/test_sequence.py000066400000000000000000003236531446255456000231130ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import copy import functools import itertools import re from types import GeneratorType from collections.abc import Hashable from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas as pd import scipy.spatial.distance import skbio.sequence.distance from skbio import Sequence, DNA from skbio.util import assert_data_frame_almost_equal from skbio.sequence._sequence import (_single_index_to_slice, _is_single_index, _as_slice_if_single_index) from skbio.util._testing import ReallyEqualMixin from skbio.metadata._testing import (MetadataMixinTests, IntervalMetadataMixinTests, PositionalMetadataMixinTests) from skbio.metadata import IntervalMetadata class SequenceSubclass(Sequence): """Used for testing purposes.""" pass class SequenceSubclassTwo(Sequence): """Used for testing purposes.""" pass class TestSequenceMetadata(TestCase, ReallyEqualMixin, MetadataMixinTests): def setUp(self): self._metadata_constructor_ = functools.partial(Sequence, '') class TestSequencePositionalMetadata(TestCase, ReallyEqualMixin, PositionalMetadataMixinTests): def setUp(self): def factory(axis_len, positional_metadata=None): return Sequence('Z' * axis_len, positional_metadata=positional_metadata) self._positional_metadata_constructor_ = factory class TestSequenceIntervalMetadata(TestCase, ReallyEqualMixin, IntervalMetadataMixinTests): def setUp(self): super()._set_up() def factory(axis_len, interval_metadata=None): return Sequence('Z' * axis_len, interval_metadata=interval_metadata) self._interval_metadata_constructor_ = factory class TestSequenceBase(TestCase): def setUp(self): self.sequence_kinds = frozenset([ str, Sequence, lambda s: np.frombuffer(s.encode('ascii'), dtype='|S1'), lambda s: np.frombuffer(s.encode('ascii'), dtype=np.uint8)]) class TestSequence(TestSequenceBase, ReallyEqualMixin): def setUp(self): super(TestSequence, self).setUp() self.lowercase_seq = Sequence('AAAAaaaa', lowercase='key') def empty_generator(): yield from () self.getitem_empty_indices = [ [], (), {}, empty_generator(), # ndarray of implicit float dtype np.array([]), np.array([], dtype=int)] def test_concat_bad_how(self): seq1 = seq2 = Sequence("123") with self.assertRaises(ValueError): Sequence.concat([seq1, seq2], how='foo') def test_concat_on_subclass(self): seq1 = SequenceSubclass("123") seq2 = Sequence("123") result = SequenceSubclass.concat([seq1, seq2]) self.assertIs(type(result), SequenceSubclass) self.assertEqual(result, SequenceSubclass("123123")) def test_concat_on_empty_iterator(self): result = SequenceSubclass.concat((_ for _ in [])) self.assertIs(type(result), SequenceSubclass) self.assertEqual(result, SequenceSubclass("")) def test_concat_on_bad_subclass(self): seq1 = Sequence("123") seq2 = SequenceSubclassTwo("123") with self.assertRaises(TypeError): SequenceSubclass.concat([seq1, seq2]) def test_concat_interval_metadata(self): seq1 = Sequence("1234") seq1.interval_metadata.add( [(0, 2)], [(True, False)], {'gene': 'sagA'}) seq2 = Sequence("5678") seq2.interval_metadata.add( [(1, 3)], [(False, True)], {'gene': 'sagB'}) obs = Sequence.concat([seq1, seq2]) exp = Sequence('12345678') exp.interval_metadata.add( [(0, 2)], [(True, False)], {'gene': 'sagA'}) exp.interval_metadata.add( [(5, 7)], [(False, True)], {'gene': 'sagB'}) self.assertEqual(exp, obs) def test_concat_one_seq_has_none_interval_metadata(self): seq1 = Sequence("1234") seq1.interval_metadata.add( [(0, 2)], [(True, False)], {'gene': 'sagA'}) seq2 = Sequence("5678") seq3 = Sequence("910") seq3.interval_metadata.add( [(1, 3)], [(False, True)], {'gene': 'sagB'}) obs = Sequence.concat([seq1, seq2, seq3]) exp = Sequence('12345678910') exp.interval_metadata.add( [(0, 2)], [(True, False)], {'gene': 'sagA'}) exp.interval_metadata.add( [(9, 11)], [(False, True)], {'gene': 'sagB'}) self.assertEqual(exp, obs) def test_concat_default_how(self): seq1 = Sequence("1234", positional_metadata={'a': [1]*4}) seq2 = Sequence("5678", positional_metadata={'a': [2]*4}) seqbad = Sequence("9", positional_metadata={'b': [9]}) result1 = Sequence.concat([seq1, seq2]) result2 = Sequence.concat([seq1, seq2], how='strict') self.assertEqual(result1, result2) with self.assertRaisesRegex(ValueError, r'.*positional.*metadata.*inner.*outer.*'): Sequence.concat([seq1, seq2, seqbad]) def test_concat_strict_simple(self): expected = Sequence( "12345678", positional_metadata={'a': [1, 1, 1, 1, 2, 2, 2, 2]}) seq1 = Sequence("1234", positional_metadata={'a': [1]*4}) seq2 = Sequence("5678", positional_metadata={'a': [2]*4}) result = Sequence.concat([seq1, seq2], how='strict') self.assertEqual(result, expected) self.assertFalse(result.metadata) def test_concat_strict_many(self): odd_key = frozenset() expected = Sequence("13579", positional_metadata={odd_key: [1, 2, 3, 4, 5], 'a': list('skbio')}) result = Sequence.concat([ Sequence("1", positional_metadata={'a': ['s'], odd_key: [1]}), Sequence("3", positional_metadata={'a': ['k'], odd_key: [2]}), Sequence("5", positional_metadata={'a': ['b'], odd_key: [3]}), Sequence("7", positional_metadata={'a': ['i'], odd_key: [4]}), Sequence("9", positional_metadata={'a': ['o'], odd_key: [5]}) ], how='strict') self.assertEqual(result, expected) self.assertFalse(result.metadata) def test_concat_strict_fail(self): seq1 = Sequence("1", positional_metadata={'a': [1]}) seq2 = Sequence("2", positional_metadata={'b': [2]}) with self.assertRaisesRegex(ValueError, r'.*positional.*metadata.*inner.*outer.*'): Sequence.concat([seq1, seq2], how='strict') def test_concat_outer_simple(self): seq1 = Sequence("1234") seq2 = Sequence("5678") result = Sequence.concat([seq1, seq2], how='outer') self.assertEqual(result, Sequence("12345678")) self.assertFalse(result.metadata) def test_concat_outer_missing(self): a = {} b = {} seq1 = Sequence("12", positional_metadata={'a': ['1', '2']}) seq2 = Sequence("34", positional_metadata={'b': [3, 4], 'c': [a, b]}) seq3 = Sequence("56") seq4 = Sequence("78", positional_metadata={'a': [7, 8]}) seq5 = Sequence("90", positional_metadata={'b': [9, 0]}) result = Sequence.concat([seq1, seq2, seq3, seq4, seq5], how='outer') expected = Sequence("1234567890", positional_metadata={ 'a': ['1', '2', np.nan, np.nan, np.nan, np.nan, 7, 8, np.nan, np.nan], 'b': [np.nan, np.nan, 3, 4, np.nan, np.nan, np.nan, np.nan, 9, 0], 'c': [np.nan, np.nan, a, b, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan] }) self.assertEqual(result, expected) self.assertFalse(result.metadata) def test_concat_inner_simple(self): seq1 = Sequence("1234") seq2 = Sequence("5678", positional_metadata={'discarded': [1] * 4}) result = Sequence.concat([seq1, seq2], how='inner') self.assertEqual(result, Sequence("12345678")) self.assertFalse(result.metadata) def test_concat_inner_missing(self): seq1 = Sequence("12", positional_metadata={'a': ['1', '2'], 'c': [{}, {}]}) seq2 = Sequence("34", positional_metadata={'a': [3, 4], 'b': [3, 4]}) seq3 = Sequence("56", positional_metadata={'a': [5, 6], 'b': [5, 6]}) result = Sequence.concat([seq1, seq2, seq3], how='inner') expected = Sequence("123456", positional_metadata={'a': ['1', '2', 3, 4, 5, 6]}) self.assertEqual(result, expected) self.assertFalse(result.metadata) def test_init_default_parameters(self): seq = Sequence('.ABC123xyz-') npt.assert_equal(seq.values, np.array('.ABC123xyz-', dtype='c')) self.assertEqual('.ABC123xyz-', str(seq)) self.assertFalse(seq.metadata) self.assertEqual(seq.metadata, {}) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame(index=range(11))) self.assertEqual(seq.interval_metadata, IntervalMetadata(len(seq))) def test_init_nondefault_parameters(self): s = '.ABC123xyz-' im = IntervalMetadata(len(s)) im.add([(0, 1)], metadata={'gene': 'sagA'}) seq = Sequence(s, metadata={'id': 'foo', 'description': 'bar baz'}, positional_metadata={'quality': range(11)}, interval_metadata=im) self.assertEqual(seq.interval_metadata, im) npt.assert_equal(seq.values, np.array('.ABC123xyz-', dtype='c')) self.assertEqual(s, str(seq)) self.assertTrue(seq.metadata) self.assertEqual(seq.metadata, {'id': 'foo', 'description': 'bar baz'}) assert_data_frame_almost_equal( seq.positional_metadata, pd.DataFrame({'quality': range(11)}, index=range(11))) def test_init_empty_sequence(self): # Test constructing an empty sequence using each supported input type. for s in (b'', # bytes '', # unicode np.array('', dtype='c'), # char vector np.frombuffer(b'', dtype=np.uint8), # byte vec Sequence('')): # another Sequence object seq = Sequence(s) self.assertIsInstance(seq.values, np.ndarray) self.assertEqual(seq.values.dtype, '|S1') self.assertEqual(seq.values.shape, (0, )) npt.assert_equal(seq.values, np.array('', dtype='c')) self.assertEqual(str(seq), '') self.assertEqual(len(seq), 0) self.assertFalse(seq.metadata) self.assertEqual(seq.metadata, {}) self.assertEqual(seq.interval_metadata, IntervalMetadata(0)) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame(index=range(0))) def test_init_single_character_sequence(self): for s in (b'A', 'A', np.array('A', dtype='c'), np.frombuffer(b'A', dtype=np.uint8), Sequence('A')): seq = Sequence(s) self.assertIsInstance(seq.values, np.ndarray) self.assertEqual(seq.values.dtype, '|S1') self.assertEqual(seq.values.shape, (1,)) npt.assert_equal(seq.values, np.array('A', dtype='c')) self.assertEqual(str(seq), 'A') self.assertEqual(len(seq), 1) self.assertFalse(seq.metadata) self.assertEqual(seq.metadata, {}) self.assertEqual(seq.interval_metadata, IntervalMetadata(1)) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame(index=range(1))) def test_init_multiple_character_sequence(self): for s in (b'.ABC\t123 xyz-', '.ABC\t123 xyz-', np.array('.ABC\t123 xyz-', dtype='c'), np.frombuffer(b'.ABC\t123 xyz-', dtype=np.uint8), Sequence('.ABC\t123 xyz-')): seq = Sequence(s) self.assertIsInstance(seq.values, np.ndarray) self.assertEqual(seq.values.dtype, '|S1') self.assertEqual(seq.values.shape, (14,)) npt.assert_equal(seq.values, np.array('.ABC\t123 xyz-', dtype='c')) self.assertEqual(str(seq), '.ABC\t123 xyz-') self.assertEqual(len(seq), 14) self.assertFalse(seq.metadata) self.assertEqual(seq.metadata, {}) self.assertEqual(seq.interval_metadata, IntervalMetadata(14)) assert_data_frame_almost_equal(seq.positional_metadata, pd.DataFrame(index=range(14))) def test_init_from_sequence_object(self): # We're testing this in its simplest form in other tests. This test # exercises more complicated cases of building a sequence from another # sequence. # just the sequence, no other metadata seq = Sequence('ACGT') self.assertEqual(Sequence(seq), seq) # sequence with metadata should have everything propagated seq = Sequence('ACGT', metadata={'id': 'foo', 'description': 'bar baz'}, positional_metadata={'quality': range(4)}) seq.interval_metadata.add([(0, 1)], metadata={'gene': 'sagA'}) self.assertEqual(Sequence(seq), seq) # should be able to override metadata im = IntervalMetadata(4) im.add([(0, 2)], metadata={'gene': 'sagB'}) self.assertEqual( Sequence(seq, metadata={'id': 'abc', 'description': '123'}, positional_metadata={'quality': [42] * 4}, interval_metadata=im), Sequence('ACGT', metadata={'id': 'abc', 'description': '123'}, positional_metadata={'quality': [42] * 4}, interval_metadata=im)) # subclasses work too im = IntervalMetadata(4) im.add([(0, 2)], metadata={'gene': 'sagB'}) seq = SequenceSubclass('ACGT', metadata={'id': 'foo', 'description': 'bar baz'}, positional_metadata={'quality': range(4)}, interval_metadata=im) self.assertEqual( Sequence(seq), Sequence('ACGT', metadata={'id': 'foo', 'description': 'bar baz'}, positional_metadata={'quality': range(4)}, interval_metadata=im)) def test_init_from_non_descendant_sequence_object(self): seq = SequenceSubclass('ACGT') with self.assertRaises(TypeError) as cm: SequenceSubclassTwo(seq) error = str(cm.exception) self.assertIn("SequenceSubclass", error) self.assertIn("SequenceSubclassTwo", error) self.assertIn("cast", error) def test_init_from_contiguous_sequence_bytes_view(self): bytes = np.array([65, 42, 66, 42, 65], dtype=np.uint8) view = bytes[:3] seq = Sequence(view) # sequence should be what we'd expect self.assertEqual(seq, Sequence('A*B')) # we shouldn't own the memory because no copy should have been made self.assertFalse(seq._owns_bytes) # can't mutate view because it isn't writeable anymore with self.assertRaises(ValueError): view[1] = 100 # sequence shouldn't have changed self.assertEqual(seq, Sequence('A*B')) # mutate bytes (*not* the view) bytes[0] = 99 # Sequence changed because we are only able to make the view read-only, # not its source (bytes). This is somewhat inconsistent behavior that # is (to the best of our knowledge) outside our control. self.assertEqual(seq, Sequence('c*B')) def test_init_from_noncontiguous_sequence_bytes_view(self): bytes = np.array([65, 42, 66, 42, 65], dtype=np.uint8) view = bytes[::2] seq = Sequence(view) # sequence should be what we'd expect self.assertEqual(seq, Sequence('ABA')) # we should own the memory because a copy should have been made self.assertTrue(seq._owns_bytes) # mutate bytes and its view bytes[0] = 99 view[1] = 100 # sequence shouldn't have changed self.assertEqual(seq, Sequence('ABA')) def test_init_no_copy_of_sequence(self): bytes = np.array([65, 66, 65], dtype=np.uint8) seq = Sequence(bytes) # should share the same memory self.assertIs(seq._bytes, bytes) # shouldn't be able to mutate the Sequence object's internals by # mutating the shared memory with self.assertRaises(ValueError): bytes[1] = 42 def test_init_invalid_sequence(self): # invalid dtype (numpy.ndarray input) with self.assertRaises(TypeError): # int64 Sequence(np.array([1, 2, 3])) with self.assertRaises(TypeError): # |S21 Sequence(np.array([1, "23", 3])) with self.assertRaises(TypeError): # object Sequence(np.array([1, {}, ()], dtype=object)) # invalid input type (non-numpy.ndarray input) with self.assertRaisesRegex(TypeError, r'tuple'): Sequence(('a', 'b', 'c')) with self.assertRaisesRegex(TypeError, r'list'): Sequence(['a', 'b', 'c']) with self.assertRaisesRegex(TypeError, r'set'): Sequence({'a', 'b', 'c'}) with self.assertRaisesRegex(TypeError, r'dict'): Sequence({'a': 42, 'b': 43, 'c': 44}) with self.assertRaisesRegex(TypeError, r'int'): Sequence(42) with self.assertRaisesRegex(TypeError, r'float'): Sequence(4.2) with self.assertRaisesRegex(TypeError, r'int64'): Sequence(np.int_(50)) with self.assertRaisesRegex(TypeError, r'float64'): Sequence(np.float_(50)) with self.assertRaisesRegex(TypeError, r'Foo'): class Foo: pass Sequence(Foo()) # out of ASCII range with self.assertRaises(UnicodeEncodeError): Sequence('abc\u1F30') def test_values_property(self): # Property tests are only concerned with testing the interface # provided by the property: that it can be accessed, can't be # reassigned or mutated in place, and that the correct type is # returned. More extensive testing of border cases (e.g., different # sequence lengths or input types, odd characters, etc.) are performed # in Sequence.__init__ tests. seq = Sequence('ACGT') # should get back a numpy.ndarray of '|S1' dtype self.assertIsInstance(seq.values, np.ndarray) self.assertEqual(seq.values.dtype, '|S1') npt.assert_equal(seq.values, np.array('ACGT', dtype='c')) # test that we can't mutate the property with self.assertRaises(ValueError): seq.values[1] = 'A' # test that we can't set the property with self.assertRaises(AttributeError): seq.values = np.array("GGGG", dtype='c') def test_sequence_numpy_compatibility(self): seq = Sequence('abc123') array = np.asarray(seq) self.assertIsInstance(array, np.ndarray) self.assertEqual(array.dtype, '|S1') npt.assert_equal(array, np.array('abc123', dtype='c')) npt.assert_equal(array, seq.values) with self.assertRaises(ValueError): array[1] = 'B' def test_observed_chars_property(self): self.assertEqual(Sequence('').observed_chars, set()) self.assertEqual(Sequence('x').observed_chars, {'x'}) self.assertEqual(Sequence('xYz').observed_chars, {'x', 'Y', 'z'}) self.assertEqual(Sequence('zzz').observed_chars, {'z'}) self.assertEqual(Sequence('xYzxxZz').observed_chars, {'x', 'Y', 'z', 'Z'}) self.assertEqual(Sequence('\t ').observed_chars, {' ', '\t'}) im = IntervalMetadata(6) im.add([(0, 2)], metadata={'gene': 'sagB'}) self.assertEqual( Sequence('aabbcc', metadata={'foo': 'bar'}, positional_metadata={'foo': range(6)}, interval_metadata=im).observed_chars, {'a', 'b', 'c'}) with self.assertRaises(AttributeError): Sequence('ACGT').observed_chars = {'a', 'b', 'c'} def test_eq_and_ne(self): seq_a = Sequence("A") seq_b = Sequence("B") im = IntervalMetadata(1) im.add([(0, 1)], metadata={'gene': 'sagA'}) im2 = IntervalMetadata(1) im.add([(0, 1)], metadata={'gene': 'sagB'}) self.assertTrue(seq_a == seq_a) self.assertTrue(Sequence("a") == Sequence("a")) self.assertTrue(Sequence("a", metadata={'id': 'b'}) == Sequence("a", metadata={'id': 'b'})) self.assertTrue(Sequence("a", metadata={'id': 'b', 'description': 'c'}) == Sequence("a", metadata={'id': 'b', 'description': 'c'})) self.assertTrue(Sequence("a", metadata={'id': 'b', 'description': 'c'}, positional_metadata={'quality': [1]}, interval_metadata=im) == Sequence("a", metadata={'id': 'b', 'description': 'c'}, positional_metadata={'quality': [1]}, interval_metadata=im)) self.assertTrue(seq_a != seq_b) self.assertTrue(SequenceSubclass("a") != Sequence("a")) self.assertTrue(Sequence("a") != Sequence("b")) self.assertTrue(Sequence("a") != Sequence("a", metadata={'id': 'b'})) self.assertTrue(Sequence("a", metadata={'id': 'c'}) != Sequence("a", metadata={'id': 'c', 'description': 't'})) self.assertTrue(Sequence("a", positional_metadata={'quality': [1]}) != Sequence("a")) self.assertTrue(Sequence("a", interval_metadata=im) != Sequence("a")) self.assertTrue(Sequence("a", positional_metadata={'quality': [1]}) != Sequence("a", positional_metadata={'quality': [2]})) self.assertTrue(Sequence("a", interval_metadata=im) != Sequence("a", interval_metadata=im2)) self.assertTrue(Sequence("c", positional_metadata={'quality': [3]}) != Sequence("b", positional_metadata={'quality': [3]})) self.assertTrue(Sequence("c", interval_metadata=im) != Sequence("b", interval_metadata=im)) self.assertTrue(Sequence("a", metadata={'id': 'b'}) != Sequence("c", metadata={'id': 'b'})) def test_eq_sequences_without_metadata_compare_equal(self): self.assertTrue(Sequence('') == Sequence('')) self.assertTrue(Sequence('z') == Sequence('z')) self.assertTrue( Sequence('ACGT') == Sequence('ACGT')) def test_eq_sequences_with_metadata_compare_equal(self): seq1 = Sequence('ACGT', metadata={'id': 'foo', 'desc': 'abc'}, positional_metadata={'qual': [1, 2, 3, 4]}) seq2 = Sequence('ACGT', metadata={'id': 'foo', 'desc': 'abc'}, positional_metadata={'qual': [1, 2, 3, 4]}) self.assertTrue(seq1 == seq2) # order shouldn't matter self.assertTrue(seq2 == seq1) def test_eq_sequences_from_different_sources_compare_equal(self): # sequences that have the same data but are constructed from different # types of data should compare equal im = IntervalMetadata(4) im.add([(0, 2)], metadata={'gene': 'sagB'}) seq1 = Sequence('ACGT', metadata={'id': 'foo', 'desc': 'abc'}, positional_metadata={'quality': (1, 2, 3, 4)}, interval_metadata=im) seq2 = Sequence(np.array([65, 67, 71, 84], dtype=np.uint8), metadata={'id': 'foo', 'desc': 'abc'}, positional_metadata={'quality': np.array([1, 2, 3, 4])}, interval_metadata=im) self.assertTrue(seq1 == seq2) def test_eq_type_mismatch(self): seq1 = Sequence('ACGT') seq2 = SequenceSubclass('ACGT') self.assertFalse(seq1 == seq2) def test_eq_positional_metadata_mismatch(self): # both provided seq1 = Sequence('ACGT', positional_metadata={'quality': [1, 2, 3, 4]}) seq2 = Sequence('ACGT', positional_metadata={'quality': [1, 2, 3, 5]}) self.assertFalse(seq1 == seq2) # one provided seq1 = Sequence('ACGT', positional_metadata={'quality': [1, 2, 3, 4]}) seq2 = Sequence('ACGT') self.assertFalse(seq1 == seq2) def test_eq_interval_metadata_mismatch(self): im1 = IntervalMetadata(4) im1.add([(0, 3)], metadata={'gene': 'sagA'}) im2 = IntervalMetadata(4) im2.add([(0, 2)], metadata={'gene': 'sagA'}) # both provided seq1 = Sequence('ACGT', interval_metadata=im1) seq2 = Sequence('ACGT', interval_metadata=im2) self.assertFalse(seq1 == seq2) # one provided seq1 = Sequence('ACGT', interval_metadata=im1) seq2 = Sequence('ACGT') self.assertFalse(seq1 == seq2) def test_eq_sequence_mismatch(self): seq1 = Sequence('ACGT') seq2 = Sequence('TGCA') self.assertFalse(seq1 == seq2) def test_getitem_gives_new_sequence(self): seq = Sequence("Sequence string !1@2#3?.,") self.assertFalse(seq is seq[:]) def test_getitem_drops_interval_metadata(self): s = "Sequence string !1@2#3?.," seq = Sequence(s, metadata={'id': 'id', 'description': 'dsc'}) seq.interval_metadata.add([(0, 3)], metadata={'gene': 'sagA'}) eseq = Sequence('Se', metadata={'id': 'id', 'description': 'dsc'}) self.assertEqual(seq[:2], eseq) def test_getitem_with_int_has_positional_metadata(self): s = "Sequence string !1@2#3?.," length = len(s) seq = Sequence(s, metadata={'id': 'id', 'description': 'dsc'}, positional_metadata={'quality': np.arange(length)}) eseq = Sequence("S", {'id': 'id', 'description': 'dsc'}, positional_metadata={'quality': np.array([0])}) self.assertEqual(seq[0], eseq) eseq = Sequence(",", metadata={'id': 'id', 'description': 'dsc'}, positional_metadata={'quality': np.array([len(seq) - 1])}) self.assertEqual(seq[len(seq) - 1], eseq) eseq = Sequence("t", metadata={'id': 'id', 'description': 'dsc'}, positional_metadata={'quality': [10]}) self.assertEqual(seq[10], eseq) def test_single_index_to_slice(self): a = [1, 2, 3, 4] self.assertEqual(slice(0, 1), _single_index_to_slice(0)) self.assertEqual([1], a[_single_index_to_slice(0)]) self.assertEqual(slice(-1, None), _single_index_to_slice(-1)) self.assertEqual([4], a[_single_index_to_slice(-1)]) def test_is_single_index(self): self.assertTrue(_is_single_index(0)) self.assertFalse(_is_single_index(True)) self.assertFalse(_is_single_index(bool())) self.assertFalse(_is_single_index('a')) def test_as_slice_if_single_index(self): self.assertEqual(slice(0, 1), _as_slice_if_single_index(0)) slice_obj = slice(2, 3) self.assertIs(slice_obj, _as_slice_if_single_index(slice_obj)) def test_slice_positional_metadata(self): seq = Sequence('ABCDEFGHIJ', positional_metadata={'foo': np.arange(10), 'bar': np.arange(100, 110)}) self.assertTrue(pd.DataFrame({'foo': [0], 'bar': [100]}).equals( seq._slice_positional_metadata(0))) self.assertTrue(pd.DataFrame({'foo': [0], 'bar': [100]}).equals( seq._slice_positional_metadata(slice(0, 1)))) self.assertTrue(pd.DataFrame({'foo': [0, 1], 'bar': [100, 101]}).equals( seq._slice_positional_metadata(slice(0, 2)))) self.assertTrue(pd.DataFrame( {'foo': [9], 'bar': [109]}, index=[9]).equals( seq._slice_positional_metadata(9))) def test_getitem_with_int_no_positional_metadata(self): seq = Sequence("Sequence string !1@2#3?.,", metadata={'id': 'id2', 'description': 'no_qual'}) eseq = Sequence("t", metadata={'id': 'id2', 'description': 'no_qual'}) self.assertEqual(seq[10], eseq) def test_getitem_with_slice_has_positional_metadata(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': np.arange(length)}) eseq = Sequence("012", metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': np.arange(3)}) self.assertEqual(seq[0:3], eseq) self.assertEqual(seq[:3], eseq) self.assertEqual(seq[:3:1], eseq) eseq = Sequence("def", metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': [13, 14, 15]}) self.assertEqual(seq[-3:], eseq) self.assertEqual(seq[-3::1], eseq) eseq = Sequence("02468ace", metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': [0, 2, 4, 6, 8, 10, 12, 14]}) self.assertEqual(seq[0:length:2], eseq) self.assertEqual(seq[::2], eseq) eseq = Sequence(s[::-1], metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': np.arange(length)[::-1]}) self.assertEqual(seq[length::-1], eseq) self.assertEqual(seq[::-1], eseq) eseq = Sequence('fdb97531', metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': [15, 13, 11, 9, 7, 5, 3, 1]}) self.assertEqual(seq[length::-2], eseq) self.assertEqual(seq[::-2], eseq) self.assertEqual(seq[0:500:], seq) eseq = Sequence('', metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': np.array([], dtype=np.int64)}) self.assertEqual(seq[length:0], eseq) self.assertEqual(seq[-length:0], eseq) self.assertEqual(seq[1:0], eseq) eseq = Sequence("0", metadata={'id': 'id3', 'description': 'dsc3'}, positional_metadata={'quality': [0]}) self.assertEqual(seq[0:1], eseq) self.assertEqual(seq[0:1:1], eseq) self.assertEqual(seq[-length::-1], eseq) def test_getitem_with_slice_no_positional_metadata(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id4', 'description': 'no_qual4'}) eseq = Sequence("02468ace", metadata={'id': 'id4', 'description': 'no_qual4'}) self.assertEqual(seq[0:length:2], eseq) self.assertEqual(seq[::2], eseq) def test_getitem_with_tuple_of_mixed_with_positional_metadata(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id5', 'description': 'dsc5'}, positional_metadata={'quality': np.arange(length)}) eseq = Sequence("00000", metadata={'id': 'id5', 'description': 'dsc5'}, positional_metadata={'quality': [0, 0, 0, 0, 0]}) self.assertEqual(seq[0, 0, 0, 0, 0], eseq) self.assertEqual(seq[0, 0:1, 0, 0, 0], eseq) self.assertEqual(seq[0, 0:1, 0, -length::-1, 0, 1:0], eseq) self.assertEqual(seq[0:1, 0:1, 0:1, 0:1, 0:1], eseq) self.assertEqual(seq[0:1, 0, 0, 0, 0], eseq) eseq = Sequence("0123fed9", metadata={'id': 'id5', 'description': 'dsc5'}, positional_metadata={'quality': [0, 1, 2, 3, 15, 14, 13, 9]}) self.assertEqual(seq[0, 1, 2, 3, 15, 14, 13, 9], eseq) self.assertEqual(seq[0, 1, 2, 3, :-4:-1, 9], eseq) self.assertEqual(seq[0:4, :-4:-1, 9, 1:0], eseq) self.assertEqual(seq[0:4, :-4:-1, 9:10], eseq) def test_getitem_with_tuple_of_mixed_no_positional_metadata(self): seq = Sequence("0123456789abcdef", metadata={'id': 'id6', 'description': 'no_qual6'}) eseq = Sequence("0123fed9", metadata={'id': 'id6', 'description': 'no_qual6'}) self.assertEqual(seq[0, 1, 2, 3, 15, 14, 13, 9], eseq) self.assertEqual(seq[0, 1, 2, 3, :-4:-1, 9], eseq) self.assertEqual(seq[0:4, :-4:-1, 9], eseq) self.assertEqual(seq[0:4, :-4:-1, 9:10], eseq) def test_getitem_with_tuple_of_mixed_no_metadata(self): seq = Sequence("0123456789abcdef") eseq = Sequence("0123fed9") self.assertEqual(seq[0, 1, 2, 3, 15, 14, 13, 9], eseq) self.assertEqual(seq[0, 1, 2, 3, :-4:-1, 9], eseq) self.assertEqual(seq[0:4, :-4:-1, 9], eseq) self.assertEqual(seq[0:4, :-4:-1, 9:10], eseq) def test_getitem_with_iterable_of_mixed_has_positional_metadata(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id7', 'description': 'dsc7'}, positional_metadata={'quality': np.arange(length)}) def generator(): yield slice(0, 4) yield slice(200, 400) yield -1 yield slice(-2, -4, -1) yield 9 eseq = Sequence("0123fed9", metadata={'id': 'id7', 'description': 'dsc7'}, positional_metadata={'quality': [0, 1, 2, 3, 15, 14, 13, 9]}) self.assertEqual(seq[[0, 1, 2, 3, 15, 14, 13, 9]], eseq) self.assertEqual(seq[generator()], eseq) self.assertEqual(seq[[slice(0, 4), slice(None, -4, -1), 9]], eseq) self.assertEqual(seq[ [slice(0, 4), slice(None, -4, -1), slice(9, 10)]], eseq) def test_getitem_with_iterable_of_mixed_no_positional_metadata(self): s = "0123456789abcdef" seq = Sequence(s, metadata={'id': 'id7', 'description': 'dsc7'}) def generator(): yield slice(0, 4) yield slice(200, 400) yield slice(None, -4, -1) yield 9 eseq = Sequence("0123fed9", metadata={'id': 'id7', 'description': 'dsc7'}) self.assertEqual(seq[[0, 1, 2, 3, 15, 14, 13, 9]], eseq) self.assertEqual(seq[generator()], eseq) self.assertEqual(seq[[slice(0, 4), slice(None, -4, -1), 9]], eseq) self.assertEqual(seq[ [slice(0, 4), slice(None, -4, -1), slice(9, 10)]], eseq) def test_getitem_with_numpy_index_has_positional_metadata(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id9', 'description': 'dsc9'}, positional_metadata={'quality': np.arange(length)}) eseq = Sequence("0123fed9", metadata={'id': 'id9', 'description': 'dsc9'}, positional_metadata={'quality': [0, 1, 2, 3, 15, 14, 13, 9]}) self.assertEqual(seq[np.array([0, 1, 2, 3, 15, 14, 13, 9])], eseq) def test_getitem_with_numpy_index_no_positional_metadata(self): s = "0123456789abcdef" seq = Sequence(s, metadata={'id': 'id10', 'description': 'dsc10'}) eseq = Sequence("0123fed9", metadata={'id': 'id10', 'description': 'dsc10'}) self.assertEqual(seq[np.array([0, 1, 2, 3, 15, 14, 13, 9])], eseq) def test_getitem_with_empty_indices_empty_seq_no_pos_metadata(self): s = "" seq = Sequence(s, metadata={'id': 'id10', 'description': 'dsc10'}) eseq = Sequence('', metadata={'id': 'id10', 'description': 'dsc10'}) tested = 0 for index in self.getitem_empty_indices: tested += 1 self.assertEqual(seq[index], eseq) self.assertEqual(tested, 6) def test_getitem_with_empty_indices_non_empty_seq_no_pos_metadata(self): s = "0123456789abcdef" seq = Sequence(s, metadata={'id': 'id10', 'description': 'dsc10'}) eseq = Sequence('', metadata={'id': 'id10', 'description': 'dsc10'}) tested = 0 for index in self.getitem_empty_indices: tested += 1 self.assertEqual(seq[index], eseq) self.assertEqual(tested, 6) def test_getitem_with_boolean_vector_has_qual(self): s = "0123456789abcdef" length = len(s) seq = Sequence(s, metadata={'id': 'id11', 'description': 'dsc11'}, positional_metadata={'quality': np.arange(length)}) eseq = Sequence("13579bdf", metadata={'id': 'id11', 'description': 'dsc11'}, positional_metadata={'quality': [1, 3, 5, 7, 9, 11, 13, 15]}) self.assertEqual(seq[np.array([False, True] * 8)], eseq) self.assertEqual(seq[[False, True] * 8], eseq) def test_getitem_with_boolean_vector_no_positional_metadata(self): s = "0123456789abcdef" seq = Sequence(s, metadata={'id': 'id11', 'description': 'dsc11'}) eseq = Sequence("13579bdf", metadata={'id': 'id11', 'description': 'dsc11'}) self.assertEqual(seq[np.array([False, True] * 8)], eseq) def test_getitem_with_invalid(self): seq = Sequence("123456", metadata={'id': 'idm', 'description': 'description'}, positional_metadata={'quality': [1, 2, 3, 4, 5, 6]}) with self.assertRaises(IndexError): seq['not an index'] with self.assertRaises(IndexError): seq[['1', '2']] with self.assertRaises(IndexError): seq[[1, slice(1, 2), 'a']] with self.assertRaises(IndexError): seq[[1, slice(1, 2), True]] with self.assertRaises(IndexError): seq[True] with self.assertRaises(IndexError): seq[np.array([True, False])] with self.assertRaises(IndexError): seq[999] with self.assertRaises(IndexError): seq[0, 0, 999] # numpy 1.8.1 and 1.9.2 raise different error types # (ValueError, IndexError). with self.assertRaises(Exception): seq[100 * [True, False, True]] def test_getitem_empty_positional_metadata(self): seq = Sequence('ACGT') seq.positional_metadata # This will create empty positional_metadata self.assertEqual(Sequence('A'), seq[0]) def test_len(self): self.assertEqual(len(Sequence("")), 0) self.assertEqual(len(Sequence("a")), 1) self.assertEqual(len(Sequence("abcdef")), 6) def test_nonzero(self): # blank self.assertFalse(Sequence("")) self.assertFalse(Sequence("", metadata={'id': 'foo'}, positional_metadata={'quality': range(0)})) # single self.assertTrue(Sequence("A")) self.assertTrue(Sequence("A", metadata={'id': 'foo'}, positional_metadata={'quality': range(1)})) # multi self.assertTrue(Sequence("ACGT")) self.assertTrue(Sequence("ACGT", metadata={'id': 'foo'}, positional_metadata={'quality': range(4)})) def test_contains(self): seq = Sequence("#@ACGT,24.13**02") tested = 0 for c in self.sequence_kinds: tested += 1 self.assertTrue(c(',24') in seq) self.assertTrue(c('*') in seq) self.assertTrue(c('') in seq) self.assertFalse(c("$") in seq) self.assertFalse(c("AGT") in seq) self.assertEqual(tested, 4) def test_contains_sequence_subclass(self): with self.assertRaises(TypeError): SequenceSubclass("A") in Sequence("AAA") self.assertTrue(SequenceSubclass("A").values in Sequence("AAA")) def test_hash(self): with self.assertRaises(TypeError): hash(Sequence("ABCDEFG")) self.assertNotIsInstance(Sequence("ABCDEFG"), Hashable) def test_iter_has_positional_metadata(self): tested = False seq = Sequence("0123456789", metadata={'id': 'a', 'desc': 'b'}, positional_metadata={'qual': np.arange(10)}) for i, s in enumerate(seq): tested = True self.assertEqual(s, Sequence(str(i), metadata={'id': 'a', 'desc': 'b'}, positional_metadata={'qual': [i]})) self.assertTrue(tested) def test_iter_no_positional_metadata(self): tested = False seq = Sequence("0123456789", metadata={'id': 'a', 'desc': 'b'}) for i, s in enumerate(seq): tested = True self.assertEqual(s, Sequence(str(i), metadata={'id': 'a', 'desc': 'b'})) self.assertTrue(tested) def test_reversed_has_positional_metadata(self): tested = False seq = Sequence("0123456789", metadata={'id': 'a', 'desc': 'b'}, positional_metadata={'qual': np.arange(10)}) for i, s in enumerate(reversed(seq)): tested = True self.assertEqual(s, Sequence(str(9 - i), metadata={'id': 'a', 'desc': 'b'}, positional_metadata={'qual': [9 - i]})) self.assertTrue(tested) def test_reversed_no_positional_metadata(self): tested = False seq = Sequence("0123456789", metadata={'id': 'a', 'desc': 'b'}) for i, s in enumerate(reversed(seq)): tested = True self.assertEqual(s, Sequence(str(9 - i), metadata={'id': 'a', 'desc': 'b'})) self.assertTrue(tested) def test_repr(self): # basic sanity checks -- more extensive testing of formatting and # special cases is performed in SequenceReprDoctests below. here we # only test that pieces of the repr are present. these tests also # exercise coverage in case doctests stop counting towards coverage in # the future # minimal obs = repr(Sequence('')) self.assertEqual(obs.count('\n'), 4) self.assertTrue(obs.startswith('Sequence')) self.assertIn('length: 0', obs) self.assertTrue(obs.endswith('-')) # no metadata obs = repr(Sequence('ACGT')) self.assertEqual(obs.count('\n'), 5) self.assertTrue(obs.startswith('Sequence')) self.assertIn('length: 4', obs) self.assertTrue(obs.endswith('0 ACGT')) # metadata and positional metadata of mixed types obs = repr( Sequence( 'ACGT', metadata={'foo': 'bar', b'bar': 33.33, None: True, False: {}, (1, 2): 3, 'acb' * 100: "'", 10: 11}, positional_metadata={'foo': range(4), 42: ['a', 'b', [], 'c']})) self.assertEqual(obs.count('\n'), 16) self.assertTrue(obs.startswith('Sequence')) self.assertIn('None: True', obs) self.assertIn('\'foo\': \'bar\'', obs) self.assertIn('42: ', obs) self.assertIn('\'foo\': ', obs) self.assertIn('length: 4', obs) self.assertTrue(obs.endswith('0 ACGT')) # sequence spanning > 5 lines obs = repr(Sequence('A' * 301)) self.assertEqual(obs.count('\n'), 9) self.assertTrue(obs.startswith('Sequence')) self.assertIn('length: 301', obs) self.assertIn('...', obs) self.assertTrue(obs.endswith('300 A')) def test_str(self): self.assertEqual(str(Sequence("GATTACA")), "GATTACA") self.assertEqual(str(Sequence("ACCGGTACC")), "ACCGGTACC") self.assertEqual(str(Sequence("GREG")), "GREG") self.assertEqual( str(Sequence("ABC", positional_metadata={'quality': [1, 2, 3]})), "ABC") self.assertIs(type(str(Sequence("A"))), str) def test_count(self): def construct_char_array(s): return np.frombuffer(s.encode('ascii'), dtype='|S1') def construct_uint8_array(s): return np.frombuffer(s.encode('ascii'), dtype=np.uint8) seq = Sequence("1234567899876555") tested = 0 for c in self.sequence_kinds: tested += 1 self.assertEqual(seq.count(c('4')), 1) self.assertEqual(seq.count(c('8')), 2) self.assertEqual(seq.count(c('5')), 4) self.assertEqual(seq.count(c('555')), 1) self.assertEqual(seq.count(c('555'), 0, 4), 0) self.assertEqual(seq.count(c('555'), start=0, end=4), 0) self.assertEqual(seq.count(c('5'), start=10), 3) self.assertEqual(seq.count(c('5'), end=10), 1) with self.assertRaises(ValueError): seq.count(c('')) self.assertEqual(tested, 4) def test_count_on_subclass(self): with self.assertRaises(TypeError) as cm: Sequence("abcd").count(SequenceSubclass("a")) self.assertIn("Sequence", str(cm.exception)) self.assertIn("SequenceSubclass", str(cm.exception)) def test_replace_sanity(self): seq = Sequence('AAGCATGCCCTTTACATTTG') index = self._make_index('10011011001111110111') obs = seq.replace(index, '_') exp = Sequence('_AG__T__CC______T___') self.assertEqual(obs, exp) def test_replace_index_array(self): seq = Sequence('TCGGGTGTTGTGCAACCACC') for _type in list, tuple, np.array, pd.Series: index = _type([0, 2, 5, 8, 9]) obs = seq.replace(index, '-') exp = Sequence('-C-GG-GT--TGCAACCACC') self.assertEqual(obs, exp) def test_replace_iterable_slices(self): seq = Sequence('CATTATGGACCCAGCGTGCC') slices = (slice(0, 5), slice(8, 12), slice(15, 17)) mixed_slices = (0, 1, 2, 3, 4, slice(8, 12), 15, 16) for _type in (lambda x: x, list, tuple, lambda x: np.array(tuple(x)), lambda x: pd.Series(tuple(x))): index = (_type(slices), _type(mixed_slices)) obs_slices = seq.replace(index[0], '-') obs_mixed = seq.replace(index[1], '-') exp = Sequence('-----TGG----AGC--GCC') self.assertEqual(obs_slices, exp) self.assertEqual(obs_mixed, exp) def test_replace_index_in_positional_metadata(self): positional_metadata = {'where': self._make_index('001110110' '10001110000')} seq = Sequence('AAGATTGATACCACAGTTGT', positional_metadata=positional_metadata) obs = seq.replace('where', '-') exp = Sequence('AA---T--T-CCA---TTGT', positional_metadata=positional_metadata) self.assertEqual(obs, exp) def test_replace_does_not_mutate_original(self): seq = Sequence('ATCG') index = self._make_index('0011') seq.replace(index, '-') obs = seq exp = Sequence('ATCG') self.assertEqual(obs, exp) def test_replace_with_metadata(self): seq = Sequence('GCACGGCAAGAAGCGCCCCA', metadata={'NM': 'Kestrel Gorlick'}, positional_metadata={'diff': list('01100001110010001100')}) seq.interval_metadata.add([(0, 1)], metadata={'gene': 'sagA'}) index = self._make_index('01100001110010001100') obs = seq.replace(index, '-') exp = Sequence('G--CGGC---AA-CGC--CA', metadata={'NM': 'Kestrel Gorlick'}, positional_metadata={'diff': list('01100001110010001100')}) exp.interval_metadata.add([(0, 1)], metadata={'gene': 'sagA'}) self.assertEqual(obs, exp) def test_replace_with_subclass(self): seq = DNA('CGACAACCGATGTGCTGTAA') index = self._make_index('10101000111111110011') obs = seq.replace(index, '-') exp = DNA('-G-C-ACC--------GT--') self.assertEqual(obs, exp) def test_replace_with_bytes(self): seq = Sequence('ABC123') obs = seq.replace([1, 3, 5], b'*') self.assertEqual(obs, Sequence('A*C*2*')) def test_replace_invalid_char_for_type_error(self): seq = DNA('TAAACGGAACGCTACGTCTG') index = self._make_index('01000001101011001001') with self.assertRaisesRegex(ValueError, r"Invalid character.*'F'"): seq.replace(index, 'F') def test_replace_invalid_char_error(self): seq = Sequence('GGGAGCTAGA') index = self._make_index('1000101110') with self.assertRaisesRegex(UnicodeEncodeError, r"can't encode character.*not in " r"range\(128\)"): seq.replace(index, '\uFFFF') def test_replace_non_single_character_error(self): seq = Sequence('CCGAACTGTC') index = self._make_index('1100110011') with self.assertRaisesRegex(TypeError, r'string of length 2 found'): seq.replace(index, 'AB') def _make_index(self, bools): return [bool(int(char)) for char in bools] def test_lowercase_mungeable_key(self): # NOTE: This test relies on Sequence._munge_to_index_array working # properly. If the internal implementation of the lowercase method # changes to no longer use _munge_to_index_array, this test may need # to be updated to cover cases currently covered by # _munge_to_index_array self.assertEqual('AAAAaaaa', self.lowercase_seq.lowercase('key')) def test_lowercase_array_key(self): # NOTE: This test relies on Sequence._munge_to_index_array working # properly. If the internal implementation of the lowercase method # changes to no longer use _munge_to_index_array, this test may need # to be updated to cover cases currently covered by # _munge_to_index_array self.assertEqual('aaAAaaaa', self.lowercase_seq.lowercase( np.array([True, True, False, False, True, True, True, True]))) self.assertEqual('AaAAaAAA', self.lowercase_seq.lowercase([1, 4])) def test_matches(self): tested = 0 for constructor in self.sequence_kinds: tested += 1 seq1 = Sequence("AACCEEGG") seq2 = constructor("ABCDEFGH") expected = np.array([True, False] * 4) npt.assert_equal(seq1.matches(seq2), expected) self.assertEqual(tested, 4) def test_matches_on_subclass(self): seq1 = Sequence("AACCEEGG") seq2 = SequenceSubclass("ABCDEFGH") with self.assertRaises(TypeError): seq1.matches(seq2) def test_matches_unequal_length(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("TOOLONGTOCOMPARE") with self.assertRaises(ValueError): seq1.matches(seq2) def test_mismatches(self): tested = 0 for constructor in self.sequence_kinds: tested += 1 seq1 = Sequence("AACCEEGG") seq2 = constructor("ABCDEFGH") expected = np.array([False, True] * 4) npt.assert_equal(seq1.mismatches(seq2), expected) self.assertEqual(tested, 4) def test_mismatches_on_subclass(self): seq1 = Sequence("AACCEEGG") seq2 = SequenceSubclass("ABCDEFGH") with self.assertRaises(TypeError): seq1.mismatches(seq2) def test_mismatches_unequal_length(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("TOOLONGTOCOMPARE") with self.assertRaises(ValueError): seq1.mismatches(seq2) def test_mismatch_frequency(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("ABCDEFGH") seq3 = Sequence("TTTTTTTT") self.assertIs(type(seq1.mismatch_frequency(seq1)), int) self.assertEqual(seq1.mismatch_frequency(seq1), 0) self.assertEqual(seq1.mismatch_frequency(seq2), 4) self.assertEqual(seq1.mismatch_frequency(seq3), 8) def test_mismatch_frequency_relative(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("ABCDEFGH") seq3 = Sequence("TTTTTTTT") self.assertIs(type(seq1.mismatch_frequency(seq1, relative=True)), float) self.assertEqual(seq1.mismatch_frequency(seq1, relative=True), 0.0) self.assertEqual(seq1.mismatch_frequency(seq2, relative=True), 0.5) self.assertEqual(seq1.mismatch_frequency(seq3, relative=True), 1.0) def test_mismatch_frequency_unequal_length(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("TOOLONGTOCOMPARE") with self.assertRaises(ValueError): seq1.mismatch_frequency(seq2) def test_mismatch_frequence_on_subclass(self): seq1 = Sequence("AACCEEGG") seq2 = SequenceSubclass("ABCDEFGH") with self.assertRaises(TypeError): seq1.mismatch_frequency(seq2) def test_match_frequency(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("ABCDEFGH") seq3 = Sequence("TTTTTTTT") self.assertIs(type(seq1.match_frequency(seq1)), int) self.assertEqual(seq1.match_frequency(seq1), 8) self.assertEqual(seq1.match_frequency(seq2), 4) self.assertEqual(seq1.match_frequency(seq3), 0) def test_match_frequency_relative(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("ABCDEFGH") seq3 = Sequence("TTTTTTTT") self.assertIs(type(seq1.match_frequency(seq1, relative=True)), float) self.assertEqual(seq1.match_frequency(seq1, relative=True), 1.0) self.assertEqual(seq1.match_frequency(seq2, relative=True), 0.5) self.assertEqual(seq1.match_frequency(seq3, relative=True), 0.0) def test_match_frequency_unequal_length(self): seq1 = Sequence("AACCEEGG") seq2 = Sequence("TOOLONGTOCOMPARE") with self.assertRaises(ValueError): seq1.match_frequency(seq2) def test_match_frequency_on_subclass(self): seq1 = Sequence("AACCEEGG") seq2 = SequenceSubclass("ABCDEFGH") with self.assertRaises(TypeError): seq1.match_frequency(seq2) def test_index(self): tested = 0 for c in self.sequence_kinds: tested += 1 seq = Sequence("ABCDEFG@@ABCDFOO") self.assertEqual(seq.index(c("A")), 0) self.assertEqual(seq.index(c("@")), 7) self.assertEqual(seq.index(c("@@")), 7) with self.assertRaises(ValueError): seq.index("A", start=1, end=5) self.assertEqual(tested, 4) def test_index_on_subclass(self): with self.assertRaises(TypeError): Sequence("ABCDEFG").index(SequenceSubclass("A")) self.assertEqual( SequenceSubclass("ABCDEFG").index(SequenceSubclass("A")), 0) def test_frequencies_empty_sequence(self): seq = Sequence('') self.assertEqual(seq.frequencies(), {}) self.assertEqual(seq.frequencies(relative=True), {}) self.assertEqual(seq.frequencies(chars=set()), {}) self.assertEqual(seq.frequencies(chars=set(), relative=True), {}) self.assertEqual(seq.frequencies(chars={'a', 'b'}), {'a': 0, 'b': 0}) # use npt.assert_equal to explicitly handle nan comparisons npt.assert_equal(seq.frequencies(chars={'a', 'b'}, relative=True), {'a': np.nan, 'b': np.nan}) def test_frequencies_observed_chars(self): seq = Sequence('x') self.assertEqual(seq.frequencies(), {'x': 1}) self.assertEqual(seq.frequencies(relative=True), {'x': 1.0}) seq = Sequence('xYz') self.assertEqual(seq.frequencies(), {'x': 1, 'Y': 1, 'z': 1}) self.assertEqual(seq.frequencies(relative=True), {'x': 1/3, 'Y': 1/3, 'z': 1/3}) seq = Sequence('zzz') self.assertEqual(seq.frequencies(), {'z': 3}) self.assertEqual(seq.frequencies(relative=True), {'z': 1.0}) seq = Sequence('xYzxxZz') self.assertEqual(seq.frequencies(), {'x': 3, 'Y': 1, 'Z': 1, 'z': 2}) self.assertEqual(seq.frequencies(relative=True), {'x': 3/7, 'Y': 1/7, 'Z': 1/7, 'z': 2/7}) seq = Sequence('\t ') self.assertEqual(seq.frequencies(), {'\t': 1, ' ': 3}) self.assertEqual(seq.frequencies(relative=True), {'\t': 1/4, ' ': 3/4}) seq = Sequence('aabbcc', metadata={'foo': 'bar'}, positional_metadata={'foo': range(6)}) self.assertEqual(seq.frequencies(), {'a': 2, 'b': 2, 'c': 2}) self.assertEqual(seq.frequencies(relative=True), {'a': 2/6, 'b': 2/6, 'c': 2/6}) def test_frequencies_specified_chars(self): seq = Sequence('abcbca') self.assertEqual(seq.frequencies(chars=set()), {}) self.assertEqual(seq.frequencies(chars=set(), relative=True), {}) self.assertEqual(seq.frequencies(chars='a'), {'a': 2}) self.assertEqual(seq.frequencies(chars='a', relative=True), {'a': 2/6}) self.assertEqual(seq.frequencies(chars={'a'}), {'a': 2}) self.assertEqual(seq.frequencies(chars={'a'}, relative=True), {'a': 2/6}) self.assertEqual(seq.frequencies(chars={'a', 'b'}), {'a': 2, 'b': 2}) self.assertEqual(seq.frequencies(chars={'a', 'b'}, relative=True), {'a': 2/6, 'b': 2/6}) self.assertEqual(seq.frequencies(chars={'a', 'b', 'd'}), {'a': 2, 'b': 2, 'd': 0}) self.assertEqual(seq.frequencies(chars={'a', 'b', 'd'}, relative=True), {'a': 2/6, 'b': 2/6, 'd': 0.0}) self.assertEqual(seq.frequencies(chars={'x', 'y', 'z'}), {'x': 0, 'y': 0, 'z': 0}) self.assertEqual(seq.frequencies(chars={'x', 'y', 'z'}, relative=True), {'x': 0.0, 'y': 0.0, 'z': 0.0}) def test_frequencies_chars_varied_type(self): seq = Sequence('zabczzzabcz') # single character case (shortcut) chars = b'z' self.assertEqual(seq.frequencies(chars=chars), {b'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {b'z': 5/11}) chars = 'z' self.assertEqual(seq.frequencies(chars=chars), {'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {'z': 5/11}) chars = np.frombuffer('z'.encode('ascii'), dtype='|S1')[0] self.assertEqual(seq.frequencies(chars=chars), {b'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {b'z': 5/11}) # set of characters, some present, some not chars = {b'x', b'z'} self.assertEqual(seq.frequencies(chars=chars), {b'x': 0, b'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {b'x': 0.0, b'z': 5/11}) chars = {'x', 'z'} self.assertEqual(seq.frequencies(chars=chars), {'x': 0, 'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {'x': 0.0, 'z': 5/11}) chars = { np.frombuffer('x'.encode('ascii'), dtype='|S1')[0], np.frombuffer('z'.encode('ascii'), dtype='|S1')[0] } self.assertEqual(seq.frequencies(chars=chars), {b'x': 0, b'z': 5}) self.assertEqual(seq.frequencies(chars=chars, relative=True), {b'x': 0.0, b'z': 5/11}) def test_frequencies_equivalent_to_kmer_frequencies_k_of_1(self): seq = Sequence('abcabc') exp = {'a': 2, 'b': 2, 'c': 2} self.assertEqual(seq.frequencies(chars=None), exp) self.assertEqual(seq.kmer_frequencies(k=1), exp) exp = {'a': 2/6, 'b': 2/6, 'c': 2/6} self.assertEqual(seq.frequencies(chars=None, relative=True), exp) self.assertEqual(seq.kmer_frequencies(k=1, relative=True), exp) def test_frequencies_passing_observed_chars_equivalent_to_default(self): seq = Sequence('abcabc') exp = {'a': 2, 'b': 2, 'c': 2} self.assertEqual(seq.frequencies(chars=None), exp) self.assertEqual(seq.frequencies(chars=seq.observed_chars), exp) exp = {'a': 2/6, 'b': 2/6, 'c': 2/6} self.assertEqual(seq.frequencies(chars=None, relative=True), exp) self.assertEqual( seq.frequencies(chars=seq.observed_chars, relative=True), exp) def test_frequencies_invalid_chars(self): seq = Sequence('abcabc') with self.assertRaisesRegex(ValueError, r'0 characters'): seq.frequencies(chars='') with self.assertRaisesRegex(ValueError, r'0 characters'): seq.frequencies(chars={''}) with self.assertRaisesRegex(ValueError, r'2 characters'): seq.frequencies(chars='ab') with self.assertRaisesRegex(ValueError, r'2 characters'): seq.frequencies(chars={'b', 'ab'}) with self.assertRaisesRegex(TypeError, r'string.*NoneType'): seq.frequencies(chars={'a', None}) with self.assertRaisesRegex(ValueError, r'outside the range'): seq.frequencies(chars='\u1F30') with self.assertRaisesRegex(ValueError, r'outside the range'): seq.frequencies(chars={'c', '\u1F30'}) with self.assertRaisesRegex(TypeError, r'set.*int'): seq.frequencies(chars=42) def _compare_kmers_results(self, observed, expected): for obs, exp in itertools.zip_longest(observed, expected, fillvalue=None): self.assertEqual(obs, exp) def test_iter_kmers(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) expected = [ Sequence('G', positional_metadata={'quality': [0]}), Sequence('A', positional_metadata={'quality': [1]}), Sequence('T', positional_metadata={'quality': [2]}), Sequence('T', positional_metadata={'quality': [3]}), Sequence('A', positional_metadata={'quality': [4]}), Sequence('C', positional_metadata={'quality': [5]}), Sequence('A', positional_metadata={'quality': [6]}) ] self._compare_kmers_results( seq.iter_kmers(1, overlap=False), expected) expected = [ Sequence('GA', positional_metadata={'quality': [0, 1]}), Sequence('TT', positional_metadata={'quality': [2, 3]}), Sequence('AC', positional_metadata={'quality': [4, 5]}) ] self._compare_kmers_results( seq.iter_kmers(2, overlap=False), expected) expected = [ Sequence('GAT', positional_metadata={'quality': [0, 1, 2]}), Sequence('TAC', positional_metadata={'quality': [3, 4, 5]}) ] self._compare_kmers_results( seq.iter_kmers(3, overlap=False), expected) expected = [ Sequence('GATTACA', positional_metadata={'quality': [0, 1, 2, 3, 4, 5, 6]}) ] self._compare_kmers_results( seq.iter_kmers(7, overlap=False), expected) expected = [] self._compare_kmers_results( seq.iter_kmers(8, overlap=False), expected) self.assertIs(type(seq.iter_kmers(1)), GeneratorType) def test_iter_kmers_no_positional_metadata(self): seq = Sequence('GATTACA') expected = [ Sequence('G'), Sequence('A'), Sequence('T'), Sequence('T'), Sequence('A'), Sequence('C'), Sequence('A') ] self._compare_kmers_results( seq.iter_kmers(1, overlap=False), expected) expected = [ Sequence('GA'), Sequence('TT'), Sequence('AC') ] self._compare_kmers_results( seq.iter_kmers(2, overlap=False), expected) expected = [ Sequence('GAT'), Sequence('TAC') ] self._compare_kmers_results( seq.iter_kmers(3, overlap=False), expected) expected = [ Sequence('GATTACA') ] self._compare_kmers_results( seq.iter_kmers(7, overlap=False), expected) expected = [] self._compare_kmers_results( seq.iter_kmers(8, overlap=False), expected) self.assertIs(type(seq.iter_kmers(1)), GeneratorType) def test_iter_kmers_with_overlap(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) expected = [ Sequence('G', positional_metadata={'quality': [0]}), Sequence('A', positional_metadata={'quality': [1]}), Sequence('T', positional_metadata={'quality': [2]}), Sequence('T', positional_metadata={'quality': [3]}), Sequence('A', positional_metadata={'quality': [4]}), Sequence('C', positional_metadata={'quality': [5]}), Sequence('A', positional_metadata={'quality': [6]}) ] self._compare_kmers_results( seq.iter_kmers(1, overlap=True), expected) expected = [ Sequence('GA', positional_metadata={'quality': [0, 1]}), Sequence('AT', positional_metadata={'quality': [1, 2]}), Sequence('TT', positional_metadata={'quality': [2, 3]}), Sequence('TA', positional_metadata={'quality': [3, 4]}), Sequence('AC', positional_metadata={'quality': [4, 5]}), Sequence('CA', positional_metadata={'quality': [5, 6]}) ] self._compare_kmers_results( seq.iter_kmers(2, overlap=True), expected) expected = [ Sequence('GAT', positional_metadata={'quality': [0, 1, 2]}), Sequence('ATT', positional_metadata={'quality': [1, 2, 3]}), Sequence('TTA', positional_metadata={'quality': [2, 3, 4]}), Sequence('TAC', positional_metadata={'quality': [3, 4, 5]}), Sequence('ACA', positional_metadata={'quality': [4, 5, 6]}) ] self._compare_kmers_results( seq.iter_kmers(3, overlap=True), expected) expected = [ Sequence('GATTACA', positional_metadata={'quality': [0, 1, 2, 3, 4, 5, 6]}) ] self._compare_kmers_results( seq.iter_kmers(7, overlap=True), expected) expected = [] self._compare_kmers_results( seq.iter_kmers(8, overlap=True), expected) self.assertIs(type(seq.iter_kmers(1)), GeneratorType) def test_iter_kmers_with_overlap_no_positional_metadata(self): seq = Sequence('GATTACA') expected = [ Sequence('G'), Sequence('A'), Sequence('T'), Sequence('T'), Sequence('A'), Sequence('C'), Sequence('A') ] self._compare_kmers_results( seq.iter_kmers(1, overlap=True), expected) expected = [ Sequence('GA'), Sequence('AT'), Sequence('TT'), Sequence('TA'), Sequence('AC'), Sequence('CA') ] self._compare_kmers_results( seq.iter_kmers(2, overlap=True), expected) expected = [ Sequence('GAT'), Sequence('ATT'), Sequence('TTA'), Sequence('TAC'), Sequence('ACA') ] self._compare_kmers_results( seq.iter_kmers(3, overlap=True), expected) expected = [ Sequence('GATTACA') ] self._compare_kmers_results( seq.iter_kmers(7, overlap=True), expected) expected = [] self._compare_kmers_results( seq.iter_kmers(8, overlap=True), expected) self.assertIs(type(seq.iter_kmers(1)), GeneratorType) def test_iter_kmers_invalid_k(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) with self.assertRaises(ValueError): list(seq.iter_kmers(0)) with self.assertRaises(ValueError): list(seq.iter_kmers(-42)) def test_iter_kmers_invalid_k_no_positional_metadata(self): seq = Sequence('GATTACA') with self.assertRaises(ValueError): list(seq.iter_kmers(0)) with self.assertRaises(ValueError): list(seq.iter_kmers(-42)) def test_iter_kmers_different_sequences(self): seq = Sequence('HE..--..LLO', metadata={'id': 'hello', 'desc': 'gapped hello'}, positional_metadata={'quality': range(11)}) expected = [ Sequence('HE.', positional_metadata={'quality': [0, 1, 2]}, metadata={'id': 'hello', 'desc': 'gapped hello'}), Sequence('.--', positional_metadata={'quality': [3, 4, 5]}, metadata={'id': 'hello', 'desc': 'gapped hello'}), Sequence('..L', positional_metadata={'quality': [6, 7, 8]}, metadata={'id': 'hello', 'desc': 'gapped hello'}) ] self._compare_kmers_results(seq.iter_kmers(3, overlap=False), expected) def test_iter_kmers_different_sequences_no_positional_metadata(self): seq = Sequence('HE..--..LLO', metadata={'id': 'hello', 'desc': 'gapped hello'}) expected = [ Sequence('HE.', metadata={'id': 'hello', 'desc': 'gapped hello'}), Sequence('.--', metadata={'id': 'hello', 'desc': 'gapped hello'}), Sequence('..L', metadata={'id': 'hello', 'desc': 'gapped hello'}) ] self._compare_kmers_results(seq.iter_kmers(3, overlap=False), expected) def test_iter_kmers_empty_sequence(self): seq = Sequence('') expected = [] self._compare_kmers_results(seq.iter_kmers(3, overlap=False), expected) def test_iter_kmers_empty_sequence_with_positional_metadata(self): seq = Sequence('', positional_metadata={'quality': []}) expected = [] self._compare_kmers_results(seq.iter_kmers(3, overlap=False), expected) def test_kmer_frequencies_empty_sequence(self): seq = Sequence('') self.assertEqual(seq.kmer_frequencies(1), {}) self.assertEqual(seq.kmer_frequencies(1, overlap=False), {}) self.assertEqual(seq.kmer_frequencies(1, relative=True), {}) self.assertEqual(seq.kmer_frequencies(1, relative=True, overlap=False), {}) def test_kmer_frequencies(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) # overlap = True expected = {'G': 1, 'A': 3, 'T': 2, 'C': 1} self.assertEqual(seq.kmer_frequencies(1, overlap=True), expected) expected = {'GAT': 1, 'ATT': 1, 'TTA': 1, 'TAC': 1, 'ACA': 1} self.assertEqual(seq.kmer_frequencies(3, overlap=True), expected) expected = {} self.assertEqual(seq.kmer_frequencies(8, overlap=True), expected) # overlap = False expected = {'GAT': 1, 'TAC': 1} self.assertEqual(seq.kmer_frequencies(3, overlap=False), expected) expected = {'GATTACA': 1} self.assertEqual(seq.kmer_frequencies(7, overlap=False), expected) expected = {} self.assertEqual(seq.kmer_frequencies(8, overlap=False), expected) def test_kmer_frequencies_relative(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) # overlap = True expected = {'A': 3/7, 'C': 1/7, 'G': 1/7, 'T': 2/7} self.assertEqual(seq.kmer_frequencies(1, overlap=True, relative=True), expected) expected = {'GAT': 1/5, 'ATT': 1/5, 'TTA': 1/5, 'TAC': 1/5, 'ACA': 1/5} self.assertEqual(seq.kmer_frequencies(3, overlap=True, relative=True), expected) expected = {} self.assertEqual(seq.kmer_frequencies(8, overlap=True, relative=True), expected) # overlap = False expected = {'GAT': 1/2, 'TAC': 1/2} self.assertEqual(seq.kmer_frequencies(3, overlap=False, relative=True), expected) expected = {'GATTACA': 1.0} self.assertEqual(seq.kmer_frequencies(7, overlap=False, relative=True), expected) expected = {} self.assertEqual(seq.kmer_frequencies(8, overlap=False, relative=True), expected) def test_kmer_frequencies_floating_point_precision(self): # Test that a sequence having no variation in k-words yields a # frequency of exactly 1.0. Note that it is important to use # self.assertEqual here instead of self.assertAlmostEqual because we # want to test for exactly 1.0. A previous implementation of # Sequence.kmer_frequencies(relative=True) added (1 / num_words) for # each occurrence of a k-word to compute the frequencies (see # https://github.com/biocore/scikit-bio/issues/801). In certain cases, # this yielded a frequency slightly less than 1.0 due to roundoff # error. The test case here uses a sequence with 10 characters that are # all identical and computes k-word frequencies with k=1. This test # case exposes the roundoff error present in the previous # implementation because there are 10 k-words (which are all # identical), so 1/10 added 10 times yields a number slightly less than # 1.0. This occurs because 1/10 cannot be represented exactly as a # floating point number. seq = Sequence('AAAAAAAAAA') self.assertEqual(seq.kmer_frequencies(1, relative=True), {'A': 1.0}) def test_find_with_regex(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) pat = re.compile('(T+A)(CA)') obs = list(seq.find_with_regex(pat)) exp = [slice(2, 5), slice(5, 7)] self.assertEqual(obs, exp) self.assertIs(type(seq.find_with_regex(pat)), GeneratorType) def test_find_with_regex_string_as_input(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) pat = '(T+A)(CA)' obs = list(seq.find_with_regex(pat)) exp = [slice(2, 5), slice(5, 7)] self.assertEqual(obs, exp) self.assertIs(type(seq.find_with_regex(pat)), GeneratorType) def test_find_with_regex_no_groups(self): seq = Sequence('GATTACA', positional_metadata={'quality': range(7)}) pat = re.compile('(FOO)') self.assertEqual(list(seq.find_with_regex(pat)), []) def test_find_with_regex_ignore_no_difference(self): seq = Sequence('..ABCDEFG..') pat = "([A-Z]+)" exp = [slice(2, 9)] self.assertEqual(list(seq.find_with_regex(pat)), exp) obs = seq.find_with_regex( pat, ignore=np.array([1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1], dtype=bool)) self.assertEqual(list(obs), exp) def test_find_with_regex_ignore(self): obs = Sequence('A..A..BBAAB.A..AB..A.').find_with_regex( "(A+)", ignore=np.array([0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1], dtype=bool)) self.assertEqual(list(obs), [slice(0, 4), slice(8, 10), slice(12, 16), slice(19, 20)]) def test_find_with_regex_ignore_index_array(self): obs = Sequence('A..A..BBAAB.A..AB..A.').find_with_regex( "(A+)", ignore=np.array([1, 2, 4, 5, 11, 13, 14, 17, 18, 20])) self.assertEqual(list(obs), [slice(0, 4), slice(8, 10), slice(12, 16), slice(19, 20)]) def test_iter_contiguous_index_array(self): s = Sequence("0123456789abcdef") for c in list, tuple, np.array, pd.Series: exp = [Sequence("0123"), Sequence("89ab")] obs = s.iter_contiguous(c([0, 1, 2, 3, 8, 9, 10, 11])) self.assertEqual(list(obs), exp) def test_iter_contiguous_boolean_vector(self): s = Sequence("0123456789abcdef") for c in list, tuple, np.array, pd.Series: exp = [Sequence("0123"), Sequence("89ab")] obs = s.iter_contiguous(c(([True] * 4 + [False] * 4) * 2)) self.assertEqual(list(obs), exp) def test_iter_contiguous_iterable_slices(self): def spaced_out(): yield slice(0, 4) yield slice(8, 12) def contiguous(): yield slice(0, 4) yield slice(4, 8) yield slice(12, 16) s = Sequence("0123456789abcdef") for c in (lambda x: x, list, tuple, lambda x: np.array(tuple(x)), lambda x: pd.Series(tuple(x))): exp = [Sequence("0123"), Sequence("89ab")] obs = s.iter_contiguous(c(spaced_out())) self.assertEqual(list(obs), exp) exp = [Sequence("01234567"), Sequence("cdef")] obs = s.iter_contiguous(c(contiguous())) self.assertEqual(list(obs), exp) def test_iter_contiguous_with_max_length(self): s = Sequence("0123456789abcdef") for c in list, tuple, np.array, pd.Series: exp = [Sequence("234"), Sequence("678"), Sequence("abc")] obs = s.iter_contiguous(c([True, False, True, True] * 4), min_length=3) self.assertEqual(list(obs), exp) exp = [Sequence("0"), Sequence("234"), Sequence("678"), Sequence("abc"), Sequence("ef")] obs1 = list(s.iter_contiguous(c([True, False, True, True] * 4), min_length=1)) obs2 = list(s.iter_contiguous(c([True, False, True, True] * 4))) self.assertEqual(obs1, obs2) self.assertEqual(obs1, exp) def test_iter_contiguous_with_invert(self): def spaced_out(): yield slice(0, 4) yield slice(8, 12) def contiguous(): yield slice(0, 4) yield slice(4, 8) yield slice(12, 16) s = Sequence("0123456789abcdef") for c in (lambda x: x, list, tuple, lambda x: np.array(tuple(x)), lambda x: pd.Series(tuple(x))): exp = [Sequence("4567"), Sequence("cdef")] obs = s.iter_contiguous(c(spaced_out()), invert=True) self.assertEqual(list(obs), exp) exp = [Sequence("89ab")] obs = s.iter_contiguous(c(contiguous()), invert=True) self.assertEqual(list(obs), exp) def test_copy_without_metadata(self): # shallow vs deep copy with sequence only should be equivalent for copy_method in copy.copy, copy.deepcopy: seq = Sequence('ACGT') seq_copy = copy_method(seq) self.assertEqual(seq_copy, seq) self.assertIsNot(seq_copy, seq) self.assertIsNot(seq_copy._bytes, seq._bytes) def test_copy_with_metadata_shallow(self): seq = Sequence('ACGT', metadata={'foo': [1]}, positional_metadata={'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]}) seq.interval_metadata.add([(0, 3)], metadata={'gene': ['sagA']}) seq_copy = copy.copy(seq) self.assertEqual(seq_copy, seq) self.assertIsNot(seq_copy, seq) self.assertIsNot(seq_copy._bytes, seq._bytes) self.assertIsNot(seq_copy._metadata, seq._metadata) self.assertIsNot(seq_copy._positional_metadata, seq._positional_metadata) self.assertIsNot(seq_copy._positional_metadata.values, seq._positional_metadata.values) self.assertIs(seq_copy._metadata['foo'], seq._metadata['foo']) self.assertIs(seq_copy._positional_metadata.loc[0, 'bar'], seq._positional_metadata.loc[0, 'bar']) self.assertIsNot(seq_copy.interval_metadata, seq.interval_metadata) self.assertIsNot(seq_copy.interval_metadata._intervals[0], seq.interval_metadata._intervals[0]) self.assertIsNot(seq_copy.interval_metadata._intervals[0].metadata, seq.interval_metadata._intervals[0].metadata) self.assertIs( seq_copy.interval_metadata._intervals[0].metadata['gene'], seq.interval_metadata._intervals[0].metadata['gene']) seq_copy.metadata['foo'].append(2) seq_copy.metadata['foo2'] = 42 self.assertEqual(seq_copy.metadata, {'foo': [1, 2], 'foo2': 42}) self.assertEqual(seq.metadata, {'foo': [1, 2]}) seq_copy.positional_metadata.loc[0, 'bar'].append(1) seq_copy.positional_metadata.loc[0, 'baz'] = 43 assert_data_frame_almost_equal( seq_copy.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [43, 42, 42, 42]})) assert_data_frame_almost_equal( seq.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [42, 42, 42, 42]})) def test_copy_with_metadata_deep(self): seq = Sequence('ACGT', metadata={'foo': [1]}, positional_metadata={'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]}) seq.interval_metadata.add([(0, 3)], metadata={'gene': ['sagA']}) seq_copy = copy.deepcopy(seq) self.assertEqual(seq_copy, seq) self.assertIsNot(seq_copy, seq) self.assertIsNot(seq_copy._bytes, seq._bytes) self.assertIsNot(seq_copy._metadata, seq._metadata) self.assertIsNot(seq_copy._positional_metadata, seq._positional_metadata) self.assertIsNot(seq_copy._positional_metadata.values, seq._positional_metadata.values) self.assertIsNot(seq_copy._metadata['foo'], seq._metadata['foo']) self.assertIsNot(seq_copy._positional_metadata.loc[0, 'bar'], seq._positional_metadata.loc[0, 'bar']) self.assertIsNot(seq_copy.interval_metadata, seq.interval_metadata) self.assertIsNot(seq_copy.interval_metadata._intervals[0], seq.interval_metadata._intervals[0]) self.assertIsNot(seq_copy.interval_metadata._intervals[0].metadata, seq.interval_metadata._intervals[0].metadata) self.assertIsNot( seq_copy.interval_metadata._intervals[0].metadata['gene'], seq.interval_metadata._intervals[0].metadata['gene']) seq_copy.metadata['foo'].append(2) seq_copy.metadata['foo2'] = 42 self.assertEqual(seq_copy.metadata, {'foo': [1, 2], 'foo2': 42}) self.assertEqual(seq.metadata, {'foo': [1]}) seq_copy.positional_metadata.loc[0, 'bar'].append(1) seq_copy.positional_metadata.loc[0, 'baz'] = 43 assert_data_frame_almost_equal( seq_copy.positional_metadata, pd.DataFrame({'bar': [[1], [], [], []], 'baz': [43, 42, 42, 42]})) assert_data_frame_almost_equal( seq.positional_metadata, pd.DataFrame({'bar': [[], [], [], []], 'baz': [42, 42, 42, 42]})) def test_copy_preserves_read_only_flag_on_bytes(self): seq = Sequence('ACGT') seq_copy = copy.copy(seq) with self.assertRaises(ValueError): seq_copy._bytes[0] = 'B' def test_deepcopy_memo_is_respected(self): # basic test to ensure deepcopy's memo is passed through to recursive # deepcopy calls seq = Sequence('ACGT', metadata={'foo': 'bar'}) memo = {} copy.deepcopy(seq, memo) self.assertGreater(len(memo), 2) def test_munge_to_index_array_valid_index_array(self): s = Sequence('123456') for c in list, tuple, np.array, pd.Series: exp = np.array([1, 2, 3], dtype=int) obs = s._munge_to_index_array(c([1, 2, 3])) npt.assert_equal(obs, exp) exp = np.array([1, 3, 5], dtype=int) obs = s._munge_to_index_array(c([1, 3, 5])) npt.assert_equal(obs, exp) def test_munge_to_index_array_invalid_index_array(self): s = Sequence("12345678") for c in list, tuple, np.array, pd.Series: with self.assertRaises(ValueError): s._munge_to_index_array(c([3, 2, 1])) with self.assertRaises(ValueError): s._munge_to_index_array(c([5, 6, 7, 2])) with self.assertRaises(ValueError): s._munge_to_index_array(c([0, 1, 2, 1])) def test_munge_to_index_array_valid_bool_array(self): s = Sequence('123456') for c in list, tuple, np.array, pd.Series: exp = np.array([2, 3, 5], dtype=int) obs = s._munge_to_index_array( c([False, False, True, True, False, True])) npt.assert_equal(obs, exp) exp = np.array([], dtype=int) obs = s._munge_to_index_array( c([False] * 6)) npt.assert_equal(obs, exp) exp = np.arange(6) obs = s._munge_to_index_array( c([True] * 6)) npt.assert_equal(obs, exp) def test_munge_to_index_array_invalid_bool_array(self): s = Sequence('123456') for c in (list, tuple, lambda x: np.array(x, dtype=bool), lambda x: pd.Series(x, dtype=bool)): with self.assertRaises(ValueError): s._munge_to_index_array(c([])) with self.assertRaises(ValueError): s._munge_to_index_array(c([True])) with self.assertRaises(ValueError): s._munge_to_index_array(c([True] * 10)) def test_munge_to_index_array_valid_iterable(self): s = Sequence('') def slices_only(): return (slice(i, i+1) for i in range(0, 10, 2)) def mixed(): return (slice(i, i+1) if i % 2 == 0 else i for i in range(10)) for c in (lambda x: x, list, tuple, lambda x: np.array(tuple(x)), lambda x: pd.Series(tuple(x))): exp = np.arange(10, dtype=int) obs = s._munge_to_index_array(c(mixed())) npt.assert_equal(obs, exp) exp = np.arange(10, step=2, dtype=int) obs = s._munge_to_index_array(c(slices_only())) npt.assert_equal(obs, exp) def test_munge_to_index_array_invalid_iterable(self): s = Sequence('') def bad1(): yield "r" yield [1, 2, 3] def bad2(): yield 1 yield 'str' def bad3(): yield False yield True yield 2 def bad4(): yield np.array([False, True]) yield slice(2, 5) for c in (lambda x: x, list, tuple, lambda x: np.array(tuple(x)), lambda x: pd.Series(tuple(x))): with self.assertRaises(TypeError): s._munge_to_index_array(bad1()) with self.assertRaises(TypeError): s._munge_to_index_array(bad2()) with self.assertRaises(TypeError): s._munge_to_index_array(bad3()) with self.assertRaises(TypeError): s._munge_to_index_array(bad4()) def test_munge_to_index_array_valid_string(self): seq = Sequence('ACGTACGT', positional_metadata={'introns': [False, True, True, False, False, True, False, False]}) npt.assert_equal(np.array([1, 2, 5]), seq._munge_to_index_array('introns')) seq.positional_metadata['exons'] = ~seq.positional_metadata['introns'] npt.assert_equal(np.array([0, 3, 4, 6, 7]), seq._munge_to_index_array('exons')) def test_munge_to_index_array_invalid_string(self): seq_str = 'ACGT' seq = Sequence(seq_str, positional_metadata={'quality': range(len(seq_str))}) with self.assertRaisesRegex(ValueError, r"No positional metadata associated with " "key 'introns'"): seq._munge_to_index_array('introns') with self.assertRaisesRegex(TypeError, r"Column 'quality' in positional metadata " "does not correspond to a boolean " "vector"): seq._munge_to_index_array('quality') def test_munge_to_bytestring_return_bytes(self): seq = Sequence('') m = 'dummy_method' str_inputs = ('', 'a', 'acgt') unicode_inputs = ('', 'a', 'acgt') byte_inputs = (b'', b'a', b'acgt') seq_inputs = (Sequence(''), Sequence('a'), Sequence('acgt')) all_inputs = str_inputs + unicode_inputs + byte_inputs + seq_inputs all_expected = [b'', b'a', b'acgt'] * 4 for input_, expected in zip(all_inputs, all_expected): observed = seq._munge_to_bytestring(input_, m) self.assertEqual(observed, expected) self.assertIs(type(observed), bytes) def test_munge_to_bytestring_unicode_out_of_ascii_range(self): seq = Sequence('') all_inputs = ('\x80', 'abc\x80', '\x80abc') for input_ in all_inputs: with self.assertRaisesRegex(UnicodeEncodeError, r"'ascii' codec can't encode character" r".*in position.*: ordinal not in" r" range\(128\)"): seq._munge_to_bytestring(input_, 'dummy_method') class TestDistance(TestSequenceBase): def test_mungeable_inputs_to_sequence(self): def metric(a, b): self.assertEqual(a, Sequence("abcdef")) self.assertEqual(b, Sequence("12bcef")) return 42.0 for constructor in self.sequence_kinds: seq1 = Sequence("abcdef") seq2 = constructor("12bcef") distance = seq1.distance(seq2, metric=metric) self.assertEqual(distance, 42.0) def test_mungeable_inputs_to_sequence_subclass(self): def metric(a, b): self.assertEqual(a, SequenceSubclass("abcdef")) self.assertEqual(b, SequenceSubclass("12bcef")) return -42.0 sequence_kinds = frozenset([ str, SequenceSubclass, lambda s: np.frombuffer(s.encode('ascii'), dtype='|S1'), lambda s: np.frombuffer(s.encode('ascii'), dtype=np.uint8)]) for constructor in sequence_kinds: seq1 = SequenceSubclass("abcdef") seq2 = constructor("12bcef") distance = seq1.distance(seq2, metric=metric) self.assertEqual(distance, -42.0) def test_sequence_type_mismatch(self): seq1 = SequenceSubclass("abcdef") seq2 = Sequence("12bcef") with self.assertRaisesRegex(TypeError, r'SequenceSubclass.*Sequence.*`distance`'): seq1.distance(seq2) with self.assertRaisesRegex(TypeError, r'Sequence.*SequenceSubclass.*`distance`'): seq2.distance(seq1) def test_munging_invalid_characters_to_self_type(self): with self.assertRaisesRegex(ValueError, r'Invalid characters.*X'): DNA("ACGT").distance("WXYZ") def test_munging_invalid_type_to_self_type(self): with self.assertRaises(TypeError): Sequence("ACGT").distance(42) def test_return_type_coercion(self): def metric(a, b): return 42 distance = Sequence('abc').distance('cba', metric=metric) self.assertIsInstance(distance, float) def test_invalid_return_type(self): def metric(a, b): return 'too far' with self.assertRaisesRegex(ValueError, r'string.*float'): Sequence('abc').distance('cba', metric=metric) def test_arbitrary_metric(self): def metric(x, y): return len(x) ** 2 + len(y) ** 2 seq1 = Sequence("12345678") seq2 = Sequence("1234") distance = seq1.distance(seq2, metric=metric) self.assertEqual(distance, 80.0) def test_scipy_hamming_metric_with_metadata(self): # test for #1254 seqs1 = [ Sequence("ACGT"), Sequence("ACGT", metadata={'id': 'abc'}), Sequence("ACGT", positional_metadata={'qual': range(4)}) ] seqs2 = [ Sequence("AAAA"), Sequence("AAAA", metadata={'id': 'def'}), Sequence("AAAA", positional_metadata={'qual': range(4, 8)}) ] for seqs in seqs1, seqs2: for seq1, seq2 in itertools.product(seqs, repeat=2): distance = seq1.distance(seq2, metric=scipy.spatial.distance.hamming) self.assertEqual(distance, 0.0) for seq1, seq2 in itertools.product(seqs1, seqs2): distance = seq1.distance(seq2, metric=scipy.spatial.distance.hamming) self.assertEqual(distance, 0.75) def test_default_metric_with_metadata(self): # test for #1254 seqs1 = [ Sequence("ACGT"), Sequence("ACGT", metadata={'id': 'abc'}), Sequence("ACGT", positional_metadata={'qual': range(4)}) ] seqs2 = [ Sequence("AAAA"), Sequence("AAAA", metadata={'id': 'def'}), Sequence("AAAA", positional_metadata={'qual': range(4, 8)}) ] for seqs in seqs1, seqs2: for seq1, seq2 in itertools.product(seqs, repeat=2): distance = seq1.distance(seq2) self.assertEqual(distance, 0.0) for seq1, seq2 in itertools.product(seqs1, seqs2): distance = seq1.distance(seq2) self.assertEqual(distance, 0.75) def test_default_metric_matches_hamming(self): seq1 = Sequence("abcdef") seq2 = Sequence("12bcef") seq_wrong = Sequence("abcdefghijklmnop") distance1 = seq1.distance(seq2) distance2 = skbio.sequence.distance.hamming(seq1, seq2) self.assertEqual(distance1, distance2) with self.assertRaises(ValueError): seq1.distance(seq_wrong) with self.assertRaises(ValueError): seq_wrong.distance(seq1) # NOTE: this must be a *separate* class for doctests only (no unit tests). nose # will not run the unit tests otherwise # # these doctests exercise the correct formatting of Sequence's repr in a # variety of situations. they are more extensive than the unit tests above # (TestSequence.test_repr) but cannot be relied upon for coverage (the unit # tests take care of this) class SequenceReprDoctests: r""">>> import pandas as pd >>> from skbio import Sequence Empty (minimal) sequence: >>> Sequence('') Sequence ------------- Stats: length: 0 ------------- Single character sequence: >>> Sequence('G') Sequence ------------- Stats: length: 1 ------------- 0 G Multicharacter sequence: >>> Sequence('ACGT') Sequence ------------- Stats: length: 4 ------------- 0 ACGT Full single line: >>> Sequence('A' * 60) Sequence ------------------------------------------------------------------- Stats: length: 60 ------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA Full single line with 1 character overflow: >>> Sequence('A' * 61) Sequence -------------------------------------------------------------------- Stats: length: 61 -------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 60 A Two full lines: >>> Sequence('T' * 120) Sequence -------------------------------------------------------------------- Stats: length: 120 -------------------------------------------------------------------- 0 TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT 60 TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT Two full lines with 1 character overflow: >>> Sequence('T' * 121) Sequence --------------------------------------------------------------------- Stats: length: 121 --------------------------------------------------------------------- 0 TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT 60 TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT TTTTTTTTTT 120 T Five full lines (maximum amount of information): >>> Sequence('A' * 300) Sequence --------------------------------------------------------------------- Stats: length: 300 --------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 60 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 120 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 180 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 240 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA Six lines starts "summarized" output: >>> Sequence('A' * 301) Sequence --------------------------------------------------------------------- Stats: length: 301 --------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 60 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA ... 240 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 300 A A naive algorithm would assume the width of the first column (noting position) based on the sequence's length alone. This can be off by one if the last position (in the last line) has a shorter width than the width calculated from the sequence's length. This test case ensures that only a single space is inserted between position 99960 and the first sequence chunk: >>> Sequence('A' * 100000) Sequence ----------------------------------------------------------------------- Stats: length: 100000 ----------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 60 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA ... 99900 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 99960 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA The largest sequence that can be displayed using six chunks per line: >>> Sequence('A' * 100020) Sequence ----------------------------------------------------------------------- Stats: length: 100020 ----------------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 60 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA ... 99900 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 99960 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA A single character longer than the previous sequence causes the optimal number of chunks per line to be 5: >>> Sequence('A' * 100021) Sequence ------------------------------------------------------------- Stats: length: 100021 ------------------------------------------------------------- 0 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 50 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA ... 99950 AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA AAAAAAAAAA 100000 AAAAAAAAAA AAAAAAAAAA A Wide range of characters (locale-independent): >>> import string >>> Sequence((string.ascii_letters + string.punctuation + string.digits + ... 'a space') * 567) Sequence ----------------------------------------------------------------------- Stats: length: 57267 ----------------------------------------------------------------------- 0 abcdefghij klmnopqrst uvwxyzABCD EFGHIJKLMN OPQRSTUVWX YZ!"#$%&'( 60 )*+,-./:;< =>?@[\]^_` {|}~012345 6789a spac eabcdefghi jklmnopqrs ... 57180 opqrstuvwx yzABCDEFGH IJKLMNOPQR STUVWXYZ!" #$%&'()*+, -./:;<=>?@ 57240 [\]^_`{|}~ 0123456789 a space Supply horrendous metadata, positional, and interval metadata to exercise a variety of metadata formatting cases and rules. Sorting should be by type, then by value within each type (Python 3 doesn't allow sorting of mixed types): >>> metadata = { ... # str key, str value ... 'abc': 'some description', ... # int value ... 'foo': 42, ... # unsupported type (dict) value ... 'bar': {}, ... # int key, wrapped str (single line) ... 42: 'some words to test text wrapping and such... yada yada yada ' ... 'yada yada yada yada yada.', ... # bool key, wrapped str (multi-line) ... True: 'abc ' * 34, ... # float key, truncated str (too long) ... 42.5: 'abc ' * 200, ... # unsupported type (tuple) key, unsupported type (list) value ... ('foo', 'bar'): [1, 2, 3], ... # bytes key, single long word that wraps ... b'long word': 'abc' * 30, ... # truncated key (too long), None value ... 'too long of a key name to display in repr': None, ... # wrapped bytes value (has b'' prefix) ... 'bytes wrapped value': b'abcd' * 25, ... # float value ... 0.1: 99.9999, ... # bool value ... 43: False, ... # None key, complex value ... None: complex(-1.0, 0.0), ... # nested quotes ... 10: '"\'' ... } >>> positional_metadata = pd.DataFrame({ ... # str key, int list value ... 'foo': [1, 2, 3, 4], ... # float key, float list value ... 42.5: [2.5, 3.0, 4.2, -0.00001], ... # int key, object list value ... 42: [[], 4, 5, {}], ... # truncated key (too long), bool list value ... 'abc' * 90: [True, False, False, True], ... # None key ... None: range(4)}) >>> positional_metadata = positional_metadata.reindex( ... columns=['foo', 42.5, 42, 'abc' * 90, None]) >>> interval_metadata = IntervalMetadata(4) >>> _ = interval_metadata.add([(0, 2), (1, 3)], ... [(False, True), (False, False)], ... {'gene': 'p53'}) >>> _ = interval_metadata.add([(1, 4)]) >>> Sequence('ACGT', metadata=metadata, ... positional_metadata=positional_metadata, ... interval_metadata=interval_metadata) Sequence ----------------------------------------------------------------------- Metadata: None: (-1+0j) True: 'abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc ' b'long word': 'abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabca bcabcabcabcabcabcabcabcabcabcabcabcabc' 0.1: 99.9999 42.5: 10: '"\'' 42: 'some words to test text wrapping and such... yada yada yada yada yada yada yada yada.' 43: False 'abc': 'some description' 'bar': 'bytes wrapped value': b'abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdab cdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd abcdabcdabcdabcd' 'foo': 42 : None : Positional metadata: 'foo': 42.5: 42: : None: Interval metadata: 2 interval features Stats: length: 4 ----------------------------------------------------------------------- 0 ACGT """ pass if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/stats/000077500000000000000000000000001446255456000160425ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/__init__.py000066400000000000000000000016271446255456000201610ustar00rootroot00000000000000""" Statistics (:mod:`skbio.stats`) =============================== .. currentmodule:: skbio.stats This package contains various statistical methods, including ordination techniques and distance matrix-based statistics. Subpackages ----------- .. autosummary:: :toctree: generated/ distance evolve ordination gradient power composition Functions --------- .. autosummary:: :toctree: generated/ subsample_counts isubsample """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._subsample import subsample_counts, isubsample __all__ = ['subsample_counts', 'isubsample'] scikit-bio-0.5.9/skbio/stats/__subsample.c000066400000000000000000010523761446255456000205150ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/arrayscalars.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarrayobject.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ndarraytypes.h", "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include/numpy/ufuncobject.h" ], "include_dirs": [ "/tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/core/include" ], "name": "skbio.stats.__subsample", "sources": [ "skbio/stats/__subsample.pyx" ] }, "module_name": "skbio.stats.__subsample" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__stats____subsample #define __PYX_HAVE_API__skbio__stats____subsample /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ndarrayobject.h" #include "numpy/ndarraytypes.h" #include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "skbio/stats/__subsample.pyx", "__init__.pxd", "type.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":689 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":690 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":691 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":696 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":697 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":698 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":703 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":704 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":713 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":714 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":715 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":717 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":718 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":719 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":721 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":722 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":724 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":725 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":726 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":728 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":729 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":730 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":732 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* BufferFallbackError.proto */ static void __Pyx_RaiseBufferFallbackError(void); /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int64(npy_int64 value); /* CIntFromPy.proto */ static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_generic = 0; static PyTypeObject *__pyx_ptype_5numpy_number = 0; static PyTypeObject *__pyx_ptype_5numpy_integer = 0; static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; static PyTypeObject *__pyx_ptype_5numpy_floating = 0; static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'skbio.stats.__subsample' */ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t = { "int64_t", NULL, sizeof(__pyx_t_5numpy_int64_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int64_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int64_t), 0 }; #define __Pyx_MODULE_NAME "skbio.stats.__subsample" extern int __pyx_module_is_main_skbio__stats____subsample; int __pyx_module_is_main_skbio__stats____subsample = 0; /* Implementation of 'skbio.stats.__subsample' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_n[] = "n"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_cnt[] = "cnt"; static const char __pyx_k_idx[] = "idx"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_empty[] = "empty"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_counts[] = "counts"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_random[] = "random"; static const char __pyx_k_result[] = "result"; static const char __pyx_k_permuted[] = "permuted"; static const char __pyx_k_unpacked[] = "unpacked"; static const char __pyx_k_counts_sum[] = "counts_sum"; static const char __pyx_k_zeros_like[] = "zeros_like"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_permutation[] = "permutation"; static const char __pyx_k_unpacked_idx[] = "unpacked_idx"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_skbio_stats___subsample[] = "skbio.stats.__subsample"; static const char __pyx_k_skbio_stats___subsample_pyx[] = "skbio/stats/__subsample.pyx"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_subsample_counts_without_replac[] = "_subsample_counts_without_replacement"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_cnt; static PyObject *__pyx_n_s_counts; static PyObject *__pyx_n_s_counts_sum; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_empty; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_idx; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_permutation; static PyObject *__pyx_n_s_permuted; static PyObject *__pyx_n_s_random; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_result; static PyObject *__pyx_n_s_skbio_stats___subsample; static PyObject *__pyx_kp_s_skbio_stats___subsample_pyx; static PyObject *__pyx_n_s_subsample_counts_without_replac; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_unpacked; static PyObject *__pyx_n_s_unpacked_idx; static PyObject *__pyx_n_s_zeros_like; static PyObject *__pyx_pf_5skbio_5stats_11__subsample__subsample_counts_without_replacement(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_counts, PyObject *__pyx_v_n, PyObject *__pyx_v_counts_sum); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_codeobj__4; /* Late includes */ /* "skbio/stats/__subsample.pyx":13 * * * def _subsample_counts_without_replacement( # <<<<<<<<<<<<<< * cnp.ndarray[cnp.int64_t, ndim=1] counts, n, counts_sum): * cdef: */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_11__subsample_1_subsample_counts_without_replacement(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_5skbio_5stats_11__subsample_1_subsample_counts_without_replacement = {"_subsample_counts_without_replacement", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_11__subsample_1_subsample_counts_without_replacement, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_5skbio_5stats_11__subsample_1_subsample_counts_without_replacement(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_counts = 0; PyObject *__pyx_v_n = 0; PyObject *__pyx_v_counts_sum = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_subsample_counts_without_replacement (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_counts,&__pyx_n_s_n,&__pyx_n_s_counts_sum,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_counts)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_subsample_counts_without_replacement", 1, 3, 3, 1); __PYX_ERR(0, 13, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_counts_sum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_subsample_counts_without_replacement", 1, 3, 3, 2); __PYX_ERR(0, 13, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_subsample_counts_without_replacement") < 0)) __PYX_ERR(0, 13, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_counts = ((PyArrayObject *)values[0]); __pyx_v_n = values[1]; __pyx_v_counts_sum = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_subsample_counts_without_replacement", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 13, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.__subsample._subsample_counts_without_replacement", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_counts), __pyx_ptype_5numpy_ndarray, 1, "counts", 0))) __PYX_ERR(0, 14, __pyx_L1_error) __pyx_r = __pyx_pf_5skbio_5stats_11__subsample__subsample_counts_without_replacement(__pyx_self, __pyx_v_counts, __pyx_v_n, __pyx_v_counts_sum); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_11__subsample__subsample_counts_without_replacement(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_counts, PyObject *__pyx_v_n, PyObject *__pyx_v_counts_sum) { PyArrayObject *__pyx_v_result = 0; PyArrayObject *__pyx_v_permuted = 0; PyArrayObject *__pyx_v_unpacked = 0; __pyx_t_5numpy_int64_t __pyx_v_cnt; Py_ssize_t __pyx_v_unpacked_idx; Py_ssize_t __pyx_v_i; CYTHON_UNUSED Py_ssize_t __pyx_v_j; npy_intp __pyx_v_idx; __Pyx_LocalBuf_ND __pyx_pybuffernd_counts; __Pyx_Buffer __pyx_pybuffer_counts; __Pyx_LocalBuf_ND __pyx_pybuffernd_permuted; __Pyx_Buffer __pyx_pybuffer_permuted; __Pyx_LocalBuf_ND __pyx_pybuffernd_result; __Pyx_Buffer __pyx_pybuffer_result; __Pyx_LocalBuf_ND __pyx_pybuffernd_unpacked; __Pyx_Buffer __pyx_pybuffer_unpacked; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; npy_intp __pyx_t_10; npy_intp __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; __pyx_t_5numpy_int64_t __pyx_t_14; __pyx_t_5numpy_int64_t __pyx_t_15; Py_ssize_t __pyx_t_16; npy_intp __pyx_t_17; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_subsample_counts_without_replacement", 0); __pyx_pybuffer_result.pybuffer.buf = NULL; __pyx_pybuffer_result.refcount = 0; __pyx_pybuffernd_result.data = NULL; __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result; __pyx_pybuffer_permuted.pybuffer.buf = NULL; __pyx_pybuffer_permuted.refcount = 0; __pyx_pybuffernd_permuted.data = NULL; __pyx_pybuffernd_permuted.rcbuffer = &__pyx_pybuffer_permuted; __pyx_pybuffer_unpacked.pybuffer.buf = NULL; __pyx_pybuffer_unpacked.refcount = 0; __pyx_pybuffernd_unpacked.data = NULL; __pyx_pybuffernd_unpacked.rcbuffer = &__pyx_pybuffer_unpacked; __pyx_pybuffer_counts.pybuffer.buf = NULL; __pyx_pybuffer_counts.refcount = 0; __pyx_pybuffernd_counts.data = NULL; __pyx_pybuffernd_counts.rcbuffer = &__pyx_pybuffer_counts; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_counts.rcbuffer->pybuffer, (PyObject*)__pyx_v_counts, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 13, __pyx_L1_error) } __pyx_pybuffernd_counts.diminfo[0].strides = __pyx_pybuffernd_counts.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_counts.diminfo[0].shape = __pyx_pybuffernd_counts.rcbuffer->pybuffer.shape[0]; /* "skbio/stats/__subsample.pyx":20 * Py_ssize_t unpacked_idx, i, j * * unpacked = np.empty(counts_sum, dtype=int) # <<<<<<<<<<<<<< * unpacked_idx = 0 * for i in range(counts.shape[0]): */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_counts_sum); __Pyx_GIVEREF(__pyx_v_counts_sum); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_counts_sum); __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 20, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 20, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_4); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_unpacked.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_unpacked.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_unpacked.rcbuffer->pybuffer, (PyObject*)__pyx_v_unpacked, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_7); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_7, __pyx_t_8, __pyx_t_9); } __pyx_t_7 = __pyx_t_8 = __pyx_t_9 = 0; } __pyx_pybuffernd_unpacked.diminfo[0].strides = __pyx_pybuffernd_unpacked.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_unpacked.diminfo[0].shape = __pyx_pybuffernd_unpacked.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 20, __pyx_L1_error) } __pyx_t_5 = 0; __pyx_v_unpacked = ((PyArrayObject *)__pyx_t_4); __pyx_t_4 = 0; /* "skbio/stats/__subsample.pyx":21 * * unpacked = np.empty(counts_sum, dtype=int) * unpacked_idx = 0 # <<<<<<<<<<<<<< * for i in range(counts.shape[0]): * cnt = counts[i] */ __pyx_v_unpacked_idx = 0; /* "skbio/stats/__subsample.pyx":22 * unpacked = np.empty(counts_sum, dtype=int) * unpacked_idx = 0 * for i in range(counts.shape[0]): # <<<<<<<<<<<<<< * cnt = counts[i] * for j in range(cnt): */ __pyx_t_10 = (__pyx_v_counts->dimensions[0]); __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_i = __pyx_t_12; /* "skbio/stats/__subsample.pyx":23 * unpacked_idx = 0 * for i in range(counts.shape[0]): * cnt = counts[i] # <<<<<<<<<<<<<< * for j in range(cnt): * unpacked[unpacked_idx] = i */ __pyx_t_13 = __pyx_v_i; __pyx_t_6 = -1; if (__pyx_t_13 < 0) { __pyx_t_13 += __pyx_pybuffernd_counts.diminfo[0].shape; if (unlikely(__pyx_t_13 < 0)) __pyx_t_6 = 0; } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_counts.diminfo[0].shape)) __pyx_t_6 = 0; if (unlikely(__pyx_t_6 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_6); __PYX_ERR(0, 23, __pyx_L1_error) } __pyx_v_cnt = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int64_t *, __pyx_pybuffernd_counts.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_counts.diminfo[0].strides)); /* "skbio/stats/__subsample.pyx":24 * for i in range(counts.shape[0]): * cnt = counts[i] * for j in range(cnt): # <<<<<<<<<<<<<< * unpacked[unpacked_idx] = i * unpacked_idx += 1 */ __pyx_t_14 = __pyx_v_cnt; __pyx_t_15 = __pyx_t_14; for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { __pyx_v_j = __pyx_t_16; /* "skbio/stats/__subsample.pyx":25 * cnt = counts[i] * for j in range(cnt): * unpacked[unpacked_idx] = i # <<<<<<<<<<<<<< * unpacked_idx += 1 * */ __pyx_t_13 = __pyx_v_unpacked_idx; __pyx_t_6 = -1; if (__pyx_t_13 < 0) { __pyx_t_13 += __pyx_pybuffernd_unpacked.diminfo[0].shape; if (unlikely(__pyx_t_13 < 0)) __pyx_t_6 = 0; } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_unpacked.diminfo[0].shape)) __pyx_t_6 = 0; if (unlikely(__pyx_t_6 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_6); __PYX_ERR(0, 25, __pyx_L1_error) } *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int64_t *, __pyx_pybuffernd_unpacked.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_unpacked.diminfo[0].strides) = __pyx_v_i; /* "skbio/stats/__subsample.pyx":26 * for j in range(cnt): * unpacked[unpacked_idx] = i * unpacked_idx += 1 # <<<<<<<<<<<<<< * * permuted = np.random.permutation(unpacked)[:n] */ __pyx_v_unpacked_idx = (__pyx_v_unpacked_idx + 1); } } /* "skbio/stats/__subsample.pyx":28 * unpacked_idx += 1 * * permuted = np.random.permutation(unpacked)[:n] # <<<<<<<<<<<<<< * * result = np.zeros_like(counts) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_permutation); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, ((PyObject *)__pyx_v_unpacked)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_unpacked)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_4, 0, 0, NULL, &__pyx_v_n, NULL, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 28, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_3); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_permuted.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_permuted.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_permuted.rcbuffer->pybuffer, (PyObject*)__pyx_v_permuted, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_7); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_9, __pyx_t_8, __pyx_t_7); } __pyx_t_9 = __pyx_t_8 = __pyx_t_7 = 0; } __pyx_pybuffernd_permuted.diminfo[0].strides = __pyx_pybuffernd_permuted.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_permuted.diminfo[0].shape = __pyx_pybuffernd_permuted.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 28, __pyx_L1_error) } __pyx_t_5 = 0; __pyx_v_permuted = ((PyArrayObject *)__pyx_t_3); __pyx_t_3 = 0; /* "skbio/stats/__subsample.pyx":30 * permuted = np.random.permutation(unpacked)[:n] * * result = np.zeros_like(counts) # <<<<<<<<<<<<<< * for idx in range(permuted.shape[0]): * result[permuted[idx]] += 1 */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros_like); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, ((PyObject *)__pyx_v_counts)) : __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_counts)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 30, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_3); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_7); Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_7, __pyx_t_8, __pyx_t_9); } __pyx_t_7 = __pyx_t_8 = __pyx_t_9 = 0; } __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) } __pyx_t_5 = 0; __pyx_v_result = ((PyArrayObject *)__pyx_t_3); __pyx_t_3 = 0; /* "skbio/stats/__subsample.pyx":31 * * result = np.zeros_like(counts) * for idx in range(permuted.shape[0]): # <<<<<<<<<<<<<< * result[permuted[idx]] += 1 * */ __pyx_t_10 = (__pyx_v_permuted->dimensions[0]); __pyx_t_11 = __pyx_t_10; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_11; __pyx_t_17+=1) { __pyx_v_idx = __pyx_t_17; /* "skbio/stats/__subsample.pyx":32 * result = np.zeros_like(counts) * for idx in range(permuted.shape[0]): * result[permuted[idx]] += 1 # <<<<<<<<<<<<<< * * return result */ __pyx_t_13 = __pyx_v_idx; __pyx_t_6 = -1; if (__pyx_t_13 < 0) { __pyx_t_13 += __pyx_pybuffernd_permuted.diminfo[0].shape; if (unlikely(__pyx_t_13 < 0)) __pyx_t_6 = 0; } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_permuted.diminfo[0].shape)) __pyx_t_6 = 0; if (unlikely(__pyx_t_6 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_6); __PYX_ERR(0, 32, __pyx_L1_error) } __pyx_t_14 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int64_t *, __pyx_pybuffernd_permuted.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_permuted.diminfo[0].strides)); __pyx_t_6 = -1; if (__pyx_t_14 < 0) { __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape; if (unlikely(__pyx_t_14 < 0)) __pyx_t_6 = 0; } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_result.diminfo[0].shape)) __pyx_t_6 = 0; if (unlikely(__pyx_t_6 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_6); __PYX_ERR(0, 32, __pyx_L1_error) } *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int64_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides) += 1; } /* "skbio/stats/__subsample.pyx":34 * result[permuted[idx]] += 1 * * return result # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "skbio/stats/__subsample.pyx":13 * * * def _subsample_counts_without_replacement( # <<<<<<<<<<<<<< * cnp.ndarray[cnp.int64_t, ndim=1] counts, n, counts_sum): * cdef: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_counts.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_permuted.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_unpacked.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("skbio.stats.__subsample._subsample_counts_without_replacement", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_counts.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_permuted.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_unpacked.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XDECREF((PyObject *)__pyx_v_permuted); __Pyx_XDECREF((PyObject *)__pyx_v_unpacked); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":735 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":734 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":738 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":737 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":741 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":740 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":744 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":743 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":747 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":746 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":751 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":750 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":753 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":749 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":929 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":930 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":928 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":933 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":935 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":934 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":936 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":932 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":942 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 942, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":943 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 943, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 944, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":941 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * __pyx_import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":940 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * __pyx_import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":948 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 948, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":949 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 949, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 950, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":947 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":946 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":954 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 954, __pyx_L3_error) /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":955 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 955, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":956 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 956, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":953 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":952 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_timedelta64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":978 * bool * """ * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":966 * * * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.timedelta64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_datetime64_object", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":993 * bool * """ * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< * * */ __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":981 * * * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< * """ * Cython equivalent of `isinstance(obj, np.datetime64)` */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1003 * also needed. That can be found using `get_datetime64_unit`. * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":996 * * * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy datetime64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1010 * returns the int64 value underlying scalar numpy timedelta64 object * """ * return (obj).obval # <<<<<<<<<<<<<< * * */ __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1006 * * * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the int64 value underlying scalar numpy timedelta64 object */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1017 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /* function exit code */ __pyx_L0:; return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec___subsample(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec___subsample}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "__subsample", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_cnt, __pyx_k_cnt, sizeof(__pyx_k_cnt), 0, 0, 1, 1}, {&__pyx_n_s_counts, __pyx_k_counts, sizeof(__pyx_k_counts), 0, 0, 1, 1}, {&__pyx_n_s_counts_sum, __pyx_k_counts_sum, sizeof(__pyx_k_counts_sum), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, {&__pyx_n_s_permutation, __pyx_k_permutation, sizeof(__pyx_k_permutation), 0, 0, 1, 1}, {&__pyx_n_s_permuted, __pyx_k_permuted, sizeof(__pyx_k_permuted), 0, 0, 1, 1}, {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1}, {&__pyx_n_s_skbio_stats___subsample, __pyx_k_skbio_stats___subsample, sizeof(__pyx_k_skbio_stats___subsample), 0, 0, 1, 1}, {&__pyx_kp_s_skbio_stats___subsample_pyx, __pyx_k_skbio_stats___subsample_pyx, sizeof(__pyx_k_skbio_stats___subsample_pyx), 0, 0, 1, 0}, {&__pyx_n_s_subsample_counts_without_replac, __pyx_k_subsample_counts_without_replac, sizeof(__pyx_k_subsample_counts_without_replac), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_unpacked, __pyx_k_unpacked, sizeof(__pyx_k_unpacked), 0, 0, 1, 1}, {&__pyx_n_s_unpacked_idx, __pyx_k_unpacked_idx, sizeof(__pyx_k_unpacked_idx), 0, 0, 1, 1}, {&__pyx_n_s_zeros_like, __pyx_k_zeros_like, sizeof(__pyx_k_zeros_like), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 22, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 944, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":944 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 944, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":950 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "skbio/stats/__subsample.pyx":13 * * * def _subsample_counts_without_replacement( # <<<<<<<<<<<<<< * cnp.ndarray[cnp.int64_t, ndim=1] counts, n, counts_sum): * cdef: */ __pyx_tuple__3 = PyTuple_Pack(11, __pyx_n_s_counts, __pyx_n_s_n, __pyx_n_s_counts_sum, __pyx_n_s_result, __pyx_n_s_permuted, __pyx_n_s_unpacked, __pyx_n_s_cnt, __pyx_n_s_unpacked_idx, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats___subsample_pyx, __pyx_n_s_subsample_counts_without_replac, 13, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 770, __pyx_L1_error) __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 772, __pyx_L1_error) __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 774, __pyx_L1_error) __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 776, __pyx_L1_error) __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 778, __pyx_L1_error) __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 780, __pyx_L1_error) __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 782, __pyx_L1_error) __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 784, __pyx_L1_error) __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 786, __pyx_L1_error) __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 788, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init__subsample(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init__subsample(void) #else __Pyx_PyMODINIT_FUNC PyInit___subsample(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit___subsample(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec___subsample(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '__subsample' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit___subsample(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("__subsample", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__stats____subsample) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.stats.__subsample")) { if (unlikely(PyDict_SetItemString(modules, "skbio.stats.__subsample", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "skbio/stats/__subsample.pyx":9 * # ---------------------------------------------------------------------------- * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as cnp * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/__subsample.pyx":13 * * * def _subsample_counts_without_replacement( # <<<<<<<<<<<<<< * cnp.ndarray[cnp.int64_t, ndim=1] counts, n, counts_sum): * cdef: */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_5skbio_5stats_11__subsample_1_subsample_counts_without_replacement, NULL, __pyx_n_s_skbio_stats___subsample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_subsample_counts_without_replac, __pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/__subsample.pyx":1 * # ---------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # Copyright (c) 2013--, scikit-bio development team. * # */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../../../tmp/pip-build-env-8sat0rrz/overlay/lib/python3.11/site-packages/numpy/__init__.pxd":1013 * * * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< * """ * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.stats.__subsample", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.stats.__subsample"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* BufferFallbackError */ static void __Pyx_RaiseBufferFallbackError(void) { PyErr_SetString(PyExc_ValueError, "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* SliceObject */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(Py_intptr_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(Py_intptr_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_int64(npy_int64 value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const npy_int64 neg_one = (npy_int64) -1, const_zero = (npy_int64) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(npy_int64) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(npy_int64) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(npy_int64) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(npy_int64) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(npy_int64), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(Py_intptr_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (Py_intptr_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (Py_intptr_t) 0; case 1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, digit, digits[0]) case 2: if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) >= 2 * PyLong_SHIFT) { return (Py_intptr_t) (((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])); } } break; case 3: if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) >= 3 * PyLong_SHIFT) { return (Py_intptr_t) (((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])); } } break; case 4: if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) >= 4 * PyLong_SHIFT) { return (Py_intptr_t) (((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (Py_intptr_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (Py_intptr_t) 0; case -1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, digit, +digits[0]) case -2: if (8 * sizeof(Py_intptr_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) { return (Py_intptr_t) (((Py_intptr_t)-1)*(((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; case 2: if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) { return (Py_intptr_t) ((((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; case -3: if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) { return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; case 3: if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) { return (Py_intptr_t) ((((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; case -4: if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) { return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; case 4: if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) { return (Py_intptr_t) ((((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]))); } } break; } #endif if (sizeof(Py_intptr_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else Py_intptr_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (Py_intptr_t) -1; } } else { Py_intptr_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (Py_intptr_t) -1; val = __Pyx_PyInt_As_Py_intptr_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to Py_intptr_t"); return (Py_intptr_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to Py_intptr_t"); return (Py_intptr_t) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/stats/__subsample.pyx000066400000000000000000000020331446255456000210730ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np cimport numpy as cnp def _subsample_counts_without_replacement( cnp.ndarray[cnp.int64_t, ndim=1] counts, n, counts_sum): cdef: cnp.ndarray[cnp.int64_t, ndim=1] result, permuted, unpacked cnp.int64_t cnt Py_ssize_t unpacked_idx, i, j unpacked = np.empty(counts_sum, dtype=int) unpacked_idx = 0 for i in range(counts.shape[0]): cnt = counts[i] for j in range(cnt): unpacked[unpacked_idx] = i unpacked_idx += 1 permuted = np.random.permutation(unpacked)[:n] result = np.zeros_like(counts) for idx in range(permuted.shape[0]): result[permuted[idx]] += 1 return result scikit-bio-0.5.9/skbio/stats/_misc.py000066400000000000000000000015451446255456000175130ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- def _pprint_strs(strs, max_chars=80, delimiter=', ', suffix='...',): """Pretty-print an iterable of strings, truncating if necessary.""" # Adapted from http://stackoverflow.com/a/250373 joined_str = delimiter.join(repr(s) for s in strs) if len(joined_str) > max_chars: truncated = joined_str[:max_chars + 1].split(delimiter)[0:-1] joined_str = delimiter.join(truncated) if joined_str: joined_str += delimiter joined_str += suffix return joined_str scikit-bio-0.5.9/skbio/stats/_subsample.py000066400000000000000000000172701446255456000205550ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import sys from heapq import heappush, heappop from collections import defaultdict from copy import copy import numpy as np from skbio.util._decorator import experimental from .__subsample import _subsample_counts_without_replacement @experimental(as_of="0.4.0") def isubsample(items, maximum, minimum=1, buf_size=1000, bin_f=None): """Randomly subsample items from bins, without replacement. Randomly subsample items without replacement from an unknown number of input items, that may fall into an unknown number of bins. This method is intended for data that either a) cannot fit into memory or b) subsampling collections of arbitrary datatypes. Parameters ---------- items : Iterable The items to evaluate. maximum : unsigned int The maximum number of items per bin. minimum : unsigned int, optional The minimum number of items per bin. The default is 1. buf_size : unsigned int, optional The size of the random value buffer. This buffer holds the random values assigned to each item from items. In practice, it is unlikely that this value will need to change. Increasing it will require more resident memory, but potentially reduce the number of function calls made to the PRNG, whereas decreasing it will result in more function calls and lower memory overhead. The default is 1000. bin_f : function, optional Method to determine what bin an item is associated with. If None (the default), then all items are considered to be part of the same bin. This function will be provided with each entry in items, and must return a hashable value indicating the bin that that entry should be placed in. Returns ------- generator (bin, item) Raises ------ ValueError If ``minimum`` is > ``maximum``. ValueError If ``minimum`` < 1 or if ``maximum`` < 1. See Also -------- subsample_counts Notes ----- Randomly get up to ``maximum`` items for each bin. If the bin has less than ``maximum``, only those bins that have >= ``minimum`` items are returned. This method will at most hold ``maximum`` * N data, where N is the number of bins. All items associated to a bin have an equal probability of being retained. Examples -------- Randomly keep up to 2 sequences per sample from a set of demultiplexed sequences: >>> from skbio.stats import isubsample >>> import numpy as np >>> np.random.seed(123) >>> seqs = [('sampleA', 'AATTGG'), ... ('sampleB', 'ATATATAT'), ... ('sampleC', 'ATGGCC'), ... ('sampleB', 'ATGGCT'), ... ('sampleB', 'ATGGCG'), ... ('sampleA', 'ATGGCA')] >>> bin_f = lambda item: item[0] >>> for bin_, item in sorted(isubsample(seqs, 2, bin_f=bin_f)): ... print(bin_, item[1]) sampleA AATTGG sampleA ATGGCA sampleB ATATATAT sampleB ATGGCG sampleC ATGGCC Now, let's set the minimum to 2: >>> bin_f = lambda item: item[0] >>> for bin_, item in sorted(isubsample(seqs, 2, 2, bin_f=bin_f)): ... print(bin_, item[1]) sampleA AATTGG sampleA ATGGCA sampleB ATATATAT sampleB ATGGCG """ if minimum > maximum: raise ValueError("minimum cannot be > maximum.") if minimum < 1 or maximum < 1: raise ValueError("minimum and maximum must be > 0.") if bin_f is None: def bin_f(x): return True # buffer some random values random_values = np.random.randint(0, sys.maxsize, buf_size) random_idx = 0 result = defaultdict(list) for item in items: bin_ = bin_f(item) heap = result[bin_] # pull a random value, and recompute random values if we've consumed # our buffer random_value = random_values[random_idx] random_idx += 1 if random_idx >= buf_size: random_values = np.random.randint(0, sys.maxsize, buf_size) random_idx = 0 # push our item on to the heap and drop the smallest if necessary heappush(heap, (random_value, copy(item))) if len(heap) > maximum: heappop(heap) # yield items for bin_, heap in result.items(): if len(heap) < minimum: continue for _, item in heap: yield (bin_, item) @experimental(as_of="0.4.0") def subsample_counts(counts, n, replace=False): """Randomly subsample from a vector of counts, with or without replacement. Parameters ---------- counts : 1-D array_like Vector of counts (integers) to randomly subsample from. n : int Number of items to subsample from `counts`. Must be less than or equal to the sum of `counts`. replace : bool, optional If ``True``, subsample with replacement. If ``False`` (the default), subsample without replacement. Returns ------- subsampled : ndarray Subsampled vector of counts where the sum of the elements equals `n` (i.e., ``subsampled.sum() == n``). Will have the same shape as `counts`. Raises ------ TypeError If `counts` cannot be safely converted to an integer datatype. ValueError If `n` is less than zero or greater than the sum of `counts` when `replace=False`. EfficiencyWarning If the accelerated code isn't present or hasn't been compiled. See Also -------- isubsample skbio.diversity.alpha Notes ----- If subsampling is performed without replacement (``replace=False``), a copy of `counts` is returned if `n` is equal to the number of items in `counts`, as all items will be chosen from the original vector. If subsampling is performed with replacement (``replace=True``) and `n` is equal to the number of items in `counts`, the subsampled vector that is returned may not necessarily be the same vector as `counts`. Examples -------- Subsample 4 items (without replacement) from a vector of counts: >>> import numpy as np >>> from skbio.stats import subsample_counts >>> a = np.array([4, 5, 0, 2, 1]) >>> sub = subsample_counts(a, 4) >>> sub.sum() 4 >>> sub.shape (5,) Trying to subsample an equal number of items (without replacement) results in the same vector as our input: >>> subsample_counts([0, 3, 0, 1], 4) array([0, 3, 0, 1]) Subsample 5 items (with replacement): >>> sub = subsample_counts([1, 0, 1, 2, 2, 3, 0, 1], 5, replace=True) >>> sub.sum() 5 >>> sub.shape (8,) """ if n < 0: raise ValueError("n cannot be negative.") counts = np.asarray(counts) counts = counts.astype(int, casting='safe') if counts.ndim != 1: raise ValueError("Only 1-D vectors are supported.") counts_sum = counts.sum() if n > counts_sum and not replace: raise ValueError("Cannot subsample more items than exist in input " "counts vector when `replace=False`.") if replace: probs = counts / counts_sum result = np.random.multinomial(n, probs) else: if counts_sum == n: result = counts else: result = _subsample_counts_without_replacement(counts, n, counts_sum) return result scikit-bio-0.5.9/skbio/stats/composition.py000066400000000000000000001535761446255456000210000ustar00rootroot00000000000000r""" Composition Statistics (:mod:`skbio.stats.composition`) ======================================================= .. currentmodule:: skbio.stats.composition This module provides functions for compositional data analysis. Many 'omics datasets are inherently compositional - meaning that they are best interpreted as proportions or percentages rather than absolute counts. Formally, :math:`x` is a composition if :math:`\sum_{i=0}^D x_{i} = c` and :math:`x_{i} > 0`, :math:`1 \leq i \leq D` and :math:`c` is a real valued constant and there are :math:`D` components for each composition. In this module :math:`c=1`. Compositional data can be analyzed using Aitchison geometry. [1]_ However, in this framework, standard real Euclidean operations such as addition and multiplication no longer apply. Only operations such as perturbation and power can be used to manipulate this data. This module allows two styles of manipulation of compositional data. Compositional data can be analyzed using perturbation and power operations, which can be useful for simulation studies. The alternative strategy is to transform compositional data into the real space. Right now, the centre log ratio transform (clr) and the isometric log ratio transform (ilr) [2]_ can be used to accomplish this. This transform can be useful for performing standard statistical tools such as parametric hypothesis testing, regressions and more. The major caveat of using this framework is dealing with zeros. In the Aitchison geometry, only compositions with nonzero components can be considered. The multiplicative replacement technique [3]_ can be used to substitute these zeros with small pseudocounts without introducing major distortions to the data. Functions --------- .. autosummary:: :toctree: closure multiplicative_replacement perturb perturb_inv power inner clr clr_inv ilr ilr_inv alr alr_inv centralize ancom sbp_basis References ---------- .. [1] V. Pawlowsky-Glahn, J. J. Egozcue, R. Tolosana-Delgado (2015), Modeling and Analysis of Compositional Data, Wiley, Chichester, UK .. [2] J. J. Egozcue., "Isometric Logratio Transformations for Compositional Data Analysis" Mathematical Geology, 35.3 (2003) .. [3] J. A. Martin-Fernandez, "Dealing With Zeros and Missing Values in Compositional Data Sets Using Nonparametric Imputation", Mathematical Geology, 35.3 (2003) Examples -------- >>> import numpy as np Consider a very simple environment with only 3 species. The species in the environment are equally distributed and their proportions are equivalent: >>> otus = np.array([1./3, 1./3., 1./3]) Suppose that an antibiotic kills off half of the population for the first two species, but doesn't harm the third species. Then the perturbation vector would be as follows >>> antibiotic = np.array([1./2, 1./2, 1]) And the resulting perturbation would be >>> perturb(otus, antibiotic) array([ 0.25, 0.25, 0.5 ]) """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd import scipy.stats import skbio.util from skbio.util._decorator import experimental from skbio.stats.distance import DistanceMatrix from scipy.sparse import coo_matrix @experimental(as_of="0.4.0") def closure(mat): """ Performs closure to ensure that all elements add up to 1. Parameters ---------- mat : array_like a matrix of proportions where rows = compositions columns = components Returns ------- array_like, np.float64 A matrix of proportions where all of the values are nonzero and each composition (row) adds up to 1 Raises ------ ValueError Raises an error if any values are negative. ValueError Raises an error if the matrix has more than 2 dimension. ValueError Raises an error if there is a row that has all zeros. Examples -------- >>> import numpy as np >>> from skbio.stats.composition import closure >>> X = np.array([[2, 2, 6], [4, 4, 2]]) >>> closure(X) array([[ 0.2, 0.2, 0.6], [ 0.4, 0.4, 0.2]]) """ mat = np.atleast_2d(mat) if np.any(mat < 0): raise ValueError("Cannot have negative proportions") if mat.ndim > 2: raise ValueError("Input matrix can only have two dimensions or less") if np.all(mat == 0, axis=1).sum() > 0: raise ValueError("Input matrix cannot have rows with all zeros") mat = mat / mat.sum(axis=1, keepdims=True) return mat.squeeze() @experimental(as_of="0.4.0") def multiplicative_replacement(mat, delta=None): r"""Replace all zeros with small non-zero values It uses the multiplicative replacement strategy [1]_ , replacing zeros with a small positive :math:`\delta` and ensuring that the compositions still add up to 1. Parameters ---------- mat: array_like a matrix of proportions where rows = compositions and columns = components delta: float, optional a small number to be used to replace zeros If delta is not specified, then the default delta is :math:`\delta = \frac{1}{N^2}` where :math:`N` is the number of components Returns ------- numpy.ndarray, np.float64 A matrix of proportions where all of the values are nonzero and each composition (row) adds up to 1 Raises ------ ValueError Raises an error if negative proportions are created due to a large `delta`. Notes ----- This method will result in negative proportions if a large delta is chosen. References ---------- .. [1] J. A. Martin-Fernandez. "Dealing With Zeros and Missing Values in Compositional Data Sets Using Nonparametric Imputation" Examples -------- >>> import numpy as np >>> from skbio.stats.composition import multiplicative_replacement >>> X = np.array([[.2,.4,.4, 0],[0,.5,.5,0]]) >>> multiplicative_replacement(X) array([[ 0.1875, 0.375 , 0.375 , 0.0625], [ 0.0625, 0.4375, 0.4375, 0.0625]]) """ mat = closure(mat) z_mat = (mat == 0) num_feats = mat.shape[-1] tot = z_mat.sum(axis=-1, keepdims=True) if delta is None: delta = (1. / num_feats)**2 zcnts = 1 - tot * delta if np.any(zcnts) < 0: raise ValueError('The multiplicative replacement created negative ' 'proportions. Consider using a smaller `delta`.') mat = np.where(z_mat, delta, zcnts * mat) return mat.squeeze() @experimental(as_of="0.4.0") def perturb(x, y): r""" Performs the perturbation operation. This operation is defined as .. math:: x \oplus y = C[x_1 y_1, \ldots, x_D y_D] :math:`C[x]` is the closure operation defined as .. math:: C[x] = \left[\frac{x_1}{\sum_{i=1}^{D} x_i},\ldots, \frac{x_D}{\sum_{i=1}^{D} x_i} \right] for some :math:`D` dimensional real vector :math:`x` and :math:`D` is the number of components for every composition. Parameters ---------- x : array_like, float a matrix of proportions where rows = compositions and columns = components y : array_like, float a matrix of proportions where rows = compositions and columns = components Returns ------- numpy.ndarray, np.float64 A matrix of proportions where all of the values are nonzero and each composition (row) adds up to 1 Examples -------- >>> import numpy as np >>> from skbio.stats.composition import perturb >>> x = np.array([.1,.3,.4, .2]) >>> y = np.array([1./6,1./6,1./3,1./3]) >>> perturb(x,y) array([ 0.0625, 0.1875, 0.5 , 0.25 ]) """ x, y = closure(x), closure(y) return closure(x * y) @experimental(as_of="0.4.0") def perturb_inv(x, y): r""" Performs the inverse perturbation operation. This operation is defined as .. math:: x \ominus y = C[x_1 y_1^{-1}, \ldots, x_D y_D^{-1}] :math:`C[x]` is the closure operation defined as .. math:: C[x] = \left[\frac{x_1}{\sum_{i=1}^{D} x_i},\ldots, \frac{x_D}{\sum_{i=1}^{D} x_i} \right] for some :math:`D` dimensional real vector :math:`x` and :math:`D` is the number of components for every composition. Parameters ---------- x : array_like a matrix of proportions where rows = compositions and columns = components y : array_like a matrix of proportions where rows = compositions and columns = components Returns ------- numpy.ndarray, np.float64 A matrix of proportions where all of the values are nonzero and each composition (row) adds up to 1 Examples -------- >>> import numpy as np >>> from skbio.stats.composition import perturb_inv >>> x = np.array([.1,.3,.4, .2]) >>> y = np.array([1./6,1./6,1./3,1./3]) >>> perturb_inv(x,y) array([ 0.14285714, 0.42857143, 0.28571429, 0.14285714]) """ x, y = closure(x), closure(y) return closure(x / y) @experimental(as_of="0.4.0") def power(x, a): r""" Performs the power operation. This operation is defined as follows .. math:: `x \odot a = C[x_1^a, \ldots, x_D^a] :math:`C[x]` is the closure operation defined as .. math:: C[x] = \left[\frac{x_1}{\sum_{i=1}^{D} x_i},\ldots, \frac{x_D}{\sum_{i=1}^{D} x_i} \right] for some :math:`D` dimensional real vector :math:`x` and :math:`D` is the number of components for every composition. Parameters ---------- x : array_like, float a matrix of proportions where rows = compositions and columns = components a : float a scalar float Returns ------- numpy.ndarray, np.float64 A matrix of proportions where all of the values are nonzero and each composition (row) adds up to 1 Examples -------- >>> import numpy as np >>> from skbio.stats.composition import power >>> x = np.array([.1,.3,.4, .2]) >>> power(x, .1) array([ 0.23059566, 0.25737316, 0.26488486, 0.24714631]) """ x = closure(x) return closure(x**a).squeeze() @experimental(as_of="0.4.0") def inner(x, y): r""" Calculates the Aitchson inner product. This inner product is defined as follows .. math:: \langle x, y \rangle_a = \frac{1}{2D} \sum\limits_{i=1}^{D} \sum\limits_{j=1}^{D} \ln\left(\frac{x_i}{x_j}\right) \ln\left(\frac{y_i}{y_j}\right) Parameters ---------- x : array_like a matrix of proportions where rows = compositions and columns = components y : array_like a matrix of proportions where rows = compositions and columns = components Returns ------- numpy.ndarray inner product result Examples -------- >>> import numpy as np >>> from skbio.stats.composition import inner >>> x = np.array([.1, .3, .4, .2]) >>> y = np.array([.2, .4, .2, .2]) >>> inner(x, y) # doctest: +ELLIPSIS 0.2107852473... """ x = closure(x) y = closure(y) a, b = clr(x), clr(y) return a.dot(b.T) @experimental(as_of="0.4.0") def clr(mat): r""" Performs centre log ratio transformation. This function transforms compositions from Aitchison geometry to the real space. The :math:`clr` transform is both an isometry and an isomorphism defined on the following spaces :math:`clr: S^D \rightarrow U` where :math:`U= \{x :\sum\limits_{i=1}^D x = 0 \; \forall x \in \mathbb{R}^D\}` It is defined for a composition :math:`x` as follows: .. math:: clr(x) = \ln\left[\frac{x_1}{g_m(x)}, \ldots, \frac{x_D}{g_m(x)}\right] where :math:`g_m(x) = (\prod\limits_{i=1}^{D} x_i)^{1/D}` is the geometric mean of :math:`x`. Parameters ---------- mat : array_like, float a matrix of proportions where rows = compositions and columns = components Returns ------- numpy.ndarray clr transformed matrix Examples -------- >>> import numpy as np >>> from skbio.stats.composition import clr >>> x = np.array([.1, .3, .4, .2]) >>> clr(x) array([-0.79451346, 0.30409883, 0.5917809 , -0.10136628]) """ mat = closure(mat) lmat = np.log(mat) gm = lmat.mean(axis=-1, keepdims=True) return (lmat - gm).squeeze() @experimental(as_of="0.4.0") def clr_inv(mat): r""" Performs inverse centre log ratio transformation. This function transforms compositions from the real space to Aitchison geometry. The :math:`clr^{-1}` transform is both an isometry, and an isomorphism defined on the following spaces :math:`clr^{-1}: U \rightarrow S^D` where :math:`U= \{x :\sum\limits_{i=1}^D x = 0 \; \forall x \in \mathbb{R}^D\}` This transformation is defined as follows .. math:: clr^{-1}(x) = C[\exp( x_1, \ldots, x_D)] Parameters ---------- mat : array_like, float a matrix of real values where rows = transformed compositions and columns = components Returns ------- numpy.ndarray inverse clr transformed matrix Examples -------- >>> import numpy as np >>> from skbio.stats.composition import clr_inv >>> x = np.array([.1, .3, .4, .2]) >>> clr_inv(x) array([ 0.21383822, 0.26118259, 0.28865141, 0.23632778]) """ # for numerical stability (aka softmax trick) mat = np.atleast_2d(mat) emat = np.exp(mat - mat.max(axis=-1, keepdims=True)) return closure(emat) @experimental(as_of="0.4.0") def ilr(mat, basis=None, check=True): r""" Performs isometric log ratio transformation. This function transforms compositions from Aitchison simplex to the real space. The :math: ilr` transform is both an isometry, and an isomorphism defined on the following spaces :math:`ilr: S^D \rightarrow \mathbb{R}^{D-1}` The ilr transformation is defined as follows .. math:: ilr(x) = [\langle x, e_1 \rangle_a, \ldots, \langle x, e_{D-1} \rangle_a] where :math:`[e_1,\ldots,e_{D-1}]` is an orthonormal basis in the simplex. If an orthornormal basis isn't specified, the J. J. Egozcue orthonormal basis derived from Gram-Schmidt orthogonalization will be used by default. Parameters ---------- mat: numpy.ndarray a matrix of proportions where rows = compositions and columns = components basis: numpy.ndarray or scipy.sparse.matrix, optional orthonormal basis for Aitchison simplex defaults to J.J.Egozcue orthonormal basis. check: bool Specifies if the basis is orthonormal. Examples -------- >>> import numpy as np >>> from skbio.stats.composition import ilr >>> x = np.array([.1, .3, .4, .2]) >>> ilr(x) array([-0.7768362 , -0.68339802, 0.11704769]) Notes ----- If the `basis` parameter is specified, it is expected to be a basis in the Aitchison simplex. If there are `D-1` elements specified in `mat`, then the dimensions of the basis needs be `D-1 x D`, where rows represent basis vectors, and the columns represent proportions. """ mat = closure(mat) if basis is None: d = mat.shape[-1] basis = _gram_schmidt_basis(d) # dimension (d-1) x d else: if len(basis.shape) != 2: raise ValueError("Basis needs to be a 2D matrix, " "not a %dD matrix." % (len(basis.shape))) if check: _check_orthogonality(basis) return clr(mat) @ basis.T @experimental(as_of="0.4.0") def ilr_inv(mat, basis=None, check=True): r""" Performs inverse isometric log ratio transform. This function transforms compositions from the real space to Aitchison geometry. The :math:`ilr^{-1}` transform is both an isometry, and an isomorphism defined on the following spaces :math:`ilr^{-1}: \mathbb{R}^{D-1} \rightarrow S^D` The inverse ilr transformation is defined as follows .. math:: ilr^{-1}(x) = \bigoplus\limits_{i=1}^{D-1} x \odot e_i where :math:`[e_1,\ldots, e_{D-1}]` is an orthonormal basis in the simplex. If an orthonormal basis isn't specified, the J. J. Egozcue orthonormal basis derived from Gram-Schmidt orthogonalization will be used by default. Parameters ---------- mat: numpy.ndarray, float a matrix of transformed proportions where rows = compositions and columns = components basis: numpy.ndarray, float, optional orthonormal basis for Aitchison simplex defaults to J.J.Egozcue orthonormal basis check: bool Specifies if the basis is orthonormal. Examples -------- >>> import numpy as np >>> from skbio.stats.composition import ilr >>> x = np.array([.1, .3, .6,]) >>> ilr_inv(x) array([ 0.34180297, 0.29672718, 0.22054469, 0.14092516]) Notes ----- If the `basis` parameter is specified, it is expected to be a basis in the Aitchison simplex. If there are `D-1` elements specified in `mat`, then the dimensions of the basis needs be `D-1 x D`, where rows represent basis vectors, and the columns represent proportions. """ mat = np.atleast_2d(mat) if basis is None: # dimension d-1 x d basis basis = _gram_schmidt_basis(mat.shape[-1] + 1) else: if len(basis.shape) != 2: raise ValueError("Basis needs to be a 2D matrix, " "not a %dD matrix." % (len(basis.shape))) if check: _check_orthogonality(basis) # this is necessary, since the clr function # performs np.squeeze() basis = np.atleast_2d(basis) return clr_inv(mat @ basis) @experimental(as_of="0.5.5") def alr(mat, denominator_idx=0): r""" Performs additive log ratio transformation. This function transforms compositions from a D-part Aitchison simplex to a non-isometric real space of D-1 dimensions. The argument `denominator_col` defines the index of the column used as the common denominator. The :math: `alr` transformed data are amenable to multivariate analysis as long as statistics don't involve distances. :math:`alr: S^D \rightarrow \mathbb{R}^{D-1}` The alr transformation is defined as follows .. math:: alr(x) = \left[ \ln \frac{x_1}{x_D}, \ldots, \ln \frac{x_{D-1}}{x_D} \right] where :math:`D` is the index of the part used as common denominator. Parameters ---------- mat: numpy.ndarray a matrix of proportions where rows = compositions and columns = components denominator_idx: int the index of the column (2D-matrix) or position (vector) of `mat` which should be used as the reference composition. By default `denominator_idx=0` to specify the first column or position. Returns ------- numpy.ndarray alr-transformed data projected in a non-isometric real space of D-1 dimensions for a D-parts composition Examples -------- >>> import numpy as np >>> from skbio.stats.composition import alr >>> x = np.array([.1, .3, .4, .2]) >>> alr(x) array([ 1.09861229, 1.38629436, 0.69314718]) """ mat = closure(mat) if mat.ndim == 2: mat_t = mat.T numerator_idx = list(range(0, mat_t.shape[0])) del numerator_idx[denominator_idx] lr = np.log(mat_t[numerator_idx, :]/mat_t[denominator_idx, :]).T elif mat.ndim == 1: numerator_idx = list(range(0, mat.shape[0])) del numerator_idx[denominator_idx] lr = np.log(mat[numerator_idx]/mat[denominator_idx]) else: raise ValueError("mat must be either 1D or 2D") return lr @experimental(as_of="0.5.5") def alr_inv(mat, denominator_idx=0): r""" Performs inverse additive log ratio transform. This function transforms compositions from the non-isometric real space of alrs to Aitchison geometry. :math:`alr^{-1}: \mathbb{R}^{D-1} \rightarrow S^D` The inverse alr transformation is defined as follows .. math:: alr^{-1}(x) = C[exp([y_1, y_2, ..., y_{D-1}, 0])] where :math:`C[x]` is the closure operation defined as .. math:: C[x] = \left[\frac{x_1}{\sum_{i=1}^{D} x_i},\ldots, \frac{x_D}{\sum_{i=1}^{D} x_i} \right] for some :math:`D` dimensional real vector :math:`x` and :math:`D` is the number of components for every composition. Parameters ---------- mat: numpy.ndarray a matrix of alr-transformed data denominator_idx: int the index of the column (2D-composition) or position (1D-composition) of the output where the common denominator should be placed. By default `denominator_idx=0` to specify the first column or position. Returns ------- numpy.ndarray Inverse alr transformed matrix or vector where rows sum to 1. Examples -------- >>> import numpy as np >>> from skbio.stats.composition import alr, alr_inv >>> x = np.array([.1, .3, .4, .2]) >>> alr_inv(alr(x)) array([ 0.1, 0.3, 0.4, 0.2]) """ mat = np.array(mat) if mat.ndim == 2: mat_idx = np.insert(mat, denominator_idx, np.repeat(0, mat.shape[0]), axis=1) comp = np.zeros(mat_idx.shape) comp[:, denominator_idx] = 1 / (np.exp(mat).sum(axis=1) + 1) numerator_idx = list(range(0, comp.shape[1])) del numerator_idx[denominator_idx] for i in numerator_idx: comp[:, i] = comp[:, denominator_idx] * np.exp(mat_idx[:, i]) elif mat.ndim == 1: mat_idx = np.insert(mat, denominator_idx, 0, axis=0) comp = np.zeros(mat_idx.shape) comp[denominator_idx] = 1 / (np.exp(mat).sum(axis=0) + 1) numerator_idx = list(range(0, comp.shape[0])) del numerator_idx[denominator_idx] for i in numerator_idx: comp[i] = comp[denominator_idx] * np.exp(mat_idx[i]) else: raise ValueError("mat must be either 1D or 2D") return comp @experimental(as_of="0.4.0") def centralize(mat): r"""Center data around its geometric average. Parameters ---------- mat : array_like, float a matrix of proportions where rows = compositions and columns = components Returns ------- numpy.ndarray centered composition matrix Examples -------- >>> import numpy as np >>> from skbio.stats.composition import centralize >>> X = np.array([[.1,.3,.4, .2],[.2,.2,.2,.4]]) >>> centralize(X) array([[ 0.17445763, 0.30216948, 0.34891526, 0.17445763], [ 0.32495488, 0.18761279, 0.16247744, 0.32495488]]) """ mat = closure(mat) cen = scipy.stats.gmean(mat, axis=0) return perturb_inv(mat, cen) @experimental(as_of="0.5.7") def _vlr(x: np.array, y: np.array, ddof: int): r""" Calculates variance log ratio Parameters ---------- x : array_like, float a 1-dimensional vector of proportions y : array_like, float a 1-dimensional vector of proportions ddof: int degrees of freedom Returns ------- float variance log ratio value References ---------- .. [1] V. Lovell D, Pawlowsky-Glahn V, Egozcue JJ, Marguerat S, Bähler J (2015) Proportionality: A Valid Alternative to Correlation for Relative Data. PLoS Comput Biol 11(3): e1004075. https://doi.org/10.1371/journal.pcbi.1004075 .. [2] Erb, I., Notredame, C. How should we measure proportionality on relative gene expression data?. Theory Biosci. 135, 21–36 (2016). https://doi.org/10.1007/s12064-015-0220-8 """ # Log transformation x = np.log(x) y = np.log(y) # Variance log ratio return np.var(x - y, ddof=ddof) @experimental(as_of="0.5.7") def _robust_vlr(x: np.ndarray, y: np.ndarray, ddof: int): r""" Calculates variance log ratio while masking zeros Parameters ---------- x : array_like, float a 1-dimensional vector of proportions y : array_like, float a 1-dimensional vector of proportions ddof: int degrees of freedom Returns ------- float variance log ratio value References ---------- .. [1] V. Lovell D, Pawlowsky-Glahn V, Egozcue JJ, Marguerat S, Bähler J (2015) Proportionality: A Valid Alternative to Correlation for Relative Data. PLoS Comput Biol 11(3): e1004075. https://doi.org/10.1371/journal.pcbi.1004075 .. [2] Erb, I., Notredame, C. How should we measure proportionality on relative gene expression data?. Theory Biosci. 135, 21–36 (2016). https://doi.org/10.1007/s12064-015-0220-8 """ # Mask zeros x = np.ma.masked_array(x, mask=x == 0) y = np.ma.masked_array(y, mask=y == 0) # Log transformation x = np.ma.log(x) y = np.ma.log(y) # Variance log ratio return np.ma.var(x - y, ddof=ddof) @experimental(as_of="0.5.7") def vlr(x: np.ndarray, y: np.ndarray, ddof: int = 1, robust: bool = False): r""" Calculates variance log ratio Parameters ---------- x : array_like, float a 1-dimensional vector of proportions y : array_like, float a 1-dimensional vector of proportions ddof: int degrees of freedom robust: bool mask zeros at the cost of performance Returns ------- float variance log ratio value Examples -------- No zeros >>> import numpy as np >>> from skbio.stats.composition import vlr >>> x = np.exp([1,2,3]) >>> y = np.exp([2,3,4]) >>> vlr(x,y) 0.0 References ---------- .. [1] V. Lovell D, Pawlowsky-Glahn V, Egozcue JJ, Marguerat S, Bähler J (2015) Proportionality: A Valid Alternative to Correlation for Relative Data. PLoS Comput Biol 11(3): e1004075. https://doi.org/10.1371/journal.pcbi.1004075 .. [2] Erb, I., Notredame, C. How should we measure proportionality on relative gene expression data?. Theory Biosci. 135, 21–36 (2016). https://doi.org/10.1007/s12064-015-0220-8 """ # Convert array_like to numpy array x = closure(x) y = closure(y) # Set up input and parameters kwargs = { "x": x, "y": y, "ddof": ddof, } # Run backend function if robust: return _robust_vlr(**kwargs) else: return _vlr(**kwargs) @experimental(as_of="0.5.7") def _pairwise_vlr(mat: np.ndarray, ddof: int): r""" Performs pairwise variance log ratio transformation Parameters ---------- mat : array_like, float a matrix of proportions where rows = compositions and columns = components ids : array_like, str component names ddof : int degrees of freedom Returns ------- skbio.DistanceMatrix distance matrix of variance log ratio values References ---------- .. [1] V. Lovell D, Pawlowsky-Glahn V, Egozcue JJ, Marguerat S, Bähler J (2015) Proportionality: A Valid Alternative to Correlation for Relative Data. PLoS Comput Biol 11(3): e1004075. https://doi.org/10.1371/journal.pcbi.1004075 .. [2] Erb, I., Notredame, C. How should we measure proportionality on relative gene expression data?. Theory Biosci. 135, 21–36 (2016). https://doi.org/10.1007/s12064-015-0220-8 """ # Log Transform X_log = np.log(mat) # Variance Log Ratio covariance = np.cov(X_log.T, ddof=ddof) diagonal = np.diagonal(covariance) vlr_data = -2*covariance + diagonal[:, np.newaxis] + diagonal return vlr_data @experimental(as_of="0.5.7") def pairwise_vlr(mat, ids=None, ddof: int = 1, robust: bool = False, validate: bool = True): r""" Performs pairwise variance log ratio transformation Parameters ---------- mat: array_like, float a matrix of proportions where rows = compositions and columns = components ids: array_like, str Component names ddof: int Degrees of freedom robust: bool Mask zeros at the cost of performance validate: bool Whether to validate the distance matrix after construction. Returns ------- skbio.DistanceMatrix if validate=True distance matrix of variance log ratio values skbio.DissimilarityMatrix if validate=False dissimilarity matrix of variance log ratio values Examples -------- import numpy as np from skbio.stats.composition import pairwise_vlr >>> mat = np.array([np.exp([1,2,2]), ... np.exp([2,3,6]), ... np.exp([2,3,12])]).T >>> dism = pairwise_vlr(mat) >>> dism.redundant_form() array([[ 0., 3., 27.], [ 3., 0., 12.], [ 27., 12., 0.]]) References ---------- .. [1] V. Lovell D, Pawlowsky-Glahn V, Egozcue JJ, Marguerat S, Bähler J (2015) Proportionality: A Valid Alternative to Correlation for Relative Data. PLoS Comput Biol 11(3): e1004075. https://doi.org/10.1371/journal.pcbi.1004075 .. [2] Erb, I., Notredame, C. How should we measure proportionality on relative gene expression data?. Theory Biosci. 135, 21–36 (2016). https://doi.org/10.1007/s12064-015-0220-8 """ # Mask zeros mat = closure(mat.astype(np.float64)) # Set up input and parameters kwargs = { "mat": mat, "ddof": ddof, } # Variance Log Ratio if robust: raise NotImplementedError( 'Pairwise version of robust VLR not implemented.') else: vlr_data = _pairwise_vlr(**kwargs) # Return distance matrix if validate: vlr_data = 0.5 * (vlr_data + vlr_data.T) return DistanceMatrix(vlr_data, ids=ids) # Return dissimilarity matrix else: return DistanceMatrix(vlr_data, ids=ids, validate=False) @experimental(as_of="0.5.8") def tree_basis(tree): r""" Calculates sparse representation of an ilr basis from a tree. This computes an orthonormal basis specified from a bifurcating tree. Parameters ---------- tree : skbio.TreeNode Input bifurcating tree. Must be strictly bifurcating (i.e. every internal node needs to have exactly 2 children). This is used to specify the ilr basis. Returns ------- scipy.sparse.coo_matrix The ilr basis required to perform the ilr_inv transform. This is also known as the sequential binary partition. Note that this matrix is represented in clr coordinates. nodes : list, str List of tree nodes indicating the ordering in the basis. Raises ------ ValueError The tree doesn't contain two branches. >>> from skbio import TreeNode >>> tree = u"((b,c)a, d)root;" >>> t = TreeNode.read([tree]) >>> basis, nodes = tree_basis(t) >>> basis.toarray() array([[-0.40824829, -0.40824829, 0.81649658], [-0.70710678, 0.70710678, 0. ]]) """ # Specifies which child is numerator and denominator # within any given node in a tree. NUMERATOR = 1 DENOMINATOR = 0 # this is inspired by @wasade in # https://github.com/biocore/gneiss/pull/8 t = tree.copy() D = len(list(tree.tips())) # calculate number of tips under each node for n in t.postorder(include_self=True): if n.is_tip(): n._tip_count = 1 else: if len(n.children) == 2: left, right = n.children[NUMERATOR], n.children[DENOMINATOR], else: raise ValueError("Not a strictly bifurcating tree.") n._tip_count = left._tip_count + right._tip_count # calculate k, r, s, t coordinate for each node left, right = t.children[NUMERATOR], t.children[DENOMINATOR], t._k, t._r, t._s, t._t = 0, left._tip_count, right._tip_count, 0 for n in t.preorder(include_self=False): if n.is_tip(): n._k, n._r, n._s, n._t = 0, 0, 0, 0 elif n == n.parent.children[NUMERATOR]: n._k = n.parent._k n._r = n.children[NUMERATOR]._tip_count n._s = n.children[DENOMINATOR]._tip_count n._t = n.parent._s + n.parent._t elif n == n.parent.children[DENOMINATOR]: n._k = n.parent._r + n.parent._k n._r = n.children[NUMERATOR]._tip_count n._s = n.children[DENOMINATOR]._tip_count n._t = n.parent._t else: raise ValueError("Tree topology is not correct.") # navigate through tree to build the basis in a sparse matrix form value = [] row, col = [], [] nodes = [] i = 0 for n in t.levelorder(include_self=True): if n.is_tip(): continue for j in range(n._k, n._k + n._r): row.append(i) # consider tips in reverse order. May want to rethink # this orientation in the future. col.append(D - 1 - j) A = np.sqrt(n._s / (n._r * (n._s + n._r))) value.append(A) for j in range(n._k + n._r, n._k + n._r + n._s): row.append(i) col.append(D - 1 - j) B = -np.sqrt(n._r / (n._s * (n._s + n._r))) value.append(B) i += 1 nodes.append(n.name) basis = coo_matrix((value, (row, col)), shape=(D - 1, D)) return basis, nodes @experimental(as_of="0.4.1") def ancom(table, grouping, alpha=0.05, tau=0.02, theta=0.1, multiple_comparisons_correction='holm-bonferroni', significance_test=None, percentiles=(0.0, 25.0, 50.0, 75.0, 100.0)): r""" Performs a differential abundance test using ANCOM. This is done by calculating pairwise log ratios between all features and performing a significance test to determine if there is a significant difference in feature ratios with respect to the variable of interest. In an experiment with only two treatments, this tests the following hypothesis for feature :math:`i` .. math:: H_{0i}: \mathbb{E}[\ln(u_i^{(1)})] = \mathbb{E}[\ln(u_i^{(2)})] where :math:`u_i^{(1)}` is the mean abundance for feature :math:`i` in the first group and :math:`u_i^{(2)}` is the mean abundance for feature :math:`i` in the second group. Parameters ---------- table : pd.DataFrame A 2D matrix of strictly positive values (i.e. counts or proportions) where the rows correspond to samples and the columns correspond to features. grouping : pd.Series Vector indicating the assignment of samples to groups. For example, these could be strings or integers denoting which group a sample belongs to. It must be the same length as the samples in `table`. The index must be the same on `table` and `grouping` but need not be in the same order. alpha : float, optional Significance level for each of the statistical tests. This can can be anywhere between 0 and 1 exclusive. tau : float, optional A constant used to determine an appropriate cutoff. A value close to zero indicates a conservative cutoff. This can can be anywhere between 0 and 1 exclusive. theta : float, optional Lower bound for the proportion for the W-statistic. If all W-statistics are lower than theta, then no features will be detected to be differentially significant. This can can be anywhere between 0 and 1 exclusive. multiple_comparisons_correction : {None, 'holm-bonferroni'}, optional The multiple comparison correction procedure to run. If None, then no multiple comparison correction procedure will be run. If 'holm-boniferroni' is specified, then the Holm-Boniferroni procedure [1]_ will be run. significance_test : function, optional A statistical significance function to test for significance between classes. This function must be able to accept at least two 1D array_like arguments of floats and returns a test statistic and a p-value. By default ``scipy.stats.f_oneway`` is used. percentiles : iterable of floats, optional Percentile abundances to return for each feature in each group. By default, will return the minimum, 25th percentile, median, 75th percentile, and maximum abundances for each feature in each group. Returns ------- pd.DataFrame A table of features, their W-statistics and whether the null hypothesis is rejected. `"W"` is the W-statistic, or number of features that a single feature is tested to be significantly different against. `"Reject null hypothesis"` indicates if feature is differentially abundant across groups (`True`) or not (`False`). pd.DataFrame A table of features and their percentile abundances in each group. If ``percentiles`` is empty, this will be an empty ``pd.DataFrame``. The rows in this object will be features, and the columns will be a multi-index where the first index is the percentile, and the second index is the group. See Also -------- multiplicative_replacement scipy.stats.ttest_ind scipy.stats.f_oneway scipy.stats.wilcoxon scipy.stats.kruskal Notes ----- The developers of this method recommend the following significance tests ([2]_, Supplementary File 1, top of page 11): if there are 2 groups, use the standard parametric t-test (``scipy.stats.ttest_ind``) or non-parametric Mann-Whitney rank test (``scipy.stats.mannwhitneyu``). For paired samples, use the parametric paired t-test (``scipy.stats.ttest_rel``) or nonparametric Wilcoxon signed-rank test (``scipy.stats.wilcoxon``). If there are more than 2 groups, use parametric one-way ANOVA (``scipy.stats.f_oneway``) or nonparametric Kruskal-Wallis (``scipy.stats.kruskal``). If there are multiple measurements obtained from the individuals, use a Friedman test (``scipy.stats.friedmanchisquare``). Because one-way ANOVA is equivalent to the standard t-test when the number of groups is two, we default to ``scipy.stats.f_oneway`` here, which can be used when there are two or more groups. Users should refer to the documentation of these tests in SciPy to understand the assumptions made by each test. This method cannot handle any zero counts as input, since the logarithm of zero cannot be computed. While this is an unsolved problem, many studies, including [2]_, have shown promising results by adding pseudocounts to all values in the matrix. In [2]_, a pseudocount of 0.001 was used, though the authors note that a pseudocount of 1.0 may also be useful. Zero counts can also be addressed using the ``multiplicative_replacement`` method. References ---------- .. [1] Holm, S. "A simple sequentially rejective multiple test procedure". Scandinavian Journal of Statistics (1979), 6. .. [2] Mandal et al. "Analysis of composition of microbiomes: a novel method for studying microbial composition", Microbial Ecology in Health & Disease, (2015), 26. Examples -------- First import all of the necessary modules: >>> from skbio.stats.composition import ancom >>> import pandas as pd Now let's load in a DataFrame with 6 samples and 7 features (e.g., these may be bacterial OTUs): >>> table = pd.DataFrame([[12, 11, 10, 10, 10, 10, 10], ... [9, 11, 12, 10, 10, 10, 10], ... [1, 11, 10, 11, 10, 5, 9], ... [22, 21, 9, 10, 10, 10, 10], ... [20, 22, 10, 10, 13, 10, 10], ... [23, 21, 14, 10, 10, 10, 10]], ... index=['s1', 's2', 's3', 's4', 's5', 's6'], ... columns=['b1', 'b2', 'b3', 'b4', 'b5', 'b6', ... 'b7']) Then create a grouping vector. In this example, there is a treatment group and a placebo group. >>> grouping = pd.Series(['treatment', 'treatment', 'treatment', ... 'placebo', 'placebo', 'placebo'], ... index=['s1', 's2', 's3', 's4', 's5', 's6']) Now run ``ancom`` to determine if there are any features that are significantly different in abundance between the treatment and the placebo groups. The first DataFrame that is returned contains the ANCOM test results, and the second contains the percentile abundance data for each feature in each group. >>> ancom_df, percentile_df = ancom(table, grouping) >>> ancom_df['W'] b1 0 b2 4 b3 0 b4 1 b5 1 b6 0 b7 1 Name: W, dtype: int64 The W-statistic is the number of features that a single feature is tested to be significantly different against. In this scenario, `b2` was detected to have significantly different abundances compared to four of the other features. To summarize the results from the W-statistic, let's take a look at the results from the hypothesis test. The `Reject null hypothesis` column in the table indicates whether the null hypothesis was rejected, and that a feature was therefore observed to be differentially abundant across the groups. >>> ancom_df['Reject null hypothesis'] b1 False b2 True b3 False b4 False b5 False b6 False b7 False Name: Reject null hypothesis, dtype: bool From this we can conclude that only `b2` was significantly different in abundance between the treatment and the placebo. We still don't know, for example, in which group `b2` was more abundant. We therefore may next be interested in comparing the abundance of `b2` across the two groups. We can do that using the second DataFrame that was returned. Here we compare the median (50th percentile) abundance of `b2` in the treatment and placebo groups: >>> percentile_df[50.0].loc['b2'] Group placebo 21.0 treatment 11.0 Name: b2, dtype: float64 We can also look at a full five-number summary for ``b2`` in the treatment and placebo groups: >>> percentile_df.loc['b2'] # doctest: +NORMALIZE_WHITESPACE Percentile Group 0.0 placebo 21.0 25.0 placebo 21.0 50.0 placebo 21.0 75.0 placebo 21.5 100.0 placebo 22.0 0.0 treatment 11.0 25.0 treatment 11.0 50.0 treatment 11.0 75.0 treatment 11.0 100.0 treatment 11.0 Name: b2, dtype: float64 Taken together, these data tell us that `b2` is present in significantly higher abundance in the placebo group samples than in the treatment group samples. """ if not isinstance(table, pd.DataFrame): raise TypeError('`table` must be a `pd.DataFrame`, ' 'not %r.' % type(table).__name__) if not isinstance(grouping, pd.Series): raise TypeError('`grouping` must be a `pd.Series`,' ' not %r.' % type(grouping).__name__) if np.any(table <= 0): raise ValueError('Cannot handle zeros or negative values in `table`. ' 'Use pseudocounts or ``multiplicative_replacement``.' ) if not 0 < alpha < 1: raise ValueError('`alpha`=%f is not within 0 and 1.' % alpha) if not 0 < tau < 1: raise ValueError('`tau`=%f is not within 0 and 1.' % tau) if not 0 < theta < 1: raise ValueError('`theta`=%f is not within 0 and 1.' % theta) if multiple_comparisons_correction is not None: if multiple_comparisons_correction != 'holm-bonferroni': raise ValueError('%r is not an available option for ' '`multiple_comparisons_correction`.' % multiple_comparisons_correction) if (grouping.isnull()).any(): raise ValueError('Cannot handle missing values in `grouping`.') if (table.isnull()).any().any(): raise ValueError('Cannot handle missing values in `table`.') percentiles = list(percentiles) for percentile in percentiles: if not 0.0 <= percentile <= 100.0: raise ValueError('Percentiles must be in the range [0, 100], %r ' 'was provided.' % percentile) duplicates = skbio.util.find_duplicates(percentiles) if duplicates: formatted_duplicates = ', '.join(repr(e) for e in duplicates) raise ValueError('Percentile values must be unique. The following' ' value(s) were duplicated: %s.' % formatted_duplicates) groups = np.unique(grouping) num_groups = len(groups) if num_groups == len(grouping): raise ValueError( "All values in `grouping` are unique. This method cannot " "operate on a grouping vector with only unique values (e.g., " "there are no 'within' variance because each group of samples " "contains only a single sample).") if num_groups == 1: raise ValueError( "All values the `grouping` are the same. This method cannot " "operate on a grouping vector with only a single group of samples" "(e.g., there are no 'between' variance because there is only a " "single group).") if significance_test is None: significance_test = scipy.stats.f_oneway table_index_len = len(table.index) grouping_index_len = len(grouping.index) mat, cats = table.align(grouping, axis=0, join='inner') if (len(mat) != table_index_len or len(cats) != grouping_index_len): raise ValueError('`table` index and `grouping` ' 'index must be consistent.') n_feat = mat.shape[1] _logratio_mat = _log_compare(mat.values, cats.values, significance_test) logratio_mat = _logratio_mat + _logratio_mat.T # Multiple comparisons if multiple_comparisons_correction == 'holm-bonferroni': logratio_mat = np.apply_along_axis(_holm_bonferroni, 1, logratio_mat) np.fill_diagonal(logratio_mat, 1) W = (logratio_mat < alpha).sum(axis=1) c_start = W.max() / n_feat if c_start < theta: reject = np.zeros_like(W, dtype=bool) else: # Select appropriate cutoff cutoff = c_start - np.linspace(0.05, 0.25, 5) prop_cut = np.array([(W > n_feat*cut).mean() for cut in cutoff]) dels = np.abs(prop_cut - np.roll(prop_cut, -1)) dels[-1] = 0 if (dels[0] < tau) and (dels[1] < tau) and (dels[2] < tau): nu = cutoff[1] elif (dels[0] >= tau) and (dels[1] < tau) and (dels[2] < tau): nu = cutoff[2] elif (dels[1] >= tau) and (dels[2] < tau) and (dels[3] < tau): nu = cutoff[3] else: nu = cutoff[4] reject = (W >= nu*n_feat) feat_ids = mat.columns ancom_df = pd.DataFrame( {'W': pd.Series(W, index=feat_ids), 'Reject null hypothesis': pd.Series(reject, index=feat_ids)}) if len(percentiles) == 0: return ancom_df, pd.DataFrame() else: data = [] columns = [] for group in groups: feat_dists = mat[cats == group] for percentile in percentiles: columns.append((percentile, group)) data.append(np.percentile(feat_dists, percentile, axis=0)) columns = pd.MultiIndex.from_tuples(columns, names=['Percentile', 'Group']) percentile_df = pd.DataFrame( np.asarray(data).T, columns=columns, index=feat_ids) return ancom_df, percentile_df def _holm_bonferroni(p): """ Performs Holm-Bonferroni correction for pvalues to account for multiple comparisons Parameters --------- p: numpy.array array of pvalues Returns ------- numpy.array corrected pvalues """ K = len(p) sort_index = -np.ones(K, dtype=np.int64) sorted_p = np.sort(p) sorted_p_adj = sorted_p*(K-np.arange(K)) for j in range(K): idx = (p == sorted_p[j]) & (sort_index < 0) num_ties = len(sort_index[idx]) sort_index[idx] = np.arange(j, (j+num_ties), dtype=np.int64) sorted_holm_p = [min([max(sorted_p_adj[:k]), 1]) for k in range(1, K+1)] holm_p = [sorted_holm_p[sort_index[k]] for k in range(K)] return holm_p def _log_compare(mat, cats, significance_test=scipy.stats.ttest_ind): """ Calculates pairwise log ratios between all features and performs a significance test (i.e. t-test) to determine if there is a significant difference in feature ratios with respect to the variable of interest. Parameters ---------- mat: np.array rows correspond to samples and columns correspond to features (i.e. OTUs) cats: np.array, float Vector of categories significance_test: function statistical test to run Returns: -------- log_ratio : np.array log ratio pvalue matrix """ r, c = mat.shape log_ratio = np.zeros((c, c)) log_mat = np.log(mat) cs = np.unique(cats) def func(x): return significance_test(*[x[cats == k] for k in cs]) for i in range(c-1): ratio = (log_mat[:, i].T - log_mat[:, i+1:].T).T m, p = np.apply_along_axis(func, axis=0, arr=ratio) log_ratio[i, i+1:] = np.squeeze(np.array(p.T)) return log_ratio def _gram_schmidt_basis(n): """ Builds clr transformed basis derived from gram schmidt orthogonalization Parameters ---------- n : int Dimension of the Aitchison simplex Returns ------- basis : np.array Dimension (n-1) x n basis matrix """ basis = np.zeros((n, n-1)) for j in range(n-1): i = j + 1 e = np.array([(1/i)]*i + [-1] + [0]*(n-i-1))*np.sqrt(i/(i+1)) basis[:, j] = e return basis.T @experimental(as_of="0.5.5") def sbp_basis(sbp): r""" Builds an orthogonal basis from a sequential binary partition (SBP). As explained in [1]_, the SBP is a hierarchical collection of binary divisions of compositional parts. The child groups are divided again until all groups contain a single part. The SBP can be encoded in a :math:`(D - 1) \times D` matrix where, for each row, parts can be grouped by -1 and +1 tags, and 0 for excluded parts. The `sbp_basis` method was originally derived from function `gsi.buildilrBase()` found in the R package `compositions` [2]_. The ith balance is computed as follows .. math:: b_i = \sqrt{ \frac{r_i s_i}{r_i+s_i} } \ln \left( \frac{g(x_{r_i})}{g(x_{s_i})} \right) where :math:`b_i` is the ith balance corresponding to the ith row in the SBP, :math:`r_i` and :math:`s_i` and the number of respectively `+1` and `-1` labels in the ith row of the SBP and where :math:`g(x) = (\prod\limits_{i=1}^{D} x_i)^{1/D}` is the geometric mean of :math:`x`. Parameters ---------- sbp: np.array, int A contrast matrix, also known as a sequential binary partition, where every row represents a partition between two groups of features. A part labelled `+1` would correspond to that feature being in the numerator of the given row partition, a part labelled `-1` would correspond to features being in the denominator of that given row partition, and `0` would correspond to features excluded in the row partition. Returns ------- numpy.array An orthonormal basis in the Aitchison simplex Examples -------- >>> import numpy as np >>> sbp = np.array([[1, 1,-1,-1,-1], ... [1,-1, 0, 0, 0], ... [0, 0, 1,-1,-1], ... [0, 0, 0, 1,-1]]) ... >>> sbp_basis(sbp) array([[ 0.54772256, 0.54772256, -0.36514837, -0.36514837, -0.36514837], [ 0.70710678, -0.70710678, 0. , 0. , 0. ], [ 0. , 0. , 0.81649658, -0.40824829, -0.40824829], [ 0. , 0. , 0. , 0.70710678, -0.70710678]]) References ---------- .. [1] Parent, S.É., Parent, L.E., Egozcue, J.J., Rozane, D.E., Hernandes, A., Lapointe, L., Hébert-Gentile, V., Naess, K., Marchand, S., Lafond, J., Mattos, D., Barlow, P., Natale, W., 2013. The plant ionome revisited by the nutrient balance concept. Front. Plant Sci. 4, 39, http://dx.doi.org/10.3389/fpls.2013.00039. .. [2] van den Boogaart, K. Gerald, Tolosana-Delgado, Raimon and Bren, Matevz, 2014. `compositions`: Compositional Data Analysis. R package version 1.40-1. https://CRAN.R-project.org/package=compositions. """ n_pos = (sbp == 1).sum(axis=1) n_neg = (sbp == -1).sum(axis=1) psi = np.zeros(sbp.shape) for i in range(0, sbp.shape[0]): psi[i, :] = sbp[i, :] * np.sqrt((n_neg[i] / n_pos[i])**sbp[i, :] / np.sum(np.abs(sbp[i, :]))) return psi def _check_orthogonality(basis): """ Checks to see if basis is truly orthonormal in the Aitchison simplex Parameters ---------- basis: numpy.ndarray basis in the Aitchison simplex of dimension d-1 x d """ basis = np.atleast_2d(basis) if not np.allclose(basis @ basis.T, np.identity(len(basis)), rtol=1e-4, atol=1e-6): raise ValueError("Basis is not orthonormal") scikit-bio-0.5.9/skbio/stats/distance/000077500000000000000000000000001446255456000176345ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/distance/__init__.py000066400000000000000000000127721446255456000217560ustar00rootroot00000000000000""" Distance matrices and distance-based statistics (:mod:`skbio.stats.distance`) ============================================================================= .. currentmodule:: skbio.stats.distance This subpackage provides functionality for serializing, deserializing, and manipulating dissimilarity and distance matrices in memory. It also contains various statistical methods that operate on distance matrices, often relating distances (e.g., community distances) to categorical and/or continuous variables of interest (e.g., gender or age). Methods are also provided for comparing distance matrices (e.g., computing the correlation between two or more distance matrices using the Mantel test). Data Structures: DissimilarityMatrix and DistanceMatrix ------------------------------------------------------- This package provides two matrix classes, `DissimilarityMatrix` and `DistanceMatrix`. Both classes can store measures of difference/distinction between objects. A dissimilarity/distance matrix includes both a matrix of dissimilarities/distances (floats) between objects, as well as unique IDs (object labels; strings) identifying each object in the matrix. `DissimilarityMatrix` can be used to store measures of dissimilarity between objects, and does not require that the dissimilarities are symmetric (e.g., dissimilarities obtained using the *Gain in PD* measure [1]_). `DissimilarityMatrix` is a more general container to store differences than `DistanceMatrix`. `DistanceMatrix` has the additional requirement that the differences it stores are symmetric (e.g., Euclidean or Hamming distances). .. note:: `DissimilarityMatrix` can be used to store distances, but it is recommended to use `DistanceMatrix` to store this type of data as it provides an additional check for symmetry. A distance matrix *is a* dissimilarity matrix; this is modeled in the class design by having `DistanceMatrix` subclass `DissimilarityMatrix`. Classes ^^^^^^^ .. autosummary:: :toctree: DissimilarityMatrix DistanceMatrix Functions ^^^^^^^^^ .. autosummary:: :toctree: randdm Exceptions ^^^^^^^^^^ .. autosummary:: :toctree: DissimilarityMatrixError DistanceMatrixError MissingIDError Examples ^^^^^^^^ Assume we have the following delimited text file storing distances between three objects with IDs ``a``, ``b``, and ``c``:: \\ta\\tb\\tc a\\t0.0\\t0.5\\t1.0 b\\t0.5\\t0.0\\t0.75 c\\t1.0\\t0.75\\t0.0 Load a distance matrix from the file: >>> from io import StringIO >>> from skbio import DistanceMatrix >>> dm_fh = StringIO("\\ta\\tb\\tc\\n" ... "a\\t0.0\\t0.5\\t1.0\\n" ... "b\\t0.5\\t0.0\\t0.75\\n" ... "c\\t1.0\\t0.75\\t0.0\\n") >>> dm = DistanceMatrix.read(dm_fh) >>> print(dm) 3x3 distance matrix IDs: 'a', 'b', 'c' Data: [[ 0. 0.5 1. ] [ 0.5 0. 0.75] [ 1. 0.75 0. ]] Access the distance (scalar) between objects ``'a'`` and ``'c'``: >>> dm['a', 'c'] 1.0 Get a row vector of distances between object ``'b'`` and all other objects: >>> dm['b'] array([ 0.5 , 0. , 0.75]) numpy indexing/slicing also works as expected. Extract the third column: >>> dm[:, 2] array([ 1. , 0.75, 0. ]) Serialize the distance matrix to delimited text file: >>> out_fh = StringIO() >>> _ = dm.write(out_fh) >>> out_fh.getvalue() == dm_fh.getvalue() True A distance matrix object can also be created from an existing ``numpy.array`` (or an array-like object, such as a nested Python list): >>> import numpy as np >>> data = np.array([[0.0, 0.5, 1.0], ... [0.5, 0.0, 0.75], ... [1.0, 0.75, 0.0]]) >>> ids = ["a", "b", "c"] >>> dm_from_np = DistanceMatrix(data, ids) >>> print(dm_from_np) 3x3 distance matrix IDs: 'a', 'b', 'c' Data: [[ 0. 0.5 1. ] [ 0.5 0. 0.75] [ 1. 0.75 0. ]] >>> dm_from_np == dm True IDs may be omitted when constructing a dissimilarity/distance matrix. Monotonically-increasing integers (cast as strings) will be automatically used: >>> dm = DistanceMatrix(data) >>> dm.ids ('0', '1', '2') Distance-based statistics ------------------------- In addition to the data structures described above, this package provides the following distance-based statistical methods. Categorical Variable Stats ^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autosummary:: :toctree: anosim permanova permdisp Continuous Variable Stats ^^^^^^^^^^^^^^^^^^^^^^^^^ .. autosummary:: :toctree: bioenv Distance Matrix Comparisons ^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autosummary:: :toctree: mantel pwmantel References ---------- .. [1] Faith, D. P. (1992). "Conservation evaluation and phylogenetic diversity". """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._base import (DissimilarityMatrixError, DistanceMatrixError, MissingIDError, DissimilarityMatrix, DistanceMatrix, randdm) from ._bioenv import bioenv from ._anosim import anosim from ._permanova import permanova from ._mantel import mantel, pwmantel from ._permdisp import permdisp __all__ = ['DissimilarityMatrixError', 'DistanceMatrixError', 'MissingIDError', 'DissimilarityMatrix', 'DistanceMatrix', 'randdm', 'anosim', 'permanova', 'bioenv', 'mantel', 'pwmantel', 'permdisp'] scikit-bio-0.5.9/skbio/stats/distance/_anosim.py000066400000000000000000000206261446255456000216410ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from functools import partial import numpy as np from scipy.stats import rankdata from ._base import (_preprocess_input, _run_monte_carlo_stats, _build_results) from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def anosim(distance_matrix, grouping, column=None, permutations=999): """Test for significant differences between groups using ANOSIM. Analysis of Similarities (ANOSIM) is a non-parametric method that tests whether two or more groups of objects (e.g., samples) are significantly different based on a categorical factor. The ranks of the distances in the distance matrix are used to calculate an R statistic, which ranges between -1 (anti-grouping) to +1 (strong grouping), with an R value of 0 indicating random grouping. Statistical significance is assessed via a permutation test. The assignment of objects to groups (`grouping`) is randomly permuted a number of times (controlled via `permutations`). An R statistic is computed for each permutation and the p-value is the proportion of permuted R statisics that are equal to or greater than the original (unpermuted) R statistic. Parameters ---------- distance_matrix : DistanceMatrix Distance matrix containing distances between objects (e.g., distances between samples of microbial communities). grouping : 1-D array_like or pandas.DataFrame Vector indicating the assignment of objects to groups. For example, these could be strings or integers denoting which group an object belongs to. If `grouping` is 1-D ``array_like``, it must be the same length and in the same order as the objects in `distance_matrix`. If `grouping` is a ``DataFrame``, the column specified by `column` will be used as the grouping vector. The ``DataFrame`` must be indexed by the IDs in `distance_matrix` (i.e., the row labels must be distance matrix IDs), but the order of IDs between `distance_matrix` and the ``DataFrame`` need not be the same. All IDs in the distance matrix must be present in the ``DataFrame``. Extra IDs in the ``DataFrame`` are allowed (they are ignored in the calculations). column : str, optional Column name to use as the grouping vector if `grouping` is a ``DataFrame``. Must be provided if `grouping` is a ``DataFrame``. Cannot be provided if `grouping` is 1-D ``array_like``. permutations : int, optional Number of permutations to use when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and the p-value will be ``np.nan``. Returns ------- pandas.Series Results of the statistical test, including ``test statistic`` and ``p-value``. See Also -------- permanova Notes ----- See [1]_ for the original method reference. The general algorithm and interface are similar to ``vegan::anosim``, available in R's vegan package [2]_. The p-value will be ``np.nan`` if `permutations` is zero. References ---------- .. [1] Clarke, KR. "Non-parametric multivariate analyses of changes in community structure." Australian journal of ecology 18.1 (1993): 117-143. .. [2] http://cran.r-project.org/web/packages/vegan/index.html Examples -------- Load a 4x4 distance matrix and grouping vector denoting 2 groups of objects: >>> from skbio import DistanceMatrix >>> dm = DistanceMatrix([[0, 1, 1, 4], ... [1, 0, 3, 2], ... [1, 3, 0, 3], ... [4, 2, 3, 0]], ... ['s1', 's2', 's3', 's4']) >>> grouping = ['Group1', 'Group1', 'Group2', 'Group2'] Run ANOSIM using 99 permutations to calculate the p-value: >>> import numpy as np >>> # make output deterministic; not necessary for normal use >>> np.random.seed(0) >>> from skbio.stats.distance import anosim >>> anosim(dm, grouping, permutations=99) method name ANOSIM test statistic name R sample size 4 number of groups 2 test statistic 0.25 p-value 0.67 number of permutations 99 Name: ANOSIM results, dtype: object The return value is a ``pandas.Series`` object containing the results of the statistical test. To suppress calculation of the p-value and only obtain the R statistic, specify zero permutations: >>> anosim(dm, grouping, permutations=0) method name ANOSIM test statistic name R sample size 4 number of groups 2 test statistic 0.25 p-value NaN number of permutations 0 Name: ANOSIM results, dtype: object You can also provide a ``pandas.DataFrame`` and a column denoting the grouping instead of a grouping vector. The following ``DataFrame``'s ``Group`` column specifies the same grouping as the vector we used in the previous examples: >>> # make output deterministic; not necessary for normal use >>> np.random.seed(0) >>> import pandas as pd >>> df = pd.DataFrame.from_dict( ... {'Group': {'s2': 'Group1', 's3': 'Group2', 's4': 'Group2', ... 's5': 'Group3', 's1': 'Group1'}}) >>> anosim(dm, df, column='Group', permutations=99) method name ANOSIM test statistic name R sample size 4 number of groups 2 test statistic 0.25 p-value 0.67 number of permutations 99 Name: ANOSIM results, dtype: object The results match the first example above. Note that when providing a ``DataFrame``, the ordering of rows and/or columns does not affect the grouping vector that is extracted. The ``DataFrame`` must be indexed by the distance matrix IDs (i.e., the row labels must be distance matrix IDs). If IDs (rows) are present in the ``DataFrame`` but not in the distance matrix, they are ignored. The previous example's ``s5`` ID illustrates this behavior: note that even though the ``DataFrame`` had 5 objects, only 4 were used in the test (see the "Sample size" row in the results above to confirm this). Thus, the ``DataFrame`` can be a superset of the distance matrix IDs. Note that the reverse is not true: IDs in the distance matrix *must* be present in the ``DataFrame`` or an error will be raised. """ sample_size, num_groups, grouping, tri_idxs, distances = _preprocess_input( distance_matrix, grouping, column) divisor = sample_size * ((sample_size - 1) / 4) ranked_dists = rankdata(distances, method='average') test_stat_function = partial(_compute_r_stat, tri_idxs, ranked_dists, divisor) stat, p_value = _run_monte_carlo_stats(test_stat_function, grouping, permutations) return _build_results('ANOSIM', 'R', sample_size, num_groups, stat, p_value, permutations) def _compute_r_stat(tri_idxs, ranked_dists, divisor, grouping): """Compute ANOSIM R statistic (between -1 and +1).""" # Create a matrix where True means that the two objects are in the same # group. This ufunc requires that grouping is a numeric vector (e.g., it # won't work with a grouping vector of strings). grouping_matrix = np.equal.outer(grouping, grouping) # Extract upper triangle from the grouping matrix. It is important to # extract the values in the same order that the distances are extracted # from the distance matrix (see ranked_dists). Extracting the upper # triangle (excluding the diagonal) preserves this order. grouping_tri = grouping_matrix[tri_idxs] # within r_W = np.mean(ranked_dists[grouping_tri]) # between r_B = np.mean(ranked_dists[np.invert(grouping_tri)]) return (r_B - r_W) / divisor scikit-bio-0.5.9/skbio/stats/distance/_base.py000066400000000000000000001400311446255456000212560ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import itertools from copy import deepcopy import numpy as np import pandas as pd from scipy.spatial.distance import squareform from skbio._base import SkbioObject from skbio.stats._misc import _pprint_strs from skbio.util import find_duplicates from skbio.util._decorator import experimental, classonlymethod from skbio.util._misc import resolve_key from ._utils import is_symmetric_and_hollow from ._utils import distmat_reorder, distmat_reorder_condensed class DissimilarityMatrixError(Exception): """General error for dissimilarity matrix validation failures.""" pass class DistanceMatrixError(DissimilarityMatrixError): """General error for distance matrix validation failures.""" pass class MissingIDError(DissimilarityMatrixError): """Error for ID lookup that doesn't exist in the dissimilarity matrix.""" def __init__(self, missing_id): super(MissingIDError, self).__init__() self.args = ("The ID '%s' is not in the dissimilarity matrix." % missing_id,) class DissimilarityMatrix(SkbioObject): """Store dissimilarities between objects. A `DissimilarityMatrix` instance stores a square, hollow, two-dimensional matrix of dissimilarities between objects. Objects could be, for example, samples or DNA sequences. A sequence of IDs accompanies the dissimilarities. Methods are provided to load and save dissimilarity matrices from/to disk, as well as perform common operations such as extracting dissimilarities based on object ID. Parameters ---------- data : array_like or DissimilarityMatrix Square, hollow, two-dimensional ``numpy.ndarray`` of dissimilarities (floats), or a structure that can be converted to a ``numpy.ndarray`` using ``numpy.asarray`` or a one-dimensional vector of dissimilarities (floats), as defined by `scipy.spatial.distance.squareform`. Can instead be a `DissimilarityMatrix` (or subclass) instance, in which case the instance's data will be used. Data will be converted to a float ``dtype`` if necessary. A copy will *not* be made if already a ``numpy.ndarray`` with a float ``dtype``. ids : sequence of str, optional Sequence of strings to be used as object IDs. Must match the number of rows/cols in `data`. If ``None`` (the default), IDs will be monotonically-increasing integers cast as strings, with numbering starting from zero, e.g., ``('0', '1', '2', '3', ...)``. validate : bool, optional If `validate` is ``True`` (the default) and data is not a DissimilarityMatrix object, the input data will be validated. See Also -------- DistanceMatrix scipy.spatial.distance.squareform Notes ----- The dissimilarities are stored in redundant (square-form) format [1]_. The data are not checked for symmetry, nor guaranteed/assumed to be symmetric. References ---------- .. [1] http://docs.scipy.org/doc/scipy/reference/spatial.distance.html """ default_write_format = 'lsmat' # Used in __str__ _matrix_element_name = 'dissimilarity' @experimental(as_of="0.4.0") def __init__(self, data, ids=None, validate=True): validate_full = validate validate_shape = False validate_ids = False if isinstance(data, DissimilarityMatrix): if isinstance(data, self.__class__): # Never validate when copying from an object # of the same type # We should be able to assume it is already # in a good state. validate_full = False validate_shape = False # but do validate ids, if redefining them validate_ids = False if ids is None else True ids = data.ids if ids is None else ids data = data.data # It is necessary to standardize the representation of the .data # attribute of this object. The input types might be list, tuple, # np.array, or possibly some other object type. Generally, this # normalization of type will require a copy of data. For example, # moving from a Python type representation (e.g., [[0, 1], [1, 0]]) # requires casting all of the values to numpy types, which is handled # as an implicit copy via np.asarray. However, these copies are # unnecessary if the data object is already a numpy array. np.asarray # is smart enough to not copy the data, however if a dtype change is # requested it will. The following block of code limits the use of # np.asarray to situations where the data are (a) not already a numpy # array or (b) the data are not a single or double precision numpy # data type. _issue_copy = True if isinstance(data, np.ndarray): if data.dtype in (np.float32, np.float64): _issue_copy = False if _issue_copy: data = np.asarray(data, dtype='float') if data.ndim == 1: # We can assume squareform will return a symmetric square matrix # so no need for full validation. # Still do basic checks (e.g. zero length) # and id validation data = squareform(data, force='tomatrix', checks=False) validate_full = False validate_shape = True validate_ids = True if ids is None: ids = (str(i) for i in range(data.shape[0])) # I just created the ids, so no need to re-validate them validate_ids = False ids = tuple(ids) if validate_full: self._validate(data, ids) else: if validate_shape: self._validate_shape(data) if validate_ids: self._validate_ids(data, ids) self._data = data self._ids = ids self._id_index = self._index_list(self._ids) @classonlymethod @experimental(as_of="0.5.1") def from_iterable(cls, iterable, metric, key=None, keys=None): """Create DissimilarityMatrix from an iterable given a metric. Parameters ---------- iterable : iterable Iterable containing objects to compute pairwise dissimilarities on. metric : callable A function that takes two arguments and returns a float representing the dissimilarity between the two arguments. key : callable or metadata key, optional A function that takes one argument and returns a string representing the id of the element in the dissimilarity matrix. Alternatively, a key to a `metadata` property if it exists for each element in the `iterable`. If None, then default ids will be used. keys : iterable, optional An iterable of the same length as `iterable`. Each element will be used as the respective key. Returns ------- DissimilarityMatrix The `metric` applied to all pairwise elements in the `iterable`. Raises ------ ValueError If `key` and `keys` are both provided. """ iterable = list(iterable) if key is not None and keys is not None: raise ValueError("Cannot use both `key` and `keys` at the same" " time.") keys_ = None if key is not None: keys_ = [resolve_key(e, key) for e in iterable] elif keys is not None: keys_ = keys dm = np.empty((len(iterable),) * 2) for i, a in enumerate(iterable): for j, b in enumerate(iterable): dm[i, j] = metric(a, b) return cls(dm, keys_) @property @experimental(as_of="0.4.0") def data(self): """Array of dissimilarities. A square, hollow, two-dimensional ``numpy.ndarray`` of dissimilarities (floats). A copy is *not* returned. Notes ----- This property is not writeable. """ return self._data @property @experimental(as_of="0.4.0") def ids(self): """Tuple of object IDs. A tuple of strings, one for each object in the dissimilarity matrix. Notes ----- This property is writeable, but the number of new IDs must match the number of objects in `data`. """ return self._ids @ids.setter def ids(self, ids_): ids_ = tuple(ids_) self._validate_ids(self.data, ids_) self._ids = ids_ self._id_index = self._index_list(self._ids) @property @experimental(as_of="0.4.0") def dtype(self): """Data type of the dissimilarities.""" return self.data.dtype @property @experimental(as_of="0.4.0") def shape(self): """Two-element tuple containing the dissimilarity matrix dimensions. Notes ----- As the dissimilarity matrix is guaranteed to be square, both tuple entries will always be equal. """ return self.data.shape @property @experimental(as_of="0.4.0") def size(self): """Total number of elements in the dissimilarity matrix. Notes ----- Equivalent to ``self.shape[0] * self.shape[1]``. """ return self.data.size @property @experimental(as_of="0.4.0") def T(self): """Transpose of the dissimilarity matrix. See Also -------- transpose """ return self.transpose() @experimental(as_of="0.4.0") def transpose(self): """Return the transpose of the dissimilarity matrix. Notes ----- A deep copy is returned. Returns ------- DissimilarityMatrix Transpose of the dissimilarity matrix. Will be the same type as `self`. """ # Note: Skip validation, since we assume self was already validated return self.__class__(self.data.T.copy(), deepcopy(self.ids), validate=False) @experimental(as_of="0.4.0") def index(self, lookup_id): """Return the index of the specified ID. Parameters ---------- lookup_id : str ID whose index will be returned. Returns ------- int Row/column index of `lookup_id`. Raises ------ MissingIDError If `lookup_id` is not in the dissimilarity matrix. """ if lookup_id in self: return self._id_index[lookup_id] else: raise MissingIDError(lookup_id) @experimental(as_of="0.4.0") def redundant_form(self): """Return an array of dissimilarities in redundant format. As this is the native format that the dissimilarities are stored in, this is simply an alias for `data`. Returns ------- ndarray Two-dimensional ``numpy.ndarray`` of dissimilarities in redundant format. Notes ----- Redundant format is described in [1]_. Does *not* return a copy of the data. References ---------- .. [1] http://docs.scipy.org/doc/scipy/reference/spatial.distance.html """ return self.data @experimental(as_of="0.4.0") def copy(self): """Return a deep copy of the dissimilarity matrix. Returns ------- DissimilarityMatrix Deep copy of the dissimilarity matrix. Will be the same type as `self`. """ # We deepcopy IDs in case the tuple contains mutable objects at some # point in the future. # Note: Skip validation, since we assume self was already validated return self.__class__(self.data.copy(), deepcopy(self.ids), validate=False) @experimental(as_of="0.4.0") def filter(self, ids, strict=True): """Filter the dissimilarity matrix by IDs. Parameters ---------- ids : iterable of str IDs to retain. May not contain duplicates or be empty. Each ID must be present in the dissimilarity matrix. strict : bool, optional If `strict` is ``True`` and an ID that is not found in the distance matrix is found in `ids`, a ``MissingIDError`` exception will be raised, otherwise the ID will be ignored. Returns ------- DissimilarityMatrix Filtered dissimilarity matrix containing only the IDs specified in `ids`. IDs will be in the same order as they appear in `ids`. Raises ------ MissingIDError If an ID in `ids` is not in the object's list of IDs. """ if tuple(self._ids) == tuple(ids): return self.__class__(self._data, self._ids) if strict: idxs = [self.index(id_) for id_ in ids] else: # get the indices to slice the inner numpy array idxs = [] # save the IDs that were found in the distance matrix found_ids = [] for id_ in ids: try: idxs.append(self.index(id_)) found_ids.append(id_) except MissingIDError: pass ids = found_ids # Note: Skip validation, since we assume self was already validated # But ids are new, so validate them explicitly filtered_data = distmat_reorder(self._data, idxs) self._validate_ids(filtered_data, ids) return self.__class__(filtered_data, ids, validate=False) def _stable_order(self, ids): """Obtain a stable ID order with respect to self Parameters ---------- ids : Iterable of ids The IDs to establish a stable ordering for. Returns ------- np.array, dtype=int The corresponding index values """ id_order = sorted(self._id_index[i] for i in ids) return np.array(id_order, dtype=int) @experimental(as_of="0.5.5") def within(self, ids): """Obtain all the distances among the set of IDs Parameters ---------- ids : Iterable of str The IDs to obtain distances for. All pairs of distances are returned such that, if provided ['a', 'b', 'c'], the distances for [('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')] are gathered. Returns ------- pd.DataFrame (i, j, value) representing the source ID ("i"), the target ID ("j") and the distance ("value"). Raises ------ MissingIDError If an ID(s) specified is not in the dissimilarity matrix. Notes ----- Order of the return items is stable, meaning that requesting IDs ['a', 'b'] is equivalent to ['b', 'a']. The order is with respect to the order of the .ids attribute of self. Example ------- >>> from skbio.stats.distance import DissimilarityMatrix >>> dm = DissimilarityMatrix([[0, 1, 2, 3, 4], [1, 0, 1, 2, 3], ... [2, 1, 0, 1, 2], [3, 2, 1, 0, 1], ... [4, 3, 2, 1, 0]], ... ['A', 'B', 'C', 'D', 'E']) >>> dm.within(['A', 'B', 'C']) i j value 0 A A 0.0 1 A B 1.0 2 A C 2.0 3 B A 1.0 4 B B 0.0 5 B C 1.0 6 C A 2.0 7 C B 1.0 8 C C 0.0 """ ids = set(ids) not_present = ids - set(self._id_index) if not_present: raise MissingIDError("At least one ID (e.g., '%s') was not " "found." % not_present.pop()) return self._subset_to_dataframe(ids, ids) @experimental(as_of="0.5.5") def between(self, from_, to_, allow_overlap=False): """Obtain the distances between the two groups of IDs Parameters ---------- from_ : Iterable of str The IDs to obtain distances from. Distances from all pairs of IDs in from and to will be obtained. to_ : Iterable of str The IDs to obtain distances to. Distances from all pairs of IDs in to and from will be obtained. allow_overlap : bool, optional If True, allow overlap in the IDs of from and to (which would in effect be collecting the within distances). Default is False. Returns ------- pd.DataFrame (i, j, value) representing the source ID ("i"), the target ID ("j") and the distance ("value"). Raises ------ MissingIDError If an ID(s) specified is not in the dissimilarity matrix. Notes ----- Order of the return items is stable, meaning that requesting IDs ['a', 'b'] is equivalent to ['b', 'a']. The order is with respect to the .ids attribute of self. Example ------- >>> from skbio.stats.distance import DissimilarityMatrix >>> dm = DissimilarityMatrix([[0, 1, 2, 3, 4], [1, 0, 1, 2, 3], ... [2, 1, 0, 1, 2], [3, 2, 1, 0, 1], ... [4, 3, 2, 1, 0]], ... ['A', 'B', 'C', 'D', 'E']) >>> dm.between(['A', 'B'], ['C', 'D', 'E']) i j value 0 A C 2.0 1 A D 3.0 2 A E 4.0 3 B C 1.0 4 B D 2.0 5 B E 3.0 """ from_ = set(from_) to_ = set(to_) all_ids = from_ | to_ not_present = all_ids - set(self._id_index) if not_present: raise MissingIDError("At least one ID (e.g., '%s') was not " "found." % not_present.pop()) overlapping = from_ & to_ if not allow_overlap and overlapping: raise KeyError("At least one ID overlaps in from_ and to_ " "(e.g., '%s'). This constraint can removed with " "allow_overlap=True." % overlapping.pop()) return self._subset_to_dataframe(from_, to_) def _subset_to_dataframe(self, i_ids, j_ids): """Extract a subset of self and express as a DataFrame Parameters ---------- i_order : Iterable of str The "from" IDs. j_order : Iterable of str The "to" IDs. Notes ----- ID membership is not tested by this private method, and it is assumed the caller has asserted the IDs are present. Returns ------- pd.DataFrame (i, j, value) representing the source ID ("i"), the target ID ("j") and the distance ("value"). """ i_indices = self._stable_order(i_ids) j_indices = self._stable_order(j_ids) j_length = len(j_indices) j_labels = tuple([self.ids[j] for j in j_indices]) i = [] j = [] # np.hstack([]) throws a ValueError. However, np.hstack([np.array([])]) # is valid and returns an empty array. Accordingly, an empty array is # included here so that np.hstack works in the event that either i_ids # or j_ids is empty. values = [np.array([])] for i_idx in i_indices: i.extend([self.ids[i_idx]] * j_length) j.extend(j_labels) subset = self._data[i_idx, j_indices] values.append(subset) i = pd.Series(i, name='i', dtype=str) j = pd.Series(j, name='j', dtype=str) values = pd.Series(np.hstack(values), name='value') return pd.concat([i, j, values], axis=1) @experimental(as_of="0.4.0") def plot(self, cmap=None, title=""): """Creates a heatmap of the dissimilarity matrix Parameters ---------- cmap: str or matplotlib.colors.Colormap, optional Sets the color scheme of the heatmap If ``None``, defaults to the colormap specified in the matplotlib rc file. title: str, optional Sets the title label of the heatmap (Default is blank) Returns ------- matplotlib.figure.Figure Figure containing the heatmap and colorbar of the plotted dissimilarity matrix. Examples -------- .. plot:: Define a dissimilarity matrix with five objects labeled A-E: >>> from skbio.stats.distance import DissimilarityMatrix >>> dm = DissimilarityMatrix([[0, 1, 2, 3, 4], [1, 0, 1, 2, 3], ... [2, 1, 0, 1, 2], [3, 2, 1, 0, 1], ... [4, 3, 2, 1, 0]], ... ['A', 'B', 'C', 'D', 'E']) Plot the dissimilarity matrix as a heatmap: >>> fig = dm.plot(cmap='Reds', title='Example heatmap') """ import matplotlib.pyplot as plt # based on http://stackoverflow.com/q/14391959/3776794 fig, ax = plt.subplots() # use pcolormesh instead of pcolor for performance heatmap = ax.pcolormesh(self.data, cmap=cmap) fig.colorbar(heatmap) # center labels within each cell ticks = np.arange(0.5, self.shape[0]) ax.set_xticks(ticks, minor=False) ax.set_yticks(ticks, minor=False) # Ensure there is no white border around the heatmap by manually # setting the limits ax.set_ylim(0, len(self.ids)) ax.set_xlim(0, len(self.ids)) # display data as it is stored in the dissimilarity matrix # (default is to have y-axis inverted) ax.invert_yaxis() ax.set_xticklabels(self.ids, rotation=90, minor=False) ax.set_yticklabels(self.ids, minor=False) ax.set_title(title) return fig def _repr_png_(self): return self._figure_data('png') def _repr_svg_(self): return self._figure_data('svg') @property @experimental(as_of="0.4.0") def png(self): """Display heatmap in IPython Notebook as PNG. """ from IPython.core.display import Image return Image(self._repr_png_(), embed=True) @property @experimental(as_of="0.4.0") def svg(self): """Display heatmap in IPython Notebook as SVG. """ from IPython.core.display import SVG return SVG(self._repr_svg_()) def _figure_data(self, format): import matplotlib.pyplot as plt from IPython.core.pylabtools import print_figure fig = self.plot() data = print_figure(fig, format) # We MUST close the figure, otherwise IPython's display machinery # will pick it up and send it as output, resulting in a double display plt.close(fig) return data @experimental(as_of="0.4.1") def to_data_frame(self): """Create a ``pandas.DataFrame`` from this ``DissimilarityMatrix``. Returns ------- pd.DataFrame ``pd.DataFrame`` with IDs on index and columns. Examples -------- >>> from skbio import DistanceMatrix >>> dm = DistanceMatrix([[0, 1, 2], ... [1, 0, 3], ... [2, 3, 0]], ids=['a', 'b', 'c']) >>> df = dm.to_data_frame() >>> df a b c a 0.0 1.0 2.0 b 1.0 0.0 3.0 c 2.0 3.0 0.0 """ return pd.DataFrame(data=self.data, index=self.ids, columns=self.ids) @experimental(as_of="0.4.0") def __str__(self): """Return a string representation of the dissimilarity matrix. Summary includes matrix dimensions, a (truncated) list of IDs, and (truncated) array of dissimilarities. Returns ------- str String representation of the dissimilarity matrix. """ return '%dx%d %s matrix\nIDs:\n%s\nData:\n' % ( self.shape[0], self.shape[1], self._matrix_element_name, _pprint_strs(self.ids)) + str(self.data) @experimental(as_of="0.4.0") def __eq__(self, other): """Compare this dissimilarity matrix to another for equality. Two dissimilarity matrices are equal if they have the same shape, IDs (in the same order!), and have data arrays that are equal. Checks are *not* performed to ensure that `other` is a `DissimilarityMatrix` instance. Parameters ---------- other : DissimilarityMatrix Dissimilarity matrix to compare to for equality. Returns ------- bool ``True`` if `self` is equal to `other`, ``False`` otherwise. """ equal = True # The order these checks are performed in is important to be as # efficient as possible. The check for shape equality is not strictly # necessary as it should be taken care of in np.array_equal, but I'd # rather explicitly bail before comparing IDs or data. Use array_equal # instead of (a == b).all() because of this issue: # http://stackoverflow.com/a/10582030 try: if self.shape != other.shape: equal = False elif self.ids != other.ids: equal = False elif not np.array_equal(self.data, other.data): equal = False except AttributeError: equal = False return equal @experimental(as_of="0.4.0") def __ne__(self, other): """Determine whether two dissimilarity matrices are not equal. Parameters ---------- other : DissimilarityMatrix Dissimilarity matrix to compare to. Returns ------- bool ``True`` if `self` is not equal to `other`, ``False`` otherwise. See Also -------- __eq__ """ return not self == other @experimental(as_of="0.4.0") def __contains__(self, lookup_id): """Check if the specified ID is in the dissimilarity matrix. Parameters ---------- lookup_id : str ID to search for. Returns ------- bool ``True`` if `lookup_id` is in the dissimilarity matrix, ``False`` otherwise. See Also -------- index """ return lookup_id in self._id_index @experimental(as_of="0.4.0") def __getitem__(self, index): """Slice into dissimilarity data by object ID or numpy indexing. Extracts data from the dissimilarity matrix by object ID, a pair of IDs, or numpy indexing/slicing. Parameters ---------- index : str, two-tuple of str, or numpy index `index` can be one of the following forms: an ID, a pair of IDs, or a numpy index. If `index` is a string, it is assumed to be an ID and a ``numpy.ndarray`` row vector is returned for the corresponding ID. Note that the ID's row of dissimilarities is returned, *not* its column. If the matrix is symmetric, the two will be identical, but this makes a difference if the matrix is asymmetric. If `index` is a two-tuple of strings, each string is assumed to be an ID and the corresponding matrix element is returned that represents the dissimilarity between the two IDs. Note that the order of lookup by ID pair matters if the matrix is asymmetric: the first ID will be used to look up the row, and the second ID will be used to look up the column. Thus, ``dm['a', 'b']`` may not be the same as ``dm['b', 'a']`` if the matrix is asymmetric. Otherwise, `index` will be passed through to ``DissimilarityMatrix.data.__getitem__``, allowing for standard indexing of a ``numpy.ndarray`` (e.g., slicing). Returns ------- ndarray or scalar Indexed data, where return type depends on the form of `index` (see description of `index` for more details). Raises ------ MissingIDError If the ID(s) specified in `index` are not in the dissimilarity matrix. Notes ----- The lookup based on ID(s) is quick. """ if isinstance(index, str): return self.data[self.index(index)] elif self._is_id_pair(index): return self.data[self.index(index[0]), self.index(index[1])] else: return self.data.__getitem__(index) def _validate_ids(self, data, ids): """Validate the IDs. Checks that IDs are unique and that the number of IDs matches the number of rows/cols in the data array. Subclasses can override this method to perform different/more specific validation. Notes ----- Accepts arguments instead of inspecting instance attributes to avoid creating an invalid dissimilarity matrix before raising an error. Otherwise, the invalid dissimilarity matrix could be used after the exception is caught and handled. """ duplicates = find_duplicates(ids) if duplicates: formatted_duplicates = ', '.join(repr(e) for e in duplicates) raise DissimilarityMatrixError("IDs must be unique. Found the " "following duplicate IDs: %s" % formatted_duplicates) if 0 == len(ids): raise DissimilarityMatrixError("IDs must be at least 1 in " "size.") if len(ids) != data.shape[0]: raise DissimilarityMatrixError("The number of IDs (%d) must match " "the number of rows/columns in the " "data (%d)." % (len(ids), data.shape[0])) def _validate_shape(self, data): """Validate the data array shape. Checks that the data is at least 1x1 in size, 2D, square, and contains only floats. Notes ----- Accepts arguments instead of inspecting instance attributes to avoid creating an invalid dissimilarity matrix before raising an error. Otherwise, the invalid dissimilarity matrix could be used after the exception is caught and handled. """ if 0 in data.shape: raise DissimilarityMatrixError("Data must be at least 1x1 in " "size.") if len(data.shape) != 2: raise DissimilarityMatrixError("Data must have exactly two " "dimensions.") if data.shape[0] != data.shape[1]: raise DissimilarityMatrixError("Data must be square (i.e., have " "the same number of rows and " "columns).") if data.dtype not in (np.float32, np.float64): raise DissimilarityMatrixError("Data must contain only floating " "point values.") def _validate(self, data, ids): """Validate the data array and IDs. Checks that the data is at least 1x1 in size, 2D, square, and contains only floats. Also checks that IDs are unique and that the number of IDs matches the number of rows/cols in the data array. Subclasses can override this method to perform different/more specific validation (e.g., see `DistanceMatrix`). Notes ----- Accepts arguments instead of inspecting instance attributes to avoid creating an invalid dissimilarity matrix before raising an error. Otherwise, the invalid dissimilarity matrix could be used after the exception is caught and handled. """ self._validate_shape(data) self._validate_ids(data, ids) def _index_list(self, list_): return {id_: idx for idx, id_ in enumerate(list_)} def _is_id_pair(self, index): return (isinstance(index, tuple) and len(index) == 2 and all(map(lambda e: isinstance(e, str), index))) class DistanceMatrix(DissimilarityMatrix): """Store distances between objects. A `DistanceMatrix` is a `DissimilarityMatrix` with the additional requirement that the matrix data is symmetric. There are additional methods made available that take advantage of this symmetry. See Also -------- DissimilarityMatrix Notes ----- The distances are stored in redundant (square-form) format [1]_. To facilitate use with other scientific Python routines (e.g., scipy), the distances can be retrieved in condensed (vector-form) format using `condensed_form`. `DistanceMatrix` only requires that the distances it stores are symmetric. Checks are *not* performed to ensure the other three metric properties hold (non-negativity, identity of indiscernibles, and triangle inequality) [2]_. Thus, a `DistanceMatrix` instance can store distances that are not metric. References ---------- .. [1] http://docs.scipy.org/doc/scipy/reference/spatial.distance.html .. [2] http://planetmath.org/metricspace """ # Override here, used in superclass __str__ _matrix_element_name = 'distance' @classonlymethod @experimental(as_of="0.4.1") def from_iterable(cls, iterable, metric, key=None, keys=None, validate=True): """Create DistanceMatrix from all pairs in an iterable given a metric. Parameters ---------- iterable : iterable Iterable containing objects to compute pairwise distances on. metric : callable A function that takes two arguments and returns a float representing the distance between the two arguments. key : callable or metadata key, optional A function that takes one argument and returns a string representing the id of the element in the distance matrix. Alternatively, a key to a `metadata` property if it exists for each element in the `iterable`. If None, then default ids will be used. keys : iterable, optional An iterable of the same length as `iterable`. Each element will be used as the respective key. validate : boolean, optional If ``True``, all pairwise distances are computed, including upper and lower triangles and the diagonal, and the resulting matrix is validated for symmetry and hollowness. If ``False``, `metric` is assumed to be hollow and symmetric and only the lower triangle (excluding the diagonal) is computed. Pass ``validate=False`` if you are sure `metric` is hollow and symmetric for improved performance. Returns ------- DistanceMatrix The `metric` applied to pairwise elements in the `iterable`. Raises ------ ValueError If `key` and `keys` are both provided. """ if validate: return super(DistanceMatrix, cls).from_iterable(iterable, metric, key, keys) iterable = list(iterable) if key is not None and keys is not None: raise ValueError("Cannot use both `key` and `keys` at the same" " time.") keys_ = None if key is not None: keys_ = [resolve_key(e, key) for e in iterable] elif keys is not None: keys_ = keys dm = np.zeros((len(iterable),) * 2) for i, a in enumerate(iterable): for j, b in enumerate(iterable[:i]): dm[i, j] = dm[j, i] = metric(a, b) return cls(dm, keys_) @experimental(as_of="0.4.0") def condensed_form(self): """Return an array of distances in condensed format. Returns ------- ndarray One-dimensional ``numpy.ndarray`` of distances in condensed format. Notes ----- Condensed format is described in [1]_. The conversion is not a constant-time operation, though it should be relatively quick to perform. References ---------- .. [1] http://docs.scipy.org/doc/scipy/reference/spatial.distance.html """ return squareform(self._data, force='tovector', checks=False) @experimental(as_of="0.4.0") def permute(self, condensed=False): """Randomly permute both rows and columns in the matrix. Randomly permutes the ordering of rows and columns in the matrix. The same permutation is applied to both rows and columns in order to maintain symmetry and hollowness. Only the rows/columns in the distance matrix are permuted; the IDs are *not* permuted. Parameters ---------- condensed : bool, optional If ``True``, return the permuted distance matrix in condensed format. Otherwise, return the permuted distance matrix as a new ``DistanceMatrix`` instance. Returns ------- DistanceMatrix or ndarray Permuted distances as a new ``DistanceMatrix`` or as a ``ndarray`` in condensed format. See Also -------- condensed_form Notes ----- This method does not modify the distance matrix that it is called on. It is more efficient to pass ``condensed=True`` than permuting the distance matrix and then converting to condensed format. """ order = np.random.permutation(self.shape[0]) if condensed: permuted_condensed = distmat_reorder_condensed(self._data, order) return permuted_condensed else: # Note: Skip validation, since we assume self was already validated permuted = distmat_reorder(self._data, order) return self.__class__(permuted, self.ids, validate=False) def _validate(self, data, ids): """Validate the data array and IDs. Overrides the superclass `_validate`. Performs a check for symmetry in addition to the checks performed in the superclass. """ super(DistanceMatrix, self)._validate(data, ids) data_sym, data_hol = is_symmetric_and_hollow(data) if not data_sym: raise DistanceMatrixError( "Data must be symmetric and cannot contain NaNs.") if not data_hol: raise DistanceMatrixError("Data must be hollow (i.e., the diagonal" " can only contain zeros).") @experimental(as_of="0.5.1") def to_series(self): """Create a ``pandas.Series`` from this ``DistanceMatrix``. The series will contain distances in condensed form: only distances from one matrix triangle are included, and the diagonal is excluded. The series' index will be a ``pd.MultiIndex`` relating pairs of IDs to distances. The pairs of IDs will be in row-major order with respect to the upper matrix triangle. To obtain all distances (i.e. both upper and lower matrix triangles and the diagonal), use ``DistanceMatrix.to_data_frame``. To obtain *only* the distances in condensed form (e.g. for use with SciPy), use ``DistanceMatrix.condensed_form``. Returns ------- pd.Series ``pd.Series`` with pairs of IDs on the index. See Also -------- to_data_frame condensed_form scipy.spatial.distance.squareform Examples -------- >>> from skbio import DistanceMatrix >>> dm = DistanceMatrix([[0, 1, 2, 3], ... [1, 0, 4, 5], ... [2, 4, 0, 6], ... [3, 5, 6, 0]], ids=['a', 'b', 'c', 'd']) >>> dm.to_series() a b 1.0 c 2.0 d 3.0 b c 4.0 d 5.0 c d 6.0 dtype: float64 """ distances = self.condensed_form() # `id_pairs` will not be interpreted as a `pd.MultiIndex` if it is an # iterable returned by `itertools.combinations`. id_pairs = list(itertools.combinations(self.ids, 2)) index = pd.Index(id_pairs, tupleize_cols=True) return pd.Series(data=distances, index=index, dtype=float) @experimental(as_of="0.4.0") def randdm(num_objects, ids=None, constructor=None, random_fn=None): """Generate a distance matrix populated with random distances. Using the default `random_fn`, distances are randomly drawn from a uniform distribution over ``[0, 1)``. Regardless of `random_fn`, the resulting distance matrix is guaranteed to be symmetric and hollow. Parameters ---------- num_objects : int The number of objects in the resulting distance matrix. For example, if `num_objects` is 3, a 3x3 distance matrix will be returned. ids : sequence of str or None, optional A sequence of strings to be used as IDs. ``len(ids)`` must be equal to `num_objects`. If not provided, IDs will be monotonically-increasing integers cast as strings (numbering starts at 1). For example, ``('1', '2', '3')``. constructor : type, optional `DissimilarityMatrix` or subclass constructor to use when creating the random distance matrix. The returned distance matrix will be of this type. If ``None`` (the default), a `DistanceMatrix` instance will be returned. random_fn : function, optional Function to generate random values. `random_fn` must accept two arguments (number of rows and number of columns) and return a 2D ``numpy.ndarray`` of floats (or something that can be cast to float). If ``None`` (the default), ``numpy.random.rand`` will be used. Returns ------- DissimilarityMatrix `DissimilarityMatrix` (or subclass) instance of random distances. Type depends on `constructor`. See Also -------- numpy.random.rand """ if constructor is None: constructor = DistanceMatrix if random_fn is None: random_fn = np.random.rand data = np.tril(random_fn(num_objects, num_objects), -1) data = data + data.T if not ids: ids = map(str, range(1, num_objects + 1)) return constructor(data, ids) # helper functions for anosim and permanova def _preprocess_input_sng(ids, sample_size, grouping, column): """Compute intermediate results not affected by permutations. These intermediate results can be computed a single time for efficiency, regardless of grouping vector permutations (i.e., when calculating the p-value). These intermediate results are used by both ANOSIM and PERMANOVA. Also validates and normalizes input (e.g., converting ``DataFrame`` column into grouping vector). """ if isinstance(grouping, pd.DataFrame): if column is None: raise ValueError( "Must provide a column name if supplying a DataFrame.") else: grouping = _df_to_vector(ids, grouping, column) elif column is not None: raise ValueError( "Must provide a DataFrame if supplying a column name.") if len(grouping) != sample_size: raise ValueError( "Grouping vector size must match the number of IDs in the " "distance matrix.") # Find the group labels and convert grouping to an integer vector # (factor). groups, grouping = np.unique(grouping, return_inverse=True) num_groups = len(groups) if num_groups == len(grouping): raise ValueError( "All values in the grouping vector are unique. This method cannot " "operate on a grouping vector with only unique values (e.g., " "there are no 'within' distances because each group of objects " "contains only a single object).") if num_groups == 1: raise ValueError( "All values in the grouping vector are the same. This method " "cannot operate on a grouping vector with only a single group of " "objects (e.g., there are no 'between' distances because there is " "only a single group).") return num_groups, grouping def _preprocess_input(distance_matrix, grouping, column): """Compute intermediate results not affected by permutations. These intermediate results can be computed a single time for efficiency, regardless of grouping vector permutations (i.e., when calculating the p-value). These intermediate results are used by both ANOSIM and PERMANOVA. Also validates and normalizes input (e.g., converting ``DataFrame`` column into grouping vector). """ if not isinstance(distance_matrix, DistanceMatrix): raise TypeError("Input must be a DistanceMatrix.") sample_size = distance_matrix.shape[0] num_groups, grouping = _preprocess_input_sng(distance_matrix.ids, sample_size, grouping, column) tri_idxs = np.triu_indices(sample_size, k=1) distances = distance_matrix.condensed_form() return sample_size, num_groups, grouping, tri_idxs, distances def _df_to_vector(ids, df, column): """Return a grouping vector from a ``DataFrame`` column. Parameters ---------- ids : liat IDs that will be mapped to group labels. df : pandas.DataFrame ``DataFrame`` (indexed by distance matrix ID). column : str Column name in `df` containing group labels. Returns ------- list Grouping vector (vector of labels) based on the IDs in `ids`. Each ID's label is looked up in the ``DataFrame`` under the column specified by `column`. Raises ------ ValueError If `column` is not in the ``DataFrame``, or a distance matrix ID is not in the ``DataFrame``. """ if column not in df: raise ValueError("Column '%s' not in DataFrame." % column) grouping = df.reindex(ids, axis=0).loc[:, column] if grouping.isnull().any(): raise ValueError( "One or more IDs in the distance matrix are not in the data " "frame.") return grouping.tolist() def _run_monte_carlo_stats(test_stat_function, grouping, permutations): """Run stat test and compute significance with Monte Carlo permutations.""" if permutations < 0: raise ValueError( "Number of permutations must be greater than or equal to zero.") stat = test_stat_function(grouping) p_value = np.nan if permutations > 0: perm_stats = np.empty(permutations, dtype=np.float64) for i in range(permutations): perm_grouping = np.random.permutation(grouping) perm_stats[i] = test_stat_function(perm_grouping) p_value = ((perm_stats >= stat).sum() + 1) / (permutations + 1) return stat, p_value def _build_results(method_name, test_stat_name, sample_size, num_groups, stat, p_value, permutations): """Return ``pandas.Series`` containing results of statistical test.""" return pd.Series( data=[method_name, test_stat_name, sample_size, num_groups, stat, p_value, permutations], index=['method name', 'test statistic name', 'sample size', 'number of groups', 'test statistic', 'p-value', 'number of permutations'], name='%s results' % method_name) scikit-bio-0.5.9/skbio/stats/distance/_bioenv.py000066400000000000000000000224721446255456000216360ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from itertools import combinations import numpy as np import pandas as pd from scipy.spatial.distance import pdist from scipy.stats import spearmanr from skbio.stats.distance import DistanceMatrix from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def bioenv(distance_matrix, data_frame, columns=None): """Find subset of variables maximally correlated with distances. Finds subsets of variables whose Euclidean distances (after scaling the variables; see Notes section below for details) are maximally rank-correlated with the distance matrix. For example, the distance matrix might contain distances between communities, and the variables might be numeric environmental variables (e.g., pH). Correlation between the community distance matrix and Euclidean environmental distance matrix is computed using Spearman's rank correlation coefficient (:math:`\\rho`). Subsets of environmental variables range in size from 1 to the total number of variables (inclusive). For example, if there are 3 variables, the "best" variable subsets will be computed for subset sizes 1, 2, and 3. The "best" subset is chosen by computing the correlation between the community distance matrix and all possible Euclidean environmental distance matrices at the given subset size. The combination of environmental variables with maximum correlation is chosen as the "best" subset. Parameters ---------- distance_matrix : DistanceMatrix Distance matrix containing distances between objects (e.g., distances between samples of microbial communities). data_frame : pandas.DataFrame Contains columns of variables (e.g., numeric environmental variables such as pH) associated with the objects in `distance_matrix`. Must be indexed by the IDs in `distance_matrix` (i.e., the row labels must be distance matrix IDs), but the order of IDs between `distance_matrix` and `data_frame` need not be the same. All IDs in the distance matrix must be present in `data_frame`. Extra IDs in `data_frame` are allowed (they are ignored in the calculations). columns : iterable of strs, optional Column names in `data_frame` to include as variables in the calculations. If not provided, defaults to all columns in `data_frame`. The values in each column must be numeric or convertible to a numeric type. Returns ------- pandas.DataFrame Data frame containing the "best" subset of variables at each subset size, as well as the correlation coefficient of each. Raises ------ TypeError If invalid input types are provided, or if one or more specified columns in `data_frame` are not numeric. ValueError If column name(s) or `distance_matrix` IDs cannot be found in `data_frame`, if there is missing data (``NaN``) in the environmental variables, or if the environmental variables cannot be scaled (e.g., due to zero variance). See Also -------- scipy.stats.spearmanr Notes ----- See [1]_ for the original method reference (originally called BIO-ENV). The general algorithm and interface are similar to ``vegan::bioenv``, available in R's vegan package [2]_. This method can also be found in PRIMER-E [3]_ (originally called BIO-ENV, but is now called BEST). .. warning:: This method can take a *long* time to run if a large number of variables are specified, as all possible subsets are evaluated at each subset size. The variables are scaled before computing the Euclidean distance: each column is centered and then scaled by its standard deviation. References ---------- .. [1] Clarke, K. R & Ainsworth, M. 1993. "A method of linking multivariate community structure to environmental variables". Marine Ecology Progress Series, 92, 205-219. .. [2] http://cran.r-project.org/web/packages/vegan/index.html .. [3] http://www.primer-e.com/primer.htm Examples -------- Import the functionality we'll use in the following examples: >>> import pandas as pd >>> from skbio import DistanceMatrix >>> from skbio.stats.distance import bioenv Load a 4x4 community distance matrix: >>> dm = DistanceMatrix([[0.0, 0.5, 0.25, 0.75], ... [0.5, 0.0, 0.1, 0.42], ... [0.25, 0.1, 0.0, 0.33], ... [0.75, 0.42, 0.33, 0.0]], ... ['A', 'B', 'C', 'D']) Load a ``pandas.DataFrame`` with two environmental variables, pH and elevation: >>> df = pd.DataFrame([[7.0, 400], ... [8.0, 530], ... [7.5, 450], ... [8.5, 810]], ... index=['A','B','C','D'], ... columns=['pH', 'Elevation']) Note that the data frame is indexed with the same IDs (``'A'``, ``'B'``, ``'C'``, and ``'D'``) that are in the distance matrix. This is necessary in order to link the environmental variables (metadata) to each of the objects in the distance matrix. In this example, the IDs appear in the same order in both the distance matrix and data frame, but this is not necessary. Find the best subsets of environmental variables that are correlated with community distances: >>> bioenv(dm, df) # doctest: +NORMALIZE_WHITESPACE size correlation vars pH 1 0.771517 pH, Elevation 2 0.714286 We see that in this simple example, pH alone is maximally rank-correlated with the community distances (:math:`\\rho=0.771517`). """ if not isinstance(distance_matrix, DistanceMatrix): raise TypeError("Must provide a DistanceMatrix as input.") if not isinstance(data_frame, pd.DataFrame): raise TypeError("Must provide a pandas.DataFrame as input.") if columns is None: columns = data_frame.columns.values.tolist() if len(set(columns)) != len(columns): raise ValueError("Duplicate column names are not supported.") if len(columns) < 1: raise ValueError("Must provide at least one column.") for column in columns: if column not in data_frame: raise ValueError("Column '%s' not in data frame." % column) # Subset and order the vars data frame to match the IDs in the distance # matrix, only keeping the specified columns. vars_df = data_frame.reindex(distance_matrix.ids, axis=0).loc[:, columns] if vars_df.isnull().any().any(): raise ValueError("One or more IDs in the distance matrix are not " "in the data frame, or there is missing data in the " "data frame.") try: vars_df = vars_df.astype(float) except ValueError: raise TypeError("All specified columns in the data frame must be " "numeric.") # Scale the vars and extract the underlying numpy array from the data # frame. We mainly do this for performance as we'll be taking subsets of # columns within a tight loop and using a numpy array ends up being ~2x # faster. vars_array = _scale(vars_df).values dm_flat = distance_matrix.condensed_form() num_vars = len(columns) var_idxs = np.arange(num_vars) # For each subset size, store the best combination of variables: # (string identifying best vars, subset size, rho) max_rhos = np.empty(num_vars, dtype=[('vars', object), ('size', int), ('correlation', float)]) for subset_size in range(1, num_vars + 1): max_rho = None for subset_idxs in combinations(var_idxs, subset_size): # Compute Euclidean distances using the current subset of # variables. pdist returns the distances in condensed form. vars_dm_flat = pdist(vars_array[:, subset_idxs], metric='euclidean') rho = spearmanr(dm_flat, vars_dm_flat)[0] # If there are ties for the best rho at a given subset size, choose # the first one in order to match vegan::bioenv's behavior. if max_rho is None or rho > max_rho[0]: max_rho = (rho, subset_idxs) vars_label = ', '.join([columns[i] for i in max_rho[1]]) max_rhos[subset_size - 1] = (vars_label, subset_size, max_rho[0]) return pd.DataFrame.from_records(max_rhos, index='vars') def _scale(df): """Center and scale each column in a data frame. Each column is centered (by subtracting the mean) and then scaled by its standard deviation. """ # Modified from http://stackoverflow.com/a/18005745 df = df.copy() df -= df.mean() df /= df.std() if df.isnull().any().any(): raise ValueError("Column(s) in the data frame could not be scaled, " "likely because the column(s) had no variance.") return df scikit-bio-0.5.9/skbio/stats/distance/_cutils.c000066400000000000000000043575061446255456000214660ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "extra_compile_args": [ "-I.", "-fopenmp-simd", "-DSIMDE_ENABLE_OPENMP" ], "name": "skbio.stats.distance._cutils", "sources": [ "skbio/stats/distance/_cutils.pyx" ] }, "module_name": "skbio.stats.distance._cutils" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__stats__distance___cutils #define __PYX_HAVE_API__skbio__stats__distance___cutils /* Early includes */ #include "pythread.h" #include #include #include #include "pystate.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "skbio/stats/distance/_cutils.pyx", "stringsource", }; /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release #define __Pyx_FastGIL_Remember() #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() /* MemviewSliceStruct.proto */ struct __pyx_memoryview_obj; typedef struct { struct __pyx_memoryview_obj *memview; char *data; Py_ssize_t shape[8]; Py_ssize_t strides[8]; Py_ssize_t suboffsets[8]; } __Pyx_memviewslice; #define __Pyx_MemoryView_Len(m) (m.shape[0]) /* Atomics.proto */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 #endif #define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS #define __pyx_atomic_int_type int #if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ (__GNUC_MINOR__ > 1 ||\ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) #ifdef __PYX_DEBUG_ATOMICS #warning "Using GNU atomics" #endif #elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL #include #undef __pyx_atomic_int_type #define __pyx_atomic_int_type long #pragma intrinsic (_InterlockedExchangeAdd) #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) #ifdef __PYX_DEBUG_ATOMICS #pragma message ("Using MSVC atomics") #endif #else #undef CYTHON_ATOMICS #define CYTHON_ATOMICS 0 #ifdef __PYX_DEBUG_ATOMICS #warning "Not using atomics" #endif #endif typedef volatile __pyx_atomic_int_type __pyx_atomic_int; #if CYTHON_ATOMICS #define __pyx_add_acquisition_count(memview)\ __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) #define __pyx_sub_acquisition_count(memview)\ __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) #else #define __pyx_add_acquisition_count(memview)\ __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) #define __pyx_sub_acquisition_count(memview)\ __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) #endif /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /*--- Type declarations ---*/ struct __pyx_array_obj; struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; /* "View.MemoryView":106 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * * cdef: */ struct __pyx_array_obj { PyObject_HEAD struct __pyx_vtabstruct_array *__pyx_vtab; char *data; Py_ssize_t len; char *format; int ndim; Py_ssize_t *_shape; Py_ssize_t *_strides; Py_ssize_t itemsize; PyObject *mode; PyObject *_format; void (*callback_free_data)(void *); int free_data; int dtype_is_object; }; /* "View.MemoryView":280 * * @cname('__pyx_MemviewEnum') * cdef class Enum(object): # <<<<<<<<<<<<<< * cdef object name * def __init__(self, name): */ struct __pyx_MemviewEnum_obj { PyObject_HEAD PyObject *name; }; /* "View.MemoryView":331 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< * * cdef object obj */ struct __pyx_memoryview_obj { PyObject_HEAD struct __pyx_vtabstruct_memoryview *__pyx_vtab; PyObject *obj; PyObject *_size; PyObject *_array_interface; PyThread_type_lock lock; __pyx_atomic_int acquisition_count[2]; __pyx_atomic_int *acquisition_count_aligned_p; Py_buffer view; int flags; int dtype_is_object; __Pyx_TypeInfo *typeinfo; }; /* "View.MemoryView":967 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" * */ struct __pyx_memoryviewslice_obj { struct __pyx_memoryview_obj __pyx_base; __Pyx_memviewslice from_slice; PyObject *from_object; PyObject *(*to_object_func)(char *); int (*to_dtype_func)(char *, PyObject *); }; /* "View.MemoryView":106 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * * cdef: */ struct __pyx_vtabstruct_array { PyObject *(*get_memview)(struct __pyx_array_obj *); }; static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; /* "View.MemoryView":331 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< * * cdef object obj */ struct __pyx_vtabstruct_memoryview { char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); }; static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; /* "View.MemoryView":967 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" * */ struct __pyx_vtabstruct__memoryviewslice { struct __pyx_vtabstruct_memoryview __pyx_base; }; static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictContains.proto */ static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { int result = PyDict_Contains(dict, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* UnicodeAsUCS4.proto */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); /* object_ord.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyObject_Ord(c)\ (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) #else #define __Pyx_PyObject_Ord(c) __Pyx__PyObject_Ord(c) #endif static long __Pyx__PyObject_Ord(PyObject* c); /* SetItemInt.proto */ #define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, int wraparound, int boundscheck); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* MemviewSliceInit.proto */ #define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d #define __Pyx_MEMVIEW_DIRECT 1 #define __Pyx_MEMVIEW_PTR 2 #define __Pyx_MEMVIEW_FULL 4 #define __Pyx_MEMVIEW_CONTIG 8 #define __Pyx_MEMVIEW_STRIDED 16 #define __Pyx_MEMVIEW_FOLLOW 32 #define __Pyx_IS_C_CONTIG 1 #define __Pyx_IS_F_CONTIG 2 static int __Pyx_init_memviewslice( struct __pyx_memoryview_obj *memview, int ndim, __Pyx_memviewslice *memviewslice, int memview_is_new_reference); static CYTHON_INLINE int __pyx_add_acquisition_count_locked( __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); #define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) #define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) #define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) #define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); /* DivInt[Py_ssize_t].proto */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* UnaryNegOverflows.proto */ #define UNARY_NEG_WOULD_OVERFLOW(x)\ (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* decode_c_string_utf16.proto */ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 0; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = -1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } /* decode_c_string.proto */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* ListExtend.proto */ static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { #if CYTHON_COMPILING_IN_CPYTHON PyObject* none = _PyList_Extend((PyListObject*)L, v); if (unlikely(!none)) return -1; Py_DECREF(none); return 0; #else return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); #endif } /* None.proto */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); /* DivInt[long].proto */ static CYTHON_INLINE long __Pyx_div_long(long, long); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED 1 #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { PyCFunctionObject func; #if PY_VERSION_HEX < 0x030500A0 PyObject *func_weakreflist; #endif PyObject *func_dict; PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; PyObject *func_classobj; void *defaults; int defaults_pyobjects; size_t defaults_size; // used by FusedFunction for copying defaults int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, size_t size, int pyobjects); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(void); /* FusedFunction.proto */ typedef struct { __pyx_CyFunctionObject func; PyObject *__signatures__; PyObject *type; PyObject *self; } __pyx_FusedFunctionObject; static PyObject *__pyx_FusedFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject *code); static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self); static PyTypeObject *__pyx_FusedFunctionType = NULL; static int __pyx_FusedFunction_init(void); #define __Pyx_FusedFunction_USED /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; /* MemviewSliceIsContig.proto */ static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); /* OverlappingSlices.proto */ static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, __Pyx_memviewslice *slice2, int ndim, size_t itemsize); /* Capsule.proto */ static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* TypeInfoCompare.proto */ static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); /* MemviewSliceValidateAndInit.proto */ static int __Pyx_ValidateAndInit_memviewslice( int *axes_specs, int c_or_f_flag, int buf_flags, int ndim, __Pyx_TypeInfo *dtype, __Pyx_BufFmt_StackElem stack[], __Pyx_memviewslice *memviewslice, PyObject *original_obj); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_long(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_float(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_long(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(PyObject *, int writable_flag); /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* MemviewSliceCopyTemplate.proto */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, const char *mode, int ndim, size_t sizeof_dtype, int contig_flag, int dtype_is_object); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* BytesContains.proto */ static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character); /* ImportNumPyArray.proto */ static PyObject *__pyx_numpy_ndarray = NULL; static PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ /* Module declarations from 'cython.view' */ /* Module declarations from 'cython' */ /* Module declarations from 'skbio.stats.distance._cutils' */ static PyTypeObject *__pyx_array_type = 0; static PyTypeObject *__pyx_MemviewEnum_type = 0; static PyTypeObject *__pyx_memoryview_type = 0; static PyTypeObject *__pyx_memoryviewslice_type = 0; static PyObject *generic = 0; static PyObject *strided = 0; static PyObject *indirect = 0; static PyObject *contiguous = 0; static PyObject *indirect_contiguous = 0; static int __pyx_memoryview_thread_locks_used; static PyThread_type_lock __pyx_memoryview_thread_locks[8]; static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ static void *__pyx_align_pointer(void *, size_t); /*proto*/ static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ static PyObject *_unellipsify(PyObject *, int); /*proto*/ static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/ static int __pyx_memoryview_err(PyObject *, char *); /*proto*/ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_long = { "long", NULL, sizeof(long), { 0 }, 0, IS_UNSIGNED(long) ? 'U' : 'I', IS_UNSIGNED(long), 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_Py_ssize_t = { "Py_ssize_t", NULL, sizeof(Py_ssize_t), { 0 }, 0, IS_UNSIGNED(Py_ssize_t) ? 'U' : 'I', IS_UNSIGNED(Py_ssize_t), 0 }; #define __Pyx_MODULE_NAME "skbio.stats.distance._cutils" extern int __pyx_module_is_main_skbio__stats__distance___cutils; int __pyx_module_is_main_skbio__stats__distance___cutils = 0; /* Implementation of 'skbio.stats.distance._cutils' */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_Ellipsis; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_IndexError; static const char __pyx_k_[] = ""; static const char __pyx_k_O[] = "O"; static const char __pyx_k_c[] = "c"; static const char __pyx_k_p[] = "p"; static const char __pyx_k_s[] = "s"; static const char __pyx_k__2[] = "()"; static const char __pyx_k__3[] = "|"; static const char __pyx_k_id[] = "id"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_add[] = "add"; static const char __pyx_k_col[] = "col"; static const char __pyx_k_idx[] = "idx"; static const char __pyx_k_in2[] = "in2"; static const char __pyx_k_in3[] = "in3"; static const char __pyx_k_mat[] = "mat"; static const char __pyx_k_mul[] = "mul"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_obj[] = "obj"; static const char __pyx_k_on2[] = "on2"; static const char __pyx_k_on3[] = "on3"; static const char __pyx_k_row[] = "row"; static const char __pyx_k_s_W[] = "s_W"; static const char __pyx_k_val[] = "val"; static const char __pyx_k_y_n[] = "y_n"; static const char __pyx_k_args[] = "args"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_coli[] = "coli"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_icol[] = "icol"; static const char __pyx_k_in_n[] = "in_n"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mode[] = "mode"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_ndim[] = "ndim"; static const char __pyx_k_pack[] = "pack"; static const char __pyx_k_rowi[] = "rowi"; static const char __pyx_k_size[] = "size"; static const char __pyx_k_step[] = "step"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_tcol[] = "tcol"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_trow[] = "trow"; static const char __pyx_k_vrow[] = "vrow"; static const char __pyx_k_xval[] = "xval"; static const char __pyx_k_yval[] = "yval"; static const char __pyx_k_ASCII[] = "ASCII"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_flags[] = "flags"; static const char __pyx_k_float[] = "float"; static const char __pyx_k_my_ps[] = "my_ps"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_out_n[] = "out_n"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_strip[] = "strip"; static const char __pyx_k_xmean[] = "xmean"; static const char __pyx_k_double[] = "double"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_in_mat[] = "in_mat"; static const char __pyx_k_is_sym[] = "is_sym"; static const char __pyx_k_kwargs[] = "kwargs"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_normxm[] = "normxm"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_struct[] = "struct"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_x_data[] = "x_data"; static const char __pyx_k_fortran[] = "fortran"; static const char __pyx_k_memview[] = "memview"; static const char __pyx_k_out_mat[] = "out_mat"; static const char __pyx_k_perms_n[] = "perms_n"; static const char __pyx_k_testval[] = "testval"; static const char __pyx_k_Ellipsis[] = "Ellipsis"; static const char __pyx_k_defaults[] = "defaults"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_grouping[] = "grouping"; static const char __pyx_k_itemsize[] = "itemsize"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_tcol_max[] = "tcol_max"; static const char __pyx_k_trow_max[] = "trow_max"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_group_idx[] = "group_idx"; static const char __pyx_k_is_hollow[] = "is_hollow"; static const char __pyx_k_local_s_W[] = "local_s_W"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_IndexError[] = "IndexError"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_perm_order[] = "perm_order"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_signatures[] = "signatures"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_group_sizes[] = "group_sizes"; static const char __pyx_k_reorder_vec[] = "reorder_vec"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_ym_normalized[] = "ym_normalized"; static const char __pyx_k_permuted_stats[] = "permuted_stats"; static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; static const char __pyx_k_distance_matrix[] = "distance_matrix"; static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_out_mat_condensed[] = "out_mat_condensed"; static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_distmat_reorder_cy[] = "distmat_reorder_cy"; static const char __pyx_k_strided_and_direct[] = ""; static const char __pyx_k_strided_and_indirect[] = ""; static const char __pyx_k_contiguous_and_direct[] = ""; static const char __pyx_k_MemoryView_of_r_object[] = ""; static const char __pyx_k_permanova_f_stat_sW_cy[] = "permanova_f_stat_sW_cy"; static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; static const char __pyx_k_contiguous_and_indirect[] = ""; static const char __pyx_k_mantel_perm_pearsonr_cy[] = "mantel_perm_pearsonr_cy"; static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; static const char __pyx_k_is_symmetric_and_hollow_cy[] = "is_symmetric_and_hollow_cy"; static const char __pyx_k_No_matching_signature_found[] = "No matching signature found"; static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; static const char __pyx_k_distmat_reorder_condensed_cy[] = "distmat_reorder_condensed_cy"; static const char __pyx_k_skbio_stats_distance__cutils[] = "skbio.stats.distance._cutils"; static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; static const char __pyx_k_strided_and_direct_or_indirect[] = ""; static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; static const char __pyx_k_Expected_at_least_d_argument_s_g[] = "Expected at least %d argument%s, got %d"; static const char __pyx_k_Function_call_with_ambiguous_arg[] = "Function call with ambiguous argument types"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_skbio_stats_distance__cutils_pyx[] = "skbio/stats/distance/_cutils.pyx"; static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; static PyObject *__pyx_kp_s_; static PyObject *__pyx_n_s_ASCII; static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; static PyObject *__pyx_kp_s_Cannot_index_with_type_s; static PyObject *__pyx_n_s_Ellipsis; static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; static PyObject *__pyx_kp_s_Expected_at_least_d_argument_s_g; static PyObject *__pyx_kp_s_Function_call_with_ambiguous_arg; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; static PyObject *__pyx_n_s_IndexError; static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; static PyObject *__pyx_n_s_MemoryError; static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; static PyObject *__pyx_kp_s_MemoryView_of_r_object; static PyObject *__pyx_kp_s_No_matching_signature_found; static PyObject *__pyx_n_b_O; static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_View_MemoryView; static PyObject *__pyx_kp_s__2; static PyObject *__pyx_kp_s__3; static PyObject *__pyx_n_s_add; static PyObject *__pyx_n_s_allocate_buffer; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_base; static PyObject *__pyx_n_s_c; static PyObject *__pyx_n_u_c; static PyObject *__pyx_n_s_class; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_col; static PyObject *__pyx_n_s_coli; static PyObject *__pyx_kp_s_contiguous_and_direct; static PyObject *__pyx_kp_s_contiguous_and_indirect; static PyObject *__pyx_n_s_defaults; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_distance_matrix; static PyObject *__pyx_n_s_distmat_reorder_condensed_cy; static PyObject *__pyx_n_s_distmat_reorder_cy; static PyObject *__pyx_n_s_double; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dtype_is_object; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_flags; static PyObject *__pyx_n_s_float; static PyObject *__pyx_n_s_format; static PyObject *__pyx_n_s_fortran; static PyObject *__pyx_n_u_fortran; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; static PyObject *__pyx_n_s_group_idx; static PyObject *__pyx_n_s_group_sizes; static PyObject *__pyx_n_s_grouping; static PyObject *__pyx_n_s_icol; static PyObject *__pyx_n_s_id; static PyObject *__pyx_n_s_idx; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_in2; static PyObject *__pyx_n_s_in3; static PyObject *__pyx_n_s_in_mat; static PyObject *__pyx_n_s_in_n; static PyObject *__pyx_n_s_is_hollow; static PyObject *__pyx_n_s_is_sym; static PyObject *__pyx_n_s_is_symmetric_and_hollow_cy; static PyObject *__pyx_n_s_itemsize; static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; static PyObject *__pyx_n_s_kind; static PyObject *__pyx_n_s_kwargs; static PyObject *__pyx_n_s_local_s_W; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mantel_perm_pearsonr_cy; static PyObject *__pyx_n_s_mat; static PyObject *__pyx_n_s_memview; static PyObject *__pyx_n_s_mode; static PyObject *__pyx_n_s_mul; static PyObject *__pyx_n_s_my_ps; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_n_s_ndim; static PyObject *__pyx_n_s_new; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_normxm; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_n_s_obj; static PyObject *__pyx_n_s_on2; static PyObject *__pyx_n_s_on3; static PyObject *__pyx_n_s_out_mat; static PyObject *__pyx_n_s_out_mat_condensed; static PyObject *__pyx_n_s_out_n; static PyObject *__pyx_n_s_p; static PyObject *__pyx_n_s_pack; static PyObject *__pyx_n_s_perm_order; static PyObject *__pyx_n_s_permanova_f_stat_sW_cy; static PyObject *__pyx_n_s_perms_n; static PyObject *__pyx_n_s_permuted_stats; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_getbuffer; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_Enum; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_reorder_vec; static PyObject *__pyx_n_s_row; static PyObject *__pyx_n_s_rowi; static PyObject *__pyx_n_s_s; static PyObject *__pyx_n_s_s_W; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_shape; static PyObject *__pyx_n_s_signatures; static PyObject *__pyx_n_s_size; static PyObject *__pyx_n_s_skbio_stats_distance__cutils; static PyObject *__pyx_kp_s_skbio_stats_distance__cutils_pyx; static PyObject *__pyx_n_s_split; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_step; static PyObject *__pyx_n_s_stop; static PyObject *__pyx_kp_s_strided_and_direct; static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; static PyObject *__pyx_kp_s_strided_and_indirect; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_strip; static PyObject *__pyx_n_s_struct; static PyObject *__pyx_n_s_tcol; static PyObject *__pyx_n_s_tcol_max; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_testval; static PyObject *__pyx_n_s_trow; static PyObject *__pyx_n_s_trow_max; static PyObject *__pyx_kp_s_unable_to_allocate_array_data; static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; static PyObject *__pyx_n_s_unpack; static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_val; static PyObject *__pyx_n_s_vrow; static PyObject *__pyx_n_s_x_data; static PyObject *__pyx_n_s_xmean; static PyObject *__pyx_n_s_xval; static PyObject *__pyx_n_s_y_n; static PyObject *__pyx_n_s_ym_normalized; static PyObject *__pyx_n_s_yval; static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_10is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_12is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_16distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_18distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_22distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat_condensed); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_24distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat_condensed); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_28mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_data, __Pyx_memviewslice __pyx_v_perm_order, float __pyx_v_xmean, float __pyx_v_normxm, __Pyx_memviewslice __pyx_v_ym_normalized, __Pyx_memviewslice __pyx_v_permuted_stats); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_30mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_data, __Pyx_memviewslice __pyx_v_perm_order, double __pyx_v_xmean, double __pyx_v_normxm, __Pyx_memviewslice __pyx_v_ym_normalized, __Pyx_memviewslice __pyx_v_permuted_stats); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_34permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_distance_matrix, __Pyx_memviewslice __pyx_v_group_sizes, __Pyx_memviewslice __pyx_v_grouping); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_36permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_distance_matrix, __Pyx_memviewslice __pyx_v_group_sizes, __Pyx_memviewslice __pyx_v_grouping); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_3; static PyObject *__pyx_int_6; static PyObject *__pyx_int_112105877; static PyObject *__pyx_int_136983863; static PyObject *__pyx_int_184977713; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_slice__20; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; static PyObject *__pyx_tuple__21; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__29; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__37; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__39; static PyObject *__pyx_tuple__40; static PyObject *__pyx_codeobj__26; static PyObject *__pyx_codeobj__28; static PyObject *__pyx_codeobj__30; static PyObject *__pyx_codeobj__32; static PyObject *__pyx_codeobj__34; static PyObject *__pyx_codeobj__41; /* Late includes */ /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_1is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy[] = "\n Check if mat is symmetric and hollow.\n Equivalent to [not (mat.T != mat).any(), np.trace(mat) == 0]\n\n Parameters\n ----------\n mat : 2D array_like\n Distance matrix.\n\n Result:\n -------\n is_symmetric: Boolean\n not (mat.T != mat).any()\n is_hollow: Boolean\n np.trace(mat) == 0\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_8distance_7_cutils_1is_symmetric_and_hollow_cy = {"is_symmetric_and_hollow_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_8distance_7_cutils_1is_symmetric_and_hollow_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy}; static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_1is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 19, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_symmetric_and_hollow_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_mat, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_mat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_1); __Pyx_GIVEREF(__pyx_int_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_1); __Pyx_INCREF(__pyx_kp_s_); __Pyx_GIVEREF(__pyx_kp_s_); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_kp_s_); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 19, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_11is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_arg_mat); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_11is_symmetric_and_hollow_cy = {"__pyx_fuse_0is_symmetric_and_hollow_cy", (PyCFunction)__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_11is_symmetric_and_hollow_cy, METH_O, __pyx_doc_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_11is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_arg_mat) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_symmetric_and_hollow_cy (wrapper)", 0); assert(__pyx_arg_mat); { __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_arg_mat, PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 19, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.is_symmetric_and_hollow_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_10is_symmetric_and_hollow_cy(__pyx_self, __pyx_v_mat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_10is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_trow; Py_ssize_t __pyx_v_tcol; Py_ssize_t __pyx_v_trow_max; Py_ssize_t __pyx_v_tcol_max; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; int __pyx_v_is_sym; int __pyx_v_is_hollow; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0is_symmetric_and_hollow_cy", 0); /* "skbio/stats/distance/_cutils.pyx":36 * np.trace(mat) == 0 * """ * cdef Py_ssize_t in_n = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = mat.shape[1] * */ __pyx_v_in_n = (__pyx_v_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":37 * """ * cdef Py_ssize_t in_n = mat.shape[0] * cdef Py_ssize_t in2 = mat.shape[1] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_in2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":39 * cdef Py_ssize_t in2 = mat.shape[1] * * assert in_n == in2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t trow,tcol */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 39, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":48 * * # use int instead of bool for portability * cdef int is_sym = True # <<<<<<<<<<<<<< * cdef int is_hollow = True * */ __pyx_v_is_sym = 1; /* "skbio/stats/distance/_cutils.pyx":49 * # use int instead of bool for portability * cdef int is_sym = True * cdef int is_hollow = True # <<<<<<<<<<<<<< * * # use a tiled approach to maximize memory locality */ __pyx_v_is_hollow = 1; /* "skbio/stats/distance/_cutils.pyx":52 * * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_in_n; if ((24 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 24 - 24/abs(24)) / 24; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(&:__pyx_v_is_hollow) reduction(&:__pyx_v_is_sym) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_row) lastprivate(__pyx_v_tcol) lastprivate(__pyx_v_tcol_max) firstprivate(__pyx_v_trow) lastprivate(__pyx_v_trow) lastprivate(__pyx_v_trow_max) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_trow = (Py_ssize_t)(0 + 24 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol_max = ((Py_ssize_t)0xbad0bad0); __pyx_v_trow_max = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":53 * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): * trow_max = min(trow+24, in_n) # <<<<<<<<<<<<<< * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) */ __pyx_t_4 = __pyx_v_in_n; __pyx_t_5 = (__pyx_v_trow + 24); if (((__pyx_t_4 < __pyx_t_5) != 0)) { __pyx_t_6 = __pyx_t_4; } else { __pyx_t_6 = __pyx_t_5; } __pyx_v_trow_max = __pyx_t_6; /* "skbio/stats/distance/_cutils.pyx":54 * for trow in prange(0, in_n, 24, nogil=True): * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): # <<<<<<<<<<<<<< * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): */ __pyx_t_6 = __pyx_v_in_n; __pyx_t_4 = __pyx_t_6; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=24) { __pyx_v_tcol = __pyx_t_5; /* "skbio/stats/distance/_cutils.pyx":55 * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) # <<<<<<<<<<<<<< * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): */ __pyx_t_7 = __pyx_v_in_n; __pyx_t_8 = (__pyx_v_tcol + 24); if (((__pyx_t_7 < __pyx_t_8) != 0)) { __pyx_t_9 = __pyx_t_7; } else { __pyx_t_9 = __pyx_t_8; } __pyx_v_tcol_max = __pyx_t_9; /* "skbio/stats/distance/_cutils.pyx":56 * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) */ __pyx_t_9 = __pyx_v_trow_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_trow; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_row = __pyx_t_8; /* "skbio/stats/distance/_cutils.pyx":57 * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row */ __pyx_t_10 = __pyx_v_tcol_max; __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = __pyx_v_tcol; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_col = __pyx_t_12; /* "skbio/stats/distance/_cutils.pyx":58 * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) # <<<<<<<<<<<<<< * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): */ __pyx_t_13 = __pyx_v_row; __pyx_t_14 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_t_16 = __pyx_v_row; __pyx_v_is_sym = (__pyx_v_is_sym & ((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_13 * __pyx_v_mat.strides[0]) )) + __pyx_t_14)) ))) == (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_15 * __pyx_v_mat.strides[0]) )) + __pyx_t_16)) ))))); } } /* "skbio/stats/distance/_cutils.pyx":59 * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) */ __pyx_t_17 = ((__pyx_v_trow == __pyx_v_tcol) != 0); if (__pyx_t_17) { /* "skbio/stats/distance/_cutils.pyx":60 * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * is_hollow &= (mat[col,col]==0) * */ __pyx_t_9 = __pyx_v_tcol_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_tcol; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_col = __pyx_t_8; /* "skbio/stats/distance/_cutils.pyx":61 * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) # <<<<<<<<<<<<<< * * return [(is_sym==True), (is_hollow==True)] */ __pyx_t_16 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_v_is_hollow = (__pyx_v_is_hollow & ((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_16 * __pyx_v_mat.strides[0]) )) + __pyx_t_15)) ))) == 0.0)); } /* "skbio/stats/distance/_cutils.pyx":59 * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) */ } } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":52 * * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":63 * is_hollow &= (mat[col,col]==0) * * return [(is_sym==True), (is_hollow==True)] # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_18 = __Pyx_PyBool_FromLong((__pyx_v_is_sym == 1)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __pyx_t_19 = __Pyx_PyBool_FromLong((__pyx_v_is_hollow == 1)); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_20 = PyList_New(2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); __Pyx_GIVEREF(__pyx_t_18); PyList_SET_ITEM(__pyx_t_20, 0, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_19); PyList_SET_ITEM(__pyx_t_20, 1, __pyx_t_19); __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_r = __pyx_t_20; __pyx_t_20 = 0; goto __pyx_L0; /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_18); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_20); __Pyx_AddTraceback("skbio.stats.distance._cutils.is_symmetric_and_hollow_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_13is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_arg_mat); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_13is_symmetric_and_hollow_cy = {"__pyx_fuse_1is_symmetric_and_hollow_cy", (PyCFunction)__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_13is_symmetric_and_hollow_cy, METH_O, __pyx_doc_5skbio_5stats_8distance_7_cutils_is_symmetric_and_hollow_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_13is_symmetric_and_hollow_cy(PyObject *__pyx_self, PyObject *__pyx_arg_mat) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_symmetric_and_hollow_cy (wrapper)", 0); assert(__pyx_arg_mat); { __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_arg_mat, PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 19, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.is_symmetric_and_hollow_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_12is_symmetric_and_hollow_cy(__pyx_self, __pyx_v_mat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_12is_symmetric_and_hollow_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_trow; Py_ssize_t __pyx_v_tcol; Py_ssize_t __pyx_v_trow_max; Py_ssize_t __pyx_v_tcol_max; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; int __pyx_v_is_sym; int __pyx_v_is_hollow; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1is_symmetric_and_hollow_cy", 0); /* "skbio/stats/distance/_cutils.pyx":36 * np.trace(mat) == 0 * """ * cdef Py_ssize_t in_n = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = mat.shape[1] * */ __pyx_v_in_n = (__pyx_v_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":37 * """ * cdef Py_ssize_t in_n = mat.shape[0] * cdef Py_ssize_t in2 = mat.shape[1] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_in2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":39 * cdef Py_ssize_t in2 = mat.shape[1] * * assert in_n == in2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t trow,tcol */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 39, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":48 * * # use int instead of bool for portability * cdef int is_sym = True # <<<<<<<<<<<<<< * cdef int is_hollow = True * */ __pyx_v_is_sym = 1; /* "skbio/stats/distance/_cutils.pyx":49 * # use int instead of bool for portability * cdef int is_sym = True * cdef int is_hollow = True # <<<<<<<<<<<<<< * * # use a tiled approach to maximize memory locality */ __pyx_v_is_hollow = 1; /* "skbio/stats/distance/_cutils.pyx":52 * * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_in_n; if ((24 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 24 - 24/abs(24)) / 24; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(&:__pyx_v_is_hollow) reduction(&:__pyx_v_is_sym) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_row) lastprivate(__pyx_v_tcol) lastprivate(__pyx_v_tcol_max) firstprivate(__pyx_v_trow) lastprivate(__pyx_v_trow) lastprivate(__pyx_v_trow_max) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_trow = (Py_ssize_t)(0 + 24 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol_max = ((Py_ssize_t)0xbad0bad0); __pyx_v_trow_max = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":53 * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): * trow_max = min(trow+24, in_n) # <<<<<<<<<<<<<< * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) */ __pyx_t_4 = __pyx_v_in_n; __pyx_t_5 = (__pyx_v_trow + 24); if (((__pyx_t_4 < __pyx_t_5) != 0)) { __pyx_t_6 = __pyx_t_4; } else { __pyx_t_6 = __pyx_t_5; } __pyx_v_trow_max = __pyx_t_6; /* "skbio/stats/distance/_cutils.pyx":54 * for trow in prange(0, in_n, 24, nogil=True): * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): # <<<<<<<<<<<<<< * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): */ __pyx_t_6 = __pyx_v_in_n; __pyx_t_4 = __pyx_t_6; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=24) { __pyx_v_tcol = __pyx_t_5; /* "skbio/stats/distance/_cutils.pyx":55 * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) # <<<<<<<<<<<<<< * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): */ __pyx_t_7 = __pyx_v_in_n; __pyx_t_8 = (__pyx_v_tcol + 24); if (((__pyx_t_7 < __pyx_t_8) != 0)) { __pyx_t_9 = __pyx_t_7; } else { __pyx_t_9 = __pyx_t_8; } __pyx_v_tcol_max = __pyx_t_9; /* "skbio/stats/distance/_cutils.pyx":56 * for tcol in range(0, in_n, 24): * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) */ __pyx_t_9 = __pyx_v_trow_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_trow; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_row = __pyx_t_8; /* "skbio/stats/distance/_cutils.pyx":57 * tcol_max = min(tcol+24, in_n) * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row */ __pyx_t_10 = __pyx_v_tcol_max; __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = __pyx_v_tcol; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_col = __pyx_t_12; /* "skbio/stats/distance/_cutils.pyx":58 * for row in range(trow, trow_max, 1): * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) # <<<<<<<<<<<<<< * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): */ __pyx_t_13 = __pyx_v_row; __pyx_t_14 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_t_16 = __pyx_v_row; __pyx_v_is_sym = (__pyx_v_is_sym & ((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_13 * __pyx_v_mat.strides[0]) )) + __pyx_t_14)) ))) == (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_15 * __pyx_v_mat.strides[0]) )) + __pyx_t_16)) ))))); } } /* "skbio/stats/distance/_cutils.pyx":59 * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) */ __pyx_t_17 = ((__pyx_v_trow == __pyx_v_tcol) != 0); if (__pyx_t_17) { /* "skbio/stats/distance/_cutils.pyx":60 * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * is_hollow &= (mat[col,col]==0) * */ __pyx_t_9 = __pyx_v_tcol_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_tcol; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_col = __pyx_t_8; /* "skbio/stats/distance/_cutils.pyx":61 * if (trow==tcol): # diagonal block, only ones that can have col==row * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) # <<<<<<<<<<<<<< * * return [(is_sym==True), (is_hollow==True)] */ __pyx_t_16 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_v_is_hollow = (__pyx_v_is_hollow & ((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_16 * __pyx_v_mat.strides[0]) )) + __pyx_t_15)) ))) == 0.0)); } /* "skbio/stats/distance/_cutils.pyx":59 * for col in range(tcol, tcol_max, 1): * is_sym &= (mat[row,col]==mat[col,row]) * if (trow==tcol): # diagonal block, only ones that can have col==row # <<<<<<<<<<<<<< * for col in range(tcol, tcol_max, 1): * is_hollow &= (mat[col,col]==0) */ } } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":52 * * # use a tiled approach to maximize memory locality * for trow in prange(0, in_n, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, in_n) * for tcol in range(0, in_n, 24): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":63 * is_hollow &= (mat[col,col]==0) * * return [(is_sym==True), (is_hollow==True)] # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_18 = __Pyx_PyBool_FromLong((__pyx_v_is_sym == 1)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __pyx_t_19 = __Pyx_PyBool_FromLong((__pyx_v_is_hollow == 1)); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_20 = PyList_New(2); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); __Pyx_GIVEREF(__pyx_t_18); PyList_SET_ITEM(__pyx_t_20, 0, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_19); PyList_SET_ITEM(__pyx_t_20, 1, __pyx_t_19); __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_r = __pyx_t_20; __pyx_t_20 = 0; goto __pyx_L0; /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_18); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_20); __Pyx_AddTraceback("skbio.stats.distance._cutils.is_symmetric_and_hollow_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/distance/_cutils.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[:, ::1] out_mat): * """ */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_3distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy[] = "\n Reorder the rows and columns of a distance matrix\n given a reorder vector.\n Not all of the columns need to be used.\n\n For example:\n [ [0, 1, 2, 3] ,\n [1, 0, 4, 5] ,\n [2, 4, 0, 6] ,\n [3, 5, 6, 0] ]\n with\n [1,0,3,2]\n will result in\n [ [0, 1, 5, 4] ,\n [1, 0, 3, 2] ,\n [5, 3, 0, 6] ,\n [4, 2, 6, 0] ]\n\n Note: No error checking is performed.\n The caller must ensure that all values in reorder_vec are valid\n\n Parameters\n ----------\n in_mat : 2D array_like\n Distance matrix.\n reorder_vec : 1D_array_like\n List of permutation indexes\n out_mat : 2D array_like\n Output, Distance matrix, must be same size as reorder_vec\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_8distance_7_cutils_3distmat_reorder_cy = {"distmat_reorder_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_8distance_7_cutils_3distmat_reorder_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy}; static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_3distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 68, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 68, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 68, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("distmat_reorder_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_in_mat, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_in_mat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 68, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 68, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 68, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 68, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 68, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 68, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 68, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 68, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_17distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_17distmat_reorder_cy = {"__pyx_fuse_0distmat_reorder_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_17distmat_reorder_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_17distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_in_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_reorder_vec = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_out_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("distmat_reorder_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_in_mat,&__pyx_n_s_reorder_vec,&__pyx_n_s_out_mat,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reorder_vec)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, 1); __PYX_ERR(0, 68, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_out_mat)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, 2); __PYX_ERR(0, 68, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "distmat_reorder_cy") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_in_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_in_mat.memview)) __PYX_ERR(0, 68, __pyx_L3_error) __pyx_v_reorder_vec = __Pyx_PyObject_to_MemoryviewSlice_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_reorder_vec.memview)) __PYX_ERR(0, 68, __pyx_L3_error) __pyx_v_out_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_out_mat.memview)) __PYX_ERR(0, 69, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_16distmat_reorder_cy(__pyx_self, __pyx_v_in_mat, __pyx_v_reorder_vec, __pyx_v_out_mat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_16distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_on3; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_vrow; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0distmat_reorder_cy", 0); /* "skbio/stats/distance/_cutils.pyx":100 * Output, Distance matrix, must be same size as reorder_vec * """ * cdef Py_ssize_t in_n = in_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] */ __pyx_v_in_n = (__pyx_v_in_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":101 * """ * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] */ __pyx_v_in2 = (__pyx_v_in_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":102 * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = out_mat.shape[0] * cdef Py_ssize_t on3 = out_mat.shape[1] */ __pyx_v_out_n = (__pyx_v_reorder_vec.shape[0]); /* "skbio/stats/distance/_cutils.pyx":103 * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on3 = out_mat.shape[1] * */ __pyx_v_on2 = (__pyx_v_out_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":104 * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] * cdef Py_ssize_t on3 = out_mat.shape[1] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on3 = (__pyx_v_out_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":106 * cdef Py_ssize_t on3 = out_mat.shape[1] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert out_n == on2 * assert out_n == on3 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 106, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":107 * * assert in_n == in2 * assert out_n == on2 # <<<<<<<<<<<<<< * assert out_n == on3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_out_n == __pyx_v_on2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 107, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":108 * assert in_n == in2 * assert out_n == on2 * assert out_n == on3 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_out_n == __pyx_v_on3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 108, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":113 * cdef Py_ssize_t vrow * * for row in prange(out_n, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * for col in range(out_n): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_out_n; if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":114 * * for row in prange(out_n, nogil=True): * vrow = reorder_vec[row] # <<<<<<<<<<<<<< * for col in range(out_n): * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] */ __pyx_t_4 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":115 * for row in prange(out_n, nogil=True): * vrow = reorder_vec[row] * for col in range(out_n): # <<<<<<<<<<<<<< * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] * */ __pyx_t_5 = __pyx_v_out_n; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_col = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":116 * vrow = reorder_vec[row] * for col in range(out_n): * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __pyx_t_4 = __pyx_v_col; __pyx_t_8 = __pyx_v_vrow; __pyx_t_9 = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); __pyx_t_10 = __pyx_v_row; __pyx_t_11 = __pyx_v_col; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_out_mat.data + __pyx_t_10 * __pyx_v_out_mat.strides[0]) )) + __pyx_t_11)) )) = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_in_mat.data + __pyx_t_8 * __pyx_v_in_mat.strides[0]) )) + __pyx_t_9)) ))); } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":113 * cdef Py_ssize_t vrow * * for row in prange(out_n, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * for col in range(out_n): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[:, ::1] out_mat): * """ */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_in_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_reorder_vec, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_out_mat, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_19distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_19distmat_reorder_cy = {"__pyx_fuse_1distmat_reorder_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_19distmat_reorder_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_2distmat_reorder_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_19distmat_reorder_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_in_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_reorder_vec = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_out_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("distmat_reorder_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_in_mat,&__pyx_n_s_reorder_vec,&__pyx_n_s_out_mat,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reorder_vec)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, 1); __PYX_ERR(0, 68, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_out_mat)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, 2); __PYX_ERR(0, 68, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "distmat_reorder_cy") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_in_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_in_mat.memview)) __PYX_ERR(0, 68, __pyx_L3_error) __pyx_v_reorder_vec = __Pyx_PyObject_to_MemoryviewSlice_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_reorder_vec.memview)) __PYX_ERR(0, 68, __pyx_L3_error) __pyx_v_out_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_out_mat.memview)) __PYX_ERR(0, 69, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("distmat_reorder_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_18distmat_reorder_cy(__pyx_self, __pyx_v_in_mat, __pyx_v_reorder_vec, __pyx_v_out_mat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_18distmat_reorder_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_on3; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_vrow; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1distmat_reorder_cy", 0); /* "skbio/stats/distance/_cutils.pyx":100 * Output, Distance matrix, must be same size as reorder_vec * """ * cdef Py_ssize_t in_n = in_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] */ __pyx_v_in_n = (__pyx_v_in_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":101 * """ * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] */ __pyx_v_in2 = (__pyx_v_in_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":102 * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = out_mat.shape[0] * cdef Py_ssize_t on3 = out_mat.shape[1] */ __pyx_v_out_n = (__pyx_v_reorder_vec.shape[0]); /* "skbio/stats/distance/_cutils.pyx":103 * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on3 = out_mat.shape[1] * */ __pyx_v_on2 = (__pyx_v_out_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":104 * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat.shape[0] * cdef Py_ssize_t on3 = out_mat.shape[1] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on3 = (__pyx_v_out_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":106 * cdef Py_ssize_t on3 = out_mat.shape[1] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert out_n == on2 * assert out_n == on3 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 106, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":107 * * assert in_n == in2 * assert out_n == on2 # <<<<<<<<<<<<<< * assert out_n == on3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_out_n == __pyx_v_on2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 107, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":108 * assert in_n == in2 * assert out_n == on2 * assert out_n == on3 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_out_n == __pyx_v_on3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 108, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":113 * cdef Py_ssize_t vrow * * for row in prange(out_n, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * for col in range(out_n): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_out_n; if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":114 * * for row in prange(out_n, nogil=True): * vrow = reorder_vec[row] # <<<<<<<<<<<<<< * for col in range(out_n): * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] */ __pyx_t_4 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":115 * for row in prange(out_n, nogil=True): * vrow = reorder_vec[row] * for col in range(out_n): # <<<<<<<<<<<<<< * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] * */ __pyx_t_5 = __pyx_v_out_n; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_col = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":116 * vrow = reorder_vec[row] * for col in range(out_n): * out_mat[row,col] = in_mat[vrow, reorder_vec[col]] # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __pyx_t_4 = __pyx_v_col; __pyx_t_8 = __pyx_v_vrow; __pyx_t_9 = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); __pyx_t_10 = __pyx_v_row; __pyx_t_11 = __pyx_v_col; *((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_out_mat.data + __pyx_t_10 * __pyx_v_out_mat.strides[0]) )) + __pyx_t_11)) )) = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_in_mat.data + __pyx_t_8 * __pyx_v_in_mat.strides[0]) )) + __pyx_t_9)) ))); } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":113 * cdef Py_ssize_t vrow * * for row in prange(out_n, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * for col in range(out_n): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[:, ::1] out_mat): * """ */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_in_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_reorder_vec, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_out_mat, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/distance/_cutils.pyx":120 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[::1] out_mat_condensed): * """ */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_5distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy[] = "\n Reorder the rows and columns of a distance matrix\n given a reorder vector.\n Not all of the columns need to be used.\n\n For example:\n [ [0, 1, 2, 3] ,\n [1, 0, 4, 5] ,\n [2, 4, 0, 6] ,\n [3, 5, 6, 0] ]\n with\n [1,0,3,2]\n will result in\n [ 1, 5, 4, 3, 2, 6 ]\n\n Note: No error checking is performed.\n The caller must ensure that all values in reorder_vec are valid\n\n Parameters\n ----------\n in_mat : 2D array_like\n Distance matrix.\n reorder_vec : 1D_array_like\n List of permutation indexes\n out_mat_condensed : 1D array_like\n Output, condensed distance matrix\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_8distance_7_cutils_5distmat_reorder_condensed_cy = {"distmat_reorder_condensed_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_8distance_7_cutils_5distmat_reorder_condensed_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy}; static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_5distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 120, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 120, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 120, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 120, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 120, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("distmat_reorder_condensed_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_in_mat, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_in_mat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 120, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 120, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 120, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 120, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 120, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 120, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 120, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 120, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_23distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_23distmat_reorder_condensed_cy = {"__pyx_fuse_0distmat_reorder_condensed_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_23distmat_reorder_condensed_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_23distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_in_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_reorder_vec = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_out_mat_condensed = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("distmat_reorder_condensed_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_in_mat,&__pyx_n_s_reorder_vec,&__pyx_n_s_out_mat_condensed,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reorder_vec)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, 1); __PYX_ERR(0, 120, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_out_mat_condensed)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, 2); __PYX_ERR(0, 120, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "distmat_reorder_condensed_cy") < 0)) __PYX_ERR(0, 120, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_in_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_in_mat.memview)) __PYX_ERR(0, 120, __pyx_L3_error) __pyx_v_reorder_vec = __Pyx_PyObject_to_MemoryviewSlice_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_reorder_vec.memview)) __PYX_ERR(0, 120, __pyx_L3_error) __pyx_v_out_mat_condensed = __Pyx_PyObject_to_MemoryviewSlice_dc_float(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_out_mat_condensed.memview)) __PYX_ERR(0, 121, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 120, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_condensed_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_22distmat_reorder_condensed_cy(__pyx_self, __pyx_v_in_mat, __pyx_v_reorder_vec, __pyx_v_out_mat_condensed); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_22distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat_condensed) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_vrow; Py_ssize_t __pyx_v_idx; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0distmat_reorder_condensed_cy", 0); /* "skbio/stats/distance/_cutils.pyx":149 * Output, condensed distance matrix * """ * cdef Py_ssize_t in_n = in_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] */ __pyx_v_in_n = (__pyx_v_in_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":150 * """ * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] */ __pyx_v_in2 = (__pyx_v_in_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":151 * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] * */ __pyx_v_out_n = (__pyx_v_reorder_vec.shape[0]); /* "skbio/stats/distance/_cutils.pyx":152 * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on2 = (__pyx_v_out_mat_condensed.shape[0]); /* "skbio/stats/distance/_cutils.pyx":154 * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert on2 == ((out_n-1)*out_n)/2 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 154, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":155 * * assert in_n == in2 * assert on2 == ((out_n-1)*out_n)/2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_on2 == __Pyx_div_Py_ssize_t(((__pyx_v_out_n - 1) * __pyx_v_out_n), 2)) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 155, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":161 * cdef Py_ssize_t idx * * for row in prange(out_n-1, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = (__pyx_v_out_n - 1); if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_idx) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":162 * * for row in prange(out_n-1, nogil=True): * vrow = reorder_vec[row] # <<<<<<<<<<<<<< * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): */ __pyx_t_4 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":163 * for row in prange(out_n-1, nogil=True): * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 # <<<<<<<<<<<<<< * for col in range(out_n-row-1): * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] */ __pyx_v_idx = ((__pyx_v_row * (__pyx_v_out_n - 1)) - __Pyx_div_Py_ssize_t(((__pyx_v_row - 1) * __pyx_v_row), 2)); /* "skbio/stats/distance/_cutils.pyx":164 * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): # <<<<<<<<<<<<<< * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] * */ __pyx_t_5 = ((__pyx_v_out_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_col = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":165 * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] # <<<<<<<<<<<<<< * * */ __pyx_t_4 = ((__pyx_v_col + __pyx_v_row) + 1); __pyx_t_8 = __pyx_v_vrow; __pyx_t_9 = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); __pyx_t_10 = (__pyx_v_idx + __pyx_v_col); *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_out_mat_condensed.data) + __pyx_t_10)) )) = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_in_mat.data + __pyx_t_8 * __pyx_v_in_mat.strides[0]) )) + __pyx_t_9)) ))); } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":161 * cdef Py_ssize_t idx * * for row in prange(out_n-1, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":120 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[::1] out_mat_condensed): * """ */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_condensed_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_in_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_reorder_vec, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_out_mat_condensed, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_25distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_25distmat_reorder_condensed_cy = {"__pyx_fuse_1distmat_reorder_condensed_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_25distmat_reorder_condensed_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_4distmat_reorder_condensed_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_25distmat_reorder_condensed_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_in_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_reorder_vec = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_out_mat_condensed = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("distmat_reorder_condensed_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_in_mat,&__pyx_n_s_reorder_vec,&__pyx_n_s_out_mat_condensed,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_in_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_reorder_vec)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, 1); __PYX_ERR(0, 120, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_out_mat_condensed)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, 2); __PYX_ERR(0, 120, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "distmat_reorder_condensed_cy") < 0)) __PYX_ERR(0, 120, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_in_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_in_mat.memview)) __PYX_ERR(0, 120, __pyx_L3_error) __pyx_v_reorder_vec = __Pyx_PyObject_to_MemoryviewSlice_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_reorder_vec.memview)) __PYX_ERR(0, 120, __pyx_L3_error) __pyx_v_out_mat_condensed = __Pyx_PyObject_to_MemoryviewSlice_dc_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_out_mat_condensed.memview)) __PYX_ERR(0, 121, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("distmat_reorder_condensed_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 120, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_condensed_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_24distmat_reorder_condensed_cy(__pyx_self, __pyx_v_in_mat, __pyx_v_reorder_vec, __pyx_v_out_mat_condensed); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_24distmat_reorder_condensed_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_in_mat, __Pyx_memviewslice __pyx_v_reorder_vec, __Pyx_memviewslice __pyx_v_out_mat_condensed) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_vrow; Py_ssize_t __pyx_v_idx; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1distmat_reorder_condensed_cy", 0); /* "skbio/stats/distance/_cutils.pyx":149 * Output, condensed distance matrix * """ * cdef Py_ssize_t in_n = in_mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] */ __pyx_v_in_n = (__pyx_v_in_mat.shape[0]); /* "skbio/stats/distance/_cutils.pyx":150 * """ * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] */ __pyx_v_in2 = (__pyx_v_in_mat.shape[1]); /* "skbio/stats/distance/_cutils.pyx":151 * cdef Py_ssize_t in_n = in_mat.shape[0] * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] * */ __pyx_v_out_n = (__pyx_v_reorder_vec.shape[0]); /* "skbio/stats/distance/_cutils.pyx":152 * cdef Py_ssize_t in2 = in_mat.shape[1] * cdef Py_ssize_t out_n = reorder_vec.shape[0] * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on2 = (__pyx_v_out_mat_condensed.shape[0]); /* "skbio/stats/distance/_cutils.pyx":154 * cdef Py_ssize_t on2 = out_mat_condensed.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert on2 == ((out_n-1)*out_n)/2 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 154, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":155 * * assert in_n == in2 * assert on2 == ((out_n-1)*out_n)/2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_on2 == __Pyx_div_Py_ssize_t(((__pyx_v_out_n - 1) * __pyx_v_out_n), 2)) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 155, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":161 * cdef Py_ssize_t idx * * for row in prange(out_n-1, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = (__pyx_v_out_n - 1); if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_idx) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/distance/_cutils.pyx":162 * * for row in prange(out_n-1, nogil=True): * vrow = reorder_vec[row] # <<<<<<<<<<<<<< * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): */ __pyx_t_4 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":163 * for row in prange(out_n-1, nogil=True): * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 # <<<<<<<<<<<<<< * for col in range(out_n-row-1): * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] */ __pyx_v_idx = ((__pyx_v_row * (__pyx_v_out_n - 1)) - __Pyx_div_Py_ssize_t(((__pyx_v_row - 1) * __pyx_v_row), 2)); /* "skbio/stats/distance/_cutils.pyx":164 * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): # <<<<<<<<<<<<<< * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] * */ __pyx_t_5 = ((__pyx_v_out_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_col = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":165 * idx = row*(out_n-1) - ((row-1)*row)/2 * for col in range(out_n-row-1): * out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] # <<<<<<<<<<<<<< * * */ __pyx_t_4 = ((__pyx_v_col + __pyx_v_row) + 1); __pyx_t_8 = __pyx_v_vrow; __pyx_t_9 = (*((long *) ( /* dim=0 */ ((char *) (((long *) __pyx_v_reorder_vec.data) + __pyx_t_4)) ))); __pyx_t_10 = (__pyx_v_idx + __pyx_v_col); *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_out_mat_condensed.data) + __pyx_t_10)) )) = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_in_mat.data + __pyx_t_8 * __pyx_v_in_mat.strides[0]) )) + __pyx_t_9)) ))); } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":161 * cdef Py_ssize_t idx * * for row in prange(out_n-1, nogil=True): # <<<<<<<<<<<<<< * vrow = reorder_vec[row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":120 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[::1] out_mat_condensed): * """ */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.distmat_reorder_condensed_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_in_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_reorder_vec, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_out_mat_condensed, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/distance/_cutils.pyx":170 * @cython.boundscheck(False) * @cython.wraparound(False) * def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, # <<<<<<<<<<<<<< * TReal xmean, TReal normxm, * TReal[::1] ym_normalized, */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_7mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy[] = "\n Fused permute, fma, pearsonr for mantel.\n\n Replaces the following python code:\n def _mantel_perm_pearsonr_one(x_flat, xmean, normxm, ym_normalized):\n # inline pearsonr, condensed from scipy.stats.pearsonr\n # and reusing some of the known values\n xm_normalized = (x_flat - xmean)/normxm\n one_stat = np.dot(xm_normalized, ym_normalized)\n one_stat = max(min(one_stat, 1.0), -1.0)\n return one_stat\n\n perm_gen = (_mantel_perm_pearsonr_one(distmat_reorder_condensed(x._data, perm_order[p,:]),\n xmean, normxm, ym_normalized)\n for p in range(permutations))\n permuted_stats = np.fromiter(perm_gen, np.float, count=permutations)\n\n Parameters\n ----------\n x_data : 2D array_like\n Distance matrix.\n perm_order : 2D array_like\n List of permutation orders.\n xmean: real\n Mean value of condensed x_data\n normxm: real\n Norm of pre-processed xm\n ym_normalized : 1D_array_like\n Normalized condensed y_data\n permuted_stats : 1D array_like\n Output, Pearson stats\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_8distance_7_cutils_7mantel_perm_pearsonr_cy = {"mantel_perm_pearsonr_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_8distance_7_cutils_7mantel_perm_pearsonr_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy}; static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_7mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 170, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 170, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 170, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("mantel_perm_pearsonr_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_x_data, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_x_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_6); __Pyx_GIVEREF(__pyx_int_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_6); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 170, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 170, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 170, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 170, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 170, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_29mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_29mantel_perm_pearsonr_cy = {"__pyx_fuse_0mantel_perm_pearsonr_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_29mantel_perm_pearsonr_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_29mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_x_data = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_perm_order = { 0, 0, { 0 }, { 0 }, { 0 } }; float __pyx_v_xmean; float __pyx_v_normxm; __Pyx_memviewslice __pyx_v_ym_normalized = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_permuted_stats = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("mantel_perm_pearsonr_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_data,&__pyx_n_s_perm_order,&__pyx_n_s_xmean,&__pyx_n_s_normxm,&__pyx_n_s_ym_normalized,&__pyx_n_s_permuted_stats,0}; PyObject* values[6] = {0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_data)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_perm_order)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 1); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmean)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 2); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normxm)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 3); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ym_normalized)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 4); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_permuted_stats)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 5); __PYX_ERR(0, 170, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "mantel_perm_pearsonr_cy") < 0)) __PYX_ERR(0, 170, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); } __pyx_v_x_data = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_data.memview)) __PYX_ERR(0, 170, __pyx_L3_error) __pyx_v_perm_order = __Pyx_PyObject_to_MemoryviewSlice_d_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_perm_order.memview)) __PYX_ERR(0, 170, __pyx_L3_error) __pyx_v_xmean = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_xmean == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error) __pyx_v_normxm = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_normxm == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error) __pyx_v_ym_normalized = __Pyx_PyObject_to_MemoryviewSlice_dc_float(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_ym_normalized.memview)) __PYX_ERR(0, 172, __pyx_L3_error) __pyx_v_permuted_stats = __Pyx_PyObject_to_MemoryviewSlice_dc_float(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_permuted_stats.memview)) __PYX_ERR(0, 173, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 170, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.mantel_perm_pearsonr_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_28mantel_perm_pearsonr_cy(__pyx_self, __pyx_v_x_data, __pyx_v_perm_order, __pyx_v_xmean, __pyx_v_normxm, __pyx_v_ym_normalized, __pyx_v_permuted_stats); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_28mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_data, __Pyx_memviewslice __pyx_v_perm_order, float __pyx_v_xmean, float __pyx_v_normxm, __Pyx_memviewslice __pyx_v_ym_normalized, __Pyx_memviewslice __pyx_v_permuted_stats) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_perms_n; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_y_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_p; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_icol; Py_ssize_t __pyx_v_vrow; Py_ssize_t __pyx_v_idx; float __pyx_v_mul; float __pyx_v_add; float __pyx_v_my_ps; float __pyx_v_yval; float __pyx_v_xval; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations float __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0mantel_perm_pearsonr_cy", 0); /* "skbio/stats/distance/_cutils.pyx":206 * Output, Pearson stats * """ * cdef Py_ssize_t in_n = x_data.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] */ __pyx_v_in_n = (__pyx_v_x_data.shape[0]); /* "skbio/stats/distance/_cutils.pyx":207 * """ * cdef Py_ssize_t in_n = x_data.shape[0] * cdef Py_ssize_t in2 = x_data.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] */ __pyx_v_in2 = (__pyx_v_x_data.shape[1]); /* "skbio/stats/distance/_cutils.pyx":208 * cdef Py_ssize_t in_n = x_data.shape[0] * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] */ __pyx_v_perms_n = (__pyx_v_perm_order.shape[0]); /* "skbio/stats/distance/_cutils.pyx":209 * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t y_n = ym_normalized.shape[0] * cdef Py_ssize_t on2 = permuted_stats.shape[0] */ __pyx_v_out_n = (__pyx_v_perm_order.shape[1]); /* "skbio/stats/distance/_cutils.pyx":210 * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = permuted_stats.shape[0] * */ __pyx_v_y_n = (__pyx_v_ym_normalized.shape[0]); /* "skbio/stats/distance/_cutils.pyx":211 * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] * cdef Py_ssize_t on2 = permuted_stats.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on2 = (__pyx_v_permuted_stats.shape[0]); /* "skbio/stats/distance/_cutils.pyx":213 * cdef Py_ssize_t on2 = permuted_stats.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert y_n == ((out_n-1)*out_n)/2 * assert perms_n == on2 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 213, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":214 * * assert in_n == in2 * assert y_n == ((out_n-1)*out_n)/2 # <<<<<<<<<<<<<< * assert perms_n == on2 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_y_n == __Pyx_div_Py_ssize_t(((__pyx_v_out_n - 1) * __pyx_v_out_n), 2)) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 214, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":215 * assert in_n == in2 * assert y_n == ((out_n-1)*out_n)/2 * assert perms_n == on2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t p */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_perms_n == __pyx_v_on2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 215, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":222 * cdef Py_ssize_t idx * * cdef TReal mul = 1.0/normxm # <<<<<<<<<<<<<< * cdef TReal add = -xmean/normxm * */ if (unlikely(__pyx_v_normxm == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 222, __pyx_L1_error) } __pyx_v_mul = (1.0 / __pyx_v_normxm); /* "skbio/stats/distance/_cutils.pyx":223 * * cdef TReal mul = 1.0/normxm * cdef TReal add = -xmean/normxm # <<<<<<<<<<<<<< * * cdef TReal my_ps */ __pyx_t_1 = (-__pyx_v_xmean); if (unlikely(__pyx_v_normxm == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 223, __pyx_L1_error) } __pyx_v_add = (__pyx_t_1 / __pyx_v_normxm); /* "skbio/stats/distance/_cutils.pyx":229 * cdef TReal xval * * for p in prange(perms_n, nogil=True): # <<<<<<<<<<<<<< * my_ps = 0.0 * for row in range(out_n-1): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_2 = __pyx_v_perms_n; if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_4 = (__pyx_t_2 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_4 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_icol) lastprivate(__pyx_v_idx) lastprivate(__pyx_v_my_ps) firstprivate(__pyx_v_p) lastprivate(__pyx_v_p) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) lastprivate(__pyx_v_xval) lastprivate(__pyx_v_yval) #endif /* _OPENMP */ for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_4; __pyx_t_3++){ { __pyx_v_p = (Py_ssize_t)(0 + 1 * __pyx_t_3); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_icol = ((Py_ssize_t)0xbad0bad0); __pyx_v_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_my_ps = ((float)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); __pyx_v_xval = ((float)__PYX_NAN()); __pyx_v_yval = ((float)__PYX_NAN()); /* "skbio/stats/distance/_cutils.pyx":230 * * for p in prange(perms_n, nogil=True): * my_ps = 0.0 # <<<<<<<<<<<<<< * for row in range(out_n-1): * vrow = perm_order[p, row] */ __pyx_v_my_ps = 0.0; /* "skbio/stats/distance/_cutils.pyx":231 * for p in prange(perms_n, nogil=True): * my_ps = 0.0 * for row in range(out_n-1): # <<<<<<<<<<<<<< * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ __pyx_t_5 = (__pyx_v_out_n - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_row = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":232 * my_ps = 0.0 * for row in range(out_n-1): * vrow = perm_order[p, row] # <<<<<<<<<<<<<< * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): */ __pyx_t_8 = __pyx_v_p; __pyx_t_9 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=1 */ ((char *) (((long *) ( /* dim=0 */ (__pyx_v_perm_order.data + __pyx_t_8 * __pyx_v_perm_order.strides[0]) )) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":233 * for row in range(out_n-1): * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 # <<<<<<<<<<<<<< * for icol in range(out_n-row-1): * col = icol+row+1 */ __pyx_v_idx = ((__pyx_v_row * (__pyx_v_out_n - 1)) - __Pyx_div_Py_ssize_t(((__pyx_v_row - 1) * __pyx_v_row), 2)); /* "skbio/stats/distance/_cutils.pyx":234 * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): # <<<<<<<<<<<<<< * col = icol+row+1 * yval = ym_normalized[idx+icol] */ __pyx_t_10 = ((__pyx_v_out_n - __pyx_v_row) - 1); __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_icol = __pyx_t_12; /* "skbio/stats/distance/_cutils.pyx":235 * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): * col = icol+row+1 # <<<<<<<<<<<<<< * yval = ym_normalized[idx+icol] * xval = x_data[vrow, perm_order[p, col]]*mul + add */ __pyx_v_col = ((__pyx_v_icol + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":236 * for icol in range(out_n-row-1): * col = icol+row+1 * yval = ym_normalized[idx+icol] # <<<<<<<<<<<<<< * xval = x_data[vrow, perm_order[p, col]]*mul + add * # do not use += to avoid having prange consider it for reduction */ __pyx_t_9 = (__pyx_v_idx + __pyx_v_icol); __pyx_v_yval = (*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_ym_normalized.data) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":237 * col = icol+row+1 * yval = ym_normalized[idx+icol] * xval = x_data[vrow, perm_order[p, col]]*mul + add # <<<<<<<<<<<<<< * # do not use += to avoid having prange consider it for reduction * my_ps = yval*xval + my_ps */ __pyx_t_9 = __pyx_v_p; __pyx_t_8 = __pyx_v_col; __pyx_t_13 = __pyx_v_vrow; __pyx_t_14 = (*((long *) ( /* dim=1 */ ((char *) (((long *) ( /* dim=0 */ (__pyx_v_perm_order.data + __pyx_t_9 * __pyx_v_perm_order.strides[0]) )) + __pyx_t_8)) ))); __pyx_v_xval = (((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_x_data.data + __pyx_t_13 * __pyx_v_x_data.strides[0]) )) + __pyx_t_14)) ))) * __pyx_v_mul) + __pyx_v_add); /* "skbio/stats/distance/_cutils.pyx":239 * xval = x_data[vrow, perm_order[p, col]]*mul + add * # do not use += to avoid having prange consider it for reduction * my_ps = yval*xval + my_ps # <<<<<<<<<<<<<< * * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of */ __pyx_v_my_ps = ((__pyx_v_yval * __pyx_v_xval) + __pyx_v_my_ps); } } /* "skbio/stats/distance/_cutils.pyx":243 * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of * # floating point arithmetic. * if my_ps>1.0: # <<<<<<<<<<<<<< * my_ps = 1.0 * elif my_ps<-1.0: */ __pyx_t_15 = ((__pyx_v_my_ps > 1.0) != 0); if (__pyx_t_15) { /* "skbio/stats/distance/_cutils.pyx":244 * # floating point arithmetic. * if my_ps>1.0: * my_ps = 1.0 # <<<<<<<<<<<<<< * elif my_ps<-1.0: * my_ps = -1.0 */ __pyx_v_my_ps = 1.0; /* "skbio/stats/distance/_cutils.pyx":243 * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of * # floating point arithmetic. * if my_ps>1.0: # <<<<<<<<<<<<<< * my_ps = 1.0 * elif my_ps<-1.0: */ goto __pyx_L14; } /* "skbio/stats/distance/_cutils.pyx":245 * if my_ps>1.0: * my_ps = 1.0 * elif my_ps<-1.0: # <<<<<<<<<<<<<< * my_ps = -1.0 * permuted_stats[p] = my_ps */ __pyx_t_15 = ((__pyx_v_my_ps < -1.0) != 0); if (__pyx_t_15) { /* "skbio/stats/distance/_cutils.pyx":246 * my_ps = 1.0 * elif my_ps<-1.0: * my_ps = -1.0 # <<<<<<<<<<<<<< * permuted_stats[p] = my_ps * */ __pyx_v_my_ps = -1.0; /* "skbio/stats/distance/_cutils.pyx":245 * if my_ps>1.0: * my_ps = 1.0 * elif my_ps<-1.0: # <<<<<<<<<<<<<< * my_ps = -1.0 * permuted_stats[p] = my_ps */ } __pyx_L14:; /* "skbio/stats/distance/_cutils.pyx":247 * elif my_ps<-1.0: * my_ps = -1.0 * permuted_stats[p] = my_ps # <<<<<<<<<<<<<< * * */ __pyx_t_8 = __pyx_v_p; *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_permuted_stats.data) + __pyx_t_8)) )) = __pyx_v_my_ps; } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":229 * cdef TReal xval * * for p in prange(perms_n, nogil=True): # <<<<<<<<<<<<<< * my_ps = 0.0 * for row in range(out_n-1): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":170 * @cython.boundscheck(False) * @cython.wraparound(False) * def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, # <<<<<<<<<<<<<< * TReal xmean, TReal normxm, * TReal[::1] ym_normalized, */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.mantel_perm_pearsonr_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_x_data, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_perm_order, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_ym_normalized, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_permuted_stats, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_31mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_31mantel_perm_pearsonr_cy = {"__pyx_fuse_1mantel_perm_pearsonr_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_31mantel_perm_pearsonr_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_6mantel_perm_pearsonr_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_31mantel_perm_pearsonr_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_x_data = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_perm_order = { 0, 0, { 0 }, { 0 }, { 0 } }; double __pyx_v_xmean; double __pyx_v_normxm; __Pyx_memviewslice __pyx_v_ym_normalized = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_permuted_stats = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("mantel_perm_pearsonr_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x_data,&__pyx_n_s_perm_order,&__pyx_n_s_xmean,&__pyx_n_s_normxm,&__pyx_n_s_ym_normalized,&__pyx_n_s_permuted_stats,0}; PyObject* values[6] = {0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x_data)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_perm_order)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 1); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmean)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 2); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normxm)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 3); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ym_normalized)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 4); __PYX_ERR(0, 170, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_permuted_stats)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, 5); __PYX_ERR(0, 170, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "mantel_perm_pearsonr_cy") < 0)) __PYX_ERR(0, 170, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 6) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); } __pyx_v_x_data = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_x_data.memview)) __PYX_ERR(0, 170, __pyx_L3_error) __pyx_v_perm_order = __Pyx_PyObject_to_MemoryviewSlice_d_dc_long(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_perm_order.memview)) __PYX_ERR(0, 170, __pyx_L3_error) __pyx_v_xmean = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_xmean == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error) __pyx_v_normxm = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_normxm == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L3_error) __pyx_v_ym_normalized = __Pyx_PyObject_to_MemoryviewSlice_dc_double(values[4], PyBUF_WRITABLE); if (unlikely(!__pyx_v_ym_normalized.memview)) __PYX_ERR(0, 172, __pyx_L3_error) __pyx_v_permuted_stats = __Pyx_PyObject_to_MemoryviewSlice_dc_double(values[5], PyBUF_WRITABLE); if (unlikely(!__pyx_v_permuted_stats.memview)) __PYX_ERR(0, 173, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("mantel_perm_pearsonr_cy", 1, 6, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 170, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.mantel_perm_pearsonr_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_30mantel_perm_pearsonr_cy(__pyx_self, __pyx_v_x_data, __pyx_v_perm_order, __pyx_v_xmean, __pyx_v_normxm, __pyx_v_ym_normalized, __pyx_v_permuted_stats); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_30mantel_perm_pearsonr_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_x_data, __Pyx_memviewslice __pyx_v_perm_order, double __pyx_v_xmean, double __pyx_v_normxm, __Pyx_memviewslice __pyx_v_ym_normalized, __Pyx_memviewslice __pyx_v_permuted_stats) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_perms_n; Py_ssize_t __pyx_v_out_n; Py_ssize_t __pyx_v_y_n; Py_ssize_t __pyx_v_on2; Py_ssize_t __pyx_v_p; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_icol; Py_ssize_t __pyx_v_vrow; Py_ssize_t __pyx_v_idx; double __pyx_v_mul; double __pyx_v_add; double __pyx_v_my_ps; double __pyx_v_yval; double __pyx_v_xval; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations double __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1mantel_perm_pearsonr_cy", 0); /* "skbio/stats/distance/_cutils.pyx":206 * Output, Pearson stats * """ * cdef Py_ssize_t in_n = x_data.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] */ __pyx_v_in_n = (__pyx_v_x_data.shape[0]); /* "skbio/stats/distance/_cutils.pyx":207 * """ * cdef Py_ssize_t in_n = x_data.shape[0] * cdef Py_ssize_t in2 = x_data.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] */ __pyx_v_in2 = (__pyx_v_x_data.shape[1]); /* "skbio/stats/distance/_cutils.pyx":208 * cdef Py_ssize_t in_n = x_data.shape[0] * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] */ __pyx_v_perms_n = (__pyx_v_perm_order.shape[0]); /* "skbio/stats/distance/_cutils.pyx":209 * cdef Py_ssize_t in2 = x_data.shape[1] * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t y_n = ym_normalized.shape[0] * cdef Py_ssize_t on2 = permuted_stats.shape[0] */ __pyx_v_out_n = (__pyx_v_perm_order.shape[1]); /* "skbio/stats/distance/_cutils.pyx":210 * cdef Py_ssize_t perms_n = perm_order.shape[0] * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t on2 = permuted_stats.shape[0] * */ __pyx_v_y_n = (__pyx_v_ym_normalized.shape[0]); /* "skbio/stats/distance/_cutils.pyx":211 * cdef Py_ssize_t out_n = perm_order.shape[1] * cdef Py_ssize_t y_n = ym_normalized.shape[0] * cdef Py_ssize_t on2 = permuted_stats.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_on2 = (__pyx_v_permuted_stats.shape[0]); /* "skbio/stats/distance/_cutils.pyx":213 * cdef Py_ssize_t on2 = permuted_stats.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert y_n == ((out_n-1)*out_n)/2 * assert perms_n == on2 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 213, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":214 * * assert in_n == in2 * assert y_n == ((out_n-1)*out_n)/2 # <<<<<<<<<<<<<< * assert perms_n == on2 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_y_n == __Pyx_div_Py_ssize_t(((__pyx_v_out_n - 1) * __pyx_v_out_n), 2)) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 214, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":215 * assert in_n == in2 * assert y_n == ((out_n-1)*out_n)/2 * assert perms_n == on2 # <<<<<<<<<<<<<< * * cdef Py_ssize_t p */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_perms_n == __pyx_v_on2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 215, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":222 * cdef Py_ssize_t idx * * cdef TReal mul = 1.0/normxm # <<<<<<<<<<<<<< * cdef TReal add = -xmean/normxm * */ if (unlikely(__pyx_v_normxm == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 222, __pyx_L1_error) } __pyx_v_mul = (1.0 / __pyx_v_normxm); /* "skbio/stats/distance/_cutils.pyx":223 * * cdef TReal mul = 1.0/normxm * cdef TReal add = -xmean/normxm # <<<<<<<<<<<<<< * * cdef TReal my_ps */ __pyx_t_1 = (-__pyx_v_xmean); if (unlikely(__pyx_v_normxm == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 223, __pyx_L1_error) } __pyx_v_add = (__pyx_t_1 / __pyx_v_normxm); /* "skbio/stats/distance/_cutils.pyx":229 * cdef TReal xval * * for p in prange(perms_n, nogil=True): # <<<<<<<<<<<<<< * my_ps = 0.0 * for row in range(out_n-1): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_2 = __pyx_v_perms_n; if ((1 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_4 = (__pyx_t_2 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_4 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_icol) lastprivate(__pyx_v_idx) lastprivate(__pyx_v_my_ps) firstprivate(__pyx_v_p) lastprivate(__pyx_v_p) lastprivate(__pyx_v_row) lastprivate(__pyx_v_vrow) lastprivate(__pyx_v_xval) lastprivate(__pyx_v_yval) #endif /* _OPENMP */ for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_4; __pyx_t_3++){ { __pyx_v_p = (Py_ssize_t)(0 + 1 * __pyx_t_3); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_icol = ((Py_ssize_t)0xbad0bad0); __pyx_v_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_my_ps = ((double)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_vrow = ((Py_ssize_t)0xbad0bad0); __pyx_v_xval = ((double)__PYX_NAN()); __pyx_v_yval = ((double)__PYX_NAN()); /* "skbio/stats/distance/_cutils.pyx":230 * * for p in prange(perms_n, nogil=True): * my_ps = 0.0 # <<<<<<<<<<<<<< * for row in range(out_n-1): * vrow = perm_order[p, row] */ __pyx_v_my_ps = 0.0; /* "skbio/stats/distance/_cutils.pyx":231 * for p in prange(perms_n, nogil=True): * my_ps = 0.0 * for row in range(out_n-1): # <<<<<<<<<<<<<< * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 */ __pyx_t_5 = (__pyx_v_out_n - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_row = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":232 * my_ps = 0.0 * for row in range(out_n-1): * vrow = perm_order[p, row] # <<<<<<<<<<<<<< * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): */ __pyx_t_8 = __pyx_v_p; __pyx_t_9 = __pyx_v_row; __pyx_v_vrow = (*((long *) ( /* dim=1 */ ((char *) (((long *) ( /* dim=0 */ (__pyx_v_perm_order.data + __pyx_t_8 * __pyx_v_perm_order.strides[0]) )) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":233 * for row in range(out_n-1): * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 # <<<<<<<<<<<<<< * for icol in range(out_n-row-1): * col = icol+row+1 */ __pyx_v_idx = ((__pyx_v_row * (__pyx_v_out_n - 1)) - __Pyx_div_Py_ssize_t(((__pyx_v_row - 1) * __pyx_v_row), 2)); /* "skbio/stats/distance/_cutils.pyx":234 * vrow = perm_order[p, row] * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): # <<<<<<<<<<<<<< * col = icol+row+1 * yval = ym_normalized[idx+icol] */ __pyx_t_10 = ((__pyx_v_out_n - __pyx_v_row) - 1); __pyx_t_11 = __pyx_t_10; for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { __pyx_v_icol = __pyx_t_12; /* "skbio/stats/distance/_cutils.pyx":235 * idx = row*(out_n-1) - ((row-1)*row)/2 * for icol in range(out_n-row-1): * col = icol+row+1 # <<<<<<<<<<<<<< * yval = ym_normalized[idx+icol] * xval = x_data[vrow, perm_order[p, col]]*mul + add */ __pyx_v_col = ((__pyx_v_icol + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":236 * for icol in range(out_n-row-1): * col = icol+row+1 * yval = ym_normalized[idx+icol] # <<<<<<<<<<<<<< * xval = x_data[vrow, perm_order[p, col]]*mul + add * # do not use += to avoid having prange consider it for reduction */ __pyx_t_9 = (__pyx_v_idx + __pyx_v_icol); __pyx_v_yval = (*((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_ym_normalized.data) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":237 * col = icol+row+1 * yval = ym_normalized[idx+icol] * xval = x_data[vrow, perm_order[p, col]]*mul + add # <<<<<<<<<<<<<< * # do not use += to avoid having prange consider it for reduction * my_ps = yval*xval + my_ps */ __pyx_t_9 = __pyx_v_p; __pyx_t_8 = __pyx_v_col; __pyx_t_13 = __pyx_v_vrow; __pyx_t_14 = (*((long *) ( /* dim=1 */ ((char *) (((long *) ( /* dim=0 */ (__pyx_v_perm_order.data + __pyx_t_9 * __pyx_v_perm_order.strides[0]) )) + __pyx_t_8)) ))); __pyx_v_xval = (((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_x_data.data + __pyx_t_13 * __pyx_v_x_data.strides[0]) )) + __pyx_t_14)) ))) * __pyx_v_mul) + __pyx_v_add); /* "skbio/stats/distance/_cutils.pyx":239 * xval = x_data[vrow, perm_order[p, col]]*mul + add * # do not use += to avoid having prange consider it for reduction * my_ps = yval*xval + my_ps # <<<<<<<<<<<<<< * * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of */ __pyx_v_my_ps = ((__pyx_v_yval * __pyx_v_xval) + __pyx_v_my_ps); } } /* "skbio/stats/distance/_cutils.pyx":243 * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of * # floating point arithmetic. * if my_ps>1.0: # <<<<<<<<<<<<<< * my_ps = 1.0 * elif my_ps<-1.0: */ __pyx_t_15 = ((__pyx_v_my_ps > 1.0) != 0); if (__pyx_t_15) { /* "skbio/stats/distance/_cutils.pyx":244 * # floating point arithmetic. * if my_ps>1.0: * my_ps = 1.0 # <<<<<<<<<<<<<< * elif my_ps<-1.0: * my_ps = -1.0 */ __pyx_v_my_ps = 1.0; /* "skbio/stats/distance/_cutils.pyx":243 * # Presumably, if abs(one_stat) > 1, then it is only some small artifact of * # floating point arithmetic. * if my_ps>1.0: # <<<<<<<<<<<<<< * my_ps = 1.0 * elif my_ps<-1.0: */ goto __pyx_L14; } /* "skbio/stats/distance/_cutils.pyx":245 * if my_ps>1.0: * my_ps = 1.0 * elif my_ps<-1.0: # <<<<<<<<<<<<<< * my_ps = -1.0 * permuted_stats[p] = my_ps */ __pyx_t_15 = ((__pyx_v_my_ps < -1.0) != 0); if (__pyx_t_15) { /* "skbio/stats/distance/_cutils.pyx":246 * my_ps = 1.0 * elif my_ps<-1.0: * my_ps = -1.0 # <<<<<<<<<<<<<< * permuted_stats[p] = my_ps * */ __pyx_v_my_ps = -1.0; /* "skbio/stats/distance/_cutils.pyx":245 * if my_ps>1.0: * my_ps = 1.0 * elif my_ps<-1.0: # <<<<<<<<<<<<<< * my_ps = -1.0 * permuted_stats[p] = my_ps */ } __pyx_L14:; /* "skbio/stats/distance/_cutils.pyx":247 * elif my_ps<-1.0: * my_ps = -1.0 * permuted_stats[p] = my_ps # <<<<<<<<<<<<<< * * */ __pyx_t_8 = __pyx_v_p; *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_permuted_stats.data) + __pyx_t_8)) )) = __pyx_v_my_ps; } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":229 * cdef TReal xval * * for p in prange(perms_n, nogil=True): # <<<<<<<<<<<<<< * my_ps = 0.0 * for row in range(out_n-1): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":170 * @cython.boundscheck(False) * @cython.wraparound(False) * def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, # <<<<<<<<<<<<<< * TReal xmean, TReal normxm, * TReal[::1] ym_normalized, */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.mantel_perm_pearsonr_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_x_data, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_perm_order, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_ym_normalized, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_permuted_stats, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/distance/_cutils.pyx":252 * @cython.boundscheck(False) * @cython.wraparound(False) * def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, # <<<<<<<<<<<<<< * Py_ssize_t[::1] group_sizes, * Py_ssize_t[::1] grouping): */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_9permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy[] = "Compute PERMANOVA pseudo-F partial statistic."; static PyMethodDef __pyx_mdef_5skbio_5stats_8distance_7_cutils_9permanova_f_stat_sW_cy = {"permanova_f_stat_sW_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_8distance_7_cutils_9permanova_f_stat_sW_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy}; static PyObject *__pyx_pw_5skbio_5stats_8distance_7_cutils_9permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 252, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 252, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 252, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 252, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 252, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("permanova_f_stat_sW_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_distance_matrix, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_distance_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 252, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 252, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 252, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 252, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 252, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 252, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 252, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 252, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 252, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.distance._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_35permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_35permanova_f_stat_sW_cy = {"__pyx_fuse_0permanova_f_stat_sW_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_35permanova_f_stat_sW_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_8distance_7_cutils_35permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_distance_matrix = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_group_sizes = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_grouping = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("permanova_f_stat_sW_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_distance_matrix,&__pyx_n_s_group_sizes,&__pyx_n_s_grouping,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_distance_matrix)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_group_sizes)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, 1); __PYX_ERR(0, 252, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_grouping)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, 2); __PYX_ERR(0, 252, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "permanova_f_stat_sW_cy") < 0)) __PYX_ERR(0, 252, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_distance_matrix = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_distance_matrix.memview)) __PYX_ERR(0, 252, __pyx_L3_error) __pyx_v_group_sizes = __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_group_sizes.memview)) __PYX_ERR(0, 253, __pyx_L3_error) __pyx_v_grouping = __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_grouping.memview)) __PYX_ERR(0, 254, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 252, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.permanova_f_stat_sW_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_34permanova_f_stat_sW_cy(__pyx_self, __pyx_v_distance_matrix, __pyx_v_group_sizes, __pyx_v_grouping); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_34permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_distance_matrix, __Pyx_memviewslice __pyx_v_group_sizes, __Pyx_memviewslice __pyx_v_grouping) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_in3; double __pyx_v_s_W; Py_ssize_t __pyx_v_group_idx; double __pyx_v_local_s_W; double __pyx_v_val; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_rowi; Py_ssize_t __pyx_v_coli; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0permanova_f_stat_sW_cy", 0); /* "skbio/stats/distance/_cutils.pyx":256 * Py_ssize_t[::1] grouping): * """Compute PERMANOVA pseudo-F partial statistic.""" * cdef Py_ssize_t in_n = distance_matrix.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = distance_matrix.shape[1] * cdef Py_ssize_t in3 = grouping.shape[0] */ __pyx_v_in_n = (__pyx_v_distance_matrix.shape[0]); /* "skbio/stats/distance/_cutils.pyx":257 * """Compute PERMANOVA pseudo-F partial statistic.""" * cdef Py_ssize_t in_n = distance_matrix.shape[0] * cdef Py_ssize_t in2 = distance_matrix.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t in3 = grouping.shape[0] * */ __pyx_v_in2 = (__pyx_v_distance_matrix.shape[1]); /* "skbio/stats/distance/_cutils.pyx":258 * cdef Py_ssize_t in_n = distance_matrix.shape[0] * cdef Py_ssize_t in2 = distance_matrix.shape[1] * cdef Py_ssize_t in3 = grouping.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_in3 = (__pyx_v_grouping.shape[0]); /* "skbio/stats/distance/_cutils.pyx":260 * cdef Py_ssize_t in3 = grouping.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert in_n == in3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 260, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":261 * * assert in_n == in2 * assert in_n == in3 # <<<<<<<<<<<<<< * * cdef double s_W = 0.0 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 261, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":263 * assert in_n == in3 * * cdef double s_W = 0.0 # <<<<<<<<<<<<<< * * cdef Py_ssize_t group_idx */ __pyx_v_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":271 * cdef Py_ssize_t row, col, rowi, coli * * for rowi in prange(in_n/2, nogil=True): # <<<<<<<<<<<<<< * # since columns get shorter, combine first and last * row=rowi */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_in_n, 2); if ((1 == 0)) abort(); { Py_ssize_t __pyx_parallel_temp0 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp1 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp2 = ((Py_ssize_t)0xbad0bad0); double __pyx_parallel_temp3 = ((double)__PYX_NAN()); Py_ssize_t __pyx_parallel_temp4 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp5 = ((Py_ssize_t)0xbad0bad0); double __pyx_parallel_temp6 = ((double)__PYX_NAN()); double __pyx_parallel_temp7 = ((double)__PYX_NAN()); const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; int __pyx_parallel_why; __pyx_parallel_why = 0; #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(+:__pyx_v_s_W) private(__pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) #endif /* _OPENMP */ { #ifdef _OPENMP #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif Py_BEGIN_ALLOW_THREADS #endif /* _OPENMP */ #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_coli) lastprivate(__pyx_v_group_idx) lastprivate(__pyx_v_local_s_W) lastprivate(__pyx_v_row) firstprivate(__pyx_v_rowi) lastprivate(__pyx_v_rowi) lastprivate(__pyx_v_val) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ if (__pyx_parallel_why < 2) { __pyx_v_rowi = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_coli = ((Py_ssize_t)0xbad0bad0); __pyx_v_group_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_local_s_W = ((double)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_val = ((double)__PYX_NAN()); /* "skbio/stats/distance/_cutils.pyx":273 * for rowi in prange(in_n/2, nogil=True): * # since columns get shorter, combine first and last * row=rowi # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ __pyx_v_row = __pyx_v_rowi; /* "skbio/stats/distance/_cutils.pyx":274 * # since columns get shorter, combine first and last * row=rowi * local_s_W = 0.0 # <<<<<<<<<<<<<< * group_idx = grouping[row] * for coli in range(in_n-row-1): */ __pyx_v_local_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":275 * row=rowi * local_s_W = 0.0 * group_idx = grouping[row] # <<<<<<<<<<<<<< * for coli in range(in_n-row-1): * col = coli+row+1 */ __pyx_t_4 = __pyx_v_row; __pyx_v_group_idx = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":276 * local_s_W = 0.0 * group_idx = grouping[row] * for coli in range(in_n-row-1): # <<<<<<<<<<<<<< * col = coli+row+1 * if grouping[col] == group_idx: */ __pyx_t_5 = ((__pyx_v_in_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_coli = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":277 * group_idx = grouping[row] * for coli in range(in_n-row-1): * col = coli+row+1 # <<<<<<<<<<<<<< * if grouping[col] == group_idx: * val = distance_matrix[row,col] */ __pyx_v_col = ((__pyx_v_coli + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":278 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ __pyx_t_4 = __pyx_v_col; __pyx_t_8 = (((*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_4)) ))) == __pyx_v_group_idx) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":279 * col = coli+row+1 * if grouping[col] == group_idx: * val = distance_matrix[row,col] # <<<<<<<<<<<<<< * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] */ __pyx_t_4 = __pyx_v_row; __pyx_t_9 = __pyx_v_col; __pyx_v_val = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_distance_matrix.data + __pyx_t_4 * __pyx_v_distance_matrix.strides[0]) )) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":280 * if grouping[col] == group_idx: * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val # <<<<<<<<<<<<<< * s_W += local_s_W/group_sizes[group_idx] * */ __pyx_v_local_s_W = (__pyx_v_local_s_W + (__pyx_v_val * __pyx_v_val)); /* "skbio/stats/distance/_cutils.pyx":278 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ } } /* "skbio/stats/distance/_cutils.pyx":281 * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] # <<<<<<<<<<<<<< * * row = in_n-rowi-2 */ __pyx_t_9 = __pyx_v_group_idx; __pyx_t_5 = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_group_sizes.data) + __pyx_t_9)) ))); if (unlikely(__pyx_t_5 == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 281, __pyx_L8_error) } __pyx_v_s_W = (__pyx_v_s_W + (__pyx_v_local_s_W / __pyx_t_5)); /* "skbio/stats/distance/_cutils.pyx":283 * s_W += local_s_W/group_sizes[group_idx] * * row = in_n-rowi-2 # <<<<<<<<<<<<<< * if row!=rowi: # don't double count * local_s_W = 0.0 */ __pyx_v_row = ((__pyx_v_in_n - __pyx_v_rowi) - 2); /* "skbio/stats/distance/_cutils.pyx":284 * * row = in_n-rowi-2 * if row!=rowi: # don't double count # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ __pyx_t_8 = ((__pyx_v_row != __pyx_v_rowi) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":285 * row = in_n-rowi-2 * if row!=rowi: # don't double count * local_s_W = 0.0 # <<<<<<<<<<<<<< * group_idx = grouping[row] * for coli in range(in_n-row-1): */ __pyx_v_local_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":286 * if row!=rowi: # don't double count * local_s_W = 0.0 * group_idx = grouping[row] # <<<<<<<<<<<<<< * for coli in range(in_n-row-1): * col = coli+row+1 */ __pyx_t_9 = __pyx_v_row; __pyx_v_group_idx = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":287 * local_s_W = 0.0 * group_idx = grouping[row] * for coli in range(in_n-row-1): # <<<<<<<<<<<<<< * col = coli+row+1 * if grouping[col] == group_idx: */ __pyx_t_5 = ((__pyx_v_in_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_coli = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":288 * group_idx = grouping[row] * for coli in range(in_n-row-1): * col = coli+row+1 # <<<<<<<<<<<<<< * if grouping[col] == group_idx: * val = distance_matrix[row,col] */ __pyx_v_col = ((__pyx_v_coli + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":289 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ __pyx_t_9 = __pyx_v_col; __pyx_t_8 = (((*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_9)) ))) == __pyx_v_group_idx) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":290 * col = coli+row+1 * if grouping[col] == group_idx: * val = distance_matrix[row,col] # <<<<<<<<<<<<<< * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] */ __pyx_t_9 = __pyx_v_row; __pyx_t_4 = __pyx_v_col; __pyx_v_val = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_distance_matrix.data + __pyx_t_9 * __pyx_v_distance_matrix.strides[0]) )) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":291 * if grouping[col] == group_idx: * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val # <<<<<<<<<<<<<< * s_W += local_s_W/group_sizes[group_idx] * */ __pyx_v_local_s_W = (__pyx_v_local_s_W + (__pyx_v_val * __pyx_v_val)); /* "skbio/stats/distance/_cutils.pyx":289 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ } } /* "skbio/stats/distance/_cutils.pyx":292 * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] # <<<<<<<<<<<<<< * * return s_W */ __pyx_t_4 = __pyx_v_group_idx; __pyx_t_5 = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_group_sizes.data) + __pyx_t_4)) ))); if (unlikely(__pyx_t_5 == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 292, __pyx_L8_error) } __pyx_v_s_W = (__pyx_v_s_W + (__pyx_v_local_s_W / __pyx_t_5)); /* "skbio/stats/distance/_cutils.pyx":284 * * row = in_n-rowi-2 * if row!=rowi: # don't double count # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ } goto __pyx_L18; __pyx_L8_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #ifdef _OPENMP #pragma omp flush(__pyx_parallel_exc_type) #endif /* _OPENMP */ if (!__pyx_parallel_exc_type) { __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; __Pyx_GOTREF(__pyx_parallel_exc_type); } #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_parallel_why = 4; goto __pyx_L17; __pyx_L17:; #ifdef _OPENMP #pragma omp critical(__pyx_parallel_lastprivates0) #endif /* _OPENMP */ { __pyx_parallel_temp0 = __pyx_v_col; __pyx_parallel_temp1 = __pyx_v_coli; __pyx_parallel_temp2 = __pyx_v_group_idx; __pyx_parallel_temp3 = __pyx_v_local_s_W; __pyx_parallel_temp4 = __pyx_v_row; __pyx_parallel_temp5 = __pyx_v_rowi; __pyx_parallel_temp6 = __pyx_v_s_W; __pyx_parallel_temp7 = __pyx_v_val; } __pyx_L18:; #ifdef _OPENMP #pragma omp flush(__pyx_parallel_why) #endif /* _OPENMP */ } } #ifdef _OPENMP Py_END_ALLOW_THREADS #else { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #endif /* _OPENMP */ /* Clean up any temporaries */ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif #ifndef _OPENMP } #endif /* _OPENMP */ } } if (__pyx_parallel_exc_type) { /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ __pyx_parallel_why = 4; } if (__pyx_parallel_why) { __pyx_v_col = __pyx_parallel_temp0; __pyx_v_coli = __pyx_parallel_temp1; __pyx_v_group_idx = __pyx_parallel_temp2; __pyx_v_local_s_W = __pyx_parallel_temp3; __pyx_v_row = __pyx_parallel_temp4; __pyx_v_rowi = __pyx_parallel_temp5; __pyx_v_s_W = __pyx_parallel_temp6; __pyx_v_val = __pyx_parallel_temp7; switch (__pyx_parallel_why) { case 4: { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_GIVEREF(__pyx_parallel_exc_type); __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } goto __pyx_L4_error; } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":271 * cdef Py_ssize_t row, col, rowi, coli * * for rowi in prange(in_n/2, nogil=True): # <<<<<<<<<<<<<< * # since columns get shorter, combine first and last * row=rowi */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L4_error: { #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L1_error; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":294 * s_W += local_s_W/group_sizes[group_idx] * * return s_W # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_10 = PyFloat_FromDouble(__pyx_v_s_W); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; /* "skbio/stats/distance/_cutils.pyx":252 * @cython.boundscheck(False) * @cython.wraparound(False) * def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, # <<<<<<<<<<<<<< * Py_ssize_t[::1] group_sizes, * Py_ssize_t[::1] grouping): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.stats.distance._cutils.permanova_f_stat_sW_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_distance_matrix, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_group_sizes, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_grouping, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_37permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_37permanova_f_stat_sW_cy = {"__pyx_fuse_1permanova_f_stat_sW_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_37permanova_f_stat_sW_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_8distance_7_cutils_8permanova_f_stat_sW_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_8distance_7_cutils_37permanova_f_stat_sW_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_distance_matrix = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_group_sizes = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_grouping = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("permanova_f_stat_sW_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_distance_matrix,&__pyx_n_s_group_sizes,&__pyx_n_s_grouping,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_distance_matrix)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_group_sizes)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, 1); __PYX_ERR(0, 252, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_grouping)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, 2); __PYX_ERR(0, 252, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "permanova_f_stat_sW_cy") < 0)) __PYX_ERR(0, 252, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_distance_matrix = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_distance_matrix.memview)) __PYX_ERR(0, 252, __pyx_L3_error) __pyx_v_group_sizes = __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_group_sizes.memview)) __PYX_ERR(0, 253, __pyx_L3_error) __pyx_v_grouping = __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_grouping.memview)) __PYX_ERR(0, 254, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("permanova_f_stat_sW_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 252, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.distance._cutils.permanova_f_stat_sW_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_8distance_7_cutils_36permanova_f_stat_sW_cy(__pyx_self, __pyx_v_distance_matrix, __pyx_v_group_sizes, __pyx_v_grouping); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_8distance_7_cutils_36permanova_f_stat_sW_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_distance_matrix, __Pyx_memviewslice __pyx_v_group_sizes, __Pyx_memviewslice __pyx_v_grouping) { Py_ssize_t __pyx_v_in_n; Py_ssize_t __pyx_v_in2; Py_ssize_t __pyx_v_in3; double __pyx_v_s_W; Py_ssize_t __pyx_v_group_idx; double __pyx_v_local_s_W; double __pyx_v_val; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_rowi; Py_ssize_t __pyx_v_coli; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1permanova_f_stat_sW_cy", 0); /* "skbio/stats/distance/_cutils.pyx":256 * Py_ssize_t[::1] grouping): * """Compute PERMANOVA pseudo-F partial statistic.""" * cdef Py_ssize_t in_n = distance_matrix.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t in2 = distance_matrix.shape[1] * cdef Py_ssize_t in3 = grouping.shape[0] */ __pyx_v_in_n = (__pyx_v_distance_matrix.shape[0]); /* "skbio/stats/distance/_cutils.pyx":257 * """Compute PERMANOVA pseudo-F partial statistic.""" * cdef Py_ssize_t in_n = distance_matrix.shape[0] * cdef Py_ssize_t in2 = distance_matrix.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t in3 = grouping.shape[0] * */ __pyx_v_in2 = (__pyx_v_distance_matrix.shape[1]); /* "skbio/stats/distance/_cutils.pyx":258 * cdef Py_ssize_t in_n = distance_matrix.shape[0] * cdef Py_ssize_t in2 = distance_matrix.shape[1] * cdef Py_ssize_t in3 = grouping.shape[0] # <<<<<<<<<<<<<< * * assert in_n == in2 */ __pyx_v_in3 = (__pyx_v_grouping.shape[0]); /* "skbio/stats/distance/_cutils.pyx":260 * cdef Py_ssize_t in3 = grouping.shape[0] * * assert in_n == in2 # <<<<<<<<<<<<<< * assert in_n == in3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 260, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":261 * * assert in_n == in2 * assert in_n == in3 # <<<<<<<<<<<<<< * * cdef double s_W = 0.0 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_in_n == __pyx_v_in3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 261, __pyx_L1_error) } } #endif /* "skbio/stats/distance/_cutils.pyx":263 * assert in_n == in3 * * cdef double s_W = 0.0 # <<<<<<<<<<<<<< * * cdef Py_ssize_t group_idx */ __pyx_v_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":271 * cdef Py_ssize_t row, col, rowi, coli * * for rowi in prange(in_n/2, nogil=True): # <<<<<<<<<<<<<< * # since columns get shorter, combine first and last * row=rowi */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_in_n, 2); if ((1 == 0)) abort(); { Py_ssize_t __pyx_parallel_temp0 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp1 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp2 = ((Py_ssize_t)0xbad0bad0); double __pyx_parallel_temp3 = ((double)__PYX_NAN()); Py_ssize_t __pyx_parallel_temp4 = ((Py_ssize_t)0xbad0bad0); Py_ssize_t __pyx_parallel_temp5 = ((Py_ssize_t)0xbad0bad0); double __pyx_parallel_temp6 = ((double)__PYX_NAN()); double __pyx_parallel_temp7 = ((double)__PYX_NAN()); const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; int __pyx_parallel_why; __pyx_parallel_why = 0; #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(+:__pyx_v_s_W) private(__pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) #endif /* _OPENMP */ { #ifdef _OPENMP #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif Py_BEGIN_ALLOW_THREADS #endif /* _OPENMP */ #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_coli) lastprivate(__pyx_v_group_idx) lastprivate(__pyx_v_local_s_W) lastprivate(__pyx_v_row) firstprivate(__pyx_v_rowi) lastprivate(__pyx_v_rowi) lastprivate(__pyx_v_val) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ if (__pyx_parallel_why < 2) { __pyx_v_rowi = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_coli = ((Py_ssize_t)0xbad0bad0); __pyx_v_group_idx = ((Py_ssize_t)0xbad0bad0); __pyx_v_local_s_W = ((double)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_val = ((double)__PYX_NAN()); /* "skbio/stats/distance/_cutils.pyx":273 * for rowi in prange(in_n/2, nogil=True): * # since columns get shorter, combine first and last * row=rowi # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ __pyx_v_row = __pyx_v_rowi; /* "skbio/stats/distance/_cutils.pyx":274 * # since columns get shorter, combine first and last * row=rowi * local_s_W = 0.0 # <<<<<<<<<<<<<< * group_idx = grouping[row] * for coli in range(in_n-row-1): */ __pyx_v_local_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":275 * row=rowi * local_s_W = 0.0 * group_idx = grouping[row] # <<<<<<<<<<<<<< * for coli in range(in_n-row-1): * col = coli+row+1 */ __pyx_t_4 = __pyx_v_row; __pyx_v_group_idx = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":276 * local_s_W = 0.0 * group_idx = grouping[row] * for coli in range(in_n-row-1): # <<<<<<<<<<<<<< * col = coli+row+1 * if grouping[col] == group_idx: */ __pyx_t_5 = ((__pyx_v_in_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_coli = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":277 * group_idx = grouping[row] * for coli in range(in_n-row-1): * col = coli+row+1 # <<<<<<<<<<<<<< * if grouping[col] == group_idx: * val = distance_matrix[row,col] */ __pyx_v_col = ((__pyx_v_coli + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":278 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ __pyx_t_4 = __pyx_v_col; __pyx_t_8 = (((*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_4)) ))) == __pyx_v_group_idx) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":279 * col = coli+row+1 * if grouping[col] == group_idx: * val = distance_matrix[row,col] # <<<<<<<<<<<<<< * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] */ __pyx_t_4 = __pyx_v_row; __pyx_t_9 = __pyx_v_col; __pyx_v_val = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_distance_matrix.data + __pyx_t_4 * __pyx_v_distance_matrix.strides[0]) )) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":280 * if grouping[col] == group_idx: * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val # <<<<<<<<<<<<<< * s_W += local_s_W/group_sizes[group_idx] * */ __pyx_v_local_s_W = (__pyx_v_local_s_W + (__pyx_v_val * __pyx_v_val)); /* "skbio/stats/distance/_cutils.pyx":278 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ } } /* "skbio/stats/distance/_cutils.pyx":281 * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] # <<<<<<<<<<<<<< * * row = in_n-rowi-2 */ __pyx_t_9 = __pyx_v_group_idx; __pyx_t_5 = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_group_sizes.data) + __pyx_t_9)) ))); if (unlikely(__pyx_t_5 == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 281, __pyx_L8_error) } __pyx_v_s_W = (__pyx_v_s_W + (__pyx_v_local_s_W / __pyx_t_5)); /* "skbio/stats/distance/_cutils.pyx":283 * s_W += local_s_W/group_sizes[group_idx] * * row = in_n-rowi-2 # <<<<<<<<<<<<<< * if row!=rowi: # don't double count * local_s_W = 0.0 */ __pyx_v_row = ((__pyx_v_in_n - __pyx_v_rowi) - 2); /* "skbio/stats/distance/_cutils.pyx":284 * * row = in_n-rowi-2 * if row!=rowi: # don't double count # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ __pyx_t_8 = ((__pyx_v_row != __pyx_v_rowi) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":285 * row = in_n-rowi-2 * if row!=rowi: # don't double count * local_s_W = 0.0 # <<<<<<<<<<<<<< * group_idx = grouping[row] * for coli in range(in_n-row-1): */ __pyx_v_local_s_W = 0.0; /* "skbio/stats/distance/_cutils.pyx":286 * if row!=rowi: # don't double count * local_s_W = 0.0 * group_idx = grouping[row] # <<<<<<<<<<<<<< * for coli in range(in_n-row-1): * col = coli+row+1 */ __pyx_t_9 = __pyx_v_row; __pyx_v_group_idx = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_9)) ))); /* "skbio/stats/distance/_cutils.pyx":287 * local_s_W = 0.0 * group_idx = grouping[row] * for coli in range(in_n-row-1): # <<<<<<<<<<<<<< * col = coli+row+1 * if grouping[col] == group_idx: */ __pyx_t_5 = ((__pyx_v_in_n - __pyx_v_row) - 1); __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_coli = __pyx_t_7; /* "skbio/stats/distance/_cutils.pyx":288 * group_idx = grouping[row] * for coli in range(in_n-row-1): * col = coli+row+1 # <<<<<<<<<<<<<< * if grouping[col] == group_idx: * val = distance_matrix[row,col] */ __pyx_v_col = ((__pyx_v_coli + __pyx_v_row) + 1); /* "skbio/stats/distance/_cutils.pyx":289 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ __pyx_t_9 = __pyx_v_col; __pyx_t_8 = (((*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_grouping.data) + __pyx_t_9)) ))) == __pyx_v_group_idx) != 0); if (__pyx_t_8) { /* "skbio/stats/distance/_cutils.pyx":290 * col = coli+row+1 * if grouping[col] == group_idx: * val = distance_matrix[row,col] # <<<<<<<<<<<<<< * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] */ __pyx_t_9 = __pyx_v_row; __pyx_t_4 = __pyx_v_col; __pyx_v_val = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_distance_matrix.data + __pyx_t_9 * __pyx_v_distance_matrix.strides[0]) )) + __pyx_t_4)) ))); /* "skbio/stats/distance/_cutils.pyx":291 * if grouping[col] == group_idx: * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val # <<<<<<<<<<<<<< * s_W += local_s_W/group_sizes[group_idx] * */ __pyx_v_local_s_W = (__pyx_v_local_s_W + (__pyx_v_val * __pyx_v_val)); /* "skbio/stats/distance/_cutils.pyx":289 * for coli in range(in_n-row-1): * col = coli+row+1 * if grouping[col] == group_idx: # <<<<<<<<<<<<<< * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val */ } } /* "skbio/stats/distance/_cutils.pyx":292 * val = distance_matrix[row,col] * local_s_W = local_s_W + val * val * s_W += local_s_W/group_sizes[group_idx] # <<<<<<<<<<<<<< * * return s_W */ __pyx_t_4 = __pyx_v_group_idx; __pyx_t_5 = (*((Py_ssize_t *) ( /* dim=0 */ ((char *) (((Py_ssize_t *) __pyx_v_group_sizes.data) + __pyx_t_4)) ))); if (unlikely(__pyx_t_5 == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 292, __pyx_L8_error) } __pyx_v_s_W = (__pyx_v_s_W + (__pyx_v_local_s_W / __pyx_t_5)); /* "skbio/stats/distance/_cutils.pyx":284 * * row = in_n-rowi-2 * if row!=rowi: # don't double count # <<<<<<<<<<<<<< * local_s_W = 0.0 * group_idx = grouping[row] */ } goto __pyx_L18; __pyx_L8_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #ifdef _OPENMP #pragma omp flush(__pyx_parallel_exc_type) #endif /* _OPENMP */ if (!__pyx_parallel_exc_type) { __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; __Pyx_GOTREF(__pyx_parallel_exc_type); } #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_parallel_why = 4; goto __pyx_L17; __pyx_L17:; #ifdef _OPENMP #pragma omp critical(__pyx_parallel_lastprivates1) #endif /* _OPENMP */ { __pyx_parallel_temp0 = __pyx_v_col; __pyx_parallel_temp1 = __pyx_v_coli; __pyx_parallel_temp2 = __pyx_v_group_idx; __pyx_parallel_temp3 = __pyx_v_local_s_W; __pyx_parallel_temp4 = __pyx_v_row; __pyx_parallel_temp5 = __pyx_v_rowi; __pyx_parallel_temp6 = __pyx_v_s_W; __pyx_parallel_temp7 = __pyx_v_val; } __pyx_L18:; #ifdef _OPENMP #pragma omp flush(__pyx_parallel_why) #endif /* _OPENMP */ } } #ifdef _OPENMP Py_END_ALLOW_THREADS #else { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #endif /* _OPENMP */ /* Clean up any temporaries */ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif #ifndef _OPENMP } #endif /* _OPENMP */ } } if (__pyx_parallel_exc_type) { /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ __pyx_parallel_why = 4; } if (__pyx_parallel_why) { __pyx_v_col = __pyx_parallel_temp0; __pyx_v_coli = __pyx_parallel_temp1; __pyx_v_group_idx = __pyx_parallel_temp2; __pyx_v_local_s_W = __pyx_parallel_temp3; __pyx_v_row = __pyx_parallel_temp4; __pyx_v_rowi = __pyx_parallel_temp5; __pyx_v_s_W = __pyx_parallel_temp6; __pyx_v_val = __pyx_parallel_temp7; switch (__pyx_parallel_why) { case 4: { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_GIVEREF(__pyx_parallel_exc_type); __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } goto __pyx_L4_error; } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/distance/_cutils.pyx":271 * cdef Py_ssize_t row, col, rowi, coli * * for rowi in prange(in_n/2, nogil=True): # <<<<<<<<<<<<<< * # since columns get shorter, combine first and last * row=rowi */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L4_error: { #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L1_error; } __pyx_L5:; } } /* "skbio/stats/distance/_cutils.pyx":294 * s_W += local_s_W/group_sizes[group_idx] * * return s_W # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_10 = PyFloat_FromDouble(__pyx_v_s_W); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; /* "skbio/stats/distance/_cutils.pyx":252 * @cython.boundscheck(False) * @cython.wraparound(False) * def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, # <<<<<<<<<<<<<< * Py_ssize_t[::1] group_sizes, * Py_ssize_t[::1] grouping): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.stats.distance._cutils.permanova_f_stat_sW_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_distance_matrix, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_group_sizes, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_grouping, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* Python wrapper */ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_shape = 0; Py_ssize_t __pyx_v_itemsize; PyObject *__pyx_v_format = 0; PyObject *__pyx_v_mode = 0; int __pyx_v_allocate_buffer; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; PyObject* values[5] = {0,0,0,0,0}; values[3] = ((PyObject *)__pyx_n_s_c); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); if (value) { values[4] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_shape = ((PyObject*)values[0]); __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) __pyx_v_format = values[2]; __pyx_v_mode = values[3]; if (values[4]) { __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) } else { /* "View.MemoryView":124 * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< * * cdef int idx */ __pyx_v_allocate_buffer = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) } __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { int __pyx_v_idx; Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_dim; PyObject **__pyx_v_p; char __pyx_v_order; int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; char *__pyx_t_7; int __pyx_t_8; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_format); /* "View.MemoryView":130 * cdef PyObject **p * * self.ndim = len(shape) # <<<<<<<<<<<<<< * self.itemsize = itemsize * */ if (unlikely(__pyx_v_shape == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 130, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) __pyx_v_self->ndim = ((int)__pyx_t_1); /* "View.MemoryView":131 * * self.ndim = len(shape) * self.itemsize = itemsize # <<<<<<<<<<<<<< * * if not self.ndim: */ __pyx_v_self->itemsize = __pyx_v_itemsize; /* "View.MemoryView":133 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError("Empty shape tuple for cython.array") * */ __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":134 * * if not self.ndim: * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< * * if itemsize <= 0: */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 134, __pyx_L1_error) /* "View.MemoryView":133 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError("Empty shape tuple for cython.array") * */ } /* "View.MemoryView":136 * raise ValueError("Empty shape tuple for cython.array") * * if itemsize <= 0: # <<<<<<<<<<<<<< * raise ValueError("itemsize <= 0 for cython.array") * */ __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":137 * * if itemsize <= 0: * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< * * if not isinstance(format, bytes): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 137, __pyx_L1_error) /* "View.MemoryView":136 * raise ValueError("Empty shape tuple for cython.array") * * if itemsize <= 0: # <<<<<<<<<<<<<< * raise ValueError("itemsize <= 0 for cython.array") * */ } /* "View.MemoryView":139 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string */ __pyx_t_2 = PyBytes_Check(__pyx_v_format); __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_4) { /* "View.MemoryView":140 * * if not isinstance(format, bytes): * format = format.encode('ASCII') # <<<<<<<<<<<<<< * self._format = format # keep a reference to the byte string * self.format = self._format */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":139 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string */ } /* "View.MemoryView":141 * if not isinstance(format, bytes): * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< * self.format = self._format * */ if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) __pyx_t_3 = __pyx_v_format; __Pyx_INCREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_format); __Pyx_DECREF(__pyx_v_self->_format); __pyx_v_self->_format = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":142 * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string * self.format = self._format # <<<<<<<<<<<<<< * * */ if (unlikely(__pyx_v_self->_format == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(1, 142, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) __pyx_v_self->format = __pyx_t_7; /* "View.MemoryView":145 * * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< * self._strides = self._shape + self.ndim * */ __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); /* "View.MemoryView":146 * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< * * if not self._shape: */ __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); /* "View.MemoryView":148 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate shape and strides.") * */ __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":149 * * if not self._shape: * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 149, __pyx_L1_error) /* "View.MemoryView":148 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate shape and strides.") * */ } /* "View.MemoryView":152 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ __pyx_t_8 = 0; __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; for (;;) { if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dim = __pyx_t_9; __pyx_v_idx = __pyx_t_8; __pyx_t_8 = (__pyx_t_8 + 1); /* "View.MemoryView":153 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim */ __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":154 * for idx, dim in enumerate(shape): * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< * self._shape[idx] = dim * */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 154, __pyx_L1_error) /* "View.MemoryView":153 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim */ } /* "View.MemoryView":155 * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim # <<<<<<<<<<<<<< * * cdef char order */ (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; /* "View.MemoryView":152 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":158 * * cdef char order * if mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) if (__pyx_t_4) { /* "View.MemoryView":159 * cdef char order * if mode == 'fortran': * order = b'F' # <<<<<<<<<<<<<< * self.mode = u'fortran' * elif mode == 'c': */ __pyx_v_order = 'F'; /* "View.MemoryView":160 * if mode == 'fortran': * order = b'F' * self.mode = u'fortran' # <<<<<<<<<<<<<< * elif mode == 'c': * order = b'C' */ __Pyx_INCREF(__pyx_n_u_fortran); __Pyx_GIVEREF(__pyx_n_u_fortran); __Pyx_GOTREF(__pyx_v_self->mode); __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_fortran; /* "View.MemoryView":158 * * cdef char order * if mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ goto __pyx_L10; } /* "View.MemoryView":161 * order = b'F' * self.mode = u'fortran' * elif mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) if (likely(__pyx_t_4)) { /* "View.MemoryView":162 * self.mode = u'fortran' * elif mode == 'c': * order = b'C' # <<<<<<<<<<<<<< * self.mode = u'c' * else: */ __pyx_v_order = 'C'; /* "View.MemoryView":163 * elif mode == 'c': * order = b'C' * self.mode = u'c' # <<<<<<<<<<<<<< * else: * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) */ __Pyx_INCREF(__pyx_n_u_c); __Pyx_GIVEREF(__pyx_n_u_c); __Pyx_GOTREF(__pyx_v_self->mode); __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_c; /* "View.MemoryView":161 * order = b'F' * self.mode = u'fortran' * elif mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ goto __pyx_L10; } /* "View.MemoryView":165 * self.mode = u'c' * else: * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< * * self.len = fill_contig_strides_array(self._shape, self._strides, */ /*else*/ { __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 165, __pyx_L1_error) } __pyx_L10:; /* "View.MemoryView":167 * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) * * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< * itemsize, self.ndim, order) * */ __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); /* "View.MemoryView":170 * itemsize, self.ndim, order) * * self.free_data = allocate_buffer # <<<<<<<<<<<<<< * self.dtype_is_object = format == b'O' * if allocate_buffer: */ __pyx_v_self->free_data = __pyx_v_allocate_buffer; /* "View.MemoryView":171 * * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< * if allocate_buffer: * */ __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_self->dtype_is_object = __pyx_t_4; /* "View.MemoryView":172 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< * * */ __pyx_t_4 = (__pyx_v_allocate_buffer != 0); if (__pyx_t_4) { /* "View.MemoryView":175 * * * self.data = malloc(self.len) # <<<<<<<<<<<<<< * if not self.data: * raise MemoryError("unable to allocate array data.") */ __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); /* "View.MemoryView":176 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate array data.") * */ __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":177 * self.data = malloc(self.len) * if not self.data: * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< * * if self.dtype_is_object: */ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 177, __pyx_L1_error) /* "View.MemoryView":176 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate array data.") * */ } /* "View.MemoryView":179 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len / itemsize): */ __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_4) { /* "View.MemoryView":180 * * if self.dtype_is_object: * p = self.data # <<<<<<<<<<<<<< * for i in range(self.len / itemsize): * p[i] = Py_None */ __pyx_v_p = ((PyObject **)__pyx_v_self->data); /* "View.MemoryView":181 * if self.dtype_is_object: * p = self.data * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< * p[i] = Py_None * Py_INCREF(Py_None) */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 181, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 181, __pyx_L1_error) } __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); __pyx_t_9 = __pyx_t_1; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; /* "View.MemoryView":182 * p = self.data * for i in range(self.len / itemsize): * p[i] = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ (__pyx_v_p[__pyx_v_i]) = Py_None; /* "View.MemoryView":183 * for i in range(self.len / itemsize): * p[i] = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * @cname('getbuffer') */ Py_INCREF(Py_None); } /* "View.MemoryView":179 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len / itemsize): */ } /* "View.MemoryView":172 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_format); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":186 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * cdef int bufmode = -1 * if self.mode == u"c": */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_bufmode; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_t_6; Py_ssize_t *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "View.MemoryView":187 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 # <<<<<<<<<<<<<< * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ __pyx_v_bufmode = -1; /* "View.MemoryView":188 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if self.mode == u"c": # <<<<<<<<<<<<<< * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": */ __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":189 * cdef int bufmode = -1 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); /* "View.MemoryView":188 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if self.mode == u"c": # <<<<<<<<<<<<<< * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": */ goto __pyx_L3; } /* "View.MemoryView":190 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": # <<<<<<<<<<<<<< * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":191 * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") */ __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); /* "View.MemoryView":190 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": # <<<<<<<<<<<<<< * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): */ } __pyx_L3:; /* "View.MemoryView":192 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data */ __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":193 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< * info.buf = self.data * info.len = self.len */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 193, __pyx_L1_error) /* "View.MemoryView":192 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data */ } /* "View.MemoryView":194 * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data # <<<<<<<<<<<<<< * info.len = self.len * info.ndim = self.ndim */ __pyx_t_4 = __pyx_v_self->data; __pyx_v_info->buf = __pyx_t_4; /* "View.MemoryView":195 * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data * info.len = self.len # <<<<<<<<<<<<<< * info.ndim = self.ndim * info.shape = self._shape */ __pyx_t_5 = __pyx_v_self->len; __pyx_v_info->len = __pyx_t_5; /* "View.MemoryView":196 * info.buf = self.data * info.len = self.len * info.ndim = self.ndim # <<<<<<<<<<<<<< * info.shape = self._shape * info.strides = self._strides */ __pyx_t_6 = __pyx_v_self->ndim; __pyx_v_info->ndim = __pyx_t_6; /* "View.MemoryView":197 * info.len = self.len * info.ndim = self.ndim * info.shape = self._shape # <<<<<<<<<<<<<< * info.strides = self._strides * info.suboffsets = NULL */ __pyx_t_7 = __pyx_v_self->_shape; __pyx_v_info->shape = __pyx_t_7; /* "View.MemoryView":198 * info.ndim = self.ndim * info.shape = self._shape * info.strides = self._strides # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = self.itemsize */ __pyx_t_7 = __pyx_v_self->_strides; __pyx_v_info->strides = __pyx_t_7; /* "View.MemoryView":199 * info.shape = self._shape * info.strides = self._strides * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = self.itemsize * info.readonly = 0 */ __pyx_v_info->suboffsets = NULL; /* "View.MemoryView":200 * info.strides = self._strides * info.suboffsets = NULL * info.itemsize = self.itemsize # <<<<<<<<<<<<<< * info.readonly = 0 * */ __pyx_t_5 = __pyx_v_self->itemsize; __pyx_v_info->itemsize = __pyx_t_5; /* "View.MemoryView":201 * info.suboffsets = NULL * info.itemsize = self.itemsize * info.readonly = 0 # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ __pyx_v_info->readonly = 0; /* "View.MemoryView":203 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.format * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":204 * * if flags & PyBUF_FORMAT: * info.format = self.format # <<<<<<<<<<<<<< * else: * info.format = NULL */ __pyx_t_4 = __pyx_v_self->format; __pyx_v_info->format = __pyx_t_4; /* "View.MemoryView":203 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.format * else: */ goto __pyx_L5; } /* "View.MemoryView":206 * info.format = self.format * else: * info.format = NULL # <<<<<<<<<<<<<< * * info.obj = self */ /*else*/ { __pyx_v_info->format = NULL; } __pyx_L5:; /* "View.MemoryView":208 * info.format = NULL * * info.obj = self # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "View.MemoryView":186 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * cdef int bufmode = -1 * if self.mode == u"c": */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":212 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< * if self.callback_free_data != NULL: * self.callback_free_data(self.data) */ /* Python wrapper */ static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":213 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data: */ __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":214 * def __dealloc__(array self): * if self.callback_free_data != NULL: * self.callback_free_data(self.data) # <<<<<<<<<<<<<< * elif self.free_data: * if self.dtype_is_object: */ __pyx_v_self->callback_free_data(__pyx_v_self->data); /* "View.MemoryView":213 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data: */ goto __pyx_L3; } /* "View.MemoryView":215 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, */ __pyx_t_1 = (__pyx_v_self->free_data != 0); if (__pyx_t_1) { /* "View.MemoryView":216 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) */ __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_1) { /* "View.MemoryView":217 * elif self.free_data: * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< * self._strides, self.ndim, False) * free(self.data) */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); /* "View.MemoryView":216 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) */ } /* "View.MemoryView":219 * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) * free(self.data) # <<<<<<<<<<<<<< * PyObject_Free(self._shape) * */ free(__pyx_v_self->data); /* "View.MemoryView":215 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, */ } __pyx_L3:; /* "View.MemoryView":220 * self._strides, self.ndim, False) * free(self.data) * PyObject_Free(self._shape) # <<<<<<<<<<<<<< * * @property */ PyObject_Free(__pyx_v_self->_shape); /* "View.MemoryView":212 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< * if self.callback_free_data != NULL: * self.callback_free_data(self.data) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":223 * * @property * def memview(self): # <<<<<<<<<<<<<< * return self.get_memview() * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":224 * @property * def memview(self): * return self.get_memview() # <<<<<<<<<<<<<< * * @cname('get_memview') */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":223 * * @property * def memview(self): # <<<<<<<<<<<<<< * return self.get_memview() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":227 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) */ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_memview", 0); /* "View.MemoryView":228 * @cname('get_memview') * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< * return memoryview(self, flags, self.dtype_is_object) * */ __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); /* "View.MemoryView":229 * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< * * def __len__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":227 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":231 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< * return self._shape[0] * */ /* Python wrapper */ static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__", 0); /* "View.MemoryView":232 * * def __len__(self): * return self._shape[0] # <<<<<<<<<<<<<< * * def __getattr__(self, attr): */ __pyx_r = (__pyx_v_self->_shape[0]); goto __pyx_L0; /* "View.MemoryView":231 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< * return self._shape[0] * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":234 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< * return getattr(self.memview, attr) * */ /* Python wrapper */ static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); /* "View.MemoryView":235 * * def __getattr__(self, attr): * return getattr(self.memview, attr) # <<<<<<<<<<<<<< * * def __getitem__(self, item): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":234 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< * return getattr(self.memview, attr) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":237 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return self.memview[item] * */ /* Python wrapper */ static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "View.MemoryView":238 * * def __getitem__(self, item): * return self.memview[item] # <<<<<<<<<<<<<< * * def __setitem__(self, item, value): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":237 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return self.memview[item] * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":240 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< * self.memview[item] = value * */ /* Python wrapper */ static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "View.MemoryView":241 * * def __setitem__(self, item, value): * self.memview[item] = value # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":240 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< * self.memview[item] = value * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":245 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< * char *mode, char *buf): * cdef array result */ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { struct __pyx_array_obj *__pyx_v_result = 0; struct __pyx_array_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("array_cwrapper", 0); /* "View.MemoryView":249 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: */ __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":250 * * if buf == NULL: * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), */ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":249 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: */ goto __pyx_L3; } /* "View.MemoryView":252 * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< * allocate_buffer=False) * result.data = buf */ /*else*/ { __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_3 = 0; /* "View.MemoryView":253 * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), * allocate_buffer=False) # <<<<<<<<<<<<<< * result.data = buf * */ __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) /* "View.MemoryView":252 * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< * allocate_buffer=False) * result.data = buf */ __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); __pyx_t_5 = 0; /* "View.MemoryView":254 * result = array(shape, itemsize, format, mode.decode('ASCII'), * allocate_buffer=False) * result.data = buf # <<<<<<<<<<<<<< * * return result */ __pyx_v_result->data = __pyx_v_buf; } __pyx_L3:; /* "View.MemoryView":256 * result.data = buf * * return result # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = __pyx_v_result; goto __pyx_L0; /* "View.MemoryView":245 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< * char *mode, char *buf): * cdef array result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":282 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< * self.name = name * def __repr__(self): */ /* Python wrapper */ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; PyObject* values[1] = {0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); /* "View.MemoryView":283 * cdef object name * def __init__(self, name): * self.name = name # <<<<<<<<<<<<<< * def __repr__(self): * return self.name */ __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_GOTREF(__pyx_v_self->name); __Pyx_DECREF(__pyx_v_self->name); __pyx_v_self->name = __pyx_v_name; /* "View.MemoryView":282 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< * self.name = name * def __repr__(self): */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":284 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< * return self.name * */ /* Python wrapper */ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__", 0); /* "View.MemoryView":285 * self.name = name * def __repr__(self): * return self.name # <<<<<<<<<<<<<< * * cdef generic = Enum("") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->name); __pyx_r = __pyx_v_self->name; goto __pyx_L0; /* "View.MemoryView":284 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< * return self.name * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.name,) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->name); __Pyx_GIVEREF(__pyx_v_self->name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.name,) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__dict = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":7 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_2 = (__pyx_v__dict != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.name is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.name is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state */ /*else*/ { __pyx_t_3 = (__pyx_v_self->name != Py_None); __pyx_v_use_setstate = __pyx_t_3; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: */ __pyx_t_3 = (__pyx_v_use_setstate != 0); if (__pyx_t_3) { /* "(tree fragment)":13 * use_setstate = self.name is not None * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_184977713); __Pyx_GIVEREF(__pyx_int_184977713); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_184977713); __Pyx_GIVEREF(__pyx_int_184977713); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __pyx_t_5 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":299 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory */ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { Py_intptr_t __pyx_v_aligned_p; size_t __pyx_v_offset; void *__pyx_r; int __pyx_t_1; /* "View.MemoryView":301 * cdef void *align_pointer(void *memory, size_t alignment) nogil: * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< * cdef size_t offset * */ __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); /* "View.MemoryView":305 * * with cython.cdivision(True): * offset = aligned_p % alignment # <<<<<<<<<<<<<< * * if offset > 0: */ __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); /* "View.MemoryView":307 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< * aligned_p += alignment - offset * */ __pyx_t_1 = ((__pyx_v_offset > 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":308 * * if offset > 0: * aligned_p += alignment - offset # <<<<<<<<<<<<<< * * return aligned_p */ __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); /* "View.MemoryView":307 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< * aligned_p += alignment - offset * */ } /* "View.MemoryView":310 * aligned_p += alignment - offset * * return aligned_p # <<<<<<<<<<<<<< * * */ __pyx_r = ((void *)__pyx_v_aligned_p); goto __pyx_L0; /* "View.MemoryView":299 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":346 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< * self.obj = obj * self.flags = flags */ /* Python wrapper */ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_obj = 0; int __pyx_v_flags; int __pyx_v_dtype_is_object; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_obj = values[0]; __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) if (values[2]) { __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) } else { __pyx_v_dtype_is_object = ((int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "View.MemoryView":347 * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj # <<<<<<<<<<<<<< * self.flags = flags * if type(self) is memoryview or obj is not None: */ __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); __Pyx_GOTREF(__pyx_v_self->obj); __Pyx_DECREF(__pyx_v_self->obj); __pyx_v_self->obj = __pyx_v_obj; /* "View.MemoryView":348 * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj * self.flags = flags # <<<<<<<<<<<<<< * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) */ __pyx_v_self->flags = __pyx_v_flags; /* "View.MemoryView":349 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: */ __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); __pyx_t_3 = (__pyx_t_2 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_obj != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "View.MemoryView":350 * self.flags = flags * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None */ __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) /* "View.MemoryView":351 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) */ __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":352 * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; /* "View.MemoryView":353 * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * if not __PYX_CYTHON_ATOMICS_ENABLED(): */ Py_INCREF(Py_None); /* "View.MemoryView":351 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) */ } /* "View.MemoryView":349 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: */ } /* "View.MemoryView":355 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: */ __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":357 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 */ __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); if (__pyx_t_1) { /* "View.MemoryView":358 * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: */ __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); /* "View.MemoryView":359 * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< * if self.lock is NULL: * self.lock = PyThread_allocate_lock() */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); /* "View.MemoryView":357 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 */ } /* "View.MemoryView":360 * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: # <<<<<<<<<<<<<< * self.lock = PyThread_allocate_lock() * if self.lock is NULL: */ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":361 * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< * if self.lock is NULL: * raise MemoryError */ __pyx_v_self->lock = PyThread_allocate_lock(); /* "View.MemoryView":362 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< * raise MemoryError * */ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":363 * self.lock = PyThread_allocate_lock() * if self.lock is NULL: * raise MemoryError # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) /* "View.MemoryView":362 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< * raise MemoryError * */ } /* "View.MemoryView":360 * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: # <<<<<<<<<<<<<< * self.lock = PyThread_allocate_lock() * if self.lock is NULL: */ } /* "View.MemoryView":355 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: */ } /* "View.MemoryView":365 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":366 * * if flags & PyBUF_FORMAT: * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< * else: * self.dtype_is_object = dtype_is_object */ __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L12_bool_binop_done; } __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); __pyx_t_1 = __pyx_t_2; __pyx_L12_bool_binop_done:; __pyx_v_self->dtype_is_object = __pyx_t_1; /* "View.MemoryView":365 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: */ goto __pyx_L11; } /* "View.MemoryView":368 * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< * * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( */ /*else*/ { __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; } __pyx_L11:; /* "View.MemoryView":370 * self.dtype_is_object = dtype_is_object * * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) * self.typeinfo = NULL */ __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); /* "View.MemoryView":372 * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) * self.typeinfo = NULL # <<<<<<<<<<<<<< * * def __dealloc__(memoryview self): */ __pyx_v_self->typeinfo = NULL; /* "View.MemoryView":346 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< * self.obj = obj * self.flags = flags */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":374 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) */ /* Python wrapper */ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { int __pyx_v_i; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyThread_type_lock __pyx_t_6; PyThread_type_lock __pyx_t_7; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":375 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: */ __pyx_t_1 = (__pyx_v_self->obj != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":376 * def __dealloc__(memoryview self): * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< * elif (<__pyx_buffer *> &self.view).obj == Py_None: * */ __Pyx_ReleaseBuffer((&__pyx_v_self->view)); /* "View.MemoryView":375 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: */ goto __pyx_L3; } /* "View.MemoryView":377 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * * (<__pyx_buffer *> &self.view).obj = NULL */ __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); if (__pyx_t_2) { /* "View.MemoryView":379 * elif (<__pyx_buffer *> &self.view).obj == Py_None: * * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< * Py_DECREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; /* "View.MemoryView":380 * * (<__pyx_buffer *> &self.view).obj = NULL * Py_DECREF(Py_None) # <<<<<<<<<<<<<< * * cdef int i */ Py_DECREF(Py_None); /* "View.MemoryView":377 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * * (<__pyx_buffer *> &self.view).obj = NULL */ } __pyx_L3:; /* "View.MemoryView":384 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: */ __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":385 * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 */ __pyx_t_3 = __pyx_memoryview_thread_locks_used; __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; /* "View.MemoryView":386 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: */ __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); if (__pyx_t_2) { /* "View.MemoryView":387 * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); /* "View.MemoryView":388 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); if (__pyx_t_2) { /* "View.MemoryView":390 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< * break * else: */ __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); /* "View.MemoryView":389 * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break */ (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; /* "View.MemoryView":388 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ } /* "View.MemoryView":391 * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break # <<<<<<<<<<<<<< * else: * PyThread_free_lock(self.lock) */ goto __pyx_L6_break; /* "View.MemoryView":386 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: */ } } /*else*/ { /* "View.MemoryView":393 * break * else: * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< * * cdef char *get_item_pointer(memoryview self, object index) except NULL: */ PyThread_free_lock(__pyx_v_self->lock); } __pyx_L6_break:; /* "View.MemoryView":384 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: */ } /* "View.MemoryView":374 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":395 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf */ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { Py_ssize_t __pyx_v_dim; char *__pyx_v_itemp; PyObject *__pyx_v_idx = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_item_pointer", 0); /* "View.MemoryView":397 * cdef char *get_item_pointer(memoryview self, object index) except NULL: * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< * * for dim, idx in enumerate(index): */ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); /* "View.MemoryView":399 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< * itemp = pybuffer_index(&self.view, itemp, idx, dim) * */ __pyx_t_1 = 0; if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } } else { __pyx_t_5 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 399, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); __pyx_t_5 = 0; __pyx_v_dim = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); /* "View.MemoryView":400 * * for dim, idx in enumerate(index): * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< * * return itemp */ __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) __pyx_v_itemp = __pyx_t_7; /* "View.MemoryView":399 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< * itemp = pybuffer_index(&self.view, itemp, idx, dim) * */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":402 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_itemp; goto __pyx_L0; /* "View.MemoryView":395 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_idx); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":405 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< * if index is Ellipsis: * return self */ /* Python wrapper */ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { PyObject *__pyx_v_have_slices = NULL; PyObject *__pyx_v_indices = NULL; char *__pyx_v_itemp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; char *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "View.MemoryView":406 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":407 * def __getitem__(memoryview self, object index): * if index is Ellipsis: * return self # <<<<<<<<<<<<<< * * have_slices, indices = _unellipsify(index, self.view.ndim) */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "View.MemoryView":406 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ } /* "View.MemoryView":409 * return self * * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * cdef char *itemp */ __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (likely(__pyx_t_3 != Py_None)) { PyObject* sequence = __pyx_t_3; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 409, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); #else __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_4; __pyx_t_4 = 0; __pyx_v_indices = __pyx_t_5; __pyx_t_5 = 0; /* "View.MemoryView":412 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) if (__pyx_t_2) { /* "View.MemoryView":413 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< * else: * itemp = self.get_item_pointer(indices) */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":412 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ } /* "View.MemoryView":415 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< * return self.convert_item_to_object(itemp) * */ /*else*/ { __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) __pyx_v_itemp = __pyx_t_6; /* "View.MemoryView":416 * else: * itemp = self.get_item_pointer(indices) * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< * * def __setitem__(memoryview self, object index, object value): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "View.MemoryView":405 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< * if index is Ellipsis: * return self */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_have_slices); __Pyx_XDECREF(__pyx_v_indices); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":418 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") */ /* Python wrapper */ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { PyObject *__pyx_v_have_slices = NULL; PyObject *__pyx_v_obj = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); /* "View.MemoryView":419 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError("Cannot assign to read-only memoryview") * */ __pyx_t_1 = (__pyx_v_self->view.readonly != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":420 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 420, __pyx_L1_error) /* "View.MemoryView":419 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError("Cannot assign to read-only memoryview") * */ } /* "View.MemoryView":422 * raise TypeError("Cannot assign to read-only memoryview") * * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * if have_slices: */ __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (likely(__pyx_t_2 != Py_None)) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 422, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_3; __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":424 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":425 * * if have_slices: * obj = self.is_slice(value) # <<<<<<<<<<<<<< * if obj: * self.setitem_slice_assignment(self[index], obj) */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_obj = __pyx_t_2; __pyx_t_2 = 0; /* "View.MemoryView":426 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":427 * obj = self.is_slice(value) * if obj: * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< * else: * self.setitem_slice_assign_scalar(self[index], value) */ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":426 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ goto __pyx_L5; } /* "View.MemoryView":429 * self.setitem_slice_assignment(self[index], obj) * else: * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< * else: * self.setitem_indexed(index, value) */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L5:; /* "View.MemoryView":424 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ goto __pyx_L4; } /* "View.MemoryView":431 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< * * cdef is_slice(self, obj): */ /*else*/ { __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L4:; /* "View.MemoryView":418 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_have_slices); __Pyx_XDECREF(__pyx_v_obj); __Pyx_XDECREF(__pyx_v_index); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":433 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< * if not isinstance(obj, memoryview): * try: */ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_slice", 0); __Pyx_INCREF(__pyx_v_obj); /* "View.MemoryView":434 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "View.MemoryView":436 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); /* "View.MemoryView":437 * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) # <<<<<<<<<<<<<< * except TypeError: * return None */ __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); /* "View.MemoryView":436 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "View.MemoryView":438 * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) * except TypeError: # <<<<<<<<<<<<<< * return None * */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); /* "View.MemoryView":439 * self.dtype_is_object) * except TypeError: * return None # <<<<<<<<<<<<<< * * return obj */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_except_return; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L7_except_return:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L0; __pyx_L9_try_end:; } /* "View.MemoryView":434 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, */ } /* "View.MemoryView":441 * return None * * return obj # <<<<<<<<<<<<<< * * cdef setitem_slice_assignment(self, dst, src): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_obj); __pyx_r = __pyx_v_obj; goto __pyx_L0; /* "View.MemoryView":433 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< * if not isinstance(obj, memoryview): * try: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_obj); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":443 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice */ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { __Pyx_memviewslice __pyx_v_dst_slice; __Pyx_memviewslice __pyx_v_src_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; __Pyx_memviewslice *__pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); /* "View.MemoryView":447 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) /* "View.MemoryView":448 * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< * src.ndim, dst.ndim, self.dtype_is_object) * */ if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) /* "View.MemoryView":449 * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":447 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) /* "View.MemoryView":443 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":451 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] * cdef void *tmp = NULL */ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { int __pyx_v_array[0x80]; void *__pyx_v_tmp; void *__pyx_v_item; __Pyx_memviewslice *__pyx_v_dst_slice; __Pyx_memviewslice __pyx_v_tmp_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; char const *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); /* "View.MemoryView":453 * cdef setitem_slice_assign_scalar(self, memoryview dst, value): * cdef int array[128] * cdef void *tmp = NULL # <<<<<<<<<<<<<< * cdef void *item * */ __pyx_v_tmp = NULL; /* "View.MemoryView":458 * cdef __Pyx_memviewslice *dst_slice * cdef __Pyx_memviewslice tmp_slice * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< * * if self.view.itemsize > sizeof(array): */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) __pyx_v_dst_slice = __pyx_t_1; /* "View.MemoryView":460 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); if (__pyx_t_2) { /* "View.MemoryView":461 * * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< * if tmp == NULL: * raise MemoryError */ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); /* "View.MemoryView":462 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":463 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) /* "View.MemoryView":462 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ } /* "View.MemoryView":464 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< * else: * item = array */ __pyx_v_item = __pyx_v_tmp; /* "View.MemoryView":460 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ goto __pyx_L3; } /* "View.MemoryView":466 * item = tmp * else: * item = array # <<<<<<<<<<<<<< * * try: */ /*else*/ { __pyx_v_item = ((void *)__pyx_v_array); } __pyx_L3:; /* "View.MemoryView":468 * item = array * * try: # <<<<<<<<<<<<<< * if self.dtype_is_object: * ( item)[0] = value */ /*try:*/ { /* "View.MemoryView":469 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_2) { /* "View.MemoryView":470 * try: * if self.dtype_is_object: * ( item)[0] = value # <<<<<<<<<<<<<< * else: * self.assign_item_from_object( item, value) */ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); /* "View.MemoryView":469 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ goto __pyx_L8; } /* "View.MemoryView":472 * ( item)[0] = value * else: * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L8:; /* "View.MemoryView":476 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":477 * * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, * item, self.dtype_is_object) */ __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":476 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ } /* "View.MemoryView":478 * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< * item, self.dtype_is_object) * finally: */ __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); } /* "View.MemoryView":481 * item, self.dtype_is_object) * finally: * PyMem_Free(tmp) # <<<<<<<<<<<<<< * * cdef setitem_indexed(self, index, value): */ /*finally:*/ { /*normal exit:*/{ PyMem_Free(__pyx_v_tmp); goto __pyx_L7; } __pyx_L6_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; { PyMem_Free(__pyx_v_tmp); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); } __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; goto __pyx_L1_error; } __pyx_L7:; } /* "View.MemoryView":451 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] * cdef void *tmp = NULL */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":483 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) */ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { char *__pyx_v_itemp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations char *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_indexed", 0); /* "View.MemoryView":484 * * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< * self.assign_item_from_object(itemp, value) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; /* "View.MemoryView":485 * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":483 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":487 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { PyObject *__pyx_v_struct = NULL; PyObject *__pyx_v_bytesitem = 0; PyObject *__pyx_v_result = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; size_t __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); /* "View.MemoryView":490 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef bytes bytesitem * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":493 * cdef bytes bytesitem * * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< * try: * result = struct.unpack(self.view.format, bytesitem) */ __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "View.MemoryView":495 * bytesitem = itemp[:self.view.itemsize] * try: * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< * except struct.error: * raise ValueError("Unable to convert item to object") */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_v_bytesitem); __Pyx_GIVEREF(__pyx_v_bytesitem); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ } /* "View.MemoryView":499 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ /*else:*/ { __pyx_t_10 = strlen(__pyx_v_self->view.format); __pyx_t_11 = ((__pyx_t_10 == 1) != 0); if (__pyx_t_11) { /* "View.MemoryView":500 * else: * if len(self.view.format) == 1: * return result[0] # <<<<<<<<<<<<<< * return result * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6_except_return; /* "View.MemoryView":499 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ } /* "View.MemoryView":501 * if len(self.view.format) == 1: * return result[0] * return result # <<<<<<<<<<<<<< * * cdef assign_item_from_object(self, char *itemp, object value): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_result); __pyx_r = __pyx_v_result; goto __pyx_L6_except_return; } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "View.MemoryView":496 * try: * result = struct.unpack(self.view.format, bytesitem) * except struct.error: # <<<<<<<<<<<<<< * raise ValueError("Unable to convert item to object") * else: */ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; if (__pyx_t_8) { __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); /* "View.MemoryView":497 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(1, 497, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L0; } /* "View.MemoryView":487 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_struct); __Pyx_XDECREF(__pyx_v_bytesitem); __Pyx_XDECREF(__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":503 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { PyObject *__pyx_v_struct = NULL; char __pyx_v_c; PyObject *__pyx_v_bytesvalue = 0; Py_ssize_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; char *__pyx_t_11; char *__pyx_t_12; char *__pyx_t_13; char *__pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); /* "View.MemoryView":506 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef char c * cdef bytes bytesvalue */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":511 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< * bytesvalue = struct.pack(self.view.format, *value) * else: */ __pyx_t_2 = PyTuple_Check(__pyx_v_value); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "View.MemoryView":512 * * if isinstance(value, tuple): * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< * else: * bytesvalue = struct.pack(self.view.format, value) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":511 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< * bytesvalue = struct.pack(self.view.format, *value) * else: */ goto __pyx_L3; } /* "View.MemoryView":514 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< * * for i, c in enumerate(bytesvalue): */ /*else*/ { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_9 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); __PYX_ERR(1, 516, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_bytesvalue); __pyx_t_10 = __pyx_v_bytesvalue; __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { __pyx_t_11 = __pyx_t_14; __pyx_v_c = (__pyx_t_11[0]); /* "View.MemoryView":517 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ __pyx_v_i = __pyx_t_9; /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_9 = (__pyx_t_9 + 1); /* "View.MemoryView":517 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "View.MemoryView":503 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_struct); __Pyx_XDECREF(__pyx_v_bytesvalue); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":520 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t *__pyx_t_4; char *__pyx_t_5; void *__pyx_t_6; int __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "View.MemoryView":521 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< * raise ValueError("Cannot create writable memory view from read-only memoryview") * */ __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_self->view.readonly != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "View.MemoryView":522 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 522, __pyx_L1_error) /* "View.MemoryView":521 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< * raise ValueError("Cannot create writable memory view from read-only memoryview") * */ } /* "View.MemoryView":524 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); if (__pyx_t_1) { /* "View.MemoryView":525 * * if flags & PyBUF_ND: * info.shape = self.view.shape # <<<<<<<<<<<<<< * else: * info.shape = NULL */ __pyx_t_4 = __pyx_v_self->view.shape; __pyx_v_info->shape = __pyx_t_4; /* "View.MemoryView":524 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ goto __pyx_L6; } /* "View.MemoryView":527 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_STRIDES: */ /*else*/ { __pyx_v_info->shape = NULL; } __pyx_L6:; /* "View.MemoryView":529 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.strides = self.view.strides * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { /* "View.MemoryView":530 * * if flags & PyBUF_STRIDES: * info.strides = self.view.strides # <<<<<<<<<<<<<< * else: * info.strides = NULL */ __pyx_t_4 = __pyx_v_self->view.strides; __pyx_v_info->strides = __pyx_t_4; /* "View.MemoryView":529 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.strides = self.view.strides * else: */ goto __pyx_L7; } /* "View.MemoryView":532 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_INDIRECT: */ /*else*/ { __pyx_v_info->strides = NULL; } __pyx_L7:; /* "View.MemoryView":534 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< * info.suboffsets = self.view.suboffsets * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); if (__pyx_t_1) { /* "View.MemoryView":535 * * if flags & PyBUF_INDIRECT: * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< * else: * info.suboffsets = NULL */ __pyx_t_4 = __pyx_v_self->view.suboffsets; __pyx_v_info->suboffsets = __pyx_t_4; /* "View.MemoryView":534 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< * info.suboffsets = self.view.suboffsets * else: */ goto __pyx_L8; } /* "View.MemoryView":537 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ /*else*/ { __pyx_v_info->suboffsets = NULL; } __pyx_L8:; /* "View.MemoryView":539 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.view.format * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":540 * * if flags & PyBUF_FORMAT: * info.format = self.view.format # <<<<<<<<<<<<<< * else: * info.format = NULL */ __pyx_t_5 = __pyx_v_self->view.format; __pyx_v_info->format = __pyx_t_5; /* "View.MemoryView":539 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.view.format * else: */ goto __pyx_L9; } /* "View.MemoryView":542 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< * * info.buf = self.view.buf */ /*else*/ { __pyx_v_info->format = NULL; } __pyx_L9:; /* "View.MemoryView":544 * info.format = NULL * * info.buf = self.view.buf # <<<<<<<<<<<<<< * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize */ __pyx_t_6 = __pyx_v_self->view.buf; __pyx_v_info->buf = __pyx_t_6; /* "View.MemoryView":545 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< * info.itemsize = self.view.itemsize * info.len = self.view.len */ __pyx_t_7 = __pyx_v_self->view.ndim; __pyx_v_info->ndim = __pyx_t_7; /* "View.MemoryView":546 * info.buf = self.view.buf * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< * info.len = self.view.len * info.readonly = self.view.readonly */ __pyx_t_8 = __pyx_v_self->view.itemsize; __pyx_v_info->itemsize = __pyx_t_8; /* "View.MemoryView":547 * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize * info.len = self.view.len # <<<<<<<<<<<<<< * info.readonly = self.view.readonly * info.obj = self */ __pyx_t_8 = __pyx_v_self->view.len; __pyx_v_info->len = __pyx_t_8; /* "View.MemoryView":548 * info.itemsize = self.view.itemsize * info.len = self.view.len * info.readonly = self.view.readonly # <<<<<<<<<<<<<< * info.obj = self * */ __pyx_t_1 = __pyx_v_self->view.readonly; __pyx_v_info->readonly = __pyx_t_1; /* "View.MemoryView":549 * info.len = self.view.len * info.readonly = self.view.readonly * info.obj = self # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "View.MemoryView":520 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":555 * * @property * def T(self): # <<<<<<<<<<<<<< * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":556 * @property * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< * transpose_memslice(&result.from_slice) * return result */ __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":557 * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< * return result * */ __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) /* "View.MemoryView":558 * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) * return result # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":555 * * @property * def T(self): # <<<<<<<<<<<<<< * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":561 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.obj * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":562 * @property * def base(self): * return self.obj # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->obj); __pyx_r = __pyx_v_self->obj; goto __pyx_L0; /* "View.MemoryView":561 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.obj * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":565 * * @property * def shape(self): # <<<<<<<<<<<<<< * return tuple([length for length in self.view.shape[:self.view.ndim]]) * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_length; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":566 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_length = (__pyx_t_2[0]); __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "View.MemoryView":565 * * @property * def shape(self): # <<<<<<<<<<<<<< * return tuple([length for length in self.view.shape[:self.view.ndim]]) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":569 * * @property * def strides(self): # <<<<<<<<<<<<<< * if self.view.strides == NULL: * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_stride; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":570 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * * raise ValueError("Buffer view does not expose strides") */ __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":572 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 572, __pyx_L1_error) /* "View.MemoryView":570 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * * raise ValueError("Buffer view does not expose strides") */ } /* "View.MemoryView":574 * raise ValueError("Buffer view does not expose strides") * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_v_stride = (__pyx_t_3[0]); __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "View.MemoryView":569 * * @property * def strides(self): # <<<<<<<<<<<<<< * if self.view.strides == NULL: * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":577 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; Py_ssize_t *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":578 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":579 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__17, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":578 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ } /* "View.MemoryView":581 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { __pyx_t_4 = __pyx_t_6; __pyx_v_suboffset = (__pyx_t_4[0]); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":577 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":584 * * @property * def ndim(self): # <<<<<<<<<<<<<< * return self.view.ndim * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":585 * @property * def ndim(self): * return self.view.ndim # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":584 * * @property * def ndim(self): # <<<<<<<<<<<<<< * return self.view.ndim * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":588 * * @property * def itemsize(self): # <<<<<<<<<<<<<< * return self.view.itemsize * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":589 * @property * def itemsize(self): * return self.view.itemsize # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":588 * * @property * def itemsize(self): # <<<<<<<<<<<<<< * return self.view.itemsize * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":592 * * @property * def nbytes(self): # <<<<<<<<<<<<<< * return self.size * self.view.itemsize * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":593 * @property * def nbytes(self): * return self.size * self.view.itemsize # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":592 * * @property * def nbytes(self): # <<<<<<<<<<<<<< * return self.size * self.view.itemsize * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":596 * * @property * def size(self): # <<<<<<<<<<<<<< * if self._size is None: * result = 1 */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_v_result = NULL; PyObject *__pyx_v_length = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":597 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ __pyx_t_1 = (__pyx_v_self->_size == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":598 * def size(self): * if self._size is None: * result = 1 # <<<<<<<<<<<<<< * * for length in self.view.shape[:self.view.ndim]: */ __Pyx_INCREF(__pyx_int_1); __pyx_v_result = __pyx_int_1; /* "View.MemoryView":600 * result = 1 * * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< * result *= length * */ __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); __pyx_t_6 = 0; /* "View.MemoryView":601 * * for length in self.view.shape[:self.view.ndim]: * result *= length # <<<<<<<<<<<<<< * * self._size = result */ __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); __pyx_t_6 = 0; } /* "View.MemoryView":603 * result *= length * * self._size = result # <<<<<<<<<<<<<< * * return self._size */ __Pyx_INCREF(__pyx_v_result); __Pyx_GIVEREF(__pyx_v_result); __Pyx_GOTREF(__pyx_v_self->_size); __Pyx_DECREF(__pyx_v_self->_size); __pyx_v_self->_size = __pyx_v_result; /* "View.MemoryView":597 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ } /* "View.MemoryView":605 * self._size = result * * return self._size # <<<<<<<<<<<<<< * * def __len__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_size); __pyx_r = __pyx_v_self->_size; goto __pyx_L0; /* "View.MemoryView":596 * * @property * def size(self): # <<<<<<<<<<<<<< * if self._size is None: * result = 1 */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_result); __Pyx_XDECREF(__pyx_v_length); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":607 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< * if self.view.ndim >= 1: * return self.view.shape[0] */ /* Python wrapper */ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__len__", 0); /* "View.MemoryView":608 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":609 * def __len__(self): * if self.view.ndim >= 1: * return self.view.shape[0] # <<<<<<<<<<<<<< * * return 0 */ __pyx_r = (__pyx_v_self->view.shape[0]); goto __pyx_L0; /* "View.MemoryView":608 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ } /* "View.MemoryView":611 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< * * def __repr__(self): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":607 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< * if self.view.ndim >= 1: * return self.view.shape[0] */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":613 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__, * id(self)) */ /* Python wrapper */ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "View.MemoryView":614 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":615 * def __repr__(self): * return "" % (self.base.__class__.__name__, * id(self)) # <<<<<<<<<<<<<< * * def __str__(self): */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "View.MemoryView":614 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":613 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__, * id(self)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":617 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__,) * */ /* Python wrapper */ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "View.MemoryView":618 * * def __str__(self): * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":617 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__,) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":621 * * * def is_c_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* Python wrapper */ static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice *__pyx_v_mslice; __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_c_contig", 0); /* "View.MemoryView":624 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'C', self.view.ndim) * */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":625 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< * * def is_f_contig(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":621 * * * def is_c_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* Python wrapper */ static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice *__pyx_v_mslice; __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_f_contig", 0); /* "View.MemoryView":630 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'F', self.view.ndim) * */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":631 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< * * def copy(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":633 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS */ /* Python wrapper */ static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice __pyx_v_mslice; int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy", 0); /* "View.MemoryView":635 * def copy(self): * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< * * slice_copy(self, &mslice) */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); /* "View.MemoryView":637 * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS * * slice_copy(self, &mslice) # <<<<<<<<<<<<<< * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, * self.view.itemsize, */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); /* "View.MemoryView":638 * * slice_copy(self, &mslice) * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_C_CONTIGUOUS, */ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":643 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< * * def copy_fortran(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":633 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":645 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS */ /* Python wrapper */ static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice __pyx_v_src; __Pyx_memviewslice __pyx_v_dst; int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy_fortran", 0); /* "View.MemoryView":647 * def copy_fortran(self): * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< * * slice_copy(self, &src) */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); /* "View.MemoryView":649 * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS * * slice_copy(self, &src) # <<<<<<<<<<<<<< * dst = slice_copy_contig(&src, "fortran", self.view.ndim, * self.view.itemsize, */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); /* "View.MemoryView":650 * * slice_copy(self, &src) * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_F_CONTIGUOUS, */ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; /* "View.MemoryView":655 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":645 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":659 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo */ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { struct __pyx_memoryview_obj *__pyx_v_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); /* "View.MemoryView":660 * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< * result.typeinfo = typeinfo * return result */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_o); __Pyx_GIVEREF(__pyx_v_o); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":661 * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo # <<<<<<<<<<<<<< * return result * */ __pyx_v_result->typeinfo = __pyx_v_typeinfo; /* "View.MemoryView":662 * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo * return result # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_check') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":659 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":665 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("memoryview_check", 0); /* "View.MemoryView":666 * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): * return isinstance(o, memoryview) # <<<<<<<<<<<<<< * * cdef tuple _unellipsify(object index, int ndim): */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); __pyx_r = __pyx_t_1; goto __pyx_L0; /* "View.MemoryView":665 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":668 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< * """ * Replace all ellipses with full slices and fill incomplete indices with */ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { PyObject *__pyx_v_tup = NULL; PyObject *__pyx_v_result = NULL; int __pyx_v_have_slices; int __pyx_v_seen_ellipsis; CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; PyObject *__pyx_v_item = NULL; Py_ssize_t __pyx_v_nslices; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; Py_ssize_t __pyx_t_8; int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_unellipsify", 0); /* "View.MemoryView":673 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< * tup = (index,) * else: */ __pyx_t_1 = PyTuple_Check(__pyx_v_index); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":674 * """ * if not isinstance(index, tuple): * tup = (index,) # <<<<<<<<<<<<<< * else: * tup = index */ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); __pyx_v_tup = __pyx_t_3; __pyx_t_3 = 0; /* "View.MemoryView":673 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< * tup = (index,) * else: */ goto __pyx_L3; } /* "View.MemoryView":676 * tup = (index,) * else: * tup = index # <<<<<<<<<<<<<< * * result = [] */ /*else*/ { __Pyx_INCREF(__pyx_v_index); __pyx_v_tup = __pyx_v_index; } __pyx_L3:; /* "View.MemoryView":678 * tup = index * * result = [] # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_result = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":679 * * result = [] * have_slices = False # <<<<<<<<<<<<<< * seen_ellipsis = False * for idx, item in enumerate(tup): */ __pyx_v_have_slices = 0; /* "View.MemoryView":680 * result = [] * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< * for idx, item in enumerate(tup): * if item is Ellipsis: */ __pyx_v_seen_ellipsis = 0; /* "View.MemoryView":681 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ __Pyx_INCREF(__pyx_int_0); __pyx_t_3 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } } else { __pyx_t_7 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 681, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_7); } __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = __pyx_t_7; __pyx_t_7 = 0; /* "View.MemoryView":682 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) */ __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":683 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True */ __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":684 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { __Pyx_INCREF(__pyx_slice__20); __Pyx_GIVEREF(__pyx_slice__20); PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__20); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":685 * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True # <<<<<<<<<<<<<< * else: * result.append(slice(None)) */ __pyx_v_seen_ellipsis = 1; /* "View.MemoryView":683 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True */ goto __pyx_L7; } /* "View.MemoryView":687 * seen_ellipsis = True * else: * result.append(slice(None)) # <<<<<<<<<<<<<< * have_slices = True * else: */ /*else*/ { __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__20); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) } __pyx_L7:; /* "View.MemoryView":688 * else: * result.append(slice(None)) * have_slices = True # <<<<<<<<<<<<<< * else: * if not isinstance(item, slice) and not PyIndex_Check(item): */ __pyx_v_have_slices = 1; /* "View.MemoryView":682 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) */ goto __pyx_L6; } /* "View.MemoryView":690 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError("Cannot index with type '%s'" % type(item)) * */ /*else*/ { __pyx_t_2 = PySlice_Check(__pyx_v_item); __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_10) { } else { __pyx_t_1 = __pyx_t_10; goto __pyx_L9_bool_binop_done; } __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); __pyx_t_1 = __pyx_t_10; __pyx_L9_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "View.MemoryView":691 * else: * if not isinstance(item, slice) and not PyIndex_Check(item): * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< * * have_slices = have_slices or isinstance(item, slice) */ __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_11, 0, 0, 0); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __PYX_ERR(1, 691, __pyx_L1_error) /* "View.MemoryView":690 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError("Cannot index with type '%s'" % type(item)) * */ } /* "View.MemoryView":693 * raise TypeError("Cannot index with type '%s'" % type(item)) * * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< * result.append(item) * */ __pyx_t_10 = (__pyx_v_have_slices != 0); if (!__pyx_t_10) { } else { __pyx_t_1 = __pyx_t_10; goto __pyx_L11_bool_binop_done; } __pyx_t_10 = PySlice_Check(__pyx_v_item); __pyx_t_2 = (__pyx_t_10 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L11_bool_binop_done:; __pyx_v_have_slices = __pyx_t_1; /* "View.MemoryView":694 * * have_slices = have_slices or isinstance(item, slice) * result.append(item) # <<<<<<<<<<<<<< * * nslices = ndim - len(result) */ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) } __pyx_L6:; /* "View.MemoryView":681 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":696 * result.append(item) * * nslices = ndim - len(result) # <<<<<<<<<<<<<< * if nslices: * result.extend([slice(None)] * nslices) */ __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); /* "View.MemoryView":697 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< * result.extend([slice(None)] * nslices) * */ __pyx_t_1 = (__pyx_v_nslices != 0); if (__pyx_t_1) { /* "View.MemoryView":698 * nslices = ndim - len(result) * if nslices: * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< * * return have_slices or nslices, tuple(result) */ __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { __Pyx_INCREF(__pyx_slice__20); __Pyx_GIVEREF(__pyx_slice__20); PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__20); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":697 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< * result.extend([slice(None)] * nslices) * */ } /* "View.MemoryView":700 * result.extend([slice(None)] * nslices) * * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): */ __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L14_bool_binop_done; } __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; __pyx_L14_bool_binop_done:; __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L0; /* "View.MemoryView":668 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< * """ * Replace all ellipses with full slices and fill incomplete indices with */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tup); __Pyx_XDECREF(__pyx_v_result); __Pyx_XDECREF(__pyx_v_idx); __Pyx_XDECREF(__pyx_v_item); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":702 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t *__pyx_t_1; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); /* "View.MemoryView":703 * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") */ __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { __pyx_t_1 = __pyx_t_3; __pyx_v_suboffset = (__pyx_t_1[0]); /* "View.MemoryView":704 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError("Indirect dimensions not supported") * */ __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":705 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(1, 705, __pyx_L1_error) /* "View.MemoryView":704 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError("Indirect dimensions not supported") * */ } } /* "View.MemoryView":702 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":712 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< * cdef int new_ndim = 0, suboffset_dim = -1, dim * cdef bint negative_step */ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { int __pyx_v_new_ndim; int __pyx_v_suboffset_dim; int __pyx_v_dim; __Pyx_memviewslice __pyx_v_src; __Pyx_memviewslice __pyx_v_dst; __Pyx_memviewslice *__pyx_v_p_src; struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; __Pyx_memviewslice *__pyx_v_p_dst; int *__pyx_v_p_suboffset_dim; Py_ssize_t __pyx_v_start; Py_ssize_t __pyx_v_stop; Py_ssize_t __pyx_v_step; int __pyx_v_have_start; int __pyx_v_have_stop; int __pyx_v_have_step; PyObject *__pyx_v_index = NULL; struct __pyx_memoryview_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; struct __pyx_memoryview_obj *__pyx_t_4; char *__pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; PyObject *(*__pyx_t_8)(PyObject *); PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; int __pyx_t_11; Py_ssize_t __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memview_slice", 0); /* "View.MemoryView":713 * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< * cdef bint negative_step * cdef __Pyx_memviewslice src, dst */ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; /* "View.MemoryView":720 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< * * cdef _memoryviewslice memviewsliceobj */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); /* "View.MemoryView":724 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< * * if isinstance(memview, _memoryviewslice): */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(1, 724, __pyx_L1_error) } } #endif /* "View.MemoryView":726 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":727 * * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview # <<<<<<<<<<<<<< * p_src = &memviewsliceobj.from_slice * else: */ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":728 * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< * else: * slice_copy(memview, &src) */ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); /* "View.MemoryView":726 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice */ goto __pyx_L3; } /* "View.MemoryView":730 * p_src = &memviewsliceobj.from_slice * else: * slice_copy(memview, &src) # <<<<<<<<<<<<<< * p_src = &src * */ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); /* "View.MemoryView":731 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< * * */ __pyx_v_p_src = (&__pyx_v_src); } __pyx_L3:; /* "View.MemoryView":737 * * * dst.memview = p_src.memview # <<<<<<<<<<<<<< * dst.data = p_src.data * */ __pyx_t_4 = __pyx_v_p_src->memview; __pyx_v_dst.memview = __pyx_t_4; /* "View.MemoryView":738 * * dst.memview = p_src.memview * dst.data = p_src.data # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __pyx_v_p_src->data; __pyx_v_dst.data = __pyx_t_5; /* "View.MemoryView":743 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< * cdef int *p_suboffset_dim = &suboffset_dim * cdef Py_ssize_t start, stop, step */ __pyx_v_p_dst = (&__pyx_v_dst); /* "View.MemoryView":744 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< * cdef Py_ssize_t start, stop, step * cdef bint have_start, have_stop, have_step */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); /* "View.MemoryView":748 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * slice_memviewslice( */ __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; __pyx_t_8 = NULL; } else { __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_8)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) #else __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } else { if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) #else __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } } else { __pyx_t_9 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_9)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 748, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_9); } __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); __pyx_t_9 = 0; __pyx_v_dim = __pyx_t_6; __pyx_t_6 = (__pyx_t_6 + 1); /* "View.MemoryView":749 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); if (__pyx_t_2) { /* "View.MemoryView":753 * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< * 0, 0, 0, # have_{start,stop,step} * False) */ __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) /* "View.MemoryView":750 * for dim, index in enumerate(indices): * if PyIndex_Check(index): * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) /* "View.MemoryView":749 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ goto __pyx_L6; } /* "View.MemoryView":756 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 */ __pyx_t_2 = (__pyx_v_index == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":757 * False) * elif index is None: * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 */ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; /* "View.MemoryView":758 * elif index is None: * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 */ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; /* "View.MemoryView":759 * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< * new_ndim += 1 * else: */ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; /* "View.MemoryView":760 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 # <<<<<<<<<<<<<< * else: * start = index.start or 0 */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); /* "View.MemoryView":756 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 */ goto __pyx_L6; } /* "View.MemoryView":762 * new_ndim += 1 * else: * start = index.start or 0 # <<<<<<<<<<<<<< * stop = index.stop or 0 * step = index.step or 0 */ /*else*/ { __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L7_bool_binop_done; } __pyx_t_10 = 0; __pyx_L7_bool_binop_done:; __pyx_v_start = __pyx_t_10; /* "View.MemoryView":763 * else: * start = index.start or 0 * stop = index.stop or 0 # <<<<<<<<<<<<<< * step = index.step or 0 * */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L9_bool_binop_done; } __pyx_t_10 = 0; __pyx_L9_bool_binop_done:; __pyx_v_stop = __pyx_t_10; /* "View.MemoryView":764 * start = index.start or 0 * stop = index.stop or 0 * step = index.step or 0 # <<<<<<<<<<<<<< * * have_start = index.start is not None */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L11_bool_binop_done; } __pyx_t_10 = 0; __pyx_L11_bool_binop_done:; __pyx_v_step = __pyx_t_10; /* "View.MemoryView":766 * step = index.step or 0 * * have_start = index.start is not None # <<<<<<<<<<<<<< * have_stop = index.stop is not None * have_step = index.step is not None */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_start = __pyx_t_1; /* "View.MemoryView":767 * * have_start = index.start is not None * have_stop = index.stop is not None # <<<<<<<<<<<<<< * have_step = index.step is not None * */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_stop = __pyx_t_1; /* "View.MemoryView":768 * have_start = index.start is not None * have_stop = index.stop is not None * have_step = index.step is not None # <<<<<<<<<<<<<< * * slice_memviewslice( */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_step = __pyx_t_1; /* "View.MemoryView":770 * have_step = index.step is not None * * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) /* "View.MemoryView":776 * have_start, have_stop, have_step, * True) * new_ndim += 1 # <<<<<<<<<<<<<< * * if isinstance(memview, _memoryviewslice): */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); } __pyx_L6:; /* "View.MemoryView":748 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * slice_memviewslice( */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":779 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, */ __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "View.MemoryView":780 * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< * memviewsliceobj.to_dtype_func, * memview.dtype_is_object) */ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } /* "View.MemoryView":781 * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< * memview.dtype_is_object) * else: */ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } /* "View.MemoryView":779 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, */ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, */ } /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ /*else*/ { __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "View.MemoryView":785 * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; } /* "View.MemoryView":712 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< * cdef int new_ndim = 0, suboffset_dim = -1, dim * cdef bint negative_step */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); __Pyx_XDECREF(__pyx_v_index); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":809 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, */ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { Py_ssize_t __pyx_v_new_shape; int __pyx_v_negative_step; int __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":829 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":831 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ __pyx_t_1 = ((__pyx_v_start < 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":832 * * if start < 0: * start += shape # <<<<<<<<<<<<<< * if not 0 <= start < shape: * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":831 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ } /* "View.MemoryView":833 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) * else: */ __pyx_t_1 = (0 <= __pyx_v_start); if (__pyx_t_1) { __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); } __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":834 * start += shape * if not 0 <= start < shape: * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< * else: * */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) /* "View.MemoryView":833 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) * else: */ } /* "View.MemoryView":829 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ goto __pyx_L3; } /* "View.MemoryView":837 * else: * * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< * * if have_step and step == 0: */ /*else*/ { __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L6_bool_binop_done; } __pyx_t_1 = ((__pyx_v_step < 0) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L6_bool_binop_done:; __pyx_v_negative_step = __pyx_t_2; /* "View.MemoryView":839 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) * */ __pyx_t_1 = (__pyx_v_have_step != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L9_bool_binop_done; } __pyx_t_1 = ((__pyx_v_step == 0) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L9_bool_binop_done:; if (__pyx_t_2) { /* "View.MemoryView":840 * * if have_step and step == 0: * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) /* "View.MemoryView":839 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) * */ } /* "View.MemoryView":843 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { /* "View.MemoryView":844 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":845 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< * if start < 0: * start = 0 */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":846 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":847 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< * elif start >= shape: * if negative_step: */ __pyx_v_start = 0; /* "View.MemoryView":846 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ } /* "View.MemoryView":844 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ goto __pyx_L12; } /* "View.MemoryView":848 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); if (__pyx_t_2) { /* "View.MemoryView":849 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":850 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = shape */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":849 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L14; } /* "View.MemoryView":852 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ /*else*/ { __pyx_v_start = __pyx_v_shape; } __pyx_L14:; /* "View.MemoryView":848 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ } __pyx_L12:; /* "View.MemoryView":843 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ goto __pyx_L11; } /* "View.MemoryView":854 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ /*else*/ { __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":855 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = 0 */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":854 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L15; } /* "View.MemoryView":857 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< * * if have_stop: */ /*else*/ { __pyx_v_start = 0; } __pyx_L15:; } __pyx_L11:; /* "View.MemoryView":859 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { /* "View.MemoryView":860 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":861 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< * if stop < 0: * stop = 0 */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); /* "View.MemoryView":862 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":863 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< * elif stop > shape: * stop = shape */ __pyx_v_stop = 0; /* "View.MemoryView":862 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ } /* "View.MemoryView":860 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ goto __pyx_L17; } /* "View.MemoryView":864 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); if (__pyx_t_2) { /* "View.MemoryView":865 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ __pyx_v_stop = __pyx_v_shape; /* "View.MemoryView":864 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ } __pyx_L17:; /* "View.MemoryView":859 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ goto __pyx_L16; } /* "View.MemoryView":867 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ /*else*/ { __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":868 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< * else: * stop = shape */ __pyx_v_stop = -1L; /* "View.MemoryView":867 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ goto __pyx_L19; } /* "View.MemoryView":870 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< * * if not have_step: */ /*else*/ { __pyx_v_stop = __pyx_v_shape; } __pyx_L19:; } __pyx_L16:; /* "View.MemoryView":872 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< * step = 1 * */ __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":873 * * if not have_step: * step = 1 # <<<<<<<<<<<<<< * * */ __pyx_v_step = 1; /* "View.MemoryView":872 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< * step = 1 * */ } /* "View.MemoryView":877 * * with cython.cdivision(True): * new_shape = (stop - start) // step # <<<<<<<<<<<<<< * * if (stop - start) - step * new_shape: */ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); /* "View.MemoryView":879 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< * new_shape += 1 * */ __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); if (__pyx_t_2) { /* "View.MemoryView":880 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< * * if new_shape < 0: */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); /* "View.MemoryView":879 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< * new_shape += 1 * */ } /* "View.MemoryView":882 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":883 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< * * */ __pyx_v_new_shape = 0; /* "View.MemoryView":882 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ } /* "View.MemoryView":886 * * * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset */ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); /* "View.MemoryView":887 * * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< * dst.suboffsets[new_ndim] = suboffset * */ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; /* "View.MemoryView":888 * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< * * */ (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; } __pyx_L3:; /* "View.MemoryView":891 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":892 * * if suboffset_dim[0] < 0: * dst.data += start * stride # <<<<<<<<<<<<<< * else: * dst.suboffsets[suboffset_dim[0]] += start * stride */ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); /* "View.MemoryView":891 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ goto __pyx_L23; } /* "View.MemoryView":894 * dst.data += start * stride * else: * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< * * if suboffset >= 0: */ /*else*/ { __pyx_t_3 = (__pyx_v_suboffset_dim[0]); (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); } __pyx_L23:; /* "View.MemoryView":896 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":897 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":898 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":899 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); /* "View.MemoryView":898 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ goto __pyx_L26; } /* "View.MemoryView":901 * dst.data = ( dst.data)[0] + suboffset * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< * "must be indexed and not sliced", dim) * else: */ /*else*/ { /* "View.MemoryView":902 * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< * else: * suboffset_dim[0] = new_ndim */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L26:; /* "View.MemoryView":897 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ goto __pyx_L25; } /* "View.MemoryView":904 * "must be indexed and not sliced", dim) * else: * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< * * return 0 */ /*else*/ { (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; } __pyx_L25:; /* "View.MemoryView":896 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ } /* "View.MemoryView":906 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":809 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":912 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 */ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { Py_ssize_t __pyx_v_shape; Py_ssize_t __pyx_v_stride; Py_ssize_t __pyx_v_suboffset; Py_ssize_t __pyx_v_itemsize; char *__pyx_v_resultp; char *__pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pybuffer_index", 0); /* "View.MemoryView":914 * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< * cdef Py_ssize_t itemsize = view.itemsize * cdef char *resultp */ __pyx_v_suboffset = -1L; /* "View.MemoryView":915 * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< * cdef char *resultp * */ __pyx_t_1 = __pyx_v_view->itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":918 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len / itemsize * stride = itemsize */ __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":919 * * if view.ndim == 0: * shape = view.len / itemsize # <<<<<<<<<<<<<< * stride = itemsize * else: */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 919, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 919, __pyx_L1_error) } __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); /* "View.MemoryView":920 * if view.ndim == 0: * shape = view.len / itemsize * stride = itemsize # <<<<<<<<<<<<<< * else: * shape = view.shape[dim] */ __pyx_v_stride = __pyx_v_itemsize; /* "View.MemoryView":918 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len / itemsize * stride = itemsize */ goto __pyx_L3; } /* "View.MemoryView":922 * stride = itemsize * else: * shape = view.shape[dim] # <<<<<<<<<<<<<< * stride = view.strides[dim] * if view.suboffsets != NULL: */ /*else*/ { __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); /* "View.MemoryView":923 * else: * shape = view.shape[dim] * stride = view.strides[dim] # <<<<<<<<<<<<<< * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] */ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); /* "View.MemoryView":924 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":925 * stride = view.strides[dim] * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< * * if index < 0: */ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); /* "View.MemoryView":924 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ } } __pyx_L3:; /* "View.MemoryView":927 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":928 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< * if index < 0: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); /* "View.MemoryView":929 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":930 * index += view.shape[dim] * if index < 0: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * if index >= shape: */ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 930, __pyx_L1_error) /* "View.MemoryView":929 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ } /* "View.MemoryView":927 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ } /* "View.MemoryView":932 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":933 * * if index >= shape: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * resultp = bufp + index * stride */ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 933, __pyx_L1_error) /* "View.MemoryView":932 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ } /* "View.MemoryView":935 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * resultp = bufp + index * stride # <<<<<<<<<<<<<< * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset */ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); /* "View.MemoryView":936 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":937 * resultp = bufp + index * stride * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< * * return resultp */ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); /* "View.MemoryView":936 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ } /* "View.MemoryView":939 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_resultp; goto __pyx_L0; /* "View.MemoryView":912 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":945 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { int __pyx_v_ndim; Py_ssize_t *__pyx_v_shape; Py_ssize_t *__pyx_v_strides; int __pyx_v_i; int __pyx_v_j; int __pyx_r; int __pyx_t_1; Py_ssize_t *__pyx_t_2; long __pyx_t_3; long __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":946 * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< * * cdef Py_ssize_t *shape = memslice.shape */ __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; __pyx_v_ndim = __pyx_t_1; /* "View.MemoryView":948 * cdef int ndim = memslice.memview.view.ndim * * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< * cdef Py_ssize_t *strides = memslice.strides * */ __pyx_t_2 = __pyx_v_memslice->shape; __pyx_v_shape = __pyx_t_2; /* "View.MemoryView":949 * * cdef Py_ssize_t *shape = memslice.shape * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_v_memslice->strides; __pyx_v_strides = __pyx_t_2; /* "View.MemoryView":953 * * cdef int i, j * for i in range(ndim / 2): # <<<<<<<<<<<<<< * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] */ __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); __pyx_t_4 = __pyx_t_3; for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":954 * cdef int i, j * for i in range(ndim / 2): * j = ndim - 1 - i # <<<<<<<<<<<<<< * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] */ __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); /* "View.MemoryView":955 * for i in range(ndim / 2): * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< * shape[i], shape[j] = shape[j], shape[i] * */ __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; /* "View.MemoryView":956 * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: */ __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; /* "View.MemoryView":958 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * */ __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); if (!__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { /* "View.MemoryView":959 * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< * * return 1 */ __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) /* "View.MemoryView":958 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * */ } } /* "View.MemoryView":961 * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * * return 1 # <<<<<<<<<<<<<< * * */ __pyx_r = 1; goto __pyx_L0; /* "View.MemoryView":945 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = 0; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":978 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * */ /* Python wrapper */ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":979 * * def __dealloc__(self): * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); /* "View.MemoryView":978 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":981 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: * return self.to_object_func(itemp) */ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); /* "View.MemoryView":982 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":983 * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: * return self.to_object_func(itemp) # <<<<<<<<<<<<<< * else: * return memoryview.convert_item_to_object(self, itemp) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":982 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ } /* "View.MemoryView":985 * return self.to_object_func(itemp) * else: * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< * * cdef assign_item_from_object(self, char *itemp, object value): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "View.MemoryView":981 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: * return self.to_object_func(itemp) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":987 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) */ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); /* "View.MemoryView":988 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< * self.to_dtype_func(itemp, value) * else: */ __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":989 * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< * else: * memoryview.assign_item_from_object(self, itemp, value) */ __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) /* "View.MemoryView":988 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< * self.to_dtype_func(itemp, value) * else: */ goto __pyx_L3; } /* "View.MemoryView":991 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< * * @property */ /*else*/ { __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "View.MemoryView":987 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":994 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.from_object * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":995 * @property * def base(self): * return self.from_object # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->from_object); __pyx_r = __pyx_v_self->from_object; goto __pyx_L0; /* "View.MemoryView":994 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.from_object * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1001 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< * int ndim, * object (*to_object_func)(char *), */ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_v_length = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_TypeInfo *__pyx_t_4; Py_buffer __pyx_t_5; Py_ssize_t *__pyx_t_6; Py_ssize_t *__pyx_t_7; Py_ssize_t *__pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_fromslice", 0); /* "View.MemoryView":1009 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); if (__pyx_t_1) { /* "View.MemoryView":1010 * * if memviewslice.memview == Py_None: * return None # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "View.MemoryView":1009 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ } /* "View.MemoryView":1015 * * * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< * * result.from_slice = memviewslice */ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1017 * result = _memoryviewslice(None, 0, dtype_is_object) * * result.from_slice = memviewslice # <<<<<<<<<<<<<< * __PYX_INC_MEMVIEW(&memviewslice, 1) * */ __pyx_v_result->from_slice = __pyx_v_memviewslice; /* "View.MemoryView":1018 * * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< * * result.from_object = ( memviewslice.memview).base */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); /* "View.MemoryView":1020 * __PYX_INC_MEMVIEW(&memviewslice, 1) * * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< * result.typeinfo = memviewslice.memview.typeinfo * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_result->from_object); __Pyx_DECREF(__pyx_v_result->from_object); __pyx_v_result->from_object = __pyx_t_2; __pyx_t_2 = 0; /* "View.MemoryView":1021 * * result.from_object = ( memviewslice.memview).base * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< * * result.view = memviewslice.memview.view */ __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; /* "View.MemoryView":1023 * result.typeinfo = memviewslice.memview.typeinfo * * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< * result.view.buf = memviewslice.data * result.view.ndim = ndim */ __pyx_t_5 = __pyx_v_memviewslice.memview->view; __pyx_v_result->__pyx_base.view = __pyx_t_5; /* "View.MemoryView":1024 * * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None */ __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); /* "View.MemoryView":1025 * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data * result.view.ndim = ndim # <<<<<<<<<<<<<< * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) */ __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; /* "View.MemoryView":1026 * result.view.buf = memviewslice.data * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; /* "View.MemoryView":1027 * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * if (memviewslice.memview).flags & PyBUF_WRITABLE: */ Py_INCREF(Py_None); /* "View.MemoryView":1029 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< * result.flags = PyBUF_RECORDS * else: */ __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); if (__pyx_t_1) { /* "View.MemoryView":1030 * * if (memviewslice.memview).flags & PyBUF_WRITABLE: * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< * else: * result.flags = PyBUF_RECORDS_RO */ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; /* "View.MemoryView":1029 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< * result.flags = PyBUF_RECORDS * else: */ goto __pyx_L4; } /* "View.MemoryView":1032 * result.flags = PyBUF_RECORDS * else: * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< * * result.view.shape = result.from_slice.shape */ /*else*/ { __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; } __pyx_L4:; /* "View.MemoryView":1034 * result.flags = PyBUF_RECORDS_RO * * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< * result.view.strides = result.from_slice.strides * */ __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); /* "View.MemoryView":1035 * * result.view.shape = result.from_slice.shape * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< * * */ __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); /* "View.MemoryView":1038 * * * result.view.suboffsets = NULL # <<<<<<<<<<<<<< * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: */ __pyx_v_result->__pyx_base.view.suboffsets = NULL; /* "View.MemoryView":1039 * * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets */ __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; __pyx_v_suboffset = (__pyx_t_6[0]); /* "View.MemoryView":1040 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * result.view.suboffsets = result.from_slice.suboffsets * break */ __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":1041 * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< * break * */ __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); /* "View.MemoryView":1042 * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets * break # <<<<<<<<<<<<<< * * result.view.len = result.view.itemsize */ goto __pyx_L6_break; /* "View.MemoryView":1040 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * result.view.suboffsets = result.from_slice.suboffsets * break */ } } __pyx_L6_break:; /* "View.MemoryView":1044 * break * * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< * for length in result.view.shape[:ndim]: * result.view.len *= length */ __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; /* "View.MemoryView":1045 * * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< * result.view.len *= length * */ __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1046 * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: * result.view.len *= length # <<<<<<<<<<<<<< * * result.to_object_func = to_object_func */ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; } /* "View.MemoryView":1048 * result.view.len *= length * * result.to_object_func = to_object_func # <<<<<<<<<<<<<< * result.to_dtype_func = to_dtype_func * */ __pyx_v_result->to_object_func = __pyx_v_to_object_func; /* "View.MemoryView":1049 * * result.to_object_func = to_object_func * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< * * return result */ __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; /* "View.MemoryView":1051 * result.to_dtype_func = to_dtype_func * * return result # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_get_slice_from_memoryview') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":1001 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< * int ndim, * object (*to_object_func)(char *), */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XDECREF(__pyx_v_length); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1054 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj */ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; __Pyx_memviewslice *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_slice_from_memview", 0); /* "View.MemoryView":1057 * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview * return &obj.from_slice */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":1058 * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): * obj = memview # <<<<<<<<<<<<<< * return &obj.from_slice * else: */ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":1059 * if isinstance(memview, _memoryviewslice): * obj = memview * return &obj.from_slice # <<<<<<<<<<<<<< * else: * slice_copy(memview, mslice) */ __pyx_r = (&__pyx_v_obj->from_slice); goto __pyx_L0; /* "View.MemoryView":1057 * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview * return &obj.from_slice */ } /* "View.MemoryView":1061 * return &obj.from_slice * else: * slice_copy(memview, mslice) # <<<<<<<<<<<<<< * return mslice * */ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); /* "View.MemoryView":1062 * else: * slice_copy(memview, mslice) * return mslice # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_slice_copy') */ __pyx_r = __pyx_v_mslice; goto __pyx_L0; } /* "View.MemoryView":1054 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_obj); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1065 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { int __pyx_v_dim; Py_ssize_t *__pyx_v_shape; Py_ssize_t *__pyx_v_strides; Py_ssize_t *__pyx_v_suboffsets; __Pyx_RefNannyDeclarations Py_ssize_t *__pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; __Pyx_RefNannySetupContext("slice_copy", 0); /* "View.MemoryView":1069 * cdef (Py_ssize_t*) shape, strides, suboffsets * * shape = memview.view.shape # <<<<<<<<<<<<<< * strides = memview.view.strides * suboffsets = memview.view.suboffsets */ __pyx_t_1 = __pyx_v_memview->view.shape; __pyx_v_shape = __pyx_t_1; /* "View.MemoryView":1070 * * shape = memview.view.shape * strides = memview.view.strides # <<<<<<<<<<<<<< * suboffsets = memview.view.suboffsets * */ __pyx_t_1 = __pyx_v_memview->view.strides; __pyx_v_strides = __pyx_t_1; /* "View.MemoryView":1071 * shape = memview.view.shape * strides = memview.view.strides * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< * * dst.memview = <__pyx_memoryview *> memview */ __pyx_t_1 = __pyx_v_memview->view.suboffsets; __pyx_v_suboffsets = __pyx_t_1; /* "View.MemoryView":1073 * suboffsets = memview.view.suboffsets * * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< * dst.data = memview.view.buf * */ __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); /* "View.MemoryView":1074 * * dst.memview = <__pyx_memoryview *> memview * dst.data = memview.view.buf # <<<<<<<<<<<<<< * * for dim in range(memview.view.ndim): */ __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); /* "View.MemoryView":1076 * dst.data = memview.view.buf * * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] */ __pyx_t_2 = __pyx_v_memview->view.ndim; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_dim = __pyx_t_4; /* "View.MemoryView":1077 * * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 */ (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); /* "View.MemoryView":1078 * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 * */ (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); /* "View.MemoryView":1079 * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_object') */ if ((__pyx_v_suboffsets != 0)) { __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); } else { __pyx_t_5 = -1L; } (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; } /* "View.MemoryView":1065 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice */ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { __Pyx_memviewslice __pyx_v_memviewslice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy", 0); /* "View.MemoryView":1085 * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< * return memoryview_copy_from_slice(memview, &memviewslice) * */ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); /* "View.MemoryView":1086 * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_object_from_slice') */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1089 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< * """ * Create a new memoryview object from a given memoryview object and slice. */ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { PyObject *(*__pyx_v_to_object_func)(char *); int (*__pyx_v_to_dtype_func)(char *, PyObject *); PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *(*__pyx_t_3)(char *); int (*__pyx_t_4)(char *, PyObject *); PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); /* "View.MemoryView":1096 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":1097 * * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: */ __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; __pyx_v_to_object_func = __pyx_t_3; /* "View.MemoryView":1098 * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< * else: * to_object_func = NULL */ __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; __pyx_v_to_dtype_func = __pyx_t_4; /* "View.MemoryView":1096 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func */ goto __pyx_L3; } /* "View.MemoryView":1100 * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: * to_object_func = NULL # <<<<<<<<<<<<<< * to_dtype_func = NULL * */ /*else*/ { __pyx_v_to_object_func = NULL; /* "View.MemoryView":1101 * else: * to_object_func = NULL * to_dtype_func = NULL # <<<<<<<<<<<<<< * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, */ __pyx_v_to_dtype_func = NULL; } __pyx_L3:; /* "View.MemoryView":1103 * to_dtype_func = NULL * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< * to_object_func, to_dtype_func, * memview.dtype_is_object) */ __Pyx_XDECREF(__pyx_r); /* "View.MemoryView":1105 * return memoryview_fromslice(memviewslice[0], memview.view.ndim, * to_object_func, to_dtype_func, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "View.MemoryView":1089 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< * """ * Create a new memoryview object from a given memoryview object and slice. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1111 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< * if arg < 0: * return -arg */ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; int __pyx_t_1; /* "View.MemoryView":1112 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< * return -arg * else: */ __pyx_t_1 = ((__pyx_v_arg < 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":1113 * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: * return -arg # <<<<<<<<<<<<<< * else: * return arg */ __pyx_r = (-__pyx_v_arg); goto __pyx_L0; /* "View.MemoryView":1112 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< * return -arg * else: */ } /* "View.MemoryView":1115 * return -arg * else: * return arg # <<<<<<<<<<<<<< * * @cname('__pyx_get_best_slice_order') */ /*else*/ { __pyx_r = __pyx_v_arg; goto __pyx_L0; } /* "View.MemoryView":1111 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< * if arg < 0: * return -arg */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1118 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { int __pyx_v_i; Py_ssize_t __pyx_v_c_stride; Py_ssize_t __pyx_v_f_stride; char __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; /* "View.MemoryView":1123 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< * cdef Py_ssize_t f_stride = 0 * */ __pyx_v_c_stride = 0; /* "View.MemoryView":1124 * cdef int i * cdef Py_ssize_t c_stride = 0 * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< * * for i in range(ndim - 1, -1, -1): */ __pyx_v_f_stride = 0; /* "View.MemoryView":1126 * cdef Py_ssize_t f_stride = 0 * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] */ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":1127 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1128 * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< * break * */ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1129 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< * * for i in range(ndim): */ goto __pyx_L4_break; /* "View.MemoryView":1127 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ } } __pyx_L4_break:; /* "View.MemoryView":1131 * break * * for i in range(ndim): # <<<<<<<<<<<<<< * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] */ __pyx_t_1 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_1; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1132 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1133 * for i in range(ndim): * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< * break * */ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1134 * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): */ goto __pyx_L7_break; /* "View.MemoryView":1132 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ } } __pyx_L7_break:; /* "View.MemoryView":1136 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1137 * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): * return 'C' # <<<<<<<<<<<<<< * else: * return 'F' */ __pyx_r = 'C'; goto __pyx_L0; /* "View.MemoryView":1136 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ } /* "View.MemoryView":1139 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< * * @cython.cdivision(True) */ /*else*/ { __pyx_r = 'F'; goto __pyx_L0; } /* "View.MemoryView":1118 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1142 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< * char *dst_data, Py_ssize_t *dst_strides, * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, */ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; Py_ssize_t __pyx_v_dst_extent; Py_ssize_t __pyx_v_src_stride; Py_ssize_t __pyx_v_dst_stride; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; /* "View.MemoryView":1149 * * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] */ __pyx_v_src_extent = (__pyx_v_src_shape[0]); /* "View.MemoryView":1150 * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] */ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); /* "View.MemoryView":1151 * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t dst_stride = dst_strides[0] * */ __pyx_v_src_stride = (__pyx_v_src_strides[0]); /* "View.MemoryView":1152 * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< * * if ndim == 1: */ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); /* "View.MemoryView":1154 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): */ __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } /* "View.MemoryView":1156 * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< * memcpy(dst_data, src_data, itemsize * dst_extent) * else: */ __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); if (__pyx_t_2) { __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); } __pyx_t_3 = (__pyx_t_2 != 0); __pyx_t_1 = __pyx_t_3; __pyx_L5_bool_binop_done:; /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ if (__pyx_t_1) { /* "View.MemoryView":1157 * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< * else: * for i in range(dst_extent): */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ goto __pyx_L4; } /* "View.MemoryView":1159 * memcpy(dst_data, src_data, itemsize * dst_extent) * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< * memcpy(dst_data, src_data, itemsize) * src_data += src_stride */ /*else*/ { __pyx_t_4 = __pyx_v_dst_extent; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1160 * else: * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< * src_data += src_stride * dst_data += dst_stride */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); /* "View.MemoryView":1161 * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< * dst_data += dst_stride * else: */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); /* "View.MemoryView":1162 * memcpy(dst_data, src_data, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< * else: * for i in range(dst_extent): */ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); } } __pyx_L4:; /* "View.MemoryView":1154 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): */ goto __pyx_L3; } /* "View.MemoryView":1164 * dst_data += dst_stride * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< * _copy_strided_to_strided(src_data, src_strides + 1, * dst_data, dst_strides + 1, */ /*else*/ { __pyx_t_4 = __pyx_v_dst_extent; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1165 * else: * for i in range(dst_extent): * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< * dst_data, dst_strides + 1, * src_shape + 1, dst_shape + 1, */ _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); /* "View.MemoryView":1169 * src_shape + 1, dst_shape + 1, * ndim - 1, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< * dst_data += dst_stride * */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); /* "View.MemoryView":1170 * ndim - 1, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, */ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); } } __pyx_L3:; /* "View.MemoryView":1142 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< * char *dst_data, Py_ssize_t *dst_strides, * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, */ /* function exit code */ } /* "View.MemoryView":1172 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: */ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { /* "View.MemoryView":1175 * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< * src.shape, dst.shape, ndim, itemsize) * */ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); /* "View.MemoryView":1172 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: */ /* function exit code */ } /* "View.MemoryView":1179 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { Py_ssize_t __pyx_v_shape; Py_ssize_t __pyx_v_size; Py_ssize_t __pyx_r; Py_ssize_t __pyx_t_1; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; /* "View.MemoryView":1181 * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< * * for shape in src.shape[:ndim]: */ __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_size = __pyx_t_1; /* "View.MemoryView":1183 * cdef Py_ssize_t shape, size = src.memview.view.itemsize * * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< * size *= shape * */ __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_shape = (__pyx_t_2[0]); /* "View.MemoryView":1184 * * for shape in src.shape[:ndim]: * size *= shape # <<<<<<<<<<<<<< * * return size */ __pyx_v_size = (__pyx_v_size * __pyx_v_shape); } /* "View.MemoryView":1186 * size *= shape * * return size # <<<<<<<<<<<<<< * * @cname('__pyx_fill_contig_strides_array') */ __pyx_r = __pyx_v_size; goto __pyx_L0; /* "View.MemoryView":1179 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1189 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, * int ndim, char order) nogil: */ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { int __pyx_v_idx; Py_ssize_t __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; /* "View.MemoryView":1198 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ __pyx_t_1 = ((__pyx_v_order == 'F') != 0); if (__pyx_t_1) { /* "View.MemoryView":1199 * * if order == 'F': * for idx in range(ndim): # <<<<<<<<<<<<<< * strides[idx] = stride * stride *= shape[idx] */ __pyx_t_2 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_idx = __pyx_t_4; /* "View.MemoryView":1200 * if order == 'F': * for idx in range(ndim): * strides[idx] = stride # <<<<<<<<<<<<<< * stride *= shape[idx] * else: */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; /* "View.MemoryView":1201 * for idx in range(ndim): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< * else: * for idx in range(ndim - 1, -1, -1): */ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } /* "View.MemoryView":1198 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ goto __pyx_L3; } /* "View.MemoryView":1203 * stride *= shape[idx] * else: * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * strides[idx] = stride * stride *= shape[idx] */ /*else*/ { for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { __pyx_v_idx = __pyx_t_2; /* "View.MemoryView":1204 * else: * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride # <<<<<<<<<<<<<< * stride *= shape[idx] * */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; /* "View.MemoryView":1205 * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< * * return stride */ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } } __pyx_L3:; /* "View.MemoryView":1207 * stride *= shape[idx] * * return stride # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_data_to_temp') */ __pyx_r = __pyx_v_stride; goto __pyx_L0; /* "View.MemoryView":1189 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, * int ndim, char order) nogil: */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1210 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *tmpslice, * char order, */ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { int __pyx_v_i; void *__pyx_v_result; size_t __pyx_v_itemsize; size_t __pyx_v_size; void *__pyx_r; Py_ssize_t __pyx_t_1; int __pyx_t_2; int __pyx_t_3; struct __pyx_memoryview_obj *__pyx_t_4; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":1221 * cdef void *result * * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< * cdef size_t size = slice_get_size(src, ndim) * */ __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":1222 * * cdef size_t itemsize = src.memview.view.itemsize * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< * * result = malloc(size) */ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); /* "View.MemoryView":1224 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< * if not result: * _err(MemoryError, NULL) */ __pyx_v_result = malloc(__pyx_v_size); /* "View.MemoryView":1225 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err(MemoryError, NULL) * */ __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1226 * result = malloc(size) * if not result: * _err(MemoryError, NULL) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) /* "View.MemoryView":1225 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err(MemoryError, NULL) * */ } /* "View.MemoryView":1229 * * * tmpslice.data = result # <<<<<<<<<<<<<< * tmpslice.memview = src.memview * for i in range(ndim): */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); /* "View.MemoryView":1230 * * tmpslice.data = result * tmpslice.memview = src.memview # <<<<<<<<<<<<<< * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] */ __pyx_t_4 = __pyx_v_src->memview; __pyx_v_tmpslice->memview = __pyx_t_4; /* "View.MemoryView":1231 * tmpslice.data = result * tmpslice.memview = src.memview * for i in range(ndim): # <<<<<<<<<<<<<< * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 */ __pyx_t_3 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_3; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1232 * tmpslice.memview = src.memview * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< * tmpslice.suboffsets[i] = -1 * */ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); /* "View.MemoryView":1233 * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, */ (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1235 * tmpslice.suboffsets[i] = -1 * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< * ndim, order) * */ (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); /* "View.MemoryView":1239 * * * for i in range(ndim): # <<<<<<<<<<<<<< * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 */ __pyx_t_3 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_3; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1240 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1241 * for i in range(ndim): * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< * * if slice_is_contig(src[0], order, ndim): */ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; /* "View.MemoryView":1240 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ } } /* "View.MemoryView":1243 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1244 * * if slice_is_contig(src[0], order, ndim): * memcpy(result, src.data, size) # <<<<<<<<<<<<<< * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) */ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); /* "View.MemoryView":1243 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ goto __pyx_L9; } /* "View.MemoryView":1246 * memcpy(result, src.data, size) * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< * * return result */ /*else*/ { copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); } __pyx_L9:; /* "View.MemoryView":1248 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_result; goto __pyx_L0; /* "View.MemoryView":1210 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *tmpslice, * char order, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = NULL; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % */ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_extents", 0); /* "View.MemoryView":1256 * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % * (i, extent1, extent2)) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_dim') */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; /* "View.MemoryView":1255 * cdef int _err_extents(int i, Py_ssize_t extent1, * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< * (i, extent1, extent2)) * */ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 1255, __pyx_L1_error) /* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1259 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii') % dim) * */ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_dim", 0); __Pyx_INCREF(__pyx_v_error); /* "View.MemoryView":1260 * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err') */ __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_INCREF(__pyx_v_error); __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 1260, __pyx_L1_error) /* "View.MemoryView":1259 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii') % dim) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_error); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1263 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< * if msg != NULL: * raise error(msg.decode('ascii')) */ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err", 0); __Pyx_INCREF(__pyx_v_error); /* "View.MemoryView":1264 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii')) * else: */ __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":1265 * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< * else: * raise error */ __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_error); __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 1265, __pyx_L1_error) /* "View.MemoryView":1264 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii')) * else: */ } /* "View.MemoryView":1267 * raise error(msg.decode('ascii')) * else: * raise error # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_contents') */ /*else*/ { __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(1, 1267, __pyx_L1_error) } /* "View.MemoryView":1263 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< * if msg != NULL: * raise error(msg.decode('ascii')) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_error); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1270 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< * __Pyx_memviewslice dst, * int src_ndim, int dst_ndim, */ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { void *__pyx_v_tmpdata; size_t __pyx_v_itemsize; int __pyx_v_i; char __pyx_v_order; int __pyx_v_broadcasting; int __pyx_v_direct_copy; __Pyx_memviewslice __pyx_v_tmp; int __pyx_v_ndim; int __pyx_r; Py_ssize_t __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; void *__pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":1278 * Check for overlapping memory and verify the shapes. * """ * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< * cdef size_t itemsize = src.memview.view.itemsize * cdef int i */ __pyx_v_tmpdata = NULL; /* "View.MemoryView":1279 * """ * cdef void *tmpdata = NULL * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< * cdef int i * cdef char order = get_best_order(&src, src_ndim) */ __pyx_t_1 = __pyx_v_src.memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":1281 * cdef size_t itemsize = src.memview.view.itemsize * cdef int i * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< * cdef bint broadcasting = False * cdef bint direct_copy = False */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); /* "View.MemoryView":1282 * cdef int i * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False # <<<<<<<<<<<<<< * cdef bint direct_copy = False * cdef __Pyx_memviewslice tmp */ __pyx_v_broadcasting = 0; /* "View.MemoryView":1283 * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False * cdef bint direct_copy = False # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice tmp * */ __pyx_v_direct_copy = 0; /* "View.MemoryView":1286 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: */ __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1287 * * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) */ __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); /* "View.MemoryView":1286 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: */ goto __pyx_L3; } /* "View.MemoryView":1288 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&dst, dst_ndim, src_ndim) * */ __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1289 * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< * * cdef int ndim = max(src_ndim, dst_ndim) */ __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); /* "View.MemoryView":1288 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&dst, dst_ndim, src_ndim) * */ } __pyx_L3:; /* "View.MemoryView":1291 * broadcast_leading(&dst, dst_ndim, src_ndim) * * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< * * for i in range(ndim): */ __pyx_t_3 = __pyx_v_dst_ndim; __pyx_t_4 = __pyx_v_src_ndim; if (((__pyx_t_3 > __pyx_t_4) != 0)) { __pyx_t_5 = __pyx_t_3; } else { __pyx_t_5 = __pyx_t_4; } __pyx_v_ndim = __pyx_t_5; /* "View.MemoryView":1293 * cdef int ndim = max(src_ndim, dst_ndim) * * for i in range(ndim): # <<<<<<<<<<<<<< * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: */ __pyx_t_5 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_5; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1294 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< * if src.shape[i] == 1: * broadcasting = True */ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); if (__pyx_t_2) { /* "View.MemoryView":1295 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< * broadcasting = True * src.strides[i] = 0 */ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1296 * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: * broadcasting = True # <<<<<<<<<<<<<< * src.strides[i] = 0 * else: */ __pyx_v_broadcasting = 1; /* "View.MemoryView":1297 * if src.shape[i] == 1: * broadcasting = True * src.strides[i] = 0 # <<<<<<<<<<<<<< * else: * _err_extents(i, dst.shape[i], src.shape[i]) */ (__pyx_v_src.strides[__pyx_v_i]) = 0; /* "View.MemoryView":1295 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< * broadcasting = True * src.strides[i] = 0 */ goto __pyx_L7; } /* "View.MemoryView":1299 * src.strides[i] = 0 * else: * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< * * if src.suboffsets[i] >= 0: */ /*else*/ { __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) } __pyx_L7:; /* "View.MemoryView":1294 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< * if src.shape[i] == 1: * broadcasting = True */ } /* "View.MemoryView":1301 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Dimension %d is not direct", i) * */ __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":1302 * * if src.suboffsets[i] >= 0: * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< * * if slices_overlap(&src, &dst, ndim, itemsize): */ __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) /* "View.MemoryView":1301 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Dimension %d is not direct", i) * */ } } /* "View.MemoryView":1304 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * * if not slice_is_contig(src, order, ndim): */ __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); if (__pyx_t_2) { /* "View.MemoryView":1306 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< * order = get_best_order(&dst, ndim) * */ __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1307 * * if not slice_is_contig(src, order, ndim): * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); /* "View.MemoryView":1306 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< * order = get_best_order(&dst, ndim) * */ } /* "View.MemoryView":1309 * order = get_best_order(&dst, ndim) * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< * src = tmp * */ __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; /* "View.MemoryView":1310 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< * * if not broadcasting: */ __pyx_v_src = __pyx_v_tmp; /* "View.MemoryView":1304 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * * if not slice_is_contig(src, order, ndim): */ } /* "View.MemoryView":1312 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1315 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): */ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1316 * * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); /* "View.MemoryView":1315 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): */ goto __pyx_L12; } /* "View.MemoryView":1317 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'F', ndim) * */ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1318 * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< * * if direct_copy: */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); /* "View.MemoryView":1317 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'F', ndim) * */ } __pyx_L12:; /* "View.MemoryView":1320 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ __pyx_t_2 = (__pyx_v_direct_copy != 0); if (__pyx_t_2) { /* "View.MemoryView":1322 * if direct_copy: * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1323 * * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) */ (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); /* "View.MemoryView":1324 * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * free(tmpdata) * return 0 */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1325 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1326 * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * if order == 'F' == get_best_order(&dst, ndim): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1320 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ } /* "View.MemoryView":1312 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1328 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< * * */ __pyx_t_2 = (__pyx_v_order == 'F'); if (__pyx_t_2) { __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); } __pyx_t_8 = (__pyx_t_2 != 0); if (__pyx_t_8) { /* "View.MemoryView":1331 * * * transpose_memslice(&src) # <<<<<<<<<<<<<< * transpose_memslice(&dst) * */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) /* "View.MemoryView":1332 * * transpose_memslice(&src) * transpose_memslice(&dst) # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) /* "View.MemoryView":1328 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1334 * transpose_memslice(&dst) * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1335 * * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, True) * */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); /* "View.MemoryView":1336 * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * * free(tmpdata) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1338 * refcount_copying(&dst, dtype_is_object, ndim, True) * * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1339 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_broadcast_leading') */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1270 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< * __Pyx_memviewslice dst, * int src_ndim, int dst_ndim, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1342 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) nogil: */ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { int __pyx_v_i; int __pyx_v_offset; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; /* "View.MemoryView":1346 * int ndim_other) nogil: * cdef int i * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< * * for i in range(ndim - 1, -1, -1): */ __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); /* "View.MemoryView":1348 * cdef int offset = ndim_other - ndim * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] */ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":1349 * * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] */ (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); /* "View.MemoryView":1350 * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * */ (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1351 * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< * * for i in range(offset): */ (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); } /* "View.MemoryView":1353 * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * * for i in range(offset): # <<<<<<<<<<<<<< * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] */ __pyx_t_1 = __pyx_v_offset; __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "View.MemoryView":1354 * * for i in range(offset): * mslice.shape[i] = 1 # <<<<<<<<<<<<<< * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 */ (__pyx_v_mslice->shape[__pyx_v_i]) = 1; /* "View.MemoryView":1355 * for i in range(offset): * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< * mslice.suboffsets[i] = -1 * */ (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); /* "View.MemoryView":1356 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * * */ (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1342 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) nogil: */ /* function exit code */ } /* "View.MemoryView":1364 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< * int ndim, bint inc) nogil: * */ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { int __pyx_t_1; /* "View.MemoryView":1368 * * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, * dst.strides, ndim, inc) */ __pyx_t_1 = (__pyx_v_dtype_is_object != 0); if (__pyx_t_1) { /* "View.MemoryView":1369 * * if dtype_is_object: * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< * dst.strides, ndim, inc) * */ __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); /* "View.MemoryView":1368 * * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, * dst.strides, ndim, inc) */ } /* "View.MemoryView":1364 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< * int ndim, bint inc) nogil: * */ /* function exit code */ } /* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * bint inc) with gil: */ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { __Pyx_RefNannyDeclarations #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); /* "View.MemoryView":1376 * Py_ssize_t *strides, int ndim, * bint inc) with gil: * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_refcount_objects_in_slice') */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); /* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * bint inc) with gil: */ /* function exit code */ __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "View.MemoryView":1379 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, bint inc): * cdef Py_ssize_t i */ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); /* "View.MemoryView":1383 * cdef Py_ssize_t i * * for i in range(shape[0]): # <<<<<<<<<<<<<< * if ndim == 1: * if inc: */ __pyx_t_1 = (__pyx_v_shape[0]); __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "View.MemoryView":1384 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_4) { /* "View.MemoryView":1385 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ __pyx_t_4 = (__pyx_v_inc != 0); if (__pyx_t_4) { /* "View.MemoryView":1386 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< * else: * Py_DECREF(( data)[0]) */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); /* "View.MemoryView":1385 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ goto __pyx_L6; } /* "View.MemoryView":1388 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, */ /*else*/ { Py_DECREF((((PyObject **)__pyx_v_data)[0])); } __pyx_L6:; /* "View.MemoryView":1384 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ goto __pyx_L5; } /* "View.MemoryView":1390 * Py_DECREF(( data)[0]) * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< * ndim - 1, inc) * */ /*else*/ { /* "View.MemoryView":1391 * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, * ndim - 1, inc) # <<<<<<<<<<<<<< * * data += strides[0] */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); } __pyx_L5:; /* "View.MemoryView":1393 * ndim - 1, inc) * * data += strides[0] # <<<<<<<<<<<<<< * * */ __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); } /* "View.MemoryView":1379 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, bint inc): * cdef Py_ssize_t i */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":1399 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< * size_t itemsize, void *item, * bint dtype_is_object) nogil: */ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { /* "View.MemoryView":1402 * size_t itemsize, void *item, * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1403 * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) */ __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); /* "View.MemoryView":1405 * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * * */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1399 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< * size_t itemsize, void *item, * bint dtype_is_object) nogil: */ /* function exit code */ } /* "View.MemoryView":1409 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * size_t itemsize, void *item) nogil: */ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_stride; Py_ssize_t __pyx_v_extent; int __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; /* "View.MemoryView":1413 * size_t itemsize, void *item) nogil: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t extent = shape[0] * */ __pyx_v_stride = (__pyx_v_strides[0]); /* "View.MemoryView":1414 * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< * * if ndim == 1: */ __pyx_v_extent = (__pyx_v_shape[0]); /* "View.MemoryView":1416 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< * for i in range(extent): * memcpy(data, item, itemsize) */ __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":1417 * * if ndim == 1: * for i in range(extent): # <<<<<<<<<<<<<< * memcpy(data, item, itemsize) * data += stride */ __pyx_t_2 = __pyx_v_extent; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1418 * if ndim == 1: * for i in range(extent): * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< * data += stride * else: */ (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); /* "View.MemoryView":1419 * for i in range(extent): * memcpy(data, item, itemsize) * data += stride # <<<<<<<<<<<<<< * else: * for i in range(extent): */ __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } /* "View.MemoryView":1416 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< * for i in range(extent): * memcpy(data, item, itemsize) */ goto __pyx_L3; } /* "View.MemoryView":1421 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) */ /*else*/ { __pyx_t_2 = __pyx_v_extent; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1422 * else: * for i in range(extent): * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< * ndim - 1, itemsize, item) * data += stride */ __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); /* "View.MemoryView":1424 * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) * data += stride # <<<<<<<<<<<<<< * * */ __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } } __pyx_L3:; /* "View.MemoryView":1409 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * size_t itemsize, void *item) nogil: */ /* function exit code */ } /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__24, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[1]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->name); __Pyx_DECREF(__pyx_v___pyx_result->name); __pyx_v___pyx_result->name = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[1]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_3 > 1) != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[1]) */ } /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_array __pyx_vtable_array; static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_array_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_array_obj *)o); p->__pyx_vtab = __pyx_vtabptr_array; p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_array(PyObject *o) { struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_array___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->mode); Py_CLEAR(p->_format); (*Py_TYPE(o)->tp_free)(o); } static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_array___setitem__(o, i, v); } else { PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); return -1; } } static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); v = __pyx_array___getattr__(o, n); } return v; } static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); } static PyMethodDef __pyx_methods_array[] = { {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_array[] = { {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_array = { __pyx_array___len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_array, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_array = { __pyx_array___len__, /*mp_length*/ __pyx_array___getitem__, /*mp_subscript*/ __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ }; static PyBufferProcs __pyx_tp_as_buffer_array = { #if PY_MAJOR_VERSION < 3 0, /*bf_getreadbuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getwritebuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getsegcount*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getcharbuffer*/ #endif __pyx_array_getbuffer, /*bf_getbuffer*/ 0, /*bf_releasebuffer*/ }; static PyTypeObject __pyx_type___pyx_array = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.distance._cutils.array", /*tp_name*/ sizeof(struct __pyx_array_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_array, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ __pyx_tp_getattro_array, /*tp_getattro*/ 0, /*tp_setattro*/ &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_array, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_array, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_array, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_MemviewEnum_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_MemviewEnum_obj *)o); p->name = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_Enum(PyObject *o) { struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->name); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { int e; struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; if (p->name) { e = (*v)(p->name, a); if (e) return e; } return 0; } static int __pyx_tp_clear_Enum(PyObject *o) { PyObject* tmp; struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; tmp = ((PyObject*)p->name); p->name = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_Enum[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type___pyx_MemviewEnum = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.distance._cutils.Enum", /*tp_name*/ sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_Enum, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_MemviewEnum___repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_Enum, /*tp_traverse*/ __pyx_tp_clear_Enum, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_Enum, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_MemviewEnum___init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_Enum, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_memoryview_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_memoryview_obj *)o); p->__pyx_vtab = __pyx_vtabptr_memoryview; p->obj = Py_None; Py_INCREF(Py_None); p->_size = Py_None; Py_INCREF(Py_None); p->_array_interface = Py_None; Py_INCREF(Py_None); p->view.obj = NULL; if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_memoryview(PyObject *o) { struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_memoryview___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->obj); Py_CLEAR(p->_size); Py_CLEAR(p->_array_interface); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { int e; struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; if (p->obj) { e = (*v)(p->obj, a); if (e) return e; } if (p->_size) { e = (*v)(p->_size, a); if (e) return e; } if (p->_array_interface) { e = (*v)(p->_array_interface, a); if (e) return e; } if (p->view.obj) { e = (*v)(p->view.obj, a); if (e) return e; } return 0; } static int __pyx_tp_clear_memoryview(PyObject *o) { PyObject* tmp; struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; tmp = ((PyObject*)p->obj); p->obj = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_size); p->_size = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_array_interface); p->_array_interface = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); Py_CLEAR(p->view.obj); return 0; } static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_memoryview___setitem__(o, i, v); } else { PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); return -1; } } static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); } static PyMethodDef __pyx_methods_memoryview[] = { {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_memoryview[] = { {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_memoryview = { __pyx_memoryview___len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_memoryview, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_memoryview = { __pyx_memoryview___len__, /*mp_length*/ __pyx_memoryview___getitem__, /*mp_subscript*/ __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ }; static PyBufferProcs __pyx_tp_as_buffer_memoryview = { #if PY_MAJOR_VERSION < 3 0, /*bf_getreadbuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getwritebuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getsegcount*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getcharbuffer*/ #endif __pyx_memoryview_getbuffer, /*bf_getbuffer*/ 0, /*bf_releasebuffer*/ }; static PyTypeObject __pyx_type___pyx_memoryview = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.distance._cutils.memoryview", /*tp_name*/ sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_memoryview___repr__, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_memoryview___str__, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_memoryview, /*tp_traverse*/ __pyx_tp_clear_memoryview, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_memoryview, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_memoryview, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_memoryview, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_memoryviewslice_obj *p; PyObject *o = __pyx_tp_new_memoryview(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_memoryviewslice_obj *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; p->from_object = Py_None; Py_INCREF(Py_None); p->from_slice.memview = NULL; return o; } static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_memoryviewslice___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->from_object); PyObject_GC_Track(o); __pyx_tp_dealloc_memoryview(o); } static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { int e; struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; if (p->from_object) { e = (*v)(p->from_object, a); if (e) return e; } return 0; } static int __pyx_tp_clear__memoryviewslice(PyObject *o) { PyObject* tmp; struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; __pyx_tp_clear_memoryview(o); tmp = ((PyObject*)p->from_object); p->from_object = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); __PYX_XDEC_MEMVIEW(&p->from_slice, 1); return 0; } static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); } static PyMethodDef __pyx_methods__memoryviewslice[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type___pyx_memoryviewslice = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.distance._cutils._memoryviewslice", /*tp_name*/ sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_memoryview___repr__, /*tp_repr*/ #else 0, /*tp_repr*/ #endif 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ #if CYTHON_COMPILING_IN_PYPY __pyx_memoryview___str__, /*tp_str*/ #else 0, /*tp_str*/ #endif 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "Internal class for passing memoryview slices to Python", /*tp_doc*/ __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ __pyx_tp_clear__memoryviewslice, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods__memoryviewslice, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets__memoryviewslice, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new__memoryviewslice, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__cutils(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__cutils}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_cutils", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, {&__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_k_Expected_at_least_d_argument_s_g, sizeof(__pyx_k_Expected_at_least_d_argument_s_g), 0, 0, 1, 0}, {&__pyx_kp_s_Function_call_with_ambiguous_arg, __pyx_k_Function_call_with_ambiguous_arg, sizeof(__pyx_k_Function_call_with_ambiguous_arg), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, {&__pyx_kp_s_No_matching_signature_found, __pyx_k_No_matching_signature_found, sizeof(__pyx_k_No_matching_signature_found), 0, 0, 1, 0}, {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1}, {&__pyx_n_s_coli, __pyx_k_coli, sizeof(__pyx_k_coli), 0, 0, 1, 1}, {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_distance_matrix, __pyx_k_distance_matrix, sizeof(__pyx_k_distance_matrix), 0, 0, 1, 1}, {&__pyx_n_s_distmat_reorder_condensed_cy, __pyx_k_distmat_reorder_condensed_cy, sizeof(__pyx_k_distmat_reorder_condensed_cy), 0, 0, 1, 1}, {&__pyx_n_s_distmat_reorder_cy, __pyx_k_distmat_reorder_cy, sizeof(__pyx_k_distmat_reorder_cy), 0, 0, 1, 1}, {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, {&__pyx_n_s_group_idx, __pyx_k_group_idx, sizeof(__pyx_k_group_idx), 0, 0, 1, 1}, {&__pyx_n_s_group_sizes, __pyx_k_group_sizes, sizeof(__pyx_k_group_sizes), 0, 0, 1, 1}, {&__pyx_n_s_grouping, __pyx_k_grouping, sizeof(__pyx_k_grouping), 0, 0, 1, 1}, {&__pyx_n_s_icol, __pyx_k_icol, sizeof(__pyx_k_icol), 0, 0, 1, 1}, {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_in2, __pyx_k_in2, sizeof(__pyx_k_in2), 0, 0, 1, 1}, {&__pyx_n_s_in3, __pyx_k_in3, sizeof(__pyx_k_in3), 0, 0, 1, 1}, {&__pyx_n_s_in_mat, __pyx_k_in_mat, sizeof(__pyx_k_in_mat), 0, 0, 1, 1}, {&__pyx_n_s_in_n, __pyx_k_in_n, sizeof(__pyx_k_in_n), 0, 0, 1, 1}, {&__pyx_n_s_is_hollow, __pyx_k_is_hollow, sizeof(__pyx_k_is_hollow), 0, 0, 1, 1}, {&__pyx_n_s_is_sym, __pyx_k_is_sym, sizeof(__pyx_k_is_sym), 0, 0, 1, 1}, {&__pyx_n_s_is_symmetric_and_hollow_cy, __pyx_k_is_symmetric_and_hollow_cy, sizeof(__pyx_k_is_symmetric_and_hollow_cy), 0, 0, 1, 1}, {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, {&__pyx_n_s_local_s_W, __pyx_k_local_s_W, sizeof(__pyx_k_local_s_W), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mantel_perm_pearsonr_cy, __pyx_k_mantel_perm_pearsonr_cy, sizeof(__pyx_k_mantel_perm_pearsonr_cy), 0, 0, 1, 1}, {&__pyx_n_s_mat, __pyx_k_mat, sizeof(__pyx_k_mat), 0, 0, 1, 1}, {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, {&__pyx_n_s_mul, __pyx_k_mul, sizeof(__pyx_k_mul), 0, 0, 1, 1}, {&__pyx_n_s_my_ps, __pyx_k_my_ps, sizeof(__pyx_k_my_ps), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_normxm, __pyx_k_normxm, sizeof(__pyx_k_normxm), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_on2, __pyx_k_on2, sizeof(__pyx_k_on2), 0, 0, 1, 1}, {&__pyx_n_s_on3, __pyx_k_on3, sizeof(__pyx_k_on3), 0, 0, 1, 1}, {&__pyx_n_s_out_mat, __pyx_k_out_mat, sizeof(__pyx_k_out_mat), 0, 0, 1, 1}, {&__pyx_n_s_out_mat_condensed, __pyx_k_out_mat_condensed, sizeof(__pyx_k_out_mat_condensed), 0, 0, 1, 1}, {&__pyx_n_s_out_n, __pyx_k_out_n, sizeof(__pyx_k_out_n), 0, 0, 1, 1}, {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, {&__pyx_n_s_perm_order, __pyx_k_perm_order, sizeof(__pyx_k_perm_order), 0, 0, 1, 1}, {&__pyx_n_s_permanova_f_stat_sW_cy, __pyx_k_permanova_f_stat_sW_cy, sizeof(__pyx_k_permanova_f_stat_sW_cy), 0, 0, 1, 1}, {&__pyx_n_s_perms_n, __pyx_k_perms_n, sizeof(__pyx_k_perms_n), 0, 0, 1, 1}, {&__pyx_n_s_permuted_stats, __pyx_k_permuted_stats, sizeof(__pyx_k_permuted_stats), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_reorder_vec, __pyx_k_reorder_vec, sizeof(__pyx_k_reorder_vec), 0, 0, 1, 1}, {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, {&__pyx_n_s_rowi, __pyx_k_rowi, sizeof(__pyx_k_rowi), 0, 0, 1, 1}, {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, {&__pyx_n_s_s_W, __pyx_k_s_W, sizeof(__pyx_k_s_W), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, {&__pyx_n_s_signatures, __pyx_k_signatures, sizeof(__pyx_k_signatures), 0, 0, 1, 1}, {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, {&__pyx_n_s_skbio_stats_distance__cutils, __pyx_k_skbio_stats_distance__cutils, sizeof(__pyx_k_skbio_stats_distance__cutils), 0, 0, 1, 1}, {&__pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_k_skbio_stats_distance__cutils_pyx, sizeof(__pyx_k_skbio_stats_distance__cutils_pyx), 0, 0, 1, 0}, {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1}, {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, {&__pyx_n_s_tcol, __pyx_k_tcol, sizeof(__pyx_k_tcol), 0, 0, 1, 1}, {&__pyx_n_s_tcol_max, __pyx_k_tcol_max, sizeof(__pyx_k_tcol_max), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_testval, __pyx_k_testval, sizeof(__pyx_k_testval), 0, 0, 1, 1}, {&__pyx_n_s_trow, __pyx_k_trow, sizeof(__pyx_k_trow), 0, 0, 1, 1}, {&__pyx_n_s_trow_max, __pyx_k_trow_max, sizeof(__pyx_k_trow_max), 0, 0, 1, 1}, {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_val, __pyx_k_val, sizeof(__pyx_k_val), 0, 0, 1, 1}, {&__pyx_n_s_vrow, __pyx_k_vrow, sizeof(__pyx_k_vrow), 0, 0, 1, 1}, {&__pyx_n_s_x_data, __pyx_k_x_data, sizeof(__pyx_k_x_data), 0, 0, 1, 1}, {&__pyx_n_s_xmean, __pyx_k_xmean, sizeof(__pyx_k_xmean), 0, 0, 1, 1}, {&__pyx_n_s_xval, __pyx_k_xval, sizeof(__pyx_k_xval), 0, 0, 1, 1}, {&__pyx_n_s_y_n, __pyx_k_y_n, sizeof(__pyx_k_y_n), 0, 0, 1, 1}, {&__pyx_n_s_ym_normalized, __pyx_k_ym_normalized, sizeof(__pyx_k_ym_normalized), 0, 0, 1, 1}, {&__pyx_n_s_yval, __pyx_k_yval, sizeof(__pyx_k_yval), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_No_matching_signature_found); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Function_call_with_ambiguous_arg); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "View.MemoryView":134 * * if not self.ndim: * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< * * if itemsize <= 0: */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "View.MemoryView":137 * * if itemsize <= 0: * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< * * if not isinstance(format, bytes): */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "View.MemoryView":149 * * if not self._shape: * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< * * */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "View.MemoryView":177 * self.data = malloc(self.len) * if not self.data: * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< * * if self.dtype_is_object: */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "View.MemoryView":193 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< * info.buf = self.data * info.len = self.len */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "View.MemoryView":420 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "View.MemoryView":497 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "View.MemoryView":522 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "View.MemoryView":572 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "View.MemoryView":579 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __pyx_tuple__17 = PyTuple_New(1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); PyTuple_SET_ITEM(__pyx_tuple__17, 0, __pyx_int_neg_1); __Pyx_GIVEREF(__pyx_tuple__17); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); /* "View.MemoryView":684 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__20); __Pyx_GIVEREF(__pyx_slice__20); /* "View.MemoryView":705 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); __pyx_tuple__24 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ __pyx_tuple__25 = PyTuple_Pack(13, __pyx_n_s_mat, __pyx_n_s_mat, __pyx_n_s_in_n, __pyx_n_s_in2, __pyx_n_s_trow, __pyx_n_s_tcol, __pyx_n_s_trow_max, __pyx_n_s_tcol_max, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_testval, __pyx_n_s_is_sym, __pyx_n_s_is_hollow); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_n_s_is_symmetric_and_hollow_cy, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 19, __pyx_L1_error) /* "skbio/stats/distance/_cutils.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[:, ::1] out_mat): * """ */ __pyx_tuple__27 = PyTuple_Pack(11, __pyx_n_s_in_mat, __pyx_n_s_reorder_vec, __pyx_n_s_out_mat, __pyx_n_s_in_n, __pyx_n_s_in2, __pyx_n_s_out_n, __pyx_n_s_on2, __pyx_n_s_on3, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_vrow); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_n_s_distmat_reorder_cy, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 68, __pyx_L1_error) /* "skbio/stats/distance/_cutils.pyx":120 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[::1] out_mat_condensed): * """ */ __pyx_tuple__29 = PyTuple_Pack(11, __pyx_n_s_in_mat, __pyx_n_s_reorder_vec, __pyx_n_s_out_mat_condensed, __pyx_n_s_in_n, __pyx_n_s_in2, __pyx_n_s_out_n, __pyx_n_s_on2, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_vrow, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_n_s_distmat_reorder_condensed_cy, 120, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 120, __pyx_L1_error) /* "skbio/stats/distance/_cutils.pyx":170 * @cython.boundscheck(False) * @cython.wraparound(False) * def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, # <<<<<<<<<<<<<< * TReal xmean, TReal normxm, * TReal[::1] ym_normalized, */ __pyx_tuple__31 = PyTuple_Pack(23, __pyx_n_s_x_data, __pyx_n_s_perm_order, __pyx_n_s_xmean, __pyx_n_s_normxm, __pyx_n_s_ym_normalized, __pyx_n_s_permuted_stats, __pyx_n_s_in_n, __pyx_n_s_in2, __pyx_n_s_perms_n, __pyx_n_s_out_n, __pyx_n_s_y_n, __pyx_n_s_on2, __pyx_n_s_p, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_icol, __pyx_n_s_vrow, __pyx_n_s_idx, __pyx_n_s_mul, __pyx_n_s_add, __pyx_n_s_my_ps, __pyx_n_s_yval, __pyx_n_s_xval); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(6, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_n_s_mantel_perm_pearsonr_cy, 170, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 170, __pyx_L1_error) /* "skbio/stats/distance/_cutils.pyx":252 * @cython.boundscheck(False) * @cython.wraparound(False) * def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, # <<<<<<<<<<<<<< * Py_ssize_t[::1] group_sizes, * Py_ssize_t[::1] grouping): */ __pyx_tuple__33 = PyTuple_Pack(14, __pyx_n_s_distance_matrix, __pyx_n_s_group_sizes, __pyx_n_s_grouping, __pyx_n_s_in_n, __pyx_n_s_in2, __pyx_n_s_in3, __pyx_n_s_s_W, __pyx_n_s_group_idx, __pyx_n_s_local_s_W, __pyx_n_s_val, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_rowi, __pyx_n_s_coli); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(3, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_distance__cutils_pyx, __pyx_n_s_permanova_f_stat_sW_cy, 252, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 252, __pyx_L1_error) /* "View.MemoryView":287 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "View.MemoryView":288 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(1, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "View.MemoryView":289 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(1, 289, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "View.MemoryView":292 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(1, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "View.MemoryView":293 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__40 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { /* InitThreads.init */ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 PyEval_InitThreads(); #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ generic = Py_None; Py_INCREF(Py_None); strided = Py_None; Py_INCREF(Py_None); indirect = Py_None; Py_INCREF(Py_None); contiguous = Py_None; Py_INCREF(Py_None); indirect_contiguous = Py_None; Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_array = &__pyx_vtable_array; __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_array.tp_print = 0; #endif if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) __pyx_array_type = &__pyx_type___pyx_array; if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_MemviewEnum.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_memoryview.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) __pyx_memoryview_type = &__pyx_type___pyx_memoryview; __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_memoryviewslice.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_cutils(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_cutils(void) #else __Pyx_PyMODINIT_FUNC PyInit__cutils(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__cutils(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__cutils(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; static PyThread_type_lock __pyx_t_3[8]; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_cutils' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__cutils(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_cutils", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__stats__distance___cutils) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.stats.distance._cutils")) { if (unlikely(PyDict_SetItemString(modules, "skbio.stats.distance._cutils", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "skbio/stats/distance/_cutils.pyx":9 * # ----------------------------------------------------------------------------- * * import numpy as np # <<<<<<<<<<<<<< * cimport cython * from cython.parallel import prange */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/distance/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): # <<<<<<<<<<<<<< * """ * Check if mat is symmetric and hollow. */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_11is_symmetric_and_hollow_cy, 0, __pyx_n_s_is_symmetric_and_hollow_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_13is_symmetric_and_hollow_cy, 0, __pyx_n_s_is_symmetric_and_hollow_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_8distance_7_cutils_1is_symmetric_and_hollow_cy, 0, __pyx_n_s_is_symmetric_and_hollow_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_symmetric_and_hollow_cy, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/stats/distance/_cutils.pyx":68 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[:, ::1] out_mat): * """ */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_17distmat_reorder_cy, 0, __pyx_n_s_distmat_reorder_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_float, __pyx_t_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_19distmat_reorder_cy, 0, __pyx_n_s_distmat_reorder_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_double, __pyx_t_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_8distance_7_cutils_3distmat_reorder_cy, 0, __pyx_n_s_distmat_reorder_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_1)->__signatures__ = __pyx_t_2; __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_distmat_reorder_cy, __pyx_t_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/distance/_cutils.pyx":120 * @cython.boundscheck(False) * @cython.wraparound(False) * def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, # <<<<<<<<<<<<<< * TReal[::1] out_mat_condensed): * """ */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_23distmat_reorder_condensed_cy, 0, __pyx_n_s_distmat_reorder_condensed_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_25distmat_reorder_condensed_cy, 0, __pyx_n_s_distmat_reorder_condensed_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_8distance_7_cutils_5distmat_reorder_condensed_cy, 0, __pyx_n_s_distmat_reorder_condensed_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_distmat_reorder_condensed_cy, __pyx_t_2) < 0) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/stats/distance/_cutils.pyx":170 * @cython.boundscheck(False) * @cython.wraparound(False) * def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, # <<<<<<<<<<<<<< * TReal xmean, TReal normxm, * TReal[::1] ym_normalized, */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_29mantel_perm_pearsonr_cy, 0, __pyx_n_s_mantel_perm_pearsonr_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_float, __pyx_t_1) < 0) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_31mantel_perm_pearsonr_cy, 0, __pyx_n_s_mantel_perm_pearsonr_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_double, __pyx_t_1) < 0) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_8distance_7_cutils_7mantel_perm_pearsonr_cy, 0, __pyx_n_s_mantel_perm_pearsonr_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_1)->__signatures__ = __pyx_t_2; __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_mantel_perm_pearsonr_cy, __pyx_t_1) < 0) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/distance/_cutils.pyx":252 * @cython.boundscheck(False) * @cython.wraparound(False) * def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, # <<<<<<<<<<<<<< * Py_ssize_t[::1] group_sizes, * Py_ssize_t[::1] grouping): */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_8distance_7_cutils_35permanova_f_stat_sW_cy, 0, __pyx_n_s_permanova_f_stat_sW_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_8distance_7_cutils_37permanova_f_stat_sW_cy, 0, __pyx_n_s_permanova_f_stat_sW_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_8distance_7_cutils_9permanova_f_stat_sW_cy, 0, __pyx_n_s_permanova_f_stat_sW_cy, NULL, __pyx_n_s_skbio_stats_distance__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_permanova_f_stat_sW_cy, __pyx_t_2) < 0) __PYX_ERR(0, 252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/stats/distance/_cutils.pyx":1 * # ----------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # Copyright (c) 2021-2021, scikit-bio development team. * # */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":210 * info.obj = self * * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * def __dealloc__(array self): */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_array_type); /* "View.MemoryView":287 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":288 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":289 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":292 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":293 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":317 * * DEF THREAD_LOCKS_PREALLOCATED = 8 * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ * PyThread_allocate_lock(), */ __pyx_memoryview_thread_locks_used = 0; /* "View.MemoryView":318 * DEF THREAD_LOCKS_PREALLOCATED = 8 * cdef int __pyx_memoryview_thread_locks_used = 0 * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< * PyThread_allocate_lock(), * PyThread_allocate_lock(), */ __pyx_t_3[0] = PyThread_allocate_lock(); __pyx_t_3[1] = PyThread_allocate_lock(); __pyx_t_3[2] = PyThread_allocate_lock(); __pyx_t_3[3] = PyThread_allocate_lock(); __pyx_t_3[4] = PyThread_allocate_lock(); __pyx_t_3[5] = PyThread_allocate_lock(); __pyx_t_3[6] = PyThread_allocate_lock(); __pyx_t_3[7] = PyThread_allocate_lock(); memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); /* "View.MemoryView":551 * info.obj = self * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 551, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_memoryview_type); /* "View.MemoryView":997 * return self.from_object * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 997, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_memoryviewslice_type); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.stats.distance._cutils", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.stats.distance._cutils"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* UnicodeAsUCS4 */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { Py_ssize_t length; #if CYTHON_PEP393_ENABLED length = PyUnicode_GET_LENGTH(x); if (likely(length == 1)) { return PyUnicode_READ_CHAR(x, 0); } #else length = PyUnicode_GET_SIZE(x); if (likely(length == 1)) { return PyUnicode_AS_UNICODE(x)[0]; } #if Py_UNICODE_SIZE == 2 else if (PyUnicode_GET_SIZE(x) == 2) { Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; if (high_val >= 0xD800 && high_val <= 0xDBFF) { Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; if (low_val >= 0xDC00 && low_val <= 0xDFFF) { return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); } } } #endif #endif PyErr_Format(PyExc_ValueError, "only single character unicode strings can be converted to Py_UCS4, " "got length %" CYTHON_FORMAT_SSIZE_T "d", length); return (Py_UCS4)-1; } /* object_ord */ static long __Pyx__PyObject_Ord(PyObject* c) { Py_ssize_t size; if (PyBytes_Check(c)) { size = PyBytes_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyBytes_AS_STRING(c)[0]; } #if PY_MAJOR_VERSION < 3 } else if (PyUnicode_Check(c)) { return (long)__Pyx_PyUnicode_AsPy_UCS4(c); #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) } else if (PyByteArray_Check(c)) { size = PyByteArray_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyByteArray_AS_STRING(c)[0]; } #endif } else { PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but %.200s found", Py_TYPE(c)->tp_name); return (long)(Py_UCS4)-1; } PyErr_Format(PyExc_TypeError, "ord() expected a character, but string of length %zd found", size); return (long)(Py_UCS4)-1; } /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (!j) return -1; r = PyObject_SetItem(o, j, v); Py_DECREF(j); return r; } static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { PyObject* old = PyList_GET_ITEM(o, n); Py_INCREF(v); PyList_SET_ITEM(o, n, v); Py_DECREF(old); return 1; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_ass_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return -1; PyErr_Clear(); } } return m->sq_ass_item(o, i, v); } } #else #if CYTHON_COMPILING_IN_PYPY if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) #else if (is_list || PySequence_Check(o)) #endif { return PySequence_SetItem(o, i, v); } #endif return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* MemviewSliceInit */ static int __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, int ndim, __Pyx_memviewslice *memviewslice, int memview_is_new_reference) { __Pyx_RefNannyDeclarations int i, retval=-1; Py_buffer *buf = &memview->view; __Pyx_RefNannySetupContext("init_memviewslice", 0); if (unlikely(memviewslice->memview || memviewslice->data)) { PyErr_SetString(PyExc_ValueError, "memviewslice is already initialized!"); goto fail; } if (buf->strides) { for (i = 0; i < ndim; i++) { memviewslice->strides[i] = buf->strides[i]; } } else { Py_ssize_t stride = buf->itemsize; for (i = ndim - 1; i >= 0; i--) { memviewslice->strides[i] = stride; stride *= buf->shape[i]; } } for (i = 0; i < ndim; i++) { memviewslice->shape[i] = buf->shape[i]; if (buf->suboffsets) { memviewslice->suboffsets[i] = buf->suboffsets[i]; } else { memviewslice->suboffsets[i] = -1; } } memviewslice->memview = memview; memviewslice->data = (char *)buf->buf; if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { Py_INCREF(memview); } retval = 0; goto no_fail; fail: memviewslice->memview = 0; memviewslice->data = 0; retval = -1; no_fail: __Pyx_RefNannyFinishContext(); return retval; } #ifndef Py_NO_RETURN #define Py_NO_RETURN #endif static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { va_list vargs; char msg[200]; #if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) va_start(vargs, fmt); #else va_start(vargs); #endif vsnprintf(msg, 200, fmt, vargs); va_end(vargs); Py_FatalError(msg); } static CYTHON_INLINE int __pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, PyThread_type_lock lock) { int result; PyThread_acquire_lock(lock, 1); result = (*acquisition_count)++; PyThread_release_lock(lock); return result; } static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, PyThread_type_lock lock) { int result; PyThread_acquire_lock(lock, 1); result = (*acquisition_count)--; PyThread_release_lock(lock); return result; } static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int first_time; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) return; if (unlikely(__pyx_get_slice_count(memview) < 0)) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); first_time = __pyx_add_acquisition_count(memview) == 0; if (unlikely(first_time)) { if (have_gil) { Py_INCREF((PyObject *) memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_INCREF((PyObject *) memview); PyGILState_Release(_gilstate); } } } static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int last_time; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) { memslice->memview = NULL; return; } if (unlikely(__pyx_get_slice_count(memview) <= 0)) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); last_time = __pyx_sub_acquisition_count(memview) == 1; memslice->data = NULL; if (unlikely(last_time)) { if (have_gil) { Py_CLEAR(memslice->memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_CLEAR(memslice->memview); PyGILState_Release(_gilstate); } } else { memslice->memview = NULL; } } /* DivInt[Py_ssize_t] */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { Py_ssize_t q = a / b; Py_ssize_t r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); return q; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; if (unlikely(!(m && m->sq_item))) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; } key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; if (likely(m && m->mp_subscript)) { return m->mp_subscript(obj, key); } return __Pyx_PyObject_GetIndex(obj, key); } #endif /* decode_c_string */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { size_t slen = strlen(cstring); if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "c-string too long to convert to Python"); return NULL; } length = (Py_ssize_t) slen; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } if (unlikely(stop <= start)) return __Pyx_NewRef(__pyx_empty_unicode); length = stop - start; cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* None */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* DivInt[long] */ static CYTHON_INLINE long __Pyx_div_long(long a, long b) { long q = a / b; long r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); return q; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* FetchCommonType */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CythonFunctionShared */ #include static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) { if (unlikely(op->func_doc == NULL)) { if (op->func.m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); #else op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp = op->func_doc; if (value == NULL) { value = Py_None; } Py_INCREF(value); op->func_doc = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_name == NULL)) { #if PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); #else op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = op->func_name; Py_INCREF(value); op->func_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->func_qualname; Py_INCREF(value); op->func_qualname = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) { PyObject *self; self = m->func_closure; if (self == NULL) self = Py_None; Py_INCREF(self); return self; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } tmp = op->func_dict; Py_INCREF(value); op->func_dict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyTuple_Check(value)) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } Py_INCREF(value); tmp = op->defaults_tuple; op->defaults_tuple = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } Py_INCREF(value); tmp = op->defaults_kwdict; op->defaults_kwdict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value || value == Py_None) { value = NULL; } else if (!PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); tmp = op->func_annotations; op->func_annotations = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) { #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else return PyString_FromString(m->func.m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { if (unlikely(op == NULL)) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; op->func_classobj = NULL; op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); Py_CLEAR(m->func.m_module); Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); Py_CLEAR(m->func_classobj); Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyObject_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); Py_VISIT(m->func.m_module); Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); Py_VISIT(m->func_classobj); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { #if PY_MAJOR_VERSION < 3 __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); return func; } if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { if (type == NULL) type = (PyObject *)(Py_TYPE(obj)); return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); } if (obj == Py_None) obj = NULL; #endif return __Pyx_PyMethod_New(func, obj, type); } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; Py_ssize_t size; switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 0)) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "__Pyx_CyFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; argc = PyTuple_GET_SIZE(args); new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_CallAsMethod, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_CyFunction_descr_get, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, #endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (unlikely(__pyx_CyFunctionType == NULL)) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_Malloc(size); if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* FusedFunction */ static PyObject * __pyx_FusedFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject *code) { PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(__pyx_CyFunctionObject, __pyx_FusedFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { __pyx_FusedFunctionObject *fusedfunc = (__pyx_FusedFunctionObject *) op; fusedfunc->__signatures__ = NULL; fusedfunc->type = NULL; fusedfunc->self = NULL; PyObject_GC_Track(op); } return op; } static void __pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self) { PyObject_GC_UnTrack(self); Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); __Pyx__CyFunction_dealloc((__pyx_CyFunctionObject *) self); } static int __pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self, visitproc visit, void *arg) { Py_VISIT(self->self); Py_VISIT(self->type); Py_VISIT(self->__signatures__); return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg); } static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self) { Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self); } static PyObject * __pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type) { __pyx_FusedFunctionObject *func, *meth; func = (__pyx_FusedFunctionObject *) self; if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(self); return self; } if (obj == Py_None) obj = NULL; meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_New( ((PyCFunctionObject *) func)->m_ml, ((__pyx_CyFunctionObject *) func)->flags, ((__pyx_CyFunctionObject *) func)->func_qualname, ((__pyx_CyFunctionObject *) func)->func_closure, ((PyCFunctionObject *) func)->m_module, ((__pyx_CyFunctionObject *) func)->func_globals, ((__pyx_CyFunctionObject *) func)->func_code); if (!meth) return NULL; if (func->func.defaults) { PyObject **pydefaults; int i; if (!__Pyx_CyFunction_InitDefaults((PyObject*)meth, func->func.defaults_size, func->func.defaults_pyobjects)) { Py_XDECREF((PyObject*)meth); return NULL; } memcpy(meth->func.defaults, func->func.defaults, func->func.defaults_size); pydefaults = __Pyx_CyFunction_Defaults(PyObject *, meth); for (i = 0; i < meth->func.defaults_pyobjects; i++) Py_XINCREF(pydefaults[i]); } Py_XINCREF(func->func.func_classobj); meth->func.func_classobj = func->func.func_classobj; Py_XINCREF(func->__signatures__); meth->__signatures__ = func->__signatures__; Py_XINCREF(type); meth->type = type; Py_XINCREF(func->func.defaults_tuple); meth->func.defaults_tuple = func->func.defaults_tuple; if (func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD) obj = type; Py_XINCREF(obj); meth->self = obj; return (PyObject *) meth; } static PyObject * _obj_to_str(PyObject *obj) { if (PyType_Check(obj)) return PyObject_GetAttr(obj, __pyx_n_s_name_2); else return PyObject_Str(obj); } static PyObject * __pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx) { PyObject *signature = NULL; PyObject *unbound_result_func; PyObject *result_func = NULL; if (self->__signatures__ == NULL) { PyErr_SetString(PyExc_TypeError, "Function is not fused"); return NULL; } if (PyTuple_Check(idx)) { PyObject *list = PyList_New(0); Py_ssize_t n = PyTuple_GET_SIZE(idx); PyObject *sep = NULL; int i; if (unlikely(!list)) return NULL; for (i = 0; i < n; i++) { int ret; PyObject *string; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(idx, i); #else PyObject *item = PySequence_ITEM(idx, i); if (unlikely(!item)) goto __pyx_err; #endif string = _obj_to_str(item); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(item); #endif if (unlikely(!string)) goto __pyx_err; ret = PyList_Append(list, string); Py_DECREF(string); if (unlikely(ret < 0)) goto __pyx_err; } sep = PyUnicode_FromString("|"); if (likely(sep)) signature = PyUnicode_Join(sep, list); __pyx_err: ; Py_DECREF(list); Py_XDECREF(sep); } else { signature = _obj_to_str(idx); } if (!signature) return NULL; unbound_result_func = PyObject_GetItem(self->__signatures__, signature); if (unbound_result_func) { if (self->self || self->type) { __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func; Py_CLEAR(unbound->func.func_classobj); Py_XINCREF(self->func.func_classobj); unbound->func.func_classobj = self->func.func_classobj; result_func = __pyx_FusedFunction_descr_get(unbound_result_func, self->self, self->type); } else { result_func = unbound_result_func; Py_INCREF(result_func); } } Py_DECREF(signature); Py_XDECREF(unbound_result_func); return result_func; } static PyObject * __pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD && !((__pyx_FusedFunctionObject *) func)->__signatures__); if (cyfunc->flags & __Pyx_CYFUNCTION_CCLASS && !static_specialized) { return __Pyx_CyFunction_CallAsMethod(func, args, kw); } else { return __Pyx_CyFunction_Call(func, args, kw); } } static PyObject * __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw) { __pyx_FusedFunctionObject *binding_func = (__pyx_FusedFunctionObject *) func; Py_ssize_t argc = PyTuple_GET_SIZE(args); PyObject *new_args = NULL; __pyx_FusedFunctionObject *new_func = NULL; PyObject *result = NULL; PyObject *self = NULL; int is_staticmethod = binding_func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD; int is_classmethod = binding_func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD; if (binding_func->self) { Py_ssize_t i; new_args = PyTuple_New(argc + 1); if (!new_args) return NULL; self = binding_func->self; #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_INCREF(self); #endif Py_INCREF(self); PyTuple_SET_ITEM(new_args, 0, self); for (i = 0; i < argc; i++) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(args, i); Py_INCREF(item); #else PyObject *item = PySequence_ITEM(args, i); if (unlikely(!item)) goto bad; #endif PyTuple_SET_ITEM(new_args, i + 1, item); } args = new_args; } else if (binding_func->type) { if (argc < 1) { PyErr_SetString(PyExc_TypeError, "Need at least one argument, 0 given."); return NULL; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS self = PyTuple_GET_ITEM(args, 0); #else self = PySequence_ITEM(args, 0); if (unlikely(!self)) return NULL; #endif } if (self && !is_classmethod && !is_staticmethod) { int is_instance = PyObject_IsInstance(self, binding_func->type); if (unlikely(!is_instance)) { PyErr_Format(PyExc_TypeError, "First argument should be of type %.200s, got %.200s.", ((PyTypeObject *) binding_func->type)->tp_name, Py_TYPE(self)->tp_name); goto bad; } else if (unlikely(is_instance == -1)) { goto bad; } } #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); self = NULL; #endif if (binding_func->__signatures__) { PyObject *tup; if (is_staticmethod && binding_func->func.flags & __Pyx_CYFUNCTION_CCLASS) { tup = PyTuple_Pack(3, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __Pyx_CyFunction_CallMethod( func, binding_func->__signatures__, tup, NULL); } else { tup = PyTuple_Pack(4, binding_func->__signatures__, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_callfunction(func, tup, NULL); } Py_DECREF(tup); if (unlikely(!new_func)) goto bad; Py_XINCREF(binding_func->func.func_classobj); Py_CLEAR(new_func->func.func_classobj); new_func->func.func_classobj = binding_func->func.func_classobj; func = (PyObject *) new_func; } result = __pyx_FusedFunction_callfunction(func, args, kw); bad: #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); #endif Py_XDECREF(new_args); Py_XDECREF((PyObject *) new_func); return result; } static PyMemberDef __pyx_FusedFunction_members[] = { {(char *) "__signatures__", T_OBJECT, offsetof(__pyx_FusedFunctionObject, __signatures__), READONLY, 0}, {0, 0, 0, 0, 0}, }; static PyMappingMethods __pyx_FusedFunction_mapping_methods = { 0, (binaryfunc) __pyx_FusedFunction_getitem, 0, }; static PyTypeObject __pyx_FusedFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "fused_cython_function", sizeof(__pyx_FusedFunctionObject), 0, (destructor) __pyx_FusedFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif 0, 0, 0, &__pyx_FusedFunction_mapping_methods, 0, (ternaryfunc) __pyx_FusedFunction_call, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 0, (traverseproc) __pyx_FusedFunction_traverse, (inquiry) __pyx_FusedFunction_clear, 0, 0, 0, 0, 0, __pyx_FusedFunction_members, __pyx_CyFunction_getsets, &__pyx_CyFunctionType_type, 0, __pyx_FusedFunction_descr_get, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, #endif }; static int __pyx_FusedFunction_init(void) { __pyx_FusedFunctionType_type.tp_base = __pyx_CyFunctionType; __pyx_FusedFunctionType = __Pyx_FetchCommonType(&__pyx_FusedFunctionType_type); if (__pyx_FusedFunctionType == NULL) { return -1; } return 0; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} view->obj = NULL; Py_DECREF(obj); } #endif /* MemviewSliceIsContig */ static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) { int i, index, step, start; Py_ssize_t itemsize = mvs.memview->view.itemsize; if (order == 'F') { step = 1; start = 0; } else { step = -1; start = ndim - 1; } for (i = 0; i < ndim; i++) { index = start + step * i; if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) return 0; itemsize *= mvs.shape[index]; } return 1; } /* OverlappingSlices */ static void __pyx_get_array_memory_extents(__Pyx_memviewslice *slice, void **out_start, void **out_end, int ndim, size_t itemsize) { char *start, *end; int i; start = end = slice->data; for (i = 0; i < ndim; i++) { Py_ssize_t stride = slice->strides[i]; Py_ssize_t extent = slice->shape[i]; if (extent == 0) { *out_start = *out_end = start; return; } else { if (stride > 0) end += stride * (extent - 1); else start += stride * (extent - 1); } } *out_start = start; *out_end = end + itemsize; } static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, __Pyx_memviewslice *slice2, int ndim, size_t itemsize) { void *start1, *end1, *start2, *end2; __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); return (start1 < end2) && (start2 < end1); } /* Capsule */ static CYTHON_INLINE PyObject * __pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) { PyObject *cobj; #if PY_VERSION_HEX >= 0x02070000 cobj = PyCapsule_New(p, sig, NULL); #else cobj = PyCObject_FromVoidPtr(p, NULL); #endif return cobj; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* TypeInfoCompare */ static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) { int i; if (!a || !b) return 0; if (a == b) return 1; if (a->size != b->size || a->typegroup != b->typegroup || a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { if (a->typegroup == 'H' || b->typegroup == 'H') { return a->size == b->size; } else { return 0; } } if (a->ndim) { for (i = 0; i < a->ndim; i++) if (a->arraysize[i] != b->arraysize[i]) return 0; } if (a->typegroup == 'S') { if (a->flags != b->flags) return 0; if (a->fields || b->fields) { if (!(a->fields && b->fields)) return 0; for (i = 0; a->fields[i].type && b->fields[i].type; i++) { __Pyx_StructField *field_a = a->fields + i; __Pyx_StructField *field_b = b->fields + i; if (field_a->offset != field_b->offset || !__pyx_typeinfo_cmp(field_a->type, field_b->type)) return 0; } return !a->fields[i].type && !b->fields[i].type; } } return 1; } /* MemviewSliceValidateAndInit */ static int __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) { if (buf->shape[dim] <= 1) return 1; if (buf->strides) { if (spec & __Pyx_MEMVIEW_CONTIG) { if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { if (unlikely(buf->strides[dim] != sizeof(void *))) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly contiguous " "in dimension %d.", dim); goto fail; } } else if (unlikely(buf->strides[dim] != buf->itemsize)) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); goto fail; } } if (spec & __Pyx_MEMVIEW_FOLLOW) { Py_ssize_t stride = buf->strides[dim]; if (stride < 0) stride = -stride; if (unlikely(stride < buf->itemsize)) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); goto fail; } } } else { if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not contiguous in " "dimension %d", dim); goto fail; } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not indirect in " "dimension %d", dim); goto fail; } else if (unlikely(buf->suboffsets)) { PyErr_SetString(PyExc_ValueError, "Buffer exposes suboffsets but no strides"); goto fail; } } return 1; fail: return 0; } static int __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) { if (spec & __Pyx_MEMVIEW_DIRECT) { if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { PyErr_Format(PyExc_ValueError, "Buffer not compatible with direct access " "in dimension %d.", dim); goto fail; } } if (spec & __Pyx_MEMVIEW_PTR) { if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly accessible " "in dimension %d.", dim); goto fail; } } return 1; fail: return 0; } static int __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) { int i; if (c_or_f_flag & __Pyx_IS_F_CONTIG) { Py_ssize_t stride = 1; for (i = 0; i < ndim; i++) { if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { PyErr_SetString(PyExc_ValueError, "Buffer not fortran contiguous."); goto fail; } stride = stride * buf->shape[i]; } } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { Py_ssize_t stride = 1; for (i = ndim - 1; i >- 1; i--) { if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { PyErr_SetString(PyExc_ValueError, "Buffer not C contiguous."); goto fail; } stride = stride * buf->shape[i]; } } return 1; fail: return 0; } static int __Pyx_ValidateAndInit_memviewslice( int *axes_specs, int c_or_f_flag, int buf_flags, int ndim, __Pyx_TypeInfo *dtype, __Pyx_BufFmt_StackElem stack[], __Pyx_memviewslice *memviewslice, PyObject *original_obj) { struct __pyx_memoryview_obj *memview, *new_memview; __Pyx_RefNannyDeclarations Py_buffer *buf; int i, spec = 0, retval = -1; __Pyx_BufFmt_Context ctx; int from_memoryview = __pyx_memoryview_check(original_obj); __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) original_obj)->typeinfo)) { memview = (struct __pyx_memoryview_obj *) original_obj; new_memview = NULL; } else { memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( original_obj, buf_flags, 0, dtype); new_memview = memview; if (unlikely(!memview)) goto fail; } buf = &memview->view; if (unlikely(buf->ndim != ndim)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", ndim, buf->ndim); goto fail; } if (new_memview) { __Pyx_BufFmt_Init(&ctx, stack, dtype); if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; } if (unlikely((unsigned) buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->len > 0) { for (i = 0; i < ndim; i++) { spec = axes_specs[i]; if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) goto fail; if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) goto fail; } if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) goto fail; } if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, new_memview != NULL) == -1)) { goto fail; } retval = 0; goto no_fail; fail: Py_XDECREF(new_memview); retval = -1; no_fail: __Pyx_RefNannyFinishContext(); return retval; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2, &__Pyx_TypeInfo_float, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2, &__Pyx_TypeInfo_double, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_long(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_long, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_float(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_float, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_double, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_long(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2, &__Pyx_TypeInfo_long, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_Py_ssize_t(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_Py_ssize_t, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* MemviewSliceCopyTemplate */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, const char *mode, int ndim, size_t sizeof_dtype, int contig_flag, int dtype_is_object) { __Pyx_RefNannyDeclarations int i; __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; struct __pyx_memoryview_obj *from_memview = from_mvs->memview; Py_buffer *buf = &from_memview->view; PyObject *shape_tuple = NULL; PyObject *temp_int = NULL; struct __pyx_array_obj *array_obj = NULL; struct __pyx_memoryview_obj *memview_obj = NULL; __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); for (i = 0; i < ndim; i++) { if (unlikely(from_mvs->suboffsets[i] >= 0)) { PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " "indirect dimensions (axis %d)", i); goto fail; } } shape_tuple = PyTuple_New(ndim); if (unlikely(!shape_tuple)) { goto fail; } __Pyx_GOTREF(shape_tuple); for(i = 0; i < ndim; i++) { temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); if(unlikely(!temp_int)) { goto fail; } else { PyTuple_SET_ITEM(shape_tuple, i, temp_int); temp_int = NULL; } } array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); if (unlikely(!array_obj)) { goto fail; } __Pyx_GOTREF(array_obj); memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( (PyObject *) array_obj, contig_flag, dtype_is_object, from_mvs->memview->typeinfo); if (unlikely(!memview_obj)) goto fail; if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) goto fail; if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, dtype_is_object) < 0)) goto fail; goto no_fail; fail: __Pyx_XDECREF(new_mvs.memview); new_mvs.memview = NULL; new_mvs.data = NULL; no_fail: __Pyx_XDECREF(shape_tuple); __Pyx_XDECREF(temp_int); __Pyx_XDECREF(array_obj); __Pyx_RefNannyFinishContext(); return new_mvs; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* BytesContains */ static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character) { const Py_ssize_t length = PyBytes_GET_SIZE(bytes); char* char_start = PyBytes_AS_STRING(bytes); return memchr(char_start, (unsigned char)character, (size_t)length) != NULL; } /* ImportNumPyArray */ static PyObject* __Pyx__ImportNumPyArray(void) { PyObject *numpy_module, *ndarray_object = NULL; numpy_module = __Pyx_Import(__pyx_n_s_numpy, NULL, 0); if (likely(numpy_module)) { ndarray_object = PyObject_GetAttrString(numpy_module, "ndarray"); Py_DECREF(numpy_module); } if (unlikely(!ndarray_object)) { PyErr_Clear(); } if (unlikely(!ndarray_object || !PyObject_TypeCheck(ndarray_object, &PyType_Type))) { Py_XDECREF(ndarray_object); Py_INCREF(Py_None); ndarray_object = Py_None; } return ndarray_object; } static CYTHON_INLINE PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void) { if (unlikely(!__pyx_numpy_ndarray)) { __pyx_numpy_ndarray = __Pyx__ImportNumPyArray(); } Py_INCREF(__pyx_numpy_ndarray); return __pyx_numpy_ndarray; } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const char neg_one = (char) -1, const_zero = (char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(char) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (char) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (char) 0; case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) case 2: if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 3: if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 4: if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (char) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(char) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (char) 0; case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) case -2: if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 2: if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -3: if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 3: if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -4: if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 4: if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; } #endif if (sizeof(char) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else char val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (char) -1; } } else { char val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (char) -1; val = __Pyx_PyInt_As_char(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to char"); return (char) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to char"); return (char) -1; } /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[5]; int same=1, i, found_dot; const char* rt_from_call = Py_GetVersion(); PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); found_dot = 0; for (i = 0; i < 4; i++) { if (!ctversion[i]) { same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/stats/distance/_cutils.pyx000066400000000000000000000214401446255456000220410ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # Copyright (c) 2021-2021, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ----------------------------------------------------------------------------- import numpy as np cimport cython from cython.parallel import prange ctypedef fused TReal: float double @cython.boundscheck(False) @cython.wraparound(False) def is_symmetric_and_hollow_cy(TReal[:, ::1] mat): """ Check if mat is symmetric and hollow. Equivalent to [not (mat.T != mat).any(), np.trace(mat) == 0] Parameters ---------- mat : 2D array_like Distance matrix. Result: ------- is_symmetric: Boolean not (mat.T != mat).any() is_hollow: Boolean np.trace(mat) == 0 """ cdef Py_ssize_t in_n = mat.shape[0] cdef Py_ssize_t in2 = mat.shape[1] assert in_n == in2 cdef Py_ssize_t trow,tcol cdef Py_ssize_t trow_max,tcol_max cdef Py_ssize_t row,col cdef TReal testval # use int instead of bool for portability cdef int is_sym = True cdef int is_hollow = True # use a tiled approach to maximize memory locality for trow in prange(0, in_n, 24, nogil=True): trow_max = min(trow+24, in_n) for tcol in range(0, in_n, 24): tcol_max = min(tcol+24, in_n) for row in range(trow, trow_max, 1): for col in range(tcol, tcol_max, 1): is_sym &= (mat[row,col]==mat[col,row]) if (trow==tcol): # diagonal block, only ones that can have col==row for col in range(tcol, tcol_max, 1): is_hollow &= (mat[col,col]==0) return [(is_sym==True), (is_hollow==True)] @cython.boundscheck(False) @cython.wraparound(False) def distmat_reorder_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, TReal[:, ::1] out_mat): """ Reorder the rows and columns of a distance matrix given a reorder vector. Not all of the columns need to be used. For example: [ [0, 1, 2, 3] , [1, 0, 4, 5] , [2, 4, 0, 6] , [3, 5, 6, 0] ] with [1,0,3,2] will result in [ [0, 1, 5, 4] , [1, 0, 3, 2] , [5, 3, 0, 6] , [4, 2, 6, 0] ] Note: No error checking is performed. The caller must ensure that all values in reorder_vec are valid Parameters ---------- in_mat : 2D array_like Distance matrix. reorder_vec : 1D_array_like List of permutation indexes out_mat : 2D array_like Output, Distance matrix, must be same size as reorder_vec """ cdef Py_ssize_t in_n = in_mat.shape[0] cdef Py_ssize_t in2 = in_mat.shape[1] cdef Py_ssize_t out_n = reorder_vec.shape[0] cdef Py_ssize_t on2 = out_mat.shape[0] cdef Py_ssize_t on3 = out_mat.shape[1] assert in_n == in2 assert out_n == on2 assert out_n == on3 cdef Py_ssize_t row,col cdef Py_ssize_t vrow for row in prange(out_n, nogil=True): vrow = reorder_vec[row] for col in range(out_n): out_mat[row,col] = in_mat[vrow, reorder_vec[col]] @cython.boundscheck(False) @cython.wraparound(False) def distmat_reorder_condensed_cy(TReal[:, ::1] in_mat, long[::1] reorder_vec, TReal[::1] out_mat_condensed): """ Reorder the rows and columns of a distance matrix given a reorder vector. Not all of the columns need to be used. For example: [ [0, 1, 2, 3] , [1, 0, 4, 5] , [2, 4, 0, 6] , [3, 5, 6, 0] ] with [1,0,3,2] will result in [ 1, 5, 4, 3, 2, 6 ] Note: No error checking is performed. The caller must ensure that all values in reorder_vec are valid Parameters ---------- in_mat : 2D array_like Distance matrix. reorder_vec : 1D_array_like List of permutation indexes out_mat_condensed : 1D array_like Output, condensed distance matrix """ cdef Py_ssize_t in_n = in_mat.shape[0] cdef Py_ssize_t in2 = in_mat.shape[1] cdef Py_ssize_t out_n = reorder_vec.shape[0] cdef Py_ssize_t on2 = out_mat_condensed.shape[0] assert in_n == in2 assert on2 == ((out_n-1)*out_n)/2 cdef Py_ssize_t row,col cdef Py_ssize_t vrow cdef Py_ssize_t idx for row in prange(out_n-1, nogil=True): vrow = reorder_vec[row] idx = row*(out_n-1) - ((row-1)*row)//2 for col in range(out_n-row-1): out_mat_condensed[idx+col] = in_mat[vrow, reorder_vec[col+row+1]] @cython.boundscheck(False) @cython.wraparound(False) def mantel_perm_pearsonr_cy(TReal[:, ::1] x_data, long[:, ::1] perm_order, TReal xmean, TReal normxm, TReal[::1] ym_normalized, TReal[::1] permuted_stats): """ Fused permute, fma, pearsonr for mantel. Replaces the following python code: def _mantel_perm_pearsonr_one(x_flat, xmean, normxm, ym_normalized): # inline pearsonr, condensed from scipy.stats.pearsonr # and reusing some of the known values xm_normalized = (x_flat - xmean)/normxm one_stat = np.dot(xm_normalized, ym_normalized) one_stat = max(min(one_stat, 1.0), -1.0) return one_stat perm_gen = (_mantel_perm_pearsonr_one(distmat_reorder_condensed(x._data, perm_order[p,:]), xmean, normxm, ym_normalized) for p in range(permutations)) permuted_stats = np.fromiter(perm_gen, np.float, count=permutations) Parameters ---------- x_data : 2D array_like Distance matrix. perm_order : 2D array_like List of permutation orders. xmean: real Mean value of condensed x_data normxm: real Norm of pre-processed xm ym_normalized : 1D_array_like Normalized condensed y_data permuted_stats : 1D array_like Output, Pearson stats """ cdef Py_ssize_t in_n = x_data.shape[0] cdef Py_ssize_t in2 = x_data.shape[1] cdef Py_ssize_t perms_n = perm_order.shape[0] cdef Py_ssize_t out_n = perm_order.shape[1] cdef Py_ssize_t y_n = ym_normalized.shape[0] cdef Py_ssize_t on2 = permuted_stats.shape[0] assert in_n == in2 assert y_n == ((out_n-1)*out_n)/2 assert perms_n == on2 cdef Py_ssize_t p cdef Py_ssize_t row,col,icol cdef Py_ssize_t vrow cdef Py_ssize_t idx cdef TReal mul = 1.0/normxm cdef TReal add = -xmean/normxm cdef TReal my_ps cdef TReal yval cdef TReal xval for p in prange(perms_n, nogil=True): my_ps = 0.0 for row in range(out_n-1): vrow = perm_order[p, row] idx = row*(out_n-1) - ((row-1)*row)//2 for icol in range(out_n-row-1): col = icol+row+1 yval = ym_normalized[idx+icol] xval = x_data[vrow, perm_order[p, col]]*mul + add # do not use += to avoid having prange consider it for reduction my_ps = yval*xval + my_ps # Presumably, if abs(one_stat) > 1, then it is only some small artifact of # floating point arithmetic. if my_ps>1.0: my_ps = 1.0 elif my_ps<-1.0: my_ps = -1.0 permuted_stats[p] = my_ps @cython.boundscheck(False) @cython.wraparound(False) def permanova_f_stat_sW_cy(TReal[:, ::1] distance_matrix, Py_ssize_t[::1] group_sizes, Py_ssize_t[::1] grouping): """Compute PERMANOVA pseudo-F partial statistic.""" cdef Py_ssize_t in_n = distance_matrix.shape[0] cdef Py_ssize_t in2 = distance_matrix.shape[1] cdef Py_ssize_t in3 = grouping.shape[0] assert in_n == in2 assert in_n == in3 cdef double s_W = 0.0 cdef Py_ssize_t group_idx cdef double local_s_W cdef double val cdef Py_ssize_t row, col, rowi, coli for rowi in prange(in_n/2, nogil=True): # since columns get shorter, combine first and last row=rowi local_s_W = 0.0 group_idx = grouping[row] for coli in range(in_n-row-1): col = coli+row+1 if grouping[col] == group_idx: val = distance_matrix[row,col] local_s_W = local_s_W + val * val s_W += local_s_W/group_sizes[group_idx] row = in_n-rowi-2 if row!=rowi: # don't double count local_s_W = 0.0 group_idx = grouping[row] for coli in range(in_n-row-1): col = coli+row+1 if grouping[col] == group_idx: val = distance_matrix[row,col] local_s_W = local_s_W + val * val s_W += local_s_W/group_sizes[group_idx] return s_W scikit-bio-0.5.9/skbio/stats/distance/_mantel.py000066400000000000000000000627211446255456000216350ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from itertools import combinations import warnings import numpy as np import pandas as pd import scipy.special from scipy.stats import kendalltau from scipy.stats import ConstantInputWarning from scipy.stats import NearConstantInputWarning from skbio.stats.distance import DistanceMatrix from skbio.util._decorator import experimental from ._cutils import mantel_perm_pearsonr_cy @experimental(as_of="0.4.0") def mantel(x, y, method='pearson', permutations=999, alternative='two-sided', strict=True, lookup=None): """Compute correlation between distance matrices using the Mantel test. The Mantel test compares two distance matrices by computing the correlation between the distances in the lower (or upper) triangular portions of the symmetric distance matrices. Correlation can be computed using Pearson's product-moment correlation coefficient or Spearman's rank correlation coefficient. As defined in [1]_, the Mantel test computes a test statistic :math:`r_M` given two symmetric distance matrices :math:`D_X` and :math:`D_Y`. :math:`r_M` is defined as .. math:: r_M=\\frac{1}{d-1}\\sum_{i=1}^{n-1}\\sum_{j=i+1}^{n} stand(D_X)_{ij}stand(D_Y)_{ij} where .. math:: d=\\frac{n(n-1)}{2} and :math:`n` is the number of rows/columns in each of the distance matrices. :math:`stand(D_X)` and :math:`stand(D_Y)` are distance matrices with their upper triangles containing standardized distances. Note that since :math:`D_X` and :math:`D_Y` are symmetric, the lower triangular portions of the matrices could equivalently have been used instead of the upper triangular portions (the current function behaves in this manner). If ``method='spearman'``, the above equation operates on ranked distances instead of the original distances. Statistical significance is assessed via a permutation test. The rows and columns of the first distance matrix (`x`) are randomly permuted a number of times (controlled via `permutations`). A correlation coefficient is computed for each permutation and the p-value is the proportion of permuted correlation coefficients that are equal to or more extreme than the original (unpermuted) correlation coefficient. Whether a permuted correlation coefficient is "more extreme" than the original correlation coefficient depends on the alternative hypothesis (controlled via `alternative`). Parameters ---------- x, y : DistanceMatrix or array_like Input distance matrices to compare. If `x` and `y` are both ``DistanceMatrix`` instances, they will be reordered based on matching IDs (see `strict` and `lookup` below for handling matching/mismatching IDs); thus they are not required to be in the same ID order. If `x` and `y` are ``array_like``, no reordering is applied and both matrices must have the same shape. In either case, `x` and `y` must be at least 3x3 in size *after* reordering and matching of IDs. method : {'pearson', 'spearman','kendalltau'} Method used to compute the correlation between distance matrices. permutations : int, optional Number of times to randomly permute `x` when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and the p-value will be ``np.nan``. alternative : {'two-sided', 'greater', 'less'} Alternative hypothesis to use when calculating statistical significance. The default ``'two-sided'`` alternative hypothesis calculates the proportion of permuted correlation coefficients whose magnitude (i.e. after taking the absolute value) is greater than or equal to the absolute value of the original correlation coefficient. ``'greater'`` calculates the proportion of permuted coefficients that are greater than or equal to the original coefficient. ``'less'`` calculates the proportion of permuted coefficients that are less than or equal to the original coefficient. strict : bool, optional If ``True``, raises a ``ValueError`` if IDs are found that do not exist in both distance matrices. If ``False``, any nonmatching IDs are discarded before running the test. See `n` (in Returns section below) for the number of matching IDs that were used in the test. This parameter is ignored if `x` and `y` are ``array_like``. lookup : dict, optional Maps each ID in the distance matrices to a new ID. Used to match up IDs across distance matrices prior to running the Mantel test. If the IDs already match between the distance matrices, this parameter is not necessary. This parameter is disallowed if `x` and `y` are ``array_like``. Returns ------- corr_coeff : float Correlation coefficient of the test (depends on `method`). p_value : float p-value of the test. n : int Number of rows/columns in each of the distance matrices, after any reordering/matching of IDs. If ``strict=False``, nonmatching IDs may have been discarded from one or both of the distance matrices prior to running the Mantel test, so this value may be important as it indicates the *actual* size of the matrices that were compared. Raises ------ ValueError If `x` and `y` are not at least 3x3 in size after reordering/matching of IDs, or an invalid `method`, number of `permutations`, or `alternative` are provided. TypeError If `x` and `y` are not both ``DistanceMatrix`` instances or ``array_like``. See Also -------- DistanceMatrix scipy.stats.pearsonr scipy.stats.spearmanr pwmantel Notes ----- The Mantel test was first described in [2]_. The general algorithm and interface are similar to ``vegan::mantel``, available in R's vegan package [3]_. ``np.nan`` will be returned for the p-value if `permutations` is zero or if the correlation coefficient is ``np.nan``. The correlation coefficient will be ``np.nan`` if one or both of the inputs does not have any variation (i.e. the distances are all constant) and ``method='spearman'``. References ---------- .. [1] Legendre, P. and Legendre, L. (2012) Numerical Ecology. 3rd English Edition. Elsevier. .. [2] Mantel, N. (1967). "The detection of disease clustering and a generalized regression approach". Cancer Research 27 (2): 209-220. PMID 6018555. .. [3] http://cran.r-project.org/web/packages/vegan/index.html Examples -------- Import the functionality we'll use in the following examples: >>> from skbio import DistanceMatrix >>> from skbio.stats.distance import mantel Define two 3x3 distance matrices: >>> x = DistanceMatrix([[0, 1, 2], ... [1, 0, 3], ... [2, 3, 0]]) >>> y = DistanceMatrix([[0, 2, 7], ... [2, 0, 6], ... [7, 6, 0]]) Compute the Pearson correlation between them and assess significance using a two-sided test with 999 permutations: >>> coeff, p_value, n = mantel(x, y) >>> print(round(coeff, 4)) 0.7559 Thus, we see a moderate-to-strong positive correlation (:math:`r_M=0.7559`) between the two matrices. In the previous example, the distance matrices (``x`` and ``y``) have the same IDs, in the same order: >>> x.ids ('0', '1', '2') >>> y.ids ('0', '1', '2') If necessary, ``mantel`` will reorder the distance matrices prior to running the test. The function also supports a ``lookup`` dictionary that maps distance matrix IDs to new IDs, providing a way to match IDs between distance matrices prior to running the Mantel test. For example, let's reassign the distance matrices' IDs so that there are no matching IDs between them: >>> x.ids = ('a', 'b', 'c') >>> y.ids = ('d', 'e', 'f') If we rerun ``mantel``, we get the following error notifying us that there are nonmatching IDs (this is the default behavior with ``strict=True``): >>> mantel(x, y) Traceback (most recent call last): ... ValueError: IDs exist that are not in both distance matrices. If we pass ``strict=False`` to ignore/discard nonmatching IDs, we see that no matches exist between `x` and `y`, so the Mantel test still cannot be run: >>> mantel(x, y, strict=False) Traceback (most recent call last): ... ValueError: No matching IDs exist between the distance matrices. To work around this, we can define a ``lookup`` dictionary to specify how the IDs should be matched between distance matrices: >>> lookup = {'a': 'A', 'b': 'B', 'c': 'C', ... 'd': 'A', 'e': 'B', 'f': 'C'} ``lookup`` maps each ID to ``'A'``, ``'B'``, or ``'C'``. If we rerun ``mantel`` with ``lookup``, we get the same results as the original example where all distance matrix IDs matched: >>> coeff, p_value, n = mantel(x, y, lookup=lookup) >>> print(round(coeff, 4)) 0.7559 ``mantel`` also accepts input that is ``array_like``. For example, if we redefine `x` and `y` as nested Python lists instead of ``DistanceMatrix`` instances, we obtain the same result: >>> x = [[0, 1, 2], ... [1, 0, 3], ... [2, 3, 0]] >>> y = [[0, 2, 7], ... [2, 0, 6], ... [7, 6, 0]] >>> coeff, p_value, n = mantel(x, y) >>> print(round(coeff, 4)) 0.7559 It is import to note that reordering/matching of IDs (and hence the ``strict`` and ``lookup`` parameters) do not apply when input is ``array_like`` because there is no notion of IDs. """ special = False # set to true, if we have a dedicated implementation if method == 'pearson': special = True elif method == 'spearman': special = True elif method == 'kendalltau': corr_func = kendalltau else: raise ValueError("Invalid correlation method '%s'." % method) if permutations < 0: raise ValueError("Number of permutations must be greater than or " "equal to zero.") if alternative not in ('two-sided', 'greater', 'less'): raise ValueError("Invalid alternative hypothesis '%s'." % alternative) x, y = _order_dms(x, y, strict=strict, lookup=lookup) n = x.shape[0] if n < 3: raise ValueError("Distance matrices must have at least 3 matching IDs " "between them (i.e., minimum 3x3 in size).") if special: if method == 'pearson': orig_stat, comp_stat, permuted_stats = \ _mantel_stats_pearson(x, y, permutations) elif method == 'spearman': orig_stat, comp_stat, permuted_stats = \ _mantel_stats_spearman(x, y, permutations) else: raise ValueError("Invalid correlation method '%s'." % method) else: x_flat = x.condensed_form() y_flat = y.condensed_form() orig_stat = comp_stat = corr_func(x_flat, y_flat)[0] del x_flat permuted_stats = [] if not (permutations == 0 or np.isnan(orig_stat)): perm_gen = (corr_func(x.permute(condensed=True), y_flat)[0] for _ in range(permutations)) permuted_stats = np.fromiter(perm_gen, float, count=permutations) del y_flat if permutations == 0 or np.isnan(orig_stat): p_value = np.nan else: if alternative == 'two-sided': count_better = (np.absolute(permuted_stats) >= np.absolute(comp_stat)).sum() elif alternative == 'greater': count_better = (permuted_stats >= comp_stat).sum() else: count_better = (permuted_stats <= comp_stat).sum() p_value = (count_better + 1) / (permutations + 1) return orig_stat, p_value, n def _mantel_stats_pearson_flat(x, y_flat, permutations): """Compute original and permuted stats using pearsonr. Parameters ---------- x : DistanceMatrix Input distance matrix. y_flat: 1D array Compact representation of a distance matrix. permutations : int Number of times to randomly permute `x` when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and permuted_stats will be an empty array. Returns ------- orig_stat : 1D array_like Correlation coefficient of the test. comp_stat : 1D array_like Correlation coefficient to compare against permuted_stats, usually the same as orig_stat, but on certain architectures it will differ. This should be used for any p-value calculation as it will match the values for any "self-permutations" in the permuted_stats. permuted_stats : 1D array_like Permuted correlation coefficients of the test. """ x_flat = x.condensed_form() # If an input is constant, the correlation coefficient is not defined. if (x_flat == x_flat[0]).all() or (y_flat == y_flat[0]).all(): warnings.warn(ConstantInputWarning()) return np.nan, np.nan, [] # inline pearsonr, condensed from scipy.stats.pearsonr xmean = x_flat.mean() xm = x_flat - xmean normxm = np.linalg.norm(xm) xm_normalized = xm/normxm del xm del x_flat ymean = y_flat.mean() ym = y_flat - ymean normym = np.linalg.norm(ym) ym_normalized = ym/normym del ym threshold = 1e-13 if (((normxm < threshold*abs(xmean)) or (normym < threshold*abs(ymean)))): # If all the values in x (likewise y) are very close to the mean, # the loss of precision that occurs in the subtraction xm = x - xmean # might result in large errors in r. warnings.warn(NearConstantInputWarning()) orig_stat = np.dot(xm_normalized, ym_normalized) # Presumably, if abs(orig_stat) > 1, then it is only some small artifact of # floating point arithmetic. orig_stat = max(min(orig_stat, 1.0), -1.0) mat_n = x._data.shape[0] # note: xmean and normxm do not change with permutations permuted_stats = [] comp_stat = orig_stat if not (permutations == 0 or np.isnan(orig_stat)): # inline DistanceMatrix.permute, grouping them together x_data = x._data if not x_data.flags.c_contiguous: x_data = np.asarray(x_data, order='C') # compute all pearsonr permutations at once # create first the list of permutations perm_order = np.empty((permutations + 1, mat_n), dtype=int) # first row/statistic will be comp_stat perm_order[0, :] = np.arange(mat_n) for row in range(1, permutations + 1): perm_order[row, :] = np.random.permutation(mat_n) permuted_stats = np.empty(permutations + 1, dtype=x_data.dtype) mantel_perm_pearsonr_cy(x_data, perm_order, xmean, normxm, ym_normalized, permuted_stats) comp_stat = permuted_stats[0] permuted_stats = permuted_stats[1:] return orig_stat, comp_stat, permuted_stats def _mantel_stats_pearson(x, y, permutations): """Compute original and permuted stats using pearsonr. Parameters ---------- x, y : DistanceMatrix Input distance matrices to compare. permutations : int Number of times to randomly permute `x` when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and permuted_stats will be an empty array. Returns ------- orig_stat : 1D array_like Correlation coefficient of the test. comp_stat : 1D array_like Correlation coefficient to compare against permuted_stats, usually the same as orig_stat, but on certain architectures it will differ. This should be used for any p-value calculation as it will match the values for any "self-permutations" in the permuted_stats. permuted_stats : 1D array_like Permuted correlation coefficients of the test. """ y_flat = y.condensed_form() return _mantel_stats_pearson_flat(x, y_flat, permutations) def _mantel_stats_spearman(x, y, permutations): """Compute original and permuted stats using spearmanr. Parameters ---------- x, y : DistanceMatrix Input distance matrices to compare. permutations : int Number of times to randomly permute `x` when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and permuted_stats will be an empty array. Returns ------- orig_stat : 1D array_like Correlation coefficient of the test. comp_stat : 1D array_like Correlation coefficient to compare against permuted_stats, usually the same as orig_stat, but on certain architectures it will differ. This should be used for any p-value calculation as it will match the values for any "self-permutations" in the permuted_stats. permuted_stats : 1D array_like Permuted correlation coefficients of the test. """ x_flat = x.condensed_form() y_flat = y.condensed_form() # If an input is constant, the correlation coefficient is not defined. if (x_flat == x_flat[0]).all() or (y_flat == y_flat[0]).all(): warnings.warn(ConstantInputWarning()) return np.nan, np.nan, [] y_rank = scipy.stats.rankdata(y_flat) del y_flat x_rank = scipy.stats.rankdata(x_flat) del x_flat x_rank_matrix = DistanceMatrix(x_rank, x.ids) del x_rank # for our purposes, spearman is just pearson on rankdata return _mantel_stats_pearson_flat(x_rank_matrix, y_rank, permutations) @experimental(as_of="0.4.0") def pwmantel(dms, labels=None, method='pearson', permutations=999, alternative='two-sided', strict=True, lookup=None): """Run Mantel tests for every pair of given distance matrices. Runs a Mantel test for each pair of distance matrices and collates the results in a ``DataFrame``. Distance matrices do not need to be in the same ID order if they are ``DistanceMatrix`` instances. Distance matrices will be re-ordered prior to running each pairwise test, and if ``strict=False``, IDs that don't match between a pair of distance matrices will be dropped prior to running the test (otherwise a ``ValueError`` will be raised if there are nonmatching IDs between any pair of distance matrices). Parameters ---------- dms : iterable of DistanceMatrix objects, array_like objects, or filepaths to distance matrices. If they are ``array_like``, no reordering or matching of IDs will be performed. labels : iterable of str or int, optional Labels for each distance matrix in `dms`. These are used in the results ``DataFrame`` to identify the pair of distance matrices used in a pairwise Mantel test. If ``None``, defaults to monotonically-increasing integers starting at zero. method : {'pearson', 'spearman'} Correlation method. See ``mantel`` function for more details. permutations : int, optional Number of permutations. See ``mantel`` function for more details. alternative : {'two-sided', 'greater', 'less'} Alternative hypothesis. See ``mantel`` function for more details. strict : bool, optional Handling of nonmatching IDs. See ``mantel`` function for more details. lookup : dict, optional Map existing IDs to new IDs. See ``mantel`` function for more details. Returns ------- pandas.DataFrame ``DataFrame`` containing the results of each pairwise test (one per row). Includes the number of objects considered in each test as column ``n`` (after applying `lookup` and filtering nonmatching IDs if ``strict=False``). Column ``p-value`` will display p-values as ``NaN`` if p-values could not be computed (they are stored as ``np.nan`` within the ``DataFrame``; see ``mantel`` for more details). See Also -------- mantel DistanceMatrix.read Notes -------- Passing a list of filepaths can be useful as it allows for a smaller amount of memory consumption as it only loads two matrices at a time as opposed to loading all distance matrices into memory. Examples -------- Import the functionality we'll use in the following examples: >>> from skbio import DistanceMatrix >>> from skbio.stats.distance import pwmantel Define three 3x3 distance matrices: >>> x = DistanceMatrix([[0, 1, 2], ... [1, 0, 3], ... [2, 3, 0]]) >>> y = DistanceMatrix([[0, 2, 7], ... [2, 0, 6], ... [7, 6, 0]]) >>> z = DistanceMatrix([[0, 5, 6], ... [5, 0, 1], ... [6, 1, 0]]) Run Mantel tests for each pair of distance matrices (there are 3 possible pairs): >>> pwmantel((x, y, z), labels=('x', 'y', 'z'), ... permutations=0) # doctest: +NORMALIZE_WHITESPACE statistic p-value n method permutations alternative dm1 dm2 x y 0.755929 NaN 3 pearson 0 two-sided z -0.755929 NaN 3 pearson 0 two-sided y z -0.142857 NaN 3 pearson 0 two-sided Note that we passed ``permutations=0`` to suppress significance tests; the p-values in the output are labelled ``NaN``. """ num_dms = len(dms) if num_dms < 2: raise ValueError("Must provide at least two distance matrices.") if labels is None: labels = range(num_dms) else: if num_dms != len(labels): raise ValueError("Number of labels must match the number of " "distance matrices.") if len(set(labels)) != len(labels): raise ValueError("Labels must be unique.") num_combs = scipy.special.comb(num_dms, 2, exact=True) results_dtype = [('dm1', object), ('dm2', object), ('statistic', float), ('p-value', float), ('n', int), ('method', object), ('permutations', int), ('alternative', object)] results = np.empty(num_combs, dtype=results_dtype) for i, pair in enumerate(combinations(zip(labels, dms), 2)): (xlabel, x), (ylabel, y) = pair if isinstance(x, str): x = DistanceMatrix.read(x) if isinstance(y, str): y = DistanceMatrix.read(y) stat, p_val, n = mantel(x, y, method=method, permutations=permutations, alternative=alternative, strict=strict, lookup=lookup) results[i] = (xlabel, ylabel, stat, p_val, n, method, permutations, alternative) return pd.DataFrame.from_records(results, index=('dm1', 'dm2')) def _order_dms(x, y, strict=True, lookup=None): """Intersect distance matrices and put them in the same order.""" x_is_dm = isinstance(x, DistanceMatrix) y_is_dm = isinstance(y, DistanceMatrix) if (x_is_dm and not y_is_dm) or (y_is_dm and not x_is_dm): raise TypeError( "Mixing DistanceMatrix and array_like input types is not " "supported. Both x and y must either be DistanceMatrix instances " "or array_like, but not mixed.") elif x_is_dm and y_is_dm: if lookup is not None: x = _remap_ids(x, lookup, 'x', 'first') y = _remap_ids(y, lookup, 'y', 'second') if tuple(x.ids) == tuple(y.ids): return x, y id_order = [id_ for id_ in x.ids if id_ in y] num_matches = len(id_order) if (strict and ((num_matches != len(x.ids)) or (num_matches != len(y.ids)))): raise ValueError("IDs exist that are not in both distance " "matrices.") if num_matches < 1: raise ValueError("No matching IDs exist between the distance " "matrices.") return x.filter(id_order), y.filter(id_order) else: # Both x and y aren't DistanceMatrix instances. if lookup is not None: raise ValueError("ID lookup can only be provided if inputs are " "DistanceMatrix instances.") x = DistanceMatrix(x) y = DistanceMatrix(y) if x.shape != y.shape: raise ValueError("Distance matrices must have the same shape.") return x, y def _remap_ids(dm, lookup, label, order): "Return a copy of `dm` with its IDs remapped based on `lookup`.""" try: remapped_ids = [lookup[id_] for id_ in dm.ids] except KeyError as e: raise KeyError("All IDs in the %s distance matrix (%s) must be in " "the lookup. Missing ID: %s" % (order, label, str(e))) # Create a copy as we'll be modifying the IDs in place. dm_copy = dm.copy() dm_copy.ids = remapped_ids return dm_copy scikit-bio-0.5.9/skbio/stats/distance/_permanova.py000066400000000000000000000122771446255456000223460ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from functools import partial import numpy as np from ._base import (_preprocess_input_sng, _run_monte_carlo_stats, _build_results, DistanceMatrix) from skbio.util._decorator import experimental from ._cutils import permanova_f_stat_sW_cy @experimental(as_of="0.4.0") def permanova(distance_matrix, grouping, column=None, permutations=999): """Test for significant differences between groups using PERMANOVA. Permutational Multivariate Analysis of Variance (PERMANOVA) is a non-parametric method that tests whether two or more groups of objects (e.g., samples) are significantly different based on a categorical factor. It is conceptually similar to ANOVA except that it operates on a distance matrix, which allows for multivariate analysis. PERMANOVA computes a pseudo-F statistic. Statistical significance is assessed via a permutation test. The assignment of objects to groups (`grouping`) is randomly permuted a number of times (controlled via `permutations`). A pseudo-F statistic is computed for each permutation and the p-value is the proportion of permuted pseudo-F statisics that are equal to or greater than the original (unpermuted) pseudo-F statistic. Parameters ---------- distance_matrix : DistanceMatrix Distance matrix containing distances between objects (e.g., distances between samples of microbial communities). grouping : 1-D array_like or pandas.DataFrame Vector indicating the assignment of objects to groups. For example, these could be strings or integers denoting which group an object belongs to. If `grouping` is 1-D ``array_like``, it must be the same length and in the same order as the objects in `distance_matrix`. If `grouping` is a ``DataFrame``, the column specified by `column` will be used as the grouping vector. The ``DataFrame`` must be indexed by the IDs in `distance_matrix` (i.e., the row labels must be distance matrix IDs), but the order of IDs between `distance_matrix` and the ``DataFrame`` need not be the same. All IDs in the distance matrix must be present in the ``DataFrame``. Extra IDs in the ``DataFrame`` are allowed (they are ignored in the calculations). column : str, optional Column name to use as the grouping vector if `grouping` is a ``DataFrame``. Must be provided if `grouping` is a ``DataFrame``. Cannot be provided if `grouping` is 1-D ``array_like``. permutations : int, optional Number of permutations to use when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and the p-value will be ``np.nan``. Returns ------- pandas.Series Results of the statistical test, including ``test statistic`` and ``p-value``. See Also -------- anosim Notes ----- See [1]_ for the original method reference, as well as ``vegan::adonis``, available in R's vegan package [2]_. The p-value will be ``np.nan`` if `permutations` is zero. References ---------- .. [1] Anderson, Marti J. "A new method for non-parametric multivariate analysis of variance." Austral Ecology 26.1 (2001): 32-46. .. [2] http://cran.r-project.org/web/packages/vegan/index.html Examples -------- See :mod:`skbio.stats.distance.anosim` for usage examples (both functions provide similar interfaces). """ if not isinstance(distance_matrix, DistanceMatrix): raise TypeError("Input must be a DistanceMatrix.") sample_size = distance_matrix.shape[0] num_groups, grouping = _preprocess_input_sng( distance_matrix.ids, sample_size, grouping, column) # Calculate number of objects in each group. group_sizes = np.bincount(grouping) s_T = (distance_matrix[:] ** 2).sum() / sample_size # we are going over the whole matrix, instead of just upper triangle # so cut in half s_T /= 2.0 test_stat_function = partial(_compute_f_stat, sample_size, num_groups, distance_matrix, group_sizes, s_T) stat, p_value = _run_monte_carlo_stats(test_stat_function, grouping, permutations) return _build_results('PERMANOVA', 'pseudo-F', sample_size, num_groups, stat, p_value, permutations) def _compute_f_stat(sample_size, num_groups, distance_matrix, group_sizes, s_T, grouping): """Compute PERMANOVA pseudo-F statistic.""" # Calculate s_W for each group, accounting for different group sizes. s_W = permanova_f_stat_sW_cy(distance_matrix.data, group_sizes, grouping) s_A = s_T - s_W return (s_A / (num_groups - 1)) / (s_W / (sample_size - num_groups)) scikit-bio-0.5.9/skbio/stats/distance/_permdisp.py000066400000000000000000000303541446255456000221750ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from functools import partial import numpy as np import pandas as pd from scipy.stats import f_oneway from scipy.spatial.distance import cdist import hdmedians as hd from ._base import (_preprocess_input_sng, _run_monte_carlo_stats, _build_results, DistanceMatrix) from skbio.stats.ordination import pcoa, OrdinationResults from skbio.util._decorator import experimental @experimental(as_of="0.5.2") def permdisp(distance_matrix, grouping, column=None, test='median', permutations=999, method="eigh", number_of_dimensions=10): """Test for Homogeneity of Multivariate Groups Disperisons using Marti Anderson's PERMDISP2 procedure. PERMDISP is a multivariate analogue of Levene's test for homogeneity of multivariate variances. Distances are handled by reducing the original distances to principal coordinates. PERMDISP calculates an F-statistic to assess whether the dispersions between groups is significant Parameters ---------- distance_matrix : DistanceMatrix or OrdinationResults Distance matrix containing distances between objects (e.g., distances between samples of microbial communities) or result of pcoa on such a matrix. grouping : 1-D array_like or pandas.DataFrame Vector indicating the assignment of objects to groups. For example, these could be strings or integers denoting which group an object belongs to. If `grouping` is 1-D ``array_like``, it must be the same length and in the same order as the objects in `distance_matrix`. If `grouping` is a ``DataFrame``, the column specified by `column` will be used as the grouping vector. The ``DataFrame`` must be indexed by the IDs in `distance_matrix` (i.e., the row labels must be distance matrix IDs), but the order of IDs between `distance_matrix` and the ``DataFrame`` need not be the same. All IDs in the distance matrix must be present in the ``DataFrame``. Extra IDs in the ``DataFrame`` are allowed (they are ignored in the calculations). column : str, optional Column name to use as the grouping vector if `grouping` is a ``DataFrame``. Must be provided if `grouping` is a ``DataFrame``. Cannot be provided if `grouping` is 1-D ``array_like``. test : {'centroid', 'median'} determines whether the analysis is done using centroid or spaitial median. permutations : int, optional Number of permutations to use when assessing statistical significance. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and the p-value will be ``np.nan``. method : str, optional Eigendecomposition method to use in performing PCoA. By default, uses SciPy's `eigh`, which computes exact eigenvectors and eigenvalues for all dimensions. The alternate method, `fsvd`, uses faster heuristic eigendecomposition but loses accuracy. The magnitude of accuracy lost is dependent on dataset. Note that using `fsvd` is still considered experimental and should be used with care. Not used if distance_matrix is a OrdinationResults object. number_of_dimensions : int, optional Dimensions to reduce the distance matrix to if using the `fsvd` method. Not used if the `eigh` method is being selected. Returns ------- pandas.Series Results of the statistical test, including ``test statistic`` and ``p-value``. Raises ------ TypeError If, when using the spatial median test, the pcoa ordination is not of type np.float32 or np.float64, the spatial median function will fail and the centroid test should be used instead ValueError If the test is not centroid or median, or if method is not eigh or fsvd TypeError If the distance matrix is not an instance of a ``skbio.DistanceMatrix``. ValueError If there is only one group ValueError If a list and a column name are both provided ValueError If a list is provided for `grouping` and it's length does not match the number of ids in distance_matrix ValueError If all of the values in the grouping vector are unique KeyError If there are ids in grouping that are not in distance_matrix See Also -------- permanova anosim Notes ----- The significance of the results from this function will be the same as the results found in vegan's betadisper, however due to floating point variability the F-statistic results may vary slightly. See [1]_ for the original method reference, as well as ``vegan::betadisper``, available in R's vegan package [2]_. References ---------- .. [1] Anderson, Marti J. "Distance-Based Tests for Homogeneity of Multivariate Dispersions." Biometrics 62 (2006):245-253 .. [2] http://cran.r-project.org/web/packages/vegan/index.html Examples -------- Load a 6x6 distance matrix and grouping vector denoting 2 groups of objects: >>> from skbio import DistanceMatrix >>> dm = DistanceMatrix([[0, 0.5, 0.75, 1, 0.66, 0.33], ... [0.5, 0, 0.25, 0.33, 0.77, 0.61], ... [0.75, 0.25, 0, 0.1, 0.44, 0.55], ... [1, 0.33, 0.1, 0, 0.75, 0.88], ... [0.66, 0.77, 0.44, 0.75, 0, 0.77], ... [0.33, 0.61, 0.55, 0.88, 0.77, 0]], ... ['s1', 's2', 's3', 's4', 's5', 's6']) >>> grouping = ['G1', 'G1', 'G1', 'G2', 'G2', 'G2'] Run PERMDISP using 99 permutations to caluculate the p-value: >>> from skbio.stats.distance import permdisp >>> import numpy as np >>> #make output deterministic, should not be included during normal use >>> np.random.seed(0) >>> permdisp(dm, grouping, permutations=99) method name PERMDISP test statistic name F-value sample size 6 number of groups 2 test statistic ... 1.03... p-value ... number of permutations 99 Name: PERMDISP results, dtype: object The return value is a ``pandas.Series`` object containing the results of the statistical test. To suppress calculation of the p-value and only obtain the F statistic, specify zero permutations: >>> permdisp(dm, grouping, permutations=0) method name PERMDISP test statistic name F-value sample size 6 number of groups 2 test statistic ... 1.03... p-value NaN number of permutations 0 Name: PERMDISP results, dtype: object PERMDISP computes variances based on two types of tests, using either centroids or spatial medians, also commonly referred to as a geometric median. The spatial median is thought to yield a more robust test statistic, and this test is used by default. Spatial medians are computed using an iterative algorithm to find the optimally minimum point from all other points in a group while centroids are computed using a deterministic formula. As such the two different tests yeild slightly different F statistics. >>> np.random.seed(0) >>> permdisp(dm, grouping, test='centroid', permutations=6) method name PERMDISP test statistic name F-value sample size 6 number of groups 2 test statistic ... 3.67... p-value ... 0.42... number of permutations 6 Name: PERMDISP results, dtype: object You can also provide a ``pandas.DataFrame`` and a column denoting the grouping instead of a grouping vector. The following DataFrame's Grouping column specifies the same grouping as the vector we used in the previous examples.: >>> import pandas as pd >>> df = pd.DataFrame.from_dict( ... {'Grouping': {'s1': 'G1', 's2': 'G1', 's3': 'G1', 's4': 'G2', ... 's5': 'G2', 's6': 'G2'}}) >>> permdisp(dm, df, 'Grouping', permutations=6, test='centroid') method name PERMDISP test statistic name F-value sample size 6 number of groups 2 test statistic ... 3.67... p-value ... 0.42... number of permutations 6 Name: PERMDISP results, dtype: object Note that when providing a ``DataFrame``, the ordering of rows and/or columns does not affect the grouping vector that is extracted. The ``DataFrame`` must be indexed by the distance matrix IDs (i.e., the row labels must be distance matrix IDs). If IDs (rows) are present in the ``DataFrame`` but not in the distance matrix, they are ignored. The previous example's ``s7`` ID illustrates this behavior: note that even though the ``DataFrame`` had 7 objects, only 6 were used in the test (see the "Sample size" row in the results above to confirm this). Thus, the ``DataFrame`` can be a superset of the distance matrix IDs. Note that the reverse is not true: IDs in the distance matrix *must* be present in the ``DataFrame`` or an error will be raised. PERMDISP should be used to determine whether the dispersions between the groups in your distance matrix are significantly separated. A non-significant test result indicates that group dispersions are similar to each other. PERMANOVA or ANOSIM should then be used in conjunction to determine whether clustering within groups is significant. """ if test not in ['centroid', 'median']: raise ValueError('Test must be centroid or median') if isinstance(distance_matrix, OrdinationResults): ordination = distance_matrix ids = ordination.samples.axes[0].to_list() sample_size = len(ids) distance_matrix = None # not used anymore, avoid using by mistake elif isinstance(distance_matrix, DistanceMatrix): if method == "eigh": # eigh does not natively support specifying number_of_dimensions # and pcoa expects it to be 0 number_of_dimensions = 0 elif method != "fsvd": raise ValueError('Method must be eigh or fsvd') ids = distance_matrix.ids sample_size = distance_matrix.shape[0] ordination = pcoa(distance_matrix, method=method, number_of_dimensions=number_of_dimensions) else: raise TypeError("Input must be a DistanceMatrix or OrdinationResults.") samples = ordination.samples num_groups, grouping = _preprocess_input_sng( ids, sample_size, grouping, column) test_stat_function = partial(_compute_groups, samples, test) stat, p_value = _run_monte_carlo_stats(test_stat_function, grouping, permutations) return _build_results('PERMDISP', 'F-value', sample_size, num_groups, stat, p_value, permutations) def _compute_groups(samples, test_type, grouping): groups = [] samples['grouping'] = grouping if test_type == 'centroid': centroids = samples.groupby('grouping').aggregate('mean') elif test_type == 'median': centroids = samples.groupby('grouping').apply(_config_med) for label, df in samples.groupby('grouping'): groups.append(cdist(df.values[:, :-1].astype('float64'), [centroids.loc[label].values], metric='euclidean')) stat, _ = f_oneway(*groups) stat = stat[0] return stat def _config_med(x): """ slice the vector up to the last value to exclude grouping column and transpose the vector to be compatible with hd.geomedian """ X = x.values[:, :-1] return pd.Series(np.array(hd.geomedian(X.T)), index=x.columns[:-1]) scikit-bio-0.5.9/skbio/stats/distance/_utils.py000066400000000000000000000131701446255456000215070ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from ._cutils import is_symmetric_and_hollow_cy from ._cutils import distmat_reorder_cy, distmat_reorder_condensed_cy def is_symmetric_and_hollow(mat): """ Check if a Distance Matrix is symmetric and hollow. Equivalent to [not (mat.T != mat).any(), np.trace(mat) == 0] Parameters ---------- mat : 2D array_like Distance matrix. Result: ------- is_symmetric: Boolean not (mat.T != mat).any() is_hollow: Boolean np.trace(mat) == 0 """ # is_symmetric_and_hollow_cy is optimized # for the common cas of c_contiguous. # For all other cases, make a copy. if not mat.flags.c_contiguous: mat = np.asarray(mat, order='C') return is_symmetric_and_hollow_cy(mat) def is_symmetric(mat): """ Check if a Distance Matrix is symmetric. Equivalent to not (mat.T != mat).any() Parameters ---------- mat : 2D array_like Distance matrix. Result: ------- is_symmetric: Boolean not (mat.T != mat).any() """ # the is_hollow check is really cheap, # so can reuse is_symmetric_and_hollow return is_symmetric_and_hollow(mat)[0] def is_hollow(mat): """ Check if a Distance Matrix is hollow. Equivalent to np.trace(mat) == 0 Parameters ---------- mat : 2D array_like Distance matrix. Result: ------- is_hollow: Boolean np.trace(mat) == 0 """ # is_symmetric_and_hollow_cy spends most # of its time in symetry check, just use numpy return (np.trace(mat) == 0) def distmat_reorder_buf(in_mat, reorder_vec, out_mat, validate=False): """ Reorder the rows and columns of a distance matrix given a reorder vector. Not all of the columns need to be used. For example: [ [0, 1, 2, 3] , [1, 0, 4, 5] , [2, 4, 0, 6] , [3, 5, 6, 0] ] with [1,0,3,2] will result in [ [0, 1, 5, 4] , [1, 0, 3, 2] , [5, 3, 0, 6] , [4, 2, 6, 0] ] Parameters ---------- in_mat : 2D array_like Distance matrix reorder_vec : 1D_array_like List of permutation indexes out_mat : 2D array_like Output, Distance matrix, must be in c_order and same size as reorder_vec validate: boolean Optional, if True, validate reorder_vec content, detaults to False """ np_reorder = np.asarray(reorder_vec, dtype=int) if validate: maxsize = in_mat.shape[0] bad_cnt = np.where((np_reorder < 0) or (np_reorder >= maxsize))[0].size if bad_cnt > 0: raise ValueError("Invalid reorder_vec") if not in_mat.flags.c_contiguous: in_mat = np.asarray(in_mat, order='C') distmat_reorder_cy(in_mat, np_reorder, out_mat) def distmat_reorder(in_mat, reorder_vec, validate=False): """ Reorder the rows and columns of a distance matrix given a reorder vector. Not all of the columns need to be used. For example: [ [0, 1, 2, 3] , [1, 0, 4, 5] , [2, 4, 0, 6] , [3, 5, 6, 0] ] with [1,0,3,2] will result in [ [0, 1, 5, 4] , [1, 0, 3, 2] , [5, 3, 0, 6] , [4, 2, 6, 0] ] Parameters ---------- in_mat : 2D array_like Distance matrix, must be in c_order reorder_vec : 1D_array_like List of permutation indexes validate: boolean Optional, if True, validate reorder_vec content, detaults to False Returns ------- out_mat : 2D array_like Distance matrix """ np_reorder = np.asarray(reorder_vec, dtype=int) if validate: maxsize = in_mat.shape[0] bad_cnt = np.where((np_reorder < 0) or (np_reorder >= maxsize))[0].size if bad_cnt > 0: raise ValueError("Invalid reorder_vec") if not in_mat.flags.c_contiguous: in_mat = np.asarray(in_mat, order='C') out_mat = np.empty([np_reorder.size, np_reorder.size], in_mat.dtype) distmat_reorder_cy(in_mat, np_reorder, out_mat) return out_mat def distmat_reorder_condensed(in_mat, reorder_vec, validate=False): """ Reorder the rows and columns of a distance matrix given a reorder vector. Not all of the columns need to be used. For example: [ [0, 1, 2, 3] , [1, 0, 4, 5] , [2, 4, 0, 6] , [3, 5, 6, 0] ] with [1,0,3,2] will result in [ 1, 5, 4 , 3, 2, 6 ] Parameters ---------- in_mat : 2D array_like Distance matrix, must be in c_order reorder_vec : 1D_array_like List of permutation indexes validate: boolean Optional, if True, validate reorder_vec content, detaults to False Returns ------- out_mat_condensed : 1D array_like Condensed distance matrix """ np_reorder = np.asarray(reorder_vec, dtype=int) if validate: maxsize = in_mat.shape[0] bad_cnt = np.where((np_reorder < 0) or (np_reorder >= maxsize))[0].size if bad_cnt > 0: raise ValueError("Invalid reorder_vec") if not in_mat.flags.c_contiguous: in_mat = np.asarray(in_mat, order='C') csize = ((np_reorder.size-1)*np_reorder.size) // 2 out_mat_condensed = np.empty([csize], in_mat.dtype) distmat_reorder_condensed_cy(in_mat, np_reorder, out_mat_condensed) return out_mat_condensed scikit-bio-0.5.9/skbio/stats/distance/tests/000077500000000000000000000000001446255456000207765ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/distance/tests/__init__.py000066400000000000000000000005411446255456000231070ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/stats/distance/tests/data/000077500000000000000000000000001446255456000217075ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/distance/tests/data/bioenv_df_vegan.txt000066400000000000000000000021241446255456000255620ustar00rootroot00000000000000#SampleID log(N) P K Ca pH Al 18 2.98568193770049 42.1 139.9 519.4 2.7 39 15 2.59525470695687 39.1 167.3 356.7 2.8 88.1 24 3.00568260440716 67.7 207.1 973.3 3 138 27 3.02529107579554 60.8 233.7 834 2.8 15.4 23 3.16968558067743 54.5 180.6 777 2.7 24.2 19 3.1267605359604 40.9 171.4 691.8 2.7 104.8 22 3.28091121578765 36.7 171.4 738.6 2.8 20.7 16 3.18635263316264 31 138.2 394.6 2.8 74.2 28 3.39450839351136 73.5 260 748.6 2.8 17.9 13 3.3357695763397 40.5 313.8 540.7 2.8 329.7 14 3.08190996979504 38.1 146.8 512.2 2.7 92.3 20 3.26575941076705 61.9 202.2 741.2 2.9 124.3 25 3.1267605359604 50.6 151.7 648 2.9 12.1 7 3.41772668361337 24.6 78.7 188.5 3.1 294.9 5 3.49953328238302 22.7 43.6 240.3 3.1 39 6 2.94968833505258 26.4 61.1 259.1 3 155.1 3 3.43720781918519 32.3 73.7 219 3.3 304.6 4 2.89037175789616 64.9 224.5 517.6 2.9 435.1 2 3.10458667846607 47.4 165.9 436.1 2.9 316.5 9 2.70805020110221 48.4 127.4 499.6 3 227.1 12 2.77258872223978 32.7 126.4 471.4 2.9 108.8 10 2.66025953726586 62.8 215.2 709.7 3.2 168.2 11 2.81540871942271 55.8 205.3 1169.7 3.6 253.6 21 3.04452243772342 26.5 104.4 484.8 3 35.8 scikit-bio-0.5.9/skbio/stats/distance/tests/data/bioenv_dm_vegan.txt000066400000000000000000000234471446255456000256040ustar00rootroot00000000000000 18 15 24 27 23 19 22 16 28 13 14 20 25 7 5 6 3 4 2 9 12 10 11 21 18 0 0.452897212693772 0.715360803826621 0.624766305873718 0.493154219155204 0.43865006075341 0.432340187193151 0.440822999771334 0.698420319937299 0.46351050707088 0.523211654445006 0.408294556891784 0.604911324328014 0.434178076197442 0.545291972003212 0.393272103797605 0.330797959207167 0.563648430837013 0.66523173799306 0.511183841155759 0.46804467412999 0.515485401604058 0.580143332456965 0.668700755517761 15 0.452897212693772 0 0.611610336420561 0.655733483106344 0.410315012072556 0.453712867932398 0.424523404131089 0.377720269664141 0.654941298927269 0.417480326012996 0.35798188425419 0.360483800701559 0.589951055270385 0.532758773890324 0.584210632971972 0.37822819560664 0.53024185913761 0.584066987502168 0.778451630131581 0.543847849995263 0.527747948281903 0.582043972050997 0.591017841508146 0.753206717859593 24 0.715360803826621 0.611610336420561 0 0.749908842875888 0.624415191219002 0.598837193048421 0.660837272556231 0.638184679569268 0.724777756165372 0.708236862111778 0.645430446977294 0.535631415741837 0.693070808707219 0.71138410637102 0.810870811602888 0.638724301482429 0.721802013418365 0.751900340516049 0.812623821498287 0.596958779537393 0.58038306362995 0.631041437421227 0.634765906326142 0.634430266921848 27 0.624766305873718 0.655733483106344 0.749908842875888 0 0.595583136283997 0.480812012211359 0.509183154263298 0.68272679039539 0.503151848497109 0.745346748197303 0.742254576600809 0.581672470591416 0.574612957968774 0.720436148000664 0.836899929519594 0.712346970098655 0.722493161303423 0.81059478353512 0.67179686908506 0.741190787334003 0.632934861831476 0.743347684665419 0.787761710107256 0.545259963579148 23 0.493154219155204 0.410315012072556 0.624415191219002 0.595583136283997 0 0.39798190453075 0.551027253590122 0.530245080842824 0.688639670633179 0.558293400969046 0.499126157677784 0.374655747006781 0.560198031134205 0.575636505169288 0.709011461350035 0.555007697254655 0.569632137079713 0.700292123849093 0.686164552961924 0.610923773488132 0.522084519099983 0.614601499571679 0.573249035174906 0.619889410480321 19 0.43865006075341 0.453712867932398 0.598837193048421 0.480812012211359 0.39798190453075 0 0.447090470008913 0.462780164587808 0.62210941999066 0.517037833858162 0.547198044950618 0.436336586468505 0.466295105039809 0.533153195372235 0.649768050102464 0.468877587536534 0.489021376289978 0.59989451354897 0.600155810641532 0.482373873247893 0.455971043613941 0.485136325934296 0.561030342274039 0.514596020968001 22 0.432340187193151 0.424523404131089 0.660837272556231 0.509183154263298 0.551027253590122 0.447090470008913 0 0.318721801577202 0.560878982326328 0.493770323127832 0.484678838434732 0.466044129553462 0.540556449240843 0.537716889466216 0.700184066308371 0.472868628510347 0.525506721244604 0.632959267911546 0.74368261302233 0.514539804165303 0.555492307675902 0.545820329626384 0.605832461377114 0.55345791449267 16 0.440822999771334 0.377720269664141 0.638184679569268 0.68272679039539 0.530245080842824 0.462780164587808 0.318721801577202 0 0.664347219281937 0.418561808219052 0.408452070724878 0.358924933851484 0.5815245364665 0.515594594372192 0.532206785163483 0.4397020901552 0.529224758564709 0.566927472518065 0.753903949731256 0.515921987762518 0.494683547387077 0.495896853216952 0.583525904687767 0.658433720786117 28 0.698420319937299 0.654941298927269 0.724777756165372 0.503151848497109 0.688639670633179 0.62210941999066 0.560878982326328 0.664347219281937 0 0.733169240464629 0.745486578838407 0.618846839169478 0.713792541454381 0.74890906664669 0.853976950339078 0.756087305765939 0.762966538206308 0.791917677364091 0.81258384801323 0.69092466328736 0.711493718852431 0.72961696443748 0.777088600232844 0.628275585712577 13 0.46351050707088 0.417480326012996 0.708236862111778 0.745346748197303 0.558293400969046 0.517037833858162 0.493770323127832 0.418561808219052 0.733169240464629 0 0.434107073238778 0.495251428454508 0.659888526193112 0.482068398983308 0.561095050557647 0.335593085096115 0.482301178660398 0.475008544079799 0.738041440415793 0.50014768619111 0.58859107425281 0.560373485926146 0.58991583345561 0.703705376166457 14 0.523211654445006 0.35798188425419 0.645430446977294 0.742254576600809 0.499126157677784 0.547198044950618 0.484678838434732 0.408452070724878 0.745486578838407 0.434107073238778 0 0.460778501195483 0.598177860722774 0.566437502573166 0.60997028881234 0.437494609608184 0.560278994397196 0.564565884853771 0.814568858546278 0.563078236117464 0.634425207383389 0.539163427744901 0.64719734947765 0.746247657025891 20 0.408294556891784 0.360483800701559 0.535631415741837 0.581672470591416 0.374655747006781 0.436336586468505 0.466044129553462 0.358924933851484 0.618846839169478 0.495251428454508 0.460778501195483 0 0.614834763166026 0.527001028768971 0.636029763289345 0.402589693145724 0.520623812716001 0.635315798842479 0.669112826680887 0.536517399269416 0.410136150776988 0.536831397119922 0.57987764447421 0.650019383574573 25 0.604911324328014 0.589951055270385 0.693070808707219 0.574612957968774 0.560198031134205 0.466295105039809 0.540556449240843 0.5815245364665 0.713792541454381 0.659888526193112 0.598177860722774 0.614834763166026 0 0.635642388269005 0.743838694259872 0.621437815990208 0.63532741224439 0.661420102186089 0.725910634940022 0.669519591989177 0.689034754247501 0.693127422615701 0.709588799419957 0.678749793333 7 0.434178076197442 0.532758773890324 0.71138410637102 0.720436148000664 0.575636505169288 0.533153195372235 0.537716889466216 0.515594594372192 0.74890906664669 0.482068398983308 0.566437502573166 0.527001028768971 0.635642388269005 0 0.510261674576661 0.323081424973504 0.332861861510004 0.588465187037358 0.640307330403348 0.582254042755471 0.59221097693992 0.57611902810367 0.682931566080637 0.694784212730897 5 0.545291972003212 0.584210632971972 0.810870811602888 0.836899929519594 0.709011461350035 0.649768050102464 0.700184066308371 0.532206785163483 0.853976950339078 0.561095050557647 0.60997028881234 0.636029763289345 0.743838694259872 0.510261674576661 0 0.476300258746816 0.526916663583772 0.593846530768998 0.758314271175518 0.691571027310973 0.761795894022086 0.702775696818748 0.581204902584864 0.85891984357451 6 0.393272103797605 0.37822819560664 0.638724301482429 0.712346970098655 0.555007697254655 0.468877587536534 0.472868628510347 0.4397020901552 0.756087305765939 0.335593085096115 0.437494609608184 0.402589693145724 0.621437815990208 0.323081424973504 0.476300258746816 0 0.382921704843115 0.495001919452646 0.623361805111518 0.50370863979105 0.494400467755648 0.488742161380673 0.573395486170862 0.701044642267538 3 0.330797959207167 0.53024185913761 0.721802013418365 0.722493161303423 0.569632137079713 0.489021376289978 0.525506721244604 0.529224758564709 0.762966538206308 0.482301178660398 0.560278994397196 0.520623812716001 0.63532741224439 0.332861861510004 0.526916663583772 0.382921704843115 0 0.541116521910622 0.538929257690873 0.50363315957546 0.477667500339432 0.485484212285837 0.642536439557206 0.731616786185991 4 0.563648430837013 0.584066987502168 0.751900340516049 0.81059478353512 0.700292123849093 0.59989451354897 0.632959267911546 0.566927472518065 0.791917677364091 0.475008544079799 0.564565884853771 0.635315798842479 0.661420102186089 0.588465187037358 0.593846530768998 0.495001919452646 0.541116521910622 0 0.569041488360324 0.555333827555126 0.650999789659056 0.618391387774669 0.620122895019617 0.79004091039811 2 0.66523173799306 0.778451630131581 0.812623821498287 0.67179686908506 0.686164552961924 0.600155810641532 0.74368261302233 0.753903949731256 0.81258384801323 0.738041440415793 0.814568858546278 0.669112826680887 0.725910634940022 0.640307330403348 0.758314271175518 0.623361805111518 0.538929257690873 0.569041488360324 0 0.6473786039708 0.537771707661098 0.605751675531862 0.787300504670568 0.71419000634693 9 0.511183841155759 0.543847849995263 0.596958779537393 0.741190787334003 0.610923773488132 0.482373873247893 0.514539804165303 0.515921987762518 0.69092466328736 0.50014768619111 0.563078236117464 0.536517399269416 0.669519591989177 0.582254042755471 0.691571027310973 0.50370863979105 0.50363315957546 0.555333827555126 0.6473786039708 0 0.458910772686871 0.197543573969677 0.453468643433417 0.589071475907458 12 0.46804467412999 0.527747948281903 0.58038306362995 0.632934861831476 0.522084519099983 0.455971043613941 0.555492307675902 0.494683547387077 0.711493718852431 0.58859107425281 0.634425207383389 0.410136150776988 0.689034754247501 0.59221097693992 0.761795894022086 0.494400467755648 0.477667500339432 0.650999789659056 0.537771707661098 0.458910772686871 0 0.405413621307249 0.521219574609625 0.6041813253885 10 0.515485401604058 0.582043972050997 0.631041437421227 0.743347684665419 0.614601499571679 0.485136325934296 0.545820329626384 0.495896853216952 0.72961696443748 0.560373485926146 0.539163427744901 0.536831397119922 0.693127422615701 0.57611902810367 0.702775696818748 0.488742161380673 0.485484212285837 0.618391387774669 0.605751675531862 0.197543573969677 0.405413621307249 0 0.438888571031113 0.584480238627684 11 0.580143332456965 0.591017841508146 0.634765906326142 0.787761710107256 0.573249035174906 0.561030342274039 0.605832461377114 0.583525904687767 0.777088600232844 0.58991583345561 0.64719734947765 0.57987764447421 0.709588799419957 0.682931566080637 0.581204902584864 0.573395486170862 0.642536439557206 0.620122895019617 0.787300504670568 0.453468643433417 0.521219574609625 0.438888571031113 0 0.747120312482333 21 0.668700755517761 0.753206717859593 0.634430266921848 0.545259963579148 0.619889410480321 0.514596020968001 0.55345791449267 0.658433720786117 0.628275585712577 0.703705376166457 0.746247657025891 0.650019383574573 0.678749793333 0.694784212730897 0.85891984357451 0.701044642267538 0.731616786185991 0.79004091039811 0.71419000634693 0.589071475907458 0.6041813253885 0.584480238627684 0.747120312482333 0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/bioenv_exp_results_vegan.txt000066400000000000000000000003441446255456000275500ustar00rootroot00000000000000vars size correlation P 1 0.25163022609618835 P, Al 2 0.4003778484896049 P, Ca, Al 3 0.4004805867496183 P, Ca, pH, Al 4 0.3618749732452448 log(N), P, Ca, pH, Al 5 0.3215524892624249 log(N), P, K, Ca, pH, Al 6 0.2821814757209515 scikit-bio-0.5.9/skbio/stats/distance/tests/data/df.txt000066400000000000000000000012041446255456000230360ustar00rootroot00000000000000#SampleID TOT_ORG_CARB SILT_CLAY ELEVATION SOIL_MOISTURE_DEFICIT CARB_NITRO_RATIO ANNUAL_SEASON_TEMP ANNUAL_SEASON_PRECPT PH CMIN_RATE LONGITUDE LATITUDE CA1.141704 16.7 73 2003 198 13 10.3 400 7.27 2.276 -111.7666667 36.05 MT2.141698 39.1 35 1000 70 23.087 7 450 6.66 19.7 -114 46.8 CO2.141657 18.1 24 2400 104 31.8 6.1 350 5.68 9.223 -105.3333333 40.58333333 TL3.141709 53.9 52 894 -212 24.6 -9.3 400 4.23 16.456 -149.5833333 68.63333333 SN3.141650 16.6 20 3000 -252 13.9 3.6 600 5.74 6.289 -118.1666667 36.45 ExtraSample 42.0 42 -42 breh 3.6 602 1.74 0.289 -122.7 36.45 BB2.141659 52.2 44 400 -680 21.4 6.1 1200 4.6 2.223 -68.1 44.86666667 scikit-bio-0.5.9/skbio/stats/distance/tests/data/df_extra_column.txt000066400000000000000000000012701446255456000256210ustar00rootroot00000000000000#SampleID SILT_CLAY ELEVATION ExtraColumn SOIL_MOISTURE_DEFICIT ANNUAL_SEASON_TEMP CARB_NITRO_RATIO ANNUAL_SEASON_PRECPT PH CMIN_RATE LONGITUDE LATITUDE TOT_ORG_CARB TL3.141709 52 894 42 -212 -9.3 24.6 400 4.23 16.456 -149.5833333 68.63333333 53.9 MT2.141698 35 1000 column 70 7 23.087 450 6.66 19.7 -114 46.8 39.1 CO2.141657 24 2400 with 104 6.1 31.8 350 5.68 9.223 -105.3333333 40.58333333 18.1 ExtraSample 42 some -42 3.6 breh 602 1.74 0.289 -122.7 36.45 42.0 SN3.141650 20 3000 really -252 3.6 13.9 600 5.74 6.289 -118.1666667 36.45 16.6 BB2.141659 44 400 invalid -680 6.1 21.4 1200 4.6 2.223 -68.1 44.86666667 52.2 CA1.141704 73 2003 data 198 10.3 13 400 7.27 2.276 -111.7666667 36.05 16.7 scikit-bio-0.5.9/skbio/stats/distance/tests/data/dm.txt000066400000000000000000000011371446255456000230520ustar00rootroot00000000000000 MT2.141698 CA1.141704 BB2.141659 CO2.141657 TL3.141709 SN3.141650 MT2.141698 0.0 0.623818643706 0.750015427505 0.585201193913 0.729023583672 0.622135587669 CA1.141704 0.623818643706 0.0 0.774881224555 0.649822398416 0.777203137034 0.629507320436 BB2.141659 0.750015427505 0.774881224555 0.0 0.688845424001 0.567470311282 0.721707516043 CO2.141657 0.585201193913 0.649822398416 0.688845424001 0.0 0.658853575764 0.661223617505 TL3.141709 0.729023583672 0.777203137034 0.567470311282 0.658853575764 0.0 0.711173405838 SN3.141650 0.622135587669 0.629507320436 0.721707516043 0.661223617505 0.711173405838 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/dm2.txt000066400000000000000000000011371446255456000231340ustar00rootroot00000000000000 MT2.141698 CA1.141704 BB2.141659 CO2.141657 TL3.141709 SN3.141650 MT2.141698 0.0 0.623818643706 0.750015427505 0.585201193913 0.729023583672 0.822135587669 CA1.141704 0.623818643706 0.0 0.974881224555 0.649822398416 0.737203137034 0.629507320436 BB2.141659 0.750015427505 0.974881224555 0.0 0.688845424001 0.567470311282 0.721707516043 CO2.141657 0.585201193913 0.649822398416 0.688845424001 0.0 0.658853575764 0.661223617505 TL3.141709 0.729023583672 0.737203137034 0.567470311282 0.658853575764 0.0 0.711173405838 SN3.141650 0.822135587669 0.629507320436 0.721707516043 0.661223617505 0.711173405838 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/dm3.txt000066400000000000000000000011371446255456000231350ustar00rootroot00000000000000 MT2.141698 CA1.141704 BB2.141659 CO2.141657 TL3.141709 SN3.141650 MT2.141698 0.0 0.523818643706 0.750015427505 0.585201193913 0.729023583672 0.622135587669 CA1.141704 0.523818643706 0.0 0.774881224555 0.649822398416 0.777203137034 0.629507320436 BB2.141659 0.750015427505 0.774881224555 0.0 0.687745424001 0.567470311282 0.721707516043 CO2.141657 0.585201193913 0.649822398416 0.687745424001 0.0 0.658853575764 0.661223617505 TL3.141709 0.729023583672 0.777203137034 0.567470311282 0.658853575764 0.0 0.781173405838 SN3.141650 0.622135587669 0.629507320436 0.721707516043 0.661223617505 0.781173405838 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/dm4.txt000066400000000000000000000011371446255456000231360ustar00rootroot00000000000000 MT2.141698 CA1.141704 BB2.141659 CO2.141657 TL3.141709 SN3.141650 MT2.141698 0.0 0.623818643706 0.750015427505 0.585201193913 0.729023583672 0.652135587669 CA1.141704 0.623818643706 0.0 0.974881224555 0.649822398416 0.737203137034 0.629507320436 BB2.141659 0.750015427505 0.974881224555 0.0 0.688845424001 0.657470311282 0.721707516043 CO2.141657 0.585201193913 0.649822398416 0.688845424001 0.0 0.658853575764 0.661223617505 TL3.141709 0.729023583672 0.737203137034 0.657470311282 0.658853575764 0.0 0.711173405838 SN3.141650 0.652135587669 0.629507320436 0.721707516043 0.661223617505 0.711173405838 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/dm_reordered.txt000066400000000000000000000011371446255456000251050ustar00rootroot00000000000000 MT2.141698 CO2.141657 BB2.141659 CA1.141704 TL3.141709 SN3.141650 MT2.141698 0.0 0.585201193913 0.750015427505 0.623818643706 0.729023583672 0.622135587669 CO2.141657 0.585201193913 0.0 0.688845424001 0.649822398416 0.658853575764 0.661223617505 BB2.141659 0.750015427505 0.688845424001 0.0 0.774881224555 0.567470311282 0.721707516043 CA1.141704 0.623818643706 0.649822398416 0.774881224555 0.0 0.777203137034 0.629507320436 TL3.141709 0.729023583672 0.658853575764 0.567470311282 0.777203137034 0.0 0.711173405838 SN3.141650 0.622135587669 0.661223617505 0.721707516043 0.629507320436 0.711173405838 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/exp_results.txt000066400000000000000000000022251446255456000250260ustar00rootroot00000000000000vars size correlation PH 1 0.75 SOIL_MOISTURE_DEFICIT, PH 2 0.7464285714285714 SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, PH 3 0.8107142857142857 TOT_ORG_CARB, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, PH 4 0.8107142857142857 ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, PH 5 0.7892857142857144 TOT_ORG_CARB, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, PH 6 0.775 TOT_ORG_CARB, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, ANNUAL_SEASON_PRECPT, PH 7 0.7285714285714285 TOT_ORG_CARB, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, ANNUAL_SEASON_PRECPT, PH, CMIN_RATE 8 0.675 TOT_ORG_CARB, SILT_CLAY, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, ANNUAL_SEASON_PRECPT, PH, CMIN_RATE 9 0.6392857142857143 TOT_ORG_CARB, SILT_CLAY, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, ANNUAL_SEASON_PRECPT, PH, CMIN_RATE, LATITUDE 10 0.6071428571428571 TOT_ORG_CARB, SILT_CLAY, ELEVATION, SOIL_MOISTURE_DEFICIT, CARB_NITRO_RATIO, ANNUAL_SEASON_TEMP, ANNUAL_SEASON_PRECPT, PH, CMIN_RATE, LONGITUDE, LATITUDE 11 0.5392857142857144 scikit-bio-0.5.9/skbio/stats/distance/tests/data/exp_results_different_column_order.txt000066400000000000000000000022251446255456000316240ustar00rootroot00000000000000vars size correlation PH 1 0.75 PH, SOIL_MOISTURE_DEFICIT 2 0.7464285714285714 PH, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT 3 0.8107142857142857 PH, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, TOT_ORG_CARB 4 0.8107142857142857 PH, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION 5 0.7892857142857144 PH, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, TOT_ORG_CARB 6 0.775 PH, ANNUAL_SEASON_PRECPT, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, TOT_ORG_CARB 7 0.7285714285714285 CMIN_RATE, PH, ANNUAL_SEASON_PRECPT, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, TOT_ORG_CARB 8 0.675 CMIN_RATE, PH, ANNUAL_SEASON_PRECPT, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, SILT_CLAY, TOT_ORG_CARB 9 0.6392857142857143 LATITUDE, CMIN_RATE, PH, ANNUAL_SEASON_PRECPT, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, SILT_CLAY, TOT_ORG_CARB 10 0.6071428571428571 LATITUDE, LONGITUDE, CMIN_RATE, PH, ANNUAL_SEASON_PRECPT, ANNUAL_SEASON_TEMP, CARB_NITRO_RATIO, SOIL_MOISTURE_DEFICIT, ELEVATION, SILT_CLAY, TOT_ORG_CARB 11 0.5392857142857144 scikit-bio-0.5.9/skbio/stats/distance/tests/data/exp_results_single_column.txt000066400000000000000000000000401446255456000277350ustar00rootroot00000000000000vars size correlation PH 1 0.75 scikit-bio-0.5.9/skbio/stats/distance/tests/data/mantel_env_dm_vegan.txt000066400000000000000000000222401446255456000264400ustar00rootroot000000000000000 2.07679533239178 6.88145502389971 4.47292990349355 2.50815747366843 3.58036212296744 2.6591292750976 2.29553760953804 4.71171667874897 5.16305059040855 2.21426134242764 3.92961213866286 3.13399015473536 4.90270725079791 5.49476199174931 4.24083600731234 6.11441501785041 6.05615282291975 4.95222984315722 4.21090492925648 2.85939902504818 4.97193013540636 6.55517500441812 2.54101803759533 2.07679533239178 0 6.90291144667953 4.64003084174476 3.72544116897342 4.23057909059422 3.32236571813861 2.52327233791657 5.13562550988481 5.1437583829781 2.50862666200143 4.72257599677909 3.43881324942989 4.85150831682718 5.50342943536056 3.52222099128756 5.87491943777315 5.49066317297654 4.27208092800677 3.15270231033824 1.74819033890028 4.12374288054719 6.15931692104792 3.35050234347791 6.88145502389971 6.90291144667953 0 5.48014130249836 5.71422767011491 5.44458516207639 6.21128694887343 7.57897769844682 5.72787031540342 5.50347777475312 6.05215034685817 5.13756253132332 6.81750519634229 8.76568212120474 9.04444618731187 8.33992506606364 9.11412838063313 5.67503738892289 6.94693258686523 5.30131540387761 6.85740763239976 5.5325902108287 6.30781548936649 7.84284307315349 4.47292990349355 4.64003084174476 5.48014130249836 0 3.48549610587919 3.96397362332123 3.14459815680532 5.59791469171996 2.25198909783448 5.18311849821211 4.54741248463763 3.71058624754798 2.69797588499755 7.82504504220559 7.61406607135237 7.13381545095109 8.44384430044265 6.71088081591996 6.35910146136893 5.18001442223706 5.2381960545819 4.7094220651569 6.46329094926891 5.88708881996361 2.50815747366843 3.72544116897342 5.71422767011491 3.48549610587919 0 2.09064557523382 2.35007842477788 3.84437623072582 3.37982049066074 4.82948860655148 2.61344414995761 3.08212085298007 3.39826001248126 6.34083256759322 6.78044024394629 5.9882682085243 7.368182657586 6.29229240618139 5.93365009305124 4.74001147278235 4.16875045563175 5.19193126631916 6.60549692940372 3.75170839493609 3.58036212296744 4.23057909059422 5.44458516207639 3.96397362332123 2.09064557523382 0 2.91550590841545 4.53693024483879 4.16796766816088 4.70318440048524 2.79541837375649 3.79457424274492 4.23335312544269 6.52562476479155 7.28216604836819 6.15919058556992 7.48332275942444 6.29601002300864 6.13547796850531 4.6792323698443 4.45343001677936 5.90808732531762 7.12563061433389 4.29741620103145 2.6591292750976 3.32236571813861 6.21128694887343 3.14459815680532 2.35007842477788 2.91550590841545 0 3.03537232143609 3.19717141237262 4.78031309163852 2.41753325811849 3.59607995374352 2.12854912039549 5.46704031619679 5.33701156479808 4.96043060818422 6.44826304723108 6.36381765874823 5.33050747387333 4.28625407689455 3.30334570818273 4.94667231796753 6.31277712868333 3.58610710419189 2.29553760953804 2.52327233791657 7.57897769844682 5.59791469171996 3.84437623072582 4.53693024483879 3.03537232143609 0 5.42581905199784 5.5382425777602 2.21628461900339 4.91569734557852 3.76898373844346 3.66958270784948 3.7596809535214 3.09087676998529 5.16423793264611 6.19348191138961 4.67007617153741 4.11204634372634 2.12921147954829 5.20716627366845 6.64769970583513 2.40407490833653 4.71171667874897 5.13562550988481 5.72787031540342 2.25198909783448 3.37982049066074 4.16796766816088 3.19717141237262 5.42581905199784 0 4.78731905692567 4.50479586376459 3.38670838656427 3.20693742829686 7.42683056394166 7.34570046678601 7.17015799953149 7.98002716787638 6.41561622183692 6.2124182195955 5.39657010741707 5.54110800674231 5.15776751659351 6.8516874226519 6.10574081766257 5.16305059040855 5.1437583829781 5.50347777475312 5.18311849821211 4.82948860655148 4.70318440048524 4.78031309163852 5.5382425777602 4.78731905692567 0 4.67746569480341 4.08051856974203 5.63341628143736 6.13993687315028 7.7127998868603 6.72017341542958 6.71492819699427 4.33113554849634 4.44684649984502 4.82408553908334 5.61768442520245 5.26230208160398 6.54992709860496 6.42845550946653 2.21426134242764 2.50862666200143 6.05215034685817 4.54741248463763 2.61344414995761 2.79541837375649 2.41753325811849 2.21628461900339 4.50479586376459 4.67746569480341 0 3.67536647198733 3.50853972062287 4.8908007524505 5.29902826407876 4.05541661524461 6.11473384050956 5.23487714375643 4.87089053925741 3.21806378630338 2.37451207574614 5.0909474774308 6.73970215554685 3.03452592937357 3.92961213866286 4.72257599677909 5.13756253132332 3.71058624754798 3.08212085298007 3.79457424274492 3.59607995374352 4.91569734557852 3.38670838656427 4.08051856974203 3.67536647198733 0 3.67506523963379 6.73163254348659 7.18535849292866 6.60015854488732 7.50539564845393 4.98323825896227 5.96071394777962 4.63371782472599 5.21021128432828 5.3351470840398 6.70375146848393 5.02891238126826 3.13399015473536 3.43881324942989 6.81750519634229 2.69797588499755 3.39826001248126 4.23335312544269 2.12854912039549 3.76898373844346 3.20693742829686 5.63341628143736 3.50853972062287 3.67506523963379 0 6.07359964931452 5.55282592144639 5.28753056505203 6.86459352948227 6.60873730627615 5.6314567316324 4.5625504604801 3.80862359775727 4.74234966729958 6.39367296383052 4.14114063107224 4.90270725079791 4.85150831682718 8.76568212120474 7.82504504220559 6.34083256759322 6.52562476479155 5.46704031619679 3.66958270784948 7.42683056394166 6.13993687315028 4.8908007524505 6.73163254348659 6.07359964931452 0 3.95581421039689 2.89070054815662 2.00584491640009 6.4169416509523 3.98054063154574 5.12176871169235 4.25495681827209 6.42605641292207 6.84353264931 4.64487610678987 5.49476199174931 5.50342943536056 9.04444618731187 7.61406607135237 6.78044024394629 7.28216604836819 5.33701156479808 3.7596809535214 7.34570046678601 7.7127998868603 5.29902826407876 7.18535849292866 5.55282592144639 3.95581421039689 0 4.04435991796256 5.01228422881506 8.11947221764963 5.86295047339197 5.99126094814824 4.58960572590818 6.61131730349409 7.40381675001318 4.84021195384958 4.24083600731234 3.52222099128756 8.33992506606364 7.13381545095109 5.9882682085243 6.15919058556992 4.96043060818422 3.09087676998529 7.17015799953149 6.72017341542958 4.05541661524461 6.60015854488732 5.28753056505203 2.89070054815662 4.04435991796256 0 3.64256798987379 6.01870458325898 4.26211882754801 3.82653767294834 2.5630508080946 5.89444500689165 6.82255468001791 4.23311465341886 6.11441501785041 5.87491943777315 9.11412838063313 8.44384430044265 7.368182657586 7.48332275942444 6.44826304723108 5.16423793264611 7.98002716787638 6.71492819699427 6.11473384050956 7.50539564845393 6.86459352948227 2.00584491640009 5.01228422881506 3.64256798987379 0 6.60501226761683 3.94055918447939 5.63216883653706 5.30106624617202 6.83112869949915 6.80321310613232 6.05396442753773 6.05615282291975 5.49066317297654 5.67503738892289 6.71088081591996 6.29229240618139 6.29601002300864 6.36381765874823 6.19348191138961 6.41561622183692 4.33113554849634 5.23487714375643 4.98323825896227 6.60873730627615 6.4169416509523 8.11947221764963 6.01870458325898 6.60501226761683 0 4.58594627180039 3.55328319122345 5.54504004833869 5.61499654775589 6.828621895957 7.2430575511398 4.95222984315722 4.27208092800677 6.94693258686523 6.35910146136893 5.93365009305124 6.13547796850531 5.33050747387333 4.67007617153741 6.2124182195955 4.44684649984502 4.87089053925741 5.96071394777962 5.6314567316324 3.98054063154574 5.86295047339197 4.26211882754801 3.94055918447939 4.58594627180039 0 3.90515299381786 4.28027849695426 4.38635292373633 5.39036567068314 6.01887662312089 4.21090492925648 3.15270231033824 5.30131540387761 5.18001442223706 4.74001147278235 4.6792323698443 4.28625407689455 4.11204634372634 5.39657010741707 4.82408553908334 3.21806378630338 4.63371782472599 4.5625504604801 5.12176871169235 5.99126094814824 3.82653767294834 5.63216883653706 3.55328319122345 3.90515299381786 0 2.65742337348713 3.85104238688071 5.57317463010724 5.08393769559955 2.85939902504818 1.74819033890028 6.85740763239976 5.2381960545819 4.16875045563175 4.45343001677936 3.30334570818273 2.12921147954829 5.54110800674231 5.61768442520245 2.37451207574614 5.21021128432828 3.80862359775727 4.25495681827209 4.58960572590818 2.5630508080946 5.30106624617202 5.54504004833869 4.28027849695426 2.65742337348713 0 4.28103353313767 5.86614162833534 3.27887996130286 4.97193013540636 4.12374288054719 5.5325902108287 4.7094220651569 5.19193126631916 5.90808732531762 4.94667231796753 5.20716627366845 5.15776751659351 5.26230208160398 5.0909474774308 5.3351470840398 4.74234966729958 6.42605641292207 6.61131730349409 5.89444500689165 6.83112869949915 5.61499654775589 4.38635292373633 3.85104238688071 4.28103353313767 0 3.33721452854301 5.88678552682047 6.55517500441812 6.15931692104792 6.30781548936649 6.46329094926891 6.60549692940372 7.12563061433389 6.31277712868333 6.64769970583513 6.8516874226519 6.54992709860496 6.73970215554685 6.70375146848393 6.39367296383052 6.84353264931 7.40381675001318 6.82255468001791 6.80321310613232 6.828621895957 5.39036567068314 5.57317463010724 5.86614162833534 3.33721452854301 0 6.7434003020233 2.54101803759533 3.35050234347791 7.84284307315349 5.88708881996361 3.75170839493609 4.29741620103145 3.58610710419189 2.40407490833653 6.10574081766257 6.42845550946653 3.03452592937357 5.02891238126826 4.14114063107224 4.64487610678987 4.84021195384958 4.23311465341886 6.05396442753773 7.2430575511398 6.01887662312089 5.08393769559955 3.27887996130286 5.88678552682047 6.7434003020233 0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/mantel_veg_dm_vegan.txt000066400000000000000000000233161446255456000264360ustar00rootroot000000000000000 0.531002122667858 0.668066081456845 0.562124668311531 0.3747077813648 0.509473807708101 0.623441897868918 0.533760972316003 0.841820910455228 0.345334659061175 0.544980977465613 0.387906855391038 0.631889119284077 0.360369716481462 0.495569929879871 0.338230884557721 0.527747996119875 0.46940182727116 0.572409158546537 0.658356940509915 0.468803827751196 0.624899560429172 0.445852306473965 0.556086425651643 0.531002122667858 0 0.359778297016791 0.405560971081094 0.365209673840692 0.456075749605471 0.35795169856699 0.397667376920489 0.522541392379812 0.60638464347191 0.48037557590249 0.378418761774833 0.337611485751577 0.671739130434783 0.717861205915813 0.635512156237545 0.757850272278487 0.684397366160893 0.820626944245034 0.776103945014594 0.679419902681042 0.764456383429945 0.471627356163032 0.760728080850839 0.668066081456845 0.359778297016791 0 0.493494677463379 0.502030649266258 0.509231821290175 0.50100504976222 0.590762326930444 0.573666487726319 0.757674655787863 0.653360627772091 0.434689236988378 0.336909757263505 0.793106938610254 0.856175256640914 0.744137292184681 0.83821186778176 0.830987488829312 0.837255085778569 0.759051704257184 0.689453763842811 0.78428294394681 0.567737261531031 0.727272727272727 0.562124668311531 0.405560971081094 0.493494677463379 0 0.428611098255195 0.487819025522041 0.465522369035986 0.568393032270116 0.302780246286657 0.754373626373627 0.746791469651645 0.495783259540375 0.500159329903947 0.77929167212542 0.873218985388874 0.749693459050357 0.809023592216291 0.841379965785972 0.758192367410313 0.741589782845171 0.625361639704983 0.70965400435519 0.632291885091214 0.54560014236142 0.3747077813648 0.365209673840692 0.502030649266258 0.428611098255195 0 0.360624235718861 0.481270602337428 0.409431221365516 0.697951879101213 0.622147127631921 0.564580791354366 0.287701365077311 0.425861695209191 0.639083780437474 0.729525454839929 0.625248311481923 0.712879825495866 0.711791887728906 0.724986879144997 0.669388904533934 0.538476172358033 0.662547573180473 0.471028037383178 0.495122079839688 0.509473807708101 0.456075749605471 0.509231821290175 0.487819025522041 0.360624235718861 0 0.47264827514003 0.449673125625773 0.643173412512372 0.573924437650142 0.633194205745151 0.395377631035906 0.431129869389152 0.695857026807473 0.789820495341968 0.568402976531196 0.530275619878684 0.517760385310054 0.538922155688623 0.539314268896846 0.428855622420053 0.505990964447063 0.329349338004224 0.531589448015961 0.623441897868918 0.35795169856699 0.50100504976222 0.465522369035986 0.481270602337428 0.47264827514003 0 0.267803106717773 0.598566633402885 0.694873612095441 0.535760932030719 0.46270201874964 0.382298106172113 0.745988552125364 0.861145064293746 0.724916160609081 0.802615164256341 0.801531425047536 0.832146445891039 0.772508176966776 0.70517511761631 0.787532847973119 0.581221922731357 0.677116737663332 0.533760972316003 0.397667376920489 0.590762326930444 0.568393032270116 0.409431221365516 0.449673125625773 0.267803106717773 0 0.701535990362414 0.551494144215115 0.482635012046777 0.373779728755815 0.430605761857816 0.659614382490881 0.718478913197665 0.650987864807943 0.683795276397356 0.646264782232478 0.735420178184445 0.818586585827965 0.634216589861751 0.765659822656361 0.517282479141836 0.747455911343173 0.841820910455228 0.522541392379812 0.573666487726319 0.302780246286657 0.697951879101213 0.643173412512372 0.598566633402885 0.701535990362414 0 0.860012230114305 0.823966727319989 0.696356043704593 0.608614963860129 0.896020179372198 0.953959215457244 0.9014440433213 0.923448497952799 0.938116913005677 0.905321324457207 0.868666952421774 0.854316702819956 0.901660445359763 0.754406370224568 0.724877304998332 0.345334659061175 0.60638464347191 0.757674655787863 0.754373626373627 0.622147127631921 0.573924437650142 0.694873612095441 0.551494144215115 0.860012230114305 0 0.554756456358287 0.57855421686747 0.741260525644297 0.453305402640425 0.514898810129157 0.351567272898162 0.496547756041427 0.388174807197943 0.596869061623382 0.729252973406388 0.590238621498489 0.716043877642022 0.427280771201043 0.72127723067741 0.544980977465613 0.48037557590249 0.653360627772091 0.746791469651645 0.564580791354366 0.633194205745151 0.535760932030719 0.482635012046777 0.823966727319989 0.554756456358287 0 0.511525795828759 0.554151727277901 0.655082959520078 0.725768053508672 0.622747338353674 0.783666100254885 0.673474291206151 0.859248929176213 0.828249694002448 0.750707371556218 0.830408783452603 0.674327728932078 0.809644950779781 0.387906855391038 0.378418761774833 0.434689236988378 0.495783259540375 0.287701365077311 0.395377631035906 0.46270201874964 0.373779728755815 0.696356043704593 0.57855421686747 0.511525795828759 0 0.451855598406777 0.595916174099946 0.715382678751259 0.543911776469916 0.669047897880314 0.677185443802873 0.695153896529142 0.698248620855873 0.518242618672176 0.67063492063492 0.446171234812094 0.632043116119549 0.631889119284077 0.337611485751577 0.336909757263505 0.500159329903947 0.425861695209191 0.431129869389152 0.382298106172113 0.430605761857816 0.608614963860129 0.741260525644297 0.554151727277901 0.451855598406777 0 0.755672609400324 0.860085791452629 0.734387197501951 0.816868430229662 0.840013416065739 0.817908907547258 0.788424259207976 0.70625642943982 0.784595481217946 0.617593040115998 0.746623195156032 0.360369716481462 0.671739130434783 0.793106938610254 0.77929167212542 0.639083780437474 0.695857026807473 0.745988552125364 0.659614382490881 0.896020179372198 0.453305402640425 0.655082959520078 0.595916174099946 0.755672609400324 0 0.32374463790058 0.175471345902557 0.515448702689836 0.560172148132405 0.646577681901937 0.83184352597575 0.699166591988529 0.769745293466224 0.526223291092406 0.793334979017526 0.495569929879871 0.717861205915813 0.856175256640914 0.873218985388874 0.729525454839929 0.789820495341968 0.861145064293746 0.718478913197665 0.953959215457244 0.514898810129157 0.725768053508672 0.715382678751259 0.860085791452629 0.32374463790058 0 0.398453833811446 0.563443208895949 0.537750556792873 0.725759700794764 0.901458342917606 0.780864053688773 0.850419084461638 0.556379750493714 0.888831597401258 0.338230884557721 0.635512156237545 0.744137292184681 0.749693459050357 0.625248311481923 0.568402976531196 0.724916160609081 0.650987864807943 0.9014440433213 0.351567272898162 0.622747338353674 0.543911776469916 0.734387197501951 0.175471345902557 0.398453833811446 0 0.451762651100795 0.466509988249118 0.555275398861018 0.722312633832977 0.576246207195492 0.656792557980023 0.407794761777063 0.672014090541248 0.527747996119875 0.757850272278487 0.83821186778176 0.809023592216291 0.712879825495866 0.530275619878684 0.802615164256341 0.683795276397356 0.923448497952799 0.496547756041427 0.783666100254885 0.669047897880314 0.816868430229662 0.515448702689836 0.563443208895949 0.451762651100795 0 0.359268929503916 0.20992028343667 0.388581148863785 0.264185101779485 0.341337757596926 0.300259669263359 0.750777302759425 0.46940182727116 0.684397366160893 0.830987488829312 0.841379965785972 0.711791887728906 0.517760385310054 0.801531425047536 0.646264782232478 0.938116913005677 0.388174807197943 0.673474291206151 0.677185443802873 0.840013416065739 0.560172148132405 0.537750556792873 0.466509988249118 0.359268929503916 0 0.484114532261228 0.622234006652847 0.487074231539852 0.577606177606177 0.321596600394597 0.764130434782609 0.572409158546537 0.820626944245034 0.837255085778569 0.758192367410313 0.724986879144997 0.538922155688623 0.832146445891039 0.735420178184445 0.905321324457207 0.596869061623382 0.859248929176213 0.695153896529142 0.817908907547258 0.646577681901937 0.725759700794764 0.555275398861018 0.20992028343667 0.484114532261228 0 0.233028585612046 0.184614740719039 0.145672877846791 0.420959606845713 0.677966101694915 0.658356940509915 0.776103945014594 0.759051704257184 0.741589782845171 0.669388904533934 0.539314268896846 0.772508176966776 0.818586585827965 0.868666952421774 0.729252973406388 0.828249694002448 0.698248620855873 0.788424259207976 0.83184352597575 0.901458342917606 0.722312633832977 0.388581148863785 0.622234006652847 0.233028585612046 0 0.227722772277228 0.111727966689799 0.514525993883792 0.595256346665464 0.468803827751196 0.679419902681042 0.689453763842811 0.625361639704983 0.538476172358033 0.428855622420053 0.70517511761631 0.634216589861751 0.854316702819956 0.590238621498489 0.750707371556218 0.518242618672176 0.70625642943982 0.699166591988529 0.780864053688773 0.576246207195492 0.264185101779485 0.487074231539852 0.184614740719039 0.227722772277228 0 0.179336829499938 0.368810178817056 0.560213727907933 0.624899560429172 0.764456383429945 0.78428294394681 0.70965400435519 0.662547573180473 0.505990964447063 0.787532847973119 0.765659822656361 0.901660445359763 0.716043877642022 0.830408783452603 0.67063492063492 0.784595481217946 0.769745293466224 0.850419084461638 0.656792557980023 0.341337757596926 0.577606177606177 0.145672877846791 0.111727966689799 0.179336829499938 0 0.50435780791633 0.614787397309741 0.445852306473965 0.471627356163032 0.567737261531031 0.632291885091214 0.471028037383178 0.329349338004224 0.581221922731357 0.517282479141836 0.754406370224568 0.427280771201043 0.674327728932078 0.446171234812094 0.617593040115998 0.526223291092406 0.556379750493714 0.407794761777063 0.300259669263359 0.321596600394597 0.420959606845713 0.514525993883792 0.368810178817056 0.50435780791633 0 0.671336257723692 0.556086425651643 0.760728080850839 0.727272727272727 0.54560014236142 0.495122079839688 0.531589448015961 0.677116737663332 0.747455911343173 0.724877304998332 0.72127723067741 0.809644950779781 0.632043116119549 0.746623195156032 0.793334979017526 0.888831597401258 0.672014090541248 0.750777302759425 0.764130434782609 0.677966101694915 0.595256346665464 0.560213727907933 0.614787397309741 0.671336257723692 0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/moving_pictures_dm.tsv000066400000000000000000000502311446255456000263430ustar00rootroot00000000000000 L1S105 L1S140 L1S208 L1S257 L1S281 L1S57 L1S76 L1S8 L2S155 L2S175 L2S204 L2S222 L2S240 L2S309 L2S357 L2S382 L3S294 L3S313 L3S341 L3S360 L3S378 L4S112 L4S137 L4S63 L5S104 L5S155 L5S174 L5S203 L5S222 L5S240 L6S20 L6S68 L6S93 L1S105 0.0 0.5390370298457626 0.5958380256061412 0.5768343811669847 0.5923046539353664 0.44786237128294343 0.39489596582130626 0.5545584734774127 0.8628589351714164 0.8434498336351259 0.8592370856547886 0.8506877032999233 0.7889826076831608 0.8359411856255106 0.8200856211804968 0.8426252468809847 0.8588300792888636 0.7569476110839489 0.7737531468949157 0.8944159171736104 0.6033584308249973 0.8470795512030315 0.821242904747876 0.8652874911410461 0.7549182333398126 0.7223305078861331 0.7614916771466183 0.7384823167933402 0.7685949288454377 0.7217074962665071 0.7245343115615573 0.7830441925323288 0.7712136041691006 L1S140 0.5390370298457626 0.0 0.5799280564700269 0.5498337267462643 0.5487499420209432 0.5617578336407074 0.5274803712970444 0.5842935186320399 0.8425845430236847 0.7832827608957819 0.832335123190656 0.83707961792672 0.7311087382394217 0.7969572429804197 0.74931933992796 0.791784337383268 0.7891927506641839 0.6721331780898249 0.7493321619468443 0.8773425730913526 0.3943371737754427 0.8380071824429106 0.7797415033649835 0.8604626784828243 0.7389385379102201 0.713927118153038 0.7409814677579339 0.6893827188871452 0.739005471405395 0.7134211109446568 0.7210216228178491 0.7548606893628177 0.75650714031249 L1S208 0.5958380256061412 0.5799280564700269 0.0 0.3514478448812178 0.3099429863936709 0.4908395118886828 0.5060147104062029 0.5921114631534051 0.8899108348691316 0.871025922389371 0.882455510304791 0.8798738374168472 0.8153291321982421 0.8616764262370401 0.8215036618481708 0.8762874977082885 0.8826136551026731 0.8218942402038897 0.8270103157643566 0.8918833194204532 0.5595063305032598 0.8896853519676307 0.8701383470494592 0.9064920956741176 0.8245445313262268 0.7952347925702751 0.8252913142216206 0.7959214036381839 0.8153225533087411 0.7836084181624914 0.791415482862234 0.8107398191951546 0.8044123679011221 L1S257 0.5768343811669847 0.5498337267462643 0.3514478448812178 0.0 0.25929060246530955 0.47255177559300116 0.43222880359346527 0.5884066995223238 0.8795468292082718 0.8633179655119932 0.8688146996880899 0.8629186587174017 0.8190468684000036 0.8492352934610714 0.8120267566814204 0.8666693265827448 0.8777562843225813 0.802227485419459 0.8160964503323095 0.8817724113978568 0.5576854601824073 0.8747926182003918 0.858838497674028 0.8925129391873841 0.828703636427477 0.8010491792499632 0.8063815782189153 0.8092051698995067 0.806495056831578 0.8032210970007331 0.7958200880953574 0.8161661389998109 0.8303929119421523 L1S281 0.5923046539353664 0.5487499420209432 0.3099429863936709 0.25929060246530955 0.0 0.4609450181065116 0.4768241494226335 0.6336173247999576 0.8985838283907426 0.8902364311520621 0.8972881153423283 0.8878063096662511 0.842173339458122 0.8796280371215733 0.8476576569873849 0.8898292712501708 0.9039077039484619 0.8485533231569067 0.852633569868443 0.9096947429872373 0.5498250250306412 0.9022662022069642 0.8832755726058907 0.9169203743757105 0.8572110146660553 0.833803405339537 0.8394041604332061 0.8290963638641423 0.8384368165385457 0.8247152739488143 0.832089497492543 0.8365271234666928 0.8483699050146564 L1S57 0.44786237128294343 0.5617578336407074 0.4908395118886828 0.47255177559300116 0.4609450181065116 0.0 0.31082469034707255 0.5024096303529431 0.9113813328862811 0.9014185555334876 0.9014865706960162 0.8945638042848107 0.8714620677099987 0.8806337056845028 0.8481649374200068 0.9084204945482022 0.913489362275528 0.852617211132442 0.8535720478866394 0.9122868711391121 0.5758415360633006 0.9020100495580599 0.9027332494336695 0.9186219021297435 0.853072903040757 0.8327332298901452 0.8629325424179554 0.838123751985925 0.8659733546560768 0.8346642658091125 0.8289313199906942 0.8703637908123152 0.8629123642673379 L1S76 0.39489596582130626 0.5274803712970444 0.5060147104062029 0.43222880359346527 0.4768241494226335 0.31082469034707255 0.0 0.4003824579445799 0.894830907945713 0.8782305450289447 0.8768848673183877 0.8694496317335333 0.834400640278251 0.8645838229241534 0.8020621529524625 0.8821339436331491 0.8821873080715426 0.8108074314407202 0.8071422086314133 0.8931657453933083 0.5741407822604754 0.8800714967479438 0.8737823256177506 0.8981103792379882 0.8193019560519106 0.7921706586389919 0.8200532532128909 0.8020963162128805 0.8249980087726344 0.7949183972892307 0.7923436575946494 0.8310029142646927 0.8322683023877507 L1S8 0.5545584734774127 0.5842935186320399 0.5921114631534051 0.5884066995223238 0.6336173247999576 0.5024096303529431 0.4003824579445799 0.0 0.8984532053428095 0.8752689122693623 0.892740827989152 0.8922691853549297 0.8314474877203453 0.8600974905243383 0.8016996748131581 0.8870353495912263 0.8805255216909961 0.7980602019240324 0.829887986255906 0.8798293357284456 0.5576624158659516 0.8948846831679798 0.8816102418936791 0.9112039786090779 0.8148374423400107 0.7791385980867408 0.8123406708143702 0.8036845403456274 0.8182429195392156 0.786233773105675 0.785902469716853 0.8323093879065956 0.8268942255033314 L2S155 0.8628589351714164 0.8425845430236847 0.8899108348691316 0.8795468292082718 0.8985838283907426 0.9113813328862811 0.894830907945713 0.8984532053428095 0.0 0.46760603559570263 0.4249569948218847 0.43461957349574365 0.7136184283615585 0.3913207521607729 0.6347075539715223 0.7018474049205657 0.48529937944992957 0.6445967049513042 0.6384694268897185 0.4614095269789821 0.8793414820335794 0.49283220104466596 0.6490593420832039 0.47563246735903575 0.7320469060900457 0.8046481081885503 0.7992253539435805 0.7608659584888517 0.761349180972591 0.8017496796623877 0.7844856344015433 0.7648448360194874 0.7728251640763542 L2S175 0.8434498336351259 0.7832827608957819 0.871025922389371 0.8633179655119932 0.8902364311520621 0.9014185555334876 0.8782305450289447 0.8752689122693623 0.46760603559570263 0.0 0.4521351118370733 0.47450759266616915 0.6496968752812166 0.4163459132801876 0.5642253392315422 0.6035203651725982 0.4127343227632307 0.5009839698168453 0.5720541940600513 0.5238301647807445 0.8519601477875526 0.45057960516670714 0.6012619962408408 0.5452699437274425 0.7004211741288418 0.7254489332170817 0.7241658196524235 0.6728749977683892 0.7120770444662118 0.7067601324302817 0.7154192599371452 0.6790044090495644 0.6670904831025087 L2S204 0.8592370856547886 0.832335123190656 0.882455510304791 0.8688146996880899 0.8972881153423283 0.9014865706960162 0.8768848673183877 0.892740827989152 0.4249569948218847 0.4521351118370733 0.0 0.34707557932356076 0.7317461021420034 0.32542423370295653 0.5940997497062588 0.7202722055635978 0.46284470929748595 0.6399875240134363 0.5427529698531464 0.41546588368326215 0.8806954039760829 0.3819763193450203 0.6864606389600179 0.4541251117472289 0.7433650255074369 0.8140552153241122 0.8171702240197111 0.7787482342908187 0.7789238492726243 0.8145023991202386 0.797521853405542 0.7823436739920101 0.7825923091798144 L2S222 0.8506877032999233 0.83707961792672 0.8798738374168472 0.8629186587174017 0.8878063096662511 0.8945638042848107 0.8694496317335333 0.8922691853549297 0.43461957349574365 0.47450759266616915 0.34707557932356076 0.0 0.7373605415524003 0.38933892308526385 0.6131841736075622 0.7071347655059155 0.5297960404918108 0.6776613871707217 0.614146849517274 0.41910689292075193 0.8807526952301693 0.43694693261646017 0.6992608535946145 0.4512186030792239 0.7657709194380475 0.8264506476297601 0.8235579667989716 0.7929926795664424 0.7900065630791773 0.8272758828816869 0.8177374352486667 0.7787324503994212 0.7937870099703493 L2S240 0.7889826076831608 0.7311087382394217 0.8153291321982421 0.8190468684000036 0.842173339458122 0.8714620677099987 0.834400640278251 0.8314474877203453 0.7136184283615585 0.6496968752812166 0.7317461021420034 0.7373605415524003 0.0 0.7032990730427625 0.5742088858732407 0.5358811200052477 0.6113293724148627 0.5506881270264428 0.5515051266923414 0.7398454298135383 0.7579742017535656 0.7115018729258218 0.48083389190461734 0.7661067183222632 0.36560695464990867 0.4412731503394013 0.41030162605879844 0.38926922412434417 0.3758838249617733 0.43476390441875573 0.4013288162093646 0.29292532554452677 0.35832282922330977 L2S309 0.8359411856255106 0.7969572429804197 0.8616764262370401 0.8492352934610714 0.8796280371215733 0.8806337056845028 0.8645838229241534 0.8600974905243383 0.3913207521607729 0.4163459132801876 0.32542423370295653 0.38933892308526385 0.7032990730427625 0.0 0.5284516343093534 0.7093129471508985 0.41393505549147774 0.6241411216254367 0.5766719921218544 0.36061963338100667 0.8395112062787546 0.4200940359303599 0.6691543813483889 0.43557544512779306 0.7065436739270591 0.7784024482700062 0.7846395088210678 0.7393917740028452 0.7397915081982174 0.7798934785055419 0.7729246906860544 0.763695527435426 0.7629847033876873 L2S357 0.8200856211804968 0.74931933992796 0.8215036618481708 0.8120267566814204 0.8476576569873849 0.8481649374200068 0.8020621529524625 0.8016996748131581 0.6347075539715223 0.5642253392315422 0.5940997497062588 0.6131841736075622 0.5742088858732407 0.5284516343093534 0.0 0.6247944934502809 0.5283785180280727 0.44838682641972477 0.375128958725295 0.6121711834124891 0.8188660070261687 0.5950936496526126 0.542689027968325 0.6689211737896941 0.5421787179552776 0.6601284562072681 0.6793754491062178 0.5918194682678256 0.6055221091296257 0.6631138650570884 0.6559008959245738 0.6414849884779625 0.6348752854444591 L2S382 0.8426252468809847 0.791784337383268 0.8762874977082885 0.8666693265827448 0.8898292712501708 0.9084204945482022 0.8821339436331491 0.8870353495912263 0.7018474049205657 0.6035203651725982 0.7202722055635978 0.7071347655059155 0.5358811200052477 0.7093129471508985 0.6247944934502809 0.0 0.680488155634992 0.5879411676849041 0.6300513986721148 0.7798117418893309 0.8451713307652351 0.7053126728281367 0.29452174278276233 0.7387926847081081 0.6760422527308095 0.6989286770361658 0.6126816214335168 0.6413026519516322 0.6319640587005974 0.6916898221776602 0.6638186733377722 0.5262410574638753 0.5609030584455355 L3S294 0.8588300792888636 0.7891927506641839 0.8826136551026731 0.8777562843225813 0.9039077039484619 0.913489362275528 0.8821873080715426 0.8805255216909961 0.48529937944992957 0.4127343227632307 0.46284470929748595 0.5297960404918108 0.6113293724148627 0.41393505549147774 0.5283785180280727 0.680488155634992 0.0 0.5793151362285137 0.532519942057993 0.4417588676636619 0.8329083701065813 0.5166391190254049 0.6344485180123575 0.5880518426822319 0.6166977936514635 0.6976139122442497 0.6965206807593246 0.6533170380479183 0.6465722615751633 0.7007111257543401 0.697083374921763 0.7001623873009802 0.7062166839383266 L3S313 0.7569476110839489 0.6721331780898249 0.8218942402038897 0.802227485419459 0.8485533231569067 0.852617211132442 0.8108074314407202 0.7980602019240324 0.6445967049513042 0.5009839698168453 0.6399875240134363 0.6776613871707217 0.5506881270264428 0.6241411216254367 0.44838682641972477 0.5879411676849041 0.5793151362285137 0.0 0.45248307788083786 0.7165487737423945 0.76582414397238 0.6574105445715698 0.560831971453598 0.7171733441832148 0.5902731094836756 0.5532059333861852 0.5853434250505234 0.5025483834097694 0.561609978051379 0.5582681387584417 0.5694158492427435 0.6032070350377756 0.5911945286328084 L3S341 0.7737531468949157 0.7493321619468443 0.8270103157643566 0.8160964503323095 0.852633569868443 0.8535720478866394 0.8071422086314133 0.829887986255906 0.6384694268897185 0.5720541940600513 0.5427529698531464 0.614146849517274 0.5515051266923414 0.5766719921218544 0.375128958725295 0.6300513986721148 0.532519942057993 0.45248307788083786 0.0 0.6196019964860159 0.783720015310488 0.5829777947168483 0.5534737998316789 0.6520900532121093 0.5493281969319693 0.6308837007391367 0.652197593637747 0.6025364874432444 0.6084801413450426 0.6341899420458715 0.6354966927534835 0.6495259871270996 0.6352447858014029 L3S360 0.8944159171736104 0.8773425730913526 0.8918833194204532 0.8817724113978568 0.9096947429872373 0.9122868711391121 0.8931657453933083 0.8798293357284456 0.4614095269789821 0.5238301647807445 0.41546588368326215 0.41910689292075193 0.7398454298135383 0.36061963338100667 0.6121711834124891 0.7798117418893309 0.4417588676636619 0.7165487737423945 0.6196019964860159 0.0 0.886859306656774 0.5343546555847905 0.7414678143333879 0.5400460290177217 0.7495782488980336 0.8108767861286648 0.8149762338575348 0.7802652073770237 0.7846158292767554 0.81147352370555 0.8005244117641637 0.8006143679532055 0.8014989491687546 L3S378 0.6033584308249973 0.3943371737754427 0.5595063305032598 0.5576854601824073 0.5498250250306412 0.5758415360633006 0.5741407822604754 0.5576624158659516 0.8793414820335794 0.8519601477875526 0.8806954039760829 0.8807526952301693 0.7579742017535656 0.8395112062787546 0.8188660070261687 0.8451713307652351 0.8329083701065813 0.76582414397238 0.783720015310488 0.886859306656774 0.0 0.8878531310256906 0.8359164049140062 0.8993931924960518 0.7252856380797102 0.6746582064114732 0.7140756986649465 0.7000095154033142 0.7254146177064372 0.6747284675539041 0.694536665024702 0.750964397649065 0.7478762997708954 L4S112 0.8470795512030315 0.8380071824429106 0.8896853519676307 0.8747926182003918 0.9022662022069642 0.9020100495580599 0.8800714967479438 0.8948846831679798 0.49283220104466596 0.45057960516670714 0.3819763193450203 0.43694693261646017 0.7115018729258218 0.4200940359303599 0.5950936496526126 0.7053126728281367 0.5166391190254049 0.6574105445715698 0.5829777947168483 0.5343546555847905 0.8878531310256906 0.0 0.6481421375149321 0.3575409039402891 0.7357714051501275 0.809583225542944 0.8029186032245896 0.7654724305797693 0.7692411532770428 0.8100058186769521 0.7895581361870725 0.7651442703099545 0.7646440275794989 L4S137 0.821242904747876 0.7797415033649835 0.8701383470494592 0.858838497674028 0.8832755726058907 0.9027332494336695 0.8737823256177506 0.8816102418936791 0.6490593420832039 0.6012619962408408 0.6864606389600179 0.6992608535946145 0.48083389190461734 0.6691543813483889 0.542689027968325 0.29452174278276233 0.6344485180123575 0.560831971453598 0.5534737998316789 0.7414678143333879 0.8359164049140062 0.6481421375149321 0.0 0.6908078779515394 0.6039667084060777 0.680281107717286 0.5936509777076375 0.6119432909211573 0.6028821638318781 0.6703353838958876 0.6453016109359295 0.5078212308619812 0.5169165993321925 L4S63 0.8652874911410461 0.8604626784828243 0.9064920956741176 0.8925129391873841 0.9169203743757105 0.9186219021297435 0.8981103792379882 0.9112039786090779 0.47563246735903575 0.5452699437274425 0.4541251117472289 0.4512186030792239 0.7661067183222632 0.43557544512779306 0.6689211737896941 0.7387926847081081 0.5880518426822319 0.7171733441832148 0.6520900532121093 0.5400460290177217 0.8993931924960518 0.3575409039402891 0.6908078779515394 0.0 0.7771055341254081 0.8401318632573123 0.8278791663557197 0.8033319145222341 0.8021181534933208 0.8397629806795364 0.8174036603850671 0.8034029168891261 0.8047837943956528 L5S104 0.7549182333398126 0.7389385379102201 0.8245445313262268 0.828703636427477 0.8572110146660553 0.853072903040757 0.8193019560519106 0.8148374423400107 0.7320469060900457 0.7004211741288418 0.7433650255074369 0.7657709194380475 0.36560695464990867 0.7065436739270591 0.5421787179552776 0.6760422527308095 0.6166977936514635 0.5902731094836756 0.5493281969319693 0.7495782488980336 0.7252856380797102 0.7357714051501275 0.6039667084060777 0.7771055341254081 0.0 0.299746565246475 0.3717459070188454 0.30611431267503736 0.2687293485232606 0.29488133279702533 0.35282575882032935 0.4059272692757093 0.3546188970208585 L5S155 0.7223305078861331 0.713927118153038 0.7952347925702751 0.8010491792499632 0.833803405339537 0.8327332298901452 0.7921706586389919 0.7791385980867408 0.8046481081885503 0.7254489332170817 0.8140552153241122 0.8264506476297601 0.4412731503394013 0.7784024482700062 0.6601284562072681 0.6989286770361658 0.6976139122442497 0.5532059333861852 0.6308837007391367 0.8108767861286648 0.6746582064114732 0.809583225542944 0.680281107717286 0.8401318632573123 0.299746565246475 0.0 0.24482970831325948 0.21540954545570457 0.28453959248410193 0.08866970541518727 0.2086655812403446 0.42817224711244256 0.35580061290923976 L5S174 0.7614916771466183 0.7409814677579339 0.8252913142216206 0.8063815782189153 0.8394041604332061 0.8629325424179554 0.8200532532128909 0.8123406708143702 0.7992253539435805 0.7241658196524235 0.8171702240197111 0.8235579667989716 0.41030162605879844 0.7846395088210678 0.6793754491062178 0.6126816214335168 0.6965206807593246 0.5853434250505234 0.652197593637747 0.8149762338575348 0.7140756986649465 0.8029186032245896 0.5936509777076375 0.8278791663557197 0.3717459070188454 0.24482970831325948 0.0 0.2877214934590952 0.25347139824912546 0.2605730633285677 0.2559815010487754 0.27892381163313434 0.3053187587048309 L5S203 0.7384823167933402 0.6893827188871452 0.7959214036381839 0.8092051698995067 0.8290963638641423 0.838123751985925 0.8020963162128805 0.8036845403456274 0.7608659584888517 0.6728749977683892 0.7787482342908187 0.7929926795664424 0.38926922412434417 0.7393917740028452 0.5918194682678256 0.6413026519516322 0.6533170380479183 0.5025483834097694 0.6025364874432444 0.7802652073770237 0.7000095154033142 0.7654724305797693 0.6119432909211573 0.8033319145222341 0.30611431267503736 0.21540954545570457 0.2877214934590952 0.0 0.24311981207597314 0.2201431600708006 0.2346438472041132 0.333150002145841 0.2850632669863039 L5S222 0.7685949288454377 0.739005471405395 0.8153225533087411 0.806495056831578 0.8384368165385457 0.8659733546560768 0.8249980087726344 0.8182429195392156 0.761349180972591 0.7120770444662118 0.7789238492726243 0.7900065630791773 0.3758838249617733 0.7397915081982174 0.6055221091296257 0.6319640587005974 0.6465722615751633 0.561609978051379 0.6084801413450426 0.7846158292767554 0.7254146177064372 0.7692411532770428 0.6028821638318781 0.8021181534933208 0.2687293485232606 0.28453959248410193 0.25347139824912546 0.24311981207597314 0.0 0.31116489519567736 0.30117438587754664 0.29331724421227606 0.2904033216874486 L5S240 0.7217074962665071 0.7134211109446568 0.7836084181624914 0.8032210970007331 0.8247152739488143 0.8346642658091125 0.7949183972892307 0.786233773105675 0.8017496796623877 0.7067601324302817 0.8145023991202386 0.8272758828816869 0.43476390441875573 0.7798934785055419 0.6631138650570884 0.6916898221776602 0.7007111257543401 0.5582681387584417 0.6341899420458715 0.81147352370555 0.6747284675539041 0.8100058186769521 0.6703353838958876 0.8397629806795364 0.29488133279702533 0.08866970541518727 0.2605730633285677 0.2201431600708006 0.31116489519567736 0.0 0.21735399370958108 0.3819989872862365 0.3241682922704345 L6S20 0.7245343115615573 0.7210216228178491 0.791415482862234 0.7958200880953574 0.832089497492543 0.8289313199906942 0.7923436575946494 0.785902469716853 0.7844856344015433 0.7154192599371452 0.797521853405542 0.8177374352486667 0.4013288162093646 0.7729246906860544 0.6559008959245738 0.6638186733377722 0.697083374921763 0.5694158492427435 0.6354966927534835 0.8005244117641637 0.694536665024702 0.7895581361870725 0.6453016109359295 0.8174036603850671 0.35282575882032935 0.2086655812403446 0.2559815010487754 0.2346438472041132 0.30117438587754664 0.21735399370958108 0.0 0.36633132081192926 0.3477206555495855 L6S68 0.7830441925323288 0.7548606893628177 0.8107398191951546 0.8161661389998109 0.8365271234666928 0.8703637908123152 0.8310029142646927 0.8323093879065956 0.7648448360194874 0.6790044090495644 0.7823436739920101 0.7787324503994212 0.29292532554452677 0.763695527435426 0.6414849884779625 0.5262410574638753 0.7001623873009802 0.6032070350377756 0.6495259871270996 0.8006143679532055 0.750964397649065 0.7651442703099545 0.5078212308619812 0.8034029168891261 0.4059272692757093 0.42817224711244256 0.27892381163313434 0.333150002145841 0.29331724421227606 0.3819989872862365 0.36633132081192926 0.0 0.19042209104190255 L6S93 0.7712136041691006 0.75650714031249 0.8044123679011221 0.8303929119421523 0.8483699050146564 0.8629123642673379 0.8322683023877507 0.8268942255033314 0.7728251640763542 0.6670904831025087 0.7825923091798144 0.7937870099703493 0.35832282922330977 0.7629847033876873 0.6348752854444591 0.5609030584455355 0.7062166839383266 0.5911945286328084 0.6352447858014029 0.8014989491687546 0.7478762997708954 0.7646440275794989 0.5169165993321925 0.8047837943956528 0.3546188970208585 0.35580061290923976 0.3053187587048309 0.2850632669863039 0.2904033216874486 0.3241682922704345 0.3477206555495855 0.19042209104190255 0.0 scikit-bio-0.5.9/skbio/stats/distance/tests/data/moving_pictures_mf.tsv000066400000000000000000000071261446255456000263520ustar00rootroot00000000000000#SampleID BarcodeSequence LinkerPrimerSequence BodySite Year Month Day Subject ReportedAntibioticUsage DaysSinceExperimentStart Description L1S8 AGCTGACTAGTC GTGCCAGCMGCCGCGGTAA gut 2008 10 28 subject-1 Yes 0 subject-1.gut.2008-10-28 L1S57 ACACACTATGGC GTGCCAGCMGCCGCGGTAA gut 2009 1 20 subject-1 No 84 subject-1.gut.2009-1-20 L1S76 ACTACGTGTGGT GTGCCAGCMGCCGCGGTAA gut 2009 2 17 subject-1 No 112 subject-1.gut.2009-2-17 L1S105 AGTGCGATGCGT GTGCCAGCMGCCGCGGTAA gut 2009 3 17 subject-1 No 140 subject-1.gut.2009-3-17 L2S155 ACGATGCGACCA GTGCCAGCMGCCGCGGTAA left palm 2009 1 20 subject-1 No 84 subject-1.left-palm.2009-1-20 L2S175 AGCTATCCACGA GTGCCAGCMGCCGCGGTAA left palm 2009 2 17 subject-1 No 112 subject-1.left-palm.2009-2-17 L2S204 ATGCAGCTCAGT GTGCCAGCMGCCGCGGTAA left palm 2009 3 17 subject-1 No 140 subject-1.left-palm.2009-3-17 L2S222 CACGTGACATGT GTGCCAGCMGCCGCGGTAA left palm 2009 4 14 subject-1 No 168 subject-1.left-palm.2009-4-14 L3S242 ACAGTTGCGCGA GTGCCAGCMGCCGCGGTAA right palm 2008 10 28 subject-1 Yes 0 subject-1.right-palm.2008-10-28 L3S294 CACGACAGGCTA GTGCCAGCMGCCGCGGTAA right palm 2009 1 20 subject-1 No 84 subject-1.right-palm.2009-1-20 L3S313 AGTGTCACGGTG GTGCCAGCMGCCGCGGTAA right palm 2009 2 17 subject-1 No 112 subject-1.right-palm.2009-2-17 L3S341 CAAGTGAGAGAG GTGCCAGCMGCCGCGGTAA right palm 2009 3 17 subject-1 No 140 subject-1.right-palm.2009-3-17 L3S360 CATCGTATCAAC GTGCCAGCMGCCGCGGTAA right palm 2009 4 14 subject-1 No 168 subject-1.right-palm.2009-4-14 L5S104 CAGTGTCAGGAC GTGCCAGCMGCCGCGGTAA tongue 2008 10 28 subject-1 Yes 0 subject-1.tongue.2008-10-28 L5S155 ATCTTAGACTGC GTGCCAGCMGCCGCGGTAA tongue 2009 1 20 subject-1 No 84 subject-1.tongue.2009-1-20 L5S174 CAGACATTGCGT GTGCCAGCMGCCGCGGTAA tongue 2009 2 17 subject-1 No 112 subject-1.tongue.2009-2-17 L5S203 CGATGCACCAGA GTGCCAGCMGCCGCGGTAA tongue 2009 3 17 subject-1 No 140 subject-1.tongue.2009-3-17 L5S222 CTAGAGACTCTT GTGCCAGCMGCCGCGGTAA tongue 2009 4 14 subject-1 No 168 subject-1.tongue.2009-4-14 L1S140 ATGGCAGCTCTA GTGCCAGCMGCCGCGGTAA gut 2008 10 28 subject-2 Yes 0 subject-2.gut.2008-10-28 L1S208 CTGAGATACGCG GTGCCAGCMGCCGCGGTAA gut 2009 1 20 subject-2 No 84 subject-2.gut.2009-1-20 L1S257 CCGACTGAGATG GTGCCAGCMGCCGCGGTAA gut 2009 3 17 subject-2 No 140 subject-2.gut.2009-3-17 L1S281 CCTCTCGTGATC GTGCCAGCMGCCGCGGTAA gut 2009 4 14 subject-2 No 168 subject-2.gut.2009-4-14 L2S240 CATATCGCAGTT GTGCCAGCMGCCGCGGTAA left palm 2008 10 28 subject-2 Yes 0 subject-2.left-palm.2008-10-28 L2S309 CGTGCATTATCA GTGCCAGCMGCCGCGGTAA left palm 2009 1 20 subject-2 No 84 subject-2.left-palm.2009-1-20 L2S357 CTAACGCAGTCA GTGCCAGCMGCCGCGGTAA left palm 2009 3 17 subject-2 No 140 subject-2.left-palm.2009-3-17 L2S382 CTCAATGACTCA GTGCCAGCMGCCGCGGTAA left palm 2009 4 14 subject-2 No 168 subject-2.left-palm.2009-4-14 L3S378 ATCGATCTGTGG GTGCCAGCMGCCGCGGTAA right palm 2008 10 28 subject-2 Yes 0 subject-2.right-palm.2008-10-28 L4S63 CTCGTGGAGTAG GTGCCAGCMGCCGCGGTAA right palm 2009 1 20 subject-2 No 84 subject-2.right-palm.2009-1-20 L4S112 GCGTTACACACA GTGCCAGCMGCCGCGGTAA right palm 2009 3 17 subject-2 No 140 subject-2.right-palm.2009-3-17 L4S137 GAACTGTATCTC GTGCCAGCMGCCGCGGTAA right palm 2009 4 14 subject-2 No 168 subject-2.right-palm.2009-4-14 L5S240 CTGGACTCATAG GTGCCAGCMGCCGCGGTAA tongue 2008 10 28 subject-2 Yes 0 subject-2.tongue.2008-10-28 L6S20 GAGGCTCATCAT GTGCCAGCMGCCGCGGTAA tongue 2009 1 20 subject-2 No 84 subject-2.tongue.2009-1-20 L6S68 GATACGTCCTGA GTGCCAGCMGCCGCGGTAA tongue 2009 3 17 subject-2 No 140 subject-2.tongue.2009-3-17 L6S93 GATTAGCACTCT GTGCCAGCMGCCGCGGTAA tongue 2009 4 14 subject-2 No 168 subject-2.tongue.2009-4-14scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_all_dms.txt000066400000000000000000000005721446255456000304330ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative 0 1 0.7020310705446676 0.001 6 pearson 999 two-sided 0 2 0.8633966325233801 0.002 6 pearson 999 two-sided 0 3 0.6476901774685102 0.006 6 pearson 999 two-sided 1 2 0.7784836464659731 0.003 6 pearson 999 two-sided 1 3 0.9206880242368882 0.004 6 pearson 999 two-sided 2 3 0.7172972179393844 0.003 6 pearson 999 two-sided scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_dm_dm2.txt000066400000000000000000000001471446255456000301600ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative 0 1 0.702031 0.001 6 pearson 999 two-sided scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_duplicate_dms.txt000066400000000000000000000002371446255456000316330ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative 0 1 1.0 1.000 3 pearson 999 less 0 2 1.0 1.000 3 pearson 999 less 1 2 1.0 1.000 3 pearson 999 less scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_minimal.txt000066400000000000000000000003261446255456000304430ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative 0 1 0.7559289460184544 0.324 3 pearson 999 greater 0 2 -0.989743318610787 1.000 3 pearson 999 greater 1 2 -0.8416975766245421 0.835 3 pearson 999 greater scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_minimal_with_labels.txt000066400000000000000000000003501446255456000330150ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative minx miny 0.7559289460184544 0.324 3 pearson 999 greater minx minz -0.989743318610787 1.000 3 pearson 999 greater miny minz -0.8416975766245421 0.835 3 pearson 999 greater scikit-bio-0.5.9/skbio/stats/distance/tests/data/pwmantel_exp_results_na_p_value.txt000066400000000000000000000001371446255456000311260ustar00rootroot00000000000000dm1 dm2 statistic p-value n method permutations alternative 0 1 0.5 NaN 3 spearman 0 two-sided pwmantel_exp_results_reordered_distance_matrices.txt000066400000000000000000000003271446255456000344530ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/distance/tests/datadm1 dm2 statistic p-value n method permutations alternative 0 1 0.7559289460184544 0.324 3 pearson 999 greater 0 2 -0.9897433186107871 1.000 3 pearson 999 greater 1 2 -0.8416975766245421 0.822 3 pearson 999 greater scikit-bio-0.5.9/skbio/stats/distance/tests/test_anosim.py000066400000000000000000000113501446255456000236750ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from functools import partial from unittest import TestCase, main import numpy as np import pandas as pd from pandas.testing import assert_series_equal from skbio import DistanceMatrix from skbio.stats.distance import anosim class TestANOSIM(TestCase): """All results were verified with R (vegan::anosim).""" def setUp(self): # Distance matrices with and without ties in the ranks, with 2 groups # of equal size. dm_ids = ['s1', 's2', 's3', 's4'] self.grouping_equal = ['Control', 'Control', 'Fast', 'Fast'] self.df = pd.read_csv( io.StringIO('ID,Group\ns2,Control\ns3,Fast\ns4,Fast\ns5,Control\n' 's1,Control'), index_col=0) self.dm_ties = DistanceMatrix([[0, 1, 1, 4], [1, 0, 3, 2], [1, 3, 0, 3], [4, 2, 3, 0]], dm_ids) self.dm_no_ties = DistanceMatrix([[0, 1, 5, 4], [1, 0, 3, 2], [5, 3, 0, 3], [4, 2, 3, 0]], dm_ids) # Test with 3 groups of unequal size. This data also generates a # negative R statistic. self.grouping_unequal = ['Control', 'Treatment1', 'Treatment2', 'Treatment1', 'Control', 'Control'] # Equivalent grouping but with different labels -- groups should be # assigned different integer labels but results should be the same. self.grouping_unequal_relabeled = ['z', 42, 'abc', 42, 'z', 'z'] self.dm_unequal = DistanceMatrix( [[0.0, 1.0, 0.1, 0.5678, 1.0, 1.0], [1.0, 0.0, 0.002, 0.42, 0.998, 0.0], [0.1, 0.002, 0.0, 1.0, 0.123, 1.0], [0.5678, 0.42, 1.0, 0.0, 0.123, 0.43], [1.0, 0.998, 0.123, 0.123, 0.0, 0.5], [1.0, 0.0, 1.0, 0.43, 0.5, 0.0]], ['s1', 's2', 's3', 's4', 's5', 's6']) # Expected series index is the same across all tests. self.exp_index = ['method name', 'test statistic name', 'sample size', 'number of groups', 'test statistic', 'p-value', 'number of permutations'] # Stricter series equality testing than the default. self.assert_series_equal = partial(assert_series_equal, check_index_type=True, check_series_type=True) def test_ties(self): # Ensure we get the same results if we rerun the method using the same # inputs. Also ensure we get the same results if we run the method # using a grouping vector or a data frame with equivalent groupings. exp = pd.Series(index=self.exp_index, data=['ANOSIM', 'R', 4, 2, 0.25, 0.671, 999], name='ANOSIM results') for _ in range(2): np.random.seed(0) obs = anosim(self.dm_ties, self.grouping_equal) self.assert_series_equal(obs, exp) for _ in range(2): np.random.seed(0) obs = anosim(self.dm_ties, self.df, column='Group') self.assert_series_equal(obs, exp) def test_no_ties(self): exp = pd.Series(index=self.exp_index, data=['ANOSIM', 'R', 4, 2, 0.625, 0.332, 999], name='ANOSIM results') np.random.seed(0) obs = anosim(self.dm_no_ties, self.grouping_equal) self.assert_series_equal(obs, exp) def test_no_permutations(self): exp = pd.Series(index=self.exp_index, data=['ANOSIM', 'R', 4, 2, 0.625, np.nan, 0], name='ANOSIM results') obs = anosim(self.dm_no_ties, self.grouping_equal, permutations=0) self.assert_series_equal(obs, exp) def test_unequal_group_sizes(self): exp = pd.Series(index=self.exp_index, data=['ANOSIM', 'R', 6, 3, -0.363636, 0.878, 999], name='ANOSIM results') np.random.seed(0) obs = anosim(self.dm_unequal, self.grouping_unequal) self.assert_series_equal(obs, exp) np.random.seed(0) obs = anosim(self.dm_unequal, self.grouping_unequal_relabeled) self.assert_series_equal(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/distance/tests/test_base.py000066400000000000000000001300421446255456000233210ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import matplotlib as mpl import numpy as np import numpy.testing as npt import pandas as pd import pandas.testing as pdt import scipy.spatial.distance from IPython.core.display import Image, SVG import skbio.sequence.distance from skbio import DistanceMatrix, Sequence from skbio.stats.distance import ( DissimilarityMatrixError, DistanceMatrixError, MissingIDError, DissimilarityMatrix, randdm) from skbio.stats.distance._base import (_preprocess_input, _run_monte_carlo_stats) from skbio.stats.distance._utils import is_symmetric_and_hollow from skbio.util import assert_data_frame_almost_equal from skbio.util._testing import assert_series_almost_equal class DissimilarityMatrixTestData: def setUp(self): self.dm_1x1_data = [[0.0]] self.dm_2x2_data = [[0.0, 0.123], [0.123, 0.0]] self.dm_2x2_asym_data = [[0.0, 1.0], [-2.0, 0.0]] self.dm_3x3_data = [[0.0, 0.01, 4.2], [0.01, 0.0, 12.0], [4.2, 12.0, 0.0]] self.dm_5x5_data = [[0, 1, 2, 3, 4], [5, 0, 6, 7, 8], [9, 1, 0, 2, 3], [4, 5, 6, 0, 7], [8, 9, 1, 2, 0]] class DissimilarityMatrixTestBase(DissimilarityMatrixTestData): matobj = None def setUp(self): super(DissimilarityMatrixTestBase, self).setUp() self.dm_1x1 = self.matobj(self.dm_1x1_data, ['a']) self.dm_2x2 = self.matobj(self.dm_2x2_data, ['a', 'b']) self.dm_2x2_asym = self.matobj(self.dm_2x2_asym_data, ['a', 'b']) self.dm_3x3 = self.matobj(self.dm_3x3_data, ['a', 'b', 'c']) self.dm_5x5 = self.matobj(self.dm_5x5_data, list('abcde')) self.dms = [self.dm_1x1, self.dm_2x2, self.dm_2x2_asym, self.dm_3x3] self.dm_shapes = [(1, 1), (2, 2), (2, 2), (3, 3)] self.dm_sizes = [1, 4, 4, 9] self.dm_transposes = [ self.dm_1x1, self.dm_2x2, self.matobj([[0, -2], [1, 0]], ['a', 'b']), self.dm_3x3] self.dm_redundant_forms = [np.array(self.dm_1x1_data), np.array(self.dm_2x2_data), np.array(self.dm_2x2_asym_data), np.array(self.dm_3x3_data)] def test_avoid_copy_on_construction(self): # ((data, expect_copy)) tests = (([[0, 1], [1, 0]], True), ([(0, 1), (1, 0)], True), (((0, 1), (1, 0)), True), (np.array([[0, 1], [1, 0]], dtype='int'), True), (np.array([[0, 1], [1, 0]], dtype='float'), False), (np.array([[0, 1], [1, 0]], dtype=np.float32), False), (np.array([[0, 1], [1, 0]], dtype=np.float64), False), (np.array([[0, 1], [1, 0]], dtype='double'), False)) for data, expect in tests: obj = DissimilarityMatrix(data) self.assertEqual(id(obj.data) != id(data), expect) def test_within(self): exp = pd.DataFrame([['a', 'a', 0.0], ['a', 'c', 4.2], ['c', 'a', 4.2], ['c', 'c', 0.0]], columns=['i', 'j', 'value']) obs = self.dm_3x3.within(['a', 'c']) pdt.assert_frame_equal(obs, exp) def test_within_order_stability(self): exp = pd.DataFrame([['a', 'a', 0.0], ['a', 'c', 4.2], ['c', 'a', 4.2], ['c', 'c', 0.0]], columns=['i', 'j', 'value']) # NOTE: order was changed from ['a', 'c'] to ['c', 'a'] # but the output order in exp is consistent with # test_within obs = self.dm_3x3.within(['c', 'a']) pdt.assert_frame_equal(obs, exp) obs = self.dm_3x3.within(['a', 'c']) pdt.assert_frame_equal(obs, exp) def test_within_missing_id(self): with self.assertRaisesRegex(MissingIDError, "not found."): self.dm_3x3.within(['x', 'a']) def test_between(self): exp = pd.DataFrame([['b', 'a', 5.], ['b', 'c', 6.], ['b', 'e', 8.], ['d', 'a', 4.], ['d', 'c', 6.], ['d', 'e', 7.]], columns=['i', 'j', 'value']) obs = self.dm_5x5.between(['b', 'd'], ['a', 'c', 'e']) pdt.assert_frame_equal(obs, exp) def test_between_order_stability(self): exp = pd.DataFrame([['b', 'a', 5.], ['b', 'c', 6.], ['b', 'e', 8.], ['d', 'a', 4.], ['d', 'c', 6.], ['d', 'e', 7.]], columns=['i', 'j', 'value']) # varying the order of the "i" values, result remains consistent # with the test_between result obs = self.dm_5x5.between(['d', 'b'], ['a', 'c', 'e']) pdt.assert_frame_equal(obs, exp) # varying the order of the "j" values, result remains consistent # with the test_between result obs = self.dm_5x5.between(['b', 'd'], ['a', 'e', 'c']) pdt.assert_frame_equal(obs, exp) # varying the order of the "i" and "j" values, result remains # consistent with the test_between result obs = self.dm_5x5.between(['d', 'b'], ['a', 'e', 'c']) pdt.assert_frame_equal(obs, exp) def test_between_overlap(self): exp = pd.DataFrame([['b', 'a', 5.], ['b', 'd', 7.], ['b', 'e', 8.], ['d', 'a', 4.], ['d', 'd', 0.], ['d', 'e', 7.]], columns=['i', 'j', 'value']) # 'd' in i and j overlap with self.assertRaisesRegex(KeyError, ("This constraint can " "removed with " "allow_overlap=True.")): self.dm_5x5.between(['b', 'd'], ['a', 'd', 'e']) obs = self.dm_5x5.between(['b', 'd'], ['a', 'd', 'e'], allow_overlap=True) pdt.assert_frame_equal(obs, exp) def test_between_missing_id(self): with self.assertRaisesRegex(MissingIDError, "not found."): self.dm_3x3.between(['x', 'a'], ['a', 'b', 'c']) with self.assertRaisesRegex(MissingIDError, "not found."): self.dm_3x3.between(['a', 'b'], ['a', 'x', 'c']) with self.assertRaisesRegex(MissingIDError, "not found."): self.dm_3x3.between(['a', 'y'], ['a', 'x', 'c']) def test_stable_order(self): exp = np.array([1, 3, 4], dtype=int) obs = self.dm_5x5._stable_order(['d', 'e', 'b']) npt.assert_equal(obs, exp) def test_subset_to_dataframe(self): exp = pd.DataFrame([['b', 'a', 5.], ['b', 'd', 7.], ['b', 'e', 8.], ['d', 'a', 4.], ['d', 'd', 0.], ['d', 'e', 7.]], columns=['i', 'j', 'value']) obs = self.dm_5x5._subset_to_dataframe(['b', 'd'], ['a', 'd', 'e']) pdt.assert_frame_equal(obs, exp) # and the empty edge cases exp = pd.DataFrame([], columns=['i', 'j', 'value'], index=pd.RangeIndex(start=0, stop=0)) obs = self.dm_5x5._subset_to_dataframe([], ['a', 'd', 'e']) pdt.assert_frame_equal(obs, exp, check_dtype=False) obs = self.dm_5x5._subset_to_dataframe(['b', 'd'], []) pdt.assert_frame_equal(obs, exp, check_dtype=False) obs = self.dm_5x5._subset_to_dataframe([], []) pdt.assert_frame_equal(obs, exp, check_dtype=False) def test_init_from_dm(self): ids = ['foo', 'bar', 'baz'] # DissimilarityMatrix -> DissimilarityMatrix exp = self.matobj(self.dm_3x3_data, ids) obs = self.matobj(self.dm_3x3, ids) self.assertEqual(obs, exp) # Test that copy of data is not made. self.assertTrue(obs.data is self.dm_3x3.data) obs.data[0, 1] = 424242 self.assertTrue(np.array_equal(obs.data, self.dm_3x3.data)) # DistanceMatrix -> DissimilarityMatrix exp = self.matobj(self.dm_3x3_data, ids) obs = self.matobj( self.matobj(self.dm_3x3_data, ('a', 'b', 'c')), ids) self.assertEqual(obs, exp) # DissimilarityMatrix -> DistanceMatrix with self.assertRaises(DistanceMatrixError): DistanceMatrix(self.dm_2x2_asym, ['foo', 'bar']) def test_init_non_hollow_dm(self): data = [[1, 1], [1, 1]] obs = self.matobj(data, ['a', 'b']) self.assertTrue(np.array_equal(obs.data, data)) data_hollow = skbio.stats.distance._utils.is_hollow(obs.data) self.assertEqual(data_hollow, False) def test_init_no_ids(self): exp = self.matobj(self.dm_3x3_data, ('0', '1', '2')) obs = self.matobj(self.dm_3x3_data) self.assertEqual(obs, exp) self.assertEqual(obs['1', '2'], 12.0) def test_init_invalid_input(self): # Empty data. with self.assertRaises(DissimilarityMatrixError): self.matobj([], []) # Another type of empty data. with self.assertRaises(DissimilarityMatrixError): self.matobj(np.empty((0, 0)), []) # Invalid number of dimensions. with self.assertRaises(DissimilarityMatrixError): self.matobj([1, 2, 3], ['a']) # Dimensions don't match. with self.assertRaises(DissimilarityMatrixError): self.matobj([[1, 2, 3]], ['a']) data = [[0, 1], [1, 0]] # Duplicate IDs. with self.assertRaises(DissimilarityMatrixError): self.matobj(data, ['a', 'a']) # Number of IDs don't match dimensions. with self.assertRaises(DissimilarityMatrixError): self.matobj(data, ['a', 'b', 'c']) with self.assertRaises(DissimilarityMatrixError): self.matobj(data, []) def test_from_iterable_non_hollow_data(self): iterable = (x for x in range(4)) exp = self.matobj([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) res = self.matobj.from_iterable(iterable, lambda a, b: 1) self.assertEqual(res, exp) def test_from_iterable_asymmetric_data(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [-1, 0, 1, 2], [-2, -1, 0, 1], [-3, -2, -1, 0]]) res = self.matobj.from_iterable(iterable, lambda a, b: b - a) self.assertEqual(res, exp) def test_from_iterable_no_key(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]]) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a)) self.assertEqual(res, exp) def test_from_iterable_with_key(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]], ['0', '1', '4', '9']) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), key=lambda x: str(x ** 2)) self.assertEqual(res, exp) def test_from_iterable_empty(self): with self.assertRaises(DissimilarityMatrixError): self.matobj.from_iterable([], lambda x: x) def test_from_iterable_single(self): exp = self.matobj([[100]]) res = self.matobj.from_iterable(["boo"], lambda a, b: 100) self.assertEqual(res, exp) def test_from_iterable_with_keys(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]], ['0', '1', '4', '9']) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), keys=iter(['0', '1', '4', '9']) ) self.assertEqual(res, exp) def test_from_iterable_with_key_and_keys(self): iterable = (x for x in range(4)) with self.assertRaises(ValueError): self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), key=str, keys=['1', '2', '3', '4']) def test_from_iterable_scipy_hamming_metric_with_metadata(self): # test for #1254 seqs = [ Sequence('ACGT'), Sequence('ACGA', metadata={'id': 'seq1'}), Sequence('AAAA', metadata={'id': 'seq2'}), Sequence('AAAA', positional_metadata={'qual': range(4)}) ] exp = self.matobj([ [0, 0.25, 0.75, 0.75], [0.25, 0.0, 0.5, 0.5], [0.75, 0.5, 0.0, 0.0], [0.75, 0.5, 0.0, 0.0]], ['a', 'b', 'c', 'd']) dm = self.matobj.from_iterable( seqs, metric=scipy.spatial.distance.hamming, keys=['a', 'b', 'c', 'd']) self.assertEqual(dm, exp) def test_from_iterable_skbio_hamming_metric_with_metadata(self): # test for #1254 seqs = [ Sequence('ACGT'), Sequence('ACGA', metadata={'id': 'seq1'}), Sequence('AAAA', metadata={'id': 'seq2'}), Sequence('AAAA', positional_metadata={'qual': range(4)}) ] exp = self.matobj([ [0, 0.25, 0.75, 0.75], [0.25, 0.0, 0.5, 0.5], [0.75, 0.5, 0.0, 0.0], [0.75, 0.5, 0.0, 0.0]], ['a', 'b', 'c', 'd']) dm = self.matobj.from_iterable( seqs, metric=skbio.sequence.distance.hamming, keys=['a', 'b', 'c', 'd']) self.assertEqual(dm, exp) def test_data(self): for dm, exp in zip(self.dms, self.dm_redundant_forms): obs = dm.data self.assertTrue(np.array_equal(obs, exp)) with self.assertRaises(AttributeError): self.dm_3x3.data = 'foo' def test_ids(self): obs = self.dm_3x3.ids self.assertEqual(obs, ('a', 'b', 'c')) # Test that we overwrite the existing IDs and that the ID index is # correctly rebuilt. new_ids = ['foo', 'bar', 'baz'] self.dm_3x3.ids = new_ids obs = self.dm_3x3.ids self.assertEqual(obs, tuple(new_ids)) self.assertTrue(np.array_equal(self.dm_3x3['bar'], np.array([0.01, 0.0, 12.0]))) with self.assertRaises(MissingIDError): self.dm_3x3['b'] def test_ids_invalid_input(self): with self.assertRaises(DissimilarityMatrixError): self.dm_3x3.ids = ['foo', 'bar'] # Make sure that we can still use the dissimilarity matrix after trying # to be evil. obs = self.dm_3x3.ids self.assertEqual(obs, ('a', 'b', 'c')) def test_dtype(self): for dm in self.dms: self.assertEqual(dm.dtype, np.float64) def test_shape(self): for dm, shape in zip(self.dms, self.dm_shapes): self.assertEqual(dm.shape, shape) def test_size(self): for dm, size in zip(self.dms, self.dm_sizes): self.assertEqual(dm.size, size) def test_transpose(self): for dm, transpose in zip(self.dms, self.dm_transposes): self.assertEqual(dm.T, transpose) self.assertEqual(dm.transpose(), transpose) # We should get a reference to a different object back, even if the # transpose is the same as the original. self.assertTrue(dm.transpose() is not dm) def test_index(self): self.assertEqual(self.dm_3x3.index('a'), 0) self.assertEqual(self.dm_3x3.index('b'), 1) self.assertEqual(self.dm_3x3.index('c'), 2) with self.assertRaises(MissingIDError): self.dm_3x3.index('d') with self.assertRaises(MissingIDError): self.dm_3x3.index(1) def test_redundant_form(self): for dm, redundant in zip(self.dms, self.dm_redundant_forms): obs = dm.redundant_form() self.assertTrue(np.array_equal(obs, redundant)) def test_copy(self): copy = self.dm_2x2.copy() self.assertEqual(copy, self.dm_2x2) self.assertFalse(copy.data is self.dm_2x2.data) # deepcopy doesn't actually create a copy of the IDs because it is a # tuple of strings, which is fully immutable. self.assertTrue(copy.ids is self.dm_2x2.ids) new_ids = ['hello', 'world'] copy.ids = new_ids self.assertNotEqual(copy.ids, self.dm_2x2.ids) copy = self.dm_2x2.copy() copy.data[0, 1] = 0.0001 self.assertFalse(np.array_equal(copy.data, self.dm_2x2.data)) def test_filter_no_filtering(self): # Don't actually filter anything -- ensure we get back a different # object. obs = self.dm_3x3.filter(['a', 'b', 'c']) self.assertEqual(obs, self.dm_3x3) self.assertFalse(obs is self.dm_3x3) def test_filter_reorder(self): # Don't filter anything, but reorder the distance matrix. order = ['c', 'a', 'b'] exp = self.matobj( [[0, 4.2, 12], [4.2, 0, 0.01], [12, 0.01, 0]], order) obs = self.dm_3x3.filter(order) self.assertEqual(obs, exp) def test_filter_single_id(self): ids = ['b'] exp = self.matobj([[0]], ids) obs = self.dm_2x2_asym.filter(ids) self.assertEqual(obs, exp) def test_filter_asymmetric(self): # 2x2 ids = ['b', 'a'] exp = self.matobj([[0, -2], [1, 0]], ids) obs = self.dm_2x2_asym.filter(ids) self.assertEqual(obs, exp) # 3x3 dm = self.matobj([[0, 10, 53], [42, 0, 22.5], [53, 1, 0]], ('bro', 'brah', 'breh')) ids = ['breh', 'brah'] exp = self.matobj([[0, 1], [22.5, 0]], ids) obs = dm.filter(ids) self.assertEqual(obs, exp) def test_filter_subset(self): ids = ('c', 'a') exp = self.matobj([[0, 4.2], [4.2, 0]], ids) obs = self.dm_3x3.filter(ids) self.assertEqual(obs, exp) ids = ('b', 'a') exp = self.matobj([[0, 0.01], [0.01, 0]], ids) obs = self.dm_3x3.filter(ids) self.assertEqual(obs, exp) # 4x4 dm = self.matobj([[0, 1, 55, 7], [1, 0, 16, 1], [55, 16, 0, 23], [7, 1, 23, 0]]) ids = np.asarray(['3', '0', '1']) exp = self.matobj([[0, 7, 1], [7, 0, 1], [1, 1, 0]], ids) obs = dm.filter(ids) self.assertEqual(obs, exp) def test_filter_duplicate_ids(self): with self.assertRaises(DissimilarityMatrixError): self.dm_3x3.filter(['c', 'a', 'c']) def test_filter_missing_ids(self): with self.assertRaises(MissingIDError): self.dm_3x3.filter(['c', 'bro']) def test_filter_missing_ids_strict_false(self): # no exception should be raised ids = ('c', 'a') exp = self.matobj([[0, 4.2], [4.2, 0]], ids) obs = self.dm_3x3.filter(['c', 'a', 'not found'], strict=False) self.assertEqual(obs, exp) def test_filter_empty_ids(self): with self.assertRaises(DissimilarityMatrixError): self.dm_3x3.filter([]) def test_plot_default(self): fig = self.dm_1x1.plot() self.assertIsInstance(fig, mpl.figure.Figure) axes = fig.get_axes() self.assertEqual(len(axes), 2) ax = axes[0] self.assertEqual(ax.get_title(), '') xticks = [] for tick in ax.get_xticklabels(): xticks.append(tick.get_text()) self.assertEqual(xticks, ['a']) yticks = [] for tick in ax.get_yticklabels(): yticks.append(tick.get_text()) self.assertEqual(yticks, ['a']) def test_plot_no_default(self): ids = ['0', 'one', '2', 'three', '4.000'] data = ([0, 1, 2, 3, 4], [1, 0, 1, 2, 3], [2, 1, 0, 1, 2], [3, 2, 1, 0, 1], [4, 3, 2, 1, 0]) dm = self.matobj(data, ids) fig = dm.plot(cmap='Reds', title='Testplot') self.assertIsInstance(fig, mpl.figure.Figure) axes = fig.get_axes() self.assertEqual(len(axes), 2) ax = axes[0] self.assertEqual(ax.get_title(), 'Testplot') xticks = [] for tick in ax.get_xticklabels(): xticks.append(tick.get_text()) self.assertEqual(xticks, ['0', 'one', '2', 'three', '4.000']) yticks = [] for tick in ax.get_yticklabels(): yticks.append(tick.get_text()) self.assertEqual(yticks, ['0', 'one', '2', 'three', '4.000']) def test_repr_png(self): dm = self.dm_1x1 obs = dm._repr_png_() self.assertIsInstance(obs, bytes) self.assertTrue(len(obs) > 0) def test_repr_svg(self): obs = self.dm_1x1._repr_svg_() self.assertIsInstance(obs, str) self.assertTrue(len(obs) > 0) def test_png(self): dm = self.dm_1x1 self.assertIsInstance(dm.png, Image) def test_svg(self): dm = self.dm_1x1 self.assertIsInstance(dm.svg, SVG) def test_to_data_frame_1x1(self): df = self.dm_1x1.to_data_frame() exp = pd.DataFrame([[0.0]], index=['a'], columns=['a']) assert_data_frame_almost_equal(df, exp) def test_to_data_frame_3x3(self): df = self.dm_3x3.to_data_frame() exp = pd.DataFrame([[0.0, 0.01, 4.2], [0.01, 0.0, 12.0], [4.2, 12.0, 0.0]], index=['a', 'b', 'c'], columns=['a', 'b', 'c']) assert_data_frame_almost_equal(df, exp) def test_to_data_frame_default_ids(self): df = self.matobj(self.dm_2x2_data).to_data_frame() exp = pd.DataFrame([[0.0, 0.123], [0.123, 0.0]], index=['0', '1'], columns=['0', '1']) assert_data_frame_almost_equal(df, exp) def test_str(self): for dm in self.dms: obs = str(dm) # Do some very light testing here to make sure we're getting a # non-empty string back. We don't want to test the exact # formatting. self.assertTrue(obs) def test_eq(self): for dm in self.dms: copy = dm.copy() self.assertTrue(dm == dm) self.assertTrue(copy == copy) self.assertTrue(dm == copy) self.assertTrue(copy == dm) self.assertFalse(self.dm_1x1 == self.dm_3x3) def test_ne(self): # Wrong class. self.assertTrue(self.dm_3x3 != 'foo') # Wrong shape. self.assertTrue(self.dm_3x3 != self.dm_1x1) # Wrong IDs. other = self.dm_3x3.copy() other.ids = ['foo', 'bar', 'baz'] self.assertTrue(self.dm_3x3 != other) # Wrong data. other = self.dm_3x3.copy() other.data[1, 0] = 42.42 self.assertTrue(self.dm_3x3 != other) self.assertFalse(self.dm_2x2 != self.dm_2x2) def test_contains(self): self.assertTrue('a' in self.dm_3x3) self.assertTrue('b' in self.dm_3x3) self.assertTrue('c' in self.dm_3x3) self.assertFalse('d' in self.dm_3x3) def test_getslice(self): # Slice of first dimension only. Test that __getslice__ defers to # __getitem__. obs = self.dm_2x2[1:] self.assertTrue(np.array_equal(obs, np.array([[0.123, 0.0]]))) self.assertEqual(type(obs), np.ndarray) def test_getitem_by_id(self): obs = self.dm_1x1['a'] self.assertTrue(np.array_equal(obs, np.array([0.0]))) obs = self.dm_2x2_asym['b'] self.assertTrue(np.array_equal(obs, np.array([-2.0, 0.0]))) obs = self.dm_3x3['c'] self.assertTrue(np.array_equal(obs, np.array([4.2, 12.0, 0.0]))) with self.assertRaises(MissingIDError): self.dm_2x2['c'] def test_getitem_by_id_pair(self): # Same object. self.assertEqual(self.dm_1x1['a', 'a'], 0.0) # Different objects (symmetric). self.assertEqual(self.dm_3x3['b', 'c'], 12.0) self.assertEqual(self.dm_3x3['c', 'b'], 12.0) # Different objects (asymmetric). self.assertEqual(self.dm_2x2_asym['a', 'b'], 1.0) self.assertEqual(self.dm_2x2_asym['b', 'a'], -2.0) with self.assertRaises(MissingIDError): self.dm_2x2['a', 'c'] def test_getitem_ndarray_indexing(self): # Single element access. obs = self.dm_3x3[0, 1] self.assertEqual(obs, 0.01) # Single element access (via two __getitem__ calls). obs = self.dm_3x3[0][1] self.assertEqual(obs, 0.01) # Row access. obs = self.dm_3x3[1] self.assertTrue(np.array_equal(obs, np.array([0.01, 0.0, 12.0]))) self.assertEqual(type(obs), np.ndarray) # Grab all data. obs = self.dm_3x3[:, :] self.assertTrue(np.array_equal(obs, self.dm_3x3.data)) self.assertEqual(type(obs), np.ndarray) with self.assertRaises(IndexError): self.dm_3x3[:, 3] def test_validate_invalid_dtype(self): with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate(np.array([[0, 42], [42, 0]]), ['a', 'b']) def test_validate_invalid_shape(self): # first check it actually likes good matrices self.dm_3x3._validate_shape(np.array([[0., 42.], [42., 0.]])) # it checks just the shape, not the content self.dm_3x3._validate_shape(np.array([[1., 2.], [3., 4.]])) # empty array with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_shape(np.array([])) # invalid shape with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_shape(np.array([[0., 42.], [42., 0.], [22., 22.]])) with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_shape(np.array([[[0., 42.], [42., 0.]], [[0., 24.], [24., 0.]]])) def test_validate_invalid_ids(self): # repeated ids with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_ids(self.dm_3x3.data, ['a', 'a']) # empty ids with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_ids(self.dm_3x3.data, []) # invalid shape with self.assertRaises(DissimilarityMatrixError): self.dm_3x3._validate_ids(self.dm_3x3.data, ['a', 'b', 'c', 'd']) class DistanceMatrixTestBase(DissimilarityMatrixTestData): matobj = None def setUp(self): super(DistanceMatrixTestBase, self).setUp() self.dm_1x1 = self.matobj(self.dm_1x1_data, ['a']) self.dm_2x2 = self.matobj(self.dm_2x2_data, ['a', 'b']) self.dm_3x3 = self.matobj(self.dm_3x3_data, ['a', 'b', 'c']) self.dms = [self.dm_1x1, self.dm_2x2, self.dm_3x3] self.dm_condensed_forms = [np.array([]), np.array([0.123]), np.array([0.01, 4.2, 12.0])] def test_init_from_condensed_form(self): data = [1, 2, 3] exp = self.matobj([[0, 1, 2], [1, 0, 3], [2, 3, 0]], ['0', '1', '2']) res = self.matobj(data) self.assertEqual(exp, res) def test_init_invalid_input(self): # Asymmetric. data = [[0.0, 2.0], [1.0, 0.0]] with self.assertRaises(DistanceMatrixError): self.matobj(data, ['a', 'b']) # Non-hollow data = [[1.0, 2.0], [2.0, 1.0]] with self.assertRaises(DistanceMatrixError): self.matobj(data, ['a', 'b']) # Ensure that the superclass validation is still being performed. with self.assertRaises(DissimilarityMatrixError): self.matobj([[1, 2, 3]], ['a']) def test_init_nans(self): with self.assertRaisesRegex(DistanceMatrixError, r'NaNs'): self.matobj([[0.0, np.nan], [np.nan, 0.0]], ['a', 'b']) def test_from_iterable_no_key(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]]) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a)) self.assertEqual(res, exp) def test_from_iterable_validate_equal_valid_data(self): validate_true = self.matobj.from_iterable((x for x in range(4)), lambda a, b: abs(b - a), validate=True) validate_false = self.matobj.from_iterable((x for x in range(4)), lambda a, b: abs(b - a), validate=False) self.assertEqual(validate_true, validate_false) def test_from_iterable_validate_false(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]]) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), validate=False) self.assertEqual(res, exp) def test_from_iterable_validate_non_hollow(self): iterable = (x for x in range(4)) with self.assertRaises(DistanceMatrixError): self.matobj.from_iterable(iterable, lambda a, b: 1) def test_from_iterable_validate_false_non_symmetric(self): exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]]) res = self.matobj.from_iterable((x for x in range(4)), lambda a, b: a - b, validate=False) self.assertEqual(res, exp) def test_from_iterable_validate_asym(self): iterable = (x for x in range(4)) with self.assertRaises(DistanceMatrixError): self.matobj.from_iterable(iterable, lambda a, b: b - a) def test_from_iterable_with_key(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]], ['0', '1', '4', '9']) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), key=lambda x: str(x**2)) self.assertEqual(res, exp) def test_from_iterable_empty(self): with self.assertRaises(DissimilarityMatrixError): self.matobj.from_iterable([], lambda x: x) def test_from_iterable_single(self): exp = self.matobj([[0]]) res = self.matobj.from_iterable(["boo"], lambda a, b: 0) self.assertEqual(res, exp) def test_from_iterable_with_keys(self): iterable = (x for x in range(4)) exp = self.matobj([[0, 1, 2, 3], [1, 0, 1, 2], [2, 1, 0, 1], [3, 2, 1, 0]], ['0', '1', '4', '9']) res = self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), keys=iter(['0', '1', '4', '9'])) self.assertEqual(res, exp) def test_from_iterable_with_key_and_keys(self): iterable = (x for x in range(4)) with self.assertRaises(ValueError): self.matobj.from_iterable(iterable, lambda a, b: abs(b - a), key=str, keys=['1', '2', '3', '4']) def test_from_iterable_scipy_hamming_metric_with_metadata(self): # test for #1254 seqs = [ Sequence('ACGT'), Sequence('ACGA', metadata={'id': 'seq1'}), Sequence('AAAA', metadata={'id': 'seq2'}), Sequence('AAAA', positional_metadata={'qual': range(4)}) ] exp = self.matobj([ [0, 0.25, 0.75, 0.75], [0.25, 0.0, 0.5, 0.5], [0.75, 0.5, 0.0, 0.0], [0.75, 0.5, 0.0, 0.0]], ['a', 'b', 'c', 'd']) dm = self.matobj.from_iterable( seqs, metric=scipy.spatial.distance.hamming, keys=['a', 'b', 'c', 'd']) self.assertEqual(dm, exp) def test_from_iterable_skbio_hamming_metric_with_metadata(self): # test for #1254 seqs = [ Sequence('ACGT'), Sequence('ACGA', metadata={'id': 'seq1'}), Sequence('AAAA', metadata={'id': 'seq2'}), Sequence('AAAA', positional_metadata={'qual': range(4)}) ] exp = self.matobj([ [0, 0.25, 0.75, 0.75], [0.25, 0.0, 0.5, 0.5], [0.75, 0.5, 0.0, 0.0], [0.75, 0.5, 0.0, 0.0]], ['a', 'b', 'c', 'd']) dm = self.matobj.from_iterable( seqs, metric=skbio.sequence.distance.hamming, keys=['a', 'b', 'c', 'd']) self.assertEqual(dm, exp) def test_condensed_form(self): for dm, condensed in zip(self.dms, self.dm_condensed_forms): obs = dm.condensed_form() self.assertTrue(np.array_equal(obs, condensed)) def test_permute_condensed(self): # Can't really permute a 1x1 or 2x2... for _ in range(2): obs = self.dm_1x1.permute(condensed=True) npt.assert_equal(obs, np.array([])) for _ in range(2): obs = self.dm_2x2.permute(condensed=True) npt.assert_equal(obs, np.array([0.123])) dm_copy = self.dm_3x3.copy() np.random.seed(0) obs = self.dm_3x3.permute(condensed=True) npt.assert_equal(obs, np.array([12.0, 4.2, 0.01])) obs = self.dm_3x3.permute(condensed=True) npt.assert_equal(obs, np.array([4.2, 12.0, 0.01])) # Ensure dm hasn't changed after calling permute() on it a couple of # times. self.assertEqual(self.dm_3x3, dm_copy) def test_permute_not_condensed(self): obs = self.dm_1x1.permute() self.assertEqual(obs, self.dm_1x1) self.assertFalse(obs is self.dm_1x1) obs = self.dm_2x2.permute() self.assertEqual(obs, self.dm_2x2) self.assertFalse(obs is self.dm_2x2) np.random.seed(0) exp = self.matobj([[0, 12, 4.2], [12, 0, 0.01], [4.2, 0.01, 0]], self.dm_3x3.ids) obs = self.dm_3x3.permute() self.assertEqual(obs, exp) exp = self.matobj([[0, 4.2, 12], [4.2, 0, 0.01], [12, 0.01, 0]], self.dm_3x3.ids) obs = self.dm_3x3.permute() self.assertEqual(obs, exp) def test_eq(self): # Compare DistanceMatrix to DissimilarityMatrix, where both have the # same data and IDs. eq_dm = DissimilarityMatrix(self.dm_3x3_data, ['a', 'b', 'c']) self.assertTrue(self.dm_3x3 == eq_dm) self.assertTrue(eq_dm == self.dm_3x3) def test_to_series_1x1(self): series = self.dm_1x1.to_series() exp = pd.Series([], index=[], dtype='float64') assert_series_almost_equal(series, exp) def test_to_series_2x2(self): series = self.dm_2x2.to_series() exp = pd.Series([0.123], index=pd.Index([('a', 'b')])) assert_series_almost_equal(series, exp) def test_to_series_4x4(self): dm = self.matobj([ [0.0, 0.2, 0.3, 0.4], [0.2, 0.0, 0.5, 0.6], [0.3, 0.5, 0.0, 0.7], [0.4, 0.6, 0.7, 0.0]], ['a', 'b', 'c', 'd']) series = dm.to_series() exp = pd.Series([0.2, 0.3, 0.4, 0.5, 0.6, 0.7], index=pd.Index([('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')])) assert_series_almost_equal(series, exp) def test_to_series_default_ids(self): series = self.matobj(self.dm_2x2_data).to_series() exp = pd.Series([0.123], index=pd.Index([('0', '1')])) assert_series_almost_equal(series, exp) def test_validate_asym_shape(self): # first check it actually likes good matrices data_good = np.array([[0., 42.], [42., 0.]]) data_sym, data_hollow = is_symmetric_and_hollow(data_good) self.assertEqual(data_sym, True) del data_sym self.assertEqual(data_hollow, True) del data_hollow data_sym = skbio.stats.distance._utils.is_symmetric(data_good) self.assertEqual(data_sym, True) del data_sym data_hollow = skbio.stats.distance._utils.is_hollow(data_good) self.assertEqual(data_hollow, True) del data_hollow self.dm_3x3._validate_shape(data_good) del data_good # _validate_shap checks just the shape, not the content bad_data = np.array([[1., 2.], [3., 4.]]) data_sym, data_hollow = is_symmetric_and_hollow(bad_data) self.assertEqual(data_sym, False) del data_sym self.assertEqual(data_hollow, False) del data_hollow data_sym = skbio.stats.distance._utils.is_symmetric(bad_data) self.assertEqual(data_sym, False) del data_sym data_hollow = skbio.stats.distance._utils.is_hollow(bad_data) self.assertEqual(data_hollow, False) del data_hollow self.dm_3x3._validate_shape(bad_data) del bad_data # re-try with partially bad data bad_data = np.array([[0., 2.], [3., 0.]]) data_sym, data_hollow = is_symmetric_and_hollow(bad_data) self.assertEqual(data_sym, False) del data_sym self.assertEqual(data_hollow, True) del data_hollow data_sym = skbio.stats.distance._utils.is_symmetric(bad_data) self.assertEqual(data_sym, False) del data_sym data_hollow = skbio.stats.distance._utils.is_hollow(bad_data) self.assertEqual(data_hollow, True) del data_hollow self.dm_3x3._validate_shape(bad_data) del bad_data class RandomDistanceMatrixTests(TestCase): def test_default_usage(self): exp = DistanceMatrix(np.asarray([[0.0]]), ['1']) obs = randdm(1) self.assertEqual(obs, exp) obs = randdm(2) self.assertEqual(obs.shape, (2, 2)) self.assertEqual(obs.ids, ('1', '2')) obs1 = randdm(5) num_trials = 10 found_diff = False for _ in range(num_trials): obs2 = randdm(5) if obs1 != obs2: found_diff = True break self.assertTrue(found_diff) def test_large_matrix_for_symmetry(self): obs3 = randdm(100) self.assertEqual(obs3, obs3.T) def test_ids(self): ids = ['foo', 'bar', 'baz'] obs = randdm(3, ids=ids) self.assertEqual(obs.shape, (3, 3)) self.assertEqual(obs.ids, tuple(ids)) def test_constructor(self): exp = DissimilarityMatrix(np.asarray([[0.0]]), ['1']) obs = randdm(1, constructor=DissimilarityMatrix) self.assertEqual(obs, exp) self.assertEqual(type(obs), DissimilarityMatrix) def test_random_fn(self): def myrand(num_rows, num_cols): # One dm to rule them all... data = np.empty((num_rows, num_cols)) data.fill(42) return data exp = DistanceMatrix(np.asarray([[0, 42, 42], [42, 0, 42], [42, 42, 0]]), ['1', '2', '3']) obs = randdm(3, random_fn=myrand) self.assertEqual(obs, exp) def test_invalid_input(self): # Invalid dimensions. with self.assertRaises(DissimilarityMatrixError): randdm(0) # Invalid dimensions. with self.assertRaises(ValueError): randdm(-1) # Invalid number of IDs. with self.assertRaises(DissimilarityMatrixError): randdm(2, ids=['foo']) class CategoricalStatsHelperFunctionTests(TestCase): def setUp(self): self.dm = DistanceMatrix([[0.0, 1.0, 2.0], [1.0, 0.0, 3.0], [2.0, 3.0, 0.0]], ['a', 'b', 'c']) self.grouping = [1, 2, 1] # Ordering of IDs shouldn't matter, nor should extra IDs. self.df = pd.read_csv( io.StringIO('ID,Group\nb,Group2\na,Group1\nc,Group1\nd,Group3'), index_col=0) self.df_missing_id = pd.read_csv( io.StringIO('ID,Group\nb,Group2\nc,Group1'), index_col=0) def test_preprocess_input_with_valid_input(self): # Should obtain same result using grouping vector or data frame. exp = (3, 2, np.array([0, 1, 0]), (np.array([0, 0, 1]), np.array([1, 2, 2])), np.array([1., 2., 3.])) obs = _preprocess_input(self.dm, self.grouping, None) npt.assert_equal(obs, exp) obs = _preprocess_input(self.dm, self.df, 'Group') npt.assert_equal(obs, exp) def test_preprocess_input_raises_error(self): # Requires a DistanceMatrix. with self.assertRaises(TypeError): _preprocess_input( DissimilarityMatrix([[0, 2], [3, 0]], ['a', 'b']), [1, 2], None) # Requires column if DataFrame. with self.assertRaises(ValueError): _preprocess_input(self.dm, self.df, None) # Cannot provide column if not data frame. with self.assertRaises(ValueError): _preprocess_input(self.dm, self.grouping, 'Group') # Column must exist in data frame. with self.assertRaises(ValueError): _preprocess_input(self.dm, self.df, 'foo') # All distance matrix IDs must be in data frame. with self.assertRaises(ValueError): _preprocess_input(self.dm, self.df_missing_id, 'Group') # Grouping vector length must match number of objects in dm. with self.assertRaises(ValueError): _preprocess_input(self.dm, [1, 2], None) # Grouping vector cannot have only unique values. with self.assertRaises(ValueError): _preprocess_input(self.dm, [1, 2, 3], None) # Grouping vector cannot have only a single group. with self.assertRaises(ValueError): _preprocess_input(self.dm, [1, 1, 1], None) def test_run_monte_carlo_stats_with_permutations(self): obs = _run_monte_carlo_stats(lambda e: 42, self.grouping, 50) npt.assert_equal(obs, (42, 1.0)) def test_run_monte_carlo_stats_no_permutations(self): obs = _run_monte_carlo_stats(lambda e: 42, self.grouping, 0) npt.assert_equal(obs, (42, np.nan)) def test_run_monte_carlo_stats_invalid_permutations(self): with self.assertRaises(ValueError): _run_monte_carlo_stats(lambda e: 42, self.grouping, -1) class DissimilarityMatrixTests(DissimilarityMatrixTestBase, TestCase): matobj = DissimilarityMatrix def setUp(self): super(DissimilarityMatrixTests, self).setUp() class DistanceMatrixTests(DistanceMatrixTestBase, TestCase): matobj = DistanceMatrix def setUp(self): super(DistanceMatrixTests, self).setUp() if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/distance/tests/test_bioenv.py000066400000000000000000000232761446255456000237030ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import pandas as pd from skbio import DistanceMatrix from skbio.stats.distance import bioenv from skbio.stats.distance._bioenv import _scale from skbio.util import get_data_path, assert_data_frame_almost_equal class BIOENVTests(TestCase): """Results were verified with R 3.0.2 and vegan 2.0-10 (vegan::bioenv).""" def setUp(self): # The test dataset used here is a subset of the Lauber et al. 2009 # "88 Soils" dataset. It has been altered to exercise various aspects # of the code, including (but not limited to): # # - order of distance matrix IDs and IDs in data frame (metadata) are # not exactly the same # - data frame has an extra sample that is not in the distance matrix # - this extra sample has non-numeric and missing values in some of its # cells # # Additional variations of the distance matrix and data frame are used # to test different orderings of rows/columns, extra non-numeric data # frame columns, etc. # # This dataset is also useful because it is non-trivial in size (6 # samples, 11 environment variables) and it includes positive/negative # floats and integers in the data frame. self.dm = DistanceMatrix.read(get_data_path('dm.txt')) # Reordered rows and columns (i.e., different ID order). Still # conceptually the same distance matrix. self.dm_reordered = DistanceMatrix.read( get_data_path('dm_reordered.txt')) self.df = pd.read_csv(get_data_path('df.txt'), sep='\t', index_col=0) # Similar to the above data frame, except that it has an extra # non-numeric column, and some of the other rows and columns have been # reordered. self.df_extra_column = pd.read_csv( get_data_path('df_extra_column.txt'), sep='\t', index_col=0) # All columns in the original data frame (these are all numeric # columns). self.cols = self.df.columns.tolist() # This second dataset is derived from vegan::bioenv's example dataset # (varespec and varechem). The original dataset includes a site x # species table (e.g., OTU table) and a data frame of environmental # variables. Since the bioenv function defined here accepts a distance # matrix, we use a Bray-Curtis distance matrix that is derived from the # site x species table (this matches what is done by vegan::bioenv when # provided an OTU table, using their default distance measure). The # data frame only includes the numeric environmental variables we're # interested in for these tests: log(N), P, K, Ca, pH, Al self.dm_vegan = DistanceMatrix.read( get_data_path('bioenv_dm_vegan.txt')) self.df_vegan = pd.read_csv( get_data_path('bioenv_df_vegan.txt'), sep='\t', converters={0: str}) self.df_vegan.set_index('#SampleID', inplace=True) # Load expected results. self.exp_results = pd.read_csv(get_data_path('exp_results.txt'), sep='\t', index_col=0) self.exp_results_single_column = pd.read_csv( get_data_path('exp_results_single_column.txt'), sep='\t', index_col=0) self.exp_results_different_column_order = pd.read_csv( get_data_path('exp_results_different_column_order.txt'), sep='\t', index_col=0) self.exp_results_vegan = pd.read_csv( get_data_path('bioenv_exp_results_vegan.txt'), sep='\t', index_col=0) def test_bioenv_all_columns_implicit(self): # Test with all columns in data frame (implicitly). obs = bioenv(self.dm, self.df) assert_data_frame_almost_equal(obs, self.exp_results) # Should get the same results if order of rows/cols in distance matrix # is changed. obs = bioenv(self.dm_reordered, self.df) assert_data_frame_almost_equal(obs, self.exp_results) def test_bioenv_all_columns_explicit(self): # Test with all columns being specified. obs = bioenv(self.dm, self.df, columns=self.cols) assert_data_frame_almost_equal(obs, self.exp_results) # Test against a data frame that has an extra non-numeric column and # some of the rows and columns reordered (we should get the same # result since we're specifying the same columns in the same order). obs = bioenv(self.dm, self.df_extra_column, columns=self.cols) assert_data_frame_almost_equal(obs, self.exp_results) def test_bioenv_single_column(self): obs = bioenv(self.dm, self.df, columns=['PH']) assert_data_frame_almost_equal(obs, self.exp_results_single_column) def test_bioenv_different_column_order(self): # Specifying columns in a different order will change the row labels in # the results data frame as the column subsets will be reordered, but # the actual results (e.g., correlation coefficients) shouldn't change. obs = bioenv(self.dm, self.df, columns=self.cols[::-1]) assert_data_frame_almost_equal( obs, self.exp_results_different_column_order) def test_bioenv_no_side_effects(self): # Deep copies of both primary inputs. dm_copy = self.dm.copy() df_copy = self.df.copy(deep=True) bioenv(self.dm, self.df) # Make sure we haven't modified the primary input in some way (e.g., # with scaling, type conversions, etc.). self.assertEqual(self.dm, dm_copy) assert_data_frame_almost_equal(self.df, df_copy) def test_bioenv_vegan_example(self): # The correlation coefficient in the first row of the # results (rho=0.2516) is different from the correlation coefficient # computed by vegan (rho=0.2513). This seems to occur due to # differences in numerical precision when calculating the Euclidean # distances, which affects the rank calculations in Spearman # (specifically, dealing with ties). The ranked distances end up being # slightly different between vegan and our implementation because some # distances are treated as ties in vegan but treated as distinct values # in our implementation. This explains the difference in rho values. I # verified that using Pearson correlation instead of Spearman on the # same distances yields *very* similar results. Thus, the discrepancy # seems to stem from differences when computing ranks/ties. obs = bioenv(self.dm_vegan, self.df_vegan) assert_data_frame_almost_equal(obs, self.exp_results_vegan, rtol=1e-3) def test_bioenv_no_distance_matrix(self): with self.assertRaises(TypeError): bioenv('breh', self.df) def test_bioenv_no_data_frame(self): with self.assertRaises(TypeError): bioenv(self.dm, None) def test_bioenv_duplicate_columns(self): with self.assertRaises(ValueError): bioenv(self.dm, self.df, columns=self.cols + ['PH']) def test_bioenv_no_columns(self): with self.assertRaises(ValueError): bioenv(self.dm, self.df, columns=[]) def test_bioenv_missing_columns(self): with self.assertRaises(ValueError): bioenv(self.dm, self.df, columns=self.cols + ['brofist']) def test_bioenv_missing_distance_matrix_ids(self): df = self.df[1:] with self.assertRaises(ValueError): bioenv(self.dm, df) def test_bioenv_nans(self): df = self.df.replace(53.9, np.nan) with self.assertRaises(ValueError): bioenv(self.dm, df) def test_bioenv_nonnumeric_columns(self): df = self.df.replace(2400, 'no cog yay') with self.assertRaises(TypeError): bioenv(self.dm, df) with self.assertRaises(TypeError): bioenv(self.dm, self.df_extra_column) def test_scale_single_column(self): df = pd.DataFrame([[1], [0], [2]], index=['A', 'B', 'C'], columns=['foo']) exp = pd.DataFrame([[0.0], [-1.0], [1.0]], index=['A', 'B', 'C'], columns=['foo']) obs = _scale(df) assert_data_frame_almost_equal(obs, exp) def test_scale_multiple_columns(self): # Floats and ints, including positives and negatives. df = pd.DataFrame([[7.0, 400, -1], [8.0, 530, -5], [7.5, 450, 1], [8.5, 810, -4]], index=['A', 'B', 'C', 'D'], columns=['pH', 'Elevation', 'negatives']) exp = pd.DataFrame([[-1.161895, -0.805979, 0.453921], [0.387298, -0.095625, -0.998625], [-0.387298, -0.532766, 1.180194], [1.161895, 1.434369, -0.635489]], index=['A', 'B', 'C', 'D'], columns=['pH', 'Elevation', 'negatives']) obs = _scale(df) assert_data_frame_almost_equal(obs, exp) def test_scale_no_variance(self): df = pd.DataFrame([[-7.0, -1.2], [6.2, -1.2], [2.9, -1.2]], index=['A', 'B', 'C'], columns=['foo', 'bar']) with self.assertRaises(ValueError): _scale(df) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/distance/tests/test_mantel.py000066400000000000000000000733421446255456000237000ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas as pd import scipy from scipy.spatial.distance import squareform from scipy.stats import pearsonr, spearmanr from skbio import DistanceMatrix from skbio.stats.distance import (DissimilarityMatrixError, DistanceMatrixError, mantel, pwmantel) from skbio.stats.distance._mantel import _order_dms from skbio.stats.distance._mantel import _mantel_stats_pearson from skbio.stats.distance._mantel import _mantel_stats_spearman from skbio.stats.distance._cutils import mantel_perm_pearsonr_cy from skbio.stats.distance._utils import distmat_reorder_condensed from skbio.util import get_data_path, assert_data_frame_almost_equal class MantelTestData(TestCase): def setUp(self): # Small dataset of minimal size (3x3). Mix of floats and ints in a # native Python nested list structure. self.minx = [[0, 1, 2], [1, 0, 3], [2, 3, 0]] self.miny = [[0, 2, 7], [2, 0, 6], [7, 6, 0]] self.minz = [[0, 0.5, 0.25], [0.5, 0, 0.1], [0.25, 0.1, 0]] # Version of the above dataset stored as DistanceMatrix instances. self.minx_dm = DistanceMatrix(self.minx) self.miny_dm = DistanceMatrix(self.miny) self.minz_dm = DistanceMatrix(self.minz) # Versions of self.minx_dm and self.minz_dm that each have an extra ID # on the end. self.minx_dm_extra = DistanceMatrix([[0, 1, 2, 7], [1, 0, 3, 2], [2, 3, 0, 4], [7, 2, 4, 0]], ['0', '1', '2', 'foo']) self.minz_dm_extra = DistanceMatrix([[0, 0.5, 0.25, 3], [0.5, 0, 0.1, 24], [0.25, 0.1, 0, 5], [3, 24, 5, 0]], ['0', '1', '2', 'bar']) class InternalMantelTests(MantelTestData): def setUp(self): super(InternalMantelTests, self).setUp() def _compute_perf_one(self, x_data, order, xmean, normxm, ym_normalized): x_flat = distmat_reorder_condensed(x_data, order) xm_normalized = (x_flat - xmean)/normxm one_stat = np.dot(xm_normalized, ym_normalized) one_stat = max(min(one_stat, 1.0), -1.0) return one_stat def test_perm_pearsonr3(self): # data pre-computed using released code x_data = np.asarray([[0., 1., 3.], [1., 0., 2.], [3., 2., 0.]]) perm_order = np.asarray([[2, 1, 0], [2, 0, 1], [0, 2, 1], [2, 0, 1]], dtype=int) xmean = 2.0 normxm = 1.4142135623730951 ym_normalized = np.asarray([-0.80178373, 0.26726124, 0.53452248]) permuted_stats = np.empty(len(perm_order), dtype=x_data.dtype) mantel_perm_pearsonr_cy(x_data, perm_order, xmean, normxm, ym_normalized, permuted_stats) for i in range(len(perm_order)): exp_res = self._compute_perf_one(x_data, perm_order[i, :], xmean, normxm, ym_normalized) self.assertAlmostEqual(permuted_stats[i], exp_res) def test_perm_pearsonr6(self): # data pre-computed using released code x_data = np.asarray([[0., 0.62381864, 0.75001543, 0.58520119, 0.72902358, 0.65213559], [0.62381864, 0., 0.97488122, 0.6498224, 0.73720314, 0.62950732], [0.75001543, 0.97488122, 0., 0.68884542, 0.65747031, 0.72170752], [0.58520119, 0.6498224, 0.68884542, 0., 0.65885358, 0.66122362], [0.72902358, 0.73720314, 0.65747031, 0.65885358, 0., 0.71117341], [0.65213559, 0.62950732, 0.72170752, 0.66122362, 0.71117341, 0.]]) perm_order = np.asarray([[0, 2, 3, 4, 1, 5], [4, 3, 2, 5, 0, 1], [2, 5, 3, 1, 0, 4], [3, 5, 4, 1, 2, 0], [4, 3, 5, 2, 0, 1]], dtype=int) xmean = 0.6953921578226 normxm = 0.3383126690576294 ym_normalized = np.asarray([-0.4999711, 0.24980825, -0.29650504, 0.18022614, -0.17407781, 0.33223145, -0.08230374, 0.33992794, -0.14964257, 0.04340053, -0.35527798, 0.15597541, -0.0523679, -0.04451187, 0.35308828]) permuted_stats = np.empty(len(perm_order), dtype=x_data.dtype) mantel_perm_pearsonr_cy(x_data, perm_order, xmean, normxm, ym_normalized, permuted_stats) for i in range(len(perm_order)): exp_res = self._compute_perf_one(x_data, perm_order[i, :], xmean, normxm, ym_normalized) self.assertAlmostEqual(permuted_stats[i], exp_res) def test_perm_pearsonr_full(self): x = DistanceMatrix.read(get_data_path('dm2.txt')) y = DistanceMatrix.read(get_data_path('dm3.txt')) x_data = x._data y_data = y._data x_flat = squareform(x_data, force='tovector', checks=False) y_flat = squareform(y_data, force='tovector', checks=False) xmean = x_flat.mean() ymean = y_flat.mean() xm = x_flat - xmean ym = y_flat - ymean normxm_la = scipy.linalg.norm(xm) normym_la = scipy.linalg.norm(ym) normxm = np.linalg.norm(xm) normym = np.linalg.norm(ym) self.assertAlmostEqual(normxm, normxm_la) self.assertAlmostEqual(normym, normym_la) perm_order = np.asarray([[0, 2, 3, 4, 1, 5], [4, 3, 2, 5, 0, 1], [2, 5, 3, 1, 0, 4], [3, 5, 4, 1, 2, 0], [4, 3, 5, 2, 0, 1], [4, 5, 1, 2, 0, 3], [3, 5, 1, 0, 4, 2], [4, 5, 3, 1, 2, 0], [2, 1, 5, 4, 0, 3], [4, 1, 0, 5, 2, 3], [1, 2, 5, 4, 0, 3], [5, 4, 0, 1, 3, 2], [3, 0, 1, 5, 4, 2], [5, 0, 2, 3, 1, 4]], dtype=int) ym_normalized = ym/normym permuted_stats = np.empty(len(perm_order), dtype=x_data.dtype) mantel_perm_pearsonr_cy(x_data, perm_order, xmean, normxm, ym_normalized, permuted_stats) for i in range(len(perm_order)): exp_res = self._compute_perf_one(x_data, perm_order[i, :], xmean, normxm, ym_normalized) self.assertAlmostEqual(permuted_stats[i], exp_res) def test_pearsonr_full(self): """ Compare the optimized version of pearson mantel with the naive loop implementation """ x = DistanceMatrix.read(get_data_path('dm2.txt')) y = DistanceMatrix.read(get_data_path('dm3.txt')) num_perms = 12 np.random.seed(0) orig_stat_fast, comp_stat, permuted_stats_fast = \ _mantel_stats_pearson(x, y, num_perms) # compute the traditional way np.random.seed(0) x_flat = x.condensed_form() y_flat = y.condensed_form() orig_stat = pearsonr(x_flat, y_flat)[0] perm_gen = (pearsonr(x.permute(condensed=True), y_flat)[0] for _ in range(num_perms)) permuted_stats = np.fromiter(perm_gen, float, count=num_perms) self.assertAlmostEqual(orig_stat_fast, orig_stat) for i in range(num_perms): self.assertAlmostEqual(permuted_stats_fast[i], permuted_stats[i]) def test_spearmanr_full(self): """ Compare the optimized version of spearman mantel with the naive loop implementation """ x = DistanceMatrix.read(get_data_path('dm2.txt')) y = DistanceMatrix.read(get_data_path('dm3.txt')) num_perms = 12 np.random.seed(0) orig_stat_fast, comp_stat, permuted_stats_fast = \ _mantel_stats_spearman(x, y, num_perms) # compute the traditional way np.random.seed(0) x_flat = x.condensed_form() y_flat = y.condensed_form() orig_stat = spearmanr(x_flat, y_flat)[0] perm_gen = (spearmanr(x.permute(condensed=True), y_flat)[0] for _ in range(num_perms)) permuted_stats = np.fromiter(perm_gen, float, count=num_perms) self.assertAlmostEqual(orig_stat_fast, orig_stat) for i in range(num_perms): self.assertAlmostEqual(permuted_stats_fast[i], permuted_stats[i]) class MantelTests(MantelTestData): """Results were verified with R 3.1.0 and vegan 2.0-10 (vegan::mantel). vegan::mantel performs a one-sided (greater) test and does not have the option to specify different alternative hypotheses. In order to test the other alternative hypotheses, I modified vegan::mantel to perform the appropriate test, source()'d the file and verified the output. """ def setUp(self): super(MantelTests, self).setUp() self.methods = ('pearson', 'spearman', 'kendalltau') self.alternatives = ('two-sided', 'greater', 'less') # No variation in distances. Taken from Figure 10.20(b), pg. 603 in L&L # 3rd edition. Their example is 4x4 but using 3x3 here for easy # comparison to the minimal dataset above. self.no_variation = [[0, 0.667, 0.667], [0.667, 0, 0.667], [0.667, 0.667, 0]] # This second dataset is derived from vegan::mantel's example dataset. # The "veg" distance matrix contains Bray-Curtis distances derived from # the varespec data (named "veg.dist" in the example). The "env" # distance matrix contains Euclidean distances derived from scaled # varechem data (named "env.dist" in the example). self.veg_dm_vegan = np.loadtxt( get_data_path('mantel_veg_dm_vegan.txt')) self.env_dm_vegan = np.loadtxt( get_data_path('mantel_env_dm_vegan.txt')) # Expected test statistic when comparing x and y with method='pearson'. self.exp_x_vs_y = 0.7559289 # Expected test statistic when comparing x and z with method='pearson'. self.exp_x_vs_z = -0.9897433 def assert_mantel_almost_equal(self, left, right): # p-value is a count based on comparing two real value # it is thus very sensitive to minor rounding errors # When counts are rare, that may make huge proportional error # se we have to keep that number high for proper "almost" comparison self.assertAlmostEqual(left[0], right[0]) npt.assert_almost_equal(left[1] + 0.5, right[1] + 0.5, decimal=2) self.assertEqual(left[2], right[2]) def test_statistic_same_across_alternatives_and_permutations(self): # Varying permutations and alternative hypotheses shouldn't affect the # computed test statistics. for n in (0, 99, 999): for alt in self.alternatives: for method, exp in (('pearson', self.exp_x_vs_y), ('spearman', 0.5), ('kendalltau', 0.33333333333333337)): obs = mantel(self.minx, self.miny, method=method, permutations=n, alternative=alt)[0] self.assertAlmostEqual(obs, exp) def test_comparing_same_matrices(self): for method in self.methods: obs = mantel(self.minx, self.minx, method=method)[0] self.assertAlmostEqual(obs, 1) obs = mantel(self.miny, self.miny, method=method)[0] self.assertAlmostEqual(obs, 1) def test_negative_correlation(self): for method, exp in (('pearson', self.exp_x_vs_z), ('spearman', -1)): obs = mantel(self.minx, self.minz, method=method)[0] self.assertAlmostEqual(obs, exp) def test_zero_permutations(self): for alt in self.alternatives: for method, exp in (('pearson', self.exp_x_vs_y), ('spearman', 0.5), ('kendalltau', 0.33333333333333337)): obs = mantel(self.minx, self.miny, permutations=0, method=method, alternative=alt) self.assertAlmostEqual(obs[0], exp) npt.assert_equal(obs[1], np.nan) self.assertEqual(obs[2], 3) # swapping order of matrices should give same result obs = mantel(self.miny, self.minx, permutations=0, method=method, alternative=alt) self.assertAlmostEqual(obs[0], exp) npt.assert_equal(obs[1], np.nan) self.assertEqual(obs[2], 3) def test_distance_matrix_instances_as_input(self): # Matrices with all matching IDs in the same order. np.random.seed(0) obs = mantel(self.minx_dm, self.miny_dm, alternative='less') self.assert_mantel_almost_equal(obs, [self.exp_x_vs_y, 0.843, 3]) def test_distance_matrix_instances_with_reordering_and_nonmatching(self): x = self.minx_dm_extra.filter(['1', '0', 'foo', '2']) y = self.miny_dm.filter(['0', '2', '1']) # strict=True should disallow IDs that aren't found in both matrices with self.assertRaises(ValueError): mantel(x, y, alternative='less', strict=True) np.random.seed(0) # strict=False should ignore IDs that aren't found in both matrices obs = mantel(x, y, alternative='less', strict=False) self.assert_mantel_almost_equal(obs, [self.exp_x_vs_y, 0.843, 3]) def test_distance_matrix_instances_with_lookup(self): self.minx_dm.ids = ('a', 'b', 'c') self.miny_dm.ids = ('d', 'e', 'f') lookup = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'A', 'e': 'B', 'f': 'C'} np.random.seed(0) obs = mantel(self.minx_dm, self.miny_dm, alternative='less', lookup=lookup) self.assert_mantel_almost_equal(obs, [self.exp_x_vs_y, 0.843, 3]) def test_one_sided_greater(self): np.random.seed(0) obs = mantel(self.minx, self.miny, alternative='greater') self.assertAlmostEqual(obs[0], self.exp_x_vs_y) self.assertAlmostEqual(obs[1], 0.324) self.assertEqual(obs[2], 3) obs = mantel(self.minx, self.minx, alternative='greater') self.assert_mantel_almost_equal(obs, [1, 0.172, 3]) def test_one_sided_less(self): # no need to seed here as permuted test statistics will all be less # than or equal to the observed test statistic (1.0) for method in self.methods: obs = mantel(self.minx, self.minx, method=method, alternative='less') npt.assert_almost_equal(obs, (1, 1, 3)) np.random.seed(0) obs = mantel(self.minx, self.miny, alternative='less') self.assert_mantel_almost_equal(obs, [self.exp_x_vs_y, 0.843, 3]) obs = mantel(self.minx, self.minz, alternative='less') self.assert_mantel_almost_equal(obs, [self.exp_x_vs_z, 0.172, 3]) def test_two_sided(self): np.random.seed(0) obs = mantel(self.minx, self.minx, method='spearman', alternative='two-sided') self.assert_mantel_almost_equal(obs, [1.0, 0.328, 3]) obs = mantel(self.minx, self.miny, method='spearman', alternative='two-sided') self.assert_mantel_almost_equal(obs, [0.5, 1.0, 3]) obs = mantel(self.minx, self.minz, method='spearman', alternative='two-sided') self.assert_mantel_almost_equal(obs, [-1, 0.322, 3]) def test_vegan_example(self): np.random.seed(0) # pearson obs = mantel(self.veg_dm_vegan, self.env_dm_vegan, alternative='greater') self.assert_mantel_almost_equal(obs, [0.3047454, 0.002, 24]) # spearman obs = mantel(self.veg_dm_vegan, self.env_dm_vegan, alternative='greater', method='spearman') self.assert_mantel_almost_equal(obs, [0.283791, 0.003, 24]) def test_no_variation_pearson(self): for alt in self.alternatives: # test one or both inputs having no variation in their # distances obs = mantel(self.miny, self.no_variation, method='pearson', alternative=alt) npt.assert_equal(obs, (np.nan, np.nan, 3)) obs = mantel(self.no_variation, self.miny, method='pearson', alternative=alt) npt.assert_equal(obs, (np.nan, np.nan, 3)) obs = mantel(self.no_variation, self.no_variation, method='pearson', alternative=alt) npt.assert_equal(obs, (np.nan, np.nan, 3)) def test_no_variation_spearman(self): exp = (np.nan, np.nan, 3) for alt in self.alternatives: obs = mantel(self.miny, self.no_variation, method='spearman', alternative=alt) npt.assert_equal(obs, exp) obs = mantel(self.no_variation, self.miny, method='spearman', alternative=alt) npt.assert_equal(obs, exp) obs = mantel(self.no_variation, self.no_variation, method='spearman', alternative=alt) npt.assert_equal(obs, exp) def test_no_side_effects(self): minx = np.asarray(self.minx, dtype='float') miny = np.asarray(self.miny, dtype='float') minx_copy = np.copy(minx) miny_copy = np.copy(miny) mantel(minx, miny) # Make sure we haven't modified the input. npt.assert_equal(minx, minx_copy) npt.assert_equal(miny, miny_copy) def test_invalid_distance_matrix(self): # Single asymmetric, non-hollow distance matrix. with self.assertRaises(DissimilarityMatrixError): mantel([[1, 2], [3, 4]], [[0, 0], [0, 0]]) # Two asymmetric distance matrices. with self.assertRaises(DistanceMatrixError): mantel([[0, 2], [3, 0]], [[0, 1], [0, 0]]) def test_invalid_input(self): # invalid correlation method with self.assertRaises(ValueError): mantel([[1]], [[1]], method='brofist') # invalid permutations with self.assertRaises(ValueError): mantel([[1]], [[1]], permutations=-1) # invalid alternative with self.assertRaises(ValueError): mantel([[1]], [[1]], alternative='no cog yay') # too small dms with self.assertRaises(ValueError): mantel([[0, 3], [3, 0]], [[0, 2], [2, 0]]) class PairwiseMantelTests(MantelTestData): def setUp(self): super(PairwiseMantelTests, self).setUp() self.min_dms = (self.minx_dm, self.miny_dm, self.minz_dm) self.exp_results_minimal = pd.read_csv( get_data_path('pwmantel_exp_results_minimal.txt'), sep='\t', index_col=(0, 1)) self.exp_results_minimal_with_labels = pd.read_csv( get_data_path('pwmantel_exp_results_minimal_with_labels.txt'), sep='\t', index_col=(0, 1)) self.exp_results_duplicate_dms = pd.read_csv( get_data_path('pwmantel_exp_results_duplicate_dms.txt'), sep='\t', index_col=(0, 1)) self.exp_results_na_p_value = pd.read_csv( get_data_path('pwmantel_exp_results_na_p_value.txt'), sep='\t', index_col=(0, 1)) self.exp_results_reordered_distance_matrices = pd.read_csv( get_data_path('pwmantel_exp_results_reordered_distance_matrices' '.txt'), sep='\t', index_col=(0, 1)) self.exp_results_dm_dm2 = pd.read_csv( get_data_path('pwmantel_exp_results_dm_dm2.txt'), sep='\t', index_col=(0, 1)) self.exp_results_all_dms = pd.read_csv( get_data_path('pwmantel_exp_results_all_dms.txt'), sep='\t', index_col=(0, 1)) def assert_pwmantel_almost_equal(self, left, right): # p-value is a count based on comparing two real value # it is thus very sensitive to minor rounding errors # When counts are rare, that may make huge proportional error # se we have to keep that number high for proper "almost" comparison # stats use the normal precision npt.assert_almost_equal(left.values[:, 0], right.values[:, 0]) # p-values use modified check npt.assert_almost_equal(left.values[:, 1] + 0.5, right.values[:, 1] + 0.5, decimal=2) def test_minimal_compatible_input(self): # Matrices are already in the correct order and have matching IDs. np.random.seed(0) # input as DistanceMatrix instances obs = pwmantel(self.min_dms, alternative='greater') assert_data_frame_almost_equal(obs, self.exp_results_minimal) np.random.seed(0) # input as array_like obs = pwmantel((self.minx, self.miny, self.minz), alternative='greater') assert_data_frame_almost_equal(obs, self.exp_results_minimal) def test_minimal_compatible_input_with_labels(self): np.random.seed(0) obs = pwmantel(self.min_dms, alternative='greater', labels=('minx', 'miny', 'minz')) assert_data_frame_almost_equal( obs, self.exp_results_minimal_with_labels) def test_duplicate_dms(self): obs = pwmantel((self.minx_dm, self.minx_dm, self.minx_dm), alternative='less') assert_data_frame_almost_equal(obs, self.exp_results_duplicate_dms) def test_na_p_value(self): obs = pwmantel((self.miny_dm, self.minx_dm), method='spearman', permutations=0) assert_data_frame_almost_equal(obs, self.exp_results_na_p_value) def test_reordered_distance_matrices(self): # Matrices have matching IDs but they all have different ordering. x = self.minx_dm.filter(['1', '0', '2']) y = self.miny_dm.filter(['0', '2', '1']) z = self.minz_dm.filter(['1', '2', '0']) np.random.seed(0) obs = pwmantel((x, y, z), alternative='greater') assert_data_frame_almost_equal( obs, self.exp_results_reordered_distance_matrices) def test_strict(self): # Matrices have some matching and nonmatching IDs, with different # ordering. x = self.minx_dm_extra.filter(['1', '0', 'foo', '2']) y = self.miny_dm.filter(['0', '2', '1']) z = self.minz_dm_extra.filter(['bar', '1', '2', '0']) np.random.seed(0) # strict=False should discard IDs that aren't found in both matrices obs = pwmantel((x, y, z), alternative='greater', strict=False) assert_data_frame_almost_equal( obs, self.exp_results_reordered_distance_matrices) def test_id_lookup(self): # Matrices have mismatched IDs but a lookup is provided. self.minx_dm_extra.ids = ['a', 'b', 'c', 'foo'] self.minz_dm_extra.ids = ['d', 'e', 'f', 'bar'] lookup = {'a': '0', 'b': '1', 'c': '2', 'foo': 'foo', 'd': '0', 'e': '1', 'f': '2', 'bar': 'bar', '0': '0', '1': '1', '2': '2'} x = self.minx_dm_extra.filter(['b', 'a', 'foo', 'c']) y = self.miny_dm.filter(['0', '2', '1']) z = self.minz_dm_extra.filter(['bar', 'e', 'f', 'd']) x_copy = x.copy() y_copy = y.copy() z_copy = z.copy() np.random.seed(0) obs = pwmantel((x, y, z), alternative='greater', strict=False, lookup=lookup) assert_data_frame_almost_equal( obs, self.exp_results_reordered_distance_matrices) # Make sure the inputs aren't modified. self.assertEqual(x, x_copy) self.assertEqual(y, y_copy) self.assertEqual(z, z_copy) def test_too_few_dms(self): with self.assertRaises(ValueError): pwmantel([self.miny_dm]) def test_wrong_number_of_labels(self): with self.assertRaises(ValueError): pwmantel(self.min_dms, labels=['foo', 'bar']) def test_duplicate_labels(self): with self.assertRaises(ValueError): pwmantel(self.min_dms, labels=['foo', 'bar', 'foo']) def test_mixed_input_types(self): # DistanceMatrix, DistanceMatrix, array_like with self.assertRaises(TypeError): pwmantel((self.miny_dm, self.minx_dm, self.minz)) def test_filepaths_as_input(self): dms = [ get_data_path('dm.txt'), get_data_path('dm2.txt'), ] np.random.seed(0) obs = pwmantel(dms) self.assert_pwmantel_almost_equal(obs, self.exp_results_dm_dm2) def test_many_filepaths_as_input(self): dms = [ get_data_path('dm2.txt'), get_data_path('dm.txt'), get_data_path('dm4.txt'), get_data_path('dm3.txt') ] np.random.seed(0) obs = pwmantel(dms) self.assert_pwmantel_almost_equal(obs, self.exp_results_all_dms) class OrderDistanceMatricesTests(MantelTestData): def setUp(self): super(OrderDistanceMatricesTests, self).setUp() def test_array_like_input(self): obs = _order_dms(self.minx, self.miny) self.assertEqual(obs, (self.minx_dm, self.miny_dm)) def test_reordered_distance_matrices(self): # All matching IDs but with different orderings. x = self.minx_dm.filter(['1', '0', '2']) y = self.miny_dm.filter(['0', '2', '1']) exp = (x, y.filter(['1', '0', '2'])) obs = _order_dms(x, y) self.assertEqual(obs, exp) def test_reordered_and_nonmatching_distance_matrices(self): # Some matching and nonmatching IDs, with different ordering. x = self.minx_dm_extra.filter(['1', '0', 'foo', '2']) z = self.minz_dm_extra.filter(['bar', '0', '2', '1']) exp = (x.filter(['1', '0', '2']), z.filter(['1', '0', '2'])) obs = _order_dms(x, z, strict=False) self.assertEqual(obs, exp) def test_id_lookup(self): # Matrices have mismatched IDs but a lookup is provided. self.minx_dm_extra.ids = ['a', 'b', 'c', 'foo'] self.minz_dm_extra.ids = ['d', 'e', 'f', 'bar'] lookup = {'a': '0', 'b': '1', 'c': '2', 'foo': 'foo', 'd': '0', 'e': '1', 'f': '2', 'bar': 'bar'} x = self.minx_dm_extra.filter(['b', 'a', 'foo', 'c']) z = self.minz_dm_extra.filter(['bar', 'e', 'f', 'd']) x_copy = x.copy() z_copy = z.copy() exp = (self.minx_dm.filter(['1', '0', '2']), self.minz_dm.filter(['1', '0', '2'])) obs = _order_dms(x, z, strict=False, lookup=lookup) self.assertEqual(obs, exp) # Make sure the inputs aren't modified. self.assertEqual(x, x_copy) self.assertEqual(z, z_copy) def test_lookup_with_array_like(self): lookup = {'0': 'a', '1': 'b', '2': 'c'} with self.assertRaises(ValueError): _order_dms(self.minx, self.miny, lookup=lookup) def test_shape_mismatch(self): with self.assertRaises(ValueError): _order_dms(self.minx, [[0, 2], [2, 0]]) def test_missing_ids_in_lookup(self): # Mapping for '1' is missing. Should get an error while remapping IDs # for the first distance matrix. lookup = {'0': 'a', '2': 'c'} with self.assertRaisesRegex(KeyError, r"first.*(x).*'1'\"$"): _order_dms(self.minx_dm, self.miny_dm, lookup=lookup) # Mapping for 'bar' is missing. Should get an error while remapping IDs # for the second distance matrix. lookup = {'0': 'a', '1': 'b', '2': 'c', 'foo': 'a', 'baz': 'c'} self.miny_dm.ids = ('foo', 'bar', 'baz') with self.assertRaisesRegex(KeyError, r"second.*(y).*'bar'\"$"): _order_dms(self.minx_dm, self.miny_dm, lookup=lookup) def test_nonmatching_ids_strict_true(self): with self.assertRaises(ValueError): _order_dms(self.minx_dm, self.minz_dm_extra, strict=True) def test_no_matching_ids(self): self.minx_dm.ids = ['foo', 'bar', 'baz'] self.miny_dm.ids = ['a', 'b', 'c'] with self.assertRaises(ValueError): _order_dms(self.minx_dm, self.miny_dm, strict=False) def test_mixed_input_types(self): with self.assertRaises(TypeError): _order_dms(self.minx, self.minz_dm) with self.assertRaises(TypeError): _order_dms(self.minz_dm, self.minx) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/distance/tests/test_permanova.py000066400000000000000000000113741446255456000244050ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from functools import partial from unittest import TestCase, main import numpy as np import pandas as pd from pandas.testing import assert_series_equal from skbio import DistanceMatrix from skbio.stats.distance import permanova class TestPERMANOVA(TestCase): """All results were verified with R (vegan::adonis).""" def setUp(self): # Distance matrices with and without ties in the ranks, with 2 groups # of equal size. dm_ids = ['s1', 's2', 's3', 's4'] self.grouping_equal = ['Control', 'Control', 'Fast', 'Fast'] self.df = pd.read_csv( io.StringIO('ID,Group\ns2,Control\ns3,Fast\ns4,Fast\ns5,Control\n' 's1,Control'), index_col=0) self.dm_ties = DistanceMatrix([[0, 1, 1, 4], [1, 0, 3, 2], [1, 3, 0, 3], [4, 2, 3, 0]], dm_ids) self.dm_no_ties = DistanceMatrix([[0, 1, 5, 4], [1, 0, 3, 2], [5, 3, 0, 3], [4, 2, 3, 0]], dm_ids) # Test with 3 groups of unequal size. self.grouping_unequal = ['Control', 'Treatment1', 'Treatment2', 'Treatment1', 'Control', 'Control'] # Equivalent grouping but with different labels -- groups should be # assigned different integer labels but results should be the same. self.grouping_unequal_relabeled = ['z', 42, 'abc', 42, 'z', 'z'] self.dm_unequal = DistanceMatrix( [[0.0, 1.0, 0.1, 0.5678, 1.0, 1.0], [1.0, 0.0, 0.002, 0.42, 0.998, 0.0], [0.1, 0.002, 0.0, 1.0, 0.123, 1.0], [0.5678, 0.42, 1.0, 0.0, 0.123, 0.43], [1.0, 0.998, 0.123, 0.123, 0.0, 0.5], [1.0, 0.0, 1.0, 0.43, 0.5, 0.0]], ['s1', 's2', 's3', 's4', 's5', 's6']) # Expected series index is the same across all tests. self.exp_index = ['method name', 'test statistic name', 'sample size', 'number of groups', 'test statistic', 'p-value', 'number of permutations'] # Stricter series equality testing than the default. self.assert_series_equal = partial(assert_series_equal, check_index_type=True, check_series_type=True) def test_call_ties(self): # Ensure we get the same results if we rerun the method using the same # inputs. Also ensure we get the same results if we run the method # using a grouping vector or a data frame with equivalent groupings. exp = pd.Series(index=self.exp_index, data=['PERMANOVA', 'pseudo-F', 4, 2, 2.0, 0.671, 999], name='PERMANOVA results') for _ in range(2): np.random.seed(0) obs = permanova(self.dm_ties, self.grouping_equal) self.assert_series_equal(obs, exp) for _ in range(2): np.random.seed(0) obs = permanova(self.dm_ties, self.df, column='Group') self.assert_series_equal(obs, exp) def test_call_no_ties(self): exp = pd.Series(index=self.exp_index, data=['PERMANOVA', 'pseudo-F', 4, 2, 4.4, 0.332, 999], name='PERMANOVA results') np.random.seed(0) obs = permanova(self.dm_no_ties, self.grouping_equal) self.assert_series_equal(obs, exp) def test_call_no_permutations(self): exp = pd.Series(index=self.exp_index, data=['PERMANOVA', 'pseudo-F', 4, 2, 4.4, np.nan, 0], name='PERMANOVA results') obs = permanova(self.dm_no_ties, self.grouping_equal, permutations=0) self.assert_series_equal(obs, exp) def test_call_unequal_group_sizes(self): exp = pd.Series( index=self.exp_index, data=['PERMANOVA', 'pseudo-F', 6, 3, 0.578848, 0.645, 999], name='PERMANOVA results') np.random.seed(0) obs = permanova(self.dm_unequal, self.grouping_unequal) self.assert_series_equal(obs, exp) np.random.seed(0) obs = permanova(self.dm_unequal, self.grouping_unequal_relabeled) self.assert_series_equal(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/distance/tests/test_permdisp.py000066400000000000000000000264351446255456000242440ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from functools import partial from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas as pd from pandas.testing import assert_series_equal from scipy.stats import f_oneway import hdmedians as hd from skbio import DistanceMatrix from skbio.stats.ordination import pcoa from skbio.stats.distance import permdisp from skbio.stats.distance._permdisp import _compute_groups from skbio.util import get_data_path class testPERMDISP(TestCase): def setUp(self): # test with 2 groups of equal size # when assigned different labels, results should be the same self.grouping_eq = ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] self.grouping_eq_relab = ['pyt', 'pyt', 'pyt', 'hon', 'hon', 'hon'] self.exp_index = ['method name', 'test statistic name', 'sample size', 'number of groups', 'test statistic', 'p-value', 'number of permutations'] # test with 3 groups of different sizes # when assigned different labels results should be the same self.grouping_uneq = ['foo', 'foo', 'bar', 'bar', 'bar', 'qw', 'qw', 'qw', 'qw'] self.grouping_uneq_relab = [12, 12, 7, 7, 7, 23, 23, 23, 23] self.grouping_un_mixed = ['a', 'a', 7, 7, 7, 'b', 'b', 'b', 'b'] eq_ids = ['s1', 's2', 's3', 's4', 's5', 's6'] uneq_ids = ['s1', 's2', 's3', 's4', 's5', 's6', 's7', 's8', 's9'] # matrix for equal grouping self.eq_mat = DistanceMatrix([[0, 4, 0, 0, 4, 2], [4, 0, 2, 0, 3, 1], [0, 2, 0, 5, 2, 5], [0, 0, 5, 0, 0, 2], [4, 3, 2, 0, 0, 2], [2, 1, 5, 2, 2, 0]], eq_ids) # matrix for unequal grouping self.uneq_mat = DistanceMatrix([[0, 0, 4, 0, 0, 3, 5, 3, 0], [0, 0, 0, 3, 4, 5, 3, 0, 3], [4, 0, 0, 4, 3, 1, 0, 5, 2], [0, 3, 4, 0, 0, 2, 1, 3, 5], [0, 4, 3, 0, 0, 1, 1, 5, 0], [3, 5, 1, 2, 1, 0, 2, 0, 5], [5, 3, 0, 1, 1, 2, 0, 4, 3], [3, 0, 5, 3, 5, 0, 4, 0, 4], [0, 3, 2, 5, 0, 5, 3, 4, 0]], uneq_ids) # null matrix for equal grouping self.null_mat = DistanceMatrix([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], eq_ids) unif_ids = ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593', 'PC.607', 'PC.634', 'PC.635', 'PC.636'] self.unifrac_dm = DistanceMatrix( [[0.0, 0.595483768391, 0.618074717633, 0.582763100909, 0.566949022108, 0.714717232268, 0.772001731764, 0.690237118413, 0.740681707488], [0.595483768391, 0.0, 0.581427669668, 0.613726772383, 0.65945132763, 0.745176523638, 0.733836123821, 0.720305073505, 0.680785600439], [0.618074717633, 0.581427669668, 0.0, 0.672149021573, 0.699416863323, 0.71405573754, 0.759178215168, 0.689701276341, 0.725100672826], [0.582763100909, 0.613726772383, 0.672149021573, 0.0, 0.64756120797, 0.666018240373, 0.66532968784, 0.650464714994, 0.632524644216], [0.566949022108, 0.65945132763, 0.699416863323, 0.64756120797, 0.0, 0.703720200713, 0.748240937349, 0.73416971958, 0.727154987937], [0.714717232268, 0.745176523638, 0.71405573754, 0.666018240373, 0.703720200713, 0.0, 0.707316869557, 0.636288883818, 0.699880573956], [0.772001731764, 0.733836123821, 0.759178215168, 0.66532968784, 0.748240937349, 0.707316869557, 0.0, 0.565875193399, 0.560605525642], [0.690237118413, 0.720305073505, 0.689701276341, 0.650464714994, 0.73416971958, 0.636288883818, 0.565875193399, 0.0, 0.575788039321], [0.740681707488, 0.680785600439, 0.725100672826, 0.632524644216, 0.727154987937, 0.699880573956, 0.560605525642, 0.575788039321, 0.0]], unif_ids) self.unif_grouping = ['Control', 'Control', 'Control', 'Control', 'Control', 'Fast', 'Fast', 'Fast', 'Fast'] self.assert_series_equal = partial(assert_series_equal, check_index_type=True, check_series_type=True) def test_centroids_eq_groups(self): exp = [[1.2886811963240687, 1.890538910062923, 1.490527658097728], [2.17349240061718, 2.3192679626679946, 2.028338553903792]] exp_stat, _ = f_oneway(*exp) dm = pcoa(self.eq_mat) dm = dm.samples obs = _compute_groups(dm, 'centroid', self.grouping_eq) self.assertAlmostEqual(obs, exp_stat, places=6) obs_relab = _compute_groups(dm, 'centroid', self.grouping_eq_relab) self.assertAlmostEqual(obs_relab, obs, places=6) def test_centroids_uneq_groups(self): """ the expected result here was calculated by hand """ exp = [[2.5847022428144935, 2.285624595858895, 1.7022431146340287], [1.724817266046108, 1.724817266046108], [2.4333280644972795, 2.389000390879655, 2.8547180589306036, 3.218568759338847]] exp_stat, _ = f_oneway(*exp) dm = pcoa(self.uneq_mat) dm = dm.samples obs = _compute_groups(dm, 'centroid', self.grouping_uneq) self.assertAlmostEqual(obs, exp_stat, places=6) obs_relab = _compute_groups(dm, 'centroid', self.grouping_uneq_relab) self.assertAlmostEqual(obs, obs_relab, places=6) def test_centroids_mixedgroups(self): exp = [[2.5847022428144935, 2.285624595858895, 1.7022431146340287], [1.724817266046108, 1.724817266046108], [2.4333280644972795, 2.389000390879655, 2.8547180589306036, 3.218568759338847]] dm = pcoa(self.uneq_mat) dm = dm.samples exp_stat, _ = f_oneway(*exp) obs_mixed = _compute_groups(dm, 'centroid', self.grouping_un_mixed) self.assertAlmostEqual(exp_stat, obs_mixed, places=6) def test_centroids_null(self): dm = pcoa(self.null_mat) dm = dm.samples obs_null = _compute_groups(dm, 'centroid', self.grouping_eq) np.isnan(obs_null) def test_centroid_normal(self): exp = pd.Series(index=self.exp_index, data=['PERMDISP', 'F-value', 9, 2, 0.244501519876, 0.63, 99], name='PERMDISP results') grouping = ['Control', 'Control', 'Control', 'Control', 'Control', 'Fast', 'Fast', 'Fast', 'Fast'] np.random.seed(0) obs = permdisp(self.unifrac_dm, grouping, test='centroid', permutations=99) self.assert_series_equal(obs, exp) def test_median_normal(self): exp = pd.Series(index=self.exp_index, data=['PERMDISP', 'F-value', 9, 2, 0.139475441876, 0.61, 99], name='PERMDISP results') np.random.seed(0) obs = permdisp(self.unifrac_dm, self.unif_grouping, test='median', permutations=99) self.assert_series_equal(obs, exp) np.random.seed(0) po = pcoa(self.unifrac_dm) obs2 = permdisp(po, self.unif_grouping, test='median', permutations=99) self.assert_series_equal(obs2, exp) def test_median_fsvd(self): exp = pd.Series(index=self.exp_index, data=['PERMDISP', 'F-value', 9, 2, 0.04078077215673714, 0.8, 99], name='PERMDISP results') np.random.seed(0) obs = permdisp(self.unifrac_dm, self.unif_grouping, test='median', permutations=99, method='fsvd', number_of_dimensions=3) self.assert_series_equal(obs, exp) np.random.seed(0) po = pcoa(self.unifrac_dm, method='fsvd', number_of_dimensions=3) obs = permdisp(po, self.unif_grouping, test='median', permutations=99) self.assert_series_equal(obs, exp) def test_not_distance_matrix(self): dm = [] grouping = ['Control', 'Control', 'Control', 'Control', 'Control', 'Fast', 'Fast', 'Fast', 'Fast'] npt.assert_raises(TypeError, permdisp, dm, grouping, permutations=0) def test_mismatched_group(self): gr = ['foo', 'bar'] npt.assert_raises(ValueError, permdisp, self.unifrac_dm, gr) def test_single_group(self): gr = ['f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f'] npt.assert_raises(ValueError, permdisp, self.unifrac_dm, gr) def test_no_permuations(self): obs = permdisp(self.eq_mat, self.grouping_eq, permutations=0) pval = obs['p-value'] np.isnan(pval) def test_hdmedians(self): exp = np.array([2.01956244, 1.53164546, 2.60571752, 0.91424179, 1.76214416, 1.69943057]) obs = np.array(hd.geomedian(self.eq_mat.data)) npt.assert_almost_equal(obs, exp, decimal=6) def test_confirm_betadispr_results(self): mp_dm = DistanceMatrix.read(get_data_path('moving_pictures_dm.tsv')) mp_mf = pd.read_csv(get_data_path('moving_pictures_mf.tsv'), sep='\t') mp_mf.set_index('#SampleID', inplace=True) obs_med_mp = permdisp(mp_dm, mp_mf, column='BodySite') obs_cen_mp = permdisp(mp_dm, mp_mf, column='BodySite', test='centroid') exp_data_m = ['PERMDISP', 'F-value', 33, 4, 10.1956, 0.001, 999] exp_data_c = ['PERMDISP', 'F-value', 33, 4, 17.4242, 0.001, 999] exp_ind = ['method name', 'test statistic name', 'sample size', 'number of groups', 'test statistic', 'p-value', 'number of permutations'] exp_med_mp = pd.Series(data=exp_data_m, index=exp_ind, dtype='object', name='PERMDISP results') exp_cen_mp = pd.Series(data=exp_data_c, index=exp_ind, dtype='object', name='PERMDISP results') self.assert_series_equal(exp_med_mp, obs_med_mp) self.assert_series_equal(exp_cen_mp, obs_cen_mp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/evolve/000077500000000000000000000000001446255456000173425ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/evolve/__init__.py000066400000000000000000000016411446255456000214550ustar00rootroot00000000000000""" Evolutionary statistics (:mod:`skbio.stats.evolve`) =================================================== .. currentmodule:: skbio.stats.evolve This package contains statistics pertaining to phylogenies and evolution. Cophylogenetic methods ---------------------- These functions test for correlation between phylogenies or representations of evolutionary distance (for example, genetic distance matrices). Functions ^^^^^^^^^ .. autosummary:: :toctree: hommola_cospeciation """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._hommola import hommola_cospeciation __all__ = ['hommola_cospeciation'] scikit-bio-0.5.9/skbio/stats/evolve/_hommola.py000066400000000000000000000254761446255456000215250ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from scipy.stats import pearsonr from skbio import DistanceMatrix from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def hommola_cospeciation(host_dist, par_dist, interaction, permutations=999): """Perform Hommola et al (2009) host/parasite cospeciation test. This test for host/parasite cospeciation is as described in [1]_. This test is a modification of a Mantel test, expanded to accept the case where multiple hosts map to a single parasite (and vice versa). For a basic Mantel test, the distance matrices being compared must have the same number of values. To determine the significance of the correlations between distances in the two matrices, the correlation coefficient of those distances is calculated and compared to the correlation coefficients calculated from a set of matrices in which rows and columns have been permuted. In this test, rather than comparing host-host to parasite-parasite distances directly (requiring one host per parasite), the distances are compared for each interaction edge between host and parasite. Thus, a host interacting with two different parasites will be represented in two different edges, with the host-host distance for the comparison between those edges equal to zero, and the parasite-parasite distance equal to the distance between those two parasites. Like in the Mantel test, significance of the interaction is assessed by permutation, in this case permutation of the host-symbiont interaction links. Note that the null hypothesis being tested here is that the hosts and parasites have evolved independently of one another. The alternative to this is a somewhat weaker case than what is often implied with the term 'cospeciation,' which is that each incidence of host speciation is recapitulated in an incidence of symbiont speciation (strict co-cladogenesis). Although there may be many factors that could contribute to non-independence of host and symbiont phylogenies, this loss of explanatory specificity comes with increased robustness to phylogenetic uncertainty. Thus, this test may be especially useful for cases where host and/or symbiont phylogenies are poorly resolved, or when simple correlation between host and symbiont evolution is of more interest than strict co-cladogenesis. This test requires pairwise distance matrices for hosts and symbionts, as well as an interaction matrix specifying links between hosts (in columns) and symbionts (in rows). This interaction matrix should have the same number of columns as the host distance matrix, and the same number of rows as the symbiont distance matrix. Interactions between hosts and symbionts should be indicated by values of ``1`` or ``True``, with non-interactions indicated by values of ``0`` or ``False``. Parameters ---------- host_dist : 2-D array_like or DistanceMatrix Symmetric matrix of m x m pairwise distances between hosts. par_dist : 2-D array_like or DistanceMatrix Symmetric matrix of n x n pairwise distances between parasites. interaction : 2-D array_like, bool n x m binary matrix of parasite x host interactions. Order of hosts (columns) should be identical to order of hosts in `host_dist`, as should order of parasites (rows) be identical to order of parasites in `par_dist`. permutations : int, optional Number of permutations used to compute p-value. Must be greater than or equal to zero. If zero, statistical significance calculations will be skipped and the p-value will be ``np.nan``. Returns ------- corr_coeff : float Pearson correlation coefficient of host : parasite association. p_value : float Significance of host : parasite association computed using `permutations` and a one-sided (greater) alternative hypothesis. perm_stats : 1-D numpy.ndarray, float Correlation coefficients observed using permuted host : parasite interactions. Length will be equal to the number of permutations used to compute p-value (see `permutations` parameter above). See Also -------- skbio.stats.distance.mantel scipy.stats.pearsonr Notes ----- It is assumed that the ordering of parasites in `par_dist` and hosts in `host_dist` are identical to their ordering in the rows and columns, respectively, of the interaction matrix. This code is loosely based on the original R code from [1]_. References ---------- .. [1] Hommola K, Smith JE, Qiu Y, Gilks WR (2009) A Permutation Test of Host-Parasite Cospeciation. Molecular Biology and Evolution, 26, 1457-1468. Examples -------- >>> from skbio.stats.evolve import hommola_cospeciation Create arrays for host distances, parasite distances, and their interactions (data taken from example in [1]_): >>> hdist = [[0,3,8,8,9], [3,0,7,7,8], [8,7,0,6,7], [8,7,6,0,3], ... [9,8,7,3,0]] >>> pdist = [[0,5,8,8,8], [5,0,7,7,7], [8,7,0,4,4], [8,7,4,0,2], ... [8,7,4,2,0]] >>> interaction = [[1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], ... [0,0,0,1,1]] Run the cospeciation test with 99 permutations. Note that the correlation coefficient for the observed values counts against the final reported p-value: >>> corr_coeff, p_value, perm_stats = hommola_cospeciation( ... hdist, pdist, interaction, permutations=99) >>> print("%.3f" % corr_coeff) 0.832 In this case, the host distances have a fairly strong positive correlation with the symbiont distances. However, this may also reflect structure inherent in the phylogeny, and is not itself indicative of significance. >>> p_value <= 0.05 True After permuting host : parasite interactions, we find that the observed correlation is indeed greater than we would expect by chance. """ host_dist = DistanceMatrix(host_dist) par_dist = DistanceMatrix(par_dist) interaction = np.asarray(interaction, dtype=bool) num_hosts = host_dist.shape[0] num_pars = par_dist.shape[0] if num_hosts < 3 or num_pars < 3: raise ValueError("Distance matrices must be a minimum of 3x3 in size.") if num_hosts != interaction.shape[1]: raise ValueError("Number of interaction matrix columns must match " "number of hosts in `host_dist`.") if num_pars != interaction.shape[0]: raise ValueError("Number of interaction matrix rows must match " "number of parasites in `par_dist`.") if permutations < 0: raise ValueError("Number of permutations must be greater than or " "equal to zero.") if interaction.sum() < 3: raise ValueError("Must have at least 3 host-parasite interactions in " "`interaction`.") # shortcut to eliminate nested for-loops specifying pairwise interaction # partners as randomizeable indices pars, hosts = np.nonzero(interaction) pars_k_labels, pars_t_labels = _gen_lists(pars) hosts_k_labels, hosts_t_labels = _gen_lists(hosts) # get a vector of pairwise distances for each interaction edge x = _get_dist(hosts_k_labels, hosts_t_labels, host_dist.data, np.arange(num_hosts)) y = _get_dist(pars_k_labels, pars_t_labels, par_dist.data, np.arange(num_pars)) # calculate the observed correlation coefficient for these hosts/symbionts corr_coeff = pearsonr(x, y)[0] # now do permutatitons. initialize index lists of the appropriate size mp = np.arange(num_pars) mh = np.arange(num_hosts) # initialize list of shuffled correlation vals perm_stats = np.empty(permutations) if permutations == 0 or np.isnan(corr_coeff): p_value = np.nan perm_stats.fill(np.nan) else: for i in range(permutations): # generate a shuffled list of indexes for each permutation. this # effectively randomizes which host is associated with which # symbiont, but maintains the distribution of genetic distances np.random.shuffle(mp) np.random.shuffle(mh) # get pairwise distances in shuffled order y_p = _get_dist(pars_k_labels, pars_t_labels, par_dist.data, mp) x_p = _get_dist(hosts_k_labels, hosts_t_labels, host_dist.data, mh) # calculate shuffled correlation coefficient perm_stats[i] = pearsonr(x_p, y_p)[0] p_value = ((perm_stats >= corr_coeff).sum() + 1) / (permutations + 1) return corr_coeff, p_value, perm_stats def _get_dist(k_labels, t_labels, dists, index): """Subset a distance matrix using a set of (randomizable) index labels. Parameters ---------- k_labels : numpy.array index labels specifying row-wise member of pairwise interaction t_labels : numpy.array index labels specifying column-wise member of pairwise interaction dists : numpy.array pairwise distance matrix index : numpy.array of int permutable indices for changing order in pairwise distance matrix Returns ------- vec : list of float List of distances associated with host:parasite edges. """ return dists[index[k_labels], index[t_labels]] def _gen_lists(labels): """Generate matched lists of row and column index labels. Shortcut function for generating matched lists of row and col index labels for the set of pairwise comparisons specified by the list of those indices recovered using ``np.nonzero(interaction)``. Reproduces values of iterated indices from the nested for-loops contained in ``get_dist`` function in original code from [1]_. Parameters ---------- labels : numpy.array array containing the indices of nonzero elements in one dimension of an interaction matrix Returns ------- k_labels : numpy.array index labels specifying row-wise member of pairwise interaction t_labels : numpy.array index labels specifying column-wise member of pairwise interaction References ---------- .. [1] Hommola K, Smith JE, Qiu Y, Gilks WR (2009) A Permutation Test of Host-Parasite Cospeciation. Molecular Biology and Evolution, 26, 1457-1468. """ i_array, j_array = np.transpose(np.tri(len(labels)-1)).nonzero() j_array = j_array + 1 return labels[i_array], labels[j_array] scikit-bio-0.5.9/skbio/stats/evolve/tests/000077500000000000000000000000001446255456000205045ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/evolve/tests/__init__.py000066400000000000000000000005411446255456000226150ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/stats/evolve/tests/test_hommola.py000066400000000000000000000174711446255456000235630ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import numpy as np import numpy.testing as npt from skbio.stats.distance import mantel from skbio.stats.evolve import hommola_cospeciation from skbio.stats.evolve._hommola import _get_dist, _gen_lists class HommolaCospeciationTests(unittest.TestCase): def setUp(self): # Test matrices, as presented in original paper by Hommola et al. self.hdist = np.array([[0, 3, 8, 8, 9], [3, 0, 7, 7, 8], [ 8, 7, 0, 6, 7], [8, 7, 6, 0, 3], [9, 8, 7, 3, 0]]) self.pdist = np.array([[0, 5, 8, 8, 8], [5, 0, 7, 7, 7], [ 8, 7, 0, 4, 4], [8, 7, 4, 0, 2], [8, 7, 4, 2, 0]]) self.interact = np.array([[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 1, 1]]) # Reduced-size host matrix for testing asymmetric interaction matrix self.hdist_4x4 = np.array([[0, 3, 8, 8], [3, 0, 7, 7], [8, 7, 0, 6], [8, 7, 6, 0]]) self.interact_5x4 = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 1]]) # One to one interaction matrix for comparing against Mantel output self.interact_1to1 = np.array([[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]) # interaction matrix yielding non-significant results. # this matrix was picked because it will generate an r value that's # less than a standard deviation away from the mean of the normal # distribution of r vals self.interact_ns = np.array( [[0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 0, 1]]) # minimal size matrices for sanity checks of inputs self.h_dist_3x3 = np.array([[0, 1, 2], [1, 0, 1], [2, 1, 0]]) self.h_dist_2x2 = np.array([[0, 3], [3, 0]]) self.p_dist_3x3 = np.array([[0, 3, 2], [3, 0, 1], [2, 1, 0]]) self.interact_3x3 = np.array([[0, 1, 1], [1, 0, 1], [0, 0, 1]]) self.interact_3x2 = np.array([[0, 1], [1, 0], [1, 1]]) self.interact_2x3 = np.array([[0, 1, 1], [1, 0, 1]]) self.interact_zero = np.array([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) def test_hommola_cospeciation_sig(self): np.random.seed(1) obs_r, obs_p, obs_perm_stats = hommola_cospeciation( self.hdist, self.pdist, self.interact, 9) exp_p = .1 exp_r = 0.83170965463247915 exp_perm_stats = np.array([-0.14928122, 0.26299538, -0.21125858, 0.24143838, 0.61557855, -0.24258293, 0.09885203, 0.02858, 0.42742399]) self.assertAlmostEqual(obs_p, exp_p) self.assertAlmostEqual(obs_r, exp_r) npt.assert_allclose(obs_perm_stats, exp_perm_stats) def test_hommola_cospeciation_asymmetric(self): np.random.seed(1) obs_r, obs_p, obs_perm_stats = hommola_cospeciation( self.hdist_4x4, self.pdist, self.interact_5x4, 9) exp_p = 0.2 exp_r = 0.85732140997411233 exp_perm_stats = np.array([-0.315244162496, -0.039405520312, 0.093429386594, -0.387835875941, 0.183711730709, 0.056057631956, 0.945732487487, 0.056057631956, -0.020412414523]) self.assertAlmostEqual(obs_p, exp_p) self.assertAlmostEqual(obs_r, exp_r) npt.assert_allclose(obs_perm_stats, exp_perm_stats) def test_hommola_cospeciation_no_sig(self): np.random.seed(1) obs_r, obs_p, obs_perm_stats = hommola_cospeciation( self.hdist, self.pdist, self.interact_ns, 9) exp_p = .6 exp_r = -0.013679391379114569 exp_perm_stats = np.array([-0.22216543, -0.14836061, -0.04434843, 0.1478281, -0.29105645, 0.56395839, 0.47304992, 0.79125657, 0.06804138]) self.assertAlmostEqual(obs_p, exp_p) self.assertAlmostEqual(obs_r, exp_r) npt.assert_allclose(obs_perm_stats, exp_perm_stats) def test_hommola_vs_mantel(self): # we don't compare p-values because the two methods use different # permutation strategies r_mantel, p_mantel, _ = mantel( self.hdist, self.pdist, method='pearson', permutations=0, alternative='greater' ) r_hommola, p_hommola, _ = hommola_cospeciation( self.hdist, self.pdist, self.interact_1to1, permutations=0 ) self.assertAlmostEqual(r_hommola, r_mantel) npt.assert_equal(p_hommola, p_mantel) def test_zero_permutations(self): obs_r, obs_p, obs_perm_stats = hommola_cospeciation( self.hdist, self.pdist, self.interact, 0) exp_p = np.nan exp_r = 0.83170965463247915 exp_perm_stats = np.array([]) npt.assert_equal(obs_p, exp_p) self.assertAlmostEqual(obs_r, exp_r) npt.assert_equal(obs_perm_stats, exp_perm_stats) def test_get_dist(self): labels = np.array([0, 1, 1, 2, 3]) k_labels, t_labels = _gen_lists(labels) dists = np.array([[0, 2, 6, 3], [2, 0, 5, 4], [6, 5, 0, 7], [3, 4, 7, 0]]) index = np.array([2, 3, 1, 0]) expected_vec = np.array([7, 7, 5, 6, 0, 4, 3, 4, 3, 2]) actual_vec = _get_dist(k_labels, t_labels, dists, index) npt.assert_allclose(actual_vec, expected_vec) def test_gen_lists(self): exp_pars_k_labels = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4]) exp_pars_t_labels = np.array([1, 2, 3, 4, 4, 2, 3, 4, 4, 3, 4, 4, 4, 4, 4]) exp_host_k_labels = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3]) exp_host_t_labels = np.array([1, 2, 3, 3, 4, 2, 3, 3, 4, 3, 3, 4, 3, 4, 4]) pars, hosts = np.nonzero(self.interact) obs_pars_k_labels, obs_pars_t_labels = _gen_lists(pars) obs_hosts_k_labels, obs_hosts_t_labels = _gen_lists(hosts) npt.assert_allclose(exp_pars_k_labels, obs_pars_k_labels) npt.assert_allclose(exp_pars_t_labels, obs_pars_t_labels) npt.assert_allclose(exp_host_k_labels, obs_hosts_k_labels) npt.assert_allclose(exp_host_t_labels, obs_hosts_t_labels) def test_dm_too_small(self): with self.assertRaises(ValueError): hommola_cospeciation(self.h_dist_2x2, self.p_dist_3x3, self.interact_3x3) def test_host_interaction_not_equal(self): with self.assertRaises(ValueError): hommola_cospeciation(self.h_dist_3x3, self.p_dist_3x3, self.interact_2x3) def test_par_interaction_not_equal(self): with self.assertRaises(ValueError): hommola_cospeciation(self.h_dist_3x3, self.p_dist_3x3, self.interact_3x2) def test_interaction_too_few(self): with self.assertRaises(ValueError): hommola_cospeciation(self.h_dist_3x3, self.p_dist_3x3, self.interact_zero) def test_permutations_too_few(self): with self.assertRaises(ValueError): hommola_cospeciation(self.h_dist_3x3, self.p_dist_3x3, self.interact_3x3, -1) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/stats/gradient.py000066400000000000000000000770661446255456000202310ustar00rootroot00000000000000r""" Gradient analyses (:mod:`skbio.stats.gradient`) =============================================== .. currentmodule:: skbio.stats.gradient This module provides functionality for performing gradient analyses. The algorithms included in this module mainly allows performing analysis of volatility on time series data, but they can be applied to any data that contains a gradient. Classes ------- .. autosummary:: :toctree: GradientANOVA AverageGradientANOVA TrajectoryGradientANOVA FirstDifferenceGradientANOVA WindowDifferenceGradientANOVA GroupResults CategoryResults GradientANOVAResults Examples -------- Assume we have the following coordinates: >>> import numpy as np >>> import pandas as pd >>> from skbio.stats.gradient import AverageGradientANOVA >>> coord_data = {'PC.354': np.array([0.2761, -0.0341, 0.0633, 0.1004]), ... 'PC.355': np.array([0.2364, 0.2186, -0.0301, -0.0225]), ... 'PC.356': np.array([0.2208, 0.0874, -0.3519, -0.0031]), ... 'PC.607': np.array([-0.1055, -0.4140, -0.15, -0.116]), ... 'PC.634': np.array([-0.3716, 0.1154, 0.0721, 0.0898])} >>> coords = pd.DataFrame.from_dict(coord_data, orient='index') the following metadata map: >>> metadata_map = {'PC.354': {'Treatment': 'Control', 'Weight': '60'}, ... 'PC.355': {'Treatment': 'Control', 'Weight': '55'}, ... 'PC.356': {'Treatment': 'Control', 'Weight': '50'}, ... 'PC.607': {'Treatment': 'Fast', 'Weight': '65'}, ... 'PC.634': {'Treatment': 'Fast', 'Weight': '68'}} >>> metadata_map = pd.DataFrame.from_dict(metadata_map, orient='index') and the following array with the proportion explained of each coord: >>> prop_expl = np.array([25.6216, 15.7715, 14.1215, 11.6913, 9.8304]) Then to compute the average trajectory of this data: >>> av = AverageGradientANOVA(coords, prop_expl, metadata_map, ... trajectory_categories=['Treatment'], ... sort_category='Weight') >>> trajectory_results = av.get_trajectories() Check the algorithm used to compute the trajectory_results: >>> print(trajectory_results.algorithm) avg Check if we weighted the data or not: >>> print(trajectory_results.weighted) False Check the results of one of the categories: >>> print(trajectory_results.categories[0].category) Treatment >>> print(trajectory_results.categories[0].probability) 0.0118478282382 Check the results of one group of one of the categories: >>> print(trajectory_results.categories[0].groups[0].name) Control >>> print(trajectory_results.categories[0].groups[0].trajectory) [ 3.52199973 2.29597001 3.20309816] >>> print(trajectory_results.categories[0].groups[0].info) {'avg': 3.007022633956606} """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from copy import deepcopy from collections import defaultdict from numbers import Integral import numpy as np from natsort import realsorted from scipy.stats import f_oneway from skbio.util._decorator import experimental def _weight_by_vector(trajectories, w_vector): r"""weights the values of `trajectories` given a weighting vector `w_vector`. Each value in `trajectories` will be weighted by the 'rate of change' to 'optimal rate of change' ratio. The 'rate of change' of a vector measures how each point in the vector changes with respect to its predecessor point. The 'optimal rate of change' is the rate of change in which each point in the vector performs the same change than its predecessor, meaning that when calling this function over evenly spaced `w_vector` values, no change will be reflected on the output. Parameters ---------- trajectories: pandas.DataFrame Values to weight w_vector: pandas.Series Values used to weight `trajectories` Returns ------- pandas.DataFrame A weighted version of `trajectories`. Raises ------ ValueError If `trajectories` and `w_vector` don't have equal lengths If `w_vector` is not a gradient TypeError If `trajectories` and `w_vector` are not iterables """ try: if len(trajectories) != len(w_vector): raise ValueError("trajectories (%d) & w_vector (%d) must be equal " "lengths" % (len(trajectories), len(w_vector))) except TypeError: raise TypeError("trajectories and w_vector must be iterables") # check no repeated values are passed in the weighting vector if len(set(w_vector)) != len(w_vector): raise ValueError("The weighting vector must be a gradient") # no need to weight in case of a one element vector if len(w_vector) == 1: return trajectories # Cast to float so divisions have a floating point resolution total_length = float(max(w_vector) - min(w_vector)) # Reflects the expected gradient between subsequent values in w_vector # the first value isn't weighted so subtract one from the number of # elements optimal_gradient = total_length/(len(w_vector)-1) # for all elements apply the weighting function for i, idx in enumerate(trajectories.index): # Skipping the first element is it doesn't need to be weighted if i != 0: trajectories.loc[idx] = ( trajectories.loc[idx] * optimal_gradient / np.abs((w_vector[i] - w_vector[i-1])) ) return trajectories.astype('float64') def _ANOVA_trajectories(category, res_by_group): r"""Run ANOVA over `res_by_group` If ANOVA cannot be run in the current category (because either there is only one group in category or there is a group with only one member) the result CategoryResults instance has `probability` and `groups` set to None and message is set to a string explaining why ANOVA was not run Returns ------- CategoryResults An instance of CategoryResults holding the results of the trajectory analysis applied on `category` """ # If there is only one group under category we cannot run ANOVA if len(res_by_group) == 1: return CategoryResults(category, None, None, 'Only one value in the group.') # Check if groups can be tested using ANOVA. ANOVA testing requires # all elements to have at least size greater to one. values = [res.trajectory.astype(float) for res in res_by_group] if any([len(value) == 1 for value in values]): return CategoryResults(category, None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') # We are ok to run ANOVA _, p_val = f_oneway(*values) return CategoryResults(category, p_val, res_by_group, None) class GroupResults: """Store the trajectory results of a group of a metadata category Attributes ---------- name : str The name of the group within the metadata category trajectory : array like The result trajectory in an 1-D numpy array mean : float The mean of the trajectory info : dict Any extra information computed by the trajectory algorithm. Depends on the algorithm message : str A message with information of the execution of the algorithm """ @experimental(as_of="0.4.0") def __init__(self, name, trajectory, mean, info, message): self.name = name self.trajectory = trajectory self.mean = mean self.info = info self.message = message @experimental(as_of="0.4.0") def to_files(self, out_f, raw_f): r"""Save the trajectory analysis results for a category group to files in text format. Parameters ---------- out_f : file-like object File-like object to write trajectory analysis data to. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) raw_f : file-like object File-like object to write trajectories trajectory values. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) """ out_f.write('For group "%s", the group means is: %f\n' % (self.name, self.mean)) raw_f.write('For group "%s":\n' % self.name) if self.message: out_f.write('%s\n' % self.message) raw_f.write('%s\n' % self.message) out_f.write('The info is: %s\n' % sorted(((k, v) for k, v in self.info.items()))) raw_f.write('The trajectory is:\n[%s]\n' % ", ".join(map(str, self.trajectory))) class CategoryResults: """Store the trajectory results of a metadata category Attributes ---------- category : str The name of the category probability : float The ANOVA probability that the category groups are independent groups : list of GroupResults The trajectory results for each group in the category message : str A message with information of the execution of the algorithm """ @experimental(as_of="0.4.0") def __init__(self, category, probability, groups, message): self.category = category self.probability = probability self.groups = groups self.message = message @experimental(as_of="0.4.0") def to_files(self, out_f, raw_f): r"""Save the trajectory analysis results for a category to files in text format. Parameters ---------- out_f : file-like object File-like object to write trajectory analysis data to. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) raw_f : file-like object File-like object to write trajectory raw values. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) """ if self.probability is None: out_f.write('Grouped by "%s": %s\n' % (self.category, self.message)) else: out_f.write('Grouped by "%s", probability: %f\n' % (self.category, self.probability)) raw_f.write('Grouped by "%s"\n' % self.category) for group in self.groups: group.to_files(out_f, raw_f) class GradientANOVAResults: """Store the trajectory results Attributes ---------- algorithm : str The algorithm used to compute trajectories weighted : bool If true, a weighting vector was used categories : list of CategoryResults The trajectory results for each metadata category """ @experimental(as_of="0.4.0") def __init__(self, algorithm, weighted, categories): self.algorithm = algorithm self.weighted = weighted self.categories = categories @experimental(as_of="0.4.0") def to_files(self, out_f, raw_f): r"""Save the trajectory analysis results to files in text format. Parameters ---------- out_f : file-like object File-like object to write trajectories analysis data to. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) raw_f : file-like object File-like object to write trajectories raw values. Must have a `write` method. It is the caller's responsibility to close `out_f` when done (if necessary) """ out_f.write('Trajectory algorithm: %s\n' % self.algorithm) raw_f.write('Trajectory algorithm: %s\n' % self.algorithm) if self.weighted: out_f.write('** This output is weighted **\n') raw_f.write('** This output is weighted **\n') out_f.write('\n') raw_f.write('\n') for cat_results in self.categories: cat_results.to_files(out_f, raw_f) out_f.write('\n') raw_f.write('\n') class GradientANOVA: r"""Base class for the Trajectory algorithms Parameters ---------- coords : pandas.DataFrame The coordinates for each sample id prop_expl : array like The numpy 1-D array with the proportion explained by each axis in coords metadata_map : pandas.DataFrame The metadata map, indexed by sample ids and columns are metadata categories trajectory_categories : list of str, optional A list of metadata categories to use to create the trajectories. If None is passed, the trajectories for all metadata categories are computed. Default: None, compute all of them sort_category : str, optional The metadata category to use to sort the trajectories. Default: None axes : int, optional The number of axes to account while doing the trajectory specific calculations. Pass 0 to compute all of them. Default: 3 weighted : bool, optional If true, the output is weighted by the space between samples in the `sort_category` column Raises ------ ValueError If any category of `trajectory_categories` is not present in `metadata_map` If `sort_category` is not present in `metadata_map` If `axes` is not between 0 and the maximum number of axes available If `weighted` is True and no `sort_category` is provided If `weighted` is True and the values under `sort_category` are not numerical If `coords` and `metadata_map` does not have samples in common """ # Should be defined by the derived classes _alg_name = None @experimental(as_of="0.4.0") def __init__(self, coords, prop_expl, metadata_map, trajectory_categories=None, sort_category=None, axes=3, weighted=False): if not trajectory_categories: # If trajectory_categories is not provided, use all the categories # present in the metadata map trajectory_categories = metadata_map.keys() else: # Check that trajectory_categories are in metadata_map for category in trajectory_categories: if category not in metadata_map: raise ValueError("Category %s not present in metadata." % category) # Check that sort_categories is in metadata_map if sort_category and sort_category not in metadata_map: raise ValueError("Sort category %s not present in metadata." % sort_category) if axes == 0: # If axes == 0, we should compute the trajectories for all axes axes = len(prop_expl) elif axes > len(prop_expl) or axes < 0: # Axes should be 0 <= axes <= len(prop_expl) raise ValueError("axes should be between 0 and the max number of " "axes available (%d), found: %d " % (len(prop_expl), axes)) # Restrict coordinates to those axes that we actually need to compute self._coords = coords.loc[:, :axes-1] self._prop_expl = prop_expl[:axes] self._metadata_map = metadata_map self._weighted = weighted # Remove any samples from coords not present in mapping file # and remove any samples from metadata_map not present in coords self._normalize_samples() # Create groups self._make_groups(trajectory_categories, sort_category) # Compute the weighting_vector self._weighting_vector = None if weighted: if not sort_category: raise ValueError("You should provide a sort category if you " "want to weight the trajectories") try: self._weighting_vector = \ self._metadata_map[sort_category].astype(np.float64) except ValueError: raise ValueError("The sorting category must be numeric") # Initialize the message buffer self._message_buffer = [] @experimental(as_of="0.4.0") def get_trajectories(self): r"""Compute the trajectories for each group in each category and run ANOVA over the results to test group independence. Returns ------- GradientANOVAResults An instance of GradientANOVAResults holding the results. """ result = GradientANOVAResults(self._alg_name, self._weighted, []) # Loop through all the categories that we should compute # the trajectories for cat, cat_groups in self._groups.items(): # Loop through all the category values present in the current # category and compute the trajectory for each of them res_by_group = [] for group in sorted(cat_groups, key=lambda k: str(k)): res_by_group.append( self._get_group_trajectories(group, cat_groups[group])) result.categories.append(_ANOVA_trajectories(cat, res_by_group)) return result def _normalize_samples(self): r"""Ensures that `self._coords` and `self._metadata_map` have the same sample ids Raises ------ ValueError If `coords` and `metadata_map` does not have samples in common """ # Figure out the sample ids in common coords_sample_ids = set(self._coords.index) mm_sample_ids = set(self._metadata_map.index) sample_ids = coords_sample_ids.intersection(mm_sample_ids) # Check if they actually have sample ids in common if not sample_ids: raise ValueError("Coordinates and metadata map had no samples " "in common") # pandas no longer allows use of set with .loc sample_ids = list(sample_ids) # Need to take a subset of coords if coords_sample_ids != sample_ids: self._coords = self._coords.loc[sample_ids] # Need to take a subset of metadata_map if mm_sample_ids != sample_ids: self._metadata_map = self._metadata_map.loc[sample_ids] def _make_groups(self, trajectory_categories, sort_category): r"""Groups the sample ids in `self._metadata_map` by the values in `trajectory_categories` Creates `self._groups`, a dictionary keyed by category and values are dictionaries in which the keys represent the group name within the category and values are ordered lists of sample ids If `sort_category` is not None, the sample ids are sorted based on the values under this category in the metadata map. Otherwise, they are sorted using the sample id. Parameters ---------- trajectory_categories : list of str A list of metadata categories to use to create the groups. Default: None, compute all of them sort_category : str or None The category from self._metadata_map to use to sort groups """ # If sort_category is provided, we used the value of such category to # sort. Otherwise, we use the sample id. if sort_category: def sort_val(sid): return self._metadata_map[sort_category][sid] else: def sort_val(sid): return sid self._groups = defaultdict(dict) for cat in trajectory_categories: # Group samples by category gb = self._metadata_map.groupby(cat) for g, df in gb: self._groups[cat][g] = realsorted(df.index, key=sort_val) def _get_group_trajectories(self, group_name, sids): r"""Compute the trajectory results for `group_name` containing the samples `sids`. Weights the data if `self._weighted` is True and ``len(sids) > 1`` Parameters ---------- group_name : str The name of the group sids : list of str The sample ids in the group Returns ------- GroupResults The trajectory results for the given group Raises ------ RuntimeError If sids is an empty list """ # We multiply the coord values with the prop_expl trajectories = self._coords.loc[sids] * self._prop_expl if trajectories.empty: # Raising a RuntimeError since in a usual execution this should # never happen. The only way this can happen is if the user # directly calls this method, which shouldn't be done # (that's why the method is private) raise RuntimeError("No samples to process, an empty list cannot " "be processed") # The weighting can only be done over trajectories with a length # greater than 1 if self._weighted and len(sids) > 1: trajectories_copy = deepcopy(trajectories) try: trajectories = _weight_by_vector(trajectories_copy, self._weighting_vector[sids]) except (FloatingPointError, ValueError): self._message_buffer.append("Could not weight group, no " "gradient in the the " "weighting vector.\n") trajectories = trajectories_copy return self._compute_trajectories_results(group_name, trajectories.loc[sids]) def _compute_trajectories_results(self, group_name, trajectories): r"""Do the actual trajectories computation over trajectories Parameters ---------- group_name : str The name of the group trajectories : pandas.DataFrame The sorted trajectories for each sample in the group Raises ------ NotImplementedError This is the base class """ raise NotImplementedError("No algorithm is implemented on the base " "class.") class AverageGradientANOVA(GradientANOVA): r"""Perform trajectory analysis using the RMS average algorithm For each group in a category, it computes the average point among the samples in such group and then computes the norm of each sample from the averaged one. See Also -------- GradientANOVA """ _alg_name = 'avg' def _compute_trajectories_results(self, group_name, trajectories): r"""Do the actual trajectory computation over trajectories Parameters ---------- group_name : str The name of the group trajectories : pandas.DataFrame The sorted trajectories for each sample in the group Returns ------- GroupResults The trajectory results for `group_name` using the average trajectories method """ center = np.average(trajectories, axis=0) if len(trajectories) == 1: trajectory = np.array([np.linalg.norm(center)]) calc = {'avg': trajectory[0]} else: trajectory = np.array([np.linalg.norm(row[1].to_numpy() - center) for row in trajectories.iterrows()]) calc = {'avg': np.average(trajectory)} msg = ''.join(self._message_buffer) if self._message_buffer else None # Reset the message buffer self._message_buffer = [] return GroupResults(group_name, trajectory, np.mean(trajectory), calc, msg) class TrajectoryGradientANOVA(GradientANOVA): r"""Perform trajectory analysis using the RMS trajectory algorithm For each group in a category, each component of the result trajectory is computed as taking the sorted list of samples in the group and taking the norm of the coordinates of the 2nd sample minus 1st sample, 3rd sample minus 2nd sample and so on. See Also -------- GradientANOVA """ _alg_name = 'trajectory' def _compute_trajectories_results(self, group_name, trajectories): r"""Do the actual trajectory computation over trajectories Parameters ---------- group_name : str The name of the group trajectories : pandas.DataFrame The sorted trajectories for each sample in the group Returns ------- GroupResults The trajectory results for `group_name` using the trajectory method """ if len(trajectories) == 1: trajectory = np.array([np.linalg.norm(trajectories)]) calc = {'2-norm': trajectory[0]} else: # Loop through all the rows in trajectories and create '2-norm' # by taking the norm of the 2nd row - 1st row, 3rd row - 2nd row... trajectory = \ np.array([np.linalg.norm(trajectories.iloc[i+1].to_numpy() - trajectories.iloc[i].to_numpy()) for i in range(len(trajectories) - 1)]) calc = {'2-norm': np.linalg.norm(trajectory)} msg = ''.join(self._message_buffer) if self._message_buffer else None # Reset the message buffer self._message_buffer = [] return GroupResults(group_name, trajectory, np.mean(trajectory), calc, msg) class FirstDifferenceGradientANOVA(GradientANOVA): r"""Perform trajectory analysis using the first difference algorithm It calculates the norm for all the time-points and then calculates the first difference for each resulting point See Also -------- GradientANOVA """ _alg_name = 'diff' def _compute_trajectories_results(self, group_name, trajectories): r"""Do the actual trajectory computation over trajectories Parameters ---------- group_name : str The name of the group trajectories : pandas.DataFrame The sorted trajectories for each sample in the group Returns ------- GroupResults The trajectory results for `group_name` using the first difference method """ if len(trajectories) == 1: trajectory = np.array([np.linalg.norm(trajectories)]) calc = {'mean': trajectory[0], 'std': 0} elif len(trajectories) == 2: trajectory = np.array([np.linalg.norm(trajectories[1] - trajectories[0])]) calc = {'mean': trajectory[0], 'std': 0} else: vec_norm = \ np.array([np.linalg.norm(trajectories.iloc[i+1].to_numpy() - trajectories.iloc[i].to_numpy()) for i in range(len(trajectories) - 1)]) trajectory = np.diff(vec_norm) calc = {'mean': np.mean(trajectory), 'std': np.std(trajectory)} msg = ''.join(self._message_buffer) if self._message_buffer else None # Reset the message buffer self._message_buffer = [] return GroupResults(group_name, trajectory, np.mean(trajectory), calc, msg) class WindowDifferenceGradientANOVA(GradientANOVA): r"""Perform trajectory analysis using the modified first difference algorithm It calculates the norm for all the time-points and subtracts the mean of the next number of elements specified in `window_size` and the current element. Parameters ---------- coords : pandas.DataFrame The coordinates for each sample id prop_expl : array like The numpy 1-D array with the proportion explained by each axis in coords metadata_map : pandas.DataFrame The metadata map, indexed by sample ids and columns are metadata categories window_size : int or long The window size to use while computing the differences Raises ------ ValueError If the window_size is not a positive integer See Also -------- GradientANOVA """ _alg_name = 'wdiff' @experimental(as_of="0.4.0") def __init__(self, coords, prop_expl, metadata_map, window_size, **kwargs): super(WindowDifferenceGradientANOVA, self).__init__(coords, prop_expl, metadata_map, **kwargs) if not isinstance(window_size, Integral) or window_size < 1: raise ValueError("The window_size must be a positive integer") self._window_size = window_size def _compute_trajectories_results(self, group_name, trajectories): r"""Do the actual trajectory computation over trajectories If the first difference cannot be calculated of the provided window size, no difference is applied and a message is added to the results. Parameters ---------- group_name : str The name of the group trajectories : pandas.DataFrame The sorted trajectories for each sample in the group Returns ------- GroupResults The trajectory results for `group_name` using the windowed difference method """ if len(trajectories) == 1: trajectory = np.array([np.linalg.norm(trajectories)]) calc = {'mean': trajectory, 'std': 0} elif len(trajectories) == 2: trajectory = np.array([np.linalg.norm(trajectories[1] - trajectories[0])]) calc = {'mean': trajectory, 'std': 0} else: vec_norm = \ np.array([np.linalg.norm(trajectories.iloc[i+1].to_numpy() - trajectories.iloc[i].to_numpy()) for i in range(len(trajectories) - 1)]) # windowed first differences won't be able on every group, # specially given the variation of size that a trajectory tends # to have if len(vec_norm) <= self._window_size: trajectory = vec_norm self._message_buffer.append("Cannot calculate the first " "difference with a window of size " "(%d)." % self._window_size) else: # Replicate the last element as many times as required for idx in range(0, self._window_size): vec_norm = np.append(vec_norm, vec_norm[-1:], axis=0) trajectory = [] for idx in range(0, len(vec_norm) - self._window_size): # Meas has to be over axis 0 so it handles arrays of arrays element = np.mean(vec_norm[(idx + 1): (idx + 1 + self._window_size)], axis=0) trajectory.append(element - vec_norm[idx]) trajectory = np.array(trajectory) calc = {'mean': np.mean(trajectory), 'std': np.std(trajectory)} msg = ''.join(self._message_buffer) if self._message_buffer else None # Reset the message buffer self._message_buffer = [] return GroupResults(group_name, trajectory, np.mean(trajectory), calc, msg) scikit-bio-0.5.9/skbio/stats/ordination/000077500000000000000000000000001446255456000202105ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/ordination/__init__.py000066400000000000000000000100571446255456000223240ustar00rootroot00000000000000r""" Ordination methods (:mod:`skbio.stats.ordination`) ================================================== .. currentmodule:: skbio.stats.ordination This module contains several ordination methods, including Principal Coordinate Analysis, Correspondence Analysis, Redundancy Analysis and Canonical Correspondence Analysis. Ordination Functions -------------------- .. autosummary:: :toctree: ca pcoa pcoa_biplot cca rda Classes ------- .. autosummary:: :toctree: OrdinationResults Utility Functions ----------------- .. autosummary:: :toctree: mean_and_std corr scale svd_rank e_matrix f_matrix Examples -------- This is an artificial dataset (table 11.3 in [1]_) that represents fish abundance in different sites (`Y`, the response variables) and environmental variables (`X`, the explanatory variables). >>> import numpy as np >>> import pandas as pd First we need to construct our explanatory variable dataset `X`. >>> X = np.array([[1.0, 0.0, 1.0, 0.0], ... [2.0, 0.0, 1.0, 0.0], ... [3.0, 0.0, 1.0, 0.0], ... [4.0, 0.0, 0.0, 1.0], ... [5.0, 1.0, 0.0, 0.0], ... [6.0, 0.0, 0.0, 1.0], ... [7.0, 1.0, 0.0, 0.0], ... [8.0, 0.0, 0.0, 1.0], ... [9.0, 1.0, 0.0, 0.0], ... [10.0, 0.0, 0.0, 1.0]]) >>> transects = ['depth', 'substrate_coral', 'substrate_sand', ... 'substrate_other'] >>> sites = ['site1', 'site2', 'site3', 'site4', 'site5', 'site6', 'site7', ... 'site8', 'site9', 'site10'] >>> X = pd.DataFrame(X, sites, transects) Then we need to create a dataframe with the information about the species observed at different sites. >>> species = ['specie1', 'specie2', 'specie3', 'specie4', 'specie5', ... 'specie6', 'specie7', 'specie8', 'specie9'] >>> Y = np.array([[1, 0, 0, 0, 0, 0, 2, 4, 4], ... [0, 0, 0, 0, 0, 0, 5, 6, 1], ... [0, 1, 0, 0, 0, 0, 0, 2, 3], ... [11, 4, 0, 0, 8, 1, 6, 2, 0], ... [11, 5, 17, 7, 0, 0, 6, 6, 2], ... [9, 6, 0, 0, 6, 2, 10, 1, 4], ... [9, 7, 13, 10, 0, 0, 4, 5, 4], ... [7, 8, 0, 0, 4, 3, 6, 6, 4], ... [7, 9, 10, 13, 0, 0, 6, 2, 0], ... [5, 10, 0, 0, 2, 4, 0, 1, 3]]) >>> Y = pd.DataFrame(Y, sites, species) We can now perform canonical correspondence analysis. Matrix `X` contains a continuous variable (depth) and a categorical one (substrate type) encoded using a one-hot encoding. >>> from skbio.stats.ordination import cca We explicitly need to avoid perfect collinearity, so we'll drop one of the substrate types (the last column of `X`). >>> del X['substrate_other'] >>> ordination_result = cca(Y, X, scaling=2) Exploring the results we see that the first three axes explain about 80% of all the variance. >>> ordination_result.proportion_explained CCA1 0.466911 CCA2 0.238327 CCA3 0.100548 CCA4 0.104937 CCA5 0.044805 CCA6 0.029747 CCA7 0.012631 CCA8 0.001562 CCA9 0.000532 dtype: float64 References ---------- .. [1] Legendre P. and Legendre L. 1998. Numerical Ecology. Elsevier, Amsterdam. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._redundancy_analysis import rda from ._correspondence_analysis import ca from ._canonical_correspondence_analysis import cca from ._principal_coordinate_analysis import pcoa, pcoa_biplot from ._ordination_results import OrdinationResults from ._utils import (mean_and_std, scale, svd_rank, corr, e_matrix, f_matrix, center_distance_matrix) __all__ = ['ca', 'rda', 'cca', 'pcoa', 'pcoa_biplot', 'OrdinationResults', 'mean_and_std', 'scale', 'svd_rank', 'corr', 'e_matrix', 'f_matrix', 'center_distance_matrix'] scikit-bio-0.5.9/skbio/stats/ordination/_canonical_correspondence_analysis.py000066400000000000000000000203171446255456000276470ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd from scipy.linalg import svd, lstsq from ._ordination_results import OrdinationResults from ._utils import corr, svd_rank, scale from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def cca(y, x, scaling=1): r"""Compute canonical (also known as constrained) correspondence analysis. Canonical (or constrained) correspondence analysis is a multivariate ordination technique. It appeared in community ecology [1]_ and relates community composition to the variation in the environment (or in other factors). It works from data on abundances or counts of samples and constraints variables, and outputs ordination axes that maximize sample separation among species. It is better suited to extract the niches of taxa than linear multivariate methods because it assumes unimodal response curves (habitat preferences are often unimodal functions of habitat variables [2]_). As more environmental variables are added, the result gets more similar to unconstrained ordination, so only the variables that are deemed explanatory should be included in the analysis. Parameters ---------- y : DataFrame Samples by features table (n, m) x : DataFrame Samples by constraints table (n, q) scaling : int, {1, 2}, optional Scaling type 1 maintains :math:`\chi^2` distances between rows. Scaling type 2 preserves :math:`\chi^2` distances between columns. For a more detailed explanation of the interpretation, check Legendre & Legendre 1998, section 9.4.3. Returns ------- OrdinationResults Object that stores the cca results. Raises ------ ValueError If `x` and `y` have different number of rows If `y` contains negative values If `y` contains a row of only 0's. NotImplementedError If scaling is not 1 or 2. See Also -------- ca rda OrdinationResults Notes ----- The algorithm is based on [3]_, \S 11.2, and is expected to give the same results as ``cca(y, x)`` in R's package vegan, except that this implementation won't drop constraining variables due to perfect collinearity: the user needs to choose which ones to input. Canonical *correspondence* analysis shouldn't be confused with canonical *correlation* analysis (CCorA, but sometimes called CCA), a different technique to search for multivariate relationships between two datasets. Canonical correlation analysis is a statistical tool that, given two vectors of random variables, finds linear combinations that have maximum correlation with each other. In some sense, it assumes linear responses of "species" to "environmental variables" and is not well suited to analyze ecological data. References ---------- .. [1] Cajo J. F. Ter Braak, "Canonical Correspondence Analysis: A New Eigenvector Technique for Multivariate Direct Gradient Analysis", Ecology 67.5 (1986), pp. 1167-1179. .. [2] Cajo J.F. Braak and Piet F.M. Verdonschot, "Canonical correspondence analysis and related multivariate methods in aquatic ecology", Aquatic Sciences 57.3 (1995), pp. 255-289. .. [3] Legendre P. and Legendre L. 1998. Numerical Ecology. Elsevier, Amsterdam. """ Y = y.values X = x.values # Perform parameter sanity checks if X.shape[0] != Y.shape[0]: raise ValueError("The samples by features table 'y' and the samples by" " constraints table 'x' must have the same number of " " rows. 'y': {0} 'x': {1}".format(X.shape[0], Y.shape[0])) if Y.min() < 0: raise ValueError( "The samples by features table 'y' must be nonnegative") row_max = Y.max(axis=1) if np.any(row_max <= 0): # Or else the lstsq call to compute Y_hat breaks raise ValueError("The samples by features table 'y' cannot contain a " "row with only 0's") if scaling not in {1, 2}: raise NotImplementedError( "Scaling {0} not implemented.".format(scaling)) # Step 1 (similar to Pearson chi-square statistic) grand_total = Y.sum() Q = Y / grand_total # Relative frequencies of Y (contingency table) # Features and sample weights (marginal totals) column_marginals = Q.sum(axis=0) row_marginals = Q.sum(axis=1) # Formula 9.32 in Lagrange & Lagrange (1998). Notice that it's an # scaled version of the contribution of each cell towards Pearson # chi-square statistic. expected = np.outer(row_marginals, column_marginals) Q_bar = (Q - expected) / np.sqrt(expected) # Step 2. Standardize columns of X with respect to sample weights, # using the maximum likelihood variance estimator (Legendre & # Legendre 1998, p. 595) X = scale(X, weights=row_marginals, ddof=0) # Step 3. Weighted multiple regression. X_weighted = row_marginals[:, None]**0.5 * X B, _, rank_lstsq, _ = lstsq(X_weighted, Q_bar) Y_hat = X_weighted.dot(B) Y_res = Q_bar - Y_hat # Step 4. Eigenvalue decomposition u, s, vt = svd(Y_hat, full_matrices=False) rank = svd_rank(Y_hat.shape, s) s = s[:rank] u = u[:, :rank] vt = vt[:rank] U = vt.T # Step 5. Eq. 9.38 U_hat = Q_bar.dot(U) * s**-1 # Residuals analysis u_res, s_res, vt_res = svd(Y_res, full_matrices=False) rank = svd_rank(Y_res.shape, s_res) s_res = s_res[:rank] u_res = u_res[:, :rank] vt_res = vt_res[:rank] U_res = vt_res.T U_hat_res = Y_res.dot(U_res) * s_res**-1 eigenvalues = np.r_[s, s_res]**2 # Scalings (p. 596 L&L 1998): # feature scores, scaling 1 V = (column_marginals**-0.5)[:, None] * U # sample scores, scaling 2 V_hat = (row_marginals**-0.5)[:, None] * U_hat # sample scores, scaling 1 F = V_hat * s # feature scores, scaling 2 F_hat = V * s # Sample scores which are linear combinations of constraint # variables Z_scaling1 = ((row_marginals**-0.5)[:, None] * Y_hat.dot(U)) Z_scaling2 = Z_scaling1 * s**-1 # Feature residual scores, scaling 1 V_res = (column_marginals**-0.5)[:, None] * U_res # Sample residual scores, scaling 2 V_hat_res = (row_marginals**-0.5)[:, None] * U_hat_res # Sample residual scores, scaling 1 F_res = V_hat_res * s_res # Feature residual scores, scaling 2 F_hat_res = V_res * s_res eigvals = eigenvalues if scaling == 1: features_scores = np.hstack((V, V_res)) sample_scores = np.hstack((F, F_res)) sample_constraints = np.hstack((Z_scaling1, F_res)) elif scaling == 2: features_scores = np.hstack((F_hat, F_hat_res)) sample_scores = np.hstack((V_hat, V_hat_res)) sample_constraints = np.hstack((Z_scaling2, V_hat_res)) biplot_scores = corr(X_weighted, u) pc_ids = ['CCA%d' % (i+1) for i in range(len(eigenvalues))] sample_ids = y.index feature_ids = y.columns eigvals = pd.Series(eigenvalues, index=pc_ids) samples = pd.DataFrame(sample_scores, columns=pc_ids, index=sample_ids) features = pd.DataFrame(features_scores, columns=pc_ids, index=feature_ids) biplot_scores = pd.DataFrame(biplot_scores, index=x.columns, columns=pc_ids[:biplot_scores.shape[1]]) sample_constraints = pd.DataFrame(sample_constraints, index=sample_ids, columns=pc_ids) return OrdinationResults( "CCA", "Canonical Correspondence Analysis", eigvals, samples, features=features, biplot_scores=biplot_scores, sample_constraints=sample_constraints, proportion_explained=eigvals / eigvals.sum()) scikit-bio-0.5.9/skbio/stats/ordination/_correspondence_analysis.py000066400000000000000000000171041446255456000256400ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd from scipy.linalg import svd from ._ordination_results import OrdinationResults from ._utils import svd_rank from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def ca(X, scaling=1): r"""Compute correspondence analysis, a multivariate statistical technique for ordination. In general, rows in the data table will correspond to samples and columns to features, but the method is symmetric. In order to measure the correspondence between rows and columns, the :math:`\chi^2` distance is used, and those distances are preserved in the transformed space. The :math:`\chi^2` distance doesn't take double zeros into account, and so it is expected to produce better ordination that PCA when the data has lots of zero values. It is related to Principal Component Analysis (PCA) but it should be preferred in the case of steep or long gradients, that is, when there are many zeros in the input data matrix. Parameters ---------- X : pd.DataFrame Samples by features table (n, m). It can be applied to different kinds of data tables but data must be non-negative and dimensionally homogeneous (quantitative or binary). The rows correspond to the samples and the columns correspond to the features. scaling : {1, 2} For a more detailed explanation of the interpretation, check Legendre & Legendre 1998, section 9.4.3. The notes that follow are quick recommendations. Scaling type 1 maintains :math:`\chi^2` distances between rows (samples): in the transformed space, the euclidean distances between rows are equal to the :math:`\chi^2` distances between rows in the original space. It should be used when studying the ordination of samples. Rows (samples) that are near a column (features) have high contributions from it. Scaling type 2 preserves :math:`\chi^2` distances between columns (features), so euclidean distance between columns after transformation is equal to :math:`\chi^2` distance between columns in the original space. It is best used when we are interested in the ordination of features. A column (features) that is next to a row (sample) means that it is more abundant there. Other types of scalings are currently not implemented, as they're less used by ecologists (Legendre & Legendre 1998, p. 456). In general, features appearing far from the center of the biplot and far from its edges will probably exhibit better relationships than features either in the center (may be multimodal features, not related to the shown ordination axes...) or the edges (sparse features...). Returns ------- OrdinationResults Object that stores the computed eigenvalues, the transformed sample coordinates, the transformed features coordinates and the proportion explained. Raises ------ NotImplementedError If the scaling value is not either `1` or `2`. ValueError If any of the input matrix elements are negative. See Also -------- cca rda OrdinationResults Notes ----- The algorithm is based on [1]_, \S 9.4.1., and is expected to give the same results as ``cca(X)`` in R's package vegan. References ---------- .. [1] Legendre P. and Legendre L. 1998. Numerical Ecology. Elsevier, Amsterdam. """ if scaling not in {1, 2}: raise NotImplementedError( "Scaling {0} not implemented.".format(scaling)) short_method_name = 'CA' long_method_name = 'Correspondance Analysis' # we deconstruct the dataframe to avoid duplicating the data and be able # to perform operations on the matrix row_ids = X.index column_ids = X.columns X = np.asarray(X.values, dtype=np.float64) # Correspondance Analysis r, c = X.shape if X.min() < 0: raise ValueError("Input matrix elements must be non-negative.") # Step 1 (similar to Pearson chi-square statistic) grand_total = X.sum() Q = X / grand_total column_marginals = Q.sum(axis=0) row_marginals = Q.sum(axis=1) # Formula 9.32 in Lagrange & Lagrange (1998). Notice that it's # an scaled version of the contribution of each cell towards # Pearson chi-square statistic. expected = np.outer(row_marginals, column_marginals) Q_bar = (Q - expected) / np.sqrt(expected) # Eq. 9.32 # Step 2 (Singular Value Decomposition) U_hat, W, Ut = svd(Q_bar, full_matrices=False) # Due to the centering, there are at most min(r, c) - 1 non-zero # eigenvalues (which are all positive) rank = svd_rank(Q_bar.shape, W) assert rank <= min(r, c) - 1 U_hat = U_hat[:, :rank] W = W[:rank] U = Ut[:rank].T # Both scalings are a bit intertwined, so we'll compute both and # then choose V = column_marginals[:, None]**-0.5 * U V_hat = row_marginals[:, None]**-0.5 * U_hat F = V_hat * W # According to Formula 9.43, this should hold # assert np.allclose(F, (row_marginals**-1)[:, None] * Q.dot(V)) # but it doesn't (notice that W**2==Lambda): # (9.43a) F = V_hat W = D(p_i+)^{-1/2} U_hat W # = D(p_i+)^{-1/2} Q_bar U W^{-1} W (substituting 9.38) # = D(p_i+)^{-1/2} Q_bar U # (9.43b) F = D(p_i+)^{-1} Q V # = D(p_i+)^{-1} Q D(p_+j)^{-1/2} U (substituting 9.41) # = D(p_i+)^{-1/2} D(p_i+)^{-1/2} Q D(p_+j)^{-1/2} U # = D(p_i+)^{-1/2} Q_tilde U (using 9.40) # It holds if we replace Q in 9.43b with Q after centering, ie # assert np.allclose( # F, # (row_marginals**-1)[:, None] * (Q - expected).dot(V)) # Comparing results with vegan and the examples in the book, 9.43a # is the right one. The same issue happens in 9.44, where also # 9.44a is the one that matches vegan's output. # (9.44a) F_hat = V W = D(p_+j)^{-1/2} U W # = D(p_+j)^{-1/2} Q_bar' U_hat W^{-1} W (using 9.39) # = D(p_+j)^{-1/2} Q_bar' U_hat # (9.44b) F_hat = D(p_+j)^{-1} Q' V_hat # = D(p_+j)^{-1/2} Q_tilde' U_hat (using 9.40 and 9.42) F_hat = V * W # Eigenvalues eigvals = W**2 # features scores features_scores = [V, F_hat][scaling - 1] # sample scores (weighted averages of features scores) sample_scores = [F, V_hat][scaling - 1] # build the OrdinationResults object sample_columns = ['%s%d' % (short_method_name, i+1) for i in range(sample_scores.shape[1])] feature_columns = ['%s%d' % (short_method_name, i+1) for i in range(features_scores.shape[1])] eigvals = pd.Series(eigvals, ['%s%d' % (short_method_name, i+1) for i in range(eigvals.shape[0])]) samples = pd.DataFrame(sample_scores, row_ids, sample_columns) features = pd.DataFrame(features_scores, column_ids, feature_columns) proportion_explained = eigvals / eigvals.sum() return OrdinationResults(short_method_name, long_method_name, eigvals, samples=samples, features=features, proportion_explained=proportion_explained) scikit-bio-0.5.9/skbio/stats/ordination/_cutils.c000066400000000000000000037370571446255456000220440ustar00rootroot00000000000000/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [], "extra_compile_args": [ "-I.", "-fopenmp-simd", "-DSIMDE_ENABLE_OPENMP" ], "name": "skbio.stats.ordination._cutils", "sources": [ "skbio/stats/ordination/_cutils.pyx" ] }, "module_name": "skbio.stats.ordination._cutils" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__skbio__stats__ordination___cutils #define __PYX_HAVE_API__skbio__stats__ordination___cutils /* Early includes */ #include "pythread.h" #include #include #include #include "pystate.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "skbio/stats/ordination/_cutils.pyx", "stringsource", }; /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release #define __Pyx_FastGIL_Remember() #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif /* MemviewSliceStruct.proto */ struct __pyx_memoryview_obj; typedef struct { struct __pyx_memoryview_obj *memview; char *data; Py_ssize_t shape[8]; Py_ssize_t strides[8]; Py_ssize_t suboffsets[8]; } __Pyx_memviewslice; #define __Pyx_MemoryView_Len(m) (m.shape[0]) /* Atomics.proto */ #include #ifndef CYTHON_ATOMICS #define CYTHON_ATOMICS 1 #endif #define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS #define __pyx_atomic_int_type int #if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ (__GNUC_MINOR__ > 1 ||\ (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) #ifdef __PYX_DEBUG_ATOMICS #warning "Using GNU atomics" #endif #elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL #include #undef __pyx_atomic_int_type #define __pyx_atomic_int_type long #pragma intrinsic (_InterlockedExchangeAdd) #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) #ifdef __PYX_DEBUG_ATOMICS #pragma message ("Using MSVC atomics") #endif #else #undef CYTHON_ATOMICS #define CYTHON_ATOMICS 0 #ifdef __PYX_DEBUG_ATOMICS #warning "Not using atomics" #endif #endif typedef volatile __pyx_atomic_int_type __pyx_atomic_int; #if CYTHON_ATOMICS #define __pyx_add_acquisition_count(memview)\ __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) #define __pyx_sub_acquisition_count(memview)\ __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) #else #define __pyx_add_acquisition_count(memview)\ __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) #define __pyx_sub_acquisition_count(memview)\ __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) #endif /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /*--- Type declarations ---*/ struct __pyx_array_obj; struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; /* "View.MemoryView":106 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * * cdef: */ struct __pyx_array_obj { PyObject_HEAD struct __pyx_vtabstruct_array *__pyx_vtab; char *data; Py_ssize_t len; char *format; int ndim; Py_ssize_t *_shape; Py_ssize_t *_strides; Py_ssize_t itemsize; PyObject *mode; PyObject *_format; void (*callback_free_data)(void *); int free_data; int dtype_is_object; }; /* "View.MemoryView":280 * * @cname('__pyx_MemviewEnum') * cdef class Enum(object): # <<<<<<<<<<<<<< * cdef object name * def __init__(self, name): */ struct __pyx_MemviewEnum_obj { PyObject_HEAD PyObject *name; }; /* "View.MemoryView":331 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< * * cdef object obj */ struct __pyx_memoryview_obj { PyObject_HEAD struct __pyx_vtabstruct_memoryview *__pyx_vtab; PyObject *obj; PyObject *_size; PyObject *_array_interface; PyThread_type_lock lock; __pyx_atomic_int acquisition_count[2]; __pyx_atomic_int *acquisition_count_aligned_p; Py_buffer view; int flags; int dtype_is_object; __Pyx_TypeInfo *typeinfo; }; /* "View.MemoryView":967 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" * */ struct __pyx_memoryviewslice_obj { struct __pyx_memoryview_obj __pyx_base; __Pyx_memviewslice from_slice; PyObject *from_object; PyObject *(*to_object_func)(char *); int (*to_dtype_func)(char *, PyObject *); }; /* "View.MemoryView":106 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< * * cdef: */ struct __pyx_vtabstruct_array { PyObject *(*get_memview)(struct __pyx_array_obj *); }; static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; /* "View.MemoryView":331 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< * * cdef object obj */ struct __pyx_vtabstruct_memoryview { char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); }; static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; /* "View.MemoryView":967 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< * "Internal class for passing memoryview slices to Python" * */ struct __pyx_vtabstruct__memoryviewslice { struct __pyx_vtabstruct_memoryview __pyx_base; }; static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictContains.proto */ static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { int result = PyDict_Contains(dict, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* UnicodeAsUCS4.proto */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); /* object_ord.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyObject_Ord(c)\ (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) #else #define __Pyx_PyObject_Ord(c) __Pyx__PyObject_Ord(c) #endif static long __Pyx__PyObject_Ord(PyObject* c); /* SetItemInt.proto */ #define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, int wraparound, int boundscheck); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* MemviewSliceInit.proto */ #define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d #define __Pyx_MEMVIEW_DIRECT 1 #define __Pyx_MEMVIEW_PTR 2 #define __Pyx_MEMVIEW_FULL 4 #define __Pyx_MEMVIEW_CONTIG 8 #define __Pyx_MEMVIEW_STRIDED 16 #define __Pyx_MEMVIEW_FOLLOW 32 #define __Pyx_IS_C_CONTIG 1 #define __Pyx_IS_F_CONTIG 2 static int __Pyx_init_memviewslice( struct __pyx_memoryview_obj *memview, int ndim, __Pyx_memviewslice *memviewslice, int memview_is_new_reference); static CYTHON_INLINE int __pyx_add_acquisition_count_locked( __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); #define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) #define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) #define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) #define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* DivInt[Py_ssize_t].proto */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); /* UnaryNegOverflows.proto */ #define UNARY_NEG_WOULD_OVERFLOW(x)\ (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* decode_c_string_utf16.proto */ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 0; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = -1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } /* decode_c_string.proto */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* ListExtend.proto */ static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { #if CYTHON_COMPILING_IN_CPYTHON PyObject* none = _PyList_Extend((PyListObject*)L, v); if (unlikely(!none)) return -1; Py_DECREF(none); return 0; #else return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); #endif } /* None.proto */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); /* DivInt[long].proto */ static CYTHON_INLINE long __Pyx_div_long(long, long); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* CythonFunctionShared.proto */ #define __Pyx_CyFunction_USED 1 #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { PyCFunctionObject func; #if PY_VERSION_HEX < 0x030500A0 PyObject *func_weakreflist; #endif PyObject *func_dict; PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; PyObject *func_classobj; void *defaults; int defaults_pyobjects; size_t defaults_size; // used by FusedFunction for copying defaults int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, size_t size, int pyobjects); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(void); /* FusedFunction.proto */ typedef struct { __pyx_CyFunctionObject func; PyObject *__signatures__; PyObject *type; PyObject *self; } __pyx_FusedFunctionObject; static PyObject *__pyx_FusedFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject *code); static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self); static PyTypeObject *__pyx_FusedFunctionType = NULL; static int __pyx_FusedFunction_init(void); #define __Pyx_FusedFunction_USED /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; /* MemviewSliceIsContig.proto */ static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); /* OverlappingSlices.proto */ static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, __Pyx_memviewslice *slice2, int ndim, size_t itemsize); /* Capsule.proto */ static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* TypeInfoCompare.proto */ static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); /* MemviewSliceValidateAndInit.proto */ static int __Pyx_ValidateAndInit_memviewslice( int *axes_specs, int c_or_f_flag, int buf_flags, int ndim, __Pyx_TypeInfo *dtype, __Pyx_BufFmt_StackElem stack[], __Pyx_memviewslice *memviewslice, PyObject *original_obj); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_float(PyObject *, int writable_flag); /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(PyObject *, int writable_flag); /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* MemviewDtypeToObject.proto */ static CYTHON_INLINE PyObject *__pyx_memview_get_float(const char *itemp); static CYTHON_INLINE int __pyx_memview_set_float(const char *itemp, PyObject *obj); /* MemviewDtypeToObject.proto */ static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp); static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj); /* MemviewSliceCopyTemplate.proto */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, const char *mode, int ndim, size_t sizeof_dtype, int contig_flag, int dtype_is_object); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* BytesContains.proto */ static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character); /* ImportNumPyArray.proto */ static PyObject *__pyx_numpy_ndarray = NULL; static PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ /* Module declarations from 'cython.view' */ /* Module declarations from 'cython' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'skbio.stats.ordination._cutils' */ static PyTypeObject *__pyx_array_type = 0; static PyTypeObject *__pyx_MemviewEnum_type = 0; static PyTypeObject *__pyx_memoryview_type = 0; static PyTypeObject *__pyx_memoryviewslice_type = 0; static PyObject *generic = 0; static PyObject *strided = 0; static PyObject *indirect = 0; static PyObject *contiguous = 0; static PyObject *indirect_contiguous = 0; static int __pyx_memoryview_thread_locks_used; static PyThread_type_lock __pyx_memoryview_thread_locks[8]; static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ static void *__pyx_align_pointer(void *, size_t); /*proto*/ static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ static PyObject *_unellipsify(PyObject *, int); /*proto*/ static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/ static int __pyx_memoryview_err(PyObject *, char *); /*proto*/ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "skbio.stats.ordination._cutils" extern int __pyx_module_is_main_skbio__stats__ordination___cutils; int __pyx_module_is_main_skbio__stats__ordination___cutils = 0; /* Implementation of 'skbio.stats.ordination._cutils' */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_Ellipsis; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_IndexError; static const char __pyx_k_[] = "()"; static const char __pyx_k_O[] = "O"; static const char __pyx_k_c[] = "c"; static const char __pyx_k_s[] = "s"; static const char __pyx_k__2[] = "|"; static const char __pyx_k_d2[] = "d2"; static const char __pyx_k_d3[] = "d3"; static const char __pyx_k_d4[] = "d4"; static const char __pyx_k_d5[] = "d5"; static const char __pyx_k_id[] = "id"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_col[] = "col"; static const char __pyx_k_el0[] = "el0"; static const char __pyx_k_mat[] = "mat"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_obj[] = "obj"; static const char __pyx_k_row[] = "row"; static const char __pyx_k_args[] = "args"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_kind[] = "kind"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mode[] = "mode"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_ndim[] = "ndim"; static const char __pyx_k_pack[] = "pack"; static const char __pyx_k_size[] = "size"; static const char __pyx_k_step[] = "step"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_tcol[] = "tcol"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_trow[] = "trow"; static const char __pyx_k_ASCII[] = "ASCII"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_flags[] = "flags"; static const char __pyx_k_float[] = "float"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_strip[] = "strip"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_double[] = "double"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_kwargs[] = "kwargs"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_struct[] = "struct"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_float32[] = "float32"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_fortran[] = "fortran"; static const char __pyx_k_gr_mean[] = "gr_mean"; static const char __pyx_k_memview[] = "memview"; static const char __pyx_k_row_sum[] = "row_sum"; static const char __pyx_k_Ellipsis[] = "Ellipsis"; static const char __pyx_k_centered[] = "centered"; static const char __pyx_k_defaults[] = "defaults"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_itemsize[] = "itemsize"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_tcol_max[] = "tcol_max"; static const char __pyx_k_trow_max[] = "trow_max"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_n_samples[] = "n_samples"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_row_means[] = "row_means"; static const char __pyx_k_IndexError[] = "IndexError"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_dtype_real[] = "dtype_real"; static const char __pyx_k_global_sum[] = "global_sum"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_signatures[] = "signatures"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_global_mean[] = "global_mean"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_row_means_np[] = "row_means_np"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_e_matrix_means_cy[] = "e_matrix_means_cy"; static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_strided_and_direct[] = ""; static const char __pyx_k_f_matrix_inplace_cy[] = "f_matrix_inplace_cy"; static const char __pyx_k_strided_and_indirect[] = ""; static const char __pyx_k_contiguous_and_direct[] = ""; static const char __pyx_k_MemoryView_of_r_object[] = ""; static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; static const char __pyx_k_contiguous_and_indirect[] = ""; static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; static const char __pyx_k_center_distance_matrix_cy[] = "center_distance_matrix_cy"; static const char __pyx_k_No_matching_signature_found[] = "No matching signature found"; static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; static const char __pyx_k_skbio_stats_ordination__cutils[] = "skbio.stats.ordination._cutils"; static const char __pyx_k_strided_and_direct_or_indirect[] = ""; static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; static const char __pyx_k_Expected_at_least_d_argument_s_g[] = "Expected at least %d argument%s, got %d"; static const char __pyx_k_Function_call_with_ambiguous_arg[] = "Function call with ambiguous argument types"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_skbio_stats_ordination__cutils_p[] = "skbio/stats/ordination/_cutils.pyx"; static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; static PyObject *__pyx_kp_s_; static PyObject *__pyx_n_s_ASCII; static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; static PyObject *__pyx_kp_s_Cannot_index_with_type_s; static PyObject *__pyx_n_s_Ellipsis; static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; static PyObject *__pyx_kp_s_Expected_at_least_d_argument_s_g; static PyObject *__pyx_kp_s_Function_call_with_ambiguous_arg; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; static PyObject *__pyx_n_s_IndexError; static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; static PyObject *__pyx_n_s_MemoryError; static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; static PyObject *__pyx_kp_s_MemoryView_of_r_object; static PyObject *__pyx_kp_s_No_matching_signature_found; static PyObject *__pyx_n_b_O; static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_View_MemoryView; static PyObject *__pyx_kp_s__2; static PyObject *__pyx_n_s_allocate_buffer; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_base; static PyObject *__pyx_n_s_c; static PyObject *__pyx_n_u_c; static PyObject *__pyx_n_s_center_distance_matrix_cy; static PyObject *__pyx_n_s_centered; static PyObject *__pyx_n_s_class; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_col; static PyObject *__pyx_kp_s_contiguous_and_direct; static PyObject *__pyx_kp_s_contiguous_and_indirect; static PyObject *__pyx_n_s_d2; static PyObject *__pyx_n_s_d3; static PyObject *__pyx_n_s_d4; static PyObject *__pyx_n_s_d5; static PyObject *__pyx_n_s_defaults; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_double; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dtype_is_object; static PyObject *__pyx_n_s_dtype_real; static PyObject *__pyx_n_s_e_matrix_means_cy; static PyObject *__pyx_n_s_el0; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_f_matrix_inplace_cy; static PyObject *__pyx_n_s_flags; static PyObject *__pyx_n_s_float; static PyObject *__pyx_n_s_float32; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_format; static PyObject *__pyx_n_s_fortran; static PyObject *__pyx_n_u_fortran; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_global_mean; static PyObject *__pyx_n_s_global_sum; static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; static PyObject *__pyx_n_s_gr_mean; static PyObject *__pyx_n_s_id; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_itemsize; static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; static PyObject *__pyx_n_s_kind; static PyObject *__pyx_n_s_kwargs; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mat; static PyObject *__pyx_n_s_memview; static PyObject *__pyx_n_s_mode; static PyObject *__pyx_n_s_n_samples; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_n_s_ndim; static PyObject *__pyx_n_s_new; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_n_s_obj; static PyObject *__pyx_n_s_pack; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_getbuffer; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_Enum; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_row; static PyObject *__pyx_n_s_row_means; static PyObject *__pyx_n_s_row_means_np; static PyObject *__pyx_n_s_row_sum; static PyObject *__pyx_n_s_s; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_shape; static PyObject *__pyx_n_s_signatures; static PyObject *__pyx_n_s_size; static PyObject *__pyx_n_s_skbio_stats_ordination__cutils; static PyObject *__pyx_kp_s_skbio_stats_ordination__cutils_p; static PyObject *__pyx_n_s_split; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_step; static PyObject *__pyx_n_s_stop; static PyObject *__pyx_kp_s_strided_and_direct; static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; static PyObject *__pyx_kp_s_strided_and_indirect; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_strip; static PyObject *__pyx_n_s_struct; static PyObject *__pyx_n_s_tcol; static PyObject *__pyx_n_s_tcol_max; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_trow; static PyObject *__pyx_n_s_trow_max; static PyObject *__pyx_kp_s_unable_to_allocate_array_data; static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; static PyObject *__pyx_n_s_unpack; static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_6e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered, __Pyx_memviewslice __pyx_v_row_means); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_8e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered, __Pyx_memviewslice __pyx_v_row_means); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_12f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_row_means, float __pyx_v_global_mean, __Pyx_memviewslice __pyx_v_centered); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_14f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_row_means, double __pyx_v_global_mean, __Pyx_memviewslice __pyx_v_centered); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_18center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered); /* proto */ static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_20center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; static PyObject *__pyx_int_3; static PyObject *__pyx_int_112105877; static PyObject *__pyx_int_136983863; static PyObject *__pyx_int_184977713; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_slice__19; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__21; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__35; static PyObject *__pyx_codeobj__25; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__36; /* Late includes */ /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_1e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy[] = "\n Compute E matrix from a distance matrix, and \n also compute the means in the process.\n\n Squares and divides by -2 the input elementwise. Eq. 9.20 in\n Legendre & Legendre 1998.\n\n\n Parameters\n ----------\n mat : 2D array_like\n Distance matrix.\n centered : 2D array_like\n Output, E matrix. Must be pre-allocated and same shape as mat.\n Can point to mat (i.e. in-place)\n row_means : 1D_array_like\n Output, Mean values of each row in `centered`\n Returns\n -------\n global_mean : real\n Global mean value\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_10ordination_7_cutils_1e_matrix_means_cy = {"e_matrix_means_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_10ordination_7_cutils_1e_matrix_means_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy}; static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_1e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 19, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("e_matrix_means_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_mat, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_mat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 19, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 19, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 19, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_7e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_7e_matrix_means_cy = {"__pyx_fuse_0e_matrix_means_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_7e_matrix_means_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_7e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("e_matrix_means_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mat,&__pyx_n_s_centered,&__pyx_n_s_row_means,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, 1); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_row_means)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, 2); __PYX_ERR(0, 19, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "e_matrix_means_cy") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 19, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 19, __pyx_L3_error) __pyx_v_row_means = __Pyx_PyObject_to_MemoryviewSlice_dc_float(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_row_means.memview)) __PYX_ERR(0, 19, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.e_matrix_means_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_6e_matrix_means_cy(__pyx_self, __pyx_v_mat, __pyx_v_centered, __pyx_v_row_means); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_6e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered, __Pyx_memviewslice __pyx_v_row_means) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_d4; Py_ssize_t __pyx_v_d5; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; long double __pyx_v_row_sum; float __pyx_v_el0; long double __pyx_v_global_sum; float __pyx_v_global_mean; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; long double __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0e_matrix_means_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":42 * Global mean value * """ * cdef Py_ssize_t n_samples = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] */ __pyx_v_n_samples = (__pyx_v_mat.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":43 * """ * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] */ __pyx_v_d2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":44 * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d4 = centered.shape[1] * cdef Py_ssize_t d5 = row_means.shape[0] */ __pyx_v_d3 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":45 * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d5 = row_means.shape[0] * */ __pyx_v_d4 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":46 * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] * cdef Py_ssize_t d5 = row_means.shape[0] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d5 = (__pyx_v_row_means.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":48 * cdef Py_ssize_t d5 = row_means.shape[0] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * assert n_samples == d4 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 48, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":49 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * assert n_samples == d4 * assert n_samples == d5 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 49, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":50 * assert n_samples == d2 * assert n_samples == d3 * assert n_samples == d4 # <<<<<<<<<<<<<< * assert n_samples == d5 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d4) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 50, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":51 * assert n_samples == d3 * assert n_samples == d4 * assert n_samples == d5 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d5) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 51, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":57 * cdef TReal el0 * * cdef long double global_sum = 0.0 # <<<<<<<<<<<<<< * for row in prange(n_samples, nogil=True): * row_sum = 0.0 */ __pyx_v_global_sum = 0.0; /* "skbio/stats/ordination/_cutils.pyx":58 * * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< * row_sum = 0.0 * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_n_samples; if ((1 == 0)) abort(); { Py_ssize_t __pyx_parallel_temp0 = ((Py_ssize_t)0xbad0bad0); float __pyx_parallel_temp1 = ((float)__PYX_NAN()); long double __pyx_parallel_temp2 = ((long double)__PYX_NAN()); Py_ssize_t __pyx_parallel_temp3 = ((Py_ssize_t)0xbad0bad0); long double __pyx_parallel_temp4 = ((long double)__PYX_NAN()); const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; int __pyx_parallel_why; __pyx_parallel_why = 0; #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(+:__pyx_v_global_sum) private(__pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) #endif /* _OPENMP */ { #ifdef _OPENMP #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif Py_BEGIN_ALLOW_THREADS #endif /* _OPENMP */ #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_el0) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_row_sum) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ if (__pyx_parallel_why < 2) { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_el0 = ((float)__PYX_NAN()); __pyx_v_row_sum = ((long double)__PYX_NAN()); /* "skbio/stats/ordination/_cutils.pyx":59 * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): * row_sum = 0.0 # <<<<<<<<<<<<<< * * for col in range(n_samples): */ __pyx_v_row_sum = 0.0; /* "skbio/stats/ordination/_cutils.pyx":61 * row_sum = 0.0 * * for col in range(n_samples): # <<<<<<<<<<<<<< * el0 = mat[row,col] * el0 = -0.5*el0*el0 */ __pyx_t_4 = __pyx_v_n_samples; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_col = __pyx_t_6; /* "skbio/stats/ordination/_cutils.pyx":62 * * for col in range(n_samples): * el0 = mat[row,col] # <<<<<<<<<<<<<< * el0 = -0.5*el0*el0 * centered[row,col] = el0 */ __pyx_t_7 = __pyx_v_row; __pyx_t_8 = __pyx_v_col; __pyx_v_el0 = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_7 * __pyx_v_mat.strides[0]) )) + __pyx_t_8)) ))); /* "skbio/stats/ordination/_cutils.pyx":63 * for col in range(n_samples): * el0 = mat[row,col] * el0 = -0.5*el0*el0 # <<<<<<<<<<<<<< * centered[row,col] = el0 * # Note: do not use +=, so it is not flagged as a global reduction */ __pyx_v_el0 = ((-0.5 * __pyx_v_el0) * __pyx_v_el0); /* "skbio/stats/ordination/_cutils.pyx":64 * el0 = mat[row,col] * el0 = -0.5*el0*el0 * centered[row,col] = el0 # <<<<<<<<<<<<<< * # Note: do not use +=, so it is not flagged as a global reduction * row_sum = row_sum + el0 */ __pyx_t_8 = __pyx_v_row; __pyx_t_7 = __pyx_v_col; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_8 * __pyx_v_centered.strides[0]) )) + __pyx_t_7)) )) = __pyx_v_el0; /* "skbio/stats/ordination/_cutils.pyx":66 * centered[row,col] = el0 * # Note: do not use +=, so it is not flagged as a global reduction * row_sum = row_sum + el0 # <<<<<<<<<<<<<< * * global_sum += row_sum */ __pyx_v_row_sum = (__pyx_v_row_sum + __pyx_v_el0); } /* "skbio/stats/ordination/_cutils.pyx":68 * row_sum = row_sum + el0 * * global_sum += row_sum # <<<<<<<<<<<<<< * row_means[row] = row_sum/n_samples * */ __pyx_v_global_sum = (__pyx_v_global_sum + __pyx_v_row_sum); /* "skbio/stats/ordination/_cutils.pyx":69 * * global_sum += row_sum * row_means[row] = row_sum/n_samples # <<<<<<<<<<<<<< * * cdef TReal global_mean = (global_sum/n_samples)/n_samples */ if (unlikely(__pyx_v_n_samples == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 69, __pyx_L8_error) } __pyx_t_7 = __pyx_v_row; *((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row_means.data) + __pyx_t_7)) )) = (__pyx_v_row_sum / __pyx_v_n_samples); goto __pyx_L13; __pyx_L8_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #ifdef _OPENMP #pragma omp flush(__pyx_parallel_exc_type) #endif /* _OPENMP */ if (!__pyx_parallel_exc_type) { __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; __Pyx_GOTREF(__pyx_parallel_exc_type); } #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_parallel_why = 4; goto __pyx_L12; __pyx_L12:; #ifdef _OPENMP #pragma omp critical(__pyx_parallel_lastprivates2) #endif /* _OPENMP */ { __pyx_parallel_temp0 = __pyx_v_col; __pyx_parallel_temp1 = __pyx_v_el0; __pyx_parallel_temp2 = __pyx_v_global_sum; __pyx_parallel_temp3 = __pyx_v_row; __pyx_parallel_temp4 = __pyx_v_row_sum; } __pyx_L13:; #ifdef _OPENMP #pragma omp flush(__pyx_parallel_why) #endif /* _OPENMP */ } } #ifdef _OPENMP Py_END_ALLOW_THREADS #else { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #endif /* _OPENMP */ /* Clean up any temporaries */ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif #ifndef _OPENMP } #endif /* _OPENMP */ } } if (__pyx_parallel_exc_type) { /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ __pyx_parallel_why = 4; } if (__pyx_parallel_why) { __pyx_v_col = __pyx_parallel_temp0; __pyx_v_el0 = __pyx_parallel_temp1; __pyx_v_global_sum = __pyx_parallel_temp2; __pyx_v_row = __pyx_parallel_temp3; __pyx_v_row_sum = __pyx_parallel_temp4; switch (__pyx_parallel_why) { case 4: { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_GIVEREF(__pyx_parallel_exc_type); __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } goto __pyx_L4_error; } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/ordination/_cutils.pyx":58 * * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< * row_sum = 0.0 * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L4_error: { #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L1_error; } __pyx_L5:; } } /* "skbio/stats/ordination/_cutils.pyx":71 * row_means[row] = row_sum/n_samples * * cdef TReal global_mean = (global_sum/n_samples)/n_samples # <<<<<<<<<<<<<< * * return global_mean */ if (unlikely(__pyx_v_n_samples == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 71, __pyx_L1_error) } __pyx_t_9 = (__pyx_v_global_sum / __pyx_v_n_samples); if (unlikely(__pyx_v_n_samples == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 71, __pyx_L1_error) } __pyx_v_global_mean = (__pyx_t_9 / __pyx_v_n_samples); /* "skbio/stats/ordination/_cutils.pyx":73 * cdef TReal global_mean = (global_sum/n_samples)/n_samples * * return global_mean # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __Pyx_XDECREF(__pyx_r); __pyx_t_10 = PyFloat_FromDouble(__pyx_v_global_mean); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.stats.ordination._cutils.e_matrix_means_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_9e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_9e_matrix_means_cy = {"__pyx_fuse_1e_matrix_means_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_9e_matrix_means_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_e_matrix_means_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_9e_matrix_means_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("e_matrix_means_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mat,&__pyx_n_s_centered,&__pyx_n_s_row_means,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, 1); __PYX_ERR(0, 19, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_row_means)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, 2); __PYX_ERR(0, 19, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "e_matrix_means_cy") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 19, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 19, __pyx_L3_error) __pyx_v_row_means = __Pyx_PyObject_to_MemoryviewSlice_dc_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_row_means.memview)) __PYX_ERR(0, 19, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("e_matrix_means_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 19, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.e_matrix_means_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_8e_matrix_means_cy(__pyx_self, __pyx_v_mat, __pyx_v_centered, __pyx_v_row_means); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_8e_matrix_means_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered, __Pyx_memviewslice __pyx_v_row_means) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_d4; Py_ssize_t __pyx_v_d5; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; long double __pyx_v_row_sum; double __pyx_v_el0; long double __pyx_v_global_sum; double __pyx_v_global_mean; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; long double __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1e_matrix_means_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":42 * Global mean value * """ * cdef Py_ssize_t n_samples = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] */ __pyx_v_n_samples = (__pyx_v_mat.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":43 * """ * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] */ __pyx_v_d2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":44 * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d4 = centered.shape[1] * cdef Py_ssize_t d5 = row_means.shape[0] */ __pyx_v_d3 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":45 * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d5 = row_means.shape[0] * */ __pyx_v_d4 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":46 * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] * cdef Py_ssize_t d5 = row_means.shape[0] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d5 = (__pyx_v_row_means.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":48 * cdef Py_ssize_t d5 = row_means.shape[0] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * assert n_samples == d4 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 48, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":49 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * assert n_samples == d4 * assert n_samples == d5 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 49, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":50 * assert n_samples == d2 * assert n_samples == d3 * assert n_samples == d4 # <<<<<<<<<<<<<< * assert n_samples == d5 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d4) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 50, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":51 * assert n_samples == d3 * assert n_samples == d4 * assert n_samples == d5 # <<<<<<<<<<<<<< * * cdef Py_ssize_t row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d5) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 51, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":57 * cdef TReal el0 * * cdef long double global_sum = 0.0 # <<<<<<<<<<<<<< * for row in prange(n_samples, nogil=True): * row_sum = 0.0 */ __pyx_v_global_sum = 0.0; /* "skbio/stats/ordination/_cutils.pyx":58 * * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< * row_sum = 0.0 * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_n_samples; if ((1 == 0)) abort(); { Py_ssize_t __pyx_parallel_temp0 = ((Py_ssize_t)0xbad0bad0); double __pyx_parallel_temp1 = ((double)__PYX_NAN()); long double __pyx_parallel_temp2 = ((long double)__PYX_NAN()); Py_ssize_t __pyx_parallel_temp3 = ((Py_ssize_t)0xbad0bad0); long double __pyx_parallel_temp4 = ((long double)__PYX_NAN()); const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; int __pyx_parallel_why; __pyx_parallel_why = 0; #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel reduction(+:__pyx_v_global_sum) private(__pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) #endif /* _OPENMP */ { #ifdef _OPENMP #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif Py_BEGIN_ALLOW_THREADS #endif /* _OPENMP */ #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_el0) firstprivate(__pyx_v_row) lastprivate(__pyx_v_row) lastprivate(__pyx_v_row_sum) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ if (__pyx_parallel_why < 2) { __pyx_v_row = (Py_ssize_t)(0 + 1 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_el0 = ((double)__PYX_NAN()); __pyx_v_row_sum = ((long double)__PYX_NAN()); /* "skbio/stats/ordination/_cutils.pyx":59 * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): * row_sum = 0.0 # <<<<<<<<<<<<<< * * for col in range(n_samples): */ __pyx_v_row_sum = 0.0; /* "skbio/stats/ordination/_cutils.pyx":61 * row_sum = 0.0 * * for col in range(n_samples): # <<<<<<<<<<<<<< * el0 = mat[row,col] * el0 = -0.5*el0*el0 */ __pyx_t_4 = __pyx_v_n_samples; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_col = __pyx_t_6; /* "skbio/stats/ordination/_cutils.pyx":62 * * for col in range(n_samples): * el0 = mat[row,col] # <<<<<<<<<<<<<< * el0 = -0.5*el0*el0 * centered[row,col] = el0 */ __pyx_t_7 = __pyx_v_row; __pyx_t_8 = __pyx_v_col; __pyx_v_el0 = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_mat.data + __pyx_t_7 * __pyx_v_mat.strides[0]) )) + __pyx_t_8)) ))); /* "skbio/stats/ordination/_cutils.pyx":63 * for col in range(n_samples): * el0 = mat[row,col] * el0 = -0.5*el0*el0 # <<<<<<<<<<<<<< * centered[row,col] = el0 * # Note: do not use +=, so it is not flagged as a global reduction */ __pyx_v_el0 = ((-0.5 * __pyx_v_el0) * __pyx_v_el0); /* "skbio/stats/ordination/_cutils.pyx":64 * el0 = mat[row,col] * el0 = -0.5*el0*el0 * centered[row,col] = el0 # <<<<<<<<<<<<<< * # Note: do not use +=, so it is not flagged as a global reduction * row_sum = row_sum + el0 */ __pyx_t_8 = __pyx_v_row; __pyx_t_7 = __pyx_v_col; *((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_8 * __pyx_v_centered.strides[0]) )) + __pyx_t_7)) )) = __pyx_v_el0; /* "skbio/stats/ordination/_cutils.pyx":66 * centered[row,col] = el0 * # Note: do not use +=, so it is not flagged as a global reduction * row_sum = row_sum + el0 # <<<<<<<<<<<<<< * * global_sum += row_sum */ __pyx_v_row_sum = (__pyx_v_row_sum + __pyx_v_el0); } /* "skbio/stats/ordination/_cutils.pyx":68 * row_sum = row_sum + el0 * * global_sum += row_sum # <<<<<<<<<<<<<< * row_means[row] = row_sum/n_samples * */ __pyx_v_global_sum = (__pyx_v_global_sum + __pyx_v_row_sum); /* "skbio/stats/ordination/_cutils.pyx":69 * * global_sum += row_sum * row_means[row] = row_sum/n_samples # <<<<<<<<<<<<<< * * cdef TReal global_mean = (global_sum/n_samples)/n_samples */ if (unlikely(__pyx_v_n_samples == 0)) { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif __PYX_ERR(0, 69, __pyx_L8_error) } __pyx_t_7 = __pyx_v_row; *((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_row_means.data) + __pyx_t_7)) )) = (__pyx_v_row_sum / __pyx_v_n_samples); goto __pyx_L13; __pyx_L8_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #ifdef _OPENMP #pragma omp flush(__pyx_parallel_exc_type) #endif /* _OPENMP */ if (!__pyx_parallel_exc_type) { __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; __Pyx_GOTREF(__pyx_parallel_exc_type); } #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_parallel_why = 4; goto __pyx_L12; __pyx_L12:; #ifdef _OPENMP #pragma omp critical(__pyx_parallel_lastprivates3) #endif /* _OPENMP */ { __pyx_parallel_temp0 = __pyx_v_col; __pyx_parallel_temp1 = __pyx_v_el0; __pyx_parallel_temp2 = __pyx_v_global_sum; __pyx_parallel_temp3 = __pyx_v_row; __pyx_parallel_temp4 = __pyx_v_row_sum; } __pyx_L13:; #ifdef _OPENMP #pragma omp flush(__pyx_parallel_why) #endif /* _OPENMP */ } } #ifdef _OPENMP Py_END_ALLOW_THREADS #else { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif #endif /* _OPENMP */ /* Clean up any temporaries */ #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif #ifndef _OPENMP } #endif /* _OPENMP */ } } if (__pyx_parallel_exc_type) { /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ __pyx_parallel_why = 4; } if (__pyx_parallel_why) { __pyx_v_col = __pyx_parallel_temp0; __pyx_v_el0 = __pyx_parallel_temp1; __pyx_v_global_sum = __pyx_parallel_temp2; __pyx_v_row = __pyx_parallel_temp3; __pyx_v_row_sum = __pyx_parallel_temp4; switch (__pyx_parallel_why) { case 4: { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_GIVEREF(__pyx_parallel_exc_type); __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } goto __pyx_L4_error; } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/ordination/_cutils.pyx":58 * * cdef long double global_sum = 0.0 * for row in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< * row_sum = 0.0 * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L4_error: { #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L1_error; } __pyx_L5:; } } /* "skbio/stats/ordination/_cutils.pyx":71 * row_means[row] = row_sum/n_samples * * cdef TReal global_mean = (global_sum/n_samples)/n_samples # <<<<<<<<<<<<<< * * return global_mean */ if (unlikely(__pyx_v_n_samples == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 71, __pyx_L1_error) } __pyx_t_9 = (__pyx_v_global_sum / __pyx_v_n_samples); if (unlikely(__pyx_v_n_samples == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 71, __pyx_L1_error) } __pyx_v_global_mean = (__pyx_t_9 / __pyx_v_n_samples); /* "skbio/stats/ordination/_cutils.pyx":73 * cdef TReal global_mean = (global_sum/n_samples)/n_samples * * return global_mean # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __Pyx_XDECREF(__pyx_r); __pyx_t_10 = PyFloat_FromDouble(__pyx_v_global_mean); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __pyx_t_10; __pyx_t_10 = 0; goto __pyx_L0; /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("skbio.stats.ordination._cutils.e_matrix_means_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/ordination/_cutils.pyx":77 * @cython.boundscheck(False) * @cython.wraparound(False) * def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Compute F matrix from E matrix inplace. */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_3f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy[] = "\n Compute F matrix from E matrix inplace.\n Centering step: for each element, the mean of the corresponding\n row and column are subtracted, and the mean of the whole\n matrix is added. Eq. 9.21 in Legendre & Legendre 1998.\n\n Modified from :func:`skbio.stats.ordination.f_matrix_inplace` function,\n\n Parameters\n ----------\n row_means : 1D_array_like\n Mean values of each row in `centered`\n global_mean : real\n Global mean value in `centered`\n centered : 2D array_like, must be symmetric\n In, a matrix representing the \"E matrix\" as described above.\n Out, the centered matrix\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_10ordination_7_cutils_3f_matrix_inplace_cy = {"f_matrix_inplace_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_10ordination_7_cutils_3f_matrix_inplace_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy}; static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_3f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 77, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 77, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 77, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 77, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 77, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("f_matrix_inplace_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_row_means, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_row_means); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_3); __Pyx_GIVEREF(__pyx_int_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 1) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 77, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 1) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 77, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 77, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 77, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 77, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 77, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 77, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 77, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_13f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_13f_matrix_inplace_cy = {"__pyx_fuse_0f_matrix_inplace_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_13f_matrix_inplace_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_13f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; float __pyx_v_global_mean; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("f_matrix_inplace_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row_means,&__pyx_n_s_global_mean,&__pyx_n_s_centered,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_row_means)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_global_mean)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, 1); __PYX_ERR(0, 77, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, 2); __PYX_ERR(0, 77, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "f_matrix_inplace_cy") < 0)) __PYX_ERR(0, 77, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_row_means = __Pyx_PyObject_to_MemoryviewSlice_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_row_means.memview)) __PYX_ERR(0, 77, __pyx_L3_error) __pyx_v_global_mean = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_global_mean == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 77, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 77, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.f_matrix_inplace_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_12f_matrix_inplace_cy(__pyx_self, __pyx_v_row_means, __pyx_v_global_mean, __pyx_v_centered); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_12f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_row_means, float __pyx_v_global_mean, __Pyx_memviewslice __pyx_v_centered) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_trow; Py_ssize_t __pyx_v_tcol; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_trow_max; Py_ssize_t __pyx_v_tcol_max; float __pyx_v_gr_mean; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0f_matrix_inplace_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":96 * Out, the centered matrix * """ * cdef Py_ssize_t n_samples = centered.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = centered.shape[1] * cdef Py_ssize_t d3 = row_means.shape[0] */ __pyx_v_n_samples = (__pyx_v_centered.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":97 * """ * cdef Py_ssize_t n_samples = centered.shape[0] * cdef Py_ssize_t d2 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = row_means.shape[0] * */ __pyx_v_d2 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":98 * cdef Py_ssize_t n_samples = centered.shape[0] * cdef Py_ssize_t d2 = centered.shape[1] * cdef Py_ssize_t d3 = row_means.shape[0] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d3 = (__pyx_v_row_means.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":100 * cdef Py_ssize_t d3 = row_means.shape[0] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 100, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":101 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * * cdef Py_ssize_t trow,tcol,row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 101, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":108 * * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, n_samples) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_n_samples; if ((24 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 24 - 24/abs(24)) / 24; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_gr_mean) lastprivate(__pyx_v_row) lastprivate(__pyx_v_tcol) lastprivate(__pyx_v_tcol_max) firstprivate(__pyx_v_trow) lastprivate(__pyx_v_trow) lastprivate(__pyx_v_trow_max) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_trow = (Py_ssize_t)(0 + 24 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_gr_mean = ((float)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol_max = ((Py_ssize_t)0xbad0bad0); __pyx_v_trow_max = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/ordination/_cutils.pyx":109 * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): * trow_max = min(trow+24, n_samples) # <<<<<<<<<<<<<< * * for tcol in range(0, n_samples, 24): */ __pyx_t_4 = __pyx_v_n_samples; __pyx_t_5 = (__pyx_v_trow + 24); if (((__pyx_t_4 < __pyx_t_5) != 0)) { __pyx_t_6 = __pyx_t_4; } else { __pyx_t_6 = __pyx_t_5; } __pyx_v_trow_max = __pyx_t_6; /* "skbio/stats/ordination/_cutils.pyx":111 * trow_max = min(trow+24, n_samples) * * for tcol in range(0, n_samples, 24): # <<<<<<<<<<<<<< * tcol_max = min(tcol+24, n_samples) * */ __pyx_t_6 = __pyx_v_n_samples; __pyx_t_4 = __pyx_t_6; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=24) { __pyx_v_tcol = __pyx_t_5; /* "skbio/stats/ordination/_cutils.pyx":112 * * for tcol in range(0, n_samples, 24): * tcol_max = min(tcol+24, n_samples) # <<<<<<<<<<<<<< * * for row in range(trow, trow_max, 1): */ __pyx_t_7 = __pyx_v_n_samples; __pyx_t_8 = (__pyx_v_tcol + 24); if (((__pyx_t_7 < __pyx_t_8) != 0)) { __pyx_t_9 = __pyx_t_7; } else { __pyx_t_9 = __pyx_t_8; } __pyx_v_tcol_max = __pyx_t_9; /* "skbio/stats/ordination/_cutils.pyx":114 * tcol_max = min(tcol+24, n_samples) * * for row in range(trow, trow_max, 1): # <<<<<<<<<<<<<< * gr_mean = global_mean - row_means[row] * */ __pyx_t_9 = __pyx_v_trow_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_trow; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_row = __pyx_t_8; /* "skbio/stats/ordination/_cutils.pyx":115 * * for row in range(trow, trow_max, 1): * gr_mean = global_mean - row_means[row] # <<<<<<<<<<<<<< * * for col in range(tcol, tcol_max, 1): */ __pyx_t_10 = __pyx_v_row; __pyx_v_gr_mean = (__pyx_v_global_mean - (*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row_means.data) + __pyx_t_10)) )))); /* "skbio/stats/ordination/_cutils.pyx":117 * gr_mean = global_mean - row_means[row] * * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * # Note: do not use +=, so it is not flagged as a global reduction * centered[row,col] = centered[row,col] + (gr_mean - row_means[col]) */ __pyx_t_11 = __pyx_v_tcol_max; __pyx_t_12 = __pyx_t_11; for (__pyx_t_13 = __pyx_v_tcol; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_col = __pyx_t_13; /* "skbio/stats/ordination/_cutils.pyx":119 * for col in range(tcol, tcol_max, 1): * # Note: do not use +=, so it is not flagged as a global reduction * centered[row,col] = centered[row,col] + (gr_mean - row_means[col]) # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __pyx_t_10 = __pyx_v_row; __pyx_t_14 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_t_16 = __pyx_v_row; __pyx_t_17 = __pyx_v_col; *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_16 * __pyx_v_centered.strides[0]) )) + __pyx_t_17)) )) = ((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_10 * __pyx_v_centered.strides[0]) )) + __pyx_t_14)) ))) + (__pyx_v_gr_mean - (*((float *) ( /* dim=0 */ ((char *) (((float *) __pyx_v_row_means.data) + __pyx_t_15)) ))))); } } } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/ordination/_cutils.pyx":108 * * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, n_samples) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/ordination/_cutils.pyx":77 * @cython.boundscheck(False) * @cython.wraparound(False) * def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Compute F matrix from E matrix inplace. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.f_matrix_inplace_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_15f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_15f_matrix_inplace_cy = {"__pyx_fuse_1f_matrix_inplace_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_15f_matrix_inplace_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_2f_matrix_inplace_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_15f_matrix_inplace_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; double __pyx_v_global_mean; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("f_matrix_inplace_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row_means,&__pyx_n_s_global_mean,&__pyx_n_s_centered,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_row_means)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_global_mean)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, 1); __PYX_ERR(0, 77, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, 2); __PYX_ERR(0, 77, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "f_matrix_inplace_cy") < 0)) __PYX_ERR(0, 77, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_row_means = __Pyx_PyObject_to_MemoryviewSlice_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_row_means.memview)) __PYX_ERR(0, 77, __pyx_L3_error) __pyx_v_global_mean = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_global_mean == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 77, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("f_matrix_inplace_cy", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 77, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.f_matrix_inplace_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_14f_matrix_inplace_cy(__pyx_self, __pyx_v_row_means, __pyx_v_global_mean, __pyx_v_centered); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_14f_matrix_inplace_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_row_means, double __pyx_v_global_mean, __Pyx_memviewslice __pyx_v_centered) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_trow; Py_ssize_t __pyx_v_tcol; Py_ssize_t __pyx_v_row; Py_ssize_t __pyx_v_col; Py_ssize_t __pyx_v_trow_max; Py_ssize_t __pyx_v_tcol_max; double __pyx_v_gr_mean; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; Py_ssize_t __pyx_t_7; Py_ssize_t __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; Py_ssize_t __pyx_t_13; Py_ssize_t __pyx_t_14; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1f_matrix_inplace_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":96 * Out, the centered matrix * """ * cdef Py_ssize_t n_samples = centered.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = centered.shape[1] * cdef Py_ssize_t d3 = row_means.shape[0] */ __pyx_v_n_samples = (__pyx_v_centered.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":97 * """ * cdef Py_ssize_t n_samples = centered.shape[0] * cdef Py_ssize_t d2 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = row_means.shape[0] * */ __pyx_v_d2 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":98 * cdef Py_ssize_t n_samples = centered.shape[0] * cdef Py_ssize_t d2 = centered.shape[1] * cdef Py_ssize_t d3 = row_means.shape[0] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d3 = (__pyx_v_row_means.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":100 * cdef Py_ssize_t d3 = row_means.shape[0] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 100, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":101 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * * cdef Py_ssize_t trow,tcol,row,col */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 101, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":108 * * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, n_samples) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { __pyx_t_1 = __pyx_v_n_samples; if ((24 == 0)) abort(); { #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) (x) #define unlikely(x) (x) #endif __pyx_t_3 = (__pyx_t_1 - 0 + 24 - 24/abs(24)) / 24; if (__pyx_t_3 > 0) { #ifdef _OPENMP #pragma omp parallel private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP #pragma omp for lastprivate(__pyx_v_col) lastprivate(__pyx_v_gr_mean) lastprivate(__pyx_v_row) lastprivate(__pyx_v_tcol) lastprivate(__pyx_v_tcol_max) firstprivate(__pyx_v_trow) lastprivate(__pyx_v_trow) lastprivate(__pyx_v_trow_max) #endif /* _OPENMP */ for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ { __pyx_v_trow = (Py_ssize_t)(0 + 24 * __pyx_t_2); /* Initialize private variables to invalid values */ __pyx_v_col = ((Py_ssize_t)0xbad0bad0); __pyx_v_gr_mean = ((double)__PYX_NAN()); __pyx_v_row = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol = ((Py_ssize_t)0xbad0bad0); __pyx_v_tcol_max = ((Py_ssize_t)0xbad0bad0); __pyx_v_trow_max = ((Py_ssize_t)0xbad0bad0); /* "skbio/stats/ordination/_cutils.pyx":109 * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): * trow_max = min(trow+24, n_samples) # <<<<<<<<<<<<<< * * for tcol in range(0, n_samples, 24): */ __pyx_t_4 = __pyx_v_n_samples; __pyx_t_5 = (__pyx_v_trow + 24); if (((__pyx_t_4 < __pyx_t_5) != 0)) { __pyx_t_6 = __pyx_t_4; } else { __pyx_t_6 = __pyx_t_5; } __pyx_v_trow_max = __pyx_t_6; /* "skbio/stats/ordination/_cutils.pyx":111 * trow_max = min(trow+24, n_samples) * * for tcol in range(0, n_samples, 24): # <<<<<<<<<<<<<< * tcol_max = min(tcol+24, n_samples) * */ __pyx_t_6 = __pyx_v_n_samples; __pyx_t_4 = __pyx_t_6; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=24) { __pyx_v_tcol = __pyx_t_5; /* "skbio/stats/ordination/_cutils.pyx":112 * * for tcol in range(0, n_samples, 24): * tcol_max = min(tcol+24, n_samples) # <<<<<<<<<<<<<< * * for row in range(trow, trow_max, 1): */ __pyx_t_7 = __pyx_v_n_samples; __pyx_t_8 = (__pyx_v_tcol + 24); if (((__pyx_t_7 < __pyx_t_8) != 0)) { __pyx_t_9 = __pyx_t_7; } else { __pyx_t_9 = __pyx_t_8; } __pyx_v_tcol_max = __pyx_t_9; /* "skbio/stats/ordination/_cutils.pyx":114 * tcol_max = min(tcol+24, n_samples) * * for row in range(trow, trow_max, 1): # <<<<<<<<<<<<<< * gr_mean = global_mean - row_means[row] * */ __pyx_t_9 = __pyx_v_trow_max; __pyx_t_7 = __pyx_t_9; for (__pyx_t_8 = __pyx_v_trow; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_row = __pyx_t_8; /* "skbio/stats/ordination/_cutils.pyx":115 * * for row in range(trow, trow_max, 1): * gr_mean = global_mean - row_means[row] # <<<<<<<<<<<<<< * * for col in range(tcol, tcol_max, 1): */ __pyx_t_10 = __pyx_v_row; __pyx_v_gr_mean = (__pyx_v_global_mean - (*((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_row_means.data) + __pyx_t_10)) )))); /* "skbio/stats/ordination/_cutils.pyx":117 * gr_mean = global_mean - row_means[row] * * for col in range(tcol, tcol_max, 1): # <<<<<<<<<<<<<< * # Note: do not use +=, so it is not flagged as a global reduction * centered[row,col] = centered[row,col] + (gr_mean - row_means[col]) */ __pyx_t_11 = __pyx_v_tcol_max; __pyx_t_12 = __pyx_t_11; for (__pyx_t_13 = __pyx_v_tcol; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_col = __pyx_t_13; /* "skbio/stats/ordination/_cutils.pyx":119 * for col in range(tcol, tcol_max, 1): * # Note: do not use +=, so it is not flagged as a global reduction * centered[row,col] = centered[row,col] + (gr_mean - row_means[col]) # <<<<<<<<<<<<<< * * @cython.boundscheck(False) */ __pyx_t_10 = __pyx_v_row; __pyx_t_14 = __pyx_v_col; __pyx_t_15 = __pyx_v_col; __pyx_t_16 = __pyx_v_row; __pyx_t_17 = __pyx_v_col; *((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_16 * __pyx_v_centered.strides[0]) )) + __pyx_t_17)) )) = ((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_centered.data + __pyx_t_10 * __pyx_v_centered.strides[0]) )) + __pyx_t_14)) ))) + (__pyx_v_gr_mean - (*((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_row_means.data) + __pyx_t_15)) ))))); } } } } } } } } #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) #undef likely #undef unlikely #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #endif } /* "skbio/stats/ordination/_cutils.pyx":108 * * # use a tiled pattern to maximize locality of row_means * for trow in prange(0, n_samples, 24, nogil=True): # <<<<<<<<<<<<<< * trow_max = min(trow+24, n_samples) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "skbio/stats/ordination/_cutils.pyx":77 * @cython.boundscheck(False) * @cython.wraparound(False) * def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Compute F matrix from E matrix inplace. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.f_matrix_inplace_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "skbio/stats/ordination/_cutils.pyx":123 * @cython.boundscheck(False) * @cython.wraparound(False) * def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Centers a distance matrix. */ /* Python wrapper */ static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_5center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy[] = "\n Centers a distance matrix.\n\n Note: If the used distance was euclidean, pairwise distances\n needn't be computed from the data table Y because F_matrix =\n Y.dot(Y.T) (if Y has been centered).\n But since we're expecting distance_matrix to be non-euclidian,\n we do the following computation as per\n Numerical Ecology (Legendre & Legendre 1998).\n\n Parameters\n ----------\n mat : 2D array_like\n Distance matrix.\n centered : 2D array_like\n Output centered matrix. Must be pre-allocated and same shape as mat.\n Can point to mat (i.e. in-place)\n "; static PyMethodDef __pyx_mdef_5skbio_5stats_10ordination_7_cutils_5center_distance_matrix_cy = {"center_distance_matrix_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5skbio_5stats_10ordination_7_cutils_5center_distance_matrix_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy}; static PyObject *__pyx_pw_5skbio_5stats_10ordination_7_cutils_5center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_signatures = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; CYTHON_UNUSED PyObject *__pyx_v_defaults = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 123, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 123, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_signatures = values[0]; __pyx_v_args = values[1]; __pyx_v_kwargs = values[2]; __pyx_v_defaults = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 123, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) { PyObject *__pyx_v_dest_sig = NULL; Py_ssize_t __pyx_v_i; PyTypeObject *__pyx_v_ndarray = 0; __Pyx_memviewslice __pyx_v_memslice; Py_ssize_t __pyx_v_itemsize; CYTHON_UNUSED int __pyx_v_dtype_signed; char __pyx_v_kind; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_dtype = NULL; PyObject *__pyx_v_arg_base = NULL; PyObject *__pyx_v_candidates = NULL; PyObject *__pyx_v_sig = NULL; int __pyx_v_match_found; PyObject *__pyx_v_src_sig = NULL; PyObject *__pyx_v_dst_type = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; long __pyx_t_7; __Pyx_memviewslice __pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("center_distance_matrix_cy", 0); __Pyx_INCREF(__pyx_v_kwargs); __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyList_SET_ITEM(__pyx_t_1, 0, Py_None); __pyx_v_dest_sig = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_4) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None); } __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_itemsize = -1L; if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_2 = ((0 < __pyx_t_5) != 0); if (__pyx_t_2) { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(((PyObject*)__pyx_v_args), 0); __Pyx_INCREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } __pyx_t_3 = (__pyx_v_kwargs != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L7_bool_binop_done; } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_mat, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_3 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_3; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_mat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_arg = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_int_2); __Pyx_GIVEREF(__pyx_int_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_2); __Pyx_INCREF(__pyx_n_s_s); __Pyx_GIVEREF(__pyx_n_s_s); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_s_s); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_L6:; while (1) { __pyx_t_2 = (__pyx_v_ndarray != ((PyTypeObject*)Py_None)); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L12; } __pyx_t_2 = __pyx_memoryview_check(__pyx_v_arg); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_base); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_arg_base = __pyx_t_6; __pyx_t_6 = 0; __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_arg_base, __pyx_v_ndarray); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg_base, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_dtype = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L13; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L13:; goto __pyx_L12; } /*else*/ { __Pyx_INCREF(Py_None); __pyx_v_dtype = Py_None; } __pyx_L12:; __pyx_v_itemsize = -1L; __pyx_t_2 = (__pyx_v_dtype != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_itemsize = __pyx_t_5; __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_Ord(__pyx_t_6); if (unlikely(__pyx_t_7 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_kind = __pyx_t_7; __pyx_v_dtype_signed = (__pyx_v_kind == 'i'); switch (__pyx_v_kind) { case 'i': case 'u': break; case 'f': __pyx_t_2 = (((sizeof(float)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 123, __pyx_L1_error) goto __pyx_L10_break; } __pyx_t_2 = (((sizeof(double)) == __pyx_v_itemsize) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_arg, __pyx_n_s_ndim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = ((((Py_ssize_t)__pyx_t_5) == 2) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L19_bool_binop_done:; if (__pyx_t_3) { if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 123, __pyx_L1_error) goto __pyx_L10_break; } break; case 'c': break; case 'O': break; default: break; } } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L22_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(float))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L22_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_float, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 123, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } __pyx_t_2 = ((__pyx_v_itemsize == -1L) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L26_bool_binop_done; } __pyx_t_2 = ((__pyx_v_itemsize == (sizeof(double))) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L26_bool_binop_done:; if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(__pyx_v_arg, 0); __pyx_v_memslice = __pyx_t_8; __pyx_t_3 = (__pyx_v_memslice.memview != 0); if (__pyx_t_3) { __PYX_XDEC_MEMVIEW((&__pyx_v_memslice), 1); if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 123, __pyx_L1_error) goto __pyx_L10_break; } /*else*/ { PyErr_Clear(); } } if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 0) < 0)) __PYX_ERR(0, 123, __pyx_L1_error) goto __pyx_L10_break; } __pyx_L10_break:; __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v_candidates = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = 0; if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_11 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_9, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_10); if (unlikely(__pyx_t_11 == 0)) break; if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_v_match_found = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_12 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_14, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_split); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_12, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_16 = __pyx_t_15; for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { __pyx_v_i = __pyx_t_17; __pyx_t_1 = PyList_GET_ITEM(__pyx_v_dest_sig, __pyx_v_i); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_dst_type != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyObject_RichCompare(__pyx_t_1, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_2) { __pyx_v_match_found = 1; goto __pyx_L34; } /*else*/ { __pyx_v_match_found = 0; goto __pyx_L32_break; } __pyx_L34:; } } __pyx_L32_break:; __pyx_t_2 = (__pyx_v_match_found != 0); if (__pyx_t_2) { __pyx_t_18 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 123, __pyx_L1_error) } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0); __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_9 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 123, __pyx_L1_error) __pyx_t_3 = ((__pyx_t_9 > 1) != 0); if (__pyx_t_3) { __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 123, __pyx_L1_error) } /*else*/ { __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_signatures == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 123, __pyx_L1_error) } __pyx_t_6 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), PyList_GET_ITEM(__pyx_v_candidates, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_AddTraceback("skbio.stats.ordination._cutils.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dest_sig); __Pyx_XDECREF(__pyx_v_ndarray); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_dtype); __Pyx_XDECREF(__pyx_v_arg_base); __Pyx_XDECREF(__pyx_v_candidates); __Pyx_XDECREF(__pyx_v_sig); __Pyx_XDECREF(__pyx_v_src_sig); __Pyx_XDECREF(__pyx_v_dst_type); __Pyx_XDECREF(__pyx_v_kwargs); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_19center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_19center_distance_matrix_cy = {"__pyx_fuse_0center_distance_matrix_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_19center_distance_matrix_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy}; static PyObject *__pyx_fuse_0__pyx_pw_5skbio_5stats_10ordination_7_cutils_19center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("center_distance_matrix_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mat,&__pyx_n_s_centered,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("center_distance_matrix_cy", 1, 2, 2, 1); __PYX_ERR(0, 123, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "center_distance_matrix_cy") < 0)) __PYX_ERR(0, 123, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 123, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 123, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("center_distance_matrix_cy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 123, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.center_distance_matrix_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_18center_distance_matrix_cy(__pyx_self, __pyx_v_mat, __pyx_v_centered); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_18center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_d4; float __pyx_v_global_mean; PyObject *__pyx_v_dtype_real = NULL; PyObject *__pyx_v_row_means_np = NULL; __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; float __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_0center_distance_matrix_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":142 * Can point to mat (i.e. in-place) * """ * cdef Py_ssize_t n_samples = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] */ __pyx_v_n_samples = (__pyx_v_mat.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":143 * """ * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] */ __pyx_v_d2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":144 * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d4 = centered.shape[1] * */ __pyx_v_d3 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":145 * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d4 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":147 * cdef Py_ssize_t d4 = centered.shape[1] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * assert n_samples == d4 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 147, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":148 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * assert n_samples == d4 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 148, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":149 * assert n_samples == d2 * assert n_samples == d3 * assert n_samples == d4 # <<<<<<<<<<<<<< * * cdef TReal global_mean */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d4) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 149, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":154 * * if TReal is float: * dtype_real = np.float32 # <<<<<<<<<<<<<< * else: * dtype_real = np.float64 */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_dtype_real = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/stats/ordination/_cutils.pyx":158 * dtype_real = np.float64 * * row_means_np = np.zeros((n_samples,), dtype=dtype_real) # <<<<<<<<<<<<<< * cdef TReal[::1] row_means = row_means_np * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_n_samples); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_v_dtype_real) < 0) __PYX_ERR(0, 158, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_row_means_np = __pyx_t_4; __pyx_t_4 = 0; /* "skbio/stats/ordination/_cutils.pyx":159 * * row_means_np = np.zeros((n_samples,), dtype=dtype_real) * cdef TReal[::1] row_means = row_means_np # <<<<<<<<<<<<<< * * global_mean = e_matrix_means_cy(mat, centered, row_means) */ __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dc_float(__pyx_v_row_means_np, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 159, __pyx_L1_error) __pyx_v_row_means = __pyx_t_5; __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; /* "skbio/stats/ordination/_cutils.pyx":161 * cdef TReal[::1] row_means = row_means_np * * global_mean = e_matrix_means_cy(mat, centered, row_means) # <<<<<<<<<<<<<< * f_matrix_inplace_cy(row_means, global_mean, centered) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_e_matrix_means_cy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_mat, 2, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_centered, 2, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_row_means, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, __pyx_t_1, __pyx_t_6}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, __pyx_t_1, __pyx_t_6}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6); __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_10 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_global_mean = __pyx_t_10; /* "skbio/stats/ordination/_cutils.pyx":162 * * global_mean = e_matrix_means_cy(mat, centered, row_means) * f_matrix_inplace_cy(row_means, global_mean, centered) # <<<<<<<<<<<<<< * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_f_matrix_inplace_cy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_row_means, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = PyFloat_FromDouble(__pyx_v_global_mean); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_centered, 2, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_9, __pyx_t_6, __pyx_t_1}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_9, __pyx_t_6, __pyx_t_1}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_t_1); __pyx_t_9 = 0; __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/stats/ordination/_cutils.pyx":123 * @cython.boundscheck(False) * @cython.wraparound(False) * def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Centers a distance matrix. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("skbio.stats.ordination._cutils.center_distance_matrix_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dtype_real); __Pyx_XDECREF(__pyx_v_row_means_np); __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_21center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_21center_distance_matrix_cy = {"__pyx_fuse_1center_distance_matrix_cy", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_21center_distance_matrix_cy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5skbio_5stats_10ordination_7_cutils_4center_distance_matrix_cy}; static PyObject *__pyx_fuse_1__pyx_pw_5skbio_5stats_10ordination_7_cutils_21center_distance_matrix_cy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { __Pyx_memviewslice __pyx_v_mat = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_centered = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("center_distance_matrix_cy (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mat,&__pyx_n_s_centered,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mat)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_centered)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("center_distance_matrix_cy", 1, 2, 2, 1); __PYX_ERR(0, 123, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "center_distance_matrix_cy") < 0)) __PYX_ERR(0, 123, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_mat = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mat.memview)) __PYX_ERR(0, 123, __pyx_L3_error) __pyx_v_centered = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_centered.memview)) __PYX_ERR(0, 123, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("center_distance_matrix_cy", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 123, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("skbio.stats.ordination._cutils.center_distance_matrix_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5skbio_5stats_10ordination_7_cutils_20center_distance_matrix_cy(__pyx_self, __pyx_v_mat, __pyx_v_centered); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5skbio_5stats_10ordination_7_cutils_20center_distance_matrix_cy(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_mat, __Pyx_memviewslice __pyx_v_centered) { Py_ssize_t __pyx_v_n_samples; Py_ssize_t __pyx_v_d2; Py_ssize_t __pyx_v_d3; Py_ssize_t __pyx_v_d4; double __pyx_v_global_mean; PyObject *__pyx_v_dtype_real = NULL; PyObject *__pyx_v_row_means_np = NULL; __Pyx_memviewslice __pyx_v_row_means = { 0, 0, { 0 }, { 0 }, { 0 } }; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; double __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_fuse_1center_distance_matrix_cy", 0); /* "skbio/stats/ordination/_cutils.pyx":142 * Can point to mat (i.e. in-place) * """ * cdef Py_ssize_t n_samples = mat.shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] */ __pyx_v_n_samples = (__pyx_v_mat.shape[0]); /* "skbio/stats/ordination/_cutils.pyx":143 * """ * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] */ __pyx_v_d2 = (__pyx_v_mat.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":144 * cdef Py_ssize_t n_samples = mat.shape[0] * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] # <<<<<<<<<<<<<< * cdef Py_ssize_t d4 = centered.shape[1] * */ __pyx_v_d3 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":145 * cdef Py_ssize_t d2 = mat.shape[1] * cdef Py_ssize_t d3 = centered.shape[1] * cdef Py_ssize_t d4 = centered.shape[1] # <<<<<<<<<<<<<< * * assert n_samples == d2 */ __pyx_v_d4 = (__pyx_v_centered.shape[1]); /* "skbio/stats/ordination/_cutils.pyx":147 * cdef Py_ssize_t d4 = centered.shape[1] * * assert n_samples == d2 # <<<<<<<<<<<<<< * assert n_samples == d3 * assert n_samples == d4 */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d2) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 147, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":148 * * assert n_samples == d2 * assert n_samples == d3 # <<<<<<<<<<<<<< * assert n_samples == d4 * */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d3) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 148, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":149 * assert n_samples == d2 * assert n_samples == d3 * assert n_samples == d4 # <<<<<<<<<<<<<< * * cdef TReal global_mean */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_n_samples == __pyx_v_d4) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 149, __pyx_L1_error) } } #endif /* "skbio/stats/ordination/_cutils.pyx":156 * dtype_real = np.float32 * else: * dtype_real = np.float64 # <<<<<<<<<<<<<< * * row_means_np = np.zeros((n_samples,), dtype=dtype_real) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_dtype_real = __pyx_t_2; __pyx_t_2 = 0; /* "skbio/stats/ordination/_cutils.pyx":158 * dtype_real = np.float64 * * row_means_np = np.zeros((n_samples,), dtype=dtype_real) # <<<<<<<<<<<<<< * cdef TReal[::1] row_means = row_means_np * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_n_samples); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_v_dtype_real) < 0) __PYX_ERR(0, 158, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_row_means_np = __pyx_t_4; __pyx_t_4 = 0; /* "skbio/stats/ordination/_cutils.pyx":159 * * row_means_np = np.zeros((n_samples,), dtype=dtype_real) * cdef TReal[::1] row_means = row_means_np # <<<<<<<<<<<<<< * * global_mean = e_matrix_means_cy(mat, centered, row_means) */ __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_v_row_means_np, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 159, __pyx_L1_error) __pyx_v_row_means = __pyx_t_5; __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; /* "skbio/stats/ordination/_cutils.pyx":161 * cdef TReal[::1] row_means = row_means_np * * global_mean = e_matrix_means_cy(mat, centered, row_means) # <<<<<<<<<<<<<< * f_matrix_inplace_cy(row_means, global_mean, centered) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_e_matrix_means_cy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_mat, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_centered, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_row_means, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, __pyx_t_1, __pyx_t_6}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_2, __pyx_t_1, __pyx_t_6}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6); __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_global_mean = __pyx_t_10; /* "skbio/stats/ordination/_cutils.pyx":162 * * global_mean = e_matrix_means_cy(mat, centered, row_means) * f_matrix_inplace_cy(row_means, global_mean, centered) # <<<<<<<<<<<<<< * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_f_matrix_inplace_cy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_row_means, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_6 = PyFloat_FromDouble(__pyx_v_global_mean); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_centered, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_9, __pyx_t_6, __pyx_t_1}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_t_9, __pyx_t_6, __pyx_t_1}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_8, __pyx_t_1); __pyx_t_9 = 0; __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "skbio/stats/ordination/_cutils.pyx":123 * @cython.boundscheck(False) * @cython.wraparound(False) * def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Centers a distance matrix. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("skbio.stats.ordination._cutils.center_distance_matrix_cy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_dtype_real); __Pyx_XDECREF(__pyx_v_row_means_np); __PYX_XDEC_MEMVIEW(&__pyx_v_row_means, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_mat, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_centered, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* Python wrapper */ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_shape = 0; Py_ssize_t __pyx_v_itemsize; PyObject *__pyx_v_format = 0; PyObject *__pyx_v_mode = 0; int __pyx_v_allocate_buffer; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; PyObject* values[5] = {0,0,0,0,0}; values[3] = ((PyObject *)__pyx_n_s_c); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); if (value) { values[4] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_shape = ((PyObject*)values[0]); __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) __pyx_v_format = values[2]; __pyx_v_mode = values[3]; if (values[4]) { __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) } else { /* "View.MemoryView":124 * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< * * cdef int idx */ __pyx_v_allocate_buffer = ((int)1); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) } __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { int __pyx_v_idx; Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_dim; PyObject **__pyx_v_p; char __pyx_v_order; int __pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; char *__pyx_t_7; int __pyx_t_8; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_format); /* "View.MemoryView":130 * cdef PyObject **p * * self.ndim = len(shape) # <<<<<<<<<<<<<< * self.itemsize = itemsize * */ if (unlikely(__pyx_v_shape == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 130, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) __pyx_v_self->ndim = ((int)__pyx_t_1); /* "View.MemoryView":131 * * self.ndim = len(shape) * self.itemsize = itemsize # <<<<<<<<<<<<<< * * if not self.ndim: */ __pyx_v_self->itemsize = __pyx_v_itemsize; /* "View.MemoryView":133 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError("Empty shape tuple for cython.array") * */ __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":134 * * if not self.ndim: * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< * * if itemsize <= 0: */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 134, __pyx_L1_error) /* "View.MemoryView":133 * self.itemsize = itemsize * * if not self.ndim: # <<<<<<<<<<<<<< * raise ValueError("Empty shape tuple for cython.array") * */ } /* "View.MemoryView":136 * raise ValueError("Empty shape tuple for cython.array") * * if itemsize <= 0: # <<<<<<<<<<<<<< * raise ValueError("itemsize <= 0 for cython.array") * */ __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":137 * * if itemsize <= 0: * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< * * if not isinstance(format, bytes): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 137, __pyx_L1_error) /* "View.MemoryView":136 * raise ValueError("Empty shape tuple for cython.array") * * if itemsize <= 0: # <<<<<<<<<<<<<< * raise ValueError("itemsize <= 0 for cython.array") * */ } /* "View.MemoryView":139 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string */ __pyx_t_2 = PyBytes_Check(__pyx_v_format); __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_4) { /* "View.MemoryView":140 * * if not isinstance(format, bytes): * format = format.encode('ASCII') # <<<<<<<<<<<<<< * self._format = format # keep a reference to the byte string * self.format = self._format */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":139 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string */ } /* "View.MemoryView":141 * if not isinstance(format, bytes): * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< * self.format = self._format * */ if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) __pyx_t_3 = __pyx_v_format; __Pyx_INCREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->_format); __Pyx_DECREF(__pyx_v_self->_format); __pyx_v_self->_format = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":142 * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string * self.format = self._format # <<<<<<<<<<<<<< * * */ if (unlikely(__pyx_v_self->_format == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); __PYX_ERR(1, 142, __pyx_L1_error) } __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) __pyx_v_self->format = __pyx_t_7; /* "View.MemoryView":145 * * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< * self._strides = self._shape + self.ndim * */ __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); /* "View.MemoryView":146 * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< * * if not self._shape: */ __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); /* "View.MemoryView":148 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate shape and strides.") * */ __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":149 * * if not self._shape: * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 149, __pyx_L1_error) /* "View.MemoryView":148 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate shape and strides.") * */ } /* "View.MemoryView":152 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ __pyx_t_8 = 0; __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; for (;;) { if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_dim = __pyx_t_9; __pyx_v_idx = __pyx_t_8; __pyx_t_8 = (__pyx_t_8 + 1); /* "View.MemoryView":153 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim */ __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":154 * for idx, dim in enumerate(shape): * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< * self._shape[idx] = dim * */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 154, __pyx_L1_error) /* "View.MemoryView":153 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim */ } /* "View.MemoryView":155 * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim # <<<<<<<<<<<<<< * * cdef char order */ (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; /* "View.MemoryView":152 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":158 * * cdef char order * if mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) if (__pyx_t_4) { /* "View.MemoryView":159 * cdef char order * if mode == 'fortran': * order = b'F' # <<<<<<<<<<<<<< * self.mode = u'fortran' * elif mode == 'c': */ __pyx_v_order = 'F'; /* "View.MemoryView":160 * if mode == 'fortran': * order = b'F' * self.mode = u'fortran' # <<<<<<<<<<<<<< * elif mode == 'c': * order = b'C' */ __Pyx_INCREF(__pyx_n_u_fortran); __Pyx_GIVEREF(__pyx_n_u_fortran); __Pyx_GOTREF(__pyx_v_self->mode); __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_fortran; /* "View.MemoryView":158 * * cdef char order * if mode == 'fortran': # <<<<<<<<<<<<<< * order = b'F' * self.mode = u'fortran' */ goto __pyx_L10; } /* "View.MemoryView":161 * order = b'F' * self.mode = u'fortran' * elif mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) if (likely(__pyx_t_4)) { /* "View.MemoryView":162 * self.mode = u'fortran' * elif mode == 'c': * order = b'C' # <<<<<<<<<<<<<< * self.mode = u'c' * else: */ __pyx_v_order = 'C'; /* "View.MemoryView":163 * elif mode == 'c': * order = b'C' * self.mode = u'c' # <<<<<<<<<<<<<< * else: * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) */ __Pyx_INCREF(__pyx_n_u_c); __Pyx_GIVEREF(__pyx_n_u_c); __Pyx_GOTREF(__pyx_v_self->mode); __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_c; /* "View.MemoryView":161 * order = b'F' * self.mode = u'fortran' * elif mode == 'c': # <<<<<<<<<<<<<< * order = b'C' * self.mode = u'c' */ goto __pyx_L10; } /* "View.MemoryView":165 * self.mode = u'c' * else: * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< * * self.len = fill_contig_strides_array(self._shape, self._strides, */ /*else*/ { __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 165, __pyx_L1_error) } __pyx_L10:; /* "View.MemoryView":167 * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) * * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< * itemsize, self.ndim, order) * */ __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); /* "View.MemoryView":170 * itemsize, self.ndim, order) * * self.free_data = allocate_buffer # <<<<<<<<<<<<<< * self.dtype_is_object = format == b'O' * if allocate_buffer: */ __pyx_v_self->free_data = __pyx_v_allocate_buffer; /* "View.MemoryView":171 * * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< * if allocate_buffer: * */ __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_self->dtype_is_object = __pyx_t_4; /* "View.MemoryView":172 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< * * */ __pyx_t_4 = (__pyx_v_allocate_buffer != 0); if (__pyx_t_4) { /* "View.MemoryView":175 * * * self.data = malloc(self.len) # <<<<<<<<<<<<<< * if not self.data: * raise MemoryError("unable to allocate array data.") */ __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); /* "View.MemoryView":176 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate array data.") * */ __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":177 * self.data = malloc(self.len) * if not self.data: * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< * * if self.dtype_is_object: */ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __PYX_ERR(1, 177, __pyx_L1_error) /* "View.MemoryView":176 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< * raise MemoryError("unable to allocate array data.") * */ } /* "View.MemoryView":179 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len / itemsize): */ __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_4) { /* "View.MemoryView":180 * * if self.dtype_is_object: * p = self.data # <<<<<<<<<<<<<< * for i in range(self.len / itemsize): * p[i] = Py_None */ __pyx_v_p = ((PyObject **)__pyx_v_self->data); /* "View.MemoryView":181 * if self.dtype_is_object: * p = self.data * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< * p[i] = Py_None * Py_INCREF(Py_None) */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 181, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 181, __pyx_L1_error) } __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); __pyx_t_9 = __pyx_t_1; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; /* "View.MemoryView":182 * p = self.data * for i in range(self.len / itemsize): * p[i] = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ (__pyx_v_p[__pyx_v_i]) = Py_None; /* "View.MemoryView":183 * for i in range(self.len / itemsize): * p[i] = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * @cname('getbuffer') */ Py_INCREF(Py_None); } /* "View.MemoryView":179 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< * p = self.data * for i in range(self.len / itemsize): */ } /* "View.MemoryView":172 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":123 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< * mode="c", bint allocate_buffer=True): * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_format); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":186 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * cdef int bufmode = -1 * if self.mode == u"c": */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_bufmode; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; Py_ssize_t __pyx_t_5; int __pyx_t_6; Py_ssize_t *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "View.MemoryView":187 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 # <<<<<<<<<<<<<< * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ __pyx_v_bufmode = -1; /* "View.MemoryView":188 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if self.mode == u"c": # <<<<<<<<<<<<<< * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": */ __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":189 * cdef int bufmode = -1 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); /* "View.MemoryView":188 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if self.mode == u"c": # <<<<<<<<<<<<<< * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": */ goto __pyx_L3; } /* "View.MemoryView":190 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": # <<<<<<<<<<<<<< * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":191 * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") */ __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); /* "View.MemoryView":190 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": # <<<<<<<<<<<<<< * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): */ } __pyx_L3:; /* "View.MemoryView":192 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data */ __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":193 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< * info.buf = self.data * info.len = self.len */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 193, __pyx_L1_error) /* "View.MemoryView":192 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data */ } /* "View.MemoryView":194 * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data # <<<<<<<<<<<<<< * info.len = self.len * info.ndim = self.ndim */ __pyx_t_4 = __pyx_v_self->data; __pyx_v_info->buf = __pyx_t_4; /* "View.MemoryView":195 * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data * info.len = self.len # <<<<<<<<<<<<<< * info.ndim = self.ndim * info.shape = self._shape */ __pyx_t_5 = __pyx_v_self->len; __pyx_v_info->len = __pyx_t_5; /* "View.MemoryView":196 * info.buf = self.data * info.len = self.len * info.ndim = self.ndim # <<<<<<<<<<<<<< * info.shape = self._shape * info.strides = self._strides */ __pyx_t_6 = __pyx_v_self->ndim; __pyx_v_info->ndim = __pyx_t_6; /* "View.MemoryView":197 * info.len = self.len * info.ndim = self.ndim * info.shape = self._shape # <<<<<<<<<<<<<< * info.strides = self._strides * info.suboffsets = NULL */ __pyx_t_7 = __pyx_v_self->_shape; __pyx_v_info->shape = __pyx_t_7; /* "View.MemoryView":198 * info.ndim = self.ndim * info.shape = self._shape * info.strides = self._strides # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = self.itemsize */ __pyx_t_7 = __pyx_v_self->_strides; __pyx_v_info->strides = __pyx_t_7; /* "View.MemoryView":199 * info.shape = self._shape * info.strides = self._strides * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = self.itemsize * info.readonly = 0 */ __pyx_v_info->suboffsets = NULL; /* "View.MemoryView":200 * info.strides = self._strides * info.suboffsets = NULL * info.itemsize = self.itemsize # <<<<<<<<<<<<<< * info.readonly = 0 * */ __pyx_t_5 = __pyx_v_self->itemsize; __pyx_v_info->itemsize = __pyx_t_5; /* "View.MemoryView":201 * info.suboffsets = NULL * info.itemsize = self.itemsize * info.readonly = 0 # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ __pyx_v_info->readonly = 0; /* "View.MemoryView":203 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.format * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":204 * * if flags & PyBUF_FORMAT: * info.format = self.format # <<<<<<<<<<<<<< * else: * info.format = NULL */ __pyx_t_4 = __pyx_v_self->format; __pyx_v_info->format = __pyx_t_4; /* "View.MemoryView":203 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.format * else: */ goto __pyx_L5; } /* "View.MemoryView":206 * info.format = self.format * else: * info.format = NULL # <<<<<<<<<<<<<< * * info.obj = self */ /*else*/ { __pyx_v_info->format = NULL; } __pyx_L5:; /* "View.MemoryView":208 * info.format = NULL * * info.obj = self # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "View.MemoryView":186 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * cdef int bufmode = -1 * if self.mode == u"c": */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":212 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< * if self.callback_free_data != NULL: * self.callback_free_data(self.data) */ /* Python wrapper */ static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":213 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data: */ __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":214 * def __dealloc__(array self): * if self.callback_free_data != NULL: * self.callback_free_data(self.data) # <<<<<<<<<<<<<< * elif self.free_data: * if self.dtype_is_object: */ __pyx_v_self->callback_free_data(__pyx_v_self->data); /* "View.MemoryView":213 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< * self.callback_free_data(self.data) * elif self.free_data: */ goto __pyx_L3; } /* "View.MemoryView":215 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, */ __pyx_t_1 = (__pyx_v_self->free_data != 0); if (__pyx_t_1) { /* "View.MemoryView":216 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) */ __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_1) { /* "View.MemoryView":217 * elif self.free_data: * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< * self._strides, self.ndim, False) * free(self.data) */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); /* "View.MemoryView":216 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) */ } /* "View.MemoryView":219 * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) * free(self.data) # <<<<<<<<<<<<<< * PyObject_Free(self._shape) * */ free(__pyx_v_self->data); /* "View.MemoryView":215 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, */ } __pyx_L3:; /* "View.MemoryView":220 * self._strides, self.ndim, False) * free(self.data) * PyObject_Free(self._shape) # <<<<<<<<<<<<<< * * @property */ PyObject_Free(__pyx_v_self->_shape); /* "View.MemoryView":212 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< * if self.callback_free_data != NULL: * self.callback_free_data(self.data) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":223 * * @property * def memview(self): # <<<<<<<<<<<<<< * return self.get_memview() * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":224 * @property * def memview(self): * return self.get_memview() # <<<<<<<<<<<<<< * * @cname('get_memview') */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":223 * * @property * def memview(self): # <<<<<<<<<<<<<< * return self.get_memview() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":227 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) */ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_memview", 0); /* "View.MemoryView":228 * @cname('get_memview') * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< * return memoryview(self, flags, self.dtype_is_object) * */ __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); /* "View.MemoryView":229 * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< * * def __len__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":227 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":231 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< * return self._shape[0] * */ /* Python wrapper */ static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__", 0); /* "View.MemoryView":232 * * def __len__(self): * return self._shape[0] # <<<<<<<<<<<<<< * * def __getattr__(self, attr): */ __pyx_r = (__pyx_v_self->_shape[0]); goto __pyx_L0; /* "View.MemoryView":231 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< * return self._shape[0] * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":234 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< * return getattr(self.memview, attr) * */ /* Python wrapper */ static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); /* "View.MemoryView":235 * * def __getattr__(self, attr): * return getattr(self.memview, attr) # <<<<<<<<<<<<<< * * def __getitem__(self, item): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":234 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< * return getattr(self.memview, attr) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":237 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return self.memview[item] * */ /* Python wrapper */ static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "View.MemoryView":238 * * def __getitem__(self, item): * return self.memview[item] # <<<<<<<<<<<<<< * * def __setitem__(self, item, value): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":237 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< * return self.memview[item] * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":240 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< * self.memview[item] = value * */ /* Python wrapper */ static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "View.MemoryView":241 * * def __setitem__(self, item, value): * self.memview[item] = value # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":240 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< * self.memview[item] = value * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":245 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< * char *mode, char *buf): * cdef array result */ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { struct __pyx_array_obj *__pyx_v_result = 0; struct __pyx_array_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("array_cwrapper", 0); /* "View.MemoryView":249 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: */ __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":250 * * if buf == NULL: * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), */ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":249 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: */ goto __pyx_L3; } /* "View.MemoryView":252 * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< * allocate_buffer=False) * result.data = buf */ /*else*/ { __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_shape); __Pyx_GIVEREF(__pyx_v_shape); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_3 = 0; /* "View.MemoryView":253 * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), * allocate_buffer=False) # <<<<<<<<<<<<<< * result.data = buf * */ __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) /* "View.MemoryView":252 * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< * allocate_buffer=False) * result.data = buf */ __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); __pyx_t_5 = 0; /* "View.MemoryView":254 * result = array(shape, itemsize, format, mode.decode('ASCII'), * allocate_buffer=False) * result.data = buf # <<<<<<<<<<<<<< * * return result */ __pyx_v_result->data = __pyx_v_buf; } __pyx_L3:; /* "View.MemoryView":256 * result.data = buf * * return result # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = __pyx_v_result; goto __pyx_L0; /* "View.MemoryView":245 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< * char *mode, char *buf): * cdef array result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":282 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< * self.name = name * def __repr__(self): */ /* Python wrapper */ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; PyObject* values[1] = {0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); } __pyx_v_name = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); /* "View.MemoryView":283 * cdef object name * def __init__(self, name): * self.name = name # <<<<<<<<<<<<<< * def __repr__(self): * return self.name */ __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_GOTREF(__pyx_v_self->name); __Pyx_DECREF(__pyx_v_self->name); __pyx_v_self->name = __pyx_v_name; /* "View.MemoryView":282 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< * self.name = name * def __repr__(self): */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":284 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< * return self.name * */ /* Python wrapper */ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__", 0); /* "View.MemoryView":285 * self.name = name * def __repr__(self): * return self.name # <<<<<<<<<<<<<< * * cdef generic = Enum("") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->name); __pyx_r = __pyx_v_self->name; goto __pyx_L0; /* "View.MemoryView":284 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< * return self.name * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.name,) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->name); __Pyx_GIVEREF(__pyx_v_self->name); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.name,) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__dict = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":7 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_2 = (__pyx_v__dict != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.name is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.name is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state */ /*else*/ { __pyx_t_3 = (__pyx_v_self->name != Py_None); __pyx_v_use_setstate = __pyx_t_3; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: */ __pyx_t_3 = (__pyx_v_use_setstate != 0); if (__pyx_t_3) { /* "(tree fragment)":13 * use_setstate = self.name is not None * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_184977713); __Pyx_GIVEREF(__pyx_int_184977713); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_184977713); __Pyx_GIVEREF(__pyx_int_184977713); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __pyx_t_5 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":299 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory */ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { Py_intptr_t __pyx_v_aligned_p; size_t __pyx_v_offset; void *__pyx_r; int __pyx_t_1; /* "View.MemoryView":301 * cdef void *align_pointer(void *memory, size_t alignment) nogil: * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< * cdef size_t offset * */ __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); /* "View.MemoryView":305 * * with cython.cdivision(True): * offset = aligned_p % alignment # <<<<<<<<<<<<<< * * if offset > 0: */ __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); /* "View.MemoryView":307 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< * aligned_p += alignment - offset * */ __pyx_t_1 = ((__pyx_v_offset > 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":308 * * if offset > 0: * aligned_p += alignment - offset # <<<<<<<<<<<<<< * * return aligned_p */ __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); /* "View.MemoryView":307 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< * aligned_p += alignment - offset * */ } /* "View.MemoryView":310 * aligned_p += alignment - offset * * return aligned_p # <<<<<<<<<<<<<< * * */ __pyx_r = ((void *)__pyx_v_aligned_p); goto __pyx_L0; /* "View.MemoryView":299 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< * "Align pointer memory on a given boundary" * cdef Py_intptr_t aligned_p = memory */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":346 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< * self.obj = obj * self.flags = flags */ /* Python wrapper */ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_obj = 0; int __pyx_v_flags; int __pyx_v_dtype_is_object; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_obj = values[0]; __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) if (values[2]) { __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) } else { __pyx_v_dtype_is_object = ((int)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "View.MemoryView":347 * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj # <<<<<<<<<<<<<< * self.flags = flags * if type(self) is memoryview or obj is not None: */ __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); __Pyx_GOTREF(__pyx_v_self->obj); __Pyx_DECREF(__pyx_v_self->obj); __pyx_v_self->obj = __pyx_v_obj; /* "View.MemoryView":348 * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj * self.flags = flags # <<<<<<<<<<<<<< * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) */ __pyx_v_self->flags = __pyx_v_flags; /* "View.MemoryView":349 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: */ __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); __pyx_t_3 = (__pyx_t_2 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_obj != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "View.MemoryView":350 * self.flags = flags * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None */ __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) /* "View.MemoryView":351 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) */ __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":352 * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; /* "View.MemoryView":353 * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * if not __PYX_CYTHON_ATOMICS_ENABLED(): */ Py_INCREF(Py_None); /* "View.MemoryView":351 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) */ } /* "View.MemoryView":349 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: */ } /* "View.MemoryView":355 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: */ __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":357 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 */ __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); if (__pyx_t_1) { /* "View.MemoryView":358 * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: */ __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); /* "View.MemoryView":359 * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< * if self.lock is NULL: * self.lock = PyThread_allocate_lock() */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); /* "View.MemoryView":357 * if not __PYX_CYTHON_ATOMICS_ENABLED(): * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 */ } /* "View.MemoryView":360 * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: # <<<<<<<<<<<<<< * self.lock = PyThread_allocate_lock() * if self.lock is NULL: */ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":361 * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< * if self.lock is NULL: * raise MemoryError */ __pyx_v_self->lock = PyThread_allocate_lock(); /* "View.MemoryView":362 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< * raise MemoryError * */ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":363 * self.lock = PyThread_allocate_lock() * if self.lock is NULL: * raise MemoryError # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) /* "View.MemoryView":362 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< * raise MemoryError * */ } /* "View.MemoryView":360 * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: # <<<<<<<<<<<<<< * self.lock = PyThread_allocate_lock() * if self.lock is NULL: */ } /* "View.MemoryView":355 * Py_INCREF(Py_None) * * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: */ } /* "View.MemoryView":365 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":366 * * if flags & PyBUF_FORMAT: * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< * else: * self.dtype_is_object = dtype_is_object */ __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L12_bool_binop_done; } __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); __pyx_t_1 = __pyx_t_2; __pyx_L12_bool_binop_done:; __pyx_v_self->dtype_is_object = __pyx_t_1; /* "View.MemoryView":365 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: */ goto __pyx_L11; } /* "View.MemoryView":368 * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') * else: * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< * * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( */ /*else*/ { __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; } __pyx_L11:; /* "View.MemoryView":370 * self.dtype_is_object = dtype_is_object * * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) * self.typeinfo = NULL */ __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); /* "View.MemoryView":372 * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) * self.typeinfo = NULL # <<<<<<<<<<<<<< * * def __dealloc__(memoryview self): */ __pyx_v_self->typeinfo = NULL; /* "View.MemoryView":346 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< * self.obj = obj * self.flags = flags */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":374 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) */ /* Python wrapper */ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { int __pyx_v_i; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyThread_type_lock __pyx_t_6; PyThread_type_lock __pyx_t_7; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":375 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: */ __pyx_t_1 = (__pyx_v_self->obj != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":376 * def __dealloc__(memoryview self): * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< * elif (<__pyx_buffer *> &self.view).obj == Py_None: * */ __Pyx_ReleaseBuffer((&__pyx_v_self->view)); /* "View.MemoryView":375 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: */ goto __pyx_L3; } /* "View.MemoryView":377 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * * (<__pyx_buffer *> &self.view).obj = NULL */ __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); if (__pyx_t_2) { /* "View.MemoryView":379 * elif (<__pyx_buffer *> &self.view).obj == Py_None: * * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< * Py_DECREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; /* "View.MemoryView":380 * * (<__pyx_buffer *> &self.view).obj = NULL * Py_DECREF(Py_None) # <<<<<<<<<<<<<< * * cdef int i */ Py_DECREF(Py_None); /* "View.MemoryView":377 * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * * (<__pyx_buffer *> &self.view).obj = NULL */ } __pyx_L3:; /* "View.MemoryView":384 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: */ __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":385 * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 */ __pyx_t_3 = __pyx_memoryview_thread_locks_used; __pyx_t_4 = __pyx_t_3; for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; /* "View.MemoryView":386 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: */ __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); if (__pyx_t_2) { /* "View.MemoryView":387 * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); /* "View.MemoryView":388 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); if (__pyx_t_2) { /* "View.MemoryView":390 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< * break * else: */ __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); /* "View.MemoryView":389 * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break */ (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; /* "View.MemoryView":388 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ } /* "View.MemoryView":391 * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break # <<<<<<<<<<<<<< * else: * PyThread_free_lock(self.lock) */ goto __pyx_L6_break; /* "View.MemoryView":386 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: */ } } /*else*/ { /* "View.MemoryView":393 * break * else: * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< * * cdef char *get_item_pointer(memoryview self, object index) except NULL: */ PyThread_free_lock(__pyx_v_self->lock); } __pyx_L6_break:; /* "View.MemoryView":384 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: */ } /* "View.MemoryView":374 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":395 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf */ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { Py_ssize_t __pyx_v_dim; char *__pyx_v_itemp; PyObject *__pyx_v_idx = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_item_pointer", 0); /* "View.MemoryView":397 * cdef char *get_item_pointer(memoryview self, object index) except NULL: * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< * * for dim, idx in enumerate(index): */ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); /* "View.MemoryView":399 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< * itemp = pybuffer_index(&self.view, itemp, idx, dim) * */ __pyx_t_1 = 0; if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) #else __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } } else { __pyx_t_5 = __pyx_t_4(__pyx_t_2); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 399, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); __pyx_t_5 = 0; __pyx_v_dim = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); /* "View.MemoryView":400 * * for dim, idx in enumerate(index): * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< * * return itemp */ __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) __pyx_v_itemp = __pyx_t_7; /* "View.MemoryView":399 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< * itemp = pybuffer_index(&self.view, itemp, idx, dim) * */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":402 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_itemp; goto __pyx_L0; /* "View.MemoryView":395 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_idx); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":405 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< * if index is Ellipsis: * return self */ /* Python wrapper */ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { PyObject *__pyx_v_have_slices = NULL; PyObject *__pyx_v_indices = NULL; char *__pyx_v_itemp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; char *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "View.MemoryView":406 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":407 * def __getitem__(memoryview self, object index): * if index is Ellipsis: * return self # <<<<<<<<<<<<<< * * have_slices, indices = _unellipsify(index, self.view.ndim) */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "View.MemoryView":406 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< * return self * */ } /* "View.MemoryView":409 * return self * * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * cdef char *itemp */ __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (likely(__pyx_t_3 != Py_None)) { PyObject* sequence = __pyx_t_3; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 409, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); #else __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_4; __pyx_t_4 = 0; __pyx_v_indices = __pyx_t_5; __pyx_t_5 = 0; /* "View.MemoryView":412 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) if (__pyx_t_2) { /* "View.MemoryView":413 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< * else: * itemp = self.get_item_pointer(indices) */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":412 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ } /* "View.MemoryView":415 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< * return self.convert_item_to_object(itemp) * */ /*else*/ { __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) __pyx_v_itemp = __pyx_t_6; /* "View.MemoryView":416 * else: * itemp = self.get_item_pointer(indices) * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< * * def __setitem__(memoryview self, object index, object value): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "View.MemoryView":405 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< * if index is Ellipsis: * return self */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_have_slices); __Pyx_XDECREF(__pyx_v_indices); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":418 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") */ /* Python wrapper */ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { PyObject *__pyx_v_have_slices = NULL; PyObject *__pyx_v_obj = NULL; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); /* "View.MemoryView":419 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError("Cannot assign to read-only memoryview") * */ __pyx_t_1 = (__pyx_v_self->view.readonly != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":420 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 420, __pyx_L1_error) /* "View.MemoryView":419 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< * raise TypeError("Cannot assign to read-only memoryview") * */ } /* "View.MemoryView":422 * raise TypeError("Cannot assign to read-only memoryview") * * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * if have_slices: */ __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (likely(__pyx_t_2 != Py_None)) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 422, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_3; __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":424 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":425 * * if have_slices: * obj = self.is_slice(value) # <<<<<<<<<<<<<< * if obj: * self.setitem_slice_assignment(self[index], obj) */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_obj = __pyx_t_2; __pyx_t_2 = 0; /* "View.MemoryView":426 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) if (__pyx_t_1) { /* "View.MemoryView":427 * obj = self.is_slice(value) * if obj: * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< * else: * self.setitem_slice_assign_scalar(self[index], value) */ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":426 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ goto __pyx_L5; } /* "View.MemoryView":429 * self.setitem_slice_assignment(self[index], obj) * else: * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< * else: * self.setitem_indexed(index, value) */ /*else*/ { __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L5:; /* "View.MemoryView":424 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ goto __pyx_L4; } /* "View.MemoryView":431 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< * * cdef is_slice(self, obj): */ /*else*/ { __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L4:; /* "View.MemoryView":418 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_XDECREF(__pyx_v_have_slices); __Pyx_XDECREF(__pyx_v_obj); __Pyx_XDECREF(__pyx_v_index); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":433 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< * if not isinstance(obj, memoryview): * try: */ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_slice", 0); __Pyx_INCREF(__pyx_v_obj); /* "View.MemoryView":434 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "View.MemoryView":436 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); /* "View.MemoryView":437 * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) # <<<<<<<<<<<<<< * except TypeError: * return None */ __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); /* "View.MemoryView":436 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "View.MemoryView":438 * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) * except TypeError: # <<<<<<<<<<<<<< * return None * */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); /* "View.MemoryView":439 * self.dtype_is_object) * except TypeError: * return None # <<<<<<<<<<<<<< * * return obj */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_except_return; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "View.MemoryView":435 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L7_except_return:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L0; __pyx_L9_try_end:; } /* "View.MemoryView":434 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, */ } /* "View.MemoryView":441 * return None * * return obj # <<<<<<<<<<<<<< * * cdef setitem_slice_assignment(self, dst, src): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_obj); __pyx_r = __pyx_v_obj; goto __pyx_L0; /* "View.MemoryView":433 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< * if not isinstance(obj, memoryview): * try: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_obj); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":443 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice */ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { __Pyx_memviewslice __pyx_v_dst_slice; __Pyx_memviewslice __pyx_v_src_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; __Pyx_memviewslice *__pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); /* "View.MemoryView":447 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) /* "View.MemoryView":448 * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< * src.ndim, dst.ndim, self.dtype_is_object) * */ if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) /* "View.MemoryView":449 * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":447 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) /* "View.MemoryView":443 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice dst_slice * cdef __Pyx_memviewslice src_slice */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":451 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] * cdef void *tmp = NULL */ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { int __pyx_v_array[0x80]; void *__pyx_v_tmp; void *__pyx_v_item; __Pyx_memviewslice *__pyx_v_dst_slice; __Pyx_memviewslice __pyx_v_tmp_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; char const *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); /* "View.MemoryView":453 * cdef setitem_slice_assign_scalar(self, memoryview dst, value): * cdef int array[128] * cdef void *tmp = NULL # <<<<<<<<<<<<<< * cdef void *item * */ __pyx_v_tmp = NULL; /* "View.MemoryView":458 * cdef __Pyx_memviewslice *dst_slice * cdef __Pyx_memviewslice tmp_slice * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< * * if self.view.itemsize > sizeof(array): */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) __pyx_v_dst_slice = __pyx_t_1; /* "View.MemoryView":460 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); if (__pyx_t_2) { /* "View.MemoryView":461 * * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< * if tmp == NULL: * raise MemoryError */ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); /* "View.MemoryView":462 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":463 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) /* "View.MemoryView":462 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ } /* "View.MemoryView":464 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< * else: * item = array */ __pyx_v_item = __pyx_v_tmp; /* "View.MemoryView":460 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ goto __pyx_L3; } /* "View.MemoryView":466 * item = tmp * else: * item = array # <<<<<<<<<<<<<< * * try: */ /*else*/ { __pyx_v_item = ((void *)__pyx_v_array); } __pyx_L3:; /* "View.MemoryView":468 * item = array * * try: # <<<<<<<<<<<<<< * if self.dtype_is_object: * ( item)[0] = value */ /*try:*/ { /* "View.MemoryView":469 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_2) { /* "View.MemoryView":470 * try: * if self.dtype_is_object: * ( item)[0] = value # <<<<<<<<<<<<<< * else: * self.assign_item_from_object( item, value) */ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); /* "View.MemoryView":469 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ goto __pyx_L8; } /* "View.MemoryView":472 * ( item)[0] = value * else: * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< * * */ /*else*/ { __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L8:; /* "View.MemoryView":476 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":477 * * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, * item, self.dtype_is_object) */ __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":476 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ } /* "View.MemoryView":478 * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< * item, self.dtype_is_object) * finally: */ __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); } /* "View.MemoryView":481 * item, self.dtype_is_object) * finally: * PyMem_Free(tmp) # <<<<<<<<<<<<<< * * cdef setitem_indexed(self, index, value): */ /*finally:*/ { /*normal exit:*/{ PyMem_Free(__pyx_v_tmp); goto __pyx_L7; } __pyx_L6_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; { PyMem_Free(__pyx_v_tmp); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); } __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; goto __pyx_L1_error; } __pyx_L7:; } /* "View.MemoryView":451 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< * cdef int array[128] * cdef void *tmp = NULL */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":483 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) */ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { char *__pyx_v_itemp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations char *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_indexed", 0); /* "View.MemoryView":484 * * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< * self.assign_item_from_object(itemp, value) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; /* "View.MemoryView":485 * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":483 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":487 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { PyObject *__pyx_v_struct = NULL; PyObject *__pyx_v_bytesitem = 0; PyObject *__pyx_v_result = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; size_t __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); /* "View.MemoryView":490 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef bytes bytesitem * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":493 * cdef bytes bytesitem * * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< * try: * result = struct.unpack(self.view.format, bytesitem) */ __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "View.MemoryView":495 * bytesitem = itemp[:self.view.itemsize] * try: * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< * except struct.error: * raise ValueError("Unable to convert item to object") */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_v_bytesitem); __Pyx_GIVEREF(__pyx_v_bytesitem); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ } /* "View.MemoryView":499 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ /*else:*/ { __pyx_t_10 = strlen(__pyx_v_self->view.format); __pyx_t_11 = ((__pyx_t_10 == 1) != 0); if (__pyx_t_11) { /* "View.MemoryView":500 * else: * if len(self.view.format) == 1: * return result[0] # <<<<<<<<<<<<<< * return result * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6_except_return; /* "View.MemoryView":499 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< * return result[0] * return result */ } /* "View.MemoryView":501 * if len(self.view.format) == 1: * return result[0] * return result # <<<<<<<<<<<<<< * * cdef assign_item_from_object(self, char *itemp, object value): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_result); __pyx_r = __pyx_v_result; goto __pyx_L6_except_return; } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "View.MemoryView":496 * try: * result = struct.unpack(self.view.format, bytesitem) * except struct.error: # <<<<<<<<<<<<<< * raise ValueError("Unable to convert item to object") * else: */ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; if (__pyx_t_8) { __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); /* "View.MemoryView":497 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(1, 497, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "View.MemoryView":494 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< * result = struct.unpack(self.view.format, bytesitem) * except struct.error: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L0; } /* "View.MemoryView":487 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_struct); __Pyx_XDECREF(__pyx_v_bytesitem); __Pyx_XDECREF(__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":503 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { PyObject *__pyx_v_struct = NULL; char __pyx_v_c; PyObject *__pyx_v_bytesvalue = 0; Py_ssize_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; char *__pyx_t_11; char *__pyx_t_12; char *__pyx_t_13; char *__pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); /* "View.MemoryView":506 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef char c * cdef bytes bytesvalue */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; /* "View.MemoryView":511 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< * bytesvalue = struct.pack(self.view.format, *value) * else: */ __pyx_t_2 = PyTuple_Check(__pyx_v_value); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "View.MemoryView":512 * * if isinstance(value, tuple): * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< * else: * bytesvalue = struct.pack(self.view.format, value) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "View.MemoryView":511 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< * bytesvalue = struct.pack(self.view.format, *value) * else: */ goto __pyx_L3; } /* "View.MemoryView":514 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< * * for i, c in enumerate(bytesvalue): */ /*else*/ { __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); __pyx_t_1 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_9 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); __PYX_ERR(1, 516, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_bytesvalue); __pyx_t_10 = __pyx_v_bytesvalue; __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { __pyx_t_11 = __pyx_t_14; __pyx_v_c = (__pyx_t_11[0]); /* "View.MemoryView":517 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ __pyx_v_i = __pyx_t_9; /* "View.MemoryView":516 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< * itemp[i] = c * */ __pyx_t_9 = (__pyx_t_9 + 1); /* "View.MemoryView":517 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< * * @cname('getbuffer') */ (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "View.MemoryView":503 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_struct); __Pyx_XDECREF(__pyx_v_bytesvalue); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":520 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; Py_ssize_t *__pyx_t_4; char *__pyx_t_5; void *__pyx_t_6; int __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "View.MemoryView":521 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< * raise ValueError("Cannot create writable memory view from read-only memoryview") * */ __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_self->view.readonly != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "View.MemoryView":522 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 522, __pyx_L1_error) /* "View.MemoryView":521 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< * raise ValueError("Cannot create writable memory view from read-only memoryview") * */ } /* "View.MemoryView":524 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); if (__pyx_t_1) { /* "View.MemoryView":525 * * if flags & PyBUF_ND: * info.shape = self.view.shape # <<<<<<<<<<<<<< * else: * info.shape = NULL */ __pyx_t_4 = __pyx_v_self->view.shape; __pyx_v_info->shape = __pyx_t_4; /* "View.MemoryView":524 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ goto __pyx_L6; } /* "View.MemoryView":527 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_STRIDES: */ /*else*/ { __pyx_v_info->shape = NULL; } __pyx_L6:; /* "View.MemoryView":529 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.strides = self.view.strides * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { /* "View.MemoryView":530 * * if flags & PyBUF_STRIDES: * info.strides = self.view.strides # <<<<<<<<<<<<<< * else: * info.strides = NULL */ __pyx_t_4 = __pyx_v_self->view.strides; __pyx_v_info->strides = __pyx_t_4; /* "View.MemoryView":529 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.strides = self.view.strides * else: */ goto __pyx_L7; } /* "View.MemoryView":532 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_INDIRECT: */ /*else*/ { __pyx_v_info->strides = NULL; } __pyx_L7:; /* "View.MemoryView":534 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< * info.suboffsets = self.view.suboffsets * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); if (__pyx_t_1) { /* "View.MemoryView":535 * * if flags & PyBUF_INDIRECT: * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< * else: * info.suboffsets = NULL */ __pyx_t_4 = __pyx_v_self->view.suboffsets; __pyx_v_info->suboffsets = __pyx_t_4; /* "View.MemoryView":534 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< * info.suboffsets = self.view.suboffsets * else: */ goto __pyx_L8; } /* "View.MemoryView":537 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ /*else*/ { __pyx_v_info->suboffsets = NULL; } __pyx_L8:; /* "View.MemoryView":539 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.view.format * else: */ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { /* "View.MemoryView":540 * * if flags & PyBUF_FORMAT: * info.format = self.view.format # <<<<<<<<<<<<<< * else: * info.format = NULL */ __pyx_t_5 = __pyx_v_self->view.format; __pyx_v_info->format = __pyx_t_5; /* "View.MemoryView":539 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< * info.format = self.view.format * else: */ goto __pyx_L9; } /* "View.MemoryView":542 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< * * info.buf = self.view.buf */ /*else*/ { __pyx_v_info->format = NULL; } __pyx_L9:; /* "View.MemoryView":544 * info.format = NULL * * info.buf = self.view.buf # <<<<<<<<<<<<<< * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize */ __pyx_t_6 = __pyx_v_self->view.buf; __pyx_v_info->buf = __pyx_t_6; /* "View.MemoryView":545 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< * info.itemsize = self.view.itemsize * info.len = self.view.len */ __pyx_t_7 = __pyx_v_self->view.ndim; __pyx_v_info->ndim = __pyx_t_7; /* "View.MemoryView":546 * info.buf = self.view.buf * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< * info.len = self.view.len * info.readonly = self.view.readonly */ __pyx_t_8 = __pyx_v_self->view.itemsize; __pyx_v_info->itemsize = __pyx_t_8; /* "View.MemoryView":547 * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize * info.len = self.view.len # <<<<<<<<<<<<<< * info.readonly = self.view.readonly * info.obj = self */ __pyx_t_8 = __pyx_v_self->view.len; __pyx_v_info->len = __pyx_t_8; /* "View.MemoryView":548 * info.itemsize = self.view.itemsize * info.len = self.view.len * info.readonly = self.view.readonly # <<<<<<<<<<<<<< * info.obj = self * */ __pyx_t_1 = __pyx_v_self->view.readonly; __pyx_v_info->readonly = __pyx_t_1; /* "View.MemoryView":549 * info.len = self.view.len * info.readonly = self.view.readonly * info.obj = self # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "View.MemoryView":520 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":555 * * @property * def T(self): # <<<<<<<<<<<<<< * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":556 * @property * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< * transpose_memslice(&result.from_slice) * return result */ __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); __pyx_t_1 = 0; /* "View.MemoryView":557 * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< * return result * */ __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) /* "View.MemoryView":558 * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) * return result # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":555 * * @property * def T(self): # <<<<<<<<<<<<<< * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":561 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.obj * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":562 * @property * def base(self): * return self.obj # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->obj); __pyx_r = __pyx_v_self->obj; goto __pyx_L0; /* "View.MemoryView":561 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.obj * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":565 * * @property * def shape(self): # <<<<<<<<<<<<<< * return tuple([length for length in self.view.shape[:self.view.ndim]]) * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_length; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":566 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_length = (__pyx_t_2[0]); __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "View.MemoryView":565 * * @property * def shape(self): # <<<<<<<<<<<<<< * return tuple([length for length in self.view.shape[:self.view.ndim]]) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":569 * * @property * def strides(self): # <<<<<<<<<<<<<< * if self.view.strides == NULL: * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_stride; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":570 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * * raise ValueError("Buffer view does not expose strides") */ __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":572 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 572, __pyx_L1_error) /* "View.MemoryView":570 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< * * raise ValueError("Buffer view does not expose strides") */ } /* "View.MemoryView":574 * raise ValueError("Buffer view does not expose strides") * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_v_stride = (__pyx_t_3[0]); __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "View.MemoryView":569 * * @property * def strides(self): # <<<<<<<<<<<<<< * if self.view.strides == NULL: * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":577 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; Py_ssize_t *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":578 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":579 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__16, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":578 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< * return (-1,) * self.view.ndim * */ } /* "View.MemoryView":581 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { __pyx_t_4 = __pyx_t_6; __pyx_v_suboffset = (__pyx_t_4[0]); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":577 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":584 * * @property * def ndim(self): # <<<<<<<<<<<<<< * return self.view.ndim * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":585 * @property * def ndim(self): * return self.view.ndim # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":584 * * @property * def ndim(self): # <<<<<<<<<<<<<< * return self.view.ndim * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":588 * * @property * def itemsize(self): # <<<<<<<<<<<<<< * return self.view.itemsize * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":589 * @property * def itemsize(self): * return self.view.itemsize # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":588 * * @property * def itemsize(self): # <<<<<<<<<<<<<< * return self.view.itemsize * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":592 * * @property * def nbytes(self): # <<<<<<<<<<<<<< * return self.size * self.view.itemsize * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":593 * @property * def nbytes(self): * return self.size * self.view.itemsize # <<<<<<<<<<<<<< * * @property */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":592 * * @property * def nbytes(self): # <<<<<<<<<<<<<< * return self.size * self.view.itemsize * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":596 * * @property * def size(self): # <<<<<<<<<<<<<< * if self._size is None: * result = 1 */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_v_result = NULL; PyObject *__pyx_v_length = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":597 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ __pyx_t_1 = (__pyx_v_self->_size == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":598 * def size(self): * if self._size is None: * result = 1 # <<<<<<<<<<<<<< * * for length in self.view.shape[:self.view.ndim]: */ __Pyx_INCREF(__pyx_int_1); __pyx_v_result = __pyx_int_1; /* "View.MemoryView":600 * result = 1 * * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< * result *= length * */ __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); __pyx_t_6 = 0; /* "View.MemoryView":601 * * for length in self.view.shape[:self.view.ndim]: * result *= length # <<<<<<<<<<<<<< * * self._size = result */ __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); __pyx_t_6 = 0; } /* "View.MemoryView":603 * result *= length * * self._size = result # <<<<<<<<<<<<<< * * return self._size */ __Pyx_INCREF(__pyx_v_result); __Pyx_GIVEREF(__pyx_v_result); __Pyx_GOTREF(__pyx_v_self->_size); __Pyx_DECREF(__pyx_v_self->_size); __pyx_v_self->_size = __pyx_v_result; /* "View.MemoryView":597 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< * result = 1 * */ } /* "View.MemoryView":605 * self._size = result * * return self._size # <<<<<<<<<<<<<< * * def __len__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->_size); __pyx_r = __pyx_v_self->_size; goto __pyx_L0; /* "View.MemoryView":596 * * @property * def size(self): # <<<<<<<<<<<<<< * if self._size is None: * result = 1 */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_result); __Pyx_XDECREF(__pyx_v_length); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":607 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< * if self.view.ndim >= 1: * return self.view.shape[0] */ /* Python wrapper */ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__len__", 0); /* "View.MemoryView":608 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":609 * def __len__(self): * if self.view.ndim >= 1: * return self.view.shape[0] # <<<<<<<<<<<<<< * * return 0 */ __pyx_r = (__pyx_v_self->view.shape[0]); goto __pyx_L0; /* "View.MemoryView":608 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< * return self.view.shape[0] * */ } /* "View.MemoryView":611 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< * * def __repr__(self): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":607 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< * if self.view.ndim >= 1: * return self.view.shape[0] */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":613 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__, * id(self)) */ /* Python wrapper */ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "View.MemoryView":614 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":615 * def __repr__(self): * return "" % (self.base.__class__.__name__, * id(self)) # <<<<<<<<<<<<<< * * def __str__(self): */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "View.MemoryView":614 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":613 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__, * id(self)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":617 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__,) * */ /* Python wrapper */ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "View.MemoryView":618 * * def __str__(self): * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":617 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< * return "" % (self.base.__class__.__name__,) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":621 * * * def is_c_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* Python wrapper */ static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice *__pyx_v_mslice; __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_c_contig", 0); /* "View.MemoryView":624 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'C', self.view.ndim) * */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":625 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< * * def is_f_contig(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":621 * * * def is_c_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* Python wrapper */ static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice *__pyx_v_mslice; __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_f_contig", 0); /* "View.MemoryView":630 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'F', self.view.ndim) * */ __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":631 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< * * def copy(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":633 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS */ /* Python wrapper */ static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice __pyx_v_mslice; int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy", 0); /* "View.MemoryView":635 * def copy(self): * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< * * slice_copy(self, &mslice) */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); /* "View.MemoryView":637 * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS * * slice_copy(self, &mslice) # <<<<<<<<<<<<<< * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, * self.view.itemsize, */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); /* "View.MemoryView":638 * * slice_copy(self, &mslice) * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_C_CONTIGUOUS, */ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; /* "View.MemoryView":643 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< * * def copy_fortran(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":633 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":645 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS */ /* Python wrapper */ static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { __Pyx_memviewslice __pyx_v_src; __Pyx_memviewslice __pyx_v_dst; int __pyx_v_flags; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy_fortran", 0); /* "View.MemoryView":647 * def copy_fortran(self): * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< * * slice_copy(self, &src) */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); /* "View.MemoryView":649 * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS * * slice_copy(self, &src) # <<<<<<<<<<<<<< * dst = slice_copy_contig(&src, "fortran", self.view.ndim, * self.view.itemsize, */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); /* "View.MemoryView":650 * * slice_copy(self, &src) * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_F_CONTIGUOUS, */ __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; /* "View.MemoryView":655 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":645 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":659 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo */ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { struct __pyx_memoryview_obj *__pyx_v_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); /* "View.MemoryView":660 * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< * result.typeinfo = typeinfo * return result */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_o); __Pyx_GIVEREF(__pyx_v_o); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":661 * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo # <<<<<<<<<<<<<< * return result * */ __pyx_v_result->typeinfo = __pyx_v_typeinfo; /* "View.MemoryView":662 * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo * return result # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_check') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":659 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":665 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("memoryview_check", 0); /* "View.MemoryView":666 * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): * return isinstance(o, memoryview) # <<<<<<<<<<<<<< * * cdef tuple _unellipsify(object index, int ndim): */ __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); __pyx_r = __pyx_t_1; goto __pyx_L0; /* "View.MemoryView":665 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< * return isinstance(o, memoryview) * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":668 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< * """ * Replace all ellipses with full slices and fill incomplete indices with */ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { PyObject *__pyx_v_tup = NULL; PyObject *__pyx_v_result = NULL; int __pyx_v_have_slices; int __pyx_v_seen_ellipsis; CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; PyObject *__pyx_v_item = NULL; Py_ssize_t __pyx_v_nslices; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); PyObject *__pyx_t_7 = NULL; Py_ssize_t __pyx_t_8; int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_unellipsify", 0); /* "View.MemoryView":673 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< * tup = (index,) * else: */ __pyx_t_1 = PyTuple_Check(__pyx_v_index); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":674 * """ * if not isinstance(index, tuple): * tup = (index,) # <<<<<<<<<<<<<< * else: * tup = index */ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); __pyx_v_tup = __pyx_t_3; __pyx_t_3 = 0; /* "View.MemoryView":673 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< * tup = (index,) * else: */ goto __pyx_L3; } /* "View.MemoryView":676 * tup = (index,) * else: * tup = index # <<<<<<<<<<<<<< * * result = [] */ /*else*/ { __Pyx_INCREF(__pyx_v_index); __pyx_v_tup = __pyx_v_index; } __pyx_L3:; /* "View.MemoryView":678 * tup = index * * result = [] # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_result = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":679 * * result = [] * have_slices = False # <<<<<<<<<<<<<< * seen_ellipsis = False * for idx, item in enumerate(tup): */ __pyx_v_have_slices = 0; /* "View.MemoryView":680 * result = [] * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< * for idx, item in enumerate(tup): * if item is Ellipsis: */ __pyx_v_seen_ellipsis = 0; /* "View.MemoryView":681 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ __Pyx_INCREF(__pyx_int_0); __pyx_t_3 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) #else __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } } else { __pyx_t_7 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 681, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_7); } __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = __pyx_t_7; __pyx_t_7 = 0; /* "View.MemoryView":682 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) */ __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":683 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True */ __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":684 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { __Pyx_INCREF(__pyx_slice__19); __Pyx_GIVEREF(__pyx_slice__19); PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__19); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "View.MemoryView":685 * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True # <<<<<<<<<<<<<< * else: * result.append(slice(None)) */ __pyx_v_seen_ellipsis = 1; /* "View.MemoryView":683 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True */ goto __pyx_L7; } /* "View.MemoryView":687 * seen_ellipsis = True * else: * result.append(slice(None)) # <<<<<<<<<<<<<< * have_slices = True * else: */ /*else*/ { __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__19); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) } __pyx_L7:; /* "View.MemoryView":688 * else: * result.append(slice(None)) * have_slices = True # <<<<<<<<<<<<<< * else: * if not isinstance(item, slice) and not PyIndex_Check(item): */ __pyx_v_have_slices = 1; /* "View.MemoryView":682 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) */ goto __pyx_L6; } /* "View.MemoryView":690 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError("Cannot index with type '%s'" % type(item)) * */ /*else*/ { __pyx_t_2 = PySlice_Check(__pyx_v_item); __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_10) { } else { __pyx_t_1 = __pyx_t_10; goto __pyx_L9_bool_binop_done; } __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); __pyx_t_1 = __pyx_t_10; __pyx_L9_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "View.MemoryView":691 * else: * if not isinstance(item, slice) and not PyIndex_Check(item): * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< * * have_slices = have_slices or isinstance(item, slice) */ __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_11, 0, 0, 0); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __PYX_ERR(1, 691, __pyx_L1_error) /* "View.MemoryView":690 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< * raise TypeError("Cannot index with type '%s'" % type(item)) * */ } /* "View.MemoryView":693 * raise TypeError("Cannot index with type '%s'" % type(item)) * * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< * result.append(item) * */ __pyx_t_10 = (__pyx_v_have_slices != 0); if (!__pyx_t_10) { } else { __pyx_t_1 = __pyx_t_10; goto __pyx_L11_bool_binop_done; } __pyx_t_10 = PySlice_Check(__pyx_v_item); __pyx_t_2 = (__pyx_t_10 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L11_bool_binop_done:; __pyx_v_have_slices = __pyx_t_1; /* "View.MemoryView":694 * * have_slices = have_slices or isinstance(item, slice) * result.append(item) # <<<<<<<<<<<<<< * * nslices = ndim - len(result) */ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) } __pyx_L6:; /* "View.MemoryView":681 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< * if item is Ellipsis: * if not seen_ellipsis: */ } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":696 * result.append(item) * * nslices = ndim - len(result) # <<<<<<<<<<<<<< * if nslices: * result.extend([slice(None)] * nslices) */ __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); /* "View.MemoryView":697 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< * result.extend([slice(None)] * nslices) * */ __pyx_t_1 = (__pyx_v_nslices != 0); if (__pyx_t_1) { /* "View.MemoryView":698 * nslices = ndim - len(result) * if nslices: * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< * * return have_slices or nslices, tuple(result) */ __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { __Pyx_INCREF(__pyx_slice__19); __Pyx_GIVEREF(__pyx_slice__19); PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__19); } } __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":697 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< * result.extend([slice(None)] * nslices) * */ } /* "View.MemoryView":700 * result.extend([slice(None)] * nslices) * * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): */ __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L14_bool_binop_done; } __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; __pyx_L14_bool_binop_done:; __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = ((PyObject*)__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L0; /* "View.MemoryView":668 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< * """ * Replace all ellipses with full slices and fill incomplete indices with */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tup); __Pyx_XDECREF(__pyx_v_result); __Pyx_XDECREF(__pyx_v_idx); __Pyx_XDECREF(__pyx_v_item); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":702 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations Py_ssize_t *__pyx_t_1; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); /* "View.MemoryView":703 * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") */ __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { __pyx_t_1 = __pyx_t_3; __pyx_v_suboffset = (__pyx_t_1[0]); /* "View.MemoryView":704 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError("Indirect dimensions not supported") * */ __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); if (unlikely(__pyx_t_4)) { /* "View.MemoryView":705 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(1, 705, __pyx_L1_error) /* "View.MemoryView":704 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * raise ValueError("Indirect dimensions not supported") * */ } } /* "View.MemoryView":702 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":712 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< * cdef int new_ndim = 0, suboffset_dim = -1, dim * cdef bint negative_step */ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { int __pyx_v_new_ndim; int __pyx_v_suboffset_dim; int __pyx_v_dim; __Pyx_memviewslice __pyx_v_src; __Pyx_memviewslice __pyx_v_dst; __Pyx_memviewslice *__pyx_v_p_src; struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; __Pyx_memviewslice *__pyx_v_p_dst; int *__pyx_v_p_suboffset_dim; Py_ssize_t __pyx_v_start; Py_ssize_t __pyx_v_stop; Py_ssize_t __pyx_v_step; int __pyx_v_have_start; int __pyx_v_have_stop; int __pyx_v_have_step; PyObject *__pyx_v_index = NULL; struct __pyx_memoryview_obj *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; struct __pyx_memoryview_obj *__pyx_t_4; char *__pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; PyObject *(*__pyx_t_8)(PyObject *); PyObject *__pyx_t_9 = NULL; Py_ssize_t __pyx_t_10; int __pyx_t_11; Py_ssize_t __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memview_slice", 0); /* "View.MemoryView":713 * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< * cdef bint negative_step * cdef __Pyx_memviewslice src, dst */ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; /* "View.MemoryView":720 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< * * cdef _memoryviewslice memviewsliceobj */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); /* "View.MemoryView":724 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< * * if isinstance(memview, _memoryviewslice): */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(1, 724, __pyx_L1_error) } } #endif /* "View.MemoryView":726 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":727 * * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview # <<<<<<<<<<<<<< * p_src = &memviewsliceobj.from_slice * else: */ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":728 * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< * else: * slice_copy(memview, &src) */ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); /* "View.MemoryView":726 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice */ goto __pyx_L3; } /* "View.MemoryView":730 * p_src = &memviewsliceobj.from_slice * else: * slice_copy(memview, &src) # <<<<<<<<<<<<<< * p_src = &src * */ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); /* "View.MemoryView":731 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< * * */ __pyx_v_p_src = (&__pyx_v_src); } __pyx_L3:; /* "View.MemoryView":737 * * * dst.memview = p_src.memview # <<<<<<<<<<<<<< * dst.data = p_src.data * */ __pyx_t_4 = __pyx_v_p_src->memview; __pyx_v_dst.memview = __pyx_t_4; /* "View.MemoryView":738 * * dst.memview = p_src.memview * dst.data = p_src.data # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __pyx_v_p_src->data; __pyx_v_dst.data = __pyx_t_5; /* "View.MemoryView":743 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< * cdef int *p_suboffset_dim = &suboffset_dim * cdef Py_ssize_t start, stop, step */ __pyx_v_p_dst = (&__pyx_v_dst); /* "View.MemoryView":744 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< * cdef Py_ssize_t start, stop, step * cdef bint have_start, have_stop, have_step */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); /* "View.MemoryView":748 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * slice_memviewslice( */ __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; __pyx_t_8 = NULL; } else { __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_8)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) #else __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } else { if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) #else __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } } else { __pyx_t_9 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_9)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(1, 748, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_9); } __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); __pyx_t_9 = 0; __pyx_v_dim = __pyx_t_6; __pyx_t_6 = (__pyx_t_6 + 1); /* "View.MemoryView":749 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); if (__pyx_t_2) { /* "View.MemoryView":753 * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< * 0, 0, 0, # have_{start,stop,step} * False) */ __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) /* "View.MemoryView":750 * for dim, index in enumerate(indices): * if PyIndex_Check(index): * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) /* "View.MemoryView":749 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< * slice_memviewslice( * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], */ goto __pyx_L6; } /* "View.MemoryView":756 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 */ __pyx_t_2 = (__pyx_v_index == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "View.MemoryView":757 * False) * elif index is None: * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 */ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; /* "View.MemoryView":758 * elif index is None: * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 */ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; /* "View.MemoryView":759 * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< * new_ndim += 1 * else: */ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; /* "View.MemoryView":760 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 # <<<<<<<<<<<<<< * else: * start = index.start or 0 */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); /* "View.MemoryView":756 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 */ goto __pyx_L6; } /* "View.MemoryView":762 * new_ndim += 1 * else: * start = index.start or 0 # <<<<<<<<<<<<<< * stop = index.stop or 0 * step = index.step or 0 */ /*else*/ { __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L7_bool_binop_done; } __pyx_t_10 = 0; __pyx_L7_bool_binop_done:; __pyx_v_start = __pyx_t_10; /* "View.MemoryView":763 * else: * start = index.start or 0 * stop = index.stop or 0 # <<<<<<<<<<<<<< * step = index.step or 0 * */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L9_bool_binop_done; } __pyx_t_10 = 0; __pyx_L9_bool_binop_done:; __pyx_v_stop = __pyx_t_10; /* "View.MemoryView":764 * start = index.start or 0 * stop = index.stop or 0 * step = index.step or 0 # <<<<<<<<<<<<<< * * have_start = index.start is not None */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L11_bool_binop_done; } __pyx_t_10 = 0; __pyx_L11_bool_binop_done:; __pyx_v_step = __pyx_t_10; /* "View.MemoryView":766 * step = index.step or 0 * * have_start = index.start is not None # <<<<<<<<<<<<<< * have_stop = index.stop is not None * have_step = index.step is not None */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_start = __pyx_t_1; /* "View.MemoryView":767 * * have_start = index.start is not None * have_stop = index.stop is not None # <<<<<<<<<<<<<< * have_step = index.step is not None * */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_stop = __pyx_t_1; /* "View.MemoryView":768 * have_start = index.start is not None * have_stop = index.stop is not None * have_step = index.step is not None # <<<<<<<<<<<<<< * * slice_memviewslice( */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_step = __pyx_t_1; /* "View.MemoryView":770 * have_step = index.step is not None * * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) /* "View.MemoryView":776 * have_start, have_stop, have_step, * True) * new_ndim += 1 # <<<<<<<<<<<<<< * * if isinstance(memview, _memoryviewslice): */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); } __pyx_L6:; /* "View.MemoryView":748 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< * if PyIndex_Check(index): * slice_memviewslice( */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":779 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, */ __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "View.MemoryView":780 * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< * memviewsliceobj.to_dtype_func, * memview.dtype_is_object) */ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } /* "View.MemoryView":781 * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< * memview.dtype_is_object) * else: */ if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } /* "View.MemoryView":779 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, */ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "View.MemoryView":778 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, */ } /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ /*else*/ { __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "View.MemoryView":785 * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "View.MemoryView":784 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; } /* "View.MemoryView":712 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< * cdef int new_ndim = 0, suboffset_dim = -1, dim * cdef bint negative_step */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); __Pyx_XDECREF(__pyx_v_index); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":809 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, */ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { Py_ssize_t __pyx_v_new_shape; int __pyx_v_negative_step; int __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":829 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_1) { /* "View.MemoryView":831 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ __pyx_t_1 = ((__pyx_v_start < 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":832 * * if start < 0: * start += shape # <<<<<<<<<<<<<< * if not 0 <= start < shape: * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":831 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< * start += shape * if not 0 <= start < shape: */ } /* "View.MemoryView":833 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) * else: */ __pyx_t_1 = (0 <= __pyx_v_start); if (__pyx_t_1) { __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); } __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":834 * start += shape * if not 0 <= start < shape: * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< * else: * */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) /* "View.MemoryView":833 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) * else: */ } /* "View.MemoryView":829 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< * * if start < 0: */ goto __pyx_L3; } /* "View.MemoryView":837 * else: * * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< * * if have_step and step == 0: */ /*else*/ { __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L6_bool_binop_done; } __pyx_t_1 = ((__pyx_v_step < 0) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L6_bool_binop_done:; __pyx_v_negative_step = __pyx_t_2; /* "View.MemoryView":839 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) * */ __pyx_t_1 = (__pyx_v_have_step != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L9_bool_binop_done; } __pyx_t_1 = ((__pyx_v_step == 0) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L9_bool_binop_done:; if (__pyx_t_2) { /* "View.MemoryView":840 * * if have_step and step == 0: * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) /* "View.MemoryView":839 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) * */ } /* "View.MemoryView":843 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { /* "View.MemoryView":844 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":845 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< * if start < 0: * start = 0 */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); /* "View.MemoryView":846 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":847 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< * elif start >= shape: * if negative_step: */ __pyx_v_start = 0; /* "View.MemoryView":846 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< * start = 0 * elif start >= shape: */ } /* "View.MemoryView":844 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< * start += shape * if start < 0: */ goto __pyx_L12; } /* "View.MemoryView":848 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); if (__pyx_t_2) { /* "View.MemoryView":849 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":850 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = shape */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":849 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L14; } /* "View.MemoryView":852 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ /*else*/ { __pyx_v_start = __pyx_v_shape; } __pyx_L14:; /* "View.MemoryView":848 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< * if negative_step: * start = shape - 1 */ } __pyx_L12:; /* "View.MemoryView":843 * * * if have_start: # <<<<<<<<<<<<<< * if start < 0: * start += shape */ goto __pyx_L11; } /* "View.MemoryView":854 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ /*else*/ { __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":855 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< * else: * start = 0 */ __pyx_v_start = (__pyx_v_shape - 1); /* "View.MemoryView":854 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< * start = shape - 1 * else: */ goto __pyx_L15; } /* "View.MemoryView":857 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< * * if have_stop: */ /*else*/ { __pyx_v_start = 0; } __pyx_L15:; } __pyx_L11:; /* "View.MemoryView":859 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { /* "View.MemoryView":860 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":861 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< * if stop < 0: * stop = 0 */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); /* "View.MemoryView":862 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":863 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< * elif stop > shape: * stop = shape */ __pyx_v_stop = 0; /* "View.MemoryView":862 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< * stop = 0 * elif stop > shape: */ } /* "View.MemoryView":860 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< * stop += shape * if stop < 0: */ goto __pyx_L17; } /* "View.MemoryView":864 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); if (__pyx_t_2) { /* "View.MemoryView":865 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< * else: * if negative_step: */ __pyx_v_stop = __pyx_v_shape; /* "View.MemoryView":864 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< * stop = shape * else: */ } __pyx_L17:; /* "View.MemoryView":859 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< * if stop < 0: * stop += shape */ goto __pyx_L16; } /* "View.MemoryView":867 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ /*else*/ { __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { /* "View.MemoryView":868 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< * else: * stop = shape */ __pyx_v_stop = -1L; /* "View.MemoryView":867 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< * stop = -1 * else: */ goto __pyx_L19; } /* "View.MemoryView":870 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< * * if not have_step: */ /*else*/ { __pyx_v_stop = __pyx_v_shape; } __pyx_L19:; } __pyx_L16:; /* "View.MemoryView":872 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< * step = 1 * */ __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":873 * * if not have_step: * step = 1 # <<<<<<<<<<<<<< * * */ __pyx_v_step = 1; /* "View.MemoryView":872 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< * step = 1 * */ } /* "View.MemoryView":877 * * with cython.cdivision(True): * new_shape = (stop - start) // step # <<<<<<<<<<<<<< * * if (stop - start) - step * new_shape: */ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); /* "View.MemoryView":879 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< * new_shape += 1 * */ __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); if (__pyx_t_2) { /* "View.MemoryView":880 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< * * if new_shape < 0: */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); /* "View.MemoryView":879 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< * new_shape += 1 * */ } /* "View.MemoryView":882 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":883 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< * * */ __pyx_v_new_shape = 0; /* "View.MemoryView":882 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< * new_shape = 0 * */ } /* "View.MemoryView":886 * * * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset */ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); /* "View.MemoryView":887 * * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< * dst.suboffsets[new_ndim] = suboffset * */ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; /* "View.MemoryView":888 * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< * * */ (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; } __pyx_L3:; /* "View.MemoryView":891 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":892 * * if suboffset_dim[0] < 0: * dst.data += start * stride # <<<<<<<<<<<<<< * else: * dst.suboffsets[suboffset_dim[0]] += start * stride */ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); /* "View.MemoryView":891 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< * dst.data += start * stride * else: */ goto __pyx_L23; } /* "View.MemoryView":894 * dst.data += start * stride * else: * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< * * if suboffset >= 0: */ /*else*/ { __pyx_t_3 = (__pyx_v_suboffset_dim[0]); (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); } __pyx_L23:; /* "View.MemoryView":896 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":897 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":898 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":899 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); /* "View.MemoryView":898 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< * dst.data = ( dst.data)[0] + suboffset * else: */ goto __pyx_L26; } /* "View.MemoryView":901 * dst.data = ( dst.data)[0] + suboffset * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< * "must be indexed and not sliced", dim) * else: */ /*else*/ { /* "View.MemoryView":902 * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< * else: * suboffset_dim[0] = new_ndim */ __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L26:; /* "View.MemoryView":897 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset */ goto __pyx_L25; } /* "View.MemoryView":904 * "must be indexed and not sliced", dim) * else: * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< * * return 0 */ /*else*/ { (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; } __pyx_L25:; /* "View.MemoryView":896 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< * if not is_slice: * if new_ndim == 0: */ } /* "View.MemoryView":906 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< * * */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":809 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":912 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 */ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { Py_ssize_t __pyx_v_shape; Py_ssize_t __pyx_v_stride; Py_ssize_t __pyx_v_suboffset; Py_ssize_t __pyx_v_itemsize; char *__pyx_v_resultp; char *__pyx_r; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pybuffer_index", 0); /* "View.MemoryView":914 * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< * cdef Py_ssize_t itemsize = view.itemsize * cdef char *resultp */ __pyx_v_suboffset = -1L; /* "View.MemoryView":915 * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< * cdef char *resultp * */ __pyx_t_1 = __pyx_v_view->itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":918 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len / itemsize * stride = itemsize */ __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":919 * * if view.ndim == 0: * shape = view.len / itemsize # <<<<<<<<<<<<<< * stride = itemsize * else: */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(1, 919, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); __PYX_ERR(1, 919, __pyx_L1_error) } __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); /* "View.MemoryView":920 * if view.ndim == 0: * shape = view.len / itemsize * stride = itemsize # <<<<<<<<<<<<<< * else: * shape = view.shape[dim] */ __pyx_v_stride = __pyx_v_itemsize; /* "View.MemoryView":918 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< * shape = view.len / itemsize * stride = itemsize */ goto __pyx_L3; } /* "View.MemoryView":922 * stride = itemsize * else: * shape = view.shape[dim] # <<<<<<<<<<<<<< * stride = view.strides[dim] * if view.suboffsets != NULL: */ /*else*/ { __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); /* "View.MemoryView":923 * else: * shape = view.shape[dim] * stride = view.strides[dim] # <<<<<<<<<<<<<< * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] */ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); /* "View.MemoryView":924 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); if (__pyx_t_2) { /* "View.MemoryView":925 * stride = view.strides[dim] * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< * * if index < 0: */ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); /* "View.MemoryView":924 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< * suboffset = view.suboffsets[dim] * */ } } __pyx_L3:; /* "View.MemoryView":927 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":928 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< * if index < 0: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); /* "View.MemoryView":929 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":930 * index += view.shape[dim] * if index < 0: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * if index >= shape: */ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 930, __pyx_L1_error) /* "View.MemoryView":929 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ } /* "View.MemoryView":927 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< * index += view.shape[dim] * if index < 0: */ } /* "View.MemoryView":932 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); if (unlikely(__pyx_t_2)) { /* "View.MemoryView":933 * * if index >= shape: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * resultp = bufp + index * stride */ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 933, __pyx_L1_error) /* "View.MemoryView":932 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * */ } /* "View.MemoryView":935 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * resultp = bufp + index * stride # <<<<<<<<<<<<<< * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset */ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); /* "View.MemoryView":936 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":937 * resultp = bufp + index * stride * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< * * return resultp */ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); /* "View.MemoryView":936 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< * resultp = ( resultp)[0] + suboffset * */ } /* "View.MemoryView":939 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_resultp; goto __pyx_L0; /* "View.MemoryView":912 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":945 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { int __pyx_v_ndim; Py_ssize_t *__pyx_v_shape; Py_ssize_t *__pyx_v_strides; int __pyx_v_i; int __pyx_v_j; int __pyx_r; int __pyx_t_1; Py_ssize_t *__pyx_t_2; long __pyx_t_3; long __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":946 * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< * * cdef Py_ssize_t *shape = memslice.shape */ __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; __pyx_v_ndim = __pyx_t_1; /* "View.MemoryView":948 * cdef int ndim = memslice.memview.view.ndim * * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< * cdef Py_ssize_t *strides = memslice.strides * */ __pyx_t_2 = __pyx_v_memslice->shape; __pyx_v_shape = __pyx_t_2; /* "View.MemoryView":949 * * cdef Py_ssize_t *shape = memslice.shape * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_v_memslice->strides; __pyx_v_strides = __pyx_t_2; /* "View.MemoryView":953 * * cdef int i, j * for i in range(ndim / 2): # <<<<<<<<<<<<<< * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] */ __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); __pyx_t_4 = __pyx_t_3; for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":954 * cdef int i, j * for i in range(ndim / 2): * j = ndim - 1 - i # <<<<<<<<<<<<<< * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] */ __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); /* "View.MemoryView":955 * for i in range(ndim / 2): * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< * shape[i], shape[j] = shape[j], shape[i] * */ __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; /* "View.MemoryView":956 * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: */ __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; /* "View.MemoryView":958 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * */ __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); if (!__pyx_t_8) { } else { __pyx_t_7 = __pyx_t_8; goto __pyx_L6_bool_binop_done; } __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); __pyx_t_7 = __pyx_t_8; __pyx_L6_bool_binop_done:; if (__pyx_t_7) { /* "View.MemoryView":959 * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< * * return 1 */ __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) /* "View.MemoryView":958 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * */ } } /* "View.MemoryView":961 * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * * return 1 # <<<<<<<<<<<<<< * * */ __pyx_r = 1; goto __pyx_L0; /* "View.MemoryView":945 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< * cdef int ndim = memslice.memview.view.ndim * */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = 0; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":978 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * */ /* Python wrapper */ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); /* "View.MemoryView":979 * * def __dealloc__(self): * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); /* "View.MemoryView":978 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":981 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: * return self.to_object_func(itemp) */ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); /* "View.MemoryView":982 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":983 * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: * return self.to_object_func(itemp) # <<<<<<<<<<<<<< * else: * return memoryview.convert_item_to_object(self, itemp) */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "View.MemoryView":982 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< * return self.to_object_func(itemp) * else: */ } /* "View.MemoryView":985 * return self.to_object_func(itemp) * else: * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< * * cdef assign_item_from_object(self, char *itemp, object value): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "View.MemoryView":981 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< * if self.to_object_func != NULL: * return self.to_object_func(itemp) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":987 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) */ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); /* "View.MemoryView":988 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< * self.to_dtype_func(itemp, value) * else: */ __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); if (__pyx_t_1) { /* "View.MemoryView":989 * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< * else: * memoryview.assign_item_from_object(self, itemp, value) */ __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) /* "View.MemoryView":988 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< * self.to_dtype_func(itemp, value) * else: */ goto __pyx_L3; } /* "View.MemoryView":991 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< * * @property */ /*else*/ { __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "View.MemoryView":987 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":994 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.from_object * */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":995 * @property * def base(self): * return self.from_object # <<<<<<<<<<<<<< * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->from_object); __pyx_r = __pyx_v_self->from_object; goto __pyx_L0; /* "View.MemoryView":994 * * @property * def base(self): # <<<<<<<<<<<<<< * return self.from_object * */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1001 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< * int ndim, * object (*to_object_func)(char *), */ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; Py_ssize_t __pyx_v_suboffset; PyObject *__pyx_v_length = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; __Pyx_TypeInfo *__pyx_t_4; Py_buffer __pyx_t_5; Py_ssize_t *__pyx_t_6; Py_ssize_t *__pyx_t_7; Py_ssize_t *__pyx_t_8; Py_ssize_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_fromslice", 0); /* "View.MemoryView":1009 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); if (__pyx_t_1) { /* "View.MemoryView":1010 * * if memviewslice.memview == Py_None: * return None # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "View.MemoryView":1009 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< * return None * */ } /* "View.MemoryView":1015 * * * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< * * result.from_slice = memviewslice */ __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1017 * result = _memoryviewslice(None, 0, dtype_is_object) * * result.from_slice = memviewslice # <<<<<<<<<<<<<< * __PYX_INC_MEMVIEW(&memviewslice, 1) * */ __pyx_v_result->from_slice = __pyx_v_memviewslice; /* "View.MemoryView":1018 * * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< * * result.from_object = ( memviewslice.memview).base */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); /* "View.MemoryView":1020 * __PYX_INC_MEMVIEW(&memviewslice, 1) * * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< * result.typeinfo = memviewslice.memview.typeinfo * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_result->from_object); __Pyx_DECREF(__pyx_v_result->from_object); __pyx_v_result->from_object = __pyx_t_2; __pyx_t_2 = 0; /* "View.MemoryView":1021 * * result.from_object = ( memviewslice.memview).base * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< * * result.view = memviewslice.memview.view */ __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; /* "View.MemoryView":1023 * result.typeinfo = memviewslice.memview.typeinfo * * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< * result.view.buf = memviewslice.data * result.view.ndim = ndim */ __pyx_t_5 = __pyx_v_memviewslice.memview->view; __pyx_v_result->__pyx_base.view = __pyx_t_5; /* "View.MemoryView":1024 * * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None */ __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); /* "View.MemoryView":1025 * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data * result.view.ndim = ndim # <<<<<<<<<<<<<< * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) */ __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; /* "View.MemoryView":1026 * result.view.buf = memviewslice.data * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< * Py_INCREF(Py_None) * */ ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; /* "View.MemoryView":1027 * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * * if (memviewslice.memview).flags & PyBUF_WRITABLE: */ Py_INCREF(Py_None); /* "View.MemoryView":1029 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< * result.flags = PyBUF_RECORDS * else: */ __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); if (__pyx_t_1) { /* "View.MemoryView":1030 * * if (memviewslice.memview).flags & PyBUF_WRITABLE: * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< * else: * result.flags = PyBUF_RECORDS_RO */ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; /* "View.MemoryView":1029 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< * result.flags = PyBUF_RECORDS * else: */ goto __pyx_L4; } /* "View.MemoryView":1032 * result.flags = PyBUF_RECORDS * else: * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< * * result.view.shape = result.from_slice.shape */ /*else*/ { __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; } __pyx_L4:; /* "View.MemoryView":1034 * result.flags = PyBUF_RECORDS_RO * * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< * result.view.strides = result.from_slice.strides * */ __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); /* "View.MemoryView":1035 * * result.view.shape = result.from_slice.shape * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< * * */ __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); /* "View.MemoryView":1038 * * * result.view.suboffsets = NULL # <<<<<<<<<<<<<< * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: */ __pyx_v_result->__pyx_base.view.suboffsets = NULL; /* "View.MemoryView":1039 * * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets */ __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; __pyx_v_suboffset = (__pyx_t_6[0]); /* "View.MemoryView":1040 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * result.view.suboffsets = result.from_slice.suboffsets * break */ __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":1041 * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< * break * */ __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); /* "View.MemoryView":1042 * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets * break # <<<<<<<<<<<<<< * * result.view.len = result.view.itemsize */ goto __pyx_L6_break; /* "View.MemoryView":1040 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< * result.view.suboffsets = result.from_slice.suboffsets * break */ } } __pyx_L6_break:; /* "View.MemoryView":1044 * break * * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< * for length in result.view.shape[:ndim]: * result.view.len *= length */ __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; /* "View.MemoryView":1045 * * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< * result.view.len *= length * */ __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":1046 * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: * result.view.len *= length # <<<<<<<<<<<<<< * * result.to_object_func = to_object_func */ __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; } /* "View.MemoryView":1048 * result.view.len *= length * * result.to_object_func = to_object_func # <<<<<<<<<<<<<< * result.to_dtype_func = to_dtype_func * */ __pyx_v_result->to_object_func = __pyx_v_to_object_func; /* "View.MemoryView":1049 * * result.to_object_func = to_object_func * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< * * return result */ __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; /* "View.MemoryView":1051 * result.to_dtype_func = to_dtype_func * * return result # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_get_slice_from_memoryview') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "View.MemoryView":1001 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< * int ndim, * object (*to_object_func)(char *), */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XDECREF(__pyx_v_length); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1054 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj */ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; __Pyx_memviewslice *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_slice_from_memview", 0); /* "View.MemoryView":1057 * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview * return &obj.from_slice */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":1058 * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): * obj = memview # <<<<<<<<<<<<<< * return &obj.from_slice * else: */ if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; /* "View.MemoryView":1059 * if isinstance(memview, _memoryviewslice): * obj = memview * return &obj.from_slice # <<<<<<<<<<<<<< * else: * slice_copy(memview, mslice) */ __pyx_r = (&__pyx_v_obj->from_slice); goto __pyx_L0; /* "View.MemoryView":1057 * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview * return &obj.from_slice */ } /* "View.MemoryView":1061 * return &obj.from_slice * else: * slice_copy(memview, mslice) # <<<<<<<<<<<<<< * return mslice * */ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); /* "View.MemoryView":1062 * else: * slice_copy(memview, mslice) * return mslice # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_slice_copy') */ __pyx_r = __pyx_v_mslice; goto __pyx_L0; } /* "View.MemoryView":1054 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< * __Pyx_memviewslice *mslice) except NULL: * cdef _memoryviewslice obj */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_obj); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1065 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { int __pyx_v_dim; Py_ssize_t *__pyx_v_shape; Py_ssize_t *__pyx_v_strides; Py_ssize_t *__pyx_v_suboffsets; __Pyx_RefNannyDeclarations Py_ssize_t *__pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; Py_ssize_t __pyx_t_5; __Pyx_RefNannySetupContext("slice_copy", 0); /* "View.MemoryView":1069 * cdef (Py_ssize_t*) shape, strides, suboffsets * * shape = memview.view.shape # <<<<<<<<<<<<<< * strides = memview.view.strides * suboffsets = memview.view.suboffsets */ __pyx_t_1 = __pyx_v_memview->view.shape; __pyx_v_shape = __pyx_t_1; /* "View.MemoryView":1070 * * shape = memview.view.shape * strides = memview.view.strides # <<<<<<<<<<<<<< * suboffsets = memview.view.suboffsets * */ __pyx_t_1 = __pyx_v_memview->view.strides; __pyx_v_strides = __pyx_t_1; /* "View.MemoryView":1071 * shape = memview.view.shape * strides = memview.view.strides * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< * * dst.memview = <__pyx_memoryview *> memview */ __pyx_t_1 = __pyx_v_memview->view.suboffsets; __pyx_v_suboffsets = __pyx_t_1; /* "View.MemoryView":1073 * suboffsets = memview.view.suboffsets * * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< * dst.data = memview.view.buf * */ __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); /* "View.MemoryView":1074 * * dst.memview = <__pyx_memoryview *> memview * dst.data = memview.view.buf # <<<<<<<<<<<<<< * * for dim in range(memview.view.ndim): */ __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); /* "View.MemoryView":1076 * dst.data = memview.view.buf * * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] */ __pyx_t_2 = __pyx_v_memview->view.ndim; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_dim = __pyx_t_4; /* "View.MemoryView":1077 * * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 */ (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); /* "View.MemoryView":1078 * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 * */ (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); /* "View.MemoryView":1079 * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_object') */ if ((__pyx_v_suboffsets != 0)) { __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); } else { __pyx_t_5 = -1L; } (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; } /* "View.MemoryView":1065 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< * cdef int dim * cdef (Py_ssize_t*) shape, strides, suboffsets */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice */ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { __Pyx_memviewslice __pyx_v_memviewslice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy", 0); /* "View.MemoryView":1085 * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< * return memoryview_copy_from_slice(memview, &memviewslice) * */ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); /* "View.MemoryView":1086 * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_object_from_slice') */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1089 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< * """ * Create a new memoryview object from a given memoryview object and slice. */ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { PyObject *(*__pyx_v_to_object_func)(char *); int (*__pyx_v_to_dtype_func)(char *, PyObject *); PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *(*__pyx_t_3)(char *); int (*__pyx_t_4)(char *, PyObject *); PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); /* "View.MemoryView":1096 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func */ __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "View.MemoryView":1097 * * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: */ __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; __pyx_v_to_object_func = __pyx_t_3; /* "View.MemoryView":1098 * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< * else: * to_object_func = NULL */ __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; __pyx_v_to_dtype_func = __pyx_t_4; /* "View.MemoryView":1096 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func */ goto __pyx_L3; } /* "View.MemoryView":1100 * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: * to_object_func = NULL # <<<<<<<<<<<<<< * to_dtype_func = NULL * */ /*else*/ { __pyx_v_to_object_func = NULL; /* "View.MemoryView":1101 * else: * to_object_func = NULL * to_dtype_func = NULL # <<<<<<<<<<<<<< * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, */ __pyx_v_to_dtype_func = NULL; } __pyx_L3:; /* "View.MemoryView":1103 * to_dtype_func = NULL * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< * to_object_func, to_dtype_func, * memview.dtype_is_object) */ __Pyx_XDECREF(__pyx_r); /* "View.MemoryView":1105 * return memoryview_fromslice(memviewslice[0], memview.view.ndim, * to_object_func, to_dtype_func, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "View.MemoryView":1089 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< * """ * Create a new memoryview object from a given memoryview object and slice. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "View.MemoryView":1111 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< * if arg < 0: * return -arg */ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; int __pyx_t_1; /* "View.MemoryView":1112 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< * return -arg * else: */ __pyx_t_1 = ((__pyx_v_arg < 0) != 0); if (__pyx_t_1) { /* "View.MemoryView":1113 * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: * return -arg # <<<<<<<<<<<<<< * else: * return arg */ __pyx_r = (-__pyx_v_arg); goto __pyx_L0; /* "View.MemoryView":1112 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< * return -arg * else: */ } /* "View.MemoryView":1115 * return -arg * else: * return arg # <<<<<<<<<<<<<< * * @cname('__pyx_get_best_slice_order') */ /*else*/ { __pyx_r = __pyx_v_arg; goto __pyx_L0; } /* "View.MemoryView":1111 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< * if arg < 0: * return -arg */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1118 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { int __pyx_v_i; Py_ssize_t __pyx_v_c_stride; Py_ssize_t __pyx_v_f_stride; char __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; /* "View.MemoryView":1123 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< * cdef Py_ssize_t f_stride = 0 * */ __pyx_v_c_stride = 0; /* "View.MemoryView":1124 * cdef int i * cdef Py_ssize_t c_stride = 0 * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< * * for i in range(ndim - 1, -1, -1): */ __pyx_v_f_stride = 0; /* "View.MemoryView":1126 * cdef Py_ssize_t f_stride = 0 * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] */ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":1127 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1128 * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< * break * */ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1129 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< * * for i in range(ndim): */ goto __pyx_L4_break; /* "View.MemoryView":1127 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * c_stride = mslice.strides[i] * break */ } } __pyx_L4_break:; /* "View.MemoryView":1131 * break * * for i in range(ndim): # <<<<<<<<<<<<<< * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] */ __pyx_t_1 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_1; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1132 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1133 * for i in range(ndim): * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< * break * */ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1134 * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): */ goto __pyx_L7_break; /* "View.MemoryView":1132 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< * f_stride = mslice.strides[i] * break */ } } __pyx_L7_break:; /* "View.MemoryView":1136 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1137 * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): * return 'C' # <<<<<<<<<<<<<< * else: * return 'F' */ __pyx_r = 'C'; goto __pyx_L0; /* "View.MemoryView":1136 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< * return 'C' * else: */ } /* "View.MemoryView":1139 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< * * @cython.cdivision(True) */ /*else*/ { __pyx_r = 'F'; goto __pyx_L0; } /* "View.MemoryView":1118 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< * """ * Figure out the best memory access order for a given slice. */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1142 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< * char *dst_data, Py_ssize_t *dst_strides, * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, */ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; Py_ssize_t __pyx_v_dst_extent; Py_ssize_t __pyx_v_src_stride; Py_ssize_t __pyx_v_dst_stride; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; /* "View.MemoryView":1149 * * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] */ __pyx_v_src_extent = (__pyx_v_src_shape[0]); /* "View.MemoryView":1150 * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] */ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); /* "View.MemoryView":1151 * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t dst_stride = dst_strides[0] * */ __pyx_v_src_stride = (__pyx_v_src_strides[0]); /* "View.MemoryView":1152 * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< * * if ndim == 1: */ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); /* "View.MemoryView":1154 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): */ __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } /* "View.MemoryView":1156 * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< * memcpy(dst_data, src_data, itemsize * dst_extent) * else: */ __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); if (__pyx_t_2) { __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); } __pyx_t_3 = (__pyx_t_2 != 0); __pyx_t_1 = __pyx_t_3; __pyx_L5_bool_binop_done:; /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ if (__pyx_t_1) { /* "View.MemoryView":1157 * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< * else: * for i in range(dst_extent): */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); /* "View.MemoryView":1155 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) */ goto __pyx_L4; } /* "View.MemoryView":1159 * memcpy(dst_data, src_data, itemsize * dst_extent) * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< * memcpy(dst_data, src_data, itemsize) * src_data += src_stride */ /*else*/ { __pyx_t_4 = __pyx_v_dst_extent; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1160 * else: * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< * src_data += src_stride * dst_data += dst_stride */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); /* "View.MemoryView":1161 * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< * dst_data += dst_stride * else: */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); /* "View.MemoryView":1162 * memcpy(dst_data, src_data, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< * else: * for i in range(dst_extent): */ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); } } __pyx_L4:; /* "View.MemoryView":1154 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): */ goto __pyx_L3; } /* "View.MemoryView":1164 * dst_data += dst_stride * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< * _copy_strided_to_strided(src_data, src_strides + 1, * dst_data, dst_strides + 1, */ /*else*/ { __pyx_t_4 = __pyx_v_dst_extent; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1165 * else: * for i in range(dst_extent): * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< * dst_data, dst_strides + 1, * src_shape + 1, dst_shape + 1, */ _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); /* "View.MemoryView":1169 * src_shape + 1, dst_shape + 1, * ndim - 1, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< * dst_data += dst_stride * */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); /* "View.MemoryView":1170 * ndim - 1, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, */ __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); } } __pyx_L3:; /* "View.MemoryView":1142 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< * char *dst_data, Py_ssize_t *dst_strides, * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, */ /* function exit code */ } /* "View.MemoryView":1172 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: */ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { /* "View.MemoryView":1175 * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< * src.shape, dst.shape, ndim, itemsize) * */ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); /* "View.MemoryView":1172 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: */ /* function exit code */ } /* "View.MemoryView":1179 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { Py_ssize_t __pyx_v_shape; Py_ssize_t __pyx_v_size; Py_ssize_t __pyx_r; Py_ssize_t __pyx_t_1; Py_ssize_t *__pyx_t_2; Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; /* "View.MemoryView":1181 * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< * * for shape in src.shape[:ndim]: */ __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_size = __pyx_t_1; /* "View.MemoryView":1183 * cdef Py_ssize_t shape, size = src.memview.view.itemsize * * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< * size *= shape * */ __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_shape = (__pyx_t_2[0]); /* "View.MemoryView":1184 * * for shape in src.shape[:ndim]: * size *= shape # <<<<<<<<<<<<<< * * return size */ __pyx_v_size = (__pyx_v_size * __pyx_v_shape); } /* "View.MemoryView":1186 * size *= shape * * return size # <<<<<<<<<<<<<< * * @cname('__pyx_fill_contig_strides_array') */ __pyx_r = __pyx_v_size; goto __pyx_L0; /* "View.MemoryView":1179 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" * cdef Py_ssize_t shape, size = src.memview.view.itemsize */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1189 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, * int ndim, char order) nogil: */ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { int __pyx_v_idx; Py_ssize_t __pyx_r; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; /* "View.MemoryView":1198 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ __pyx_t_1 = ((__pyx_v_order == 'F') != 0); if (__pyx_t_1) { /* "View.MemoryView":1199 * * if order == 'F': * for idx in range(ndim): # <<<<<<<<<<<<<< * strides[idx] = stride * stride *= shape[idx] */ __pyx_t_2 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_idx = __pyx_t_4; /* "View.MemoryView":1200 * if order == 'F': * for idx in range(ndim): * strides[idx] = stride # <<<<<<<<<<<<<< * stride *= shape[idx] * else: */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; /* "View.MemoryView":1201 * for idx in range(ndim): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< * else: * for idx in range(ndim - 1, -1, -1): */ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } /* "View.MemoryView":1198 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< * for idx in range(ndim): * strides[idx] = stride */ goto __pyx_L3; } /* "View.MemoryView":1203 * stride *= shape[idx] * else: * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * strides[idx] = stride * stride *= shape[idx] */ /*else*/ { for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { __pyx_v_idx = __pyx_t_2; /* "View.MemoryView":1204 * else: * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride # <<<<<<<<<<<<<< * stride *= shape[idx] * */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; /* "View.MemoryView":1205 * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride * stride *= shape[idx] # <<<<<<<<<<<<<< * * return stride */ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } } __pyx_L3:; /* "View.MemoryView":1207 * stride *= shape[idx] * * return stride # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_data_to_temp') */ __pyx_r = __pyx_v_stride; goto __pyx_L0; /* "View.MemoryView":1189 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, * int ndim, char order) nogil: */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1210 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *tmpslice, * char order, */ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { int __pyx_v_i; void *__pyx_v_result; size_t __pyx_v_itemsize; size_t __pyx_v_size; void *__pyx_r; Py_ssize_t __pyx_t_1; int __pyx_t_2; int __pyx_t_3; struct __pyx_memoryview_obj *__pyx_t_4; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":1221 * cdef void *result * * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< * cdef size_t size = slice_get_size(src, ndim) * */ __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":1222 * * cdef size_t itemsize = src.memview.view.itemsize * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< * * result = malloc(size) */ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); /* "View.MemoryView":1224 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< * if not result: * _err(MemoryError, NULL) */ __pyx_v_result = malloc(__pyx_v_size); /* "View.MemoryView":1225 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err(MemoryError, NULL) * */ __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1226 * result = malloc(size) * if not result: * _err(MemoryError, NULL) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) /* "View.MemoryView":1225 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< * _err(MemoryError, NULL) * */ } /* "View.MemoryView":1229 * * * tmpslice.data = result # <<<<<<<<<<<<<< * tmpslice.memview = src.memview * for i in range(ndim): */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); /* "View.MemoryView":1230 * * tmpslice.data = result * tmpslice.memview = src.memview # <<<<<<<<<<<<<< * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] */ __pyx_t_4 = __pyx_v_src->memview; __pyx_v_tmpslice->memview = __pyx_t_4; /* "View.MemoryView":1231 * tmpslice.data = result * tmpslice.memview = src.memview * for i in range(ndim): # <<<<<<<<<<<<<< * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 */ __pyx_t_3 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_3; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1232 * tmpslice.memview = src.memview * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< * tmpslice.suboffsets[i] = -1 * */ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); /* "View.MemoryView":1233 * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, */ (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1235 * tmpslice.suboffsets[i] = -1 * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< * ndim, order) * */ (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); /* "View.MemoryView":1239 * * * for i in range(ndim): # <<<<<<<<<<<<<< * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 */ __pyx_t_3 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_3; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "View.MemoryView":1240 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1241 * for i in range(ndim): * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< * * if slice_is_contig(src[0], order, ndim): */ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; /* "View.MemoryView":1240 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< * tmpslice.strides[i] = 0 * */ } } /* "View.MemoryView":1243 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1244 * * if slice_is_contig(src[0], order, ndim): * memcpy(result, src.data, size) # <<<<<<<<<<<<<< * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) */ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); /* "View.MemoryView":1243 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< * memcpy(result, src.data, size) * else: */ goto __pyx_L9; } /* "View.MemoryView":1246 * memcpy(result, src.data, size) * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< * * return result */ /*else*/ { copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); } __pyx_L9:; /* "View.MemoryView":1248 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_result; goto __pyx_L0; /* "View.MemoryView":1210 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< * __Pyx_memviewslice *tmpslice, * char order, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = NULL; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % */ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_extents", 0); /* "View.MemoryView":1256 * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % * (i, extent1, extent2)) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_dim') */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; /* "View.MemoryView":1255 * cdef int _err_extents(int i, Py_ssize_t extent1, * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< * (i, extent1, extent2)) * */ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 1255, __pyx_L1_error) /* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1259 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii') % dim) * */ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_dim", 0); __Pyx_INCREF(__pyx_v_error); /* "View.MemoryView":1260 * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err') */ __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_INCREF(__pyx_v_error); __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 1260, __pyx_L1_error) /* "View.MemoryView":1259 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii') % dim) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_error); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1263 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< * if msg != NULL: * raise error(msg.decode('ascii')) */ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err", 0); __Pyx_INCREF(__pyx_v_error); /* "View.MemoryView":1264 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii')) * else: */ __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); if (unlikely(__pyx_t_1)) { /* "View.MemoryView":1265 * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< * else: * raise error */ __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_error); __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 1265, __pyx_L1_error) /* "View.MemoryView":1264 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< * raise error(msg.decode('ascii')) * else: */ } /* "View.MemoryView":1267 * raise error(msg.decode('ascii')) * else: * raise error # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_copy_contents') */ /*else*/ { __Pyx_Raise(__pyx_v_error, 0, 0, 0); __PYX_ERR(1, 1267, __pyx_L1_error) } /* "View.MemoryView":1263 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< * if msg != NULL: * raise error(msg.decode('ascii')) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_XDECREF(__pyx_v_error); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif return __pyx_r; } /* "View.MemoryView":1270 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< * __Pyx_memviewslice dst, * int src_ndim, int dst_ndim, */ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { void *__pyx_v_tmpdata; size_t __pyx_v_itemsize; int __pyx_v_i; char __pyx_v_order; int __pyx_v_broadcasting; int __pyx_v_direct_copy; __Pyx_memviewslice __pyx_v_tmp; int __pyx_v_ndim; int __pyx_r; Py_ssize_t __pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; void *__pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; /* "View.MemoryView":1278 * Check for overlapping memory and verify the shapes. * """ * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< * cdef size_t itemsize = src.memview.view.itemsize * cdef int i */ __pyx_v_tmpdata = NULL; /* "View.MemoryView":1279 * """ * cdef void *tmpdata = NULL * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< * cdef int i * cdef char order = get_best_order(&src, src_ndim) */ __pyx_t_1 = __pyx_v_src.memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; /* "View.MemoryView":1281 * cdef size_t itemsize = src.memview.view.itemsize * cdef int i * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< * cdef bint broadcasting = False * cdef bint direct_copy = False */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); /* "View.MemoryView":1282 * cdef int i * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False # <<<<<<<<<<<<<< * cdef bint direct_copy = False * cdef __Pyx_memviewslice tmp */ __pyx_v_broadcasting = 0; /* "View.MemoryView":1283 * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False * cdef bint direct_copy = False # <<<<<<<<<<<<<< * cdef __Pyx_memviewslice tmp * */ __pyx_v_direct_copy = 0; /* "View.MemoryView":1286 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: */ __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1287 * * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) */ __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); /* "View.MemoryView":1286 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: */ goto __pyx_L3; } /* "View.MemoryView":1288 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&dst, dst_ndim, src_ndim) * */ __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1289 * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< * * cdef int ndim = max(src_ndim, dst_ndim) */ __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); /* "View.MemoryView":1288 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< * broadcast_leading(&dst, dst_ndim, src_ndim) * */ } __pyx_L3:; /* "View.MemoryView":1291 * broadcast_leading(&dst, dst_ndim, src_ndim) * * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< * * for i in range(ndim): */ __pyx_t_3 = __pyx_v_dst_ndim; __pyx_t_4 = __pyx_v_src_ndim; if (((__pyx_t_3 > __pyx_t_4) != 0)) { __pyx_t_5 = __pyx_t_3; } else { __pyx_t_5 = __pyx_t_4; } __pyx_v_ndim = __pyx_t_5; /* "View.MemoryView":1293 * cdef int ndim = max(src_ndim, dst_ndim) * * for i in range(ndim): # <<<<<<<<<<<<<< * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: */ __pyx_t_5 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_5; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1294 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< * if src.shape[i] == 1: * broadcasting = True */ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); if (__pyx_t_2) { /* "View.MemoryView":1295 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< * broadcasting = True * src.strides[i] = 0 */ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { /* "View.MemoryView":1296 * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: * broadcasting = True # <<<<<<<<<<<<<< * src.strides[i] = 0 * else: */ __pyx_v_broadcasting = 1; /* "View.MemoryView":1297 * if src.shape[i] == 1: * broadcasting = True * src.strides[i] = 0 # <<<<<<<<<<<<<< * else: * _err_extents(i, dst.shape[i], src.shape[i]) */ (__pyx_v_src.strides[__pyx_v_i]) = 0; /* "View.MemoryView":1295 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< * broadcasting = True * src.strides[i] = 0 */ goto __pyx_L7; } /* "View.MemoryView":1299 * src.strides[i] = 0 * else: * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< * * if src.suboffsets[i] >= 0: */ /*else*/ { __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) } __pyx_L7:; /* "View.MemoryView":1294 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< * if src.shape[i] == 1: * broadcasting = True */ } /* "View.MemoryView":1301 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Dimension %d is not direct", i) * */ __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); if (__pyx_t_2) { /* "View.MemoryView":1302 * * if src.suboffsets[i] >= 0: * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< * * if slices_overlap(&src, &dst, ndim, itemsize): */ __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) /* "View.MemoryView":1301 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< * _err_dim(ValueError, "Dimension %d is not direct", i) * */ } } /* "View.MemoryView":1304 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * * if not slice_is_contig(src, order, ndim): */ __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); if (__pyx_t_2) { /* "View.MemoryView":1306 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< * order = get_best_order(&dst, ndim) * */ __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1307 * * if not slice_is_contig(src, order, ndim): * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); /* "View.MemoryView":1306 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< * order = get_best_order(&dst, ndim) * */ } /* "View.MemoryView":1309 * order = get_best_order(&dst, ndim) * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< * src = tmp * */ __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; /* "View.MemoryView":1310 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< * * if not broadcasting: */ __pyx_v_src = __pyx_v_tmp; /* "View.MemoryView":1304 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< * * if not slice_is_contig(src, order, ndim): */ } /* "View.MemoryView":1312 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); if (__pyx_t_2) { /* "View.MemoryView":1315 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): */ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1316 * * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); /* "View.MemoryView":1315 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): */ goto __pyx_L12; } /* "View.MemoryView":1317 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'F', ndim) * */ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); if (__pyx_t_2) { /* "View.MemoryView":1318 * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< * * if direct_copy: */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); /* "View.MemoryView":1317 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< * direct_copy = slice_is_contig(dst, 'F', ndim) * */ } __pyx_L12:; /* "View.MemoryView":1320 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ __pyx_t_2 = (__pyx_v_direct_copy != 0); if (__pyx_t_2) { /* "View.MemoryView":1322 * if direct_copy: * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1323 * * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) */ (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); /* "View.MemoryView":1324 * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * free(tmpdata) * return 0 */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1325 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1326 * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * if order == 'F' == get_best_order(&dst, ndim): */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1320 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ } /* "View.MemoryView":1312 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1328 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< * * */ __pyx_t_2 = (__pyx_v_order == 'F'); if (__pyx_t_2) { __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); } __pyx_t_8 = (__pyx_t_2 != 0); if (__pyx_t_8) { /* "View.MemoryView":1331 * * * transpose_memslice(&src) # <<<<<<<<<<<<<< * transpose_memslice(&dst) * */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) /* "View.MemoryView":1332 * * transpose_memslice(&src) * transpose_memslice(&dst) # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) /* "View.MemoryView":1328 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< * * */ } /* "View.MemoryView":1334 * transpose_memslice(&dst) * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, True) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1335 * * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< * refcount_copying(&dst, dtype_is_object, ndim, True) * */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); /* "View.MemoryView":1336 * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * * free(tmpdata) */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1338 * refcount_copying(&dst, dtype_is_object, ndim, True) * * free(tmpdata) # <<<<<<<<<<<<<< * return 0 * */ free(__pyx_v_tmpdata); /* "View.MemoryView":1339 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_broadcast_leading') */ __pyx_r = 0; goto __pyx_L0; /* "View.MemoryView":1270 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< * __Pyx_memviewslice dst, * int src_ndim, int dst_ndim, */ /* function exit code */ __pyx_L1_error:; { #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } __pyx_r = -1; __pyx_L0:; return __pyx_r; } /* "View.MemoryView":1342 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) nogil: */ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { int __pyx_v_i; int __pyx_v_offset; int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; /* "View.MemoryView":1346 * int ndim_other) nogil: * cdef int i * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< * * for i in range(ndim - 1, -1, -1): */ __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); /* "View.MemoryView":1348 * cdef int offset = ndim_other - ndim * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] */ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; /* "View.MemoryView":1349 * * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] */ (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); /* "View.MemoryView":1350 * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * */ (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); /* "View.MemoryView":1351 * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< * * for i in range(offset): */ (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); } /* "View.MemoryView":1353 * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * * for i in range(offset): # <<<<<<<<<<<<<< * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] */ __pyx_t_1 = __pyx_v_offset; __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "View.MemoryView":1354 * * for i in range(offset): * mslice.shape[i] = 1 # <<<<<<<<<<<<<< * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 */ (__pyx_v_mslice->shape[__pyx_v_i]) = 1; /* "View.MemoryView":1355 * for i in range(offset): * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< * mslice.suboffsets[i] = -1 * */ (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); /* "View.MemoryView":1356 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< * * */ (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } /* "View.MemoryView":1342 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< * int ndim, * int ndim_other) nogil: */ /* function exit code */ } /* "View.MemoryView":1364 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< * int ndim, bint inc) nogil: * */ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { int __pyx_t_1; /* "View.MemoryView":1368 * * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, * dst.strides, ndim, inc) */ __pyx_t_1 = (__pyx_v_dtype_is_object != 0); if (__pyx_t_1) { /* "View.MemoryView":1369 * * if dtype_is_object: * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< * dst.strides, ndim, inc) * */ __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); /* "View.MemoryView":1368 * * * if dtype_is_object: # <<<<<<<<<<<<<< * refcount_objects_in_slice_with_gil(dst.data, dst.shape, * dst.strides, ndim, inc) */ } /* "View.MemoryView":1364 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< * int ndim, bint inc) nogil: * */ /* function exit code */ } /* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * bint inc) with gil: */ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { __Pyx_RefNannyDeclarations #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); /* "View.MemoryView":1376 * Py_ssize_t *strides, int ndim, * bint inc) with gil: * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_refcount_objects_in_slice') */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); /* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * bint inc) with gil: */ /* function exit code */ __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD __Pyx_PyGILState_Release(__pyx_gilstate_save); #endif } /* "View.MemoryView":1379 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, bint inc): * cdef Py_ssize_t i */ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); /* "View.MemoryView":1383 * cdef Py_ssize_t i * * for i in range(shape[0]): # <<<<<<<<<<<<<< * if ndim == 1: * if inc: */ __pyx_t_1 = (__pyx_v_shape[0]); __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "View.MemoryView":1384 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_4) { /* "View.MemoryView":1385 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ __pyx_t_4 = (__pyx_v_inc != 0); if (__pyx_t_4) { /* "View.MemoryView":1386 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< * else: * Py_DECREF(( data)[0]) */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); /* "View.MemoryView":1385 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< * Py_INCREF(( data)[0]) * else: */ goto __pyx_L6; } /* "View.MemoryView":1388 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, */ /*else*/ { Py_DECREF((((PyObject **)__pyx_v_data)[0])); } __pyx_L6:; /* "View.MemoryView":1384 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< * if inc: * Py_INCREF(( data)[0]) */ goto __pyx_L5; } /* "View.MemoryView":1390 * Py_DECREF(( data)[0]) * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< * ndim - 1, inc) * */ /*else*/ { /* "View.MemoryView":1391 * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, * ndim - 1, inc) # <<<<<<<<<<<<<< * * data += strides[0] */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); } __pyx_L5:; /* "View.MemoryView":1393 * ndim - 1, inc) * * data += strides[0] # <<<<<<<<<<<<<< * * */ __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); } /* "View.MemoryView":1379 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, bint inc): * cdef Py_ssize_t i */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "View.MemoryView":1399 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< * size_t itemsize, void *item, * bint dtype_is_object) nogil: */ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { /* "View.MemoryView":1402 * size_t itemsize, void *item, * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); /* "View.MemoryView":1403 * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) */ __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); /* "View.MemoryView":1405 * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< * * */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); /* "View.MemoryView":1399 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< * size_t itemsize, void *item, * bint dtype_is_object) nogil: */ /* function exit code */ } /* "View.MemoryView":1409 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * size_t itemsize, void *item) nogil: */ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { CYTHON_UNUSED Py_ssize_t __pyx_v_i; Py_ssize_t __pyx_v_stride; Py_ssize_t __pyx_v_extent; int __pyx_t_1; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; /* "View.MemoryView":1413 * size_t itemsize, void *item) nogil: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< * cdef Py_ssize_t extent = shape[0] * */ __pyx_v_stride = (__pyx_v_strides[0]); /* "View.MemoryView":1414 * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< * * if ndim == 1: */ __pyx_v_extent = (__pyx_v_shape[0]); /* "View.MemoryView":1416 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< * for i in range(extent): * memcpy(data, item, itemsize) */ __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { /* "View.MemoryView":1417 * * if ndim == 1: * for i in range(extent): # <<<<<<<<<<<<<< * memcpy(data, item, itemsize) * data += stride */ __pyx_t_2 = __pyx_v_extent; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1418 * if ndim == 1: * for i in range(extent): * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< * data += stride * else: */ (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); /* "View.MemoryView":1419 * for i in range(extent): * memcpy(data, item, itemsize) * data += stride # <<<<<<<<<<<<<< * else: * for i in range(extent): */ __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } /* "View.MemoryView":1416 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< * for i in range(extent): * memcpy(data, item, itemsize) */ goto __pyx_L3; } /* "View.MemoryView":1421 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) */ /*else*/ { __pyx_t_2 = __pyx_v_extent; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "View.MemoryView":1422 * else: * for i in range(extent): * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< * ndim - 1, itemsize, item) * data += stride */ __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); /* "View.MemoryView":1424 * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) * data += stride # <<<<<<<<<<<<<< * * */ __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } } __pyx_L3:; /* "View.MemoryView":1409 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< * Py_ssize_t *strides, int ndim, * size_t itemsize, void *item) nogil: */ /* function exit code */ } /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__23, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) * __pyx_result = Enum.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[1]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->name); __Pyx_DECREF(__pyx_v___pyx_result->name); __pyx_v___pyx_result->name = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[1]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_3 > 1) != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[1]) */ } /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_array __pyx_vtable_array; static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_array_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_array_obj *)o); p->__pyx_vtab = __pyx_vtabptr_array; p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_array(PyObject *o) { struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_array___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->mode); Py_CLEAR(p->_format); (*Py_TYPE(o)->tp_free)(o); } static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_array___setitem__(o, i, v); } else { PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); return -1; } } static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); v = __pyx_array___getattr__(o, n); } return v; } static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); } static PyMethodDef __pyx_methods_array[] = { {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_array[] = { {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_array = { __pyx_array___len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_array, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_array = { __pyx_array___len__, /*mp_length*/ __pyx_array___getitem__, /*mp_subscript*/ __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ }; static PyBufferProcs __pyx_tp_as_buffer_array = { #if PY_MAJOR_VERSION < 3 0, /*bf_getreadbuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getwritebuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getsegcount*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getcharbuffer*/ #endif __pyx_array_getbuffer, /*bf_getbuffer*/ 0, /*bf_releasebuffer*/ }; static PyTypeObject __pyx_type___pyx_array = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.ordination._cutils.array", /*tp_name*/ sizeof(struct __pyx_array_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_array, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ __pyx_tp_getattro_array, /*tp_getattro*/ 0, /*tp_setattro*/ &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_array, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_array, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_array, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_MemviewEnum_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_MemviewEnum_obj *)o); p->name = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_Enum(PyObject *o) { struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->name); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { int e; struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; if (p->name) { e = (*v)(p->name, a); if (e) return e; } return 0; } static int __pyx_tp_clear_Enum(PyObject *o) { PyObject* tmp; struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; tmp = ((PyObject*)p->name); p->name = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_Enum[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type___pyx_MemviewEnum = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.ordination._cutils.Enum", /*tp_name*/ sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_Enum, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_MemviewEnum___repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_Enum, /*tp_traverse*/ __pyx_tp_clear_Enum, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_Enum, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_MemviewEnum___init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_Enum, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_memoryview_obj *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_memoryview_obj *)o); p->__pyx_vtab = __pyx_vtabptr_memoryview; p->obj = Py_None; Py_INCREF(Py_None); p->_size = Py_None; Py_INCREF(Py_None); p->_array_interface = Py_None; Py_INCREF(Py_None); p->view.obj = NULL; if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_memoryview(PyObject *o) { struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_memoryview___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->obj); Py_CLEAR(p->_size); Py_CLEAR(p->_array_interface); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { int e; struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; if (p->obj) { e = (*v)(p->obj, a); if (e) return e; } if (p->_size) { e = (*v)(p->_size, a); if (e) return e; } if (p->_array_interface) { e = (*v)(p->_array_interface, a); if (e) return e; } if (p->view.obj) { e = (*v)(p->view.obj, a); if (e) return e; } return 0; } static int __pyx_tp_clear_memoryview(PyObject *o) { PyObject* tmp; struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; tmp = ((PyObject*)p->obj); p->obj = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_size); p->_size = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->_array_interface); p->_array_interface = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); Py_CLEAR(p->view.obj); return 0; } static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { if (v) { return __pyx_memoryview___setitem__(o, i, v); } else { PyErr_Format(PyExc_NotImplementedError, "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); return -1; } } static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); } static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); } static PyMethodDef __pyx_methods_memoryview[] = { {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_memoryview[] = { {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_memoryview = { __pyx_memoryview___len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_memoryview, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_memoryview = { __pyx_memoryview___len__, /*mp_length*/ __pyx_memoryview___getitem__, /*mp_subscript*/ __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ }; static PyBufferProcs __pyx_tp_as_buffer_memoryview = { #if PY_MAJOR_VERSION < 3 0, /*bf_getreadbuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getwritebuffer*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getsegcount*/ #endif #if PY_MAJOR_VERSION < 3 0, /*bf_getcharbuffer*/ #endif __pyx_memoryview_getbuffer, /*bf_getbuffer*/ 0, /*bf_releasebuffer*/ }; static PyTypeObject __pyx_type___pyx_memoryview = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.ordination._cutils.memoryview", /*tp_name*/ sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif __pyx_memoryview___repr__, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_memoryview___str__, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_memoryview, /*tp_traverse*/ __pyx_tp_clear_memoryview, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_memoryview, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_memoryview, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_memoryview, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_memoryviewslice_obj *p; PyObject *o = __pyx_tp_new_memoryview(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_memoryviewslice_obj *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; p->from_object = Py_None; Py_INCREF(Py_None); p->from_slice.memview = NULL; return o; } static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); __pyx_memoryviewslice___dealloc__(o); __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->from_object); PyObject_GC_Track(o); __pyx_tp_dealloc_memoryview(o); } static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { int e; struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; if (p->from_object) { e = (*v)(p->from_object, a); if (e) return e; } return 0; } static int __pyx_tp_clear__memoryviewslice(PyObject *o) { PyObject* tmp; struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; __pyx_tp_clear_memoryview(o); tmp = ((PyObject*)p->from_object); p->from_object = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); __PYX_XDEC_MEMVIEW(&p->from_slice, 1); return 0; } static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); } static PyMethodDef __pyx_methods__memoryviewslice[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type___pyx_memoryviewslice = { PyVarObject_HEAD_INIT(0, 0) "skbio.stats.ordination._cutils._memoryviewslice", /*tp_name*/ sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_memoryview___repr__, /*tp_repr*/ #else 0, /*tp_repr*/ #endif 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ #if CYTHON_COMPILING_IN_PYPY __pyx_memoryview___str__, /*tp_str*/ #else 0, /*tp_str*/ #endif 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "Internal class for passing memoryview slices to Python", /*tp_doc*/ __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ __pyx_tp_clear__memoryviewslice, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods__memoryviewslice, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets__memoryviewslice, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new__memoryviewslice, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec__cutils(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec__cutils}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "_cutils", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, {&__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_k_Expected_at_least_d_argument_s_g, sizeof(__pyx_k_Expected_at_least_d_argument_s_g), 0, 0, 1, 0}, {&__pyx_kp_s_Function_call_with_ambiguous_arg, __pyx_k_Function_call_with_ambiguous_arg, sizeof(__pyx_k_Function_call_with_ambiguous_arg), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, {&__pyx_kp_s_No_matching_signature_found, __pyx_k_No_matching_signature_found, sizeof(__pyx_k_No_matching_signature_found), 0, 0, 1, 0}, {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, {&__pyx_n_s_center_distance_matrix_cy, __pyx_k_center_distance_matrix_cy, sizeof(__pyx_k_center_distance_matrix_cy), 0, 0, 1, 1}, {&__pyx_n_s_centered, __pyx_k_centered, sizeof(__pyx_k_centered), 0, 0, 1, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1}, {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, {&__pyx_n_s_d2, __pyx_k_d2, sizeof(__pyx_k_d2), 0, 0, 1, 1}, {&__pyx_n_s_d3, __pyx_k_d3, sizeof(__pyx_k_d3), 0, 0, 1, 1}, {&__pyx_n_s_d4, __pyx_k_d4, sizeof(__pyx_k_d4), 0, 0, 1, 1}, {&__pyx_n_s_d5, __pyx_k_d5, sizeof(__pyx_k_d5), 0, 0, 1, 1}, {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, {&__pyx_n_s_dtype_real, __pyx_k_dtype_real, sizeof(__pyx_k_dtype_real), 0, 0, 1, 1}, {&__pyx_n_s_e_matrix_means_cy, __pyx_k_e_matrix_means_cy, sizeof(__pyx_k_e_matrix_means_cy), 0, 0, 1, 1}, {&__pyx_n_s_el0, __pyx_k_el0, sizeof(__pyx_k_el0), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_f_matrix_inplace_cy, __pyx_k_f_matrix_inplace_cy, sizeof(__pyx_k_f_matrix_inplace_cy), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, {&__pyx_n_s_float32, __pyx_k_float32, sizeof(__pyx_k_float32), 0, 0, 1, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_global_mean, __pyx_k_global_mean, sizeof(__pyx_k_global_mean), 0, 0, 1, 1}, {&__pyx_n_s_global_sum, __pyx_k_global_sum, sizeof(__pyx_k_global_sum), 0, 0, 1, 1}, {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, {&__pyx_n_s_gr_mean, __pyx_k_gr_mean, sizeof(__pyx_k_gr_mean), 0, 0, 1, 1}, {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, {&__pyx_n_s_kind, __pyx_k_kind, sizeof(__pyx_k_kind), 0, 0, 1, 1}, {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mat, __pyx_k_mat, sizeof(__pyx_k_mat), 0, 0, 1, 1}, {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, {&__pyx_n_s_n_samples, __pyx_k_n_samples, sizeof(__pyx_k_n_samples), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, {&__pyx_n_s_row_means, __pyx_k_row_means, sizeof(__pyx_k_row_means), 0, 0, 1, 1}, {&__pyx_n_s_row_means_np, __pyx_k_row_means_np, sizeof(__pyx_k_row_means_np), 0, 0, 1, 1}, {&__pyx_n_s_row_sum, __pyx_k_row_sum, sizeof(__pyx_k_row_sum), 0, 0, 1, 1}, {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, {&__pyx_n_s_signatures, __pyx_k_signatures, sizeof(__pyx_k_signatures), 0, 0, 1, 1}, {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, {&__pyx_n_s_skbio_stats_ordination__cutils, __pyx_k_skbio_stats_ordination__cutils, sizeof(__pyx_k_skbio_stats_ordination__cutils), 0, 0, 1, 1}, {&__pyx_kp_s_skbio_stats_ordination__cutils_p, __pyx_k_skbio_stats_ordination__cutils_p, sizeof(__pyx_k_skbio_stats_ordination__cutils_p), 0, 0, 1, 0}, {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1}, {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, {&__pyx_n_s_tcol, __pyx_k_tcol, sizeof(__pyx_k_tcol), 0, 0, 1, 1}, {&__pyx_n_s_tcol_max, __pyx_k_tcol_max, sizeof(__pyx_k_tcol_max), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_trow, __pyx_k_trow, sizeof(__pyx_k_trow), 0, 0, 1, 1}, {&__pyx_n_s_trow_max, __pyx_k_trow_max, sizeof(__pyx_k_trow_max), 0, 0, 1, 1}, {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_No_matching_signature_found); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_Function_call_with_ambiguous_arg); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "View.MemoryView":134 * * if not self.ndim: * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< * * if itemsize <= 0: */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "View.MemoryView":137 * * if itemsize <= 0: * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< * * if not isinstance(format, bytes): */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "View.MemoryView":149 * * if not self._shape: * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< * * */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "View.MemoryView":177 * self.data = malloc(self.len) * if not self.data: * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< * * if self.dtype_is_object: */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "View.MemoryView":193 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< * info.buf = self.data * info.len = self.len */ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "View.MemoryView":420 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "View.MemoryView":497 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "View.MemoryView":522 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "View.MemoryView":572 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "View.MemoryView":579 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __pyx_tuple__16 = PyTuple_New(1); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); PyTuple_SET_ITEM(__pyx_tuple__16, 0, __pyx_int_neg_1); __Pyx_GIVEREF(__pyx_tuple__16); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "View.MemoryView":684 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ __pyx_slice__19 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__19)) __PYX_ERR(1, 684, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__19); __Pyx_GIVEREF(__pyx_slice__19); /* "View.MemoryView":705 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); __pyx_tuple__23 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ __pyx_tuple__24 = PyTuple_Pack(14, __pyx_n_s_mat, __pyx_n_s_centered, __pyx_n_s_row_means, __pyx_n_s_n_samples, __pyx_n_s_d2, __pyx_n_s_d3, __pyx_n_s_d4, __pyx_n_s_d5, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_row_sum, __pyx_n_s_el0, __pyx_n_s_global_sum, __pyx_n_s_global_mean); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(3, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_ordination__cutils_p, __pyx_n_s_e_matrix_means_cy, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 19, __pyx_L1_error) /* "skbio/stats/ordination/_cutils.pyx":77 * @cython.boundscheck(False) * @cython.wraparound(False) * def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Compute F matrix from E matrix inplace. */ __pyx_tuple__26 = PyTuple_Pack(13, __pyx_n_s_row_means, __pyx_n_s_global_mean, __pyx_n_s_centered, __pyx_n_s_n_samples, __pyx_n_s_d2, __pyx_n_s_d3, __pyx_n_s_trow, __pyx_n_s_tcol, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_trow_max, __pyx_n_s_tcol_max, __pyx_n_s_gr_mean); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_ordination__cutils_p, __pyx_n_s_f_matrix_inplace_cy, 77, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 77, __pyx_L1_error) /* "skbio/stats/ordination/_cutils.pyx":123 * @cython.boundscheck(False) * @cython.wraparound(False) * def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Centers a distance matrix. */ __pyx_tuple__28 = PyTuple_Pack(10, __pyx_n_s_mat, __pyx_n_s_centered, __pyx_n_s_n_samples, __pyx_n_s_d2, __pyx_n_s_d3, __pyx_n_s_d4, __pyx_n_s_global_mean, __pyx_n_s_dtype_real, __pyx_n_s_row_means_np, __pyx_n_s_row_means); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_skbio_stats_ordination__cutils_p, __pyx_n_s_center_distance_matrix_cy, 123, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 123, __pyx_L1_error) /* "View.MemoryView":287 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "View.MemoryView":288 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "View.MemoryView":289 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(1, 289, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "View.MemoryView":292 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(1, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "View.MemoryView":293 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__35 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { /* InitThreads.init */ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 PyEval_InitThreads(); #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ generic = Py_None; Py_INCREF(Py_None); strided = Py_None; Py_INCREF(Py_None); indirect = Py_None; Py_INCREF(Py_None); contiguous = Py_None; Py_INCREF(Py_None); indirect_contiguous = Py_None; Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_array = &__pyx_vtable_array; __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_array.tp_print = 0; #endif if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) __pyx_array_type = &__pyx_type___pyx_array; if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_MemviewEnum.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_memoryview.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) __pyx_memoryview_type = &__pyx_type___pyx_memoryview; __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_memoryviewslice.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC init_cutils(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC init_cutils(void) #else __Pyx_PyMODINIT_FUNC PyInit__cutils(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit__cutils(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__cutils(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; static PyThread_type_lock __pyx_t_3[8]; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_cutils' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit__cutils(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("_cutils", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_skbio__stats__ordination___cutils) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "skbio.stats.ordination._cutils")) { if (unlikely(PyDict_SetItemString(modules, "skbio.stats.ordination._cutils", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "skbio/stats/ordination/_cutils.pyx":8 * # The full license is in the file LICENSE.txt, distributed with this software. * # ----------------------------------------------------------------------------- * import numpy as np # <<<<<<<<<<<<<< * cimport cython * from cython.parallel import prange */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/ordination/_cutils.pyx":19 * @cython.boundscheck(False) * @cython.wraparound(False) * def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): # <<<<<<<<<<<<<< * """ * Compute E matrix from a distance matrix, and */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_7e_matrix_means_cy, 0, __pyx_n_s_e_matrix_means_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_9e_matrix_means_cy, 0, __pyx_n_s_e_matrix_means_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_10ordination_7_cutils_1e_matrix_means_cy, 0, __pyx_n_s_e_matrix_means_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_e_matrix_means_cy, __pyx_t_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/stats/ordination/_cutils.pyx":77 * @cython.boundscheck(False) * @cython.wraparound(False) * def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Compute F matrix from E matrix inplace. */ __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_13f_matrix_inplace_cy, 0, __pyx_n_s_f_matrix_inplace_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_float, __pyx_t_1) < 0) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_15f_matrix_inplace_cy, 0, __pyx_n_s_f_matrix_inplace_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_double, __pyx_t_1) < 0) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_10ordination_7_cutils_3f_matrix_inplace_cy, 0, __pyx_n_s_f_matrix_inplace_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_1)->__signatures__ = __pyx_t_2; __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_f_matrix_inplace_cy, __pyx_t_1) < 0) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "skbio/stats/ordination/_cutils.pyx":123 * @cython.boundscheck(False) * @cython.wraparound(False) * def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): # <<<<<<<<<<<<<< * """ * Centers a distance matrix. */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_0__pyx_mdef_5skbio_5stats_10ordination_7_cutils_19center_distance_matrix_cy, 0, __pyx_n_s_center_distance_matrix_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_fuse_1__pyx_mdef_5skbio_5stats_10ordination_7_cutils_21center_distance_matrix_cy, 0, __pyx_n_s_center_distance_matrix_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_FusedFunction_New(&__pyx_mdef_5skbio_5stats_10ordination_7_cutils_5center_distance_matrix_cy, 0, __pyx_n_s_center_distance_matrix_cy, NULL, __pyx_n_s_skbio_stats_ordination__cutils, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple); ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_center_distance_matrix_cy, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "skbio/stats/ordination/_cutils.pyx":1 * # ----------------------------------------------------------------------------- # <<<<<<<<<<<<<< * # Copyright (c) 2013--, scikit-bio development team. * # */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":210 * info.obj = self * * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * def __dealloc__(array self): */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_array_type); /* "View.MemoryView":287 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":288 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":289 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":292 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":293 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "View.MemoryView":317 * * DEF THREAD_LOCKS_PREALLOCATED = 8 * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ * PyThread_allocate_lock(), */ __pyx_memoryview_thread_locks_used = 0; /* "View.MemoryView":318 * DEF THREAD_LOCKS_PREALLOCATED = 8 * cdef int __pyx_memoryview_thread_locks_used = 0 * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< * PyThread_allocate_lock(), * PyThread_allocate_lock(), */ __pyx_t_3[0] = PyThread_allocate_lock(); __pyx_t_3[1] = PyThread_allocate_lock(); __pyx_t_3[2] = PyThread_allocate_lock(); __pyx_t_3[3] = PyThread_allocate_lock(); __pyx_t_3[4] = PyThread_allocate_lock(); __pyx_t_3[5] = PyThread_allocate_lock(); __pyx_t_3[6] = PyThread_allocate_lock(); __pyx_t_3[7] = PyThread_allocate_lock(); memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); /* "View.MemoryView":551 * info.obj = self * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 551, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_memoryview_type); /* "View.MemoryView":997 * return self.from_object * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 997, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_memoryviewslice_type); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":11 * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.name = __pyx_state[0] * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init skbio.stats.ordination._cutils", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init skbio.stats.ordination._cutils"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* UnicodeAsUCS4 */ static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) { Py_ssize_t length; #if CYTHON_PEP393_ENABLED length = PyUnicode_GET_LENGTH(x); if (likely(length == 1)) { return PyUnicode_READ_CHAR(x, 0); } #else length = PyUnicode_GET_SIZE(x); if (likely(length == 1)) { return PyUnicode_AS_UNICODE(x)[0]; } #if Py_UNICODE_SIZE == 2 else if (PyUnicode_GET_SIZE(x) == 2) { Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; if (high_val >= 0xD800 && high_val <= 0xDBFF) { Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; if (low_val >= 0xDC00 && low_val <= 0xDFFF) { return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); } } } #endif #endif PyErr_Format(PyExc_ValueError, "only single character unicode strings can be converted to Py_UCS4, " "got length %" CYTHON_FORMAT_SSIZE_T "d", length); return (Py_UCS4)-1; } /* object_ord */ static long __Pyx__PyObject_Ord(PyObject* c) { Py_ssize_t size; if (PyBytes_Check(c)) { size = PyBytes_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyBytes_AS_STRING(c)[0]; } #if PY_MAJOR_VERSION < 3 } else if (PyUnicode_Check(c)) { return (long)__Pyx_PyUnicode_AsPy_UCS4(c); #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) } else if (PyByteArray_Check(c)) { size = PyByteArray_GET_SIZE(c); if (likely(size == 1)) { return (unsigned char) PyByteArray_AS_STRING(c)[0]; } #endif } else { PyErr_Format(PyExc_TypeError, "ord() expected string of length 1, but %.200s found", Py_TYPE(c)->tp_name); return (long)(Py_UCS4)-1; } PyErr_Format(PyExc_TypeError, "ord() expected a character, but string of length %zd found", size); return (long)(Py_UCS4)-1; } /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (!j) return -1; r = PyObject_SetItem(o, j, v); Py_DECREF(j); return r; } static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { PyObject* old = PyList_GET_ITEM(o, n); Py_INCREF(v); PyList_SET_ITEM(o, n, v); Py_DECREF(old); return 1; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_ass_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return -1; PyErr_Clear(); } } return m->sq_ass_item(o, i, v); } } #else #if CYTHON_COMPILING_IN_PYPY if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) #else if (is_list || PySequence_Check(o)) #endif { return PySequence_SetItem(o, i, v); } #endif return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* MemviewSliceInit */ static int __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, int ndim, __Pyx_memviewslice *memviewslice, int memview_is_new_reference) { __Pyx_RefNannyDeclarations int i, retval=-1; Py_buffer *buf = &memview->view; __Pyx_RefNannySetupContext("init_memviewslice", 0); if (unlikely(memviewslice->memview || memviewslice->data)) { PyErr_SetString(PyExc_ValueError, "memviewslice is already initialized!"); goto fail; } if (buf->strides) { for (i = 0; i < ndim; i++) { memviewslice->strides[i] = buf->strides[i]; } } else { Py_ssize_t stride = buf->itemsize; for (i = ndim - 1; i >= 0; i--) { memviewslice->strides[i] = stride; stride *= buf->shape[i]; } } for (i = 0; i < ndim; i++) { memviewslice->shape[i] = buf->shape[i]; if (buf->suboffsets) { memviewslice->suboffsets[i] = buf->suboffsets[i]; } else { memviewslice->suboffsets[i] = -1; } } memviewslice->memview = memview; memviewslice->data = (char *)buf->buf; if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { Py_INCREF(memview); } retval = 0; goto no_fail; fail: memviewslice->memview = 0; memviewslice->data = 0; retval = -1; no_fail: __Pyx_RefNannyFinishContext(); return retval; } #ifndef Py_NO_RETURN #define Py_NO_RETURN #endif static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { va_list vargs; char msg[200]; #if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) va_start(vargs, fmt); #else va_start(vargs); #endif vsnprintf(msg, 200, fmt, vargs); va_end(vargs); Py_FatalError(msg); } static CYTHON_INLINE int __pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, PyThread_type_lock lock) { int result; PyThread_acquire_lock(lock, 1); result = (*acquisition_count)++; PyThread_release_lock(lock); return result; } static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, PyThread_type_lock lock) { int result; PyThread_acquire_lock(lock, 1); result = (*acquisition_count)--; PyThread_release_lock(lock); return result; } static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int first_time; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) return; if (unlikely(__pyx_get_slice_count(memview) < 0)) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); first_time = __pyx_add_acquisition_count(memview) == 0; if (unlikely(first_time)) { if (have_gil) { Py_INCREF((PyObject *) memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_INCREF((PyObject *) memview); PyGILState_Release(_gilstate); } } } static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int last_time; struct __pyx_memoryview_obj *memview = memslice->memview; if (unlikely(!memview || (PyObject *) memview == Py_None)) { memslice->memview = NULL; return; } if (unlikely(__pyx_get_slice_count(memview) <= 0)) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); last_time = __pyx_sub_acquisition_count(memview) == 1; memslice->data = NULL; if (unlikely(last_time)) { if (have_gil) { Py_CLEAR(memslice->memview); } else { PyGILState_STATE _gilstate = PyGILState_Ensure(); Py_CLEAR(memslice->memview); PyGILState_Release(_gilstate); } } else { memslice->memview = NULL; } } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* DivInt[Py_ssize_t] */ static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { Py_ssize_t q = a / b; Py_ssize_t r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); return q; } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; if (unlikely(!(m && m->sq_item))) { PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; } key_value = __Pyx_PyIndex_AsSsize_t(index); if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { PyErr_Clear(); PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); } return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; if (likely(m && m->mp_subscript)) { return m->mp_subscript(obj, key); } return __Pyx_PyObject_GetIndex(obj, key); } #endif /* decode_c_string */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { size_t slen = strlen(cstring); if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "c-string too long to convert to Python"); return NULL; } length = (Py_ssize_t) slen; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } if (unlikely(stop <= start)) return __Pyx_NewRef(__pyx_empty_unicode); length = stop - start; cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* None */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* DivInt[long] */ static CYTHON_INLINE long __Pyx_div_long(long a, long b) { long q = a / b; long r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); return q; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* FetchCommonType */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* CythonFunctionShared */ #include static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) { if (unlikely(op->func_doc == NULL)) { if (op->func.m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); #else op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp = op->func_doc; if (value == NULL) { value = Py_None; } Py_INCREF(value); op->func_doc = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_name == NULL)) { #if PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); #else op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = op->func_name; Py_INCREF(value); op->func_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->func_qualname; Py_INCREF(value); op->func_qualname = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) { PyObject *self; self = m->func_closure; if (self == NULL) self = Py_None; Py_INCREF(self); return self; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } tmp = op->func_dict; Py_INCREF(value); op->func_dict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyTuple_Check(value)) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } Py_INCREF(value); tmp = op->defaults_tuple; op->defaults_tuple = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } Py_INCREF(value); tmp = op->defaults_kwdict; op->defaults_kwdict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { PyObject* tmp; if (!value || value == Py_None) { value = NULL; } else if (!PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); tmp = op->func_annotations; op->func_annotations = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) { #if PY_MAJOR_VERSION >= 3 Py_INCREF(m->func_qualname); return m->func_qualname; #else return PyString_FromString(m->func.m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { if (unlikely(op == NULL)) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; op->func_classobj = NULL; op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); Py_CLEAR(m->func.m_module); Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); Py_CLEAR(m->func_classobj); Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyObject_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); Py_VISIT(m->func.m_module); Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); Py_VISIT(m->func_classobj); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { #if PY_MAJOR_VERSION < 3 __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); return func; } if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { if (type == NULL) type = (PyObject *)(Py_TYPE(obj)); return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); } if (obj == Py_None) obj = NULL; #endif return __Pyx_PyMethod_New(func, obj, type); } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; Py_ssize_t size; switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 0)) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { size = PyTuple_GET_SIZE(arg); if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "__Pyx_CyFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; argc = PyTuple_GET_SIZE(args); new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_CallAsMethod, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_CyFunction_descr_get, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, #endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (unlikely(__pyx_CyFunctionType == NULL)) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_Malloc(size); if (unlikely(!m->defaults)) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* FusedFunction */ static PyObject * __pyx_FusedFunction_New(PyMethodDef *ml, int flags, PyObject *qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject *code) { PyObject *op = __Pyx_CyFunction_Init( PyObject_GC_New(__pyx_CyFunctionObject, __pyx_FusedFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { __pyx_FusedFunctionObject *fusedfunc = (__pyx_FusedFunctionObject *) op; fusedfunc->__signatures__ = NULL; fusedfunc->type = NULL; fusedfunc->self = NULL; PyObject_GC_Track(op); } return op; } static void __pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self) { PyObject_GC_UnTrack(self); Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); __Pyx__CyFunction_dealloc((__pyx_CyFunctionObject *) self); } static int __pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self, visitproc visit, void *arg) { Py_VISIT(self->self); Py_VISIT(self->type); Py_VISIT(self->__signatures__); return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg); } static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self) { Py_CLEAR(self->self); Py_CLEAR(self->type); Py_CLEAR(self->__signatures__); return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self); } static PyObject * __pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type) { __pyx_FusedFunctionObject *func, *meth; func = (__pyx_FusedFunctionObject *) self; if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(self); return self; } if (obj == Py_None) obj = NULL; meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_New( ((PyCFunctionObject *) func)->m_ml, ((__pyx_CyFunctionObject *) func)->flags, ((__pyx_CyFunctionObject *) func)->func_qualname, ((__pyx_CyFunctionObject *) func)->func_closure, ((PyCFunctionObject *) func)->m_module, ((__pyx_CyFunctionObject *) func)->func_globals, ((__pyx_CyFunctionObject *) func)->func_code); if (!meth) return NULL; if (func->func.defaults) { PyObject **pydefaults; int i; if (!__Pyx_CyFunction_InitDefaults((PyObject*)meth, func->func.defaults_size, func->func.defaults_pyobjects)) { Py_XDECREF((PyObject*)meth); return NULL; } memcpy(meth->func.defaults, func->func.defaults, func->func.defaults_size); pydefaults = __Pyx_CyFunction_Defaults(PyObject *, meth); for (i = 0; i < meth->func.defaults_pyobjects; i++) Py_XINCREF(pydefaults[i]); } Py_XINCREF(func->func.func_classobj); meth->func.func_classobj = func->func.func_classobj; Py_XINCREF(func->__signatures__); meth->__signatures__ = func->__signatures__; Py_XINCREF(type); meth->type = type; Py_XINCREF(func->func.defaults_tuple); meth->func.defaults_tuple = func->func.defaults_tuple; if (func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD) obj = type; Py_XINCREF(obj); meth->self = obj; return (PyObject *) meth; } static PyObject * _obj_to_str(PyObject *obj) { if (PyType_Check(obj)) return PyObject_GetAttr(obj, __pyx_n_s_name_2); else return PyObject_Str(obj); } static PyObject * __pyx_FusedFunction_getitem(__pyx_FusedFunctionObject *self, PyObject *idx) { PyObject *signature = NULL; PyObject *unbound_result_func; PyObject *result_func = NULL; if (self->__signatures__ == NULL) { PyErr_SetString(PyExc_TypeError, "Function is not fused"); return NULL; } if (PyTuple_Check(idx)) { PyObject *list = PyList_New(0); Py_ssize_t n = PyTuple_GET_SIZE(idx); PyObject *sep = NULL; int i; if (unlikely(!list)) return NULL; for (i = 0; i < n; i++) { int ret; PyObject *string; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(idx, i); #else PyObject *item = PySequence_ITEM(idx, i); if (unlikely(!item)) goto __pyx_err; #endif string = _obj_to_str(item); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(item); #endif if (unlikely(!string)) goto __pyx_err; ret = PyList_Append(list, string); Py_DECREF(string); if (unlikely(ret < 0)) goto __pyx_err; } sep = PyUnicode_FromString("|"); if (likely(sep)) signature = PyUnicode_Join(sep, list); __pyx_err: ; Py_DECREF(list); Py_XDECREF(sep); } else { signature = _obj_to_str(idx); } if (!signature) return NULL; unbound_result_func = PyObject_GetItem(self->__signatures__, signature); if (unbound_result_func) { if (self->self || self->type) { __pyx_FusedFunctionObject *unbound = (__pyx_FusedFunctionObject *) unbound_result_func; Py_CLEAR(unbound->func.func_classobj); Py_XINCREF(self->func.func_classobj); unbound->func.func_classobj = self->func.func_classobj; result_func = __pyx_FusedFunction_descr_get(unbound_result_func, self->self, self->type); } else { result_func = unbound_result_func; Py_INCREF(result_func); } } Py_DECREF(signature); Py_XDECREF(unbound_result_func); return result_func; } static PyObject * __pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD && !((__pyx_FusedFunctionObject *) func)->__signatures__); if (cyfunc->flags & __Pyx_CYFUNCTION_CCLASS && !static_specialized) { return __Pyx_CyFunction_CallAsMethod(func, args, kw); } else { return __Pyx_CyFunction_Call(func, args, kw); } } static PyObject * __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw) { __pyx_FusedFunctionObject *binding_func = (__pyx_FusedFunctionObject *) func; Py_ssize_t argc = PyTuple_GET_SIZE(args); PyObject *new_args = NULL; __pyx_FusedFunctionObject *new_func = NULL; PyObject *result = NULL; PyObject *self = NULL; int is_staticmethod = binding_func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD; int is_classmethod = binding_func->func.flags & __Pyx_CYFUNCTION_CLASSMETHOD; if (binding_func->self) { Py_ssize_t i; new_args = PyTuple_New(argc + 1); if (!new_args) return NULL; self = binding_func->self; #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_INCREF(self); #endif Py_INCREF(self); PyTuple_SET_ITEM(new_args, 0, self); for (i = 0; i < argc; i++) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *item = PyTuple_GET_ITEM(args, i); Py_INCREF(item); #else PyObject *item = PySequence_ITEM(args, i); if (unlikely(!item)) goto bad; #endif PyTuple_SET_ITEM(new_args, i + 1, item); } args = new_args; } else if (binding_func->type) { if (argc < 1) { PyErr_SetString(PyExc_TypeError, "Need at least one argument, 0 given."); return NULL; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS self = PyTuple_GET_ITEM(args, 0); #else self = PySequence_ITEM(args, 0); if (unlikely(!self)) return NULL; #endif } if (self && !is_classmethod && !is_staticmethod) { int is_instance = PyObject_IsInstance(self, binding_func->type); if (unlikely(!is_instance)) { PyErr_Format(PyExc_TypeError, "First argument should be of type %.200s, got %.200s.", ((PyTypeObject *) binding_func->type)->tp_name, Py_TYPE(self)->tp_name); goto bad; } else if (unlikely(is_instance == -1)) { goto bad; } } #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); self = NULL; #endif if (binding_func->__signatures__) { PyObject *tup; if (is_staticmethod && binding_func->func.flags & __Pyx_CYFUNCTION_CCLASS) { tup = PyTuple_Pack(3, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __Pyx_CyFunction_CallMethod( func, binding_func->__signatures__, tup, NULL); } else { tup = PyTuple_Pack(4, binding_func->__signatures__, args, kw == NULL ? Py_None : kw, binding_func->func.defaults_tuple); if (unlikely(!tup)) goto bad; new_func = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_callfunction(func, tup, NULL); } Py_DECREF(tup); if (unlikely(!new_func)) goto bad; Py_XINCREF(binding_func->func.func_classobj); Py_CLEAR(new_func->func.func_classobj); new_func->func.func_classobj = binding_func->func.func_classobj; func = (PyObject *) new_func; } result = __pyx_FusedFunction_callfunction(func, args, kw); bad: #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_XDECREF(self); #endif Py_XDECREF(new_args); Py_XDECREF((PyObject *) new_func); return result; } static PyMemberDef __pyx_FusedFunction_members[] = { {(char *) "__signatures__", T_OBJECT, offsetof(__pyx_FusedFunctionObject, __signatures__), READONLY, 0}, {0, 0, 0, 0, 0}, }; static PyMappingMethods __pyx_FusedFunction_mapping_methods = { 0, (binaryfunc) __pyx_FusedFunction_getitem, 0, }; static PyTypeObject __pyx_FusedFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "fused_cython_function", sizeof(__pyx_FusedFunctionObject), 0, (destructor) __pyx_FusedFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif 0, 0, 0, &__pyx_FusedFunction_mapping_methods, 0, (ternaryfunc) __pyx_FusedFunction_call, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, 0, (traverseproc) __pyx_FusedFunction_traverse, (inquiry) __pyx_FusedFunction_clear, 0, 0, 0, 0, 0, __pyx_FusedFunction_members, __pyx_CyFunction_getsets, &__pyx_CyFunctionType_type, 0, __pyx_FusedFunction_descr_get, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, #endif }; static int __pyx_FusedFunction_init(void) { __pyx_FusedFunctionType_type.tp_base = __pyx_CyFunctionType; __pyx_FusedFunctionType = __Pyx_FetchCommonType(&__pyx_FusedFunctionType_type); if (__pyx_FusedFunctionType == NULL) { return -1; } return 0; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} view->obj = NULL; Py_DECREF(obj); } #endif /* MemviewSliceIsContig */ static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) { int i, index, step, start; Py_ssize_t itemsize = mvs.memview->view.itemsize; if (order == 'F') { step = 1; start = 0; } else { step = -1; start = ndim - 1; } for (i = 0; i < ndim; i++) { index = start + step * i; if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) return 0; itemsize *= mvs.shape[index]; } return 1; } /* OverlappingSlices */ static void __pyx_get_array_memory_extents(__Pyx_memviewslice *slice, void **out_start, void **out_end, int ndim, size_t itemsize) { char *start, *end; int i; start = end = slice->data; for (i = 0; i < ndim; i++) { Py_ssize_t stride = slice->strides[i]; Py_ssize_t extent = slice->shape[i]; if (extent == 0) { *out_start = *out_end = start; return; } else { if (stride > 0) end += stride * (extent - 1); else start += stride * (extent - 1); } } *out_start = start; *out_end = end + itemsize; } static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, __Pyx_memviewslice *slice2, int ndim, size_t itemsize) { void *start1, *end1, *start2, *end2; __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); return (start1 < end2) && (start2 < end1); } /* Capsule */ static CYTHON_INLINE PyObject * __pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) { PyObject *cobj; #if PY_VERSION_HEX >= 0x02070000 cobj = PyCapsule_New(p, sig, NULL); #else cobj = PyCObject_FromVoidPtr(p, NULL); #endif return cobj; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number, ndim; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* TypeInfoCompare */ static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) { int i; if (!a || !b) return 0; if (a == b) return 1; if (a->size != b->size || a->typegroup != b->typegroup || a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { if (a->typegroup == 'H' || b->typegroup == 'H') { return a->size == b->size; } else { return 0; } } if (a->ndim) { for (i = 0; i < a->ndim; i++) if (a->arraysize[i] != b->arraysize[i]) return 0; } if (a->typegroup == 'S') { if (a->flags != b->flags) return 0; if (a->fields || b->fields) { if (!(a->fields && b->fields)) return 0; for (i = 0; a->fields[i].type && b->fields[i].type; i++) { __Pyx_StructField *field_a = a->fields + i; __Pyx_StructField *field_b = b->fields + i; if (field_a->offset != field_b->offset || !__pyx_typeinfo_cmp(field_a->type, field_b->type)) return 0; } return !a->fields[i].type && !b->fields[i].type; } } return 1; } /* MemviewSliceValidateAndInit */ static int __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) { if (buf->shape[dim] <= 1) return 1; if (buf->strides) { if (spec & __Pyx_MEMVIEW_CONTIG) { if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { if (unlikely(buf->strides[dim] != sizeof(void *))) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly contiguous " "in dimension %d.", dim); goto fail; } } else if (unlikely(buf->strides[dim] != buf->itemsize)) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); goto fail; } } if (spec & __Pyx_MEMVIEW_FOLLOW) { Py_ssize_t stride = buf->strides[dim]; if (stride < 0) stride = -stride; if (unlikely(stride < buf->itemsize)) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); goto fail; } } } else { if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not contiguous in " "dimension %d", dim); goto fail; } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not indirect in " "dimension %d", dim); goto fail; } else if (unlikely(buf->suboffsets)) { PyErr_SetString(PyExc_ValueError, "Buffer exposes suboffsets but no strides"); goto fail; } } return 1; fail: return 0; } static int __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) { if (spec & __Pyx_MEMVIEW_DIRECT) { if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { PyErr_Format(PyExc_ValueError, "Buffer not compatible with direct access " "in dimension %d.", dim); goto fail; } } if (spec & __Pyx_MEMVIEW_PTR) { if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly accessible " "in dimension %d.", dim); goto fail; } } return 1; fail: return 0; } static int __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) { int i; if (c_or_f_flag & __Pyx_IS_F_CONTIG) { Py_ssize_t stride = 1; for (i = 0; i < ndim; i++) { if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { PyErr_SetString(PyExc_ValueError, "Buffer not fortran contiguous."); goto fail; } stride = stride * buf->shape[i]; } } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { Py_ssize_t stride = 1; for (i = ndim - 1; i >- 1; i--) { if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { PyErr_SetString(PyExc_ValueError, "Buffer not C contiguous."); goto fail; } stride = stride * buf->shape[i]; } } return 1; fail: return 0; } static int __Pyx_ValidateAndInit_memviewslice( int *axes_specs, int c_or_f_flag, int buf_flags, int ndim, __Pyx_TypeInfo *dtype, __Pyx_BufFmt_StackElem stack[], __Pyx_memviewslice *memviewslice, PyObject *original_obj) { struct __pyx_memoryview_obj *memview, *new_memview; __Pyx_RefNannyDeclarations Py_buffer *buf; int i, spec = 0, retval = -1; __Pyx_BufFmt_Context ctx; int from_memoryview = __pyx_memoryview_check(original_obj); __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) original_obj)->typeinfo)) { memview = (struct __pyx_memoryview_obj *) original_obj; new_memview = NULL; } else { memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( original_obj, buf_flags, 0, dtype); new_memview = memview; if (unlikely(!memview)) goto fail; } buf = &memview->view; if (unlikely(buf->ndim != ndim)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", ndim, buf->ndim); goto fail; } if (new_memview) { __Pyx_BufFmt_Init(&ctx, stack, dtype); if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; } if (unlikely((unsigned) buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->len > 0) { for (i = 0; i < ndim; i++) { spec = axes_specs[i]; if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) goto fail; if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) goto fail; } if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) goto fail; } if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, new_memview != NULL) == -1)) { goto fail; } retval = 0; goto no_fail; fail: Py_XDECREF(new_memview); retval = -1; no_fail: __Pyx_RefNannyFinishContext(); return retval; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_float(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2, &__Pyx_TypeInfo_float, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 2, &__Pyx_TypeInfo_double, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_float(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_float, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* ObjectToMemviewSlice */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(PyObject *obj, int writable_flag) { __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_BufFmt_StackElem stack[1]; int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; int retcode; if (obj == Py_None) { result.memview = (struct __pyx_memoryview_obj *) Py_None; return result; } retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, &__Pyx_TypeInfo_double, stack, &result, obj); if (unlikely(retcode == -1)) goto __pyx_fail; return result; __pyx_fail: result.memview = NULL; result.data = NULL; return result; } /* MemviewDtypeToObject */ static CYTHON_INLINE PyObject *__pyx_memview_get_float(const char *itemp) { return (PyObject *) PyFloat_FromDouble(*(float *) itemp); } static CYTHON_INLINE int __pyx_memview_set_float(const char *itemp, PyObject *obj) { float value = __pyx_PyFloat_AsFloat(obj); if ((value == (float)-1) && PyErr_Occurred()) return 0; *(float *) itemp = value; return 1; } /* MemviewDtypeToObject */ static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp) { return (PyObject *) PyFloat_FromDouble(*(double *) itemp); } static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj) { double value = __pyx_PyFloat_AsDouble(obj); if ((value == (double)-1) && PyErr_Occurred()) return 0; *(double *) itemp = value; return 1; } /* MemviewSliceCopyTemplate */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, const char *mode, int ndim, size_t sizeof_dtype, int contig_flag, int dtype_is_object) { __Pyx_RefNannyDeclarations int i; __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; struct __pyx_memoryview_obj *from_memview = from_mvs->memview; Py_buffer *buf = &from_memview->view; PyObject *shape_tuple = NULL; PyObject *temp_int = NULL; struct __pyx_array_obj *array_obj = NULL; struct __pyx_memoryview_obj *memview_obj = NULL; __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); for (i = 0; i < ndim; i++) { if (unlikely(from_mvs->suboffsets[i] >= 0)) { PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " "indirect dimensions (axis %d)", i); goto fail; } } shape_tuple = PyTuple_New(ndim); if (unlikely(!shape_tuple)) { goto fail; } __Pyx_GOTREF(shape_tuple); for(i = 0; i < ndim; i++) { temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); if(unlikely(!temp_int)) { goto fail; } else { PyTuple_SET_ITEM(shape_tuple, i, temp_int); temp_int = NULL; } } array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); if (unlikely(!array_obj)) { goto fail; } __Pyx_GOTREF(array_obj); memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( (PyObject *) array_obj, contig_flag, dtype_is_object, from_mvs->memview->typeinfo); if (unlikely(!memview_obj)) goto fail; if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) goto fail; if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, dtype_is_object) < 0)) goto fail; goto no_fail; fail: __Pyx_XDECREF(new_mvs.memview); new_mvs.memview = NULL; new_mvs.data = NULL; no_fail: __Pyx_XDECREF(shape_tuple); __Pyx_XDECREF(temp_int); __Pyx_XDECREF(array_obj); __Pyx_RefNannyFinishContext(); return new_mvs; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* BytesContains */ static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character) { const Py_ssize_t length = PyBytes_GET_SIZE(bytes); char* char_start = PyBytes_AS_STRING(bytes); return memchr(char_start, (unsigned char)character, (size_t)length) != NULL; } /* ImportNumPyArray */ static PyObject* __Pyx__ImportNumPyArray(void) { PyObject *numpy_module, *ndarray_object = NULL; numpy_module = __Pyx_Import(__pyx_n_s_numpy, NULL, 0); if (likely(numpy_module)) { ndarray_object = PyObject_GetAttrString(numpy_module, "ndarray"); Py_DECREF(numpy_module); } if (unlikely(!ndarray_object)) { PyErr_Clear(); } if (unlikely(!ndarray_object || !PyObject_TypeCheck(ndarray_object, &PyType_Type))) { Py_XDECREF(ndarray_object); Py_INCREF(Py_None); ndarray_object = Py_None; } return ndarray_object; } static CYTHON_INLINE PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void) { if (unlikely(!__pyx_numpy_ndarray)) { __pyx_numpy_ndarray = __Pyx__ImportNumPyArray(); } Py_INCREF(__pyx_numpy_ndarray); return __pyx_numpy_ndarray; } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const char neg_one = (char) -1, const_zero = (char) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(char) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (char) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (char) 0; case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) case 2: if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 3: if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 4: if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (char) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(char) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (char) 0; case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) case -2: if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 2: if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -3: if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 3: if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -4: if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 4: if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; } #endif if (sizeof(char) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else char val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (char) -1; } } else { char val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (char) -1; val = __Pyx_PyInt_As_char(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to char"); return (char) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to char"); return (char) -1; } /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[5]; int same=1, i, found_dot; const char* rt_from_call = Py_GetVersion(); PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); found_dot = 0; for (i = 0; i < 4; i++) { if (!ctversion[i]) { same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ scikit-bio-0.5.9/skbio/stats/ordination/_cutils.pyx000066400000000000000000000121021446255456000224100ustar00rootroot00000000000000# ----------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ----------------------------------------------------------------------------- import numpy as np cimport cython from cython.parallel import prange from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free ctypedef fused TReal: float double @cython.boundscheck(False) @cython.wraparound(False) def e_matrix_means_cy(TReal[:, ::1] mat, TReal[:, ::1] centered, TReal[::1] row_means): """ Compute E matrix from a distance matrix, and also compute the means in the process. Squares and divides by -2 the input elementwise. Eq. 9.20 in Legendre & Legendre 1998. Parameters ---------- mat : 2D array_like Distance matrix. centered : 2D array_like Output, E matrix. Must be pre-allocated and same shape as mat. Can point to mat (i.e. in-place) row_means : 1D_array_like Output, Mean values of each row in `centered` Returns ------- global_mean : real Global mean value """ cdef Py_ssize_t n_samples = mat.shape[0] cdef Py_ssize_t d2 = mat.shape[1] cdef Py_ssize_t d3 = centered.shape[1] cdef Py_ssize_t d4 = centered.shape[1] cdef Py_ssize_t d5 = row_means.shape[0] assert n_samples == d2 assert n_samples == d3 assert n_samples == d4 assert n_samples == d5 cdef Py_ssize_t row,col cdef long double row_sum cdef TReal el0 cdef long double global_sum = 0.0 for row in prange(n_samples, nogil=True): row_sum = 0.0 for col in range(n_samples): el0 = mat[row,col] el0 = -0.5*el0*el0 centered[row,col] = el0 # Note: do not use +=, so it is not flagged as a global reduction row_sum = row_sum + el0 global_sum += row_sum row_means[row] = row_sum/n_samples cdef TReal global_mean = (global_sum/n_samples)/n_samples return global_mean @cython.boundscheck(False) @cython.wraparound(False) def f_matrix_inplace_cy(TReal[::1] row_means, TReal global_mean, TReal[:, ::1] centered): """ Compute F matrix from E matrix inplace. Centering step: for each element, the mean of the corresponding row and column are subtracted, and the mean of the whole matrix is added. Eq. 9.21 in Legendre & Legendre 1998. Modified from :func:`skbio.stats.ordination.f_matrix_inplace` function, Parameters ---------- row_means : 1D_array_like Mean values of each row in `centered` global_mean : real Global mean value in `centered` centered : 2D array_like, must be symmetric In, a matrix representing the "E matrix" as described above. Out, the centered matrix """ cdef Py_ssize_t n_samples = centered.shape[0] cdef Py_ssize_t d2 = centered.shape[1] cdef Py_ssize_t d3 = row_means.shape[0] assert n_samples == d2 assert n_samples == d3 cdef Py_ssize_t trow,tcol,row,col cdef Py_ssize_t trow_max,tcol_max cdef TReal gr_mean # use a tiled pattern to maximize locality of row_means for trow in prange(0, n_samples, 24, nogil=True): trow_max = min(trow+24, n_samples) for tcol in range(0, n_samples, 24): tcol_max = min(tcol+24, n_samples) for row in range(trow, trow_max, 1): gr_mean = global_mean - row_means[row] for col in range(tcol, tcol_max, 1): # Note: do not use +=, so it is not flagged as a global reduction centered[row,col] = centered[row,col] + (gr_mean - row_means[col]) @cython.boundscheck(False) @cython.wraparound(False) def center_distance_matrix_cy(TReal[:, ::1] mat, TReal[:, ::1] centered): """ Centers a distance matrix. Note: If the used distance was euclidean, pairwise distances needn't be computed from the data table Y because F_matrix = Y.dot(Y.T) (if Y has been centered). But since we're expecting distance_matrix to be non-euclidian, we do the following computation as per Numerical Ecology (Legendre & Legendre 1998). Parameters ---------- mat : 2D array_like Distance matrix. centered : 2D array_like Output centered matrix. Must be pre-allocated and same shape as mat. Can point to mat (i.e. in-place) """ cdef Py_ssize_t n_samples = mat.shape[0] cdef Py_ssize_t d2 = mat.shape[1] cdef Py_ssize_t d3 = centered.shape[1] cdef Py_ssize_t d4 = centered.shape[1] assert n_samples == d2 assert n_samples == d3 assert n_samples == d4 cdef TReal global_mean if TReal is float: dtype_real = np.float32 else: dtype_real = np.float64 row_means_np = np.zeros((n_samples,), dtype=dtype_real) cdef TReal[::1] row_means = row_means_np global_mean = e_matrix_means_cy(mat, centered, row_means) f_matrix_inplace_cy(row_means, global_mean, centered) scikit-bio-0.5.9/skbio/stats/ordination/_ordination_results.py000066400000000000000000000410251446255456000246520ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import functools import numpy as np from IPython.core.pylabtools import print_figure from IPython.core.display import Image, SVG from skbio._base import SkbioObject from skbio.stats._misc import _pprint_strs from skbio.util._decorator import experimental class OrdinationResults(SkbioObject): """Store ordination results, providing serialization and plotting support. Stores various components of ordination results. Provides methods for serializing/deserializing results, as well as generation of basic matplotlib 3-D scatterplots. Will automatically display PNG/SVG representations of itself within the IPython Notebook. Attributes ---------- short_method_name : str Abbreviated ordination method name. long_method_name : str Ordination method name. eigvals : pd.Series The resulting eigenvalues. The index corresponds to the ordination axis labels samples : pd.DataFrame The position of the samples in the ordination space, row-indexed by the sample id. features : pd.DataFrame The position of the features in the ordination space, row-indexed by the feature id. biplot_scores : pd.DataFrame Correlation coefficients of the samples with respect to the features. sample_constraints : pd.DataFrame Site constraints (linear combinations of constraining variables): coordinates of the sites in the space of the explanatory variables X. These are the fitted site scores proportion_explained : pd.Series Proportion explained by each of the dimensions in the ordination space. The index corresponds to the ordination axis labels See Also -------- ca cca pcoa rda """ default_write_format = 'ordination' @experimental(as_of="0.4.0") def __init__(self, short_method_name, long_method_name, eigvals, samples, features=None, biplot_scores=None, sample_constraints=None, proportion_explained=None): self.short_method_name = short_method_name self.long_method_name = long_method_name self.eigvals = eigvals self.samples = samples self.features = features self.biplot_scores = biplot_scores self.sample_constraints = sample_constraints self.proportion_explained = proportion_explained @experimental(as_of="0.4.0") def __str__(self): """Return a string representation of the ordination results. String representation lists ordination results attributes and indicates whether or not they are present. If an attribute is present, its dimensions are listed. A truncated list of features and sample IDs are included (if they are present). Returns ------- str String representation of the ordination results. """ lines = ['Ordination results:'] method = '%s (%s)' % (self.long_method_name, self.short_method_name) lines.append(self._format_attribute(method, 'Method', str)) attrs = [(self.eigvals, 'Eigvals'), (self.proportion_explained, 'Proportion explained'), (self.features, 'Features'), (self.samples, 'Samples'), (self.biplot_scores, 'Biplot Scores'), (self.sample_constraints, 'Sample constraints')] for attr, attr_label in attrs: def formatter(e): return 'x'.join(['%d' % s for s in e.shape]) lines.append(self._format_attribute(attr, attr_label, formatter)) lines.append(self._format_attribute( self.features, 'Feature IDs', lambda e: _pprint_strs(e.index.tolist()))) lines.append(self._format_attribute( self.samples, 'Sample IDs', lambda e: _pprint_strs(e.index.tolist()))) return '\n'.join(lines) @experimental(as_of="0.4.0") def plot(self, df=None, column=None, axes=(0, 1, 2), axis_labels=None, title='', cmap=None, s=20): """Create a 3-D scatterplot of ordination results colored by metadata. Creates a 3-D scatterplot of the ordination results, where each point represents a sample. Optionally, these points can be colored by metadata (see `df` and `column` below). Parameters ---------- df : pd.DataFrame, optional ``DataFrame`` containing sample metadata. Must be indexed by sample ID, and all sample IDs in the ordination results must exist in the ``DataFrame``. If ``None``, samples (i.e., points) will not be colored by metadata. column : str, optional Column name in `df` to color samples (i.e., points in the plot) by. Cannot have missing data (i.e., ``np.nan``). `column` can be numeric or categorical. If numeric, all values in the column will be cast to ``float`` and mapped to colors using `cmap`. A colorbar will be included to serve as a legend. If categorical (i.e., not all values in `column` could be cast to ``float``), colors will be chosen for each category using evenly-spaced points along `cmap`. A legend will be included. If ``None``, samples (i.e., points) will not be colored by metadata. axes : iterable of int, optional Indices of sample coordinates to plot on the x-, y-, and z-axes. For example, if plotting PCoA results, ``axes=(0, 1, 2)`` will plot PC 1 on the x-axis, PC 2 on the y-axis, and PC 3 on the z-axis. Must contain exactly three elements. axis_labels : iterable of str, optional Labels for the x-, y-, and z-axes. If ``None``, labels will be the values of `axes` cast as strings. title : str, optional Plot title. cmap : str or matplotlib.colors.Colormap, optional Name or instance of matplotlib colormap to use for mapping `column` values to colors. If ``None``, defaults to the colormap specified in the matplotlib rc file. Qualitative colormaps (e.g., ``Set1``) are recommended for categorical data, while sequential colormaps (e.g., ``Greys``) are recommended for numeric data. See [1]_ for these colormap classifications. s : scalar or iterable of scalars, optional Size of points. See matplotlib's ``Axes3D.scatter`` documentation for more details. Returns ------- matplotlib.figure.Figure Figure containing the scatterplot and legend/colorbar if metadata were provided. Raises ------ ValueError Raised on invalid input, including the following situations: - there are not at least three dimensions to plot - there are not exactly three values in `axes`, they are not unique, or are out of range - there are not exactly three values in `axis_labels` - either `df` or `column` is provided without the other - `column` is not in the ``DataFrame`` - sample IDs in the ordination results are not in `df` or have missing data in `column` See Also -------- mpl_toolkits.mplot3d.Axes3D.scatter Notes ----- This method creates basic plots of ordination results, and is intended to provide a quick look at the results in the context of metadata (e.g., from within the IPython Notebook). For more customization and to generate publication-quality figures, we recommend EMPeror [2]_. References ---------- .. [1] http://matplotlib.org/examples/color/colormaps_reference.html .. [2] EMPeror: a tool for visualizing high-throughput microbial community data. Vazquez-Baeza Y, Pirrung M, Gonzalez A, Knight R. Gigascience. 2013 Nov 26;2(1):16. http://biocore.github.io/emperor/ Examples -------- .. plot:: Define a distance matrix with four samples labelled A-D: >>> from skbio import DistanceMatrix >>> dm = DistanceMatrix([[0., 0.21712454, 0.5007512, 0.91769271], ... [0.21712454, 0., 0.45995501, 0.80332382], ... [0.5007512, 0.45995501, 0., 0.65463348], ... [0.91769271, 0.80332382, 0.65463348, 0.]], ... ['A', 'B', 'C', 'D']) Define metadata for each sample in a ``pandas.DataFrame``: >>> import pandas as pd >>> metadata = { ... 'A': {'body_site': 'skin'}, ... 'B': {'body_site': 'gut'}, ... 'C': {'body_site': 'gut'}, ... 'D': {'body_site': 'skin'}} >>> df = pd.DataFrame.from_dict(metadata, orient='index') Run principal coordinate analysis (PCoA) on the distance matrix: >>> from skbio.stats.ordination import pcoa >>> pcoa_results = pcoa(dm) Plot the ordination results, where each sample is colored by body site (a categorical variable): >>> fig = pcoa_results.plot(df=df, column='body_site', ... title='Samples colored by body site', ... cmap='Set1', s=50) """ # Note: New features should not be added to this method and should # instead be added to EMPeror (http://biocore.github.io/emperor/). # Only bug fixes and minor updates should be made to this method. coord_matrix = self.samples.values.T self._validate_plot_axes(coord_matrix, axes) # derived from # http://matplotlib.org/examples/mplot3d/scatter3d_demo.html import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # noqa fig = plt.figure() ax = fig.add_subplot(111, projection='3d') xs = coord_matrix[axes[0]] ys = coord_matrix[axes[1]] zs = coord_matrix[axes[2]] point_colors, category_to_color = self._get_plot_point_colors( df, column, self.samples.index, cmap) scatter_fn = functools.partial(ax.scatter, xs, ys, zs, s=s) if point_colors is None: plot = scatter_fn() else: plot = scatter_fn(c=point_colors, cmap=cmap) if axis_labels is None: axis_labels = ['%d' % axis for axis in axes] elif len(axis_labels) != 3: raise ValueError("axis_labels must contain exactly three elements " "(found %d elements)." % len(axis_labels)) ax.set_xlabel(axis_labels[0]) ax.set_ylabel(axis_labels[1]) ax.set_zlabel(axis_labels[2]) ax.set_xticklabels([]) ax.set_yticklabels([]) ax.set_zticklabels([]) ax.set_title(title) # create legend/colorbar if point_colors is not None: if category_to_color is None: fig.colorbar(plot) else: self._plot_categorical_legend(ax, category_to_color) fig.tight_layout() return fig def _validate_plot_axes(self, coord_matrix, axes): """Validate `axes` against coordinates matrix.""" num_dims = coord_matrix.shape[0] if num_dims < 3: raise ValueError("At least three dimensions are required to plot " "ordination results. There are only %d " "dimension(s)." % num_dims) if len(axes) != 3: raise ValueError("`axes` must contain exactly three elements " "(found %d elements)." % len(axes)) if len(set(axes)) != 3: raise ValueError("The values provided for `axes` must be unique.") for idx, axis in enumerate(axes): if axis < 0 or axis >= num_dims: raise ValueError("`axes[%d]` must be >= 0 and < %d." % (idx, num_dims)) def _get_plot_point_colors(self, df, column, ids, cmap): """Return a list of colors for each plot point given a metadata column. If `column` is categorical, additionally returns a dictionary mapping each category (str) to color (used for legend creation). """ import matplotlib.pyplot as plt if ((df is None and column is not None) or (df is not None and column is None)): raise ValueError("Both df and column must be provided, or both " "must be None.") elif df is None and column is None: point_colors, category_to_color = None, None else: if column not in df: raise ValueError("Column '%s' not in data frame." % column) col_vals = df.reindex(ids, axis=0).loc[:, column] if col_vals.isnull().any(): raise ValueError("One or more IDs in the ordination results " "are not in the data frame, or there is " "missing data in the data frame's '%s' " "column." % column) category_to_color = None try: point_colors = col_vals.astype(float) except ValueError: # we have categorical data, so choose a color for each # category, where colors are evenly spaced across the # colormap. # derived from http://stackoverflow.com/a/14887119 categories = col_vals.unique() cmap = plt.get_cmap(cmap) category_colors = cmap(np.linspace(0, 1, len(categories))) category_to_color = dict(zip(categories, category_colors)) point_colors = col_vals.apply(lambda x: category_to_color[x]) point_colors = point_colors.tolist() return point_colors, category_to_color def _plot_categorical_legend(self, ax, color_dict): """Add legend to plot using specified mapping of category to color.""" # derived from http://stackoverflow.com/a/20505720 import matplotlib as mpl proxies = [] labels = [] for category in color_dict: proxy = mpl.lines.Line2D([0], [0], linestyle='none', c=color_dict[category], marker='o') proxies.append(proxy) labels.append(category) # place legend outside of the axes (centered) # derived from http://matplotlib.org/users/legend_guide.html ax.legend(proxies, labels, numpoints=1, loc=6, bbox_to_anchor=(1.05, 0.5), borderaxespad=0.) # Here we define the special repr methods that provide the IPython display # protocol. Code derived from: # https://github.com/ipython/ipython/blob/2.x/examples/Notebook/ # Custom%20Display%20Logic.ipynb # See licenses/ipython.txt for more details. def _repr_png_(self): return self._figure_data('png') def _repr_svg_(self): return self._figure_data('svg') # We expose the above reprs as properties, so that the user can see them # directly (since otherwise the client dictates which one it shows by # default) @property @experimental(as_of="0.4.0") def png(self): """Display basic 3-D scatterplot in IPython Notebook as PNG.""" return Image(self._repr_png_(), embed=True) @property @experimental(as_of="0.4.0") def svg(self): """Display basic 3-D scatterplot in IPython Notebook as SVG.""" return SVG(self._repr_svg_()) def _figure_data(self, format): import matplotlib.pyplot as plt fig = self.plot() data = print_figure(fig, format) # We MUST close the figure, otherwise IPython's display machinery # will pick it up and send it as output, resulting in a double display plt.close(fig) return data def _format_attribute(self, attr, attr_label, formatter): if attr is None: formatted_attr = 'N/A' else: formatted_attr = formatter(attr) return '\t%s: %s' % (attr_label, formatted_attr) scikit-bio-0.5.9/skbio/stats/ordination/_principal_coordinate_analysis.py000066400000000000000000000415451446255456000270250ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd from numpy import dot, hstack from numpy.linalg import qr, svd from numpy.random import standard_normal from scipy.linalg import eigh from warnings import warn from skbio.stats.distance import DistanceMatrix from skbio.util._decorator import experimental from ._ordination_results import OrdinationResults from ._utils import center_distance_matrix, scale @experimental(as_of="0.4.0") def pcoa(distance_matrix, method="eigh", number_of_dimensions=0, inplace=False): r"""Perform Principal Coordinate Analysis. Principal Coordinate Analysis (PCoA) is a method similar to Principal Components Analysis (PCA) with the difference that PCoA operates on distance matrices, typically with non-euclidian and thus ecologically meaningful distances like UniFrac in microbiome research. In ecology, the euclidean distance preserved by Principal Component Analysis (PCA) is often not a good choice because it deals poorly with double zeros (Species have unimodal distributions along environmental gradients, so if a species is absent from two sites at the same site, it can't be known if an environmental variable is too high in one of them and too low in the other, or too low in both, etc. On the other hand, if an species is present in two sites, that means that the sites are similar.). Note that the returned eigenvectors are not normalized to unit length. Parameters ---------- distance_matrix : DistanceMatrix A distance matrix. method : str, optional Eigendecomposition method to use in performing PCoA. By default, uses SciPy's `eigh`, which computes exact eigenvectors and eigenvalues for all dimensions. The alternate method, `fsvd`, uses faster heuristic eigendecomposition but loses accuracy. The magnitude of accuracy lost is dependent on dataset. number_of_dimensions : int, optional Dimensions to reduce the distance matrix to. This number determines how many eigenvectors and eigenvalues will be returned. By default, equal to the number of dimensions of the distance matrix, as default eigendecomposition using SciPy's `eigh` method computes all eigenvectors and eigenvalues. If using fast heuristic eigendecomposition through `fsvd`, a desired number of dimensions should be specified. Note that the default eigendecomposition method `eigh` does not natively support a specifying number of dimensions to reduce a matrix to, so if this parameter is specified, all eigenvectors and eigenvalues will be simply be computed with no speed gain, and only the number specified by `number_of_dimensions` will be returned. Specifying a value of `0`, the default, will set `number_of_dimensions` equal to the number of dimensions of the specified `distance_matrix`. inplace : bool, optional If true, centers a distance matrix in-place in a manner that reduces memory consumption. Returns ------- OrdinationResults Object that stores the PCoA results, including eigenvalues, the proportion explained by each of them, and transformed sample coordinates. See Also -------- OrdinationResults Notes ----- .. note:: If the distance is not euclidean (for example if it is a semimetric and the triangle inequality doesn't hold), negative eigenvalues can appear. There are different ways to deal with that problem (see Legendre & Legendre 1998, \S 9.2.3), but none are currently implemented here. However, a warning is raised whenever negative eigenvalues appear, allowing the user to decide if they can be safely ignored. """ distance_matrix = DistanceMatrix(distance_matrix) # Center distance matrix, a requirement for PCoA here matrix_data = center_distance_matrix(distance_matrix.data, inplace=inplace) # If no dimension specified, by default will compute all eigenvectors # and eigenvalues if number_of_dimensions == 0: if method == "fsvd" and matrix_data.shape[0] > 10: warn("FSVD: since no value for number_of_dimensions is specified, " "PCoA for all dimensions will be computed, which may " "result in long computation time if the original " "distance matrix is large.", RuntimeWarning) # distance_matrix is guaranteed to be square number_of_dimensions = matrix_data.shape[0] elif number_of_dimensions < 0: raise ValueError('Invalid operation: cannot reduce distance matrix ' 'to negative dimensions using PCoA. Did you intend ' 'to specify the default value "0", which sets ' 'the number_of_dimensions equal to the ' 'dimensionality of the given distance matrix?') # Perform eigendecomposition if method == "eigh": # eigh does not natively support specifying number_of_dimensions, i.e. # there are no speed gains unlike in FSVD. Later, we slice off unwanted # dimensions to conform the result of eigh to the specified # number_of_dimensions. eigvals, eigvecs = eigh(matrix_data) long_method_name = "Principal Coordinate Analysis" elif method == "fsvd": eigvals, eigvecs = _fsvd(matrix_data, number_of_dimensions) long_method_name = "Approximate Principal Coordinate Analysis " \ "using FSVD" else: raise ValueError( "PCoA eigendecomposition method {} not supported.".format(method)) # cogent makes eigenvalues positive by taking the # abs value, but that doesn't seem to be an approach accepted # by L&L to deal with negative eigenvalues. We raise a warning # in that case. First, we make values close to 0 equal to 0. negative_close_to_zero = np.isclose(eigvals, 0) eigvals[negative_close_to_zero] = 0 if np.any(eigvals < 0): warn( "The result contains negative eigenvalues." " Please compare their magnitude with the magnitude of some" " of the largest positive eigenvalues. If the negative ones" " are smaller, it's probably safe to ignore them, but if they" " are large in magnitude, the results won't be useful. See the" " Notes section for more details. The smallest eigenvalue is" " {0} and the largest is {1}.".format(eigvals.min(), eigvals.max()), RuntimeWarning ) # eigvals might not be ordered, so we first sort them, then analogously # sort the eigenvectors by the ordering of the eigenvalues too idxs_descending = eigvals.argsort()[::-1] eigvals = eigvals[idxs_descending] eigvecs = eigvecs[:, idxs_descending] # If we return only the coordinates that make sense (i.e., that have a # corresponding positive eigenvalue), then Jackknifed Beta Diversity # won't work as it expects all the OrdinationResults to have the same # number of coordinates. In order to solve this issue, we return the # coordinates that have a negative eigenvalue as 0 num_positive = (eigvals >= 0).sum() eigvecs[:, num_positive:] = np.zeros(eigvecs[:, num_positive:].shape) eigvals[num_positive:] = np.zeros(eigvals[num_positive:].shape) if method == "fsvd": # Since the dimension parameter, hereafter referred to as 'd', # restricts the number of eigenvalues and eigenvectors that FSVD # computes, we need to use an alternative method to compute the sum # of all eigenvalues, used to compute the array of proportions # explained. Otherwise, the proportions calculated will only be # relative to d number of dimensions computed; whereas we want # it to be relative to the entire dimensionality of the # centered distance matrix. # An alternative method of calculating th sum of eigenvalues is by # computing the trace of the centered distance matrix. # See proof outlined here: https://goo.gl/VAYiXx sum_eigenvalues = np.trace(matrix_data) else: # Calculate proportions the usual way sum_eigenvalues = np.sum(eigvals) proportion_explained = eigvals / sum_eigenvalues # In case eigh is used, eigh computes all eigenvectors and -values. # So if number_of_dimensions was specified, we manually need to ensure # only the requested number of dimensions # (number of eigenvectors and eigenvalues, respectively) are returned. eigvecs = eigvecs[:, :number_of_dimensions] eigvals = eigvals[:number_of_dimensions] proportion_explained = proportion_explained[:number_of_dimensions] # Scale eigenvalues to have length = sqrt(eigenvalue). This # works because np.linalg.eigh returns normalized # eigenvectors. Each row contains the coordinates of the # objects in the space of principal coordinates. Note that at # least one eigenvalue is zero because only n-1 axes are # needed to represent n points in a euclidean space. coordinates = eigvecs * np.sqrt(eigvals) axis_labels = ["PC%d" % i for i in range(1, number_of_dimensions + 1)] return OrdinationResults( short_method_name="PCoA", long_method_name=long_method_name, eigvals=pd.Series(eigvals, index=axis_labels), samples=pd.DataFrame(coordinates, index=distance_matrix.ids, columns=axis_labels), proportion_explained=pd.Series(proportion_explained, index=axis_labels)) def _fsvd(centered_distance_matrix, number_of_dimensions=10): """ Performs singular value decomposition, or more specifically in this case eigendecomposition, using fast heuristic algorithm nicknamed "FSVD" (FastSVD), adapted and optimized from the algorithm described by Halko et al (2011). Parameters ---------- centered_distance_matrix : np.array Numpy matrix representing the distance matrix for which the eigenvectors and eigenvalues shall be computed number_of_dimensions : int Number of dimensions to keep. Must be lower than or equal to the rank of the given distance_matrix. Returns ------- np.array Array of eigenvectors, each with number_of_dimensions length. np.array Array of eigenvalues, a total number of number_of_dimensions. Notes ----- The algorithm is based on 'An Algorithm for the Principal Component analysis of Large Data Sets' by N. Halko, P.G. Martinsson, Y. Shkolnisky, and M. Tygert. Original Paper: https://arxiv.org/abs/1007.5510 Ported from MATLAB implementation described here: https://stats.stackexchange.com/a/11934/211065 """ m, n = centered_distance_matrix.shape # Number of levels of the Krylov method to use. # For most applications, num_levels=1 or num_levels=2 is sufficient. num_levels = 1 # Changes the power of the spectral norm, thus minimizing the error). use_power_method = False # Note: a (conjugate) transpose is removed for performance, since we # only expect square matrices. if m != n: raise ValueError('FSVD expects square distance matrix') if number_of_dimensions > m or number_of_dimensions > n: raise ValueError('FSVD: number_of_dimensions cannot be larger than' ' the dimensionality of the given distance matrix.') if number_of_dimensions < 0: raise ValueError('Invalid operation: cannot reduce distance matrix ' 'to negative dimensions using PCoA. Did you intend ' 'to specify the default value "0", which sets ' 'the number_of_dimensions equal to the ' 'dimensionality of the given distance matrix?') k = number_of_dimensions + 2 # Form a real nxl matrix G whose entries are independent, identically # distributed Gaussian random variables of zero mean and unit variance G = standard_normal(size=(n, k)) if use_power_method: # use only the given exponent H = dot(centered_distance_matrix, G) for x in range(2, num_levels + 2): # enhance decay of singular values # note: distance_matrix is no longer transposed, saves work # since we're expecting symmetric, square matrices anyway # (Daniel McDonald's changes) H = dot(centered_distance_matrix, dot(centered_distance_matrix, H)) else: # compute the m x l matrices H^{(0)}, ..., H^{(i)} # Note that this is done implicitly in each iteration below. H = dot(centered_distance_matrix, G) # to enhance performance H = hstack( (H, dot(centered_distance_matrix, dot(centered_distance_matrix, H)))) for x in range(3, num_levels + 2): tmp = dot(centered_distance_matrix, dot(centered_distance_matrix, H)) H = hstack( (H, dot(centered_distance_matrix, dot(centered_distance_matrix, tmp)))) # Using the pivoted QR-decomposition, form a real m * ((i+1)l) matrix Q # whose columns are orthonormal, s.t. there exists a real # ((i+1)l) * ((i+1)l) matrix R for which H = QR Q, R = qr(H) # Compute the n * ((i+1)l) product matrix T = A^T Q T = dot(centered_distance_matrix, Q) # step 3 # Form an SVD of T Vt, St, W = svd(T, full_matrices=False) W = W.transpose() # Compute the m * ((i+1)l) product matrix Ut = dot(Q, W) U_fsvd = Ut[:, :number_of_dimensions] S = St[:number_of_dimensions] # drop imaginary component, if we got one # Note: # In cogent, after computing eigenvalues/vectors, the imaginary part # is dropped, if any. We know for a fact that the eigenvalues are # real, so that's not necessary, but eigenvectors can in principle # be complex (see for example # http://math.stackexchange.com/a/47807/109129 for details) eigenvalues = S.real eigenvectors = U_fsvd.real return eigenvalues, eigenvectors @experimental(as_of="0.5.3") def pcoa_biplot(ordination, y): """Compute the projection of descriptors into a PCoA matrix This implementation is as described in Chapter 9 of Legendre & Legendre, Numerical Ecology 3rd edition. Parameters ---------- ordination: OrdinationResults The computed principal coordinates analysis of dimensions (n, c) where the matrix ``y`` will be projected onto. y: DataFrame Samples by features table of dimensions (n, m). These can be environmental features or abundance counts. This table should be normalized in cases of dimensionally heterogenous physical variables. Returns ------- OrdinationResults The modified input object that includes projected features onto the ordination space in the ``features`` attribute. """ # acknowledge that most saved ordinations lack a name, however if they have # a name, it should be PCoA if (ordination.short_method_name != '' and ordination.short_method_name != 'PCoA'): raise ValueError('This biplot computation can only be performed in a ' 'PCoA matrix.') if set(y.index) != set(ordination.samples.index): raise ValueError('The eigenvectors and the descriptors must describe ' 'the same samples.') eigvals = ordination.eigvals.values coordinates = ordination.samples N = coordinates.shape[0] # align the descriptors and eigenvectors in a sample-wise fashion y = y.reindex(coordinates.index) # S_pc from equation 9.44 # Represents the covariance matrix between the features matrix and the # column-centered eigenvectors of the pcoa. spc = (1 / (N - 1)) * y.values.T.dot(scale(coordinates, ddof=1)) # U_proj from equation 9.55, is the matrix of descriptors to be projected. # # Only get the power of non-zero values, otherwise this will raise a # divide by zero warning. There shouldn't be negative eigenvalues(?) Uproj = np.sqrt(N - 1) * spc.dot(np.diag(np.power(eigvals, -0.5, where=eigvals > 0))) ordination.features = pd.DataFrame(data=Uproj, index=y.columns.copy(), columns=coordinates.columns.copy()) ordination.features.fillna(0.0, inplace=True) return ordination scikit-bio-0.5.9/skbio/stats/ordination/_redundancy_analysis.py000066400000000000000000000222461446255456000247660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import pandas as pd from scipy.linalg import svd, lstsq from skbio.util._decorator import experimental from ._ordination_results import OrdinationResults from ._utils import corr, svd_rank, scale @experimental(as_of="0.4.0") def rda(y, x, scale_Y=False, scaling=1): r"""Compute redundancy analysis, a type of canonical analysis. It is related to PCA and multiple regression because the explained variables `y` are fitted to the explanatory variables `x` and PCA is then performed on the fitted values. A similar process is performed on the residuals. RDA should be chosen if the studied gradient is small, and CCA when it's large, so that the contingency table is sparse. Parameters ---------- y : pd.DataFrame :math:`n \times p` response matrix, where :math:`n` is the number of samples and :math:`p` is the number of features. Its columns need be dimensionally homogeneous (or you can set `scale_Y=True`). This matrix is also referred to as the community matrix that commonly stores information about species abundances x : pd.DataFrame :math:`n \times m, n \geq m` matrix of explanatory variables, where :math:`n` is the number of samples and :math:`m` is the number of metadata variables. Its columns need not be standardized, but doing so turns regression coefficients into standard regression coefficients. scale_Y : bool, optional Controls whether the response matrix columns are scaled to have unit standard deviation. Defaults to `False`. scaling : int Scaling type 1 produces a distance biplot. It focuses on the ordination of rows (samples) because their transformed distances approximate their original euclidean distances. Especially interesting when most explanatory variables are binary. Scaling type 2 produces a correlation biplot. It focuses on the relationships among explained variables (`y`). It is interpreted like scaling type 1, but taking into account that distances between objects don't approximate their euclidean distances. See more details about distance and correlation biplots in [1]_, \S 9.1.4. Returns ------- OrdinationResults Object that stores the computed eigenvalues, the proportion explained by each of them (per unit), transformed coordinates for feature and samples, biplot scores, sample constraints, etc. See Also -------- ca cca OrdinationResults Notes ----- The algorithm is based on [1]_, \S 11.1, and is expected to give the same results as ``rda(y, x)`` in R's package vegan. The eigenvalues reported in vegan are re-normalized to :math:`\sqrt{\frac{s}{n-1}}` `n` is the number of samples, and `s` is the original eigenvalues. Here we will only return the original eigenvalues, as recommended in [1]_. References ---------- .. [1] Legendre P. and Legendre L. 1998. Numerical Ecology. Elsevier, Amsterdam. """ Y = y.values X = x.values n, p = y.shape n_, m = x.shape if n != n_: raise ValueError( "Both data matrices must have the same number of rows.") if n < m: # Mmm actually vegan is able to do this case, too raise ValueError( "Explanatory variables cannot have less rows than columns.") sample_ids = y.index feature_ids = y.columns # Centre response variables (they must be dimensionally # homogeneous) Y = scale(Y, with_std=scale_Y) # Centre explanatory variables X = scale(X, with_std=False) # Distribution of variables should be examined and transformed # if necessary (see paragraph 4 in p. 580 L&L 1998) # Compute Y_hat (fitted values by multivariate linear # regression, that is, linear least squares). Formula 11.6 in # L&L 1998 involves solving the normal equations, but that fails # when cond(X) ~ eps**(-0.5). A more expensive but much more # stable solution (fails when cond(X) ~ eps**-1) is computed # using the QR decomposition of X = QR: # (11.6) Y_hat = X [X' X]^{-1} X' Y # = QR [R'Q' QR]^{-1} R'Q' Y # = QR [R' R]^{-1} R'Q' Y # = QR R^{-1} R'^{-1} R' Q' Y # = Q Q' Y # and B (matrix of regression coefficients) # (11.4) B = [X' X]^{-1} X' Y # = R^{-1} R'^{-1} R' Q' Y # = R^{-1} Q' # Q, R = np.linalg.qr(X) # Y_hat = Q.dot(Q.T).dot(Y) # B = scipy.linalg.solve_triangular(R, Q.T.dot(Y)) # This works provided X has full rank. When not, you can still # fix it using R's pseudoinverse or partitioning R. To avoid any # issues, like the numerical instability when trying to # reproduce an example in L&L where X was rank-deficient, we'll # just use `np.linalg.lstsq`, which uses the SVD decomposition # under the hood and so it's also more expensive. B, _, rank_X, _ = lstsq(X, Y) Y_hat = X.dot(B) # Now let's perform PCA on the fitted values from the multiple # regression u, s, vt = svd(Y_hat, full_matrices=False) # vt are the right eigenvectors, which is what we need to # perform PCA. That is, we're changing points in Y_hat from the # canonical basis to the orthonormal basis given by the right # eigenvectors of Y_hat (or equivalently, the eigenvectors of # the covariance matrix Y_hat.T.dot(Y_hat)) # See 3) in p. 583 in L&L 1998 rank = svd_rank(Y_hat.shape, s) # Theoretically, there're at most min(p, m, n - 1) non-zero eigenvalues U = vt[:rank].T # U as in Fig. 11.2 # Ordination in the space of response variables. Its columns are # sample scores. (Eq. 11.12) F = Y.dot(U) # Ordination in the space of explanatory variables. Its columns # are fitted sample scores. (Eq. 11.13) Z = Y_hat.dot(U) # Canonical coefficients (formula 11.14) # C = B.dot(U) # Not used Y_res = Y - Y_hat # PCA on the residuals u_res, s_res, vt_res = svd(Y_res, full_matrices=False) # See 9) in p. 587 in L&L 1998 rank_res = svd_rank(Y_res.shape, s_res) # Theoretically, there're at most min(p, n - 1) non-zero eigenvalues as U_res = vt_res[:rank_res].T F_res = Y_res.dot(U_res) # Ordination in the space of residuals eigenvalues = np.r_[s[:rank], s_res[:rank_res]] # Compute scores if scaling not in {1, 2}: raise NotImplementedError("Only scalings 1, 2 available for RDA.") # According to the vegan-FAQ.pdf, the scaling factor for scores # is (notice that L&L 1998 says in p. 586 that such scaling # doesn't affect the interpretation of a biplot): eigvals = pd.Series( eigenvalues, index=['RDA%d' % (i+1) for i in range(len(eigenvalues))]) const = np.sum(eigenvalues**2)**0.25 if scaling == 1: scaling_factor = const elif scaling == 2: scaling_factor = eigenvalues / const feature_scores = np.hstack((U, U_res)) * scaling_factor sample_scores = np.hstack((F, F_res)) / scaling_factor feature_scores = pd.DataFrame( feature_scores, index=feature_ids, columns=['RDA%d' % (i+1) for i in range(feature_scores.shape[1])]) sample_scores = pd.DataFrame( sample_scores, index=sample_ids, columns=['RDA%d' % (i+1) for i in range(sample_scores.shape[1])]) # TODO not yet used/displayed sample_constraints = np.hstack((Z, F_res)) / scaling_factor sample_constraints = pd.DataFrame( sample_constraints, index=sample_ids, columns=['RDA%d' % (i+1) for i in range(sample_constraints.shape[1])]) # Vegan seems to compute them as corr(X[:, :rank_X], # u) but I don't think that's a good idea. In fact, if # you take the example shown in Figure 11.3 in L&L 1998 you # can see that there's an arrow for each of the 4 # environmental variables (depth, coral, sand, other) even if # other = not(coral or sand) biplot_scores = corr(X, u) biplot_scores = pd.DataFrame( biplot_scores, index=x.columns, columns=['RDA%d' % (i+1) for i in range(biplot_scores.shape[1])]) # The "Correlations of environmental variables with sample # scores" from table 11.4 are quite similar to vegan's biplot # scores, but they're computed like this: # corr(X, F)) p_explained = pd.Series( eigenvalues / eigenvalues.sum(), index=['RDA%d' % (i+1) for i in range(len(eigenvalues))]) return OrdinationResults('RDA', 'Redundancy Analysis', eigvals=eigvals, proportion_explained=p_explained, features=feature_scores, samples=sample_scores, biplot_scores=biplot_scores, sample_constraints=sample_constraints) scikit-bio-0.5.9/skbio/stats/ordination/_utils.py000066400000000000000000000237101446255456000220640ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np from skbio.util._decorator import experimental from ._cutils import center_distance_matrix_cy @experimental(as_of="0.4.0") def mean_and_std(a, axis=None, weights=None, with_mean=True, with_std=True, ddof=0): """Compute the weighted average and standard deviation along the specified axis. Parameters ---------- a : array_like Calculate average and standard deviation of these values. axis : int, optional Axis along which the statistics are computed. The default is to compute them on the flattened array. weights : array_like, optional An array of weights associated with the values in `a`. Each value in `a` contributes to the average according to its associated weight. The weights array can either be 1-D (in which case its length must be the size of `a` along the given axis) or of the same shape as `a`. If `weights=None`, then all data in `a` are assumed to have a weight equal to one. with_mean : bool, optional, defaults to True Compute average if True. with_std : bool, optional, defaults to True Compute standard deviation if True. ddof : int, optional, defaults to 0 It means delta degrees of freedom. Variance is calculated by dividing by `n - ddof` (where `n` is the number of elements). By default it computes the maximum likelyhood estimator. Returns ------- average, std Return the average and standard deviation along the specified axis. If any of them was not required, returns `None` instead """ if not (with_mean or with_std): raise ValueError("Either the mean or standard deviation need to be" " computed.") a = np.asarray(a) if weights is None: avg = a.mean(axis=axis) if with_mean else None std = a.std(axis=axis, ddof=ddof) if with_std else None else: avg = np.average(a, axis=axis, weights=weights) if with_std: if axis is None: variance = np.average((a - avg)**2, weights=weights) else: # Make sure that the subtraction to compute variance works for # multidimensional arrays a_rolled = np.rollaxis(a, axis) # Numpy doesn't have a weighted std implementation, but this is # stable and fast variance = np.average((a_rolled - avg)**2, axis=0, weights=weights) if ddof != 0: # Don't waste time if variance doesn't need scaling if axis is None: variance *= a.size / (a.size - ddof) else: variance *= a.shape[axis] / (a.shape[axis] - ddof) std = np.sqrt(variance) else: std = None avg = avg if with_mean else None return avg, std @experimental(as_of="0.4.0") def scale(a, weights=None, with_mean=True, with_std=True, ddof=0, copy=True): """Scale array by columns to have weighted average 0 and standard deviation 1. Parameters ---------- a : array_like 2D array whose columns are standardized according to the weights. weights : array_like, optional Array of weights associated with the columns of `a`. By default, the scaling is unweighted. with_mean : bool, optional, defaults to True Center columns to have 0 weighted mean. with_std : bool, optional, defaults to True Scale columns to have unit weighted std. ddof : int, optional, defaults to 0 If with_std is True, variance is calculated by dividing by `n - ddof` (where `n` is the number of elements). By default it computes the maximum likelyhood stimator. copy : bool, optional, defaults to True Whether to perform the standardization in place, or return a new copy of `a`. Returns ------- 2D ndarray Scaled array. Notes ----- Wherever std equals 0, it is replaced by 1 in order to avoid division by zero. """ if copy: a = a.copy() a = np.asarray(a, dtype=np.float64) avg, std = mean_and_std(a, axis=0, weights=weights, with_mean=with_mean, with_std=with_std, ddof=ddof) if with_mean: a -= avg if with_std: std[std == 0] = 1.0 a /= std return a @experimental(as_of="0.4.0") def svd_rank(M_shape, S, tol=None): """Matrix rank of `M` given its singular values `S`. See `np.linalg.matrix_rank` for a rationale on the tolerance (we're not using that function because it doesn't let us reuse a precomputed SVD).""" if tol is None: tol = S.max() * max(M_shape) * np.finfo(S.dtype).eps return np.sum(S > tol) @experimental(as_of="0.4.0") def corr(x, y=None): """Computes correlation between columns of `x`, or `x` and `y`. Correlation is covariance of (columnwise) standardized matrices, so each matrix is first centered and scaled to have variance one, and then their covariance is computed. Parameters ---------- x : 2D array_like Matrix of shape (n, p). Correlation between its columns will be computed. y : 2D array_like, optional Matrix of shape (n, q). If provided, the correlation is computed between the columns of `x` and the columns of `y`. Else, it's computed between the columns of `x`. Returns ------- correlation Matrix of computed correlations. Has shape (p, p) if `y` is not provided, else has shape (p, q). """ x = np.asarray(x) if y is not None: y = np.asarray(y) if y.shape[0] != x.shape[0]: raise ValueError("Both matrices must have the same number of rows") x, y = scale(x), scale(y) else: x = scale(x) y = x # Notice that scaling was performed with ddof=0 (dividing by n, # the default), so now we need to remove it by also using ddof=0 # (dividing by n) return x.T.dot(y) / x.shape[0] @experimental(as_of="0.4.0") def e_matrix(distance_matrix): """Compute E matrix from a distance matrix. Squares and divides by -2 the input elementwise. Eq. 9.20 in Legendre & Legendre 1998.""" return distance_matrix * distance_matrix / -2 def f_matrix(E_matrix): """Compute F matrix from E matrix. Centring step: for each element, the mean of the corresponding row and column are substracted, and the mean of the whole matrix is added. Eq. 9.21 in Legendre & Legendre 1998.""" row_means = E_matrix.mean(axis=1, keepdims=True) col_means = E_matrix.mean(axis=0, keepdims=True) matrix_mean = E_matrix.mean() return E_matrix - row_means - col_means + matrix_mean def center_distance_matrix(distance_matrix, inplace=False): """ Centers a distance matrix. Note: If the used distance was euclidean, pairwise distances needn't be computed from the data table Y because F_matrix = Y.dot(Y.T) (if Y has been centered). But since we're expecting distance_matrix to be non-euclidian, we do the following computation as per Numerical Ecology (Legendre & Legendre 1998). Parameters ---------- distance_matrix : 2D array_like Distance matrix. inplace : bool, optional Whether or not to center the given distance matrix in-place, which is more efficient in terms of memory and computation. """ if not distance_matrix.flags.c_contiguous: # center_distance_matrix_cy requires c_contiguous, so make a copy distance_matrix = np.asarray(distance_matrix, order='C') if inplace: center_distance_matrix_cy(distance_matrix, distance_matrix) return distance_matrix else: centered = np.empty(distance_matrix.shape, distance_matrix.dtype) center_distance_matrix_cy(distance_matrix, centered) return centered def _e_matrix_inplace(distance_matrix): """ Compute E matrix from a distance matrix inplace. Squares and divides by -2 the input element-wise. Eq. 9.20 in Legendre & Legendre 1998. Modified from :func:`skbio.stats.ordination.e_matrix` function, performing row-wise operations to avoid excessive memory allocations. Parameters ---------- distance_matrix : 2D array_like Distance matrix. """ distance_matrix = distance_matrix.astype(float) for i in np.arange(len(distance_matrix)): distance_matrix[i] = (distance_matrix[i] * distance_matrix[i]) / -2 return distance_matrix def _f_matrix_inplace(e_matrix): """ Compute F matrix from E matrix inplace. Centering step: for each element, the mean of the corresponding row and column are subtracted, and the mean of the whole matrix is added. Eq. 9.21 in Legendre & Legendre 1998. Modified from :func:`skbio.stats.ordination.f_matrix` function, performing row-wise operations to avoid excessive memory allocations. Parameters ---------- e_matrix : 2D array_like A matrix representing the "E matrix" as described above. """ e_matrix = e_matrix.astype(float) row_means = np.zeros(len(e_matrix), dtype=float) col_means = np.zeros(len(e_matrix), dtype=float) matrix_mean = 0.0 for i in np.arange(len(e_matrix)): row_means[i] = e_matrix[i].mean() matrix_mean += e_matrix[i].sum() col_means += e_matrix[i] matrix_mean /= len(e_matrix) ** 2 col_means /= len(e_matrix) for i in np.arange(len(e_matrix)): v = e_matrix[i] v -= row_means[i] v -= col_means v += matrix_mean e_matrix[i] = v return e_matrix scikit-bio-0.5.9/skbio/stats/ordination/tests/000077500000000000000000000000001446255456000213525ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/ordination/tests/__init__.py000066400000000000000000000005411446255456000234630ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/stats/ordination/tests/data/000077500000000000000000000000001446255456000222635ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/ordination/tests/data/L&L_CA_data000066400000000000000000000000301446255456000241100ustar00rootroot0000000000000010 10 20 10 15 10 15 5 5scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_biplot_descriptors000066400000000000000000000021751446255456000267670ustar00rootroot00000000000000Taxon PC.636 PC.635 PC.356 PC.481 PC.354 PC.593 PC.355 PC.607 PC.634 Root;k__Bacteria;Other 0.0202702702703 0.0469798657718 0.0266666666667 0.027397260274 0.0134228187919 0.0134228187919 0.0136054421769 0.0469798657718 0.02 Root;k__Bacteria;p__Actinobacteria 0.00675675675676 0.00671140939597 0.0 0.00684931506849 0.0 0.0 0.0 0.0201342281879 0.02 Root;k__Bacteria;p__Bacteroidetes 0.695945945946 0.523489932886 0.193333333333 0.143835616438 0.0738255033557 0.389261744966 0.285714285714 0.275167785235 0.653333333333 Root;k__Bacteria;p__Deferribacteres 0.0472972972973 0.0134228187919 0.0 0.0 0.0 0.0 0.0 0.0201342281879 0.0333333333333 Root;k__Bacteria;p__Firmicutes 0.209459459459 0.395973154362 0.773333333333 0.787671232877 0.89932885906 0.41610738255 0.700680272109 0.456375838926 0.22 Root;k__Bacteria;p__Proteobacteria 0.00675675675676 0.00671140939597 0.0 0.0 0.0 0.0335570469799 0.0 0.0201342281879 0.0133333333333 Root;k__Bacteria;p__TM7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0133333333333 Root;k__Bacteria;p__ 0.0135135135135 0.00671140939597 0.00666666666667 0.0342465753425 0.0134228187919 0.147651006711 0.0 0.161073825503 0.0266666666667 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_biplot_projected_descriptors000066400000000000000000000030511446255456000310200ustar00rootroot00000000000000"","Axis.1","Axis.2","Axis.3","Axis.4","Axis.5","Axis.6","Axis.7","Axis.8" "Root;k__Bacteria;Other",-0.0251703458354009,-0.0387419997798285,0.0370307944752097,-0.0182485866183309,-0.00129741030252842,0.000814106793625313,-0.0173701207829898,0.0361211055519348 "Root;k__Bacteria;p__Actinobacteria",-0.0243896442435075,-0.0173750855733946,0.00412122918478027,-0.00122921164491863,-0.0133154056835269,-0.0154481346200809,0.0110025326657988,-0.0193889181281414 "Root;k__Bacteria;p__Bacteroidetes",-0.715120229604841,0.317840715450945,-0.183247320427738,0.616597812375811,0.261720590975174,-0.0233954969961052,0.0235684811385711,0.108576064612194 "Root;k__Bacteria;p__Deferribacteres",-0.0581057801759818,0.0109676872979955,0.000973434160884227,0.0403394413149601,-0.0126657203131676,0.0312522995897358,0.00445295277091873,-0.0391828157435708 "Root;k__Bacteria;p__Firmicutes",0.826514889978526,0.0338669291769973,0.258683679610306,-0.820041925817023,-0.236331008329088,0.0820371240664409,-0.146993916645359,-0.114613637622136 "Root;k__Bacteria;p__Proteobacteria",-0.00665357958782869,-0.0351957821869525,-0.0269691957766513,0.0384070851104123,0.019915981256556,-0.0152225877254676,0.019285238587548,0.0101464789573946 "Root;k__Bacteria;p__TM7",-0.00936607225354557,0.00504668520861811,-0.00329562583232389,-0.00189853964818609,0.00398022745872819,-0.0160400884328152,0.0128760393792986,-0.0162949930598132 "Root;k__Bacteria;p__",0.0122907617222583,-0.276409149593715,-0.0872969953941216,0.146073924926225,-0.022007255063595,-0.0439972226754927,0.0931787928855206,0.0346367154320729 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data000066400000000000000000000021131446255456000253170ustar00rootroot000000000000000 0.099 0.033 0.183 0.148 0.198 0.462 0.628 0.113 0.173 0.434 0.762 0.53 0.586 0.099 0 0.022 0.114 0.224 0.039 0.266 0.442 0.07 0.119 0.419 0.633 0.389 0.435 0.033 0.022 0 0.042 0.059 0.053 0.322 0.444 0.046 0.162 0.339 0.781 0.482 0.55 0.183 0.114 0.042 0 0.068 0.085 0.435 0.406 0.047 0.331 0.505 0.7 0.579 0.53 0.148 0.224 0.059 0.068 0 0.051 0.268 0.24 0.034 0.177 0.469 0.758 0.597 0.552 0.198 0.039 0.053 0.085 0.051 0 0.025 0.129 0.002 0.039 0.39 0.625 0.498 0.509 0.462 0.266 0.322 0.435 0.268 0.025 0 0.014 0.106 0.089 0.315 0.469 0.374 0.369 0.628 0.442 0.444 0.406 0.24 0.129 0.014 0 0.129 0.237 0.349 0.618 0.562 0.471 0.113 0.07 0.046 0.047 0.034 0.002 0.106 0.129 0 0.071 0.151 0.44 0.247 0.234 0.173 0.119 0.162 0.331 0.177 0.039 0.089 0.237 0.071 0 0.43 0.538 0.383 0.346 0.434 0.419 0.339 0.505 0.469 0.39 0.315 0.349 0.151 0.43 0 0.607 0.387 0.456 0.762 0.633 0.781 0.7 0.758 0.625 0.469 0.618 0.44 0.538 0.607 0 0.084 0.09 0.53 0.389 0.482 0.579 0.597 0.498 0.374 0.562 0.247 0.383 0.387 0.084 0 0.038 0.586 0.435 0.55 0.53 0.552 0.509 0.369 0.471 0.234 0.346 0.456 0.09 0.038 0 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data_12dim000066400000000000000000000051271446255456000263230ustar00rootroot00000000000000 1 2 3 4 5 6 7 8 9 10 11 12 1 0.0 0.909636950834479 0.9869428157422727 0.7190893636533138 0.6960053958431593 0.6477238596907942 0.30557161358653495 0.8946966124829346 0.12780699944110363 0.39915339691165386 0.7641239434153432 0.6248070796484706 2 0.909636950834479 0.0 0.3871354292850083 0.6881160960373599 0.5550593584027527 0.5855786600007656 0.4843215561734061 0.20448304199758327 0.4067028703340123 0.2754701840044086 0.6269219445617967 0.05629366991581264 3 0.9869428157422727 0.3871354292850083 0.0 0.6088130886750466 0.8611896463567201 0.2815827949525225 0.6500535832888426 0.8196046614443331 0.356410088497226 0.05164123821334954 0.7110953188954077 0.32855281988632934 4 0.7190893636533138 0.6881160960373599 0.6088130886750466 0.0 0.7453215102240474 0.9916540031629704 0.14394284428694282 0.8388378539413649 0.15115603934799038 0.13871462268568635 0.1934605692727246 0.9804118301943398 5 0.6960053958431593 0.5550593584027527 0.8611896463567201 0.7453215102240474 0.0 0.7996611932937304 0.30579824243478326 0.5227960305398314 0.8564730629853469 0.7786384040043949 0.06843106040159719 0.7715973816221341 6 0.6477238596907942 0.5855786600007656 0.2815827949525225 0.9916540031629704 0.7996611932937304 0.0 0.8869204659721949 0.1619378942802252 0.10200764546980268 0.17805335055828198 0.8796559972720953 0.20933243431218862 7 0.30557161358653495 0.4843215561734061 0.6500535832888426 0.14394284428694282 0.30579824243478326 0.8869204659721949 0.0 0.9489770186788868 0.9531210051205121 0.5834385348164726 0.31984891724102216 0.5852822100268925 8 0.8946966124829346 0.20448304199758327 0.8196046614443331 0.8388378539413649 0.5227960305398314 0.1619378942802252 0.9489770186788868 0.0 0.16681381452925792 0.9281238242741929 0.604480007052297 0.43978806925866687 9 0.12780699944110363 0.4067028703340123 0.356410088497226 0.15115603934799038 0.8564730629853469 0.10200764546980268 0.9531210051205121 0.16681381452925792 0.0 0.10766387594368387 0.9552101788877516 0.6135541732435132 10 0.39915339691165386 0.2754701840044086 0.05164123821334954 0.13871462268568635 0.7786384040043949 0.17805335055828198 0.5834385348164726 0.9281238242741929 0.10766387594368387 0.0 0.4157921207508062 0.31997143485314194 11 0.7641239434153432 0.6269219445617967 0.7110953188954077 0.1934605692727246 0.06843106040159719 0.8796559972720953 0.31984891724102216 0.604480007052297 0.9552101788877516 0.4157921207508062 0.0 0.11189976154475101 12 0.6248070796484706 0.05629366991581264 0.32855281988632934 0.9804118301943398 0.7715973816221341 0.20933243431218862 0.5852822100268925 0.43978806925866687 0.6135541732435132 0.31997143485314194 0.11189976154475101 0.0 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data_2000066400000000000000000000016041446255456000255440ustar00rootroot000000000000000.000000000000000000e+00 7.123610999999999693e-01 7.684919799999999634e-01 8.001856299999999811e-01 6.824852399999999930e-01 7.463462899999999678e-01 7.123610999999999693e-01 0.000000000000000000e+00 8.664569100000000246e-01 8.048528200000000243e-01 8.338130099999999656e-01 7.388172600000000312e-01 7.684919799999999634e-01 8.664569100000000246e-01 0.000000000000000000e+00 8.230839599999999479e-01 7.745174599999999909e-01 7.649887199999999554e-01 8.001856299999999811e-01 8.048528200000000243e-01 8.230839599999999479e-01 0.000000000000000000e+00 8.416736500000000509e-01 7.761436600000000130e-01 6.824852399999999930e-01 8.338130099999999656e-01 7.745174599999999909e-01 8.416736500000000509e-01 0.000000000000000000e+00 7.266116299999999528e-01 7.463462899999999678e-01 7.388172600000000312e-01 7.649887199999999554e-01 7.761436600000000130e-01 7.266116299999999528e-01 0.000000000000000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data_3000066400000000000000000000023141446255456000255440ustar00rootroot00000000000000 PC.636 PC.635 PC.356 PC.481 PC.354 PC.593 PC.355 PC.607 PC.634 PC.636 0.0 0.60737953696 0.748276547061 0.669767446745 0.747947798007 0.7377413135 0.70062016649 0.722772498498 0.581124366673 PC.635 0.60737953696 0.0 0.72197480583 0.655979250216 0.70672669146 0.745154628257 0.745509981365 0.659269044234 0.558850879936 PC.356 0.748276547061 0.72197480583 0.0 0.697796152694 0.610208881707 0.718770654329 0.615310834175 0.735768463546 0.788355481145 PC.481 0.669767446745 0.655979250216 0.697796152694 0.0 0.595087696488 0.657351659549 0.647258584304 0.686601452856 0.663208945591 PC.354 0.747947798007 0.70672669146 0.610208881707 0.595087696488 0.0 0.585097582096 0.599541095803 0.726258935536 0.781832289452 PC.593 0.7377413135 0.745154628257 0.718770654329 0.657351659549 0.585097582096 0.0 0.660981656067 0.713741192899 0.763317384716 PC.355 0.70062016649 0.745509981365 0.615310834175 0.647258584304 0.599541095803 0.660981656067 0.0 0.77062394744 0.753575681654 PC.607 0.722772498498 0.659269044234 0.735768463546 0.686601452856 0.726258935536 0.713741192899 0.77062394744 0.0 0.726387392797 PC.634 0.581124366673 0.558850879936 0.788355481145 0.663208945591 0.781832289452 0.763317384716 0.753575681654 0.726387392797 0.0scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data_3_eigh_ref_3dim000066400000000000000000000014761446255456000303200ustar00rootroot00000000000000Eigvals 3 0.5123672604605051 0.30071909442702155 0.26791206600414047 Proportion explained 3 0.26757383277657976 0.15704469604990076 0.13991186377402365 Species 0 0 Site 9 3 PC.636 -0.2584654611828421 0.17399954688273872 -0.03828757925519412 PC.635 -0.27100113539100934 -0.018595131906339258 0.08648419263485663 PC.356 0.23507789817473093 0.09625192544887005 0.34579272671386985 PC.481 0.026140766432533755 -0.011145967653319655 -0.14766060301460787 PC.354 0.2850075522831216 -0.019254988848331687 -0.062326337538532166 PC.593 0.20463632624145514 -0.13936115093164073 -0.29151381962286704 PC.355 0.23348240321199026 0.22525797406849954 0.018862309626814944 PC.607 -0.09496319113225934 -0.4209748024953033 0.15486945486941445 PC.634 -0.35991515863772167 0.11382259543482587 -0.06622034441375392 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_sample_data_3_fsvd_ref_3dim000066400000000000000000000014651446255456000303440ustar00rootroot00000000000000Eigvals 3 0.5123672604605054 0.3007190944270222 0.2679120660041405 Proportion explained 3 0.2675738327765797 0.15704469604990098 0.13991186377402356 Species 0 0 Site 9 3 PC.636 -0.2584654611828421 0.17399954688273822 -0.03828757925519378 PC.635 -0.2710011353910087 -0.018595131906339074 0.08648419263485721 PC.356 0.23507789817473107 0.0962519254488692 0.3457927267138707 PC.481 0.026140766432533644 -0.011145967653318808 -0.14766060301460796 PC.354 0.28500755228312136 -0.019254988848331694 -0.06232633753853236 PC.593 0.20463632624145525 -0.13936115093164014 -0.2915138196228672 PC.355 0.23348240321199093 0.22525797406849954 0.018862309626815132 PC.607 -0.09496319113225955 -0.4209748024953044 0.1548694548694131 PC.634 -0.35991515863772144 0.1138225954348267 -0.06622034441375402 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/PCoA_skbio000066400000000000000000000037101446255456000241600ustar00rootroot00000000000000Eigvals 9 0.5123672604605048 0.30071909442702155 0.2679120660041405 0.20898868107836532 0.19169895326008157 0.16054234528018121 0.1501769571197782 0.12245774816668883 0.0 Proportion explained 9 0.2675738327765797 0.1570446960499008 0.1399118637740237 0.109140272453788 0.10011104850250738 0.08384011619116792 0.07842699390110737 0.06395117635092507 0.0 Species 0 0 Site 9 9 PC.636 -0.25846546118284214 0.17399954688273864 -0.03828757925519388 0.1944775056196811 -0.08311760208440848 0.2624303332005185 -0.023163639223487725 0.018479403958060633 -0.0 PC.635 -0.27100113539100923 -0.01859513190633933 0.08648419263485602 -0.11806424531525102 0.19880835843691802 -0.021172359953453967 -0.19102402756537798 -0.1556465923768283 -0.0 PC.356 0.2350778981747308 0.0962519254488697 0.3457927267138699 0.003208625776186833 0.09637776755188007 0.04570253869527276 0.1854728132858981 -0.04040939717932225 -0.0 PC.481 0.026140766432533637 -0.011145967653319279 -0.14766060301460832 -0.29087660852960373 -0.20394547280060757 0.06197123847575147 0.10164132870879576 -0.1056909987185146 -0.0 PC.354 0.2850075522831214 -0.019254988848331458 -0.062326337538532166 -0.13812679985198154 0.10479860242276298 0.09517207306283292 -0.12963609754202599 0.22068717037162142 -0.0 PC.593 0.20463632624145503 -0.13936115093164061 -0.2915138196228669 0.18156678682059035 0.1595801327151684 -0.024641213016179383 0.08662524044412884 -0.09962214768709698 -0.0 PC.355 0.23348240321199026 0.22525797406849948 0.018862309626814986 0.10772998183109622 -0.1771089995718839 -0.19290583515124646 -0.14981947140833857 -0.03835490374645002 -0.0 PC.607 -0.09496319113225948 -0.42097480249530345 0.1548694548694144 0.08984275092805967 -0.15261819448811528 -0.0334232691500879 -0.02512247773026579 0.05089885364091516 -0.0 PC.634 -0.35991515863772167 0.11382259543482588 -0.06622034441375366 -0.029757997278778266 0.05722540781828547 -0.1931335061634077 0.14502633103067314 0.14965861173761527 -0.0 Biplot 0 0 Site constraints 0 0 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_X000066400000000000000000000017501446255456000242150ustar00rootroot000000000000001.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 2.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 3.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 4.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 5.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 6.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 7.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 8.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 9.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+01 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_Y000066400000000000000000000002001446255456000242030ustar00rootroot000000000000001 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 11 4 0 0 8 1 11 5 17 7 0 0 9 6 0 0 6 2 9 7 13 10 0 0 7 8 0 0 4 3 7 9 10 13 0 0 5 10 0 0 2 4 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_biplot_scaling1000066400000000000000000000004221446255456000270530ustar00rootroot000000000000000.422650 -0.559143 -0.713251 1.165734e-16 1.471046e-16 1.831868e-16 0.988496 0.150787 -0.011785 6.106227e-17 6.661338e-17 8.326673e-17 -0.556517 0.817600 0.147714 -4.996004e-17 4.440892e-17 -7.216450e-17 -0.404080 -0.905843 -0.127150 2.775558e-18 -2.220446e-17 0.000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_biplot_scaling2000066400000000000000000000004231446255456000270550ustar00rootroot00000000000000 0.422650 -0.559143 -0.713251 1.165734e-16 1.471046e-16 1.831868e-16 0.988496 0.150787 -0.011785 6.106227e-17 6.661338e-17 8.326673e-17 -0.556517 0.817600 0.147714 -4.996004e-17 4.440892e-17 -7.216450e-17 -0.404080 -0.905843 -0.127150 2.775558e-18 -2.220446e-17 0.000000e+00scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_sample_constraints_scaling1000066400000000000000000000015021446255456000314720ustar00rootroot00000000000000-1.203552 0.973291 0.398346 -4.377164e-02 -2.025459e-01 -4.174845e-02 2.251712e-03 -1.233129 1.048075 0.112959 1.946350e-16 -3.553872e-16 8.349689e-02 -1.554395e-16 -1.262706 1.122859 -0.172429 4.377164e-02 2.025459e-01 -4.174845e-02 -2.251712e-03 -0.629153 -1.155379 0.778203 -3.794874e-01 5.000171e-02 3.937851e-16 2.503876e-04 2.249463 0.043725 0.561763 6.747053e-01 2.580938e-02 6.726139e-16 1.835041e-02 -0.688307 -1.005810 0.207427 -1.264958e-01 1.666724e-02 -6.333665e-17 8.346252e-05 2.190309 0.193293 -0.009012 -4.068089e-02 -1.574523e-02 -6.651371e-18 -3.978716e-02 -0.747462 -0.856242 -0.363348 1.264958e-01 -1.666724e-02 -4.098446e-16 -8.346252e-05 2.131154 0.342861 -0.579787 -6.340244e-01 -1.006415e-02 -4.849801e-16 2.143675e-02 -0.806617 -0.706674 -0.934123 3.794874e-01 -5.000171e-02 -7.280846e-16 -2.503876e-04 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_sample_constraints_scaling2000066400000000000000000000014751446255456000315040ustar00rootroot00000000000000-1.481311 2.070632 1.420611 -2.272346e-01 -3.841304e+00 -2.304877e+00 2.600617e-01 -1.517714 2.229732 0.402842 1.010421e-15 -6.739956e-15 4.609755e+00 -1.795250e-14 -1.554117 2.388832 -0.614928 2.272346e-01 3.841304e+00 -2.304877e+00 -2.600617e-01 -0.774350 -2.458015 2.775281 -1.970058e+00 9.482876e-01 2.174036e-14 2.891853e-02 2.768601 0.093023 2.003399 3.502642e+00 4.894777e-01 3.713413e-14 2.119383e+00 -0.847157 -2.139816 0.739742 -6.566859e-01 3.160959e-01 -3.496734e-15 9.639511e-03 2.695794 0.411223 -0.032139 -2.111894e-01 -2.986100e-01 -3.672135e-16 -4.595222e+00 -0.919963 -1.821616 -1.295796 6.566859e-01 -3.160959e-01 -2.262699e-14 -9.639511e-03 2.622988 0.729422 -2.067677 -3.291452e+00 -1.908677e-01 -2.677512e-14 2.475840e+00 -0.992770 -1.503417 -3.331334 1.970058e+00 -9.482876e-01 -4.019660e-14 -2.891853e-02 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_site_scaling1_from_vegan000066400000000000000000000014231446255456000307330ustar00rootroot00000000000000-1.209385 0.9996717 0.2040803 -0.04377164 -0.2025459 -0.04174845 0.002251712 -1.262748 1.114136 0.1333392 -5.659699e-17 2.478790e-16 0.0834969 -1.146481e-16 -1.227255 1.030418 0.001456920 0.04377164 0.2025459 -0.04174845 -0.002251712 -0.7091313 -1.234889 0.7539303 -0.3794874 0.05000171 6.953961e-17 0.0002503876 2.414956 0.1515006 0.7018385 0.6747053 0.02580938 2.771828e-16 0.01835041 -0.7149669 -1.032314 0.1993367 -0.1264958 0.01666724 5.423912e-17 8.346252e-05 2.146560 0.1833668 -0.02417943 -0.04068089 -0.01574523 -3.100586e-16 -0.03978716 -0.7208024 -0.8297385 -0.3552569 0.1264958 -0.01666724 7.539371e-18 -8.346252e-05 2.009409 0.2450122 -0.7046952 -0.6340244 -0.01006415 2.966077e-16 0.02143675 -0.726638 -0.6271632 -0.9098504 0.3794874 -0.05000171 9.260122e-17 -0.0002503876 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_site_scaling2_from_vegan000066400000000000000000000013461446255456000307400ustar00rootroot00000000000000-1.488490 2.126756 0.7278053 -0.2272346 -3.841304 -2.304877 0.2600617 -1.554168 2.370273 0.4755236 -2.938157e-16 4.701051e-15 4.609755 -1.324129e-14 -1.510485 2.192167 0.005195769 0.2272346 3.841304 -2.304877 -0.2600617 -0.8727866 -2.627171 2.688719 -1.970058 0.9482876 3.839191e-15 0.02891853 2.972287 0.3223107 2.502946 3.502642 0.4894777 1.53029e-14 2.119383 -0.8799689 -2.196201 0.7108885 -0.6566859 0.3160959 2.994471e-15 0.009639511 2.641949 0.3901046 -0.08623036 -0.2111894 -0.2986100 -1.711793e-14 -4.595222 -0.8871512 -1.765231 -1.266942 0.6566859 -0.3160959 4.162388e-16 -0.009639511 2.473146 0.5212524 -2.513133 -3.291452 -0.1908677 1.637533e-14 2.475840 -0.8943335 -1.334261 -3.244772 1.970058 -0.9482876 5.112392e-15 -0.02891853 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_species_scaling1_from_vegan000066400000000000000000000006501446255456000314230ustar00rootroot000000000000001.700926 -3.648509 2.254854 0.03700915 2.285531 -3.992165 -0.9423084 1.131309 -2.668483 -4.203715 -0.03700915 -2.285531 -3.992165 0.9423084 4.183397 0.9492028 1.450372 3.89008 1.505626 2.78929e-14 3.804618 3.105920 0.9508293 -1.474339 -3.319613 -1.214393 3.792181e-14 3.87476 -0.6542268 -2.856405 1.655304 -2.139057 3.761467 -1.190933e-14 0.6985568 -0.3552263 -1.215823 -1.449786 1.069529 -1.880733 -6.738172e-15 -0.3492784 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example2_species_scaling2_from_vegan000066400000000000000000000007131446255456000314240ustar00rootroot000000000000001.381987 -1.714964 0.6322725 0.007128982 0.1205124 -0.07231043 -0.00815886 0.9191784 -1.254308 -1.178743 -0.007128982 -0.1205124 -0.07231043 0.00815886 3.398972 0.4461683 0.4066916 0.7493367 0.07938928 5.052266e-16 0.03294182 2.523533 0.4469328 -0.4134120 -0.639449 -0.064033 6.868811e-16 0.03354913 -0.5315534 -1.342640 0.4641556 -0.4120414 0.1983362 -2.157147e-16 0.006048367 -0.2886182 -0.5714919 -0.4065273 0.2060207 -0.0991681 -1.220491e-16 -0.003024184 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_X000066400000000000000000000017501446255456000242160ustar00rootroot000000000000001.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 2.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 3.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 4.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 5.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 6.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 7.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 8.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 9.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+01 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_Y000066400000000000000000000003041446255456000242110ustar00rootroot000000000000001 0 0 0 0 0 2 4 4 0 0 0 0 0 0 5 6 1 0 1 0 0 0 0 0 2 3 11 4 0 0 8 1 6 2 0 11 5 17 7 0 0 6 6 2 9 6 0 0 6 2 10 1 4 9 7 13 10 0 0 4 5 4 7 8 0 0 4 3 6 6 4 7 9 10 13 0 0 6 2 0 5 10 0 0 2 4 0 1 3 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_biplot_scaling1000066400000000000000000000001261446255456000270550ustar00rootroot00000000000000-0.169747 0.630691 0.760769 -0.994017 0.060953 -0.044937 0.184353 -0.974868 0.030987 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_biplot_scaling2000066400000000000000000000001261446255456000270560ustar00rootroot00000000000000-0.169747 0.630691 0.760769 -0.994017 0.060953 -0.044937 0.184353 -0.974868 0.030987 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_sample_constraints_scaling1000066400000000000000000000015401446255456000314750ustar00rootroot00000000000000 0.418807 -1.331731 -0.092311 -0.357222 -0.201114 -0.077319 0.024296 -0.127088 0.023765 0.402119 -1.323781 0.064653 0.774418 0.400533 0.124249 0.046928 0.031790 -0.027526 0.385431 -1.315831 0.221617 -0.893930 -0.432358 -0.106748 -0.138400 0.169415 0.011485 0.670971 0.216324 -0.436938 0.191154 -0.206474 0.219195 -0.110093 0.000480 -0.000760 -0.586949 0.028310 -0.314662 -0.175743 0.184258 0.048211 0.057137 0.011500 0.017735 0.637595 0.232225 -0.123010 0.082373 -0.107580 -0.221430 0.169356 0.010714 -0.009033 -0.620325 0.044211 -0.000734 -0.120892 -0.020910 -0.060213 -0.067075 -0.013264 -0.035699 0.604219 0.248126 0.190919 -0.001622 0.236689 -0.162758 -0.145629 -0.005405 0.015899 -0.653701 0.060112 0.313195 0.335670 -0.188566 0.011227 0.008564 0.001462 0.019120 0.570843 0.264027 0.504847 -0.367420 0.068042 0.303396 0.104854 -0.008683 -0.009463 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_sample_constraints_scaling2000066400000000000000000000015431446255456000315010ustar00rootroot00000000000000 0.692139 -3.080537 -0.328747 -1.245288 -1.072935 -0.506242 0.244127 -3.631648 1.163119 0.664560 -3.062146 0.230249 2.699651 2.136829 0.813520 0.471530 0.908423 -1.347244 0.636980 -3.043755 0.789246 -3.116275 -2.306609 -0.698930 -1.390626 4.841176 0.562103 1.108876 0.500397 -1.556068 0.666370 -1.101532 1.435176 -1.106200 0.013703 -0.037180 -0.970016 0.065487 -1.120607 -0.612647 0.983007 0.315662 0.574110 0.328630 0.868028 1.053717 0.537179 -0.438075 0.287157 -0.573935 -1.449806 1.701670 0.306164 -0.442116 -1.025175 0.102269 -0.002614 -0.421433 -0.111552 -0.394242 -0.673964 -0.379019 -1.747250 0.998559 0.573961 0.679918 -0.005653 1.262724 -1.065657 -1.463266 -0.154459 0.778140 -1.080333 0.139050 1.115379 1.170159 -1.005992 0.073507 0.086046 0.041765 0.935820 0.943400 0.610742 1.797911 -1.280840 0.363003 1.986480 1.053561 -0.248131 -0.463165 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_site_scaling1_from_vegan000066400000000000000000000017301446255456000307350ustar00rootroot000000000000000.4299704 -1.332221 0.06167733 -0.3572215 -0.2011142 -0.07731854 0.02429630 -0.1270878 0.02376451 0.3538402 -1.299809 -0.2660402 0.7744182 0.4005334 0.1242493 0.04692828 0.03178983 -0.02752649 0.4615241 -1.362879 0.6006922 -0.8939302 -0.4323576 -0.1067479 -0.1383998 0.1694146 0.01148472 0.6730478 0.4632174 -0.5265713 0.191154 -0.2064744 0.2191950 -0.1100927 0.0004795276 -0.000759659 -0.5924553 -0.02607423 -0.1955122 -0.1757430 0.1842576 0.04821126 0.05713738 0.01150025 0.01773529 0.631247 0.1986126 -0.1796544 0.08237334 -0.1075801 -0.2214295 0.1693559 0.01071407 -0.009033185 -0.5775539 -0.03661717 0.03720809 -0.1208918 -0.02090970 -0.06021282 -0.06707516 -0.01326357 -0.03569931 0.5731844 -0.04684914 0.1477290 -0.001621561 0.2366887 -0.1627582 -0.1456291 -0.005405227 0.01589872 -0.6946946 0.2120237 0.1343200 0.3356701 -0.1885661 0.01122678 0.008563613 0.001461538 0.01912039 0.6250085 0.4474569 0.7713248 -0.3674199 0.06804227 0.3033959 0.1048540 -0.008683241 -0.009463257 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_site_scaling2_from_vegan000066400000000000000000000016131446255456000307360ustar00rootroot000000000000000.7105873 -3.081668 0.2196514 -1.245288 -1.072935 -0.5062419 0.2441267 -3.631648 1.163119 0.5847714 -3.006693 -0.9474487 2.699651 2.136829 0.81352 0.4715303 0.908423 -1.347244 0.7627343 -3.152586 2.139244 -3.116275 -2.306609 -0.6989299 -1.390626 4.841176 0.562103 1.112307 1.071506 -1.875277 0.6663702 -1.101532 1.435176 -1.106200 0.01370293 -0.03718039 -0.9791168 -0.06031443 -0.6962774 -0.6126467 0.9830066 0.3156624 0.5741102 0.3286300 0.8680277 1.043226 0.459427 -0.6398028 0.2871566 -0.5739354 -1.449806 1.70167 0.3061643 -0.442116 -0.9544901 -0.08470217 0.1325091 -0.4214334 -0.1115523 -0.3942425 -0.673964 -0.3790186 -1.747250 0.9472688 -0.1083706 0.5261072 -0.005652824 1.262724 -1.065657 -1.463266 -0.1544592 0.7781397 -1.148082 0.4904493 0.4783537 1.170159 -1.005992 0.07350714 0.08604627 0.04176476 0.9358196 1.032916 1.035049 2.746918 -1.280840 0.3630026 1.986480 1.053561 -0.2481314 -0.4631652 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_species_scaling1_from_vegan000066400000000000000000000014641446255456000314300ustar00rootroot000000000000000.1823706 0.6532424 -0.7230468 -0.006709309 -0.4387088 0.5613251 -0.1226234 -1.215044 0.2284292 0.2336159 0.7020405 1.408284 -0.4924596 -0.1434352 0.937947 0.4323209 1.361292 -0.1116756 -1.678295 0.2216763 -0.7060727 -0.3653404 0.6936791 0.1597882 0.4669268 0.7694895 1.713529 -1.712479 0.2535825 0.7869925 0.7796179 -1.300374 -0.1696223 -0.5366468 -0.9018874 1.255149 1.741418 1.242592 -1.560116 0.7790618 -1.728251 0.8161103 -1.198472 1.189485 -1.869424 1.650260 1.327675 2.421391 -1.359427 1.595568 2.150528 2.131749 -2.371434 -2.151822 0.4218299 -0.4121355 -0.7269577 1.510841 0.3772344 -1.23206 1.275166 0.1284123 -0.5996156 0.2422044 -1.983235 -0.05430946 0.1839251 1.891113 -0.2729081 -1.999644 -0.06107332 -0.3832015 0.6837066 -1.637614 0.7681627 -2.406462 -0.7918731 -2.188509 -0.06317185 -0.1040515 -0.6006456 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/example3_species_scaling2_from_vegan000066400000000000000000000015611446255456000314270ustar00rootroot000000000000000.1103509 0.2824 -0.2030290 -0.001924623 -0.08223286 0.08573143 -0.01220389 -0.04251988 0.004667199 0.1413590 0.3034956 0.3954412 -0.1412663 -0.02688592 0.1432531 0.04302603 0.04763777 -0.002281724 -1.015522 0.09583179 -0.1982627 -0.1048010 0.1300252 0.02440453 0.04647012 0.02692792 0.03501032 -1.036207 0.1096250 0.2209847 0.2236401 -0.2437459 -0.02590649 -0.05340889 -0.03156112 0.02564484 1.053717 0.5371787 -0.4380751 0.2234806 -0.3239485 0.1246449 -0.1192759 0.04162547 -0.03819552 0.9985587 0.5739606 0.6799181 -0.3899634 0.2990779 0.328451 0.2121588 -0.08298719 -0.0439654 0.2552457 -0.1781683 -0.2041272 0.4333976 0.07070992 -0.1881731 0.1269088 0.004493729 -0.01225117 0.1465559 -0.8573625 -0.01524991 0.0527605 0.3544758 -0.04168137 -0.1990112 -0.002137232 -0.007829461 0.4137051 -0.707949 0.2156974 -0.6903142 -0.148431 -0.3342519 -0.006287074 -0.003641234 -0.01227222 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/exp_PCoAEigenResults_site000066400000000000000000000040161446255456000272230ustar00rootroot00000000000000-2.584654599999999802e-01 1.739995500000000028e-01 3.828758000000000161e-02 -1.944775099999999923e-01 8.311759999999999982e-02 2.624303299999999894e-01 -2.316363999999999923e-02 -1.847939999999999999e-02 0.000000000000000000e+00 -2.710011399999999737e-01 -1.859513000000000138e-02 -8.648419000000000245e-02 1.180642499999999956e-01 -1.988083599999999895e-01 -2.117236000000000118e-02 -1.910240300000000113e-01 1.556465900000000013e-01 0.000000000000000000e+00 2.350779000000000063e-01 9.625192999999999943e-02 -3.457927299999999926e-01 -3.208630000000000076e-03 -9.637777000000000149e-02 4.570253999999999983e-02 1.854728099999999880e-01 4.040939999999999810e-02 0.000000000000000000e+00 2.614077000000000067e-02 -1.114596999999999984e-02 1.476606000000000030e-01 2.908766099999999799e-01 2.039454699999999898e-01 6.197123999999999688e-02 1.016413300000000020e-01 1.056909999999999933e-01 0.000000000000000000e+00 2.850075499999999984e-01 -1.925498999999999961e-02 6.232634000000000091e-02 1.381267999999999940e-01 -1.047986000000000056e-01 9.517206999999999750e-02 -1.296361000000000041e-01 -2.206871699999999881e-01 0.000000000000000000e+00 2.046363300000000052e-01 -1.393611499999999892e-01 2.915138199999999791e-01 -1.815667900000000057e-01 -1.595801299999999867e-01 -2.464121000000000020e-02 8.662524000000000612e-02 9.962215000000000653e-02 0.000000000000000000e+00 2.334824000000000066e-01 2.252579700000000018e-01 -1.886231000000000019e-02 -1.077299800000000030e-01 1.771089999999999887e-01 -1.929058399999999951e-01 -1.498194700000000101e-01 3.835489999999999733e-02 0.000000000000000000e+00 -9.496319000000000288e-02 -4.209747999999999823e-01 -1.548694499999999918e-01 -8.984274999999999900e-02 1.526181899999999869e-01 -3.342326999999999798e-02 -2.512247999999999912e-02 -5.089885000000000242e-02 0.000000000000000000e+00 -3.599151600000000117e-01 1.138225999999999960e-01 6.622034000000000253e-02 2.975799999999999973e-02 -5.722540999999999739e-02 -1.931335100000000082e-01 1.450263300000000088e-01 -1.496586099999999975e-01 0.000000000000000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/exp_PCoAzeros_site000066400000000000000000000114441446255456000257570ustar00rootroot000000000000002.407881329999999875e-01 2.336771619999999938e-01 2.142755920000000147e-02 2.933648560000000002e-02 2.323964740000000057e-02 7.204402660000000513e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.136560330000000035e-01 1.167860260000000011e-01 4.047749600000000170e-02 4.171719389999999777e-02 5.458618300000000340e-02 5.687754019999999994e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 2.393598090000000067e-01 7.600313170000000396e-02 8.108063910000000429e-02 2.004822419999999911e-02 4.581686060000000373e-03 6.111682289999999934e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 2.129341230000000029e-01 6.047901669999999896e-02 1.108399510000000060e-01 1.568068159999999878e-01 4.018964929999999797e-02 1.244166470000000052e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 2.494895480000000054e-01 6.933176589999999473e-02 6.654290229999999806e-02 1.767019729999999914e-02 6.618815479999999585e-02 1.519420850000000045e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.487285489999999877e-01 7.783569120000000119e-02 5.321890979999999854e-02 3.189647279999999890e-02 8.112682020000000493e-02 2.872780789999999917e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 5.139397400000000199e-02 1.623059860000000132e-01 2.992259149999999986e-03 1.115089660000000010e-01 3.296634109999999757e-02 2.308574460000000091e-04 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.153621120000000028e-02 3.446314899999999848e-01 1.169549180000000084e-02 3.466400010000000170e-02 1.169378239999999992e-02 1.366916789999999930e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 3.932616380000000106e-03 5.908732849999999946e-03 2.629546940000000027e-02 7.368117420000000473e-02 1.939265150000000007e-02 2.257115020000000083e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 3.856929369999999996e-02 8.874156730000000784e-03 8.037018469999999970e-02 1.252655340000000117e-01 6.270869140000000230e-02 9.891935890000000051e-03 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 4.211582109999999907e-02 5.655546539999999761e-02 3.122599229999999948e-01 4.320305709999999744e-02 3.457770230000000149e-03 2.089115019999999989e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 5.158303490000000213e-01 2.909775239999999943e-02 9.484347120000000131e-02 2.340326009999999998e-02 3.819325810000000210e-02 4.608673130000000284e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 3.180272690000000013e-01 1.500964499999999924e-01 6.675638650000000063e-02 3.818534149999999738e-02 1.598195930000000098e-02 3.005567279999999883e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 3.237616709999999731e-01 4.748628319999999986e-02 5.282383000000000217e-02 4.852971259999999676e-02 7.869736770000000659e-02 4.101528460000000015e-02 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_biplot_from_vegan.csv000066400000000000000000000033071446255456000303420ustar00rootroot00000000000000"RDA1","RDA2","RDA3","RDA4","RDA5","RDA6" "N",-0.374511707101879,0.279141775958977,-0.113262015862774,0.0291604466058106,-0.00381582755421537,0.0424863529236013 "P",-0.0788656563464819,-0.472632677542489,-0.0651887823463463,-0.0513067111958969,-0.0626909273376982,-0.00110889996021487 "K",-0.201461843066864,-0.381022612236819,-0.0251340010064783,0.0598912302377648,-0.0959494580327501,-0.0171435160344495 "Ca",-0.235421762881426,-0.415332965840277,0.0156842418693768,-0.0304645964200932,-0.0193425068993681,0.0307301502356508 "Mg",-0.258006129373729,-0.351149186002239,0.0198906297437563,-0.0603137013913655,-0.062802597760679,-0.0064268580320466 "S",0.110423012128282,-0.327827092711384,0.0273964647390279,0.0128822505351356,-0.131322241122595,-0.0161293619330301 "Al",0.622794612442927,0.223726801861401,-0.0774758868765043,0.0133921880598012,-0.0975006207689577,-0.0375948643932326 "Fe",0.538546175590668,0.252910024481109,-0.128206469586592,-0.00122698444588682,-0.0370755089903238,-0.0301862362243074 "Mn",-0.53181428311314,-0.387983018850023,-0.0369812755533416,0.028195676589086,0.0139082147231988,-0.010802072964436 "Zn",-0.189256949293269,-0.321619350980509,-0.0296694989201669,-0.0516020128947528,-0.100811021654885,0.0631043516762351 "Mo",0.0825455222136991,0.105558125042181,0.0444498655868074,-0.013149221839644,-0.129692423248781,-0.0279316900201847 "Baresoil",-0.584523854747717,0.0175764195098462,0.249347810472773,-0.0433132869859633,-0.0219797931388049,-0.0115874538804695 "Humdepth",-0.528249123722545,-0.348123615804582,0.139315047829644,0.0255225451725187,-0.00106320905614231,-0.0391497797327695 "pH",0.485293188422395,0.145941294383608,-0.144156426452744,-0.0680477191104673,0.017879488382429,0.028893908227529 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_constraints_from_vegan.csv000066400000000000000000000053541446255456000314240ustar00rootroot00000000000000"RDA1","RDA2","RDA3","RDA4","RDA5","RDA6" "18",-1.94540324526486,1.35619693843417,0.703939871143434,-0.273017904915305,0.430167111988789,-0.48660737084197 "15",0.141838231206451,-0.829758087643046,0.173141397491083,-0.0156875043824831,0.0136619216795438,-0.408528269058105 "24",-1.43248927964489,-0.54425653333442,-0.306236786536847,-0.979876701440387,-0.731804914672737,0.321212796309646 "27",-2.80798626244276,-1.82787096826377,-0.915538594054524,-0.10113999881667,0.165371808326588,-0.272482540524553 "23",-1.32166553682556,-0.588228004227234,0.79516884314486,-0.100577754862558,0.312457897704011,-0.162743742127975 "19",-0.525042043686618,-1.34621680872358,0.603541116383373,-0.350740907365001,-0.10559130781142,-0.222556236954221 "22",-1.6970783295333,-0.00841159288220255,0.350604237250266,1.06598318305367,0.329079144655896,0.216254552790676 "16",-1.02617620074073,1.16222063659566,0.276350890008082,0.508682734424414,0.110047918087361,0.229152398042771 "28",-2.81539141691889,-2.87330917539132,-1.4254501909053,0.278788463109637,-0.0715764088962425,0.0383464804901234 "13",-0.56793332760884,0.978469150560303,-0.0102101554071479,1.15471089199982,-0.893165637481288,-0.179567246057747 "14",0.123702948593575,-0.279611839517576,0.857490241180555,0.288565237262797,-0.0962678825382923,0.386913110717701 "20",-0.889372681662648,-0.172942499513205,1.20564982758643,-0.384640065668512,-0.329123722655264,0.40082339960546 "25",-1.25287864077043,-0.862513780744027,-0.209243578856711,-0.147987569283365,0.455041774670079,0.00853808793906775 "7",0.836595155865492,3.14264733462783,-0.552874592253968,-0.309850905157291,0.156192445586091,-0.608122966237938 "5",-1.03320113118202,2.71896020759242,-1.00737497595167,-0.217427871913452,0.20643732081764,0.836448050498042 "6",0.261185057560469,1.0060253513401,-0.216278932347733,0.191968910927705,0.205015879586198,-0.202134531184565 "3",2.0251525928349,0.838200337107143,-0.890575565259071,-0.221678715814349,0.0510468211613041,-0.177568585625492 "4",0.304232766529097,1.06258912371904,-0.346193660344245,-0.0766334378573768,-0.817513397231726,-0.386397972418401 "2",3.8927613225141,-0.214065093420055,-0.421802196571513,0.0641876476814947,0.0763106413897994,0.455052488664798 "9",4.49140913947389,-1.24888267627012,0.716772000188893,0.0761750818231677,-0.0738996910301799,-0.0631749857609068 "12",1.22495554555309,-0.302280829527584,0.345679740337339,0.568930336840597,0.189701343000118,-0.0324863384828909 "10",3.8583881810421,-1.69957275456566,-0.30263129042612,-0.244748829936061,0.13487999114786,-0.0898553381384633 "11",1.48652810795229,-0.077774982953761,-0.500871495640448,-0.0865802555774825,0.246429358792296,0.261018343487596 "21",-1.33213095284393,0.610386547000902,1.07694384984097,-0.687404064133014,0.0371015837235694,0.138466414867343 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_eigvals_from_vegan.csv000066400000000000000000000010501446255456000304740ustar00rootroot00000000000000"x" "RDA1",820.104210710977 "RDA2",399.28474306136 "RDA3",102.561678139934 "RDA4",47.6316939665912 "RDA5",26.8382218045756 "RDA6",24.0480874768085 "RDA7",19.0643755874934 "RDA8",10.1669953619382 "RDA9",4.42878597644952 "RDA10",2.27203567668609 "RDA11",1.5353256650454 "RDA12",0.925527669731662 "RDA13",0.715510164471211 "RDA14",0.311861227346199 "PC1",186.191732488638 "PC2",88.4641941356934 "PC3",38.1882774045901 "PC4",18.4020745527723 "PC5",12.8394334391492 "PC6",10.551972429882 "PC7",5.51940479440112 "PC8",4.52105681330178 "PC9",1.09220616230999 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_propexpl_from_vegan.csv000066400000000000000000000005261446255456000307220ustar00rootroot00000000000000"x" "RDA1",0.44921 "RDA2",0.21871 "RDA3",0.05618 "RDA4",0.02609 "RDA5",0.0147 "RDA6",0.01317 "RDA7",0.01044 "RDA8",0.00557 "RDA9",0.00243 "RDA10",0.00124 "RDA11",0.00084 "RDA12",0.00051 "RDA13",0.00039 "RDA14",0.00017 "PC1",0.10199 "PC2",0.04846 "PC3",0.02092 "PC4",0.01008 "PC5",0.00703 "PC6",0.00578 "PC7",0.00302 "PC8",0.00248 "PC9",6e-04 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_sites_from_vegan.csv000066400000000000000000000053561446255456000302060ustar00rootroot00000000000000"RDA1","RDA2","RDA3","RDA4","RDA5","RDA6" "18",-0.725180341740889,1.32304743578072,0.536735571384135,-0.39768741234737,0.233754657058704,-0.561316258413971 "15",-1.93529754271851,-0.766164733988552,-0.273348455556674,0.390736768713259,0.0177606558885408,-0.169349974419623 "24",-1.81353741848749,-0.970245493575222,-0.0374209701843787,-0.872025399986459,-0.789699995023076,0.493449832483016 "27",-2.33510121426858,-2.13826666457436,-0.985623024073038,-0.145132098331367,0.583205282290284,-0.313874765445323 "23",-1.41317135065566,-0.1177033753694,0.766850507492372,-0.501223786646214,0.401907289450705,-0.278342018223195 "19",-0.0575697569183517,-0.821681038610851,0.206606955195771,-0.182752763015451,-0.130617003087652,-0.244482299124097 "22",-1.84743663448918,-0.634524208599755,0.802635258758064,1.66371301803693,0.685511124204389,0.639715037447257 "16",-1.50266104356433,0.202771968994942,0.343618483724244,1.10930062109802,0.325281324139236,0.681725828414122 "28",-2.88734608017533,-2.8973024244037,-1.64121631383754,0.0549907838317931,-0.142301693170976,-0.220948911082786 "13",-0.216157151714584,1.4060194258153,-0.0466575925757337,0.799855819301344,-1.0946823960693,-0.416466375199514 "14",-1.20534703154947,0.418683116827144,1.3597696084289,0.513403260974061,-0.776146451075579,0.28265707897677 "20",-1.22313804827702,0.22033914415852,0.616483727488239,-0.430533982693562,-0.160467249867719,0.177868834807142 "25",-1.77661950967122,-0.825044182048943,0.361003390009536,-0.107164123598687,-0.148676491945586,0.237023999173496 "7",-0.678511723219697,2.89559652272012,-0.547824463296798,-0.235728554420752,0.165597328353004,-0.710828270319712 "5",-0.487596122987802,3.18852947968577,-1.41737309023615,-0.422865480680066,0.253132238647981,0.727755243784674 "6",-0.0243012352784496,2.50490917263305,-0.360296245554514,-0.0702120962654929,0.0909124415194519,-0.936567113418783 "3",2.80827785868984,0.455143313772751,-0.613132585731335,0.00451399728070384,0.0225377341796233,0.258222116793284 "4",0.963314315837764,0.84576412181764,-0.066781701948557,0.0887932875301872,-0.700374853742517,-0.116961021287795 "2",3.99917033463046,-0.482115663123818,-0.454217823172445,-0.0665100409733586,0.266626884554847,0.381471681881249 "9",4.36400742802721,-1.736534702518,0.405907326952517,-0.0368661340355564,0.0832432640777509,-0.136409557861582 "12",3.03564636652536,-0.827580749873411,0.102186438399489,-0.171696624931404,0.288862751499394,-0.0309441831749462 "10",4.48325878385124,-1.33798990585379,0.229165601207832,0.0330101538089084,0.11942053442103,-0.0256496604321859 "11",0.817850354912684,0.213402853934839,-0.88018842594682,-0.127740767588512,0.086264341451757,0.125072918411801 "21",-0.342553236757974,-0.119053413601001,1.59311782307288,-0.890178445060962,0.318948282245704,0.157177836230702 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/vare_rda_species_from_vegan.csv000066400000000000000000000126071446255456000305070ustar00rootroot00000000000000"RDA1","RDA2","RDA3","RDA4","RDA5","RDA6" "Callvulg",-0.226273730144909,0.693800038650831,0.338218922488515,6.67088802095297,-7.21896322666435,-0.779857240089175 "Empenigr",-0.238899164401276,-0.631301245805765,2.60480743178841,-1.55330692069587,5.61834172767659,-2.20332774370264 "Rhodtome",-0.17142303305129,-0.0654248519425288,0.185549293155117,-0.217665325317797,0.322372965190883,0.0853972606062568 "Vaccmyrt",-1.09428970452297,-1.23571473681342,-0.940502994941989,0.218545935413684,0.657932487096486,0.837134528181776 "Vaccviti",-0.162201143615588,-1.38843399510951,4.76670106297968,-3.77408048235071,5.43168646890937,-2.79074856413388 "Pinusylv",0.0369862347468032,-0.0238456401875,0.0478650516626519,0.0763337150565842,0.0639052442139435,0.0825651654004402 "Descflex",-0.147574817002457,-0.167722789057799,-0.27793799775637,0.0344024518701595,0.288412456210204,-0.299444024885208 "Betupube",-0.00425890842744653,0.00301626626963975,0.023633639469157,-0.0287099967609287,0.008285119424158,0.0144904045944417 "Vacculig",-0.00617517925092514,0.586329345378346,-0.424343136945186,-0.267181701965188,0.899708457788426,-2.10623236401806 "Diphcomp",-0.0193891282832212,0.0848409769290093,0.0886832373456673,-0.125925466951118,0.302273874297346,-0.479439541135259 "Dicrsp",-0.584662822766602,-0.554381688683121,-0.76501102421792,-4.62706081016606,-3.61916960506924,3.01061244828378 "Dicrfusc",-1.28109719764106,0.103470480549643,2.67976193286694,10.2747384364546,6.22585244770623,4.2615539016749 "Dicrpoly",-0.0527337929905133,-0.00090081484981692,0.221880786125258,-0.683724436531866,-0.345681664095091,0.394727452877124 "Hylosple",-0.522637153726359,-0.918065056916316,-1.62638166301937,0.295469951213255,-0.0135580694056817,-0.334186893959993 "Pleuschr",-5.50878076569324,-8.8886978183423,-8.37459165372512,1.41924983472743,1.57437830231155,-2.29995876920357 "Polypili",0.000632590233791712,0.0102615110484168,-0.0159075161955889,-0.018096445320708,0.031500746301268,0.0786160198924179 "Polyjuni",-0.12340157237603,-0.171463376700033,0.0728402465477063,-0.446428512892154,1.22564488464636,-0.0622820830373054 "Polycomm",-0.0103528544039597,-0.00993084811579174,0.0216129382454449,-0.0489313397543105,0.0229047076022281,-0.011862059575897 "Pohlnuta",0.00970583089927341,-0.018349828466775,0.0527104964420516,-0.0571342448078905,-0.020164288017587,0.0418920415970837 "Ptilcili",-0.159464075362797,0.10006784787628,1.05136092046601,-1.2908733474554,0.33545113524691,0.404450545385935 "Barbhatc",-0.0466890634925938,0.0382613228575175,0.276662021782069,-0.373812730583367,0.0219595583756616,0.138309628865647 "Cladarbu",-0.416846189233898,5.31641622718912,-0.930205800774416,2.81811168990724,-0.554814634260353,-10.4595841461921 "Cladrang",1.29592368856734,8.36409911724857,-8.96098432978265,-0.969135607167511,4.09265280992759,3.38742710658704 "Cladstel",12.9993162839447,-4.60357024457592,-2.45511784152944,1.63313879335609,0.811266886992104,-1.04082533645468 "Cladunci",-0.139665650154971,-0.200952644353237,2.01080043905276,0.112942947894908,-2.80683515519727,4.71782772042145 "Cladcocc",0.0140440451319673,0.0120659834096241,0.00879969627655237,0.0504748534035485,0.0439656404180021,0.0166991824468257 "Cladcorn",-0.0171421483490833,-0.0318891939249154,0.0851353096044147,-0.0712924559399341,0.247868762857871,-0.0985092679795218 "Cladgrac",-0.014291516155796,0.0207918228721213,0.0478283724736316,-0.0599532273483947,-0.0244356304170684,-0.0119910291097221 "Cladfimb",0.00461344583647884,0.00630264328769572,0.0615207799865213,0.0490653816228835,0.0599873314053227,-0.0755759161054924 "Cladcris",-0.00958758815249997,-0.0295565794036219,0.243789050898361,0.130760954099805,0.0658965803482975,-0.231256073310349 "Cladchlo",0.0187488915228099,-0.00928114626307454,0.0285623673752264,-0.0587116824010891,-0.00900681474395845,-0.0135004250016505 "Cladbotr",-0.00660812579632819,0.00125815962588916,0.0253237320949088,-0.0237179502029999,-0.0196117567973272,0.00711937194787014 "Cladamau",-0.00136745162702629,0.00480205186223178,-5.41472575201337e-05,-0.00654936924677102,0.0139883033489021,-0.00709922460632658 "Cladsp",0.00992686294206172,-0.00373711675547203,0.0158895402267187,0.0215400183589053,-0.0307100869494753,-0.0192034215304599 "Cetreric",0.00737025600460116,0.00496065101699207,0.0252933788488033,-0.0709698476248171,-0.295480904895558,0.15202504773877 "Cetrisla",0.0168171538461378,-0.00955018178379953,0.064611315838899,-0.0807719773413275,0.00582196133393798,0.0526210231757201 "Flavniva",0.0758578271997996,0.25014312602853,-0.305377423821448,-0.181549650656412,-2.66963212661746,-1.46522484606432 "Nepharct",-0.061783073424573,-0.0763675615694388,-0.106412306793283,-0.155075628433089,0.7492348600785,-0.0401582665032977 "Stersp",-0.110643408686953,0.675909058528055,-0.847389185822014,-0.584961498181175,0.824411871660421,2.59432085604071 "Peltapht",-0.00433509537730518,-0.00792550879085397,0.00628297623647816,-0.0102203772879107,0.0660236532497632,-0.00750239908018623 "Icmaeric",-0.001603267524481,0.00986109695445918,-0.00702150205760372,0.0019342085956161,0.010326600170813,0.0330394729689556 "Cladcerv",0.00116172819790058,0.000657287114342154,-0.00296642933466362,-0.000910130438819726,-0.00978815736822817,-0.00203673989458803 "Claddefo",-0.0471902500908342,-0.0319259473091497,0.429430035290953,0.0132849661625517,-0.0669419782195097,0.146247353879757 "Cladphyl",0.0267818636482677,-0.0171932277857551,0.00184089496193447,-0.00923266735869818,0.0239144294161575,0.0171690545470201 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/varechem.csv000066400000000000000000000033521446255456000245750ustar00rootroot00000000000000"ID","N","P","K","Ca","Mg","S","Al","Fe","Mn","Zn","Mo","Baresoil","Humdepth","pH" "18",19.8,42.1,139.9,519.4,90,32.3,39,40.9,58.1,4.5,0.3,43.9,2.2,2.7 "15",13.4,39.1,167.3,356.7,70.7,35.2,88.1,39,52.4,5.4,0.3,23.6,2.2,2.8 "24",20.2,67.7,207.1,973.3,209.1,58.1,138,35.4,32.1,16.8,0.8,21.2,2,3 "27",20.6,60.8,233.7,834,127.2,40.7,15.4,4.4,132,10.7,0.2,18.7,2.9,2.8 "23",23.8,54.5,180.6,777,125.8,39.5,24.2,3,50.1,6.6,0.3,46,3,2.7 "19",22.8,40.9,171.4,691.8,151.4,40.8,104.8,17.6,43.6,9.1,0.4,40.5,3.8,2.7 "22",26.6,36.7,171.4,738.6,94.9,33.8,20.7,2.5,77.6,7.4,0.3,23,2.8,2.8 "16",24.2,31,138.2,394.6,45.3,27.1,74.2,9.8,24.4,5.2,0.3,29.8,2,2.8 "28",29.8,73.5,260,748.6,105.3,42.5,17.9,2.4,106.6,9.3,0.3,17.6,3,2.8 "13",28.1,40.5,313.8,540.7,118.9,60.2,329.7,109.9,61.7,9.1,0.5,29.9,2.2,2.8 "14",21.8,38.1,146.8,512.2,75,36.6,92.3,4.6,29,8.1,0.5,33.3,2.7,2.7 "20",26.2,61.9,202.2,741.2,86.3,48.6,124.3,23.6,94.5,10.2,0.6,56.9,2.5,2.9 "25",22.8,50.6,151.7,648,64.8,30.2,12.1,2.3,122.9,8.1,0.2,23.7,2.6,2.9 "7",30.5,24.6,78.7,188.5,55.5,25.3,294.9,123.8,10.1,3,0.4,18.6,1.7,3.1 "5",33.1,22.7,43.6,240.3,25.7,14.9,39,8.4,26.8,8.4,0.2,8.1,1,3.1 "6",19.1,26.4,61.1,259.1,37,21.4,155.1,81.4,20.6,4,0.6,5.8,1.9,3 "3",31.1,32.3,73.7,219,52.5,25.5,304.6,204.4,14.2,2.6,0.5,3.6,1.8,3.3 "4",18,64.9,224.5,517.6,59.7,52.9,435.1,101.2,38,9.5,1.1,21.3,1.8,2.9 "2",22.3,47.4,165.9,436.1,64.3,42.3,316.5,200.1,28.2,7.2,0.3,0.01,1.5,2.9 "9",15,48.4,127.4,499.6,75.1,46.9,227.1,32.2,35.1,8.9,0.7,6.07,2.2,3 "12",16,32.7,126.4,471.4,61.3,31.1,108.8,9.5,26.4,6,0.4,11.2,2.2,2.9 "10",14.3,62.8,215.2,709.7,102.5,48.6,168.2,32,46.9,8.7,0.05,4.4,1.2,3.2 "11",16.7,55.8,205.3,1169.7,126.3,35.9,253.6,96.4,25.1,8.2,0.05,7.6,1.1,3.6 "21",21,26.5,104.4,484.8,74.4,22.2,35.8,5.9,27.5,5.3,0.2,56,2.5,3 scikit-bio-0.5.9/skbio/stats/ordination/tests/data/varespec.csv000066400000000000000000000105731446255456000246160ustar00rootroot00000000000000"ID","Callvulg","Empenigr","Rhodtome","Vaccmyrt","Vaccviti","Pinusylv","Descflex","Betupube","Vacculig","Diphcomp","Dicrsp","Dicrfusc","Dicrpoly","Hylosple","Pleuschr","Polypili","Polyjuni","Polycomm","Pohlnuta","Ptilcili","Barbhatc","Cladarbu","Cladrang","Cladstel","Cladunci","Cladcocc","Cladcorn","Cladgrac","Cladfimb","Cladcris","Cladchlo","Cladbotr","Cladamau","Cladsp","Cetreric","Cetrisla","Flavniva","Nepharct","Stersp","Peltapht","Icmaeric","Cladcerv","Claddefo","Cladphyl" "18",0.55,11.13,0,0,17.8,0.07,0,0,1.6,2.07,0,1.62,0,0,4.67,0.02,0.13,0,0.13,0.12,0,21.73,21.47,3.5,0.3,0.18,0.23,0.25,0.25,0.23,0,0,0.08,0.02,0.02,0,0.12,0.02,0.62,0.02,0,0,0.25,0 "15",0.67,0.17,0,0.35,12.13,0.12,0,0,0,0,0.33,10.92,0.02,0,37.75,0.02,0.23,0,0.03,0.02,0,12.05,8.13,0.18,2.65,0.13,0.18,0.23,0.25,1.23,0,0,0,0,0.15,0.03,0,0,0.85,0,0,0,1,0 "24",0.1,1.55,0,0,13.47,0.25,0,0,0,0,23.43,0,1.68,0,32.92,0,0.23,0,0.32,0.03,0,3.58,5.52,0.07,8.93,0,0.2,0.48,0,0.07,0.1,0.02,0,0,0.78,0.12,0,0,0.03,0,0,0,0.33,0 "27",0,15.13,2.42,5.92,15.97,0,3.7,0,1.12,0,0,3.63,0,6.7,58.07,0,0,0.13,0.02,0.08,0.08,1.42,7.63,2.55,0.15,0,0.38,0.12,0.1,0.03,0,0.02,0,0.02,0,0,0,0,0,0.07,0,0,0.15,0 "23",0,12.68,0,0,23.73,0.03,0,0,0,0,0,3.42,0.02,0,19.42,0.02,2.12,0,0.17,1.8,0.02,9.08,9.22,0.05,0.73,0.08,1.42,0.5,0.17,1.78,0.05,0.05,0,0,0,0,0.02,0,1.58,0.33,0,0,1.97,0 "19",0,8.92,0,2.42,10.28,0.12,0.02,0,0,0,0,0.32,0.02,0,21.03,0.02,1.58,0.18,0.07,0.27,0.02,7.23,4.95,22.08,0.25,0.1,0.25,0.18,0.1,0.12,0.05,0.02,0,0,0,0,0.02,0,0.28,0,0,0,0.37,0 "22",4.73,5.12,1.55,6.05,12.4,0.1,0.78,0.02,2,0,0.03,37.07,0,0,26.38,0,0,0,0.1,0.03,0,6.1,3.6,0.23,2.38,0.17,0.13,0.18,0.2,0.2,0.02,0,0,0.02,0.02,0,0,0,0,0,0,0,0.15,0 "16",4.47,7.33,0,2.15,4.33,0.1,0,0,0,0,1.02,25.8,0.23,0,18.98,0,0.02,0,0.13,0.1,0,7.13,14.03,0.02,0.82,0.15,0.05,0.22,0.22,0.17,0,0,0,0.02,0.18,0.08,0,0,0.03,0,0.07,0,0.67,0 "28",0,1.63,0.35,18.27,7.13,0.05,0.4,0,0.2,0,0.3,0.52,0.2,9.97,70.03,0,0.08,0,0.07,0.03,0,0.17,0.87,0,0.05,0.02,0.03,0.07,0.1,0.02,0,0.02,0,0,0,0.02,0,0,0.02,0,0,0,0.08,0 "13",24.13,1.9,0.07,0.22,5.3,0.12,0,0,0,0.07,0.02,2.5,0,0,5.52,0,0.02,0,0.03,0.25,0.07,23.07,23.67,11.9,0.95,0.17,0.05,0.23,0.18,0.57,0.02,0.07,0,0.07,0.18,0.02,0,0,0.03,0.02,0,0,0.47,0 "14",3.75,5.65,0,0.08,5.3,0.1,0,0,0,0,0,11.32,0,0,7.75,0,0.3,0.02,0.07,0,0,17.45,1.32,0.12,23.68,0.22,0.5,0.15,0.23,0.97,0,0,0,0,0.68,0.02,0,0,0.33,0,0.02,0,1.57,0.05 "20",0.02,6.45,0,0,14.13,0.07,0,0,0.47,0,0.85,1.87,0.08,1.35,13.73,0.07,0.05,0,0.12,0,0,6.8,11.22,0.05,4.75,0.03,0.12,0.22,0.18,0.07,0,0.02,0,0.02,0.15,0,0,0.02,0,0,0,0,1.2,0 "25",0,6.93,0,0,10.6,0.02,0.1,0.02,0.05,0.07,14.02,10.82,0,0.02,28.77,0,6.98,0.13,0,0.22,0,6,2.25,0,0.8,0.12,0.57,0.17,0.15,0.07,0,0,0,0.02,0.03,0.02,0,4.87,0.1,0.07,0,0.02,0.05,0 "7",0,5.3,0,0,8.2,0,0.05,0,8.1,0.28,0,0.45,0.03,0,0.1,0,0.25,0,0.03,0,0,35,42.5,0.28,0.35,0.08,0.2,0.25,0.18,0.13,0.08,0,0,0,0.05,0,0.23,0.2,0.93,0,0.03,0,0.1,0 "5",0,0.13,0,0,2.75,0.03,0,0,0,0,0,0.25,0.03,0,0.03,0.18,0.65,0,0,0,0,18.5,59,0.98,0.28,0.23,0.23,0.23,0.1,0.05,0,0,0.03,0,0.18,0,0.28,0,10.28,0,0.1,0,0.25,0 "6",0.3,5.75,0,0,10.5,0.1,0,0,0,0,0,0.85,0,0,0.05,0.03,0.08,0,0,0.08,0,39,37.5,11.3,3.45,0.18,0.2,0.25,0.25,0.23,0.03,0,0,0.03,0.35,0,0.08,0,0.03,0,0,0,0.28,0 "3",0.03,3.65,0,0,4.43,0,0,0,1.65,0.5,0,0.55,0,0,0.05,0,0,0,0.03,0.03,0,8.8,29.5,55.6,0.25,0.08,0.25,0.25,0.15,0.1,0.03,0,0.03,0,0.05,0,0.15,0.15,0.28,0,0,0,0.08,0 "4",3.4,0.63,0,0,1.98,0.05,0.05,0,0.03,0,0,0.2,0,0,1.53,0,0.1,0,0.05,0,0,15.73,20.03,28.2,0.73,0.1,0.15,0.13,0.1,0.15,0,0,0,0.05,0.28,0.05,10.03,0,0.95,0,0,0.05,0.08,0 "2",0.05,9.3,0,0,8.5,0.03,0,0,0,0,0,0.03,0,0,0.75,0,0.03,0,0,0.03,0,0.48,24.5,75,0.2,0,0.03,0.03,0.05,0.03,0.03,0,0,0,0,0,0,0,0,0,0,0.03,0.03,0 "9",0,3.47,0,0.25,20.5,0.25,0,0,0,0.25,0,0.38,0.25,0,4.07,0,0.25,0,0.25,0.25,0,0.46,4,84.3,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0,0,0.25,0.25,0.25,0.67,0,0,0,0,0,0.25,0.25 "12",0.25,11.5,0,0,15.8,1.2,0,0,0,0,0.25,0.25,0,0,6,0,0,0,0.25,0,0,3.6,14.6,63.3,1.3,0,0.25,0.25,0.25,0.25,0,0,0,0,0,0.25,0,0,0,0,0,0,0.25,0 "10",0.25,11,0,0,11.9,0.25,0,0,0,0,0,0.25,0.25,0,0.67,0,0.25,0,0.25,0,0,1.3,8.7,84.3,0.25,0.25,0.25,0,0.25,0.25,0.25,0,0,0,0.25,0.25,0.25,0,0.25,0,0,0,0.25,0.25 "11",2.37,0.67,0,0,12.9,0.8,0,0,0,0,0,0.25,0.25,0,17.7,0.25,0.25,0,0.25,0.67,0,9.67,29.8,31.8,2.53,0.25,0.25,0.25,0,0.25,0,0,0,0,0,0.25,0,0,0.93,0.25,0,0,0,0.25 "21",0,16,4,15,25,0.25,0.5,0.25,0,0,0.25,0.25,3,0,2,0,0.25,0.25,0.25,10,3,0.7,4.7,10.9,0.25,0,0.05,0.25,0.25,0.25,0.25,0.25,0,0,0,0.67,0,0,0,0,0,0,0.4,0 scikit-bio-0.5.9/skbio/stats/ordination/tests/test_canonical_correspondence_analysis.py000066400000000000000000000147621446255456000317200ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import numpy.testing as npt import pandas as pd from unittest import TestCase, main from skbio import OrdinationResults from skbio.stats.ordination import cca from skbio.util import get_data_path, assert_ordination_results_equal class TestCCAErrors(TestCase): def setUp(self): """Data from table 11.3 in Legendre & Legendre 1998.""" self.Y = pd.DataFrame(np.loadtxt(get_data_path('example3_Y'))) self.X = pd.DataFrame(np.loadtxt(get_data_path('example3_X'))) def test_shape(self): X, Y = self.X, self.Y with npt.assert_raises(ValueError): cca(Y, X[:-1]) def test_Y_values(self): X, Y = self.X, self.Y Y.iloc[0, 0] = -1 with npt.assert_raises(ValueError): cca(Y, X) Y.iloc[0] = 0 with npt.assert_raises(ValueError): cca(Y, X) def test_scaling(self): X, Y = self.X, self.Y with npt.assert_raises(NotImplementedError): cca(Y, X, 3) def test_all_zero_row(self): X, Y = pd.DataFrame(np.zeros((3, 3))), pd.DataFrame(np.zeros((3, 3))) with npt.assert_raises(ValueError): cca(X, Y) class TestCCAResults1(TestCase): def setUp(self): """Data from table 11.3 in Legendre & Legendre 1998 (p. 590). Loaded results as computed with vegan 2.0-8 and compared with table 11.5 if also there.""" self.feature_ids = ['Feature0', 'Feature1', 'Feature2', 'Feature3', 'Feature4', 'Feature5', 'Feature6', 'Feature7', 'Feature8'] self.sample_ids = ['Sample0', 'Sample1', 'Sample2', 'Sample3', 'Sample4', 'Sample5', 'Sample6', 'Sample7', 'Sample8', 'Sample9'] self.env_ids = ['Constraint0', 'Constraint1', 'Constraint2'] self.pc_ids = ['CCA1', 'CCA2', 'CCA3', 'CCA4', 'CCA5', 'CCA6', 'CCA7', 'CCA8', 'CCA9'] self.Y = pd.DataFrame( np.loadtxt(get_data_path('example3_Y')), columns=self.feature_ids, index=self.sample_ids) self.X = pd.DataFrame( np.loadtxt(get_data_path('example3_X'))[:, :-1], columns=self.env_ids, index=self.sample_ids ) def test_scaling1(self): scores = cca(self.Y, self.X, scaling=1) # Load data as computed with vegan 2.0-8 vegan_features = pd.DataFrame( np.loadtxt(get_data_path( 'example3_species_scaling1_from_vegan')), index=self.feature_ids, columns=self.pc_ids) vegan_samples = pd.DataFrame( np.loadtxt(get_data_path( 'example3_site_scaling1_from_vegan')), index=self.sample_ids, columns=self.pc_ids) sample_constraints = pd.DataFrame( np.loadtxt(get_data_path( 'example3_sample_constraints_scaling1')), index=self.sample_ids, columns=self.pc_ids) mat = np.loadtxt(get_data_path( 'example3_biplot_scaling1')) cropped_pcs = self.pc_ids[:mat.shape[1]] biplot_scores = pd.DataFrame(mat, index=self.env_ids, columns=cropped_pcs) proportion_explained = pd.Series([0.466911, 0.238327, 0.100548, 0.104937, 0.044805, 0.029747, 0.012631, 0.001562, 0.000532], index=self.pc_ids) eigvals = pd.Series([0.366136, 0.186888, 0.078847, 0.082288, 0.035135, 0.023327, 0.009905, 0.001225, 0.000417], index=self.pc_ids) exp = OrdinationResults( 'CCA', 'Canonical Correspondence Analysis', samples=vegan_samples, features=vegan_features, sample_constraints=sample_constraints, biplot_scores=biplot_scores, proportion_explained=proportion_explained, eigvals=eigvals) assert_ordination_results_equal(scores, exp, decimal=6) def test_scaling2(self): scores = cca(self.Y, self.X, scaling=2) # Load data as computed with vegan 2.0-8 vegan_features = pd.DataFrame( np.loadtxt(get_data_path( 'example3_species_scaling2_from_vegan')), index=self.feature_ids, columns=self.pc_ids) vegan_samples = pd.DataFrame( np.loadtxt(get_data_path( 'example3_site_scaling2_from_vegan')), index=self.sample_ids, columns=self.pc_ids) sample_constraints = pd.DataFrame( np.loadtxt(get_data_path( 'example3_sample_constraints_scaling2')), index=self.sample_ids, columns=self.pc_ids) mat = np.loadtxt(get_data_path( 'example3_biplot_scaling2')) cropped_pc_ids = self.pc_ids[:mat.shape[1]] biplot_scores = pd.DataFrame(mat, index=self.env_ids, columns=cropped_pc_ids) proportion_explained = pd.Series([0.466911, 0.238327, 0.100548, 0.104937, 0.044805, 0.029747, 0.012631, 0.001562, 0.000532], index=self.pc_ids) eigvals = pd.Series([0.366136, 0.186888, 0.078847, 0.082288, 0.035135, 0.023327, 0.009905, 0.001225, 0.000417], index=self.pc_ids) exp = OrdinationResults( 'CCA', 'Canonical Correspondence Analysis', samples=vegan_samples, features=vegan_features, sample_constraints=sample_constraints, biplot_scores=biplot_scores, proportion_explained=proportion_explained, eigvals=eigvals) assert_ordination_results_equal(scores, exp, decimal=6) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/ordination/tests/test_correspondence_analysis.py000066400000000000000000000200011446255456000276700ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import numpy.testing as npt import pandas as pd from scipy.spatial.distance import pdist from unittest import TestCase, main from skbio import OrdinationResults from skbio.stats.ordination import ca from skbio.util import get_data_path, assert_ordination_results_equal def chi_square_distance(data_table, between_rows=True): """Computes the chi-square distance between two rows or columns of input. It is a measure that has no upper limit, and it excludes double-zeros. Parameters ---------- data_table : 2D array_like An array_like object of shape (n, p). The input must be a frequency table (so that the sum of all cells equals 1, and all values are non-negative). between_rows : bool (defaults to True) Indicates whether distance is computed between rows (default) or columns. Returns ------- Y : ndarray Returns a condensed distance matrix. For each i and j (where i 0) def test_repr_svg(self): obs = self.min_ord_results._repr_svg_() self.assertIsInstance(obs, str) self.assertTrue(len(obs) > 0) def test_png(self): self.assertIsInstance(self.min_ord_results.png, Image) def test_svg(self): self.assertIsInstance(self.min_ord_results.svg, SVG) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/stats/ordination/tests/test_principal_coordinate_analysis.py000066400000000000000000000332641446255456000310660ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import numpy.testing as npt import pandas as pd from copy import deepcopy from unittest import TestCase, main from skbio import DistanceMatrix, OrdinationResults from skbio.stats.distance import DissimilarityMatrixError from skbio.stats.ordination import pcoa, pcoa_biplot from skbio.util import (get_data_path, assert_ordination_results_equal, assert_data_frame_almost_equal) class TestPCoA(TestCase): def setUp(self): # Sample data set from page 111 of W.J Krzanowski. Principles # of multivariate analysis, 2000, Oxford University Press. self.dm = DistanceMatrix( np.loadtxt(get_data_path('PCoA_sample_data'))) def test_simple(self): eigvals = [0.51236726, 0.30071909, 0.26791207, 0.20898868, 0.19169895, 0.16054235, 0.15017696, 0.12245775, 0.0] proportion_explained = [0.2675738328, 0.157044696, 0.1399118638, 0.1091402725, 0.1001110485, 0.0838401162, 0.0784269939, 0.0639511764, 0.0] sample_ids = ['PC.636', 'PC.635', 'PC.356', 'PC.481', 'PC.354', 'PC.593', 'PC.355', 'PC.607', 'PC.634'] axis_labels = ['PC%d' % i for i in range(1, 10)] expected_results = OrdinationResults( short_method_name='PCoA', long_method_name='Principal Coordinate Analysis', eigvals=pd.Series(eigvals, index=axis_labels), samples=pd.DataFrame( np.loadtxt(get_data_path('exp_PCoAEigenResults_site')), index=sample_ids, columns=axis_labels), proportion_explained=pd.Series(proportion_explained, index=axis_labels)) dm = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) results = pcoa(dm) assert_ordination_results_equal(results, expected_results, ignore_directionality=True) def test_fsvd_inplace(self): dm1 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) dm2 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) expected_results = pcoa(dm1, method="eigh", number_of_dimensions=3, inplace=True) results = pcoa(dm2, method="fsvd", number_of_dimensions=3, inplace=True) assert_ordination_results_equal(results, expected_results, ignore_directionality=True, ignore_method_names=True) def test_fsvd(self): dm1 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) dm2 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) dm3 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) # Test eigh vs. fsvd pcoa and inplace parameter expected_results = pcoa(dm1, method="eigh", number_of_dimensions=3, inplace=False) results = pcoa(dm2, method="fsvd", number_of_dimensions=3, inplace=False) results_inplace = pcoa(dm2, method="fsvd", number_of_dimensions=3, inplace=True) assert_ordination_results_equal(results, expected_results, ignore_directionality=True, ignore_method_names=True) assert_ordination_results_equal(results, results_inplace, ignore_directionality=True, ignore_method_names=True) # Test number_of_dimensions edge cases results2 = pcoa(dm3, method="fsvd", number_of_dimensions=0, inplace=False) expected_results2 = pcoa(dm3, method="fsvd", number_of_dimensions=dm3.data.shape[0], inplace=False) assert_ordination_results_equal(results2, expected_results2, ignore_directionality=True, ignore_method_names=True) dm4 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) with self.assertRaises(ValueError): dim_too_large = dm1.data.shape[0] + 10 pcoa(dm4, method="fsvd", number_of_dimensions=dim_too_large) with self.assertRaises(ValueError): pcoa(dm4, method="fsvd", number_of_dimensions=-1) with self.assertRaises(ValueError): dim_too_large = dm1.data.shape[0] + 10 pcoa(dm4, method="eigh", number_of_dimensions=dim_too_large) with self.assertRaises(ValueError): pcoa(dm4, method="eigh", number_of_dimensions=-1) dm_big = DistanceMatrix.read(get_data_path('PCoA_sample_data_12dim')) with self.assertWarnsRegex(RuntimeWarning, r"no value for number_of_dimensions"): pcoa(dm_big, method="fsvd", number_of_dimensions=0) def test_permutted(self): dm1 = DistanceMatrix.read(get_data_path('PCoA_sample_data_3')) # this should not throw pcoa(dm1, method="fsvd", number_of_dimensions=3, inplace=False) # some operations, like permute, will change memory structure # we want to test that this does not break pcoa dm2 = dm1.permute() # we just want to assure it does not throw pcoa(dm2, method="fsvd", number_of_dimensions=3, inplace=False) def test_extensive(self): eigvals = [0.3984635, 0.36405689, 0.28804535, 0.27479983, 0.19165361, 0.0] proportion_explained = [0.2626621381, 0.2399817314, 0.1898758748, 0.1811445992, 0.1263356565, 0.0] sample_ids = [str(i) for i in range(6)] axis_labels = ['PC%d' % i for i in range(1, 7)] samples = [[-0.028597, 0.22903853, 0.07055272, 0.26163576, 0.28398669, 0.0], [0.37494056, 0.22334055, -0.20892914, 0.05057395, -0.18710366, 0.0], [-0.33517593, -0.23855979, -0.3099887, 0.11521787, -0.05021553, 0.0], [0.25412394, -0.4123464, 0.23343642, 0.06403168, -0.00482608, 0.0], [-0.28256844, 0.18606911, 0.28875631, -0.06455635, -0.21141632, 0.0], [0.01727687, 0.012458, -0.07382761, -0.42690292, 0.1695749, 0.0]] expected_results = OrdinationResults( short_method_name='PCoA', long_method_name='Principal Coordinate Analysis', eigvals=pd.Series(eigvals, index=axis_labels), samples=pd.DataFrame(samples, index=sample_ids, columns=axis_labels), proportion_explained=pd.Series(proportion_explained, index=axis_labels)) data = np.loadtxt(get_data_path('PCoA_sample_data_2')) # test passing a numpy.ndarray and a DistanceMatrix to pcoa # gives same results for dm in (data, DistanceMatrix(data)): results = pcoa(dm) assert_ordination_results_equal(results, expected_results, ignore_directionality=True) def test_book_example_dataset(self): # Adapted from PyCogent's `test_principal_coordinate_analysis`: # "I took the example in the book (see intro info), and did # the principal coordinates analysis, plotted the data and it # looked right". eigvals = [0.73599103, 0.26260032, 0.14926222, 0.06990457, 0.02956972, 0.01931184, 0., 0., 0., 0., 0., 0., 0., 0.] proportion_explained = [0.58105792, 0.20732046, 0.1178411, 0.05518899, 0.02334502, 0.01524651, 0., 0., 0., 0., 0., 0., 0., 0.] sample_ids = [str(i) for i in range(14)] axis_labels = ['PC%d' % i for i in range(1, 15)] expected_results = OrdinationResults( short_method_name='PCoA', long_method_name='Principal Coordinate Analysis', eigvals=pd.Series(eigvals, index=axis_labels), samples=pd.DataFrame( np.loadtxt(get_data_path('exp_PCoAzeros_site')), index=sample_ids, columns=axis_labels), proportion_explained=pd.Series(proportion_explained, index=axis_labels)) results = npt.assert_warns(RuntimeWarning, pcoa, self.dm) # Note the absolute value because column can have signs swapped results.samples = np.abs(results.samples) assert_ordination_results_equal(results, expected_results, ignore_directionality=True) def test_invalid_input(self): with npt.assert_raises(DissimilarityMatrixError): pcoa([[1, 2], [3, 4]]) class TestPCoABiplot(TestCase): def setUp(self): # Crawford dataset for unweighted UniFrac fp = get_data_path('PCoA_sample_data_3') self.ordination = pcoa(DistanceMatrix.read(fp)) fp = get_data_path('PCoA_biplot_descriptors') self.descriptors = pd.read_table(fp, index_col='Taxon').T def test_pcoa_biplot_from_ape(self): """Test against a reference implementation from R's ape package The test data was generated with the R script below and using a modified version of pcoa.biplot that returns the U matrix. library(ape) # files can be found in the test data folder of the ordination module y = t(read.table('PCoA_biplot_descriptors', row.names = 1, header = 1)) dm = read.table('PCoA_sample_data_3', row.names = 1, header = 1) h = pcoa(dm) # biplot.pcoa will only calculate the biplot for two axes at a time acc = NULL for (axes in c(1, 3, 5, 7)) { new = biplot.pcoa(h, y, plot.axes=c(axes, axes+1), rn = rep('.', length(colnames(dm))) ) if(is.null(acc)) { acc = new } else { b = acc acc <- cbind(acc, new) } } write.csv(acc, file='PCoA_biplot_projected_descriptors') """ obs = pcoa_biplot(self.ordination, self.descriptors) # we'll build a dummy ordination results object based on the expected # the main thing we'll compare and modify is the features dataframe exp = deepcopy(obs) fp = get_data_path('PCoA_biplot_projected_descriptors') # R won't calculate the last dimension, so pad with zeros to make the # arrays comparable exp.features = pd.read_table(fp, sep=',', index_col=0) exp.features['Axis.9'] = np.zeros_like(exp.features['Axis.8']) # make the order comparable exp.features = exp.features.reindex(obs.features.index) assert_ordination_results_equal(obs, exp, ignore_directionality=True, ignore_axis_labels=True) def test_pcoa_biplot_subset_input(self): # create a 2D copy of the full ordination two_dims = deepcopy(self.ordination) two_dims.eigvals = two_dims.eigvals[:2] two_dims.samples = two_dims.samples.iloc[:, :2] two_dims.proportion_explained = two_dims.proportion_explained[:2] # only look at the features subset = pcoa_biplot(two_dims, self.descriptors).features full = pcoa_biplot(self.ordination, self.descriptors).features # the biplot should be identical regardless of the number of axes used assert_data_frame_almost_equal(subset, full.iloc[:, :2]) def test_mismatching_samples(self): new_index = self.descriptors.index.tolist() new_index[3] = 'Not.an.id' self.descriptors.index = pd.Index(new_index) with self.assertRaisesRegex(ValueError, r'The eigenvectors and the ' 'descriptors must describe ' 'the same ' 'samples.'): pcoa_biplot(self.ordination, self.descriptors) def test_not_a_pcoa(self): self.ordination.short_method_name = 'RDA' self.ordination.long_method_name = 'Redundancy Analysis' with self.assertRaisesRegex(ValueError, r'This biplot computation can' ' only be performed in a ' 'PCoA matrix.'): pcoa_biplot(self.ordination, self.descriptors) def test_from_seralized_results(self): # the current implementation of ordination results loses some # information, test that pcoa_biplot works fine regardless results = OrdinationResults.read(get_data_path('PCoA_skbio')) serialized = pcoa_biplot(results, self.descriptors) in_memory = pcoa_biplot(self.ordination, self.descriptors) assert_ordination_results_equal(serialized, in_memory, ignore_directionality=True, ignore_axis_labels=True, ignore_method_names=True) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/stats/ordination/tests/test_redundancy_analysis.py000066400000000000000000000242661446255456000270340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import numpy as np import numpy.testing as npt import pandas as pd from unittest import TestCase, main from skbio import OrdinationResults from skbio.stats.ordination import rda from skbio.util import get_data_path, assert_ordination_results_equal class TestRDAErrors(TestCase): def setUp(self): pass def test_shape(self): for n, p, n_, m in [(3, 4, 2, 1), (3, 4, 3, 10)]: Y = pd.DataFrame(np.random.randn(n, p)) X = pd.DataFrame(np.random.randn(n_, m)) yield npt.assert_raises, ValueError, rda, Y, X, None, None class TestRDAResults(TestCase): # STATUS: L&L only shows results with scaling 1, and they agree # with vegan's (module multiplying by a constant). I can also # compute scaling 2, agreeing with vegan, but there are no written # results in L&L. def setUp(self): """Data from table 11.3 in Legendre & Legendre 1998.""" self.sample_ids = ['Site0', 'Site1', 'Site2', 'Site3', 'Site4', 'Site5', 'Site6', 'Site7', 'Site8', 'Site9'] self.feature_ids = ['Species0', 'Species1', 'Species2', 'Species3', 'Species4', 'Species5'] self.env_ids = list(map(str, range(4))) self.pc_ids = ['RDA1', 'RDA2', 'RDA3', 'RDA4', 'RDA5', 'RDA6', 'RDA7'] self.Y = pd.DataFrame( np.loadtxt(get_data_path('example2_Y')), index=self.sample_ids, columns=self.feature_ids) self.X = pd.DataFrame( np.loadtxt(get_data_path('example2_X')), index=self.sample_ids, columns=self.env_ids) def test_scaling1(self): scores = rda(self.Y, self.X, scaling=1) sample_constraints = pd.DataFrame(np.loadtxt( get_data_path('example2_sample_constraints_scaling1'))) # Load data as computed with vegan 2.0-8 vegan_features = pd.DataFrame( np.loadtxt(get_data_path( 'example2_species_scaling1_from_vegan')), index=self.feature_ids, columns=self.pc_ids) vegan_samples = pd.DataFrame( np.loadtxt(get_data_path( 'example2_site_scaling1_from_vegan')), index=self.sample_ids, columns=self.pc_ids) sample_constraints = pd.DataFrame( np.loadtxt(get_data_path( 'example2_sample_constraints_scaling1')), index=self.sample_ids, columns=self.pc_ids) mat = np.loadtxt(get_data_path( 'example2_biplot_scaling1')) cropped_pc_ids = self.pc_ids[:mat.shape[1]] biplot_scores = pd.DataFrame(mat, index=self.env_ids, columns=cropped_pc_ids) proportion_explained = pd.Series([0.44275783, 0.25614586, 0.15280354, 0.10497021, 0.02873375, 0.00987052, 0.00471828], index=self.pc_ids) eigvals = pd.Series([25.897954, 14.982578, 8.937841, 6.139956, 1.680705, 0.577350, 0.275984], index=self.pc_ids) exp = OrdinationResults( 'RDA', 'Redundancy Analysis', samples=vegan_samples, features=vegan_features, sample_constraints=sample_constraints, biplot_scores=biplot_scores, proportion_explained=proportion_explained, eigvals=eigvals) assert_ordination_results_equal(scores, exp, ignore_directionality=True, decimal=6) def test_scaling2(self): scores = rda(self.Y, self.X, scaling=2) mat = np.loadtxt(get_data_path('example2_biplot_scaling2')) cropped_pc_ids = self.pc_ids[:mat.shape[1]] biplot_scores = pd.DataFrame(mat, index=self.env_ids, columns=cropped_pc_ids) sample_constraints = pd.DataFrame(np.loadtxt( get_data_path('example2_sample_constraints_scaling2'))) # Load data as computed with vegan 2.0-8 vegan_features = pd.DataFrame( np.loadtxt(get_data_path( 'example2_species_scaling2_from_vegan')), index=self.feature_ids, columns=self.pc_ids) vegan_samples = pd.DataFrame( np.loadtxt(get_data_path( 'example2_site_scaling2_from_vegan')), index=self.sample_ids, columns=self.pc_ids) sample_constraints = pd.DataFrame( np.loadtxt(get_data_path( 'example2_sample_constraints_scaling2')), index=self.sample_ids, columns=self.pc_ids) mat = np.loadtxt(get_data_path( 'example2_biplot_scaling2')) cropped_pc_ids = self.pc_ids[:mat.shape[1]] biplot_scores = pd.DataFrame(mat, index=self.env_ids, columns=cropped_pc_ids) proportion_explained = pd.Series([0.44275783, 0.25614586, 0.15280354, 0.10497021, 0.02873375, 0.00987052, 0.00471828], index=self.pc_ids) eigvals = pd.Series([25.897954, 14.982578, 8.937841, 6.139956, 1.680705, 0.577350, 0.275984], index=self.pc_ids) exp = OrdinationResults( 'RDA', 'Redundancy Analysis', samples=vegan_samples, features=vegan_features, sample_constraints=sample_constraints, biplot_scores=biplot_scores, proportion_explained=proportion_explained, eigvals=eigvals) assert_ordination_results_equal(scores, exp, ignore_directionality=True, decimal=6) class TestRDAResults_biplot_score(TestCase): # STATUS: L&L only shows results with scaling 1, and they agree # with vegan's (module multiplying by a constant). I can also # compute scaling 2, agreeing with vegan, but there are no written # results in L&L. def setUp(self): """varespec and varechem from Väre etal. 1995 DOI: 10.2307/3236351""" self.Y = pd.read_csv(get_data_path('varespec.csv'), index_col=0) self.X = pd.read_csv(get_data_path('varechem.csv'), index_col=0) self.Y.index.name = None self.X.index.name = None def test_biplot_score(self): rda_ = rda(y=self.Y, x=self.X, scale_Y=False, scaling=1) # Load data as computed with vegan 2.4-3: # library(vegan) # data(varechem) # data(varespec) # rda_ = rda(X=varespec, Y=varechem, scale=FALSE) # write.table(summary(rda_, scaling=1)$biplot, # 'vare_rda_biplot_from_vegan.csv', sep=',') # write.table(summary(rda_, scaling=1)$sites, # 'vare_rda_sites_from_vegan.csv', sep=',') # write.table(summary(rda_, scaling=1)$species, # 'vare_rda_species_from_vegan.csv', sep=',') # write.table(summary(rda_, scaling=1)$constraints, # # 'vare_rda_constraints_from_vegan.csv', sep=',') # write.table(summary(rda_, scaling=1)$cont$importance[2, ], # 'vare_rda_propexpl_from_vegan.csv', sep=',') # write.table(summary(rda_, scaling=1)$cont$importance[1, ], # 'vare_rda_eigvals_from_vegan.csv', sep=',') vegan_features = pd.read_csv( get_data_path('vare_rda_species_from_vegan.csv')) vegan_samples = pd.read_csv( get_data_path('vare_rda_sites_from_vegan.csv')) vegan_biplot = pd.read_csv( get_data_path('vare_rda_biplot_from_vegan.csv')) vegan_constraints = pd.read_csv( get_data_path('vare_rda_constraints_from_vegan.csv')) vegan_propexpl = pd.read_csv( get_data_path('vare_rda_propexpl_from_vegan.csv')) vegan_propexpl = pd.Series( vegan_propexpl.x.values, index=rda_.eigvals.index) vegan_eigvals = pd.read_csv( get_data_path('vare_rda_eigvals_from_vegan.csv')) vegan_eigvals = pd.Series( vegan_eigvals.x.values, index=rda_.eigvals.index) # scikit-bio returns singular values, whereas vegan returns eigenvalues vegan_eigvals = np.sqrt(vegan_eigvals*vegan_eigvals.shape[0]) vegan_propexpl = vegan_eigvals/vegan_eigvals.sum() # transform the output of rda_ to match column selection of vegan res_samples = rda_.samples.iloc[:, 0:6] res_features = rda_.features.iloc[:, 0:6] rda_ = OrdinationResults( 'RDA', 'Redundancy Analysis', samples=res_samples, features=res_features, sample_constraints=rda_.sample_constraints.iloc[:, 0:6], biplot_scores=rda_.biplot_scores.iloc[:, 0:6], proportion_explained=rda_.proportion_explained, eigvals=rda_.eigvals) exp = OrdinationResults( 'RDA', 'Redundancy Analysis', samples=vegan_samples, features=vegan_features, sample_constraints=vegan_constraints, biplot_scores=vegan_biplot, proportion_explained=vegan_propexpl, eigvals=vegan_eigvals) # This scaling constant is required to make skbio comparable to vegan. scaling = (rda_.eigvals[0] / rda_.eigvals[:6]) exp.biplot_scores *= scaling assert_ordination_results_equal( rda_, exp, ignore_directionality=True, decimal=6) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/ordination/tests/test_util.py000066400000000000000000000113551446255456000237450ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import copy import numpy as np import numpy.testing as npt from skbio.stats.ordination import corr, mean_and_std, e_matrix, f_matrix, \ center_distance_matrix from skbio.stats.ordination._utils import _e_matrix_inplace, _f_matrix_inplace class TestUtils(TestCase): def setUp(self): self.x = np.array([[1, 2, 3], [4, 5, 6]]) self.y = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) self.matrix = np.arange(1, 7).reshape(2, 3) self.matrix2 = np.arange(1, 10).reshape(3, 3) self.small_mat = np.array([[7, 5, 5], [4, 4, 9], [7, 5, 3]]) self.dist_mat = np.asarray([[0., 7., 5., 5.], [7., 0., 4., 9.], [5., 4., 0., 3.], [5., 9., 3., 0.]], dtype=np.float64) self.dist_mat_fp32 = np.asarray([[0., 7., 5., 5.], [7., 0., 4., 9.], [5., 4., 0., 3.], [5., 9., 3., 0.]], dtype=np.float32) def test_mean_and_std(self): obs = mean_and_std(self.x) npt.assert_almost_equal((3.5, 1.707825127), obs) obs = mean_and_std(self.x, with_std=False) self.assertEqual((3.5, None), obs) obs = mean_and_std(self.x, ddof=2) npt.assert_almost_equal((3.5, 2.091650066), obs) def test_mean_and_std_no_mean_no_std(self): with npt.assert_raises(ValueError): mean_and_std(self.x, with_mean=False, with_std=False) def test_corr(self): obs = corr(self.small_mat) npt.assert_almost_equal(np.array([[1, 1, -0.94491118], [1, 1, -0.94491118], [-0.94491118, -0.94491118, 1]]), obs) def test_corr_shape_mismatch(self): with npt.assert_raises(ValueError): corr(self.x, self.y) def test_e_matrix(self): E = e_matrix(self.matrix) expected_E = np.array([[-0.5, -2., -4.5], [-8., -12.5, -18.]]) npt.assert_almost_equal(E, expected_E) def test_f_matrix(self): F = f_matrix(self.matrix2) expected_F = np.zeros((3, 3)) # Note that `test_make_F_matrix` in cogent is wrong npt.assert_almost_equal(F, expected_F) def test_e_matrix_inplace(self): E = _e_matrix_inplace(self.matrix) expected_E = np.array([[-0.5, -2., -4.5], [-8., -12.5, -18.]]) npt.assert_almost_equal(E, expected_E) def test_f_matrix_inplace(self): F = _f_matrix_inplace(self.matrix2) expected_F = np.zeros((3, 3)) npt.assert_almost_equal(F, expected_F) def test_center_distance_matrix_inplace(self): dm_expected = f_matrix(e_matrix(self.dist_mat)) # make copy of matrix to test inplace centering matrix_copy = copy.deepcopy(self.dist_mat) dm_centered = center_distance_matrix(matrix_copy, inplace=False) # ensure that matrix_copy was NOT modified inplace self.assertTrue(np.array_equal(matrix_copy, self.dist_mat)) # and ensure that the result of centering was correct npt.assert_almost_equal(dm_expected, dm_centered) # next, sort same matrix inplace matrix_copy2 = copy.deepcopy(self.dist_mat) dm_centered_inp = center_distance_matrix(matrix_copy2, inplace=True) # and ensure that the result of inplace centering was correct npt.assert_almost_equal(dm_expected, dm_centered_inp) def test_center_distance_matrix_single(self): dm_expected = f_matrix(e_matrix(self.dist_mat_fp32)) # make copy of matrix to test inplace centering matrix_copy = copy.deepcopy(self.dist_mat_fp32) dm_centered = center_distance_matrix(matrix_copy, inplace=False) # ensure that matrix_copy was NOT modified inplace self.assertTrue(np.array_equal(matrix_copy, self.dist_mat_fp32)) # and ensure that the result of centering was correct npt.assert_almost_equal(dm_expected, dm_centered) # next, sort same matrix inplace matrix_copy2 = copy.deepcopy(self.dist_mat_fp32) dm_centered_inp = center_distance_matrix(matrix_copy2, inplace=True) # and ensure that the result of inplace centering was correct npt.assert_almost_equal(dm_expected, dm_centered_inp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/power.py000066400000000000000000001356041446255456000175610ustar00rootroot00000000000000r""" Empirical Power Estimation (:mod:`skbio.stats.power`) ===================================================== .. currentmodule:: skbio.stats.power The purpose of this module is to provide empirical, post-hoc power estimation of normally and non-normally distributed data. It also provides support to subsample data to facilitate this analysis. The underlying principle is based on subsampling and Monte Carlo simulation. Assume that there is some set of populations, :math:`K_{1}, K_{2}, ... K_{n}` which have some property, :math:`\mu` such that :math:`\mu_{1} \neq \mu_{2} \neq ... \neq \mu_{n}`. For each of the populations, a sample, :math:`S` can be drawn, with a parameter, :math:`x` where :math:`x \approx \mu` and for the samples, we can use a test, :math:`f`, to show that :math:`x_{1} \neq x_{2} \neq ... \neq x_{n}`. Since we know that :math:`\mu_{1} \neq \mu_{2} \neq ... \neq \mu_{n}`, we know we should reject the null hypothesis. If we fail to reject the null hypothesis, we have committed a Type II error and our result is a false negative. We can estimate the frequency of Type II errors at various sampling depths by repeatedly subsampling the populations and observing how often we see a false negative. If we repeat this several times for each subsampling depth, and vary the depths we use, we can start to approximate a relationship between the number of samples we use and the rate of false negatives, also called the statistical power of the test. To generate complete power curves from data which appears underpowered, the `statsmodels.stats.power` package can be used to solve for an effect size. The effect size can be used to extrapolate a power curve for the data. Most functions in this module accept a statistical test function which takes a list of samples and returns a p value. The test is then evaluated over a series of subsamples. Sampling may be handled in two ways. For any set of samples, we may simply choose to draw :math:`n` observations at random for each sample. Alternatively, if metadata is available, samples can be matched based on a set of control categories so that paired samples are drawn at random from the set of available matches. Functions --------- .. autosummary:: :toctree: subsample_power subsample_paired_power confidence_bound paired_subsamples Examples -------- Suppose we wanted to test that there's a relationship between two random variables, `ind` and `dep`. Let's use random subsampling to estimate the statistical power of our test with an alpha of 0.1, 0.01, and 0.001. To control for the pseudo-random number generation, we will use a seed. When using these functions with your own data, you don't need to include the step. >>> import numpy as np >>> np.random.seed(20) >>> ind = np.random.randint(0, 20, 15) >>> ind array([ 3, 15, 9, 11, 7, 2, 0, 8, 19, 16, 6, 6, 16, 9, 5]) >>> dep = (3 * ind + 5 + np.random.randn(15) * 5).round(3) >>> dep array([ 15.617, 47.533, 28.04 , 33.788, 19.602, 12.229, 4.779, 36.838, 67.256, 55.032, 22.157, 7.051, 58.601, 38.664, 18.783]) Let's define a test that will draw a list of sample pairs and determine if they're correlated. We'll use `scipy.stats.pearsonr` which takes two arrays and returns a correlation coefficient and a p-value representing the probability the two distributions are correlated. >>> from scipy.stats import pearsonr >>> f = lambda x: pearsonr(x[0], x[1])[1] Now, let's use random sampling to estimate the power of our test on the first distribution. >>> samples = [ind, dep] >>> print("%.3e" % f(samples)) 3.646e-08 In `subsample_power`, we can maintain a paired relationship between samples by setting `draw_mode` to "matched". We can also set our critical value, so that we estimate power for a critical value of :math:`\alpha = 0.05`, an estimate for the critical value of 0.01, and a critical value of 0.001. >>> from skbio.stats.power import subsample_power >>> pwr_100, counts_100 = subsample_power(test=f, ... samples=samples, ... max_counts=10, ... min_counts=3, ... counts_interval=1, ... draw_mode="matched", ... alpha_pwr=0.1, ... num_iter=25) >>> pwr_010, counts_010 = subsample_power(test=f, ... samples=samples, ... max_counts=10, ... min_counts=3, ... counts_interval=1, ... draw_mode="matched", ... alpha_pwr=0.01, ... num_iter=25) >>> pwr_001, counts_001 = subsample_power(test=f, ... samples=samples, ... max_counts=10, ... min_counts=3, ... counts_interval=1, ... draw_mode="matched", ... alpha_pwr=0.001, ... num_iter=25) >>> counts_100 array([3, 4, 5, 6, 7, 8, 9]) >>> pwr_100.mean(0) array([ 0.484, 0.844, 0.932, 0.984, 1. , 1. , 1. ]) >>> pwr_010.mean(0) array([ 0.044, 0.224, 0.572, 0.836, 0.928, 0.996, 1. ]) >>> pwr_001.mean(0) array([ 0. , 0.016, 0.108, 0.332, 0.572, 0.848, 0.956]) Based on this power estimate, as we increase our confidence that we have not committed a type I error and identified a false positive, the number of samples we need to be confident that we have not committed a type II error increases. """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import collections import copy import numpy as np import scipy.stats from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def subsample_power(test, samples, draw_mode='ind', alpha_pwr=0.05, ratio=None, max_counts=50, counts_interval=10, min_counts=None, num_iter=500, num_runs=10): r"""Subsamples data to iteratively calculate power Parameters ---------- test : function The statistical test which accepts a list of arrays of values (sample ids or numeric values) and returns a p value or one-dimensional array of p values. samples : array_like `samples` can be a list of lists or a list of arrays where each sublist or row in the array corresponds to a sampled group. draw_mode : {"ind", "matched"}, optional "matched" samples should be used when observations in samples have corresponding observations in other groups. For instance, this may be useful when working with regression data where :math:`x_{1}, x_{2}, ..., x_{n}` maps to :math:`y_{1}, y_{2}, ..., y_{n}`. Sample vectors must be the same length in "matched" mode. If there is no reciprocal relationship between samples, then "ind" mode should be used. alpha_pwr : float, optional The critical value used to calculate the power. ratio : 1-D array, optional The fraction of the sample counts which should be assigned to each group. If this is a 1-D array, it must be the same length as `samples`. If no value is supplied (`ratio` is None), then an equal number of observations will be drawn for each sample. In `matched` mode, this will be set to one. max_counts : positive int, optional The maximum number of samples per group to draw for effect size calculation. counts_interval : positive int, optional The difference between each subsampling count. min_counts : positive int, optional How many samples should be drawn for the smallest subsample. If this is None, the `counts_interval` will be used. num_iter : positive int, optional The number of p-values to generate for each point on the curve. num_runs : positive int, optional The number of times to calculate each curve. Returns ------- power : array The power calculated for each subsample at each count. The array has `num_runs` rows, a length with the same number of elements as `sample_counts` and a depth equal to the number of p values returned by `test`. If `test` returns a float, the returned array will be two-dimensional instead of three. sample_counts : array The number of samples drawn at each power calculation. Raises ------ ValueError If the `mode` is "matched", an error will occur if the arrays in `samples` are not the same length. ValueError There is a ValueError if there are fewer samples than the minimum count. ValueError If the `counts_interval` is greater than the difference between the sample start and the max value, the function raises a ValueError. ValueError There are not an equal number of groups in `samples` and in `ratios`. TypeError `test` does not return a float or a 1-dimensional numpy array. Examples -------- Let's say we wanted to look at the relationship between the presence of a specific bacteria, *Gardnerella vaginalis* in the vaginal community, and the probability of a pre or post menopausal woman experiencing a urinary tract infection (UTI). Healthy women were enrolled in the study either before or after menopause, and followed for eight weeks. Participants submitted fecal samples at the beginning of the study, and were then followed for clinical symptoms of a UTI. A confirmed UTI was an endpoint in the study. Using available literature and 16S sequencing, a set of candidate taxa were identified as correlated with UTIs, including *G. vaginalis*. In the 100 women (50 premenopausal and 50 postmenopausal samples) who had UTIs, the presence or absence of *G. vaginalis* was confirmed with quantitative PCR. We can model the probability that detectable *G. vaginalis* was found in these samples using a binomial model. (*Note that this is a simulation.*) >>> import numpy as np >>> np.random.seed(25) >>> pre_rate = np.random.binomial(1, 0.85, size=(50,)) >>> pre_rate.sum() 45 >>> pos_rate = np.random.binomial(1, 0.40, size=(50,)) >>> pos_rate.sum() 21 Let's set up a test function, so we can test the probability of finding a difference in frequency between the two groups. We'll use `scipy.stats.chisquare` to look for the difference in frequency between groups. >>> from scipy.stats import chisquare >>> test = lambda x: chisquare(np.array([x[i].sum() for i in ... range(len(x))]))[1] Let's make sure that our two distributions are different. >>> print(round(test([pre_rate, pos_rate]), 3)) 0.003 Since there are an even number of samples, and we don't have enough information to try controlling the data, we'll use `skbio.stats.power.subsample_power` to compare the two groups. If we had metadata about other risk factors, like a reproductive history, BMI, tobacco use, we might want to use `skbio.stats.power.subsample_paired_power`. We'll also use "ind" `draw_mode`, since there is no linkage between the two groups of samples. >>> from skbio.stats.power import subsample_power >>> pwr_est, counts = subsample_power(test=test, ... samples=[pre_rate, pos_rate], ... num_iter=100, ... num_runs=5, ... counts_interval=5) >>> counts array([ 5, 10, 15, 20, 25, 30, 35, 40, 45]) >>> np.nanmean(pwr_est, axis=0) # doctest: +NORMALIZE_WHITESPACE array([ 0.056, 0.074, 0.226, 0.46 , 0.61 , 0.806, 0.952, 1. , 1. ]) >>> counts[np.nanmean(pwr_est, axis=0) > 0.8].min() 30 So, we can estimate that we will see a significant difference in the presence of *G. vaginalis* in the stool of pre and post women with UTIs if we have at least 30 samples per group. If we wanted to test the relationship of a second candidate taxa which is more rare in the population, but may have a similar effect, based on available literature, we might also start by trying to identify 30 samples per group where the second candidate taxa is present. Suppose, now, that we want to test that a secondary metabolite seen only in the presence of *G vaginalis* to see if it is also correlated with UTIs. We can model the abundance of the metabolite as a normal distribution. >>> met_pos = (np.random.randn(pre_rate.sum() + pos_rate.sum()) * 2000 + ... 2500) >>> met_pos[met_pos < 0] = 0 >>> met_neg = met_neg = (np.random.randn(100 - (pre_rate.sum() + ... pos_rate.sum())) * 2000 + 500) >>> met_neg[met_neg < 0] = 0 Let's compare the populations with a kruskal-wallis test. Physically, there cannot be a negative concentration of a chemical, so we've set the lower bound at 0. This means that we can no longer assume our distribution is normal. >>> from scipy.stats import kruskal >>> def metabolite_test(x): ... return kruskal(x[0], x[1])[1] >>> print(round(metabolite_test([met_pos, met_neg]), 3)) 0.005 When we go to perform the statistical test on all the data, you might notice that there are twice as many samples from women with *G. vaginalis* than those without. It might make sense to account for this difference when we're testing power. So, we're going to set the `ratio` parameter, which lets us draw twice as many samples from women with *G. vaginalis*. >>> pwr_est2, counts2 = subsample_power(test=metabolite_test, ... samples=[met_pos, met_neg], ... counts_interval=5, ... num_iter=100, ... num_runs=5, ... ratio=[2, 1]) >>> counts2 array([ 5., 10., 15., 20., 25., 30.]) >>> np.nanmean(pwr_est2, axis=0) array([ 0.14 , 0.272, 0.426, 0.646, 0.824, 0.996]) >>> counts2[np.nanmean(pwr_est2, axis=0) > 0.8].min() 25.0 When we consider the number of samples per group needed in the power analysis, we need to look at the ratio. The analysis says that we need 25 samples in the smallest group, in this case, the group of women without *G. vaginalis* and 50 samples from women with *G. vaginalis* to see a significant difference in the abundance of our secondary metabolite at 80% power. """ # Checks the inputs ratio, num_p, sample_counts = \ _check_subsample_power_inputs(test=test, samples=samples, draw_mode=draw_mode, ratio=ratio, min_counts=min_counts, max_counts=max_counts, counts_interval=counts_interval) # Prealocates the power array power = np.zeros((num_runs, len(sample_counts), num_p)) # Calculates the power instances for id2, c in enumerate(sample_counts): count = np.round(c * ratio, 0).astype(int) for id1 in range(num_runs): ps = _compare_distributions(test=test, samples=samples, num_p=num_p, counts=count, num_iter=num_iter, mode=draw_mode) power[id1, id2, :] = _calculate_power(ps, alpha_pwr) power = power.squeeze() return power, sample_counts @experimental(as_of="0.4.0") def subsample_paired_power(test, meta, cat, control_cats, order=None, strict_match=True, alpha_pwr=0.05, max_counts=50, counts_interval=10, min_counts=None, num_iter=500, num_runs=10): r"""Estimates power iteratively using samples with matching metadata Parameters ---------- test : function The statistical test which accepts a list of arrays sample ids and returns a p value. meta : pandas.DataFrame The metadata associated with the samples. cat : str The metadata category being varied between samples. control_cats : list The metadata categories to be used as controls. For example, if you wanted to vary age (`cat` = "AGE"), you might want to control for gender and health status (i.e. `control_cats` = ["SEX", "HEALTHY"]). order : list, optional The order of groups in the category. This can be used to limit the groups selected. For example, if there's a category with groups 'A', 'B' and 'C', and you only want to look at A vs B, `order` would be set to ['A', 'B']. strict_match : bool, optional This determines how data is grouped using `control_cats`. If a sample within `meta` has an undefined value (NaN) for any of the columns in `control_cats`, the sample will not be considered as having a match and will be ignored when `strict_match` is True. If `strict_match` is False, missing values (NaN) in the `control_cats` can be considered matches. alpha_pwr : float, optional The critical value used to calculate the power. max_counts : positive int, optional The maximum number of observations per sample to draw for effect size calculation. counts_interval : positive int, optional The difference between each subsampling count. min_counts : positive int, optional How many samples should be drawn for the smallest subsample. If this is None, the `counts_interval` will be used. num_iter : positive int, optional The number of p-values to generate for each point on the curve. num_runs : positive int, optional The number of times to calculate each curve. Returns ------- power : array The power calculated for each subsample at each count. The array is `num_runs` rows, a length with the same number of elements as `sample_counts` and a depth equal to the number of p values returned by `test`. If `test` returns a float, the returned array will be two-dimensional instead of three. sample_counts : array The number of samples drawn at each power calculation. Raises ------ ValueError There is a ValueError if there are fewer samples than the minimum count. ValueError If the `counts_interval` is greater than the difference between the sample start and the max value, the function raises a ValueError. TypeError `test` does not return a float or a 1-dimensional numpy array. Examples -------- Assume you are interested in the role of a specific cytokine of protein translocation in myeloid-lineage cells. You are able to culture two macrophage lineages (bone marrow derived phagocytes and peritoneally-derived macrophages). Due to unfortunate circumstances, your growth media must be acquired from multiple sources (lab, company A, company B). Also unfortunate, you must use labor-intensive low throughput assays. You have some preliminary measurements, and you'd like to predict how many (more) cells you need to analyze for 80% power. You have information about 60 cells, which we'll simulate below. Note that we are setting a random seed value for consistency. >>> import numpy as np >>> import pandas as pd >>> np.random.seed(25) >>> data = pd.DataFrame.from_dict({ ... 'CELL_LINE': np.random.binomial(1, 0.5, size=(60,)), ... 'SOURCE': np.random.binomial(2, 0.33, size=(60,)), ... 'TREATMENT': np.hstack((np.zeros((30)), np.ones((30)))), ... 'INCUBATOR': np.random.binomial(1, 0.2, size=(60,))}) >>> data['OUTCOME'] = (0.25 + data.TREATMENT * 0.25) + \ ... np.random.randn(60) * (0.1 + data.SOURCE/10 + data.CELL_LINE/5) >>> data.loc[data.OUTCOME < 0, 'OUTCOME'] = 0 >>> data.loc[data.OUTCOME > 1, 'OUTCOME'] = 1 We will approach this by assuming that the distribution of our outcome is not normally distributed, and apply a kruskal-wallis test to compare between the cytokine treated and untreated cells. >>> from scipy.stats import kruskal >>> f = lambda x: kruskal(*[data.loc[i, 'OUTCOME'] for i in x])[1] Let's check that cytokine treatment has a significant effect across all the cells. >>> treatment_stat = [g for g in data.groupby('TREATMENT').groups.values()] >>> round(f(treatment_stat), 17) 0.00193863362662502 Now, let's pick the control categories. It seems reasonable to assume there may be an effect of cell line on the treatment outcome, which may be attributed to differences in receptor expression. It may also be possible that there are differences due cytokine source. Incubators were maintained under the same conditions throughout the experiment, within one degree of temperature difference at any given time, and the same level of CO2. So, at least initially, let's ignore differences due to the incubator. It's recommended that as a first pass analysis, control variables be selected based on an idea of what may be biologically relevant to the system, although further iteration might encourage the consideration of variable with effect sizes similar, or larger than the variable of interest. >>> control_cats = ['SOURCE', 'CELL_LINE'] >>> from skbio.stats.power import subsample_paired_power >>> pwr, cnt = subsample_paired_power(test=f, ... meta=data, ... cat='TREATMENT', ... control_cats=control_cats, ... counts_interval=5, ... num_iter=25, ... num_runs=5) >>> cnt array([ 5., 10., 15., 20.]) >>> pwr.mean(0) array([ 0.24 , 0.528, 0.68 , 0.88 ]) >>> pwr.std(0).round(3) array([ 0.088, 0.127, 0.168, 0.08 ]) Estimating off the power curve, it looks like 20 cells per group may provide adequate power for this experiment, although the large variance in power might suggest extending the curves or increasing the number of samples per group. """ # Handles the order argument if order is None: order = sorted(meta.groupby(cat).groups.keys()) order = np.array(order) # Checks for the number of sampling pairs available meta_pairs, index = _identify_sample_groups(meta, cat, control_cats, order, strict_match) min_obs = min([_get_min_size(meta, cat, control_cats, order, strict_match), np.floor(len(index)*0.9)]) sub_ids = _draw_paired_samples(meta_pairs, index, min_obs) ratio, num_p, sample_counts = \ _check_subsample_power_inputs(test=test, samples=sub_ids, draw_mode='matched', min_counts=min_counts, max_counts=max_counts, counts_interval=counts_interval) # Prealocates the power array power = np.zeros((num_runs, len(sample_counts), num_p)) # Calculates power instances for id2, c in enumerate(sample_counts): for id1 in range(num_runs): ps = np.zeros((num_p, num_iter)) for id3 in range(num_iter): subs = _draw_paired_samples(meta_pairs, index, c) ps[:, id3] = test(subs) power[id1, id2, :] = _calculate_power(ps, alpha_pwr) power = power.squeeze() return power, sample_counts @experimental(as_of="0.4.0") def confidence_bound(vec, alpha=0.05, df=None, axis=None): r"""Calculates a confidence bound assuming a normal distribution Parameters ---------- vec : array_like The array of values to use in the bound calculation. alpha : float, optional The critical value, used for the confidence bound calculation. df : float, optional The degrees of freedom associated with the distribution. If None is given, df is assumed to be the number of elements in specified axis. axis : positive int, optional The axis over which to take the deviation. When axis is None, a single value will be calculated for the whole matrix. Returns ------- bound : float The confidence bound around the mean. The confidence interval is [mean - bound, mean + bound]. """ # Determines the number of non-nan counts vec = np.asarray(vec) vec_shape = vec.shape if axis is None and len(vec_shape) == 1: num_counts = vec_shape[0] - np.isnan(vec).sum() elif axis is None: num_counts = vec_shape[0] * vec_shape[1] - np.isnan(vec).sum() else: num_counts = vec_shape[axis] - np.isnan(vec).sum() / \ (vec_shape[0] * vec_shape[1]) # Gets the df if not supplied if df is None: df = num_counts - 1 # Calculates the bound # In the conversion from scipy.stats.nanstd -> np.nanstd `ddof=1` had to be # added to match the scipy default of `bias=False`. bound = np.nanstd(vec, axis=axis, ddof=1) / np.sqrt(num_counts - 1) * \ scipy.stats.t.ppf(1 - alpha / 2, df) return bound @experimental(as_of="0.4.0") def paired_subsamples(meta, cat, control_cats, order=None, strict_match=True): r"""Draws a list of samples varied by `cat` and matched for `control_cats` This function is designed to provide controlled samples, based on a metadata category. For example, one could control for age, sex, education level, and diet type while measuring exercise frequency. Parameters ---------- meta : pandas.DataFrame The metadata associated with the samples. cat : str, list The metadata category (or a list of categories) for comparison. control_cats : list The metadata categories to be used as controls. For example, if you wanted to vary age (`cat` = "AGE"), you might want to control for gender and health status (i.e. `control_cats` = ["SEX", "HEALTHY"]) order : list, optional The order of groups in the category. This can be used to limit the groups selected. For example, if there's a category with groups 'A', 'B' and 'C', and you only want to look at A vs B, `order` would be set to ['A', 'B']. strict_match: bool, optional This determines how data is grouped using `control_cats`. If a sample within `meta` has an undefined value (`NaN`) for any of the columns in `control_cats`, the sample will not be considered as having a match and will be ignored when `strict_match` is True. If `strict_match` is False, missing values (NaN) in the `control_cats` can be considered matches. Returns ------- ids : array a set of ids which satisfy the criteria. These are not grouped by `cat`. An empty array indicates there are no sample ids which satisfy the requirements. Examples -------- If we have a mapping file for a set of random individuals looking at housing, sex, age and antibiotic use. >>> import pandas as pd >>> import numpy as np >>> meta = {'SW': {'HOUSING': '2', 'SEX': 'M', 'AGE': np.nan, 'ABX': 'Y'}, ... 'TS': {'HOUSING': '2', 'SEX': 'M', 'AGE': '40s', 'ABX': 'Y'}, ... 'CB': {'HOUSING': '3', 'SEX': 'M', 'AGE': '40s', 'ABX': 'Y'}, ... 'BB': {'HOUSING': '1', 'SEX': 'M', 'AGE': '40s', 'ABX': 'Y'}} >>> meta = pd.DataFrame.from_dict(meta, orient="index") >>> meta #doctest: +SKIP ABX HOUSING AGE SEX BB Y 1 40s M CB Y 3 40s M SW Y 2 NaN M TS Y 2 40s M We may want to vary an individual's housing situation, while holding constant their age, sex and antibiotic use so we can estimate the effect size for housing, and later compare it to the effects of other variables. >>> from skbio.stats.power import paired_subsamples >>> ids = paired_subsamples(meta, 'HOUSING', ['SEX', 'AGE', 'ABX']) >>> np.hstack(ids) #doctest: +ELLIPSIS array(['BB', 'TS', 'CB']...) So, for this set of data, we can match TS, CB, and BB based on their age, sex, and antibiotic use. SW cannot be matched in either group because `strict_match` was true, and there is missing AGE data for this sample. """ # Handles the order argument if order is None: order = sorted(meta.groupby(cat).groups.keys()) order = np.array(order) # Checks the groups in the category min_obs = _get_min_size(meta, cat, control_cats, order, strict_match) # Identifies all possible subsamples meta_pairs, index = _identify_sample_groups(meta=meta, cat=cat, control_cats=control_cats, order=order, strict_match=strict_match) # Draws paired ids ids = _draw_paired_samples(meta_pairs=meta_pairs, index=index, num_samps=min_obs) return ids def _get_min_size(meta, cat, control_cats, order, strict_match): """Determines the smallest group represented""" if strict_match: all_cats = copy.deepcopy(control_cats) all_cats.append(cat) meta = meta[all_cats].dropna() return meta.groupby(cat).count().loc[order, control_cats[0]].min() def _check_nans(x, switch=False): r"""Returns False if x is a nan and True is x is a string or number """ if isinstance(x, str): return True elif isinstance(x, (float, int)): return not np.isnan(x) elif switch and isinstance(x, (list, tuple)) and np.nan in x: return False elif switch and isinstance(x, (list, tuple)): return True else: raise TypeError('input must be a string, float or a nan') def _calculate_power(p_values, alpha=0.05): r"""Calculates statistical power empirically Parameters ---------- p_values : 1-D array A 1-D numpy array with the test results. alpha : float The critical value for the power calculation. Returns ------- power : float The empirical power, or the fraction of observed p values below the critical value. """ p_values = np.atleast_2d(p_values) w = (p_values < alpha).sum(axis=1)/p_values.shape[1] return w def _compare_distributions(test, samples, num_p, counts=5, mode="ind", num_iter=100): r"""Compares two distribution arrays iteratively Parameters ---------- test : function The statistical test which accepts an array_like of sample ids (list of lists) and returns a p-value. This can be a one-dimensional array, or a float. samples : list of arrays A list where each 1-d array represents a sample. If `mode` is "matched", there must be an equal number of observations in each sample. num_p : positive int, optional The number of p-values returned by the test. counts : positive int or 1-D array, optional The number of samples to draw from each distribution. If this is a 1-D array, the length must correspond to the number of samples. The function will not draw more observations than are in a sample. In "matched" `mode`, the same number of observations will be drawn from each group. mode : {"ind", "matched", "paired"}, optional "matched" samples should be used when observations in samples have corresponding observations in other groups. For instance, this may be useful when working with regression data where :math:`x_{1}, x_{2}, ..., x_{n}` maps to :math:`y_{1}, y_{2}, ... , y_{n}`. num_iter : positive int, optional Default 1000. The number of p-values to generate for each point on the curve. Returns ------- p_values : array The p-values for the subsampled tests. If `test` returned a single p value, p_values is a one-dimensional array. If `test` returned an array, `p_values` has dimensions `num_iter` x `num_p` Raises ------ ValueError If mode is not "ind" or "matched". ValueError If the arrays in samples are not the same length in "matched" mode. ValueError If counts is a 1-D array and counts and samples are different lengths. """ # Prealocates the pvalue matrix p_values = np.zeros((num_p, num_iter)) # Determines the number of samples per group num_groups = len(samples) samp_lens = [len(sample) for sample in samples] if isinstance(counts, int): counts = np.array([counts] * num_groups) for idx in range(num_iter): if mode == "matched": pos = np.random.choice(np.arange(0, samp_lens[0]), counts[0], replace=False) subs = [sample[pos] for sample in samples] else: subs = [np.random.choice(np.array(pop), counts[i], replace=False) for i, pop in enumerate(samples)] p_values[:, idx] = test(subs) if num_p == 1: p_values = p_values.squeeze() return p_values def _check_subsample_power_inputs(test, samples, draw_mode='ind', ratio=None, max_counts=50, counts_interval=10, min_counts=None): r"""Makes sure that everything is sane before power calculations Parameters ---------- test : function The statistical test which accepts a list of arrays of values (sample ids or numeric values) and returns a p value or one-dimensional array of p values. samples : array_like `samples` can be a list of lists or a list of arrays where each sublist or row in the array corresponds to a sampled group. draw_mode : {"ind", "matched"}, optional "matched" samples should be used when observations in samples have corresponding observations in other groups. For instance, this may be useful when working with regression data where :math:`x_{1}, x_{2}, ..., x_{n}` maps to :math:`y_{1}, y_{2}, ..., y_{n}`. Sample vectors must be the same length in "matched" mode. If there is no reciprocal relationship between samples, then "ind" mode should be used. ratio : 1-D array, optional The fraction of the sample counts which should be assigned to each group. If this is a 1-D array, it must be the same length as `samples`. If no value is supplied (`ratio` is None), then an equal number of observations will be drawn for each sample. In `matched` mode, this will be set to one. max_counts : positive int, optional The maximum number of samples per group to draw for effect size calculation. counts_interval : positive int, optional The difference between each subsampling count. min_counts : positive int, optional How many samples should be drawn for the smallest subsample. If this is None, the `counts_interval` will be used. Returns ------- ratio : 1-D array The fraction of the sample counts which should be assigned to each group. num_p : positive integer The number of p values returned by `test`. sample_counts : array The number of samples drawn at each power calculation. Raises ------ ValueError If the `mode` is "matched", an error will occur if the arrays in `samples` are not the same length. ValueError There is a ValueError if there are fewer samples than the minimum count. ValueError If the `counts_interval` is greater than the difference between the sample start and the max value, the function raises a ValueError. ValueError There are not an equal number of groups in `samples` and in `ratios`. TypeError `test` does not return a float or a 1-dimensional numpy array. """ if draw_mode not in {'ind', 'matched'}: raise ValueError('mode must be "matched" or "ind".') # Determines the minimum number of ids in a category id_counts = np.array([len(id_) for id_ in samples]) num_ids = id_counts.min() # Determines the number of groups num_groups = len(samples) # Checks that "matched" mode is handled appropriately if draw_mode == "matched": for id_ in samples: if not len(id_) == num_ids: raise ValueError('Each vector in samples must be the same ' 'length in "matched" draw_mode.') # Checks the number of counts is appropriate if min_counts is None: min_counts = counts_interval if (max_counts - min_counts) < counts_interval: raise ValueError("No subsamples of the specified size can be drawn.") # Checks the ratio argument is sane if ratio is None or draw_mode == 'matched': ratio = np.ones((num_groups)) else: ratio = np.asarray(ratio) if not ratio.shape == (num_groups,): raise ValueError('There must be a ratio for each group.') ratio_counts = np.array([id_counts[i] / ratio[i] for i in range(num_groups)]) largest = ratio_counts.min() # Determines the number of p values returned by the test p_return = test(samples) if isinstance(p_return, float): num_p = 1 elif isinstance(p_return, np.ndarray) and len(p_return.shape) == 1: num_p = p_return.shape[0] else: raise TypeError('test must return a float or one-dimensional array.') # Calculates the same counts sample_counts = np.arange(min_counts, min(max_counts, largest), counts_interval) return ratio, num_p, sample_counts def _identify_sample_groups(meta, cat, control_cats, order, strict_match): """Aggregates samples matches for `control_cats` that vary by `cat` Parameters ---------- meta : pandas.DataFrame The metadata associated with the samples. cat : str, list The metadata category (or a list of categories) for comparison. control_cats : list The metadata categories to be used as controls. For example, if you wanted to vary age (`cat` = "AGE"), you might want to control for gender and health status (i.e. `control_cats` = ["SEX", "HEALTHY"]) order : list The order of groups in the category. This can be used to limit the groups selected. For example, if there's a category with groups 'A', 'B' and 'C', and you only want to look at A vs B, `order` would be set to ['A', 'B']. ctrl_pos : int The location of the smallest group in `order`. strict_match: bool, optional This determines how data is grouped using `control_cats`. If a sample within `meta` has an undefined value (`NaN`) for any of the columns in `control_cats`, the sample will not be considered as having a match and will be ignored when `strict_match` is True. If `strict_match` is False, missing values (NaN) in the `control_cats` can be considered matches. Returns ------- meta_pairs : dict Describes the categories matched for metadata. The `control_cat`-grouped samples are numbered, corresponding to the second list in `index`. The group is keyed to the list of sample arrays with the same length of `order`. index : list A list of numpy arrays describing the positions of samples to be drawn. The first array is an index array. The second gives an integer corresponding to the `control_cat`-group, and the third lists the position of the reference group sample in the list of samples. """ # Sets up variables to be filled meta_pairs = {} index = [] i1 = 0 # Groups the data by the control groups ctrl_groups = meta.groupby(control_cats).groups # Identifies the samples that satisfy the control pairs. Keys are iterated # in sorted order so that results don't change with different dictionary # ordering. for g in sorted(ctrl_groups, key=lambda k: str(k)): ids = ctrl_groups[g] # If strict_match, Skips over data that has nans if not _check_nans(g, switch=True) and strict_match: continue # Draws the samples that are matched for control cats m_ids = meta.loc[ids].groupby(cat).groups # Checks if samples from the cat groups are represented in those # Samples id_vecs = [sorted(m_ids[o]) for o in order if o in m_ids] # If all groups are represented, the index and results are retained if len(id_vecs) == len(order): min_vec = np.array([len(v) for v in id_vecs]) loc_vec = np.arange(0, min_vec.min()) meta_pairs[i1] = id_vecs index.append(np.zeros(loc_vec.shape) + i1) i1 = i1 + 1 # If the groups are not represented, an empty array gets passed else: index.append(np.array([])) # Converts index to a 1d array index = np.hstack(index) # If index is empty, sets up meta_paris with a no key. if not meta_pairs: meta_pairs['no'] = order return meta_pairs, index def _draw_paired_samples(meta_pairs, index, num_samps): """Draws a random set of ids from a matched list Parameters ---------- meta_pairs : dict Describes the categories matched for metadata. The `control_cat`-grouped samples are numbered, corresponding to the second list in `index`. The group is keyed to the list of sample arrays with the same length of `order`. index : list A list of numpy arrays describing the positions of samples to be drawn. The first array is an index array. The second gives an integer corresponding to the `control_cat`-group, and the third lists the position of the reference group sample in the list of samples. Returns ------- ids : list A set of randomly selected ids groups from each group. """ # Handles an empty paired vector if 'no' in meta_pairs: return [np.array([]) for o in meta_pairs['no']] # Identifies the absolute positions of the control group being drawn set_pos = np.random.choice(index, int(num_samps), replace=False).astype(int) subs = [] # Draws the other groups. Get a collection.Counter object for simplicity counter = collections.Counter(set_pos) # counter.items() order isn't guaranteed in python 3.6 and then the random # choice isn't reproducible between python version, even specifying seed; # so we access such values through sets. set_list = set(set_pos) # then, as stated by @RNAer, since we can't assure that items in sets are # ordered, we choose to order set_list before accessing values set_list = sorted(set_list) # now set_list is ordered and we can iterate over it to get counter obj for set_ in set_list: num_ = counter[set_] r2 = [np.random.choice(col, num_, replace=False) for col in meta_pairs[set_]] subs.append(r2) ids = [np.hstack(ids) for ids in zip(*subs)] return ids def _calculate_power_curve(test, samples, sample_counts, ratio=None, mode='ind', num_iter=1000, alpha=0.05): r"""Generates an empirical power curve for the samples. Parameters ---------- test : function The statistical test which accepts a list of arrays of values and returns a p value. samples : array_like `samples` can be a list of lists or an array where each sublist or row in the array corresponds to a sampled group. sample_counts : 1-D array A vector of the number of samples which should be sampled in each curve. mode : {"ind", "matched"}, optional "matched" samples should be used when observations in samples have corresponding observations in other groups. For instance, this may be useful when working with regression data where :math:`x_{1}, x_{2}, ..., x_{n}` maps to :math:`y_{1}, y_{2}, ... , y_{n}`. ratio : 1-D array, optional The fraction of the sample counts which should be assigned to each group. If this is a 1-D array, it must be the same length as `samples`. If no value is supplied (`ratio` is None), then an equal number of observations will be drawn for each sample. num_iter : int The default is 1000. The number of p-values to generate for each point on the curve. Returns ------- p_values : array The p-values associated with the input sample counts. Raises ------ ValueError If ratio is an array and ratio is not the same length as samples """ # Casts array-likes to arrays sample_counts = np.asarray(sample_counts) # Determines the number of groups num_groups = len(samples) num_samps = len(sample_counts) if isinstance(alpha, float): vec = True pwr = np.zeros((num_samps)) alpha = np.array([alpha]) else: vec = False num_crit = alpha.shape[0] pwr = np.zeros((num_crit, num_samps)) # Checks the ratio argument if ratio is None: ratio = np.ones((num_groups)) ratio = np.asarray(ratio) if not ratio.shape == (num_groups,): raise ValueError('There must be a ratio for each group.') # Loops through the sample sizes for id2, s in enumerate(sample_counts): count = np.round(s * ratio, 0).astype(int) for id1, a in enumerate(alpha): ps = _compare_distributions(test=test, samples=samples, counts=count, num_p=1, num_iter=num_iter, mode=mode) if vec: pwr[id2] = _calculate_power(ps, a) else: pwr[id1, id2] = _calculate_power(ps, a) return pwr scikit-bio-0.5.9/skbio/stats/tests/000077500000000000000000000000001446255456000172045ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/tests/__init__.py000066400000000000000000000005411446255456000213150ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/stats/tests/data/000077500000000000000000000000001446255456000201155ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/tests/data/cr_data_out000066400000000000000000000004511446255456000223240ustar00rootroot00000000000000Grouped by "bar", probability: 0.011000 For group "Foo", the group means is: -1.439800 The info is: [('mean', -1.4398), ('std', 1.3184)] For group "Bar", the group means is: 5.958900 Cannot calculate the first difference with a window of size (3). The info is: [('mean', 5.9589), ('std', 2.7942)] scikit-bio-0.5.9/skbio/stats/tests/data/cr_data_raw000066400000000000000000000003221446255456000223030ustar00rootroot00000000000000Grouped by "bar" For group "Foo": The trajectory is: [-2.675, -0.251, -2.8322, 0.0] For group "Bar": Cannot calculate the first difference with a window of size (3). The trajectory is: [9.6823, 2.9511, 5.2434] scikit-bio-0.5.9/skbio/stats/tests/data/cr_no_data_out000066400000000000000000000001321446255456000230140ustar00rootroot00000000000000Grouped by "foo": This group can not be used. All groups should have more than 1 element. scikit-bio-0.5.9/skbio/stats/tests/data/cr_no_data_raw000066400000000000000000000000001446255456000227700ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/stats/tests/data/gr_w_msg_out000066400000000000000000000002401446255456000225270ustar00rootroot00000000000000For group "Bar", the group means is: 5.958900 Cannot calculate the first difference with a window of size (3). The info is: [('mean', 5.9589), ('std', 2.7942)] scikit-bio-0.5.9/skbio/stats/tests/data/gr_w_msg_raw000066400000000000000000000001761446255456000225210ustar00rootroot00000000000000For group "Bar": Cannot calculate the first difference with a window of size (3). The trajectory is: [9.6823, 2.9511, 5.2434] scikit-bio-0.5.9/skbio/stats/tests/data/gr_wo_msg_out000066400000000000000000000001411446255456000227060ustar00rootroot00000000000000For group "Foo", the group means is: -1.439800 The info is: [('mean', -1.4398), ('std', 1.3184)] scikit-bio-0.5.9/skbio/stats/tests/data/gr_wo_msg_raw000066400000000000000000000001031446255456000226660ustar00rootroot00000000000000For group "Foo": The trajectory is: [-2.675, -0.251, -2.8322, 0.0] scikit-bio-0.5.9/skbio/stats/tests/data/vr_out000066400000000000000000000007001446255456000213530ustar00rootroot00000000000000Trajectory algorithm: wdiff ** This output is weighted ** Grouped by "foo": This group can not be used. All groups should have more than 1 element. Grouped by "bar", probability: 0.011000 For group "Foo", the group means is: -1.439800 The info is: [('mean', -1.4398), ('std', 1.3184)] For group "Bar", the group means is: 5.958900 Cannot calculate the first difference with a window of size (3). The info is: [('mean', 5.9589), ('std', 2.7942)] scikit-bio-0.5.9/skbio/stats/tests/data/vr_raw000066400000000000000000000004171446255456000213420ustar00rootroot00000000000000Trajectory algorithm: wdiff ** This output is weighted ** Grouped by "bar" For group "Foo": The trajectory is: [-2.675, -0.251, -2.8322, 0.0] For group "Bar": Cannot calculate the first difference with a window of size (3). The trajectory is: [9.6823, 2.9511, 5.2434] scikit-bio-0.5.9/skbio/stats/tests/data/vr_real_out000066400000000000000000000010051446255456000223550ustar00rootroot00000000000000Trajectory algorithm: avg Grouped by "Description": This group can not be used. All groups should have more than 1 element. Grouped by "DOB": This group can not be used. All groups should have more than 1 element. Grouped by "Weight": This group can not be used. All groups should have more than 1 element. Grouped by "Treatment", probability: 0.933100 For group "Control", the group means is: 4.050800 The info is: [('avg', 4.0508)] For group "Fast", the group means is: 4.159600 The info is: [('avg', 4.1596)] scikit-bio-0.5.9/skbio/stats/tests/data/vr_real_raw000066400000000000000000000003151446255456000223420ustar00rootroot00000000000000Trajectory algorithm: avg Grouped by "Treatment" For group "Control": The trajectory is: [2.3694, 3.3716, 5.4452, 4.5704, 4.4972] For group "Fast": The trajectory is: [7.2220, 4.2726, 1.1169, 4.0271] scikit-bio-0.5.9/skbio/stats/tests/test_composition.py000066400000000000000000001557731446255456000232020ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import functools from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas.testing as pdt from numpy.random import normal import pandas as pd import scipy import copy from skbio import TreeNode from skbio.util import assert_data_frame_almost_equal from skbio.stats.distance import DistanceMatrixError from skbio.stats.composition import (closure, multiplicative_replacement, perturb, perturb_inv, power, inner, clr, clr_inv, ilr, ilr_inv, alr, alr_inv, sbp_basis, _gram_schmidt_basis, centralize, _holm_bonferroni, ancom, vlr, pairwise_vlr, tree_basis) from scipy.sparse import coo_matrix def assert_coo_allclose(res, exp, rtol=1e-7, atol=1e-7): res_data = np.vstack((res.row, res.col, res.data)).T exp_data = np.vstack((exp.row, exp.col, exp.data)).T # sort by row and col res_data = res_data[res_data[:, 1].argsort()] res_data = res_data[res_data[:, 0].argsort()] exp_data = exp_data[exp_data[:, 1].argsort()] exp_data = exp_data[exp_data[:, 0].argsort()] npt.assert_allclose(res_data, exp_data, rtol=rtol, atol=atol) class CompositionTests(TestCase): def setUp(self): # Compositional data self.cdata1 = np.array([[2, 2, 6], [4, 4, 2]]) self.cdata2 = np.array([2, 2, 6]) self.cdata3 = np.array([[1, 2, 3, 0, 5], [1, 0, 0, 4, 5], [1, 2, 3, 4, 5]]) self.cdata4 = np.array([1, 2, 3, 0, 5]) self.cdata5 = [[2, 2, 6], [4, 4, 2]] self.cdata6 = [[1, 2, 3, 0, 5], [1, 0, 0, 4, 5], [1, 2, 3, 4, 5]] self.cdata7 = [np.exp(1), 1, 1] self.cdata8 = [np.exp(1), 1, 1, 1] # Simplicial orthonormal basis obtained from Gram-Schmidt self.ortho1 = [[0.44858053, 0.10905743, 0.22118102, 0.22118102], [0.3379924, 0.3379924, 0.0993132, 0.22470201], [0.3016453, 0.3016453, 0.3016453, 0.09506409]] # Real data self.rdata1 = [[0.70710678, -0.70710678, 0., 0.], [0.40824829, 0.40824829, -0.81649658, 0.], [0.28867513, 0.28867513, 0.28867513, -0.8660254]] # Bad datasets # negative count self.bad1 = np.array([1, 2, -1]) # zero count self.bad2 = np.array([[[1, 2, 3, 0, 5]]]) def test_closure(self): npt.assert_allclose(closure(self.cdata1), np.array([[.2, .2, .6], [.4, .4, .2]])) npt.assert_allclose(closure(self.cdata2), np.array([.2, .2, .6])) npt.assert_allclose(closure(self.cdata5), np.array([[.2, .2, .6], [.4, .4, .2]])) with self.assertRaises(ValueError): closure(self.bad1) with self.assertRaises(ValueError): closure(self.bad2) # make sure that inplace modification is not occurring closure(self.cdata2) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_closure_warning(self): with self.assertRaises(ValueError): closure([0., 0., 0.]) with self.assertRaises(ValueError): closure([[0., 0., 0.], [0., 5., 5.]]) def test_perturb(self): pmat = perturb(closure(self.cdata1), closure(np.array([1, 1, 1]))) npt.assert_allclose(pmat, np.array([[.2, .2, .6], [.4, .4, .2]])) pmat = perturb(closure(self.cdata1), closure(np.array([10, 10, 20]))) npt.assert_allclose(pmat, np.array([[.125, .125, .75], [1./3, 1./3, 1./3]])) pmat = perturb(closure(self.cdata1), closure(np.array([10, 10, 20]))) npt.assert_allclose(pmat, np.array([[.125, .125, .75], [1./3, 1./3, 1./3]])) pmat = perturb(closure(self.cdata2), closure([1, 2, 1])) npt.assert_allclose(pmat, np.array([1./6, 2./6, 3./6])) pmat = perturb(closure(self.cdata5), closure(np.array([1, 1, 1]))) npt.assert_allclose(pmat, np.array([[.2, .2, .6], [.4, .4, .2]])) with self.assertRaises(ValueError): perturb(closure(self.cdata5), self.bad1) # make sure that inplace modification is not occurring perturb(self.cdata2, [1, 2, 3]) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_power(self): pmat = power(closure(self.cdata1), 2) npt.assert_allclose(pmat, np.array([[.04/.44, .04/.44, .36/.44], [.16/.36, .16/.36, .04/.36]])) pmat = power(closure(self.cdata2), 2) npt.assert_allclose(pmat, np.array([.04, .04, .36])/.44) pmat = power(closure(self.cdata5), 2) npt.assert_allclose(pmat, np.array([[.04/.44, .04/.44, .36/.44], [.16/.36, .16/.36, .04/.36]])) with self.assertRaises(ValueError): power(self.bad1, 2) # make sure that inplace modification is not occurring power(self.cdata2, 4) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_perturb_inv(self): pmat = perturb_inv(closure(self.cdata1), closure([.1, .1, .1])) imat = perturb(closure(self.cdata1), closure([10, 10, 10])) npt.assert_allclose(pmat, imat) pmat = perturb_inv(closure(self.cdata1), closure([1, 1, 1])) npt.assert_allclose(pmat, closure([[.2, .2, .6], [.4, .4, .2]])) pmat = perturb_inv(closure(self.cdata5), closure([.1, .1, .1])) imat = perturb(closure(self.cdata1), closure([10, 10, 10])) npt.assert_allclose(pmat, imat) with self.assertRaises(ValueError): perturb_inv(closure(self.cdata1), self.bad1) # make sure that inplace modification is not occurring perturb_inv(self.cdata2, [1, 2, 3]) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_inner(self): a = inner(self.cdata5, self.cdata5) npt.assert_allclose(a, np.array([[0.80463264, -0.50766667], [-0.50766667, 0.32030201]])) b = inner(self.cdata7, self.cdata7) npt.assert_allclose(b, 0.66666666666666663) # Make sure that orthogonality holds npt.assert_allclose(inner(self.ortho1, self.ortho1), np.identity(3), rtol=1e-04, atol=1e-06) with self.assertRaises(ValueError): inner(self.cdata1, self.cdata8) # make sure that inplace modification is not occurring inner(self.cdata1, self.cdata1) npt.assert_allclose(self.cdata1, np.array([[2, 2, 6], [4, 4, 2]])) def test_multiplicative_replacement(self): amat = multiplicative_replacement(closure(self.cdata3)) npt.assert_allclose(amat, np.array([[0.087273, 0.174545, 0.261818, 0.04, 0.436364], [0.092, 0.04, 0.04, 0.368, 0.46], [0.066667, 0.133333, 0.2, 0.266667, 0.333333]]), rtol=1e-5, atol=1e-5) amat = multiplicative_replacement(closure(self.cdata4)) npt.assert_allclose(amat, np.array([0.087273, 0.174545, 0.261818, 0.04, 0.436364]), rtol=1e-5, atol=1e-5) amat = multiplicative_replacement(closure(self.cdata6)) npt.assert_allclose(amat, np.array([[0.087273, 0.174545, 0.261818, 0.04, 0.436364], [0.092, 0.04, 0.04, 0.368, 0.46], [0.066667, 0.133333, 0.2, 0.266667, 0.333333]]), rtol=1e-5, atol=1e-5) with self.assertRaises(ValueError): multiplicative_replacement(self.bad1) with self.assertRaises(ValueError): multiplicative_replacement(self.bad2) # make sure that inplace modification is not occurring multiplicative_replacement(self.cdata4) npt.assert_allclose(self.cdata4, np.array([1, 2, 3, 0, 5])) def multiplicative_replacement_warning(self): with self.assertRaises(ValueError): multiplicative_replacement([0, 1, 2], delta=1) def test_clr(self): cmat = clr(closure(self.cdata1)) A = np.array([.2, .2, .6]) B = np.array([.4, .4, .2]) npt.assert_allclose(cmat, [np.log(A / np.exp(np.log(A).mean())), np.log(B / np.exp(np.log(B).mean()))]) cmat = clr(closure(self.cdata2)) A = np.array([.2, .2, .6]) npt.assert_allclose(cmat, np.log(A / np.exp(np.log(A).mean()))) cmat = clr(closure(self.cdata5)) A = np.array([.2, .2, .6]) B = np.array([.4, .4, .2]) npt.assert_allclose(cmat, [np.log(A / np.exp(np.log(A).mean())), np.log(B / np.exp(np.log(B).mean()))]) with self.assertRaises(ValueError): clr(self.bad1) with self.assertRaises(ValueError): clr(self.bad2) # make sure that inplace modification is not occurring clr(self.cdata2) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_clr_inv(self): npt.assert_allclose(clr_inv(self.rdata1), self.ortho1) npt.assert_allclose(clr(clr_inv(self.rdata1)), self.rdata1, rtol=1e-4, atol=1e-5) # make sure that inplace modification is not occurring clr_inv(self.rdata1) npt.assert_allclose(self.rdata1, np.array([[0.70710678, -0.70710678, 0., 0.], [0.40824829, 0.40824829, -0.81649658, 0.], [0.28867513, 0.28867513, 0.28867513, -0.8660254]])) def test_centralize(self): cmat = centralize(closure(self.cdata1)) npt.assert_allclose(cmat, np.array([[0.22474487, 0.22474487, 0.55051026], [0.41523958, 0.41523958, 0.16952085]])) cmat = centralize(closure(self.cdata5)) npt.assert_allclose(cmat, np.array([[0.22474487, 0.22474487, 0.55051026], [0.41523958, 0.41523958, 0.16952085]])) with self.assertRaises(ValueError): centralize(self.bad1) with self.assertRaises(ValueError): centralize(self.bad2) # make sure that inplace modification is not occurring centralize(self.cdata1) npt.assert_allclose(self.cdata1, np.array([[2, 2, 6], [4, 4, 2]])) def test_ilr(self): mat = closure(self.cdata7) npt.assert_array_almost_equal(ilr(mat), np.array([0.70710678, 0.40824829])) # Should give same result as inner npt.assert_allclose(ilr(self.ortho1), np.identity(3), rtol=1e-04, atol=1e-06) with self.assertRaises(ValueError): ilr(self.cdata1, basis=self.cdata1) # make sure that inplace modification is not occurring ilr(self.cdata1) npt.assert_allclose(self.cdata1, np.array([[2, 2, 6], [4, 4, 2]])) def test_ilr_basis(self): table = np.array([[1., 10.], [1.14141414, 9.90909091], [1.28282828, 9.81818182], [1.42424242, 9.72727273], [1.56565657, 9.63636364]]) basis = np.atleast_2d(clr([[0.80442968, 0.19557032]])) res = ilr(table, basis=basis) exp = np.array([[np.log(1/10)*np.sqrt(1/2)], [np.log(1.14141414 / 9.90909091)*np.sqrt(1/2)], [np.log(1.28282828 / 9.81818182)*np.sqrt(1/2)], [np.log(1.42424242 / 9.72727273)*np.sqrt(1/2)], [np.log(1.56565657 / 9.63636364)*np.sqrt(1/2)]]) npt.assert_allclose(res, exp) def test_ilr_basis_one_dimension_error(self): table = np.array([[1., 10.], [1.14141414, 9.90909091], [1.28282828, 9.81818182], [1.42424242, 9.72727273], [1.56565657, 9.63636364]]) basis = np.array([0.80442968, 0.19557032]) with self.assertRaises(ValueError): ilr(table, basis=basis) def test_ilr_inv(self): mat = closure(self.cdata7) npt.assert_array_almost_equal(ilr_inv(ilr(mat)), mat) npt.assert_allclose(ilr_inv(np.identity(3)), self.ortho1, rtol=1e-04, atol=1e-06) with self.assertRaises(ValueError): ilr_inv(self.cdata1, basis=self.cdata1) # make sure that inplace modification is not occurring ilr_inv(self.cdata1) npt.assert_allclose(self.cdata1, np.array([[2, 2, 6], [4, 4, 2]])) def test_ilr_basis_isomorphism(self): # tests to make sure that the isomorphism holds # with the introduction of the basis. basis = np.atleast_2d(clr([[0.80442968, 0.19557032]])) table = np.array([[np.log(1/10)*np.sqrt(1/2), np.log(1.14141414 / 9.90909091)*np.sqrt(1/2), np.log(1.28282828 / 9.81818182)*np.sqrt(1/2), np.log(1.42424242 / 9.72727273)*np.sqrt(1/2), np.log(1.56565657 / 9.63636364)*np.sqrt(1/2)]]).T lr = ilr_inv(table, basis=basis) res = ilr(lr, basis=basis) npt.assert_allclose(res, table) table = np.array([[1., 10.], [1.14141414, 9.90909091], [1.28282828, 9.81818182], [1.42424242, 9.72727273], [1.56565657, 9.63636364]]) res = ilr_inv(ilr(table, basis=basis), basis=basis) npt.assert_allclose(res, closure(table.squeeze())) def test_ilr_inv_basis(self): exp = closure(np.array([[1., 10.], [1.14141414, 9.90909091], [1.28282828, 9.81818182], [1.42424242, 9.72727273], [1.56565657, 9.63636364]])) basis = np.atleast_2d(clr([[0.80442968, 0.19557032]])) table = np.array([[np.log(1/10)*np.sqrt(1/2), np.log(1.14141414 / 9.90909091)*np.sqrt(1/2), np.log(1.28282828 / 9.81818182)*np.sqrt(1/2), np.log(1.42424242 / 9.72727273)*np.sqrt(1/2), np.log(1.56565657 / 9.63636364)*np.sqrt(1/2)]]).T res = ilr_inv(table, basis=basis) npt.assert_allclose(res, exp) def test_ilr_inv_basis_one_dimension_error(self): basis = clr([0.80442968, 0.19557032]) table = np.array([[np.log(1/10)*np.sqrt(1/2), np.log(1.14141414 / 9.90909091)*np.sqrt(1/2), np.log(1.28282828 / 9.81818182)*np.sqrt(1/2), np.log(1.42424242 / 9.72727273)*np.sqrt(1/2), np.log(1.56565657 / 9.63636364)*np.sqrt(1/2)]]).T with self.assertRaises(ValueError): ilr_inv(table, basis=basis) def test_alr(self): # 2d-composition comp1 = closure(self.cdata1) alr2d_byhand = np.array([np.log(comp1[:, 0]/comp1[:, 1]), np.log(comp1[:, 2]/comp1[:, 1])]).T alr2d_method = alr(comp1, denominator_idx=1) npt.assert_allclose(alr2d_byhand, alr2d_method) # 1d-composition comp2 = closure(self.cdata2) alr1d_byhand = np.array([np.log(comp2[0]/comp2[1]), np.log(comp2[2]/comp2[1])]).T alr1d_method = alr(comp2, denominator_idx=1) npt.assert_allclose(alr1d_byhand, alr1d_method) with self.assertRaises(ValueError): alr(self.bad1) with self.assertRaises(ValueError): alr(self.bad2) # make sure that inplace modification is not occurring alr(self.cdata2) npt.assert_allclose(self.cdata2, np.array([2, 2, 6])) def test_alr_inv(self): # 2d-composition comp1 = closure(self.cdata1) alr2d_byhand = np.array([np.log(comp1[:, 0]/comp1[:, 1]), np.log(comp1[:, 2]/comp1[:, 1])]).T alr2d_method = alr(comp1, denominator_idx=1) B = 1/(1 + np.exp(alr2d_byhand[:, 0]) + np.exp(alr2d_byhand[:, 1])) A = B * np.exp(alr2d_byhand[:, 0]) C = B * np.exp(alr2d_byhand[:, 1]) alrinv2d_byhand = np.column_stack((A, B, C)) alrinv2d_method = alr_inv(alr2d_method, denominator_idx=1) npt.assert_allclose(alrinv2d_byhand, alrinv2d_method) # 1d-composition comp2 = closure(self.cdata2) alr1d_byhand = np.array([np.log(comp2[0]/comp2[1]), np.log(comp2[2]/comp2[1])]).T alr1d_method = alr(comp2, denominator_idx=1) B = 1/(1 + np.exp(alr1d_byhand[0]) + np.exp(alr1d_byhand[1])) A = B * np.exp(alr1d_byhand[0]) C = B * np.exp(alr1d_byhand[1]) alrinv1d_byhand = np.column_stack((A, B, C))[0, :] alrinv1d_method = alr_inv(alr1d_method, denominator_idx=1) npt.assert_allclose(alrinv1d_byhand, alrinv1d_method) # make sure that inplace modification is not occurring alr_inv(self.rdata1) npt.assert_allclose(self.rdata1, np.array([[0.70710678, -0.70710678, 0., 0.], [0.40824829, 0.40824829, -0.81649658, 0.], [0.28867513, 0.28867513, 0.28867513, -0.8660254]])) with self.assertRaises(ValueError): alr_inv(self.bad2) def test_sbp_basis_gram_schmidt(self): gsbasis = _gram_schmidt_basis(5) sbp = np.array([[1, -1, 0, 0, 0], [1, 1, -1, 0, 0], [1, 1, 1, -1, 0], [1, 1, 1, 1, -1]]) sbpbasis = sbp_basis(sbp) npt.assert_allclose(gsbasis, sbpbasis) def test_sbp_basis_elementwise(self): sbp = np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1], [1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 0], [1, 1, 1, 1, 1, 1, -1, 0, 0, 0, 0, 0], [1, 1, -1, -1, -1, 1, 0, 0, 0, 0, 0, 0], [1, -1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0], [0, 0, 1, -1, -1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, -1, -1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0]]) sbpbasis = sbp_basis(sbp) # by hand, element-wise r = np.apply_along_axis(func1d=lambda x: np.sum(x > 0), axis=1, arr=sbp) s = np.apply_along_axis(func1d=lambda x: np.sum(x < 0), axis=1, arr=sbp) psi = np.zeros(sbp.shape) for i in range(0, sbp.shape[0]): for j in range(0, sbp.shape[1]): if sbp[i, j] == 1: psi[i, j] = np.sqrt(s[i]/(r[i]*(r[i]+s[i]))) elif sbp[i, j] == -1: psi[i, j] = -np.sqrt(r[i]/(s[i]*(r[i]+s[i]))) npt.assert_allclose(psi, sbpbasis) class TestTreeBasis(TestCase): def test_tree_basis_base_case(self): tree = u"(a,b);" t = TreeNode.read([tree]) exp_basis = coo_matrix( np.array([[-np.sqrt(1. / 2), np.sqrt(1. / 2)]])) exp_keys = [t.name] res_basis, res_keys = tree_basis(t) assert_coo_allclose(exp_basis, res_basis) self.assertListEqual(exp_keys, res_keys) def test_tree_basis_invalid(self): with self.assertRaises(ValueError): tree = u"(a,b,c);" t = TreeNode.read([tree]) tree_basis(t) def test_tree_basis_unbalanced(self): tree = u"((a,b)c, d);" t = TreeNode.read([tree]) exp_basis = coo_matrix(np.array( [[-np.sqrt(1. / 6), -np.sqrt(1. / 6), np.sqrt(2. / 3)], [-np.sqrt(1. / 2), np.sqrt(1. / 2), 0]] )) exp_keys = [t.name, t[0].name] res_basis, res_keys = tree_basis(t) assert_coo_allclose(exp_basis, res_basis) self.assertListEqual(exp_keys, res_keys) def test_tree_basis_unbalanced2(self): tree = u"(d, (a,b)c);" t = TreeNode.read([tree]) exp_basis = coo_matrix(np.array( [ [-np.sqrt(2. / 3), np.sqrt(1. / 6), np.sqrt(1. / 6)], [0, -np.sqrt(1. / 2), np.sqrt(1. / 2)] ] )) exp_keys = [t.name, t[1].name] res_basis, res_keys = tree_basis(t) assert_coo_allclose(exp_basis, res_basis, atol=1e-7, rtol=1e-7) self.assertListEqual(exp_keys, res_keys) class AncomTests(TestCase): def setUp(self): # Basic count data with 2 groupings self.table1 = pd.DataFrame([ [10, 10, 10, 20, 20, 20], [11, 12, 11, 21, 21, 21], [10, 11, 10, 10, 11, 10], [10, 11, 10, 10, 10, 9], [10, 11, 10, 10, 10, 10], [10, 11, 10, 10, 10, 11], [10, 13, 10, 10, 10, 12]]).T self.cats1 = pd.Series([0, 0, 0, 1, 1, 1]) # Real valued data with 2 groupings D, L = 40, 80 np.random.seed(0) self.table2 = np.vstack((np.concatenate((normal(10, 1, D), normal(200, 1, D))), np.concatenate((normal(20, 1, D), normal(100000, 1, D))), normal(10, 1, L), normal(10, 1, L), np.concatenate((normal(20, 1, D), normal(100000, 1, D))), normal(10, 1, L), normal(10, 1, L), normal(10, 1, L), normal(10, 1, L))) self.table2 = np.absolute(self.table2) self.table2 = pd.DataFrame(self.table2.astype(int).T) self.cats2 = pd.Series([0]*D + [1]*D) # Real valued data with 2 groupings and no significant difference self.table3 = pd.DataFrame([ [10, 10.5, 10, 10, 10.5, 10.3], [11, 11.5, 11, 11, 11.5, 11.3], [10, 10.5, 10, 10, 10.5, 10.2], [10, 10.5, 10, 10, 10.5, 10.3], [10, 10.5, 10, 10, 10.5, 10.1], [10, 10.5, 10, 10, 10.5, 10.6], [10, 10.5, 10, 10, 10.5, 10.4]]).T self.cats3 = pd.Series([0, 0, 0, 1, 1, 1]) # Real valued data with 3 groupings D, L = 40, 120 np.random.seed(0) self.table4 = np.vstack((np.concatenate((normal(10, 1, D), normal(200, 1, D), normal(400, 1, D))), np.concatenate((normal(20, 1, D), normal(100000, 1, D), normal(2000, 1, D))), normal(10, 1, L), normal(10, 1, L), np.concatenate((normal(20, 1, D), normal(100000, 1, D), normal(2000, 1, D))), normal(10, 1, L), normal(10, 1, L), normal(10, 1, L), normal(10, 1, L))) self.table4 = np.absolute(self.table4) self.table4 = pd.DataFrame(self.table4.astype(int).T) self.cats4 = pd.Series([0]*D + [1]*D + [2]*D) # Noncontiguous case self.table5 = pd.DataFrame([ [11, 12, 21, 11, 21, 21], [10, 11, 10, 10, 11, 10], [10, 11, 10, 10, 10, 9], [10, 11, 10, 10, 10, 10], [10, 11, 10, 10, 10, 11], [10, 10, 20, 9, 20, 20], [10, 13, 10, 10, 10, 12]]).T self.cats5 = pd.Series([0, 0, 1, 0, 1, 1]) # Different number of classes case self.table6 = pd.DataFrame([ [11, 12, 9, 11, 21, 21], [10, 11, 10, 10, 11, 10], [10, 11, 10, 10, 10, 9], [10, 11, 10, 10, 10, 10], [10, 11, 10, 10, 10, 11], [10, 10, 10, 9, 20, 20], [10, 13, 10, 10, 10, 12]]).T self.cats6 = pd.Series([0, 0, 0, 0, 1, 1]) # Categories are letters self.table7 = pd.DataFrame([ [11, 12, 9, 11, 21, 21], [10, 11, 10, 10, 11, 10], [10, 11, 10, 10, 10, 9], [10, 11, 10, 10, 10, 10], [10, 11, 10, 10, 10, 11], [10, 10, 10, 9, 20, 20], [10, 13, 10, 10, 10, 12]]).T self.cats7 = pd.Series(['a', 'a', 'a', 'a', 'b', 'b']) # Swap samples self.table8 = pd.DataFrame([ [10, 10, 10, 20, 20, 20], [11, 12, 11, 21, 21, 21], [10, 11, 10, 10, 11, 10], [10, 11, 10, 10, 10, 9], [10, 11, 10, 10, 10, 10], [10, 11, 10, 10, 10, 11], [10, 13, 10, 10, 10, 12]]).T self.table8.index = ['a', 'b', 'c', 'd', 'e', 'f'] self.cats8 = pd.Series([0, 0, 1, 0, 1, 1], index=['a', 'b', 'd', 'c', 'e', 'f']) # Real valued data with 3 groupings D, L = 40, 120 np.random.seed(0) self.table9 = np.vstack((np.concatenate((normal(10, 1, D), normal(200, 1, D), normal(400, 1, D))), np.concatenate((normal(200000, 1, D), normal(10, 1, D), normal(2000, 1, D))), normal(10, 10, L), normal(10, 10, L), np.concatenate((normal(2000, 1, D), normal(100000, 1, D), normal(2000, 1, D))), normal(10000, 1000, L), normal(10, 10, L), normal(10, 10, L), normal(10, 10, L), normal(10000, 1000, L), normal(10, 10, L), normal(10, 10, L), normal(10, 10, L), np.concatenate((normal(2000, 1, D), normal(100000, 1, D), normal(2000, 1, D))), normal(10000, 1000, L), normal(10, 10, L), normal(10, 10, L), normal(10, 10, L))) self.table9 = np.absolute(self.table9)+1 self.table9 = pd.DataFrame(self.table9.astype(int).T) self.cats9 = pd.Series([0]*D + [1]*D + [2]*D) # Real valued data with 2 groupings D, L = 40, 80 np.random.seed(0) self.table10 = np.vstack((np.concatenate((normal(10, 1, D), normal(200, 1, D))), np.concatenate((normal(10, 1, D), normal(200, 1, D))), np.concatenate((normal(20, 10, D), normal(100, 10, D))), normal(10, 1, L), np.concatenate((normal(200, 100, D), normal(100000, 100, D))), np.concatenate((normal(200000, 100, D), normal(300, 100, D))), np.concatenate((normal(200000, 100, D), normal(300, 100, D))), np.concatenate((normal(20, 20, D), normal(40, 10, D))), np.concatenate((normal(20, 20, D), normal(40, 10, D))), np.concatenate((normal(20, 20, D), normal(40, 10, D))), normal(100, 10, L), normal(100, 10, L), normal(1000, 10, L), normal(1000, 10, L), normal(10, 10, L), normal(10, 10, L), normal(10, 10, L), normal(10, 10, L))) self.table10 = np.absolute(self.table10) + 1 self.table10 = pd.DataFrame(self.table10.astype(int).T) self.cats10 = pd.Series([0]*D + [1]*D) # zero count self.bad1 = pd.DataFrame(np.array([ [10, 10, 10, 20, 20, 0], [11, 11, 11, 21, 21, 21], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10]]).T) # negative count self.bad2 = pd.DataFrame(np.array([ [10, 10, 10, 20, 20, 1], [11, 11, 11, 21, 21, 21], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, -1], [10, 10, 10, 10, 10, 10]]).T) # missing count self.bad3 = pd.DataFrame(np.array([ [10, 10, 10, 20, 20, 1], [11, 11, 11, 21, 21, 21], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, 10], [10, 10, 10, 10, 10, np.nan], [10, 10, 10, 10, 10, 10]]).T) self.badcats1 = pd.Series([0, 0, 0, 1, np.nan, 1]) self.badcats2 = pd.Series([0, 0, 0, 0, 0, 0]) self.badcats3 = pd.Series([0, 0, 1, 1]) self.badcats4 = pd.Series(range(len(self.table1))) self.badcats5 = pd.Series([1]*len(self.table1)) def test_ancom_basic_counts(self): test_table = pd.DataFrame(self.table1) original_table = copy.deepcopy(test_table) test_cats = pd.Series(self.cats1) original_cats = copy.deepcopy(test_cats) result = ancom(test_table, test_cats, multiple_comparisons_correction=None) # Test to make sure that the input table hasn't be altered assert_data_frame_almost_equal(original_table, test_table) # Test to make sure that the input table hasn't be altered pdt.assert_series_equal(original_cats, test_cats) exp = pd.DataFrame( {'W': np.array([5, 5, 2, 2, 2, 2, 2]), 'Reject null hypothesis': np.array([True, True, False, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_percentiles(self): table = pd.DataFrame([[12, 11], [9, 11], [1, 11], [22, 100], [20, 53], [23, 1]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1', 'b2']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) percentiles = [0.0, 25.0, 50.0, 75.0, 100.0] groups = ['a', 'b'] tuples = [(p, g) for g in groups for p in percentiles] exp_mi = pd.MultiIndex.from_tuples(tuples, names=['Percentile', 'Group']) exp_data = np.array( [[1.0, 11.0], [5.0, 11.0], [9.0, 11.0], [10.5, 11.0], [12.0, 11.0], [20.0, 1.0], [21.0, 27.0], [22.0, 53.0], [22.5, 76.5], [23.0, 100.0]]) exp = pd.DataFrame(exp_data.T, columns=exp_mi, index=['b1', 'b2']) result = ancom(table, grouping)[1] assert_data_frame_almost_equal(result, exp) def test_ancom_percentiles_alt_categories(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'c', 'b', 'b', 'c'], index=['s1', 's2', 's3', 's4', 's5', 's6']) percentiles = [0.0, 25.0, 50.0, 75.0, 100.0] groups = ['a', 'b', 'c'] tuples = [(p, g) for g in groups for p in percentiles] exp_mi = pd.MultiIndex.from_tuples(tuples, names=['Percentile', 'Group']) exp_data = np.array([[9.0], [9.75], [10.5], [11.25], [12.0], # a [20.0], [20.5], [21.0], [21.5], [22.0], # b [1.0], [6.5], [12.0], [17.5], [23.0]]) # c exp = pd.DataFrame(exp_data.T, columns=exp_mi, index=['b1']) result = ancom(table, grouping, percentiles=percentiles)[1] assert_data_frame_almost_equal(result, exp) def test_ancom_alt_percentiles(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) percentiles = [42.0, 50.0] groups = ['a', 'b'] tuples = [(p, g) for g in groups for p in percentiles] exp_mi = pd.MultiIndex.from_tuples(tuples, names=['Percentile', 'Group']) exp_data = np.array([[7.71999999], [9.0], # a [21.68], [22.0]]) # b exp = pd.DataFrame(exp_data.T, columns=exp_mi, index=['b1']) result = ancom(table, grouping, percentiles=percentiles)[1] assert_data_frame_almost_equal(result, exp) def test_ancom_percentiles_swapped(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'b', 'a', 'b', 'b'], index=['s1', 's2', 's4', 's3', 's5', 's6']) percentiles = [42.0, 50.0] groups = ['a', 'b'] tuples = [(p, g) for g in groups for p in percentiles] exp_mi = pd.MultiIndex.from_tuples(tuples, names=['Percentile', 'Group']) exp_data = np.array([[7.71999999], [9.0], # a [21.68], [22.0]]) # b exp = pd.DataFrame(exp_data.T, columns=exp_mi, index=['b1']) result = ancom(table, grouping, percentiles=percentiles)[1] assert_data_frame_almost_equal(result, exp) def test_ancom_percentile_order_unimportant(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) # order of percentiles in unimportant after sorting result1 = ancom(table, grouping, percentiles=[50.0, 42.0])[1] result2 = ancom(table, grouping, percentiles=[42.0, 50.0])[1] assert_data_frame_almost_equal( result1.sort_index(axis=1), result2.sort_index(axis=1)) def test_ancom_percentiles_iterator(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) percentiles = [42.0, 50.0] groups = ['a', 'b'] tuples = [(p, g) for g in groups for p in percentiles] exp_mi = pd.MultiIndex.from_tuples(tuples, names=['Percentile', 'Group']) exp_data = np.array([[7.71999999], [9.0], # a [21.68], [22.0]]) # b exp = pd.DataFrame(exp_data.T, columns=exp_mi, index=['b1']) result = ancom(table, grouping, percentiles=iter(percentiles))[1] assert_data_frame_almost_equal(result, exp) def test_ancom_no_percentiles(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) result = ancom(table, grouping, percentiles=[])[1] assert_data_frame_almost_equal(result, pd.DataFrame()) def test_ancom_percentile_out_of_range(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) with self.assertRaises(ValueError): ancom(table, grouping, percentiles=[-1.0]) with self.assertRaises(ValueError): ancom(table, grouping, percentiles=[100.1]) with self.assertRaises(ValueError): ancom(table, grouping, percentiles=[10.0, 3.0, 101.0, 100]) def test_ancom_duplicate_percentiles(self): table = pd.DataFrame([[12], [9], [1], [22], [20], [23]], index=['s1', 's2', 's3', 's4', 's5', 's6'], columns=['b1']) grouping = pd.Series(['a', 'a', 'a', 'b', 'b', 'b'], index=['s1', 's2', 's3', 's4', 's5', 's6']) with self.assertRaises(ValueError): ancom(table, grouping, percentiles=[10.0, 10.0]) def test_ancom_basic_proportions(self): # Converts from counts to proportions test_table = pd.DataFrame(closure(self.table1)) original_table = copy.deepcopy(test_table) test_cats = pd.Series(self.cats1) original_cats = copy.deepcopy(test_cats) result = ancom(test_table, test_cats, multiple_comparisons_correction=None) # Test to make sure that the input table hasn't be altered assert_data_frame_almost_equal(original_table, test_table) # Test to make sure that the input table hasn't be altered pdt.assert_series_equal(original_cats, test_cats) exp = pd.DataFrame( {'W': np.array([5, 5, 2, 2, 2, 2, 2]), 'Reject null hypothesis': np.array([True, True, False, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_multiple_groups(self): test_table = pd.DataFrame(self.table4) original_table = copy.deepcopy(test_table) test_cats = pd.Series(self.cats4) original_cats = copy.deepcopy(test_cats) result = ancom(test_table, test_cats) # Test to make sure that the input table hasn't be altered assert_data_frame_almost_equal(original_table, test_table) # Test to make sure that the input table hasn't be altered pdt.assert_series_equal(original_cats, test_cats) exp = pd.DataFrame( {'W': np.array([8, 7, 3, 3, 7, 3, 3, 3, 3]), 'Reject null hypothesis': np.array([True, True, False, False, True, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_noncontiguous(self): result = ancom(self.table5, self.cats5, multiple_comparisons_correction=None) exp = pd.DataFrame( {'W': np.array([6, 2, 2, 2, 2, 6, 2]), 'Reject null hypothesis': np.array([True, False, False, False, False, True, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_unbalanced(self): result = ancom(self.table6, self.cats6, multiple_comparisons_correction=None) exp = pd.DataFrame( {'W': np.array([5, 3, 3, 2, 2, 5, 2]), 'Reject null hypothesis': np.array([True, False, False, False, False, True, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_letter_categories(self): result = ancom(self.table7, self.cats7, multiple_comparisons_correction=None) exp = pd.DataFrame( {'W': np.array([5, 3, 3, 2, 2, 5, 2]), 'Reject null hypothesis': np.array([True, False, False, False, False, True, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_multiple_comparisons(self): significance_test = functools.partial(scipy.stats.mannwhitneyu, alternative='two-sided') result = ancom(self.table1, self.cats1, multiple_comparisons_correction='holm-bonferroni', significance_test=significance_test) exp = pd.DataFrame( {'W': np.array([0]*7), 'Reject null hypothesis': np.array([False]*7, dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_alternative_test(self): result = ancom(self.table1, self.cats1, multiple_comparisons_correction=None, significance_test=scipy.stats.ttest_ind) exp = pd.DataFrame( {'W': np.array([5, 5, 2, 2, 2, 2, 2]), 'Reject null hypothesis': np.array([True, True, False, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_normal_data(self): result = ancom(self.table2, self.cats2, multiple_comparisons_correction=None, significance_test=scipy.stats.ttest_ind) exp = pd.DataFrame( {'W': np.array([8, 8, 3, 3, 8, 3, 3, 3, 3]), 'Reject null hypothesis': np.array([True, True, False, False, True, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_basic_counts_swapped(self): result = ancom(self.table8, self.cats8) exp = pd.DataFrame( {'W': np.array([5, 5, 2, 2, 2, 2, 2]), 'Reject null hypothesis': np.array([True, True, False, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_no_signal(self): result = ancom(self.table3, self.cats3, multiple_comparisons_correction=None) exp = pd.DataFrame( {'W': np.array([0]*7), 'Reject null hypothesis': np.array([False]*7, dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_tau(self): exp1 = pd.DataFrame( {'W': np.array([8, 7, 3, 3, 7, 3, 3, 3, 3]), 'Reject null hypothesis': np.array([True, False, False, False, False, False, False, False, False], dtype=bool)}) exp2 = pd.DataFrame( {'W': np.array([17, 17, 5, 6, 16, 5, 7, 5, 4, 5, 8, 4, 5, 16, 5, 11, 4, 6]), 'Reject null hypothesis': np.array([True, True, False, False, True, False, False, False, False, False, False, False, False, True, False, False, False, False], dtype=bool)}) exp3 = pd.DataFrame( {'W': np.array([16, 16, 17, 10, 17, 16, 16, 15, 15, 15, 13, 10, 10, 10, 9, 9, 9, 9]), 'Reject null hypothesis': np.array([True, True, True, False, True, True, True, True, True, True, True, False, False, False, False, False, False, False], dtype=bool)}) result1 = ancom(self.table4, self.cats4, multiple_comparisons_correction=None, tau=0.25) result2 = ancom(self.table9, self.cats9, multiple_comparisons_correction=None, tau=0.02) result3 = ancom(self.table10, self.cats10, multiple_comparisons_correction=None, tau=0.02) assert_data_frame_almost_equal(result1[0], exp1) assert_data_frame_almost_equal(result2[0], exp2) assert_data_frame_almost_equal(result3[0], exp3) def test_ancom_theta(self): result = ancom(self.table1, self.cats1, theta=0.3) exp = pd.DataFrame( {'W': np.array([5, 5, 2, 2, 2, 2, 2]), 'Reject null hypothesis': np.array([True, True, False, False, False, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_alpha(self): result = ancom(self.table1, self.cats1, multiple_comparisons_correction=None, alpha=0.5) exp = pd.DataFrame( {'W': np.array([6, 6, 4, 5, 5, 4, 2]), 'Reject null hypothesis': np.array([True, True, False, True, True, False, False], dtype=bool)}) assert_data_frame_almost_equal(result[0], exp) def test_ancom_fail_type(self): with self.assertRaises(TypeError): ancom(self.table1.values, self.cats1) with self.assertRaises(TypeError): ancom(self.table1, self.cats1.values) def test_ancom_fail_zeros(self): with self.assertRaises(ValueError): ancom(self.bad1, self.cats2, multiple_comparisons_correction=None) def test_ancom_fail_negative(self): with self.assertRaises(ValueError): ancom(self.bad2, self.cats2, multiple_comparisons_correction=None) def test_ancom_fail_not_implemented_multiple_comparisons_correction(self): with self.assertRaises(ValueError): ancom(self.table2, self.cats2, multiple_comparisons_correction='fdr') def test_ancom_fail_missing(self): with self.assertRaises(ValueError): ancom(self.bad3, self.cats1) with self.assertRaises(ValueError): ancom(self.table1, self.badcats1) def test_ancom_fail_groups(self): with self.assertRaises(ValueError): ancom(self.table1, self.badcats2) def test_ancom_fail_size_mismatch(self): with self.assertRaises(ValueError): ancom(self.table1, self.badcats3) def test_ancom_fail_group_unique(self): with self.assertRaises(ValueError): ancom(self.table1, self.badcats4) def test_ancom_fail_1_group(self): with self.assertRaises(ValueError): ancom(self.table1, self.badcats5) def test_ancom_fail_tau(self): with self.assertRaises(ValueError): ancom(self.table1, self.cats1, tau=-1) with self.assertRaises(ValueError): ancom(self.table1, self.cats1, tau=1.1) def test_ancom_fail_theta(self): with self.assertRaises(ValueError): ancom(self.table1, self.cats1, theta=-1) with self.assertRaises(ValueError): ancom(self.table1, self.cats1, theta=1.1) def test_ancom_fail_alpha(self): with self.assertRaises(ValueError): ancom(self.table1, self.cats1, alpha=-1) with self.assertRaises(ValueError): ancom(self.table1, self.cats1, alpha=1.1) def test_ancom_fail_multiple_groups(self): with self.assertRaises(TypeError): ancom(self.table4, self.cats4, significance_test=scipy.stats.ttest_ind) def test_holm_bonferroni(self): p = [0.005, 0.011, 0.02, 0.04, 0.13] corrected_p = p * np.arange(1, 6)[::-1] guessed_p = _holm_bonferroni(p) for a, b in zip(corrected_p, guessed_p): self.assertAlmostEqual(a, b) class TestVLR(TestCase): def setUp(self): self.mat = np.array([[1, 1, 2], [3, 5, 8], [13, 21, 55]]) self.mat_neg = np.array([[-1, 1, 2], [3, -5, 8], [13, 21, -55]]) self.mat_with_zero = np.array([[0, 1, 2], [3, 5, 8], [13, 21, 55]]) def test_vlr(self): # No zeros output = vlr( x=self.mat[0], y=self.mat[1], ddof=1, robust=False, ) self.assertAlmostEqual(output, 0.0655828061998637) # With zeros output = vlr( x=self.mat_with_zero[0], y=self.mat_with_zero[1], ddof=1, robust=False, ) assert np.isnan(output) # assert raises error with self.assertRaises(ValueError): vlr( x=self.mat_neg[0], y=self.mat_neg[1], ddof=1, robust=False, ) def test_robust_vlr(self): # No zeros output = vlr( x=self.mat[0], y=self.mat[1], ddof=1, robust=True, ) self.assertAlmostEqual(output, 0.0655828061998637) # With zeros output = vlr( x=self.mat_with_zero[0], y=self.mat_with_zero[1], ddof=1, robust=True, ) self.assertAlmostEqual(output, 0.024896522246558722) def test_pairwise_vlr(self): # No zeros dism = pairwise_vlr(self.mat, ids=None, ddof=1, robust=False) output = dism.condensed_form().sum() self.assertAlmostEqual(output, 0.2857382286903922) # With zeros with self.assertRaises(DistanceMatrixError): pairwise_vlr(self.mat_with_zero, ids=None, ddof=1, robust=False) # no validation dism = pairwise_vlr(self.mat, ids=None, ddof=1, robust=False, validate=False) output = dism.data.sum() / 2 self.assertAlmostEqual(output, 0.2857382286903922) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/stats/tests/test_gradient.py000066400000000000000000001542321446255456000224210ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from operator import attrgetter from unittest import TestCase, main import numpy as np import pandas as pd import numpy.testing as npt import pandas.testing as pdt from skbio.util import get_data_path, assert_data_frame_almost_equal from skbio.stats.gradient import (GradientANOVA, AverageGradientANOVA, TrajectoryGradientANOVA, FirstDifferenceGradientANOVA, WindowDifferenceGradientANOVA, GroupResults, CategoryResults, GradientANOVAResults, _weight_by_vector, _ANOVA_trajectories) class BaseTests(TestCase): def setUp(self): """Initializes some data for testing""" coord_data = { 'PC.636': np.array([-0.212230626531, 0.216034194368, 0.03532727349, -0.254450494129, -0.0687468542543, 0.231895596562, 0.00496549154314, -0.0026246871695, 9.73837390723e-10]), 'PC.635': np.array([-0.277487312135, -0.0295483215975, -0.0744173437992, 0.0957182357964, 0.204714844022, -0.0055407341857, -0.190287966833, 0.16307126638, 9.73837390723e-10]), 'PC.356': np.array([0.220886492631, 0.0874848360559, -0.351990132198, -0.00316535032886, 0.114635191853, -0.00019194106125, 0.188557853937, 0.030002427212, 9.73837390723e-10]), 'PC.481': np.array([0.0308923744062, -0.0446295973489, 0.133996451689, 0.29318228566, -0.167812539312, 0.130996149793, 0.113551017379, 0.109987942454, 9.73837390723e-10]), 'PC.354': np.array([0.27616778138, -0.0341866951102, 0.0633000238256, 0.100446653327, 0.123802521199, 0.1285839664, -0.132852841046, -0.217514322505, 9.73837390723e-10]), 'PC.593': np.array([0.202458130052, -0.115216120518, 0.301820871723, -0.18300251046, 0.136208248567, -0.0989435556722, 0.0927738484879, 0.0909429797672, 9.73837390723e-10]), 'PC.355': np.array([0.236467470907, 0.21863434374, -0.0301637746424, -0.0225473129718, -0.205287183891, -0.180224615141, -0.165277751908, 0.0411933458557, 9.73837390723e-10]), 'PC.607': np.array([-0.105517545144, -0.41405687433, -0.150073017617, -0.116066751485, -0.158763393475, -0.0223918378516, -0.0263068046112, -0.0501209518091, 9.73837390723e-10]), 'PC.634': np.array([-0.371636765565, 0.115484234741, 0.0721996475289, 0.0898852445906, 0.0212491652909, -0.184183028843, 0.114877153051, -0.164938000185, 9.73837390723e-10]) } self.coords = pd.DataFrame.from_dict(coord_data, orient='index') coord_data = { 'PC.636': np.array([-0.212230626531, 0.216034194368, 0.03532727349]), 'PC.635': np.array([-0.277487312135, -0.0295483215975, -0.0744173437992]), 'PC.356': np.array([0.220886492631, 0.0874848360559, -0.351990132198]), 'PC.481': np.array([0.0308923744062, -0.0446295973489, 0.133996451689]), 'PC.354': np.array([0.27616778138, -0.0341866951102, 0.0633000238256]), 'PC.593': np.array([0.202458130052, -0.115216120518, 0.301820871723]), 'PC.355': np.array([0.236467470907, 0.21863434374, -0.0301637746424]), 'PC.607': np.array([-0.105517545144, -0.41405687433, -0.150073017617]), 'PC.634': np.array([-0.371636765565, 0.115484234741, 0.0721996475289]) } self.coords_3axes = pd.DataFrame.from_dict(coord_data, orient='index') metadata_map = {'PC.354': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '60', 'Description': 'Control_mouse_I.D._354'}, 'PC.355': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '55', 'Description': 'Control_mouse_I.D._355'}, 'PC.356': {'Treatment': 'Control', 'DOB': '20061126', 'Weight': '50', 'Description': 'Control_mouse_I.D._356'}, 'PC.481': {'Treatment': 'Control', 'DOB': '20070314', 'Weight': '52', 'Description': 'Control_mouse_I.D._481'}, 'PC.593': {'Treatment': 'Control', 'DOB': '20071210', 'Weight': '57', 'Description': 'Control_mouse_I.D._593'}, 'PC.607': {'Treatment': 'Fast', 'DOB': '20071112', 'Weight': '65', 'Description': 'Fasting_mouse_I.D._607'}, 'PC.634': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '68', 'Description': 'Fasting_mouse_I.D._634'}, 'PC.635': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '70', 'Description': 'Fasting_mouse_I.D._635'}, 'PC.636': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '72', 'Description': 'Fasting_mouse_I.D._636'}} self.metadata_map = pd.DataFrame.from_dict(metadata_map, orient='index') self.prop_expl = np.array([25.6216900347, 15.7715955926, 14.1215046787, 11.6913885817, 9.83044890697, 8.51253468595, 7.88775505332, 6.56308246609, 4.42499350906e-16]) gr_wo_msg = GroupResults('Foo', np.array([-2.6750, -0.2510, -2.8322, 0.]), -1.4398, {'mean': -1.4398, 'std': 1.3184}, None) gr_w_msg = GroupResults('Bar', np.array([9.6823, 2.9511, 5.2434]), 5.9589, {'mean': 5.9589, 'std': 2.7942}, "Cannot calculate the first difference " "with a window of size (3).") self.groups = [gr_wo_msg, gr_w_msg] cr_no_data = CategoryResults('foo', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') cr_data = CategoryResults('bar', 0.0110, self.groups, None) self.categories = [cr_no_data, cr_data] vr = GradientANOVAResults('wdiff', True, self.categories) description = CategoryResults('Description', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') weight = CategoryResults('Weight', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') dob = CategoryResults('DOB', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') control_group = GroupResults('Control', np.array([2.3694, 3.3716, 5.4452, 4.5704, 4.4972]), 4.0508, {'avg': 4.0508}, None) fast_group = GroupResults('Fast', np.array([7.2220, 4.2726, 1.1169, 4.0271]), 4.1596, {'avg': 4.1596}, None) treatment = CategoryResults('Treatment', 0.9331, [control_group, fast_group], None) vr_real = GradientANOVAResults('avg', False, [description, weight, dob, treatment]) self.vec_results = [vr, vr_real] # This function makes the comparisons between the results classes easier def assert_group_results_almost_equal(self, obs, exp): """Tests that obs and exp are almost equal""" self.assertEqual(obs.name, exp.name) npt.assert_almost_equal(obs.trajectory, exp.trajectory) npt.assert_almost_equal(obs.mean, exp.mean) self.assertEqual(obs.info.keys(), exp.info.keys()) for key in obs.info: npt.assert_almost_equal(obs.info[key], exp.info[key]) self.assertEqual(obs.message, exp.message) def assert_category_results_almost_equal(self, obs, exp): """Tests that obs and exp are almost equal""" self.assertEqual(obs.category, exp.category) if exp.probability is None: self.assertTrue(obs.probability is None) self.assertTrue(obs.groups is None) else: npt.assert_almost_equal(obs.probability, exp.probability) for o, e in zip(sorted(obs.groups, key=attrgetter('name')), sorted(exp.groups, key=attrgetter('name'))): self.assert_group_results_almost_equal(o, e) def assert_gradientANOVA_results_almost_equal(self, obs, exp): """Tests that obs and exp are almost equal""" self.assertEqual(obs.algorithm, exp.algorithm) self.assertEqual(obs.weighted, exp.weighted) for o, e in zip(sorted(obs.categories, key=attrgetter('category')), sorted(exp.categories, key=attrgetter('category'))): self.assert_category_results_almost_equal(o, e) class GradientTests(BaseTests): def test_weight_by_vector(self): """Correctly weights the vectors""" trajectory = pd.DataFrame.from_dict({'s1': np.array([1]), 's2': np.array([2]), 's3': np.array([3]), 's4': np.array([4]), 's5': np.array([5]), 's6': np.array([6]), 's7': np.array([7]), 's8': np.array([8])}, orient='index') trajectory.sort_values(by=0, inplace=True) w_vector = pd.Series(np.array([1, 5, 8, 12, 45, 80, 85, 90]), ['s1', 's2', 's3', 's4', 's5', 's6', 's7', 's8']).astype(np.float64) exp = pd.DataFrame.from_dict({'s1': np.array([1]), 's2': np.array([6.3571428571]), 's3': np.array([12.7142857142]), 's4': np.array([12.7142857142]), 's5': np.array([1.9264069264]), 's6': np.array([2.1795918367]), 's7': np.array([17.8]), 's8': np.array([20.3428571428])}, orient='index').astype(np.float64) obs = _weight_by_vector(trajectory, w_vector) assert_data_frame_almost_equal(obs.sort_index(), exp.sort_index()) trajectory = pd.DataFrame.from_dict({'s1': np.array([1]), 's2': np.array([2]), 's3': np.array([3]), 's4': np.array([4]), 's5': np.array([5]), 's6': np.array([6]), 's7': np.array([7]), 's8': np.array([8])}, orient='index') trajectory.sort_values(by=0, inplace=True) w_vector = pd.Series(np.array([1, 2, 3, 4, 5, 6, 7, 8]), ['s1', 's2', 's3', 's4', 's5', 's6', 's7', 's8']).astype(np.float64) exp = pd.DataFrame.from_dict({'s1': np.array([1]), 's2': np.array([2]), 's3': np.array([3]), 's4': np.array([4]), 's5': np.array([5]), 's6': np.array([6]), 's7': np.array([7]), 's8': np.array([8]) }, orient='index').astype(np.float64) obs = _weight_by_vector(trajectory, w_vector) assert_data_frame_almost_equal(obs.sort_index(), exp.sort_index()) trajectory = pd.DataFrame.from_dict({'s2': np.array([2]), 's3': np.array([3]), 's4': np.array([4]), 's5': np.array([5]), 's6': np.array([6])}, orient='index') trajectory.sort_values(by=0, inplace=True) w_vector = pd.Series(np.array([25, 30, 35, 40, 45]), ['s2', 's3', 's4', 's5', 's6']).astype(np.float64) exp = pd.DataFrame.from_dict({'s2': np.array([2]), 's3': np.array([3]), 's4': np.array([4]), 's5': np.array([5]), 's6': np.array([6])}, orient='index').astype(np.float64) obs = _weight_by_vector(trajectory, w_vector) assert_data_frame_almost_equal(obs.sort_index(), exp.sort_index()) trajectory = pd.DataFrame.from_dict({'s1': np.array([1, 2, 3]), 's2': np.array([2, 3, 4]), 's3': np.array([5, 6, 7]), 's4': np.array([8, 9, 10])}, orient='index') trajectory.sort_values(by=0, inplace=True) w_vector = pd.Series(np.array([1, 2, 3, 4]), ['s1', 's2', 's3', 's4']).astype(np.float64) exp = pd.DataFrame.from_dict({'s1': np.array([1, 2, 3]), 's2': np.array([2, 3, 4]), 's3': np.array([5, 6, 7]), 's4': np.array([8, 9, 10])}, orient='index').astype(np.float64) obs = _weight_by_vector(trajectory, w_vector) assert_data_frame_almost_equal(obs.sort_index(), exp.sort_index()) sample_ids = ['PC.356', 'PC.481', 'PC.355', 'PC.593', 'PC.354'] trajectory = pd.DataFrame.from_dict({'PC.356': np.array([5.65948525, 1.37977545, -4.9706303]), 'PC.481': np.array([0.79151484, -0.70387996, 1.89223152]), 'PC.355': np.array([6.05869624, 3.44821245, -0.42595788]), 'PC.593': np.array([5.18731945, -1.81714206, 4.26216485]), 'PC.354': np.array([7.07588529, -0.53917873, 0.89389158]) }, orient='index') w_vector = pd.Series(np.array([50, 52, 55, 57, 60]), sample_ids).astype(np.float64) exp = pd.DataFrame.from_dict({'PC.356': np.array([5.65948525, 1.37977545, -4.9706303]), 'PC.481': np.array([0.98939355, -0.87984995, 2.3652894]), 'PC.355': np.array([5.04891353, 2.87351038, -0.3549649]), 'PC.593': np.array([6.48414931, -2.27142757, 5.32770606]), 'PC.354': np.array([5.89657108, -0.44931561, 0.74490965]) }, orient='index') obs = _weight_by_vector(trajectory.loc[sample_ids], w_vector[sample_ids]) assert_data_frame_almost_equal(obs.sort_index(), exp.sort_index()) def test_weight_by_vector_single_element(self): trajectory = pd.DataFrame.from_dict({'s1': np.array([42])}, orient='index') w_vector = pd.Series(np.array([5]), ['s1']).astype(np.float64) obs = _weight_by_vector(trajectory, w_vector) assert_data_frame_almost_equal(obs, trajectory) def test_weight_by_vector_error(self): """Raises an error with erroneous inputs""" # Different vector lengths with self.assertRaises(ValueError): _weight_by_vector([1, 2, 3, 4], [1, 2, 3]) # Inputs are not iterables with self.assertRaises(TypeError): _weight_by_vector(9, 1) # Weighting vector is not a gradient with self.assertRaises(ValueError): _weight_by_vector([1, 2, 3, 4], [1, 2, 3, 3]) def test_ANOVA_trajectories(self): """Correctly performs the check before running ANOVA""" # Only one group in a given category group = GroupResults('Bar', np.array([2.3694943596755276, 3.3716388181385781, 5.4452089176253367, 4.5704258453173559, 4.4972603724478377]), 4.05080566264, {'avg': 4.0508056626409275}, None) obs = _ANOVA_trajectories('Foo', [group]) exp = CategoryResults('Foo', None, None, 'Only one value in the group.') self.assert_category_results_almost_equal(obs, exp) # One element have only one element group2 = GroupResults('FooBar', np.array([4.05080566264]), 4.05080566264, {'avg': 4.05080566264}, None) obs = _ANOVA_trajectories('Foo', [group, group2]) exp = CategoryResults('Foo', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') self.assert_category_results_almost_equal(obs, exp) gr1 = GroupResults('Foo', np.array([-0.219044992, 0.079674486, 0.09233683]), -0.015677892, {'avg': -0.015677892}, None) gr2 = GroupResults('Bar', np.array([-0.042258081, 0.000204041, 0.024837603]), -0.0732878716, {'avg': -0.0732878716}, None) gr3 = GroupResults('FBF', np.array([0.080504323, -0.212014503, -0.088353435]), -0.0057388123, {'avg': -0.0057388123}, None) obs = _ANOVA_trajectories('Cat', [gr1, gr2, gr3]) exp = CategoryResults('Cat', 0.8067456876, [gr1, gr2, gr3], None) self.assert_category_results_almost_equal(obs, exp) class GroupResultsTests(BaseTests): def test_to_file(self): out_paths = ['gr_wo_msg_out', 'gr_w_msg_out'] raw_paths = ['gr_wo_msg_raw', 'gr_w_msg_raw'] for gr, out_fp, raw_fp in zip(self.groups, out_paths, raw_paths): obs_out_f = io.StringIO() obs_raw_f = io.StringIO() gr.to_files(obs_out_f, obs_raw_f) obs_out = obs_out_f.getvalue() obs_raw = obs_raw_f.getvalue() obs_out_f.close() obs_raw_f.close() with open(get_data_path(out_fp)) as f: exp_out = f.read() with open(get_data_path(raw_fp)) as f: exp_raw = f.read() self.assertEqual(obs_out, exp_out) self.assertEqual(obs_raw, exp_raw) class CategoryResultsTests(BaseTests): def test_to_file(self): out_paths = ['cr_no_data_out', 'cr_data_out'] raw_paths = ['cr_no_data_raw', 'cr_data_raw'] for cat, out_fp, raw_fp in zip(self.categories, out_paths, raw_paths): obs_out_f = io.StringIO() obs_raw_f = io.StringIO() cat.to_files(obs_out_f, obs_raw_f) obs_out = obs_out_f.getvalue() obs_raw = obs_raw_f.getvalue() obs_out_f.close() obs_raw_f.close() with open(get_data_path(out_fp)) as f: exp_out = f.read() with open(get_data_path(raw_fp)) as f: exp_raw = f.read() self.assertEqual(obs_out, exp_out) self.assertEqual(obs_raw, exp_raw) class GradientANOVAResultsTests(BaseTests): def test_to_file(self): out_paths = ['vr_out'] raw_paths = ['vr_raw'] for vr, out_fp, raw_fp in zip(self.vec_results, out_paths, raw_paths): obs_out_f = io.StringIO() obs_raw_f = io.StringIO() vr.to_files(obs_out_f, obs_raw_f) obs_out = obs_out_f.getvalue() obs_raw = obs_raw_f.getvalue() obs_out_f.close() obs_raw_f.close() with open(get_data_path(out_fp)) as f: exp_out = f.read() with open(get_data_path(raw_fp)) as f: exp_raw = f.read() self.assertEqual(obs_out, exp_out) self.assertEqual(obs_raw, exp_raw) class GradientANOVATests(BaseTests): def test_init(self): """Correctly initializes the class attributes""" # Note self._groups is tested on test_make_groups # so we are not testing it here # Test with weighted = False bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) assert_data_frame_almost_equal(bv._coords.loc[self.coords_3axes.index], self.coords_3axes) exp_prop_expl = np.array([25.6216900347, 15.7715955926, 14.1215046787]) npt.assert_equal(bv._prop_expl, exp_prop_expl) assert_data_frame_almost_equal(bv._metadata_map.loc[self.metadata_map.index], # noqa self.metadata_map) self.assertTrue(bv._weighting_vector is None) self.assertFalse(bv._weighted) # Test with weighted = True bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map, sort_category='Weight', weighted=True) assert_data_frame_almost_equal(bv._coords.loc[self.coords_3axes.index], self.coords_3axes) npt.assert_equal(bv._prop_expl, exp_prop_expl) assert_data_frame_almost_equal(bv._metadata_map.loc[self.metadata_map.index], # noqa self.metadata_map) exp_weighting_vector = pd.Series( np.array([60, 55, 50, 52, 57, 65, 68, 70, 72]), ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593', 'PC.607', 'PC.634', 'PC.635', 'PC.636'], name='Weight' ).astype(np.float64) pdt.assert_series_equal(bv._weighting_vector.loc[exp_weighting_vector.index], # noqa exp_weighting_vector) self.assertTrue(bv._weighted) def test_init_error(self): """Raises an error with erroneous inputs""" # Raises ValueError if any category in trajectory_categories is not # present in metadata_map with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['foo']) with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Weight', 'Treatment', 'foo']) # Raises ValueError if sort_category is not present in metadata_map with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, sort_category='foo') # Raises ValueError if weighted == True and sort_category == None with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, weighted=True) # Raises ValueError if weighted == True and the values under # sort_category are not numerical with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, sort_category='Treatment', weighted=True) # Raises ValueError if axes > len(prop_expl) with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, axes=10) # Raises ValueError if axes < 0 with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, self.metadata_map, axes=-1) def test_normalize_samples(self): """Correctly normalizes the samples between coords and metadata_map""" coord_data = { 'PC.636': np.array([-0.212230626531, 0.216034194368, 0.03532727349]), 'PC.635': np.array([-0.277487312135, -0.0295483215975, -0.0744173437992]), 'PC.355': np.array([0.236467470907, 0.21863434374, -0.0301637746424]), 'PC.607': np.array([-0.105517545144, -0.41405687433, -0.150073017617]), 'PC.634': np.array([-0.371636765565, 0.115484234741, 0.0721996475289]) } subset_coords = pd.DataFrame.from_dict(coord_data, orient='index') metadata_map = {'PC.355': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '55', 'Description': 'Control_mouse_I.D._355'}, 'PC.607': {'Treatment': 'Fast', 'DOB': '20071112', 'Weight': '65', 'Description': 'Fasting_mouse_I.D._607'}, 'PC.634': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '68', 'Description': 'Fasting_mouse_I.D._634'}, 'PC.635': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '70', 'Description': 'Fasting_mouse_I.D._635'}, 'PC.636': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '72', 'Description': 'Fasting_mouse_I.D._636'}} subset_metadata_map = pd.DataFrame.from_dict(metadata_map, orient='index') # Takes a subset from metadata_map bv = GradientANOVA(subset_coords, self.prop_expl, self.metadata_map) assert_data_frame_almost_equal( bv._coords.sort_index(), subset_coords.sort_index()) assert_data_frame_almost_equal( bv._metadata_map.sort_index(), subset_metadata_map.sort_index()) # Takes a subset from coords bv = GradientANOVA(self.coords, self.prop_expl, subset_metadata_map) assert_data_frame_almost_equal( bv._coords.sort_index(), subset_coords.sort_index()) assert_data_frame_almost_equal( bv._metadata_map.sort_index(), subset_metadata_map.sort_index()) # Takes a subset from metadata_map and coords at the same time coord_data = { 'PC.636': np.array([-0.212230626531, 0.216034194368, 0.03532727349]), 'PC.635': np.array([-0.277487312135, -0.0295483215975, -0.0744173437992]), 'PC.355': np.array([0.236467470907, 0.21863434374, -0.0301637746424]) } subset_coords = pd.DataFrame.from_dict(coord_data, orient='index') metadata_map = {'PC.355': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '55', 'Description': 'Control_mouse_I.D._355'}, 'PC.607': {'Treatment': 'Fast', 'DOB': '20071112', 'Weight': '65', 'Description': 'Fasting_mouse_I.D._607'}, 'PC.634': {'Treatment': 'Fast', 'DOB': '20080116', 'Weight': '68', 'Description': 'Fasting_mouse_I.D._634'}} subset_metadata_map = pd.DataFrame.from_dict(metadata_map, orient='index') bv = GradientANOVA(subset_coords, self.prop_expl, subset_metadata_map) exp_coords = pd.DataFrame.from_dict( {'PC.355': np.array([0.236467470907, 0.21863434374, -0.0301637746424])}, orient='index') assert_data_frame_almost_equal( bv._coords.sort_index(), exp_coords.sort_index()) exp_metadata_map = pd.DataFrame.from_dict( {'PC.355': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '55', 'Description': 'Control_mouse_I.D._355'}}, orient='index') assert_data_frame_almost_equal( bv._metadata_map.sort_index(), exp_metadata_map.sort_index()) def test_normalize_samples_error(self): """Raises an error if coords and metadata_map does not have samples in common""" error_metadata_map = pd.DataFrame.from_dict( {'Foo': {'Treatment': 'Control', 'DOB': '20061218', 'Weight': '55', 'Description': 'Control_mouse_I.D._355'}, 'Bar': {'Treatment': 'Fast', 'DOB': '20071112', 'Weight': '65', 'Description': 'Fasting_mouse_I.D._607'}}, orient='index') with self.assertRaises(ValueError): GradientANOVA(self.coords, self.prop_expl, error_metadata_map) def test_make_groups(self): """Correctly generates the groups for trajectory_categories""" # Test with all categories bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) exp_groups = {'Treatment': {'Control': ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593'], 'Fast': ['PC.607', 'PC.634', 'PC.635', 'PC.636']}, 'DOB': {'20061218': ['PC.354', 'PC.355'], '20061126': ['PC.356'], '20070314': ['PC.481'], '20071210': ['PC.593'], '20071112': ['PC.607'], '20080116': ['PC.634', 'PC.635', 'PC.636']}, 'Weight': {'60': ['PC.354'], '55': ['PC.355'], '50': ['PC.356'], '52': ['PC.481'], '57': ['PC.593'], '65': ['PC.607'], '68': ['PC.634'], '70': ['PC.635'], '72': ['PC.636']}, 'Description': {'Control_mouse_I.D._354': ['PC.354'], 'Control_mouse_I.D._355': ['PC.355'], 'Control_mouse_I.D._356': ['PC.356'], 'Control_mouse_I.D._481': ['PC.481'], 'Control_mouse_I.D._593': ['PC.593'], 'Fasting_mouse_I.D._607': ['PC.607'], 'Fasting_mouse_I.D._634': ['PC.634'], 'Fasting_mouse_I.D._635': ['PC.635'], 'Fasting_mouse_I.D._636': ['PC.636']}} self.assertEqual(bv._groups, exp_groups) # Test with user-defined categories bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment', 'DOB']) exp_groups = {'Treatment': {'Control': ['PC.354', 'PC.355', 'PC.356', 'PC.481', 'PC.593'], 'Fast': ['PC.607', 'PC.634', 'PC.635', 'PC.636']}, 'DOB': {'20061218': ['PC.354', 'PC.355'], '20061126': ['PC.356'], '20070314': ['PC.481'], '20071210': ['PC.593'], '20071112': ['PC.607'], '20080116': ['PC.634', 'PC.635', 'PC.636']}} self.assertEqual(bv._groups, exp_groups) def test_make_groups_natural_sorting(self): # Ensure sample IDs are sorted using a natural sorting algorithm. df = pd.DataFrame.from_dict({ 'a2': {'Col1': 'foo', 'Col2': '1.0'}, 'a1': {'Col1': 'bar', 'Col2': '-42.0'}, 'a11.0': {'Col1': 'foo', 'Col2': '2e-5'}, 'a-10': {'Col1': 'foo', 'Col2': '5'}, 'a10': {'Col1': 'bar', 'Col2': '5'}}, orient='index') coords = pd.DataFrame.from_dict({ 'a10': np.array([-0.212230626531, 0.216034194368, 0.03532727349]), 'a11.0': np.array([-0.277487312135, -0.0295483215975, -0.0744173437992]), 'a1': np.array([0.220886492631, 0.0874848360559, -0.351990132198]), 'a2': np.array([0.0308923744062, -0.0446295973489, 0.133996451689]), 'a-10': np.array([0.27616778138, -0.0341866951102, 0.0633000238256])}, orient='index') prop_expl = np.array([25.6216900347, 15.7715955926, 14.1215046787, 11.6913885817, 9.83044890697]) # Sort by sample IDs. ga = GradientANOVA(coords, prop_expl, df) exp_groups = { 'Col1': { 'foo': ['a-10', 'a2', 'a11.0'], 'bar': ['a1', 'a10'] }, 'Col2': { '1.0': ['a2'], '-42.0': ['a1'], '2e-5': ['a11.0'], '5': ['a-10', 'a10'] } } self.assertEqual(ga._groups, exp_groups) # Sort sample IDs by Col2. ga = GradientANOVA(coords, prop_expl, df, trajectory_categories=['Col1'], sort_category='Col2') exp_groups = { 'Col1': { 'foo': ['a11.0', 'a2', 'a-10'], 'bar': ['a1', 'a10'] } } self.assertEqual(ga._groups, exp_groups) def test_get_trajectories(self): """Should raise a NotImplementedError as this is a base class""" bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) with self.assertRaises(NotImplementedError): bv.get_trajectories() def test_get_group_trajectories(self): """Should raise a NotImplementedError in usual execution as this is a base class""" bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) with self.assertRaises(NotImplementedError): bv.get_trajectories() def test_get_group_trajectories_error(self): """Should raise a RuntimeError if the user call _get_group_trajectories with erroneous inputs""" bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) with self.assertRaises(KeyError): bv._get_group_trajectories("foo", ['foo']) with self.assertRaises(RuntimeError): bv._get_group_trajectories("bar", []) def test_compute_trajectories_results(self): """Should raise a NotImplementedError as this is a base class""" bv = GradientANOVA(self.coords, self.prop_expl, self.metadata_map) with self.assertRaises(NotImplementedError): bv._compute_trajectories_results("foo", []) class AverageGradientANOVATests(BaseTests): def test_get_trajectories_all(self): """get_trajectories returns the results of all categories""" av = AverageGradientANOVA(self.coords, self.prop_expl, self.metadata_map) obs = av.get_trajectories() exp_description = CategoryResults('Description', None, None, 'This group can not be used. All ' 'groups should have more than 1 ' 'element.') exp_weight = CategoryResults('Weight', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') exp_dob = CategoryResults('DOB', None, None, 'This group can not be used. All groups ' 'should have more than 1 element.') exp_control_group = GroupResults('Control', np.array([2.3694943596755276, 3.3716388181385781, 5.4452089176253367, 4.5704258453173559, 4.4972603724478377]), 4.05080566264, {'avg': 4.0508056626409275}, None) exp_fast_group = GroupResults('Fast', np.array([7.2220488239279126, 4.2726021564374372, 1.1169097274372082, 4.02717600030876]), 4.15968417703, {'avg': 4.1596841770278292}, None) exp_treatment = CategoryResults('Treatment', 0.93311555, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('avg', False, [exp_description, exp_weight, exp_dob, exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) def test_get_trajectories_single(self): """get_trajectories returns the results of the provided category""" av = AverageGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment']) obs = av.get_trajectories() exp_control_group = GroupResults('Control', np.array([2.3694943596755276, 3.3716388181385781, 5.4452089176253367, 4.5704258453173559, 4.4972603724478377]), 4.05080566264, {'avg': 4.0508056626409275}, None) exp_fast_group = GroupResults('Fast', np.array([7.2220488239279126, 4.2726021564374372, 1.1169097274372082, 4.02717600030876]), 4.15968417703, {'avg': 4.1596841770278292}, None) exp_treatment = CategoryResults('Treatment', 0.93311555, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('avg', False, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) def test_get_trajectories_weighted(self): """get_trajectories returns the correct weighted results""" av = AverageGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment'], sort_category='Weight', weighted=True) obs = av.get_trajectories() exp_control_group = GroupResults('Control', np.array([5.7926887872, 4.3242308936, 2.9212403501, 5.5400792151, 1.2326804315]), 3.9621839355, {'avg': 3.9621839355}, None) exp_fast_group = GroupResults('Fast', np.array([7.2187223286, 2.5522161282, 2.2349795861, 4.5278215248]), 4.1334348919, {'avg': 4.1334348919}, None) exp_treatment = CategoryResults('Treatment', 0.9057666800, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('avg', True, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) class TrajectoryGradientANOVATests(BaseTests): def test_get_trajectories(self): tv = TrajectoryGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment'], sort_category='Weight') obs = tv.get_trajectories() exp_control_group = GroupResults('Control', np.array([8.6681963576, 7.0962717982, 7.1036434615, 4.0675712674]), 6.73392072123, {'2-norm': 13.874494152}, None) exp_fast_group = GroupResults('Fast', np.array([11.2291654905, 3.9163741156, 4.4943507388]), 6.5466301150, {'2-norm': 12.713431181}, None) exp_treatment = CategoryResults('Treatment', 0.9374500147, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('trajectory', False, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) def test_get_trajectories_weighted(self): tv = TrajectoryGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment'], sort_category='Weight', weighted=True) obs = tv.get_trajectories() exp_control_group = GroupResults('Control', np.array([8.9850643421, 6.1617529749, 7.7989125908, 4.9666249268]), 6.9780887086, {'2-norm': 14.2894710091}, None) exp_fast_group = GroupResults('Fast', np.array([9.6823682852, 2.9511115209, 5.2434091953]), 5.9589630005, {'2-norm': 11.3995901159}, None) exp_treatment = CategoryResults('Treatment', 0.6248157720, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('trajectory', True, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) class FirstDifferenceGradientANOVATests(BaseTests): def test_get_trajectories(self): dv = FirstDifferenceGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment'], sort_category='Weight') obs = dv.get_trajectories() exp_control_group = GroupResults('Control', np.array([-1.5719245594, 0.0073716633, -3.0360721941]), -1.5335416967, {'mean': -1.5335416967, 'std': 1.2427771485}, None) exp_fast_group = GroupResults('Fast', np.array([-7.3127913749, 0.5779766231]), -3.3674073758, {'mean': -3.3674073758, 'std': 3.9453839990}, None) exp_treatment = CategoryResults('Treatment', 0.6015260608, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('diff', False, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) def test_get_trajectories_weighted(self): dv = FirstDifferenceGradientANOVA(self.coords, self.prop_expl, self.metadata_map, trajectory_categories=['Treatment'], sort_category='Weight', weighted=True) obs = dv.get_trajectories() exp_control_group = GroupResults('Control', np.array([-2.8233113671, 1.6371596158, -2.8322876639]), -1.3394798050, {'mean': -1.3394798050, 'std': 2.1048051097}, None) exp_fast_group = GroupResults('Fast', np.array([-6.7312567642, 2.2922976743]), -2.2194795449, {'mean': -2.2194795449, 'std': 4.5117772193}, None) exp_treatment = CategoryResults('Treatment', 0.8348644420, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('diff', True, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) class WindowDifferenceGradientANOVATests(BaseTests): def test_get_trajectories(self): wdv = WindowDifferenceGradientANOVA( self.coords, self.prop_expl, self.metadata_map, 3, trajectory_categories=['Treatment'], sort_category='Weight') obs = wdv.get_trajectories() exp_control_group = GroupResults('Control', np.array([-2.5790341819, -2.0166764661, -3.0360721941, 0.]), -1.9079457105, {'mean': -1.9079457105, 'std': 1.1592139913}, None) exp_fast_group = GroupResults('Fast', np.array([11.2291654905, 3.9163741156, 4.4943507388]), 6.5466301150, {'mean': 6.5466301150, 'std': 3.3194494926}, "Cannot calculate the first difference " "with a window of size (3).") exp_treatment = CategoryResults('Treatment', 0.0103976830, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('wdiff', False, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) def test_get_trajectories_weighted(self): wdv = WindowDifferenceGradientANOVA( self.coords, self.prop_expl, self.metadata_map, 3, trajectory_categories=['Treatment'], sort_category='Weight', weighted=True) obs = wdv.get_trajectories() exp_control_group = GroupResults('Control', np.array([-2.6759675112, -0.2510321601, -2.8322876639, 0.]), -1.4398218338, {'mean': -1.4398218338, 'std': 1.31845790844}, None) exp_fast_group = GroupResults('Fast', np.array([9.6823682852, 2.9511115209, 5.2434091953]), 5.9589630005, {'mean': 5.9589630005, 'std': 2.7942163293}, "Cannot calculate the first difference " "with a window of size (3).") exp_treatment = CategoryResults('Treatment', 0.0110675605, [exp_control_group, exp_fast_group], None) exp = GradientANOVAResults('wdiff', True, [exp_treatment]) self.assert_gradientANOVA_results_almost_equal(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/tests/test_misc.py000066400000000000000000000033701446255456000215530ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main from skbio.stats._misc import _pprint_strs class PPrintStrsTests(TestCase): def test_truncation(self): # truncation between items (on comma) exp = "'a', ..." obs = _pprint_strs(['a', 'b', 'c'], max_chars=4) self.assertEqual(obs, exp) # truncation between items (on space) exp = "'a', ..." obs = _pprint_strs(['a', 'b', 'c'], max_chars=5) self.assertEqual(obs, exp) # truncation on item exp = "'a', ..." obs = _pprint_strs(['a', 'b', 'c'], max_chars=6) self.assertEqual(obs, exp) # truncation (no items) exp = "..." obs = _pprint_strs(['a', 'b', 'c'], max_chars=2) self.assertEqual(obs, exp) def test_no_truncation(self): exp = "'a'" obs = _pprint_strs(['a'], max_chars=3) self.assertEqual(obs, exp) exp = "'a', 'b', 'c'" obs = _pprint_strs(['a', 'b', 'c']) self.assertEqual(obs, exp) exp = "'a', 'b', 'c'" obs = _pprint_strs(['a', 'b', 'c'], max_chars=13) self.assertEqual(obs, exp) def test_non_default_delimiter_and_suffix(self): exp = "'abc','defg',...." obs = _pprint_strs(['abc', 'defg', 'hi', 'jklmno'], max_chars=14, delimiter=',', suffix='....') self.assertEqual(obs, exp) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/tests/test_power.py000066400000000000000000000525071446255456000217620ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from unittest import TestCase, main import numpy as np import numpy.testing as npt import pandas as pd from scipy.stats import kruskal from skbio.stats.power import (subsample_power, subsample_paired_power, _check_nans, confidence_bound, _calculate_power, _compare_distributions, _calculate_power_curve, _check_subsample_power_inputs, _identify_sample_groups, _draw_paired_samples, _get_min_size, paired_subsamples ) class PowerAnalysisTest(TestCase): def setUp(self): # Defines a testing functions def test_meta(ids, meta, cat, div): """Checks thhe div metric with a kruskal wallis""" out = [meta.loc[id_, div] for id_ in ids] return kruskal(*out)[1] def meta_f(x): """Applies `test_meta` to a result""" return test_meta(x, self.meta, 'INT', 'DIV') def f(x): """returns the p value of a kruskal wallis test""" return kruskal(*x)[1] self.test_meta = test_meta self.f = f self.meta_f = meta_f self.num_p = 1 # Sets the random seed np.random.seed(5) # Sets up the distributions of data for use self.s1 = np.arange(0, 10, 1) # Sets up two distributions which will never be equal by a rank-sum # test. self.samps = [np.ones((10))/10., np.ones((10))] self.pop = [np.arange(0, 10, 0.1), np.arange(0, 20, 0.2)] # Sets up a vector of alpha values self.alpha = np.power(10, np.array([-1, -1.301, -2, -3])).round(3) # Sets up a vector of samples self.num_samps = np.arange(10, 100, 10) # Sets up a mapping file meta = {'GW': {'INT': 'N', 'ABX': np.nan, 'DIV': 19.5, 'AGE': '30s', 'SEX': 'M'}, 'CB': {'INT': 'Y', 'ABX': np.nan, 'DIV': 42.7, 'AGE': '30s', 'SEX': 'M'}, 'WM': {'INT': 'N', 'ABX': 'N', 'DIV': 27.5, 'AGE': '20s', 'SEX': 'F'}, 'MH': {'INT': 'Y', 'ABX': 'N', 'DIV': 62.3, 'AGE': '30s', 'SEX': 'F'}, 'CD': {'INT': 'Y', 'ABX': 'Y', 'DIV': 36.4, 'AGE': '40s', 'SEX': 'F'}, 'LF': {'INT': 'Y', 'ABX': 'N', 'DIV': 50.2, 'AGE': '20s', 'SEX': 'M'}, 'PP': {'INT': 'N', 'ABX': 'Y', 'DIV': 10.8, 'AGE': '30s', 'SEX': 'F'}, 'MM': {'INT': 'N', 'ABX': 'N', 'DIV': 55.6, 'AGE': '40s', 'SEX': 'F'}, 'SR': {'INT': 'N', 'ABX': 'Y', 'DIV': 2.2, 'AGE': '20s', 'SEX': 'M'}, 'TS': {'INT': 'N', 'ABX': 'Y', 'DIV': 16.1, 'AGE': '40s', 'SEX': 'M'}, 'PC': {'INT': 'Y', 'ABX': 'N', 'DIV': 82.6, 'AGE': '40s', 'SEX': 'M'}, 'NR': {'INT': 'Y', 'ABX': 'Y', 'DIV': 15.7, 'AGE': '20s', 'SEX': 'F'}} self.meta = pd.DataFrame.from_dict(meta, orient='index') self.meta_pairs = {0: [['GW', 'SR', 'TS'], ['CB', 'LF', 'PC']], 1: [['MM', 'PP', 'WM'], ['CD', 'MH', 'NR']]} self.pair_index = np.array([0, 0, 0, 1, 1, 1]) self.counts = np.array([5, 15, 25, 35, 45]) self.powers = [np.array([[0.105, 0.137, 0.174, 0.208, 0.280], [0.115, 0.135, 0.196, 0.204, 0.281], [0.096, 0.170, 0.165, 0.232, 0.256], [0.122, 0.157, 0.202, 0.250, 0.279], [0.132, 0.135, 0.173, 0.203, 0.279]]), np.array([[0.157, 0.345, 0.522, 0.639, 0.739], [0.159, 0.374, 0.519, 0.646, 0.757], [0.161, 0.339, 0.532, 0.634, 0.745], [0.169, 0.372, 0.541, 0.646, 0.762], [0.163, 0.371, 0.522, 0.648, 0.746]]), np.array([[0.276, 0.626, 0.865, 0.927, 0.992], [0.267, 0.667, 0.848, 0.937, 0.978], [0.236, 0.642, 0.850, 0.935, 0.977], [0.249, 0.633, 0.828, 0.955, 0.986], [0.249, 0.663, 0.869, 0.951, 0.985]])] self.power_alpha = 0.1 self.effects = np.array([0.15245, 0.34877, 0.55830]) self.bounds = np.array([0.01049, 0.00299, 0.007492]) self.labels = np.array(['Age', 'Intervenption', 'Antibiotics']) self.cats = np.array(['AGE', 'INT', 'ABX']) self.cat = "AGE" self.control_cats = ['INT', 'ABX'] def test_subsample_power_defaults(self): test_p, test_c = subsample_power(self.f, self.pop, num_iter=10, num_runs=5) self.assertEqual(test_p.shape, (5, 4)) npt.assert_array_equal(np.array([10, 20, 30, 40]), test_c) def test_subsample_power_counts(self): test_p, test_c = subsample_power(self.f, samples=self.pop, num_iter=10, num_runs=2, min_counts=5) self.assertEqual(test_p.shape, (2, 5)) npt.assert_array_equal(np.arange(5, 50, 10), test_c) def test_subsample_power_matches(self): test_p, test_c = subsample_power(self.f, samples=self.pop, num_iter=10, num_runs=5, draw_mode="matched") self.assertEqual(test_p.shape, (5, 4)) npt.assert_array_equal(np.array([10, 20, 30, 40]), test_c) def test_subsample_power_multi_p(self): test_p, test_c = subsample_power(lambda x: np.array([0.5, 0.5]), samples=self.pop, num_iter=10, num_runs=5) self.assertEqual(test_p.shape, (5, 4, 2)) npt.assert_array_equal(np.array([10, 20, 30, 40]), test_c) def test_subsample_paired_power(self): known_c = np.array([1, 2, 3, 4]) # Sets up the handling values cat = 'INT' control_cats = ['SEX'] # Tests for the control cats test_p, test_c = subsample_paired_power(self.meta_f, meta=self.meta, cat=cat, control_cats=control_cats, counts_interval=1, num_iter=10, num_runs=2) # Test the output shapes are sane self.assertEqual(test_p.shape, (2, 4)) npt.assert_array_equal(known_c, test_c) def test_subsample_paired_power_multi_p(self): def f(x): return np.array([0.5, 0.5, 0.005]) cat = 'INT' control_cats = ['SEX'] # Tests for the control cats test_p, test_c = subsample_paired_power(f, meta=self.meta, cat=cat, control_cats=control_cats, counts_interval=1, num_iter=10, num_runs=2) self.assertEqual(test_p.shape, (2, 4, 3)) def test_check_nans_str(self): self.assertTrue(_check_nans('string')) def test_check_nans_num(self): self.assertTrue(_check_nans(4.2)) def test__check_nans_nan(self): self.assertFalse(_check_nans(np.nan)) def test__check_nans_clean_list(self): self.assertTrue(_check_nans(['foo', 'bar'], switch=True)) def test__check_nans_list_nan(self): self.assertFalse(_check_nans(['foo', np.nan], switch=True)) def test__check_str_error(self): with self.assertRaises(TypeError): _check_nans(self.f) def test__get_min_size_strict(self): known = 5 test = _get_min_size(self.meta, 'INT', ['ABX', 'SEX'], ['Y', 'N'], True) self.assertEqual(test, known) def test__get_min_size_relaxed(self): known = 5 test = _get_min_size(self.meta, 'INT', ['ABX', 'SEX'], ['Y', 'N'], False) self.assertEqual(known, test) def test_confidence_bound_default(self): # Sets the know confidence bound known = 2.2830070 test = confidence_bound(self.s1) npt.assert_almost_equal(test, known, 3) def test_confidence_bound_df(self): known = 2.15109 test = confidence_bound(self.s1, df=15) npt.assert_almost_equal(known, test, 3) def test_confidence_bound_alpha(self): known = 3.2797886 test = confidence_bound(self.s1, alpha=0.01) npt.assert_almost_equal(known, test, 3) def test_confidence_bound_nan(self): # Sets the value to test samples = np.array([[4, 3.2, 3.05], [2, 2.8, 2.95], [5, 2.9, 3.07], [1, 3.1, 2.93], [3, np.nan, 3.00]]) # Sets the know value known = np.array([2.2284, 0.2573, 0.08573]) # Tests the function test = confidence_bound(samples, axis=0) npt.assert_almost_equal(known, test, 3) def test_confidence_bound_axis_none(self): # Sets the value to test samples = np.array([[4, 3.2, 3.05], [2, 2.8, 2.95], [5, 2.9, 3.07], [1, 3.1, 2.93], [3, np.nan, 3.00]]) # Sest the known value known = 0.52852 # Tests the output test = confidence_bound(samples, axis=None) npt.assert_almost_equal(known, test, 3) def test__calculate_power(self): # Sets up the values to test crit = 0.025 # Sets the known value known = 0.5 # Calculates the test value test = _calculate_power(self.alpha, crit) # Checks the test value npt.assert_almost_equal(known, test) def test__calculate_power_n(self): crit = 0.025 known = np.array([0.5, 0.5]) alpha = np.vstack((self.alpha, self.alpha)) test = _calculate_power(alpha, crit) npt.assert_almost_equal(known, test) def test__compare_distributions_sample_counts_error(self): with self.assertRaises(ValueError): _compare_distributions(self.f, [self.pop[0][:5], self.pop[1]], 1, counts=25) def test__compare_distributions_all_mode(self): known = np.ones((100))*0.0026998 test = _compare_distributions(self.f, self.samps, 1, num_iter=100) npt.assert_allclose(known, test, 5) def test__compare_distributions_matched_mode(self): # Sets the known value known_mean = 0.162195 known_std = 0.121887 known_shape = (100,) # Tests the sample value test = _compare_distributions(self.f, self.pop, self.num_p, mode='matched', num_iter=100) npt.assert_allclose(known_mean, test.mean(), rtol=0.1, atol=0.02) npt.assert_allclose(known_std, test.std(), rtol=0.1, atol=0.02) self.assertEqual(known_shape, test.shape) def test__compare_distributions_draw_mode(self): draw_mode = 'Ultron' with self.assertRaises(ValueError): _check_subsample_power_inputs(self.f, self.pop, draw_mode, self.num_p) def test__compare_distributions_multiple_returns(self): known = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) def f(x): return np.array([1, 2, 3]) test = _compare_distributions(f, self.pop, 3, mode='matched', num_iter=3) npt.assert_array_equal(known, test) def test_check_subsample_power_inputs_matched_mode(self): with self.assertRaises(ValueError): _check_subsample_power_inputs(self.f, samples=[np.ones((2)), np.ones((5))], draw_mode="matched") def test_check_subsample_power_inputs_counts(self): with self.assertRaises(ValueError): _check_subsample_power_inputs(self.f, samples=[np.ones((3)), np.ones((5))], min_counts=5, counts_interval=1000, max_counts=7) def test_check_subsample_power_inputs_ratio(self): with self.assertRaises(ValueError): _check_subsample_power_inputs(self.f, self.samps, ratio=np.array([1, 2, 3])) def test_check_subsample_power_inputs_test(self): # Defines a test function def test(x): return 'Hello World!' with self.assertRaises(TypeError): _check_subsample_power_inputs(test, self.samps) def test_check_sample_power_inputs(self): # Defines the know returns known_num_p = 1 known_ratio = np.ones((2)) known_counts = np.arange(2, 10, 2) # Runs the code for the returns test_ratio, test_num_p, test_counts = \ _check_subsample_power_inputs(self.f, self.samps, counts_interval=2, max_counts=10) # Checks the returns are sane self.assertEqual(known_num_p, test_num_p) npt.assert_array_equal(known_ratio, test_ratio) npt.assert_array_equal(known_counts, test_counts) def test__calculate_power_curve_ratio_error(self): with self.assertRaises(ValueError): _calculate_power_curve(self.f, self.pop, self.num_samps, ratio=np.array([0.1, 0.2, 0.3]), num_iter=100) def test__calculate_power_curve_default(self): # Sets the known output known = np.array([0.509, 0.822, 0.962, 0.997, 1.000, 1.000, 1.000, 1.000, 1.000]) # Generates the test values test = _calculate_power_curve(self.f, self.pop, self.num_samps, num_iter=100) # Checks the samples returned sanely npt.assert_allclose(test, known, rtol=0.1, atol=0.01) def test__calculate_power_curve_alpha(self): # Sets the know output known = np.array([0.31, 0.568, 0.842, 0.954, 0.995, 1.000, 1.000, 1.000, 1.000]) # Generates the test values test = _calculate_power_curve(self.f, self.pop, self.num_samps, alpha=0.01, num_iter=100) # Checks the samples returned sanely npt.assert_allclose(test, known, rtol=0.1, atol=0.1) def test__calculate_power_curve_ratio(self): # Sets the know output known = np.array([0.096, 0.333, 0.493, 0.743, 0.824, 0.937, 0.969, 0.996, 0.998]) # Generates the test values test = _calculate_power_curve(self.f, self.pop, self.num_samps, ratio=np.array([0.25, 0.75]), num_iter=100) # Checks the samples returned sanely npt.assert_allclose(test, known, rtol=0.1, atol=0.1) def test_paired_subsamples_default(self): # Sets the known np.array set known_array = [{'MM', 'SR', 'TS', 'GW', 'PP', 'WM'}, {'CD', 'LF', 'PC', 'CB', 'MH', 'NR'}] # Gets the test value cat = 'INT' control_cats = ['SEX', 'AGE'] test_array = paired_subsamples(self.meta, cat, control_cats) self.assertEqual(known_array[0], set(test_array[0])) self.assertEqual(known_array[1], set(test_array[1])) def test_paired_subsamples_break(self): # Sets known np.array set known_array = [np.array([]), np.array([])] # Gets the test value cat = 'ABX' control_cats = ['SEX', 'AGE', 'INT'] test_array = paired_subsamples(self.meta, cat, control_cats) npt.assert_array_equal(known_array, test_array) def test_paired_subsample_undefined(self): known_array = np.zeros((2, 0)) cat = 'INT' order = ['Y', 'N'] control_cats = ['AGE', 'ABX', 'SEX'] test_array = paired_subsamples(self.meta, cat, control_cats, order=order) npt.assert_array_equal(test_array, known_array) def test_paired_subsample_fewer(self): # Set known value known_array = {'PP', 'MH', 'CD', 'PC', 'TS', 'MM'} # Sets up test values cat = 'AGE' order = ['30s', '40s'] control_cats = ['ABX'] test_array = paired_subsamples(self.meta, cat, control_cats, order=order) for v in test_array[0]: self.assertTrue(v in known_array) for v in test_array[1]: self.assertTrue(v in known_array) def test_paired_subsamples_not_strict(self): known_array = [{'WM', 'MM', 'GW', 'SR', 'TS'}, {'LF', 'PC', 'CB', 'NR', 'CD'}] # Gets the test values cat = 'INT' control_cats = ['ABX', 'AGE'] test_array = paired_subsamples(self.meta, cat, control_cats, strict_match=False) self.assertEqual(set(test_array[0]), known_array[0]) self.assertEqual(set(test_array[1]), known_array[1]) def test__identify_sample_groups(self): # Defines the know values known_pairs = {0: [['MM'], ['CD']], 1: [['SR'], ['LF']], 2: [['TS'], ['PC']], 3: [['GW'], ['CB']], 4: [['PP'], ['MH']], 5: [['WM'], ['NR']]} known_index = np.array([0, 1, 2, 3, 4, 5]) test_pairs, test_index = _identify_sample_groups(self.meta, 'INT', ['SEX', 'AGE'], order=['N', 'Y'], strict_match=True) self.assertEqual(known_pairs.keys(), test_pairs.keys()) self.assertEqual(sorted(known_pairs.values()), sorted(test_pairs.values())) npt.assert_array_equal(known_index, test_index) def test__identify_sample_groups_not_strict(self): # Defines the know values known_pairs = {1: [np.array(['PP'], dtype=object), np.array(['CD', 'NR'], dtype=object)], 0: [np.array(['MM', 'WM'], dtype=object), np.array(['MH'], dtype=object)], 2: [np.array(['GW'], dtype=object), np.array(['CB'], dtype=object)]} known_index = np.array([0, 1, 2]) test_pairs, test_index = _identify_sample_groups(self.meta, 'INT', ['SEX', 'ABX'], order=['N', 'Y'], strict_match=False) self.assertEqual(known_pairs.keys(), test_pairs.keys()) for k in known_pairs: for i in range(2): npt.assert_array_equal(known_pairs[k][i], test_pairs[k][i]) npt.assert_array_equal(known_index, test_index) def test__draw_paired_samples(self): num_samps = 3 known_sets = [{'GW', 'SR', 'TS', 'MM', 'PP', 'WM'}, {'CB', 'LF', 'PC', 'CD', 'MH', 'NR'}] test_samps = _draw_paired_samples(self.meta_pairs, self.pair_index, num_samps) for i, t in enumerate(test_samps): self.assertTrue(set(t).issubset(known_sets[i])) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/stats/tests/test_subsample.py000066400000000000000000000215341446255456000226150ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import warnings import numpy as np import numpy.testing as npt from skbio.stats import subsample_counts, isubsample def setup(): """Ignore warnings during tests.""" warnings.simplefilter("ignore") def teardown(): """Clear the list of warning filters, so that no filters are active.""" warnings.resetwarnings() class SubsampleCountsTests(unittest.TestCase): def test_subsample_counts_nonrandom(self): a = np.array([0, 5, 0]) # Subsample same number of items that are in input (without # replacement). npt.assert_equal(subsample_counts(a, 5), a) # Can only choose from one bin. exp = np.array([0, 2, 0]) npt.assert_equal(subsample_counts(a, 2), exp) npt.assert_equal( subsample_counts(a, 2, replace=True), exp) # Subsample zero items. a = [3, 0, 1] exp = np.array([0, 0, 0]) npt.assert_equal(subsample_counts(a, 0), exp) npt.assert_equal(subsample_counts(a, 0, replace=True), exp) def test_subsample_counts_without_replacement(self): # Selecting 2 counts from the vector 1000 times yields each of the two # possible results at least once each. a = np.array([2, 0, 1]) actual = set() for i in range(1000): obs = subsample_counts(a, 2) actual.add(tuple(obs)) self.assertEqual(actual, {(1, 0, 1), (2, 0, 0)}) obs = subsample_counts(a, 2) self.assertTrue(np.array_equal(obs, np.array([1, 0, 1])) or np.array_equal(obs, np.array([2, 0, 0]))) def test_subsample_counts_with_replacement(self): # Can choose from all in first bin, all in last bin (since we're # sampling with replacement), or split across bins. a = np.array([2, 0, 1]) actual = set() for i in range(1000): obs = subsample_counts(a, 2, replace=True) actual.add(tuple(obs)) self.assertEqual(actual, {(1, 0, 1), (2, 0, 0), (0, 0, 2)}) # Test that selecting 35 counts from a 36-count vector 1000 times # yields more than 10 different subsamples. If we were subsampling # *without* replacement, there would be only 10 possible subsamples # because there are 10 nonzero bins in array a. However, there are more # than 10 possibilities when sampling *with* replacement. a = np.array([2, 0, 1, 2, 1, 8, 6, 0, 3, 3, 5, 0, 0, 0, 5]) actual = set() for i in range(1000): obs = subsample_counts(a, 35, replace=True) self.assertEqual(obs.sum(), 35) actual.add(tuple(obs)) self.assertTrue(len(actual) > 10) def test_subsample_counts_with_replacement_equal_n(self): # test when n == counts.sum() a = np.array([0, 0, 3, 4, 2, 1]) actual = set() for i in range(1000): obs = subsample_counts(a, 10, replace=True) self.assertEqual(obs.sum(), 10) actual.add(tuple(obs)) self.assertTrue(len(actual) > 1) def test_subsample_counts_invalid_input(self): # Negative n. with self.assertRaises(ValueError): subsample_counts([1, 2, 3], -1) # Floats. with self.assertRaises(TypeError): subsample_counts([1, 2.3, 3], 2) # Wrong number of dimensions. with self.assertRaises(ValueError): subsample_counts([[1, 2, 3], [4, 5, 6]], 2) # Input has too few counts. with self.assertRaises(ValueError): subsample_counts([0, 5, 0], 6, replace=False) # Input has too counts, but should work with bootstrap subsample_counts([0, 5, 0], 6, replace=True) class ISubsampleTests(unittest.TestCase): def setUp(self): np.random.seed(123) # comment indicates the expected random value self.sequences = [ ('a_1', 'AATTGGCC-a1'), # 2, 3624216819017203053 ('a_2', 'AATTGGCC-a2'), # 5, 5278339153051796802 ('b_1', 'AATTGGCC-b1'), # 4, 4184670734919783522 ('b_2', 'AATTGGCC-b2'), # 0, 946590342492863505 ('a_4', 'AATTGGCC-a4'), # 3, 4048487933969823850 ('a_3', 'AATTGGCC-a3'), # 7, 7804936597957240377 ('c_1', 'AATTGGCC-c1'), # 8, 8868534167180302049 ('a_5', 'AATTGGCC-a5'), # 1, 3409506807702804593 ('c_2', 'AATTGGCC-c2'), # 9, 8871627813779918895 ('c_3', 'AATTGGCC-c3') # 6, 7233291490207274528 ] def mock_sequence_iter(self, items): return ({'SequenceID': sid, 'Sequence': seq} for sid, seq in items) def test_isubsample_simple(self): maximum = 10 def bin_f(x): return x['SequenceID'].rsplit('_', 1)[0] # note, the result here is sorted by sequence_id but is in heap order # by the random values associated to each sequence exp = sorted([('a', {'SequenceID': 'a_5', 'Sequence': 'AATTGGCC-a5'}), ('a', {'SequenceID': 'a_1', 'Sequence': 'AATTGGCC-a1'}), ('a', {'SequenceID': 'a_4', 'Sequence': 'AATTGGCC-a4'}), ('a', {'SequenceID': 'a_3', 'Sequence': 'AATTGGCC-a3'}), ('a', {'SequenceID': 'a_2', 'Sequence': 'AATTGGCC-a2'}), ('b', {'SequenceID': 'b_2', 'Sequence': 'AATTGGCC-b2'}), ('b', {'SequenceID': 'b_1', 'Sequence': 'AATTGGCC-b1'}), ('c', {'SequenceID': 'c_3', 'Sequence': 'AATTGGCC-c3'}), ('c', {'SequenceID': 'c_2', 'Sequence': 'AATTGGCC-c2'}), ('c', {'SequenceID': 'c_1', 'Sequence': 'AATTGGCC-c1'})], key=lambda x: x[0]) obs = isubsample(self.mock_sequence_iter(self.sequences), maximum, bin_f=bin_f) self.assertEqual(sorted(obs, key=lambda x: x[0]), exp) def test_per_sample_sequences_min_seqs(self): maximum = 10 minimum = 3 def bin_f(x): return x['SequenceID'].rsplit('_', 1)[0] # note, the result here is sorted by sequence_id but is in heap order # by the random values associated to each sequence exp = sorted([('a', {'SequenceID': 'a_5', 'Sequence': 'AATTGGCC-a5'}), ('a', {'SequenceID': 'a_1', 'Sequence': 'AATTGGCC-a1'}), ('a', {'SequenceID': 'a_4', 'Sequence': 'AATTGGCC-a4'}), ('a', {'SequenceID': 'a_3', 'Sequence': 'AATTGGCC-a3'}), ('a', {'SequenceID': 'a_2', 'Sequence': 'AATTGGCC-a2'}), ('c', {'SequenceID': 'c_3', 'Sequence': 'AATTGGCC-c3'}), ('c', {'SequenceID': 'c_2', 'Sequence': 'AATTGGCC-c2'}), ('c', {'SequenceID': 'c_1', 'Sequence': 'AATTGGCC-c1'})], key=lambda x: x[0]) obs = isubsample(self.mock_sequence_iter(self.sequences), maximum, minimum, bin_f=bin_f) self.assertEqual(sorted(obs, key=lambda x: x[0]), exp) def test_per_sample_sequences_complex(self): maximum = 2 def bin_f(x): return x['SequenceID'].rsplit('_', 1)[0] exp = sorted([('a', {'SequenceID': 'a_2', 'Sequence': 'AATTGGCC-a2'}), ('a', {'SequenceID': 'a_3', 'Sequence': 'AATTGGCC-a3'}), ('b', {'SequenceID': 'b_2', 'Sequence': 'AATTGGCC-b2'}), ('b', {'SequenceID': 'b_1', 'Sequence': 'AATTGGCC-b1'}), ('c', {'SequenceID': 'c_1', 'Sequence': 'AATTGGCC-c1'}), ('c', {'SequenceID': 'c_2', 'Sequence': 'AATTGGCC-c2'})], key=lambda x: x[0]) obs = isubsample(self.mock_sequence_iter(self.sequences), maximum, bin_f=bin_f, buf_size=1) self.assertEqual(sorted(obs, key=lambda x: x[0]), exp) def test_min_gt_max(self): gen = isubsample([1, 2, 3], maximum=2, minimum=10) with self.assertRaises(ValueError): next(gen) def test_min_lt_zero(self): gen = isubsample([1, 2, 3], maximum=0, minimum=-10) with self.assertRaises(ValueError): next(gen) def test_max_lt_zero(self): gen = isubsample([1, 2, 3], maximum=-10) with self.assertRaises(ValueError): next(gen) def test_binf_is_none(self): maximum = 2 items = [1, 2] exp = [(True, 1), (True, 2)] obs = isubsample(items, maximum) self.assertEqual(list(obs), exp) if __name__ == '__main__': import nose nose.runmodule() scikit-bio-0.5.9/skbio/test.py000066400000000000000000000006651446255456000162440ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from skbio.util import pytestrunner if __name__ == '__main__': pytestrunner() scikit-bio-0.5.9/skbio/tests/000077500000000000000000000000001446255456000160465ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/tests/__init__.py000066400000000000000000000005411446255456000201570ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/tests/test_base.py000066400000000000000000000030211446255456000203650ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest from skbio._base import SkbioObject, ElasticLines class TestSkbioObject(unittest.TestCase): def test_no_instantiation(self): class Foo(SkbioObject): pass with self.assertRaises(TypeError): Foo() class TestElasticLines(unittest.TestCase): def setUp(self): self.el = ElasticLines() def test_empty(self): self.assertEqual(self.el.to_str(), '') def test_add_line(self): self.el.add_line('foo') self.assertEqual(self.el.to_str(), 'foo') def test_add_lines(self): self.el = ElasticLines() self.el.add_lines(['alice', 'bob', 'carol']) self.assertEqual(self.el.to_str(), 'alice\nbob\ncarol') def test_add_separator(self): self.el.add_separator() self.assertEqual(self.el.to_str(), '') self.el.add_line('foo') self.assertEqual(self.el.to_str(), '---\nfoo') self.el.add_separator() self.el.add_lines(['bar', 'bazzzz']) self.el.add_separator() self.assertEqual(self.el.to_str(), '------\nfoo\n------\nbar\nbazzzz\n------') if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/tests/test_workflow.py000066400000000000000000000315571446255456000213440ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from collections import defaultdict from skbio.workflow import (Exists, NotExecuted, NotNone, Workflow, not_none, requires, method) from unittest import TestCase, main def construct_iterator(**kwargs): """make an iterator for testing purposes""" to_gen = [] for k in sorted(kwargs): if k.startswith('iter'): to_gen.append(kwargs[k]) if len(to_gen) == 1: return (x for x in to_gen[0]) else: return zip(*to_gen) class MockWorkflow(Workflow): def initialize_state(self, item): self.state[0] = None self.state[1] = item @method(priority=90) @requires(option='A', values=True) def wf_groupA(self): self.methodA1() self.methodA2() @method() @requires(option='B', values=True) def wf_groupB(self): self.methodB1() self.methodB2() @method(priority=10) @requires(option='C', values=True) def wf_groupC(self): self.methodC1() self.methodC2() def methodA1(self): name = 'A1' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] def methodA2(self): name = 'A2' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] def methodB1(self): name = 'B1' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = 'failed' else: self.state = [name, self.state[-1]] @requires(option='foo', values=[1, 2, 3]) def methodB2(self): name = 'B2' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = 'failed' else: self.state = [name, self.state[-1]] def methodC1(self): name = 'C1' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] @requires(option='C2', values=[1, 2, 3]) def methodC2(self): name = 'C2' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] class WorkflowTests(TestCase): def setUp(self): opts = {'A': True, 'C': True} self.obj_short = MockWorkflow([None, None], options=opts, stats=defaultdict(int)) self.obj_debug = MockWorkflow([None, None], debug=True, options=opts, stats=defaultdict(int)) self.obj_noshort = MockWorkflow([None, None], short_circuit=False, options=opts, stats=defaultdict(int)) def test_debug_trace(self): gen = construct_iterator(**{'iter_x': [1, 2, 3, 4, 5]}) obj = self.obj_debug(gen) exp = ['C1', 1] obs = next(obj) self.assertEqual(obs, exp) exp_trace = set([('wf_groupA', 0), ('methodA1', 1), ('methodA2', 2), ('wf_groupC', 3), ('methodC1', 4)]) exp_pre_state = {('wf_groupA', 0): [None, 1], ('methodA1', 1): [None, 1], ('methodA2', 2): ['A1', 1], ('wf_groupC', 3): ['A2', 1], ('methodC1', 4): ['A2', 1]} exp_post_state = {('wf_groupA', 0): ['A2', 1], ('methodA1', 1): ['A1', 1], ('methodA2', 2): ['A2', 1], ('wf_groupC', 3): ['C1', 1], ('methodC1', 4): ['C1', 1]} obs_trace = self.obj_debug.debug_trace obs_pre_state = self.obj_debug.debug_pre_state obs_post_state = self.obj_debug.debug_post_state self.assertEqual(obs_trace, exp_trace) self.assertEqual(obs_pre_state, exp_pre_state) self.assertEqual(obs_post_state, exp_post_state) def test_init(self): self.assertEqual(self.obj_short.options, {'A': True, 'C': True}) self.assertEqual(self.obj_short.stats, {}) self.assertTrue(self.obj_short.short_circuit) self.assertEqual(self.obj_noshort.options, {'A': True, 'C': True}) self.assertEqual(self.obj_noshort.stats, {}) self.assertFalse(self.obj_noshort.short_circuit) def test_init_reserved_attributes(self): with self.assertRaises(AttributeError): Workflow('foo', failed=True) def test_all_wf_methods(self): # note on priority: groupA:90, groupC:10, groupB:0 (default) exp = [self.obj_short.wf_groupA, self.obj_short.wf_groupC, self.obj_short.wf_groupB] obs = self.obj_short._all_wf_methods() self.assertEqual(obs, exp) def test_call_AC_no_fail(self): iter_ = construct_iterator(**{'iter_x': [1, 2, 3, 4, 5]}) # success function def sf(x): return x.state[:] exp_stats = {'A1': 5, 'A2': 5, 'C1': 5} # C2 isn't executed as its requirements aren't met in the options exp_result = [['C1', 1], ['C1', 2], ['C1', 3], ['C1', 4], ['C1', 5]] obs_result = list(self.obj_short(iter_, sf, None)) self.assertEqual(obs_result, exp_result) self.assertEqual(self.obj_short.stats, exp_stats) def test_call_AC_fail(self): iter_ = construct_iterator(**{'iter_x': [1, 2, 'fail A2', 4, 5]}) # success function def sf(x): return x.state[:] ff = sf # failed function exp_stats = {'A1': 5, 'A2': 5, 'C1': 4, 'C2': 4} self.obj_short.options['C2'] = 1 # pass in a failed callback to capture the result, and pause execution gen = self.obj_short(iter_, sf, ff) r1 = next(gen) self.assertEqual(r1, ['C2', 1]) self.assertFalse(self.obj_short.failed) r2 = next(gen) self.assertEqual(r2, ['C2', 2]) self.assertFalse(self.obj_short.failed) r3 = next(gen) self.assertEqual(self.obj_short.state, ['A2', 'fail A2']) self.assertTrue(self.obj_short.failed) self.assertEqual(r3, ['A2', 'fail A2']) r4 = next(gen) self.assertEqual(r4, ['C2', 4]) self.assertFalse(self.obj_short.failed) r5 = next(gen) self.assertEqual(r5, ['C2', 5]) self.assertFalse(self.obj_short.failed) self.assertEqual(self.obj_short.stats, exp_stats) def test_call_AC_fail_noshort(self): iter_ = construct_iterator(**{'iter_x': [1, 2, 'fail A2', 4, 5]}) # success function def sf(x): return x.state[:] ff = sf # failed function exp_stats = {'A1': 5, 'A2': 5, 'C1': 5} # pass in a failed callback to capture the result, and pause execution gen = self.obj_noshort(iter_, sf, ff) r1 = next(gen) self.assertEqual(r1, ['C1', 1]) self.assertFalse(self.obj_noshort.failed) r2 = next(gen) self.assertEqual(r2, ['C1', 2]) self.assertFalse(self.obj_noshort.failed) next(gen) self.assertEqual(self.obj_noshort.state, ['C1', 'fail A2']) self.assertTrue(self.obj_noshort.failed) r4 = next(gen) self.assertEqual(r4, ['C1', 4]) self.assertFalse(self.obj_noshort.failed) r5 = next(gen) self.assertEqual(r5, ['C1', 5]) self.assertFalse(self.obj_noshort.failed) self.assertEqual(self.obj_noshort.stats, exp_stats) class MockWorkflowReqTest(Workflow): def _allocate_state(self): self.state = None def initialize_state(self, item): self.state = [None, item] @method(priority=5) @requires(state=lambda x: x[-1] < 3) def wf_needs_data(self): name = 'needs_data' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] @method(priority=10) def wf_always_run(self): name = 'always_run' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] @method(priority=20) @requires(option='cannot_be_none', values=not_none) def wf_run_if_not_none(self): name = 'run_if_not_none' self.stats[name] += 1 if self.state[-1] == 'fail %s' % name: self.failed = True self.state = [name, self.state[-1]] class RequiresTests(TestCase): def test_validdata(self): obj = MockWorkflowReqTest([None, None], stats=defaultdict(int)) single_iter = construct_iterator(**{'iter_x': [1, 2, 3, 4, 5]}) exp_stats = {'needs_data': 2, 'always_run': 5} exp_result = [['needs_data', 1], ['needs_data', 2], ['always_run', 3], ['always_run', 4], ['always_run', 5]] obs_result = list(obj(single_iter)) self.assertEqual(obs_result, exp_result) self.assertEqual(obj.stats, exp_stats) def test_not_none_avoid(self): obj = MockWorkflowReqTest([None, None], {'cannot_be_none': None}, stats=defaultdict(int)) single_iter = construct_iterator(**{'iter_x': [1, 2, 3, 4, 5]}) exp_stats = {'needs_data': 2, 'always_run': 5} exp_result = [['needs_data', 1], ['needs_data', 2], ['always_run', 3], ['always_run', 4], ['always_run', 5]] obs_result = list(obj(single_iter)) self.assertEqual(obs_result, exp_result) self.assertEqual(obj.stats, exp_stats) def test_not_none_execute(self): obj = MockWorkflowReqTest([None, None], options={'cannot_be_none': True}, debug=True, stats=defaultdict(int)) single_iter = construct_iterator(**{'iter_x': [1, 2, 3, 4, 5]}) exp_stats = {'needs_data': 2, 'always_run': 5, 'run_if_not_none': 5} exp_result = [['needs_data', 1], ['needs_data', 2], ['always_run', 3], ['always_run', 4], ['always_run', 5]] obs_result = list(obj(single_iter)) self.assertEqual(obs_result, exp_result) self.assertEqual(obj.stats, exp_stats) def test_methodb1(self): obj = MockWorkflow([None, None], stats=defaultdict(int)) obj.initialize_state('test') obj.methodB1() self.assertEqual(obj.state, ['B1', 'test']) self.assertFalse(obj.failed) # methodb1 executes regardless of if self.failed obj.failed = True obj.initialize_state('test 2') obj.methodB1() self.assertEqual(obj.state, ['B1', 'test 2']) obj.failed = False obj.state = [None, 'fail B1'] obj.methodB1() self.assertEqual(obj.state, 'failed') self.assertEqual(obj.stats, {'B1': 3}) def test_methodb2_accept(self): # methodb2 is setup to be valid when foo is in [1,2,3], make sure we # can execute obj = MockWorkflow([None, None], options={'foo': 1}, stats=defaultdict(int)) obj.initialize_state('test') obj.methodB2() self.assertEqual(obj.state, ['B2', 'test']) self.assertEqual(obj.stats, {'B2': 1}) def test_methodb2_ignore(self): # methodb2 is setup to be valid when foo is in [1, 2, 3], make sure # we do not execute obj = MockWorkflow([None, None], options={'foo': 'bar'}, stats=defaultdict(int)) obj.methodB2() self.assertEqual(obj.state, [None, None]) self.assertEqual(obj.stats, {}) class PriorityTests(TestCase): def test_dec(self): @method(priority=10) def foo(x, y, z): """doc check""" return x + y + z self.assertEqual(foo.priority, 10) self.assertEqual(foo.__name__, 'foo') self.assertEqual(foo.__doc__, 'doc check') class NotExecutedTests(TestCase): def test_call(self): ne = NotExecuted() obs = ne('foo') self.assertTrue(obs is ne) self.assertEqual(obs.msg, 'foo') class ExistsTests(TestCase): def test_contains(self): e = Exists() self.assertTrue('foo' in e) self.assertTrue(None in e) class NotNoneTests(TestCase): def test_contains(self): nn = NotNone() self.assertTrue('foo' in nn) self.assertFalse(None in nn) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/tree/000077500000000000000000000000001446255456000156435ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/tree/__init__.py000066400000000000000000000132621446255456000177600ustar00rootroot00000000000000r""" Tree representations (:mod:`skbio.tree`) ======================================== .. currentmodule:: skbio.tree This module provides functionality for working with trees, including phylogenetic trees and hierarchies. Functionality is provided for constructing trees, for traversing in multiple ways, comparisons, fetching subtrees, and more. This module supports trees that are multifurcating and nodes that have single descendants. Classes ------- .. autosummary:: :toctree: generated/ TreeNode Phylogenetic Reconstruction --------------------------- .. autosummary:: :toctree: generated/ nj Utility Functions ----------------- .. autosummary:: :toctree: generated/ majority_rule Exceptions ---------- .. autosummary:: :toctree: generated/ TreeError NoLengthError DuplicateNodeError MissingNodeError NoParentError Examples -------- >>> from skbio import TreeNode >>> from io import StringIO A new tree can be constructed from a Newick string. Newick is a common format used to represent tree objects within a file. Newick was part of the original PHYLIP package from Joseph Felsenstein's group (defined `here `_), and is based around representing nesting with parentheses. For instance, the following string describes a 3 taxon tree, with one internal node: ((A, B)C, D)root; Where A, B, and D are tips of the tree, and C is an internal node that covers tips A and B. Now let's construct a simple tree and dump an ASCII representation: >>> tree = TreeNode.read(StringIO("((A, B)C, D)root;")) >>> print(tree.is_root()) # is this the root of the tree? True >>> print(tree.is_tip()) # is this node a tip? False >>> print(tree.ascii_art()) /-A /C-------| -root----| \-B | \-D There are a few common ways to traverse a tree, and depending on your use, some methods are more appropriate than others. Wikipedia has a well written page on tree `traversal methods `_, and will go into further depth than what we'll cover here. We're only going to cover two of the commonly used traversals here, preorder and postorder, but we will show examples of two other common helper traversal methods to gather tips or internal nodes. The first traversal we'll cover is a preorder traversal in which you evaluate from root to tips, looking at the left most child first. For instance: >>> for node in tree.preorder(): ... print(node.name) root C A B D The next method we'll look at is a postorder traveral which will evaluate the left subtree tips first before walking back up the tree: >>> for node in tree.postorder(): ... print(node.name) A B C D root `TreeNode` provides two helper methods as well for iterating over just the tips or for iterating over just the internal nodes. >>> for node in tree.tips(): ... print("Node name: %s, Is a tip: %s" % (node.name, node.is_tip())) Node name: A, Is a tip: True Node name: B, Is a tip: True Node name: D, Is a tip: True >>> for node in tree.non_tips(): ... print("Node name: %s, Is a tip: %s" % (node.name, node.is_tip())) Node name: C, Is a tip: False Note, by default, `non_tips` will ignore `self` (which is the root in this case). You can pass the `include_self` flag to `non_tips` if you wish to include `self`. The `TreeNode` provides a few ways to compare trees. First, let's create two similar trees and compare their topologies using `compare_subsets`. This distance is the fraction of common clades present in the two trees, where a distance of 0 means the trees contain identical clades, and a distance of 1 indicates the trees do not share any common clades: >>> tree1 = TreeNode.read(StringIO("((A, B)C, (D, E)F, (G, H)I)root;")) >>> tree2 = TreeNode.read(StringIO("((G, H)C, (D, E)F, (B, A)I)root;")) >>> tree3 = TreeNode.read(StringIO("((D, B)C, (A, E)F, (G, H)I)root;")) >>> print(tree1.compare_subsets(tree1)) # identity case 0.0 >>> print(tree1.compare_subsets(tree2)) # same tree but different clade order 0.0 >>> print(tree1.compare_subsets(tree3)) # only 1 of 3 common subsets 0.6666666666666667 We can additionally take into account branch length when computing distances between trees. First, we're going to construct two new trees with described branch length, note the difference in the Newick strings: >>> tree1 = \ ... TreeNode.read(StringIO("((A:0.1, B:0.2)C:0.3, D:0.4, E:0.5)root;")) >>> tree2 = \ ... TreeNode.read(StringIO("((A:0.4, B:0.8)C:0.3, D:0.1, E:0.5)root;")) In these two trees, we've added on a description of length from the node to its parent, so for instance: >>> for node in tree1.postorder(): ... print(node.name, node.length) A 0.1 B 0.2 C 0.3 D 0.4 E 0.5 root None Now let's compare two trees using the distances computed pairwise between tips in the trees. The distance computed, by default, is the correlation of all pairwise tip-to-tip distances between trees: >>> print(tree1.compare_tip_distances(tree1)) # identity case 0.0 >>> print(tree1.compare_tip_distances(tree2)) 0.120492524415 """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._tree import TreeNode from ._nj import nj from ._majority_rule import majority_rule from ._exception import (TreeError, NoLengthError, DuplicateNodeError, MissingNodeError, NoParentError) __all__ = ['TreeNode', 'nj', 'majority_rule', 'TreeError', 'NoLengthError', 'DuplicateNodeError', 'MissingNodeError', 'NoParentError'] scikit-bio-0.5.9/skbio/tree/_exception.py000066400000000000000000000013541446255456000203550ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- class TreeError(Exception): """General tree error""" pass class NoLengthError(TreeError): """Missing length when expected""" pass class DuplicateNodeError(TreeError): """Duplicate nodes with identical names""" pass class MissingNodeError(TreeError): """Expecting a node""" pass class NoParentError(MissingNodeError): """Missing a parent""" pass scikit-bio-0.5.9/skbio/tree/_majority_rule.py000066400000000000000000000246601446255456000212510ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from collections import defaultdict import numpy as np from skbio.tree import TreeNode from skbio.util._decorator import experimental def _walk_clades(trees, weights): """Walk all the clades of all the trees Parameters ---------- trees : list of TreeNode The trees to walk weights : np.array Tree weights Returns ------- list of tuple The clades and support values sorted by support value such that the most supported clade is index 0. The tuples are of the form: (frozenset, float). defaultdict(float) The edge lengths, keyed by frozenset of the clade, and valued by the weighted average length of the clade by the trees the clade was observed in. """ clade_counts = defaultdict(float) edge_lengths = defaultdict(float) total = weights.sum() # get clade counts def tipnames_f(n): return [n.name] if n.is_tip() else [] for tree, weight in zip(trees, weights): tree.cache_attr(tipnames_f, 'tip_names', frozenset) for node in tree.postorder(): tip_names = node.tip_names # if node.length is not None, fetch it and weight it length = node.length * weight if node.length is not None else None clade_counts[tip_names] += weight if length is None: edge_lengths[tip_names] = None else: edge_lengths[tip_names] += length / total # sort clades by number times observed clade_counts = sorted(clade_counts.items(), key=lambda x: len(x[0]), reverse=True) return clade_counts, edge_lengths def _filter_clades(clade_counts, cutoff_threshold): """Filter clades that not well supported or are contradicted Parameters ---------- clade_counts : list of tuple Where the first element in each tuple is the frozenset of the clade, and the second element is the support value. It is expected that this list is sorted by descending order by support. cutoff_threshold : float The minimum weighted observation count that a clade must have to be considered supported. Returns ------- dict A dict of the accepted clades, keyed by the frozenset of the clade and valued by the support value. """ accepted_clades = {} for clade, count in clade_counts: conflict = False if count <= cutoff_threshold: continue if len(clade) > 1: # check the current clade against all the accepted clades to see if # it conflicts. A conflict is defined as: # 1. the clades are not disjoint # 2. neither clade is a subset of the other for accepted_clade in accepted_clades: intersect = clade.intersection(accepted_clade) subset = clade.issubset(accepted_clade) superset = clade.issuperset(accepted_clade) if intersect and not (subset or superset): conflict = True if conflict is False: accepted_clades[clade] = count return accepted_clades def _build_trees(clade_counts, edge_lengths, support_attr, tree_node_class): """Construct the trees with support Parameters ---------- clade_counts : dict Keyed by the frozenset of the clade and valued by the support edge_lengths : dict Keyed by the frozenset of the clade and valued by the weighted length support_attr : str The name of the attribute to hold the support value tree_node_class : type Specifies type of consensus trees that are returned. Either ``TreeNode`` or a type that implements the same interface (most usefully, a subclass of ``TreeNode``). Returns ------- list of tree_node_class instances A list of the constructed trees """ nodes = {} queue = [(len(clade), clade) for clade in clade_counts] while queue: # The values within the queue are updated on each iteration, so it # doesn't look like an insertion sort will make sense unfortunately queue.sort() (clade_size, clade) = queue.pop(0) new_queue = [] # search for ancestors of clade for (_, ancestor) in queue: if clade.issubset(ancestor): # update ancestor such that, in the following example: # ancestor == {1, 2, 3, 4} # clade == {2, 3} # new_ancestor == {1, {2, 3}, 4} new_ancestor = (ancestor - clade) | frozenset([clade]) # update references for counts and lengths clade_counts[new_ancestor] = clade_counts.pop(ancestor) edge_lengths[new_ancestor] = edge_lengths.pop(ancestor) ancestor = new_ancestor new_queue.append((len(ancestor), ancestor)) # if the clade is a tip, then we have a name if clade_size == 1: name = list(clade)[0] else: name = None # the clade will not be in nodes if it is a tip children = [nodes.pop(c) for c in clade if c in nodes] length = edge_lengths[clade] node = tree_node_class(children=children, length=length, name=name) setattr(node, support_attr, clade_counts[clade]) nodes[clade] = node queue = new_queue return list(nodes.values()) @experimental(as_of="0.4.0") def majority_rule(trees, weights=None, cutoff=0.5, support_attr='support', tree_node_class=TreeNode): r"""Determines consensus trees from a list of rooted trees Parameters ---------- trees : list of TreeNode The trees to operate on weights : list or np.array of {int, float}, optional If provided, the list must be in index order with `trees`. Each tree will receive the corresponding weight. If omitted, all trees will be equally weighted. cutoff : float, 0.0 <= cutoff <= 1.0, optional Any clade that has <= cutoff support will be dropped. If cutoff is < 0.5, then it is possible that ties will result. If so, ties are broken arbitrarily depending on list sort order. support_attr : str, optional The attribute to be decorated onto the resulting trees that contain the consensus support. tree_node_class : type, optional Specifies type of consensus trees that are returned. Either ``TreeNode`` (the default) or a type that implements the same interface (most usefully, a subclass of ``TreeNode``). Returns ------- list of tree_node_class instances Each tree will be of type `tree_node_class`. Multiple trees can be returned in the case of two or more disjoint sets of tips represented on input. Notes ----- This code was adapted from PyCogent's majority consensus code originally written by Matthew Wakefield. The method is based off the original description of consensus trees in [1]_. An additional description can be found in the Phylip manual [2]_. This method does not support majority rule extended. Support is computed as a weighted average of the tree weights in which the clade was observed in. For instance, if {A, B, C} was observed in 5 trees all with a weight of 1, its support would then be 5. References ---------- .. [1] Margush T, McMorris FR. (1981) "Consensus n-trees." Bulletin for Mathematical Biology 43(2) 239-44. .. [2] http://evolution.genetics.washington.edu/phylip/doc/consense.html Examples -------- Computing the majority consensus, using the example from the Phylip manual with the exception that we are computing majority rule and not majority rule extended. >>> from skbio.tree import TreeNode >>> from io import StringIO >>> trees = [ ... TreeNode.read(StringIO("(A,(B,(H,(D,(J,(((G,E),(F,I)),C))))));")), ... TreeNode.read(StringIO("(A,(B,(D,((J,H),(((G,E),(F,I)),C)))));")), ... TreeNode.read(StringIO("(A,(B,(D,(H,(J,(((G,E),(F,I)),C))))));")), ... TreeNode.read(StringIO("(A,(B,(E,(G,((F,I),((J,(H,D)),C))))));")), ... TreeNode.read(StringIO("(A,(B,(E,(G,((F,I),(((J,H),D),C))))));")), ... TreeNode.read(StringIO("(A,(B,(E,((F,I),(G,((J,(H,D)),C))))));")), ... TreeNode.read(StringIO("(A,(B,(E,((F,I),(G,(((J,H),D),C))))));")), ... TreeNode.read(StringIO("(A,(B,(E,((G,(F,I)),((J,(H,D)),C)))));")), ... TreeNode.read(StringIO("(A,(B,(E,((G,(F,I)),(((J,H),D),C)))));"))] >>> consensus = majority_rule(trees, cutoff=0.5)[0] >>> for node in sorted(consensus.non_tips(), ... key=lambda k: k.count(tips=True)): ... support_value = node.support ... names = ' '.join(sorted(n.name for n in node.tips())) ... print("Tips: %s, support: %s" % (names, support_value)) Tips: F I, support: 9.0 Tips: D H J, support: 6.0 Tips: C D H J, support: 6.0 Tips: C D F G H I J, support: 6.0 Tips: C D E F G H I J, support: 9.0 Tips: B C D E F G H I J, support: 9.0 In the next example, multiple trees will be returned which can happen if clades are not well supported across the trees. In addition, this can arise if not all tips are present across all trees. >>> trees = [ ... TreeNode.read(StringIO("((a,b),(c,d),(e,f));")), ... TreeNode.read(StringIO("(a,(c,d),b,(e,f));")), ... TreeNode.read(StringIO("((c,d),(e,f),b);")), ... TreeNode.read(StringIO("(a,(c,d),(e,f));"))] >>> consensus_trees = majority_rule(trees) >>> len(consensus_trees) 4 """ if weights is None: weights = np.ones(len(trees), dtype=float) else: weights = np.asarray(weights) if len(weights) != len(trees): raise ValueError("Number of weights and trees differ.") cutoff_threshold = cutoff * weights.sum() clade_counts, edge_lengths = _walk_clades(trees, weights) clade_counts = _filter_clades(clade_counts, cutoff_threshold) trees = _build_trees(clade_counts, edge_lengths, support_attr, tree_node_class) return trees scikit-bio-0.5.9/skbio/tree/_nj.py000066400000000000000000000251111446255456000167630ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import numpy as np from skbio.stats.distance import DistanceMatrix from skbio.tree import TreeNode from skbio.util._decorator import experimental @experimental(as_of="0.4.0") def nj(dm, disallow_negative_branch_length=True, result_constructor=None): r""" Apply neighbor joining for phylogenetic reconstruction. Parameters ---------- dm : skbio.DistanceMatrix Input distance matrix containing distances between OTUs. disallow_negative_branch_length : bool, optional Neighbor joining can result in negative branch lengths, which don't make sense in an evolutionary context. If `True`, negative branch lengths will be returned as zero, a common strategy for handling this issue that was proposed by the original developers of the algorithm. result_constructor : function, optional Function to apply to construct the result object. This must take a newick-formatted string as input. The result of applying this function to a newick-formatted string will be returned from this function. This defaults to ``lambda x: TreeNode.read(StringIO(x), format='newick')``. Returns ------- TreeNode By default, the result object is a `TreeNode`, though this can be overridden by passing `result_constructor`. See Also -------- TreeNode.root_at_midpoint Notes ----- Neighbor joining was initially described in Saitou and Nei (1987) [1]_. The example presented here is derived from the Wikipedia page on neighbor joining [2]_. The Phylip manual also describes the method [3]_ and Phylip itself provides an implementation which is useful for comparison. Neighbor joining, by definition, creates unrooted trees. One strategy for rooting the resulting trees is midpoint rooting, which is accessible as ``TreeNode.root_at_midpoint``. References ---------- .. [1] Saitou N, and Nei M. (1987) "The neighbor-joining method: a new method for reconstructing phylogenetic trees." Molecular Biology and Evolution. PMID: 3447015. .. [2] http://en.wikipedia.org/wiki/Neighbour_joining .. [3] http://evolution.genetics.washington.edu/phylip/doc/neighbor.html Examples -------- Define a new distance matrix object describing the distances between five OTUs: a, b, c, d, and e. >>> from skbio import DistanceMatrix >>> from skbio.tree import nj >>> data = [[0, 5, 9, 9, 8], ... [5, 0, 10, 10, 9], ... [9, 10, 0, 8, 7], ... [9, 10, 8, 0, 3], ... [8, 9, 7, 3, 0]] >>> ids = list('abcde') >>> dm = DistanceMatrix(data, ids) Contstruct the neighbor joining tree representing the relationship between those OTUs. This is returned as a TreeNode object. >>> tree = nj(dm) >>> print(tree.ascii_art()) /-d | | /-c |---------| ---------| | /-b | \--------| | \-a | \-e Again, construct the neighbor joining tree, but instead return the newick string representing the tree, rather than the TreeNode object. (Note that in this example the string output is truncated when printed to facilitate rendering.) >>> newick_str = nj(dm, result_constructor=str) >>> print(newick_str[:55], "...") (d:2.000000, (c:4.000000, (b:3.000000, a:2.000000):3.00 ... """ if dm.shape[0] < 3: raise ValueError( "Distance matrix must be at least 3x3 to " "generate a neighbor joining tree.") if result_constructor is None: def result_constructor(x): return TreeNode.read(io.StringIO(x), format='newick') # initialize variables node_definition = None # while there are still more than three distances in the distance matrix, # join neighboring nodes. while (dm.shape[0] > 3): # compute the Q matrix q = _compute_q(dm) # identify the pair of nodes that have the lowest Q value. if multiple # pairs have equally low Q values, the first pair identified (closest # to the top-left of the matrix) will be chosen. these will be joined # in the current node. idx1, idx2 = _lowest_index(q) pair_member_1 = dm.ids[idx1] pair_member_2 = dm.ids[idx2] # determine the distance of each node to the new node connecting them. pair_member_1_len, pair_member_2_len = _pair_members_to_new_node( dm, idx1, idx2, disallow_negative_branch_length) # define the new node in newick style node_definition = "(%s:%f, %s:%f)" % (pair_member_1, pair_member_1_len, pair_member_2, pair_member_2_len) # compute the new distance matrix, which will contain distances of all # other nodes to this new node dm = _compute_collapsed_dm( dm, pair_member_1, pair_member_2, disallow_negative_branch_length=disallow_negative_branch_length, new_node_id=node_definition) # When there are three distances left in the distance matrix, we have a # fully defined tree. The last node is internal, and its distances are # defined by these last three values. # First determine the distance between the last two nodes to be joined in # a pair... pair_member_1 = dm.ids[1] pair_member_2 = dm.ids[2] pair_member_1_len, pair_member_2_len = \ _pair_members_to_new_node(dm, pair_member_1, pair_member_2, disallow_negative_branch_length) # ...then determine their distance to the other remaining node, but first # handle the trival case where the input dm was only 3 x 3 node_definition = node_definition or dm.ids[0] internal_len = 0.5 * (dm[pair_member_1, node_definition] + dm[pair_member_2, node_definition] - dm[pair_member_1, pair_member_2]) if disallow_negative_branch_length and internal_len < 0: internal_len = 0 # ...and finally create the newick string describing the whole tree. newick = "(%s:%f, %s:%f, %s:%f);" % (pair_member_1, pair_member_1_len, node_definition, internal_len, pair_member_2, pair_member_2_len) # package the result as requested by the user and return it. return result_constructor(newick) def _compute_q(dm): """Compute Q matrix, used to identify the next pair of nodes to join. """ q = np.zeros(dm.shape) n = dm.shape[0] big_sum = np.array([dm.data.sum(1)] * dm.shape[0]) big_sum_diffs = big_sum + big_sum.T q = (n - 2) * dm.data - big_sum_diffs np.fill_diagonal(q, 0) return DistanceMatrix(q, dm.ids) def _compute_collapsed_dm(dm, i, j, disallow_negative_branch_length, new_node_id): """Return the distance matrix resulting from joining ids i and j in a node. If the input distance matrix has shape ``(n, n)``, the result will have shape ``(n-1, n-1)`` as the ids `i` and `j` are collapsed to a single new ids. """ in_n = dm.shape[0] out_n = in_n - 1 out_ids = [new_node_id] out_ids.extend([e for e in dm.ids if e not in (i, j)]) result = np.zeros((out_n, out_n)) # pre-populate the result array with known distances ij_indexes = [dm.index(i), dm.index(j)] result[1:, 1:] = np.delete(np.delete(dm.data, ij_indexes, axis=0), ij_indexes, axis=1) # calculate the new distances from the current DistanceMatrix k_to_u = 0.5 * (dm[i] + dm[j] - dm[i, j]) # set negative branches to 0 if specified if disallow_negative_branch_length: k_to_u[k_to_u < 0] = 0 # drop nodes being joined k_to_u = np.delete(k_to_u, ij_indexes) # assign the distances to the result array result[0] = result[:, 0] = np.concatenate([[0], k_to_u]) return DistanceMatrix(result, out_ids) def _lowest_index(dm): """Return the index of the lowest value in the input distance matrix. If there are ties for the lowest value, the index of top-left most occurrence of that value will be returned. This should be ultimately be replaced with a new DistanceMatrix object method (#228). """ # get the positions of the lowest value results = np.vstack(np.where(dm.data == np.amin(dm.condensed_form()))).T # select results in the bottom-left of the array results = results[results[:, 0] > results[:, 1]] # calculate the distances of the results to [0, 0] res_distances = np.sqrt(results[:, 0]**2 + results[:, 1]**2) # detect distance ties & return the point which would have # been produced by the original function if np.count_nonzero(res_distances == np.amin(res_distances)) > 1: eqdistres = results[res_distances == np.amin(res_distances)] res_coords = eqdistres[np.argmin([r[0] for r in eqdistres])] else: res_coords = results[np.argmin(res_distances)] return tuple([res_coords[0], res_coords[1]]) def _pair_members_to_new_node(dm, i, j, disallow_negative_branch_length): """Return the distance between a new node and decendants of that new node. Parameters ---------- dm : skbio.DistanceMatrix The input distance matrix. i, j : str Identifiers of entries in the distance matrix to be collapsed (i.e., the descendents of the new node, which is internally represented as `u`). disallow_negative_branch_length : bool Neighbor joining can result in negative branch lengths, which don't make sense in an evolutionary context. If `True`, negative branch lengths will be returned as zero, a common strategy for handling this issue that was proposed by the original developers of the algorithm. """ n = dm.shape[0] i_to_j = dm[i, j] i_to_u = (0.5 * i_to_j) + ((dm[i].sum() - dm[j].sum()) / (2 * (n - 2))) if disallow_negative_branch_length and i_to_u < 0: i_to_u = 0 j_to_u = i_to_j - i_to_u if disallow_negative_branch_length and j_to_u < 0: j_to_u = 0 return i_to_u, j_to_u scikit-bio-0.5.9/skbio/tree/_tree.py000066400000000000000000003123721446255456000173230ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import warnings from operator import or_, itemgetter from copy import deepcopy from itertools import combinations from functools import reduce from collections import defaultdict import numpy as np import pandas as pd from scipy.spatial.distance import correlation from skbio._base import SkbioObject from skbio.stats.distance import DistanceMatrix from ._exception import (NoLengthError, DuplicateNodeError, NoParentError, MissingNodeError, TreeError) from skbio.util import RepresentationWarning from skbio.util._decorator import experimental, classonlymethod def distance_from_r(m1, m2): r"""Estimates distance as (1-r)/2: neg correl = max distance Parameters ---------- m1 : DistanceMatrix a distance matrix to compare m2 : DistanceMatrix a distance matrix to compare Returns ------- float The distance between m1 and m2 """ return correlation(m1.data.flat, m2.data.flat) / 2 class TreeNode(SkbioObject): r"""Representation of a node within a tree A `TreeNode` instance stores links to its parent and optional children nodes. In addition, the `TreeNode` can represent a `length` (e.g., a branch length) between itself and its parent. Within this object, the use of "children" and "descendants" is frequent in the documentation. A child is a direct descendant of a node, while descendants are all nodes that are below a given node (e.g., grand-children, etc). Parameters ---------- name : str or None A node can have a name. It is common for tips in particular to have names, for instance, in a phylogenetic tree where the tips correspond to species. length : float, int, or None Length of the branch connecting this node to its parent. Can represent ellapsed time, amount of mutations, or other measures of evolutionary distance. support : float, int, or None Support value of the branch connecting this node to its parent. Can be bootstrap value, posterior probability, or other metrics measuring the confidence or frequency of this branch. parent : TreeNode or None Connect this node to a parent children : list of TreeNode or None Connect this node to existing children """ default_write_format = 'newick' _exclude_from_copy = set(['parent', 'children', '_tip_cache', '_non_tip_cache']) @experimental(as_of="0.4.0") def __init__(self, name=None, length=None, support=None, parent=None, children=None): self.name = name self.length = length self.support = support self.parent = parent self._tip_cache = {} self._non_tip_cache = {} self._registered_caches = set() self.children = [] self.id = None if children is not None: self.extend(children) @experimental(as_of="0.4.0") def __repr__(self): r"""Returns summary of the tree Returns ------- str A summary of this node and all descendants Notes ----- This method returns the name of the node and a count of tips and the number of internal nodes in the tree Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c, d)root;"]) >>> repr(tree) '' """ nodes = [n for n in self.traverse(include_self=False)] n_tips = sum([n.is_tip() for n in nodes]) n_nontips = len(nodes) - n_tips classname = self.__class__.__name__ name = self.name if self.name is not None else "unnamed" return "<%s, name: %s, internal node count: %d, tips count: %d>" % \ (classname, name, n_nontips, n_tips) @experimental(as_of="0.4.0") def __str__(self): r"""Returns string version of self, with names and distances Returns ------- str Returns a Newick representation of the tree See Also -------- read write Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> str(tree) '((a,b)c);\n' """ return str(''.join(self.write([]))) @experimental(as_of="0.4.0") def __iter__(self): r"""Node iter iterates over the `children`.""" return iter(self.children) @experimental(as_of="0.4.0") def __len__(self): return len(self.children) @experimental(as_of="0.4.0") def __getitem__(self, i): r"""Node delegates slicing to `children`.""" return self.children[i] @experimental(as_of="0.4.0") def _adopt(self, node): r"""Update `parent` references but does NOT update `children`.""" self.invalidate_caches() if node.parent is not None: node.parent.remove(node) node.parent = self return node @experimental(as_of="0.4.0") def append(self, node): r"""Appends a node to `children`, in-place, cleaning up refs `append` will invalidate any node lookup caches, remove an existing parent on `node` if one exists, set the parent of `node` to self and add the `node` to `self` `children`. Parameters ---------- node : TreeNode An existing TreeNode object See Also -------- extend Examples -------- >>> from skbio import TreeNode >>> root = TreeNode(name="root") >>> child1 = TreeNode(name="child1") >>> child2 = TreeNode(name="child2") >>> root.append(child1) >>> root.append(child2) >>> print(root) (child1,child2)root; """ self.children.append(self._adopt(node)) @experimental(as_of="0.4.0") def extend(self, nodes): r"""Append a `list` of `TreeNode` to `self`. `extend` will invalidate any node lookup caches, remove existing parents of the `nodes` if they have any, set their parents to self and add the nodes to `self` `children`. Parameters ---------- nodes : list of TreeNode A list of TreeNode objects See Also -------- append Examples -------- >>> from skbio import TreeNode >>> root = TreeNode(name="root") >>> root.extend([TreeNode(name="child1"), TreeNode(name="child2")]) >>> print(root) (child1,child2)root; """ self.children.extend([self._adopt(n) for n in nodes[:]]) @experimental(as_of="0.4.0") def pop(self, index=-1): r"""Remove a `TreeNode` from `self`. Remove a child node by its index position. All node lookup caches are invalidated, and the parent reference for the popped node will be set to `None`. Parameters ---------- index : int The index position in `children` to pop Returns ------- TreeNode The popped child See Also -------- remove remove_deleted Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(a,b)c;"]) >>> print(tree.pop(0)) a; """ return self._remove_node(index) def _remove_node(self, idx): r"""The actual (and only) method that performs node removal""" self.invalidate_caches() node = self.children.pop(idx) node.parent = None return node @experimental(as_of="0.4.0") def remove(self, node): r"""Remove a node from self Remove a `node` from `self` by identity of the node. Parameters ---------- node : TreeNode The node to remove from self's children Returns ------- bool `True` if the node was removed, `False` otherwise See Also -------- pop remove_deleted Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(a,b)c;"]) >>> tree.remove(tree.children[0]) True """ for (i, curr_node) in enumerate(self.children): if curr_node is node: self._remove_node(i) return True return False @experimental(as_of="0.4.0") def remove_deleted(self, func): r"""Delete nodes in which `func(node)` evaluates `True`. Remove all descendants from `self` that evaluate `True` from `func`. This has the potential to drop clades. Parameters ---------- func : a function A function that evaluates `True` when a node should be deleted See Also -------- pop remove Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(a,b)c;"]) >>> tree.remove_deleted(lambda x: x.name == 'b') >>> print(tree) (a)c; """ for node in self.traverse(include_self=False): if func(node): node.parent.remove(node) @experimental(as_of="0.4.0") def prune(self): r"""Reconstructs correct topology after nodes have been removed. Internal nodes with only one child will be removed and new connections will be made to reflect change. This method is useful to call following node removals as it will clean up nodes with singular children. Names and properties of singular children will override the names and properties of their parents following the prune. Node lookup caches are invalidated. See Also -------- shear remove pop remove_deleted Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> to_delete = tree.find('b') >>> tree.remove_deleted(lambda x: x == to_delete) >>> print(tree) ((a)c,(d,e)f)root; >>> tree.prune() >>> print(tree) ((d,e)f,a)root; """ # build up the list of nodes to remove so the topology is not altered # while traversing nodes_to_remove = [] for node in self.traverse(include_self=False): if len(node.children) == 1: nodes_to_remove.append(node) # clean up the single children nodes for node in nodes_to_remove: child = node.children[0] if child.length is None or node.length is None: child.length = child.length or node.length else: child.length += node.length if node.parent is None: continue node.parent.append(child) node.parent.remove(node) # if a single descendent from the root, the root adopts the childs # properties. we can't "delete" the root as that would be deleting # self. if len(self.children) == 1: node_to_copy = self.children[0] efc = self._exclude_from_copy for key in node_to_copy.__dict__: if key not in efc: self.__dict__[key] = deepcopy(node_to_copy.__dict__[key]) self.remove(node_to_copy) self.extend(node_to_copy.children) @experimental(as_of="0.4.0") def shear(self, names): """Lop off tips until the tree just has the desired tip names. Parameters ---------- names : Iterable of str The tip names on the tree to keep Returns ------- TreeNode The resulting tree Raises ------ ValueError If the names do not exist in the tree See Also -------- prune remove pop remove_deleted Examples -------- >>> from skbio import TreeNode >>> t = TreeNode.read(['((H:1,G:1):2,(R:0.5,M:0.7):3);']) >>> sheared = t.shear(['G', 'M']) >>> print(sheared) (G:3.0,M:3.7); """ tcopy = self.deepcopy() all_tips = {n.name for n in tcopy.tips()} ids = set(names) if not ids.issubset(all_tips): raise ValueError("ids are not a subset of the tree.") marked = set() for tip in tcopy.tips(): if tip.name in ids: marked.add(tip) for anc in tip.ancestors(): if anc in marked: break else: marked.add(anc) for node in list(tcopy.traverse()): if node not in marked: node.parent.remove(node) tcopy.prune() return tcopy @experimental(as_of="0.4.0") def copy(self): r"""Returns a copy of self using an iterative approach Perform an iterative deepcopy of self. It is not assured that the copy of node attributes will be performed iteratively as that depends on the copy method of the types being copied Returns ------- TreeNode A new copy of self See Also -------- unrooted_deepcopy unrooted_copy Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> tree_copy = tree.copy() >>> tree_nodes = set([id(n) for n in tree.traverse()]) >>> tree_copy_nodes = set([id(n) for n in tree_copy.traverse()]) >>> print(len(tree_nodes.intersection(tree_copy_nodes))) 0 """ def __copy_node(node_to_copy): r"""Helper method to copy a node""" # this is _possibly_ dangerous, we're assuming the node to copy is # of the same class as self, and has the same exclusion criteria. # however, it is potentially dangerous to mix TreeNode subclasses # within a tree, so... result = self.__class__() efc = self._exclude_from_copy for key in node_to_copy.__dict__: if key not in efc: result.__dict__[key] = deepcopy(node_to_copy.__dict__[key]) return result root = __copy_node(self) nodes_stack = [[root, self, len(self.children)]] while nodes_stack: # check the top node, any children left unvisited? top = nodes_stack[-1] new_top_node, old_top_node, unvisited_children = top if unvisited_children: top[2] -= 1 old_child = old_top_node.children[-unvisited_children] new_child = __copy_node(old_child) new_top_node.append(new_child) nodes_stack.append([new_child, old_child, len(old_child.children)]) else: # no unvisited children nodes_stack.pop() return root __copy__ = copy __deepcopy__ = deepcopy = copy @experimental(as_of="0.4.0") def unrooted_deepcopy(self, parent=None): r"""Walks the tree unrooted-style and returns a new copy Perform a deepcopy of self and return a new copy of the tree as an unrooted copy. This is useful for defining new roots of the tree as the `TreeNode`. This method calls `TreeNode.unrooted_copy` which is recursive. Parameters ---------- parent : TreeNode or None Used to avoid infinite loops when performing the unrooted traverse Returns ------- TreeNode A new copy of the tree See Also -------- copy unrooted_copy root_at Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,(b,c)d)e,(f,g)h)i;"]) >>> new_tree = tree.find('d').unrooted_deepcopy() >>> print(new_tree) (b,c,(a,((f,g)h)e)d)root; """ root = self.root() root.assign_ids() new_tree = root.copy() new_tree.assign_ids() new_tree_self = new_tree.find_by_id(self.id) return new_tree_self.unrooted_copy(parent) @experimental(as_of="0.4.0") def unrooted_copy(self, parent=None): r"""Walks the tree unrooted-style and returns a copy Perform a copy of self and return a new copy of the tree as an unrooted copy. This is useful for defining new roots of the tree as the `TreeNode`. This method is recursive. Warning, this is _NOT_ a deepcopy Parameters ---------- parent : TreeNode or None Used to avoid infinite loops when performing the unrooted traverse Returns ------- TreeNode A new copy of the tree See Also -------- copy unrooted_deepcopy root_at Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,(b,c)d)e,(f,g)h)i;"]) >>> new_tree = tree.find('d').unrooted_copy() >>> print(new_tree) (b,c,(a,((f,g)h)e)d)root; """ neighbors = self.neighbors(ignore=parent) children = [c.unrooted_copy(parent=self) for c in neighbors] # we might be walking UP the tree, so: if parent is None: # base edge edgename = None length = None elif parent.parent is self: # self's parent is becoming self's child edgename = parent.name length = parent.length else: assert parent is self.parent edgename = self.name length = self.length result = self.__class__(name=edgename, children=children, length=length) if parent is None: result.name = "root" return result @experimental(as_of="0.4.0") def count(self, tips=False): """Get the count of nodes in the tree Parameters ---------- tips : bool If `True`, only return the count of the number of tips Returns ------- int The number of nodes or tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,(b,c)d)e,(f,g)h)i;"]) >>> print(tree.count()) 9 >>> print(tree.count(tips=True)) 5 """ if tips: return len(list(self.tips())) else: return len(list(self.traverse(include_self=True))) @experimental(as_of="0.4.1") def observed_node_counts(self, tip_counts): """Returns counts of node observations from counts of tip observations Parameters ---------- tip_counts : dict of ints Counts of observations of tips. Keys correspond to tip names in ``self``, and counts are unsigned ints. Returns ------- dict Counts of observations of nodes. Keys correspond to node names (internal nodes or tips), and counts are unsigned ints. Raises ------ ValueError If a count less than one is observed. MissingNodeError If a count is provided for a tip not in the tree, or for an internal node. """ result = defaultdict(int) for tip_name, count in tip_counts.items(): if count < 1: raise ValueError("All tip counts must be greater than zero.") else: t = self.find(tip_name) if not t.is_tip(): raise MissingNodeError( "Counts can only be for tips in the tree. %s is an " "internal node." % t.name) result[t] += count for internal_node in t.ancestors(): result[internal_node] += count return result @experimental(as_of="0.4.0") def subtree(self, tip_list=None): r"""Make a copy of the subtree""" raise NotImplementedError() @experimental(as_of="0.4.0") def subset(self): r"""Returns set of names that descend from specified node Get the set of `name` on tips that descend from this node. Returns ------- frozenset The set of names at the tips of the clade that descends from self See Also -------- subsets compare_subsets Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,(b,c)d)e,(f,g)h)i;"]) >>> sorted(tree.subset()) ['a', 'b', 'c', 'f', 'g'] """ return frozenset({i.name for i in self.tips()}) @experimental(as_of="0.4.0") def subsets(self): r"""Return all sets of names that come from self and its descendants Compute all subsets of tip names over `self`, or, represent a tree as a set of nested sets. Returns ------- frozenset A frozenset of frozensets of str See Also -------- subset compare_subsets Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(((a,b)c,(d,e)f)h)root;"]) >>> subsets = tree.subsets() >>> len(subsets) 3 """ sets = [] for i in self.postorder(include_self=False): if not i.children: i.__leaf_set = frozenset([i.name]) else: leaf_set = reduce(or_, [c.__leaf_set for c in i.children]) if len(leaf_set) > 1: sets.append(leaf_set) i.__leaf_set = leaf_set return frozenset(sets) @experimental(as_of="0.4.0") def root_at(self, node): r"""Return a new tree rooted at the provided node. This can be useful for drawing unrooted trees with an orientation that reflects knowledge of the true root location. Parameters ---------- node : TreeNode or str The node to root at Returns ------- TreeNode A new copy of the tree Raises ------ TreeError Raises a `TreeError` if a tip is specified as the new root See Also -------- root_at_midpoint unrooted_deepcopy Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(((a,b)c,(d,e)f)g,h)i;"]) >>> print(tree.root_at('c')) (a,b,((d,e)f,(h)g)c)root; """ if isinstance(node, str): node = self.find(node) if not node.children: raise TreeError("Can't use a tip (%s) as the root" % repr(node.name)) return node.unrooted_deepcopy() @experimental(as_of="0.4.0") def root_at_midpoint(self): r"""Return a new tree rooted at midpoint of the two tips farthest apart This method doesn't preserve the internal node naming or structure, but does keep tip to tip distances correct. Uses `unrooted_copy` but operates on a full copy of the tree. Raises ------ TreeError If a tip ends up being the mid point Returns ------- TreeNode A tree rooted at its midpoint LengthError Midpoint rooting requires `length` and will raise (indirectly) if evaluated nodes don't have length. See Also -------- root_at unrooted_deepcopy Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["(((d:1,e:1,(g:1)f:1)c:1)b:1,h:1)a:1;"]) >>> print(tree.root_at_midpoint()) ((d:1.0,e:1.0,(g:1.0)f:1.0)c:0.5,((h:1.0)b:1.0):0.5)root; """ tree = self.copy() max_dist, tips = tree.get_max_distance() half_max_dist = max_dist / 2.0 if max_dist == 0.0: # only pathological cases with no lengths return tree tip1 = tree.find(tips[0]) tip2 = tree.find(tips[1]) lca = tree.lowest_common_ancestor([tip1, tip2]) if tip1.accumulate_to_ancestor(lca) > half_max_dist: climb_node = tip1 else: climb_node = tip2 dist_climbed = 0.0 while dist_climbed + climb_node.length < half_max_dist: dist_climbed += climb_node.length climb_node = climb_node.parent # now midpt is either at on the branch to climb_node's parent # or midpt is at climb_node's parent if dist_climbed + climb_node.length == half_max_dist: # climb to midpoint spot climb_node = climb_node.parent if climb_node.is_tip(): raise TreeError('error trying to root tree at tip') else: return climb_node.unrooted_copy() else: # make a new node on climb_node's branch to its parent old_br_len = climb_node.length new_root = tree.__class__() climb_node.parent.append(new_root) new_root.append(climb_node) climb_node.length = half_max_dist - dist_climbed new_root.length = old_br_len - climb_node.length return new_root.unrooted_copy() @experimental(as_of="0.4.0") def is_tip(self): r"""Returns `True` if the current node has no `children`. Returns ------- bool `True` if the node is a tip See Also -------- is_root has_children Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> print(tree.is_tip()) False >>> print(tree.find('a').is_tip()) True """ return not self.children @experimental(as_of="0.4.0") def is_root(self): r"""Returns `True` if the current is a root, i.e. has no `parent`. Returns ------- bool `True` if the node is the root See Also -------- is_tip has_children Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> print(tree.is_root()) True >>> print(tree.find('a').is_root()) False """ return self.parent is None @experimental(as_of="0.4.0") def has_children(self): r"""Returns `True` if the node has `children`. Returns ------- bool `True` if the node has children. See Also -------- is_tip is_root Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> print(tree.has_children()) True >>> print(tree.find('a').has_children()) False """ return not self.is_tip() @experimental(as_of="0.4.0") def traverse(self, self_before=True, self_after=False, include_self=True): r"""Returns iterator over descendants This is a depth-first traversal. Since the trees are not binary, preorder and postorder traversals are possible, but inorder traversals would depend on the data in the tree and are not handled here. Parameters ---------- self_before : bool includes each node before its descendants if True self_after : bool includes each node after its descendants if True include_self : bool include the initial node if True `self_before` and `self_after` are independent. If neither is `True`, only terminal nodes will be returned. Note that if self is terminal, it will only be included once even if `self_before` and `self_after` are both `True`. Yields ------ TreeNode Traversed node. See Also -------- preorder postorder pre_and_postorder levelorder tips non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> for node in tree.traverse(): ... print(node.name) None c a b """ if self_before: if self_after: return self.pre_and_postorder(include_self=include_self) else: return self.preorder(include_self=include_self) else: if self_after: return self.postorder(include_self=include_self) else: return self.tips(include_self=include_self) @experimental(as_of="0.4.0") def preorder(self, include_self=True): r"""Performs preorder iteration over tree Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse postorder pre_and_postorder levelorder tips non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> for node in tree.preorder(): ... print(node.name) None c a b """ stack = [self] while stack: curr = stack.pop() if include_self or (curr is not self): yield curr if curr.children: stack.extend(curr.children[::-1]) @experimental(as_of="0.4.0") def postorder(self, include_self=True): r"""Performs postorder iteration over tree. This is somewhat inelegant compared to saving the node and its index on the stack, but is 30% faster in the average case and 3x faster in the worst case (for a comb tree). Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse preorder pre_and_postorder levelorder tips non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> for node in tree.postorder(): ... print(node.name) a b c None """ child_index_stack = [0] curr = self curr_children = self.children curr_children_len = len(curr_children) while 1: curr_index = child_index_stack[-1] # if there are children left, process them if curr_index < curr_children_len: curr_child = curr_children[curr_index] # if the current child has children, go there if curr_child.children: child_index_stack.append(0) curr = curr_child curr_children = curr.children curr_children_len = len(curr_children) curr_index = 0 # otherwise, yield that child else: yield curr_child child_index_stack[-1] += 1 # if there are no children left, return self, and move to # self's parent else: if include_self or (curr is not self): yield curr if curr is self: break curr = curr.parent curr_children = curr.children curr_children_len = len(curr_children) child_index_stack.pop() child_index_stack[-1] += 1 @experimental(as_of="0.4.0") def pre_and_postorder(self, include_self=True): r"""Performs iteration over tree, visiting node before and after Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse postorder preorder levelorder tips non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c);"]) >>> for node in tree.pre_and_postorder(): ... print(node.name) None c a b c None """ # handle simple case first if not self.children: if include_self: yield self return child_index_stack = [0] curr = self curr_children = self.children while 1: curr_index = child_index_stack[-1] if not curr_index: if include_self or (curr is not self): yield curr # if there are children left, process them if curr_index < len(curr_children): curr_child = curr_children[curr_index] # if the current child has children, go there if curr_child.children: child_index_stack.append(0) curr = curr_child curr_children = curr.children curr_index = 0 # otherwise, yield that child else: yield curr_child child_index_stack[-1] += 1 # if there are no children left, return self, and move to # self's parent else: if include_self or (curr is not self): yield curr if curr is self: break curr = curr.parent curr_children = curr.children child_index_stack.pop() child_index_stack[-1] += 1 @experimental(as_of="0.4.0") def levelorder(self, include_self=True): r"""Performs levelorder iteration over tree Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse postorder preorder pre_and_postorder tips non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> for node in tree.levelorder(): ... print(node.name) None c f a b d e """ queue = [self] while queue: curr = queue.pop(0) if include_self or (curr is not self): yield curr if curr.children: queue.extend(curr.children) @experimental(as_of="0.4.0") def tips(self, include_self=False): r"""Iterates over tips descended from `self`. Node order is consistent between calls and is ordered by a postorder traversal of the tree. Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse postorder preorder pre_and_postorder levelorder non_tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> for node in tree.tips(): ... print(node.name) a b d e """ for n in self.postorder(include_self=include_self): if n.is_tip(): yield n @experimental(as_of="0.4.0") def non_tips(self, include_self=False): r"""Iterates over nontips descended from self `include_self`, if `True` (default is False), will return the current node as part of non_tips if it is a non_tip. Node order is consistent between calls and is ordered by a postorder traversal of the tree. Parameters ---------- include_self : bool include the initial node if True Yields ------ TreeNode Traversed node. See Also -------- traverse postorder preorder pre_and_postorder levelorder tips Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> for node in tree.non_tips(): ... print(node.name) c f """ for n in self.postorder(include_self): if not n.is_tip(): yield n @experimental(as_of="0.4.0") def invalidate_caches(self, attr=True): r"""Delete lookup and attribute caches Parameters ---------- attr : bool, optional If ``True``, invalidate attribute caches created by `TreeNode.cache_attr`. See Also -------- create_caches cache_attr find """ if not self.is_root(): self.root().invalidate_caches() else: self._tip_cache = {} self._non_tip_cache = {} if self._registered_caches and attr: for n in self.traverse(): for cache in self._registered_caches: if hasattr(n, cache): delattr(n, cache) @experimental(as_of="0.4.0") def create_caches(self): r"""Construct an internal lookups to facilitate searching by name This method will not cache nodes in which the .name is None. This method will raise `DuplicateNodeError` if a name conflict in the tips is discovered, but will not raise if on internal nodes. This is because, in practice, the tips of a tree are required to be unique while no such requirement holds for internal nodes. Raises ------ DuplicateNodeError The tip cache requires that names are unique (with the exception of names that are None) See Also -------- invalidate_caches cache_attr find """ if not self.is_root(): self.root().create_caches() else: if self._tip_cache and self._non_tip_cache: return self.invalidate_caches(attr=False) tip_cache = {} non_tip_cache = defaultdict(list) for node in self.postorder(): name = node.name if name is None: continue if node.is_tip(): if name in tip_cache: raise DuplicateNodeError("Tip with name '%s' already " "exists." % name) tip_cache[name] = node else: non_tip_cache[name].append(node) self._tip_cache = tip_cache self._non_tip_cache = non_tip_cache @experimental(as_of="0.4.0") def find_all(self, name): r"""Find all nodes that match `name` The first call to `find_all` will cache all nodes in the tree on the assumption that additional calls to `find_all` will be made. Parameters ---------- name : TreeNode or str The name or node to find. If `name` is `TreeNode` then all other nodes with the same name will be returned. Raises ------ MissingNodeError Raises if the node to be searched for is not found Returns ------- list of TreeNode The nodes found See Also -------- find find_by_id find_by_func Examples -------- >>> from skbio.tree import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)d,(f,g)c);"]) >>> for node in tree.find_all('c'): ... print(node.name, node.children[0].name, node.children[1].name) c a b c f g >>> for node in tree.find_all('d'): ... print(node.name, str(node)) d (d,e)d; d d; """ root = self.root() # if what is being passed in looks like a node, just return it if isinstance(name, root.__class__): return [name] root.create_caches() tip = root._tip_cache.get(name, None) nodes = root._non_tip_cache.get(name, []) nodes.append(tip) if tip is not None else None if not nodes: raise MissingNodeError("Node %s is not in self" % name) else: return nodes @experimental(as_of="0.4.0") def find(self, name): r"""Find a node by `name`. The first call to `find` will cache all nodes in the tree on the assumption that additional calls to `find` will be made. `find` will first attempt to find the node in the tips. If it cannot find a corresponding tip, then it will search through the internal nodes of the tree. In practice, phylogenetic trees and other common trees in biology do not have unique internal node names. As a result, this find method will only return the first occurance of an internal node encountered on a postorder traversal of the tree. Parameters ---------- name : TreeNode or str The name or node to find. If `name` is `TreeNode` then it is simply returned Raises ------ MissingNodeError Raises if the node to be searched for is not found Returns ------- TreeNode The found node See Also -------- find_all find_by_id find_by_func Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> print(tree.find('c').name) c """ root = self.root() # if what is being passed in looks like a node, just return it if isinstance(name, root.__class__): return name root.create_caches() node = root._tip_cache.get(name, None) if node is None: node = root._non_tip_cache.get(name, [None])[0] if node is None: raise MissingNodeError("Node %s is not in self" % name) else: return node @experimental(as_of="0.4.0") def find_by_id(self, node_id): r"""Find a node by `id`. This search method is based from the root. Parameters ---------- node_id : int The `id` of a node in the tree Returns ------- TreeNode The tree node with the matching id Notes ----- This method does not cache id associations. A full traversal of the tree is performed to find a node by an id on every call. Raises ------ MissingNodeError This method will raise if the `id` cannot be found See Also -------- find find_all find_by_func Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> print(tree.find_by_id(2).name) d """ # if this method gets used frequently, then we should cache by ID # as well root = self.root() root.assign_ids() node = None for n in self.traverse(include_self=True): if n.id == node_id: node = n break if node is None: raise MissingNodeError("ID %d is not in self" % node_id) else: return node @experimental(as_of="0.4.0") def find_by_func(self, func): r"""Find all nodes given a function This search method is based on the current subtree, not the root. Parameters ---------- func : a function A function that accepts a TreeNode and returns `True` or `False`, where `True` indicates the node is to be yielded Yields ------ TreeNode Node found by `func`. See Also -------- find find_all find_by_id Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f);"]) >>> func = lambda x: x.parent == tree.find('c') >>> [n.name for n in tree.find_by_func(func)] ['a', 'b'] """ for node in self.traverse(include_self=True): if func(node): yield node @experimental(as_of="0.4.0") def ancestors(self): r"""Returns all ancestors back to the root This call will return all nodes in the path back to root, but does not include the node instance that the call was made from. Returns ------- list of TreeNode The path, toward the root, from self Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> [node.name for node in tree.find('a').ancestors()] ['c', 'root'] """ result = [] curr = self while not curr.is_root(): result.append(curr.parent) curr = curr.parent return result @experimental(as_of="0.4.0") def root(self): r"""Returns root of the tree `self` is in Returns ------- TreeNode The root of the tree Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> tip_a = tree.find('a') >>> root = tip_a.root() >>> root == tree True """ curr = self while not curr.is_root(): curr = curr.parent return curr @experimental(as_of="0.4.0") def siblings(self): r"""Returns all nodes that are `children` of `self` `parent`. This call excludes `self` from the list. Returns ------- list of TreeNode The list of sibling nodes relative to self See Also -------- neighbors Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e,f)g)root;"]) >>> tip_e = tree.find('e') >>> [n.name for n in tip_e.siblings()] ['d', 'f'] """ if self.is_root(): return [] result = self.parent.children[:] result.remove(self) return result @experimental(as_of="0.4.0") def neighbors(self, ignore=None): r"""Returns all nodes that are connected to self This call does not include `self` in the result Parameters ---------- ignore : TreeNode A node to ignore Returns ------- list of TreeNode The list of all nodes that are connected to self Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> node_c = tree.find('c') >>> [n.name for n in node_c.neighbors()] ['a', 'b', 'root'] """ nodes = [n for n in self.children + [self.parent] if n is not None] if ignore is None: return nodes else: return [n for n in nodes if n is not ignore] @experimental(as_of="0.4.0") def lowest_common_ancestor(self, tipnames): r"""Lowest common ancestor for a list of tips Parameters ---------- tipnames : list of TreeNode or str The nodes of interest Returns ------- TreeNode The lowest common ancestor of the passed in nodes Raises ------ ValueError If no tips could be found in the tree, or if not all tips were found. Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> nodes = [tree.find('a'), tree.find('b')] >>> lca = tree.lowest_common_ancestor(nodes) >>> print(lca.name) c >>> nodes = [tree.find('a'), tree.find('e')] >>> lca = tree.lca(nodes) # lca is an alias for convience >>> print(lca.name) root """ if len(tipnames) == 1: return self.find(tipnames[0]) tips = [self.find(name) for name in tipnames] if len(tips) == 0: raise ValueError("No tips found.") nodes_to_scrub = [] for t in tips: if t.is_root(): # has to be the LCA... return t prev = t curr = t.parent while curr and not hasattr(curr, 'black'): setattr(curr, 'black', [prev]) nodes_to_scrub.append(curr) prev = curr curr = curr.parent # increase black count, multiple children lead to here if curr: curr.black.append(prev) curr = self while len(curr.black) == 1: curr = curr.black[0] # clean up tree for n in nodes_to_scrub: delattr(n, 'black') return curr lca = lowest_common_ancestor # for convenience @classonlymethod @experimental(as_of="0.4.0") def from_taxonomy(cls, lineage_map): r"""Construct a tree from a taxonomy Parameters ---------- lineage_map : iterable of tuple A id to lineage mapping where the first index is an ID and the second index is an iterable of the lineage. Returns ------- TreeNode The constructed taxonomy See Also -------- from_taxdump Examples -------- >>> from skbio.tree import TreeNode >>> lineages = [ ... ('1', ['Bacteria', 'Firmicutes', 'Clostridia']), ... ('2', ['Bacteria', 'Firmicutes', 'Bacilli']), ... ('3', ['Bacteria', 'Bacteroidetes', 'Sphingobacteria']), ... ('4', ['Archaea', 'Euryarchaeota', 'Thermoplasmata']), ... ('5', ['Archaea', 'Euryarchaeota', 'Thermoplasmata']), ... ('6', ['Archaea', 'Euryarchaeota', 'Halobacteria']), ... ('7', ['Archaea', 'Euryarchaeota', 'Halobacteria']), ... ('8', ['Bacteria', 'Bacteroidetes', 'Sphingobacteria']), ... ('9', ['Bacteria', 'Bacteroidetes', 'Cytophagia'])] >>> tree = TreeNode.from_taxonomy(lineages) >>> print(tree.ascii_art()) /Clostridia-1 /Firmicutes | \Bacilli- /-2 /Bacteria| | | /-3 | | /Sphingobacteria | \Bacteroidetes \-8 | | ---------| \Cytophagia-9 | | /-4 | /Thermoplasmata | | \-5 \Archaea- /Euryarchaeota | /-6 \Halobacteria \-7 """ root = cls(name=None) root._lookup = {} for id_, lineage in lineage_map: cur_node = root # for each name, see if we've seen it, if not, add that puppy on for name in lineage: if name in cur_node._lookup: cur_node = cur_node._lookup[name] else: new_node = cls(name=name) new_node._lookup = {} cur_node._lookup[name] = new_node cur_node.append(new_node) cur_node = new_node cur_node.append(cls(name=id_)) # scrub the lookups for node in root.non_tips(include_self=True): del node._lookup return root def _balanced_distance_to_tip(self): """Return the distance to tip from this node. The distance to every tip from this node must be equal for this to return a correct result. Returns ------- int The distance to tip of a length-balanced tree """ node = self distance = 0 while node.has_children(): distance += node.children[0].length node = node.children[0] return distance @classonlymethod @experimental(as_of="0.4.0") def from_linkage_matrix(cls, linkage_matrix, id_list): """Return tree from SciPy linkage matrix. Parameters ---------- linkage_matrix : ndarray A SciPy linkage matrix as returned by `scipy.cluster.hierarchy.linkage` id_list : list The indices of the `id_list` will be used in the linkage_matrix Returns ------- TreeNode An unrooted bifurcated tree See Also -------- scipy.cluster.hierarchy.linkage """ tip_width = len(id_list) cluster_count = len(linkage_matrix) lookup_len = cluster_count + tip_width node_lookup = np.empty(lookup_len, dtype=cls) for i, name in enumerate(id_list): node_lookup[i] = cls(name=name) for i in range(tip_width, lookup_len): node_lookup[i] = cls() newest_cluster_index = cluster_count + 1 for link in linkage_matrix: child_a = node_lookup[int(link[0])] child_b = node_lookup[int(link[1])] path_length = link[2] / 2 child_a.length = path_length - child_a._balanced_distance_to_tip() child_b.length = path_length - child_b._balanced_distance_to_tip() new_cluster = node_lookup[newest_cluster_index] new_cluster.append(child_a) new_cluster.append(child_b) newest_cluster_index += 1 return node_lookup[-1] @experimental(as_of="0.4.0") def to_taxonomy(self, allow_empty=False, filter_f=None): """Returns a taxonomy representation of self Parameters ---------- allow_empty : bool, optional Allow gaps the taxonomy (e.g., internal nodes without names). filter_f : function, optional Specify a filtering function that returns True if the lineage is to be returned. This function must accept a ``TreeNode`` as its first parameter, and a ``list`` that represents the lineage as the second parameter. Yields ------ tuple ``(tip, [lineage])`` where ``tip`` corresponds to a tip in the tree and ``[lineage]`` is the expanded names from root to tip. ``None`` and empty strings are omitted from the lineage. Notes ----- If ``allow_empty`` is ``True`` and the root node does not have a name, then that name will not be included. This is because it is common to have multiple domains represented in the taxonomy, which would result in a root node that does not have a name and does not make sense to represent in the output. Examples -------- >>> from skbio.tree import TreeNode >>> lineages = {'1': ['Bacteria', 'Firmicutes', 'Clostridia'], ... '2': ['Bacteria', 'Firmicutes', 'Bacilli'], ... '3': ['Bacteria', 'Bacteroidetes', 'Sphingobacteria'], ... '4': ['Archaea', 'Euryarchaeota', 'Thermoplasmata'], ... '5': ['Archaea', 'Euryarchaeota', 'Thermoplasmata'], ... '6': ['Archaea', 'Euryarchaeota', 'Halobacteria'], ... '7': ['Archaea', 'Euryarchaeota', 'Halobacteria'], ... '8': ['Bacteria', 'Bacteroidetes', 'Sphingobacteria'], ... '9': ['Bacteria', 'Bacteroidetes', 'Cytophagia']} >>> tree = TreeNode.from_taxonomy(lineages.items()) >>> lineages = sorted([(n.name, l) for n, l in tree.to_taxonomy()]) >>> for name, lineage in lineages: ... print(name, '; '.join(lineage)) 1 Bacteria; Firmicutes; Clostridia 2 Bacteria; Firmicutes; Bacilli 3 Bacteria; Bacteroidetes; Sphingobacteria 4 Archaea; Euryarchaeota; Thermoplasmata 5 Archaea; Euryarchaeota; Thermoplasmata 6 Archaea; Euryarchaeota; Halobacteria 7 Archaea; Euryarchaeota; Halobacteria 8 Bacteria; Bacteroidetes; Sphingobacteria 9 Bacteria; Bacteroidetes; Cytophagia """ if filter_f is None: def filter_f(a, b): return True self.assign_ids() seen = set() lineage = [] # visit internal nodes while traversing out to the tips, and on the # way back up for node in self.traverse(self_before=True, self_after=True): if node.is_tip(): if filter_f(node, lineage): yield (node, lineage[:]) else: if allow_empty: if node.is_root() and not node.name: continue else: if not node.name: continue if node.id in seen: lineage.pop(-1) else: lineage.append(node.name) seen.add(node.id) @experimental(as_of="0.4.0") def to_array(self, attrs=None, nan_length_value=None): """Return an array representation of self Parameters ---------- attrs : list of tuple or None The attributes and types to return. The expected form is [(attribute_name, type)]. If `None`, then `name`, `length`, and `id` are returned. nan_length_value : float, optional If provided, replaces any `nan` in the branch length vector (i.e., ``result['length']``) with this value. `nan` branch lengths can arise from an edge not having a length (common for the root node parent edge), which can making summing problematic. Returns ------- dict of array {id_index: {id: TreeNode}, child_index: ((node_id, left_child_id, right_child_id)), attr_1: array(...), ... attr_N: array(...)} Notes ----- Attribute arrays are in index order such that TreeNode.id can be used as a lookup into the array. Examples -------- >>> from pprint import pprint >>> from skbio import TreeNode >>> t = TreeNode.read(['(((a:1,b:2,c:3)x:4,(d:5)y:6)z:7);']) >>> res = t.to_array() >>> sorted(res.keys()) ['child_index', 'id', 'id_index', 'length', 'name'] >>> res['child_index'] array([[4, 0, 2], [5, 3, 3], [6, 4, 5], [7, 6, 6]]) >>> for k, v in res['id_index'].items(): ... print(k, v) ... 0 a:1.0; 1 b:2.0; 2 c:3.0; 3 d:5.0; 4 (a:1.0,b:2.0,c:3.0)x:4.0; 5 (d:5.0)y:6.0; 6 ((a:1.0,b:2.0,c:3.0)x:4.0,(d:5.0)y:6.0)z:7.0; 7 (((a:1.0,b:2.0,c:3.0)x:4.0,(d:5.0)y:6.0)z:7.0); >>> res['id'] array([0, 1, 2, 3, 4, 5, 6, 7]) >>> res['name'] array(['a', 'b', 'c', 'd', 'x', 'y', 'z', None], dtype=object) """ if attrs is None: attrs = [('name', object), ('length', float), ('id', int)] else: for attr, dtype in attrs: if not hasattr(self, attr): raise AttributeError("Invalid attribute '%s'." % attr) id_index, child_index = self.index_tree() n = self.id + 1 # assign_ids starts at 0 tmp = [np.zeros(n, dtype=dtype) for attr, dtype in attrs] for node in self.traverse(include_self=True): n_id = node.id for idx, (attr, dtype) in enumerate(attrs): tmp[idx][n_id] = getattr(node, attr) results = {'id_index': id_index, 'child_index': child_index} results.update({attr: arr for (attr, dtype), arr in zip(attrs, tmp)}) if nan_length_value is not None: length_v = results['length'] length_v[np.isnan(length_v)] = nan_length_value return results def _ascii_art(self, char1='-', show_internal=True, compact=False): LEN = 10 PAD = ' ' * LEN PA = ' ' * (LEN - 1) namestr = self._node_label() if self.children: mids = [] result = [] for c in self.children: if c is self.children[0]: char2 = '/' elif c is self.children[-1]: char2 = '\\' else: char2 = '-' (clines, mid) = c._ascii_art(char2, show_internal, compact) mids.append(mid + len(result)) result.extend(clines) if not compact: result.append('') if not compact: result.pop() (lo, hi, end) = (mids[0], mids[-1], len(result)) prefixes = [PAD] * (lo + 1) + [PA + '|'] * \ (hi - lo - 1) + [PAD] * (end - hi) mid = int(np.trunc((lo + hi) / 2)) prefixes[mid] = char1 + '-' * (LEN - 2) + prefixes[mid][-1] result = [p + l for (p, l) in zip(prefixes, result)] if show_internal: stem = result[mid] result[mid] = stem[0] + namestr + stem[len(namestr) + 1:] return (result, mid) else: return ([char1 + '-' + namestr], 0) @experimental(as_of="0.4.0") def ascii_art(self, show_internal=True, compact=False): r"""Returns a string containing an ascii drawing of the tree Note, this method calls a private recursive function and is not safe for large trees. Parameters ---------- show_internal : bool includes internal edge names compact : bool use exactly one line per tip Returns ------- str an ASCII formatted version of the tree Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b)c,(d,e)f)root;"]) >>> print(tree.ascii_art()) /-a /c-------| | \-b -root----| | /-d \f-------| \-e """ (lines, mid) = self._ascii_art(show_internal=show_internal, compact=compact) return '\n'.join(lines) @experimental(as_of="0.4.0") def accumulate_to_ancestor(self, ancestor): r"""Return the sum of the distance between self and ancestor Parameters ---------- ancestor : TreeNode The node of the ancestor to accumulate distance too Returns ------- float The sum of lengths between self and ancestor Raises ------ NoParentError A NoParentError is raised if the ancestor is not an ancestor of self NoLengthError A NoLengthError is raised if one of the nodes between self and ancestor (including self) lacks a `length` attribute See Also -------- distance Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a:1,b:2)c:3,(d:4,e:5)f:6)root;"]) >>> root = tree >>> tree.find('a').accumulate_to_ancestor(root) 4.0 """ accum = 0.0 curr = self while curr is not ancestor: if curr.is_root(): raise NoParentError("Provided ancestor is not in the path") if curr.length is None: raise NoLengthError("No length on node %s found." % curr.name or "unnamed") accum += curr.length curr = curr.parent return accum @experimental(as_of="0.4.0") def distance(self, other): """Return the distance between self and other This method can be used to compute the distances between two tips, however, it is not optimized for computing pairwise tip distances. Parameters ---------- other : TreeNode The node to compute a distance to Returns ------- float The distance between two nodes Raises ------ NoLengthError A NoLengthError will be raised if a node without `length` is encountered See Also -------- tip_tip_distances accumulate_to_ancestor compare_tip_distances get_max_distance Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a:1,b:2)c:3,(d:4,e:5)f:6)root;"]) >>> tip_a = tree.find('a') >>> tip_d = tree.find('d') >>> tip_a.distance(tip_d) 14.0 """ if self is other: return 0.0 self_ancestors = [self] + list(self.ancestors()) other_ancestors = [other] + list(other.ancestors()) if self in other_ancestors: return other.accumulate_to_ancestor(self) elif other in self_ancestors: return self.accumulate_to_ancestor(other) else: root = self.root() lca = root.lowest_common_ancestor([self, other]) accum = self.accumulate_to_ancestor(lca) accum += other.accumulate_to_ancestor(lca) return accum def _set_max_distance(self): """Propagate tip distance information up the tree This method was originally implemented by Julia Goodrich with the intent of being able to determine max tip to tip distances between nodes on large trees efficiently. The code has been modified to track the specific tips the distance is between """ maxkey = itemgetter(0) for n in self.postorder(): if n.is_tip(): n.MaxDistTips = ((0.0, n), (0.0, n)) else: if len(n.children) == 1: raise TreeError("No support for single descedent nodes") else: tip_info = [(max(c.MaxDistTips, key=maxkey), c) for c in n.children] dists = [i[0][0] for i in tip_info] best_idx = np.argsort(dists)[-2:] (tip_a_d, tip_a), child_a = tip_info[best_idx[0]] (tip_b_d, tip_b), child_b = tip_info[best_idx[1]] tip_a_d += child_a.length or 0.0 tip_b_d += child_b.length or 0.0 n.MaxDistTips = ((tip_a_d, tip_a), (tip_b_d, tip_b)) def _get_max_distance_singledesc(self): """returns the max distance between any pair of tips Also returns the tip names that it is between as a tuple""" distmtx = self.tip_tip_distances() idx_max = divmod(distmtx.data.argmax(), distmtx.shape[1]) max_pair = (distmtx.ids[idx_max[0]], distmtx.ids[idx_max[1]]) return distmtx[idx_max], max_pair @experimental(as_of="0.4.0") def get_max_distance(self): """Returns the max tip tip distance between any pair of tips Returns ------- float The distance between the two most distant tips in the tree tuple of TreeNode The two most distant tips in the tree Raises ------ NoLengthError A NoLengthError will be thrown if a node without length is encountered See Also -------- distance tip_tip_distances compare_tip_distances Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a:1,b:2)c:3,(d:4,e:5)f:6)root;"]) >>> dist, tips = tree.get_max_distance() >>> dist 16.0 >>> [n.name for n in tips] ['b', 'e'] """ if not hasattr(self, 'MaxDistTips'): # _set_max_distance will throw a TreeError if a node with a single # child is encountered try: self._set_max_distance() except TreeError: # return self._get_max_distance_singledesc() longest = 0.0 tips = [None, None] for n in self.non_tips(include_self=True): tip_a, tip_b = n.MaxDistTips dist = (tip_a[0] + tip_b[0]) if dist > longest: longest = dist tips = [tip_a[1], tip_b[1]] return longest, tips @experimental(as_of="0.4.0") def tip_tip_distances(self, endpoints=None): """Returns distance matrix between pairs of tips, and a tip order. By default, all pairwise distances are calculated in the tree. If `endpoints` are specified, then only the distances between those tips are computed. Parameters ---------- endpoints : list of TreeNode or str, or None A list of TreeNode objects or names of TreeNode objects Returns ------- DistanceMatrix The distance matrix Raises ------ ValueError If any of the specified `endpoints` are not tips See Also -------- distance compare_tip_distances Notes ----- If a node does not have an associated length, 0.0 will be used and a ``RepresentationWarning`` will be raised. Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a:1,b:2)c:3,(d:4,e:5)f:6)root;"]) >>> mat = tree.tip_tip_distances() >>> print(mat) 4x4 distance matrix IDs: 'a', 'b', 'd', 'e' Data: [[ 0. 3. 14. 15.] [ 3. 0. 15. 16.] [ 14. 15. 0. 9.] [ 15. 16. 9. 0.]] """ all_tips = list(self.tips()) if endpoints is None: tip_order = all_tips else: tip_order = [self.find(n) for n in endpoints] for n in tip_order: if not n.is_tip(): raise ValueError("Node with name '%s' is not a tip." % n.name) # linearize all tips in postorder # .__start, .__stop compose the slice in tip_order. for i, node in enumerate(all_tips): node.__start, node.__stop = i, i + 1 # the result map provides index in the result matrix result_map = {n.__start: i for i, n in enumerate(tip_order)} num_all_tips = len(all_tips) # total number of tips num_tips = len(tip_order) # total number of tips in result result = np.zeros((num_tips, num_tips), float) # tip by tip matrix distances = np.zeros((num_all_tips), float) # dist from tip to tip def update_result(): # set tip_tip distance between tips of different child for child1, child2 in combinations(node.children, 2): for tip1 in range(child1.__start, child1.__stop): if tip1 not in result_map: continue t1idx = result_map[tip1] for tip2 in range(child2.__start, child2.__stop): if tip2 not in result_map: continue t2idx = result_map[tip2] result[t1idx, t2idx] = distances[ tip1] + distances[tip2] for node in self.postorder(): if not node.children: continue # subtree with solved child wedges # can possibly use np.zeros starts, stops = [], [] # to calc ._start and ._stop for curr node for child in node.children: length = child.length if length is None: warnings.warn( "`TreeNode.tip_tip_distances`: Node with name %r does " "not have an associated length, so a length of 0.0 " "will be used." % child.name, RepresentationWarning) length = 0.0 distances[child.__start:child.__stop] += length starts.append(child.__start) stops.append(child.__stop) node.__start, node.__stop = min(starts), max(stops) if len(node.children) > 1: update_result() return DistanceMatrix(result + result.T, [n.name for n in tip_order]) @experimental(as_of="0.4.0") def compare_rfd(self, other, proportion=False): """Calculates the Robinson and Foulds symmetric difference Parameters ---------- other : TreeNode A tree to compare against proportion : bool Return a proportional difference Returns ------- float The distance between the trees Notes ----- Implementation based off of code by Julia Goodrich. The original description of the algorithm can be found in [1]_. Raises ------ ValueError If the tip names between `self` and `other` are equal. See Also -------- compare_subsets compare_tip_distances References ---------- .. [1] Comparison of phylogenetic trees. Robinson and Foulds. Mathematical Biosciences. 1981. 53:131-141 Examples -------- >>> from skbio import TreeNode >>> tree1 = TreeNode.read(["((a,b),(c,d));"]) >>> tree2 = TreeNode.read(["(((a,b),c),d);"]) >>> tree1.compare_rfd(tree2) 2.0 """ t1names = {n.name for n in self.tips()} t2names = {n.name for n in other.tips()} if t1names != t2names: if t1names < t2names: tree1 = self tree2 = other.shear(t1names) else: tree1 = self.shear(t2names) tree2 = other else: tree1 = self tree2 = other tree1_sets = tree1.subsets() tree2_sets = tree2.subsets() not_in_both = tree1_sets.symmetric_difference(tree2_sets) dist = float(len(not_in_both)) if proportion: total_subsets = len(tree1_sets) + len(tree2_sets) dist = dist / total_subsets return dist @experimental(as_of="0.4.0") def compare_subsets(self, other, exclude_absent_taxa=False): """Returns fraction of overlapping subsets where self and other differ. Names present in only one of the two trees will count as mismatches, if you don't want this behavior, strip out the non-matching tips first. Parameters ---------- other : TreeNode The tree to compare exclude_absent_taxa : bool Strip out names that don't occur in both trees Returns ------- float The fraction of overlapping subsets that differ between the trees See Also -------- compare_rfd compare_tip_distances subsets Examples -------- >>> from skbio import TreeNode >>> tree1 = TreeNode.read(["((a,b),(c,d));"]) >>> tree2 = TreeNode.read(["(((a,b),c),d);"]) >>> tree1.compare_subsets(tree2) 0.5 """ self_sets, other_sets = self.subsets(), other.subsets() if exclude_absent_taxa: in_both = self.subset() & other.subset() self_sets = (i & in_both for i in self_sets) self_sets = frozenset({i for i in self_sets if len(i) > 1}) other_sets = (i & in_both for i in other_sets) other_sets = frozenset({i for i in other_sets if len(i) > 1}) total_subsets = len(self_sets) + len(other_sets) intersection_length = len(self_sets & other_sets) if not total_subsets: # no common subsets after filtering, so max dist return 1 return 1 - (2 * intersection_length / float(total_subsets)) @experimental(as_of="0.4.0") def compare_tip_distances(self, other, sample=None, dist_f=distance_from_r, shuffle_f=np.random.shuffle): """Compares self to other using tip-to-tip distance matrices. Value returned is `dist_f(m1, m2)` for the two matrices. Default is to use the Pearson correlation coefficient, with +1 giving a distance of 0 and -1 giving a distance of +1 (the maximum possible value). Depending on the application, you might instead want to use distance_from_r_squared, which counts correlations of both +1 and -1 as identical (0 distance). Note: automatically strips out the names that don't match (this is necessary for this method because the distance between non-matching names and matching names is undefined in the tree where they don't match, and because we need to reorder the names in the two trees to match up the distance matrices). Parameters ---------- other : TreeNode The tree to compare sample : int or None Randomly subsample the tips in common between the trees to compare. This is useful when comparing very large trees. dist_f : function The distance function used to compare two the tip-tip distance matrices shuffle_f : function The shuffling function used if `sample` is not None Returns ------- float The distance between the trees Raises ------ ValueError A ValueError is raised if there does not exist common tips between the trees See Also -------- compare_subsets compare_rfd Examples -------- >>> from skbio import TreeNode >>> # note, only three common taxa between the trees >>> tree1 = TreeNode.read(["((a:1,b:1):2,(c:0.5,X:0.7):3);"]) >>> tree2 = TreeNode.read(["(((a:1,b:1,Y:1):2,c:3):1,Z:4);"]) >>> dist = tree1.compare_tip_distances(tree2) >>> print("%.9f" % dist) 0.000133446 """ self_names = {i.name: i for i in self.tips()} other_names = {i.name: i for i in other.tips()} common_names = frozenset(self_names) & frozenset(other_names) common_names = list(common_names) if not common_names: raise ValueError("No tip names in common between the two trees.") if len(common_names) <= 2: return 1 # the two trees must match by definition in this case if sample is not None: shuffle_f(common_names) common_names = common_names[:sample] self_nodes = [self_names[k] for k in common_names] other_nodes = [other_names[k] for k in common_names] self_matrix = self.tip_tip_distances(endpoints=self_nodes) other_matrix = other.tip_tip_distances(endpoints=other_nodes) return dist_f(self_matrix, other_matrix) @experimental(as_of="0.4.2") def bifurcate(self, insert_length=None): r"""Reorders the tree into a bifurcating tree. All nodes that have more than 2 children will have additional intermediate nodes inserted to ensure that every node has only 2 children. Parameters ---------- insert_length : int, optional The branch length assigned to all inserted nodes. See Also -------- prune Notes ----- Any nodes that have a single child can be collapsed using the prune method to create strictly bifurcating trees. Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b,g,h)c,(d,e)f)root;"]) >>> print(tree.ascii_art()) /-a | |--b /c-------| | |--g | | -root----| \-h | | /-d \f-------| \-e >>> tree.bifurcate() >>> print(tree.ascii_art()) /-h /c-------| | | /-g | \--------| | | /-a -root----| \--------| | \-b | | /-d \f-------| \-e """ for n in self.traverse(include_self=True): if len(n.children) > 2: stack = n.children while len(stack) > 2: ind = stack.pop() intermediate = self.__class__() intermediate.length = insert_length intermediate.extend(stack) n.append(intermediate) for k in stack: n.remove(k) n.extend([ind, intermediate]) @experimental(as_of="0.4.0") def index_tree(self): """Index a tree for rapid lookups within a tree array Indexes nodes in-place as `n._leaf_index`. Returns ------- dict A mapping {node_id: TreeNode} np.array of ints This arrays describes the IDs of every internal node, and the ID range of the immediate descendents. The first column in the array corresponds to node_id. The second column is the left most descendent's ID. The third column is the right most descendent's ID. """ self.assign_ids() id_index = {} child_index = [] for n in self.postorder(): for c in n.children: id_index[c.id] = c if c: # c has children itself, so need to add to result child_index.append((c.id, c.children[0].id, c.children[-1].id)) # handle root, which should be t itself id_index[self.id] = self # only want to add to the child_index if self has children... if self.children: child_index.append((self.id, self.children[0].id, self.children[-1].id)) child_index = np.asarray(child_index, dtype=np.int64) child_index = np.atleast_2d(child_index) return id_index, child_index @experimental(as_of="0.4.0") def assign_ids(self): """Assign topologically stable unique ids to self Following the call, all nodes in the tree will have their id attribute set """ curr_index = 0 for n in self.postorder(): for c in n.children: c.id = curr_index curr_index += 1 self.id = curr_index @experimental(as_of="0.4.0") def descending_branch_length(self, tip_subset=None): """Find total descending branch length from self or subset of self tips Parameters ---------- tip_subset : Iterable, or None If None, the total descending branch length for all tips in the tree will be returned. If a list of tips is provided then only the total descending branch length associated with those tips will be returned. Returns ------- float The total descending branch length for the specified set of tips. Raises ------ ValueError A ValueError is raised if the list of tips supplied to tip_subset contains internal nodes or non-tips. Notes ----- This function replicates cogent's totalDescendingBranch Length method and extends that method to allow the calculation of total descending branch length of a subset of the tips if requested. The postorder guarantees that the function will always be able to add the descending branch length if the node is not a tip. Nodes with no length will have their length set to 0. The root length (if it exists) is ignored. Examples -------- >>> from skbio import TreeNode >>> tr = TreeNode.read(["(((A:.1,B:1.2)C:.6,(D:.9,E:.6)F:.9)G:2.4," ... "(H:.4,I:.5)J:1.3)K;"]) >>> tdbl = tr.descending_branch_length() >>> sdbl = tr.descending_branch_length(['A','E']) >>> print(round(tdbl, 1), round(sdbl, 1)) 8.9 2.2 """ self.assign_ids() if tip_subset is not None: all_tips = self.subset() if not set(tip_subset).issubset(all_tips): raise ValueError('tip_subset contains ids that aren\'t tip ' 'names.') lca = self.lowest_common_ancestor(tip_subset) ancestors = {} for tip in tip_subset: curr = self.find(tip) while curr is not lca: ancestors[curr.id] = curr.length if curr.length is not \ None else 0.0 curr = curr.parent return sum(ancestors.values()) else: return sum(n.length for n in self.postorder(include_self=False) if n.length is not None) @experimental(as_of="0.4.0") def cache_attr(self, func, cache_attrname, cache_type=list): """Cache attributes on internal nodes of the tree Parameters ---------- func : function func will be provided the node currently being evaluated and must return a list of item (or items) to cache from that node or an empty list. cache_attrname : str Name of the attribute to decorate on containing the cached values cache_type : {set, frozenset, list} The type of the cache Notes ----- This method is particularly useful if you need to frequently look up attributes that would normally require a traversal of the tree. WARNING: any cache created by this method will be invalidated if the topology of the tree changes (e.g., if `TreeNode.invalidate_caches` is called). Raises ------ TypeError If an cache_type that is not a `set` or a `list` is specified. Examples -------- Cache the tip names of the tree on its internal nodes >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b,(c,d)e)f,(g,h)i)root;"]) >>> f = lambda n: [n.name] if n.is_tip() else [] >>> tree.cache_attr(f, 'tip_names') >>> for n in tree.traverse(include_self=True): ... print("Node name: %s, cache: %r" % (n.name, n.tip_names)) Node name: root, cache: ['a', 'b', 'c', 'd', 'g', 'h'] Node name: f, cache: ['a', 'b', 'c', 'd'] Node name: a, cache: ['a'] Node name: b, cache: ['b'] Node name: e, cache: ['c', 'd'] Node name: c, cache: ['c'] Node name: d, cache: ['d'] Node name: i, cache: ['g', 'h'] Node name: g, cache: ['g'] Node name: h, cache: ['h'] """ if cache_type in [set, frozenset]: def reduce_f(a, b): return a | b elif cache_type == list: def reduce_f(a, b): return a + b else: raise TypeError("Only list, set and frozenset are supported.") for node in self.postorder(include_self=True): node._registered_caches.add(cache_attrname) cached = [getattr(c, cache_attrname) for c in node.children] cached.append(cache_type(func(node))) setattr(node, cache_attrname, reduce(reduce_f, cached)) @experimental(as_of="0.4.0") def shuffle(self, k=None, names=None, shuffle_f=np.random.shuffle, n=1): """Yield trees with shuffled tip names Parameters ---------- k : int, optional The number of tips to shuffle. If k is not `None`, k tips are randomly selected, and only those names will be shuffled. names : list, optional The specific tip names to shuffle. k and names cannot be specified at the same time. shuffle_f : func Shuffle method, this function must accept a list and modify inplace. n : int, optional The number of iterations to perform. Value must be > 0 and `np.inf` can be specified for an infinite number of iterations. Notes ----- Tip names are shuffled inplace. If neither `k` nor `names` are provided, all tips are shuffled. Yields ------ TreeNode Tree with shuffled tip names. Raises ------ ValueError If `k` is < 2 If `n` is < 1 ValueError If both `k` and `names` are specified MissingNodeError If `names` is specified but one of the names cannot be found Examples -------- Alternate the names on two of the tips, 'a', and 'b', and do this 5 times. >>> from skbio import TreeNode >>> tree = TreeNode.read(["((a,b),(c,d));"]) >>> rev = lambda items: items.reverse() >>> shuffler = tree.shuffle(names=['a', 'b'], shuffle_f=rev, n=5) >>> for shuffled_tree in shuffler: ... print(shuffled_tree) ((b,a),(c,d)); ((a,b),(c,d)); ((b,a),(c,d)); ((a,b),(c,d)); ((b,a),(c,d)); """ if k is not None and k < 2: raise ValueError("k must be None or >= 2") if k is not None and names is not None: raise ValueError("n and names cannot be specified at the sametime") if n < 1: raise ValueError("n must be > 0") self.assign_ids() if names is None: all_tips = list(self.tips()) if n is None: n = len(all_tips) shuffle_f(all_tips) names = [tip.name for tip in all_tips[:k]] nodes = [self.find(name) for name in names] # Since the names are being shuffled, the association between ID and # name is no longer reliable self.invalidate_caches() counter = 0 while counter < n: shuffle_f(names) for node, name in zip(nodes, names): node.name = name yield self counter += 1 @experimental(as_of="0.5.6") def _extract_support(self): """Extract the support value from a node label, if available. Returns ------- tuple of int, float or None The support value extracted from the node label str or None The node label with the support value stripped """ support, label = None, None if self.name: # separate support value from node name by the first colon left, _, right = self.name.partition(':') try: support = int(left) except ValueError: try: support = float(left) except ValueError: pass # strip support value from node name label = right or None if support is not None else self.name return support, label @experimental(as_of="0.5.6") def _node_label(self): """Generate a node label in the format of "support:name" if both exist, or "support" or "name" if either exists. Returns ------- str Generated node label """ lblst = [] if self.support is not None: # prevents support of NoneType lblst.append(str(self.support)) if self.name: # prevents name of NoneType lblst.append(self.name) return ':'.join(lblst) @experimental(as_of="0.5.6") def assign_supports(self): """Extract support values from internal node labels of a tree. Notes ----- A "support value" measures the confidence or frequency of the incoming branch (the branch from parent to self) of an internal node in a tree. Roots and tips do not have support values. To extract a support value from a node label, this method reads from left and stops at the first ":" (if any), and attempts to convert it to a number. For examples: "(a,b)1.0", "(a,b)1.0:2.5", and "(a,b)'1.0:species_A'". In these cases the support values are all 1.0. For examples: "(a,b):1.0" and "(a,b)species_A". In these cases there are no support values. If a support value is successfully extracted, it will be stripped from the node label and assigned to the `support` property. IMPORTANT: mathematically, "support value" is a property of a branch, not a node. Because of historical reasons, support values are usually attached to nodes in a typical tree file [1]. [1] Czech, Lucas, Jaime Huerta-Cepas, and Alexandros Stamatakis. "A Critical Review on the Use of Support Values in Tree Viewers and Bioinformatics Toolkits." Molecular biology and evolution 34.6 (2017): 1535-1542. Examples -------- >>> from skbio import TreeNode >>> newick = "((a,b)95,(c,d):1.1,(e,f)'80:speciesA':1.0);" >>> tree = TreeNode.read([newick]) >>> tree.assign_supports() >>> tree.lca(['a', 'b']).support 95 >>> tree.lca(['c', 'd']).support is None True >>> tree.lca(['e', 'f']).support 80 >>> tree.lca(['e', 'f']).name 'speciesA' """ for node in self.traverse(): if node.is_root() or node.is_tip(): node.support = None else: node.support, node.name = node._extract_support() @experimental(as_of="0.5.3") def unpack(self): """Unpack an internal node in place. Notes ----- This function sequentially: 1) elongates child nodes by branch length of self (omit if there is no branch length), 2) removes self from parent node, and 3) grafts child nodes to parent node. Raises ------ ValueError if input node is root or tip See also -------- unpack_by_func prune Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(['((c:2.0,d:3.0)a:1.0,(e:2.0,f:1.0)b:2.0);']) >>> tree.find('b').unpack() >>> print(tree) ((c:2.0,d:3.0)a:1.0,e:4.0,f:3.0); """ if self.is_root(): raise TreeError('Cannot unpack root.') if self.is_tip(): raise TreeError('Cannot unpack tip.') parent = self.parent blen = (self.length or 0.0) for child in self.children: clen = (child.length or 0.0) child.length = (clen + blen or None) parent.remove(self) parent.extend(self.children) @experimental(as_of="0.5.3") def unpack_by_func(self, func): """Unpack internal nodes of a tree that meet certain criteria. Parameters ---------- func : function a function that accepts a TreeNode and returns `True` or `False`, where `True` indicates the node is to be unpacked See also -------- unpack prune Examples -------- >>> from skbio import TreeNode >>> tree = TreeNode.read(['((c:2,d:3)a:1,(e:1,f:2)b:2);']) >>> tree.unpack_by_func(lambda x: x.length <= 1) >>> print(tree) ((e:1.0,f:2.0)b:2.0,c:3.0,d:4.0); >>> tree = TreeNode.read(['(((a,b)85,(c,d)78)75,(e,(f,g)64)80);']) >>> tree.assign_supports() >>> tree.unpack_by_func(lambda x: x.support < 75) >>> print(tree) (((a,b)85,(c,d)78)75,(e,f,g)80); """ nodes_to_unpack = [] for node in self.non_tips(include_self=False): if func(node): nodes_to_unpack.append(node) for node in nodes_to_unpack: node.unpack() @classonlymethod @experimental(as_of="0.5.8") def from_taxdump(cls, nodes, names=None): """Construct a tree from the NCBI taxonomy database. Parameters ---------- nodes : pd.DataFrame Taxon hierarchy names : pd.DataFrame or dict, optional Taxon names Returns ------- TreeNode The constructed tree Notes ----- ``nodes`` and ``names`` correspond to "nodes.dmp" and "names.dmp" of the NCBI taxonomy database. The should be read into data frames using ``skbio.io.read`` prior to this operation. Alternatively, ``names`` may be provided as a dictionary. If ``names`` is omitted, taxonomy IDs be used as taxon names. Raises ------ ValueError If there is no top-level node ValueError If there are more than one top-level node See Also -------- from_taxonomy skbio.io.format.taxdump Examples -------- >>> import pandas as pd >>> from skbio.tree import TreeNode >>> nodes = pd.DataFrame([ ... [1, 1, 'no rank'], ... [2, 1, 'domain'], ... [3, 1, 'domain'], ... [4, 2, 'phylum'], ... [5, 2, 'phylum']], columns=[ ... 'tax_id', 'parent_tax_id', 'rank']).set_index('tax_id') >>> names = {1: 'root', 2: 'Bacteria', 3: 'Archaea', ... 4: 'Firmicutes', 5: 'Bacteroidetes'} >>> tree = TreeNode.from_taxdump(nodes, names) >>> print(tree.ascii_art()) /-Firmicutes /Bacteria| -root----| \\-Bacteroidetes | \\-Archaea """ # identify top level of hierarchy tops = nodes[nodes['parent_tax_id'] == nodes.index] # validate root uniqueness n_top = tops.shape[0] if n_top == 0: raise ValueError('There is no top-level node.') elif n_top > 1: raise ValueError('There are more than one top-level node.') # get root taxid root_id = tops.index[0] # get parent-to-child(ren) map to_children = {p: g.index.tolist() for p, g in nodes[ nodes.index != root_id].groupby('parent_tax_id')} # get rank map ranks = nodes['rank'].to_dict() # get taxon-to-name map # if not provided, use tax_id as name if names is None: names = {x: str(x) for x in nodes.index} # use "scientific name" as name elif isinstance(names, pd.DataFrame): names = names[names['name_class'] == 'scientific name'][ 'name_txt'].to_dict() # initiate tree tree = cls(names[root_id]) tree.id = root_id tree.rank = ranks[root_id] # helper for extending tree def _extend_tree(node): self_id = node.id if self_id not in to_children: return children = [] for id_ in to_children[self_id]: child = TreeNode(names[id_]) child.id = id_ child.rank = ranks[id_] _extend_tree(child) children.append(child) node.extend(children) # extend tree _extend_tree(tree) return tree scikit-bio-0.5.9/skbio/tree/tests/000077500000000000000000000000001446255456000170055ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/tree/tests/__init__.py000066400000000000000000000005411446255456000211160ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/tree/tests/test_majority_rule.py000066400000000000000000000172531446255456000233130ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main import numpy as np from skbio import TreeNode from skbio.tree import majority_rule from skbio.tree._majority_rule import (_walk_clades, _filter_clades, _build_trees) class MajorityRuleTests(TestCase): def test_majority_rule(self): trees = [ TreeNode.read( io.StringIO("(A,(B,(H,(D,(J,(((G,E),(F,I)),C))))));")), TreeNode.read( io.StringIO("(A,(B,(D,((J,H),(((G,E),(F,I)),C)))));")), TreeNode.read( io.StringIO("(A,(B,(D,(H,(J,(((G,E),(F,I)),C))))));")), TreeNode.read( io.StringIO("(A,(B,(E,(G,((F,I),((J,(H,D)),C))))));")), TreeNode.read( io.StringIO("(A,(B,(E,(G,((F,I),(((J,H),D),C))))));")), TreeNode.read( io.StringIO("(A,(B,(E,((F,I),(G,((J,(H,D)),C))))));")), TreeNode.read( io.StringIO("(A,(B,(E,((F,I),(G,(((J,H),D),C))))));")), TreeNode.read( io.StringIO("(A,(B,(E,((G,(F,I)),((J,(H,D)),C)))));")), TreeNode.read( io.StringIO("(A,(B,(E,((G,(F,I)),(((J,H),D),C)))));"))] exp = TreeNode.read(io.StringIO("(((E,(G,(F,I),(C,(D,J,H)))),B),A);")) obs = majority_rule(trees) self.assertEqual(exp.compare_subsets(obs[0]), 0.0) self.assertEqual(len(obs), 1) tree = obs[0] exp_supports = sorted([9.0, 9.0, 9.0, 6.0, 6.0, 6.0]) obs_supports = sorted([n.support for n in tree.non_tips()]) self.assertEqual(obs_supports, exp_supports) obs = majority_rule(trees, weights=np.ones(len(trees)) * 2) self.assertEqual(exp.compare_subsets(obs[0]), 0.0) self.assertEqual(len(obs), 1) tree = obs[0] exp_supports = sorted([18.0, 18.0, 12.0, 18.0, 12.0, 12.0]) obs_supports = sorted([n.support for n in tree.non_tips()]) with self.assertRaises(ValueError): majority_rule(trees, weights=[1, 2]) def test_majority_rule_multiple_trees(self): trees = [ TreeNode.read(io.StringIO("((a,b),(c,d),(e,f));")), TreeNode.read(io.StringIO("(a,(c,d),b,(e,f));")), TreeNode.read(io.StringIO("((c,d),(e,f),b);")), TreeNode.read(io.StringIO("(a,(c,d),(e,f));"))] trees = majority_rule(trees) self.assertEqual(len(trees), 4) for tree in trees: self.assertIs(type(tree), TreeNode) exp = set([ frozenset(['a']), frozenset(['b']), frozenset([None, 'c', 'd']), frozenset([None, 'e', 'f'])]) obs = set([frozenset([n.name for n in t.traverse()]) for t in trees]) self.assertEqual(obs, exp) def test_majority_rule_tree_node_class(self): class TreeNodeSubclass(TreeNode): pass trees = [ TreeNode.read(io.StringIO("((a,b),(c,d),(e,f));")), TreeNode.read(io.StringIO("(a,(c,d),b,(e,f));")), TreeNode.read(io.StringIO("((c,d),(e,f),b);")), TreeNode.read(io.StringIO("(a,(c,d),(e,f));"))] trees = majority_rule(trees, tree_node_class=TreeNodeSubclass) self.assertEqual(len(trees), 4) for tree in trees: self.assertIs(type(tree), TreeNodeSubclass) exp = set([ frozenset(['a']), frozenset(['b']), frozenset([None, 'c', 'd']), frozenset([None, 'e', 'f'])]) obs = set([frozenset([n.name for n in t.traverse()]) for t in trees]) self.assertEqual(obs, exp) def test_walk_clades(self): trees = [TreeNode.read(io.StringIO("((A,B),(D,E));")), TreeNode.read(io.StringIO("((A,B),(D,(E,X)));"))] exp_clades = [ (frozenset(['A']), 2.0), (frozenset(['B']), 2.0), (frozenset(['A', 'B']), 2.0), (frozenset(['D', 'E']), 1.0), (frozenset(['D', 'E', 'A', 'B']), 1.0), (frozenset(['D']), 2.0), (frozenset(['E']), 2.0), (frozenset(['X']), 1.0), (frozenset(['E', 'X']), 1.0), (frozenset(['D', 'E', 'X']), 1.0), (frozenset(['A', 'B', 'D', 'E', 'X']), 1.0)] exp_lengths_nolength = { frozenset(['A']): None, frozenset(['B']): None, frozenset(['A', 'B']): None, frozenset(['D', 'E']): None, frozenset(['D', 'E', 'A', 'B']): None, frozenset(['D']): None, frozenset(['E']): None, frozenset(['X']): None, frozenset(['E', 'X']): None, frozenset(['D', 'E', 'X']): None, frozenset(['A', 'B', 'D', 'E', 'X']): None} exp_lengths = { frozenset(['A']): 2.0, frozenset(['B']): 2.0, frozenset(['A', 'B']): 2.0, frozenset(['D', 'E']): 1.0, frozenset(['D', 'E', 'A', 'B']): 1.0, frozenset(['D']): 2.0, frozenset(['E']): 2.0, frozenset(['X']): 1.0, frozenset(['E', 'X']): 1.0, frozenset(['D', 'E', 'X']): 1.0, frozenset(['A', 'B', 'D', 'E', 'X']): 1.0} obs_clades, obs_lengths = _walk_clades(trees, np.ones(len(trees))) self.assertEqual(set(obs_clades), set(exp_clades)) self.assertEqual(obs_lengths, exp_lengths_nolength) for t in trees: for n in t.traverse(include_self=True): n.length = 2.0 obs_clades, obs_lengths = _walk_clades(trees, np.ones(len(trees))) self.assertEqual(set(obs_clades), set(exp_clades)) self.assertEqual(obs_lengths, exp_lengths) def test_filter_clades(self): clade_counts = [(frozenset(['A', 'B']), 8), (frozenset(['A', 'C']), 7), (frozenset(['A']), 6), (frozenset(['B']), 5)] obs = _filter_clades(clade_counts, 2) exp = {frozenset(['A', 'B']): 8, frozenset(['A']): 6, frozenset(['B']): 5} self.assertEqual(obs, exp) clade_counts = [(frozenset(['A']), 8), (frozenset(['B']), 7), (frozenset(['C']), 7), (frozenset(['A', 'B']), 6), (frozenset(['A', 'B', 'C']), 5), (frozenset(['D']), 2)] obs = _filter_clades(clade_counts, 4) exp = {frozenset(['A']): 8, frozenset(['B']): 7, frozenset(['C']): 7, frozenset(['A', 'B']): 6, frozenset(['A', 'B', 'C']): 5} self.assertEqual(obs, exp) def test_build_trees(self): clade_counts = {frozenset(['A', 'B']): 6, frozenset(['A']): 7, frozenset(['B']): 8} edge_lengths = {frozenset(['A', 'B']): 1, frozenset(['A']): 2, frozenset(['B']): 3} tree = _build_trees(clade_counts, edge_lengths, 'foo', TreeNode)[0] self.assertEqual(tree.foo, 6) tree_foos = set([c.foo for c in tree.children]) tree_lens = set([c.length for c in tree.children]) self.assertEqual(tree_foos, set([7, 8])) self.assertEqual(tree_lens, set([2, 3])) if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/tree/tests/test_nj.py000066400000000000000000000202601446255456000210250ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main from skbio import DistanceMatrix, TreeNode, nj from skbio.tree._nj import ( _compute_q, _compute_collapsed_dm, _lowest_index, _pair_members_to_new_node) class NjTests(TestCase): def setUp(self): data1 = [[0, 5, 9, 9, 8], [5, 0, 10, 10, 9], [9, 10, 0, 8, 7], [9, 10, 8, 0, 3], [8, 9, 7, 3, 0]] ids1 = list('abcde') self.dm1 = DistanceMatrix(data1, ids1) # this newick string was confirmed against http://www.trex.uqam.ca/ # which generated the following (isomorphic) newick string: # (d:2.0000,e:1.0000,(c:4.0000,(a:2.0000,b:3.0000):3.0000):2.0000); self.expected1_str = ("(d:2.000000, (c:4.000000, (b:3.000000," " a:2.000000):3.000000):2.000000, e:1.000000);") self.expected1_TreeNode = TreeNode.read( io.StringIO(self.expected1_str)) # this example was pulled from the Phylip manual # http://evolution.genetics.washington.edu/phylip/doc/neighbor.html data2 = [[0.0000, 1.6866, 1.7198, 1.6606, 1.5243, 1.6043, 1.5905], [1.6866, 0.0000, 1.5232, 1.4841, 1.4465, 1.4389, 1.4629], [1.7198, 1.5232, 0.0000, 0.7115, 0.5958, 0.6179, 0.5583], [1.6606, 1.4841, 0.7115, 0.0000, 0.4631, 0.5061, 0.4710], [1.5243, 1.4465, 0.5958, 0.4631, 0.0000, 0.3484, 0.3083], [1.6043, 1.4389, 0.6179, 0.5061, 0.3484, 0.0000, 0.2692], [1.5905, 1.4629, 0.5583, 0.4710, 0.3083, 0.2692, 0.0000]] ids2 = ["Bovine", "Mouse", "Gibbon", "Orang", "Gorilla", "Chimp", "Human"] self.dm2 = DistanceMatrix(data2, ids2) self.expected2_str = ("(Mouse:0.76891, (Gibbon:0.35793, (Orang:0.28469" ", (Gorilla:0.15393, (Chimp:0.15167, Human:0.117" "53):0.03982):0.02696):0.04648):0.42027, Bovine:" "0.91769);") self.expected2_TreeNode = TreeNode.read( io.StringIO(self.expected2_str)) data3 = [[0, 5, 4, 7, 6, 8], [5, 0, 7, 10, 9, 11], [4, 7, 0, 7, 6, 8], [7, 10, 7, 0, 5, 8], [6, 9, 6, 5, 0, 8], [8, 11, 8, 8, 8, 0]] ids3 = map(str, range(6)) self.dm3 = DistanceMatrix(data3, ids3) self.expected3_str = ("((((0:1.000000,1:4.000000):1.000000,2:2.000000" "):1.250000,5:4.750000):0.750000,3:2.750000,4:2." "250000);") self.expected3_TreeNode = TreeNode.read( io.StringIO(self.expected3_str)) # this dm can yield negative branch lengths data4 = [[0, 5, 9, 9, 800], [5, 0, 10, 10, 9], [9, 10, 0, 8, 7], [9, 10, 8, 0, 3], [800, 9, 7, 3, 0]] ids4 = list('abcde') self.dm4 = DistanceMatrix(data4, ids4) def test_nj_dm1(self): self.assertEqual(nj(self.dm1, result_constructor=str), self.expected1_str) # what is the correct way to compare TreeNode objects for equality? actual_TreeNode = nj(self.dm1) # precision error on ARM: 1.6653345369377348e-16 != 0.0 self.assertAlmostEqual(actual_TreeNode.compare_tip_distances( self.expected1_TreeNode), 0.0, places=10) def test_nj_dm2(self): actual_TreeNode = nj(self.dm2) self.assertAlmostEqual(actual_TreeNode.compare_tip_distances( self.expected2_TreeNode), 0.0) def test_nj_dm3(self): actual_TreeNode = nj(self.dm3) self.assertAlmostEqual(actual_TreeNode.compare_tip_distances( self.expected3_TreeNode), 0.0) def test_nj_zero_branch_length(self): # no nodes have negative branch length when we disallow negative # branch length. self is excluded as branch length is None tree = nj(self.dm4) for n in tree.postorder(include_self=False): self.assertTrue(n.length >= 0) # only tips associated with the large distance in the input # have positive branch lengths when we allow negative branch # length tree = nj(self.dm4, False) self.assertTrue(tree.find('a').length > 0) self.assertTrue(tree.find('b').length < 0) self.assertTrue(tree.find('c').length < 0) self.assertTrue(tree.find('d').length < 0) self.assertTrue(tree.find('e').length > 0) def test_nj_trivial(self): data = [[0, 3, 2], [3, 0, 3], [2, 3, 0]] dm = DistanceMatrix(data, list('abc')) expected_str = "(b:2.000000, a:1.000000, c:1.000000);" self.assertEqual(nj(dm, result_constructor=str), expected_str) def test_nj_error(self): data = [[0, 3], [3, 0]] dm = DistanceMatrix(data, list('ab')) self.assertRaises(ValueError, nj, dm) def test_compute_q(self): expected_data = [[0, -50, -38, -34, -34], [-50, 0, -38, -34, -34], [-38, -38, 0, -40, -40], [-34, -34, -40, 0, -48], [-34, -34, -40, -48, 0]] expected_ids = list('abcde') expected = DistanceMatrix(expected_data, expected_ids) self.assertEqual(_compute_q(self.dm1), expected) data = [[0, 3, 2], [3, 0, 3], [2, 3, 0]] dm = DistanceMatrix(data, list('abc')) # computed this manually expected_data = [[0, -8, -8], [-8, 0, -8], [-8, -8, 0]] expected = DistanceMatrix(expected_data, list('abc')) self.assertEqual(_compute_q(dm), expected) def test_compute_collapsed_dm(self): expected_data = [[0, 7, 7, 6], [7, 0, 8, 7], [7, 8, 0, 3], [6, 7, 3, 0]] expected_ids = ['x', 'c', 'd', 'e'] expected1 = DistanceMatrix(expected_data, expected_ids) self.assertEqual(_compute_collapsed_dm(self.dm1, 'a', 'b', True, 'x'), expected1) # computed manually expected_data = [[0, 4, 3], [4, 0, 3], [3, 3, 0]] expected_ids = ['yy', 'd', 'e'] expected2 = DistanceMatrix(expected_data, expected_ids) self.assertEqual( _compute_collapsed_dm(expected1, 'x', 'c', True, 'yy'), expected2) def test_lowest_index(self): self.assertEqual(_lowest_index(self.dm1), (4, 3)) self.assertEqual(_lowest_index(_compute_q(self.dm1)), (1, 0)) def test_pair_members_to_new_node(self): self.assertEqual(_pair_members_to_new_node(self.dm1, 'a', 'b', True), (2, 3)) self.assertEqual(_pair_members_to_new_node(self.dm1, 'a', 'c', True), (4, 5)) self.assertEqual(_pair_members_to_new_node(self.dm1, 'd', 'e', True), (2, 1)) def test_pair_members_to_new_node_zero_branch_length(self): # the values in this example don't really make sense # (I'm not sure how you end up with these distances between # three sequences), but that doesn't really matter for the sake # of this test data = [[0, 4, 2], [4, 0, 38], [2, 38, 0]] ids = ['a', 'b', 'c'] dm = DistanceMatrix(data, ids) self.assertEqual(_pair_members_to_new_node(dm, 'a', 'b', True), (0, 4)) # this makes it clear why negative branch lengths don't make sense... self.assertEqual( _pair_members_to_new_node(dm, 'a', 'b', False), (-16, 20)) if __name__ == "__main__": main() scikit-bio-0.5.9/skbio/tree/tests/test_tree.py000066400000000000000000001765411446255456000213730ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io from unittest import TestCase, main from collections import defaultdict import numpy as np import numpy.testing as npt import pandas as pd from scipy.stats import pearsonr from skbio import DistanceMatrix, TreeNode from skbio.tree import (DuplicateNodeError, NoLengthError, TreeError, MissingNodeError, NoParentError) from skbio.util import RepresentationWarning class TreeNodeSubclass(TreeNode): pass class TreeTests(TestCase): def setUp(self): """Prep the self""" self.simple_t = TreeNode.read(io.StringIO("((a,b)i1,(c,d)i2)root;")) nodes = dict([(x, TreeNode(x)) for x in 'abcdefgh']) nodes['a'].append(nodes['b']) nodes['b'].append(nodes['c']) nodes['c'].append(nodes['d']) nodes['c'].append(nodes['e']) nodes['c'].append(nodes['f']) nodes['f'].append(nodes['g']) nodes['a'].append(nodes['h']) self.TreeRoot = nodes['a'] def rev_f(items): items.reverse() def rotate_f(items): tmp = items[-1] items[1:] = items[:-1] items[0] = tmp self.rev_f = rev_f self.rotate_f = rotate_f self.complex_tree = TreeNode.read(io.StringIO( "(((a,b)int1,(x,y,(w,z)int2,(c,d)int3)int4),(e,f)int5);")) def test_bug_issue_1416(self): tree = TreeNode.read(['(((a,b,f,g),c),d);']) new_tree = tree.shear(['a', 'b', 'c', 'f']) exp = {'a', 'b', 'c', 'f'} obs = {n.name for n in new_tree.tips()} self.assertEqual(obs, exp) self.assertEqual(id(new_tree), id(new_tree.children[0].parent)) self.assertEqual(id(new_tree), id(new_tree.children[1].parent)) def test_observed_node_counts(self): """returns observed nodes counts given vector of otu observation counts """ # no OTUs observed otu_counts = {} expected = defaultdict(int) self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) # error on zero count(s) otu_counts = {'a': 0} self.assertRaises(ValueError, self.simple_t.observed_node_counts, otu_counts) otu_counts = {'a': 0, 'b': 0, 'c': 0, 'd': 0} self.assertRaises(ValueError, self.simple_t.observed_node_counts, otu_counts) # all OTUs observed once otu_counts = {'a': 1, 'b': 1, 'c': 1, 'd': 1} expected = defaultdict(int) expected[self.simple_t.find('root')] = 4 expected[self.simple_t.find('i1')] = 2 expected[self.simple_t.find('i2')] = 2 expected[self.simple_t.find('a')] = 1 expected[self.simple_t.find('b')] = 1 expected[self.simple_t.find('c')] = 1 expected[self.simple_t.find('d')] = 1 self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) # some OTUs observed twice otu_counts = {'a': 2, 'b': 1, 'c': 1, 'd': 1} expected = defaultdict(int) expected[self.simple_t.find('root')] = 5 expected[self.simple_t.find('i1')] = 3 expected[self.simple_t.find('i2')] = 2 expected[self.simple_t.find('a')] = 2 expected[self.simple_t.find('b')] = 1 expected[self.simple_t.find('c')] = 1 expected[self.simple_t.find('d')] = 1 self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) otu_counts = {'a': 2, 'b': 1, 'c': 1, 'd': 2} expected = defaultdict(int) expected[self.simple_t.find('root')] = 6 expected[self.simple_t.find('i1')] = 3 expected[self.simple_t.find('i2')] = 3 expected[self.simple_t.find('a')] = 2 expected[self.simple_t.find('b')] = 1 expected[self.simple_t.find('c')] = 1 expected[self.simple_t.find('d')] = 2 self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) # some OTUs observed, others not observed otu_counts = {'a': 2, 'b': 1} expected = defaultdict(int) expected[self.simple_t.find('root')] = 3 expected[self.simple_t.find('i1')] = 3 expected[self.simple_t.find('a')] = 2 expected[self.simple_t.find('b')] = 1 self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) otu_counts = {'d': 1} expected = defaultdict(int) expected[self.simple_t.find('root')] = 1 expected[self.simple_t.find('i2')] = 1 expected[self.simple_t.find('d')] = 1 self.assertEqual(self.simple_t.observed_node_counts(otu_counts), expected) # error on non-tips otu_counts = {'a': 2, 'e': 1} self.assertRaises(MissingNodeError, self.simple_t.observed_node_counts, otu_counts) otu_counts = {'a': 2, 'i1': 1} self.assertRaises(MissingNodeError, self.simple_t.observed_node_counts, otu_counts) # test with another tree otu_counts = {} expected = defaultdict(int) self.assertEqual(self.complex_tree.observed_node_counts(otu_counts), expected) otu_counts = {'e': 42, 'f': 1} expected[self.complex_tree.root()] = 43 expected[self.complex_tree.find('int5')] = 43 expected[self.complex_tree.find('e')] = 42 expected[self.complex_tree.find('f')] = 1 self.assertEqual(self.complex_tree.observed_node_counts(otu_counts), expected) def test_count(self): """Get node counts""" exp = 7 obs = self.simple_t.count() self.assertEqual(obs, exp) exp = 4 obs = self.simple_t.count(tips=True) self.assertEqual(obs, exp) def test_copy(self): """copy a tree""" self.simple_t.children[0].length = 1.2 self.simple_t.children[1].children[0].length = 0.5 cp = self.simple_t.copy() gen = zip(cp.traverse(include_self=True), self.simple_t.traverse(include_self=True)) for a, b in gen: self.assertIsNot(a, b) self.assertEqual(a.name, b.name) self.assertEqual(a.length, b.length) def test_append(self): """Append a node to a tree""" second_tree = TreeNode.read(io.StringIO("(x,y)z;")) self.simple_t.append(second_tree) self.assertEqual(self.simple_t.children[0].name, 'i1') self.assertEqual(self.simple_t.children[1].name, 'i2') self.assertEqual(self.simple_t.children[2].name, 'z') self.assertEqual(len(self.simple_t.children), 3) self.assertEqual(self.simple_t.children[2].children[0].name, 'x') self.assertEqual(self.simple_t.children[2].children[1].name, 'y') self.assertEqual(second_tree.parent, self.simple_t) def test_extend(self): """Extend a few nodes""" second_tree = TreeNode.read(io.StringIO("(x1,y1)z1;")) third_tree = TreeNode.read(io.StringIO("(x2,y2)z2;")) first_tree = TreeNode.read(io.StringIO("(x1,y1)z1;")) fourth_tree = TreeNode.read(io.StringIO("(x2,y2)z2;")) self.simple_t.extend([second_tree, third_tree]) first_tree.extend(fourth_tree.children) self.assertEqual(0, len(fourth_tree.children)) self.assertEqual(first_tree.children[0].name, 'x1') self.assertEqual(first_tree.children[1].name, 'y1') self.assertEqual(first_tree.children[2].name, 'x2') self.assertEqual(first_tree.children[3].name, 'y2') self.assertEqual(self.simple_t.children[0].name, 'i1') self.assertEqual(self.simple_t.children[1].name, 'i2') self.assertEqual(self.simple_t.children[2].name, 'z1') self.assertEqual(self.simple_t.children[3].name, 'z2') self.assertEqual(len(self.simple_t.children), 4) self.assertEqual(self.simple_t.children[2].children[0].name, 'x1') self.assertEqual(self.simple_t.children[2].children[1].name, 'y1') self.assertEqual(self.simple_t.children[3].children[0].name, 'x2') self.assertEqual(self.simple_t.children[3].children[1].name, 'y2') self.assertIs(second_tree.parent, self.simple_t) self.assertIs(third_tree.parent, self.simple_t) def test_extend_empty(self): """Extend on the empty case should work""" self.simple_t.extend([]) self.assertEqual(self.simple_t.children[0].name, 'i1') self.assertEqual(self.simple_t.children[1].name, 'i2') self.assertEqual(len(self.simple_t.children), 2) def test_iter(self): """iter wraps children""" exp = ['i1', 'i2'] obs = [n.name for n in self.simple_t] self.assertEqual(obs, exp) def test_gops(self): """Basic TreeNode operations should work as expected""" p = TreeNode() self.assertEqual(str(p), ';\n') p.name = 'abc' self.assertEqual(str(p), 'abc;\n') p.length = 3 self.assertEqual(str(p), 'abc:3;\n') # don't suppress branch from root q = TreeNode() p.append(q) self.assertEqual(str(p), '()abc:3;\n') r = TreeNode() q.append(r) self.assertEqual(str(p), '(())abc:3;\n') r.name = 'xyz' self.assertEqual(str(p), '((xyz))abc:3;\n') q.length = 2 self.assertEqual(str(p), '((xyz):2)abc:3;\n') def test_pop(self): """Pop off a node""" second_tree = TreeNode.read(io.StringIO("(x1,y1)z1;")) third_tree = TreeNode.read(io.StringIO("(x2,y2)z2;")) self.simple_t.extend([second_tree, third_tree]) i1 = self.simple_t.pop(0) z2 = self.simple_t.pop() self.assertEqual(i1.name, 'i1') self.assertEqual(z2.name, 'z2') self.assertEqual(i1.children[0].name, 'a') self.assertEqual(i1.children[1].name, 'b') self.assertEqual(z2.children[0].name, 'x2') self.assertEqual(z2.children[1].name, 'y2') self.assertEqual(self.simple_t.children[0].name, 'i2') self.assertEqual(self.simple_t.children[1].name, 'z1') self.assertEqual(len(self.simple_t.children), 2) def test_remove(self): """Remove nodes""" self.assertTrue(self.simple_t.remove(self.simple_t.children[0])) self.assertEqual(len(self.simple_t.children), 1) n = TreeNode() self.assertFalse(self.simple_t.remove(n)) def test_remove_deleted(self): """Remove nodes by function""" def f(node): return node.name in ['b', 'd'] self.simple_t.remove_deleted(f) exp = "((a)i1,(c)i2)root;\n" obs = str(self.simple_t) self.assertEqual(obs, exp) def test_adopt(self): """Adopt a node!""" n1 = TreeNode(name='n1') n2 = TreeNode(name='n2') n3 = TreeNode(name='n3') self.simple_t._adopt(n1) self.simple_t.children[-1]._adopt(n2) n2._adopt(n3) # adopt doesn't update .children self.assertEqual(len(self.simple_t.children), 2) self.assertIs(n1.parent, self.simple_t) self.assertIs(n2.parent, self.simple_t.children[-1]) self.assertIs(n3.parent, n2) def test_remove_node(self): """Remove a node by index""" n = self.simple_t._remove_node(-1) self.assertEqual(n.parent, None) self.assertEqual(len(self.simple_t.children), 1) self.assertEqual(len(n.children), 2) self.assertNotIn(n, self.simple_t.children) def test_shear_prune_parent_dropped(self): bugtree = "((a,b),((c,d),(e,f)));" to_keep = ['c', 'd'] exp = "(c,d);\n" obs = str(TreeNode.read(io.StringIO(bugtree)).shear(to_keep)) self.assertEqual(obs, exp) def test_prune_nested_single_descendent(self): bugtree = "(((a,b)));" exp = "(a,b);\n" t = TreeNode.read(io.StringIO(bugtree)) t.prune() obs = str(t) self.assertEqual(obs, exp) def test_prune_root_single_desc(self): t = TreeNode.read(["((a,b)c)extra;"]) exp = "(a,b)c;\n" t.prune() self.assertEqual(str(t), exp) def test_prune(self): """Collapse single descendent nodes""" # check the identity case cp = self.simple_t.copy() self.simple_t.prune() gen = zip(cp.traverse(include_self=True), self.simple_t.traverse(include_self=True)) for a, b in gen: self.assertIsNot(a, b) self.assertEqual(a.name, b.name) self.assertEqual(a.length, b.length) # create a single descendent by removing tip 'a' n = self.simple_t.children[0] n.remove(n.children[0]) self.simple_t.prune() self.assertEqual(len(self.simple_t.children), 2) self.assertEqual(self.simple_t.children[0].name, 'i2') self.assertEqual(self.simple_t.children[1].name, 'b') def test_prune_length(self): """Collapse single descendent nodes""" # check the identity case cp = self.simple_t.copy() self.simple_t.prune() gen = zip(cp.traverse(include_self=True), self.simple_t.traverse(include_self=True)) for a, b in gen: self.assertIsNot(a, b) self.assertEqual(a.name, b.name) self.assertEqual(a.length, b.length) for n in self.simple_t.traverse(): n.length = 1.0 # create a single descendent by removing tip 'a' n = self.simple_t.children[0] n.remove(n.children[0]) self.simple_t.prune() self.assertEqual(len(self.simple_t.children), 2) self.assertEqual(self.simple_t.children[0].name, 'i2') self.assertEqual(self.simple_t.children[1].name, 'b') self.assertEqual(self.simple_t.children[1].length, 2.0) def test_subset(self): """subset should return set of leaves that descends from node""" t = self.simple_t self.assertEqual(t.subset(), frozenset('abcd')) c = t.children[0] self.assertEqual(c.subset(), frozenset('ab')) leaf = c.children[1] self.assertEqual(leaf.subset(), frozenset('')) def test_subsets(self): """subsets should return all subsets descending from a set""" t = self.simple_t self.assertEqual(t.subsets(), frozenset( [frozenset('ab'), frozenset('cd')])) def test_is_tip(self): """see if we're a tip or not""" self.assertFalse(self.simple_t.is_tip()) self.assertFalse(self.simple_t.children[0].is_tip()) self.assertTrue(self.simple_t.children[0].children[0].is_tip()) def test_is_root(self): """see if we're at the root or not""" self.assertTrue(self.simple_t.is_root()) self.assertFalse(self.simple_t.children[0].is_root()) self.assertFalse(self.simple_t.children[0].children[0].is_root()) def test_root(self): """Get the root!""" root = self.simple_t self.assertIs(root, self.simple_t.root()) self.assertIs(root, self.simple_t.children[0].root()) self.assertIs(root, self.simple_t.children[1].children[1].root()) def test_invalidate_lookup_caches(self): root = self.simple_t root.create_caches() self.assertNotEqual(root._tip_cache, {}) self.assertNotEqual(root._non_tip_cache, {}) root.invalidate_caches() self.assertEqual(root._tip_cache, {}) self.assertEqual(root._non_tip_cache, {}) def test_invalidate_attr_caches(self): tree = TreeNode.read(io.StringIO("((a,b,(c,d)e)f,(g,h)i)root;")) def f(n): return [n.name] if n.is_tip() else [] tree.cache_attr(f, 'tip_names') tree.invalidate_caches() for n in tree.traverse(include_self=True): self.assertFalse(hasattr(n, 'tip_names')) def test_create_caches_duplicate_tip_names(self): with self.assertRaises(DuplicateNodeError): TreeNode.read(io.StringIO('(a, a);')).create_caches() def test_find_all(self): t = TreeNode.read(io.StringIO("((a,b)c,((d,e)c)c,(f,(g,h)c)a)root;")) exp = [t.children[0], t.children[1].children[0], t.children[1], t.children[2].children[1]] obs = t.find_all('c') self.assertEqual(obs, exp) identity = t.find_all(t) self.assertEqual(len(identity), 1) self.assertEqual(identity[0], t) identity_name = t.find_all('root') self.assertEqual(len(identity_name), 1) self.assertEqual(identity_name[0], t) exp = [t.children[2], t.children[0].children[0]] obs = t.find_all('a') self.assertEqual(obs, exp) with self.assertRaises(MissingNodeError): t.find_all('missing') def test_find(self): """Find a node in a tree""" t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f);")) exp = t.children[0] obs = t.find('c') self.assertEqual(obs, exp) exp = t.children[0].children[1] obs = t.find('b') self.assertEqual(obs, exp) with self.assertRaises(MissingNodeError): t.find('does not exist') def test_find_cache_bug(self): """First implementation did not force the cache to be at the root""" t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f,(g,h)f);")) exp_tip_cache_keys = set(['a', 'b', 'd', 'e', 'g', 'h']) exp_non_tip_cache_keys = set(['c', 'f']) tip_a = t.children[0].children[0] tip_a.create_caches() self.assertEqual(tip_a._tip_cache, {}) self.assertEqual(set(t._tip_cache), exp_tip_cache_keys) self.assertEqual(set(t._non_tip_cache), exp_non_tip_cache_keys) self.assertEqual(t._non_tip_cache['f'], [t.children[1], t.children[2]]) def test_find_by_id(self): """Find a node by id""" t1 = TreeNode.read(io.StringIO("((,),(,,));")) t2 = TreeNode.read(io.StringIO("((,),(,,));")) exp = t1.children[1] obs = t1.find_by_id(6) # right inner node with 3 children self.assertEqual(obs, exp) exp = t2.children[1] obs = t2.find_by_id(6) # right inner node with 3 children self.assertEqual(obs, exp) with self.assertRaises(MissingNodeError): t1.find_by_id(100) def test_find_by_func(self): """Find nodes by a function""" t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f);")) def func(x): return x.parent == t.find('c') exp = ['a', 'b'] obs = [n.name for n in t.find_by_func(func)] self.assertEqual(obs, exp) def test_ancestors(self): """Get all the ancestors""" exp = ['i1', 'root'] obs = self.simple_t.children[0].children[0].ancestors() self.assertEqual([o.name for o in obs], exp) exp = ['root'] obs = self.simple_t.children[0].ancestors() self.assertEqual([o.name for o in obs], exp) exp = [] obs = self.simple_t.ancestors() self.assertEqual([o.name for o in obs], exp) def test_siblings(self): """Get the siblings""" exp = [] obs = self.simple_t.siblings() self.assertEqual(obs, exp) exp = ['i2'] obs = self.simple_t.children[0].siblings() self.assertEqual([o.name for o in obs], exp) exp = ['c'] obs = self.simple_t.children[1].children[1].siblings() self.assertEqual([o.name for o in obs], exp) self.simple_t.append(TreeNode(name="foo")) self.simple_t.append(TreeNode(name="bar")) exp = ['i1', 'foo', 'bar'] obs = self.simple_t.children[1].siblings() self.assertEqual([o.name for o in obs], exp) def test_ascii_art(self): """Make some ascii trees""" # unlabeled internal node tr = TreeNode.read(io.StringIO("(B:0.2,(C:0.3,D:0.4):0.6)F;")) obs = tr.ascii_art(show_internal=True, compact=False) exp = (" /-B\n" "-F-------|\n" " | /-C\n" " \\--------|\n" " \\-D") self.assertEqual(obs, exp) obs = tr.ascii_art(show_internal=True, compact=True) exp = ("-F------- /-B\n" " \\-------- /-C\n" " \\-D") self.assertEqual(obs, exp) obs = tr.ascii_art(show_internal=False, compact=False) exp = (" /-B\n" "---------|\n" " | /-C\n" " \\--------|\n" " \\-D") self.assertEqual(obs, exp) def test_ascii_art_with_support(self): """Make some ascii trees with support values""" tr = TreeNode.read(io.StringIO("(B:0.2,(C:0.3,D:0.4)90:0.6)F;")) exp = " /-B\n-F-------|\n | /-C\n "\ " \\90------|\n \\-D" obs = tr.ascii_art(show_internal=True, compact=False) self.assertEqual(obs, exp) tr.assign_supports() obs = tr.ascii_art(show_internal=True, compact=False) self.assertEqual(obs, exp) tr = TreeNode.read(io.StringIO("((A,B)75,(C,D)'80:spA');")) exp = " /-A\n /75------|\n | "\ " \\-B\n---------|\n | /-C\n \\"\ "80:spA--|\n \\-D" obs = tr.ascii_art(show_internal=True, compact=False) self.assertEqual(obs, exp) tr.assign_supports() obs = tr.ascii_art(show_internal=True, compact=False) self.assertEqual(obs, exp) def test_ascii_art_three_children(self): obs = TreeNode.read(io.StringIO('(a,(b,c,d));')).ascii_art() self.assertEqual(obs, exp_ascii_art_three_children) def test_accumulate_to_ancestor(self): """Get the distance from a node to its ancestor""" t = TreeNode.read(io.StringIO( "((a:0.1,b:0.2)c:0.3,(d:0.4,e)f:0.5)root;")) a = t.find('a') b = t.find('b') exp_to_root = 0.1 + 0.3 obs_to_root = a.accumulate_to_ancestor(t) self.assertEqual(obs_to_root, exp_to_root) with self.assertRaises(NoParentError): a.accumulate_to_ancestor(b) def test_distance_nontip(self): # example derived from issue #807, credit @wwood tstr = "((A:1.0,B:2.0)'g__genus1':3.0)root;" tree = TreeNode.read(io.StringIO(tstr)) self.assertEqual(tree.find('A').distance(tree.find('g__genus1')), 1.0) def test_distance(self): """Get the distance between two nodes""" t = TreeNode.read(io.StringIO( "((a:0.1,b:0.2)c:0.3,(d:0.4,e)f:0.5)root;")) tips = sorted([n for n in t.tips()], key=lambda x: x.name) npt.assert_almost_equal(tips[0].distance(tips[0]), 0.0) npt.assert_almost_equal(tips[0].distance(tips[1]), 0.3) npt.assert_almost_equal(tips[0].distance(tips[2]), 1.3) with self.assertRaises(NoLengthError): tips[0].distance(tips[3]) npt.assert_almost_equal(tips[1].distance(tips[0]), 0.3) npt.assert_almost_equal(tips[1].distance(tips[1]), 0.0) npt.assert_almost_equal(tips[1].distance(tips[2]), 1.4) with self.assertRaises(NoLengthError): tips[1].distance(tips[3]) self.assertEqual(tips[2].distance(tips[0]), 1.3) self.assertEqual(tips[2].distance(tips[1]), 1.4) self.assertEqual(tips[2].distance(tips[2]), 0.0) with self.assertRaises(NoLengthError): tips[2].distance(tips[3]) def test_lowest_common_ancestor(self): """TreeNode lowestCommonAncestor should return LCA for set of tips""" t1 = TreeNode.read(io.StringIO("((a,(b,c)d)e,f,(g,h)i)j;")) t2 = t1.copy() t3 = t1.copy() t4 = t1.copy() input1 = ['a'] # return self input2 = ['a', 'b'] # return e input3 = ['b', 'c'] # return d input4 = ['a', 'h', 'g'] # return j exp1 = t1.find('a') exp2 = t2.find('e') exp3 = t3.find('d') exp4 = t4 obs1 = t1.lowest_common_ancestor(input1) obs2 = t2.lowest_common_ancestor(input2) obs3 = t3.lowest_common_ancestor(input3) obs4 = t4.lowest_common_ancestor(input4) self.assertEqual(obs1, exp1) self.assertEqual(obs2, exp2) self.assertEqual(obs3, exp3) self.assertEqual(obs4, exp4) # verify multiple calls work t_mul = t1.copy() exp_1 = t_mul.find('d') exp_2 = t_mul.find('i') obs_1 = t_mul.lowest_common_ancestor(['b', 'c']) obs_2 = t_mul.lowest_common_ancestor(['g', 'h']) self.assertEqual(obs_1, exp_1) self.assertEqual(obs_2, exp_2) # empty case with self.assertRaises(ValueError): t1.lowest_common_ancestor([]) def test_get_max_distance(self): """get_max_distance should get max tip distance across tree""" tree = TreeNode.read(io.StringIO( "((a:0.1,b:0.2)c:0.3,(d:0.4,e:0.5)f:0.6)root;")) dist, nodes = tree.get_max_distance() npt.assert_almost_equal(dist, 1.6) self.assertEqual(sorted([n.name for n in nodes]), ['b', 'e']) def test_set_max_distance(self): """set_max_distance sets MaxDistTips across tree""" tree = TreeNode.read(io.StringIO( "((a:0.1,b:0.2)c:0.3,(d:0.4,e:0.5)f:0.6)root;")) tree._set_max_distance() tip_a, tip_b = tree.MaxDistTips self.assertEqual(tip_a[0] + tip_b[0], 1.6) self.assertEqual(sorted([tip_a[1].name, tip_b[1].name]), ['b', 'e']) def test_set_max_distance_tie_bug(self): """Corresponds to #1077""" s = io.StringIO("((a:1,b:1)c:2,(d:3,e:4)f:5)root;") t = TreeNode.read(s) exp = ((3.0, t.find('a')), (9.0, t.find('e'))) # the above tree would trigger an exception in max. The central issue # was that the data being passed to max were a tuple of tuple: # ((left_d, left_n), (right_d, right_n)) # the call to max would break in this scenario as it would fall onto # idx 1 of each tuple to assess the "max". t._set_max_distance() self.assertEqual(t.MaxDistTips, exp) def test_set_max_distance_inplace_modification_bug(self): """Corresponds to #1223""" s = io.StringIO("((a:1,b:1)c:2,(d:3,e:4)f:5)root;") t = TreeNode.read(s) exp = [((0.0, t.find('a')), (0.0, t.find('a'))), ((0.0, t.find('b')), (0.0, t.find('b'))), ((1.0, t.find('a')), (1.0, t.find('b'))), ((0.0, t.find('d')), (0.0, t.find('d'))), ((0.0, t.find('e')), (0.0, t.find('e'))), ((3.0, t.find('d')), (4.0, t.find('e'))), ((3.0, t.find('a')), (9.0, t.find('e')))] t._set_max_distance() self.assertEqual([n.MaxDistTips for n in t.postorder()], exp) def test_shear(self): """Shear the nodes""" t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) obs = str(t.shear(['G', 'M'])) exp = '(G:3.0,M:3.7);\n' self.assertEqual(obs, exp) def test_compare_tip_distances(self): t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) t2 = TreeNode.read(io.StringIO('(((H:1,G:1,O:1):2,R:3):1,X:4);')) obs = t.compare_tip_distances(t2) # note: common taxa are H, G, R (only) m1 = np.array([[0, 2, 6.5], [2, 0, 6.5], [6.5, 6.5, 0]]) m2 = np.array([[0, 2, 6], [2, 0, 6], [6, 6, 0]]) r = pearsonr(m1.flat, m2.flat)[0] self.assertAlmostEqual(obs, (1 - r) / 2) def test_compare_tip_distances_sample(self): t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) t2 = TreeNode.read(io.StringIO('(((H:1,G:1,O:1):2,R:3):1,X:4);')) obs = t.compare_tip_distances(t2, sample=3, shuffle_f=sorted) # note: common taxa are H, G, R (only) m1 = np.array([[0, 2, 6.5], [2, 0, 6.5], [6.5, 6.5, 0]]) m2 = np.array([[0, 2, 6], [2, 0, 6], [6, 6, 0]]) r = pearsonr(m1.flat, m2.flat)[0] self.assertAlmostEqual(obs, (1 - r) / 2) # 4 common taxa, still picking H, G, R s = '((H:1,G:1):2,(R:0.5,M:0.7,Q:5):3);' t = TreeNode.read(io.StringIO(s)) s3 = '(((H:1,G:1,O:1):2,R:3,Q:10):1,X:4);' t3 = TreeNode.read(io.StringIO(s3)) obs = t.compare_tip_distances(t3, sample=3, shuffle_f=sorted) def test_compare_tip_distances_no_common_tips(self): t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) t2 = TreeNode.read(io.StringIO('(((Z:1,Y:1,X:1):2,W:3):1,V:4);')) with self.assertRaises(ValueError): t.compare_tip_distances(t2) def test_compare_tip_distances_single_common_tip(self): t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) t2 = TreeNode.read(io.StringIO('(((R:1,Y:1,X:1):2,W:3):1,V:4);')) self.assertEqual(t.compare_tip_distances(t2), 1) self.assertEqual(t2.compare_tip_distances(t), 1) def test_tip_tip_distances_endpoints(self): """Test getting specifc tip distances with tipToTipDistances""" t = TreeNode.read(io.StringIO('((H:1,G:1):2,(R:0.5,M:0.7):3);')) nodes = [t.find('H'), t.find('G'), t.find('M')] names = ['H', 'G', 'M'] exp = DistanceMatrix(np.array([[0, 2.0, 6.7], [2.0, 0, 6.7], [6.7, 6.7, 0.0]]), ['H', 'G', 'M']) obs = t.tip_tip_distances(endpoints=names) self.assertEqual(obs, exp) obs = t.tip_tip_distances(endpoints=nodes) self.assertEqual(obs, exp) def test_tip_tip_distances_non_tip_endpoints(self): t = TreeNode.read(io.StringIO('((H:1,G:1)foo:2,(R:0.5,M:0.7):3);')) with self.assertRaises(ValueError): t.tip_tip_distances(endpoints=['foo']) def test_tip_tip_distances_no_length(self): t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f);")) exp_t = TreeNode.read(io.StringIO("((a:0,b:0)c:0,(d:0,e:0)f:0);")) exp_t_dm = exp_t.tip_tip_distances() t_dm = npt.assert_warns(RepresentationWarning, t.tip_tip_distances) self.assertEqual(t_dm, exp_t_dm) for node in t.preorder(): self.assertIs(node.length, None) def test_tip_tip_distances_missing_length(self): t = TreeNode.read(io.StringIO("((a,b:6)c:4,(d,e:0)f);")) exp_t = TreeNode.read(io.StringIO("((a:0,b:6)c:4,(d:0,e:0)f:0);")) exp_t_dm = exp_t.tip_tip_distances() t_dm = npt.assert_warns(RepresentationWarning, t.tip_tip_distances) self.assertEqual(t_dm, exp_t_dm) def test_neighbors(self): """Get neighbors of a node""" t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f);")) exp = t.children obs = t.neighbors() self.assertEqual(obs, exp) exp = t.children[0].children + [t] obs = t.children[0].neighbors() self.assertEqual(obs, exp) exp = [t.children[0].children[0]] + [t] obs = t.children[0].neighbors(ignore=t.children[0].children[1]) self.assertEqual(obs, exp) exp = [t.children[0]] obs = t.children[0].children[0].neighbors() self.assertEqual(obs, exp) def test_has_children(self): """Test if has children""" t = TreeNode.read(io.StringIO("((a,b)c,(d,e)f);")) self.assertTrue(t.has_children()) self.assertTrue(t.children[0].has_children()) self.assertTrue(t.children[1].has_children()) self.assertFalse(t.children[0].children[0].has_children()) self.assertFalse(t.children[0].children[1].has_children()) self.assertFalse(t.children[1].children[0].has_children()) self.assertFalse(t.children[1].children[1].has_children()) def test_tips(self): """Tip traversal of tree""" exp = ['a', 'b', 'c', 'd'] obs = [n.name for n in self.simple_t.tips()] self.assertEqual(obs, exp) obs2 = [n.name for n in self.simple_t.traverse(False, False)] self.assertEqual(obs2, exp) def test_tips_self(self): """ See issue #1509 """ tree = TreeNode.read(['(c, (b,a)x)y;']) ts = list(tree.find('c').tips(include_self=True)) self.assertEqual(len(ts), 1) t = ts[0] self.assertEqual(t.name, 'c') self.assertTrue(t.is_tip()) def test_pre_and_postorder(self): """Pre and post order traversal of the tree""" exp = ['root', 'i1', 'a', 'b', 'i1', 'i2', 'c', 'd', 'i2', 'root'] obs = [n.name for n in self.simple_t.pre_and_postorder()] self.assertEqual(obs, exp) obs2 = [n.name for n in self.simple_t.traverse(True, True)] self.assertEqual(obs2, exp) def test_pre_and_postorder_no_children(self): t = TreeNode('brofist') # include self exp = ['brofist'] obs = [n.name for n in t.pre_and_postorder()] self.assertEqual(obs, exp) # do not include self obs = list(t.pre_and_postorder(include_self=False)) self.assertEqual(obs, []) def test_levelorder(self): """Test level order traversal of the tree""" exp = ['root', 'i1', 'i2', 'a', 'b', 'c', 'd'] obs = [n.name for n in self.simple_t.levelorder()] self.assertEqual(obs, exp) def test_bifurcate(self): t1 = TreeNode.read(io.StringIO('(((a,b),c),(d,e));')) t2 = TreeNode.read(io.StringIO('((a,b,c));')) t3 = t2.copy() t1.bifurcate() t2.bifurcate() t3.bifurcate(insert_length=0) self.assertEqual(str(t1), '(((a,b),c),(d,e));\n') self.assertEqual(str(t2), '((c,(a,b)));\n') self.assertEqual(str(t3), '((c,(a,b):0));\n') def test_bifurcate_with_subclass(self): tree = TreeNodeSubclass() tree.append(TreeNodeSubclass()) tree.append(TreeNodeSubclass()) tree.append(TreeNodeSubclass()) tree.append(TreeNodeSubclass()) tree.bifurcate() for node in tree.traverse(): self.assertIs(type(node), TreeNodeSubclass) def test_index_tree_single_node(self): """index_tree handles single node tree""" t1 = TreeNode.read(io.StringIO('root;')) id_index, child_index = t1.index_tree() self.assertEqual(id_index[0], t1) npt.assert_equal(child_index, np.array([[]])) def test_index_tree(self): """index_tree should produce correct index and node map""" # test for first tree: contains singleton outgroup t1 = TreeNode.read(io.StringIO('(((a,b),c),(d,e));')) t2 = TreeNode.read(io.StringIO('(((a,b),(c,d)),(e,f));')) t3 = TreeNode.read(io.StringIO('(((a,b,c),(d)),(e,f));')) id_1, child_1 = t1.index_tree() nodes_1 = [n.id for n in t1.traverse(self_before=False, self_after=True)] self.assertEqual(nodes_1, [0, 1, 2, 3, 6, 4, 5, 7, 8]) npt.assert_equal(child_1, np.array([[2, 0, 1], [6, 2, 3], [7, 4, 5], [8, 6, 7]])) # test for second tree: strictly bifurcating id_2, child_2 = t2.index_tree() nodes_2 = [n.id for n in t2.traverse(self_before=False, self_after=True)] self.assertEqual(nodes_2, [0, 1, 4, 2, 3, 5, 8, 6, 7, 9, 10]) npt.assert_equal(child_2, np.array([[4, 0, 1], [5, 2, 3], [8, 4, 5], [9, 6, 7], [10, 8, 9]])) # test for third tree: contains trifurcation and single-child parent id_3, child_3 = t3.index_tree() nodes_3 = [n.id for n in t3.traverse(self_before=False, self_after=True)] self.assertEqual(nodes_3, [0, 1, 2, 4, 3, 5, 8, 6, 7, 9, 10]) npt.assert_equal(child_3, np.array([[4, 0, 2], [5, 3, 3], [8, 4, 5], [9, 6, 7], [10, 8, 9]])) def test_root_at(self): """Form a new root""" t = TreeNode.read(io.StringIO("(((a,b)c,(d,e)f)g,h)i;")) with self.assertRaises(TreeError): t.root_at(t.find('h')) exp = "(a,b,((d,e)f,(h)g)c)root;\n" rooted = t.root_at('c') obs = str(rooted) self.assertEqual(obs, exp) def test_root_at_midpoint(self): """Root at the midpoint""" tree1 = self.TreeRoot for n in tree1.traverse(): n.length = 1 result = tree1.root_at_midpoint() self.assertEqual(result.distance(result.find('e')), 1.5) self.assertEqual(result.distance(result.find('g')), 2.5) exp_dist = tree1.tip_tip_distances() obs_dist = result.tip_tip_distances() self.assertEqual(obs_dist, exp_dist) def test_root_at_midpoint_no_lengths(self): # should get same tree back (a copy) nwk = '(a,b)c;\n' t = TreeNode.read(io.StringIO(nwk)) obs = t.root_at_midpoint() self.assertEqual(str(obs), nwk) def test_root_at_midpoint_tie(self): nwk = "(((a:1,b:1)c:2,(d:3,e:4)f:5),g:1)root;" t = TreeNode.read(io.StringIO(nwk)) exp = "((d:3,e:4)f:2,((a:1,b:1)c:2,(g:1)):3)root;" texp = TreeNode.read(io.StringIO(exp)) obs = t.root_at_midpoint() for o, e in zip(obs.traverse(), texp.traverse()): self.assertEqual(o.name, e.name) self.assertEqual(o.length, e.length) def test_compare_subsets(self): """compare_subsets should return the fraction of shared subsets""" t = TreeNode.read(io.StringIO('((H,G),(R,M));')) t2 = TreeNode.read(io.StringIO('(((H,G),R),M);')) t4 = TreeNode.read(io.StringIO('(((H,G),(O,R)),X);')) result = t.compare_subsets(t) self.assertEqual(result, 0) result = t2.compare_subsets(t2) self.assertEqual(result, 0) result = t.compare_subsets(t2) self.assertEqual(result, 0.5) result = t.compare_subsets(t4) self.assertEqual(result, 1 - 2. / 5) result = t.compare_subsets(t4, exclude_absent_taxa=True) self.assertEqual(result, 1 - 2. / 3) result = t.compare_subsets(self.TreeRoot, exclude_absent_taxa=True) self.assertEqual(result, 1) result = t.compare_subsets(self.TreeRoot) self.assertEqual(result, 1) def test_compare_rfd(self): """compare_rfd should return the Robinson Foulds distance""" t = TreeNode.read(io.StringIO('((H,G),(R,M));')) t2 = TreeNode.read(io.StringIO('(((H,G),R),M);')) t4 = TreeNode.read(io.StringIO('(((H,G),(O,R)),X);')) obs = t.compare_rfd(t2) exp = 2.0 self.assertEqual(obs, exp) self.assertEqual(t.compare_rfd(t2), t2.compare_rfd(t)) obs = t.compare_rfd(t2, proportion=True) exp = 0.5 self.assertEqual(obs, exp) with self.assertRaises(ValueError): t.compare_rfd(t4) def test_assign_ids(self): """Assign IDs to the tree""" t1 = TreeNode.read(io.StringIO("(((a,b),c),(e,f),(g));")) t2 = TreeNode.read(io.StringIO("(((a,b),c),(e,f),(g));")) t3 = TreeNode.read(io.StringIO("((g),(e,f),(c,(a,b)));")) t1_copy = t1.copy() t1.assign_ids() t2.assign_ids() t3.assign_ids() t1_copy.assign_ids() self.assertEqual([(n.name, n.id) for n in t1.traverse()], [(n.name, n.id) for n in t2.traverse()]) self.assertEqual([(n.name, n.id) for n in t1.traverse()], [(n.name, n.id) for n in t1_copy.traverse()]) self.assertNotEqual([(n.name, n.id) for n in t1.traverse()], [(n.name, n.id) for n in t3.traverse()]) def test_assign_ids_index_tree(self): """assign_ids and index_tree should assign the same IDs""" t1 = TreeNode.read(io.StringIO('(((a,b),c),(d,e));')) t2 = TreeNode.read(io.StringIO('(((a,b),(c,d)),(e,f));')) t3 = TreeNode.read(io.StringIO('(((a,b,c),(d)),(e,f));')) t1_copy = t1.copy() t2_copy = t2.copy() t3_copy = t3.copy() t1.assign_ids() t1_copy.index_tree() t2.assign_ids() t2_copy.index_tree() t3.assign_ids() t3_copy.index_tree() self.assertEqual([n.id for n in t1.traverse()], [n.id for n in t1_copy.traverse()]) self.assertEqual([n.id for n in t2.traverse()], [n.id for n in t2_copy.traverse()]) self.assertEqual([n.id for n in t3.traverse()], [n.id for n in t3_copy.traverse()]) def test_unrooted_deepcopy(self): """Do an unrooted_copy""" t = TreeNode.read(io.StringIO("((a,(b,c)d)e,(f,g)h)i;")) exp = "(b,c,(a,((f,g)h)e)d)root;\n" obs = t.find('d').unrooted_deepcopy() self.assertEqual(str(obs), exp) t_ids = {id(n) for n in t.traverse()} obs_ids = {id(n) for n in obs.traverse()} self.assertEqual(t_ids.intersection(obs_ids), set()) def test_descending_branch_length_bug_1847(self): tr = TreeNode.read(io.StringIO( "(((A:.1,B:1.2)C:.6,(D:.9,E:.6)F:.9)G:2.4,(H:.4,I:.5)J:1.3)K;")) tr.length = 1 tdbl = tr.descending_branch_length() npt.assert_almost_equal(tdbl, 8.9) def test_descending_branch_length(self): """Calculate descending branch_length""" tr = TreeNode.read(io.StringIO( "(((A:.1,B:1.2)C:.6,(D:.9,E:.6)F:.9)G:2.4,(H:.4,I:.5)J:1.3)K;")) tdbl = tr.descending_branch_length() sdbl = tr.descending_branch_length(['A', 'E']) npt.assert_almost_equal(tdbl, 8.9) npt.assert_almost_equal(sdbl, 2.2) self.assertRaises(ValueError, tr.descending_branch_length, ['A', 'DNE']) self.assertRaises(ValueError, tr.descending_branch_length, ['A', 'C']) tr = TreeNode.read(io.StringIO( "(((A,B:1.2)C:.6,(D:.9,E:.6)F:.9)G:2.4,(H:.4,I:.5)J:1.3)K;")) tdbl = tr.descending_branch_length() npt.assert_almost_equal(tdbl, 8.8) tr = TreeNode.read(io.StringIO( "(((A,B:1.2)C:.6,(D:.9,E:.6)F)G:2.4,(H:.4,I:.5)J:1.3)K;")) tdbl = tr.descending_branch_length() npt.assert_almost_equal(tdbl, 7.9) tr = TreeNode.read(io.StringIO( "(((A,B:1.2)C:.6,(D:.9,E:.6)F)G:2.4,(H:.4,I:.5)J:1.3)K;")) tdbl = tr.descending_branch_length(['A', 'D', 'E']) npt.assert_almost_equal(tdbl, 2.1) tr = TreeNode.read(io.StringIO( "(((A,B:1.2)C:.6,(D:.9,E:.6)F:.9)G:2.4,(H:.4,I:.5)J:1.3)K;")) tdbl = tr.descending_branch_length(['I', 'D', 'E']) npt.assert_almost_equal(tdbl, 6.6) # test with a situation where we have unnamed internal nodes tr = TreeNode.read(io.StringIO( "(((A,B:1.2):.6,(D:.9,E:.6)F):2.4,(H:.4,I:.5)J:1.3);")) tdbl = tr.descending_branch_length() npt.assert_almost_equal(tdbl, 7.9) def test_to_array(self): """Convert a tree to arrays""" t = TreeNode.read(io.StringIO( '(((a:1,b:2,c:3)x:4,(d:5)y:6)z:7,(e:8,f:9)z:10);')) id_index, child_index = t.index_tree() arrayed = t.to_array() self.assertEqual(id_index, arrayed['id_index']) npt.assert_equal(child_index, arrayed['child_index']) exp = np.array([1, 2, 3, 5, 4, 6, 8, 9, 7, 10, np.nan]) obs = arrayed['length'] npt.assert_equal(obs, exp) exp = np.array(['a', 'b', 'c', 'd', 'x', 'y', 'e', 'f', 'z', 'z', None]) obs = arrayed['name'] npt.assert_equal(obs, exp) exp = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) obs = arrayed['id'] npt.assert_equal(obs, exp) def test_to_array_attrs(self): t = TreeNode.read(io.StringIO( '(((a:1,b:2,c:3)x:4,(d:5)y:6)z:7,(e:8,f:9)z:10);')) id_index, child_index = t.index_tree() arrayed = t.to_array(attrs=[('name', object)]) # should only have id_index, child_index, and name since we specified # attrs self.assertEqual(len(arrayed), 3) self.assertEqual(id_index, arrayed['id_index']) npt.assert_equal(child_index, arrayed['child_index']) exp = np.array(['a', 'b', 'c', 'd', 'x', 'y', 'e', 'f', 'z', 'z', None]) obs = arrayed['name'] npt.assert_equal(obs, exp) # invalid attrs with self.assertRaises(AttributeError): t.to_array(attrs=[('name', object), ('brofist', int)]) def test_to_array_nan_length_value(self): t = TreeNode.read(io.StringIO("((a:1, b:2)c:3)root;")) indexed = t.to_array(nan_length_value=None) npt.assert_equal(indexed['length'], np.array([1, 2, 3, np.nan], dtype=float)) indexed = t.to_array(nan_length_value=0.0) npt.assert_equal(indexed['length'], np.array([1, 2, 3, 0.0], dtype=float)) indexed = t.to_array(nan_length_value=42.0) npt.assert_equal(indexed['length'], np.array([1, 2, 3, 42.0], dtype=float)) t = TreeNode.read(io.StringIO("((a:1, b:2)c:3)root:4;")) indexed = t.to_array(nan_length_value=42.0) npt.assert_equal(indexed['length'], np.array([1, 2, 3, 4], dtype=float)) t = TreeNode.read(io.StringIO("((a:1, b:2)c)root;")) indexed = t.to_array(nan_length_value=42.0) npt.assert_equal(indexed['length'], np.array([1, 2, 42.0, 42.0], dtype=float)) def test_from_taxonomy(self): input_lineages = {'1': ['a', 'b', 'c', 'd', 'e', 'f', 'g'], '2': ['a', 'b', 'c', None, None, 'x', 'y'], '3': ['h', 'i', 'j', 'k', 'l', 'm', 'n'], '4': ['h', 'i', 'j', 'k', 'l', 'm', 'q'], '5': ['h', 'i', 'j', 'k', 'l', 'm', 'n']} exp = TreeNode.read(io.StringIO( "((((((((1)g)f)e)d,((((2)y)x)))c)b)a," "(((((((3,5)n,(4)q)m)l)k)j)i)h);")) root = TreeNode.from_taxonomy(input_lineages.items()) self.assertIs(type(root), TreeNode) self.assertEqual(root.compare_subsets(exp), 0.0) root = TreeNodeSubclass.from_taxonomy(input_lineages.items()) self.assertIs(type(root), TreeNodeSubclass) def test_to_taxonomy(self): input_lineages = {'1': ['a', 'b', 'c', 'd', 'e', 'f', 'g'], '2': ['a', 'b', 'c', None, None, 'x', 'y'], '3': ['h', 'i', 'j', 'k', 'l', 'm', 'n'], '4': ['h', 'i', 'j', 'k', 'l', 'm', 'q'], '5': ['h', 'i', 'j', 'k', 'l', 'm', 'n']} tree = TreeNode.from_taxonomy(input_lineages.items()) exp = sorted(input_lineages.items()) obs = [(n.name, lin) for n, lin in tree.to_taxonomy(allow_empty=True)] self.assertEqual(sorted(obs), exp) def test_to_taxonomy_filter(self): input_lineages = {'1': ['a', 'b', 'c', 'd', 'e', 'f', 'g'], '2': ['a', 'b', 'c', None, None, 'x', 'y'], '3': ['h', 'i', 'j', 'k', 'l'], # test jagged '4': ['h', 'i', 'j', 'k', 'l', 'm', 'q'], '5': ['h', 'i', 'j', 'k', 'l', 'm', 'n']} tree = TreeNode.from_taxonomy(input_lineages.items()) def f(node, lin): return 'k' in lin or 'x' in lin exp = [('2', ['a', 'b', 'c', 'x', 'y']), ('3', ['h', 'i', 'j', 'k', 'l']), ('4', ['h', 'i', 'j', 'k', 'l', 'm', 'q']), ('5', ['h', 'i', 'j', 'k', 'l', 'm', 'n'])] obs = [(n.name, lin) for n, lin in tree.to_taxonomy(filter_f=f)] self.assertEqual(sorted(obs), exp) def test_linkage_matrix(self): # Ensure matches: http://www.southampton.ac.uk/~re1u06/teaching/upgma/ id_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G'] linkage = np.asarray([[1.0, 5.0, 1.0, 2.0], [0.0, 3.0, 8.0, 2.0], [6.0, 7.0, 12.5, 3.0], [8.0, 9.0, 16.5, 5.0], [2.0, 10.0, 29.0, 6.0], [4.0, 11.0, 34.0, 7.0]]) tree = TreeNode.from_linkage_matrix(linkage, id_list) self.assertIs(type(tree), TreeNode) self.assertEqual("(E:17.0,(C:14.5,((A:4.0,D:4.0):4.25,(G:6.25,(B:0.5," "F:0.5):5.75):2.0):6.25):2.5);\n", str(tree)) tree = TreeNodeSubclass.from_linkage_matrix(linkage, id_list) self.assertIs(type(tree), TreeNodeSubclass) def test_shuffle_invalid_iter(self): shuffler = self.simple_t.shuffle(n=-1) with self.assertRaises(ValueError): next(shuffler) def test_shuffle_n_2(self): exp = ["((a,b)i1,(d,c)i2)root;\n", "((a,b)i1,(c,d)i2)root;\n", "((a,b)i1,(d,c)i2)root;\n", "((a,b)i1,(c,d)i2)root;\n", "((a,b)i1,(d,c)i2)root;\n"] obs_g = self.simple_t.shuffle(k=2, shuffle_f=self.rev_f, n=np.inf) obs = [str(next(obs_g)) for i in range(5)] self.assertEqual(obs, exp) def test_shuffle_n_none(self): exp = ["((d,c)i1,(b,a)i2)root;\n", "((a,b)i1,(c,d)i2)root;\n", "((d,c)i1,(b,a)i2)root;\n", "((a,b)i1,(c,d)i2)root;\n"] obs_g = self.simple_t.shuffle(shuffle_f=self.rev_f, n=4) obs = [str(next(obs_g)) for i in range(4)] self.assertEqual(obs, exp) def test_shuffle_complex(self): exp = ["(((a,b)int1,(x,y,(w,z)int2,(f,e)int3)int4),(d,c)int5);\n", "(((a,b)int1,(x,y,(w,z)int2,(c,d)int3)int4),(e,f)int5);\n", "(((a,b)int1,(x,y,(w,z)int2,(f,e)int3)int4),(d,c)int5);\n", "(((a,b)int1,(x,y,(w,z)int2,(c,d)int3)int4),(e,f)int5);\n"] obs_g = self.complex_tree.shuffle(shuffle_f=self.rev_f, names=['c', 'd', 'e', 'f'], n=4) obs = [str(next(obs_g)) for i in range(4)] self.assertEqual(obs, exp) def test_shuffle_names(self): exp = ["((c,a)i1,(b,d)i2)root;\n", "((b,c)i1,(a,d)i2)root;\n", "((a,b)i1,(c,d)i2)root;\n", "((c,a)i1,(b,d)i2)root;\n"] obs_g = self.simple_t.shuffle(names=['a', 'b', 'c'], shuffle_f=self.rotate_f, n=np.inf) obs = [str(next(obs_g)) for i in range(4)] self.assertEqual(obs, exp) def test_shuffle_raises(self): with self.assertRaises(ValueError): next(self.simple_t.shuffle(k=1)) with self.assertRaises(ValueError): next(self.simple_t.shuffle(k=5, names=['a', 'b'])) with self.assertRaises(MissingNodeError): next(self.simple_t.shuffle(names=['x', 'y'])) def test_assign_supports(self): """Extract support values of internal nodes.""" # test nodes with support values alone as labels tree = TreeNode.read(['((a,b)75,(c,d)90);']) tree.assign_supports() node1, node2 = tree.children # check if internal nodes are assigned correct support values self.assertEqual(node1.support, 75) self.assertEqual(node2.support, 90) # check if original node names are cleared self.assertIsNone(node1.name) self.assertIsNone(node2.name) # check if support values are not assigned to root and tips self.assertIsNone(tree.support) for taxon in ('a', 'b', 'c', 'd'): self.assertIsNone(tree.find(taxon).support) # test nodes with support values and branch lengths tree = TreeNode.read(['((a,b)0.85:1.23,(c,d)0.95:4.56);']) tree.assign_supports() node1, node2 = tree.children self.assertEqual(node1.support, 0.85) self.assertEqual(node2.support, 0.95) # test whether integer or float support values can be correctly parsed tree = TreeNode.read(['((a,b)75,(c,d)80.0,(e,f)97.5,(g,h)0.95);']) tree.assign_supports() node1, node2, node3, node4 = tree.children self.assertTrue(isinstance(node1.support, int)) self.assertEqual(node1.support, 75) self.assertTrue(isinstance(node2.support, float)) self.assertEqual(node2.support, 80.0) self.assertTrue(isinstance(node3.support, float)) self.assertEqual(node3.support, 97.5) self.assertTrue(isinstance(node4.support, float)) self.assertEqual(node4.support, 0.95) # test support values that are negative or scientific notation (not a # common scenario but can happen) tree = TreeNode.read(['((a,b)-1.23,(c,d)1.23e-4);']) tree.assign_supports() node1, node2 = tree.children self.assertEqual(node1.support, -1.23) self.assertEqual(node2.support, 0.000123) # test nodes with support and extra label tree = TreeNode.read(['((a,b)\'80:X\',(c,d)\'60:Y\');']) tree.assign_supports() node1, node2 = tree.children self.assertEqual(node1.support, 80) self.assertEqual(node1.name, 'X') self.assertEqual(node2.support, 60) self.assertEqual(node2.name, 'Y') # test nodes without label, with non-numeric label, and with branch # length only tree = TreeNode.read(['((a,b),(c,d)x,(e,f):1.0);']) tree.assign_supports() for node in tree.children: self.assertIsNone(node.support) def test_unpack(self): """Unpack an internal node.""" # test unpacking a node without branch length tree = TreeNode.read(['((c,d)a,(e,f)b);']) tree.find('b').unpack() exp = '((c,d)a,e,f);\n' self.assertEqual(str(tree), exp) # test unpacking a node with branch length tree = TreeNode.read(['((c:2.0,d:3.0)a:1.0,(e:2.0,f:1.0)b:2.0);']) tree.find('b').unpack() exp = '((c:2.0,d:3.0)a:1.0,e:4.0,f:3.0);' self.assertEqual(str(tree).rstrip(), exp) # test attempting to unpack root tree = TreeNode.read(['((d,e)b,(f,g)c)a;']) msg = 'Cannot unpack root.' with self.assertRaisesRegex(TreeError, msg): tree.find('a').unpack() # test attempting to unpack tip msg = 'Cannot unpack tip.' with self.assertRaisesRegex(TreeError, msg): tree.find('d').unpack() def test_unpack_by_func(self): """Unpack internal nodes of a tree by a function.""" # unpack internal nodes with branch length <= 1.0 def func(x): return x.length <= 1.0 # will unpack node 'a', but not tip 'e' # will add the branch length of 'a' to its child nodes 'c' and 'd' tree = TreeNode.read(['((c:2,d:3)a:1,(e:1,f:2)b:2);']) tree.unpack_by_func(func) exp = '((e:1.0,f:2.0)b:2.0,c:3.0,d:4.0);' self.assertEqual(str(tree).rstrip(), exp) # unpack internal nodes with branch length < 2.01 # will unpack both 'a' and 'b' tree = TreeNode.read(['((c:2,d:3)a:1,(e:1,f:2)b:2);']) tree.unpack_by_func(lambda x: x.length <= 2.0) exp = '(c:3.0,d:4.0,e:3.0,f:4.0);' self.assertEqual(str(tree).rstrip(), exp) # unpack two nested nodes 'a' and 'c' simultaneously tree = TreeNode.read(['(((e:3,f:2)c:1,d:3)a:1,b:4);']) tree.unpack_by_func(lambda x: x.length <= 2.0) exp = '(b:4.0,d:4.0,e:5.0,f:4.0);' self.assertEqual(str(tree).rstrip(), exp) # test a complicated scenario (unpacking nodes 'g', 'h' and 'm') def func(x): return x.length < 2.0 tree = TreeNode.read(['(((a:1.04,b:2.32,c:1.44)d:3.20,' '(e:3.91,f:2.47)g:1.21)h:1.75,' '(i:4.14,(j:2.06,k:1.58)l:3.32)m:0.77);']) tree.unpack_by_func(func) exp = ('((a:1.04,b:2.32,c:1.44)d:4.95,e:6.87,f:5.43,i:4.91,' '(j:2.06,k:1.58)l:4.09);') self.assertEqual(str(tree).rstrip(), exp) # unpack nodes with support < 75 def func(x): return x.support < 75 tree = TreeNode.read(['(((a,b)85,(c,d)78)75,(e,(f,g)64)80);']) tree.assign_supports() tree.unpack_by_func(func) exp = '(((a,b)85,(c,d)78)75,(e,f,g)80);' self.assertEqual(str(tree).rstrip(), exp) # unpack nodes with support < 85 tree = TreeNode.read(['(((a,b)85,(c,d)78)75,(e,(f,g)64)80);']) tree.assign_supports() tree.unpack_by_func(lambda x: x.support < 85) exp = '((a,b)85,c,d,e,f,g);' self.assertEqual(str(tree).rstrip(), exp) # unpack nodes with support < 0.95 tree = TreeNode.read(['(((a,b)0.97,(c,d)0.98)1.0,(e,(f,g)0.88)0.96);']) tree.assign_supports() tree.unpack_by_func(lambda x: x.support < 0.95) exp = '(((a,b)0.97,(c,d)0.98)1.0,(e,f,g)0.96);' self.assertEqual(str(tree).rstrip(), exp) # test a case where there are branch lengths, none support values and # node labels tree = TreeNode.read(['(((a:1.02,b:0.33)85:0.12,(c:0.86,d:2.23)' '70:3.02)75:0.95,(e:1.43,(f:1.69,g:1.92)64:0.20)' 'node:0.35)root;']) tree.assign_supports() tree.unpack_by_func(lambda x: x.support is not None and x.support < 75) exp = ('(((a:1.02,b:0.33)85:0.12,c:3.88,d:5.25)75:0.95,' '(e:1.43,f:1.89,g:2.12)node:0.35)root;') self.assertEqual(str(tree).rstrip(), exp) def test_from_taxdump(self): # same example as in skbio.io.format.taxdump nodes = pd.DataFrame([ [1, 1, 'no rank'], [2, 131567, 'superkingdom'], [543, 91347, 'family'], [548, 570, 'species'], [561, 543, 'genus'], [562, 561, 'species'], [570, 543, 'genus'], [620, 543, 'genus'], [622, 620, 'species'], [766, 28211, 'order'], [1224, 2, 'phylum'], [1236, 1224, 'class'], [28211, 1224, 'class'], [91347, 1236, 'order'], [118884, 1236, 'no rank'], [126792, 36549, 'species'], [131567, 1, 'no rank'], [585056, 562, 'no rank'], [1038927, 562, 'no rank'], [2580236, 488338, 'species']], columns=['tax_id', 'parent_tax_id', 'rank']).set_index('tax_id') names = pd.DataFrame([ [1, 'root', np.nan, 'scientific name'], [2, 'Bacteria', 'Bacteria ', 'scientific name'], [2, 'eubacteria', np.nan, 'genbank common name'], [543, 'Enterobacteriaceae', np.nan, 'scientific name'], [548, 'Klebsiella aerogenes', np.nan, 'scientific name'], [561, 'Escherichia', np.nan, 'scientific name'], [562, '"Bacillus coli" Migula 1895', np.nan, 'authority'], [562, 'Escherichia coli', np.nan, 'scientific name'], [562, 'Escherichia/Shigella coli', np.nan, 'equivalent name'], [570, 'Donovania', np.nan, 'synonym'], [570, 'Klebsiella', np.nan, 'scientific name'], [620, 'Shigella', np.nan, 'scientific name'], [622, 'Shigella dysenteriae', np.nan, 'scientific name'], [766, 'Rickettsiales', np.nan, 'scientific name'], [1224, 'Proteobacteria', np.nan, 'scientific name'], [1236, 'Gammaproteobacteria', np.nan, 'scientific name'], [28211, 'Alphaproteobacteria', np.nan, 'scientific name'], [91347, 'Enterobacterales', np.nan, 'scientific name'], [118884, 'unclassified Gammaproteobacteria', np.nan, 'scientific name'], [126792, 'Plasmid pPY113', np.nan, 'scientific name'], [131567, 'cellular organisms', np.nan, 'scientific name'], [585056, 'Escherichia coli UMN026', np.nan, 'scientific name'], [1038927, 'Escherichia coli O104:H4', np.nan, 'scientific name'], [2580236, 'synthetic Escherichia coli Syn61', np.nan, 'scientific name']], columns=['tax_id', 'name_txt', 'unique_name', 'name_class']).set_index('tax_id') # nodes without names (use tax_id as name) obs = TreeNode.from_taxdump(nodes) exp = ('(((((((((585056,1038927)562)561,(548)570,(622)620)543)91347,' '118884)1236,(766)28211)1224)2)131567)1;') self.assertEqual(str(obs).rstrip(), exp) self.assertEqual(obs.count(), 18) self.assertEqual(obs.count(tips=True), 6) # default scenario (nodes and names) obs = TreeNode.from_taxdump(nodes, names) # check tree is in same size self.assertEqual(obs.count(), 18) self.assertEqual(obs.count(tips=True), 6) # check id, name and rank are correctly set at root self.assertEqual(obs.id, 1) self.assertEqual(obs.name, 'root') self.assertEqual(obs.rank, 'no rank') # check an internal node node = obs.find('Enterobacteriaceae') self.assertEqual(node.id, 543) self.assertEqual(node.rank, 'family') # check its children (which should preserve input order) self.assertEqual(len(node.children), 3) self.assertListEqual([x.name for x in node.children], [ 'Escherichia', 'Klebsiella', 'Shigella']) # check that non-scientific name isn't used with self.assertRaises(MissingNodeError): obs.find('Donovania') # name as a dictionary names = names[names['name_class'] == 'scientific name'][ 'name_txt'].to_dict() obs = TreeNode.from_taxdump(nodes, names) self.assertEqual(obs.count(), 18) self.assertEqual(obs.name, 'root') self.assertEqual(obs.find('Enterobacteriaceae').id, 543) # nodes has no top level nodes = pd.DataFrame([ [2, 1, 'A'], [3, 2, 'B'], [1, 3, 'C']], columns=['tax_id', 'parent_tax_id', 'rank']).set_index('tax_id') with self.assertRaises(ValueError) as ctx: TreeNode.from_taxdump(nodes) self.assertEqual(str(ctx.exception), 'There is no top-level node.') # nodes has more than one top level nodes = pd.DataFrame([ [1, 1, 'A'], [2, 2, 'B'], [3, 3, 'C']], columns=['tax_id', 'parent_tax_id', 'rank']).set_index('tax_id') with self.assertRaises(ValueError) as ctx: TreeNode.from_taxdump(nodes) self.assertEqual(str( ctx.exception), 'There are more than one top-level node.') sample = """ ( ( xyz:0.28124, ( def:0.24498, mno:0.03627) :0.17710) :0.04870, abc:0.05925, ( ghi:0.06914, jkl:0.13776) :0.09853); """ node_data_sample = """ ( ( xyz:0.28124, ( def:0.24498, mno:0.03627) 'A':0.17710) B:0.04870, abc:0.05925, ( ghi:0.06914, jkl:0.13776) C:0.09853); """ minimal = "();" no_names = "((,),(,));" missing_tip_name = "((a,b),(c,));" empty = '();' single = '(abc:3);' double = '(abc:3, def:4);' onenest = '(abc:3, (def:4, ghi:5):6 );' nodedata = '(abc:3, (def:4, ghi:5)jkl:6 );' exp_ascii_art_three_children = r""" /-a | ---------| /-b | | \--------|--c | \-d""" if __name__ == '__main__': main() scikit-bio-0.5.9/skbio/util/000077500000000000000000000000001446255456000156615ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/util/__init__.py000066400000000000000000000035151446255456000177760ustar00rootroot00000000000000""" Utility functionality (:mod:`skbio.util`) ========================================= .. currentmodule:: skbio.util This package provides general exception/warning definitions used throughout scikit-bio, as well as various utility functionality, including I/O and unit-testing convenience functions. Testing functionality --------------------- Common functionality to support testing in skbio. .. autosummary:: :toctree: generated/ get_data_path assert_ordination_results_equal assert_data_frame_almost_equal Miscellaneous functionality --------------------------- Generally useful functionality that doesn't fit in more specific locations. .. autosummary:: :toctree: generated/ cardinal_to_ordinal find_duplicates safe_md5 classproperty Warnings -------- .. autosummary:: :toctree: generated/ EfficiencyWarning RepresentationWarning """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- from ._warning import EfficiencyWarning, RepresentationWarning, SkbioWarning from ._misc import cardinal_to_ordinal, find_duplicates, safe_md5 from ._testing import (get_data_path, assert_ordination_results_equal, assert_data_frame_almost_equal, pytestrunner) from ._decorator import classproperty __all__ = ['SkbioWarning', 'EfficiencyWarning', 'RepresentationWarning', 'cardinal_to_ordinal', 'find_duplicates', 'safe_md5', 'get_data_path', 'assert_ordination_results_equal', 'assert_data_frame_almost_equal', 'classproperty', 'pytestrunner'] scikit-bio-0.5.9/skbio/util/_decorator.py000066400000000000000000000276241446255456000203670ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import warnings import textwrap import decorator from ._exception import OverrideError from ._warning import DeprecationWarning as SkbioDeprecationWarning class _state_decorator: """ Base class for decorators of all public functionality. """ _required_kwargs = () def _get_indentation_level(self, docstring_lines, default_existing_docstring=4, default_no_existing_docstring=0): """ Determine the level of indentation of the docstring to match it. The indented content after the first line of a docstring can differ based on the nesting of the functionality being documented. For example, a top-level function may have its "Parameters" section indented four-spaces, but a method nested under a class may have its "Parameters" section indented eight spaces. This function determines the indentation level of the first non-whitespace line following the initial summary line. """ # if there is no existing docstring, return the corresponding default if len(docstring_lines) == 0: return default_no_existing_docstring # if there is an existing docstring with only a single line, return # the corresponding default if len(docstring_lines) == 1: return default_existing_docstring # find the first non-blank line (after the initial summary line) and # return the number of leading spaces on that line for line in docstring_lines[1:]: if len(line.strip()) == 0: # ignore blank lines continue else: return len(line) - len(line.lstrip()) # if there is an existing docstring with only a single non-whitespace # line, return the corresponding default return default_existing_docstring def _update_docstring(self, docstring, state_desc, state_desc_prefix='State: '): # Hande the case of no initial docstring if docstring is None: return "%s%s" % (state_desc_prefix, state_desc) docstring_lines = docstring.split('\n') docstring_content_indentation = \ self._get_indentation_level(docstring_lines) # wrap lines at 79 characters, accounting for the length of # docstring_content_indentation and start_desc_prefix len_state_desc_prefix = len(state_desc_prefix) wrap_at = 79 - (docstring_content_indentation + len_state_desc_prefix) state_desc_lines = textwrap.wrap(state_desc, wrap_at) # The first line of the state description should start with # state_desc_prefix, while the others should start with spaces to align # the text in this section. This is for consistency with numpydoc # formatting of deprecation notices, which are done using the note # Sphinx directive. state_desc_lines[0] = '%s%s%s' % (' ' * docstring_content_indentation, state_desc_prefix, state_desc_lines[0]) header_spaces = ' ' * (docstring_content_indentation + len_state_desc_prefix) for i, line in enumerate(state_desc_lines[1:], 1): state_desc_lines[i] = '%s%s' % (header_spaces, line) new_doc_lines = '\n'.join(state_desc_lines) docstring_lines[0] = '%s\n\n%s' % (docstring_lines[0], new_doc_lines) return '\n'.join(docstring_lines) def _validate_kwargs(self, **kwargs): for required_kwarg in self._required_kwargs: if required_kwarg not in kwargs: raise ValueError('%s decorator requires parameter: %s' % (self.__class__, required_kwarg)) class stable(_state_decorator): """ State decorator indicating stable functionality. Used to indicate that public functionality is considered ``stable``, meaning that its API will be backward compatible unless it is deprecated. Decorating functionality as stable will update its doc string to indicate the first version of scikit-bio when the functionality was considered stable. Parameters ---------- as_of : str First release version where functionality is considered to be stable. See Also -------- experimental deprecated Examples -------- >>> @stable(as_of='0.3.0') ... def f_stable(): ... \"\"\" An example stable function. ... \"\"\" ... pass >>> help(f_stable) Help on function f_stable in module skbio.util._decorator: f_stable() An example stable function. State: Stable as of 0.3.0. """ _required_kwargs = ('as_of', ) def __init__(self, *args, **kwargs): self._validate_kwargs(**kwargs) self.as_of = kwargs['as_of'] def __call__(self, func): state_desc = 'Stable as of %s.' % self.as_of func.__doc__ = self._update_docstring(func.__doc__, state_desc) return func class experimental(_state_decorator): """ State decorator indicating experimental functionality. Used to indicate that public functionality is considered experimental, meaning that its API is subject to change or removal with little or (rarely) no warning. Decorating functionality as experimental will update its doc string to indicate the first version of scikit-bio when the functionality was considered experimental. Parameters ---------- as_of : str First release version where feature is considered to be experimental. See Also -------- stable deprecated Examples -------- >>> @experimental(as_of='0.3.0') ... def f_experimental(): ... \"\"\" An example experimental function. ... \"\"\" ... pass >>> help(f_experimental) Help on function f_experimental in module skbio.util._decorator: f_experimental() An example experimental function. State: Experimental as of 0.3.0. """ _required_kwargs = ('as_of', ) def __init__(self, *args, **kwargs): self._validate_kwargs(**kwargs) self.as_of = kwargs['as_of'] def __call__(self, func): state_desc = 'Experimental as of %s.' % self.as_of func.__doc__ = self._update_docstring(func.__doc__, state_desc) return func class deprecated(_state_decorator): """ State decorator indicating deprecated functionality. Used to indicate that a public class or function is deprecated, meaning that its API will be removed in a future version of scikit-bio. Decorating functionality as deprecated will update its doc string to indicate the first version of scikit-bio when the functionality was deprecated, the first version of scikit-bio when the functionality will no longer exist, and the reason for deprecation of the API. It will also cause calls to the API to raise a ``DeprecationWarning``. Parameters ---------- as_of : str First development version where feature is considered to be deprecated. until : str First release version where feature will no longer exist. reason : str Brief description of why the API is deprecated. See Also -------- stable experimental Examples -------- >>> @deprecated(as_of='0.3.0', until='0.3.3', ... reason='Use skbio.g().') ... def f_deprecated(x, verbose=False): ... \"\"\" An example deprecated function. ... \"\"\" ... pass >>> help(f_deprecated) Help on function f_deprecated in module skbio.util._decorator: f_deprecated(x, verbose=False) An example deprecated function. .. note:: Deprecated as of 0.3.0 for removal in 0.3.3. Use skbio.g(). """ _required_kwargs = ('as_of', 'until', 'reason') def __init__(self, *args, **kwargs): self._validate_kwargs(**kwargs) self.as_of = kwargs['as_of'] self.until = kwargs['until'] self.reason = kwargs['reason'] def __call__(self, func, *args, **kwargs): state_desc = 'Deprecated as of %s for removal in %s. %s' %\ (self.as_of, self.until, self.reason) func.__doc__ = self._update_docstring(func.__doc__, state_desc, state_desc_prefix='.. note:: ') def wrapped_f(*args, **kwargs): warnings.warn('%s is deprecated as of scikit-bio version %s, and ' 'will be removed in version %s. %s' % (func.__name__, self.as_of, self.until, self.reason), SkbioDeprecationWarning) # args[0] is the function being wrapped when this is called # after wrapping with decorator.decorator, but why??? return func(*args[1:], **kwargs) return decorator.decorator(wrapped_f, func) # Adapted from http://stackoverflow.com/a/8313042/579416 def overrides(interface_class): """Decorator for class-level members. Used to indicate that a member is being overridden from a specific parent class. If the member does not have a docstring, it will pull one from the parent class. When chaining decorators, this should be first as it is relatively nondestructive. Parameters ---------- interface_class : class The class which has a member overridden by the decorated member. Returns ------- function The function is not changed or replaced. Raises ------ OverrideError If the `interface_class` does not possess a member of the same name as the decorated member. """ def overrider(method): if method.__name__ not in dir(interface_class): raise OverrideError("%r is not present in parent class: %r." % (method.__name__, interface_class.__name__)) backup = classproperty.__get__ classproperty.__get__ = lambda x, y, z: x if method.__doc__ is None: method.__doc__ = getattr(interface_class, method.__name__).__doc__ classproperty.__get__ = backup return method return overrider class classproperty(property): """Decorator for class-level properties. Supports read access only. The property will be read-only within an instance. However, the property can always be redefined on the class, since Python classes are mutable. Parameters ---------- func : function Method to make a class property. Returns ------- property Decorated method. Raises ------ AttributeError If the property is set on an instance. """ def __init__(self, func): name = func.__name__ doc = func.__doc__ super(classproperty, self).__init__(classmethod(func)) self.__name__ = name self.__doc__ = doc def __get__(self, cls, owner): return self.fget.__get__(None, owner)() def __set__(self, obj, value): raise AttributeError("can't set attribute") class classonlymethod(classmethod): """Just like `classmethod`, but it can't be called on an instance.""" def __get__(self, obj, cls=None): if obj is not None: raise TypeError("Class-only method called on an instance. Use" " '%s.%s' instead." % (cls.__name__, self.__func__.__name__)) return super().__get__(obj, cls) scikit-bio-0.5.9/skbio/util/_exception.py000066400000000000000000000011771446255456000203760ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- class TestingUtilError(Exception): """Raised when an exception is needed to test exception handling.""" __test__ = False # prevent py-test from collecting it class OverrideError(AssertionError): """Raised when a property does not exist in the parent class.""" pass scikit-bio-0.5.9/skbio/util/_misc.py000066400000000000000000000127071446255456000173340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import hashlib import inspect from types import FunctionType from ._decorator import experimental def resolve_key(obj, key): """Resolve key given an object and key.""" if callable(key): return key(obj) elif hasattr(obj, 'metadata'): return obj.metadata[key] raise TypeError("Could not resolve key %r. Key must be callable or %s must" " have `metadata` attribute." % (key, obj.__class__.__name__)) def make_sentinel(name): return type(name, (), { '__repr__': lambda s: name, '__str__': lambda s: name, '__class__': None })() def find_sentinels(function, sentinel): params = inspect.signature(function).parameters return [name for name, param in params.items() if param.default is sentinel] class MiniRegistry(dict): def __call__(self, name): """Act as a decorator to register functions with self""" def decorator(func): self[name] = func return func return decorator def copy(self): """Useful for inheritance""" return self.__class__(super(MiniRegistry, self).copy()) def formatted_listing(self): """Produce an RST list with descriptions.""" if len(self) == 0: return "\tNone" else: return "\n".join(["\t%r\n\t %s" % (name, self[name].__doc__.split("\n")[0]) for name in sorted(self)]) def interpolate(self, obj, name): """Inject the formatted listing in the second blank line of `name`.""" f = getattr(obj, name) f2 = FunctionType(f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__) # Conveniently the original docstring is on f2, not the new ones if # inheritance is happening. I have no idea why. t = f2.__doc__.split("\n\n") t.insert(2, self.formatted_listing()) f2.__doc__ = "\n\n".join(t) setattr(obj, name, f2) def chunk_str(s, n, char): """Insert `char` character every `n` characters in string `s`. Canonically pronounced "chunkster". """ # Modified from http://stackoverflow.com/a/312464/3776794 if n < 1: raise ValueError( "Cannot split string into chunks with n=%d. n must be >= 1." % n) return char.join((s[i:i+n] for i in range(0, len(s), n))) @experimental(as_of="0.4.0") def cardinal_to_ordinal(n): """Return ordinal string version of cardinal int `n`. Parameters ---------- n : int Cardinal to convert to ordinal. Must be >= 0. Returns ------- str Ordinal version of cardinal `n`. Raises ------ ValueError If `n` is less than 0. Notes ----- This function can be useful when writing human-readable error messages. Examples -------- >>> from skbio.util import cardinal_to_ordinal >>> cardinal_to_ordinal(0) '0th' >>> cardinal_to_ordinal(1) '1st' >>> cardinal_to_ordinal(2) '2nd' >>> cardinal_to_ordinal(3) '3rd' """ # Taken and modified from http://stackoverflow.com/a/20007730/3776794 # Originally from http://codegolf.stackexchange.com/a/4712 by Gareth if n < 0: raise ValueError("Cannot convert negative integer %d to ordinal " "string." % n) return "%d%s" % (n, "tsnrhtdd"[(n//10 % 10 != 1)*(n % 10 < 4)*n % 10::4]) @experimental(as_of="0.4.0") def safe_md5(open_file, block_size=2 ** 20): """Computes an md5 sum without loading the file into memory Parameters ---------- open_file : file object open file handle to the archive to compute the checksum. It must be open as a binary file block_size : int, optional size of the block taken per iteration Returns ------- md5 : md5 object from the hashlib module object with the loaded file Notes ----- This method is based on the answers given in: http://stackoverflow.com/a/1131255/379593 Examples -------- >>> from io import BytesIO >>> from skbio.util import safe_md5 >>> fd = BytesIO(b"foo bar baz") # open file like object >>> x = safe_md5(fd) >>> x.hexdigest() 'ab07acbb1e496801937adfa772424bf7' >>> fd.close() """ md5 = hashlib.md5() data = True while data: data = open_file.read(block_size) if data: md5.update(data) return md5 @experimental(as_of="0.4.0") def find_duplicates(iterable): """Find duplicate elements in an iterable. Parameters ---------- iterable : iterable Iterable to be searched for duplicates (i.e., elements that are repeated). Returns ------- set Repeated elements in `iterable`. """ # modified from qiita.qiita_db.util.find_repeated # https://github.com/biocore/qiita # see licenses/qiita.txt seen, repeated = set(), set() for e in iterable: if e in seen: repeated.add(e) else: seen.add(e) return repeated scikit-bio-0.5.9/skbio/util/_testing.py000066400000000000000000000327031446255456000200540ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import inspect import os import sys import numpy as np import numpy.testing as npt import pandas.testing as pdt from scipy.spatial.distance import pdist from ._decorator import experimental class ReallyEqualMixin: """Use this for testing __eq__/__ne__. Taken and modified from the following public domain code: https://ludios.org/testing-your-eq-ne-cmp/ """ def assertReallyEqual(self, a, b): # assertEqual first, because it will have a good message if the # assertion fails. self.assertEqual(a, b) self.assertEqual(b, a) self.assertTrue(a == b) self.assertTrue(b == a) self.assertFalse(a != b) self.assertFalse(b != a) def assertReallyNotEqual(self, a, b): # assertNotEqual first, because it will have a good message if the # assertion fails. self.assertNotEqual(a, b) self.assertNotEqual(b, a) self.assertFalse(a == b) self.assertFalse(b == a) self.assertTrue(a != b) self.assertTrue(b != a) @experimental(as_of="0.4.0") def get_data_path(fn, subfolder='data'): """Return path to filename ``fn`` in the data folder. During testing it is often necessary to load data files. This function returns the full path to files in the ``data`` subfolder by default. Parameters ---------- fn : str File name. subfolder : str, defaults to ``data`` Name of the subfolder that contains the data. Returns ------- str Inferred absolute path to the test data for the module where ``get_data_path(fn)`` is called. Notes ----- The requested path may not point to an existing file, as its existence is not checked. """ # getouterframes returns a list of tuples: the second tuple # contains info about the caller, and the second element is its # filename callers_filename = inspect.getouterframes(inspect.currentframe())[1][1] path = os.path.dirname(os.path.abspath(callers_filename)) data_path = os.path.join(path, subfolder, fn) return data_path @experimental(as_of="0.4.0") def assert_ordination_results_equal(left, right, ignore_method_names=False, ignore_axis_labels=False, ignore_directionality=False, decimal=7): """Assert that ordination results objects are equal. This is a helper function intended to be used in unit tests that need to compare ``OrdinationResults`` objects. Parameters ---------- left, right : OrdinationResults Ordination results to be compared for equality. ignore_method_names : bool, optional Ignore differences in `short_method_name` and `long_method_name`. ignore_axis_labels : bool, optional Ignore differences in axis labels (i.e., column labels). ignore_directionality : bool, optional Ignore differences in directionality (i.e., differences in signs) for attributes `samples`, `features` and `biplot_scores`. Raises ------ AssertionError If the two objects are not equal. """ npt.assert_equal(type(left) is type(right), True) if not ignore_method_names: npt.assert_equal(left.short_method_name, right.short_method_name) npt.assert_equal(left.long_method_name, right.long_method_name) _assert_frame_dists_equal(left.samples, right.samples, ignore_columns=ignore_axis_labels, ignore_directionality=ignore_directionality, decimal=decimal) _assert_frame_dists_equal(left.features, right.features, ignore_columns=ignore_axis_labels, ignore_directionality=ignore_directionality, decimal=decimal) _assert_frame_dists_equal(left.biplot_scores, right.biplot_scores, ignore_columns=ignore_axis_labels, ignore_directionality=ignore_directionality, decimal=decimal) _assert_frame_dists_equal(left.sample_constraints, right.sample_constraints, ignore_columns=ignore_axis_labels, ignore_directionality=ignore_directionality, decimal=decimal) _assert_series_equal(left.eigvals, right.eigvals, ignore_axis_labels, decimal=decimal) _assert_series_equal(left.proportion_explained, right.proportion_explained, ignore_axis_labels, decimal=decimal) def _assert_series_equal(left_s, right_s, ignore_index=False, decimal=7): # assert_series_equal doesn't like None... if left_s is None or right_s is None: assert left_s is None and right_s is None else: npt.assert_almost_equal(left_s.values, right_s.values, decimal=decimal) if not ignore_index: pdt.assert_index_equal(left_s.index, right_s.index) def _assert_frame_dists_equal(left_df, right_df, ignore_index=False, ignore_columns=False, ignore_directionality=False, decimal=7): if left_df is None or right_df is None: assert left_df is None and right_df is None else: left_values = left_df.values right_values = right_df.values left_dists = pdist(left_values) right_dists = pdist(right_values) npt.assert_almost_equal(left_dists, right_dists, decimal=decimal) if not ignore_index: pdt.assert_index_equal(left_df.index, right_df.index) if not ignore_columns: pdt.assert_index_equal(left_df.columns, right_df.columns) def _assert_frame_equal(left_df, right_df, ignore_index=False, ignore_columns=False, ignore_directionality=False, decimal=7): # assert_frame_equal doesn't like None... if left_df is None or right_df is None: assert left_df is None and right_df is None else: left_values = left_df.values right_values = right_df.values if ignore_directionality: left_values, right_values = _normalize_signs(left_values, right_values) npt.assert_almost_equal(left_values, right_values, decimal=decimal) if not ignore_index: pdt.assert_index_equal(left_df.index, right_df.index) if not ignore_columns: pdt.assert_index_equal(left_df.columns, right_df.columns) def _normalize_signs(arr1, arr2): """Change column signs so that "column" and "-column" compare equal. This is needed because results of eigenproblmes can have signs flipped, but they're still right. Notes ===== This function tries hard to make sure that, if you find "column" and "-column" almost equal, calling a function like np.allclose to compare them after calling `normalize_signs` succeeds. To do so, it distinguishes two cases for every column: - It can be all almost equal to 0 (this includes a column of zeros). - Otherwise, it has a value that isn't close to 0. In the first case, no sign needs to be flipped. I.e., for |epsilon| small, np.allclose(-epsilon, 0) is true if and only if np.allclose(epsilon, 0) is. In the second case, the function finds the number in the column whose absolute value is largest. Then, it compares its sign with the number found in the same index, but in the other array, and flips the sign of the column as needed. """ # Let's convert everyting to floating point numbers (it's # reasonable to assume that eigenvectors will already be floating # point numbers). This is necessary because np.array(1) / # np.array(0) != np.array(1.) / np.array(0.) arr1 = np.asarray(arr1, dtype=np.float64) arr2 = np.asarray(arr2, dtype=np.float64) if arr1.shape != arr2.shape: raise ValueError( "Arrays must have the same shape ({0} vs {1}).".format(arr1.shape, arr2.shape) ) # To avoid issues around zero, we'll compare signs of the values # with highest absolute value max_idx = np.abs(arr1).argmax(axis=0) max_arr1 = arr1[max_idx, range(arr1.shape[1])] max_arr2 = arr2[max_idx, range(arr2.shape[1])] sign_arr1 = np.sign(max_arr1) sign_arr2 = np.sign(max_arr2) # Store current warnings, and ignore division by zero (like 1. / # 0.) and invalid operations (like 0. / 0.) wrn = np.seterr(invalid='ignore', divide='ignore') differences = sign_arr1 / sign_arr2 # The values in `differences` can be: # 1 -> equal signs # -1 -> diff signs # Or nan (0/0), inf (nonzero/0), 0 (0/nonzero) np.seterr(**wrn) # Now let's deal with cases where `differences != \pm 1` special_cases = (~np.isfinite(differences)) | (differences == 0) # In any of these cases, the sign of the column doesn't matter, so # let's just keep it differences[special_cases] = 1 return arr1 * differences, arr2 @experimental(as_of="0.4.0") def assert_data_frame_almost_equal(left, right, rtol=1e-5): """Raise AssertionError if ``pd.DataFrame`` objects are not "almost equal". Wrapper of ``pd.util.testing.assert_frame_equal``. Floating point values are considered "almost equal" if they are within a threshold defined by ``assert_frame_equal``. This wrapper uses a number of checks that are turned off by default in ``assert_frame_equal`` in order to perform stricter comparisons (for example, ensuring the index and column types are the same). It also does not consider empty ``pd.DataFrame`` objects equal if they have a different index. Other notes: * Index (row) and column ordering must be the same for objects to be equal. * NaNs (``np.nan``) in the same locations are considered equal. This is a helper function intended to be used in unit tests that need to compare ``pd.DataFrame`` objects. Parameters ---------- left, right : pd.DataFrame ``pd.DataFrame`` objects to compare. Raises ------ AssertionError If `left` and `right` are not "almost equal". See Also -------- pandas.util.testing.assert_frame_equal """ # pass all kwargs to ensure this function has consistent behavior even if # `assert_frame_equal`'s defaults change pdt.assert_frame_equal(left, right, check_dtype=True, check_index_type=True, check_column_type=True, check_frame_type=True, check_names=True, by_blocks=False, check_exact=False, rtol=rtol) # this check ensures that empty DataFrames with different indices do not # compare equal. exact=True specifies that the type of the indices must be # exactly the same assert_index_equal(left.index, right.index) def assert_series_almost_equal(left, right): # pass all kwargs to ensure this function has consistent behavior even if # `assert_series_equal`'s defaults change pdt.assert_series_equal(left, right, check_dtype=True, check_index_type=True, check_series_type=True, check_names=True, check_exact=False, check_datetimelike_compat=False, obj='Series') # this check ensures that empty Series with different indices do not # compare equal. assert_index_equal(left.index, right.index) def assert_index_equal(a, b): pdt.assert_index_equal(a, b, exact=True, check_names=True, check_exact=True) def pytestrunner(): try: import numpy try: # NumPy 1.14 changed repr output breaking our doctests, # request the legacy 1.13 style numpy.set_printoptions(legacy="1.13") except TypeError: # Old Numpy, output should be fine as it is :) # TypeError: set_printoptions() got an unexpected # keyword argument 'legacy' pass except ImportError: numpy = None try: import pandas # Max columns is automatically set by pandas based on terminal # width, so set columns to unlimited to prevent the test suite # from passing/failing based on terminal size. pandas.options.display.max_columns = None except ImportError: pandas = None # import here, cause outside the eggs aren't loaded import pytest args = ['--pyargs', 'skbio', '--doctest-modules', '--doctest-glob', '*.pyx', '-o', '"doctest_optionflags=NORMALIZE_WHITESPACE' ' IGNORE_EXCEPTION_DETAIL"'] + sys.argv[1:] errno = pytest.main(args=args) sys.exit(errno) scikit-bio-0.5.9/skbio/util/_warning.py000066400000000000000000000027451446255456000200470ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- class SkbioWarning(Warning): """Used to filter our warnings from warnings given by 3rd parties""" pass class EfficiencyWarning(SkbioWarning): """Warn about potentially accidental use of inefficient code. For example, if a user doesn't have an optimized version of a function/algorithm available in their scikit-bio installation, a slower, pure-Python implementation may be used instead. This warning can be used to let the user know they are using a version of the function that could be potentially orders of magnitude slower. """ pass class RepresentationWarning(SkbioWarning): """Warn about assumptions made for the successful completion of a process. Warn about substitutions, assumptions, or particular alterations that were made for the successful completion of a process. For example, if a value that is required for a task is not present, a best guess or least deleterious value could be used, accompanied by this warning. """ pass class DeprecationWarning(DeprecationWarning, SkbioWarning): """Used to indicate deprecated functionality in scikit-bio.""" pass scikit-bio-0.5.9/skbio/util/tests/000077500000000000000000000000001446255456000170235ustar00rootroot00000000000000scikit-bio-0.5.9/skbio/util/tests/__init__.py000066400000000000000000000005411446255456000211340ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- scikit-bio-0.5.9/skbio/util/tests/test_decorator.py000066400000000000000000000271371446255456000224300ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import unittest import inspect import warnings from skbio.util import classproperty from skbio.util._decorator import overrides, classonlymethod from skbio.util._decorator import (stable, experimental, deprecated, _state_decorator) from skbio.util._exception import OverrideError class TestClassOnlyMethod(unittest.TestCase): def test_works_on_class(self): class A: @classonlymethod def example(cls): return cls self.assertEqual(A.example(), A) def test_fails_on_instance(self): class A: @classonlymethod def example(cls): pass with self.assertRaises(TypeError) as e: A().example() self.assertIn('A.example', str(e.exception)) self.assertIn('instance', str(e.exception)) def test_matches_classmethod(self): class A: pass def example(cls, thing): """doc""" A.example1 = classmethod(example) A.example2 = classonlymethod(example) self.assertEqual(A.__dict__['example1'].__func__, example) self.assertEqual(A.__dict__['example2'].__func__, example) self.assertEqual(A.example1.__doc__, example.__doc__) self.assertEqual(A.example2.__doc__, example.__doc__) self.assertEqual(A.example1.__name__, example.__name__) self.assertEqual(A.example2.__name__, example.__name__) def test_passes_args_kwargs(self): self.ran_test = False class A: @classonlymethod def example(cls, arg1, arg2, kwarg1=None, kwarg2=None, default=5): self.assertEqual(arg1, 1) self.assertEqual(arg2, 2) self.assertEqual(kwarg1, '1') self.assertEqual(kwarg2, '2') self.assertEqual(default, 5) self.ran_test = True A.example(1, *[2], kwarg2='2', **{'kwarg1': '1'}) self.assertTrue(self.ran_test) class TestOverrides(unittest.TestCase): def test_raises_when_missing(self): class A: pass with self.assertRaises(OverrideError): class B(A): @overrides(A) def test(self): pass def test_doc_inherited(self): class A: def test(self): """Docstring""" pass class B(A): @overrides(A) def test(self): pass self.assertEqual(B.test.__doc__, "Docstring") def test_doc_not_inherited(self): class A: def test(self): """Docstring""" pass class B(A): @overrides(A) def test(self): """Different""" pass self.assertEqual(B.test.__doc__, "Different") class TestClassProperty(unittest.TestCase): def test_getter_only(self): class Foo: _foo = 42 @classproperty def foo(cls): return cls._foo # class-level getter self.assertEqual(Foo.foo, 42) # instance-level getter f = Foo() self.assertEqual(f.foo, 42) with self.assertRaises(AttributeError): f.foo = 4242 class TestStabilityState(unittest.TestCase): # the indentation spacing gets weird, so I'm defining the # input doc string explicitly and adding it after function # defintion _test_docstring = (" Add 42, or something else, to x.\n" "\n" " Parameters\n" " ----------\n" " x : int, x\n" " y : int, optional\n") class TestBase(TestStabilityState): def test_get_indentation_level(self): c = _state_decorator() self.assertEqual(c._get_indentation_level([]), 0) self.assertEqual( c._get_indentation_level([], default_no_existing_docstring=3), 3) self.assertEqual(c._get_indentation_level([""]), 4) self.assertEqual( c._get_indentation_level([""], default_existing_docstring=3), 3) in_ = (["summary"]) self.assertEqual(c._get_indentation_level(in_), 4) in_ = (["summary", "", "", " ", "", " ", ""]) self.assertEqual(c._get_indentation_level(in_), 4) in_ = (["summary", " More indentation", " Less indentation"]) self.assertEqual(c._get_indentation_level(in_), 5) def test_update_docstring(self): c = _state_decorator() in_ = None exp = ("""State: Test!!""") self.assertEqual(c._update_docstring(in_, "Test!!"), exp) in_ = """""" exp = ("""\n\n State: Test!!""") self.assertEqual(c._update_docstring(in_, "Test!!"), exp) in_ = ("""Short summary\n\n Parameters\n\n----------\n """ """x : int\n""") exp = ("""Short summary\n\n State: Test!!\n\n""" """ Parameters\n\n----------\n x : int\n""") self.assertEqual(c._update_docstring(in_, "Test!!"), exp) in_ = ("""Short summary\n\n Parameters\n\n----------\n """ """x : int\n""") exp = ("""Short summary\n\n State: Test!!\n\n""" """ Parameters\n\n----------\n x : int\n""") self.assertEqual(c._update_docstring(in_, "Test!!"), exp) in_ = ("""Short summary\n\n Parameters\n\n----------\n """ """x : int\n""") exp = ("""Short summary\n\n State: Test!!Test!!Test!!Test!!Test!!""" """Test!!Test!!Test!!Test!!Test!!Test!!Te\n st!!T""" """est!!Test!!Test!!Test!!Test!!Test!!Test!!Test!!\n\n""" """ Parameters\n\n----------\n x : int\n""") self.assertEqual(c._update_docstring(in_, "Test!!"*20), exp) class TestStable(TestStabilityState): def _get_f(self, as_of): def f(x, y=42): return x + y f.__doc__ = self._test_docstring f = stable(as_of=as_of)(f) return f def test_function_output(self): f = self._get_f('0.1.0') self.assertEqual(f(1), 43) def test_function_docstring(self): f = self._get_f('0.1.0') e1 = (" Add 42, or something else, to x.\n\n" " State: Stable as of 0.1.0.\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) f = self._get_f('0.1.1') e1 = (" Add 42, or something else, to x.\n\n" " State: Stable as of 0.1.1.\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) def test_function_signature(self): f = self._get_f('0.1.0') parameters = [ inspect.Parameter('x', inspect.Parameter.POSITIONAL_OR_KEYWORD), inspect.Parameter('y', inspect.Parameter.POSITIONAL_OR_KEYWORD, default=42) ] expected = inspect.Signature(parameters) self.assertEqual(inspect.signature(f), expected) self.assertEqual(f.__name__, 'f') def test_missing_kwarg(self): self.assertRaises(ValueError, stable) self.assertRaises(ValueError, stable, '0.1.0') class TestExperimental(TestStabilityState): def _get_f(self, as_of): def f(x, y=42): return x + y f.__doc__ = self._test_docstring f = experimental(as_of=as_of)(f) return f def test_function_output(self): f = self._get_f('0.1.0') self.assertEqual(f(1), 43) def test_function_docstring(self): f = self._get_f('0.1.0') e1 = (" Add 42, or something else, to x.\n\n" " State: Experimental as of 0.1.0.\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) f = self._get_f('0.1.1') e1 = (" Add 42, or something else, to x.\n\n" " State: Experimental as of 0.1.1.\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) def test_function_signature(self): f = self._get_f('0.1.0') parameters = [ inspect.Parameter('x', inspect.Parameter.POSITIONAL_OR_KEYWORD), inspect.Parameter('y', inspect.Parameter.POSITIONAL_OR_KEYWORD, default=42) ] expected = inspect.Signature(parameters) self.assertEqual(inspect.signature(f), expected) self.assertEqual(f.__name__, 'f') def test_missing_kwarg(self): self.assertRaises(ValueError, experimental) self.assertRaises(ValueError, experimental, '0.1.0') class TestDeprecated(TestStabilityState): def _get_f(self, as_of, until, reason): def f(x, y=42): return x + y f.__doc__ = self._test_docstring f = deprecated(as_of=as_of, until=until, reason=reason)(f) return f def test_function_output(self): f = self._get_f('0.1.0', until='0.1.4', reason='You should now use skbio.g().') self.assertEqual(f(1), 43) def test_deprecation_warning(self): f = self._get_f('0.1.0', until='0.1.4', reason='You should now use skbio.g().') # adapted from SO example here: http://stackoverflow.com/a/3892301 with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") f(1) self.assertTrue(issubclass(w[0].category, DeprecationWarning)) expected_str = "is deprecated as of scikit-bio version 0.1.0" self.assertTrue(expected_str in str(w[0].message)) def test_function_docstring(self): f = self._get_f('0.1.0', until='0.1.4', reason='You should now use skbio.g().') e1 = (" Add 42, or something else, to x.\n\n" " .. note:: Deprecated as of 0.1.0 for " "removal in 0.1.4. You should now use\n" " skbio.g().\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) f = self._get_f('0.1.1', until='0.1.5', reason='You should now use skbio.h().') e1 = (" Add 42, or something else, to x.\n\n" " .. note:: Deprecated as of 0.1.1 for " "removal in 0.1.5. You should now use\n" " skbio.h().\n\n" " Parameters") self.assertTrue(f.__doc__.startswith(e1)) def test_function_signature(self): f = self._get_f('0.1.0', until='0.1.4', reason='You should now use skbio.g().') parameters = [ inspect.Parameter('x', inspect.Parameter.POSITIONAL_OR_KEYWORD), inspect.Parameter('y', inspect.Parameter.POSITIONAL_OR_KEYWORD, default=42) ] expected = inspect.Signature(parameters) self.assertEqual(inspect.signature(f), expected) self.assertEqual(f.__name__, 'f') def test_missing_kwarg(self): self.assertRaises(ValueError, deprecated) self.assertRaises(ValueError, deprecated, '0.1.0') self.assertRaises(ValueError, deprecated, as_of='0.1.0') self.assertRaises(ValueError, deprecated, as_of='0.1.0', until='0.1.4') if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/util/tests/test_misc.py000066400000000000000000000175001446255456000213720ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import io import unittest from skbio.util import cardinal_to_ordinal, safe_md5, find_duplicates from skbio.util._misc import MiniRegistry, chunk_str, resolve_key class TestMiniRegistry(unittest.TestCase): def setUp(self): self.registry = MiniRegistry() def test_decoration(self): self.assertNotIn("name1", self.registry) self.assertNotIn("name2", self.registry) self.n1_called = False self.n2_called = False @self.registry("name1") def some_registration1(): self.n1_called = True @self.registry("name2") def some_registration2(): self.n2_called = True self.assertIn("name1", self.registry) self.assertEqual(some_registration1, self.registry["name1"]) self.assertIn("name2", self.registry) self.assertEqual(some_registration2, self.registry["name2"]) self.registry["name1"]() self.assertTrue(self.n1_called) self.registry["name2"]() self.assertTrue(self.n2_called) def test_copy(self): @self.registry("name") def some_registration(): pass new = self.registry.copy() self.assertIsNot(new, self.registry) @new("other") def other_registration(): pass self.assertIn("name", self.registry) self.assertNotIn("other", self.registry) self.assertIn("other", new) self.assertIn("name", new) def test_everything(self): class SomethingToInterpolate: def interpolate_me(): """First line Some description of things, also this: Other things are happening now. """ def dont_interpolate_me(): """First line Some description of things, also this: Other things are happening now. """ class Subclass(SomethingToInterpolate): pass @self.registry("a") def a(): """x""" @self.registry("b") def b(): """y""" @self.registry("c") def c(): """z""" subclass_registry = self.registry.copy() @subclass_registry("o") def o(): """p""" self.registry.interpolate(SomethingToInterpolate, "interpolate_me") subclass_registry.interpolate(Subclass, "interpolate_me") self.assertEqual(SomethingToInterpolate.interpolate_me.__doc__, "First line\n\n Some description of th" "ings, also this:\n\n\t'a'\n\t x\n\t'b'\n\t y\n\t'c" "'\n\t z\n\n Other things are happeni" "ng now.\n ") self.assertEqual(SomethingToInterpolate.dont_interpolate_me.__doc__, "First line\n\n Some description of th" "ings, also this:\n\n Other things are" " happening now.\n ") self.assertEqual(Subclass.interpolate_me.__doc__, "First line\n\n Some description of th" "ings, also this:\n\n\t'a'\n\t x\n\t'b'\n\t y\n\t'c" "'\n\t z\n\t'o'\n\t p\n\n Other thin" "gs are happening now.\n ") self.assertEqual(Subclass.dont_interpolate_me.__doc__, "First line\n\n Some description of th" "ings, also this:\n\n Other things are" " happening now.\n ") class ResolveKeyTests(unittest.TestCase): def test_callable(self): def func(x): return str(x) self.assertEqual(resolve_key(1, func), "1") self.assertEqual(resolve_key(4, func), "4") def test_index(self): class MetadataHaver(dict): @property def metadata(self): return self obj = MetadataHaver({'foo': 123}) self.assertEqual(resolve_key(obj, 'foo'), 123) obj = MetadataHaver({'foo': 123, 'bar': 'baz'}) self.assertEqual(resolve_key(obj, 'bar'), 'baz') def test_wrong_type(self): with self.assertRaises(TypeError): resolve_key({'foo': 1}, 'foo') class ChunkStrTests(unittest.TestCase): def test_even_split(self): self.assertEqual(chunk_str('abcdef', 6, ' '), 'abcdef') self.assertEqual(chunk_str('abcdef', 3, ' '), 'abc def') self.assertEqual(chunk_str('abcdef', 2, ' '), 'ab cd ef') self.assertEqual(chunk_str('abcdef', 1, ' '), 'a b c d e f') self.assertEqual(chunk_str('a', 1, ' '), 'a') self.assertEqual(chunk_str('abcdef', 2, ''), 'abcdef') def test_no_split(self): self.assertEqual(chunk_str('', 2, '\n'), '') self.assertEqual(chunk_str('a', 100, '\n'), 'a') self.assertEqual(chunk_str('abcdef', 42, '|'), 'abcdef') def test_uneven_split(self): self.assertEqual(chunk_str('abcdef', 5, '|'), 'abcde|f') self.assertEqual(chunk_str('abcdef', 4, '|'), 'abcd|ef') self.assertEqual(chunk_str('abcdefg', 3, ' - '), 'abc - def - g') def test_invalid_n(self): with self.assertRaisesRegex(ValueError, r'n=0'): chunk_str('abcdef', 0, ' ') with self.assertRaisesRegex(ValueError, r'n=-42'): chunk_str('abcdef', -42, ' ') class SafeMD5Tests(unittest.TestCase): def test_safe_md5(self): exp = 'ab07acbb1e496801937adfa772424bf7' fd = io.BytesIO(b'foo bar baz') obs = safe_md5(fd) self.assertEqual(obs.hexdigest(), exp) fd.close() class CardinalToOrdinalTests(unittest.TestCase): def test_valid_range(self): # taken and modified from http://stackoverflow.com/a/20007730/3776794 exp = ['0th', '1st', '2nd', '3rd', '4th', '5th', '6th', '7th', '8th', '9th', '10th', '11th', '12th', '13th', '14th', '15th', '16th', '17th', '18th', '19th', '20th', '21st', '22nd', '23rd', '24th', '25th', '26th', '27th', '28th', '29th', '30th', '31st', '32nd', '100th', '101st', '42042nd'] obs = [cardinal_to_ordinal(n) for n in list(range(0, 33)) + [100, 101, 42042]] self.assertEqual(obs, exp) def test_invalid_n(self): with self.assertRaisesRegex(ValueError, r'-1'): cardinal_to_ordinal(-1) class TestFindDuplicates(unittest.TestCase): def test_empty_input(self): def empty_gen(): yield from () for empty in [], (), '', set(), {}, empty_gen(): self.assertEqual(find_duplicates(empty), set()) def test_no_duplicates(self): self.assertEqual(find_duplicates(['a', 'bc', 'def', 'A']), set()) def test_one_duplicate(self): self.assertEqual(find_duplicates(['a', 'bc', 'def', 'a']), set(['a'])) def test_many_duplicates(self): self.assertEqual(find_duplicates(['a', 'bc', 'bc', 'def', 'a']), set(['a', 'bc'])) def test_all_duplicates(self): self.assertEqual( find_duplicates(('a', 'bc', 'bc', 'def', 'a', 'def', 'def')), set(['a', 'bc', 'def'])) def test_mixed_types(self): def gen(): yield from ('a', 1, 'bc', 2, 'a', 2, 2, 3.0) self.assertEqual(find_duplicates(gen()), set(['a', 2])) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/util/tests/test_testing.py000066400000000000000000000241701446255456000221150ustar00rootroot00000000000000# ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import os import itertools import unittest import pandas as pd import numpy as np import numpy.testing as npt from skbio import OrdinationResults from skbio.util import (get_data_path, assert_ordination_results_equal, assert_data_frame_almost_equal) from skbio.util._testing import _normalize_signs, assert_series_almost_equal class TestGetDataPath(unittest.TestCase): def test_get_data_path(self): fn = 'parrot' path = os.path.dirname(os.path.abspath(__file__)) data_path = os.path.join(path, 'data', fn) data_path_2 = get_data_path(fn) self.assertEqual(data_path_2, data_path) class TestAssertOrdinationResultsEqual(unittest.TestCase): def test_assert_ordination_results_equal(self): minimal1 = OrdinationResults('foo', 'bar', pd.Series([1.0, 2.0]), pd.DataFrame([[1, 2, 3], [4, 5, 6]])) # a minimal set of results should be equal to itself assert_ordination_results_equal(minimal1, minimal1) # type mismatch with npt.assert_raises(AssertionError): assert_ordination_results_equal(minimal1, 'foo') # numeric values should be checked that they're almost equal almost_minimal1 = OrdinationResults( 'foo', 'bar', pd.Series([1.0000001, 1.9999999]), pd.DataFrame([[1, 2, 3], [4, 5, 6]])) assert_ordination_results_equal(minimal1, almost_minimal1) # test each of the optional numeric attributes for attr in ('features', 'samples', 'biplot_scores', 'sample_constraints'): # missing optional numeric attribute in one, present in the other setattr(almost_minimal1, attr, pd.DataFrame([[1, 2], [3, 4]])) with npt.assert_raises(AssertionError): assert_ordination_results_equal(minimal1, almost_minimal1) setattr(almost_minimal1, attr, None) # optional numeric attributes present in both, but not almost equal setattr(minimal1, attr, pd.DataFrame([[1, 2], [3, 4]])) setattr(almost_minimal1, attr, pd.DataFrame([[1, 2], [3.00002, 4]])) with npt.assert_raises(AssertionError): assert_ordination_results_equal(minimal1, almost_minimal1) setattr(minimal1, attr, None) setattr(almost_minimal1, attr, None) # optional numeric attributes present in both, and almost equal setattr(minimal1, attr, pd.DataFrame([[1.0, 2.0], [3.0, 4.0]])) setattr(almost_minimal1, attr, pd.DataFrame([[1.0, 2.0], [3.00000002, 4]])) assert_ordination_results_equal(minimal1, almost_minimal1) setattr(minimal1, attr, None) setattr(almost_minimal1, attr, None) # missing optional numeric attribute in one, present in the other almost_minimal1.proportion_explained = pd.Series([1, 2, 3]) with npt.assert_raises(AssertionError): assert_ordination_results_equal(minimal1, almost_minimal1) almost_minimal1.proportion_explained = None # optional numeric attributes present in both, but not almost equal minimal1.proportion_explained = pd.Series([1, 2, 3]) almost_minimal1.proportion_explained = pd.Series([1, 2, 3.00002]) with npt.assert_raises(AssertionError): assert_ordination_results_equal(minimal1, almost_minimal1) almost_minimal1.proportion_explained = None almost_minimal1.proportion_explained = None # optional numeric attributes present in both, and almost equal minimal1.proportion_explained = pd.Series([1, 2, 3]) almost_minimal1.proportion_explained = pd.Series([1, 2, 3.00000002]) assert_ordination_results_equal(minimal1, almost_minimal1) almost_minimal1.proportion_explained = None almost_minimal1.proportion_explained = None class TestNormalizeSigns(unittest.TestCase): def test_shapes_and_nonarray_input(self): with self.assertRaises(ValueError): _normalize_signs([[1, 2], [3, 5]], [[1, 2]]) def test_works_when_different(self): """Taking abs value of everything would lead to false positives.""" a = np.array([[1, -1], [2, 2]]) b = np.array([[-1, -1], [2, 2]]) with self.assertRaises(AssertionError): npt.assert_equal(*_normalize_signs(a, b)) def test_easy_different(self): a = np.array([[1, 2], [3, -1]]) b = np.array([[-1, 2], [-3, -1]]) npt.assert_equal(*_normalize_signs(a, b)) def test_easy_already_equal(self): a = np.array([[1, -2], [3, 1]]) b = a.copy() npt.assert_equal(*_normalize_signs(a, b)) def test_zeros(self): a = np.array([[0, 3], [0, -1]]) b = np.array([[0, -3], [0, 1]]) npt.assert_equal(*_normalize_signs(a, b)) def test_hard(self): a = np.array([[0, 1], [1, 2]]) b = np.array([[0, 1], [-1, 2]]) npt.assert_equal(*_normalize_signs(a, b)) def test_harder(self): """We don't want a value that might be negative due to floating point inaccuracies to make a call to allclose in the result to be off.""" a = np.array([[-1e-15, 1], [5, 2]]) b = np.array([[1e-15, 1], [5, 2]]) # Clearly a and b would refer to the same "column # eigenvectors" but a slopppy implementation of # _normalize_signs could change the sign of column 0 and make a # comparison fail npt.assert_almost_equal(*_normalize_signs(a, b)) def test_column_zeros(self): a = np.array([[0, 1], [0, 2]]) b = np.array([[0, -1], [0, -2]]) npt.assert_equal(*_normalize_signs(a, b)) def test_column_almost_zero(self): a = np.array([[1e-15, 3], [-2e-14, -6]]) b = np.array([[0, 3], [-1e-15, -6]]) npt.assert_almost_equal(*_normalize_signs(a, b)) class TestAssertDataFrameAlmostEqual(unittest.TestCase): def setUp(self): self.df = pd.DataFrame({'bar': ['a', 'b', 'cd', 'e'], 'foo': [42, 42.0, np.nan, 0]}) def test_not_equal(self): unequal_dfs = [ self.df, # floating point error too large to be "almost equal" pd.DataFrame({'bar': ['a', 'b', 'cd', 'e'], 'foo': [42, 42.001, np.nan, 0]}), # extra NaN pd.DataFrame({'bar': ['a', 'b', 'cd', 'e'], 'foo': [42, np.nan, np.nan, 0]}), # different column order pd.DataFrame(self.df, columns=['foo', 'bar']), # different index order pd.DataFrame(self.df, index=np.arange(4)[::-1]), # different index type pd.DataFrame(self.df, index=np.arange(4).astype(float)), # various forms of "empty" DataFrames that are not equivalent pd.DataFrame(), pd.DataFrame(index=np.arange(10)), pd.DataFrame(columns=np.arange(10)), pd.DataFrame(index=np.arange(10), columns=np.arange(10)), pd.DataFrame(index=np.arange(9)), pd.DataFrame(columns=np.arange(9)), pd.DataFrame(index=np.arange(9), columns=np.arange(9)) ] # each df should compare equal to itself and a copy of itself for df in unequal_dfs: assert_data_frame_almost_equal(df, df) assert_data_frame_almost_equal(df, pd.DataFrame(df, copy=True)) # every pair of dfs should not compare equal. use permutations instead # of combinations to test that comparing df1 to df2 and df2 to df1 are # both not equal for df1, df2 in itertools.permutations(unequal_dfs, 2): with self.assertRaises(AssertionError): assert_data_frame_almost_equal(df1, df2) def test_equal(self): equal_dfs = [ self.df, # floating point error small enough to be "almost equal" pd.DataFrame({'bar': ['a', 'b', 'cd', 'e'], 'foo': [42, 42.00001, np.nan, 0]}) ] for df in equal_dfs: assert_data_frame_almost_equal(df, df) for df1, df2 in itertools.permutations(equal_dfs, 2): assert_data_frame_almost_equal(df1, df2) class TestAssertSeriesAlmostEqual(unittest.TestCase): def setUp(self): self.series = [ pd.Series(dtype='float64'), pd.Series(dtype=object), pd.Series(dtype='int64'), pd.Series([1, 2, 3]), pd.Series([3, 2, 1]), pd.Series([1, 2, 3, 4]), pd.Series([1., 2., 3.]), pd.Series([1, 2, 3], [1.0, 2.0, 3.0]), pd.Series([1, 2, 3], [1, 2, 3]), pd.Series([1, 2, 3], ['c', 'b', 'a']), pd.Series([3, 2, 1], ['c', 'b', 'a']), ] def test_not_equal(self): # no pair of series should compare equal for s1, s2 in itertools.permutations(self.series, 2): with self.assertRaises(AssertionError): assert_series_almost_equal(s1, s2) def test_equal(self): s1 = pd.Series([1., 2., 3.]) s2 = pd.Series([1.000001, 2., 3.]) assert_series_almost_equal(s1, s2) # all series should be equal to themselves and copies of themselves for s in self.series: assert_series_almost_equal(s, s) assert_series_almost_equal(s, pd.Series(s, copy=True)) if __name__ == '__main__': unittest.main() scikit-bio-0.5.9/skbio/workflow.py000066400000000000000000000446031446255456000171370ustar00rootroot00000000000000r""" Constructing workflows (:mod:`skbio.workflow`) ============================================== .. currentmodule:: skbio.workflow Construct arbitrarily complex workflows in which the specific methods run are determined at runtime. This module supports short circuiting a workflow if an item fails, supports ordering methods, callbacks for processed items, and deciding what methods are executed based on state or runtime options. Classes ------- .. autosummary:: :toctree: generated/ Workflow Decorators ---------- .. autosummary:: :toctree: generated/ requires method Examples -------- >>> from skbio.workflow import Workflow As an example of the ``Workflow`` object, let's construct a sequence processor that will filter sequences that are < 10 nucleotides, reverse the sequence if the runtime options indicate to, and truncate if a specific nucleotide pattern is observed. The ``Workflow`` object will only short circuit, and evaluate requirements on methods decorated by ``method``. Developers are free to define as many methods as they'd like within the object definition, and which can be called from workflow methods, but they will not be subjected directly to workflow checks. >>> nuc_pattern = 'AATTG' >>> has_nuc_pattern = lambda s: s[:len(nuc_pattern)] == nuc_pattern >>> class SequenceProcessor(Workflow): ... def initialize_state(self, item): ... # Setup the state for a new item (e.g., a new sequence) ... self.state = item ... @method(priority=100) ... def check_length(self): ... # Always make sure the sequence is at least 10 nucleotides ... if len(self.state) < 10: ... self.failed = True ... @method(priority=90) ... @requires(state=has_nuc_pattern) ... def truncate(self): ... # Truncate if a specific starting nucleotide pattern is observed ... self.state = self.state[len(nuc_pattern):] ... @method(priority=80) ... @requires(option='reverse', values=True) ... def reverse(self): ... # Reverse the sequence if indicatd at runtime ... self.state = self.state[::-1] An instance of a ``Workflow`` must be passed a ``state`` object and any runtime options. There are a few other useful parameters that can be specfied but are out of scope for the purposes of this example. We also do not need to provide a state object as our ``initialize_state`` method overrides ``self.state``. Now, let's create the instance. >>> wf = SequenceProcessor(state=None, options={'reverse=': False}) To run items through the ``SequenceProcessor``, we need to pass in an iterable. So, lets create a ``list`` of sequences. >>> seqs = ['AAAAAAATTTTTTT', 'ATAGACC', 'AATTGCCGGAC', 'ATATGAACAAA'] Before we run these sequences through, we're going to also define callbacks that are applied to the result of an single pass through the ``Workflow``. Callbacks are optional -- by default, a success will simply yield the state member variable while failures are ignored -- but, depending on your workflow, it can be useful to handle failures or potentially do something fun and exciting on success. >>> def success_f(obj): ... return "SUCCESS: %s" % obj.state >>> def fail_f(obj): ... return "FAIL: %s" % obj.state Now, lets process some data! >>> for result in wf(seqs, success_callback=success_f, fail_callback=fail_f): ... print(result) SUCCESS: AAAAAAATTTTTTT FAIL: ATAGACC SUCCESS: CCGGAC SUCCESS: ATATGAACAAA A few things of note just happened. First off, none of the sequences were reversed as the ``SequenceProcessor`` did not have option "reverse" set to ``True``. Second, you'll notice that the 3rd sequence was truncated, which is expected as it matched our nucleotide pattern of interest. Finally, of the sequences we processed, only a single sequence failed. To assist in constructing workflows, debug information is available but it must be turned on at instantiation. Let's do that, and while we're at it, let's go ahead and enable the reversal method. This time through though, were going to walk through an item at a time so we can examine the debug information. >>> wf = SequenceProcessor(state=None, options={'reverse':True}, debug=True) >>> gen = wf(seqs, fail_callback=lambda x: x.state) >>> next(gen) 'TTTTTTTAAAAAAA' >>> wf.failed False >>> sorted(wf.debug_trace) [('check_length', 0), ('reverse', 2)] The ``debug_trace`` specifies the methods executed, and the order of their execution where closer to zero indicates earlier in the execution order. Gaps indicate there was a method evaluated but not executed. Each of the items in the ``debug_trace`` is a key into a few other ``dict`` of debug information which we'll discuss in a moment. Did you see that the sequence was reversed this time through the workflow? Now, let's take a look at the next item, which on our prior run through the workflow was a failed item. >>> next(gen) 'ATAGACC' >>> wf.failed True >>> sorted(wf.debug_trace) [('check_length', 0)] What we can see is that the failed sequence only executed the check_length method. Since the sequence didn't pass our length filter of 10 nucleotides, it was marked as failed within the ``check_length`` method. As a result, none of the other methods were evaluated (note: this short circuiting behavior can be disabled if desired). This third item previously matched our nucleotide pattern of interest for truncation. Let's see what that looks like in the debug output. >>> next(gen) 'CAGGCC' >>> wf.failed False >>> sorted(wf.debug_trace) [('check_length', 0), ('reverse', 2), ('truncate', 1)] In this last example, we can see that the ``truncate`` method was executed prior to the ``reverse`` method and following the ``check_length`` method. This is as anticipated given the priorities we specified for these methods. Since the ``truncate`` method is doing something interesting, let's take a closer look at how the ``state`` is changing. First, we're going to dump out the state of the workflow prior to the call to ``truncate`` and then we're going to dump out the ``state`` following the call to ``truncate``, which will allow us to rapidly what is going on. >>> wf.debug_pre_state[('truncate', 1)] 'AATTGCCGGAC' >>> wf.debug_post_state[('truncate', 1)] 'CCGGAC' As we expect, we have our original sequence going into ``truncate``, and following the application of ``truncate``, our sequence is missing our nucleotide pattern of interest. Awesome, right? There is one final piece of debug output, ``wf.debug_runtime``, which can be useful when diagnosing the amount of time required for individual methods on a particular piece of state (as opposed to the aggregate as provided by cProfile). Three final components of the workflow that are quite handy are objects that allow you to indicate ``anything`` as an option value, anything that is ``not_none``, and a mechanism to define a range of valid values. >>> from skbio.workflow import not_none, anything >>> class Ex(Workflow): ... @method() ... @requires(option='foo', values=not_none) ... def do_something(self): ... pass ... @method() ... @requires(option='bar', values=anything) ... def do_something_else(self): ... pass ... @method() ... @requires(option='foobar', values=[1,2,3]) ... def do_something_awesome(self): ... pass ... """ # ---------------------------------------------------------------------------- # Copyright (c) 2013--, scikit-bio development team. # # Distributed under the terms of the Modified BSD License. # # The full license is in the file LICENSE.txt, distributed with this software. # ---------------------------------------------------------------------------- import sys from copy import deepcopy from time import time from functools import update_wrapper from collections.abc import Iterable from types import MethodType from skbio.util._decorator import experimental class NotExecuted: """Helper object to track if a method was executed""" @experimental(as_of="0.4.0") def __init__(self): self.msg = None @experimental(as_of="0.4.0") def __call__(self, msg): self.msg = msg return self _not_executed = NotExecuted() class Exists: """Stub object to assist with ``requires`` when a value exists""" @experimental(as_of="0.4.0") def __contains__(self, item): return True anything = Exists() # external, for when a value can be anything class NotNone: @experimental(as_of="0.4.0") def __contains__(self, item): if item is None: return False else: return True not_none = NotNone() class Workflow: """Arbitrary workflow support structure Methods that are considered to be directly part of the workflow must be decorated with ``method``. The workflow methods offer a mechanism to logically group functionality together, and are free to make subsequent calls to other methods. All methods of a subclass of Workflow (those with and without the ``method`` decoration) can take advantage of the ``requires`` decorator to specify any option or state requirements for the decorated function. Parameters ---------- state : object State can be anything or nothing. This is dependent on the workflow as in some cases, it is useful to preallocate state while in other workflows state may be ignored. short_circuit : bool if True, enables ignoring function methods when a given item has failed debug : bool Enable debug mode options : dict runtime options, {'option':values}, that the ``requires`` decorator can interrogate. kwargs : dict Additional arguments will be added as member variables to self. This is handy if additional contextual information is needed by a workflow method (e.g., a lookup table). """ @experimental(as_of="0.4.0") def __init__(self, state, short_circuit=True, debug=False, options=None, **kwargs): r"""Build thy workflow of self""" if options is None: self.options = {} else: self.options = options self.short_circuit = short_circuit self.failed = False self.debug = debug self.state = state self.iter_ = None for k, v in kwargs.items(): if hasattr(self, k): raise AttributeError("'%s' already exists in self." % k) setattr(self, k, v) if self.debug: self._setup_debug() @experimental(as_of="0.4.0") def initialize_state(self, item): """Initialize state This method is called first prior to any other defined workflow method with the exception of _setup_debug_trace if self.debug is True Parameters ---------- item : anything Workflow dependent """ raise NotImplementedError("Must implement this method") def _setup_debug(self): """Wrap all methods with debug trace support""" # ignore all members of the baseclass ignore = set(dir(Workflow)) for attrname in dir(self): if attrname in ignore: continue attr = getattr(self, attrname) if isinstance(attr, MethodType): setattr(self, attrname, self._debug_trace_wrapper(attr)) def _all_wf_methods(self): """Get all workflow methods Methods are sorted by priority """ methods = [] for item in dir(self): obj = getattr(self, item) if hasattr(obj, 'priority'): methods.append(obj) def key(x): return getattr(x, 'priority') methods_sorted = sorted(methods, key=key, reverse=True) if self.debug: methods_sorted.insert(0, self._setup_debug_trace) return methods_sorted def _setup_debug_trace(self): """Setup a trace The trace is per item iterated over by the workflow. Information about each method executed is tracked and keyed by:: (function name, order of execution) Order of execution starts from zero. Multiple calls to the same function are independent in the trace. The following information is tracked:: debug_trace : set([key]) debug_runtime : {key: runtime} debug_pre_state : {key: deepcopy(Workflow.state)}, state prior to method execution debug_post_state : {key: deepcopy(Workflow.state)}, state following method execution """ self.debug_counter = 0 self.debug_trace = set() self.debug_runtime = {} self.debug_pre_state = {} self.debug_post_state = {} @experimental(as_of="0.4.0") def __call__(self, iter_, success_callback=None, fail_callback=None): """Operate on all the data This is the processing engine of the workflow. Callbacks are executed following applying all workflow methods to an item from ``iter_`` (unless ``short_cicruit=True`` in which case method execution for an item is stopped if ``failed=True``). Callbacks are provided ``self`` which allows them to examine any aspect of the workflow. Parameters ---------- it : an iterator success_callback : method to call on a successful item prior to yielding. By default, ``self.state`` is yielded. fail_callback : method to call on a failed item prior to yielding. By default, failures are ignored. """ if success_callback is None: def success_callback(x): return x.state self.iter_ = iter_ workflow = self._all_wf_methods() for item in self.iter_: self.failed = False self.initialize_state(item) for func in workflow: if self.short_circuit and self.failed: break else: func() if self.failed: if fail_callback is not None: yield fail_callback(self) else: yield success_callback(self) self.iter_ = None def _debug_trace_wrapper(self, func): """Trace a function call""" def wrapped(): """Track debug information about a method execution""" if not hasattr(self, 'debug_trace'): raise AttributeError( "%s doesn't have debug_trace." % self.__class__) exec_order = self.debug_counter name = func.__name__ key = (name, exec_order) pre_state = deepcopy(self.state) self.debug_trace.add(key) self.debug_counter += 1 start_time = time() if func() is _not_executed: self.debug_trace.remove(key) else: self.debug_runtime[key] = time() - start_time self.debug_pre_state[key] = pre_state self.debug_post_state[key] = deepcopy(self.state) return update_wrapper(wrapped, func) class method: """Decorate a function to indicate it is a workflow method Parameters ---------- priority : int Specify a priority for the method, the higher the value the higher the priority. Priorities are relative to a given workflow """ highest_priority = sys.maxsize @experimental(as_of="0.4.0") def __init__(self, priority=0): self.priority = priority @experimental(as_of="0.4.0") def __call__(self, func): func.priority = self.priority return func class requires: """Decorator that executes a function if requirements are met Parameters ---------- option : any Hashable object An option that is required for the decorated method to execute. This option will be looked up within the containing ``Workflow``s' ``options``. values : object A required value. This defaults to ``anything`` indicating that the only requirement is that the ``option`` exists. It can be useful to specify ``not_none`` which indicates that the requirement is satisfied if the ``option`` exists and it holds a value that is not ``None``. Values also supports iterables or singular values. state : Function A requirement on workflow state. This must be a function that accepts a single argument, and returns ``True`` to indicate the requirement is satisfied, or ``False`` to indicate the requirement is not satisfied. This method will be passed the containing ``Workflow``s' ``state`` member variable. """ @experimental(as_of="0.4.0") def __init__(self, option=None, values=anything, state=None): # self here is the requires object self.option = option self.required_state = state if values is anything: self.values = anything elif values is not_none: self.values = not_none elif isinstance(values, set): self.values = values else: if isinstance(values, str): self.values = values elif isinstance(values, Iterable): self.values = set(values) else: self.values = set([values]) @experimental(as_of="0.4.0") def __call__(self, func): """Wrap a function func : the function to wrap """ def decorated(dec_self): """A decorated function that has requirements dec_self : this is "self" for the decorated function """ if self.required_state is not None: if not self.required_state(dec_self.state): return _not_executed s_opt = self.option ds_opts = dec_self.options # if this is a function that doesn't have an option to validate if s_opt is None: func(dec_self) # if the option exists in the Workflow elif s_opt in ds_opts: val = ds_opts[s_opt] # if the value just needs to be not None if self.values is not_none and val is not None: func(dec_self) # otherwise make sure the value is acceptable elif val in self.values: func(dec_self) else: return _not_executed else: return _not_executed return update_wrapper(decorated, func)